Ultraljud och display

Dela med sig!

0 kommentarer

Välkommen till den fjärde bloggen i vår Arduino-bloggserie ! Den här gången kommer vi att arbeta med en ultraljudssensor och en grafisk LCD-display för att skapa en enhet som kan mäta avstånd och visa det på displayen.

Vi kommer att använda en HC-SR04 ultraljudssensor som kan skicka ultraljudssignaler och mäta tiden det tar för signalen att reflekteras tillbaka från ett objekt. Utifrån denna tid kan vi beräkna avståndet mellan sensorn och objektet.

För att göra det mer interaktivt och användarvänligt kommer vi att lägga till en grafisk LCD-display med en storlek på 20x4 tecken. Denna display kommer att visa det uppmätta avståndet i en lättläst form så att användaren enkelt kan läsa resultatet.

För att bygga det här projektet kommer vi att använda en breadboard och bygelkablar för att ansluta komponenterna till Arduino . Detta ger ett flexibelt och tillfälligt sätt att bygga kretsen så att den enkelt kan modifieras eller återanvändas för andra projekt.

I de kommande inläggen kommer vi att dyka ner i detaljerna kring att sätta upp och koda projektet. Du får lära dig hur du kopplar ihop ultraljudssensorn och LCD-displayen, ställer in kontrasten och programmerar Arduino att läsa avståndet och visa det på displayen.

Nödvändiga komponenter

Arduino UNO

Ultraljudssensor HC-SR04

LCD 20x4

Bygeltrådar

eller

Ultraljudsavståndsmätare

HC-SR04 ultraljudssensor

Sensorn vi använder i detta projekt är en HC-SR04 ultraljudssensor. Denna sensor har 4 stift , där VCC och GND är anslutna till 5V- och GND-stiften på Arduino , medan Trig och Echo är anslutna till valfria digitala stift på Arduino .

Med hjälp av Trig-stickan skickar vi ett ultraljud med en frekvens på 40 000 Hz i luften. Om det finns ett föremål eller hinder i dess väg kommer ljudet att reflekteras tillbaka till sensorn. Genom att mäta tiden för denna resa och känna till ljudets hastighet kan vi beräkna avståndet till objektet.

Det är fascinerande att tänka på hur sensorn avger dessa ultraljudsvågor som färdas genom luften. När de träffar ett föremål reflekteras de tillbaka till sensorn, vilket gör att vi kan få exakta avståndsmätningar.

För att generera ultraljud ställer vi in Trig-stiftet till ett högt tillstånd i 10 μs. Detta skickar en kort skur av ultraljudssignaler som färdas med ljudets hastighet. Efter denna skur växlar Echo-stiftet till ett högt läge och börjar lyssna efter den reflekterade signalen från ett objekt.

Om inget objekt reflekterar signalen, kommer Echo-stiftet att ta slut efter 38ms och växla tillbaka till ett lågt läge.

Om det finns ett objekt som reflekterar signalen kommer Echo-stiftet att växla till lågt läge inom 38ms. Genom att mäta hur länge Echo-stiftet var i högt tillstånd kan vi bestämma avståndet ljudet har färdats, och därmed avståndet mellan sensorn och objektet

Om vi får en reflekterad puls kommer Echo-stiftet att falla snabbare än 38ms. Beroende på hur länge Echo-stiftet var HÖGT kan vi bestämma avståndet ljudvågen reste och därmed avståndet från sensorn till objektet.

För detta ändamål använder vi följande grundläggande formel för avståndsberäkning:
Avstånd = hastighet x tid

Vi vet faktiskt både hastighets- och tidsvärdena. Tiden är den tid då Echo-stiftet var HÖG och hastigheten är ljudets hastighet, som är 340 m/s . Det finns ett extra steg som vi måste göra, och det är att dela det slutliga resultatet med 2. Och det beror på att vi mäter hur länge ljudvågen behöver för att resa till objektet och studsa tillbaka igen.

Låt oss säga att Echo-stiftet var HÖG i 2ms. Om vi vill få avståndsresultatet i cm kan vi omvandla ljudhastighetsvärdet från 340 m/s till 34 cm/ms.

Avstånd = (Hastighet x Tid) / 2 = (34 cm/ms x 1,5 ms) / 2 = 25,5 cm.

