Bouw een Arduino-servo-toggleschakelaar met een drukknop

Bouw een Arduino-servo-toggleschakelaar met een drukknop

Bouw een Arduino-servo-toggleschakelaar met een drukknop

Deze projectgids laat je zien hoe je een eenvoudig maar zeer nuttig circuit maakt: een servomotor die bij elke indrukking van één enkele drukknop schakelt tussen twee posities. Bij de eerste indrukking zal de servo soepel van 0 naar 180 graden bewegen. Bij de tweede indrukking zal hij teruggaan van 180 naar 0 graden. Dit is een fundamenteel concept in robotica en automatisering, perfect voor het maken van mechanismen zoals een automatische deurvergrendeling, een eenvoudige robotarm, een vlaggenzwaaier of elk project dat een fysieke actie met twee toestanden vereist.

We bespreken de benodigde hardware, de bedrading en geven een gedetailleerde uitleg van de Arduino-code die alles laat werken.

Hardware en bedrading

De componenten voor dit project zijn minimaal en komen veel voor in de meeste Arduino-startkits. Je hebt een Arduino-bord (zoals een Uno), een standaard hobby-servomotor (bijv. SG90), een drukknop en een paar jumperkabels nodig.

De bedrading is eenvoudig. De stroom- en aardingslijnen van de servo worden aangesloten op de 5V- en GND-pinnen van de Arduino, terwijl de signaallijn wordt aangesloten op een PWM-capabele pin (pin 9 in onze code). De drukknop wordt aangesloten tussen digitale pin 2 en GND.

De Arduino-code uitgelegd

De sketch gebruikt de standaard Servo.h-bibliotheek, die bij de Arduino IDE wordt meegeleverd. De code is ontworpen om overzichtelijk en gemakkelijk te begrijpen te zijn, met vlaggen om de status van de servo bij te houden en for-lussen om een soepele beweging te creëren.

Globale variabelen en configuratie

Bovenaan de code definiëren we de pinnen en het gedrag van de servo. Dit zijn de belangrijkste waarden die je mogelijk voor je project wilt aanpassen.

#include <Servo.h>

// Definieer variabelen voor servo- en knop-pinnen
const int servoPin = 9;   // Sluit de servosignaaldraad aan op digitale pin 9
const int buttonPin = 2;  // Sluit de drukknop aan op digitale pin 2

// Definieer parameters voor servobeweging
const int initialAngle = 0;   // Starthoek van de servo
const int targetAngle1 = 180; // Eerste doelhoek
const int targetAngle2 = 0;   // Tweede doelhoek
const int movingStep = 1;     // Stapgrootte voor soepele beweging (1 graad per keer)

Servo myServo; // Maak een Servo-object

// Variabelen voor statustracking
int currentAngle = initialAngle;
bool buttonPressed = false;
bool servoAt180 = false;

• servoPin: De pin die is aangesloten op de signaaldraad van de servo. Dit moet een PWM-pin zijn (gemarkeerd met een `~` op de meeste Arduino-borden).
• buttonPin: De pin waarop de drukknop is aangesloten.
• initialAngle, targetAngle1, targetAngle2: Deze definiëren het start- en eindpunt van de beweging van de servo.
• movingStep: Dit bepaalt hoeveel graden de servo in elke stap van de lus beweegt. Een kleiner getal zorgt voor een soepelere, langzamere beweging.

De setup()-functie

De setup()-functie wordt één keer uitgevoerd wanneer de Arduino wordt ingeschakeld. Het initialiseert de servo, configureert de knop-pin en zet de servo in zijn startpositie.

void setup() {
  myServo.attach(servoPin); // Koppelt de servo aan zijn pin
  pinMode(buttonPin, INPUT_PULLUP); // Stel de knop-pin in als invoer met interne pull-up
  myServo.write(initialAngle);      // Verplaats de servo naar zijn beginpositie
  Serial.begin(9600);               // Start seriële communicatie voor debugging
}

We gebruiken INPUT_PULLUP voor de knop-pin. Dit activeert een interne weerstand in de Arduino, die de status van de pin HOOG houdt wanneer de knop niet wordt ingedrukt. Wanneer de knop wordt ingedrukt, verbindt deze de pin met aarde, waardoor de status LAAG wordt. Deze handige functie betekent dat je geen externe pull-up-weerstand aan je circuit hoeft toe te voegen.

De loop() - De kernlogica

De hoofdlus controleert continu op een knopdruk. Wanneer een druk wordt gedetecteerd, verplaatst het de servo naar zijn volgende doelpositie.

