3 Byte nacheinander vergleichen und inkrementieren

[Joe S. (bubblejoe)]

Hallo,

ich stehe gerade leider total auf dem Schlauch und möchte weiterkommen.
Ich habe auf einem PIC16F (XC8 Compiler) drei Byte, die ich von einem 
Startwert erhöhen möchte auf einen vorgegebenen Endwert.
Ich muss irgendwo einen Denk- bzw. Codefehler haben, da nicht das von 
mir erwartete (bzw. gewünschte) eintritt.
Vlt. fällt er jemanden von euch auf die Schnelle auf.

Vielen Dank und Grüße vorab.

Die xxx_byte werden vorher noch auf die Startwerte gesetzt (die 
niedriger als die Endwerte sind).

if(upper_byte<=upper_byte_end)
                {
                    if(high_byte<=high_byte_end)
                    {
                        if(low_byte<low_byte_end)
                        {
                            low_byte++;
                            if(low_byte==0)     // Check overflow
                            {
                                high_byte++;
                                if(high_byte==0)
                                {
                                    if(upper_byte<255)
                                    {
                                        upper_byte++;
                                    }
                                }
                            }
                        }
                    }
                }

[EAF (Gast)]

Joe S. schrieb:
> if(low_byte<low_byte_end)
>                         {
>                             low_byte++;
>                             if(low_byte==0)     // Check overflow

Wie soll da ein Überlauf stattfinden, wenn low_byte_end kleiner 255 ist?

[EAF (Gast)]

Nachtrag:

Ich kann solche If Kaskaden nicht leiden.
Der Grund: Nicht zu überblicken.
(offenbar auch für dich nicht)

[Teo D. (teoderix)]

Nimm halt ne 16bit Var und gut is!

><(()°> ?-/

[Wolfgang (Gast)]

Joe S. schrieb:
> Ich habe auf einem PIC16F (XC8 Compiler) drei Byte, die ich von einem
> Startwert erhöhen möchte auf einen vorgegebenen Endwert.

Und warum erhöhst du sie dann nicht einfach und prüfst am Ende, ob der 
Endwert erreicht ist?

[Joe S. (bubblejoe)]

EAF schrieb:
> Wie soll da ein Überlauf stattfinden, wenn low_byte_end kleiner 255 ist?

Danke! Mit dem Tipp habe ich es nun hinbekommen.

Manchmal hat man so eine Denkblockade, oh weh oh weh...

[EAF (Gast)]

Joe S. schrieb:
> Mit dem Tipp habe ich es nun hinbekommen.

Eigentlich war das kein Tipp, sondern ein offensichtlicher/markanter 
Sprung in der Logik, welcher eine ganze Latte Fragezeichen aufgeworfen 
hat.

Joe S. schrieb:
> Manchmal hat man so eine Denkblockade, oh weh oh weh...

Jetzt kommt ein Tipp:
Das sind die if Kaskaden.
Die machen Knoten in die Hirnwindungen.
Der Verzicht auf solche Kaskaden, schafft Klarheit.

Das Programmierer Genie zeichnet sich übrigens nicht dadurch aus, dass 
es beliebig tiefe Kontrollstrukturen im Blickfeld behalten kann, sondern 
dadurch dass er/sei/es diese Komplexität auflösen/abflachen kann.

[Wolfgang (Gast)]

uint32 Zahl;

while (Zahl < Endwert)
  Zahl++;

[Gerald K. (geku)]

Teo D. schrieb:
> Nimm halt ne 16bit Var und gut is!

Normalerweise sollte ein C Compiler deb Datentyp long unterstützen. long 
i++

Mit union kann man die Variable als long oder 4 bzw. 3 Bytes behandeln.

[Nasenarchitekt (Gast)]

> while (Zahl < Endwert)
>  Zahl++;

Kwatsch.

Zahl = Endwert;

[Dietrich L. (dietrichl)]

Teo D. schrieb:
> Nimm halt ne 16bit Var und gut is!

Bei mir ist 3x8=24...

[Gerald K. (geku)]

union CNT
{ 
    long l;
    unsigned char b[4]; 
} myCnt;


myCnt.l++;

[Justus (Gast)]

Wolfgang schrieb:
> uint32 Zahl;
>
> while (Zahl < Endwert)
>   Zahl++;
Seid ihr alle neben der Kappe?
GRÖL :-]]]]]

Nasenarchitekt schrieb:
> Zahl = Endwert;
Danke! Du hast den Tag gerettet.

[Teo D. (teoderix)]

Dietrich L. schrieb:
> Teo D. schrieb:
>> Nimm halt ne 16bit Var und gut is!
>
> Bei mir ist 3x8=24...

Ja ja, is ja schon gut. Hab mich halt in dem Geschwurbel "verzählt"....

[A. S. (Gast)]

EAF schrieb:
> Jetzt kommt ein Tipp:
> Das sind die if Kaskaden.
> Die machen Knoten in die Hirnwindungen.
> Der Verzicht auf solche Kaskaden, schafft Klarheit.

Ich habe zwar keine Ahnung, wie der Code des TO jetzt aussieht, aber 
eine gute Lösung wird kaum kleiner oder eleganter sein als im OP.

