Festkommaarithmetik

[Frank G. (frankg)]

Hallo ich habe den obigen Beitrag gelesen und will mich auch daran 
halten. Aber mein Prozessor wohl nicht.

Ich habe eine Schaltung mit einem Mega 16 aufgebaut. Die geht auch.
Am Port PA0 will ich eine Spannung messen (Zwischen 0 und 5 Volt)
Da die 5V aus 1024 Stücken bestehen, muss ich den ADC Wert *5 /1024 
nehmen.
Ich habe am Mega 16 auch eine JTAG Schnittstelle, so dass ich die 
Operationen verfolgen kann
adc16 ist das Korrekte Ergebnis vom AD Programm (uint16_t)
Der Wert soll * 5000 genommen werden und dann durch 1024 Dividiert 
werden
Dann hat man das Ergebnis im mV

        adc16 = (adcval=ADC_Read_Avg(0,10));   Das geht bei fast 4V = 
987
  adc64 =  (adc16 * 5000);               adc64 uint64_t
  adc32 = (adc16 * 5000);                adc32 uint32_t
    adcul = (adc16 * 5000);                adcul unsigned long

Nach dem schrittweisen Ausführen steht bei Wert (Watch Ansicht)
bei allen 3 Variablen 19800    anstatt  4935000   ???
Kann mir jemand helfen was ist falsch? Ich brauche nur eine Zeile, die 
aber richtig rechnet.

[m.n. (Gast)]

Frank G. schrieb:
> Ich brauche nur eine Zeile, die
> aber richtig rechnet.

Nimm "float" und dann ist es gut!

[Benjamin S. (recycler)]

versuch mal:
adc64 =  ((uint64_t)adc16) * 5000;

[Frank G. (frankg)]

m.n. schrieb:
> Nimm "float" und dann ist es gut!

Meine Variablen
volatile float adcf = 0;
volatile uint64_t adc64 = 0;
volatile uint32_t adc32 = 0;
volatile uint16_t adc16 = 0;

Wenn ich im Schritt durchgehe  adc16 = 985

adcf adc64 adc32  alle 9800 ??  (ich hatte die Zeile adcf = adc16 * 
5000);
eingefügt

[Ralph S. (jjflash)]

... unabhängig davon, dass ich den Sinn dieser Rechnerei nicht 
verstehe.... ein uint64_t gibts zwar beim avr-gcc... imho ist dieser 
allerdings dennoch bloß 32 Bit groß.

[Frank G. (frankg)]

Sinn...........
ich möchte einfach nur aus dem Wert z.B.985 die Spannung in mV 
ausrechnen und wenn bei einer Teiloperation (* 5000) schon Quatsch 
rauskommt, brauche ich mit dem Ergebnis nicht weiter rechnen.

[eProfi (Gast)]

Nimm 5000UL, dann rechnet er die Multiplikation mit 32 Bit.

[Falk B. (falk)]

@Frank G. (frankg)

>Sinn...........
>ich möchte einfach nur aus dem Wert z.B.985 die Spannung in mV
>ausrechnen

Dann solltest du den Artikel Festkommaarithmetik noch einmal in Ruhe 
lesen, dort steht nämlich alles drin. 64 Bit Operationen braucht man 
dazu mal sicher NICHT, 32 Bit reichen.

Expertentip . . .

"Wichtig ist dabei, daß "

etc. pp.

[Frank G. (frankg)]

Falk B. schrieb:
> noch einmal in Ruhe
> lesen

.......  mach ich, ich bin fast verzweifelt ABER 5000UL GEHT......Danke

[Christian S. (roehrenvorheizer)]

Beitrag "ADC-Wert in Spannung umrechnen"

Mfg

[eProfi (Gast)]

Viele Wege führen nach Rom:

1024 und 5000 kann man maximal um 8 kürzen, am besten durch 4, es 
bleiben
256 und 1250
d.h. statt der Division durch 256 lässt man das unterste Byte weg.

Aber es gibt noch eine elegantere Lösung, wenn man sich die Bits und 
deren Wertigkeit ansieht:

Bit Wert mV
 9  512  2500
 8  256  1250
 7  128   625
 6   64   312,5
 5   32   156,25
 4   16    78,125
 3    8    39,0625
 2    4    19,53125
 1    2     9,765625
 0    1     4,8828125

uint16_t mask = 512, add = 2500, mV = 0;
do{
  if(adc & mask) mV+=add;
  add >>=1;
  }while((mask>>=1)!=0);
//Dann ist die maximale Summe: 2500+1250+625+312+156+78+39+19+9+4= 4992

//Genauer ist wegen Runden:
uint16_t mask = 512, add = 2500, mV = 0;
do{if(adc & mask) mV+=add; add >>=1;} while((mask>>=1)>4);add = 20;  // mask ist jetzt 4
do{if(adc & mask) mV+=add; add >>=1;} while((mask>>=1)!=0);

//Dann ist die maximale Summe: 2500+1250+625+312+156+78+39+20+10+5= 4995

//Man kann auch Loop-Unrolling machen, ist auch nicht viel länger, aber schneller:
uint16_t mV = 0;
  if(adc & 512) mV+=2500;
  if(adc & 256) mV+=1250;
  if(adc & 128) mV+=625;
  if(adc &  64) mV+=312;
  if(adc &  32) mV+=156;
  if(adc &  16) mV+=78;
  if(adc &   8) mV+=39;
  if(adc &   4) mV+=20;
  if(adc &   2) mV+=10;
  if(adc &   1) mV+=5;

