ST Visual Develop STM8 compiler error - was mach ich falsch?

[Max M. (maxmicr)]

Hallo,

ich versuche gerade den ADC eines STM8 zu aktivieren, aber der Compiler 
liefert bei diesem Code den Fehler

13:bad struct/union operand
13:ADC_CSR undefined

#include <stm8s.h>
#include <stm8s_adc1.h>
#include <stm8s_adc2.h>

void delay_ms(uint16_t ms);
void initADC();

void initADC(){
  ADC_CR1->ADON=1; //turn ADC on
  ADC_CSR->CH |= (1<<3); //Pin D3 (AIN4) as Analog Channel
  ADC_CR1->SPSEL |= (1<<4); //Set Prescaler to f/4 (4MHz)
}

Wo genau liegt mein Fehler?

[hp-freund (Gast)]

Habe keine Ahnung vom STM8, aber hast Du einen Blick in die stm8s_adc1.h 
und stm8s_adc2.h geworfen.

[google (Gast)]

> ADC_CSR->CH

muss das nicht ADC_CR1->CH heißen?

[Max M. (maxmicr)]

Danke für eure Antworten, aber anscheinend ist die Syntax etwas anders 
(danke an hp-freund für den Hinweis mal in den Header-Dateien 
nachzuschauen). So compiliert es zumindest:

void initADC(){
  ADC1->CR1 |= ADC1_CR1_ADON; //turn ADC on
  ADC1->CSR |= (1<<3); //Pin D3 (AIN4) as Analog Channel
  ADC1->CR1 |= (1<<2); //Set Prescaler to f/4 of master (4MHz)
}

[google (Gast)]

google schrieb:
> muss das nicht ADC_CR1->CH heißen?

Nein, Deine Bezeichnung war richtig. Aber CH[0..3] sind vier Bits, in C 
ein Bitfeld. Guck in die zugehörige .h Datei, wie vorher schon 
geschrieben. Dort steht, wie Du es in Assembler ansprechen kannst. (Von 
Assembler hab ich keine Ahnung)

[Max M. (maxmicr)]

google schrieb:
> Aber CH[0..3] sind vier Bits, in C
> ein Bitfeld.

Soweit ich die Beschreibung des Registers richtig verstehe:

Bits 3:0 CH[3:0]: Channel selection bits
These bits are set and cleared by software. They select the input 
channel to be converted.
0000: Channel AIN0
0001: Channel AIN1
....
1111: Channel AIN15


müsste ich für "AIN4" 0100 schreiben, dann müsste (1<<3) doch stimmen, 
oder?

[google (Gast)]

Max M. schrieb:
> müsste ich für "AIN4" 0100 schreiben, dann müsste (1<<3) doch stimmen,
> oder?

Ja.


Er macht das zwar in C, aber ist ja nur Bitgeschubse:

http://blog.mark-stevens.co.uk/2012/09/single-scan-adc-on-the-stm8s/

Vielleicht hilft Dir das etwas, er erklärt alles immer recht gut.

[Max M. (maxmicr)]

google schrieb:
> Vielleicht hilft Dir das etwas, er erklärt alles immer recht gut.

Danke für den Link, aber da ist die Syntax auch anders als in STVD 
(warum eigentlich keine einheitliche Syntax?).

Edit: Noch eine Frage, warum bekomme ich hier den Fehler "missing 
prototype" (bei "initADC();")? Ich hab doch mit

uint16_t readAnalogValue();

die Methode ganz brav "vorinitialisiert"?

#include <stm8s.h>

void initADC();
void initADC(){
  ADC1->CR1 |= ADC1_CR1_ADON; //turn ADC on
  ADC1->CSR |= (1<<3); //Pin D3 (AIN4) as Analog Channel
  ADC1->CR1 |= (1<<2); //Set Prescaler to f/4 of master (4MHz)
}

