- Materiaal vereist:
- ADC0804 Enkelkanaals 8-bit ADC-module:
- Schakelschema en uitleg:
- Programmeren van de Raspberry Pi:
- Flex-sensorwaarde weergeven op LCD met Raspberry Pi:
Raspberry Pi is een op ARM-architectuur gebaseerde processor, ontworpen voor elektronische ingenieurs en hobbyisten. De PI is momenteel een van de meest vertrouwde platformen voor projectontwikkeling. Met een hogere processorsnelheid en 1 GB RAM kan de PI worden gebruikt voor veel spraakmakende projecten zoals beeldverwerking en internet der dingen. Er zijn veel leuke dingen die met een PI kunnen worden gedaan, maar een trieste eigenschap is dat deze geen ingebouwde ADC-module heeft.
Alleen als de Raspberry Pi kan worden gekoppeld aan sensoren, kan hij de parameters van de echte wereld leren kennen en ermee communiceren. De meeste sensoren die er zijn, zijn analoge sensoren en daarom moeten we leren om een externe ADC-module-IC met Raspberry Pi te gebruiken om deze sensoren te koppelen. In dit project zullen we leren hoe we de Flex-sensor kunnen koppelen met Raspberry Pi en de waarden ervan op een LCD-scherm kunnen weergeven.
Materiaal vereist:
- Raspberry Pi (elk model)
- ADC0804 IC
- 16 * 2 LCD-scherm
- Flex-sensor
- Weerstanden en condensatoren
- Breadboard of perfboard.
ADC0804 Enkelkanaals 8-bit ADC-module:
Laten we, voordat we verder gaan, meer te weten komen over deze ADC0804 IC en hoe we deze kunnen gebruiken met Raspberry Pi. ADC0804 is een 8-bit IC met één kanaal, wat betekent dat het een enkele ADC-waarde kan lezen en deze kan toewijzen aan 8-bit digitale gegevens. Deze 8-bits digitale gegevens kunnen worden gelezen door de Raspberry Pi, dus de waarde zal 0-255 zijn aangezien 2 ^ 8 256 is. Zoals te zien is in de pinouts van het IC hieronder, worden de pinnen DB0 tot DB7 gebruikt om deze digitale waarden.
Een ander belangrijk ding hier is, de ADC0804 werkt op 5V en levert dus output in een logisch signaal van 5V. In 8-pins uitvoer (die 8 bits vertegenwoordigt), biedt elke pin + 5V-uitvoer om logische '1' weer te geven. Het probleem is dus dat de PI-logica + 3.3v is, dus je kunt geen + 5V-logica geven aan de + 3.3V GPIO-pin van PI. Als je + 5V aan een GPIO-pin van PI geeft, raakt het bord beschadigd.
Dus om het logische niveau van + 5V te verlagen, zullen we een spanningsdelercircuit gebruiken. We hebben het Voltage Divider Circuit eerder besproken, onderzoeken het voor verdere verduidelijking. Wat we zullen doen is, we gebruiken twee weerstanden om + 5V logica te verdelen in 2 * 2,5V logica. Dus na deling geven we + 2.5v logica aan Raspberry Pi. Dus wanneer logica '1' wordt gepresenteerd door ADC0804, zien we + 2.5V op de PI GPIO-pin, in plaats van + 5V. Lees hier meer over ADC: Inleiding tot ADC0804.
Hieronder ziet u de afbeelding van de ADC-module met ADC0804 die we op Perf Board hebben gebouwd:
Schakelschema en uitleg:
Het volledige schakelschema voor het koppelen van de Flex-sensor met de Raspberry Pi wordt hieronder weergegeven. De uitleg hiervan is als volgt.
Dit Raspberry Pi Flex- sensorcircuit lijkt misschien een beetje ingewikkeld met veel draden, maar als je goed kijkt, zijn de meeste draden rechtstreeks verbonden vanaf het LCD-scherm en de 8-bits datapin met de Raspberry Pi. De volgende tabel helpt u bij het maken en controleren van de verbindingen.
|
Pin naam |
Raspberry Pin-nummer |
Raspberry Pi GPIO-naam |
|
LCD Vss |
Pin 4 |
Grond |
|
LCD Vdd |
Pin 6 |
Vcc (+ 5 V) |
|
LCD Vee |
Pin 4 |
Grond |
|
LCD Rs |
Speld 38 |
GPIO 20 |
|
LCD RW |
Pin 39 |
Grond |
|
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 |
Speld 11 |
GPIO 17 |
|
ADC0804 Vcc |
Pin 2 |
Vcc (+ 5 V) |
|
ADC0804 B0 |
Pin 19 (tot 5,1K) |
GPIO 10 |
|
ADC0804 B1 |
Pin 21 (tot 5,1K) |
GPIO 9 |
|
ADC0804 B2 |
Pin 23 (tot 5,1K) |
GPIO 11 |
|
ADC0804 B3 |
Pin 29 (tot 5,1K) |
GPIO 5 |
|
ADC0804 B4 |
Pin 31 (tot 5,1K) |
GPIO 6 |
|
ADC0804 B5 |
Pin 33 (tot 5,1K) |
GPIO 13 |
|
ADC0804 B6 |
Pin 35 (tot 5,1K) |
GPIO 19 |
|
ADC0804 B7 |
Pin 37 (tot 5,1K) |
GPIO 26 |
|
ADC0804 WR / INTR |
Speld 15 |
GPIO 22 |
U kunt de volgende afbeelding gebruiken om de pincodes op Raspberry te bepalen sinds.
Zoals alle ADC-modules heeft de ADC0804 IC ook een kloksignaal nodig om te werken, gelukkig heeft dit IC een interne klokbron, dus we hoeven alleen het RC-circuit toe te voegen aan de CLK in en CLK R-pinnen zoals weergegeven in het circuit. We hebben een waarde van 10K en 105pf gebruikt, maar we kunnen elke waarde in de buurt gebruiken, zoals 1uf, 0,1 uf, 0,01 uf zou ook moeten werken.
Om vervolgens de Flex-sensor aan te sluiten, hebben we een potentiaaldelercircuit gebruikt met een weerstand van 100K. Als de Flex-sensor gebogen is, zal de weerstand erover variëren, evenals de potentiaalverlaging over de weerstand. Deze daling wordt gemeten door de ADC0804 IC en 8-bits gegevens worden dienovereenkomstig gegenereerd.
Bekijk andere projecten met betrekking tot Flex Sensor:
- Flex-sensorinterface met AVR-microcontroller
- Op Arduino gebaseerde Angry Bird Game Controller met Flex Sensor
- Servomotorbesturing door Flex-sensor
- Tonen genereren door op vingers te tikken met Arduino
Programmeren van de Raspberry Pi:
Als we klaar zijn met de verbindingen, moeten we de status van deze 8-bits lezen met Raspberry Pi en ze converteren naar decimaal, zodat we er gebruik van kunnen maken. Het programma om hetzelfde te doen en de resulterende waarden op het LCD-scherm weer te geven, wordt aan het einde van deze pagina gegeven. Verder wordt de code hieronder uitgelegd in kleine junks.
We hebben een LCD- bibliotheek nodig om LCD met Pi te verbinden. Hiervoor gebruiken we de door shubham ontwikkelde bibliotheek die ons zal helpen om een 16 * 2 LCD-scherm te koppelen aan een Pi in vierdraadsmodus. We hebben ook bibliotheken nodig om gebruik te maken van tijd en Pi GPIO-pinnen.
Opmerking : de lcd.py moet van hier worden gedownload en in dezelfde map worden geplaatst als waar dit programma is opgeslagen. Alleen dan zal de code compileren.
import lcd #Import the LCD library by [email protected] import time #Import time import RPi.GPIO als GPIO #GPIO wordt alleen aangeduid als GPIO
De definities van de LCD-pinnen zijn toegewezen aan de variabelen zoals hieronder weergegeven. Merk op dat deze nummers de GPIO-pincodes zijn en niet de daadwerkelijke pincodes. U kunt de bovenstaande tabel gebruiken om GPIO-nummers te vergelijken met pincodes. Het binaire array bevat alle gegevenspinnummers en de arraybits slaan de resulterende waarde van alle GPIO-pinnen op.
#LCD-pindefinities D4 = 2 D5 = 3 D6 = 4 D7 = 17 RS = 20 EN = 21 binaire waarden = (10,9,11,5,6,13,19,26) # Array van pincodes verbinden met DB0- DB7 bits = # resulterende waarden van 8-bits gegevens
Nu moeten we de invoer- en uitvoerpinnen definiëren. De zeven datapinnen zijn de invoerpen en de triggerpen (RST en INTR) de uitvoerpen. We kunnen de 8-bits gegevenswaarden van de invoerpin alleen lezen als we de uitvoerpin gedurende een bepaalde tijd hoog activeren volgens het gegevensblad. Omdat we de binaire pinnen in de binaire array hebben gedeclareerd, kunnen we een for- lus gebruiken voor declaratie, zoals hieronder wordt weergegeven.
voor binair in binair: GPIO.setup (binair, GPIO.IN) #Alle binaire pinnen zijn invoerpinnen #Triggerpin GPIO.setup (22, GPIO.OUT) #WR en INTR pinnen worden uitgevoerd
Met behulp van de LCD-bibliotheekopdrachten kunnen we de LCD-module initialiseren en een klein introbericht weergeven, zoals hieronder wordt weergegeven.
mylcd = lcd.lcd () mylcd.begin (D4, D5, D6, D7, RS, EN) #Intro Bericht mylcd.Print ("Flex Sensor with") mylcd.setCursor (2,1) mylcd.Print ("Raspberry Pi ") time.sleep (2) mylcd.clear ()
Binnen de oneindige while- lus beginnen we met het lezen van de binaire waarden, converteren ze naar decimalen en werken het resultaat bij op het LCD-scherm. Zoals eerder gezegd, hebben we de ADC-waarden gelezen, we moeten de triggerpin gedurende een bepaalde tijd hoog maken om de ADC-conversie te activeren. Dit wordt gedaan door de volgende regels te gebruiken.
GPIO.output (22, 1) #Turn ON Trigger time.sleep (0.1) GPIO.output (22, 0) #Turn OFF Trigger
Nu moeten we de 8-datapinnen lezen en het resultaat in de bits-array bijwerken. Om dit te doen, gebruiken we een for- lus om elke invoerpin te vergelijken met True en False. Als dit waar is, wordt de respectieve bits reeks gemaakt als 1, anders wordt het gemaakt als 0. Dit was dat alle 8-bits gegevens worden gemaakt als 0 en 1 van de respectieve waarden die worden gelezen.
#Lees de invoerpinnen en werk het resultaat bij in bit-array voor i in bereik (8): if (GPIO.input (binarys) == True): bits = 1 if (GPIO.input (binarys) == False): bits = 0
Nadat we de bits-array hebben bijgewerkt, moeten we deze array converteren naar een decimale waarde. Dit is niets anders dan binaire naar decimale conversie. Voor 8-bits binaire gegevens is 2 ^ 8 256. We krijgen dus decimale gegevens van 0 tot 255. In python wordt de operator "**" gebruikt om de macht van een willekeurige waarde te vinden. Omdat bits begint met MSB, vermenigvuldigen we het met 2 ^ (7-positie). Op deze manier kunnen we alle binaire waarden converteren naar decimale gegevens en deze vervolgens op het LCD-scherm weergeven
#bereken de decimale waarde met behulp van bit-array voor i in bereik (8): decimaal = decimaal + (bits * (2 ** (7-i)))
Zodra we de decimale waarde kennen, is het gemakkelijk om de spanningswaarde te berekenen. We moeten het gewoon vermenigvuldigen met 19,63. Omdat voor een 8-bit 5VADC elke bit een analogie is van 19,3 milli volt. De resulterende spanningswaarde is de waarde van de spanning die is verschenen over de pinnen Vin + en Vin- van de ADC0804 IC.
#bereken spanningswaarde Spanning = decimaal * 19,63 * 0,001 #een eenheid is 19,3mV
Met behulp van de waarde van de spanning kunnen we bepalen hoe de flex-sensor is gebogen en in welke richting deze is gebogen. In de onderstaande regels heb ik zojuist de afgelezen spanningswaarden vergeleken met vooraf bepaalde spanningswaarden om de positie van de Flex-sensor op het LCD-scherm aan te geven.
# vergelijk spanning en weergavestatus van sensor mylcd.setCursor (1,1) if (Voltage> 3.8): mylcd.Print ("Bent Forward") elif (Voltage <3.5): mylcd.Print ("Bent Backward") anders: mylcd.Print ("Stabiel")
Op dezelfde manier kunt u de spanningswaarde gebruiken om elke taak uit te voeren die u de Raspberry Pi wilt laten uitvoeren.
Flex-sensorwaarde weergeven op LCD met Raspberry Pi:
De werking van het project is heel eenvoudig. Maar zorg ervoor dat je het lcd.py header-bestand hebt gedownload en in dezelfde map hebt geplaatst als je huidige programma. Maak vervolgens de verbindingen die in het schakelschema worden getoond met behulp van een breadboard of een perfboard en draai het onderstaande programma op je Pi en je zou het werk moeten krijgen. Je installatie zou er als volgt uit moeten zien.
Zoals weergegeven toont het LCD-scherm de decimale waarde, de spanningswaarde en de sensorpositie. Buig de sensor gewoon naar voren of naar achteren en u zou moeten kunnen zien dat de spanning en de decimale waarde variëren, er wordt ook een statustekst weergegeven. U kunt elke sensor aansluiten en merken dat de spanning erover varieert.
De volledige werking van de tutorial is te vinden in de onderstaande video. Ik hoop dat je het project begreep en het leuk vond om iets soortgelijks te bouwen. Als je twijfelt, laat ze dan achter in het commentaargedeelte of op de forums en ik zal mijn best doen om ze te beantwoorden.