Servo och Potentiometer

Dela med sig!

0 kommentarer

Välkommen till vår andra blogg i den här serien om styrning av en servo med potentiometer! I den här guiden kommer vi att utforska spännande möjligheter med Arduino och lära oss hur vi kan använda en potentiometer för att styra rörelsen av en servo. En servo är en motor designad för exakt kontroll av positionen. I vårt projekt kommer vi att använda en MG90S metallväxelservomotor, känd för sin tillförlitlighet och precision.

Med hjälp av en potentiometer , som är ett variabelt motstånd , kommer vi att kunna ändra spänningsnivån och därmed styra rörelsen av servos axel. När vi vrider på potentiometern kommer axeln på servo att röra sig i enlighet med detta. Detta öppnar upp en värld av kreativa möjligheter där vi kan skapa interaktiva mekaniska rörelser och robotapplikationer.

Så låt oss kombinera hårdvara och mjukvara för att skapa dynamiska projekt. Låt oss dyka in i detaljerna och lära oss hur vi kan bygga våra egna servostyrda konstruktioner med Arduino-plattformen!

Komponenter som används i projektet

Arduino UNO

Servomotor

Potentiometer

Bygeltrådar

Bakbord

Arduino UNO : Arduino UNO är hjärtat i vårt projekt. Det är en mikrokontrollerbaserad enhet som fungerar som vår programmerbara hjärna. Det låter oss ansluta till och styra olika elektroniska komponenter och utföra olika uppgifter.
Servomotor : Servomotorn är en speciell typ av motor som används för exakta rörelser. I vårt projekt styr vi en ' MG90S metallväxelservomotor '. Den tar emot kommandon från Arduino och svänger i en specifik vinkel, vilket gör att vi kan uppnå exakt positionering och rörelse.
Potentiometer : Potentiometern är ett variabelt motstånd. Den fungerar som en vridknapp som låter oss justera värdet på motståndet. I vårt projekt använder vi potentiometern för att styra rörelsen hos vår servomotor genom att ändra vinkeln med vilken den roterar.
Bygeltrådar : Bygeltrådarna är korta kablar med kontakter i ändarna som gör att vi kan koppla ihop olika komponenter. De är väldigt flexibla och lätta att använda för att koppla ihop vår Arduino, servomotor, potentiometer och breadboard.
Breadboard/fumleboard : En breadboard, även känd som en fumbleboard, är ett användbart verktyg för tillfällig prototypframställning av elektroniska kretsar. Det gör att vi enkelt kan ansluta våra komponenter utan att behöva göra permanent lödning. Vi kan sätta in våra komponenter i hålen på brödbrädan och göra anslutningar med hjälp av byglingskablarna.

Låt oss snabbt ta en närmare titt på vår servomotor .

Servomotor SG-90

Servomotor SG-90 är en liten och kompakt motor som används för att flytta mekaniska delar med precision. Det är mycket vanligt i hobbyprojekt, robotteknik och fjärrstyrda enheter.
Här är några viktiga punkter om servomotorn SG-90:

Styrning : Servomotor SG-90 är en typ av återkopplingsmotor, vilket innebär att den noggrant följer de styrsignaler den tar emot. Den kan rotera inom en viss vinkel (vanligtvis 180 grader) och flytta till en viss position.
Vridmoment : SG-90 har relativt lågt vridmoment jämfört med större servomotorer, men det räcker för många lätta till medelstora projekt. Den kan flytta små mekaniska delar och komponenter.
Spänning : Servomotor SG-90 arbetar vanligtvis med en driftspänning på 4,8 V till 6 V. Den kan använda en extern strömkälla eller få ström från Arduino-kortet, beroende på projektets krav.
Signalkontroll : För att styra servomotorn SG-90 måste den ta emot en PWM-signal (Pulse Width Modulation). PWM-signalen består av pulser med olika varaktighet, där varaktigheten anger önskad position eller vinkel för motorn.
Anslutning : Servomotor SG-90 har vanligtvis tre ledningar - röd (Vcc/+) , svart (GND/-) och orange (signal) . De röda och svarta ledningarna är för strömförsörjning, medan den orangea kabeln är för att ta emot PWM-styrsignalen.

Kretsen i projektet

Eftersom vi redan har byggt vår första krets och därmed har lite erfarenhet finns det denna gång plats för lite... metaforer... i förklaringen till projektets krets. Låt oss gå...
I vår spännande krets som får vår servo att dansa till tonerna av potentiometern, vänder vi oss åter till vår trogna följeslagare, brödbrädan. Den här gången slår vi oss ihop med en speciell karaktär, " MG90S metallväxelservomotor ", känd för sin legendariska precision. Bredvid honom har vi våra livliga assistenter, bygeltrådarna och den charmiga potentiometern som ger oss full kontroll.

