8 Bit Variable unter TI320F2808

[Markus W. (kornbanane)]

Hi,

habe folgendes Problem:

Ich programmiere gerade einen TI320F2808 DSP mit C.

Jetzt brauche ich unbedingt eine 8 Bit Variable (da ich deren Überlauf 
brauche). Das Problem ist nur, das bei diesem Controller ein char auch 
16 Bit groß ist !

Bei Ti habe ich dazu folgendes gefunden:

If char is 16 bits, how can I access 8-bit values efficiently?

To access data in increments of 8 bits, use the __byte() and 
__mov_byte() intrinsics described in TMS320C28x Optimizing C/C++ 
Compiler User's Guide (spru514).


Bei dem Users Giude http://www.ti.com/lit/ug/spru514e/spru514e.pdf steht 
auf Seite 133 was dazu. Leider versteh ich nur Bahnhof bzw. das was ich 
Probiert habe funktioniert nicht. Mehr dazu kann ich auch nicht 
finden....

Hier noch einmal wie ichs probiert habe:

Ausgangssituation:

unsigned char test='0'+'0'+'5'+'0'+'2'+'='+'?';  // Gibt laut debugger  371, da es halt ne 16 Bit Variable ist

Neue Version:

unsigned char test;
__byte(test)+=1;      /// Gibt zwei Fehler: 
"argument of type unsigned char is incompatible with parameter of type "int *"  und too few arguments in function call

Hoffe ihr könnt mir helfen, so dämliche sachen nerven echt gewaltig !! 
Ein Char sollte auch ein Char sein....

[Karl H. (kbuchegg)]

Markus Wi*** schrieb:
> Hi,
>
> habe folgendes Problem:
>
> Ich programmiere gerade einen TI320F2808 DSP mit C.
>
> Jetzt brauche ich unbedingt eine 8 Bit Variable (da ich deren Überlauf
> brauche).

Wozu brauchst du den?

unsigned char c;

   c = ( c + 1 ) & 0xFF00;

realisiert dir in c die Folge 0, 1, 2, ...., 254, 255, 0, 1, ...

> Hoffe ihr könnt mir helfen, so dämliche sachen nerven echt gewaltig !!
> Ein Char sollte auch ein Char sein....

Ist es auch.
Nur hast du vom C-Standard keine Zusicherung, dass ein C-char dasselbe 
ist, was du ein 8-Bit Byte nennst. Wir gehen zwar oft implizit davon 
aus, aber es gibt eben auch Architekturen bei denen das sinnvollerweise 
eben nicht so ist.

[Bronco (Gast)]

Markus Wi*** schrieb:
> Jetzt brauche ich unbedingt eine 8 Bit Variable (da ich deren Überlauf
> brauche).

Kannst Du das etwas genauer erklären?
Du kannst doch problemlos eine 8-Bit-Variable in einer 16-Bit-Variablen 
speichern/darstellen. Mußt halt immer nur die unteren 8 Bits anschauen.

> Leider versteh ich nur Bahnhof

Du hast Dir die Syntax von __byte() nicht näher angeschaut, was?
Da steht, daß man ein Array und einen Offset im Array angeben muß.
Dann kann

__byte(test)+=1;

natürlich nicht gehen.

Warum machst Du nicht einfach

test+=1;

