Archivo de la categoría: Raspberry Pi

Instalación Node-RED

Node-RED es un motor de flujos con enfoque IoT, que permite definir gráficamente flujos de servicios, a través de protocolos estándares como REST, MQTT, Websocket, AMQP… ademas de ofrecer integración con apis de terceros, tales como Twitter, Facebook, Yahoo!…

Más información: https://about.sofia2.com/2016/11/16/que-es-nodered/

Instalar Node-RED en Raspberry Pi

Node-Red no viene instalado en Raspberry Pi pero se puede hacer desde add/remove software.

La forma recomendada es desde Menú – Preferencias – Software Recomendado. También  se instala de esta manera, se puede actualizar usando sudo apt-get upgrade.

Luego se puede ejecutar manualmente con el comando “node-red-star” o :

Para iniciar Node-RED en el arranque de Raspberry Pi de forma automática usar:

  • sudo systemctl enable nodered.service

Más información https://nodered.org/docs/hardware/raspberrypi

Para comprobar que funciona abrir en un navegador http://ip-raspberry:1880

Para encontrar más nodos y ejemplos de flows ver https://flows.nodered.org/ estos nodos se pueden instalar desde el palette.

Los nodos también se pueden instalar mediante npm. Para añadir nodos adicionales primero debe instalar la herramienta npm, ya que no está incluida en la instalación predeterminada de Raspbian. Esto no es necesario si ha actualizado a Node.js 8.x.

npm es el sistema de gestión de paquetes por defecto para Node.js

Los siguientes comandos instalan npm y luego lo actualizan a la última versión.

  • sudo apt-get install npm (Instala npm)
  • sudo npm install -g npm (Actualiza npm a la última versión en modo global)

Para poder ver la paleta e instalar nodos, reiniciar el servicio:

  • sudo systemctl restart nodered.service

Y luego para instalar un nodo:

  • cd ~/.node-red
  • npm install node-red-{example node name}

node-red-admin es la herramienta de línea de comandos le permite administrar de forma remota una instancia de Node-RED: https://nodered.org/docs/user-guide/node-red-admin

Para instalar node-red-admin: sudo npm install -g node-red-admin

Para ver todos los nodos instalados: node-red-admin list

Instalación Recomendada de Node-Red

La instalación recomendada para tener la última version de Node-RED en Raspberry Pi: https://nodered.org/docs/getting-started/raspberrypi

Comprobar la versión de node.js y npm instalada:

  • npm –version
  • node –version

Últimas versiones (marzo 2020):

  • Node v12.16.1
  • Npm 6.14.2

Ejecutar el script, ojo cuesta un tiempo instalar: 

Este script sirve para instalar Node.js, npm y Node-RED en una Raspberry Pi. El script también se puede utilizar para actualizar una instalación existente cuando hay una nueva versión disponible.

El script que se descarga y ejecuta puede verse en: https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered

Este script eliminará las versiones de Node.js anteriores a la versión 7.x, y Node-RED y

si es necesario, reemplaza con con Node.js 10.x LTS (dubnium) y el último Node-RED de Npm.

También mueve cualquier nodo Node-RED que esté instalado globalmente en su usuario ~/.node-red/node_modules, y los agrega a su package.json, para que puede administrarlos con el administrador de paletas.

También intenta ejecutar ‘npm rebuild’ para actualizar los nodos adicionales que haya instalado que puede tener un componente binario nativo. Si bien esto normalmente funciona bien, necesitas para comprobar que tiene éxito para su combinación de nodos instalados.

Estos son los pasos que realiza:

  • Stop Node-RED                   
  • Remove old version of Node-RED      
  • Remove old version of Node.js       
  • Install Node.js                     
  • Clean npm cache                     
  • Install Node-RED core               
  • Move global nodes to local          
  • Install extra Pi nodes              
  • Npm rebuild existing nodes          
  • Add shortcut commands               
  • Update systemd script               

Los errores de instalación se pueden ver en: /var/log/nodered-install.log

Más información:

Instalar Node-RED en CentOS

La instalación en local se hace siguiendo este enlace: https://nodered.org/docs/getting-started/local

Es recomendable crear un usuario nodered y hacer la instalación con ese usuario.

Para instalar Node-RED es necesario una versión soportada de Node-js: https://nodered.org/docs/faq/node-versions

Para versiones de Linux basada en RPM como Red HAT, fedora o CenOS usar esta instalación: https://github.com/node-red/linux-installers

Primero instalar node.js en CentOS: https://linuxize.com/post/how-to-install-node-js-on-centos-7/

Hay dos formas de instalar nodejs:

  • usando yum con el repositorio
  • Usando la utilidad n de npm

Para instalar la última version con yum: https://tecadmin.net/install-latest-nodejs-and-npm-on-centos/

Usando la utilidad n de npm para actualizar a la última versión de nodejs con estos comandos:

  1. Clear NPM’s cache:
    sudo npm cache clean -f
  2. Install a little helper called ‘n’
    sudo npm install -g n
  3. Install latest stable Node.js version
    sudo n stable

Más información: https://tecadmin.net/upgrade-nodejs-via-npm/

Para poder instalar add-ons: sudo yum install gcc-c++ make

Para actualizar npm: npm install -g npm

Y luego instalar node-RED (use the node package manager, npm, that comes with Node.js): sudo npm install -g –unsafe-perm node-red

Running Node-RED: https://nodered.org/docs/getting-started/running 

  • poner node-red
  • abrir firewall  sudo firewall-cmd –permanent –add-port=1880/tcp
  • firewall-cmd –reload

Arrancar node-red en el arranque: https://nodered.org/docs/hardware/raspberrypi#adding-autostart-capability-using-systemd

Más información para la instalación: https://ketandesai.co.uk/os/install-node-red-on-centos-7/

Hay que cambiar /lib/systemd/system/nodered.service el usuario pi por el usuario root en este caso o el usuario que ha instalado node-red

User=root

Group=root

WorkingDirectory=/root

Creo un usuario del grupo sudores llamado nodered y contraseña para que ejecute los servicios en el servidor!!!

Para actualizar node-red instalado en local https://nodered.org/docs/getting-started/local usar el comando: sudo npm install -g –unsafe-perm node-red

NOTA: no olvidar actualizar a la última versión de nodejs.

Para configurar:

Para securizar:

Comandos básicos de npm: https://vortexbird.com/comandos-basicos-de-npm/

Instalar Node-RED en Local

Para instalar Node-RED en local, ya sea Windows, Linux o MacOS seguir https://nodered.org/docs/getting-started/local

Iniciar Node-RED en el inicio: https://nodered.org/docs/faq/starting-node-red-on-boot

Instalación en Windows:

Instalar Node-RED en Docker

Node-RED en docker: https://nodered.org/docs/getting-started/docker

Docker hub oficial de Node-RED desde la version 1.x: https://hub.docker.com/r/nodered/node-red/

Imagen de Node-RED: https://github.com/node-red/node-red-docker/blob/master/README.md

Para versiones antiguas: https://hub.docker.com/r/nodered/node-red-docker

La forma más sencilla de ejecutar Node-RED en docker:

  • docker run -it -p 1880:1880 –name mynodered nodered/node-red

