Capitulo III. - firteconline.com.arfirteconline.com.ar/Digitales/CapII.pdf · solo 16 son visibles...

Capitulo III.

Pantalla LCD Hitachi 44780.Si bien para visualizar datos los dígitos de siete segmentos son muy usados y útiles las pantallas LCD como la clásica Hitachi 44780 que brinda una solución elegante y de bajo costo.

Básicamente podemos imaginar una pantalla LCD como una memoria de 40 caracteres de los cualessolo 16 son visibles (pantallas 16x2).

Estas pantallas se pueden manejar en 8 o 4 bit's. En este manual usaremos el enfoque de 4 bit's ya que esta modalidad nos libera mas pines en el puerto de la Raspberry PI.

El manejo de un LCD, no es nada del otromundo si comprendemos la arquitectura deun modulo LCD. Los módulos LCD, llevan integrado a suscircuitos, 3 regiones de memorias que seránla base fundamental para el funcionamientodel modulo. Por un lado, tenemos dos regiones donde sealbergan datos temporales con características RAM. Estas dos regiones, son las llamadas CGRAM y DDRAM, que son en si los espacios donde se almacenan los datos que se van a mostrar en pantalla. La diferencia entre una y otra, es que la CGRAM (Character Generator RAM), nos permite definir y

Electrónica Digital con RaspberryPI Pagina 54 de 81

alojar 8 nuevos caracteres personalizados. En la CGRAM, es donde se alojan los caracteres creados por el usuario con matrices personalizadas, y la DDRAM (Data Display RAM), es un espacio temporal donde se almacenan los caracteres que se van a mostrar en pantalla.La DDRAM, tiene una capacidad de 80 bytes, 40 por cada línea, de los cuales sólo 32 se pueden visualizar a la vez (16 bytes por línea). Las dos direcciones más importantes de la DDRAM son:

• Dirección 0x00, que es el comienzo de la primera línea.• Dirección 0x40, que es el comienzo de la segunda línea.

Por otro lado, tenemos un espacio de memoria interna no volátil del tipo ROM, llamada CGROM (Character Generator ROM), que es donde se almacena una tabla con los 192 caracteres que puedenser visualizados (ver el siguiente cuadro).

Cada uno de los caracteres tiene su representación binaria de 8 bits. Para visualizar un carácter deberecibir por el bus de datos el código correspondiente. El módulo LCD además de tener definidos todo el conjunto de caracteres ASCII, permite al usuario definir 4 u 8 caracteres gráficos. La composición de estos caracteres se va guardando en una memoria llamada CGRAM con capacidad


para 64 bytes. Cada carácter gráfico definido por el usuario se compone de 16 u 8 bytes que se almacenan en sucesivas posiciones de la CGRAM.Se debe establecer la dirección en la memoria CGRAM a partir de la cual se irán almacenando los bytes que definen un carácter gráfico. Para la creación de caracteres gráficos hagamos un poco de memoria. Cuando enviamos el código de un carácter alfanumérico a la DDRAM del LCD, su chip interno buscará en la CGROM el patrón correspondiente y luego lo visualizará en la pantalla. Así se escriben todos los textos.

Ahora bien, si el código enviado vale entre 0x00 y 0x07 (o 0x08 y 0x0F), el chip interno buscará su patrón de visualización en la CGRAM. Siendo ésta una RAM de lectura/escritura, podemos programar en ella los diseños que se nos ocurran.

La CGRAM (Character Generator RAM) consta de 64 bytes en los que se pueden escribir los patrones de 8 nuevos caracteres de 5×7 puntos ó 4 caracteres de 5×10 puntos.

Cuando los caracteres son de 5×7 puntos los 64 bytes se dividen en 8 bloques de 8 bytes cada uno, ycada bloque almacena el patrón de un nuevo carácter. El esquema mostrado arriba indica que:

• El primer bloque de CGRAM, con direcciones desde 0b00000000 hasta 0b00000111, corresponde al código 0x00 (ó 0x80) de la DDRAM.

• El segundo bloque CGRAM, con direcciones desde 0b00001000 hasta 0b00001111, corresponde al código 0x01 (ó 0x88) de la DDRAM; y así sucesivamente.

Por ejemplo, la figura de arriba indica que se han rellenado los dos primeros bloques con los


patrones de dos pacmans. Hasta ahí solo se han creado dos nuevos caracteres. Para mostrarlos en el LCD habría que escribir un código con las funciones adecuadas para esto.

Es importante dejar claro que los caracteres creados por el usuario se contienen en RAM por lo tanto cuando el LCD pierda su alimentación el carácter se perderá, esto implica que el código dentro del controlador debe contemplar la creación del carácter cada vez que el LCD arranque consumiendo en esto memoria de programa.

