STM8 und ADC

[Ralph S. (jjflash)]

Im Rahmen der Erweiterung meiner "Steckbretthelferleins" wollte ich ein 
weiteres Modul hinzufügen das eine Art "Voltmeter" fürs Steckbrett ist. 
Mit einem STM32F030 hab ich das schon auf einem Steckbrett realisiert 
und funktioniert.

Jetzt dachte ich mir: Gut, das müßte ja auch mit einem STM8S103 
funktionieren (mit 10 statt 12 Bit Auflösung könnte ich gut leben). Nach 
einem schnellen Aufbau dachte ich schon, ich wäre am Ziel, aber nach 
einer Überprüfung der Genauigkeit war ich ernüchtert !

Also allen möglichen Ballast weggeworfen, nur die allernötigste Hardware 
(ohne Eingangsspannungsteiler), Software auf Mindestmaß reduziert.

Ergebnis: Ungenügende Genauigkeit.

Minimalschaltung und Minimalprogramm im Anhang, verwendeter Compiler 
SDCC v3.6.

Problem:

Unterhalb von 0,2V Eingangsspannung zuckt der ADC mit keinem einzigen 
Bit (insgesamt mit 3 verschiedenen STM8S103 und einem STM8S003 
getestet).

Von 0 .. 0,2V liefert der ADC den Wert 0. Danach nähert er sich dem 
wirklichen Spannungswert immer mehr an. Bei einer Eingangsspanunng von 
2,0V gibt es eine Abweichung von ca. 75mV. Erst die maximale 
Eingangsspannung von 3,3V wird richtig angegeben.

Das Referenzvoltmeter ist ein Fluke 45 (im Januar diesen Jahres frisch 
kalibriert).

Gerade im Bereich von 0,0 bis 1,0V bräuchte ich es genauer, ansonsten 
macht ein Eingangsspannungsteiler keinen Sinn.

Das Auslesen des ADC geschieht mit folgendem Code:

#define adc_init(ch)         {  ADC_CSR =  (ch);                  \
                                ADC_CR1 |= ADC_CR1_ADON; }


/* ---------------------------------------------------------
                           adc_read
     liest den 10-Bit ADC und gibt den Messwert als Argument
     zurueck (Werte 0..1023)
   --------------------------------------------------------- */
uint16_t adc_read(void)
{
  uint16_t  adcvalue;

  ADC_CR1 |= ADC_CR1_ADON;            // AD-Wandlung starten
  while (!(ADC_CSR & ADC_CSR_EOX));   // warten bis Conversion beendet
  delay_us(5);                        // Warten bis Wert gelesen werden kann

  adcvalue = (ADC_DRH << 2);          // die unteren 2 Bit
  adcvalue += ADC_DRL;                // die oberen 8 Bit

  return adcvalue;
}

Woran liegt der Fehler und / oder ist es sinnvoller, mein 
Steckbrettvoltmeter dann doch eher mit einem STM32F030 zu realisieren?

[pegel (Gast)]

Es gibt eine Appnote dazu. Kennst du die?

http://www.st.com/resource/en/application_note/cd00186359.pdf

[Dr. Sommer (Gast)]

Ralph S. schrieb:
> oder ist es sinnvoller, mein
> Steckbrettvoltmeter dann doch eher mit einem STM32F030 zu realisieren?
Da der Hardware-USB hat, könntest du dir da auch den CH340G sparen und 
das Helferlein noch kleiner bauen.

[Dr. Sommer (Gast)]

Oh sorry, hat er gar nicht, das war der STM32F070.

[Ralph S. (jjflash)]

Dr. Sommer schrieb:
> Da der Hardware-USB hat, könntest du dir da auch den CH340G sparen und
> das Helferlein noch kleiner bauen.

Der CH340 ist hier nur zum Überprüfen, das Helferlein wird ein OLED 
128x64 Display haben und keine serielle Schnittstelle.

pegel schrieb:
> Es gibt eine Appnote dazu. Kennst du die?
>
> http://www.st.com/resource/en/application_note/cd00186359.pdf