Las imágenes Node-RED se basan en imágenes oficiales de Node JS Alpine Linux para mantenerlas lo más pequeñas posible. El uso de Alpine Linux reduce el tamaño de la imagen construida, pero elimina las dependencias estándar que se requieren para la compilación del módulo nativo.

Una vez que está Node-RED ejecutándose con Docker, debemos asegurarnos de que los nodos o flujos agregados no se pierdan si se destruye el contenedor. Estos datos de usuario pueden conservarse montando un directorio de datos en un volumen fuera del contenedor. Esto puede hacerse usando un montaje de enlace o un volumen de datos con nombre.

Node-RED utiliza el directorio /data dentro del contenedor para almacenar los datos de configuración del usuario.

Para guardar el directorio de usuario Node-RED dentro del contenedor en un directorio host fuera del contenedor, puede usar el siguiente comando. Para permitir el acceso a este directorio de host, el usuario de node-red (uid predeterminado = 1000) dentro del contenedor debe tener el mismo uid que el propietario del directorio de host. Esto puedes ser forzado con el comando sudo chown -R 1000:1000 path/to/your/node-red/data. Más información https://github.com/node-red/node-red-docker/wiki/Permissions-and-Persistence

docker run -it -p 1880:1880 -v /home/pi/.node-red:/data –name mynodered nodered/node-red

Montar un volumen de datos dentro del contenedor en esta ruta de directorio significa que la configuración de usuario pueden guardarse fuera del contenedor e incluso compartirse entre instancias de contenedor.

En este ejemplo, el directorio host /home/pi/.node-red está vinculado al directorio contenedor /data

El contenedor utiliza el directorio /data como el directorio de configuración del usuario. Para agregar nodos adicionales, puede abrir el shell en el contenedor y ejecutar los comandos de instalación npm adecuados:

  • docker exec -it mynodered /bin/bash (Abre un shell en el contenedor)
  • cd /data
  • npm install node-red-node-smooth (una vez en el contenedor npm instala el nodo)
  • exit
  • docker stop mynodered
  • docker start mynodered (reiniciar contenedor)

Para montar /data en un path externo:

  • docker run –restart always -d -p 1880:1880 -v /opt/docker_volumes/nodered_data:/data –name nodered nodered/node-red

Para que funcione hay que dar permisos de escritura al directorio /opt/docker_volumes/nodered_data

Para actualizar el contendor:

  • docker pull nodered/node-red
  • docker stop mynodered
  • docker start mynodered

Para cambiar la time zone del contenedor:

  • docker run -it -p 1880:1880 –name mynodered -e TZ=Europe/London nodered/node-red

Docker de node-red en raspberry pi: https://domology.es/docker-de-node-red-en-raspberry-pi/

Más información: https://nodered.org/docs/getting-started/docker

Enlazar Contenedores

Puede vincular contenedores “internamente” dentro del docker runtime utilizando la opción –link.

Por ejemplo, tengo un contenedor de un broker MQTT simple disponible como:

  • docker run -it –name mybroker eclipse-mosquitto

No es necesario exponer el puerto 1883 a nivel global a menos que desee.

A continuación, ejecute docker, pero esta vez con un parámetro de enlace (nombre: alias)

  • docker run -it -p 1880:1880 –name mynodered –link mybroker:broker nodered/node-red

Ejecutar Node-RED

Una vez instalado Node-RED ejecutar el comando node-red

La salida del registro le proporciona varias piezas de información:

  • Las versiones de Node-RED y Node.js
  • Cualquier error cuando intentó cargar los nodos de la paleta
  • La ubicación de su archivo de configuración y directorio de usuarios
  • El nombre del archivo de flujos que está utilizando.

Nodo-RED utiliza el fichero flows_<hostname>.json como el archivo de flujos predeterminado. Puede cambiar esto proporcionando el nombre del archivo de flujos como argumento para el comando node-red

Uso de la línea de comandos de node-red: https://nodered.org/docs/getting-started/local#command-line-usage

Más información: https://nodered.org/docs/getting-started/local

Manejar GPIO Raspberry Pi

En este punto https://aprendiendoarduino.wordpress.com/2020/03/01/gpio-raspberry-pi/ ya hemos visto las características físicas del GPIO de Raspberry Pi

Para controlar GPIO con Python, primero debes importar una librería de código escrito previamente. El más común y difundido es el Rpi.GPIO, utilizado para crear miles de proyectos desde los primeros días de la Raspberry Pi.

Ben Croston creó una biblioteca de Python llamada RPi.GPIO, que utilizó como parte de su proceso de elaboración de cerveza. Esto permitió a las personas controlar los pines GPIO desde sus programas Python, y se convirtió en un éxito tanto en educación como en proyectos personales. Lo usamos en muchos de nuestros recursos de aprendizaje gratuitos.

Web: https://pypi.org/project/RPi.GPIO/

Más recientemente, se ha introducido otra biblioteca, llamada GPIO Zero, que ofrece una experiencia más fácil para aquellos que son nuevos en Python y en la electrónica básica. GPIO Zero es una librería creada por Raspberry Pi para que sea más accesible y fácil de usar que RPi.GPIO

Web: https://pypi.org/project/gpiozero/

Documentación: https://gpiozero.readthedocs.io/en/stable/

Versión 1.5: https://www.raspberrypi.org/blog/gpio-zero-v1-5/

GPIO Zero creada por Raspberry Pi: https://www.raspberrypi.org/blog/gpio-zero-a-friendly-python-api-for-physical-computing/

Migrar de GPIO Zero desde RPi.GPIO https://gpiozero.readthedocs.io/en/stable/migrating_from_rpigpio.html

Linea de comandos gpiozero: https://gpiozero.readthedocs.io/en/stable/cli_tools.html

El módulo gpiozero siempre usa la numeración Broadcom GPIO para identificar un GPIO.

El módulo RPi.GPIO puede usar la numeración física de pin (BOARD) o la numeración Broadcom GPIO (BCM).

Ambas bibliotecas están preinstaladas en el sistema operativo Raspbian. En cuanto a la nomenclatura de los pines GPIO, hay varias maneras de identificarlos; el método más simple y obvio es definitivamente el que se refiere a su ubicación física. Empezando por la parte superior izquierda del GPIO, y con esto nos referimos al pin más cercano a la ranura de la micro SD, tenemos el pin físico 1 que proporciona alimentación 3v3. A la derecha de ese pin se encuentra el pin físico de 2 que proporciona 5v de potencia. El número de pines seguirá creciendo a medida que desciendas por las columnas, como habrás entendido a la izquierda encontraremos todos los pines con números impares y a la derecha los pares. 

Hay otro método utilizado, y es la numeración de pines de Broadcom (BCM) (numeración de pines GPIO) que, sin embargo, para el usuario medio puede parecer caótica, con GPIO17, 22 y 27 siguiéndole unos a otros con lo que parecería una pequeña reflexión sobre la numeración lógica. En realidad, el mapeo de pines BCM se refiere a los pines GPIO que estaban conectados directamente al SoC del Raspberry Pi.

