Interfaçage du capteur Flex avec le Raspberry Pi en utilisant ADC0804

Raspberry Pi est une carte basée sur un processeur d'architecture ARM conçue pour les ingénieurs en électronique et les amateurs. Le PI est l'une des plates-formes de développement de projet les plus fiables actuellement. Avec une vitesse de processeur plus élevée et 1 Go de RAM, le PI peut être utilisé pour de nombreux projets de haut niveau tels que le traitement d'image et l'Internet des objets. Il y a beaucoup de choses intéressantes qui peuvent être faites avec un PI, mais une caractéristique triste est qu'il n'a pas de module ADC intégré.

Seulement, si le Raspberry Pi pouvait être interfacé avec des capteurs, il pourra connaître les paramètres du monde réel et interagir avec lui. La plupart des capteurs sont des capteurs analogiques et nous devrions donc apprendre à utiliser un module ADC externe IC avec Raspberry Pi pour interfacer ces capteurs. Dans ce projet, nous allons apprendre comment nous pouvons interfacer le capteur Flex avec Raspberry Pi et afficher ses valeurs sur un écran LCD.

Matériel requis:

Raspberry Pi (tout modèle)
ADC0804 IC
Écran LCD 16 * 2
Capteur Flex
Résistances et condensateurs
Planche à pain ou planche de perf.

Module ADC 8 bits monocanal ADC0804:

Avant d'aller plus loin, apprenons à propos de ce circuit intégré ADC0804 et de son utilisation avec raspberry pi. L'ADC0804 est un circuit intégré 8 bits à canal unique, ce qui signifie qu'il peut lire une seule valeur ADC et la mapper à 8 bits de données numériques. Ces données numériques 8 bits peuvent être lues par le Raspberry Pi, donc la valeur sera 0-255 puisque 2 ^ 8 est 256. Comme indiqué dans les brochages de l'IC ci-dessous, les broches DB0 à DB7 sont utilisées pour lire ces valeurs.

Maintenant, une autre chose importante ici est que l' ADC0804 fonctionne à 5V et fournit donc une sortie en signal logique 5V. En sortie à 8 broches (représentant 8 bits), chaque broche fournit une sortie + 5V pour représenter la logique «1». Le problème est donc que la logique PI est de + 3.3v, vous ne pouvez donc pas donner de logique + 5V à la broche GPIO + 3.3V de PI. Si vous donnez + 5V à une broche GPIO de PI, la carte est endommagée.

Donc, pour abaisser le niveau logique à partir de + 5V, nous utiliserons un circuit diviseur de tension. Nous avons déjà discuté du circuit diviseur de tension pour plus de précisions. Ce que nous allons faire, c'est que nous utilisons deux résistances pour diviser la logique + 5V en logique 2 * 2.5V. Donc, après la division, nous donnerons une logique + 2.5v à Raspberry Pi. Ainsi, chaque fois que la logique «1» est présentée par ADC0804, nous verrons + 2,5 V sur la broche PI GPIO, au lieu de + 5 V. En savoir plus sur ADC ici: Introduction à ADC0804.

Vous trouverez ci-dessous l'image du module ADC utilisant ADC0804 que nous avons construit sur la carte Perf:

Schéma de circuit et explication:

Le schéma de circuit complet pour l' interfaçage du capteur Flex avec Raspberry Pi est illustré ci-dessous. L'explication de la même chose est la suivante.

Ce circuit de capteur flex Raspberry pi peut sembler un peu complexe avec beaucoup de fils, mais si vous regardez de plus près, la plupart des fils sont directement connectés depuis l'écran LCD et la broche de données 8 bits au Raspberry pi. Le tableau suivant vous aidera lors de l'établissement et de la vérification des connexions.

Nom de la broche	Numéro de broche framboise	Nom GPIO du Raspberry Pi
LCD Vss	Broche 4	Sol
LCD Vdd	Broche 6	Vcc (+ 5 V)
LCD Vee	Broche 4	Sol
LCD Rs	Épingle 38	GPIO 20
LCD RW	Épingle 39	Sol
LCD E	Broche 40	GPIO 21
LCD D4	Broche 3	GPIO 2
LCD D5	Broche 5	GPIO 3
LCD D6	Broche 7	GPIO 4
LCD D7	Broche 11	GPIO 17
ADC0804 Vcc	Broche 2	Vcc (+ 5 V)
ADC0804 B0	Broche 19 (à 5.1K)	GPIO 10
ADC0804 B1	Broche 21 (à 5.1K)	GPIO 9
ADC0804 B2	Broche 23 (à 5.1K)	GPIO 11
ADC0804 B3	Broche 29 (à 5.1K)	GPIO 5
ADC0804 B4	Broche 31 (à 5.1K)	GPIO 6
ADC0804 B5	Broche 33 (à 5.1K)	GPIO 13
ADC0804 B6	Broche 35 (à 5.1K)	GPIO 19
ADC0804 B7	Broche 37 (à 5.1K)	GPIO 26
ADC0804 WR / INTR	Broche 15	GPIO 22

