Vamos a abordar una de las facetas mas interesantes de nuestra tarjeta: su comunicación con el mundo exterior. Para ello, vamos a describir – de una manera sencilla – la forma en que la Raspi hace uso de su
puerto de señales de propósito general, más conocido como GPIO.
Nota: esta entrada se basa en el harware Raspberry Pi y en el software Raspbian (p.ej. Wheezy)
Vamos a comentar en este primer artículo – y de la manera más didáctica posible – el hardware asociado al citado puerto, asi como la forma en que Linux controla el mismo, para finalizar manejando una tarjeta I/O “educativa” (XUE-001) que permite el control desde la Raspberry de una señal de salida y otra de entrada, o dicho de otra manera : hacer que Raspbian controle un hardware externo vía software.
El resumen de lo que comentaremos a continuación es:
(1) Descripción (muy) básica del puerto GPIO.
(2) Algo de teoría sobre entradas y salidas.
(3) Hardware I/O para Raspi: la tarjeta XUE-001
(4) Cómo “ve” Linux el puerto GPIO de la Raspberry Pi.
(5) Primer programa (sencillo) de prueba: lectura y escritura vía GPIO.
1 – Descripción (muy) básica del puerto GPIO
La tarjeta Raspberry Pi puede comunicarse con dispositivos externos mediante el conector GPIO incorporado. En dicho conector se integran patillas de alimentación ( +5 y +3.3 V) , masa, y entradas/salidas capaces de implementar diferentes protocolos.
Como quiera que hay 2 versiones de Raspberry a nivel hardware (rev. 1 y 2) las asignaciones de puertos también varían. Sin entrar – de momento – en detalles de protocolos, las dos posibles versiones de nuestra Raspberry hacen que nos encontremos a su vez con dos posibles escenarios hardware. Vemos aquí un esquema comparativo de la numeración de patillas.
Es importante tener en cuenta que – a nivel software – tenemos que saber con que patilla queremos comunicarnos, y por tanto, en esta y en posteriores entradas vamos a optar por utilizar patillas comunes a ambas releases.
Además de las patillas correspondientes a +5, +3.3 y masa, tenemos varios pines de uso genérico donde podemos conectar dispositivos hardware. En este artículo, de momento, vamos a explicar la forma de utilizar una patilla como entrada (INPUT) y otra como salida (OUTPUT).
Es muy importante comentar que cualquier manipulación errónea, conexionado equivocado o descarga estática sobre las patillas GPIO puede dañarlas de forma permanente. Por esta razón aconsejamos seguir fielmente las recomendaciones dadas al respecto.
2 – Algo de teoría sobre entradas y salidas..
Cuando un ordenador, un microprocesador o cualquier dispositivo microcontrolado efectua un control vía I/O el software se comunica con un dispositivo hardware externo, y las posibilidades de hacerlo son, típicamente, dos:
OUTPUT : genera una salida lógica (escribe) en una patilla configurada como SALIDA.
INPUT : obtiene un entrada lógica (lee) en una patilla configurada como ENTRADA.
En esta entrada vamos a tomar un par de patillas para efectuar las correspondientes lecturas/escrituras y conseguir así controlar un dispositivo externo, es decir, activar o desactivar mediante la patilla de salida y recibir una señal lógica mediante la patilla de entrada.
En nuestro ejemplo, vamos a utilizar la tarjeta XUE-001 de la firma Webtronika
y las patillas utilizadas por la misma son:
Patilla 8 (GPIO14) : salida digital
Patilla 24 (GPIO8) : entrada digital
Dado que el “nivel lógico” que maneja la Raspberry es de 3.3 V, las posibilidades y relaciones entre el software y el hardware son:
Para la ENTRADA (Patilla 24):
> leeremos un nivel lógico 1 (software) cuando tengamos 3.3 V en la misma (hardware)
> leeremos un nivel lógico 0 (software) cuando tengamos 0 V en la misma (hardware)
Para la SALIDA (Patilla 8):
> escribiremos un 1 lógico (software) para conseguir tener 3.3 V en la misma (hardware)
> escribiremos un 0 lógico (software) para conseguir tener 0 V en la misma (hardware)
En entradas posteriores ahondaremos en configuraciones tales como protocolos, resistencias de pull-up, etc. pero – de momento – podemos continuar sin utilizar estos parámetros.
4 – Cómo “ve” Linux el puerto GPIO de la Raspberry Pi.
Linux, como ya muchos conocen, referencia casi todo lo que maneja en forma de “fichero”, y las patillas del puerto GPIO no iban a ser una excepción. No es preciso que seamos unos “expertos” en Linux y conocer exactamente su gestión interna, pero lo que si conviene saber es que el “nucleo” de Linux ya sabe de la existencia de dicho puerto, pero no así el resto del sistema Linux, razón por la que tendremos que “informar” a nuestra tarjeta ( vía software) de la presencia del puerto GPIO para que la Raspi “vea” el mismo.
Para realizar esta operación tendremos que “exportar” la información I/O desde el núcleo Linux antes de poder acceder al puerto tal y como si de un fichero más se tratase. Para ello hemos de efectuar los comandos destinados a «crear» el acceso al hardware vía ficheros, y una vez efectuados tendremos el acceso en /sys/class/gpio.
Nota: la operativa de exportación ha de hacerse como root (su)
Si damos un vistazo a dicho directorio antes de «mapear» puerto alguno vemos que el contenido es :
Ahora adquirimos privilegios de root para efectuar los comandos mediante
sudo -i
y efectuamos en primer lugar el comando para exportar la patilla gpio14 como salida mediante
echo «14» > /sys/class/gpio/export
le damos permisos totales
chmod 777 -R /sys/class/gpio/gpio14
fijamos la dirección en la patilla como «salida»
echo «out» > /sys/class/gpio/gpio14/direction
Si ahora vemos de nuevo el contenido de /sys/class/gpio/ tenemos :
por lo que ya comprobamos que gpio14 está «exportado»
Debemos repetir un proceso homólogo con la patilla que usaremos como entrada (gpio8), así :
echo «8» > /sys/class/gpio/export
chmod 777 -R /sys/class/gpio/gpio8
echo «in» > /sys/class/gpio/gpio8/direction
y podemos comprobar luego el efecto en el directorio /sys/class/gpio/
En este punto las patillas que utilizaremos con la tarjeta XUE-001 ya están listas, por lo que solo tendremos que elegir el lenguaje de programación que más nos plazca y proceder a su control desde la Raspberry Pi.
5 – Primer programa (sencillo) de prueba: lectura y escritura vía GPIO.
Controlar la tarjeta XUE-001 no es complejo si seguimos las instrucciones aquí comentadas. La forma más sencilla de controlar las salidas a GPIO es mediante comandos del propio sistema operativo. Su manejo mediante lenguajes de alto nivel será comentado en entradas posteriores.
Los pasos a seguir para ello son:
(A) – Conectamos la tarjeta XUE-001 al puerto GPIO de la Raspberry mediante el cable plano que acompaña a la tarjeta.
Nota : efectuamos esta conexión con la tarjeta Raspberry Pi sin alimentar esta y prestando especial cuidado a la posición correcta de inserción del conector, tanto en la Raspberry como en la XUE-001.
(B) – Conectamos el cable alimentador USB a la tarjeta XUE-001. Es un conector típico en formato USB-B (hembra) y que coincide con los utilizados para conectar impresoras USB.
Nota: el cable USB-B no está incluido en el kit recibido al adquirir la tarjeta XUE-001
(C ) – Alimentamos la tarjeta Raspberry y dejamos que el sistema arranque. Si el proceso es correcto se debe iluminar el LED amarillo nada mas arrancar la Raspberry (señal POWER de Raspberry) y el verde (SALIDA).
Nota: si se han «exportado» previamente los puertos GPIO el LED verde estará apagado
El rojo (ENTRADA) debe permanecer apagado (salvo que pulsemos el micro-switch de TEST).
(D) – En la Raspberry Pi efectuamos la exportación de puertos ( gpio14 como salida y gpio8 como entrada ) tal y como hemos comentado en el punto anterior.
Ahora ya estamos listos para leer y escribir en el puerto GPIO de nuestra Raspi. ¡Vamos alla! …
— Controlando la salida de la Raspberry Pi —
El conector [OUTPUT] de la tarjeta XUE-001 incorpora un conector de 3 tomas (tornillos), a saber :
* NC – Contacto normalmente cerrado
* Co – Contacto común
* NO – Contacto normalmente abierto
estas provienen de un relé el cual, a su vez, es gestionado por la señal que llega a la tarjeta XUE-001 desde la Raspberry Pi y que es optoacoplada para añadir una máxima seguridad y aislamiento hardware a nuestra Raspi.
Si hemos realizado la «exportación» (y antes de enviar comando alguno desde la Raspi) deberá estar activo solo el LED amarillo (POWER). En este momento el relé mantiene cerrados los contactos «Co» y «NC».
Para cambiar el estado de la salida – y por tanto el del relé, el LED verde indicador y cualquier dispositivo conectado a través del mismo – ejecutamos:
echo «1» > /sys/class/gpio/gpio14/value
activando la salida y haciendo conmutar al relé. En este instante los contactos «Co» y «NO» deben haberse cerrado y el LED verde deberá activarse.
para desactivar la salida ejecutamos
echo «0» > /sys/class/gpio/gpio14/value
Ahora los contactos «Co» y «NC» deben haberse cerrado y el LED verde deberá apagarse.
Podemos controlar mediante los contactos del relé un dispositivo externo desde nuestra Raspi. ¿ Cual ? … eso ya dependerá de nuestra imaginación.
Nota : el consumo controlado desde el relé no debe sobrepasar los 750 mA (1A max).
— Controlando la entrada a la Raspberry Pi —
Vemos que la tarjeta XUE-001 incorpora un micro-interruptor etiquetado como «TEST«, el cual nos permite efectuar una verificación rápida del estatus de la señal de entrada. Esto resulta muy interesante ya que podemos verificar que la Raspi lee correctamente la señal de entrada antes de conectarle cualquier señal o sensor a la misma.
Cuando pulsemos el citado micro-interruptor se iluminará el LED rojo, momento en que se envía – también de forma optoacoplada – una señal de nivel lógico «1» al puerto GPIO de la Raspi. Cuando el micro-interruptor no está pulsado (LED rojo apagado) la señal que recibe la Raspi es un «0» lógico.
Para «leer» esta entrada (suponemos ya mapeado / exportado el puerto gpio8) hemos de ver el valor (0/1) que hay en el fichero exportado anteriormente, por lo que efectuamos el comando
more /sys/class/gpio/gpio8/value
vemos que el valor obtenido depende de que pulsemos (1) o no (0) el micro-interruptor de «TEST». De esta forma podemos crear un software que actúe dependiendo del estado de nuestra entrada …
La tarjeta XUE-001 incorpora como entrada dos diferentes posibilidades, a saber:
Entrada A – Modo (switch) => se activa cerrando los contactos (SW-SW)
Entrada B – Modo (signal) => se activa por nivel [ 5 a 12 V ] en contactos (+ -)
podemos probar la entrada A cortocircuitando las entradas etiquetadas como SW-SW y ver que se activa el LED rojo. Para la entrada B deberemos conectar cualquier sensor (respetando la polaridad) que nos suministre un nivel entre 5 y 12 V.
En una próxima entrada comentaremos cómo controlar el puerto GPIO usando otras interesantes opciones … ahora a DIVERTIRSE
Bitcoin Currency Converter