La mayoría de los tutoriales de Raspberry Pi que verás utilizan este esquema de numeración, también porque es el que cuenta con el apoyo oficial de la Fundación Raspberry Pi. También ten en cuenta que los números de pin BCM y GPIO se refieren al mismo esquema. Por ejemplo, GPIO17 es lo mismo que BCM17. Por último, algunos pines GPIO también tienen funciones secundarias que les permiten interactuar con diferentes tipos de dispositivos que utilizan los protocolos I2C, SPI o UART; por ejemplo, los pines GPIO3 y GPIO4 también son pines SDA y SCL I2C utilizados para conectar dispositivos a través del protocolo I2C

Más información: https://descubrearduino.com/pines-gpio-de-la-raspberry-pi-4/

Pines GPIO Zero

Uso de los pines:

PWM con RPi: http://www.instructables.com/id/RaspberryPi-Pulse-Width-Modulation-Demonstration/?ALLSTEPS

Ejemplos de Uso

Blink Led

Antes de empezar recordar comprobar la posición de los pines porque en caso de error podemos dañar la Raspberry Pi ya que los GPIO no tienen ninguna protección.

  • Cuando conectes cables a los GPIO procura no equivocarte y fíjate bien.
  • Usa cables con recubrimiento del tipo Dupont Macho-hembra por ejemplo, y no acerques cables sin proteger a tus GPIO (Y mucho menos un destornillador) porque puedes hacer un corto con facilidad.
cables M-F
  • Una vez que conectes un cable hembra protegido, vuelve a mirar y asegúrate de que lo has conectado al pin que querías y no al de al lado.
  • Especial cuidado con los pines que uses para sacar 3V o 5V de tu Raspi. No dejes el otro extremo al aire: Asegúrate de conectarlo a algún sitio.
  • NO CONECTES NADA DE 5V si no estás seguro. Tu Raspberry funciona a 3.3V y meterle 5V en un pin puede suponer quemar el procesador central. 

Instalar las librerías para el uso de los pines GPIO desde Python, asegurandonos de tener actualizado Raspbian:

  • sudo apt-get update
  • sudo apt-get upgrade
  • sudo apt-get install python-dev
  • sudo apt-get install pyton-rpi.gpio

Tened en cuenta que en esta ocasión vamos a alimentar el LED con 3.3V (Que es lo que proporciona un pin de la Raspi) y que la intensidad que obtendremos será: 3.3 / 220 Ω = 15 mA.

Esquema de GPIO:

Conectamos GND al pin 6 de la Raspberry y vamos a usar el pin 12 (GPIO 18) como control del encendido mediante una resistencia intermedia. El esquema de conexión es:

Abrir el IDLE de Python 3 para empezar nuestro programa:

Y copiar código:

import RPi.GPIO as gpio

import time

gpio.setmode(gpio.BOARD)
gpio.setup(12, gpio.OUT)

for  x in range ( 0, 10):

    gpio.output(12, True)
    time.sleep(0.5)

    gpio.output(12, False)
    time.sleep(0.5)

print “Ejecución finalizada”

Guardar el fichero con el nombre blink.py en /home/pi y ejecutarlo pulsando F5

Bucle infinito: https://github.com/jecrespo/Aprendiendo-RaspberryPi/blob/master/Ejercicio01-Blink/rpi_led.py

Más información:

Botón

Leer estado de un pulsador:

Código: https://github.com/jecrespo/Aprendiendo-RaspberryPi/blob/master/Ejercicio04-Pulsador/rpi_pushbutton_test.py

Código con detección de flanco: https://github.com/jecrespo/Aprendiendo-RaspberryPi/blob/master/Ejercicio04-Pulsador/rpi_pushbutton_block.py

GPIO.cleanup() – limpia el estado de in out y pull up down para que no se quede.

GPIO.setwarnings(false) – deshabilita warnings

Con eventos https://github.com/jecrespo/Aprendiendo-RaspberryPi/blob/master/Ejercicio04-Pulsador/rpi_pushbutton_detect.py

Multithread mucho más eficiente si uso con más procesamiento: https://github.com/jecrespo/Aprendiendo-RaspberryPi/blob/master/Ejercicio04-Pulsador/rpi_pushbutton_threaded.py

En un hilo de ejecución ejecuto el script que lo pone a dormir y en otro hilo ejecuta la función de callback.

PWM

Cambio de intensidad LED.

Código: https://github.com/jecrespo/Aprendiendo-RaspberryPi/blob/master/Ejercicio05-PWM/rpi_led_pwm.py

Led y Pulsador con GPIO Zero

Ejemplos https://www.raspberrypi.org/documentation/usage/gpio/python/README.md

Documentación GPIO Zero

Tutoriales GPIO Oficiales

Inicio GPIO: https://projects.raspberrypi.org/en/projects/physical-computing/0

Recetas básicas: https://gpiozero.readthedocs.io/en/stable/recipes.html

Más información

Tutorial Adafruit: https://learn.adafruit.com/playing-sounds-and-using-buttons-with-raspberry-pi/overview

Remote GPIO

Remote gpio: Se agregó para permitir el acceso remoto a los pines GPIO desde otro Pi en la red, usando el demonio pigpio, ya que esto es posible usando la biblioteca Python GPIO Zero.

Ver con más detalle: http://bennuttall.com/whats-new-gpio-zero-v1-3/ 

GPIO con Node-RED

Otra forma de manejar el GPIO de Raspberry Pi es usando Node-RED con el nodo https://flows.nodered.org/node/node-red-node-pi-gpio que es el módulo que viene instalado por defecto

Aunque hay más nodos para manejar el GPIO:

Más información: https://nodered.org/docs/faq/interacting-with-pi-gpio

Node-Red no viene instalado en Raspberry Pi pero se puede hacer desde add/remove software.

La forma recomendada es desde Menú – Preferencias – Software Recomendado. Si se instala de esta manera, se puede actualizar usando sudo apt-get upgrade.

Luego se puede ejecutar manualmente con el comando “node-red-star” o :

Para iniciar Node-RED en el arranque de Raspberry Pi de forma automática usar:

  • sudo systemctl enable nodered.service

Más información https://nodered.org/docs/hardware/raspberrypi

Para comprobar que funciona abrir en un navegador http://ip-raspberry:1880

pantalla node-red

Documentación del nodo: https://flows.nodered.org/node/node-red-node-pi-gpio

Tutoriales básicos Node-RED:

Getting started con Node-RED: https://projects.raspberrypi.org/en/projects/getting-started-with-node-red

Programación Básica en Python

Introducción a Python

Python es un lenguaje interpretado, es decir, no requiere del proceso de escribir / compilar / volcar. Simplemente escribir la instrucción y listo el ordenador la “interpreta” o sea ejecuta sobre la marcha sin más complicación.

Python también es:

Esto hace que los lenguajes interpretados sean más fáciles de aprender porque nos parecen más naturales, y aunque el programa corre más lento que en los compilados, pero con la potencia actual o es tan importante.

Python no es un lenguaje diseñado para ser fácil comprometiendo su potencia. Muy al contrario la potencia y capacidad de cálculo que muestra suelen sorprender a la gente acostumbrada a otros lenguajes.

