Zu deiner Interrupt Funktion kann ich nicht viel sagen, kenne deinen
Prozessor nicht und weiß daher nicht, ob das so alles koscher ist. Die
Routine selbst ist aber dem Ansehen nach ziemlich kurz und sieht soweit
vernünftig aus.
Das hier
1 | do {
|
2 | Zaehler1 = 0;
|
3 | Wert_Eingelesen = 0;
|
4 | do{
|
5 | if (Zaehler1 > 0){
|
6 | Wert_Eingelesen <<= 1;
|
7 | Wert_Eingelesen |= Wert_Array[Zaehler1];
|
8 | ++Zaehler1;
|
9 | }
|
10 | else{
|
11 | Minuswert = Wert_Array[Zaehler1];
|
12 | ++Zaehler1;
|
13 | }
|
14 | }while (Zaehler1 < 24);
|
kannst du auch kürzer schreiben. den if-else in der innersten Schleife
brauchst du im Grunde nicht, da gehts es ja nur darum, dass der erste
Wert im Wert_Array anders behandelt wird. Das kannst du aber auch vor
die Schleife ziehen
1 | Wert_Eingelesen = 0;
|
2 | Minuswert = Wert_Array[0];
|
3 | Zaehler1 = 1;
|
4 | do {
|
5 | Wert_Eingelesen <<= 1;
|
6 | Wert_Eingelesen |= Wert_Array[Zaehler1];
|
7 | ++Zaehler1;
|
8 | } while (Zaehler1 < 24);
|
Und damit könnte man dann auch die do-while Schleife gegen die
universellere und hier wohl auch angebrachtere for-Schleife austauschen
1 | Wert_Eingelesen = 0;
|
2 | Minuswert = Wert_Array[0];
|
3 | for( Zaehler1 = 1; Zaehler1 < 24; ++Zaehler1 )
|
4 | Wert_Eingelesen = ( Wert_Eingelesen << 1 ) | Wert_Array[Zaehler1];
|
Zugegeben: die letzte Transformation ist mehr syntaktischer Zucker als
sonst was.
Auch der Sinn der Variablen Minuswert ist dann etwas fraglich. Warum in
eine andere Variable umkopieren und nicht in weiterer Folge nicht gleich
Wert_Array[0] verwenden? OK. Der Compiler wird die Variable
wahrscheinlich sowieso selbst rausschmeissen und diese Transformation
machen, ich seh allerdings auch keinen wesentlichen dokumentarischen
Wert in dieser Umkopiererei. Ein kleiner Kommentar an der Stelle
1 | if (Wert_Array[0]){ // wenn negativ
|
2 | Rechnungswert = (~Wert_Eingelesen & 8388607);
|
3 | }
|
4 | else{
|
5 | Rechnungswert = Wert_Eingelesen;
|
6 | }
|
erfüllt den gleichen Zweck und ist vielleicht klarer als der Umweg über
eine Zwischenvariable.
Was du dir aber überlegen solltest (und da kommt jetzt wieder meine
Unkentnis des Prozessors ins Spiel): Ich habe in main nichts gesehen,
was mich an Interrupts zulassen/sperren erinnert. Was passiert
eigentlich, wenn genau während dieser Ausleserei ein Interrupt zuschlägt
und das Wert_Array verändert?
> Rechnungswert = (~Wert_Eingelesen & 8388607);
Das würde ich nicht so schreiben. Die Zahl 8399607 sieht da etwas
seltsam aus. In Hex geschrieben, wäre das
1 | Rechnungswert = (~Wert_Eingelesen & 0x7FFFFF);
|
und jetzt sieht der kundige C-Leser dann auch, dass das offenbar eine
Maskierung sein soll, die die untersten 23 Bits herausmaskiert. An
dieser Stelle ist die Hex-Zahl dem Verständnis wesentlich zuträglicher
als die Dezimalzahl.
(PS: Bist du dir sicher, dass negative Zahlen lediglich durch Bitumkehr
dargestellt werden, also im Einerkomplement. Ist etwas unüblich.
Normalerweise benutzt man das 2-er Komplement: Alle Bits umdrehen und 1
dazuzählen.)
Thread beobachten
Seitenaufteilung abschalten