uint16_t readAnalogValue();
uint16_t readAnalogValue(){
  if((ADC1->CSR & (1<<7)) == 1){ //check End of Conversion Bit
    uint8_t hRegister = ADC1->DRH;
    uint8_t lRegister = ADC1->DRL;
    uint16_t completeValue = hRegister << 8 | lRegister;
    return completeValue;
  }
}

void delay_ms(uint16_t ms);
void delay_ms(uint16_t ms){
  while(ms--){
    uint16_t i;
    for(i = 0; i < ms; i++){
      nop();
    }
  }
}

void main()
{
  initADC();
}

[google (Gast)]

google schrieb:
> Dort steht, wie Du es in Assembler ansprechen kannst. (Von
> Assembler hab ich keine Ahnung)

Ich hab im Titel "ST Visual Develop" gelesen und das unmittelbar mit 
Assembler assoziiert, sorry. Du bist ja in C unterwegs. Welchen Compiler 
nutzt Du?



Laß mal die "Prototypen" vorläufig weg:

> void initADC();
> uint16_t readAnalogValue();
> void delay_ms(uint16_t ms);


Wie es richtig geht und warum man die braucht, steht hier:
http://www.c-howto.de/tutorial-funktionen-funktions-prototypen.html

[Max M. (maxmicr)]

google schrieb:
> Du bist ja in C unterwegs. Welchen Compiler
> nutzt Du?

Jup, ich nutze den Cosmic C compiler. Den gibts ja seit März '16 
kostenlos ohne Codebeschränkung!

google schrieb:
> Laß mal die "Prototypen" vorläufig weg:

Anscheinend ist da mein Compiler (?) ziemlich pingelig, so 
funktionierts:

uint16_t readAnalogValue(void);
uint16_t readAnalogValue(){
  if((ADC1->CSR & (1<<7)) == 1){ //check End of Conversion Bit
    uint8_t hRegister = ADC1->DRH;
    uint8_t lRegister = ADC1->DRL;
    
    uint16_t completeValue = hRegister << 8 | lRegister;
    return completeValue;
  }
}

Anscheinend fehlt noch irgendwas bei der Initialisierung da:

if((ADC1->CSR & (1<<7)) == 1)

beim Debuggen nicht "true" ist...

[Max M. (maxmicr)]

Hm, bin leider immer noch nicht weiter gekommen, das hier ist mein Code:

/* MAIN.C file */
#include <stm8s.h>

void initADC(void);
void initADC(){
  ADC1->CR1 |= (1<<0); //turn ADC on
  ADC1->CSR |= (1<<2); //Pin D3 (AIN4) as Analog Channel
  ADC1->CR1 |= (1<<5); //Set Prescaler to f/4 of master (4MHz)
}

uint16_t readAnalogValue(void);
uint16_t readAnalogValue(){
  ADC1->CSR &= ~(1<<7);
  ADC1->CR1 |= (1<<0); //Start conversion
  if((ADC1->CSR & (1<<7)) == 1){ //check End of Conversion Bit
    uint8_t hRegister = ADC1->DRH;
    uint8_t lRegister = ADC1->DRL;
    
    uint16_t completeValue = hRegister << 8 | lRegister;
    return completeValue;
  }
}

void delay_ms(uint16_t ms);
void delay_ms(uint16_t ms){
  while(ms--){
    uint16_t i;
    for(i = 0; i < ms; i++){
      nop();
    }
  }
}

void main()
{
  GPIOC->DDR|=(1<<7); //PD3 as Output
  GPIOC->CR1|=(1<<7); //PD3 as Push Pull
  
  initADC();
  while(1){
    uint16_t adc_value = readAnalogValue();
    if(adc_value > 0){
      GPIOC->ODR |= (1<<7);//turn PD3 on
      delay_ms(250);
      GPIOC->ODR &= ~(1<<7);//turn PD3 off
      delay_ms(250);
    }
  }
}

