Interface do sensor flex com raspberry pi usando adc0804

Raspberry Pi é uma placa baseada em processador de arquitetura ARM projetada para engenheiros eletrônicos e amadores. O PI é uma das plataformas de desenvolvimento de projeto mais confiáveis que existe agora. Com maior velocidade do processador e 1 GB de RAM, o PI pode ser usado para muitos projetos de alto perfil, como processamento de imagens e Internet das coisas. Há muitas coisas interessantes que podem ser feitas com um PI, mas uma característica triste é que ele não tem um módulo ADC embutido.

Apenas, se o Raspberry Pi puder ser conectado a sensores, ele poderá conhecer os parâmetros do mundo real e interagir com eles. A maioria dos sensores que existem são analógicos e, portanto, devemos aprender a usar um módulo ADC externo IC com Raspberry Pi para fazer a interface desses sensores. Neste projeto, aprenderemos como podemos fazer a interface do sensor Flex com Raspberry Pi e exibir seus valores na tela LCD.

Material necessário:

Raspberry Pi (qualquer modelo)
ADC0804 IC
Visor LCD 16 * 2
Sensor Flex
Resistores e capacitores
Placa de ensaio ou placa de desempenho.

ADC0804 Módulo ADC de 8 bits de canal único:

Antes de prosseguirmos, vamos aprender sobre este IC ADC0804 e como usá-lo com raspberry pi. O ADC0804 é um IC de 8 bits de canal único, o que significa que pode ler um único valor ADC e mapeá-lo para dados digitais de 8 bits. Esses dados digitais de 8 bits podem ser lidos pelo Raspberry Pi, portanto, o valor será 0-255 já que 2 ^ 8 é 256. Como mostrado nas pinagens do IC abaixo, os pinos DB0 a DB7 são usados para ler esses dados digitais valores.

Agora, outra coisa importante aqui é que o ADC0804 opera a 5V e, portanto, fornece saída em sinal lógico de 5V. Na saída de 8 pinos (representando 8 bits), cada pino fornece saída de + 5 V para representar a lógica '1'. Portanto, o problema é que a lógica do PI é de + 3,3 V, então você não pode dar lógica de + 5 V ao pino GPIO de + 3,3 V do PI. Se você fornecer + 5V a qualquer pino GPIO de PI, a placa será danificada.

Portanto, para reduzir o nível lógico de + 5V, usaremos um circuito divisor de tensão. Já discutimos o Circuito Divisor de Tensão, examiná-lo anteriormente para obter mais esclarecimentos. O que faremos é usar dois resistores para dividir a lógica de + 5 V em lógicas de 2 * 2,5 V. Portanto, após a divisão, daremos a lógica de + 2,5 V ao Raspberry Pi. Portanto, sempre que a lógica '1' for apresentada pelo ADC0804, veremos + 2,5 V no pino PI GPIO, em vez de + 5 V. Saiba mais sobre ADC aqui: Introdução ao ADC0804.

Abaixo está a imagem do Módulo ADC usando ADC0804 que construímos no Perf Board:

Diagrama de circuito e explicação:

O diagrama de circuito completo para fazer a interface do Flex Sensor com Raspberry Pi é mostrado abaixo. A explicação do mesmo é a seguinte.

Este circuito sensor flexível do raspberry pi pode parecer um pouco complexo com muitos fios, mas se você olhar mais de perto, a maioria dos fios está diretamente conectado do LCD e do pino de dados de 8 bits ao Raspberry pi. A tabela a seguir o ajudará a fazer e verificar as conexões.