Så om Echo-stiftet var HÖGT i 2ms (vilket vi mäter med pulseIn()-funktionen), är avståndet från sensorn till objektet 34 cm.

Okej Super! Låt oss nu titta på hur vi använder vår ultrasensor med vår Arduino UNO . Vi kommer senare att lägga till vår display i projektet.

HC-SR04 Ultraljudssensor för Arduino

Inställningen för den här kretsen är inte så skrämmande och när kretsen är redo att gå kan vi titta och ladda upp koden. På så sätt kan vi kontrollera om vår ultraljudssensor är korrekt kalibrerad med hjälp av seriell monitor .

Jord- och VCC-stiften på modulen ska anslutas till jord respektive 5-voltsstift på Arduino och trig- och ekostiften till valfritt digitalt I/O-stift på Arduino-kortet .

Arduino Code (Serial Monitor)

Här är en kod för att mäta avstånd med HC-SR04 ultraljudssensor och Arduino.

 // definierar pin-nummer 
const int trigPin = 9 ;
 const int echoPin = 10 ;
 // definiera variabler
 lång varaktighet;
 int avstånd;
 void setup () {
 pinMode (trigPin, OUTPUT ); // Ställer in trigPin som en utgång 
pinMode (echoPin, INPUT ); // Ställer in echoPin som en ingång
 Seriell . börja ( 9600 ); // Startar seriell kommunikation
 }
 void loop () {
 // Rensar trigPin
 digitalWrite (trigPin, LOW ); 
delayMikrosekunder ( 2 );
 // Ställer in trigPin på HIGH-tillståndet i 10 mikrosekunder
 digitalWrite (trigPin, HIGH );
 delayMikrosekunder ( 10 );
 digitalWrite (trigPin, LOW );
 // Läser echoPin, returnerar ljudvågens färdtid i mikrosekunder
 duration = pulseIn (echoPin, HIGH ); 
// Beräknar avståndet
 avstånd = varaktighet * 0,034 / 2 ;
 // Skriver ut avståndet på seriell monitor
 Seriell . print ( "Avstånd: " );
 Seriell . println (avstånd);
 }

Förklaring av koden

Först måste vi definiera Trig- och Echo-stiften. I det här fallet är de stift nummer 9 och 10 på Arduino och de kallas trigPin och echoPin. Då behöver vi en lång variabel som kallas "duration" för den restid vi får från sensorn och en heltalsvariabel för avståndet.

 // definierar pin-nummer
 const int trigPin = 9 ;
 const int echoPin = 10 ;
 // definiera variabler
 lång varaktighet; 
int avstånd;

I void setup() måste vi definiera trigPin som en utgång och echoPin som en ingång och även starta den seriella kommunikationen för att visa resultaten på den seriella skärmen.

 void setup () {
 pinMode (trigPin, OUTPUT ); // Ställer in trigPin som en utgång
 pinMode (echoPin, INPUT ); // Ställer in echoPin som en ingång 
Seriell . börja ( 9600 ); // Startar seriell kommunikation
 }

I void loop() måste vi först se till att trigPin är redo, så vi måste ställa in det stiftet till ett LOW-tillstånd för bara 2 μs. Nu för att generera ultraljudvågen måste vi ställa in trigPin på HIGH State i 10 μs.

 // Rensar trigPin
 digitalWrite (trigPin, LOW );
 delayMikrosekunder ( 2 ); 
// Ställer trigPin på HIGH-tillståndet i 10 mikrosekunder
 digitalWrite (trigPin, HIGH );
 delayMikrosekunder ( 10 );
 digitalWrite (trigPin, LOW );

Med hjälp av pulseIn()-funktionen läser vi av restiden och lägger in detta värde i variabeln "duration". Den här funktionen har 2 parametrar, den första är namnet på Echo-stiftet och den andra är tillståndet för pulsen vi läser, antingen HÖG eller LÅG.

 // Läser echoPin, returnerar ljudvågens färdtid i mikrosekunder
 duration = pulseIn (echoPin, HIGH );

I det här fallet behöver vi denna inställning på HÖG, eftersom HC-SR04-sensorerna ställer in ekopinnen till HÖG efter att ha skickat 8-cyklers ultraljudskurar från sändaren. Detta startar faktiskt timingen och när vi tar emot den reflekterade ljudvågen blir Echo-stiftet LÅG vilket stoppar timingen. I slutet returnerar funktionen pulsens längd i mikrosekunder.

