Drehscheibe Modellbahn mit RF24

Acki1985:
Mit dem Befehl werden Zusatzzahlen erstellt

Zufallszahlen.

Gruß Tommy

Meinte ich natürlich auch. Hab es übrigens gerade getestet. Das sieht gut aus.

:wink:

Sieht nach Autokorrektur aus.

Durch Zufall (... Pseudo! Sind immer die Gleichen, da ich keinen Seed setze) werden die beteiligten Gleise 'ausgewürfelt', die Formeln werden mit diesen Gleisen durchgerechnet und Du bekommst das Ergebnis ins Terminal.
Hier musst Du 'nur noch' entscheiden, ob die Ergebnisse ok sind, wobei 'Alle falsch' ebenfalls ok ist - dann muß man nur die Abfrage oder die Ansteuerung des Motor umdrehen.

Wenn vereinzelt Ausreißer auftreten, müsste man Diesen nachgehen, wer wo was falsch berechnet.

MfG

Hab den Code etwas abgeändert, in der Hoffnung das ich das richtig interpretiert habe?

const byte schritte_max = 48;   //Anzahl an möglichen Anschlußpunkten

byte von;                       //Ausgangsgleis
byte nach;                      //Zielgleis

void setup() {
  // put your setup code here, to run once:
Serial.begin(9600);
}




void loop() {
  // put your main code here, to run repeatedly:
  von = random(schritte_max) + 1;   //von und bis 'auswürfeln'
  nach = random(schritte_max) + 1;

  Serial.print("Von ");       // Von 1
  Serial.print(von);
  Serial.print(" nach ");     // nach 12
  Serial.println(nach);

  byte schritte_a = abs(von - nach);
  Serial.print("Entfernung links 1-");
  Serial.print(schritte_max - 1);
  Serial.print(" Wechsel ");  //Entfernung ohne 1-47 Wechsel 11
  Serial.println(schritte_a);
  byte schritte_b = schritte_max - schritte_a;
  Serial.print("Entfernung rechts 1-");
  Serial.print(schritte_max - 1);
  Serial.print(" Wechsel ");   //Entfernung mit 1-47 Wechsel 37
  Serial.println(schritte_b);
  //wenn schritte_a<schritte_b && von<nach, dann 'aufwärts' drehend ... 1->12
  //wenn schritte_a<schritte_b && von>nach, dann 'abwärts' drehend  ... 12->1
  //wenn schritte_a>schritte_b && von<nach, dann 'abwärts' drehend  ... 1->48
  //wenn schritte_a>schritte_b && von>nach, dann 'aufwärts' drehend  ... 48->1
  if (schritte_a) {
    if (schritte_a < schritte_b xor von < nach) { //jedes der Statements kann nur wahr oder falsch sein
      Serial.println("Starte links");   // wenn nur Eines wahr ist
    } else {
      Serial.println("Starte rechts");  // wenn Keines oder Beide wahr sind
    }
  } else {
    Serial.println("identisches Gleis");
  }
  delay(1000);
}

Komischerweise kommt dann irgendwann:

Von 4 nach 24
Entfernung links 1-47 Wechsel 20
Entfernung rechts 1-47 Wechsel 28
Starte rechts
?
rechts ist ja richtig aber es sind nur 20 anstatt 28 Schritte??

oder
Von 9 nach 20
Entfernung links 1-47 Wechsel 11
Entfernung rechts 1-47 Wechsel 37
Starte rechts

oder

Von 3 nach 34
Entfernung links 1-47 Wechsel 31
Entfernung rechts 1-47 Wechsel 17
Starte links

oder

Von 37 nach 38
Entfernung links 1-47 Wechsel 1
Entfernung rechts 1-47 Wechsel 47
Starte rechts

Ich glaube es ist mein Fehler. Mit Wechsel meinst es geht über 0 zur 47 und ohne Wechsel meinst du es geht nicht über 0. Richtig? Somit ist meine Änderung Käse

Hi

Ok, eigentlich sollte 'rechts herum' im Uhrzeigersinn sein - also von 4 nach 24 Rechts:20, Links:28

