Cómo Traducir Vídeos de YouTube a cualquier Idioma 

*(Generar subtítulos en Español)

TALLER DE RASPBERRY PI para PRINCIPIANTES

por Michael

Actualizado el 04 de Diciembre de 2018

(Traducido) 

Capítulo 2: PROGRAMACIÓN CON PYTHON

2.0 Resumen del capítulo

En este capítulo aprenderemos sobre:

•     Cómo escribir un programa simple en Python
•     Usar variables
•     Declarar funciones para organizar nuestro código
•     Usar Python para conectarnos al mundo real a través de GPIO

Recursos del capítulo:

La biblioteca estándar de Python: muy útil para referencias de sintaxis y para explorar qué funciones preconstruidas tenemos disponibles. 

Biblioteca Raspberry Pi GPIO: esto es lo que usaremos para interactuar con el mundo exterior. Hay múltiples ejemplos útiles.

2.1 Introducción a Python

IDLE es el entorno de Python. Es útil para probar comandos en tiempo real. Podemos escribir un script de Python, que es solo una secuencia de comandos de Python.

He tratado de incluir tantas funciones de Python como pude en este breve script. Compare el script con el resultado que ve cuándo se ejecuta.

¡Definitivamente hay algunos trucos que vale la pena conocer!

Código para esta sección:

Desafío: cambia el bucle for que cuenta de dos en dos para que cuente de -5 a 25 en pasos de 5.

Recuerda que tienes disponible la Documentación de la biblioteca estándar de Python, intenta buscar rango.

2.2 Conexión con el mundo exterior con GPIO

GPIO  (General Purpose Input/Output) es un pin genérico en un chip que permite que la Raspberry Pi se conecte al mundo. Los pines pueden generar voltaje, absorber corriente y leer niveles de voltaje. Las comunicaciones digitales complejas también pueden tener lugar en el GPIO.

Antes de comenzar, una aclaración sobre la conexión a GPIO: los pines en el encabezado de GPIO están conectados directamente al procesador Broadcom que es el corazón de una Raspberry Pi. Nunca debemos crear prototipos de circuitos mientras su Raspberry Pi está encendida porque un cortocircuito, por breve que sea, podría freír inmediatamente nuestra PI.

Apagaremos nuestra PI de manera segura, como se describe en la Sección 1.3, antes de desconectar la alimentación, ¡entonces estaremos listos para crear prototipos de algunos circuitos!

* Hemos preparado un gran repaso sobre cómo usar una placa de prueba, si no ha usado una antes (en inglés).

Sparkfun tiene un tutorial completo sobre cómo funcionan las resistencias pull-up (en inglés), si estamos interesado en leer más.

Necesitaremoss:

•     una placa de pruebas
•     2x LED
•     2 resistencias de 470 ohmios
•     un botón provisional
•     cable de conexión/cables de puente macho-hembra

Código para esta sección:

2.3 Pretty Demo: uso de matemáticas y funciones

Vamos a animar una bonita onda sinusoidal en nuestra interfaz. Para hacer esto escribiremos una función simple.

Código para esta sección:

2.4 Efecto LED de respiración

Reutilizaremos la configuración del botón LED de la Sección 2.2 para esta sección.

Código para esta sección:

La documentación de RPi.GPIO también tiene un ejemplo que ilumina/atenua un LED (en inglés). Para lograr ese fin, podemos usar algunos bucles for. Os animamos a comprobar cómo lo hicieron.

¡Asegurarse de cambiar el número pin GPIO en el código al que estemos usando!

2.5 Uso de HAT y el emulador Sense HAT

Todos los ejemplos de esta sección provienen directamente del Sense Hat Emulator. Podemos acceder a ellos seleccionando Archivo > Abrir ejemplo.

Tengamos en cuenta que cuando abrimos un ejemplo desde este menú, se guarda una copia del ejemplo en su directorio de inicio ( /home/pi ).

Así podemos acceder a la Demo de Rainbow (rainbow.py):

Capítulo 3: SECUENCIA DE COMANDOS DE SHELL CON BASH

En este capítulo aprenderemos sobre:

•     Cómo escribir un script BASH simple
•     Uso de variables y argumentos
•     Programación de tareas
•     Cómo usar el manual de comandos para que puedas usar los nuevos comandos correctamente.

3.1 Permisos de archivo, argumentos y nuestro primer script

Los argumentos son piezas de información que pasamos a un programa o función. Cuando ejecuta un comando como cd /home/pi, aquí el comando es cd y hay un argumento, /home/pi.

