ADS1112 ADC Wert in Spannung rechnen

[Borsty B. (mantabernd)]

Guten Abend,

ich habe einen ADS1112 den ich über I2C im Single Ended Modus auslese.

Das Lesen der Register klappt auch.
Ich bekomme für das High Byte z.B.: 0x37 und für das Low Byte: 0xe8.

Lesen des Konfigurationsregisters klappt ebenfalls. Die Werte stimmen 
also.

So, nun muss ich ja das High- und Lowbyte zusammenbringen und wie im 
Datenblatt auf Seite 6 beschrieben umrechnen.


Also die zwei Bytes zusammenfassen erledige ich hiermit:

int highbyte = messageBuf[1];
int lowbyte = messageBuf[2];

long t = highbyte << 8 |  lowbyte;

... umrechnen eventuell so?

 double v = (double) t * 2.048/32768.0;

Und Ausgabe auf dem Display dann hiermit:

itoa( v, ausgabe,10); 
lcd_string(ausgabe);

Leider erscheint da nur 0 bzw. 1 auf dem Display :(

Vielleicht kann mir jemand einen Tipp geben und mich auf den richtigen 
Weg schupsen?


Ich arbeite mit AVR Studio und einem Attiny2313. Sprache: C.

Vielen Dank :)

[Dirk K. (dekoepi)]

Du berechnest so eine float in V, die wiederum in dein double gewandelt 
wird - du wirst also eine Dezimalzahl zwischen -2 und +2 sehen, {-2; -1; 
0; 1; 2;}.
Wenn du mV sehen willst, entferne den Punkt bei der 2.048, fertig.

[Borsty B. (mantabernd)]

Super, danke hat funktioniert.

Nun muss ich nur noch einen Weg finden die Zahl mit einem Komma aufs 
Display zu bringen...

für 8,50V steht nun nämlich z.B. 85000 auf dem Display.

bei 15V sind es 15000.

[Borsty B. (mantabernd)]

Jemand eine Idee das ohne sprintf zu machen?

Der Attiny2313 hat leider nicht genug Speicher für solche Spielereien.

[Dirk K. (dekoepi)]

Das ist doch ab hier trivial?

double v = (double) t * 2048/32768.0; 
double w = v/1000;
itoa( w, ausgabe,2); 
lcd_string(ausgabe); 
ausgabe="."; 
lcd_string(ausgabe);
itoa( (v-1000*w), ausgabe,6); 
lcd_string(ausgabe);

Je nachdem, wie deine Funktion lcd_string() funktioniert, musst du das 
natürlich etwas anpassen wegen Zeilenumbrüchen und ähnlichem. Ein wenig 
Eigeninitiative würde da tatsächlich nicht schaden.

[Borsty B. (mantabernd)]

Danke, habe eine Lösung gefunden (wobei deine wohl die schönere ist...). 
Leider passt deine Lösung nicht mehr in den Speicher. 7% zu viel, und 
das schon bei bester Optimierung.

Damit geht's aber gerade so:

int Messwert = v;
int vorKomma = Messwert / 1000; // zwei Nachkommastellen "abschneiden"
int nachKomma = Messwert % 1000; // zwei Nachkommastellen "isolieren"
      
lcd_string("Solar ");
itoa( vorKomma, ausgabe,10);
lcd_string(ausgabe);
lcd_string(",");
itoa( nachKomma, ausgabe,10);
lcd_string(ausgabe);
lcd_string("  ");

Danke für deine Unterstützung!

[DerDan (Gast)]

die lösung ist auch noch nicht ganz richtig

für 2.001 V zeigt dein Display 2.1 an !!!

[DerDan (Gast)]

Borsty B. schrieb:
> int vorKomma = Messwert / 1000; // zwei Nachkommastellen "abschneiden"
> int nachKomma = Messwert % 1000; // zwei Nachkommastellen "isolieren"

und der Typische Fehler das der Kommantar lügt

[Borsty B. (mantabernd)]

DerDan schrieb:
> die lösung ist auch noch nicht ganz richtig
>
> für 2.001 V zeigt dein Display 2.1 an !!!