Vi ansluter först vår servo till vår Arduino genom att ge den en solid anslutning till 5V och GND , vilket ger den kraften och jordningen den behöver för sina danssteg. Sedan inbjuder vi honom att ta plats vid GPIO 9-stiftet , där han kommer att ta emot våra kommandon och förvandla dem till graciösa rörelser. Det är vid denna tidpunkt som vår potentiometer kommer in på scenen med sin egen glamorösa närvaro.

Vår potentiometer är också en del av vår elfest och får lika mycket kärlek som servo. Vi ansluter den till 5V och GND från vår älskade Arduino för att se till att den känns bekväm och jordad. Sedan inbjuder vi den att dela med sig av sina hemligheter genom att ansluta den till det analoga stiftet GPIO A0 , där den kommer att berätta historien om sin nuvarande position.

Nu när vår krets är på plats och våra komponenter är redo för ACTION , är det dags att fokusera på koden. Vi kommer återigen i den här bloggen att använda Arduino-kod för att styra vår servo och potentiometer och skapa en elegant rörelsesekvens. Låt oss dyka in i programmeringsvärlden och utforska hur vi kan tämja dessa komponenter och bringa dem i harmoni med våra önskade rörelser.

Koden

I den här koden introducerar vi bibliotek på Arduino IDE-plattformen!
Arduino-bibliotek är viktiga eftersom de ger oss tillgång till färdig kod utvecklad av andra superbegåvade människor. Detta gör det lättare för oss andra att implementera komplexa funktioner eller styra olika komponenter utan att behöva skriva all kod från grunden. Bibliotek innehåller fördefinierade funktioner, konstanter och definitioner som gör programmering med Arduino mer effektiv och tillgänglig för alla.
Tänk på bibliotek som program vi kan ladda ner för att ta giltiga genvägar i vår programmering.

Gör följande för att installera inbyggda bibliotek i Arduino IDE:

Öppna Arduino IDE-programvaran på din dator.
Gå till "Sketch" i menyn högst upp på skärmen.
Klicka på "Inkludera bibliotek".
En lista över olika bibliotek visas. Sök via sökfältet och hitta önskat bibliotek.
Klicka på bibliotekets namn för att installera det.
Arduino IDE kommer att ladda ner och installera biblioteket automatiskt.
När installationen är klar är biblioteket redo att användas.

I koden använder vi en biblioteksfunktion som heter " Servo ". Ett bibliotek är som sagt en samling fördefinierade funktioner och kod som gör det lättare för oss att arbeta med specifika komponenter eller funktionaliteter. I det här fallet använder vi Servo-biblioteket för att styra vår servomotor.

