Hallöchen,

ich Lese ein paar Bytes von der Seriellen.
Jetzt ist aber die Länge nicht immer gleich.
Anhand des ersten Bytes, muss/kann ich entscheiden ob das nächste noch dazu gehört, oder die nächsten zwei, oder einfach ein neuer "Satz" dazu kommt.
Erhalten kann ich:

markieren

Code:

Erstes Byte Zweites Byte Drittes Byte
0 - 111      0 - 255
126          0 - 31
127          0 oder 128
128 - 159    0 - 111       0 - 255

So, ich brauch jetzt ein paar Ideen, wie ich das am besten lösen kann/soll, ohne ein 10 Meter langen Case zu benutzen, mit 100 Meter langen IFs.
Vielen Dank.

Grüsse, Daniel

Kommen da noch mehr Bytes? Wenn es sich nur um 3 handelt, dann wird die Case-Anweisung nicht Meter lang.

markieren

Delphi-Quellcode:

Case Bytes[0] of
  0..111: Bytes[1] := ReadByte;
  126: Bytes[1] := ReadByte;
  127: Bytes[1] := ReadByte;
  128..159: ;
  else raise Exception.Create('Unerwarteter Wert');
end;

ja, aber je nachdem, was beim ersten mal eingelesen wurde, ist doch beim zweiten mal, immer was anderes ein "unerwarteter Wert".

Ich würde sagen, um die meterlange case-Konstruktion kommst du nicht rum.

Soweit hatte ich mir ea schon überlegt, nur!
Ich muss Anhand des ersten, zweiten und evtl. dritten Bytes, unterschiedliche sachen machen.

Wenn also 111 kommt und danach 255 muss ich was machen, oder wenn 57 und dann 137, dann wieder was anderes.
Jedesmal wenn irgend! eine Kombination eintrifft, muss ich was bestimtes machen!
Es heisst nicht das wenn das erste 2 ist, das dann das zweite auch 2 ist. Alles unabhängig.

Bei 127 ist es ainfach, da dahinter nur 0 oder 128 kommen kann.
Bei 126 gehts auch noch, weil dahinter auch nur noch 0 bis 31 kommen kann.

Aber wenn das erste Byte zwischen 0 und 111 ist, dann hab ich schon 256 möglichkeiten, und das auch noch abhängig vom ersten Byte.
Das gleiche gilt aus für 128-159.
Da wird es noch schlimmer.
Das erste kann zwischen 128 und 159 liegen, egal welche Zahl kommt, kommt dahinter noch irgendwas zwischen 0 und 111 und als drittes Byte noch was zwischen 0 und 255.

Es sind wirklich "abartig" viele möglichkeiten.

Grüsse, Daniel

Moin Daniel,

dann wirst Du wohl nicht darum herumkommen das die ganzen Abfragen umfangreicher werden.

Am Besten nimm' doch als Basis jbg's Vorschlag, und dann als geschachtelter Case.

Irgendwo muss es doch aber auch Einschränkungen geben, denn wenn jeder der Kombinationen einen anderen Vorgang zur Folge hat viel Spass

Es sind insgesamt 946210 Mögliche Kombinationen

Zitat von Christian Seehase:

Am Besten nimm' doch als Basis jbg's Vorschlag, und dann als geschachtelter Case.

Genau und in jeden gefundenen case, muss dementsprechend ganz doll viele IFs schreiben.

Zitat:

Irgendwo muss es doch aber auch Einschränkungen geben, denn wenn jeder der Kombinationen einen anderen Vorgang zur Folge hat viel Spass

Ich muss es mir nochmal überlegen. Eventuell könnte ein "paar" einsparen.

Zitat:

Es sind insgesamt 946210 Mögliche Kombinationen

Ich sagte ja, 10 Meter lange Case und 100 Meter lange IFs.

Nur mal ein Bespiel. //Vielleicht hilft es was, wenn man weiss was die Bits zu bedeuten haben...
Ich bekomme immer ein Byte.
Das erste Byte steht für eine Adresse. Also Adresse 0 bis 111.
Jede Adresse kann den Wert 0 bis 255 haben.
Hier sollten dann die ganzen IFs herhalten.
Die ersten 5 Bits, des zwieten Bytes, stehen für die Zahlen 0 bis 31. Die Entspricht einer Fahrstufe der Lok. Und zwar wenn sie vorwärts fährt! Das sechte Bit, gibt die Richtung an. 0 ist Vor, 1 ist Rückw.
Wenn das zweite Byte, den Wert 40 hat, dann entspricht das Fahrstufe 6 Rückwärst. Das siebte Bit ist das Licht, das achte der Horn.
Erhalte ich also den Wert 255, so fährt die Lok mit FS 31, Rückwärts und mit eingeschalötetem Licht und Horn.
Soweit Klar?

Grüsse, Daniel

Moin Daniel,

wenn ich mich mal eben selber zitieren darf:

Zitat:

... und dann als geschachtelter Case.

Nix mit Unmengen If/Then Konstruktionen

zusammenfalten · markieren

Delphi-Quellcode:

case Wert[0] of
0..111
  begin
     case Wert[1] of
       0 :
        begin
        end;
       //...
     end;
// ...
  end;
end;

Wenn nun aber bestimmte Bits bestimmte Bedeutungen haben, dann wird's doch deutlich einfacher.
Auch wenn Du noch intensiver Vorarbeiten betreiben musst:

Bitmasken basteln.

Um in Deinem Beispiel zu bleiben

markieren

Delphi-Quellcode:

const
  _mskStep = $F8; // Die obersten 5 Bit werden ausmaskiert $F8 = 11111000 bin
  _mskDirection = $04; // Das Fahrtrichtungsbit wird ausmaskiert
  _mskLight = $02; // Licht
  _mskHorn = $01; // Horn

Wenn alle 8 Bit benutzt werden kann man durch oder Verknüpfung der Masken feststellen, ob man alle Bit berücksichtigt hat. Dann muss 255 rauskommen.
(Bei weniger benutzten Bits entsprechend natürlich weniger)
40 müsste übrigens Fahrstufe 5 Rückwärts sein (00101000)

Um die Fahrstufe zu errechnen kannst Du nun

  iStep := (Wert[1] and $F8) shr 3; rechnen.

Die oberen 5 Bit ausmaskieren und dann um so viele Bit nach rechts verschieben, dass das niederwertigste Bit der Fahrstufe ganz rechts steht. Dann stimmt auch der Dezimalwert.

Die anderen drei Bit kannst Du dann als Boolean Werte (Flags) nehmen:

z.b.

  fHornIsOn := (Wert[i] and _mskHorn) = _mskHorn; dann kannst Du mit

if fHornIsOn then // ... Lesbar entscheiden was los ist.

Soweit Klar?

Moin Christian,

Zitat von Christian Seehase:

Soweit Klar?

Ich denke Ja! Werd es mir nochmal genauer anschauen, hab aber verstanden woraf Du hinaus willst. Danke.

Grüsse, Daniel