En BASH, se accede a los argumentos en el orden en que se pasaron con $x, donde x es el número del argumento. Esto significa que $1 se refiere al primer argumento y $4 se refiere al cuarto argumento (si lo hay). El nombre del comando emitido es $0.

Código para esta sección:

Listar archivos y sus permisos con

          ls  -l

Los permisos determinan quién puede leer, escribir (modificar o eliminar) y ejecutar (ejecutar) un archivo. Dado que probablemente solo haya un usuario en una Raspberry Pi, modificaremos los permisos solo para el propietario del archivo (que somos nosotros).

Agregue permisos de ejecución a un archivo de su propiedad con

          chmod u x <archivo>

Por supuesto, siempre podemos editar los permisos de archivos desde el escritorio gráfico haciendo clic con el botón derecho en un archivo y seleccionando Propiedades > Permisos > Control de acceso.

3.2 Variables y toma de decisiones

Para crear una variable, todo lo que necesitamos hacer es asignarla, por ejemplo a=5. ¡No usar ningún espacio! Para hacer algo de aritmética con la variable a, debemos envolver la expresión entre paréntesis dobles y agregar el símbolo $.

P.ej. para hacer que b sea igual a 5 veces a, escribiremos b=$(($a*5))

Código para esta sección:

Aquí hay algunas expresiones de ejemplo que podemos usar en enunciados IF:

3.3 Escribir un script de copia de seguridad útil

Vamos a escribir un script de archivo útil ahora. Este script tomará cualquier directorio o archivo que le demos y lo copiará en un directorio de archivo predeterminado.

Código para esta sección:

3.4 Mejorando el Backup-Script (Usando el Manual)

Vamos a mejorar nuestra secuencia de comandos de archivo para incluir la copia de archivos de entrada en un directorio con sello de fecha. Para lograr este fin, tendremos que repasar el uso del comando de fecha date leyendo su página del manual.

Esta será una habilidad útil para investigar comandos para usar en futuros scripts.

Código para esta sección:

3.5 Programación de tareas y ejecución al inicio

Utilizaremos siempre rutas de archivo absolutas cuando trabajemos con estas herramientas. Esto significa que la mayoría de los directorios que especifiquemos comenzarán con /home/pi. No usar sólo ~ o ./

Ejecutar comandos/programas al inicio:

Las entradas en /etc/rc.local se ejecutan al inicio.

Debemos editar este archivo con permisos de root, por ejemplo:

          sudo nano /etc/rc.local

Podemos agregar comandos debajo de la sección citada, pero asegurándonos de que la última línea se deje como salida 0

¡Advertencia!

Si un comando se ejecuta continuamente, como un script de Python con un ciclo infinito (while 1:) o algo que nunca sale, debe terminar la entrada con un carácter de  ( & ), por ejemplo:

          python3 /home/pi/script.py &

¡Si no hacemos esto, su Pi no arrancará porque está atascado en una secuencia de comandos de bucle infinito!

Todos los scripts de shell ingresados en rc.local deben terminar con una salida 0 para indicar que se completaron con éxito.

Una alternativa al uso de rc.local es usar el crontab (archivo de texto que guarda una lista de comandos a ejecutar en un tiempo especificado por el usuario), que se trata a continuación. El crontab es quizás un poco más seguro de usar que las ediciones en rc.local.

Programación de comandos/programas para que se ejecuten periódicamente:

    Las tareas se pueden programar introduciéndolas en el crontab. Edite el crontab con

               crontab -e

Aquí hay algunos ejemplos de cómo ejecutar algunas tareas cron:

Capítulo 4: APLICACIONES DE ESCRITORIO

En este capítulo aprenderemos sobre:

•     Cómo crear interfaces gráficas de usuario (GUI)
•     Programación basada en eventos

Comenzaremos con la creación de una interfaz muy simple y poco a poco ampliaremos su funcionalidad. Al final del capítulo, tendremos una interfaz gráfica de usuario ordenada que puede controlar el GPIO, útil si desea probar un poco de automatización del hogar o crear una interfaz dedicada para un proyecto.

Recursos del capítulo:

Documentación de Tkinter (en inglés)

4.1 Introducción a Tkinter

4.2 Nuestra primera GUI

Vamos a crear una GUI (Interfaz Gráfica de Usuario) muy sencilla para alternar un pin GPIO. Esto nos familiarizará con el flujo de trabajo de Tkinter:

1.     Crear la ventana principal de la GUI
2.     Crear widget, variable(s) requerida(s)
3.     Posicionar el widget
4.     Crear y adjuntar una función de evento
5.     Programa la función para que haga lo que queramos
6.    Repetir los pasos 2-6 según sea necesario

