Hallo,
ich habe nun weiter meinen Code getestet und entschlackt.
Auch bei einer Basisroutine: Servosignale über die Lib RC Receiver von rcarduino.tk einlesen und dieser wieder über die Standard Servo-Lib ausgeben gibt es manchmal erratische lange Verzögerungen.
Ich rühre mit einem Poti meines Servotesters herum, und die Servos funktionieren erstmal auch prima. Plötzlich steht die ganze Kiste für eine halbe bis zu 10 Sekunden, und nimmt dann erst den neuen Wert an.
Das Signal des Servotesters (ein anderer Arduino) habe ich mit einem Oszi überprüft, das ist OK. Das Signal an die Servos habe ich auch mit dem Oszi geprüft, es entspricht auch dem, was ich erfahre: Zuweilen Stillstand, es scheint also kein Problem der Servo(Strom&Signal)versorgung zu sein.
Ich habe alles andere aus meinem Code herausgeworfen, also nix mehr mit I2C Bus, LCD oder 10DOF Treiber aus dem ursprünglichem Projekt.
Falls da noch ungenutzte Variablen deklariert sein sollten, dann liegt es daran, daß ich hier ein Excerpt aus einem größeren Code mit PID Regler, LCD, Gyrosensor etc. erstellte, um auf des Pudels Kern zu kommen.
Das zwischenzeitliche Ummappen der Servowerte auf +/- 2^10-1 ist Absicht, um Rundungsfehler einer geplanten weiteren Berechnung mit PID Regler etc. zu minimieren.
/*
Testroutine, reicht einfach Servosignale die über die Bibliothek RCReceiver empfangen wurden an die
Standard Arduino Servo-Bibliothek weiter.
Zwischendurch Mapping der Servowerte 0 bis 255 der RC Receiver Lib auf -1023 bis +1023, um bei späteren Berechnungen
mit einem PID Regler Spielraum ohne zuviele Rundungsfehler zu haben.
Am Ende Mapping der Servosignale auf die 0 bis 180 Grad der Servo Lib.
*/
#include <Servo.h>
#include "makros.h"
#include "debug.h"
#include "RCReceive.h"
//---------- SERVO----------------------
Servo myservo1; // create servo object to control a servo
Servo myservo2; // create servo object to control a servo
#define ServoSignalAusgang1 9 // Das Signal für den Ausgangsservo 1
#define ServoSignalAusgang2 10 // Das Signal für den Ausgangsservo 2
int ServoWert1 = 0; // variable to store the value coming from the sensor
int ServoWert2 = 0; // variable to store the value coming from the sensor
// ********************** Code für das Auslesen des RC-Signals *****************************
// Code aus http://www.rcarduino.tk/
RCReceive rcReceiver1; // Der Empfänger: QR-Signal
RCReceive rcReceiver2; // Der Empfänger: Schaltkanal
boolean KeinRCSignal1 = true;
boolean KeinRCSignal2 = true;
byte Servovalue1;
byte Servovalue2;
boolean QR_Stabi_AN = false;
#define RC_QR 2 //arduino pins attached to the receiver Die Interrupts gehen nur für Pin 2 und 3
#define RC_SCHALT 3
void setup() // #################### SETUP ##################################################
{
myservo1.attach(ServoSignalAusgang1); // attaches the servo on pin 9 to the servo object 1
myservo2.attach(ServoSignalAusgang2); // attaches the servo on pin 10 to the servo object 2
pinMode(RC_QR, INPUT); //Querruder-Signal
pinMode(RC_SCHALT, INPUT); // Das Schaltsignal, daß mal die PID-Regelung ausschalten soll
// ********************** Code für das Auslesen des RC-Signals *****************************
// Für die Signalanalyse via Interrupts, geht nur an Pin 2 und 3
rcReceiver1.attachInt(RC_QR);
rcReceiver2.attachInt(RC_SCHALT);
}
void loop() // #################### LOOP ##################################################
{
// ********************** Code für das Auslesen des RC-Signals über Interrupts *****************************
if (rcReceiver1.hasNP() && !rcReceiver1.hasError())
{
Servovalue1 = rcReceiver1.getValue(); //Es werden Werte von 0 bis 255 ausgegeben
KeinRCSignal1 = false;
}
else if (rcReceiver1.hasError()) {
KeinRCSignal1 = true;// Fehlerbehandlung failsafe oder sowas...
Servovalue1 = 0; // Failsafe: Neutralstellung
}
// ******************** Ende Auslesen RC-Signal für das QR***********************************
if (KeinRCSignal1 == false) //nur dann ist es ein gültiger Wert
{
ServoWert1 = constrain(map(Servovalue1, 0, 255, -1023, +1023), -1023, +1023);
}
// ************************* Der Schaltkanal wird abgefragt
if (rcReceiver2.hasNP() && !rcReceiver2.hasError())
{
Servovalue2 = rcReceiver2.getValue(); //Es werden Werte von 0 bis 255 ausgegeben
KeinRCSignal2 = false;
}
else if (rcReceiver2.hasError()) {
KeinRCSignal2 = true;// Fehlerbehandlung failsafe oder sowas...
Servovalue2 = 0; // Failsafe: Neutralstellung
}
// ******************** Ende Auslesen RC-Signal ***********************************
if (KeinRCSignal2 == false) //nur dann ist es ein gültiger Wert
{
ServoWert2 = constrain(map(Servovalue2, 0, 255, -1023, 1023), -1023, 1023);
// Wertebereich zwischen -1023 und +1023, Mittenwert ist 0, das wäre dann Setpoint Null
}
myservo1.write(map(ServoWert1, -1023, +1023, 160, 20)); // Durchreichen der erfassten Servosignale vom Empfänger
myservo2.write(map(ServoWert1, -1023, +1023, 160, 20)); // Durchreichen der erfassten Servosignale vom Empfänger
}
Hat da irgendjemand (Willie1968 ?) noch eine Idee ? Bzgl. der Signalauslesung habe ich mich ja ziemlich an die Beispielroutine des RC Receivers von RCarduino gehalten. Ist evtl. die Standard Servo-Bibliothek von Arduino faul oder inkompatibel dazu ?
Ansonsten würde ich später mal durchaus gerne den Mischbetrieb testen, also 2 interrupt gesteuerte Kanäle für die zeitkritischen Regelprozesse zur Stabilisierung von Querruder und Seitenruder, sowie einen etwas weniger zeitkritischen Schaltkanal zur Abschaltung dieser Regelung. Wenn ich hier 200 ms Sekunden warten müsste und die Auslesung der anderen Servos blockiert wäre, wäre das noch im Rahmen des machbaren. Die PID Regelung der Servos sollte hingegen über die Interruptsteuerung schneller laufen .
Danke & Gruß,
Tütenflieger
Meine Hardware: China-Arduino Uno , die beiden Miniservos des Testaufbaus werden über ein externes NT gespeist, unabhängig von der USB-Speisung des Unos. Müssen Servosignale evtl. nochmal verstärkt werden, sind die Eingangsströme in die Servos evtl. zu hoch ? Ich ging eigentlich davon aus, daß das vernachlässigbar sei.
