Sketch für Platine "Die Gelbe" für Arduino NANO oder UNO

Racker

Hallo,

die Platine "Die Gelbe" habe ich für ein nicht-Modellbau-Projekt entwickelt und dient dazu ein Servo über 4 Schalteingänge auf einstellbare Positionen zu fahren. In meiner Anwendung werden die Schalteingänge über einen 433MHz Funkempfänger angesteuert, man kann dies aber natürlich auch über ein herkömmliches Schaltmodul oder Sensoren (Schalter/Taster usw.) tun. Weiterhin ist Platz für einen Taster 6x6 mm und ein Trimm-Poti (stehend) vorgesehen, sowie eine LED mit Vorwiderstand.

Der Sketch für die Platine hat folgende Funktionen:

Das Servo an J2 wird über ein Signal an den Schalteingängen D3 bis D6 auf die programmierte Position/en gefahren, dabei wird zwischen kurzer und langer Betätigung unterschieden:

kurz an D4 fährt das Servo auf die linke Position und nach der eingestellten Haltezeit zurück auf die Mittelstellung; lang an D4 fährt das Servo auf die linke Position und es bleibt dort stehen bis ein Signal über D3, D5 oder D6 erkannt wird
kurz an D5 fährt das Servo auf die rechte Position und nach der eingestellten Haltezeit zurück auf die Mittelstellung; lang an D5 fährt das Servo auf die rechte Position und es bleibt dort stehen bis ein Signal über D3, D4 oder D6 erkannt wird
kurz an D3 fährt das Servo zurück auf die Mittelstellung
kurz an D6 fährt das Servo erst auf die linke Position und nach der Haltezeit auf die rechte Position, dann nach der Haltezeit wieder auf die Mittelstellung (Signale an D3, D4 und D5 werden solange ignoriert)
lang an D6 fährt das Servo erst auf die rechte Position und nach der Haltezeit auf die linke Position, dann nach der Haltezeit wieder auf die Mittelstellung (Signale an D3, D4 und D5 werden solange ignoriert)
Kalibrierungs-Routine für Servo-Positionen und Haltezeit, wird über den Taster gestartet
Poti zur Einstellung der Servo-Positionen (Mitte, Rechts und Links) und Haltezeit
Eingestellte Werte werden im EEPROM abgespeichert und bei jedem Start des Arduino ausgelesen, so daß die Kalibrierung nur einmalig nötig ist
Schalteingang über positives (z.B. mit Funkempfänger) oder negatives Signal
LED leuchtet, wenn sich das Servo nicht in der Mittelstellung befindet

Anwendungsbeispiel:

Eine Türe/Klappe öffnen oder einen Kran/den Turm einer Kanone auf rechte oder linke Position drehen, je nach Betätigungsdauer mit automatischer Rückstellung nach Ablauf der Haltezeit oder Verweilen auf Position bis ein neues Steuersignal erkannt wird.

Kalibrierung:

Es wird empfohlen, das Poti vor dem Starten der Kalibrierung in die Mittelstellung zu bringen um einen unerwünschten Ausschlag nach rechts oder links zu vermeiden!

Taster 1x kurz drücken startet die Kalibrierung, es kann nun die Mittelstellung über das Poti eingestellt werden. Die LED blinkt währenddessen 1x schnell.
Taster 1x kurz drücken speichert den Wert für die Mittelstellung; nun kann die linke Position über das Poti eingestellt werden. Die LED blinkt währenddessen 2x schnell.
Taster 1x kurz drücken speichert den Wert für die linke Position; nun kann die rechte Position über das Poti eingestellt werden. Die LED blinkt währenddessen 3x schnell.
Taster 1x kurz drücken speichert den Wert für die rechte Position; nun kann die Haltezeit (500 bis 10.000 ms) über das Poti eingestellt werden. Die LED blinkt währenddessen 4x schnell.
Taster 1x kurz drücken fährt das Servo auf die linke Position für die Dauer der Haltezeit. Dieser Schritt kann beliebig oft wiederholt werden, so daß die Änderungen über das Poti sofort überprüfbar sind.
Taster 1x lang drücken speichert die Haltezeit. Die LED leuchtet für 2 Sekunden und zeigt das Ende der Kalibrierung an. Danach wird das Programm gestartet.

Im Serial Monitor der Arduino IDE können die Einstellungen während der Kalibrierung nachverfolgt werden. Im Loop-Teil sind diese ausgeklammert, können aber z.B. zur Fehlersuche aktiviert werden, in dem man die „//“ Zeichen vor den Serial.print(ln) Zeilen entfernt.

Der Sketch ist für positive (5V) oder negative (GND/Minus) Schaltsignale vorhanden. Bei Verwendung von positiven Signalen (wie beim Funkempfänger) muß das Widerstands-Netzwerk als Pull-Down eingesetzt werden. Bei negativen Signalen werden die internen Pull-Up Widerstände des Arduinos verwendet, das Widerstands-Netzwerk darf dann nicht auf die Platine gelötet werden!

Im Sketch kann die minimale und maximale Impulslänge (544 bis 2400 μs) eingestellt werden, abhängig vom verwendetem Servo oder zum Begrenzen der Endpunkte. Diese Werte werden dann auch bei der Kalibrierung berücksichtigt.

Die Haltezeit kann von 500 bis 10.000 ms eingestellt werden, eine Änderung im Sketch ist möglich.

Benötigte Bibliotheken:

Button.h - Button-Arduino 2.0.0 by Davide Palladino

Servo.h - in Arduino IDE enthalten

EEPROM.h - in Arduino IDE enthalten

Racker

Sketch für Steuerung der Schalteingänge über negative (Minus) Schaltsignale - Teil 1:

C

// Servo Steuerung über negatives (Minus) Schaltsignal v1
// v1 Erste Version
// Für Arduino UNO und NANO
// Letzte Änderung 28.10.2021

#include <Button.h>                         // Bibliothek für Taster (mit Unterscheidung kurz/lang)
#include <Servo.h>                          // Bibliothek für Servo
#include <EEPROM.h>                         // Bibliothek für EEPROM

Button EingangTaster(2, B_PULLUP, 750);       // Digitaler Eingang für Taster zum Aufruf der Kalibrierung (lang > 750ms)
Button EingangServoMitte(3, B_PULLUP);        // Digitaler Eingang zum Setzen von Servo auf Mittelposition
Button EingangServoLinks(4, B_PULLUP, 750);   // Digitaler Eingang zum Setzen von Servo Links mit lang/kurz Unterscheidung
Button EingangServoRechts(5, B_PULLUP, 750);  // Digitaler Eingang zum Setzen von Servo Rechts mit lang/kurz Unterscheidung
Button EingangServoWischer(6, B_PULLUP, 750); // Digitaler Eingang zum Drehen von Servo Rechts<->Links mit lang/kurz Untersch.

Servo Servo1;

const int Servo1MinPWM = 1000;              // Minimum Impulslänge Servo1 bei Drehung Links (>= 544 und < 1500)
const int Servo1MaxPWM = 2000;              // Maximum Impulslänge Servo1 bei Drehung Rechts (> 1500 und <= 2400)
const int LED1 = LED_BUILTIN;               // Interne LED an Ausgang 13

word Zeitinterval = 500;                    // Zeitinterval für LED Blinken in ms (0 bis 65535)
word Servo1LinksPWM = 1499;                 // Impulslänge für Servo1 Drehung Links  (>= Servo1MinPWM und < Servo1MittePWM)
word Servo1MittePWM = 1500;                 // Impulslänge für Servo1 Mittelstellung (> Servo1MinPWM und < Servo1MaxPWM)
word Servo1RechtsPWM = 1501;                // Impulslänge für Servo1 Drehung Rechts (> Servo1MittePWM und <= Servo1MaxPWM)

word Servo1ZeitHalten;                      // Zeit für Servo Position halten bei kurzer Betätigung in ms (500 bis 10000)
word Servo1ZeitHaltenAnalog = 512;          // Analoger Wert für Servo1 Zeit Halten (>= 0 und <= 1023)
word Servo1LinksAnalog = 512;               // Analoger Wert für Servo1 Drehung Links  (>= 0 und <= 1023)
word Servo1MitteAnalog = 512;               // Analoger Wert für Servo1 Mittelstellung (>= 0 und <= 1023)
word Servo1RechtsAnalog = 512;              // Analoger Wert für Servo1 Drehung Rechts (>= 0 und <= 1023)