Vous pouvez utiliser l'image suivante pour déterminer les numéros de broches sur Raspberry depuis.

Comme tous les modules ADC, le circuit intégré ADC0804 nécessite également un signal d'horloge pour fonctionner, heureusement, ce circuit intégré a une source d'horloge interne, il suffit donc d'ajouter le circuit RC aux broches CLK in et CLK R comme indiqué dans le circuit. Nous avons utilisé une valeur de 10K et 105pf, mais nous pouvons utiliser n'importe quelle valeur proche comme 1uf, 0.1uf, 0.01uf devrait également fonctionner.

Ensuite, pour connecter le capteur Flex, nous avons utilisé un circuit diviseur de potentiel utilisant une résistance de 100K. Au fur et à mesure que le capteur Flex est plié, la résistance à travers elle variera, de même que le potentiel chutera à travers la résistance. Cette chute est mesurée par le circuit intégré ADC0804 et des données 8 bits sont générées en conséquence.

Vérifiez d'autres projets liés à Flex Sensor:

Interfaçage du capteur Flex avec le microcontrôleur AVR
Contrôleur de jeu Angry Bird basé sur Arduino utilisant Flex Sensor
Contrôle du servomoteur par Flex Sensor
Générer des sons en tapant des doigts à l'aide d'Arduino

Programmation du Raspberry Pi:

Une fois que nous avons terminé avec les connexions, nous devrions lire l'état de ces 8 bits à l'aide de Raspberry Pi et les convertir en décimal afin que nous puissions les utiliser. Le programme pour faire de même et afficher les valeurs résultantes sur l'écran LCD est donné à la fin de cette page. De plus, le code est expliqué en petites jonques ci-dessous.

Nous avons besoin d'une bibliothèque LCD pour interfacer LCD avec Pi. Pour cela, nous utilisons la bibliothèque développée par shubham qui nous aidera à interfacer un écran LCD 16 * 2 avec un Pi en mode quatre fils. Nous avons également besoin de bibliothèques pour utiliser le temps et les broches GPIO Pi.

Remarque : Le lcd.py doit être téléchargé à partir d'ici, et placé dans le même répertoire où ce programme est enregistré. Ce n'est qu'alors que le code sera compilé.

import lcd #Importer la bibliothèque LCD par [email protected] import time #Import time import RPi.GPIO as GPIO #GPIO sera référencé comme GPIO uniquement

Les définitions des broches LCD sont affectées aux variables comme indiqué ci-dessous. Notez que ces numéros sont les numéros de broches GPIO et non les numéros de broches réels. Vous pouvez utiliser le tableau ci-dessus pour comparer les numéros GPIO avec les numéros de broches. Le binaire du tableau comprendra tous les numéros de broches de données et les bits du tableau stockeront la valeur résultante de toutes les broches GPIO.

#Définitions des broches LCD D4 = 2 D5 = 3 D6 = 4 D7 = 17 RS = 20 EN = 21 binaires = (10,9,11,5,6,13,19,26) # Tableau de numéros de broches se connecter à DB0- DB7 bits = # valeurs résultantes de données 8 bits

Maintenant, nous devons définir les broches d'entrée et de sortie. Les sept broches de données seront la broche d'entrée et la broche de déclenchement (RST et INTR) sera la broche de sortie. Nous pouvons lire les valeurs de données 8 bits à partir de la broche d'entrée uniquement si nous déclenchons la broche de sortie haute pendant un temps particulier selon la fiche technique. Étant donné que nous avons déclaré les broches binaires en tableau binarys nous pouvons utiliser une pour boucle de déclaration, comme indiqué ci - dessous.

pour les binaires en binaires: GPIO.setup (binaire, GPIO.IN) #Toutes les broches binaires sont des broches d'entrée #Trigger pin GPIO.setup (22, GPIO.OUT) #WR et INTR pins sont sorties

