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

1. 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.
   
   
2. 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.
   
   
3. 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.
   
   
4. Anslutningskablar : Anslutningskablarna ä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.
   
   
5. Kopplingsdäck : 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å kopplingsdäcket och göra anslutningar med hjälp av anslutningskablarna.

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

Servomotor SG-90

 
SG-90 är en liten och kompakt servo för precisa mekaniska rörelser, vanlig i hobbyprojekt, robotik och fjärrstyrda enheter. Översikten beskriver SG-90, medan projektet också nämner MG90S; kontrollera därför specifikationerna för den servo som faktiskt levereras.
Här är några viktiga punkter om servomotorn SG-90:

• Styrning: SG-90 använder återkopplad positionsstyrning. Den rör sig inom ett begränsat vinkelområde, ofta beskrivet som 180 grader; säker rörelse och pulsgränser beror på exakt modell.

• 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: Kontrollera servons spännings- och strömmärkning; 4,8 V till 6 V anges ofta för dessa hobbyservon men är ingen allmän garanti. Använd en reglerad extern matning dimensionerad för start-/stallström och anslut dess jord till Arduino-jord. Anta inte att UNO:s 5V-utgång kan driva servon tillförlitligt.

• Signalkontroll: Servon tar emot positionspulser vars bredd anger önskad vinkel. Detta kallas ofta servo-PWM men är inte samma sak som vanlig pulsbreddsstyrning med Arduino analogWrite().

• Anslutning : Servomotor SG-90 har vanligtvis tre ledningar - röd (Vcc/+) , svart (GND/-) och orange (signal). Färger kan variera, så kontrollera dokumentationen. Matning och jord försörjer motorn; signalledningen tar emot positionspulser.

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, kopplingsdäcket. 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, anslutningskablarna och den charmiga potentiometern som ger oss full kontroll.

Försörj först servon med en lämplig extern reglerad matning, här nominellt 5V inom dokumenterad märkning, och anslut matningens GND till både servojord och Arduino-jord. Anslut inte den externa plusmatningen till UNO:s 5V-skena när kortet matas via USB. Anslut servosignalen till 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.

Potentiometern deltar också. Anslut dess två ytteranslutningar till 5V och GND på Arduino och anslut släpkontakten till analogstift A0, där den visar sin aktuella 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.

Installera ett bibliotek med Arduino IDE:

1. Öppna Arduino IDE-programvaran på din dator.
2. Öppna Library Manager i sidofältet eller välj Sketch > Include Library > Manage Libraries.
3. Sök efter biblioteket, här Servo.
4. Välj rätt bibliotek och kontrollera upphovsperson och kortkompatibilitet.
5. Klicka på Install.
6. Arduino IDE kommer att ladda ner och installera biblioteket automatiskt.
7. När installationen är klar är biblioteket redo att användas.

I koden använder vi biblioteket ”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>  // Tilføj servo-biblioteket

Servo myservo;  // Opret servo-objekt til at styre en servo

int potpin = 0;  // Analog pin brugt til at forbinde potentiometeret
int val;    // Variabel til at læse værdien fra den analoge pin

void setup() {
  myservo.attach(9);  // Tilslut servoen på pin 9 til servo-objektet
}

