Raspberry Pi y Python. Computación física.

Basado en el curso: Teaching Physical Computing with Raspberry Pi and Python Raspberry Pi Foundation. Extraído de: https://www.futurelearn.com.

Curso gratuito en inglés para el aprendizaje de Python con la Raspberry Pi. Traducción al español realizada por Chito con algunas adaptaciones.

Material de consulta:
Computación física. https://github.com/raspberrypilearning/physical-computing-with-python

Problemas con la Raspberry Pi

Si tiene algún problema para empezar con su Raspberry Pi, hay ayuda con más guías de hardware y software, es fácil de seguir las instrucciones para empezar con la Raspberry Pi. (Material en inglés).

Raspberry Pi/help
Top Ten Tips for Troubleshooting
Hardware guide
Software guide
Teacher’s guide

Comenzando con Python

Los ordenadores necesitan instrucciones para cualquier uso, sin instrucciones son simplemente caros (en el caso de la Raspberry Pi, muy barato) son grumos de plástico y metal. Podemos escribir estas instrucciones usando un lenguaje de programación. Uno de los idiomas más fáciles, basados en texto, es Python. Sólo porque Python es fácil de aprender, no significa que no sea poderoso.

En el escritorio de Raspbian deberías ver un botón de la "frambuesa" el logo de la Raspberry en la parte superior izquierda. Haga clic en este para ver los diferentes tipos de aplicaciones que vienen pre-instaladas en el sistema Raspbian. A continuación, haga clic en Programación y a continuación, haga clic en Python 3 (IDLE).

Debe abrirse una nueva ventana en su escritorio. Este programa se llama IDE, que significa Interactive Development Environment., Entorno de desarrollo interactivo. Este IDE particular se llama IDLE.

La ventana que se ha abierto es conocida como un shell. En el shell se puede escribir código Python, y se ejecutará de inmediato. Escriba las siguientes líneas en el shell. No te preocupes por los tres símbolos de chevron (>>>), ya que estos serán añadidos por tu IDLE.

>>> print('Yo estoy escribiendo en python')
>>> 6+6
>>> #Esto es un comentario, esto no ejecuta nada

El shell es útil para probar algunas líneas de código o interactuar con programas que ha escrito, pero para escribir un programa de computadora, necesita escribir código en un archivo.

Haga clic en Archivo y Nuevo archivo, y se abrirá una segunda ventana. Es útil posicionarlos lado a lado de la siguiente manera:

El juego de "reacción simple" usando: entradas, salidas y variables

Podemos comenzar con un programa muy simple que implica entradas y salidas de variables

print('Rápido, presione la tecla enter')
input()
print('Que rápido has sido')

Guarde su archivo en (File > Save As...) y llámelo game.py. Para correr el archivo puedes presionar F5 en tú teclado

Las función print son de tipo salida. Le está indicando a la computadora que muestre texto en la pantalla.
La función input toma la entrada de las pulsaciones del teclado del usuario.
Hagamos que el programa sea un poco más interesante.
Podríamos hacer que el programa se detenga un poco antes de que comience el juego. Manejo de tiempo puede ser un poco complicado sin embargo, pero afortunadamente para nosotros el código de interfaz con el reloj de la computadora ha sido escrito para nosotros y empaquetado en un pequeño módulo agradable que podemos utilizar. Para empezar, sólo necesitamos una función del módulo time. Se llama la función de sleep.

from time import sleep
sleep(5)

print('Rápido, presione la tecla enter')
input()
print('Que rápido has sido')

Aquí se ha importado la función de sleep del módulo de tiempo y luego se le indicó al programa que hiciera una pausa de cinco segundos.
Guarde y ejecute su código para jugar con su nuevo juego.
Sería estupendo saber cuán rápido el usuario estaba entre ver el mensaje y presionar la tecla. Una vez más, el módulo de tiempo se puede utilizar para esto, y en particular una función llamada time (confusamente!). Podemos agregar la importación a nuestra primera línea.

from time import sleep, time
sleep(5)

print('Rápido, presione la tecla enter')
input()
print('Que rápido has sido')

La función de tiempo obtendrá el número de segundos que han transcurrido desde el 1 de enero de 1970. frambuesaAlmacenando este valor en una variable cuando se muestra el mensaje, y luego restando el tiempo de nuevo, después de que el usuario ha presionado una tecla, podemos resolver Su tiempo de reacción. Aquí, el valor del tiempo de reacción se almacena en la variable reaction_time. No puede tener espacios en nombres de variables, por lo que usamos subrayados.

from time import sleep, time

sleep(5)
start = time()
print('Rápido, presione la tecla enter')
input()
tiempo_reaccion = time() - start
print('Tú tiempo de reacción ha sido de ', tiempo_reaccion, 'segundos')

Guarde y ejecute su código y luego haga una reproducción. ¿Qué tan rápido puede golpear esa tecla Enter?