Maintenant, en utilisant les commandes de la bibliothèque LCD, nous pouvons initialiser le module LCD et afficher un petit message d'introduction comme indiqué ci-dessous.

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

À l'intérieur de la boucle while infinie, nous commençons à lire les valeurs binaires, les convertissons en décimal et mettons à jour le résultat sur l'écran LCD. Comme indiqué précédemment, nous avons lu les valeurs ADC, nous devons faire en sorte que la broche de déclenchement soit haute pendant un temps particulier pour activer la conversion ADC. Cela se fait en utilisant les lignes suivantes.

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

Maintenant, nous devrions lire les 8 broches de données et mettre à jour le résultat dans le tableau de bits. Pour ce faire, nous utilisons une boucle for pour comparer chaque broche d'entrée avec True et False. Si vrai, le tableau de bits respectif sera fait comme 1, sinon il sera rendu comme 0. C'était toutes les données de 8 bits seront rendues 0 et 1 respectives des valeurs lues.

# Lisez les broches d'entrée et mettez à jour le résultat dans le tableau de bits pour i dans la plage (8): if (GPIO.input (binarys) == True): bits = 1 if (GPIO.input (binarys) == False): bits = 0

Une fois que nous avons mis à jour le tableau de bits, nous devons convertir ce tableau en valeur décimale. Ce n'est rien d'autre qu'une conversion binaire en décimale. Pour les données binaires 8 bits, 2 ^ 8 est égal à 256. Nous obtiendrons donc des données décimales de 0 à 255. En python, l'opérateur «**» est utilisé pour trouver la puissance de toute valeur. Puisque les bits commencent par MSB, nous le multiplions par 2 ^ (7 positions). De cette façon, nous pouvons convertir toutes les valeurs binaires en données décimales, puis les afficher sur l'écran LCD

#calculer la valeur décimale en utilisant un tableau de bits pour i dans la plage (8): decimal = decimal + (bits * (2 ** (7-i)))

Une fois que nous connaissons la valeur décimale, il est facile de calculer la valeur de tension. Il suffit de le multiplier par 19,63. Parce que pour un 5VADC 8 bits, chaque bit est une analogie de 19,3 milli volt. La valeur de tension résultante est la valeur de la tension apparue entre les broches Vin + et Vin- du circuit intégré ADC0804.

#calculer la valeur de tension Tension = décimal * 19,63 * 0,001 #une unité est 19,3 mV

En utilisant la valeur de la tension, nous pouvons déterminer comment le capteur flexible a été plié et dans quelle direction il a été plié. Dans les lignes ci-dessous, je viens de comparer les valeurs de tension lues avec des valeurs de tension prédéterminées pour indiquer la position du capteur Flex sur l'écran LCD.

#comparer la tension et afficher l'état du capteur mylcd.setCursor (1,1) if (Tension> 3,8): mylcd.Print ("Bent Forward") elif (Voltage <3.5): mylcd.Print ("Bent Backward") else: mylcd.Print ("Stable")

De même, vous pouvez utiliser la valeur de tension pour effectuer toute tâche que vous souhaitez que le Raspberry Pi effectue.

Affichage de la valeur du capteur Flex sur l'écran LCD à l'aide de Raspberry Pi:

Le fonctionnement du projet est très simple. Mais assurez-vous d'avoir téléchargé le fichier d'en-tête lcd.py et de l'avoir placé dans le même répertoire où se trouve votre programme actuel. Ensuite, effectuez les connexions indiquées dans le schéma de circuit à l'aide d'une maquette ou d'une carte de performance et exécutez le programme ci-dessous sur votre Pi et vous devriez faire fonctionner les choses. Votre configuration devrait ressembler à ceci ci-dessous.

Comme indiqué, l' écran LCD affichera la valeur décimale, la valeur de tension et la position du capteur. Pliez simplement le capteur vers l'avant ou vers l'arrière et vous devriez être en mesure de voir la tension et la valeur décimale varier, un texte d'état sera également affiché. Vous pouvez connecter n'importe quel capteur et remarquer que la tension à travers celui-ci varie.

Le fonctionnement complet du tutoriel peut être trouvé dans la vidéo ci-dessous. J'espère que vous avez compris le projet et aimé construire quelque chose de similaire. Si vous avez le moindre doute, laissez-les dans la section commentaires ou sur les forums et je ferai de mon mieux pour y répondre.