Para el manejo de estas pantallas contamos con una librería que trabaja conjuntamente con WiringPiy siempre antes de usar comando para el LCD se debe haber ejecutado la función wiringPiSetup() y luego la función

lcdInit(2, 16, 4, RS, EN, D0, D1, D2, D3, D0, D1, D2, D3);

Donde 2 es la cantidad de líneas, 16 los caracteres visibles y el resto son los pines de acuerdo a la definición.

const int RS = 3; GPIO_3const int EN = 14; GPIO_14const int D0 = 4; GPIO_4const int D1 = 12; GPIO_12const int D2 = 13; GPIO_13const int D3 = 6; GPIO_6

La función lcdPosition(lcdFD,0,1) indica donde estará l cursor, en este caso primera columna de la segunda fila (primer casillero-caracter de la segunda línea). La librería para el manejo de la pantalla consiste en dos archivos lcd.c y lcd.h que siempre estarán formando parte de los proyectos en que usemos la pantalla LCD.

Distribución de pines en la pantalla Hitachi 44780.

El pin R / W (pin 5) en la pantalla LCD debe estar conectado a 0V (GND), esto es muy importante si utiliza una pantalla de 5V, si conecta este pin a Raspberry destruirá el puerto. Esto es porque la pantalla intentará escribir en la Raspberry enviando niveles lógicos de 5V a un puerto que solo admite 3V.

Veamos un pequeño código en C que verifica el funcionamiento de la pantalla.

#include <stdio.h>#include <stdlib.h>#include <stdint.h>#include <unistd.h>#include <string.h>#include <wiringPi.h>


Pines usados por el LCD.

#include "lcd.h"#include <errno.h>

const int RS = 3;const int EN = 14;const int D0 = 4;const int D1 = 12;const int D2 = 13;const int D3 = 6;

int main(){

if (wiringPiSetup() < 0){

fprintf (stderr, "No puedo configurar el dispositivo %s\n", strerror (errno)) ;

return 1 ;

}

int lcdFD;

lcdFD = lcdInit(2, 16, 4, RS, EN, D0, D1, D2, D3, D0, D1, D2, D3);

lcdPosition(lcdFD,2 ,0);lcdPrintf(lcdFD,"RaspBerry PI");

lcdPosition(lcdFD,0,1);

lcdPrintf(lcdFD, "Firtec Argentina");

return 0;

}

Conversión Analógica Digital. En muchos proyectos tenemos que tratar con las señales o información del mundo analógico, comola temperatura, presión, corriente, etc .

Estas señales son analógicas de forma predeterminada y en la mayoría de los casos se utilizan sensores que convierten estas señales a analógico de tensión eléctrica que será presentada en un pindel microcontrolador para hacer algún trabajo.

Por desgracia, los microcontroladores son digitales y no pueden hacer frente a las señales analógicas por lo que estas señales deben ser convertidas en señales digitales que sean comprensibles por el núcleo del microcontrolador.

Para este propósito, los fabricantes de microcontroladores suelen incorporar estos módulos en los microcontroladores sin embargo los chips Broadcom de Raspberry no lo tienen por lo que será necesario conectarlos como periféricos y vincularlos a Raspberry a través de un bus o línea de comunicaciones. Básicamente digitalizar algo es simplemente convertirlo a una secuencia de números de tal forma que si hacemos el proceso inverso de leer esos números podemos reconstruir la información original.


El valor analógico a digitalizar puede ser cualquiera pero los números que se puede tratar en el conversor tienen valores finitos que dependen de la precisión del conversor A/D.

La operación de digitalización nos devuelve una secuencia de números que si usamos un convertidor de 12 bits serian entre 0 y 4095.

En la mayoría de los conversores analógico-digitales hay dos operaciones se cumplen de forma separada.

Sample y Hold convierte la señal en una señal que sigue siendo analógica, pero tiene valores sólo eninstantes de tiempo discretos (muestreo y retención ). El ADC convierte la serie de muestras en números (conversor analógico a digital ).


Conversor A/D MCP3201.

Como ejemplo vamos a implementar el conversor analógico digital MCP3201 fabricado por la empresa Microchip.Este conversor tiene una resolución de 12 bits pudiendo generar 4096 números por cada medición.

Puede ser alimentado de 2.7 a 5V por lo que cubre perfectamente el rango de voltajes que nos interesa (3V) para Raspberry.