void loop() {
  // Lees de status van de knop
  int buttonState = digitalRead(buttonPin);

  // Controleer of de knop is ingedrukt (LAAG) en niet al werd ingedrukt gehouden
  if (buttonState == LOW && !buttonPressed) {
    delay(50); // Debounce-vertraging om meerdere triggers te voorkomen
    if (digitalRead(buttonPin) == LOW) { // Controleer de knopstatus opnieuw
      buttonPressed = true; // Markeer de knop als ingedrukt

      if (!servoAt180) {
        // Als niet op 180, beweeg naar 180
        for (int angle = currentAngle; angle <= targetAngle1; angle += movingStep) {
          myServo.write(angle);
          delay(15); // Vertraging tussen stappen om de snelheid te regelen
        }
        currentAngle = targetAngle1;
        servoAt180 = true; // Werk status bij
      } else {
        // Als op 180, beweeg terug naar 0
        for (int angle = currentAngle; angle >= targetAngle2; angle -= movingStep) {
          myServo.write(angle);
          delay(15);
        }
        currentAngle = targetAngle2;
        servoAt180 = false; // Werk status bij
      }
    }
  }

  // Reset de knopdruk-vlag zodra de knop wordt losgelaten
  if (buttonState == HIGH) {
    buttonPressed = false;
  }
}

De code gebruikt een booleaanse vlag, servoAt180, om de laatste positie van de servo te onthouden. Wanneer de knop wordt ingedrukt, controleert het deze vlag: als de servo niet op 180 graden staat, beweegt het hem daarheen; anders beweegt het hem terug naar 0. De for-lussen zorgen voor de vloeiende zwaaiende beweging, waarbij de servo één graad tegelijk beweegt met een kleine vertraging tussen elke stap.

Hoe Het Werkt

Zodra je de code uploadt en je Arduino inschakelt, beweegt de servo naar zijn initiële positie van 0 graden.

1. Eerste indruk: Wanneer je de knop indrukt, detecteert de code de invoer en begint de servo van 0 naar 180 graden te bewegen, één graad tegelijk.
2. Tweede indruk: Nadat de servo 180 graden heeft bereikt, zorgt de volgende knopdruk ervoor dat hij terugzwaait van 180 naar 0 graden.

Deze cyclus herhaalt zich bij elke volgende knopdruk, waardoor een betrouwbaar en voorspelbaar schakelmechanisme voor je project ontstaat.

/*
This code is provided by robojax.com
you can view the wiring diagram and details of this tutorial 
here https://robojax.com/T661
*/
#include <Servo.h>

// Define variables for servo and button pins
const int servoPin = 9;   // Connect servo signal wire to digital pin 9
const int buttonPin = 2;  // Connect push button to digital pin 2

// Define servo movement parameters
const int initialAngle = 0;   // Servo's starting angle
const int targetAngle1 = 180; // First target angle
const int targetAngle2 = 0;   // Second target angle (same as initial in this case)
const int movingStep = 1;     // Step size for smooth movement (e.g., 1 degree at a time)

Servo myServo; // Create a Servo object

int currentAngle = initialAngle; // Variable to keep track of the servo's current angle
bool buttonPressed = false;      // Flag to track button state
bool servoAt180 = false;         // Flag to track if the servo is at 180 degrees

void setup() {
  myServo.attach(servoPin); // Attaches the servo on the servoPin to the servo object
  pinMode(buttonPin, INPUT_PULLUP); // Set the button pin as input with internal pull-up resistor
  myServo.write(initialAngle);      // Set the servo to its initial angle
  Serial.begin(9600);              // Start serial communication for debugging
}

void loop() {
  // Read the state of the button
  int buttonState = digitalRead(buttonPin);

  // Check if the button is pressed (LOW because of INPUT_PULLUP) and it was not pressed before
  if (buttonState == LOW && !buttonPressed) {
    delay(50); // Debounce delay
    if (digitalRead(buttonPin) == LOW) { // Confirm button press after debounce
      buttonPressed = true; // Set flag to indicate button is currently pressed

      if (!servoAt180) {
        // Move servo to 180 degrees
        Serial.println("Moving to 180 degrees");
        for (int angle = currentAngle; angle <= targetAngle1; angle += movingStep) {
          myServo.write(angle);
          delay(15); // Adjust this delay for desired speed
        }
        currentAngle = targetAngle1;
        servoAt180 = true;
      } else {
        // Move servo to 0 degrees
        Serial.println("Moving to 0 degrees");
        for (int angle = currentAngle; angle >= targetAngle2; angle -= movingStep) {
          myServo.write(angle);
          delay(15); // Adjust this delay for desired speed
        }
        currentAngle = targetAngle2;
        servoAt180 = false;
      }
    }
  }

  // Reset buttonPressed flag when button is released
  if (buttonState == HIGH) {
    buttonPressed = false;
  }
}