Här är koden för projektet

 # include <Servo.h> // Lägg till servobiblioteket

 Servo mus servo; // Skapa servoobjekt för att styra en servo

 int potpin = 0 ; // Analogt stift som används för att ansluta potentiometern
 int val; // Variabel för att läsa värdet från det analoga stiftet

 void setup () { 
mus servo. fäst ( 9 ); // Anslut servo på stift 9 till servoobjektet
 }

 void loop () {
 val = analogRead (potpin); // Läser värdet från potentiometern (värde mellan 0 och 1023) 
val = karta (val, 0 , 1023 , 0 , 180 ); // Skala värdet som ska användas med servo (värde mellan 0 och 180)
 mus servo. skriva (val); // Ställ in servo till det skalade värdet
 fördröjning ( 15 ); // Vänta tills servo når önskad position

I den här serien, och därmed i den här bloggen, fortsätter vi att använda hyperlänkar till Arduino-plattformen för att introducera nya programmeringskoncept. Vi rekommenderar att du klickar på dessa hyperlänkar och läser beskrivningarna om de förvirrar dig. Det kan verka överväldigande till en början, men med lite tålamod och beslutsamhet kan du enkelt övervinna det och bemästra det!

Vi börjar med att inkludera Servo-biblioteket genom att skriva "#include < Servo.h >". Detta ger oss tillgång till alla användbara funktioner och kommandon som finns i Servo-biblioteket.

Sedan skapar vi ett objekt som heter "myservo" med hjälp av "Servo myservo;". Detta objekt låter oss styra vår servomotor.

Vi definierar en variabel "potpin" och tilldelar den värdet 0. Denna variabel används för att läsa av värdet från vår potentiometer, som är kopplad till analog pin 0 på Arduino.

I inställningsfunktionen använder vi " myservo.attach (9);" för att ansluta vår servomotor till stift 9 på Arduino.

I loop-funktionen läser vi värdet på potentiometern med "val = analogRead (potpin);".
analogRead() är väldigt lik digitalRead() , som vi lärde oss om i den första bloggen i den här serien: Ljus & Ljud .
AnalogRead-funktionen används för att läsa värden från analoga ingångsstift på Arduino-kortet. Till skillnad från digitalRead, som bara kan läsa antingen hög (1) eller låg (0), kan analogRead läsa ett bredare spektrum av värden som representerar spänningsnivåer.
På en Arduino UNO finns det 6 analoga ingångsstift markerade som A0 till A5 . När du använder analogRead på en av dessa stift kommer funktionen att returnera ett värde mellan 0 och 1023. Detta värde är baserat på den analoga spänningen som är kopplad till stiftet. 0 motsvarar en analog spänning på 0 volt, och 1023 motsvarar referensspänningen som anges på Arduino (vanligtvis 5 volt på Arduino UNO).

Vi använder sedan " map "-funktionen för att skala detta värde från området 0-1023 till området 0-180, eftersom vår servomotor kan rotera inom detta område.

Vi använder " myservo.write (val);" för att ställa in servons position enligt det skalade värdet.
Slutligen använder vi " delay (15);" att vänta 15 millisekunder innan du upprepar loopfunktionen.

Ladda upp koden

För att ladda upp koden och testa om vårt projekt fungerar ansluter vi Arduino till vår dator med en USB-kabel och följer stegen nedan.

Öppna Arduino-programvaran.
Klicka på "Verifiera"-knappen längst upp i verktygsfältet. Detta kontrollerar koden för eventuella fel eller problem.
Om det inte finns några fel kommer du att se ett meddelande om att verifieringen lyckades.
Välj rätt Arduino-kort och port från menyn "Verktyg" i programvaran.
Klicka på knappen "Ladda upp" högst upp i verktygsfältet. Detta kompilerar koden och överför den till Arduino.
Om allt går bra kommer du att se ett meddelande om att uppladdningen är klar.
Nu kan du testa ditt projekt och se om det fungerar som förväntat.

Vi har nu utforskat spännande projekt med både ljudsensor och servomotor. Du har lärt dig hur du bygger kretsarna, programmerar Arduino och ser dina skapelser ta form. Men vänta! Det kommer mer!

Om du skulle vilja utveckla mer elektronik har vi en spännande bonus – ett extra projekt för dig som kombinerar det bästa av två världar. Vi kommer att kombinera servo från blogg 2 med ljudsensorn från blogg 1 i serien och skapa ett interaktivt ljudstyrt rörelseprojekt.

BONUSPROJEKT

I vårt spännande bonusprojekt kommer vi att kombinera det bästa av två världar och skapa ett interaktivt ljudstyrt rörelseprojekt. Vi kommer att använda servomotorn från blogg 2 och ljudsensorn från blogg 1 för att skapa en unik och rolig upplevelse.

I det här projektet kommer vi att programmera Arduino för att svara på ljud, speciellt fingersnäpp. När du snärtar en gång kommer servomotorn att rotera i en viss riktning och den gröna lysdioden lyser, och när du snärtar två gånger så kommer den att rotera i motsatt riktning, nu tänds den röda lysdioden istället. Denna kombination av ljud och rörelse gör att du kan interagera med ditt projekt på ett helt nytt sätt.

Nu kommer den mest spännande delen av vårt bonusprojekt - det är dags att sätta dina egna färdigheter på prov! Vi utmanar dig att bygga kretsen och implementera koden för att få vårt ljudstyrda rörelseprojekt att fungera.

Ta din älskade Arduino, din pålitliga servomotor och din pålitliga ljudsensor. Anslut dem med kärlek och passion på brödbrädan med hjälp av bygeltrådarna. Glöm inte att ge dem rätt anslutning till 5V och GND .

Nu är det dags att ta en närmare titt på vår kod. Öppna Arduino IDE och kopiera den presenterade koden till ett nytt skissfönster.

 # include <Servo.h>


 Servo mus servo;
 int soundSensor = 2 ; // Ljudsensorn är ansluten till stift 2 
int grön LED = 5 ; // Grön lysdiod är ansluten till stift 5
 int röd LED = 4 ; // Röd lysdiod är ansluten till stift 4
 boolean greenLEDStatus = false; // Status för grön lysdiod
 boolean redLEDStatus = false; // Tillstånd för röd lysdiod 
unsigned long greenLEDTimestamp = 0 ; // Tidsstämpel för grön lysdiod
 unsigned long redLEDTimestamp = 0 ; // Tidsstämpel för röd lysdiod
 int doubleSnapDelay = 2000 ; // Justera detta värde efter behov


 void setup () { 
mus servo. fäst ( 9 );
 pinMode (ljudsensor, INPUT );
 pinMode (grönLED, OUTPUT );
 pinMode (röd LED, OUTPUT );
 mus servo. skriv ( 0 ); // Ställ in positionen för servo till 0 grader 
fördröjning ( 1000 ); // Vänta ett ögonblick tills servo når utgångsläget
 }


 void loop () {
 int SensorData = digitalRead (soundSensor);
 if (SensorData == 1 ) {

 unsigned long currentTime = millis ();
 
// Kontrollera om det har gått tillräckligt med tid sedan den gröna lysdioden senast tändes
 if (currentTime - greenLEDTimestamp >= doubleSnapDelay) {
 greenLEDStatus = false;
 digitalWrite (grönLED, LÅG );
 }

 // Kontrollera om det har gått tillräckligt med tid sedan den röda lysdioden senast tändes
 if (currentTime - redLEDTimestamp >= doubleSnapDelay) {
 redLEDStatus = false;
 digitalWrite (redLED, LOW );
 }

 if (greenLEDStatus == false && redLEDStatus == false) {
 greenLEDStatus = sant; 
digitalWrite (grönLED, HÖG );

 // Ett snäpp upptäckt, rotera servo från 0 till 180 grader
 mus servo. skriva ( 180 );
 fördröjning ( 700 ); // Justera fördröjningen om det behövs

 // Uppdatera grön LED-tidsstämpel
 greenLEDTimestamp = millis ();
 
} annat om (grönLEDStatus == sant && redLEDStatus == falskt) {
 unsigned long snapTime = millis ();
 int numSnaps = 0 ;
 boolean doubleSnapDetected = false;

 while ( millis () - snapTime <= doubleSnapDelay) {
 int SensorData = digitalRead (soundSensor); 
if (SensorData == 1 ) {
 numSnaps++;
 fördröjning ( 100 ); // Fördröjning för att undvika flera snap-detekteringar

 if (numSnaps > 1 ) {
 doubleSnapDetected = sant;
 ha sönder
 }
 }
 }

 if (doubleSnapDetected) {
 // Två snaps upptäcktes, slå på den röda lysdioden
 redLEDStatus = sant; 
digitalWrite (röd LED, HÖG );

 // Rotera servo från 180 till 0 grader
 mus servo. skriv ( 0 );
 fördröjning ( 700 ); // Justera fördröjningen vid behov
 }

 // Uppdatera röd LED-tidsstämpel
 redLEDTimestamp = millis ();

 // Stäng av grön lysdiod
 greenLEDStatus = false; 
digitalWrite (grönLED, LÅG );
 }
 }
 }

PSST! Här är lite hjälp för att komma igång.

Först och främst använder vi i den här koden en ny funktion som kallas millis ().

Denna funktion returnerar antalet millisekunder som har gått sedan Arduino startades eller återställdes.

I vårt projekt använder vi millis() för att hålla reda på tiden som har gått sedan ett snap registrerades. Vi lagrar tiden i en variabel och jämför den senare med den aktuella tiden för att se om det har gått tillräckligt med tid för att utföra en viss åtgärd.

I detta projekt definierar vi "tidsstämplar" för våra lysdioder som variabler av typen "unsigned long". Detta beror på att "tidsstämplar" använder en stor mängd numeriska värden, eftersom de representerar tider mätta i millisekunder. En " unsigned long " variabeltyp kan lagra större positiva heltal jämfört med andra variabeltyper.

Genom att använda "unsigned long" undviker vi potentiella problem med overflow , där en variabel når sitt maximala värde och sedan "rullar runt" tillbaka till noll.

Även om en vanlig "int" förmodligen skulle räcka här, är det bra att "träna med bra form" från början och därför använda "unsigned long" för att säkerställa precision och undvika eventuella spillproblem i framtida projekt.

Så nu när vi har en bättre förståelse för koden för bonusprojektet kan du prova att läsa hur du ställer in kretsen. Till exempel, baserat på raden "int soundSensor = 2;", kan vi se att ljudsensorn ska anslutas till stift 2 på Arduino. Kan du läsa hur de andra komponenterna måste ställas in?

Kom också ihåg att använda motstånd (ca 1k ohm) för att skydda lysdioderna och koppla komponenterna till både matningsspänningen ( 5V från Arduino ) och jord (GND-stiftet på Arduino ). Nu är det dags att omsätta kunskap i praktiken och se bonusprojektet i praktiken!

Dela med sig!