Störe Dich nicht am eigentlichen Text einer Anzeige, sondern passe Diese so an, daß Die zum Vorhaben stimmt.
Ich habe den Sketch so runtergetippt und geschaut, ob Er kompiliert - on Rechts jetzt wirklich Rechts ist - entscheidest Du.
Hätte auch A und B schreiben können, dann muß man aber IMMER in den Kommentaren schauen, was welche Zeile bedeuten soll.
Passe die Zeilen so an, daß Das bei Dir Sinn ergibt.

Dann bitte drei Beispiele mit vonnach - wenn in Deiner Ausgabe dann auch noch die Richtung, Die eingeschlagen werden soll, richtig 'geschwätzt' wird, schadet bestimmt auch nicht.

Wenn Er dann immer noch Fehler bringt, Diese bitte auch hier rein mit dem Sketch/der Berechnung, Die Du dann benutzt.

MfG

PS: Ja, Da fehlt klassisch ein 'MIT' und ein 'OHNE' - ist wohl rausgeflogen, als ich von '48' auf 'schritte_max' geändert habe - liest sich SO nämlich äußerst anstrengend!

Hoffe man kann es jetzt besser lesen.

Von 13 nach 3
Entfernung in Drehrichtung links 1-47 nicht ueber 0 =10 Schritte
Entfernung in Drehrichtung rechts 1-47 ueber 0 =38 Schritte
gewählte Drehrichtung links

Von 3 nach 34
Entfernung in Drehrichtung links 1-47 nicht ueber 0 =31 Schritte
Entfernung in Drehrichtung rechts 1-47 ueber 0 =17 Schritte
gewählte Drehrichtung links

Von 4 nach 22
Entfernung in Drehrichtung links 1-47 nicht ueber 0 =18 Schritte
Entfernung in Drehrichtung rechts 1-47 ueber 0 =30 Schritte
gewählte Drehrichtung rechts

Von 32 nach 33
Entfernung in Drehrichtung links 1-47 nicht ueber 0 =1 Schritte
Entfernung in Drehrichtung rechts 1-47 ueber 0 =47 Schritte
gewählte Drehrichtung rechts

Von 2 nach 25
Entfernung in Drehrichtung links 1-47 nicht ueber 0 =23 Schritte
Entfernung in Drehrichtung rechts 1-47 ueber 0 =25 Schritte
gewählte Drehrichtung rechts

Von 19 nach 38
Entfernung in Drehrichtung links 1-47 nicht ueber 0 =19 Schritte
Entfernung in Drehrichtung rechts 1-47 ueber 0 =29 Schritte
gewählte Drehrichtung rechts

Mit dem Code:

const byte schritte_max = 48;   //Anzahl an möglichen Anschlußpunkten

byte von;                       //Ausgangsgleis
byte nach;                      //Zielgleis

void setup() {
  // put your setup code here, to run once:
Serial.begin(9600);
}

void loop() {
  // put your main code here, to run repeatedly:
  von = random(schritte_max) + 1;   //von und bis 'auswürfeln'
  nach = random(schritte_max) + 1;

  Serial.print("Von ");       // Von 1
  Serial.print(von);
  Serial.print(" nach ");     // nach 12
  Serial.println(nach);

  byte schritte_a = abs(von - nach);
  Serial.print("Entfernung in Drehrichtung links 1-");
  Serial.print(schritte_max - 1);
  Serial.print(" nicht ueber 0 =");  //Entfernung ohne 1-47 Wechsel 11
  Serial.print(schritte_a);
  Serial.println(" Schritte");
  byte schritte_b = schritte_max - schritte_a;
  Serial.print("Entfernung in Drehrichtung rechts 1-");
  Serial.print(schritte_max - 1);
  Serial.print(" ueber 0 =");   //Entfernung mit 1-47 Wechsel 37
  Serial.print(schritte_b);
  Serial.println(" Schritte");
  //wenn schritte_a<schritte_b && von<nach, dann 'rechts' drehend ... 1->12
  //wenn schritte_a<schritte_b && von>nach, dann 'links' drehend  ... 12->1
  //wenn schritte_a>schritte_b && von<nach, dann 'links' drehend  ... 1->48
  //wenn schritte_a>schritte_b && von>nach, dann 'rechts' drehend  ... 48->1
  if (schritte_a) {
    if (schritte_a < schritte_b xor von < nach) { //jedes der Statements kann nur wahr oder falsch sein
      Serial.println("gewählte Drehrichtung links");   // wenn nur Eines wahr ist
    Serial.println(" ");
    } else {
      Serial.println("gewählte Drehrichtung rechts");  // wenn Keines oder Beide wahr sind
    Serial.println(" ");
    }
  } else {
    Serial.println("identisches Gleis");
    Serial.println(" ");
  }
  delay(1000);
}