Ja, würde es gerne richtig machen. Mein Programm ist nur leider für den 
Controller ohnehin schon zu groß :(

Siehe: Beitrag "C-Code optimieren (passt nicht in Attiny2313) :("

[Karl H. (kbuchegg)]

Ich denke, die einfachste Variante besteht darin, auf itoa bzw utoa zu 
verzichten und sich selbst eine entsprechende ASCII Konvertierung zu 
schreiben.
Dann ist es nämlich einfach sicherzustellen, dass die führenden 0-en 
auch tatsächlich erscheinen. Ganz im Gegenteil: führende 0-en 
wegzulassen ist Aufwand. Die dann nachträglich wieder zu ergänzen ist 
irgendwie doppelt gemoppelt.

Als Anhaltspunkt kann gleich der erste Punkt in der FAQ
FAQ
dienen. Dort kannst du dir ansehen, wie man so eine Konvertierung macht, 
wenn man sie selbst machen muss/will.

Ich denke allerdings auch:
wenn du die double Rechnerei losgeworden bist, hast du den Speicher um 
sprintf benutzen zu können. Mit den Formatiermöglichkeiten von sprintf 
wirds trivial, auch wenn sprintf etliches zum Code beitragen wird. Aber 
alleine das Ausrichten in einem Feld, so dass die Zahl bei wechselnden 
Vor bzw. Nachkomma Ziffern Anzahlen nicht dauernd hin und her springt, 
ist es schon wert. Denn auch das müsste/sollte man programmieren. Es 
gibt nichts schlimmeres, als wenn einem beim Lesen von Zahlen auf einem 
LCD die Zahl dauern links/rechts hin und herschwimmt, nur weil der 
Zahlenwert von 10.000 auf 9.999 hin und her hüpft.

Im Zweifelsfall lieber die double loswerden und dafür sprintf einsetzen 
können :-)

[Joachim B. (jar)]

Karl H. schrieb:
> Es
> gibt nichts schlimmeres, als wenn einem beim Lesen von Zahlen auf einem
> LCD die Zahl dauern links/rechts hin und herschwimmt, nur weil der
> Zahlenwert von 10.000 auf 9.999 hin und her hüpft.

denn gibt man ständig
<space>9999 oder 10000 aus und fügt an der 3 Stelle von links das Komma 
ein, reine Stringverarbeitung

[Borsty B. (mantabernd)]

Also egal wie ich's dreh oder wende, es funktioniert so nicht:

long t = highbyte << 8 |  lowbyte;
double v = (double) t * 2048/32768.0; 
double w = v/1000;
itoa( w, ausgabe,2); 
lcd_string(ausgabe); 
ausgabe="."; 
lcd_string(ausgabe);
itoa( (v-1000*w), ausgabe,6); 
lcd_string(ausgabe);

Mit diesem Code bekomme ich die mV ohne Punkt und Komma aufs Display:

t = highbyte << 8 |  lowbyte;
v = (double) t * 2048/32768.0;
lcd_setcursor( 0, 4 );
itoa( v, ausgabe,10);
lcd_string(ausgabe);

Allerdings brauch ich die Anzeige ja in Volt mit Zenertrennung...

P.S. jetzt bitte nicht am Long und double aufhängen, ich versuch das 
grad auf einem Controller mit ausreichend Platz und möchte es einfach 
mal zum laufen bringen.

[Borsty B. (mantabernd)]

Hat denn keiner eine Idee wie ich diesen 16-Bit Hex Wert des AD1112 in 
Volt umrechne?

Millivolt funktioniert ja, brauch also eigentlich nur Millivolt in Volt.

Ich steck im programmieren leider nicht tief genug drin. Auch mit 
Sprintf funktioniert es nicht wie ich es möchte :(

[Bernd N (Gast)]

Formatiert ausgeben kannst du deine Spannung z.B. so...

void AdcValOut (uint16_t AdcValue)
{
    uint8_t AdcValArray [5];                                      // Integer Array
    uint8_t m = 4;                                                // Schleifenzähler für Ausgabe

    do  {
        AdcValArray [m] = '0' + AdcValue %10;                     // Berechnung der einzelnen Stellen sowie
        AdcValue /= 10;                                           // Wandlung nach ASCII und abspeichern im
    } while (m--);                                                // Array
    while (m != 3) {                                              // Anzahl der auszugebenden Stellen = 4
        lcd_string (AdcValArray [++m]);                           // ADC Wert ausgeben
        if (m == 0) lcd_string ('.');                             // Dezimalpunkt setzen
    }
}

[Borsty B. (mantabernd)]

... irgendwie komme ich auch damit nicht klar. :(

Das Display liefert mir dabei nur wirre Zeichen.

... hab's jetzt so gelöst:

unsigned char val_array[4];
val_array[3] = v / 1000;
val_array[2] = v % 1000 / 100;
val_array[1] = v % 100 / 10;
val_array[0] = v % 10;
  
sprintf(ausgabe,"%d%d,%d%dV",val_array[3],val_array[2],val_array[1],val_array[0]);
lcd_string(ausgabe);