und ignorierst beim Auslesen von test die oberen 8 Bit (z.B. per "& 
0x00FF")?

[Markus W. (kornbanane)]

Ja so einfach ist das nicht, es müssen wirklich 8 Bit (und dann der 
Überlauf sein), da ich die Variable benutzte um eine Checksumme zu 
berechnen.

Soll heißen ich empfange über UART ein Telegramm und am Ende des 
Telegramms ist die "aufaddierte Checksumme" aller Bytes enthalten. Diese 
Checksumme wird in einem Byte Übertragen. Und diese Checksumme hat 
natürlich wegen dem Wertebereich eines Bytes immer einen Wert zwischen 
0-255, egal wie lange mein Telegramm ist.

Ich will auch nichts an der Berechnung der Checksumme oder sonst was 
ändern, da das Gegenstück (ein anderer Controller) schon fubnktionsfähig 
ist.

Man echt wer braucht so ein scheiß... so was blödes.

Das __byte() irgendwas mit Arrays zu tun hat hab ich auch gesehn aber 
dachte es sei halt nur ein Beispiel. Kann ja nich sein, das man jetzt 
nur bei Arrays eine 8Bit Variable ansprechen kann ...

[Karl H. (kbuchegg)]

Markus Wi*** schrieb:
> Ja so einfach ist das nicht


????

> Soll heißen ich empfange über UART ein Telegramm und am Ende des
> Telegramms ist die "aufaddierte Checksumme" aller Bytes enthalten.

aufaddieren?

Doch. Dann ist es so einfach.
Genau dann ist es so einfach.

> Diese
> Checksumme wird in einem Byte Übertragen. Und diese Checksumme hat
> natürlich wegen dem Wertebereich eines Bytes immer einen Wert zwischen
> 0-255, egal wie lange mein Telegramm ist.

Und?
Von deiner berechneten Checksumme über alles, maskierst du dir zum 
Schluss die obersten 8 Bit weg und du hast den Wert zum Vergleichen. Was 
kümmern dich da Überläufe? Interessiert doch keinen.

Wenn du 8 Preise addierst

   76
   23
   18
   45
   98
 ----
  260

und da dann zum Schluss nur die Zehner+Einer benutzt, die 60, dann ist 
das genau dasselbe Ergebnis, also wie wenn du jedesmal beim 'Überlauf' 
in die Hunderter den Hunderter jeweils los wirst.

Einfach alle Bytes addieren und vom Endergebnis nur die untersten 8 Bit 
verwenden.

> Man echt wer braucht so ein scheiß... so was blödes.

Ganz ehrlich?
Es ist nicht die Programmiersprache und auch nicht diese spezielle 
C-Implementierung, die in diesem Fall das Problem darstellt :-)

[Markus W. (kornbanane)]

so habs jetzt gelöst mit der Variante von Karl Heinz Buchegger, vielen 
Dank dafür.

Trotzdem würde es mich interessieren wie man einfach eine 8 Bit Variable 
ansprechen kann

[Markus W. (kornbanane)]

> Ganz ehrlich?
>Es ist nicht die Programmiersprache und auch nicht diese spezielle
>C-Implementierung, die in diesem Fall das Problem darstellt :-)


Ja mag ja sein, aber erklähr mir doch mal den Sinn wieso der eine es so 
definiert und der andere so ...

Wenn ich 8 Bit will nehm ich char oder short, bei 16 Bit Int dann wären 
doch alle glücklich oder ?

[Karl H. (kbuchegg)]

Markus Wi*** schrieb:

> Trotzdem würde es mich interessieren wie man einfach eine 8 Bit Variable
> ansprechen kann

Gar nicht!

Genau das ist der springende Punkt.
Aber du kannst zb 2 8-Bit Einheiten in einem 16 BIt char unterbringen 
und die wieder auseinanderdröseln, wenn du das brauchst.
Du kannst aber auch einfach die obersten 8 Bit dauernd ignorieren oder 
wegmaskieren, dann hast du auch 8 Bit - realisiert in 16 Bit.


Der µC den du da hast, der ist nun mal nicht dafür gebaut, dass man mit 
ihm schnöde 8 Bit Einheiten durch die Gegend jagt. Der ist für größeres 
gebaut. Und es gibt einen Grund, warum der so gebaut ist - bei einer 
bestimmten Datenbreite hat der maximalen Durchsatz. Und genau auf diesen 
Durchsatz ist man aus.

[Bronco (Gast)]

Markus Wi*** schrieb:
> Wenn ich 8 Bit will nehm ich char oder short, bei 16 Bit Int dann wären
> doch alle glücklich oder ?

Du siehst das falsch.
Du hast einen DSP, der darauf optimiert ist, 16Bit-Zugriffe zu machen. 
Er ist auf Datendurchsatz mit fixer Wortbreite optimiert, weil das sein 
Haupteinsatzgebiet ist. Das ist halt etwas anderes ein 
General-Purpose-µC.

PS: Programmier mal in BCPL ;)

[Marco M. (marco_m)]

Wenn du zwei 8 bit Werte addierst, dann findest du den Überlauf in Bit 
9.

unsigned a=100;
unsigned b=200;

if ((a+b) & 0x100)
{
 // Überlauf!!
}

Wo genau ist jetzt also das Problem?

[Marco M. (marco_m)]

> Neue Version:
>
>

> unsigned char test;
> __byte(test)+=1;      /// Gibt zwei Fehler:
> "argument of type unsigned char is incompatible with parameter of type
> "int *"  und too few arguments in function call
>

Im TI Dokument steht eindeutig, daß __byte() zwei Parameter hat.:

int &__byte( int *array, unsigned int byte_index )

Also tippe ich mal:

unsigned int test;

__byte(&test,0)+=1; // Ändert das erste Byte von test
__byte(&test,1)-=1; // ändert das zweite Byte von test.