Guten abend,

Kann mir jemand helfen?

Hallo alle zusammen,

von 4 nach 24 wird immer die Falsche Richtung genommen?
Woran könnte das liegen?

const byte schritte_max = 48;   //Anzahl an möglichen Anschlußpunkten

byte von;                       //Ausgangsgleis
byte nach;                      //Zielgleis

void setup() {
  // put your setup code here, to run once:
Serial.begin(9600);
}

void loop() {
  // put your main code here, to run repeatedly:
  von = random(schritte_max) + 1;   //von und bis 'auswürfeln'
  nach = random(schritte_max) + 1;

  Serial.print("Von ");       // Von 1
  Serial.print(von);
  Serial.print(" nach ");     // nach 12
  Serial.println(nach);

  byte schritte_a = abs(nach - von);
  Serial.print("Entfernung in Drehrichtung links 1-");
  Serial.print(schritte_max );
  Serial.print(" nicht ueber 0 =");  //Entfernung ohne 1-47 Wechsel 11
  Serial.print(schritte_a);
  Serial.println(" Schritte");
 
  byte schritte_b = schritte_max - schritte_a;
  Serial.print("Entfernung in Drehrichtung rechts 1-");
  Serial.print(schritte_max );
  Serial.print(" ueber 0 =");   //Entfernung mit 1-47 Wechsel 37
  Serial.print(schritte_b);
  Serial.println(" Schritte");
  //wenn schritte_a<schritte_b && von<nach, dann 'rechts' drehend ... 1->12
  //wenn schritte_a<schritte_b && von>nach, dann 'links' drehend  ... 12->1
  //wenn schritte_a>schritte_b && von<nach, dann 'links' drehend  ... 1->48
  //wenn schritte_a>schritte_b && von>nach, dann 'rechts' drehend  ... 48->1
  if (schritte_a) {
    if (schritte_a < schritte_b) { //jedes der Statements kann nur wahr oder falsch sein
      Serial.println("gewählte Drehrichtung links");   // wenn nur Eines wahr ist
    Serial.println(" ");
    } else {
      Serial.println("gewählte Drehrichtung rechts");  // wenn Keines oder Beide wahr sind
    Serial.println(" ");
    }
  } else {
    Serial.println("identisches Gleis");
    Serial.println(" ");
  }
  delay(1000);
}

verstehe es nicht?

Von 3 nach 34
Entfernung in Drehrichtung links 1-48 nicht ueber 0 =31 Schritte //falsch
Entfernung in Drehrichtung rechts 1-48 ueber 0 =17 Schritte
gewählte Drehrichtung rechts

Von 20 nach 14
Entfernung in Drehrichtung links 1-48 nicht ueber 0 =6 Schritte //richtig
Entfernung in Drehrichtung rechts 1-48 ueber 0 =42 Schritte
gewählte Drehrichtung links

Von 4 nach 22
Entfernung in Drehrichtung links 1-48 nicht ueber 0 =18 Schritte //falsch
Entfernung in Drehrichtung rechts 1-48 ueber 0 =30 Schritte
gewählte Drehrichtung links

Von 32 nach 33
Entfernung in Drehrichtung links 1-48 nicht ueber 0 =1 Schritte //falsch
Entfernung in Drehrichtung rechts 1-48 ueber 0 =47 Schritte
gewählte Drehrichtung links

Von 2 nach 25
Entfernung in Drehrichtung links 1-48 nicht ueber 0 =23 Schritte //falsch
Entfernung in Drehrichtung rechts 1-48 ueber 0 =25 Schritte
gewählte Drehrichtung links

Von 30 nach 18
Entfernung in Drehrichtung links 1-48 nicht ueber 0 =12 Schritte //richtig
Entfernung in Drehrichtung rechts 1-48 ueber 0 =36 Schritte
gewählte Drehrichtung links

Von 45 nach 44
Entfernung in Drehrichtung links 1-48 nicht ueber 0 =1 Schritte //richtig
Entfernung in Drehrichtung rechts 1-48 ueber 0 =47 Schritte
gewählte Drehrichtung links