Applied Activity: Working with loops

En Python se puede utilizar bucles "loops" para hacer que las líneas de código se repitan. Hay dos tipos de loops - while y for. A continuación veremos ejemplos de ambos.

while

while True:
    print('Hola')
    input()

While es un loop infinito que repetirá las líneas subsiguientes que estén sangradas hasta que la condición deje de ser verdadera, quedaremos en un bucle infinito que nunca podremos salir, a menos que salgamos del programa.

SUGERENCIA: Si necesita detener el programa en ejecución, puede presionar Ctrl + C para detenerlo

for

for i in range(10):# cada iteracion es contada por range
    print("hola")
    print(i)# imprimirá el loop que lleva
    input()#al pulsar enter se inicia el loop
print("se acabo")# al realizar 10 iteraciones salta a este paso

Este bucle "loop" for es un bucle finito y se repetirá un número fijo de veces. Para cada valor de 0 hasta (pero no incluido) 10 asignará el valor a la variable i y llevará a cabo las líneas sangradas.
i= iteration, número de iteraciones. Se puede colocar cualquier letra

Observe que ambos bucles necesitan dos puntos (:) añadiendo al final de la línea, y luego cuatro espacios deben colocarse antes de las líneas de código que se van a repetir. Pruebe ambos programas mini para ver cuál es la diferencia entre los dos bucles.

SUGERENCIA: Si necesita detener el programa en ejecución, puede presionar Ctrl + C para detenerlo

     ¿Puedes usar bucles en tu juego para hacerlo repetir?
     ¿Se pueden usar variables para almacenar el tiempo de reacción total después de varios juegos?
     ¿Puedes calcular el tiempo medio de reacción?

Luces intermitentes con Leds

Vamos a usar la aplicación, IDE - IDLE, para escribir y ejecutar el código. Abra IDLE y haga click en: Menu > Programming > Python 3 (IDLE) en tu Raspberry Pi.
Vamos a necesitar abrir un archivo vacío para escribirlo, haga Click en File > New File y ábralo en una nueva ventana. Guardelo (File > Save As..) y llámelo blink.py
La otra vez usamos el módulo time e importamos la función sleep . Esta semana vamos a usar el módulo llamado "GPIO 0" gpiozero. Este módulo te da acceso a los GPIO pines de la Raspberry Pi de una forma fácil. No necesitas usar todo el gpiozero en tu programa, sólo una pequeña unidad de código llamando a la clase del módulo que te ayuda a controlar los LEDs. En la parte superior de su archivo escriba:
```
from gpiozero import LED
```
```
 
```
El siguiente paso es crear un nuevo objeto para el componente específico y el alfiler que estamos usando. Aquí hemos llamado el objeto red_led, pero el nombre que le das no importa realmente. Este objeto puede recibir diferentes comandos para controlar su comportamiento.

Red_led = LED (17)

Guarde y ejecute su programa. Puede hacerlo haciendo clic en File > Save y luego Ejecutar> Ejecutar módulo, o utilizando las teclas de acceso directo - ctrl + s y luego F5.
Nada sucederá de inmediato. Haga clic en el shell (la primera ventana que se abrió en IDLE) y ahora puede pasar algunos comandos diferentes a su objeto red_led. Pruebe los dos comandos siguientes.
```
 
```
```
>>> red_led.on()
>>> red_led.off()
```
```
 
```
Your led should turn on and off each time your type the lines. Let’s try and automate that a little. Back in the blink.py file you can import the time module, and specifically the sleep function. Alter you code so it looks like this:
```
 
```
```
from gpiozero import LED
from time import sleep
red_led = LED(17)
```
```
 
```
Ahora puede indicar a su programa que encienda y apague repetidamente el LED, usando un bucle infinito.
```
 
```
```
while True:
  red_led.on()
  sleep(1)
  red_led.off()
  sleep(1)
```
```
 
```
Guarde y ejecute su programa, y vea lo que sucede. ¿Qué hace cambiar la cantidad de tiempo pasado a la función sleep? ¿Cuál es el menor tiempo de sleep que puedes usar?

Todo el código sería así:

#Este programa hace que un led parpadee

#led_bliking.py. Nombre sugerido

from gpiozero import LED # biblioteca gpiozero función led
from time import sleep #biblioteca time función sleep

red_led = LED(17)# nombra a la variable "red_led" vinculada al pin 17

#loop para encender y apagar led
while True:
red_led.on() # hace que la variable este encendida, encender led
sleep(1) # El tiempo en espera sera de 1 s
red_led.off() # hace que la variable este apagada, apagar led
sleep(1) # el tiempo de espera será 1 s y vuelve al loop

Otros comandos del módulo gpiozero, que podrían ser útiles

El módulo gpiozero tiene algunos métodos incorporados para darle aún más control a tú LED. Estas son simplificaciones. La complejidad se ha ocultado, haciendo el código más fácil de escribir y más legible.