Para quienes vengáis de Arduino, C++ es un lenguaje compilado, esto significa que el compilador lee lo escrito en una primera pasada y después compila, es decir traduce a un lenguaje propio del micro de Arduino qué es lo que se vuelca y ejecuta la placa que usemos.

Hay dos versiones de Python 2 y 3, pero la versión 2 ya no tienes soporte desde el 1 de enero de 2020, aunque en Raspbian disponemos de las dos versiones. El inconveniente es que hay librerías que aún se mantienen en Python 2.

Para iniciar python se puede hacer desde consola:

  • python
  • python3

O usar el entorno gráfico con IDLE. IDLE significa Integrated DeveLopment Environment, o Integrated Development and Learning Environment.

Para instalarlo ejecutar: sudo apt-get install idle3

Dentro de la consola ya es posible ejecutar comandos.

Otra opción es usar el Thonny Python IDE incluido en Raspbian: https://thonny.org/

Práctica: Ejecutar los comandos:

  • 3.8 + 7
  • 2 * (3+5) / 4
  • “Hola.”
  • x=3
  • H=”Buenos dias”
  • print(x)
  • print(h)
  • print(H)
  • print(x,H)
  • 123 ** 1234

Python puede con grandes números mientras le quede memoria RAM, pero tu Raspberry puede quedarse un tanto bloqueada mientras calcula.

El resumen es que Python tiene una precisión ilimitadamente grande en los enteros mientras tenga recursos disponibles, un detalle sorprendente para cualquiera que este acostumbrado a programar en otros lenguajes, y una de las razones por las que Python se ha convertido en lenguaje de facto para la ciencia y especialmente para la investigaciones numéricas.

Práctica: crear un fichero llamado hello.py que saque por pantalla el texto “Hola Mundo” desde consola conectado por ssh y ejecutarlo.

Más información: Introducción a Python.

Variables y Tipos de Datos en Python

Una variable es algo parecido a un contenedor o cajón con un nombre. Una cosa es el nombre del cajón y otra su contenido y conviene entender desde ya la diferencia.

Las variables pueden tomar distintos valores e ir cambiandolo en función del programa, de la misma manera que un cajón puede ir variando su contenido sin que se mueva de sitio.

En Python no es necesario definir las variables antes de usarlas, a diferencia de C y similares. Basta con que la declares asignándole un valor.

Por ejemplo escribe directamente:

  • base = 86
  • iva = base * 0.21
  • total = base + iva
  • print (total)
  • print(base, iva, total)
  • base = input (“Dame el precio del artículo, por favor : “)
  • print(base + base * 0.21)
  • type(base)
  • print (int(base) + int(base) * 0.21)
  • iva = float(base) * 0.21
  • print (int(base) +iva)

Práctica: Hacer un programa llamado iva.py y que pida el valor del articulo y devuelva el valor con iva.

Más información: Variables y tipos en Python.

En Python existen 4 tipos diferentes de variables numéricas:

  • int Número entero con precisión fija (ℤ).
  • long Número entero en caso de sobrepasar el tamaño de un int.
  • float Número en coma flotante de doble precisión (ℝ).
  • complex Número complejo (parte real + j parte imaginaria) (ℂ)

Una función muy útil, que sirve para conocer el tipo de una variable es: type()

El tipo booleano es un tipo de variable que sólo puede contener dos valores: True y False.

Se definen como caracteres entre comillas simples ‘ o dobles “.

Tipo listas

Se definen poniendo el contenido de la lista entre corchetes, separando cada uno de los elementos mediante una coma. Cada posición de la lista puede contener elementos de distinto tipo. Además, las listas son mutables, es decir, sus elementos pueden ser modificados. En Python los elementos de una lista se numeran desde 0 hasta longitud−1.Hay numerosas funciones que pueden aplicarse a una lista.

Para acceder al elemento de una lista se pone el nombre de la lista y a continuación el índice al que queremos acceder entre corchetes(si ponemos el índice con signo negativo empezará por el final de la lista). Para acceder a un rango dentro de una lista tenemos diferentes opciones:

  • Desde el inicio tomar a elementos (no incluye a):
    lista[:a]
  • Desde la posición a (incluida) tomar todos los elementos hasta el final
    lista[a:]
  • Tomar los elementos desde a hasta b (sin incluir b)
    lista[a:b]

Las listas tienen asociadas una serie de métodos que permiten una gran variedad de operaciones sobre ellas:

  • .append(), añade un elemento al final de la lista.
  • .insert(), se usa para insertar un elemento en el índice asignado.
  • .pop(), elimina y devuelve el valor en la posición del índice asignado.
  • .reverse(), reordena la lista de forma reversa.
  • .sort(), reordena la lista de forma ascendente.

Más en listas: https://docs.python.org/3/tutorial/datastructures.html#more-on-lists

Ejercicio: probar estos ejemplos de listas 

Tipo tuplas

Las tuplas son similares a las listas, se definen con paréntesis en vez de corchetes. Tienen la peculiaridad de ser inmutables.

Tipo diccionarios

Los diccionarios definen una relación uno a uno entre claves y valores y son mutables. Se definen colocando una lista separada por comas de pares clave:valor. Una vez definido, podemos acceder al valor asociado a una clave buscando por la clave. Además, podemos buscar si una determinada clave existe o no en nuestro diccionario.

Los diccionarios se definen con {}

  • .keys()
  • .values()
  • .items() – devuelve una lista de tuplas clave – valor del diccionario

zip me permite coger dos listas y hacer un diccionario: diccionario = dict(zip(lista_claves,lista_valores))

del(diccionario[‘clave’]) – borra la entrada de un diccionario

Ojo, al copiar un diccionario con ciudades_2 = ciudades, no creo una copia sino dos variables que apuntan a un mismo objeto.

id(diccionario) – me devuelve el número del puntero al diccionario

ciudades_2 = ciudades.copy() -> así tengo una copia independiente de un diccionario

Ejercicio: ejecucar algunos ejemplos con diccionarios https://recursospython.com/guias-y-manuales/diccionarios/

Ver:

Operadores aritméticos

Las diferentes operaciones aritméticas en Python son los siguientes:

  • +
  • ∗∗  – elevado
  • / – división entera
  • // – división
  • %

Operadores de asignación

Los diferentes operadores de asignación en Python son los siguientes:

  • =: Asigna a la variable del lado derecho aquello que pongamos en el lado derecho.
  • +=: Suma a la variable del lado izquierdo la variable del lado derecho.
  • −=: Resta a la variable del lado izquierdo la variable del lado derecho.
  • ∗=: Multiplica la variable del lado izquierdo por la variable del lado derecho.
  • /=: Divide la variable del lado izquierdo por la variable del lado derecho.
  • ∗∗=: Eleva la variable de la izquierda a la potencia de la variable de la derecha.
  • //=: División entera de la variable de la izquierda entre la de la derecha.
  • %=: Resto de la división de la variable de la izquierda entre la de la derecha.

Operadores relacionales