void loop() {
  val = analogRead(potpin);            // Læser værdien fra potentiometeret (værdi mellem 0 og 1023)
  val = map(val, 0, 1023, 0, 180);     // Skalér værdien til brug med servoen (værdi mellem 0 og 180)
  myservo.write(val);                  // Indstil servoen til den skalerede værdi
  delay(15);                           // Vent på at servoen når den ønskede 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. På klassiska UNO returnerar analogRead normalt 0–1023 från en 10-bitars ADC. Värdet anger ingången relativt vald referensspänning, normalt nominellt 5 V; upplösning garanterar inte absolut noggrannhet.

Vi använder sedan " map” för att skala 0–1023 till 0–180 i exemplet. Kontrollera servons säkra rörelse- och pulsgränser och begränsa området vid behov.

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.

1. Öppna Arduino-programvaran.
2. Klicka på Verify i verktygsfältet. Koden kompileras och kompileringsfel kontrolleras; det verifierar inte den fysiska kopplingen eller allt beteende.
3. Om det inte finns några fel kommer du att se ett meddelande om att verifieringen lyckades.
4. Välj rätt Arduino-kort och port från menyn "Verktyg" i programvaran.
5. Klicka på knappen "Ladda upp" högst upp i verktygsfältet. Detta kompilerar koden och överför den till Arduino.
6. Om allt går bra kommer du att se ett meddelande om att uppladdningen är klar.
7. 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 Arduino, servon och ljudsensorn och koppla ihop dem på kopplingsdäcket. Följ anvisningarna om separat servomatning ovan; ge övriga moduler rätt märkspänning, här 5V, och anslut alla GND-punkter tillsammans.

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 myservo;
int soundSensor = 2;                  // Lydsensor er tilsluttet pin 2
int greenLED = 5;                     // Grøn LED er tilsluttet pin 5
int redLED = 4;                       // Rød LED er tilsluttet pin 4
boolean greenLEDStatus = false;       // Status for grøn LED
boolean redLEDStatus = false;         // Status for rød LED
unsigned long greenLEDTimestamp = 0;  // Tidsstempel for grøn LED
unsigned long redLEDTimestamp = 0;    // Tidsstempel for rød LED
int doubleSnapDelay = 2000;           // Juster denne værdi efter behov


void setup() {
  myservo.attach(9);
  pinMode(soundSensor, INPUT);
  pinMode(greenLED, OUTPUT);
  pinMode(redLED, OUTPUT);
  myservo.write(0);  // Indstil servoens position til 0 grader
  delay(1000);       // Vent et øjeblik for at servo nå den indledende position
}


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

    unsigned long currentTime = millis();

    // Tjek om der er gået nok tid siden grøn LED sidst blev tændt
    if (currentTime - greenLEDTimestamp >= doubleSnapDelay) {
      greenLEDStatus = false;
      digitalWrite(greenLED, LOW);
    }

    // Tjek om der er gået nok tid siden rød LED sidst blev tændt
    if (currentTime - redLEDTimestamp >= doubleSnapDelay) {
      redLEDStatus = false;
      digitalWrite(redLED, LOW);
    }

    if (greenLEDStatus == false && redLEDStatus == false) {
      greenLEDStatus = true;
      digitalWrite(greenLED, HIGH);

      // Ét knips registreret, drej servo fra 0 til 180 grader
      myservo.write(180);
      delay(700);  // Juster forsinkelsen om nødvendigt

      // Opdater tidsstempel for grøn LED
      greenLEDTimestamp = millis();

    } else if (greenLEDStatus == true && redLEDStatus == false) {
      unsigned long snapTime = millis();
      int numSnaps = 0;
      boolean doubleSnapDetected = false;

      while (millis() - snapTime <= doubleSnapDelay) {
        int SensorData = digitalRead(soundSensor);
        if (SensorData == 1) {
          numSnaps++;
          delay(100);  // Forsinkelse for at undgå flere knips-detektioner

          if (numSnaps > 1) {
            doubleSnapDetected = true;
            break;
          }
        }
      }

      if (doubleSnapDetected) {
        // To knips registreret, tænd rød LED
        redLEDStatus = true;
        digitalWrite(redLED, HIGH);

        // Drej servo fra 180 til 0 grader
        myservo.write(0);
        delay(700);  // Juster forsinkelsen om nødvendigt
      }

      // Opdater tidsstempel for rød LED
      redLEDTimestamp = millis();

      // Sluk grøn LED
      greenLEDStatus = false;
      digitalWrite(greenLED, LOW);
    }
  }
}

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.

LED-tidsstämplarna använder unsigned long, vilket motsvarar millis() på klassiska UNO. En ”unsigned long” lagrar icke-negativa heltal över ett större område än UNO:s signerade int.

Att använda unsigned long eliminerar inte overflow: millis() börjar om från noll efter ungefär 49,7 dagar på klassiska UNO.

Kontrollera förfluten tid med unsigned-subtraktion, exempelvis now - previous >= interval, och lämpliga intervallgränser. En vanlig 16-bitars int passar inte för millis()-tidsstämplar. Rollover-säker aritmetik behövs utöver rätt typ.

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 ihåg strömbegränsande resistorer (cirka 1k ohm) till LED:erna. Anslut komponenter med låg strömförbrukning till lämplig matning (5V från Arduino ) och jord (GND-stiftet på Arduino). Följ anvisningarna om separat servomatning ovan. Nu är det dags att omsätta kunskapen i praktiken och se bonusprojektet i gång!