Probleme beim Kompilieren

Hallo Community,

ich habe folgenden Code geschrieben.
Wenn ich kompilieren will dann kommt eine Fehlermeldung, die ich nicht ganz verstehe:

c:/program files/arduino/hardware/tools/avr/bin/…/lib/gcc/avr/4.3.2/…/…/…/…/avr/lib/avr6/crtm2560.o: In function __vector_default': (.vectors+0x64): relocation truncated to fit: R_AVR_13_PCREL against symbol __vector_25’ defined in .text.__vector_25 section in core.a(HardwareSerial.cpp.o)

Mein Code lautet wie folgt:

#include <Servo.h>

Servo Servo1;
Servo Servo2;
float Toleranzwert = 0.01;
float Differenz;

const int TRIG_PIN1 = 12;
const int ECHO_PIN1 = 13;
const int ECHO_PIN2 = 8;
const int TRIG_PIN2 = 9;
void setup() {
// initialize serial communication:
Serial.begin(9600);

pinMode(TRIG_PIN1,OUTPUT);
pinMode(ECHO_PIN1,INPUT);
pinMode(TRIG_PIN2, OUTPUT);
pinMode(ECHO_PIN2, INPUT);

Servo1.attach(50);
Servo2.attach(51);
}
void loop()
{
long duration1, distanceCm1;
long duration2, distanceCm2;

// Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
digitalWrite(TRIG_PIN1, LOW);
delayMicroseconds(2);
digitalWrite(TRIG_PIN1, HIGH);
delayMicroseconds(2);
digitalWrite(TRIG_PIN1, LOW);
duration1 = pulseIn(ECHO_PIN1,HIGH);

// convert the time into a distance
distanceCm1 = duration1 / 29.1 / 2 ;

if (distanceCm1 <= 0){
Serial.println(“Out of range”);
}
else {
Serial.print(distanceCm1);
Serial.print(“cm”);
Serial.println();
}

digitalWrite(TRIG_PIN2, LOW);
delayMicroseconds(2);
digitalWrite(TRIG_PIN2, HIGH);
delayMicroseconds(2);
digitalWrite(TRIG_PIN2, LOW);
duration2 = pulseIn(ECHO_PIN2,HIGH);

// convert the time into a distance
distanceCm2 = duration2 / 29.1 / 2 ;

if (distanceCm2 <= 0){
Serial.println(“Out of range”);
}
else {
Serial.print(distanceCm2);
Serial.print(“cm”);
Serial.println();
}

delay(100);

Differenz = abs(distanceCm2 - distanceCm1);

if(((distanceCm1 + distanceCm2)/2) > 53) {
while (((distanceCm1 + distanceCm2)/2) > 53)
{
Servo1.write(93);
Servo2.write(100);
while ( Differenz > Toleranzwert)
{
if ( distanceCm2 > distanceCm1)
{
Servo2.write(120);
Servo1.write(90);
}
else
{
Servo1.write(120);
Servo2.write(90);
}
Differenz = abs(distanceCm2 - distanceCm1);
}
}
}
else if(((distanceCm1 + distanceCm2)/2) < 48) {
while (((distanceCm1 + distanceCm2)/2) < 48)
{
Servo2.write(93);
Servo1.write(100);
while ( Differenz > Toleranzwert)
{
if ( distanceCm2 > distanceCm1)
{
Servo2.write(120);
Servo1.write(90);
}
else
{
Servo1.write(120);
Servo2.write(90);
}
Differenz = abs(distanceCm2 - distanceCm1);
}
}
}
else {
if(Differenz <= Toleranzwert)
{
Servo1.write(100);
Servo2.write(100);
}
}
}

ga69jot: ich habe folgenden Code geschrieben. Wenn ich kompilieren will dann kommt eine Fehlermeldung, die ich nicht ganz verstehe:

Wenn ich mir Deinen Code ansehe, dann sehe ich Variablen und Berechnungen, die ich nicht ganz verstehe:

Warum verwendest Du float Differenz; und nicht long Differenz; ???

Die Differenz bildest Du aus zwei long-Variablen. Warum in aller Welt soll diese Differenz dann float sein, wenn es doch um die Differenz von long-Werten geht?

Verwendest Du "long Differenz", dann läßt sich der Code auch sofort fehlerfrei kompilieren.

Auf meiner IDE 1.0.5 kompiliert der Code auch ohne Änderungen fehlerlos (was nicht heissen will, dass er nicht logische Fehler enthält).

Welche Version der IDE verwendest Du denn?

Ich weiß nicht wieso ich da float verwendet habe :D

Gestern in der Nacht hat es doch kompiliert... Gibt es denn außer diesem float noch andere programmierfehler?

Und was ich noch fragen wollte...am Anfang hatte ich nur einen ultraschallsensor...dieser hat ziemlich schnell gemessen, auf dem serial Monitor wurden zügig die neuen Werte angezeigt. Jetzt wo ich den zweiten Sensor dazu programmiert hab geht alles viel langsamer, auch wenn ich Delay verkürze ändert sich nichts. Habt ihr vielleicht Ideen woran es liegt?

