Drehscheibe Modellbahn mit RF24

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-- ;

Hi

if (encoderWert < 48) encoderWert++ ;

Hier bist Du im Bereich 'Aufwärts' - Du hast also wohl rechts herum gedreht.
Deine jetzige Abfrage fragt, ob der Wert kleiner 48 ist, wenn Das gegeben ist, zählst Du 1 hinzu.
Da Das bei 48 nicht mehr gegeben ist, kannst Du entweder einen else-Zweig machen, um dort encoderWert auf 1 zu setzen, oder Du rechnest 'mit Überlauf'.

48+1->49
49%48->1 (Modulo, Rest der Division, 49:48=1, Rest 1)

Damit Das auch 'rückwärts' klappt, musst Du '-1' addieren - dabei kannst Du aber einen Unterlauf erzeugen - dann wird Dir Modulo 48 wohl keine 47 zurück geben.
Deshalb addierst Du '48-1'.

Beim 'Hochdrehen' stur +1
Beim Runterdrehen stur +47 (=48-1)
Ein +48 wäre das Gleiche, wie ein +0, somit bekommst Du durch +47 Dein '-1', aber in die Richtung 'nach Oben'.
Nach der Addition (also +1 oder +47) erzeugst Du das Modulo:

encoderWert=encoderWert%48+1;

Hier fällt Dir wohl die +1 auf - Die brauchen wir hier, weil Dein Sketch von 1-48 'zählt', Modulo aber Ergebnisse von 0-47 liefert (eben der Rest, wenn wir keine 48 mehr abziehen können).
Richtung, von, über (Addition), nach (Modulo)
+> 1 -> 2 -> 2
+> 2 -> 3 -> 3
-> 3 -> 49 -> 2
-> 2 -> 48 -> 1
-> 1 -> 47 -> 48
-> 48 -> 95 -> 47

MfG

Ich danke dir. Oh kannst mir das genauer erklären wie ich das machen muss. Versteh das leider nicht.

Da, wo Du um 1 erhöhst, erhöhst Du auch weiterhin um 1.
Da, Wo Du um 1 verminderst, erhöhst Du um 47 (einen weniger als MAX-Positionen).
BEIDE, ohne die IF-Abfrage davor, wir wollen ja bei 1 auch runter und bei 48 auch hoch zählen.
Hinter der Zählerei kommt dann die Korrektur des gezählten Wert, die Modulo-Berechnung.

Etwas Spieltrieb darfst Du gerne auch zeigen - wenn's wider Erwarten doch nicht klappt, hast Du die Vorversion (Die Du Dir UNBEDINGT Exportieren/Archivieren solltest).

Zur größten Not schreibe Dir einen Testsketch und lasse eine Variable von 0 bis 32000 hoch zählen (int geht dafür).
Diese Variable verrechnest Du mit %48 (Modulo 48) und lässt Dir dieses Ergebnis anzeigen.

MfG

Aber wen ich die If Abfragen für den Encoderwert wegnehme, mach das doch keinen Sinn mehr oder?

if (encoderWert < 48) encoderWert++ ;
} else {
if (encoderWert > 1) encoderWert-- ;

Ich begreif das einfach nicht. Gibt es da eventuell irgendwo ein Beispiel?

Hi

if ((messungPin1 == LOW) && (messungPin1Alt == HIGH) && (nullStellung == true)) {
    if (digitalRead(encoderPinB) == HIGH) {
      if (encoderWert < 48) encoderWert++ ;
    } else {
      if (encoderWert > 1) encoderWert-- ;
  1. Zeile: Abfrage, ob der Encoder gedreht wurde, wenn JA, geht's weiter
  2. Zeile, Abfrage, ob der Encoder HOCH gedreht wurde, wenn JA, geht's direkt weiter, sonst beim ELSE
  3. Zeile - HIER begrenzt Du den Wert auf 48 - DIESE IF raus und NUR encoderwert++; dahin
  4. Zeile ... ein ELSE, ab hier, wenn 'RUNTER' gedreht wurde
  5. Zeile - HIER begrenzt Du auf den Wert 1 - DIESES IF raus und statt -- machst Du hier encoderwert+=47; (oder +(maxiwert-1) )
    DAHINTER - quasi Zeile 5 1/2
    encoderwert=encoderwert%48; (oder maxwert)

... fertig ...

Die 3.te und die 5.te Zeile haben NICHTS mit der Abfrage des Encoder zu tun - DIE verhindern nur, daß der Wert <1 oder >48 werden kann.

Wenn man mit der IF-Verschachtelung nicht klar kommt, sollte man STUR ALLE Klammern setzen.
Das hier:
if (encoderWert < 48) encoderWert++ ;
ist eine komplette und gültige IF-Abfrage mit einer Anweisung, wenn Diese erfüllt ist.
if (encoderWert < 48) {
//hier, wenn Bedingung erfüllt
encoderWert++ ;
}else{
//hier, wenn Bedingung NICHT erfüllt
}
Ohne die Klammern (Block-Bildung), kannst Du auch nur EINEN Befehl bedingt ausführen lassen.
Im Block beliebig Viele.

MfG