Nome do pin	Número do framboesa	Nome do Raspberry Pi GPIO
LCD Vss	Pino 4	Terra
LCD Vdd	Pino 6	Vcc (+ 5V)
LCD Vee	Pino 4	Terra
Rs LCD	Pin 38	GPIO 20
LCD RW	Pin 39	Terra
LCD E	Pino 40	GPIO 21
LCD D4	Pino 3	GPIO 2
LCD D5	Pino 5	GPIO 3
LCD D6	Pino 7	GPIO 4
LCD D7	Pino 11	GPIO 17
ADC0804 Vcc	Pino 2	Vcc (+ 5V)
ADC0804 B0	Pino 19 (a 5.1K)	GPIO 10
ADC0804 B1	Pino 21 (a 5,1 K)	GPIO 9
ADC0804 B2	Pino 23 (a 5.1K)	GPIO 11
ADC0804 B3	Pino 29 (a 5.1K)	GPIO 5
ADC0804 B4	Pino 31 (a 5.1K)	GPIO 6
ADC0804 B5	Pino 33 (a 5.1K)	GPIO 13
ADC0804 B6	Pino 35 (a 5.1K)	GPIO 19
ADC0804 B7	Pino 37 (a 5,1 K)	GPIO 26
ADC0804 WR / INTR	Pino 15	GPIO 22

Você pode usar a seguinte imagem para determinar os números dos pinos no Raspberry desde então.

Como todos os módulos ADC, o IC ADC0804 também requer um sinal de clock para operar, felizmente este IC tem uma fonte de clock interna, então só temos que adicionar o circuito RC aos pinos CLK in e CLK R conforme mostrado no circuito. Usamos um valor de 10K e 105pf, mas podemos usar qualquer valor próximo como 1uf, 0.1uf, 0.01uf também deve funcionar.

Então, para conectar o sensor Flex, usamos um circuito divisor de potencial com um resistor de 100K. À medida que o sensor Flex é dobrado, a resistência ao longo dele irá variar e também a queda de potencial ao longo do resistor. Esta queda é medida pelo ADC0804 IC e os dados de 8 bits são gerados em conformidade.

Confira outros projetos relacionados ao Flex Sensor:

Interface de sensor flexível com microcontrolador AVR
Controlador de jogo Angry Bird baseado em Arduino usando Flex Sensor
Controle de servo motor por Flex Sensor
Gerando tons tocando os dedos usando o Arduino

Programando o Raspberry Pi:

Assim que terminarmos as conexões, devemos ler o estado desses 8 bits usando Raspberry Pi e convertê-los em decimais para que possamos usá-los. O programa para fazer o mesmo e exibir os valores resultantes na tela LCD é fornecido no final desta página. Além disso, o código é explicado em pequenos juncos abaixo.

Precisamos de uma biblioteca LCD para fazer a interface do LCD com Pi. Para isso usamos a biblioteca desenvolvida por shubham que nos ajudará a fazer a interface de um display LCD 16 * 2 com um Pi em modo de quatro fios. Também precisamos de bibliotecas para aproveitar o tempo e os pinos Pi GPIO.

Nota : O lcd.py deve ser baixado daqui e colocado no mesmo diretório onde o programa foi salvo. Só então o código será compilado.

import lcd #Importar a biblioteca LCD por [email protected] import time #Import time import RPi.GPIO como GPIO #GPIO será referido como GPIO apenas

As definições dos pinos do LCD são atribuídas às variáveis conforme mostrado abaixo. Observe que esses números são os números dos pinos GPIO e não os números reais dos pinos. Você pode usar a tabela acima para comparar os números GPIO com os números dos pinos. O binário da matriz incluirá todos os números dos pinos de dados e os bits da matriz armazenarão o valor resultante de todos os pinos GPIO.

#Definições de pino LCD D4 = 2 D5 = 3 D6 = 4 D7 = 17 RS = 20 EN = 21 binários = (10,9,11,5,6,13,19,26) #Array de números de pino conectar a DB0- DB7 bits = #resultando valores de dados de 8 bits

Agora, temos que definir os pinos de entrada e saída. Os sete pinos de dados serão o pino de entrada e o pino de disparo (RST e INTR) será o pino de saída. Podemos ler os valores de dados de 8 bits do pino de entrada somente se acionarmos o pino de saída alto por um determinado momento, de acordo com a folha de dados. Desde que declararam os pinos binários em série binarys podemos usar um para loop para declaração como mostrado abaixo.

para binários em binários: GPIO.setup (binary, GPIO.IN) #Todos os pinos binários são pinos de entrada # Trigger pin GPIO.setup (22, GPIO.OUT) #WR e INTR pinos são produzidos

Agora, usando os comandos da biblioteca LCD, podemos inicializar o módulo LCD e exibir uma pequena mensagem de introdução conforme mostrado abaixo.