byte Kalibrierung = 0;                      // Zähler für Kalibrierungs-Stufe
byte EEAdresse = 0;                         // Erste Speicher-Addresse für EEPROM
byte Zaehler = 0;                           // Zähler für LEDblink

const byte EingangPotiKalibrierung = A7;    // Analoger Eingang für Poti zur Einstellung der Servo Positionen und Haltezeit

bool Servo1ResetAnforderung = false;        // Servo1 automatisch nach Zeit auf Mitte fahren (wahr/falsch)

unsigned long vorherigeZeitBlinken = 0;     // Vorherige Zeit für LEDblink()
unsigned long vorherigeZeitServo1 = 0;      // Vorherige Zeit für Servo1Reset()

void setup() {

  Serial.begin(115200);                     // Serielle Schnittstelle initializieren
  pinMode(LED1, OUTPUT);                    // Pin für LED1 als Ausgang definieren
  digitalWrite(LED1, LOW);                  // LED1 ausschalten

  // EEPROM Werte auslesen und an den Serial Monitor schicken:

  Servo1MittePWM = EEPROM.get(EEAdresse, Servo1MittePWM);
  EEAdresse += sizeof(word);
  Servo1LinksPWM = EEPROM.get(EEAdresse, Servo1LinksPWM);
  EEAdresse += sizeof(word);
  Servo1RechtsPWM = EEPROM.get(EEAdresse, Servo1RechtsPWM);
  EEAdresse += sizeof(word);
  Servo1ZeitHalten = EEPROM.get(EEAdresse, Servo1ZeitHalten);
  EEAdresse = 0;

  Serial.print("EEPROM Wert Servo1 Mitte: ");
  Serial.println(Servo1MittePWM, DEC);
  Serial.print("EEPROM Wert Servo1 Links: ");
  Serial.println(Servo1LinksPWM, DEC);
  Serial.print("EEPROM Wert Servo1 Rechts: ");
  Serial.println(Servo1RechtsPWM, DEC);
  Serial.print("EEPROM Wert Servo1 Zeit Halten: ");
  Serial.println(Servo1ZeitHalten, DEC);
  delay(500);

  Servo1.attach(9);                           // Servo1 an Pin X zuordnen (muß ein PWM Pin sein)
  Servo1.writeMicroseconds(Servo1MittePWM);   // Servo auf Mittelstellung fahren
  delay(250);
}

void loop() {

  if (EingangTaster.checkPress() == 1) {
    delay(500);
    Serial.println("Kalibrierung gestartet");
    calibrate();
  }

  if (EingangServoMitte.checkPress() == 1) {
//    Serial.print("Mitte, Servo μs: ");
//    Serial.println(Servo1MittePWM);
    Servo1.writeMicroseconds(Servo1MittePWM);
    digitalWrite(LED1, LOW);

  } else if (EingangServoLinks.checkPress() == 1) {     // "1" = kurzer Tastendruck
    digitalWrite(LED1, HIGH);
//    Serial.print("Links kurz, Servo μs: ");
//    Serial.println(Servo1LinksPWM);
    Servo1.writeMicroseconds(Servo1LinksPWM);
    vorherigeZeitServo1 = millis();
    Servo1ResetAnforderung = true;

  } else if (EingangServoLinks.checkPress() == -1) {    // "-1" = langer Tastendruck
    digitalWrite(LED1, HIGH);
//    Serial.print("Links lang, Servo μs: ");
//    Serial.println(Servo1LinksPWM);
    Servo1.writeMicroseconds(Servo1LinksPWM);

  } else if (EingangServoRechts.checkPress() == 1) {
    digitalWrite(LED1, HIGH);
//    Serial.print("Rechts kurz, Servo μs: ");
//    Serial.println(Servo1RechtsPWM);
    Servo1.writeMicroseconds(Servo1RechtsPWM);
    vorherigeZeitServo1 = millis();
    Servo1ResetAnforderung = true;

  } else if (EingangServoRechts.checkPress() == -1) {
    digitalWrite(LED1, HIGH);
//    Serial.print("Rechts lang, Servo μs: ");
//    Serial.println(Servo1RechtsPWM);
    Servo1.writeMicroseconds(Servo1RechtsPWM);

  } else if (EingangServoWischer.checkPress() == 1) {
    digitalWrite(LED1, HIGH);
//    Serial.print("Drehung Links > Rechts > Mitte, Servo μs: ");
//    Serial.print(Servo1LinksPWM);
//    Serial.print("   ");
//    Serial.println(Servo1RechtsPWM);
    Servo1.writeMicroseconds(Servo1LinksPWM);
    delay(Servo1ZeitHalten);
    Servo1.writeMicroseconds(Servo1RechtsPWM);
    delay(Servo1ZeitHalten);
    Servo1.writeMicroseconds(Servo1MittePWM);

  } else if (EingangServoWischer.checkPress() == -1) {
    digitalWrite(LED1, HIGH);
//    Serial.print("Drehung Rechts > Links > Mitte, Servo μs: ");
//    Serial.print(Servo1RechtsPWM);
//    Serial.print("   ");
//    Serial.println(Servo1LinksPWM);
    Servo1.writeMicroseconds(Servo1RechtsPWM);
    delay(Servo1ZeitHalten);
    Servo1.writeMicroseconds(Servo1LinksPWM);
    delay(Servo1ZeitHalten);
    Servo1.writeMicroseconds(Servo1MittePWM);
  }
  
  if (Servo1ResetAnforderung) {
    Servo1AutoReset();
  }
}

void calibrate() {

  Kalibrierung = 1;
  Serial.println("Kalibriere Servo1 Mitte");

  while (Kalibrierung == 1) {
    LEDblink();

    Servo1MitteAnalog = analogRead(EingangPotiKalibrierung);
    Serial.print("Poti Mitte analog: ");
    Serial.print(Servo1MitteAnalog);
    Servo1MittePWM = map(Servo1MitteAnalog, 0, 1023, Servo1MinPWM, Servo1MaxPWM);
    Serial.print("  Servo1 Mitte μs: ");
    Serial.println(Servo1MittePWM);
    Servo1.writeMicroseconds(Servo1MittePWM);

    if (EingangTaster.checkPress() == 1) {
      Serial.print("EEPROM Speicher Adresse: ");
      Serial.print(EEAdresse);
      Serial.print("  Wert Servo1 Mitte: ");
      Serial.println(Servo1MittePWM);
      EEPROM.put(EEAdresse, Servo1MittePWM);
      delay(100);
      EEAdresse += sizeof(word);
      Kalibrierung = 2;
      Serial.println("Kalibriere Servo1 Links");
    }

Alles anzeigen

Racker

Teil 2:

Code

    while (Kalibrierung == 2) {
      LEDblink();

      Servo1LinksAnalog = analogRead(EingangPotiKalibrierung);
      Serial.print("Poti Links analog: ");
      Serial.print(Servo1LinksAnalog);
      Servo1LinksPWM = map(Servo1LinksAnalog, 0, 1023, Servo1MinPWM, Servo1MaxPWM);
      Serial.print("  Servo1 Links μs: ");
      Serial.println(Servo1LinksPWM);
      Servo1.writeMicroseconds(Servo1LinksPWM);

      if (EingangTaster.checkPress() == 1) {
        Serial.print("EEPROM Speicher Adresse: ");
        Serial.print(EEAdresse);
        Serial.print("  Wert Servo 1 Links: ");
        Serial.println(Servo1LinksPWM);
        EEPROM.put(EEAdresse, Servo1LinksPWM);
        delay(100);
        EEAdresse += sizeof(word);
        Kalibrierung = 3;
        Serial.println("Kalibriere Servo1 Rechts");
      }

      while (Kalibrierung == 3) {
        LEDblink();

        Servo1RechtsAnalog = analogRead(EingangPotiKalibrierung);
        Serial.print("Poti Rechts analog: ");
        Serial.print(Servo1RechtsAnalog);
        Servo1RechtsPWM = map(Servo1RechtsAnalog, 0, 1023, Servo1MinPWM, Servo1MaxPWM);
        Serial.print("  Servo1 Rechts μs: ");
        Serial.println(Servo1RechtsPWM);
        Servo1.writeMicroseconds(Servo1RechtsPWM);

        if (EingangTaster.checkPress() == 1) {
          Serial.print("EEPROM Speicher Adresse: ");
          Serial.print(EEAdresse);
          Serial.print("  Wert Servo1 Rechts: ");
          Serial.println(Servo1RechtsPWM);
          EEPROM.put(EEAdresse, Servo1RechtsPWM);
          delay(100);
          EEAdresse += sizeof(word);
          Kalibrierung = 4;
          Servo1.writeMicroseconds(Servo1MittePWM);
          Serial.println("Kalibriere Zeit für Servo Halten kurz ... ");
        }

        while (Kalibrierung == 4) {
          LEDblink();

          Servo1ZeitHaltenAnalog = analogRead(EingangPotiKalibrierung);
          Serial.print("Poti Zeit analog: ");
          Serial.print(Servo1ZeitHaltenAnalog);
          Servo1ZeitHalten = map(Servo1ZeitHaltenAnalog, 1, 1023, 10000, 500);
          Serial.print("  Servo1 Zeit Halten ms: ");
          Serial.println(Servo1ZeitHalten);

          if (EingangTaster.checkPress() == 1) {
            Servo1.writeMicroseconds(Servo1LinksPWM);
            delay(Servo1ZeitHalten);
            Serial.print("Mitte, Servo μs: ");
            Serial.println(Servo1MittePWM);
            Servo1.writeMicroseconds(Servo1MittePWM);
          }

          if (EingangTaster.checkPress() == -1) {
            Serial.print("EEPROM Speicher Adresse: ");
            Serial.print(EEAdresse);
            Serial.print("  Wert Servo1 Zeit Halten: ");
            Serial.println(Servo1ZeitHalten);
            EEPROM.put(EEAdresse, Servo1ZeitHalten);
            delay(100);
            EEAdresse = 0;
            Kalibrierung = 0;
            Serial.println("Kalibrierung beendet ... ");
            digitalWrite(LED1, HIGH);
            delay(2000);
            digitalWrite(LED1, LOW);
            Servo1.writeMicroseconds(Servo1MittePWM);
            Serial.println("Starte Programm ...");
            return;
          }
        }
      }
    }
  }
}