El MCP3201 cuenta con un registro de aproximación sucesiva (SAR) y una interface serial SPI, lo que permite la capacidad de añadir un ADC de 12bits a cualquier Microcontrolador que implementeel protocolo de comunicaciones SPI. Algunas características del MCP3201 son la capacidad de tomar 100k muestras/segundos, posee un canal de entrada, muy bajo consumo de energía (5nA en standby, 400uA máximo en estado activo) y esta disponible en encapsulado de 8 pines PDIP, SOIC y TSSOP.

Algunas de las aplicaciones donde puede incluirse el MCP3201 son adquisición de datos, instrumentos de medición, procesadores de datos, mediciones industriales, control de motores, robótica, automatismos industriales, pequeños sensores para instrumentación portátil y aplicaciones de medicina.

Protocolo de comunicaciones SPI.

El SPI es un protocolo de comunicación sincrónica de 4 cables. Desarrollado por Motorola en 1982y con gran aceptación en la industria como sistema de comunicación de muy corta distancia, normalmente dentro la placa de circuito impreso vinculando distintos chips.

Es un protocolo de transmisión que permite alcanzar velocidades muy altas y que se diseñó pensando en comunicar un microcontrolador con distintos periféricos y que funciona a full dúplex (Una forma retorcida de decir que puede enviar y recibir datos al mismo tiempo).

SPI utiliza una solución síncrona, porque utiliza unas líneas diferentes para los datos y el reloj. El reloj (Clock) es una señal que indica al que escucha exactamente cuándo leer las líneas de datos, con lo que el problema de perdida de sincronía se elimina de raíz.


http://ww1.microchip.com/downloads/en/DeviceDoc/21290D.pdf

Por eso mismo, no se necesita pactar la velocidad de transmisión, ya que será el Clock quien fije la velocidad y puede ser variable a lo largo de la comunicación sin que sea un problema (Aunque por supuesto según el dispositivo habrá un límite de velocidad).

Uno de los motivos por los que SPI es tan popular es que el hardware de recepción puede ser sencillo lo que es una solución mucho más simple que una UART que trataremos en el siguiente capítulo.

En un bus SPI una de las partes genera el Clock al que llamamos master, (en nuestro caso raspberry es master) y el resto son los esclavos, pudiendo haber uno o varios en el bus. A la señal de reloj se lesuele llamar CLK por Clock o SCK por Serial Clock.

Cuando el master envía información, lo hace por una línea de datos normalmente de nombre MOSI(Master Out Slave In) y si el esclavo responde lo hace a través de una línea llamada MISO (Master In Slave Out).

Como es el master quien genera el Clock, necesita saber de antemano, si un esclavo va a devolver una respuesta y de que longitud, para mantener el Clock hasta que la transferencia esté completa.

Hay una última línea de control, llamada Slave Select o SS, que indica a un esclavo que el mensaje que viene es para él, o bien que se reclama que envié una respuesta a una petición del master.


La línea SS normalmente se mantiene alta y se activa con nivel bajo, lo que “despierta” al esclavo seleccionado. Cuando se termina la transferencia la línea es puesta a nivel alto y el esclavo se desactiva. Hay dos maneras de conectar múltiples esclavos a un bus SPI. Con una línea SS por cada esclavo o en cascada. En general cada esclavo requiere su propia línea SS para ser activado, y así evitar que dos hablen a la vez, porque el resultado sería ruido inútil. Basta con activar la línea correspondiente y el esclavo esta listo para recibir sus órdenes.

Cuando el número de esclavos crece suele ser más frecuente conectarlos en cascada, con el MISO de uno (Salida), conectado al MOSI (Entrada) del siguiente. En este caso solo usamos una única línea SS, que se comparte entre todos los esclavos.

Esta configuración es típica de una situación en la que le master envía datos pero no recibe nada de vuelta, como en el caso de una cadena de múltiples display LEDs ( Matrices de 8×8) , en los que se envía información para ser mostrada pero, no hay datos de retorno.


En este caso incluso podemos desconectar la línea MISO.

En la placa Raspberry el periférico SPI no está activada de forma predeterminada.

Para habilitarlo, haga lo siguiente.