Noch schneller wird es, wenn wir den ADC-Wert in zwei Bytes zerlegen:
uint16_t mV = 0;adch = ADCH; adcl = ADCL; 
//zwischenspeichern, damit sich nichts während der Abfrage ändert
  if(adch &   2) mV+=2500;
  if(adch &   1) mV+=1250;
  if(adcl & 128) mV+=625;
  if(adcl &  64) mV+=312;
  if(adcl &  32) mV+=156;
  if(adcl &  16) mV+=78;
  if(adcl &   8) mV+=39;
  if(adcl &   4) mV+=20;
  if(adcl &   2) mV+=10;
  if(adcl &   1) mV+=5;

Alles aus dem Stegreif und ungetestet.

[S. R. (svenska)]

Ralph S. schrieb:
> ein uint64_t gibts zwar beim avr-gcc... imho ist dieser
> allerdings dennoch bloß 32 Bit groß.

Das ist falsch. Wo ein int64 draufsteht, ist auch ein int64 drin.

Aber: "double" und "float" sind auf dem AVR gleich.

[eProfi (Gast)]

Wenn man bei adc 1023  5000mV angezeigt haben will:

  if(adch &   2) mV+=2500;
  if(adch &   1) mV+=1250;
  if(adcl & 128) mV+= 626;
  if(adcl &  64) mV+= 313;
  if(adcl &  32) mV+= 157;
  if(adcl &  16) mV+=  79;
  if(adcl &   8) mV+=  40;
  if(adcl &   4) mV+=  20;
  if(adcl &   2) mV+=  10;
  if(adcl &   1) mV+=   5;

Wenn bei adc 1023  3300 mV angezeigt werden soll:
  if(adch &   2) mV+=1650;
  if(adch &   1) mV+= 826;
  if(adcl & 128) mV+= 413;
  if(adcl &  64) mV+= 207;
  if(adcl &  32) mV+= 104;
  if(adcl &  16) mV+=  52;
  if(adcl &   8) mV+=  26;
  if(adcl &   4) mV+=  13;
  if(adcl &   2) mV+=   6;
  if(adcl &   1) mV+=   3;

Wenn bei adc 1023  3297 mV angezeigt werden soll:
  if(adch &   2) mV+=1650;
  if(adch &   1) mV+= 825;
  if(adcl & 128) mV+= 413;
  if(adcl &  64) mV+= 206;
  if(adcl &  32) mV+= 103;
  if(adcl &  16) mV+=  52;
  if(adcl &   8) mV+=  26;
  if(adcl &   4) mV+=  13;
  if(adcl &   2) mV+=   6;
  if(adcl &   1) mV+=   3;

[Falk B. (falk)]

@eProfi (Gast)

>Alles aus dem Stegreif und ungetestet.

Und auch völlig daneben. Der Op wollte nicht mehr als einen ADC-Wert in 
ein eine Meßgröße umrechnen und nicht irgendwelche Exkurse in die Welt 
der Micro- und Nonsensoptimierung unternehmen. Das Ziel erreicht man mit 
einer einfachen, übersichlichtlichen Zeile C-Code, die zu 99% auch 
vollkommen ausreicht.

[eProfi (Gast)]

Es geht noch schneller, wenn man die Reihenfolge umdreht und die ersten 
Additionen (solange die Summe in 8 Bit passt), mit 8 Bit ausführt:

typedef union{
  uint16_t W; /Word
  struct{
    uint8_t L; //Lo-Byte (Reihenfolge je nach Endianess)
    uint8_t H; //Hi-Byte (Reihenfolge je nach Endian-ness)
  };
} un_i16;

  un_i16 mV;
  mV.W=0;
  if(adcl &   1) mV.L+=   5; //8-Bit-Addition
  if(adcl &   2) mV.L+=  10;
  if(adcl &   4) mV.L+=  20;
  if(adcl &   8) mV.L+=  40;
  if(adcl &  16) mV.L+=  79;
  if(adcl &  32) mV.W+= 157; //16-Bit-Addition
  if(adcl &  64) mV.W+= 313;
  if(adcl & 128) mV.W+= 626;
  if(adch &   1) mV.W+=1250;
  if(adch &   2) mV.W+=2500;

//bei 3300 geht noch eine Zeile mehr mit .L:
  mV.W=0;
  if(adcl &   1) mV.L+=   3; //8-Bit-Addition
  if(adcl &   2) mV.L+=   6;
  if(adcl &   4) mV.L+=  13;
  if(adcl &   8) mV.L+=  26;
  if(adcl &  16) mV.L+=  52;
  if(adcl &  32) mV.L+= 104;
  if(adcl &  64) mV.W+= 207; //16-Bit-Addition
  if(adcl & 128) mV.W+= 413;
  if(adch &   1) mV.W+= 826;
  if(adch &   2) mV.W+=1650;

Um den vollen 16-bit-Wertebereich zu nutzen, kann man die addierten 
Werte mit 8 (nur 4 shifts), 10 (human readable), 13 (65535/5000=13,107), 
16 (nur 4 shifts) oder 19 (65535/3300=19,859) multiplizieren (dadurch 
werden sie genauer) und nach den Additionen wieder dividieren, bringt 
aber fast nichts.