Das schau ich mir jetzt gerade im Moment an...

[Ralph S. (jjflash)]

Zitat aus der App-Note:

Offset and gain errors can easily be calibrated by the application firmware. First, apply zero 
volts to the ADC input and perform a conversion, then the conversion result represents the 
zero offset error. Then perform a gain adjustment. A subsequent offset error calibration may 
be required. A useful method for offset and gain calibration is the least square method 
(which calculates the smallest error in all the used range)

Wenn es nur mal so "easily" wäre ! Das kann man dann kalibrieren, wenn 
anstelle von 0 Volt eine Spannung "detektiert" wird und man die dann 
schlicht abziehen würde. Das funktioniert aber nicht, wenn der ADC 
schlicht schon gar nicht loslegt und mittels der Referenz kann man an 
diesem Controller auch nicht "spielen" weil die Referenzanschlüsse nicht 
aufgelegt sind.

Oder (was ich schon eher glaube) ich bin nur zu doof die App-Note 
richtig zu lesen !

[Axel S. (a-za-z0-9)]

Ralph S. schrieb:

> adcvalue = (ADC_DRH << 2);          // die unteren 2 Bit
> adcvalue += ADC_DRL;                // die oberen 8 Bit

Das stimmt so nicht wirklich. Also mindestens die Kommentare sind 
falsch.

Ich lese das Datenblatt so, daß der Default left-aligned ist 
(ADC_CR2:ALIGN = 0). Die 8 MSB stehen dann in ADC_DRH und die beiden LSB 
in ADC_DRL. Dann ist das, was du programmiert hast, im Prinzip richtig, 
vorausgesetzt, der Compiler macht das Linksschieben auf allen 16 Bit und 
nicht nur auf den 8 Bit aus ADC_DRH. Im Zweifel würde ich das explizit 
formulieren:

adcvalue  = (uint16_t)ADC_DRH << 2;
adcvalue += ADC_DRL;

oder alternativ

adcvalue   = ADC_DRH;
adcvalue <<= 2;
adcvalue  += ADC_DRL;

[Ralph S. (jjflash)]

... schön wärs gewesen wenn ich nur n dummen Schiebefehler gemacht hab. 
Der Kommentar ist leider falsch (aber das Schieben richtig). Muß heißen, 
die oberen 2 Bits und die unteren 8 Bits (des 10-Bit Wertes).

Wenn der Compiler hier nicht richtig casten würde, dann würde ich nie 
einen ADC - Result von 1023 haben können (aber ich habs dennoch auch mit 
der alternativen Formulierung versucht, gleiches Problem).

Hab das jetzt erst einmal auf die Seite gelegt und werkel parallel dazu 
am gleichen Helferlein jedoch mit STM32 ... (natürlich wird mich das 
hier jedoch nicht loslassen).

[Martin B. (ratazong)]

Hallo,


ich kenn das Datenblatt nicht, aber vielleicht liegt es an ADC_DRL.

Was steht denn in den oberen bits von ADC_DRL ?

vielleicht die oberen bits von ADC_DRL vorher explizit nullen

adcvalue   = ADC_DRH;
adcvalue <<= 2;
adcvalue  += (ADC_DRL & 3);

[Ralph S. (jjflash)]

Das Zusammenschieben des Wertes ist nicht das Problem:

Bis 0,2V liefert der ADC den Wert 0 !!!!

Das zeigt auch die (überflüssiger Weisse gemachte) getrennte Ausgabe von 
ADC_DRH und ADC_DRL.

Bis 0,2V steht in den Registern 0 drin !

[neuer PIC Freund (Gast)]

Frei nach RM0016

