STM8S ADC Problem

[Christoph R. (christoph_r463)]

Hallo Zusammen,

Ich versuche gerade irgendwie einen random Seed für mein rand() auf 
einem STM8S003F3P6 zu erzeugen. Da mein Pin D3 noch nicht beschaltet ist 
(hängt in der Luft), dachte ich mir, ich könnte einfach das Rauschen des 
Pins via ADC messen und mir daraus den Seed generieren.

#define ADC_PORT                            GPIOD   
#define ADC_PIN                             GPIO_PIN_3
#define ADC_CHANNEL                         ADC1_CHANNEL_4


static void locADCConfig(void)
{
  /* initialize ADC pin */
  GPIO_Init(ADC_PORT, ADC_PIN, GPIO_MODE_IN_FL_NO_IT);

  /* De-Init ADC1 peripheral */
  ADC1_DeInit();   

  /* init */
  ADC1_Init(ADC1_CONVERSIONMODE_CONTINUOUS, 
            ADC1_CHANNEL_4,// AIN4 -> PD3
            ADC1_PRESSEL_FCPU_D2, 
            ADC1_EXTTRIG_TIM, 
            DISABLE, 
            ADC1_ALIGN_RIGHT, 
            ADC1_SCHMITTTRIG_CHANNEL4,
            DISABLE);  
    
  ADC1_StartConversion();       
        
  return;
}

Wenn ich nun in der main in einer Schleife den ADC Wert abfrage, bekomme 
ich immer den selben Wert.

locADCConfig();

while(1)
{
   wValue = ADC1_GetConversionValue();
   _delay_ms(1000);
}

Der Wert ist zum Beispiel 0x9C00, auch nach dem Neustart und wenn ich 
den Finger auf den ADC-Pin lege. Füge ich irgendwo Code hinzu und 
kompiliere, ist der Wert meist ein anderer, zum Beispiel 0x9500.

Was kann da falsch sein?
Grüße
Chris

[Max M. (maxmicr)]

Hi,
wie sieht deine "GetConversion" aus? Oder ist das eine Funktion aus der 
stm8s_adc.h ?

[Christoph R. (christoph_r463)]

Max M. schrieb:
> Hi,
> wie sieht deine "GetConversion" aus? Oder ist das eine Funktion aus der
> stm8s_adc.h ?

Hi Max,

ja genau, das ist eine Library Funktion vom STM

uint16_t ADC1_GetConversionValue(void)
{
  uint16_t temph = 0;
  uint8_t templ = 0;
  
  if ((ADC1->CR2 & ADC1_CR2_ALIGN) != 0) /* Right alignment */
  {
    /* Read LSB first */
    templ = ADC1->DRL;
    /* Then read MSB */
    temph = ADC1->DRH;
    
    temph = (uint16_t)(templ | (uint16_t)(temph << (uint8_t)8));
  }
  else /* Left alignment */
  {
    /* Read MSB first*/
    temph = ADC1->DRH;
    /* Then read LSB */
    templ = ADC1->DRL;
    
    temph = (uint16_t)((uint16_t)((uint16_t)templ << 6) | (uint16_t)((uint16_t)temph << 8));
  }
  
  return ((uint16_t)temph);
}

[Christoph R. (christoph_r463)]

Hallo Zusammen,

mittlerweile habe ich es noch auf einem 2ten, identischen Board 
ausprobiert und dort bekomme ich die gleichen Werte wie beim ersten 
Board.

Auch habe ich mit den Flags getestet:

while(1)
{

  while(RESET == ADC1_GetFlagStatus(ADC1_FLAG_EOC));
  ADC1_ClearFlag(ADC1_FLAG_EOC);
  
  byLow = ADC1->DRL;
  byHigh =  ADC1->DRH;
  
  ADC1_StartConversion();
  
  _delay_ms(1000);
}

Auch am Mode (continuous und single) des ADC1 habe experimentiert, - 
alles unverändert.

Der ADC scheint einfach nicht zu wandeln.

Die Werte lese ich immer via Debugger aus, - kann es da evtl noch ein 
Problem geben, dass im Debug-Mode da etwas nicht eingeschaltet wird?

Grüße
Chris

[Ingo L. (corrtexx)]

Muss man bei den STm8 auch den Clock für die Peripherie per Hand 
einschalten? Falls ja, sehe ich das nirgends...

[Christoph R. (christoph_r463)]

Hallo Alle miteinander,

das Problem lag tatsächlich nicht am ADC... der läuft wunderbar. Das 
Problem lag an meiner Variablen, die ich mit dem Debugger abfrage...
Es kommt darauf an, wo ich die Variable wValue definiere. Definiere ich 
sie einmal und lasse sie immer wieder überschreiben, denkt der Kompiler 
scheinbar, er müsse die Variable nicht mit jedem Durchlauf der While(1) 
Schleife aktualisieren.

NOT OK:

unsigned int wValue = 0;

while(1)
{
   wValue = ADC1_GetConversionValue();
   _delay_ms(1000);
}

vs.

OK:

while(1)
{
   unsigned int wValue = ADC1_GetConversionValue();
   _delay_ms(1000);
}

volatile vor die Variable geht natürlich auch.

Grüße und Danke für den Input!
Chris

[Ingo L. (corrtexx)]

Christoph R. schrieb:
> denkt der Kompiler
> scheinbar, er müsse die Variable nicht mit jedem Durchlauf der While(1)
> Schleife aktualisieren.
Nee, er optimiert dein Programm einfach gänzlich weg, da du die Variable 
nicht weiter benutzt und dein Programm nichts weiter tut. Macht er 
richtig so... Normalerweise spuckt er aber auch ne Warnung ala "unused 
Variable" aus, die du wahrscheinlich nicht beachtet hast.

[Christoph R. (christoph_r463)]

In meinem Fall hat der Kompiler wegoptimiert, das der Wert meiner 
Variable mit dem tatsächlichen Wert in der Hardware synchronisiert wird 
(Unused ist sie nicht. Hinter dieser "Testschleife" kommt noch mein 
komplettes Programm und da wird mit der Variablen gerechnet.). Mit 
volatile "erzwingt" man das und dann gehts dann auch.