Von 19 nach 38
Entfernung in Drehrichtung links 1-48 nicht ueber 0 =19 Schritte //falsch
Entfernung in Drehrichtung rechts 1-48 ueber 0 =29 Schritte
gewählte Drehrichtung links

Von 42 nach 18
Entfernung in Drehrichtung links 1-48 nicht ueber 0 =24 Schritte //richtig
Entfernung in Drehrichtung rechts 1-48 ueber 0 =24 Schritte
gewählte Drehrichtung rechts

Von 5 nach 41
Entfernung in Drehrichtung links 1-48 nicht ueber 0 =36 Schritte / /richtig
Entfernung in Drehrichtung rechts 1-48 ueber 0 =12 Schritte
gewählte Drehrichtung rechts

Von 5 nach 3
Entfernung in Drehrichtung links 1-48 nicht ueber 0 =2 Schritte //richtig
Entfernung in Drehrichtung rechts 1-48 ueber 0 =46 Schritte
gewählte Drehrichtung links

Von 13 nach 21
Entfernung in Drehrichtung links 1-48 nicht ueber 0 =8 Schritte //falsch
Entfernung in Drehrichtung rechts 1-48 ueber 0 =40 Schritte
gewählte Drehrichtung links

Hi

Schade, daß Du einen 'Ausreißer' drin hast

Von 5 nach 41
Entfernung in Drehrichtung links 1-48 nicht ueber 0 =36 Schritte / /richtig
Entfernung in Drehrichtung rechts 1-48 ueber 0 =12 Schritte
gewählte Drehrichtung rechts

Ohne diesen 'Richtig', wären alle Fälle falsch gewesen, in Denen das Start-Gleis kleiner als das Ziel-Gleis war - durch den Ausreißer ist diese Theorie aber wieder Müll.

Sorry, daß Du mit meinem Versuch jetzt doch so viel Zeit unnütz verballert hast.
Leider sehe ich gerade aber auch keine Gemeinsamkeit - der XOR-Ansatz hätte eigentlich passen sollen ... eigentlich.

MfG

Hallo alle zusammen,

das mit dem richtig habe ich manuell dazu geschrieben. Überall wo richtig dahinter steht, stimmen die Schritte und die Richtung und bei denen wo falsch dahinter steht stimmen Ricchtung und Schritte nicht.

Hat noch wer ne Idee, wie man es lösen könnte?

Keiner ne Idee? Es muss doch irgendwie möglich sein. Ich denke das das Problem daran liegt, dass man über Null dreht.

Man könnte doch auch die Richtung über die drhrichtung des encoders wählen. Dazu müsste man aber den Encoder über 0 zählen lassen können. Geht sowas und wenn ja wie könnte man das machen?

Hi

Über Null zählen ist nicht so schwer:

  • wenn über 47 (Maximal-Wert -1), einfach 48 (Maximal-Wert) abziehen
  • wenn unter 0 (dafür signed Typ notwendig) 48 (Maximal-Wert) addieren

Oder, ohne signed-Typ, beim Hochzählen prüfen, ob wir damit auf 48 (Maximal-Wert) kämen, ja->0, nein ->+1, beim Runterzählen, ob wir jetzt noch auf NULL sind, ja ->Maximal-Wert-1, nein -> -1.

Trotzdem muß Es gehen, daß der Arduino die richtige Richtung errechnet.
Wenn mir akut aber auch eine direkte Idee fehlt und die Zeit - da bekommen dann doch eher eigene Projekte den Vorrang.

MfG

  • gelöscht mein Fehler*

Habe einen Weg gefunden. :slight_smile:

const byte schritte_max = 48;   //Anzahl an möglichen Anschlußpunkten

byte von;                       //Ausgangsgleis
byte nach;                      //Zielgleis

void setup() {
  // put your setup code here, to run once:
Serial.begin(9600);
}