För att få avståndet multiplicerar vi varaktigheten med 0,034 och dividerar den med 2, som vi tidigare förklarat denna ekvation.

 // Beräknar avståndet 
avstånd= varaktighet* 0,034 / 2 ;
 // Skriver ut avståndet på seriell monitor
 Seriell . print ( "Avstånd: " );
 Seriell . println (avstånd);

Slutligen skriver vi ut värdet på avståndet i den seriella monitorn. Så ladda upp koden, öppna Serial Monitor och använd en plan yta för att kontrollera om avståndet som visas i Serial Monitor är korrekt! När den geten är rakad är vi redo att implementera vår visning i projektet!

Arduino ultraljudssensor och LCD-skärm

Här är ett annat exempel på hur man använder ultraljudssensorn med Arduino och visar resultaten på en LCD.

Du kan ansluta ultraljudssensorn och LDC som visas i nästa bild. (Vi kommer att gå in mer på djupet med denna inställning lite längre ner på bloggen). Vi behöver inte ändra inställningen av vår ultraljudssensor.

När du ansluter skärmen till Arduino med I2C-protokollet kommer du vanligtvis att använda både hona-hona-bygelkablar och man-hane-byglingskablar . Här följer en kort beskrivning av hur de används i detta sammanhang.

Hona-hona bygeltrådar : Dessa används för att ansluta displaymodulen till Arduinos kontakter som har hanstift (t.ex. GND, VCC, SDA och SCL). Du behöver fyra hona-hona bygelkablar för att ansluta motsvarande stift på displaymodulen och Arduino.
Hane-hane-byglingskablar : Dessa används för att ansluta displaymodulen till Arduinos honkontakt utformad för I2C-kommunikation (A4 och A5). Du behöver två hane-hane-byglingskablar för att ansluta SDA-stiftet på skärmen till A4-stiftet på Arduino och SCL-stiftet på skärmen till A5-stiftet på Arduino.

Anslut GND-stiftet på displaymodulen till GND på Arduino . Detta säkerställer en gemensam jordanslutning mellan skärmen och Arduino.

Anslut VCC-stiftet på displaymodulen till 5V-stiftet på Arduino . Detta ger ström till displayen.

Anslut SDA-stiftet på displaymodulen till A4-stiftet på Arduino . Detta är dataanslutningen mellan skärmen och Arduino.

Anslut SCL-stiftet på displaymodulen till A5-stiftet på Arduino . Detta är klockanslutningen mellan skärmen och Arduino.

Nu när din skärm är ordentligt ansluten till Arduino kan du börja arbeta med koden för att styra skärmen. Vi använder biblioteken Wire.h, LCD.h och LiquidCrystal_I2C.h för att förenkla kommunikationen mellan Arduino och skärmen.
Koden som mäter avståndet är i huvudsak densamma som grundexemplet. Här skriver vi ut dem på LCD-skärmen istället för att skriva ut resultaten på serieskärmen.

Arduino-kod (20x4 display)

I koden med displayen har bibliotek (Wire.h, LCD.h, LiquidCrystal_I2C.h) och initieringen av LCD-displayen med funktionen lcd.begin() lagts till. Dessutom har kodavsnitt lagts till för att styra LCD-skärmen och skriva ut avståndsmätningarna på skärmen med hjälp av lcd.print()-funktionen.

Här är några specifika ändringar:

Tillagda bibliotek: Koden inkluderar nu biblioteken Wire.h , LCD.h och LiquidCrystal_I2C.h för att styra LCD-skärmen.
LCD-objektinitiering: Ett objekt av typen LiquidCrystal_I2C med adressen 0x27 och stiftkonfigurationen har skapats med klassen LiquidCrystal_I2C .
Displaymått: I funktionen lcd.begin() har LCD-skärmens mått (bredd och höjd) ändrats till 20 och 4 , vilket indikerar att displayen har en bredd på 20 tecken och 4 rader.
Utskrift på displayen: Istället för att skriva ut avståndsvärdet på den seriella monitorn, används nu lcd.print() -funktionen för att skriva ut texten och avståndsvärdet på LCD-skärmen. Det finns två utskrifter, en för centimeter och en för tum, var och en på en separat rad på displayen.
Väntetid: Det finns en liten väntetid (fördröjning(10)) mellan varje uppdatering av displayen för att ge tid för att läsa och visa data.

 # include <Wire.h>
 # inkluderar <LCD.h>
 # include <LiquidCrystal_I2C.h> 