Podríamos eliminar while true (lazo o loop) copia su código anterior en un nuevo archivo para que se vea así:

from gpiozero import LED
from time import sleep
red_led = LED(17)

Ahora puede intentar agregar las siguientes funciones al programa. Pruebe uno a la vez y juegue con los números para ver lo que hacen.

BLINK . Con dos parámetros (tiempo de encendido y tiempo de apagado)
red_led.blink(0.1, 0.2)

BLINK. Con tres parámetros(tiempo de encendido, tiempo de apagado y

número de ciclos)

red_led.blink(0.2, 0.1, 5)

TOGGLE. Cambia el estado del pin y visualiza su estado

(true o false)

red_led.toggle()
sleep(1)
print(red_led.is_lit)
red_led.toggle()
sleep(1)
print(red_led.is_lit)

Detectar pulsaciones de botones

Entonces, ¿cómo se puede detectar el estado de un pin?. Una vez más, puede utilizar la biblioteca gpiozero para ayudarle con esto. En las dos líneas siguientes, se ha creado un objeto Button con el pin 4.
```
 
```
```
from gpiozero import Button
btn = Button(4) 
```
```
 
```
```
 
```
Ahora necesita detectar cuando se pulsa el botón, y dar al usuario alguna indicación de la acción que se ha producido. Wait_for_press y wait_for_release son dos métodos que harán una pausa en el programa hasta que se reciba una señal del botón.
```
while True:
    btn.wait_for_press()
    print('You pressed me')
    btn.wait_for_release()
    print('You released me')
```
```
 
```
Ejecuta tu programa y presiona ese botón, para ver qué pasa.

Prueba de reflejos

Por traducir

Ahora que ha adquirido las habilidades y conocimientos para controlar los LEDs y detectar pulsaciones de botones, es hora de construir su primer juego.
Cree un nuevo archivo de Python y guárdelo como reaction_game.py.
La idea del juego será tener un LED encendido después de un período aleatorio de tiempo. El jugador tendrá que pulsar un botón en el momento en que el LED se encienda, y el tiempo entre el LED que se enciende y el botón que está siendo presionado puede ser grabado y el tiempo de reacción aparecerá en la pantalla.
Para empezar, necesitarás usar algunas clases y funciones de los módulos que ya usaste en este curso. En particular, necesitará la clase Button y LED de gpiozero y las funciones de tiempo, sleep y randint de los módulos de tiempo y aleatorio.

En la parte superior de su archivo, importe las clases y la función como se muestra

a continuación.

from gpiozero import Button, LED
from time import time, sleep
from random import randint

La siguiente etapa será crear un nuevo objeto LED en el pin 17 y un objeto Button en el pin 4.

led = LED(17)
btn = Button(4)

Conecte físicamente un LED y un botón a las clavijas 17 y 4 respectivamente (no olvide utilizar una resistencia para proteger el LED).

Siempre es una buena idea probar su cableado, así que vamos a añadir un poco de código para asegurarse de que todo funcione bien.

led.on()
btn.wait_for_press()
led.off()

Guarde y ejecute su código. El led se encenderá y luego se apagará de nuevo cuando se presione el botón.

led = LED(17)

btn = Button(4)

while True:
    sleep(randint(1,10))
    led.on()
    start = time()
    btn.wait_for_press()
    end = time()
    led.off()
    print(end - start)

Si los guardas y lo ejecutas, el led debe encenderse, apagarse cuando se presiona el botón y volver a encenderse de nuevo. El bucle se ejecuta tan rápidamente que es posible que ni siquiera notes el parpadeo del LED. Usted
 puede colocar un sleep "pausa" en el bucle para detener este comportamiento, al
 igual que lo hizo en la última lección cuando hizo que el LED parpadee. Sin
 embargo, esta vez, en lugar de hacer que el programa duerma durante un 
tiempo determinado, podemos hacerlo dormir durante un número aleatorio 
de segundos usando la función randint. En el código siguiente, el tiempo será un número entero aleatorio entre 1 y 10 segundos 

while True:
    sleep(randint(1,10))
    led.on()
    start = time()
    btn.wait_for_press()
    led.off()
    end = time()

Para terminar el juego básico, puedes restar el inicio "start" del final "end" para calcular el Tiempo de reacción, y luego imprimirlo en la pantalla.

from gpiozero import Button, LED
from time import time, sleep
from random import randint

led = LED(17)
btn = Button(4)

while True:
    sleep(randint(1,10))
    led.on()
    start = time()
    btn.wait_for_press()
    end = time()
    led.off()
    print(end - start)

Guarda y ejecuta tu juego para ver cómo son tus tiempos de reacción. Puede salir del programa utilizando ctrl + c.

El blog de Chito de tecnología

Buscar este blog