void loop() {
  // put your main code here, to run repeatedly:
  von = random(schritte_max) + 1;   //von und bis 'auswürfeln'
  nach = random(schritte_max) + 1;
  //  von = 19;
    //nach = 38;
  Serial.print("Von ");       // Von 1
  Serial.print(von);
  Serial.print(" nach ");     // nach 12
  Serial.println(nach);
if (von > nach){
  int schritte_links = (von - nach);
  Serial.println("Entfernung in Drehrichtung links");
  Serial.println(schritte_links);
  Serial.println(" ");
  
  int schritte_rechts = nach - von;
  Serial.println("Entfernung in Drehrichtung rechts");
  Serial.println(schritte_rechts);
  int schritte_rechts_erg = schritte_rechts + 48;
  Serial.println(schritte_rechts_erg);
  Serial.println(" ");
  if (schritte_links > schritte_rechts_erg) {
    Serial.println("Drehrichtung rechts");
    
  }
  else if (schritte_links < schritte_rechts_erg) {
    Serial.println("Drehrichtung links");
  }
}
if (von < nach) {
    int schritte_links = abs ((nach - von) -48);
    Serial.println("Entfernung in Drehrichtung links");
    Serial.println(schritte_links);
    Serial.println(" ");
    int schritte_rechts = (nach - von);
    Serial.println("Entfernung in Drehrichtung rechts");
    Serial.println(schritte_rechts);
    Serial.println(" ");
    if (schritte_links > schritte_rechts) {
      Serial.println("Drehrichtung rechts");
    }
    else if (schritte_links < schritte_rechts) {
      Serial.println("Drehrichtung links");
    }
  }

  
  
  Serial.println("-------------------------------------------------------------------------");

  delay(1000);
}

geht auch nicht. Schade

das kommt bei:

Von 42 nach 18
Entfernung in Drehrichtung links
24

Entfernung in Drehrichtung rechts
-24
24

raus. ::slight_smile:

Hab es rausbekommen. Er wusste nicht in welche Richtung er fahren soll, da bei Richtungen die gleiche Anzahl an Schritten hatte.

Jetzt funktioniert es. :slight_smile:

const byte schritte_max = 48;   //Anzahl an möglichen Anschlußpunkten

byte von;                       //Ausgangsgleis
byte nach;                      //Zielgleis

void setup() {
  // put your setup code here, to run once:
Serial.begin(9600);
}

void loop() {
  // put your main code here, to run repeatedly:
 von = random(schritte_max) + 1;   //von und bis 'auswürfeln'
 nach = random(schritte_max) + 1;
  //von = 25;
  //nach = 1;
  Serial.print("Von ");       // Von 1
  Serial.print(von);
  Serial.print(" nach ");     // nach 12
  Serial.println(nach);
if (von > nach){
  int schritte_links = (von - nach);
  Serial.println("Entfernung in Drehrichtung links");
  Serial.println(schritte_links);
  Serial.println(" ");
  
  int schritte_rechts = nach - von;
  Serial.println("Entfernung in Drehrichtung rechts");
  Serial.println(schritte_rechts);
  int schritte_rechts_erg = schritte_rechts + 48;
  Serial.println(schritte_rechts_erg);
  Serial.println(" ");
  if (schritte_links >= schritte_rechts_erg) {
    Serial.println("Drehrichtung rechts");
    
  }
  else if (schritte_links < schritte_rechts_erg) {
    Serial.println("Drehrichtung links");
  }
}
if (von < nach) {
    int schritte_links = abs ((nach - von) -48);
    Serial.println("Entfernung in Drehrichtung links");
    Serial.println(schritte_links);
    Serial.println(" ");
    int schritte_rechts = (nach - von);
    Serial.println("Entfernung in Drehrichtung rechts");
    Serial.println(schritte_rechts);
    Serial.println(" ");
    if (schritte_links >= schritte_rechts) {
      Serial.println("Drehrichtung rechts");
    }
    else if (schritte_links < schritte_rechts) {
      Serial.println("Drehrichtung links");
    }
  }

  
  
  Serial.println("-------------------------------------------------------------------------");
  
  
  delay(1000);
}

Guten Abend,

Wie bekomme ich hin, dass man den Encoderwert überdrehen kann. Ich meine, das ich wenn ich den Encoder bei 48 weiter drehe dann als nächstes der Wert 1 kommt und wenn ich ihn zurück drehe der Wert 48?

void encoder_lesen () {
  messungPin1 = digitalRead(encoderPinA);
  if ((messungPin1 == LOW) && (messungPin1Alt == HIGH) && (nullStellung == true)) {
    if (digitalRead(encoderPinB) == HIGH) {
      if (encoderWert < 48) encoderWert++ ;
    } else {
      if (encoderWert > 1) encoderWert-- ;