Beim Debuggen ist der Wert der "adc_value" Variable zu Beginn "256", 
danach aber immer 0.Laut Datenblatt muss ich das erste Bit im CR1 
Register sowohl setzen, um den ADC aufzuwecken als auch um eine 
Umrechnung zu starten. Beides mache ich ja. Wo liegt nun mein Fehler?

[aSma>> (Gast)]

Servus,
dir fehlt es an elementaren Grundwissen. Man hat dir schon ein Link 
geschickt wie man richtig Prototypen deklariert. Hier ist noch ein Link:
http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/009_c_funktionen_005.htm#mje421cf9136c8c0c1fa1f340719d12e5b

 //Prototyp
void initADC(void);
void delay_ms(uint16_t ms);
uint16_t readAnalogValue(void);


//main
int main(){

return 0;
}


//funktion1
void initADC(void){
//inhalt
}


//funktion2
void delay_ms(uint16_t ms){
//inhalt
}


//funktion3
uint16_t readAnalogValue(void){
//inhalt
//return x
}

Max M. schrieb:
> Beim Debuggen ist der Wert der "adc_value" Variable zu Beginn "256",
> danach aber immer 0.Laut Datenblatt muss ich das erste Bit im CR1
> Register sowohl setzen, um den ADC aufzuwecken als auch um eine
> Umrechnung zu starten. Beides mache ich ja. Wo liegt nun mein Fehler?

Es gibt zich Beispiele. Guck Sie dir an. Debugge erstmal die Register 
durch sind diese auch richtig gesetzt? Vielleicht hast du irgendeine 
clock nicht gesetzt.

mfg

[Max M. (maxmicr)]

aSma>> schrieb:
> Man hat dir schon ein Link
> geschickt wie man richtig Prototypen deklariert.

Achso, die Reihenfolge des Codes ändert natürlich alles. Das dient 
bestenfalls der Übersichtlichkeit, ändert aber, in meinem Beispiel, 
nichts an der Funktionalität.

aSma>> schrieb:
> Es gibt zich Beispiele. Guck Sie dir an.

Wenn es wirklich so viele gäbe, hätte ich nicht gefragt.

Aber, danke für die Antwort.

[Max M. (maxmicr)]

Okay, mein Code funktioniert jetzt soweit:

/* MAIN.C file */
#include <stm8s.h>

void initADC(void);
uint16_t readAnalogValue(void);
void delay_ms(uint16_t ms);

void initADC(){
  ADC1->CR1 |= (1<<0); //turn ADC on
  ADC1->CSR |= (1<<2); //Pin D3 (AIN4) as Analog Channel
  ADC1->CR1 |= (1<<5); //Set Prescaler to f/4 of master (4MHz)
}

uint16_t readAnalogValue(){
  ADC1->CSR &= ~(1<<7); //reset End of Conversion Bit
  ADC1->CR1 |= (1<<0); //Start conversion
  delay_ms(10);
  if((ADC1->CSR & (1<<7))){ //check End of Conversion Bit
    uint8_t hRegister = ADC1->DRH;
    uint8_t lRegister = ADC1->DRL;
    
    uint16_t completeValue = hRegister << 8 | lRegister;
    return completeValue;
  }
}

void delay_ms(uint16_t ms){
  while(ms--){
    uint16_t i;
    for(i = 0; i < ms; i++){
      nop();
    }
  }
}

void main()
{
  GPIOC->DDR|=(1<<7); //PD3 as Output
  GPIOC->CR1|=(1<<7); //PD3 as Push Pull
  
  initADC();
  while(1){
    uint16_t adc_value = readAnalogValue();

    if(adc_value > 20){
      GPIOC->ODR |= (1<<7);//turn PD3 on
      delay_ms(250);
      GPIOC->ODR &= ~(1<<7);//turn PD3 off
      delay_ms(250);
    }
  }
}