void Servo1AutoReset() {

  unsigned long aktuelleZeit = millis();

  if (aktuelleZeit - vorherigeZeitServo1 >= Servo1ZeitHalten) {

//    Serial.print("Mitte, Servo μs: ");
//    Serial.println(Servo1MittePWM);
    Servo1.writeMicroseconds(Servo1MittePWM);
    digitalWrite(LED1, LOW);
    Servo1ResetAnforderung = false;

  } else {
    return;
  }
}

void LEDblink() {

  unsigned long aktuelleZeit = millis();

  if (aktuelleZeit - vorherigeZeitBlinken >= Zeitinterval) {
    digitalWrite(LED1, HIGH);

    if (Zaehler < Kalibrierung) {
      vorherigeZeitBlinken = aktuelleZeit;
      Zeitinterval = 500;
      Zaehler++;

    } else {
      Zaehler = 1;
      vorherigeZeitBlinken = aktuelleZeit;

      if (Kalibrierung == 1) {
        return;
      }

      Zeitinterval = Zeitinterval + 500;
    }
  } else {
    digitalWrite(LED1, LOW);
  }
  return;
}

Alles anzeigen

Racker

Sketch für Steuerung der Schalteingänge über positive (Plus) Schaltsignale - Teil 1:

C

// Servo Steuerung über positives (Plus) Schaltsignal v1
// v1 Erste Version
// Für Arduino UNO und NANO
// Letzte Änderung 28.10.2021

#include <Button.h>                         // Bibliothek für Taster (mit Unterscheidung kurz/lang)
#include <Servo.h>                          // Bibliothek für Servo
#include <EEPROM.h>                         // Bibliothek für EEPROM

Button EingangTaster(2, B_PULLUP, 750);     // Digitaler Eingang für Taster zum Aufruf der Kalibrierung (lang > 750ms)
Button EingangServoMitte(3);                // Digitaler Eingang zum Setzen von Servo auf Mittelposition
Button EingangServoLinks(4, 750);           // Digitaler Eingang zum Setzen von Servo Links mit lang/kurz Unterscheidung
Button EingangServoRechts(5, 750);          // Digitaler Eingang zum Setzen von Servo Rechts mit lang/kurz Unterscheidung
Button EingangServoWischer(6, 750);         // Digitaler Eingang zum Drehen von Servo Rechts<->Links mit lang/kurz Untersch.

Servo Servo1;

const int Servo1MinPWM = 1000;              // Minimum Impulslänge Servo1 bei Drehung Links (>= 544 und < 1500)
const int Servo1MaxPWM = 2000;              // Maximum Impulslänge Servo1 bei Drehung Rechts (> 1500 und <= 2400)
const int LED1 = LED_BUILTIN;               // Interne LED an Ausgang 13

word Zeitinterval = 500;                    // Zeitinterval für LED Blinken in ms (0 bis 65535)
word Servo1LinksPWM = 1499;                 // Impulslänge für Servo1 Drehung Links  (>= Servo1MinPWM und < Servo1MittePWM)
word Servo1MittePWM = 1500;                 // Impulslänge für Servo1 Mittelstellung (> Servo1MinPWM und < Servo1MaxPWM)
word Servo1RechtsPWM = 1501;                // Impulslänge für Servo1 Drehung Rechts (> Servo1MittePWM und <= Servo1MaxPWM)

word Servo1ZeitHalten;                      // Zeit für Servo Position halten bei kurzer Betätigung in ms (500 bis 10000)
word Servo1ZeitHaltenAnalog = 512;          // Analoger Wert für Servo1 Zeit Halten (>= 0 und <= 1023)
word Servo1LinksAnalog = 512;               // Analoger Wert für Servo1 Drehung Links  (>= 0 und <= 1023)
word Servo1MitteAnalog = 512;               // Analoger Wert für Servo1 Mittelstellung (>= 0 und <= 1023)
word Servo1RechtsAnalog = 512;              // Analoger Wert für Servo1 Drehung Rechts (>= 0 und <= 1023)

byte Kalibrierung = 0;                      // Zähler für Kalibrierungs-Stufe
byte EEAdresse = 0;                         // Erste Speicher-Addresse für EEPROM
byte Zaehler = 0;                           // Zähler für LEDblink

const byte EingangPotiKalibrierung = A7;    // Analoger Eingang für Poti zur Einstellung der Servo Positionen und Haltezeit

bool Servo1ResetAnforderung = false;        // Servo1 automatisch nach Zeit auf Mitte fahren (wahr/falsch)

unsigned long vorherigeZeitBlinken = 0;     // Vorherige Zeit für LEDblink()
unsigned long vorherigeZeitServo1 = 0;      // Vorherige Zeit für Servo1Reset()

void setup() {

  Serial.begin(115200);                     // Serielle Schnittstelle initializieren
  pinMode(LED1, OUTPUT);                    // Pin für LED1 als Ausgang definieren
  digitalWrite(LED1, LOW);                  // LED1 ausschalten

  // EEPROM Werte auslesen und an den Serial Monitor schicken:

  Servo1MittePWM = EEPROM.get(EEAdresse, Servo1MittePWM);
  EEAdresse += sizeof(word);
  Servo1LinksPWM = EEPROM.get(EEAdresse, Servo1LinksPWM);
  EEAdresse += sizeof(word);
  Servo1RechtsPWM = EEPROM.get(EEAdresse, Servo1RechtsPWM);
  EEAdresse += sizeof(word);
  Servo1ZeitHalten = EEPROM.get(EEAdresse, Servo1ZeitHalten);
  EEAdresse = 0;

  Serial.print("EEPROM Wert Servo1 Mitte: ");
  Serial.println(Servo1MittePWM, DEC);
  Serial.print("EEPROM Wert Servo1 Links: ");
  Serial.println(Servo1LinksPWM, DEC);
  Serial.print("EEPROM Wert Servo1 Rechts: ");
  Serial.println(Servo1RechtsPWM, DEC);
  Serial.print("EEPROM Wert Servo1 Zeit Halten: ");
  Serial.println(Servo1ZeitHalten, DEC);
  delay(500);

  Servo1.attach(9);                           // Servo1 an Pin X zuordnen (muß ein PWM Pin sein)
  Servo1.writeMicroseconds(Servo1MittePWM);   // Servo auf Mittelstellung fahren
  delay(250);
}