Erstaunlich, dass es nur “langsam” geht.

Wenn ich nicht was übersehe, sollten z.B. in

    while (((distanceCm1 + distanceCm2)/2) > 53) 
    {
      Servo1.write(93);
      Servo2.write(100);
      while ( Differenz > Toleranzwert)
      {
        if ( distanceCm2 > distanceCm1)
        {
          Servo2.write(120);
          Servo1.write(90);
        }
        else
        {
          Servo1.write(120);
          Servo2.write(90);
        }
        Differenz = abs(distanceCm2 - distanceCm1);
     }
   }

sich die distance Variablen nicht ändern und du also eine Endlos-Schleife haben.

while Schleifen innerhalb von loop machen alles eher komplizierter. loop ist doch schon eine große Schleife…

Wieso sollten sich die distance werte nicht ändern?

?

Wo ändert sich distanceCm1 ( oder distanceCm2 ) in der zitierten while - Schleife ?

Vermutlich ist in deinen Tests die mittlere Distanz nie > 53 cm, so dass die ganze while Schleife nur zu unserer Verwirrung dient und nie dran kommt ?

Ich dachte nach einem durchlauf misst der Sensor nochmal und berechnet alles mit den neuen distance's.

Ich dachte nach einem durchlauf misst der Sensor nochmal und berechnet alles mit den neuen distance's.

Ja, so sollte es sein: Mach aus dem while(x) ein if(x) und dein sketch bleibt nicht hängen, sondern kann einen neuen Durchlauf machen.

Jetzt wo ich den zweiten Sensor dazu programmiert hab, geht alles viel langsamer

Bleibt aber noch unklar...

Lange Zeiten kommen z.B. von delay, pulseIn, und while Schleifen

Heißt dass ich alle 3 while Schleifen mit if ersetzen muss?

Was heisst "muss" ? Du solltest spätestens jetzt wissen, was ein while macht und ob du willst, dass der Code innerhalb der while Schleife wiederholt wird solange die Bedingung der while Schleife erfüllt ist, ohne dass Code ausserhalb jemals dran kommt.

Wenn du deinen Sketch mit Code Tags formatierst  ( auswählen und den # Button )
und richtig einrückst ( Strg-T in der Arduino IDE ) , 
wäre auch leichter zu erkennen, was wann abläuft. 
°__°

Hier ist nochmal der Code, damit alles besser zu sehen ist…
Ich möchte damit einen elektrischen Rollstuhl automatisch an einer wand entlang fahren zu lassen.
Ich habe 2 Ultraschallsensoren um damit einmal die Parallelität zur Wand gewährleisten zu können und um den Abstand zur Wand regeln zu können. Das ist grob die Idee des Projektes…

#include <Servo.h>

Servo Servo1;
Servo Servo2;
float Toleranzwert = 0.01;
long Differenz;

const int TRIG_PIN1 = 12;
const int ECHO_PIN1 = 13;
const int ECHO_PIN2 = 8;
const int TRIG_PIN2 = 9;
void setup() {
  // initialize serial communication:
  Serial.begin(9600);

  pinMode(TRIG_PIN1,OUTPUT);
  pinMode(ECHO_PIN1,INPUT);
  pinMode(TRIG_PIN2, OUTPUT);
  pinMode(ECHO_PIN2, INPUT);

  Servo1.attach(50);
  Servo2.attach(51);
} 
void loop()
{
  long duration1, distanceCm1;
  long duration2, distanceCm2;

  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  digitalWrite(TRIG_PIN1, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN1, HIGH);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN1, LOW);
  duration1 = pulseIn(ECHO_PIN1,HIGH);

  // convert the time into a distance
  distanceCm1 = duration1 / 29.1 / 2 ;


  if (distanceCm1 <= 0){
    Serial.println("Out of range");
  }
  else {
    Serial.print(distanceCm1);
    Serial.print("cm");
    Serial.println();
  }
  delay(100);

  digitalWrite(TRIG_PIN2, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN2, HIGH);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN2, LOW);
  duration2 = pulseIn(ECHO_PIN2,HIGH);

  // convert the time into a distance
  distanceCm2 = duration2 / 29.1 / 2 ;


  if (distanceCm2 <= 0){
    Serial.println("Out of range");
  }
  else {
    Serial.print(distanceCm2);
    Serial.print("cm");
    Serial.println();
  }


  delay(100);

  Differenz = abs(distanceCm2 - distanceCm1);

  if(((distanceCm1 + distanceCm2)/2) > 53) { 
    while (((distanceCm1 + distanceCm2)/2) > 53) 
    {
      Servo1.write(93);
      Servo2.write(100);
      while ( Differenz > Toleranzwert)
      {
        if ( distanceCm2 > distanceCm1)
        {
          Servo2.write(120);
          Servo1.write(90);
        }
        else
        {
          Servo1.write(120);
          Servo2.write(90);
        }
        Differenz = abs(distanceCm2 - distanceCm1);
      }
    }
  }
  else if(((distanceCm1 + distanceCm2)/2) < 48) { 
    while (((distanceCm1 + distanceCm2)/2) < 48) 
    {
      Servo2.write(93);
      Servo1.write(100);
      while ( Differenz > Toleranzwert)
      {
        if ( distanceCm2 > distanceCm1)
        {
          Servo2.write(120);
          Servo1.write(90);
        }
        else
        {
          Servo1.write(120);
          Servo2.write(90);
        }
        Differenz = abs(distanceCm2 - distanceCm1);
      }
    }
  }
  else {
    if(Differenz <= Toleranzwert)
    {
      Servo1.write(100);
      Servo2.write(100);
    }
  }
}