Beim Debuggen werden Werte um die ~3100 angezeigt. Jetzt ist nur die 
Frage, wie ich diesen Wert wieder in die Eingangsspannung umwandel? In 
den Dokumenten finde ich keine Formel, wie der ADC-Wert berechnet wird, 
oder hab ich was übersehen?

[Christopher B. (chrimbo)]

Spannung = ADCWert * 5/65536 dann hast du es in Volt

[Max M. (maxmicr)]

Danke, das kommt hin! Aber woher hattest du diese Formel? Oder aus 
welchen Gegebenheiten erschließt sich die?

[aSma>> (Gast)]

Max M. schrieb:
> Danke, das kommt hin! Aber woher hattest du diese Formel? Oder aus
> welchen Gegebenheiten erschließt sich die?

Servus,
einfacher Dreisatz Kollega.

Wobei ich der stm8 eher 10bit ADC hat. K.A. steht alles in den 
Datenblätter.

Eine analoge Spannung wird immer durch einen ADC digitalisiert, d.h. es 
werden diskrete Werte von den gemessenen analogen Wert aufgenommen.

Annahme 10bit Auflösung: 2^10-1 ergibt 1023. stm8 hat 5 Volt ADC 
Eingänge.
Klingelt es ?

mfg

[Eric B. (beric)]

Max M. schrieb:
> müsste ich für "AIN4" 0100 schreiben, dann müsste (1<<3) doch stimmen,
> oder?

Nein. 0100 wäre (1<<2), oder einfach 4.

[Christopher B. (chrimbo)]

aSma>> schrieb:
> Wobei ich der stm8 eher 10bit ADC hat. K.A. steht alles in den
> Datenblätter.

Korrekt. Wobei ich jetzt einfach von left aligned ausgegangen bin, weil 
er einen Wert >1023 rausbekommen hat :)

[honk (Gast)]

ST stellt für den STM8 eine Lib bereit.

Sieht dann so aus und der Käse ist gegessen:

ADC1_Init(ADC1_CONVERSIONMODE_CONTINUOUS, ADC1_CHANNEL_6, 
ADC1_PRESSEL_FCPU_D18, ADC1_EXTTRIG_TIM, DISABLE, ADC1_ALIGN_RIGHT, 
ADC1_SCHMITTTRIG_CHANNEL0, DISABLE);

[Max M. (maxmicr)]

aSma>> schrieb:
> Annahme 10bit Auflösung: 2^10-1 ergibt 1023. stm8 hat 5 Volt ADC
> Eingänge.
> Klingelt es ?

Ehrlich gesagt nicht. Beim Atmega des Arduino war die Formel für mich 
eingängiger, da die Auflösung, wie du schon sagst, 2^10 beträgt. Von 
daher wäre Vref / 1024 (wie es bei den Atmegas auch ist) sinnvoller. Wie 
man auf 2^16 kommt, ist mir nicht klar.

Eric B. schrieb:
> Nein. 0100 wäre (1<<2), oder einfach 4.

Danke.

honk schrieb:
> Sieht dann so aus und der Käse ist gegessen:

Das sieht jetzt aber auch nicht wesentlich kürzer aus im Vergleich zu 
meiner Init-Funktion.

[Christopher B. (chrimbo)]

ADC1->CR2 |= (1<<3)
dann kannst du mit deinen 1024 rechnen. Warum dass so ist musst du aber 
selber herausfinden :-)

[guest (Gast)]

Max M. schrieb:
> Ehrlich gesagt nicht. Beim Atmega des Arduino war die Formel für mich
> eingängiger, da die Auflösung, wie du schon sagst, 2^10 beträgt. Von
> daher wäre Vref / 1024 (wie es bei den Atmegas auch ist) sinnvoller. Wie
> man auf 2^16 kommt, ist mir nicht klar.

Aber nur wenn das entsprechende Config-Bit 0 ist. Wenn es 1 ist muß man 
auch beim ATmega mit 2^16 rechnen (oder mit 2^8, je nachdem wie man den 
ADC Wert ausliest).