LiquidCrystal_I2C lcd( 0x27 , 2 , 1 , 0 , 4 , 5 , 6 , 7 ); // Skapar ett LCD-objekt. Parametrar: (rs, aktivera, d4, d5, d6, d7)

 const int trigPin = 9 ;
 const int echoPin = 10 ; 
lång varaktighet;
 int distanceCm, distanceInch;


 void setup () {

 lcd. börja ( 20 , 4 ); // Initierar anslutningen till LCD-skärmen och anger måtten (bredd och höjd) på skärmen
 lcd.setBacklightPin( 3 , POSITIV); // Ställer in bakgrundsbelysningsstiftet till positiv matningsspänning 
lcd.setBacklight( HIGH ); // Slår på bakgrundsbelysningen
 pinMode (trigPin, OUTPUT ); // Ställer in trigPin till OUTPUT-läge
 pinMode (echoPin, INPUT ); // Ställer echoPin till INPUT-läge
 }
 void loop () { 
digitalWrite (trigPin, LOW ); // Ställ in trigPin till lågt logiskt värde (0V)
 delayMikrosekunder ( 2 ); // Väntar i 2 mikrosekunder
 digitalWrite (trigPin, HIGH ); // Ställer in trigPin till högt logiskt värde (5V)
 delayMikrosekunder ( 10 ); // Väntar i 10 mikrosekunder 
digitalWrite (trigPin, LOW ); // Ställ in trigPin till lågt logiskt värde (0V)
 duration = pulseIn (echoPin, HIGH ); // Mäter tiden för att ekosignalen ska vara hög (HIGH) och lagrar den i varaktighet
 distansCm = varaktighet * 0,034 / 2 ; // Beräknar avståndet i centimeter baserat på tiden 
distanceInch = varaktighet * 0,0133 / 2 ; // Beräknar avståndet i tum baserat på tiden


 lcd. setCursor ( 0 , 0 ); // Ställer in den position där efterföljande text som skrivits till LCD-skärmen ska visas
 lcd. print ( "Avstånd: " ); // Skriver ut strängen "Distance" på LCD-skärmen 
lcd. print (distanceCm, DEC); // Skriver ut avståndsvärdet från sensorn i centimeter


 lcd. print ( "cm" ); // Skriver ut "cm" på LCD-skärmen


 fördröjning ( 10 ); // Väntar i 10 millisekunder
 lcd. setCursor ( 0 , 1 ); // Ställer in positionen till nästa rad 
lcd. print ( "Avstånd: " ); // Skriver ut strängen "Distance" på LCD-skärmen
 lcd. print (avståndInch, DEC); // Skriver ut avståndsvärdet från sensorn i tum
 lcd. print ( "tum" ); // Skriver ut "tum" på LCD-skärmen
 fördröjning ( 10 ); // Väntar i 10 millisekunder
 }

Justera kontrasten på LCD-skärmen

På displaymodulen, där de fyra stiften är kopplade mellan displayen och Arduino, finns även en potentiometer. Denna potentiometer kan vridas för att justera kontrasten på LCD-skärmen . Genom att vrida på potentiometern kan vi ändra intensiteten på bakgrundsbelysningen på displayen och uppnå önskad visuell effekt.

När du har anslutit displayen korrekt och justerat ljusstyrkan med potentiometern har du slutfört ett nytt projekt!

Du har nu framgångsrikt anslutit Arduino, ultraljudssensorn och LCD-skärmen , och du kan visualisera avståndsmätningarna på LCD-skärmen . Det öppnar upp för många möjligheter att använda dessa komponenter i olika projekt.

Vi har gått igenom processen att ansluta en ultraljudssensor till en Arduino och visa avståndsmätningarna på en LCD-skärm .

Vi hoppas att den här bloggen har varit användbar för dig och att den har inspirerat dig att utforska och experimentera med Arduino och elektroniska komponenter. Kom alltid ihåg att ha kul med dina projekt och fortsätt lära dig och utmana dig själv. Njut av dina framtida Arduino-äventyr!