Oder hast Du eine alternative, unter der Annahme 3 einzelne Bytes? (Und 
ja, eine 16 Bit Variable macht es deutlich eleganter.

[EAF (Gast)]

A. S. schrieb:
> aber
> eine gute Lösung wird kaum kleiner oder eleganter sein als im OP.
6 geschachtelte if scheinen mir nicht sonderlich elegant zu sein.

A. S. schrieb:
> der hast Du eine alternative
Da ich den Algorithmus/Problem/Aufgabe/Sinn/Zweck nicht verstehe, leider 
nein.
z.B. sind die Endwerte konstant, oder variabel?
Wohin soll optimiert werden? Lesbarkeit oder Speed?
Ohne Kontext keine Chance.

Einen Bock habe ich ja schon gezeigt.....
Den zweiten identischen schießt er mit high_byte
Das macht schon mal 2 if weniger, liegt damit deutlich auf meiner 
Wunschlinie.

Tendenziell, würde versuchen die Variablen irgendwie zusammen zu fassen.
z.B. in einem Array, einer Struktur, oder gar, wenn die Endwerte zu 2er 
Potenzen passen in ein Bitfeld. Wenn * oder / Rechnungen nicht zu teuer 
sind, auch in einer 32Bit Variablen, denn dann reicht ein Vergleich auf 
Endwert, und nur ein Increment.
Potentielle Möglichkeiten gibt es satt.

Als Hürde kommt hinzu, dass ich weder den µC noch den Compiler im 
Zugriff habe.


Also nein!
Ich habe keinen konkreten besseren Vorschlag. So ist das einzige 
"Besser" welches mir KONKRET einfällt, die Anzahl ifs zu reduzieren.

Mantra:
> Jedes vermiedene if ist ein gutes if.
> Jedes vermeidbare if ist ein böses if
Zwischen den beiden Grenzen findet sich eine Hysterese, dort wo die 
unvermeidbaren/notwendigen if stecken.

[Joe S. (bubblejoe)]

Hallo,

ich habe die drei Byte letztendlich wie vorgeschlagen in einer (32bit, 
long) Variable zusammengefasst und mache damit die Berechnungen / 
Vergleiche.
Zuletzt lese ich aus der long Variable die einzelnen Byte wieder aus.

Danke für eure Hilfe, Viele Grüße Joe.

[A. S. (Gast)]

Joe S. schrieb:
> Zuletzt lese ich aus der long Variable die einzelnen Byte wieder aus.

Darf man denn dann fragen, warum Du die Bytes einzeln brauchst? Falls es 
wegen Serialisierung ist, dann lieber dazu nachfragen.

Die Verwendung von 3 einzelnen Bytes (nicht mal ein Array oder eine 
Struktur) ist nur sehr selten zielführend. Manchmal unterstützen 
Compiler für kleine Prozessoren sogar 24 Bit Integer direkt

[Nasenarchitekt (Gast)]

Am besten das ganze auf einem PIC in Assembler schreiben.
Da sieht mann dann die 'if's nicht so.
Und gegen ein gutes™ GOTO kann mann ja nichts haben.
Schon FORTRAN1 hatte das im Sprachstandard.

[Klaus H. (klummel69)]

Gerald K. schrieb:
> union CNT

Nutze ich auch oft, man sollte jedoch Bedenken dass es zwischen little 
und Bug endian Unterschiede gibt.

[Gerald K. (geku)]

Das probiert man am besten aus in dem man den Longwert auf 0x0815 setzt 
und sich den Wert der einzelnen Bytes ansieht. Danke für den Hinweiß!

[Torx (Gast)]

Wittgenstein:
>Ich habe einen Schmerz in Ihrem Oberarm.

https://www1.wdr.de/radio/wdr5/sendungen/philosophisches-radio/wilhelm-vossenkuhl-100.html

Joe S. schrieb:
> ... total auf dem Schlauch.

EAF schrieb:
> Ich kann solche If Kaskaden nicht leiden.

Teo D. schrieb:
>><(()°> ?-/

Justus schrieb:
> Seid ihr alle neben der Kappe?
> GRÖL :-]]]]]

ack cfm Jöuh!

Weiter Lustig Und Vergnügt Bis Der Arsch Im Grabe Liegt.

[Dieter R. (drei)]

A. S. schrieb:

> Die Verwendung von 3 einzelnen Bytes (nicht mal ein Array oder eine
> Struktur) ist nur sehr selten zielführend. Manchmal unterstützen
> Compiler für kleine Prozessoren sogar 24 Bit Integer direkt

Der Prozessor nicht direkt, aber der Compiler. Kann man sogar auf dieser 
Website nachlesen:

https://www.mikrocontroller.net/attachment/211304/MPLAB_XC8_C_Compiler_User_s_Guide_1_2.pdf

oder ganz aktuell beim Hersteller:

https://www.microchip.com/content/dam/mchp/documents/DEV/ProductDocuments/UserGuides/50002737D.pdf

S. 89, __uint24, little-endian

Dann braucht man exakt Null ifs und die Variable hat auch kein Byte zu 
viel.