Noch was wegen dem Delay vorhin, also normalerweise hat mein ultraschallsensor immer nach 100ms neuen Abstandswert ausgegeben, jetzt egal welchen Delay-Wert ich eingebe, gibt er immer nach genau 1sec den neuen Wert an...

Ist mein Board kaputt oder wie kann ich das interpretieren?

Das könnte der Timeout eines pulseIn sein ...

Edit: Richtig, jurs ;)

Kommen die Serial Ausgaben denn paarweise oder ist bei jeder Zeile eine 1 sec Pause ??? Könntest auch mitschreiben, welcher der beiden Sensoren gerade gemessen wurde. Und deine zwei while() { nach den if kannst du weglassen, mal abgesehen davon dass du zum Test erstmal den ganzen Steuerungsteil weglassen kannst, bis klar ist, warum jede Messung 1 sec dauert...

void ping(byte TPin)
{
  digitalWrite(TPin, LOW);
  delayMicroseconds(2);
  digitalWrite(TPin, HIGH);
  delayMicroseconds(2);
  digitalWrite(TPin, LOW);
}

void loop()
{
  unsigned long duration1, duration2;
  ping(TRIG_PIN1);
  duration1 = pulseIn(ECHO_PIN1,HIGH);
  if (duration1 == 0) Serial.println("Error 1");
  else   { Serial.print(duration1/60); Serial.print (" cm (1)       "); }
  delay(100);
  ping(TRIG_PIN2);
  duration2 = pulseIn(ECHO_PIN2,HIGH);
  if (duration2 == 0) Serial.println("Error 2");
  else   { Serial.print(duration2/60); Serial.println (" cm (2)"); }
  delay(100);
}

Ich weiß nicht woran es gelegen hat, aber meine Sensoren messen jetzt wieder ganz wie gewohnt...komisch aber gut, hauptsache es funktioniert...

Ich glaube ich sollte meinen ganzen Code zur Steuerung nochmal Schritt für Schritt durchdenken...

Ich hätte noch eine Frage.

Und zwar könnte ich das ganze was ich eigentlich vorhabe auch mit einem pid Regler oder ähnliches machen?

Ein spezl meinte, dass das scheitern wird weil die servo Motoren einen internen Regler haben und wenn man von außen noch einen Regler programmiert, das nicht funktioniert.

Ich hätte noch eine Frage.

Das wäre ein Anlass für einen extra Thread ;) - Wir finden immer was zu meckern -

Man kann Regler überlagern, und das kann sich auch stören. Kann auch gut gehen.

Wie implementiere ich beim arduino einen Regler ? Ganz normal die Gleichungen berechnen? Ich habe mal was von der pid Library gelesen, wie bediene ich diese?

Kann ich mit einem Regler Parallelität und Abstand zur Wand halten können?

ja. ( Und eine Library bedient dich, nicht umgekehrt ;)

Der Regel-Algorithmus ( z.B. PID ) ist das wenigste. Dass du zwei Ultraschall-Sensoren hast, geht ja aus dem Thread Titel ("Probleme beim Kompilieren") hervor. Wie willst du nun " Parallelität und Abstand zur Wand " einstellen ?

Ich möchte einfach dass mein elektrischer Rollstuhl entlang einer Wand fährt, mit einem vorgegebenem Abstand und wenn möglich auch ziemlich parallel, damit er nicht mit der Wand crasht.

Mein erster Code was ich am Anfang gepostet habe, sollte ja auch dafür dienen...

Edit:

Ja wie das sein soll, also mit den zwei Sensoren...Sensoren messen den Abstand zur Wand, und zur Parallelität, habe zwei unterschiedliche Distanzen und wenn die beiden gemessenen distanzen zur Wand eine geringe Differenz haben, dann ist der Rollstuhl sozusagen parallel zur Wand. Ach ja, was ich natürlich auch noch erwähnen muss, ich muss zwei Motoren steuern.

Brauche ich also zwei Regler oder reicht nur einer? Wird das überhaupt mit einem Regler funktionieren? Oder ist es besser wie im ersten Post den Code einfach zu verbessern und somit zum laufen bringen zu lassen?