void loop() {

  if (EingangTaster.checkPress() == 1) {
    delay(500);
    Serial.println("Kalibrierung gestartet");
    calibrate();
  }

  if (EingangServoMitte.checkPress() == 1) {
//    Serial.print("Mitte, Servo μs: ");
//    Serial.println(Servo1MittePWM);
    Servo1.writeMicroseconds(Servo1MittePWM);
    digitalWrite(LED1, LOW);

  } else if (EingangServoLinks.checkPress() == 1) {     // "1" = kurzer Tastendruck
    digitalWrite(LED1, HIGH);
//    Serial.print("Links kurz, Servo μs: ");
//    Serial.println(Servo1LinksPWM);
    Servo1.writeMicroseconds(Servo1LinksPWM);
    vorherigeZeitServo1 = millis();
    Servo1ResetAnforderung = true;

  } else if (EingangServoLinks.checkPress() == -1) {    // "-1" = langer Tastendruck
    digitalWrite(LED1, HIGH);
//    Serial.print("Links lang, Servo μs: ");
//    Serial.println(Servo1LinksPWM);
    Servo1.writeMicroseconds(Servo1LinksPWM);

  } else if (EingangServoRechts.checkPress() == 1) {
    digitalWrite(LED1, HIGH);
//    Serial.print("Rechts kurz, Servo μs: ");
//    Serial.println(Servo1RechtsPWM);
    Servo1.writeMicroseconds(Servo1RechtsPWM);
    vorherigeZeitServo1 = millis();
    Servo1ResetAnforderung = true;

  } else if (EingangServoRechts.checkPress() == -1) {
    digitalWrite(LED1, HIGH);
//    Serial.print("Rechts lang, Servo μs: ");
//    Serial.println(Servo1RechtsPWM);
    Servo1.writeMicroseconds(Servo1RechtsPWM);

  } else if (EingangServoWischer.checkPress() == 1) {
    digitalWrite(LED1, HIGH);
//    Serial.print("Drehung Links > Rechts > Mitte, Servo μs: ");
//    Serial.print(Servo1LinksPWM);
//    Serial.print("   ");
//    Serial.println(Servo1RechtsPWM);
    Servo1.writeMicroseconds(Servo1LinksPWM);
    delay(Servo1ZeitHalten);
    Servo1.writeMicroseconds(Servo1RechtsPWM);
    delay(Servo1ZeitHalten);
    Servo1.writeMicroseconds(Servo1MittePWM);

  } else if (EingangServoWischer.checkPress() == -1) {
    digitalWrite(LED1, HIGH);
//    Serial.print("Drehung Rechts > Links > Mitte, Servo μs: ");
//    Serial.print(Servo1RechtsPWM);
//    Serial.print("   ");
//    Serial.println(Servo1LinksPWM);
    Servo1.writeMicroseconds(Servo1RechtsPWM);
    delay(Servo1ZeitHalten);
    Servo1.writeMicroseconds(Servo1LinksPWM);
    delay(Servo1ZeitHalten);
    Servo1.writeMicroseconds(Servo1MittePWM);
  }
  
  if (Servo1ResetAnforderung) {
    Servo1AutoReset();
  }
}