En la configuración de nuestra Raspberry, en la lengüeta interfaces debemos activar los puertos que nos interesan, reiniciamos el sistema. Luego desde la consola verificamos que los dos puertos SPI están activos escribiendo: ls /dev/*spi*

Lo que debería responder: /dev/spidev0.0 /dev/spidev0.1


Conectando el conversor MCP3201 a Raspberry.

Una vez que tenemos todo preparado a nivel de protocolo SPI podemos pasar al hardware para obtener un resultado como el que se ve en la siguiente captura.

Usaremos el siguiente conexionado para medir las variaciones de voltaje en el punto medio del potenciómetro de 10K.

El siguiente es el programa para verificar el funcionamiento del puerto SPI con el conversor analógico digital MCP3201, Raspberry tiene dos puertos SPI, estamos usando el puerto 0.

#include <stdio.h>#include <stdlib.h>#include <stdint.h>#include <unistd.h>#include <string.h>#include <wiringPi.h>


#include <wiringPiSPI.h>#include "lcd.h"#include <errno.h>

void MCP3201(void); // Se informa que se creara una función llamada MCP3201.

const int RS = 3;const int EN = 11;const int D0 = 4;const int D1 = 5;const int D2 = 6;const int D3 = 7;

char buf [14];int ce = 0;

unsigned char ByteSPI[2]; unsigned char low; unsigned char hi; unsigned short int dato; unsigned int M0; unsigned char muestras =0; double Va;

int lcdFD;

int main(){if (wiringPiSetup() < 0){ fprintf (stderr, "No puedo configurar wiringPI!! %s\n", strerror (errno)) ; return 1 ;}

printf ("Conversor MCP3201\n") ; printf ("www.firtec.com.ar\n") ; if (wiringPiSPISetup (0, 100000) < 0) // Conexión a 1 MHz sobre SPI 0

{

fprintf (stderr, "Error en dispositivo SPI 0: %s\n", strerror (errno)) ; exit (1) ;

}

lcdFD = lcdInit(2, 16, 4, RS, EN, D0, D1, D2, D3, D0, D1, D2, D3); lcdPosition(lcdFD, 0,0);

lcdPrintf(lcdFD, "Conversor MCP3201");while(1){

MCP3201(); // Función para leer el conversor. } return 0;}

void MCP3201(void){ wiringPiSPIDataRW (0, ByteSPI, 2); // Lee dos Byte usleep(100); // Espera 100 uS. hi = (ByteSPI[0] & 0x1F); // Salva la parte alta del byte.

low = (ByteSPI[1] & 0xFe); // Salva la parte baja del byte.dato = (hi << 8) | low; // Alinea los bytes y los une en dato

M0 += dato; // Acumula en M0 16 mediciones.

if (15 == muestras++){ // Ya se hicieron 16 mediciones? dato = M0/16; M0 =0; // Borra las variables para la siguiente medición. muestras =0; Va = (double) (dato) * 3.3 / 8192.0; // Escala el dato a voltios. sprintf (buf, "Voltios:%3.3f",Va); // Convierte el dato a valores ASCII.


lcdPosition(lcdFD,0,1); // Coloca el cursor en posición. lcdPuts(0, buf); // Muestra el voltaje. }}

Escritorios remotos.Todo lo visto supone que usted tiene conectado a su Raspberry un monitor y un teclado lo cual está perfecto pero esto no es absolutamente necesario para usar Raspberry siendo que puede manejar todo desde su computadora conectada a la red y a través de escritorios virtuales. Para poder responder a las conexiones entrantes todo lo que hemos de hacer es instalar el paquete xrdp en nuestra Raspberry, primero ejecutamos el comando de actualización.

sudo apt-get update

y, a continuación, lanzamos la instalación del servidor de escritorios virtuales.

sudo apt-get install xrdp

Una vez instalado podemos conectarnos con cualquier cliente para escritorios remotos.El imagen siguiente se aprecia una computadora con GNU Linux Debian corriendo el cliente de escritorios remotos para KDE denominado KRDC.

Observe podemos ver el mismo escritorio que vemos en el monitor conectado a Raspberry y ejecutar los mismos programas tal cual como si estuviéramos trabajando físicamente sobre nuestra placa Raspberry.

Todo esto lo podemos hacer a través de nuestra red Wi-Fi sin necesidad incluso que la placa Raspberri se encuentra físicamente en el mismo lugar donde estamos trabajando.

Desde el sistema Windows es lo mismo con la facilidad agregada que Windows ya trae un cliente


para escritorios virtuales por defecto solo debemos llamar a la aplicación y colocar la dir IP de nuestra placa Raspberry, podemos averiguarlo ejecutando.

sudo ifconfig -a

Ponemos el usuario (por defecto pi) y la clave que hayamos definido para nuestra Raspberry.

Una vez cumplido estos pasos podemos conectarnos a nuestra Raspberry por la red Wi-Fi.

Windows 7 mostrando el escritorio de Raspberry.

Un detalle a tener presente es que siempre la conexión por escritorio remoto será un tanto mas lenta que si estamos vinculados físicamente a nuestra Raspberry.

También nos puede ser muy útil instalar un servidor FTP para transferir archivos hacia y desde nuestra Raspberry por la misma red Wi-Fi. Para instalar el servidor en nuestra Raspberry escribimos en la terminal.

sudo apt-get install vsftpd

Luego que el programa se instala vamos a configuración para indicar que siempre lo queremos


activo, para esto escribimos en a terminal.

sudo nano /etc/vsftpd.conf

Y realizamos las siguientes reformas.Editando o descomentando las siguientes líneas

Anonymous_enable = NOLocal_enable = SIWrite_enable = SIAscii_upload_enable = SIAscii_download_enable = SI

Salvamos el archivo y reiniciamos el servicio con sudo /etc / init.d / vsftpd restart.Luego con cualquier cliente FTP podemos conectarnos a nuestra Raspberry para transferir archivos.

El FileZilla es una buena opción, siendo muy simple de utilizar solo requiere que indiquemos la dir IP del servidor (IP de nuestra RaspBerry) el usuario (generalmente pi) y la clave de acceso de nuestra placa Raspberry. (El número de puerto lo podemos dejar libre FileZilla lo configura por defecto).


Sensor Analógico LM35El LM35 es un sensor de temperatura con una precisión calibrada de 1ºC. Su rango de medición abarca desde -55°C hasta 150°C. La salida es lineal y cada grado Celsius equivale a 10mV.

Por lo tanto las mediciones serian 1500 milivoltios equivalen a 150 ºC y -550 milivoltios serán -55 ºC .

Sus características más relevantes son:

• Está calibrado directamente en grados Celsius.

• La tensión de salida es proporcional a la temperatura.

• Tiene una precisión garantizada de 0.5 °C a 25 °C.

• Baja impedancia de salida.

• Baja corriente de alimentación (60 μA).

• Bajo coste.

El LM35 no requiere de circuitos adicionales para calibrarlo externamente. La baja impedancia de salida, su salida lineal y su precisa calibración hace posible que este integrado sea instalado fácilmente en un circuito de control. Debido a su baja corriente de alimentación se produce un efecto de auto calentamiento muy reducido. Se encuentra en diferentes tipos de encapsulado, el máscomún es el TO62 utilizada por transistores de baja potencia.

La salida del sensor de temperatura se conecta a la entrada del conversor analógico. El mismo circuito que usamos con el potenciómetro cambiando el potenciómetro por el sensor de temperatura.

Si bien se puede conectar el sensor a 3V la hoja de datos indica que su funcionamiento correcto se obtiene con un voltaje de alimentación mínimo de 4V.

Para verificar su funcionamiento vamos a escribir el siguiente programa en C (también lo encontrará en las carpetas de ejemplos del curso).

Debe prestar especial cuidado al conectar el sensor, invertir alguna conexión dañará el LM35.


Programa para el LM35.

#include <stdio.h>

#include <stdlib.h>

#include <stdint.h>

#include <unistd.h>

#include <string.h>

#include <wiringPi.h>

#include <wiringPiSPI.h>

#include "lcd.h"

#include <errno.h>

void MCP3201(void);

const int RS = 3;

const int EN = 11;

const int D0 = 0;

const int D1 = 5;

const int D2 = 6;

const int D3 = 7;

char buf [14];

int ce = 0;

unsigned char ByteSPI[2];

unsigned char low;

unsigned char hi;

unsigned short int dato;

unsigned int M0;

unsigned char muestras =0;

double Va, temperatura;

int lcdFD;

int main(){



return 1 ;}

printf ("Probando el conversor MCP3201 y LM35\n") ; printf ("www.firtec.com.ar\n") ;

if (wiringPiSPISetup (0, 100000) < 0){

fprintf (stderr, "ERROR en SPI 0: %s\n", strerror (errno)) ;

exit (1) ; }



lcdPosition(lcdFD, 1,0);

lcdPrintf(lcdFD, "MCP3201 & LM35");while(1){

MCP3201(); } return 0;}

void MCP3201(void){

wiringPiSPIDataRW (0, ByteSPI, 2);

usleep(100);

hi = (ByteSPI[0] & 0x1F);low = (ByteSPI[1] & 0xFe);dato = (hi << 8) | low;M0 += dato;

if (15 == muestras++){

dato = M0/16;

M0 =0;

muestras =0;

Va = (double) (dato) * 3.3 / 8192.0;

temperatura = Va / (10.0 / 1000);

sprintf (buf, "Temp:%2.1f",temperatura);


lcdPuts(0, buf);

}

}

Sensor 1-Wire DS18B20El sensor de temperatura DS18B20 es un dispositivo que se comunica deforma digital. Cuenta con tres terminales, los dos de alimentación y el pin dedatos.

Con Raspberry podemos “leer” la temperatura que registra este sensor queposee una característica muy peculiar. Utiliza la comunicación OneWire, lacual es un poco complicada para los que no tienen mucha experiencia en elárea de electrónica digital.

Básicamente se trata de un protocolo especial que permite enviar y recibirdatos utilizando un solo cable, a diferencia de la mayoría de los protocolosque requiere dos vías. De hecho, Raspberry posee pines RX y TX que sonlos encargados de enviar y recibir información mediante la UART.

Para muchas personas que intenten aprender a utilizar el sensor DS18B20 probablemente sea un poco difícil encontrar información precisa y concisa, debido a que se habla mucho de este protocolode comunicación de un solo cable y los códigos de ejemplo normalmente complejos tratando de explicar al usuario una serie de conceptos que para nuestros propósitos no tienen relevancia.

El sensor DS18B20 es un termómetro digital de alta precisión, entre 9 y 12 bits de temperatura en


grados Celsius (el usuario puede escoger la precisión deseada). Su temperatura operativa se encuentra entre -50 y 125 grados Celsius. La precisión, en el rango comprendido entre -10 y 85 grados es de ±0.5 grados. Su precio es económico, su interfaz de funcionamiento es sencilla y su uso es muy provechoso para proyectos que requieran mediciones precisas y confiables.

Una particularidad interesante de estos sensores es que poseen un número ID, algo así como un número MAC único grabado por el fabricante en cada sensor lo que posibilita tener muchos sensores y direccionarlos por su ID para conocer la temperatura en ese punto en particular.

Podemos ver en el siguiente diagrama la forma de conectar tres sensores (o mas) al pin GPIO-4 deRaspberry. El protocolo 1-Wire exige una resistencia de 4,7K colocada entre el pin de datos y 3,3V,recuerde estos sensores son en realidad un microcontrolador completo con un puerto decomunicaciones y claro un sensor de temperatura pero su electrónica interna es verdaderamentecompleja a pesar de su aspecto simple. Recuerde, parecen un transistor pero no lo son.

Rspberry no trae un puerto de comunicaciones en este protocolo y para hacerlo funcionardeberemos seguir algunos pasos. Primero vamos a editar un de configuración para definir un pinpara este protocolo,para esto escribimos en la terminal.

sudo nano /boot/config.txt

Y al final del archivo agregamos lo siguiente.(preste atención a no cometer un error en la sintaxis delo que escribe).

dtoverlay=w1-gpio,gpiopin=4

Luego reiniciamos la Raspberry y ejecutamos los siguientes pasos:

Dentro del directorio /sys/bus/w1/devices se encontrarán dos capetas, uno de ellos tendrá como


nombre el ID del sensor. Si tiene varios sensores cada uno tendrá una carpeta con su ID.

Siempre primero deberá editar el archivo config.txt de lo contrario no funcionará.

Una vez que tenemos nuestros sensores ubicados podemos escribir un simple programa en C para verificar su funcionamiento. (El proyecto completo lo encontrará en las carpetas de ejemplos).

Con este programa veremos la temperatura en la pantalla Hitachi44780 como se aprecia en la imagen siguiente.

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <sys/fcntl.h>

#include <time.h>


#include "lcd.h"

#include <errno.h>

const int RS = 3;

const int EN = 11;

const int D0 = 0;

const int D1 = 1;

const int D2 = 2;

const int D3 = 10;

static int lcdHandle ;

char buf [4] ;

char temp [5];

int main(int argc, char *argv[]){

int fd = -1, ret;

char *tmp1, tmp2[10], ch='t';

char devname_head[50] = "/sys/devices/w1_bus_master1/28-00000482b243";

char devname_end[10] = "/w1_slave";

char dev_name[100];

long value;


ID del sensor conectado

Pines GPIO asignados a la pantalla LCD

int integer, decimal;

char buffer[100];

printf ("Corriendo DS18B20 & LCD 16*2\n") ;

printf ("www.firtec.com.ar\n") ;



return 1 ;}

pinMode (0, OUTPUT) ;digitalWrite (0, 0) ;strcpy(dev_name, devname_head);strcat(dev_name, devname_end);

int lcdFD;




lcdPrintf(lcdFD, "Sensor DS18B20");

lcdPuts(0, buf);


lcdPrintf(lcdFD, "Temp: ");

while(1){

if ((fd = open(dev_name, O_RDONLY)) < 0){

perror("Error abriendo archivo");

exit(1);}


ret = read(fd, buffer, sizeof(buffer));

if (ret < 0){

perror("Error de Lectura");

exit(1);}

close(fd);

tmp1 = strchr(buffer, ch);

sscanf(tmp1, "t=%s", tmp2);

value = atoi(tmp2);

integer = value / 100;

sprintf (buf, "%03d", integer) ;

temp [0]= buf[0];

temp [1]= buf[1];

temp [2]= '.';

temp [3]= buf[2];


lcdPuts(lcdHandle, temp); delay (50) ; }

return 0;}

Funcionamiento de la UART.En la actualidad y ante la ausencia de puertos RS232en las computadoras, acostumbramos a trabajar conpuentes USB-RS232 que solucionan muchos o todoslos problemas a la hora de vincularnos concomputadoras a través del viejo protocolo 232.Raspberry tiene un puerto UART que utiliza el GPIO_15 para transmitir (TX) y el GPIO_16 pararecibir (RX).

El controlador no resuelve la capa física, es decir que para implementar las comunicaciones deberemos utilizar ya sea el clásico MAX232 o los modernos puentes USB-232.

Esto es particularmente interesante porque conesta tecnología podemos reutilizar los viejos programas en puertos COM que por cuestionesde licencias o complejidad son mas simples deimplementar que las aplicaciones USB nativas.

Protocolo RS-232

El protocolo RS-232 es una norma o estándar mundial que rigelos parámetros de uno de los modos de comunicación serial. Por medio de este protocolo se estandarizan las velocidades detransferencia de datos, la forma de control que utiliza dichatransferencia, los niveles de voltajes utilizados, el tipo de cablepermitido, las distancias entre equipos, los conectores, etc.Además de las líneas de transmisión (Tx) y recepción (Rx), lascomunicaciones seriales poseen otras líneas de control de flujo(Hands-hake), donde su uso es opcional dependiendo del dispositivo a conectar.

A nivel de software, la configuración principal que se debe dar a una conexión a través de puertos seriales. RS-232 es básicamente la selección de la velocidad en baudios (1200, 2400, 4800, etc.), la verificación de datos o paridad (parida par o paridad impar o sin paridad), los bits de parada luego de cada dato(1 ó 2), y la cantidad de bits por dato (7 ó 8), que se utiliza para cada símbolo o carácterenviado. La Norma RS-232 fue definida para conectar un ordenador a un modem. Además de transmitirse losdatos de una forma serie asíncrona son necesarias una serie de señales adicionales, que se definen en la norma. Las tensiones empleadas están comprendidas entre +15/-15 voltios para el puerto original en computadoras en el caso de Raspberry los niveles son de 3,3 Voltios.


Para una comunicación punto a punto a una distancia no superior a 15 metros es lo que indica la norma.

Para visualizar los datos recibidos vamos a usar la aplicación terminal.exe que se encuentra entre las herramientas del curso.

El ejemplo que vamos a ver recibe los datos enviados desde el teclado de una PC y los re-transmite como un eco por el mismo puerto serial.

Observe que la velocidad en baudios debe ser la misma en programa receptor que en el emisor.Condición absolutamente necesaria para que una transmisión serial asincrónica funcione.


Dato enviado

Dato recibido

Un detalle importante para hacer funcionar la UART con nuestra electrónica es que tenemos primero que deshabilitar el serial desde las opciones de Raspberry.

Esto es necesario porque Linux hace uso del puerto serial, supone que lo usaremos para transferencias seriales con el propio sistema Linux y si no sacamos esta condición nuestros programas que hacen uso del serial se verán afectados por el propio sistema operativo que es “propietario” de la UART.

#include <stdio.h>#include <string.h>#include <errno.h>

#include <wiringPi.h>#include <wiringSerial.h>

int main (){ int fd ; // Descriptor del puerto serial char dato; if ((fd = serialOpen ("/dev/ttyAMA0", 115200)) < 0){ fprintf (stderr, "ERROR al abrir el dispositivo: %s\n", strerror (errno)) ; return 1 ; } if (wiringPiSetup () == -1){ fprintf (stdout, "ERROR al iniciar wiringPi: %s\n", strerror (errno)) ; return 1 ; }

for (;;){ while (serialDataAvail (fd)){ dato = serialGetchar (fd); // Lee el carácter y lo guarda en dato. serialPutchar (fd, dato) ; // Envía el carácter por el puerto UART. fflush (stdout) ; // Limpia buffer interno } } return 0 ;}

El ejemplo que sigue incorpora varios de los puntos vistos como son, el protocolo SPI para


Velocidad de comunicación en Baudios. Misma que la fijada en el programa Terminal.exe.

conectarnos a un conversor analógico digital, una pantalla LCD 16x2 y el puerto UART conectado aun software informático que representa un voltímetro virtual donde veremos el voltaje leído por el conversor al mismo tiempo que se muestra en la pantalla LCD. (Todo el proyecto como el software informático está en la carpeta de ejemplos).

/*******************************************************************************

* Ejemplo para UART + SPI + LCD con Raspberry PI.

* Mide la diferencia de voltaje generado con un potenciómetro aplicado a un conversor A/D MCP3201. El voltaje se muestra en una pantalla LCD 16x2 y seenvía por la UART para ser interpretado por un voltímetro virtual en la PC.

* www.firtec.com.ar - [email protected]

*******************************************************************************/