mylcd = lcd.lcd () mylcd.begin (D4, D5, D6, D7, RS, EN) #Intro Message mylcd.Print ("Flex Sensor with") mylcd.setCursor (2,1) mylcd.Print ("Raspberry Pi ") time.sleep (2) mylcd.clear ()

Dentro do infinito enquanto loop, nós começar a ler os valores binários convertê-los em decimal e atualizar o resultado no LCD. Como dito anteriormente, antes de lermos os valores do ADC , devemos fazer com que o pino de disparo seja alto por um determinado momento para ativar a conversão do ADC. Isso é feito usando as seguintes linhas.

GPIO.output (22, 1) #Turn ON Trigger time.sleep (0.1) GPIO.output (22, 0) #Turn OFF Trigger

Agora, devemos ler os pinos de 8 dados e atualizar o resultado na matriz de bits. Para fazer isso, usamos um loop for para comparar cada pino de entrada com True e False. Se verdadeiro, o arranjo de bits respectivos será feito como 1, senão, será feito como 0. Todos os dados de 8 bits serão transformados em 0 e 1 respectivo dos valores lidos.

#Leia os pinos de entrada e atualize o resultado na matriz de bits para i no intervalo (8): if (GPIO.input (binários) == Verdadeiro): bits = 1 se (GPIO.input (binários) == Falso): bits = 0

Depois de atualizar o array de bits, devemos converter esse array para o valor decimal. Isso nada mais é do que conversão binária para decimal. Para dados binários de 8 bits, 2 ^ 8 é 256. Portanto, obteremos dados decimais de 0 a 255. Em python, o operador “**” é usado para encontrar a potência de qualquer valor. Como os bits começam com MSB, nós o multiplicamos por 2 ^ (7 posições). Desta forma, podemos converter todos os valores binários em dados decimais e depois exibi-los no LCD

#calcule o valor decimal usando a matriz de bits para i no intervalo (8): decimal = decimal + (bits * (2 ** (7-i)))

Uma vez que sabemos o valor decimal, é fácil calcular o valor da tensão. Só temos que multiplicar por 19,63. Porque para um 5VADC de 8 bits, cada bit é uma analogia de 19,3 milivolt. O valor de tensão resultante é o valor da tensão que apareceu nos pinos Vin + e Vin- do IC ADC0804.

# calcular o valor da tensão Tensão = decimal * 19,63 * 0,001 # uma unidade é 19,3 mV

Usando o valor da tensão, podemos determinar como o sensor flexível foi dobrado e em que direção foi dobrado. Nas linhas abaixo, acabei de comparar os valores de tensão lidos com valores predeterminados de tensão para indicar a posição do sensor Flex na tela LCD.

#compare a tensão e o status de exibição do sensor mylcd.setCursor (1,1) if (Voltage> 3.8): mylcd.Print ("Bent Forward") elif (Voltage <3.5): mylcd.Print ("Bent Backward") else: mylcd.Print ("Estável")

Da mesma forma, você pode usar o valor da tensão para realizar qualquer tarefa que deseja que o Raspberry Pi execute.

Mostrando o valor do Sensor Flex no LCD usando Raspberry Pi:

O funcionamento do projeto é muito simples. Mas certifique-se de ter baixado o arquivo de cabeçalho lcd.py e colocado no mesmo diretório onde seu programa atual está presente. Em seguida, faça as conexões que são mostradas no diagrama de circuito usando um breadboard ou um perf board e execute o programa abaixo em seu Pi e você deve fazer tudo funcionar. A configuração deve ser semelhante a esta abaixo.

Conforme mostrado, o LCD exibirá o valor decimal, o valor da tensão e a posição do sensor. Basta dobrar o sensor para frente ou para trás e você deverá ser capaz de ver a tensão e o valor decimal variando, também um texto de status será exibido. Você pode conectar qualquer sensor e perceber que a tensão nele varia.

O funcionamento completo do tutorial pode ser encontrado no vídeo abaixo. Espero que você tenha entendido o projeto e gostado de construir algo semelhante. Se você tiver alguma dúvida, deixe-os na seção de comentários ou nos fóruns e tentarei o meu melhor para respondê-los.