LPC 2294 ad auslesen funktionen whileschleife C

[Thorsten H. (imonkey)]

Hallo Forum,

ich habe eine funktion geschrieben mit dem ich einen belibigen der 8 
kanäle des ad auslesen kann. Diese Funktion kann ich in einer while 
schleife beliebig oft laufen lassen und mir den wert über hyperterminal 
anzeigen lassen.
soweit so gut, möchte ich nun zwei kanäle nacheinander in der while 
schleife auslesen (funktion wird zweimal nacheinander 
aufgerufen)funktioniert es auch, aber die iterationszahl der schleife 
wird nicht eingehalten.
Die schleife läuft praktisch unendlich oft durch.
Lass ich den schleifenindex ausgeben, zeigt sich das die schleife selbst 
in einer unendlichen schleife steckt z.b:1 2 3 1 2 3 1 2 3 ...

wer weis rat?

beste grüße

thorsten heimberg

[Falk B. (falk)]

Quelltext?

[Thorsten H. (imonkey)]

Quelltext main:

#include <stdio.h>                          /* I/O Functions */
#include <LPC22XX.H>                        /* LPC22XX Peripheral 
Registers */

extern void init_serial (void);

int sendchar (int ch);

long adout0 ();
long adout1 ();

//void delay (void)  {                        /* Delay Function */
//  unsigned long x;
//
//  for (x = 0; x < 400000; x++);
//}

int main (void) {

  int i=1;
  long a,b;
  double z;
  init_serial();                            /* Initialize Serial 
Interface */

  IODIR0 = 0x00000100;                      /* P0.8 defined as Output */

  while (i<=3)
  {

  IOCLR0 = 0x00000100;                    /* Turn LED On  (P0.8 = 0) */

  a=adout0();
//    delay();                                /* Delay */
  b=adout1();
//  a=i*2;
//  b=i+2;
  //z=(double)y/x;

//  printf ("wert0:\n");
  printf ("%d  %d  %d \n",i,a,b);

//  printf ("wert1:\n");
  //printf ("%d\n", y);

//  printf ("wert3:\n");
  //printf ("%f\n", z);

  IOSET0 = 0x00000100;                    /* Turn LED Off (P0.8 = 1) */

  i=i+1;

  }
}
......................................................
quelltext adout0:

//this funktion should read out the ad-converter on the
//lpc2294and return the obtained value to the main program

// channel 0

#include <LPC22XX.H>      /* LPC22XX Peripheral Registers */

long adout0 ()

{
// turn on the adc, input is ain0
long xy;

ADCR = 0xF1200B01;         //init adc
//ADCR = 0x01000000 ;      // start conversion

while (!(ADDR & 0x80000000));
xy = ADDR;
xy = xy & 0xFFC0;

xy =  xy >> 6;

ADCR = 0x040D0000;      //turn off ad

return xy;
}
...............................................................

quelltext adout1:

//this funktion should read out the ad-converter on the
//lpc2294and return the obtained value to the main program

// channel 1

#include <LPC22XX.H>      /* LPC22XX Peripheral Registers */

long adout1 ()

{
// turn on the adc, input is ain1
long x;

ADCR = 0xF1200B02;         //init adc
//ADCR = 0x01000000 ;      // start conversion

while (!(ADDR & 0x80000000));
x = ADDR;
x = x & 0xFFC0;

x =  x >> 6;

ADCR = 0x040D0000;

return x;
}

[Oliver (Gast)]

Äh, was genau passiert denn deiner Meinung nach, wenn die 
while-Bedingung false wird? Ich vermute doch, daß das Programm auf einem 
Mikrocontroller läuft, oder?

Oliver

[Falk B. (falk)]

@ Thorsten Heimberg (imonkey)

>Die schleife läuft praktisch unendlich oft durch.
>Lass ich den schleifenindex ausgeben, zeigt sich das die schleife selbst
>in einer unendlichen schleife steckt z.b:1 2 3 1 2 3 1 2 3 ...

Naja, du beendest ja nach 3 Durchläufen die main() Funktion. Was dann 
passiert ist compilerabhängig.Einige halten die CPU in einer 
Endlosschleife, deiner macht möglicherweise einen Neustart. Versuchmal 
ein while(1); nach deiner While-Schleife. Dann sollte er definitiv nur 
dreimal druchlaufen und dann anhalten.

MfG
Falk

[Andreas K. (a-k)]

> ADCR = 0xF1200B01

Wie kommst du auf diesen Wert?
Fxxxxxxx: undefinierte Bits

[Thorsten H. (imonkey)]

@ oliver

ja das programm laüft, bei bisherigen schleifen ist es so das wenn die 
while-bed. false wird nichts mehr passiert und der µC neu gestartet 
werden muss um das programm erneut ablaufen zu lassen.

hier habe ich nun den eindruck das das main-programm selbst in einer 
schleife steckt; wenn die while-bed false wird startet das main programm 
erneut, obwohl es dazu eigentlich keinen anlass geben dürfte...?

rufe ich die funktion adout1 oder adout0 in der schleife nur einmal auf 
funktioniert es auch...also main wiederholt sich nicht endlos.

[Andreas K. (a-k)]

Thorsten Heimberg wrote:

>  bei bisherigen schleifen ist es so das wenn die
> while-bed. false wird nichts mehr passiert und der µC neu gestartet
> werden muss um das programm erneut ablaufen zu lassen.

Gleicher Controller, gleicher Compiler, gleiche Startup-Routine?

Auf Controllern ist das Verhalten bei Verlassen der main() Funktion als 
undefiniert zu betrachten. Kann sein dort stoppt er, kann sein er 
startet neu, kann auch sein er spinnt.

[Thorsten H. (imonkey)]

@ falk

vielen dank falk soweit hattest du recht!
aber wieso loop er main unendlich wenn ich adout1 und adout0 
nacheinander aufrufe, und tut es nicht wenn ich nur adout1 oder adout0 
aufrufe?

beste grüße

[Thorsten H. (imonkey)]

@ andy kaiser

alles gleich...

[Falk B. (falk)]

@ Thorsten Heimberg (imonkey)

>aber wieso loop er main unendlich wenn ich adout1 und adout0
>nacheinander aufrufe, und tut es nicht wenn ich nur adout1 oder adout0
>aufrufe?

Keine Ahnung. Könnte mit den Stack zusammenhängen, ist aber eher Zufall. 
Vielleicht springt er zufällig an eine Stelle und bleibt in einer 
unkritischen Endlosschleife hängen. Sicher ist nur ein explizites 
while(1); am Ende von main().

MFG
Falk

[Andreas K. (a-k)]

> alles gleich...

Tja, dann hast du eben den Vorzug genossen, zu lernen was "undefiniert" 
heisst.

[Thorsten H. (imonkey)]

mal so, mal so, halt

vielen dank an alle die geantwortet haben!
Thorsten Heimberg

[Falk B. (falk)]

Nachtrag.

Der WinAVR läuft definiert in eine Endlosschleife.

MFG
Falk