#include <stdio.h>

#include <stdlib.h>

#include <stdint.h>

#include <unistd.h>

#include <fcntl.h>

#include <termios.h>

#include <unistd.h>

#include <string.h>


#include <wiringPiSPI.h>

#include "lcd.h"

#include <wiringSerial.h>

#include <errno.h>

// Función para el conversor A/Dvoid MCP3201(void);

// Pines de la pantalla LCD

const int RS = 3;

const int EN = 11;

const int D0 = 0;

const int D1 = 1;

const int D2 = 2;

const int D3 = 6;

// Variables del programa

char buf [14];

unsigned char TX_HI=0;

unsigned char TX_Low=0;

unsigned char bandera_medir =0;

int ce = 0;


unsigned char ByteSPI[2];

unsigned char low;

unsigned char hi;

unsigned short int dato;

unsigned int M0;

unsigned char muestras =0;

double Va;

int lcdFD;

Función Principal del Programa

int main(){

int fd ; // Descriptor del puerto serial

if ((fd = serialOpen ("/dev/ttyAMA0", 9600)) < 0)

{

fprintf (stderr, "ERROR al abrir el dispositivo: %s\n", strerror (errno)) ;

return 1 ;

}

if (wiringPiSetup() < 0)

{


return 1 ;

}

printf ("Probando el conversor MCP3201\n") ;

printf ("www.firtec.com.ar\n") ;

if (wiringPiSPISetup (0, 100000) < 0)//Conexion SPI a 1 MHz

{

fprintf (stderr, "Unable to open SPI device 0: %s\n", strerror (errno)) ;

exit (1) ;

}



lcdPrintf(lcdFD, "Conv A/D MCP3201");

Bucle Principal del Programa

while(1){

unsigned char dato_rx = 0;

if(!(bandera_medir)) // Se pueden tomar nuevos datos?

MCP3201(); // Obtiene nuevos datos desde el conversor

while (serialDataAvail (fd))


{

if(serialDataAvail (fd) != 0){ // Algún dato para leer?

dato_rx = serialGetchar (fd); // Obtiene el caracter recibido por la UART

fflush (stdout) ;

if(dato_rx == 0xFD) // Boton Conectar/Desconectar envía órden para

bandera_medir = 0; // asegurar que no se bloquee el conversor.

if(dato_rx == 0xFE){ // Soft-PC pide parte baja del dato.

serialPutchar (fd, TX_Low) ;

bandera_medir = 1; // No medir mientras se pasan los bytes.

}

if(dato_rx == 0xFF){ // Soft-PC pide parte alta del byte.

serialPutchar (fd, TX_HI) ;

bandera_medir = 0; // Permite medir nuevamente.

}

fflush (stdout) ; // Limpio registros

}

}

}

return 0;

}

Función para Leer el Conversor

void MCP3201(void){

wiringPiSPIDataRW (0, ByteSPI, 2);

usleep(100);

hi = (ByteSPI[0] & 0x1F);

low = (ByteSPI[1] & 0xFe);

dato = (hi << 8) | low;

M0 += dato;

if (15 == muestras++){

dato = M0/16;

M0 =0;

muestras =0;

TX_HI = dato/256;

TX_Low = dato - (TX_HI * 256);

Va = (double) (dato) * 3.3 / 8192.0;

sprintf (buf, "Voltios:%3.2f",Va);



lcdPuts(0, buf);

}

}

/************ Fin de programa *************************************************/

En el próximo capitulo veremos como agregar a nuestra Raspberry un calendario y el manejo de otro protocolo importante en electrónica, el I2C y el manejo de datos por RF (Radio Frecuencia) muy útil a la hora de enviar y recibir información como teclados remotos, sensores de presencia, etcevitando tener que pasar cables con toda la incomodidad que esto presenta.

También veremos el diseño de un sistema de seguridad con ingreso codificado y monitoreo por maily video.


Capitulo III. - firteconline.com.arfirteconline.com.ar/Digitales/CapII.pdf · solo 16 son visibles...

Documents

Transcript of Capitulo III. - firteconline.com.arfirteconline.com.ar/Digitales/CapII.pdf · solo 16 son visibles...