Los operadores relacionales de Python son:

  • ==: Evalúa que los valores sean iguales.
  • !=: Evalúa que los valores sean distintos.
  • <: Evalúa que el valor de la izquierda sea menor que el de la derecha.
  • >: Evalúa que el valor de la izquierda sea mayor que el de la derecha.
  • <=: Evalúa que el valor de la izquierda sea menor o igual que el de la derecha.
  • >=: Evalúa que el valor de la izquierda sea mayor o igual que el de la derecha.
  • not: negación de una variable booleana

Librerías

Python es un lenguaje pensado para ser ampliado con lo necesario y hace tiempo que se ha convertido en el pilar de la investigación en numerosos campos de ciencia y tecnología

Disponemos de infinidad de librerías que podemos usar llamando a la clausula import

La librería estándar de python incluye muchos módulos: https://docs.python.org/dev/library/index.html

Ejecutar:

  • from fractions import *
  • F1 = Fraction(2,3)
  • F2 = Fraction(3,4
  • print(F1, F2)
  • print (F1 + F2)
  • print (F1 * F2)
  • print (F1 / F2)
  • import math
  • math.factorial(4)
  • math.factorial(432)
  • import numpy
  • a = numpy.array(([1,2,3],[4,5,6],[7,8,9]))
  • print (a)
  • print (a * a)
  • from matplotlib import pyplot
  • pip install matplot lib
  • x = numpy.linspace(0, 2 * numpy.pi, 100)
  • y = numpy.sin(x)
  • pyplot.plot(x, y)
  • pyplot.show()

NumPy es una extensión de Python, que le agrega mayor soporte para vectores y matrices, constituyendo una biblioteca de funciones matemáticas de alto nivel para operar con esos vectores o matrices.

Estos módulos externos que podemos descargar e importar a nuestros programas reciben en Python el nombre de packages. Existen packages que podemos importar, más o menos estándar para lo que se te ocurra.

Python Package Index: https://pypi.org/

Más información: Imports en Python

Módulos en Python: http://research.iac.es/sieinvens/python-course/source/modulos.html

Módulos y paquetes: https://www.learnpython.org/en/Modules_and_Packages 

Diferencia entre módulos, Paquetes y librerías

Standar Library: https://docs.python.org/3/library/ 

Métodos de instalación de Paquetes:

Como instalar y usar pip: https://pip.pypa.io/en/latest/installing.html

Por defecto estos gestores de paquetes buscan en https://pypi.org/

El Python Package Index o PyPI es el repositorio de software oficial para aplicaciones de terceros en el lenguaje de programación Python. Los desarrolladores de Python pretenden que sea un catálogo exhaustivo de todos los paquetes de Python escritos en código abierto. https://es.wikipedia.org/wiki/%C3%8Dndice_de_paquetes_de_Python

Para ver la ruta de los paquetes:

  • import sys
  •  print (‘\n’.join(sys.path))

Para ver los módulos instalados: pip freeze o pip list

Para actualizar ejecutar: pip install –upgrade pip

Instalar paquetes de Python: https://www.raspberrypi.org/documentation/linux/software/python.md

Sentencias condicionales

Imaginemos que queremos crear un sistema automático de riego en nuestra casa, de forma que cuando la lectura de un sensor de humedad sea menor que un cierto valor, encienda el sistema y que si la lectura es mayor que un cierto valor, lo apague. Con las herramientas que tenemos hasta ahora, esto no sería posible, para esto utilizamos la sentencia if/elif/else, que tiene la siguiente estructura:

if <expresion_booleana>:   # Solo si la condicion booleana es True, 

    bloque codigo          # el bloque de código se ejecuta

    …

elif <expresion_booleana>: # No es necesario, añade condiciones extra al conjunto.

    bloque codigo          # Se puede poner tantas como se necesiten.

    …

else:                      # No se necesario. Se ejecuta solo si

    bloque codigo          # todas las condiciones anteriores son falsas.         

    …

Nota: Es importante saber la importancia de la indentación en Python. Cuando usemos sentencias que acaben en “:” (if, for…) las líneas que estén dentro de esta sentencia irán después de un tabulador o 4 espacio, como se muestra en los ejemplos.

Ejemplo:

num = float(input(“Enter a number: “))

if num >= 0:

    if num == 0:

        print(“Zero”)

    else:

        print(“Positive number”)

else:

    print(“Negative number”)

Más información: El tipo Bool y sus operaciones.

Sentencias bucle

Anteriormente hemos visto el tipo de variable lista. Estas contenían una cierta cantidad de elementos. Imaginemos que tenemos una lista de enteros y queremos mostrar por pantalla los elementos que contiene que sean mayores que 5. Para esto, entre otras cosas, tenemos sentencias bucle.

En Python existen dos tipos estructuras de bucles:

  • Bucles for
  • Bucles while

La sintaxis de un bucle for es:

for <variable_sin_definir> in <Iterable>: # El bloque se ejecuta tantas veces 

    bloque codigo                         # como elementos tiene el iterable

    …

El blucle ejecuta un bloque de código tantas veces como esté definido. El número de veces que se recorre el bucle es equivalente al número de elementos en el iterable que se usa. La variable que se usa toma como valores los elementos del iterable de forma secuencial, un valor por cada iteración.

Los bucles for son una gran herramienta para recorrer todos los elementos de una colección.

Ejemplo:

fruits = [“apple”, “banana”, “cherry”]

for x in fruits:

  print(x)

Ejemplo:

for x in range(6):

  print(x)

else:

  print(“Finally finished!”)

La sintaxis de los bucles while es:

while <condicion_boolena>:   # El bloque se ejecuta hasta que la condición es falsa.

    bloque codigo            # Antes de ejecutar asegurarse que se va a salir.

    …

El bucle while se ejecuta de forma indefinida hasta que la condición después del while sea falsa. Por lo tanto es necesario realizar un cambio dentro del bucle que finalmente hará que se vuelva la condición False.

Adicionalmente existen un par de comandos dentro de Python que sirven para tener más control sobre los bucles:

  • continue. El intérprete cuando lo lee termina de ejecutar la presente iteración y pasa a la siguiente iteración.
  • break . El intérprete cuando lo lee termina la ejecución del bucle, continuando la ejecución de las siguientes líneas.

Ejemplo:

i = 1

while i < 6:

  print(i)

  if i == 3:

    break

  i += 1

Más información: Mas sobre Python for y While.

Iteradores

En Python existen diferentes estructuras que son conjuntos de elementos, son las llamadas colecciones. Este tipo de estructuras son iterables, es decir, se pueden recorrer elemento por elemento. Como veíamos antes, el bucle for itera sobre un iterable, por lo que utilizamos esta sentencia para recorrerlos. Algunos tipos de variable que son iterables son:

  • Cadena de caracteres (str)
  • Lista (list)
  • Tupla (tuple)
  • Diccionario (dict)

Además, muchas veces queremos repetir un bucle un número determinado de veces. Para esto puede ser útil la función range(n). Esta función genera un iterable que va desde 0 hasta n-1.

Más información:Iteraciones for en Python 3.

Funciones

Es muy posible que a lo largo de un programa necesitemos calcular el factorial de un número. Podemos escribir el código necesario para calcularlo en cada punto que lo necesitamos, o crear una función que podamos llamar desde cualquier punto y nos calcule el factorial de un número. 

La sintaxis para definir una función en Python es la siguiente:

def nombre_funcion(<parametro1>, <parametro2>, …): # Los parametros son opcionales

    Bloque codigo

    …

    return <valor_a_devolver> # El comando es opcional (puede devolver varios valores)

Los parámetros son las variables que se definen dentro del paréntesis, separados por comas. Son opcionales y sirven para pasarle valores a la función. Son opcionales una vez definimos la función, pero si la función está definida con n argumentos, tendremos que informarlos.

Adicionalmente puede introducirse una sentencia return que termina la ejecución de la función y devuelve el valor/objeto que está colocado justo después.

Los nombres de las funciones sigue el mismo convenio que el de las variables.

Para llamar a una función, como hemos visto antes, tenemos que escribir el nombre de la función y añadir entre paréntesis los argumentos que la funció necesita. Aunque la función no necesite argumentos, tenemos que escribir los paréntesis.

Ejemplo:

def escribe_media(x, y):

    media = (x + y) / 2

    print(f”La media de {x} y {y} es: {media}”)

    return

a = 3

b = 5

escribe_media(a, b)

print(“Programa terminado”)

Código de python (ejemplos y snippets):

Ejemplos de Python aplicados a la Industria

Ejemplos:

Ejercicio: Recoger datos meteorológicos de aemet

Aemet Open data: http://www.aemet.es/es/datos_abiertos/AEMET_OpenData

Obtener Api Key: https://opendata.aemet.es/centrodedescargas/inicio

Documentación de la API: https://opendata.aemet.es/dist/index.html?

Ejemplo programa Python: https://opendata.aemet.es/centrodedescargas/ejemProgramas?

Crear un ejemplo usando la librería requests: https://pypi.org/project/requests/ y ejecutar para logroño.

Código: https://github.com/jecrespo/Aprendiendo-RaspberryPi/blob/master/Ejercicio03-Aemet/aemet.py

Librería: https://pypi.org/project/python-aemet/

No hay librería de AEMET en Node-RED, pero podemos hacer las peticiones a la web como se ha hecho en python.

Instalación de Raspbian

Software quickstart: https://www.raspberrypi.org/learning/software-guide/quickstart/ 

Guías de iniciación:

Formatear la tarjeta SD de la forma correcta.

Uno de los errores más frecuentes de los usuarios de tarjetas de memoria SD está en creer que este tipo de memorias funcionan igual que una memoria USB o un disco duro y se pueden formatear con las utilidades del sistema operativo. A diferencia de otros dispositivos de almacenamiento, las tarjetas SD incluyen una zona especial denominada “Protected Area”, empleada para temas de seguridad, que requiere un tratamiento especial. Adicionalmente – y dependiendo de la configuración y el tipo de tarjeta – es necesario un formateo ajustado al tipo de tarjeta.

Descargar e instalar la utilidad “SD Card Formatter” provista por la SD Association, los mismos que definen los estándares de este medio de almacenamiento. Después de instalada, se debe proceder a formatear la tarjeta SD antes de utilizarla. De esta forma se garantiza que se usará todo el espacio disponible de la tarjeta y se optimizará su desempeño y almacenamiento de acuerdo con las especificaciones del fabricante.

Descarga https://www.sdcard.org/downloads/formatter_4/eula_windows/index.html 

Instalar Raspbian en Disco Externo o Memoria USB

Con la capacidad de las Raspberry Pi de arrancar desde USB, es posible hacer funcionar una Raspberry Pi con una memoria USB o mejor aun con un disco externo.

Raspberry Pi con SSD: https://www.youtube.com/watch?v=gp6XW-fGVjo 

Documentación oficial: https://www.raspberrypi.org/documentation/hardware/raspberrypi/bootmodes/msd.md 

Modos de arranque: https://www.raspberrypi.org/documentation/hardware/raspberrypi/bootmodes/README.md

Instalar Imagen Raspbian

Descargar imagen Raspbian zip: https://www.raspberrypi.org/downloads/

Descargar Raspbian Buster with desktop desde: https://downloads.raspberrypi.org/raspbian_latest 

La versión por defecto de Raspbian es ahora una instalación mínima – le da el escritorio, el navegador Chromium, el reproductor multimedia VLC, Python, y algunos programas accesorios. Junto a esto se encuentra la imagen “Raspbian Full”, que también incluye todos los programas recomendados: LibreOffice, Scratch, SonicPi, Thonny, Mathematica y varios otros.

El programa de software recomendado se puede utilizar para instalar o desinstalar cualquiera de los programas adicionales que se encuentran en la imagen completa; si descarga la imagen mínima y comprueba todas las opciones en el software recomendado, terminará con la imagen completa, y viceversa.

Buster la nueva versión de Raspbian: https://www.raspberrypi.org/blog/buster-the-new-version-of-raspbian/

Descargar imagen Raspbian zip: https://www.raspberrypi.org/downloads/

Emular Raspberry Pi en Virtual Box: https://www.luisllamas.es/raspberry-pi-virtualbox/

Guia de instalación https://www.raspberrypi.org/documentation/installation/installing-images/README.md 

Para copiar la imagen a una SD usar:

Tutoriales de instalación de Raspbian:

Etcher

Etcher es una herramienta gráfica de escritura de tarjetas SD que funciona en Mac OS, Linux y Windows, y es la opción más fácil para la mayoría de los usuarios. Etcher también soporta la escritura de imágenes directamente desde el archivo zip, sin necesidad de descomprimirlas.

balenaEtcher es normalmente la opción más fácil para la mayoría de los usuarios de escribir imágenes en tarjetas SD, por lo que es un buen punto de partida. Si busca una alternativa en Windows, puede usar Win32DiskImager.

Descargar Etcher: https://www.balena.io/etcher/ y yscribir tu imagen con Etcher.

Pasos:

  • Descargar SO: Raspbian
  • Formatear microSD: SD Card Formatter 4.0
  • Flashear: Etcher
  • Acceder a la SD desde un PC: Partición “/boot” es accesible desde Windows, partición expandida no
  • Preconfiguración (recomendado para modo headless): SSH

Win32DiskImager

Con Win32DiskImager no solo se puede copiar una imagen sino guardar una imagen de una tarjeta SD, pero el uso de Etcher es más sencillo.

Descarga https://sourceforge.net/projects/win32diskimager/

Con Win32DiskImager no solo se puede copiar una imagen sino guardar una imagen de una tarjeta SD.

Post Instalación

Una vez instalado raspbian, conectar un monitor, teclado y ratón a Raspberry Pi para seguir con su configuración.

En caso de no tener un monitor, se puede hacer una instalación headless:

Una vez entramos en Raspberry Pi, seguimos los pasos que nos indica para cambiar contraseña, cambiar el nombre (hostname), configurar y actualizar Raspberry Pi.

Luego es posible hacer más configuraciones desde “Configuración de  Raspberry Pi” o desde comando “sudo raspi-config”:

Para ejecutar el wizard de configuración otra vez:

  • sudo piwiz
  • sudo raspi-config

Más información:

Conexión a la Red

La forma general de conectar a Internet la Raspberry Pi es mediante 

  • Conexión a Ethernet por DHCP
  • Conectar a Wifi por DHCP

Por este motivo no es necesario configurar nada si conectamos a un router con DHCP configurado para ethernet y en WiFi solo deberemos configurar la red wifi.

DHCP:

La propia Raspberry Pi podría hacer de servidor DHCP: https://www.raspberrypi.org/learning/networking-lessons/lesson-3/plan/ 

La Raspberry Pi 3 es la primera de la familia en incluir WIFI estándar de serie, lo que es un gran avance de salida y garantiza que se normalice las conexiones, a diferencia de las versiones previas en las que había que comprar un módulo WiFi y configurar la WIFI en función del modelo de adaptador que usasemos.

En el caso actual, la configuración de la WIFI se reduce a listar las redes disponibles y elegir la nuestra, para después proporcionar la contraseña de acceso. 

Detalle seleccion WIFI

Aquí tienes iconos para la configuración de varios elementos, como el volumen de audio la WIFI y hasta el Bluetooth, que recuerda viene de serie en la Nueva Raspi3. Para configurar la WIFI pincha y selecciona el icono y selecciona la WiFi a conectarse.

Desplegando wifi

Una vez configurado comprobar que se puede navegar.

Aunque hayas conectado correctamente a Internet hay mil razones por las que necesitas conocer más información de tus conexiones IP, especialmente saber la IP para que al actuar como servidor saber a qué IP conectarnos.

Con el comando “ifconfig” podemos saber qué interfaces están conectados y que DNS usan o que Gateway o router estas usando como salida.

ifconfig 0

Para obtener los datos de ethernet teclea ifconfig eth0 y para wifi teclea ifconfig wlan0

Con el comando route -ne se pueden ver las rutas configuradas

Más información: https://www.prometec.net/conectar-a-internet/ 

Para obtener más información de las redes ver los directorios:

  • /sys/class/net/eth0
  • /sys/class/net/wlan0

Por ejemplo en el fichero address está la dirección MAC del controlador de red

En algunas ocasiones nos puede interesar asignar una IP fija, para ello seguir el tutorial:https://www.luisllamas.es/raspberry-pi-ip-estatica/ 

Los fichero de configuración de IP son:

  •  /etc/dhcpcd.conf
  • /etc/network/interfaces

Más información: https://raspberrypi.stackexchange.com/questions/39785/dhcpcd-vs-etc-network-interfaces 

También es conveniente cambiar el hostname, seguir este tutorial: https://www.howtogeek.com/167195/how-to-change-your-raspberry-pi-or-other-linux-devices-hostname/ 

Acceso Remoto

Una vez instalado vamos a asegurarnos el acceso remoto para no tener que tener conectado a un monitor y un teclado y ratón y podamos manejarlo.

Acceso Remoto: https://www.raspberrypi.org/documentation/remote-access/

SSH

La mejor forma de acceder a Raspberry Pi remotamente en modo comando en línea estando en la misma red es usando SSH. 

SSH sigue un modelo cliente-servidor. El cliente inicia una petición al servidor, que autentifica la comunicación e inicia el entorno Shell. Múltiples clientes pueden conectarse a un mismo servidor. Por defecto SSH emplea el puerto TCP 22 aunque puede cambiarse fácilmente. 

SSH dispone de más usos muy interesantes. por ejemplo, podemos copiar archivos de forma segura entre dos dispositivos, o tunelizar cualquier conexión de otra aplicación a través de un canal seguro SSH.

Para activar el servidor SSH en Raspberry Pi comprobar que estás activado en menu – Preferencias- Configuración de Raspberry Pi – Interfaces

Esta conexión sólo funciona en red local. Para poder acceder desde fuera, a través de Internet, hay que configurar un mapeo de puertos en el router. El proceso completo depende del router,.

Para conectarnos desde Windows a SSH, deberemos emplear un cliente SSH para conectarnos con Raspberry Pi. El cliente más utilizado en Windows es Putty, que es Open Source y está disponible en https://www.putty.org/

Descargamos y ejecutamos Putty y nos aparece una ventana donde podemos introducir la dirección IP (o el nombre) de la Raspberry Pi. Al conectarnos se nos preguntará el nombre del usuario y la contraseña.

Más información:

VNC

La mejor forma de acceder a Raspberry Pi remotamente en modo escritorio estando en la misma red es usando VNC.

VNC es un programa de software libre basado en una estructura cliente-servidor que permite observar las acciones del ordenador servidor remotamente a través de un ordenador cliente. VNC no impone restricciones en el sistema operativo del ordenador servidor con respecto al del cliente: es posible compartir la pantalla de una máquina con cualquier sistema operativo que admita VNC conectándose desde otro ordenador o dispositivo que disponga de un cliente VNC portado.

Seguir este tutorial: https://www.raspberrypi.org/documentation/remote-access/vnc/README.md

La conexión de VNC de RealVNC se incluye con Raspbian. Consiste en el servidor de VNC, que permite controlar Raspberry Pi remotamente, y el VNC viewer, que permite que controlar ordenadores remotamente de su Raspberry Pi.

El servidor VNC debe habilitarse para poder conectarse remotamente, para ello ir a menu – Preferencias- Configuración de Raspberry Pi – Interfaces y asegurarse que VNC está activado.

Una vez activado establecer la conexión desde el ordenador instalando el VNC viewer: https://www.realvnc.com/en/connect/download/viewer/ y conectarse a la IP de nuestra Raspberry:

Con VNC también se puede establecer una conexión en la nube.

Más información:

Team Viewer

En el caso que queramos conectarnos a nuestra Raspberry Pi estando en cualquier parte del mundo, una buena opción es TeamViewer.

TeamViewer es un software informático privado de fácil acceso, que permite conectarse remotamente a otro equipo. Entre sus funciones están: compartir y controlar escritorios, reuniones en línea, videoconferencias y transferencia de archivos entre ordenadores.Team Viewer es gratuito para uso personal.

Web: https://www.teamviewer.com/es/ 

La instalación es muy simple solo hay que descargarse TeamViewer Host para raspberry Pi desde https://www.teamviewer.com/es/descarga/linux/ y acerse una cuenta en la web de TeamViewer https://www.teamviewer.com/es/ 

Enlace de descarga: https://download.teamviewer.com/download/linux/teamviewer-host_armhf.deb 

Instalar el fichero teamviewer-host_xxx_armhf.deb, simplemente haciendo doble click o con el comando “sudo dpkg -i filename.deb”

Si hay dependencias solucionarlo con  “sudo apt-get update” y “sudo apt-get -f upgrade”

Una vez instalado ejecutar TeamViewer en Raspberry Pi y poner las credenciales de la cuenta de TeamViewer

Una vez instalado, acceder a https://login.teamviewer.com/LogOn con la cuenta de TeamViewer y ya podemos acceder a nuestra Raspberry Pi. Necesitaremos instalar el cliente de TeamViewer o la app de Chrome:

Solo para controlar la Raspberry Pi remotamente ejecutar el cliente “TeamViewer_Setup.exe” de esta forma:

Más información:

Más de TeamViewer

Otras Alternativas al Acceso Remoto

Logmein: https://www.logmein.com/es 

Otra opción de acceso remoto es el xrdp:

Alternativa opensource interesante para acceso remoto

http://www.instructables.com/id/Controlling-your-raspberry-pi-mouse-and-keyboard-r/?ALLSTEPS. Ver el código en: https://github.com/piBoard

Si queremos un acceso remoto por consola pero no hay acceso directo a la IP es posible usar https://remote.it/

Conectar a Unidades de Red

Ver tutoriales:

Configuración Headless (sin monitor)

Configurar raspbian para que no haga falta conectarse al monitor y teclado.

Tutorial: https://www.luisllamas.es/como-configurar-raspberry-pi-sin-monitor-ni-teclado/ 

Un servidor DHCP interesante en caso de no tener uno puede ser: http://www.vercot.com/~serva/ usandolo de forma temporal para asignar IPs

Cambiar la ip por comando (ip fija) una vez accedemos por SSH: http://raspberryparatorpes.net/instalacion/poner-la-direccin-ip-fija-en-raspbian/

Es posible usar una configuración de failback, que en caso que falle el DHCP dar una fija. Ver este ejemplo: https://wiki.archlinux.org/index.php/Dhcpcd#Static_profile

Buen tutorial para Raspberry Pi Zero W de confguración headless: https://www.internetdelascosas.cl/2017/10/30/configurando-una-raspberry-pi-zero-wifi-sin-un-monitor/

Clonado de Imágenes Raspberry Pi

Si clonamos imágenes de Raspberry Pi nos podemos encontrar algunos problemas si la imagen es mayor que la capacidad de la tarjeta donde clonar.

Proceso de clonado:

Solución si la imagen es mayor que el tamaño de la tarjeta SD, básicamente se trata de encoger la imagen puesto que parte de la imagen es espacio libre:

Cambiar el tamaño de la partición en un fichero imagen:

Otras aplicaciones para hacerlo:

Si es una SD mayor que el de la imagen, habrá que expandir el file system para poder usar todo el espacio la tarjeta SD

Raspberry Pi Zero W

Getting started:

Configuración headless RAspberry Pi Zero:

Configurar por USB: https://www.raspberrypi.org/blog/programming-pi-zero-usb/

Conectar raspberry Pi zero W por usb

Interesante tutorial para raspberry Pi zero y usarlo con USB: https://learn.adafruit.com/turning-your-raspberry-pi-zero-into-a-usb-gadget/overview 

Otros tutoriales para la zero w:

Control Remoto Raspberry Pi Zero

En caso que no usemos entorno gráfico, algo no recomendable con Raspberry Pi Zero, podemos conectarnos remotamente consola pero sin hay acceso directo a la IP mediante https://remote.it/

Raspberry Pi en la Industria

Dada la gran popularidad de Raspberry Pi, su uso también se ha extendido en la industria.

Artículo de Raspberry Pi en la industria: https://blog.temboo.com/raspberry-pi-iot/

  • Barato
  • Disponibilidad
  • Documentación y soporte de la comunidad

Uso de Raspberry Pi en productos comerciales: https://tecnoticias.net/2019/07/20/por-que-la-raspberry-pi-no-es-una-buena-opcion-para-productos-comerciales/

Una primera opción es usar una carcasa para carril DIN:  http://www.hwhardsoft.de/english/projects/rasppibox-open/

Comprar en: http://www.modmypi.com/raspberry-pi/cases/din-rail-mount/raspibox-open-plus-prototyping-din-rail-raspberry-pi-case/

Como montarlo: http://www.instructables.com/id/How-to-install-the-Raspberry-Pi-to-a-cap-rail/?ALLSTEPS

Uso con Codesys: https://www.instructables.com/id/Raspberry-Pi-Based-IEC-61131-3-Compatible-PLC/

Interesante módulo con salida de relés y entradas opto aisladas http://www.hwhardsoft.de/english/simplibox/io/

Panel Industrial Basado en Raspberry Pi

De industrial Shields: https://www.industrialshields.com/es_ES/industrial-panel-pc-based-on-raspberry-pi

Productos: https://www.industrialshields.com/es_ES/shop/category/hmi-and-panel-pc-panel-pc-3

Comprar: https://www.industrialshields.com/es_ES/shop/product/touchberry-pi-10-1-raspberry-pi-4b-1478?category=3

Guia de Usuario: https://www.industrialshields.com/web/content?model=ir.attachment&field=datas&id=137792&

UPS y RTC shield: https://www.industrialshields.com/es_ES/shop/product/raspberry-pi-ups-and-rtc-shield-584?search=raspberry

Módulos de Entradas y Salidas

Web: http://developer.opto22.com/pi/

Uso con Node-RED: http://developer.opto22.com/nodered/general/

UniPi

Unipi: https://www.unipi.technology/ 

Productos: https://www.unipi.technology/products

Revolution Pi

Web: https://revolution.kunbus.com/

Productos: https://revolution.kunbus.com/revolution-pi-series/

Comprar: https://revolution.kunbus.de/shop/en/

HW industrial basado en Raspberry Pi: https://hardwaresfera.com/noticias/hardware/raspberry-pi-crean-los-modulos-kunbus-basados-en-una-compute-module-3-para-iot-y-para-industria/

Iono Pi/Strato

Web: https://www.sferalabs.cc/

Unidades de control: https://www.sferalabs.cc/strato/

Módulos de entrada y salida: https://www.sferalabs.cc/iono-pi/

Artículo: https://www.open-electronics.org/iono-pi-a-raspberry-pi-based-plc/

Rex controls (Software)

No solo hay HW industrial basado en Raspberry Pi, sino software industrial para Rpi. Amplia gama de dispositivos soportados.

Usar raspberry Pi como scada y programación tipo ladder:

Otros Módulos

Hat: https://www.digikey.es/es/articles/techzone/2018/jan/build-a-low-cost-industrial-controller-with-the-raspberry-pi-3

OpenPLC en Raspberry Pi: https://www.openplcproject.com/getting-started-rpi

Getting Started Open PLC: https://www.openplcproject.com/getting-started

Raspberry Din: https://whitebream.com/raspberry-din.shtml

Extensión Raspberry Pi: https://www.elektor.com/pixtend-v1-3-kit-full-version, comprar https://www.amazon.es/PiXtend-L-Extension-Board-programmable/dp/B07GNDJY68

Alternativa a Raspberry Pi

Además de usar Raspberry Pi en la industria como un PLC o autómata, también se está usando como un servidor de aplicaciones: broker MQTT, Node-RED, Base de Datos, ejecución de scripts, etc…

Como alternativa a este uso de Raspberry Pi, se puede usar un servidor con un Sistema Operativo Linux o incluso Windows en las propias instalaciones o un servidor dedicado, un VPS, un servidor cloud o incluso en un contenedor (Docker). Puede tener aplicaciones:

  • Mosquitto
  • BBDD (InfluxD, MongoDB)
  • Grafana
  • Node-red
  • Otros servicios automatizados…

Por ejemplo recoger datos modbus usando una Raspberry Pi o un servidor: