- Material requerido:
- Módulo ADC de 8 bits de un solo canal ADC0804:
- Diagrama de circuito y explicación:
- Programando la Raspberry Pi:
- Mostrando el valor del sensor flexible en la pantalla LCD usando Raspberry Pi:
Raspberry Pi es una placa basada en procesador de arquitectura ARM diseñada para ingenieros electrónicos y aficionados. PI es una de las plataformas de desarrollo de proyectos más confiables que existen en la actualidad. Con una velocidad de procesador más alta y 1 GB de RAM, el PI se puede utilizar para muchos proyectos de alto perfil como procesamiento de imágenes e Internet de las cosas. Hay muchas cosas interesantes que se pueden hacer con un PI, pero una característica triste es que no tiene un módulo ADC incorporado.
Solo que, si la Raspberry Pi pudiera interconectarse con sensores, puede conocer los parámetros del mundo real e interactuar con ellos. La mayoría de los sensores que existen son sensores analógicos y, por lo tanto, debemos aprender a usar un IC de módulo ADC externo con Raspberry Pi para conectar estos sensores. En este proyecto, aprenderemos cómo podemos conectar el sensor flexible con Raspberry Pi y mostrar sus valores en la pantalla LCD.
Material requerido:
- Raspberry Pi (cualquier modelo)
- ADC0804 IC
- Pantalla LCD 16 * 2
- Sensor flexible
- Resistencias y condensadores
- Tablero de pruebas o tablero de perforación.
Módulo ADC de 8 bits de un solo canal ADC0804:
Antes de continuar, aprendamos sobre este IC ADC0804 y cómo usarlo con raspberry pi. ADC0804 es un IC de 8 bits de un solo canal, lo que significa que puede leer un solo valor de ADC y asignarlo a 8 bits de datos digitales. Estos datos digitales de 8 bits pueden ser leídos por la Raspberry Pi, por lo que el valor será 0-255 ya que 2 ^ 8 es 256. Como se muestra en los pines del IC a continuación, los pines DB0 a DB7 se utilizan para leer estos datos digitales. valores.
Ahora, otra cosa importante aquí es que el ADC0804 funciona a 5 V y, por lo tanto, proporciona una salida en una señal lógica de 5 V. En la salida de 8 pines (que representan 8 bits), cada pin proporciona una salida de + 5 V para representar un '1' lógico. Entonces, el problema es que la lógica PI es de + 3.3v, por lo que no puede dar una lógica de + 5V al pin GPIO de + 3.3V de PI. Si le da + 5V a cualquier pin GPIO de PI, la placa se daña.
Entonces, para reducir el nivel lógico de + 5V, usaremos un circuito divisor de voltaje. Hemos discutido el circuito divisor de voltaje, lo investigamos anteriormente para obtener más aclaraciones. Lo que haremos es usar dos resistencias para dividir la lógica de + 5V en lógicas de 2 * 2.5V. Entonces, después de la división, le daremos lógica + 2.5v a Raspberry Pi. Entonces, siempre que ADC0804 presente un '1' lógico, veremos + 2.5V en el Pin GPIO PI, en lugar de + 5V. Obtenga más información sobre ADC aquí: Introducción a ADC0804.
A continuación se muestra la imagen del módulo ADC con ADC0804 que hemos construido en Perf Board:
Diagrama de circuito y explicación:
El diagrama de circuito completo para la interfaz Flex Sensor con Raspberry Pi se muestra a continuación. La explicación del mismo es la siguiente.
Este circuito de sensor flexible de frambuesa pi puede parecer un poco complejo con muchos cables, pero si observa más de cerca, la mayoría de los cables están conectados directamente desde la pantalla LCD y el pin de datos de 8 bits a la frambuesa pi. La siguiente tabla le ayudará a realizar y verificar las conexiones.
|
Nombre del pin |
Número de PIN de frambuesa |
Nombre GPIO de Raspberry Pi |
|
LCD Vss |
Pin 4 |
Suelo |
|
LCD Vdd |
Pin 6 |
Vcc (+ 5 V) |
|
LCD V |
Pin 4 |
Suelo |
|
LCD Rs |
Pin 38 |
GPIO 20 |
|
LCD RW |
Pin 39 |
Suelo |
|
LCD E |
Pin 40 |
GPIO 21 |
|
LCD D4 |
Pin 3 |
GPIO 2 |
|
LCD D5 |
Pin 5 |
GPIO 3 |
|
LCD D6 |
Pin 7 |
GPIO 4 |
|
LCD D7 |
Pin 11 |
GPIO 17 |
|
ADC0804 Vcc |
Pin 2 |
Vcc (+ 5 V) |
|
ADC0804 B0 |
Pin 19 (hasta 5.1K) |
GPIO 10 |
|
ADC0804 B1 |
Pin 21 (hasta 5.1K) |
GPIO 9 |
|
ADC0804 B2 |
Pin 23 (hasta 5.1K) |
GPIO 11 |
|
ADC0804 B3 |
Pin 29 (hasta 5.1K) |
GPIO 5 |
|
ADC0804 B4 |
Pin 31 (hasta 5.1K) |
GPIO 6 |
|
ADC0804 B5 |
Pin 33 (hasta 5.1K) |
GPIO 13 |
|
ADC0804 B6 |
Pin 35 (hasta 5.1K) |
GPIO 19 |
|
ADC0804 B7 |
Pin 37 (hasta 5.1K) |
GPIO 26 |
|
ADC0804 WR / INTR |
Pin 15 |
GPIO 22 |
Puede utilizar la siguiente imagen para determinar los números de pin en Raspberry desde.
Como todos los módulos ADC, el ADC0804 IC también requiere una señal de reloj para funcionar, afortunadamente este IC tiene una fuente de reloj interna, por lo que solo tenemos que agregar el circuito RC a los pines CLK in y CLK R como se muestra en el circuito. Hemos usado un valor de 10K y 105pf, pero podemos usar cualquier valor cercano como 1uf, 0.1uf, 0.01uf también debería funcionar.
Luego, para conectar el sensor Flex, hemos usado un circuito divisor de potencial usando una resistencia de 100K. A medida que el sensor Flex se dobla, la resistencia a través de él variará y también lo hará la caída de potencial a través de la resistencia. Esta caída es medida por el ADC0804 IC y los datos de 8 bits se generan en consecuencia.
Consulta otros proyectos relacionados con Flex Sensor:
- Interfaz de sensor flexible con microcontrolador AVR
- Controlador de juego Angry Bird basado en Arduino con sensor Flex
- Control de servomotor por sensor flexible
- Generando tonos tocando los dedos usando Arduino
Programando la Raspberry Pi:
Una vez que hayamos terminado con las conexiones, debemos leer el estado de estos 8 bits usando Raspberry Pi y convertirlos a Decimal para que podamos hacer uso de ellos. El programa para hacer lo mismo y mostrar los valores resultantes en la pantalla LCD se da al final de esta página. Además, el código se explica en pequeños archivos basura a continuación.
Necesitamos una biblioteca LCD para conectar LCD con Pi. Para ello utilizamos la biblioteca desarrollada por shubham que nos ayudará a conectar una pantalla LCD de 16 * 2 con un Pi en modo de cuatro cables. También necesitamos bibliotecas para hacer uso del tiempo y los pines Pi GPIO.
Nota : El lcd.py debe descargarse desde aquí y colocarse en el mismo directorio donde se guarda este programa. Solo entonces se compilará el código.
importar lcd #Importar la biblioteca LCD por [email protected] tiempo de importación #Importar tiempo importar RPi.GPIO como GPIO #GPIO será referido como GPIO solamente
Las definiciones de los pines de la pantalla LCD se asignan a las variables como se muestra a continuación. Tenga en cuenta que estos números son los números de pin GPIO y no los números de pin reales. Puede utilizar la tabla anterior para comparar números GPIO con números de pin. El binario de la matriz incluirá todos los números de los pines de datos y los bits de la matriz almacenarán el valor resultante de todos los pines GPIO.
#Definiciones de pines del LCD D4 = 2 D5 = 3 D6 = 4 D7 = 17 RS = 20 EN = 21 binarios = (10,9,11,5,6,13,19,26) # Matriz de números de pines se conectan a DB0- DB7 bits = # valores resultantes de datos de 8 bits
Ahora, tenemos que definir los pines de entrada y salida. Los siete pines de datos serán el pin de entrada y el pin de disparo (RST e INTR) será el pin de salida. Podemos leer los valores de datos de 8 bits desde el pin de entrada solo si activamos el pin de salida alto durante un tiempo particular de acuerdo con la hoja de datos. Puesto que hemos declarado los pasadores binarios en binarys array podemos utilizar un para de bucle para la declaración como se muestra a continuación.
para binarios en binarios: GPIO.setup (binario, GPIO.IN) #Todos los pines binarios son pines de entrada #Pin de activación GPIO.setup (22, GPIO.OUT) # Se emiten pines WR e INTR
Ahora, usando los comandos de la biblioteca LCD, podemos inicializar el módulo LCD y mostrar un pequeño mensaje de introducción como se muestra a continuación.
mylcd = lcd.lcd () mylcd.begin (D4, D5, D6, D7, RS, EN) #Intro Message mylcd.Print ("Sensor flexible con") mylcd.setCursor (2,1) mylcd.Print ("Frambuesa Pi ") time.sleep (2) mylcd.clear ()
Dentro del ciclo while infinito, comenzamos a leer los valores binarios, los convertimos a decimales y actualizamos el resultado en la pantalla LCD. Como dijimos antes, leemos los valores de ADC , debemos hacer que el pin de activación esté alto durante un tiempo en particular para activar la conversión de ADC. Esto se hace usando las siguientes líneas.
GPIO.output (22, 1) #Encender Trigger time.sleep (0.1) GPIO.output (22, 0) #Turn OFF Trigger
Ahora, deberíamos leer los pines de 8 datos y actualizar el resultado en la matriz de bits. Para hacer esto usamos un bucle for para comparar cada pin de entrada con Verdadero y Falso. Si es verdadero, la matriz de bits respectiva se hará como 1; de lo contrario, se hará como 0. Esto fue, todos los datos de 8 bits se convertirán en 0 y 1 respectivamente de los valores leídos.
# Lee los pines de entrada y actualiza el resultado en la matriz de bits para i en el rango (8): if (GPIO.input (binarys) == True): bits = 1 if (GPIO.input (binarys) == False): bits = 0
Una vez que hayamos actualizado la matriz de bits, debemos convertir esta matriz a valor decimal. Esto no es más que una conversión de binario a decimal. Para datos binarios de 8 bits, 2 ^ 8 es 256. Así que obtendremos datos decimales de 0 a 255. En Python, el operador “**” se usa para encontrar la potencia de cualquier valor. Dado que los bits comienzan con MSB, lo multiplicamos por 2 ^ (7 posiciones). De esta manera podemos convertir todos los valores binarios a datos decimales y luego mostrarlos en la pantalla LCD
#calcular el valor decimal usando la matriz de bits para i en el rango (8): decimal = decimal + (bits * (2 ** (7-i)))
Una vez que conocemos el valor decimal, es fácil calcular el valor de voltaje. Solo tenemos que multiplicarlo por 19,63. Porque para un 5VADC de 8 bits, cada bit es una analogía de 19,3 milivoltios. El valor de voltaje resultante es el valor de voltaje que ha aparecido a través de los pines Vin + y Vin- del ADC0804 IC.
# calcular el valor del voltaje Voltaje = decimal * 19.63 * 0.001 # una unidad es 19.3mV
Usando el valor del voltaje podemos determinar cómo se ha doblado el sensor flexible y en qué dirección se ha doblado. En las siguientes líneas, acabo de comparar los valores de voltaje leídos con valores predeterminados de voltaje para indicar la posición del sensor Flex en la pantalla LCD.
#compare el voltaje y el estado de visualización del sensor mylcd.setCursor (1,1) if (Voltage> 3.8): mylcd.Print ("Bent Forward") elif (Voltage <3.5): mylcd.Print ("Bent Backward") else: mylcd.Print ("Estable")
De manera similar, puede usar el valor de voltaje para realizar cualquier tarea que desee que realice la Raspberry Pi.
Mostrando el valor del sensor flexible en la pantalla LCD usando Raspberry Pi:
El funcionamiento del proyecto es muy sencillo. Pero asegúrese de haber descargado el archivo de encabezado lcd.py y de haberlo colocado en el mismo directorio donde está presente su programa actual. Luego, haga las conexiones que se muestran en el diagrama de circuito usando una placa de pruebas o una placa de perforación y ejecute el programa a continuación en su Pi y debería hacer que todo funcione. La configuración debería verse así a continuación.
Como se muestra, la pantalla LCD mostrará el valor decimal, el valor de voltaje y la posición del sensor. Simplemente doble el sensor hacia adelante o hacia atrás y debería poder ver que el voltaje y el valor decimal varían, también se mostrará un texto de estado. Puede conectar cualquier sensor y notar que el voltaje a través de él varía.
El funcionamiento completo del tutorial se puede encontrar en el video que se muestra a continuación. Espero que haya entendido el proyecto y haya disfrutado construyendo algo similar. Si tiene alguna duda, déjela en la sección de comentarios o en los foros y haré todo lo posible para responderla.