Aquí está la documentación de gpiozero (en inglés) si  preferiremos usarla en lugar de RPi.GPIO.

Usaremos este circuito LED simple,  *(estoy usando una resistencia de 470 ohmios):

4.3 Un recorrido por otros widgets

La programación de GUI es bastante repetitiva, por lo que podemos pensar en esta sección como una

referencia útil para copiar código e implementar rápidamente un widget.

4.4 Centro de comando LED con cuadro de entrada de texto

4.5 Barras de menú y ventanas adicionales

4.6 Eventos y enlaces

En ejemplos que usan GPIO, hemos estado capturando el evento WM_DELETE_WINDOW que ocurre si el

usuario hace clic en el botón de cerrar ventana (x). Aquí, demostraremos cómo capturar un evento de

doble clic y convertirlo en una interfaz de menú genial.

Hay muchos otros eventos que podemos utilizar.

Capítulo 5: INTERNET DE LAS COSAS

2.0 Resumen del capítulo

En el Capítulo 5, analizaremos qué es Internet de las cosas (IoT) y qué podemos hacer con él.

Exploraremos algunos servicios de IoT fáciles de usar que nos ayudarán a despegar con un mínimo de complicaciones.

Al final de este capítulo, podremos usar nuestra Raspberry Pi como una "cosa" conectada a la web que podemos controlar desde cualquier parte del planeta con una conexión a Internet.

5.1 Introducción a los servicios de IoT

IFTTT: If This, Then That se basa en applets y servicios. Los servicios son cosas que usamos todos los días, como correo electrónico, Twitter, Dropbox, Spotify, Instagram... y la lista continúa. Los applets son la forma en que IFTTT conecta nuestros servicios para cumplir nuestras órdenes. La estructura de una aplicación IFTTT es simple: si se detecta una determinada condición en un servicio, realice una acción que afecte a otro servicio. Si suena abstracto, no se preocupe. Pronto veremos un ejemplo aclaratorio.

Particle es una empresa de IoT que produce placas de microcontroladores conectadas a Internet. También mantienen Particle Cloud, un servicio que hace que sea muy fácil conectar dispositivos  a través de Internet. Recientemente, Particle agregó compatibilidad con Raspberry Pi a su servicio en la nube, lo que significa que podemos poner nuestra Pi en Particle Cloud de forma gratuita.

Para el resto de este capítulo, usaremos IFTTT y Particle, así que podemos registrarnos para obtener una cuenta con ambos servicios. También necesitaremos una cuenta de Gmail. Voy a crear una cuenta de Gmail especial solo para este capítulo. Si desea mantener su correo electrónico personal separado de sus experimentos de IoT, no estará de más hacer lo mismo.

En el momento de escribir este artículo, Particle Pi está en Beta, por lo que es posible que deba seguir este enlace después de configurar su cuenta de Particle.

MQTT es un protocolo de mensajería ligero para dispositivos IoT. Funciona como una interfaz de publicación -> suscripción. Simplemente, los dispositivos IoT se suscriben a un tema que les interesa. Un editor publica datos en un tema y esos datos se envían a todos los suscriptores de ese tema. Si desea obtener más información, hemos preparado un tutorial sobre cómo comenzar con MQTT en una Raspberry Pi. Adafruit también alberga un servidor MQTT gratuito llamado Adafruit IO.

Sparkfun ha creado su propio servidor de datos de uso gratuito en data.sparkfun.com. Aquí podemos crear flujos de datos, almacenar datos e incluso crear un servidor de datos privado.

5.2 Particle Pi y IFTTT

Al final de este vídeo seremos capaces de controlar un GPIO por correo electrónico. Dejemos que eso se asimile.

1. Construya el siguiente circuito

    2. Configurar el particle-agent en su Pi

Puedes encontrar la documentación completa de instalación de particle-agent aquí.

Instala particle-agent ejecutando:

             bash <( curl -sL https://particle.io/install-pi )

Una vez que el agent se ha instalado, se le pedirá que introduzca su nombre de usuario y contraseña para vincular su Pi a la nube  (Tendremos la oportunidad de dar a nuestra Pi un nombre que aparecerá en la nube). Una vez completado esto, podremos iniciar sesión en build.particle.io y ver nuestra PI listada y mostrada como "online".

   3. Crear una Particle APP

En build.particle.io, seleccionar "Create New App" y copiar el código en nuestra aplicación. Tenemos que cambiar la cadena "unique_event_name" por una cadena única de nuestra elección (no la hagas corta y sencilla). Hacer clic en el icono del "rayo" para que la aplicación aparezca en nuestra Pi. (Así es, estamos desarrollando código para nuestra Pi desde un navegador de Internet, y podremos cargar nuestro código a través de Internet. Podemos estar haciendo esto desde cualquier parte del mundo. Momento para tomarnos un descanso y recuperarnos, tal vez sea hora de una taza de té).

// -----------------------------------------

// Demonstrate Particle and IFTTT

/* -----------------------------------------

This program subscribes to a a particle event.

An IFTTT app monitors inbox activity of a Gmail account and publishes events to the Particle Cloud.

------------------------------------------*/

int led = D1;

int boardLed = D7;

// setup() is run only once, it's where we set up GPIO and initialise peripherals

void setup() {

  // Setup GPIO

  pinMode(led,OUTPUT); // Our LED pin is output (lighting up the LED)

  pinMode(boardLed,OUTPUT); // Our on-board LED is output as well

  digitalWrite(led,LOW);

  digitalWrite(boardLed,LOW);

  // Subscribe to an event published by IFTTT using Particle.subscribe

  Particle.subscribe("unique_event_name", myHandler);

  // TODO:

  // Subscribe will listen for the event unique_event_name and, when it finds it, will run the function myHandler()

  // (Remember to replace unique_event_name with an event name of your own choosing. Make it somewhat complicated to make sure it's unique.)

  // myHandler() is declared later in this app.

}

// loop() runs continuously, it's our infinite loop. In this program we only want to repsond to events, so loop can be empty.

void loop() {

}

// Now for the myHandler function, which is called when the Particle cloud tells us that our email event is published.

void myHandler(const char *event, const char *data)

{

  /* Particle.subscribe handlers are void functions, which means they don't return anything.

  They take two variables-- the name of your event, and any data that goes along with your event.

  In this case, the event will be "buddy_unique_event_name" and the data will be "on" or "off"

  */

  if (strcmp(data,"led-off")==0) {

    // if subject line of email is "off"

    digitalWrite(led,LOW);

    digitalWrite(boardLed,LOW);

  }

  else if (strcmp(data,"led-on")==0) {

    // if subject line of email is "on"

    digitalWrite(led,HIGH);

    digitalWrite(boardLed,HIGH);

  }

}

4. Construya un nuevo subprograma IFTTT

Nuestra Pi está quieta pacientemente, esperando algún evento desencadenante. Démosle uno.

Iniciemos sesión en IFTTT y creemos un nuevo subprograma (Mis subprogramas > Nuevo subprograma)

Haga clic en éste y seleccione o busque 'Gmail'; Se le pedirá que autorice a IFTTT para acceder a su cuenta de Gmail. A continuación, seleccione Nuevo correo electrónico en la bandeja de entrada de la búsqueda. Este es un propósito que podemos refinar en el próximo paso.

Ahora tenemos que introducir nuestra condición de búsqueda. Queremos verificar el campo de asunto de un correo electrónico entrante para los asuntos led-on (activados) y led-off (desactivados). Podemos hacer clic para ver otros operadores de búsqueda útiles, pero para este ejemplo vamos a ingresar {subject:led-on subject:led-off} que verifica cualquier tema.

De vuelta en el menú del subprograma, veremos que gmail se ha colocado en la condición if. Ahora seleccione  "that". Aquí es donde vinculamos nuestro servicio de correo electrónico a Particle Cloud. Seleccione o busque 'Partícle' y seleccione la opción Publish an even. En el cuadro Event name, ingrese el nombre único del evento que eligimos anteriormente. Dejamos el campo de datos como Subjet  (así es cómo pasaremos la información a nuestra Pi).

5. Envíémonos un correo electrónico a nosotros mismos

Envíe un correo electrónico con el asunto led-on desde cualquier dirección a la que configuró como activador de IFTTT. (En mi caso, solo voy a enviarme un correo electrónico).

Podemos hacer que IFTTT verifique manualmente su activación abriendo el applet y haciendo clic en check now. Esto es útil para cuando estamos depurando, porque el tiempo de respuesta para IFTTT puede variar enormemente, de segundos a minutos.

¡Tu LED debería encenderse! Y cuando envíe un correo electrónico con el asunto como led apagado, el led debería apagarse. ¿¡Qué genial es esto!?

Particle Pinout Reference

Paricle fabrica su propio hardware, por lo que han mantenido su propia nomenclatura GPIO en su servicio Particle Pi. Esto es bastante bueno, porque significa que puede cambiar fácilmente en qué tipo de dispositivo (Pi <==> Particle) se ejecuta su código si lo desea.

Aquí tenemos una tabla muy útil para realizar un seguimiento del GPIO, según lo definido por Particle.

5.3 Comunicaciones Pi a Pi con Particle Pi

En la última sección nos pondremos al día con IFTTT, un servicio súper versátil. IFTTT es flexible, pero a veces no se activa instantáneamente. Si nuestro proyecto es sensible al tiempo, nos comunicaremos directamente a través de Particle Cloud. Aquí, publicaremos y nos suscribiremos a eventos en dos Raspberry Pi.

Editor

Publisher

Circuito

Particle App

// -----------------------------------------

// Publisher Code Demo

/* -----------------------------------------

    Each time a button is pressed, publish

    the total number of button-presses to

    an event. 

------------------------------------------*/

// GPIO Definitions

int pwr3_3 = D12; // 3.3V supply for button

int flashButton = D13;

int resetButton = D16;

int boardLed = D7;

int pressCount = 0; // Stores the number of times the flash-button is pressed

// Setup GPIO

void setup() {

    pinMode(flashButton, INPUT);

    pinMode(resetButton, INPUT);

    pinMode(boardLed, OUTPUT);

    pinMode(pwr3_3, OUTPUT);

    digitalWrite(boardLed, HIGH); // Start the onboard LED as OFF (boardLed is inverted)

    digitalWrite(pwr3_3, HIGH);

}

// Poll the button status, increment or reset the counter, publish the count.

void loop() {

    if (digitalRead(flashButton) == HIGH) {// HIGH when pressed

        pressCount  ;

        String dataString = String(pressCount);

        Particle.publish("buttonPressed",dataString,60,PRIVATE);

        // And flash the on-board LED on and off.

        digitalWrite(boardLed,LOW); // On

        delay(500);

        digitalWrite(boardLed,HIGH); // Off

    }

    if (digitalRead(resetButton) == HIGH) pressCount = 0; // Reset the press-counter

}

Subscriber

Particle App

// -----------------------------------------

// Subscriber Code Demo

/* -----------------------------------------

    Subscribe to an event and assume all 

    data that comes in is numeric.

    Convert the string data to an integer

    and flash an LED that number of times.

------------------------------------------*/

int led = D1;

volatile int blinkCount = 0;

volatile bool trigger = 0;

void setup() {

  // Setup GPIO

  pinMode(led,OUTPUT); // Our LED pin is output (lighting up the LED)

  digitalWrite(led,LOW);

  // Subscribe to an event published by our second Raspberry Pi (or other device!)

  Particle.subscribe("buttonPressed", myHandler, MY_DEVICES);

  // The MY_DEVICES argument means that only events published by devices registered to this Particle Cloud account will be accepted.

}

void loop() {

    if (trigger) { // trigger is set TRUE in the event handler

        for(int i = 0; i < blinkCount; i  ){

            digitalWrite(led, HIGH);

            delay(350);

            digitalWrite(led, LOW);

            delay(350);

        }

        trigger = 0; // Need to reset the trigger

    }

}

void myHandler(const char *event, const char *data)

{

    String dataVar = data;       // Load data, which is a constant into a string variable

    blinkCount = dataVar.toInt(); // Now we can call a special function which converts the numberic data in the string, to an integer

    trigger = 1; // Trigger the blink loop

}

5.4 Cierre del taller: ¿Hacia dónde desde aquí?

Hemos cubierto varios temas a lo largo de este taller, y realmente sólo hemos arañado la superficie de cada uno. A estas alturas, hemos reunido una caja de herramientas, de habilidades útiles y somos conscientes de los tipos de tareas que nuestra Raspberry PI puede manejar.

Dónde encontrar inspiración:

Un buen lugar para comenzar con una nueva pieza de hardware es encontrar un proyecto bien documentado y copiarlo. Hay un montón de proyectos geniales en instructables.com, hackaday.io, y en nuestra propia página de proyectos.

Dónde obtener ayuda:

Raspberry Pi Stack Exchange (en inglés) es el lugar indicado para preguntas específicas sobre Raspberry Pi.

The Unix and Linux Stack Exchange  (en inglés) es el lugar al que debe responder sus preguntas sobre Linux, como el uso de comandos, secuencias de comandos de shell y otras tareas del sistema operativo.

*(Para recibir respuestas de calidad en Stack Exchange, asegúrese de hacer preguntas de calidad. Proporcione información sucinta en sus preguntas, y siempre ayuda haber buscado un poco en Google primero).

Por supuesto, siempre hay nuestros propios foros (en inglés).