static void adc_init(void)
{
    // write reset state
    ADC1->CSR = 0;
    ADC1->CR1 = 0;
    ADC1->CR2 = 0;
    ADC1->CR3 = 0;
    ADC1->TDRH = 0;
    ADC1->TDRL = 0;
    ADC1->HTRH = 0xFF;
    ADC1->HTRL = 0x03;
    ADC1->LTRH = 0;
    ADC1->LTRL = 0;
    ADC1->AWSRH = 0;
    ADC1->AWSRL = 0;
    ADC1->AWCRH = 0;
    ADC1->AWCRL = 0;
    
    // ADC clock 1 ... 4 MHz
    ADC1->CR1 = (ADC1->CR1 & ~ADC1_CR1_SPSEL) | (0x4 << 4); // 0x4 -> fmaster/8
    
    // disable schmitt trigger of used channels
    /* ToDO */
    
    // change default alignment
    //ADC1->CR2 |= ADC1_CR2_ALIGN;
}

static uint16_t adc_read(uint8_t channel)
{
    uint16_t adc = 0;
    uint8_t current_channel;
    
    // wake up adc
    if (!(ADC1->CR1 & ADC1_CR1_ADON))
    {
        ADC1->CR1 |= ADC1_CR1_ADON;
    }
    
    // set channel
    current_channel = ADC1->CSR & ADC1_CSR_CH;
    if (channel != current_channel)
    {
        ADC1->CSR |= (channel & ADC1_CSR_CH);
    }
    
    // start conversion
    ADC1->CSR &= ~(ADC1_CSR_EOC);
    ADC1->CR1 |= ADC1_CR1_ADON;
    
    // wait end of conversion
    while (!(ADC1->CSR & ADC1_CSR_EOC))
    {
        __asm__ ("nop");            // possible breakpoint
    }
    
    // check consistency
    if (ADC1->CR3 & ADC1_CR3_OVR)
    {
        return 0x8000;
    }
    
    // read out data
    if (ADC1->CR2 & ADC1_CR2_ALIGN)
    {
        // right aligned
        adc = ADC1->DRL;
        adc |= (ADC1->DRH << 8);
    }
    else
    {
        // left aligned
        adc = (ADC1->DRH << 2);
        adc |= ADC1->DRL;
    }
    
    return adc;
}


MAINLOOP:
    adc = adc_read(3);      // channel 3 == PD2
    
    uart_send(0x55);        // 'U'
    uart_send(adc >> 8);
    uart_send(adc & 0xFF);
    uart_send(0x55);
    
    goto MAINLOOP;

Betrieben bei 3.3V, angesteuert mit Dreiecksignal, welches über 4k7 auf 
PD2 wirkt. V_max(signal) > 3.3V, V_min(signal) < 0.0V, daher das 
clipping.

[Ralph S. (jjflash)]

Hey.... das werde ich doch glatt ausprobieren, allerdings wohl nach 
Weihnachten, die Partnerin ist da und wenn ich jetzt das Elektronikzeugs 
wieder auspacke, dann bekommt sie einen Anfall.

lach, sie sagt immer "Was du nur an den scharzen Käferlein findest, 
die eh kein Mensch mehr sehen kann".

[neuer PIC Freund (Gast)]

Da fehlt eine Maskierung beim setChannel

    // set channel
    channel &= ADC1_CSR_CH;
    current_channel = ADC1->CSR & ADC1_CSR_CH;
    if (channel != current_channel)
    {
        ADC1->CSR = (ADC1->CSR & ~(ADC1_CSR_CH)) | channel;
    }

[(º°)·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.· (Gast)]

Ein STM8S208RBT6 auf einem Evalbord ist bzgl. der ADs voellig 
unauffaellig.
Vermutlich machst einfach was flasch.

[Ralph S. (jjflash)]

Schmunzeln muss, ich geh mal schwer davon aus, dass ich etwas falsch 
mache, auf einem STM8S105 ist es auch unauffällig. Ich werde nach 
Weihnachten den Tip von Pic-Freund ausprobieren und ich werde eine 
Prototypenplatine ätzen, vor allem mit sauberen Masseleitungen und nicht 
auf dem Steckbrett. Wenn das dann nicht hilft, gebe ich auf und 
realisiere das endgültig mit einem STM32F030 (vor allem funktioniert 
hier schon die komplette Software und ist sozusagen fertig).