void calibrate() {

  Kalibrierung = 1;
  Serial.println("Kalibriere Servo1 Mitte");

  while (Kalibrierung == 1) {
    LEDblink();

    Servo1MitteAnalog = analogRead(EingangPotiKalibrierung);
    Serial.print("Poti Mitte analog: ");
    Serial.print(Servo1MitteAnalog);
    Servo1MittePWM = map(Servo1MitteAnalog, 0, 1023, Servo1MinPWM, Servo1MaxPWM);
    Serial.print("  Servo1 Mitte μs: ");
    Serial.println(Servo1MittePWM);
    Servo1.writeMicroseconds(Servo1MittePWM);

    if (EingangTaster.checkPress() == 1) {
      Serial.print("EEPROM Speicher Adresse: ");
      Serial.print(EEAdresse);
      Serial.print("  Wert Servo1 Mitte: ");
      Serial.println(Servo1MittePWM);
      EEPROM.put(EEAdresse, Servo1MittePWM);
      delay(100);
      EEAdresse += sizeof(word);
      Kalibrierung = 2;
      Serial.println("Kalibriere Servo1 Links");
    }

Alles anzeigen

Teil 2 wie oben.

Racker

Servo-Umpoler / Servo-Reverse

Hallo,

hier ist ein weiterer Sketch um mit der Platine "Die Gelbe" einen Servo-Umpoler / Servo-Reverse zu realisieren. Der Sketch ist sehr einfach und benötigt nur die Servo-Bibliothek. Da der Arduino nicht viel zu tun hat wird die Fuktion pulseIn() verwendet. Es ist keine Kalibrierung o.ä. nötig, daher werden Poti und Taster auch nicht benötigt.

Ein Pull-Down Widerstand an Port D3 ist empfohlen, dieser kann über das Widerstands-Netzwerk oder einen einzelnen Widerstand zwischen RN1 Masse und RN1 D3 realisiert werden.

Die min/max Werte für das Ausgangs-Signal können im Sketch eingestellt werden. Somit kann auch der (invertierte) Weg des Servo begrenzt werden.

Die LED auf dem Arduino Board sowie die (optionale) LED auf der Platine zeigt folgende Zustände an:

- LED blinkt wenn kein Signal empfangen wird

- LED leuchtet dauernd, wenn das Impuls-Signal am Eingang außerhalb der eingestellten Werte liegt

PWM Eingang: D3 (J4 Pin 1-3)

Hier kann eine 3-polige Stiftleiste eingesetzt werden, so daß der Empänger über ein normales Servo-Patchkabel angeschlossen werden kann. Wenn der Arduino über eine externe Spannung (5V) versorgt wird muß das rote Kabel aus dem Servo-Stecker gezogen werden!

Eine externe Spannungsversorgung (BEC) ist immer dann empfohlen, wenn das Servo einen hohen Strom zieht. Die Speisung der Platine erfolgt dann über J1 oder J4 und muß exakt 5V betragen.

PWM Ausgang: D9 (J2)

Anschluß für Servo oder Fahrregler.

C

// Servo Umpoler / Servo Reverse v1
// v1 Erste Version
// Für Arduino UNO und NANO
// Letzte Änderung 06.11.2021

// Min/Max Werte der Servo-Bibliothek: 544 / 2400 µs
// Min/Max Werte müssen symmetrisch sein, d.h. den gleichen Abstand zur Neutralstellung haben
// Beispiel wenn Neutral = 1500: OK min = 750, max = 2250; nicht OK min = 750, max = 2300

// Wenn kein Signal am Eingang anliegt blinkt die LED
// Wenn das Signal am Eingang außerhalb des Bereichs von PWMein_min bis PWMein_max liegt leuchtet die LED dauernd

// Unabhängig von der Einstellung PWMein_min/_max wird das Ausgangs-Signal immer auf PWMaus_min/_max skaliert

#include <Servo.h>                    // Servo Bibliothek

Servo Servo1;

word PWMein_min = 500;                // Untere Grenze des Eingang-Signals in µs (>=500 und <=1400, typ. 500-1000)
word PWMein_max = 2500;               // Obere Grenze des Eingang-Signals in µs (>=1600 und <=2500, typ. 2000-2500)
word PWMaus_min = 600;                // Untere Grenze des Ausgang-Signals in µs (>=600 und <=1400, typ. 600)
word PWMaus_max = 2400;               // Obere Grenze des Ausgang-Signals in µs (>=1600 und <=2400, typ. 2400)
word PWMaus = 1500;                   // Neutralstellung in µs
const byte PWMeingang = 3;            // Eingang# für Impuls-Signal vom Emfpänger
const int LED1 = LED_BUILTIN;         // Eingebaute LED (D13)

void setup() {

  Serial.begin(115200);               // Serielle Schnittstelle initializieren
  pinMode(PWMeingang, INPUT);         // Pin für Impuls-Signal vom Empfänger als Eingang definieren
  pinMode(LED1, OUTPUT);              // Pin für LED als Ausgang definieren

  Servo1.attach(9);                   // Servo1 an Pin X zuordnen (muß ein PWM-Pin sein)
  Servo1.writeMicroseconds(PWMaus);   // Servo1 auf Neutralstellung fahren
  delay(250);
}

void loop() {

  unsigned long PWMein = pulseIn(PWMeingang, HIGH);

  if (PWMein > 0) {

    digitalWrite(LED1, LOW);

    if ((PWMein >= PWMein_min) && (PWMein <= PWMein_max)) {

      PWMaus = map(PWMein, PWMein_min, PWMein_max, PWMaus_max, PWMaus_min);

      Servo1.writeMicroseconds(PWMaus);

      //      Serial.print("PWMein:   ");
      //      Serial.print(PWMein);
      //      Serial.print("...");
      //      Serial.print("PWMaus:   ");
      //      Serial.println(PWMaus);
      //      delay(50);
    }
    else {
      digitalWrite(LED1, HIGH);
    }
  }
  else {
    digitalWrite(LED1, HIGH);
    delay(250);
    digitalWrite(LED1, LOW);
    delay(250);
  }
}

Alles anzeigen

Racker

Servo-Wegbegrenzung

Hallo,

und noch ein Sketch um mit der Platine "Die Gelbe" eine einstellbare Servo-Wegbegrenzung zu realisieren. Die Einstellung erfolgt durch eine Kalibrierungs-Routine mit nur 2 Stufen, für den linken und rechten Endpunkt.

Poti und Taster werden zur Kalibrierung benötigt. Der Taster muß länger als 750ms gedrückt werden um die Kalibrierung zu starten, zum nächsten Schritt zu springen bzw. die Kalibrierung zu beenden. Das Ende wird durch ein Leuchten der LED für 2 Sekunden angezeigt. Wie oben kann die Kalibirierung bei Bedarf im Serial Monitor verfolgt werden. Die eingestellten Werte werden im EEPROM gespeichert.

Die min/max Werte für das Ausgangs-Signal können im Sketch eingestellt werden und werden bei der Kalibrierung berücksichtigt.

Da der Arduino nicht viel zu tun hat wird die Fuktion pulseIn() verwendet.

Ein Pull-Down Widerstand an Port D3 ist empfohlen, dieser kann über das Widerstands-Netzwerk oder einen einzelnen Widerstand zwischen RN1 Masse und RN1 D3 realisiert werden.

Die LED auf dem Arduino Board sowie die (optionale) LED auf der Platine zeigt folgende Zustände an:

- LED blinkt wenn kein Signal empfangen wird

- LED leuchtet dauernd, wenn das Impuls-Signal am Eingang außerhalb der eingestellten Werte liegt

- Während der Kalibrierung blinkt die LED entsprechend der Stufe (Stufe 1 - links: 1x, Stufe 2 - rechts: 2x)

- Am Ende der Kalibrierung leuchtet die LED für 2 Sekunden

PWM Eingang: D3 (J4 Pin 1-3)

Hier kann eine 3-polige Stiftleiste eingesetzt werden, so daß der Empänger über ein normales Servo-Patchkabel angeschlossen werden kann. Wenn der Arduino über eine externe Spannung (5V) versorgt wird muß das rote Kabel aus dem Servo-Stecker gezogen werden!

Eine externe Spannungsversorgung (BEC) ist immer dann empfohlen, wenn das Servo einen hohen Strom zieht. Die Speisung der Platine erfolgt dann über J1 oder J4 und muß exakt 5V betragen.

PWM Ausgang: D9 (J2)

Anschluß für Servo oder Fahrregler.

Benötigte Bibliotheken:

Button.h - Button-Arduino 2.0.0 by Davide Palladino

Servo.h - in Arduino IDE enthalten

EEPROM.h - in Arduino IDE enthalten

C

// Einstellbare Servo Wegbegrenzung über Poti v1
// v1 Erste Version
// Für Arduino UNO und NANO
// Letzte Änderung 06.11.2021

// Min/Max Werte der Servo-Bibliothek: 544 / 2400 µs

// Wenn kein Impuls-Signal am Eingang anliegt blinkt die LED
// Wenn das Impuls-Signal am Eingang außerhalb der Endpunkte liegt leuchtet die LED dauernd
// Während der Endpunkt-Einstellung blinkt die LED entsprechend der Stufe (Stufe 1 - links: 1x, Stufe 2 - rechts: 2x)

#include <Button.h>                         // Bibliothek für Taster (benötigt mindestens Version 2.0.0)
#include <Servo.h>                          // Bibliothek für Servo
#include <EEPROM.h>                         // Bibliothek für EEPROM

Button EingangTaster(2, B_PULLUP, 750);     // Digitaler Eingang für Taster zum Aufruf der Kalibrierung

Servo Servo1;

const int PWMaus_min = 544;                 // Min. untere Impulslänge für Servo1 bei Drehung Links (>= 544 und < 1400)
const int PWMaus_max = 2400;                // Max. obere Impulslänge für Servo1 bei Drehung Rechts (> 1600 und <= 2400)
const int LED1 = LED_BUILTIN;               // Interne LED an D13

word Zeitinterval = 500;                    // Zeitinterval für LED Blinken in ms (0 bis 65535)

word Servo1LinksAnalog = 512;               // Analoger Wert für Servo1 Drehung Links  (>= 0 und <= 1023)
word Servo1RechtsAnalog = 512;              // Analoger Wert für Servo1 Drehung Rechts (>= 0 und <= 1023)
word Servo1LinksPWM = 1500;                 // Endpunkt für Servo1 Drehung Links  (>= Servo1MinPWM und <= 1500)
word Servo1RechtsPWM = 1500;                // Endpunkt für Servo1 Drehung Rechts (>= 1500 und <= Servo1MaxPWM)

byte Kalibrierung = 0;                      // Zähler für Kalibrierungs-Stufe
byte EEAdresse = 0;                         // Erste Speicher-Addresse für EEPROM
byte Zaehler = 0;                           // Zähler für LEDblink

const byte PWMeingang = 3;                  // Eingang# für Impuls-Signal
const byte EingangPotiKalibrierung = A7;    // Analoger Eingang für Poti zur Einstellung der Servo Endpunkte

unsigned long vorherigeZeitBlinken = 0;     // Vorherige Zeit für LEDblink()

void setup() {

  Serial.begin(115200);                     // Serielle Schnittstelle initializieren
  pinMode(PWMeingang, INPUT);               // Pin für Signal vom Empfänger als Eingang definieren
  pinMode(LED1, OUTPUT);                    // Pin für LED1 als Ausgang definieren
  digitalWrite(LED1, LOW);                  // LED1 ausschalten

  // EEPROM Werte auslesen und an den Serial Monitor schicken:

  Servo1LinksPWM = EEPROM.get(EEAdresse, Servo1LinksPWM);
  EEAdresse += sizeof(word);
  Servo1RechtsPWM = EEPROM.get(EEAdresse, Servo1RechtsPWM);
  EEAdresse += sizeof(word);
  EEAdresse = 0;

  Serial.print("EEPROM Wert Servo1 Endpunkt Links: ");
  Serial.println(Servo1LinksPWM, DEC);
  Serial.print("EEPROM Wert Servo1 Endpunkt Rechts: ");
  Serial.println(Servo1RechtsPWM, DEC);
  delay(250);

  Servo1.attach(9);                           // Servo1 an Pin X zuordnen (muß ein PWM-Pin sein)
  delay(250);
}

void loop() {

  if (EingangTaster.checkPress() == -1) {
    delay(500);
    Serial.println("Kalibrierung gestartet");
    calibrate();
  }

  unsigned long PWMein = pulseIn(PWMeingang, HIGH);

  if (PWMein > 0) {

    digitalWrite(LED1, LOW);

    if ((PWMein >= Servo1LinksPWM) && (PWMein <= Servo1RechtsPWM)) {

      Servo1.writeMicroseconds(PWMein);
      //      Serial.print("PWMein:   ");
      //      Serial.println(PWMein);
      //      delay(50);
    }
    else if (PWMein < Servo1LinksPWM) {
      Servo1.writeMicroseconds(Servo1LinksPWM);
      digitalWrite(LED1, HIGH);
    }
    else if (PWMein > Servo1RechtsPWM) {
      Servo1.writeMicroseconds(Servo1RechtsPWM);
      digitalWrite(LED1, HIGH);
    }
  }
  else {
    digitalWrite(LED1, HIGH);
    delay(250);
    digitalWrite(LED1, LOW);
    delay(250);
  }
}

void calibrate() {

  Kalibrierung = 1;
  Serial.println("Kalibriere Endpunkt Servo1 Links");

  while (Kalibrierung == 1) {
    LEDblink();

    Servo1LinksAnalog = analogRead(EingangPotiKalibrierung);
    Serial.print("Poti Links analog: ");
    Serial.print(Servo1LinksAnalog);
    Servo1LinksPWM = map(Servo1LinksAnalog, 0, 1023, PWMaus_max, PWMaus_min);
    Serial.print("  Servo1 Endpunkt Links μs: ");
    Serial.println(Servo1LinksPWM);
    Servo1.writeMicroseconds(Servo1LinksPWM);

    if (EingangTaster.checkPress() == -1) {
      Serial.print("EEPROM Speicher Adresse: ");
      Serial.print(EEAdresse);
      Serial.print("  Wert Servo1 Endpunkt Links: ");
      Serial.println(Servo1LinksPWM);
      EEPROM.put(EEAdresse, Servo1LinksPWM);
      delay(100);
      EEAdresse += sizeof(word);
      Kalibrierung = 2;
      Serial.println("Kalibriere Endpunkt Servo1 Rechts");
    }

    while (Kalibrierung == 2) {
      LEDblink();

      Servo1RechtsAnalog = analogRead(EingangPotiKalibrierung);
      Serial.print("Poti Rechts analog: ");
      Serial.print(Servo1RechtsAnalog);
      Servo1RechtsPWM = map(Servo1RechtsAnalog, 0, 1023, PWMaus_max, PWMaus_min);
      Serial.print("  Servo1 Endpunkt Rechts μs: ");
      Serial.println(Servo1RechtsPWM);
      Servo1.writeMicroseconds(Servo1RechtsPWM);

      if (EingangTaster.checkPress() == -1) {
        Serial.print("EEPROM Speicher Adresse: ");
        Serial.print(EEAdresse);
        Serial.print("  Wert Servo1 Endpunkt Rechts: ");
        Serial.println(Servo1RechtsPWM);
        EEPROM.put(EEAdresse, Servo1RechtsPWM);
        delay(100);
        EEAdresse = 0;
        Kalibrierung = 0;
        Serial.println("Kalibrierung beendet ... ");
        digitalWrite(LED1, HIGH);
        delay(2000);
        digitalWrite(LED1, LOW);
        Serial.println("Starte Programm ...");
        return;
      }
    }
  }
}

void LEDblink() {

  unsigned long aktuelleZeit = millis();

  if (aktuelleZeit - vorherigeZeitBlinken >= Zeitinterval) {
    digitalWrite(LED1, HIGH);

    if (Zaehler < Kalibrierung) {
      vorherigeZeitBlinken = aktuelleZeit;
      Zeitinterval = 500;
      Zaehler++;

    } else {
      Zaehler = 1;
      vorherigeZeitBlinken = aktuelleZeit;

      if (Kalibrierung == 1) {
        return;
      }

      Zeitinterval = Zeitinterval + 500;
    }
  } else {
    digitalWrite(LED1, LOW);
  }
  return;
}

Alles anzeigen

Racker

Servo-Expander / Servo-Stretcher

Hallo,

und zu guter Letzt noch ein Sketch um mit der Platine "Die Gelbe" einen Servo-Expander / Servo-Stretcher zu realisieren. Der Sketch ist relativ einfach, berücksichtigt aber auch die unsymmetrische Aufteilung zwischen oberen (1500 bis 2400) und unteren (544-1500) Bereich für das Impuls-Signal am Ausgang. Benötigt nur die Servo-Bibliothek.

Da der Arduino nicht viel zu tun hat wird die Fuktion pulseIn() verwendet. Es ist keine Kalibrierung o.ä. nötig, daher werden Poti und Taster auch nicht benötigt.

Ein Pull-Down Widerstand an Port D3 ist empfohlen, dieser kann über das Widerstands-Netzwerk oder einen einzelnen Widerstand zwischen RN1 Masse und RN1 D3 realisiert werden.

Die min/max Werte für das Eingangs- und Ausgangs-Signal können im Sketch eingestellt werden.

Die LED auf dem Arduino Board sowie die (optionale) LED auf der Platine zeigt folgende Zustände an:

- LED blinkt wenn kein Signal empfangen wird

- LED leuchtet dauernd, wenn das Impuls-Signal am Eingang außerhalb der eingestellten min/max Werte liegt (in dem Fall wird der entsprechende min oder max Wert für das Ausgangs-Signal ausgegeben)

PWM Eingang: D3 (J4 Pin 1-3)

Hier kann eine 3-polige Stiftleiste eingesetzt werden, so daß der Empänger über ein normales Servo-Patchkabel angeschlossen werden kann. Wenn der Arduino über eine externe Spannung (5V) versorgt wird muß das rote Kabel aus dem Servo-Stecker gezogen werden!

Eine externe Spannungsversorgung (BEC) ist immer dann empfohlen, wenn das Servo einen hohen Strom zieht. Die Speisung der Platine erfolgt dann über J1 oder J4 und muß exakt 5V betragen.

PWM Ausgang: D9 (J2)

Anschluß für Servo oder Fahrregler.

C

// Servo Expander / Servo Stretcher v1
// v1 Erste Version
// Für Arduino UNO und NANO
// Letzte Änderung 06.11.2021

// Min/Max Werte der Servo-Bibliothek: 544 / 2400 µs

// Wenn kein Signal am Eingang anliegt blinkt die LED
// Wenn das Signal am Eingang außerhalb des Bereichs von PWMein_min/_max liegt leuchtet die LED dauernd

// Unabhängig von der Einstellung PWMein_min/_max wird das Ausgangs-Signal immer auf PWMaus_min/_max skaliert

#include <Servo.h>                    // Servo Bibliothek

Servo Servo1;

word PWMneu = 1500;                   // Neutralstellung in µs
word PWMein_min = 1000;               // Untere Grenze des Eingang-Signals in µs (>=500 und <=1400, typ. 1000)
word PWMein_max = 2000;               // Obere Grenze des Eingang-Signals in µs (>=1600 und <=2500, typ. 2000)
word PWMaus_min = 544;                // Untere Grenze des Ausgang-Signals in µs (>=544 und <=1400, typ. 544)
word PWMaus_max = 2400;               // Obere Grenze des Ausgang-Signals in µs (>=1600 und <=2400, typ. 2400)
word PWMaus;                          // Variable für Ausgangs-Signal

const byte PWMeingang = 3;            // Eingang# für Impuls-Signal vom Emfpänger
const int LED1 = LED_BUILTIN;         // Eingebaute LED (D13)

void setup() {

  Serial.begin(115200);               // Serielle Schnittstelle initializieren
  pinMode(PWMeingang, INPUT);         // Pin für Impuls-Signal vom Empfänger als Eingang definieren
  pinMode(LED1, OUTPUT);              // Pin für LED als Ausgang definieren

  Servo1.attach(9);                   // Servo1 an Pin X zuordnen (muß ein PWM-Pin sein)
  Servo1.writeMicroseconds(PWMaus);   // Servo1 auf Neutralstellung fahren
  delay(250);
}

void loop() {

  unsigned long PWMein = pulseIn(PWMeingang, HIGH);

  if (PWMein > 0) {

    digitalWrite(LED1, LOW);

    if (PWMein == PWMneu) {

      PWMaus = PWMneu;

      Servo1.writeMicroseconds(PWMaus);
    }

    if ((PWMein > PWMneu) && (PWMein <= PWMein_max)) {

      PWMaus = map(PWMein, PWMneu, PWMein_max, PWMneu, PWMaus_max);

      Servo1.writeMicroseconds(PWMaus);
    }

    if ((PWMein >= PWMein_min) && (PWMein < PWMneu)) {

      PWMaus = map(PWMein, PWMein_min, PWMneu, PWMaus_min, PWMneu);

      Servo1.writeMicroseconds(PWMaus);
    }

    else if (PWMein < PWMein_min) {
      Servo1.writeMicroseconds(PWMaus_min);
      digitalWrite(LED1, HIGH);
    }

    else if (PWMein > PWMein_max) {
      Servo1.writeMicroseconds(PWMaus_max);
      digitalWrite(LED1, HIGH);
    }
  }

  else {
    digitalWrite(LED1, HIGH);
    delay(250);
    digitalWrite(LED1, LOW);
    delay(250);
  }
}

Alles anzeigen

Racker

Dual-Rate (DR)

Hallo,

ich hatte mal wieder Langeweile und habe eine Dual-Rate Funktion programmiert. Dual-Rate (DR) skaliert das Signal von 100-0%, so daß der Servoweg eingeschränkt werden kann. DR unterscheidet sich von der Servowegbegrenzung dadurch, das es keinen "harten Stop" gibt sondern der Geber wie Knüppel, Poti oder Schieberegler immer über den ganzen Weg genutzt wird.

Der Sketch akzeptiert ein Eingangs-Signal mit einer Impulsbreite von 500-2500µs und gibt maximal 600-2400µs aus. Über das Poti kann das Ausgangs-Signal stufenlos (naja, mit einer Auflösung von 1998 Stufen) von 100-0% skaliert werden. Linker Anschlag entspricht 100%, d.h. das Ausgangs-Signal entspricht dem Eingangs-Signal zwischen 600-2400µs, und rechter Anschlag 0%, in dem Fall ist das Ausgangs-Signal immer 1500µs.

Zusätzlich wurde noch ein Toleranzbereich (+/- 20µs) für die Neutralstellung eingebaut, der Wert kann im Sketch unter PWMneu_tol geändert werden.

Änderungen über das Poti sind sofort wirksam, können also jederzeit im laufenden Betrieb geändert werden. Ist das nicht erwünscht einfach die folgende Zeile in den setup() Teil schieben:

Code

AnalogerWert = analogRead(PotiEingang);

Änderungen der Poti-Einstellungen erfordern dann einen Reset des Arduinos um wirksam zu werden.

Da der Arduino nicht viel zu tun hat wird die Fuktion pulseIn() verwendet. Es ist keine Kalibrierung nötig, aber die DR Skalierung wird direkt über das Poti eingestellt. Benötigt wird nur die Servo-Bibliothek.

Die min/max Werte für das Eingangs- und Ausgangs-Signal können im Sketch eingestellt werden. Änderungen sollten aber nur vorgenommen werden, wenn man weis was man tut. U.U. funktionieren die Berechnungen dann nicht mehr.

Im Serial Monitor der Arduino IDE können einige Werte nachverfolgt werden. Sie sind z.Zt. ausgeklammert, können aber z.B. zur Fehlersuche aktiviert werden, in dem man die „//“ Zeichen vor den Serial.print(ln) Zeilen entfernt. Die Zeilen können auch gelöscht werden, wenn man sie nicht benötigt.

Ein Pull-Down Widerstand an Port D3 ist empfohlen, dieser kann über das Widerstands-Netzwerk oder einen einzelnen Widerstand zwischen RN1 Masse und RN1 D3 realisiert werden.

Die LED auf dem Arduino Board sowie die (optionale) LED auf der Platine zeigt folgende Zustände an:

- LED blinkt wenn kein Signal empfangen wird

- LED leuchtet dauernd, wenn das Impuls-Signal am Eingang außerhalb der eingestellten min/max Werte liegt (in dem Fall wird der entsprechende min oder max Wert für das Ausgangs-Signal ausgegeben)

PWM Eingang: D3 (J4 Pin 1-3)

Hier kann eine 3-polige Stiftleiste eingesetzt werden, so daß der Empänger über ein normales Servo-Patchkabel angeschlossen werden kann. Wenn der Arduino über eine externe Spannung (5V) versorgt wird muß das rote Kabel aus dem Servo-Stecker gezogen werden!

Eine externe Spannungsversorgung (BEC) ist immer dann empfohlen, wenn das Servo einen hohen Strom zieht. Die Speisung der Platine erfolgt dann über J1 oder J4 und muß exakt 5V betragen.

PWM Ausgang: D9 (J2)

Anschluß für Servo oder Fahrregler.

C

// Servo Dual-Rate v1
// v1 Erste Version
// Für Arduino UNO und NANO
// Letzte Änderung 13.11.2021

// Min/Max Werte der Servo-Bibliothek: 544 / 2400 µs

// Wenn kein Signal am Eingang anliegt blinkt die LED
// Wenn das Signal am Eingang außerhalb des Bereichs von PWMein_min/_max liegt leuchtet die LED dauernd

#include <Servo.h>                    // Servo Bibliothek

Servo Servo1;

const byte PWMeingang = 3;            // Eingang für Impuls-Signal vom Emfpänger
const byte PotiEingang = A7;          // Eingang für Potentiometer
const int LED1 = LED_BUILTIN;         // Eingebaute LED (D13)

// Folgende Werte nur ändern wenn man wirklich weis was man tut!

const word PWMneu = 1500;             // Neutralstellung in µs (typ. 1500)
const word PWMneu_tol = 20;           // Toleranz-Wert für Neutralstellung +/- in µs (typ. 20)
const word PWMein_min = 500;          // Untere Grenze des Eingang-Signals in µs (>=500 und <=1400, typ. 500)
const word PWMein_max = 2500;         // Obere Grenze des Eingang-Signals in µs (>=1600 und <=2500, typ. 2500)
const word PWMaus_min = 600;          // Untere Grenze des Ausgang-Signals in µs (>=544 und <=1400, typ. 600)
const word PWMaus_max = 2400;         // Obere Grenze des Ausgang-Signals in µs (>=1600 und <=2400, typ. 2400)
const word DualRateWert = 1000;       // Wert für Dual-Rate Kalkulation (typ. 1000)

word AnalogerWert;                    // Variable für Potentiometer-Stellung
word PWMaus;                          // Variable für PWM Ausgangs-Signal
word PWMsk1 = 0;                      // Variable für PWM Wert zur Skalierung (Eingangssignal < PWMneu)
word PWMsk2 = 0;                      // Variable für PWM Wert zur Skalierung (Eingangssignal > PWMneu)

float Wert1 = 0;                      // Ergebnis aus map()-Funktion
float Wert2 = 0;                      // Zwischenergebnis zur Berechnung der Skalierung

void setup() {

  Serial.begin(115200);               // Serielle Schnittstelle initializieren
  pinMode(PWMeingang, INPUT);         // Pin für Impuls-Signal vom Empfänger als Eingang definieren
  pinMode(LED1, OUTPUT);              // Pin für LED als Ausgang definieren

  Servo1.attach(9);                   // Servo1 an Pin X zuordnen (muß ein PWM-Pin sein)
  Servo1.writeMicroseconds(PWMneu);   // Servo1 auf Neutralstellung fahren
  delay(250);
}

void loop() {

  unsigned long PWMein = pulseIn(PWMeingang, HIGH);

//   Serial.print("PWM Ein:  ");
//   Serial.print(PWMein);

  if (PWMein > 0) {

    digitalWrite(LED1, LOW);

    AnalogerWert = analogRead(PotiEingang);

 //    Serial.print("   Analoger Wert:  ");
 //    Serial.print(AnalogerWert);

    Wert1 = map(AnalogerWert, 1023, 0, 1, DualRateWert);

    if ((PWMein >= PWMein_min) && (PWMein < PWMneu - PWMneu_tol)) {

      Wert2 = PWMaus_min + ((PWMneu - PWMaus_min) / (DualRateWert / Wert1));

      PWMsk1 = abs(Wert2);

      PWMaus = map(PWMein, PWMaus_min, PWMneu, PWMsk1, PWMneu);

//      Serial.print(".... PWM:  ");
//      Serial.println(PWMaus);

      Servo1.writeMicroseconds(PWMaus);
    }

    if ((PWMein >= PWMneu + PWMneu_tol) && (PWMein < PWMein_max)) {

      Wert2 = PWMaus_max - ((PWMaus_max - PWMneu) / (DualRateWert / Wert1));

      PWMsk2 = abs(Wert2);

      PWMaus = map(PWMein, PWMneu, PWMaus_max, PWMneu, PWMsk2);

//      Serial.print(".... PWM:  ");
//      Serial.println(PWMaus);

      Servo1.writeMicroseconds(PWMaus);
    }

    else if ((PWMein >= PWMneu - PWMneu_tol) && (PWMein <= PWMneu + PWMneu_tol)) {
      Servo1.writeMicroseconds(PWMneu);

//      Serial.print("... PWM Neutral-Wert: ");
//      Serial.println(PWMneu);
    }

    else if (PWMein < PWMein_min) {
      Servo1.writeMicroseconds(PWMsk1);
      digitalWrite(LED1, HIGH);

//      Serial.print("... PWM Skalierungs-Wert 1: ");
//      Serial.println(PWMsk1);
    }

    else  if (PWMein > PWMein_max) {
      Servo1.writeMicroseconds(PWMsk2);
      digitalWrite(LED1, HIGH);

//      Serial.print("... PWM Skalierungs-Wert 2: ");
//     Serial.println(PWMsk2);
    }
  }

  else {
    digitalWrite(LED1, HIGH);
    delay(250);
    digitalWrite(LED1, LOW);
    delay(250);
  }
}

Alles anzeigen

Racker

Hallo,

ich habe ein Problem mit der "Button.h" Bibliothek gefunden, bei der neuen Version 2.0.0 funktioniert das Beenden der Kalibrierungs-Routine durch den langen Tastendruck nicht mehr. Daher bitte nur Version 1.2.1 installieren. Die folgende Zeile

Code

Button EingangTaster(12, B_PULLUP, 750);

muß daher auf

Code

Button EingangTaster(12, PULLUP, 750);

geändert werden.

Ich kann dies leider oben nicht mehr korrigieren, daher bitte beachten.

Racker

Oh Mist, auch noch ein Fehler im letzten Beitrag den ich jetzt nicht mehr editieren kann:

Code

Button EingangTaster(2, B_PULLUP, 750);

ändern nach

Code

Button EingangTaster(2, PULLUP, 750);

Dazu "Button-Arduino" Bibliothek Version 1.2.1 installieren, nicht auf Version 2.0.0 updaten!

Racker

Servo Slower / Servo Delay

Hallo,

das hat uns noch gefehlt .... jetzt gibt es endlich auch einen Servo Slower aka Servo Delay!

Der Sketch akzeptiert ein Eingangs-Signal mit einer Impulsbreite von 500-2500µs und gibt maximal 544-2400µs aus. Der Sketch verlangsamt die Servo-Bewegung, in dem zwischen jedem Schritt eine Verzögerung eingefügt wird. Über das Poti kann die Verzögerung eingestellt werden, die Änderungen sind sofort wirksam, können also jederzeit im laufenden Betrieb angepasst werden.

Die Verzögerung kann über eine Änderung im Sketch in µs oder ms erfolgen; ist eine Verzögerung in ms gewählt sind somit auch sehr langsame Bewegungen möglich.

Die Werte für 'minimale Verzögerung' und 'maximale Verzögerung' in µs oder ms können im Sketch ebenfalls eingestellt werden. Sehr hohe Werte (über 10000) machen wenig Sinn, da die Auflösung des analogen Eingangs nur 1024 Einheiten beträgt, statt dessen sollte dann besser die Verzögerung von µs auf ms umgestellt und der Wert für die 'maximale Verzögerung' entsprechend angepasst werden.

Der Sketch nutzt statt der Funktion pulseIn() den Hardware-Interrupt von Pin D3 zum Berechnen des PWM Signals. Es wird auch kein delay() für die Verzögerung genutzt, statt dessen wird diese über die Funktionen micros() bzw. millis() berechnet (s.o.). Dadurch ist der Sketch blockierungsfrei aka non-blocking.

Ein Pull-Down Widerstand an Port D3 für den PWM Eingang ist empfohlen, dieser kann über das Widerstands-Netzwerk oder einen einzelnen Widerstand zwischen RN1 Masse und RN1 D3 realisiert werden.

Die LED auf dem Arduino Board sowie die (optionale) LED auf der Platine blinkt wenn beim Einschalten kein PWM Signal empfangen wird. Sobald ein PWM Signal empfangen wurde erlischt die LED und bleibt auch aus, wenn danach kein PWM Signal mehr empfangen wird.

PWM Eingang: D3 (J4 Pin 1-3)

Hier kann eine 3-polige Stiftleiste eingesetzt werden, so daß der Empänger über ein normales Servo-Patchkabel angeschlossen werden kann. Wenn der Arduino über eine externe Spannung (5V) versorgt wird muß das rote Kabel aus dem Servo-Stecker gezogen werden!

Eine externe Spannungsversorgung (BEC) ist immer dann empfohlen, wenn das Servo einen hohen Strom zieht. Die Speisung der Platine erfolgt dann über J1 oder J4 und muß exakt 5V betragen.

PWM Ausgang: D9 (J2)

Anschluß für Servo oder Fahrregler.

C

// Servo Delay / Servo Slower v1
// v1 Erste Version
// Letzte Änderung 02.02.2022

// Min/Max Werte der Servo-Bibliothek: 544 / 2400 µs

// Wenn beim Einschalten kein PWM Signal am Eingang anliegt blinkt die LED

#include <Servo.h>                    // Servo Bibliothek

Servo Servo1;

byte Richtung = 0;                    // Variabel für Berechnung der neuen Servo-Position (1 = +, 2 = -)

const byte PWMeingang = 3;            // Eingang für Impuls-Signal vom Emfpänger (Pulldown Widerstand empfohlen)
const byte PotiEingang = A7;          // Eingang für Potentiometer
const int LED1 = LED_BUILTIN;         // Eingebaute LED (D13)

word minimaleVerzoegerung = 0;        // Wert für minimale Verzögerung zwischen den Schritten vom Servo (typ. 0)
word maximaleVerzoegerung = 10000;    // Wert für maximale Verzögerung zwischen den Schritten vom Servo (typ. 10000)

// Der Wert für minimale und maximale Verzögerung ist in µs oder ms, abhängig davon ob
// die Funktion micros() oder millis() in der Funktion 'Verzoegerung()' genutzt wird !

// Folgende Werte nur ändern wenn man weis was man tut!

word aktuellePosition = 1500;         // Wert für aktuelle Servo Position in µs (typ. 1500)

const word PWMein_min = 500;          // Untere Grenze des Eingang-Signals in µs (>=500 und <=1400, typ. 500)
const word PWMein_max = 2500;         // Obere Grenze des Eingang-Signals in µs (>=1600 und <=2500, typ. 2500)

unsigned long analogerWert;           // Analoger Wert der Potentiometer-Stellung = Verzoegerung in ms pro Schritt
unsigned long vorherigeZeit1 = 0;     // Vorherige Zeit zur Prüfung der Servobewegung in µs oder ms

volatile int PWMein = 0;              // Wert für berechnetes PWM Signal in µs
volatile int vorherigeZeit2 = 0;      // Vorherige Zeit zur Berechnung des PWM Signals in µs

void setup() {

  // Hardware Interrupt für Pin 'PWMEingang'
  EIFR = 1;
  attachInterrupt(digitalPinToInterrupt(PWMeingang), rising, RISING);

  Serial.begin(115200);                           // Serielle Schnittstelle initializieren
  pinMode(PWMeingang, INPUT);                     // Pin für Impuls-Signal vom Empfänger als Eingang definieren
  pinMode(LED1, OUTPUT);                          // Pin für LED als Ausgang definieren

  Servo1.attach(9);                               // Servo1 mit Pin X verbinden
  Servo1.writeMicroseconds(aktuellePosition);     // Servo1 auf Position fahren
  delay(250);
}

void loop() {

  analogerWert = analogRead(PotiEingang);
  analogerWert = map(analogerWert, 0, 1024, maximaleVerzoegerung, minimaleVerzoegerung);

  if (PWMein > 0) {

    if (PWMein < PWMein_min) {
      PWMein = PWMein_min;
    }

    else if (PWMein > PWMein_max) {
      PWMein = PWMein_max;
    }

    if (PWMein >= PWMein_min && PWMein <= PWMein_max) {

      digitalWrite(LED1, LOW);

      if (PWMein > aktuellePosition) {
        Richtung = 1;
        Verzoegerung();
      }

      else if (PWMein < aktuellePosition) {
        Richtung = 2;
        Verzoegerung();
      }
    }
  }

  else {
    digitalWrite(LED1, HIGH);
    delay(250);
    digitalWrite(LED1, LOW);
    delay(250);
  }
}

void Verzoegerung() {

  //  unsigned long aktuelleZeit = millis();  // Verzögerung noch langsamer wenn millis() statt micros()
  
  unsigned long aktuelleZeit = micros();      // wenn millis() gewählt Wert für 'maximaleVerzoegerung' anpassen

  if (aktuelleZeit - vorherigeZeit1 > analogerWert) {
    if (Richtung == 1) {
      Servo1.writeMicroseconds(aktuellePosition);
      vorherigeZeit1 = aktuelleZeit;
      aktuellePosition++;
    }

    if (Richtung == 2) {
      Servo1.writeMicroseconds(aktuellePosition);
      vorherigeZeit1 = aktuelleZeit;
      aktuellePosition--;
    }
  }

  else {
    //    Zeit läuft noch
  }
}

void rising() {
  attachInterrupt(digitalPinToInterrupt(PWMeingang), falling, FALLING);
  vorherigeZeit2 = micros();
}

void falling() {
  attachInterrupt(digitalPinToInterrupt(PWMeingang), rising, RISING);
  PWMein = micros() - vorherigeZeit2;
}

Alles anzeigen

Als nächstes kommt dann der Servo Beschleuniger.

Sketch für Platine "Die Gelbe" für Arduino NANO oder UNO

Jetzt mitmachen!

Tags