AD eingang auf usart ausgang legen

[Sven K. (svenku81)]

Hallo,

ich bin hier neu, habe mich aber schon durch alle möglichen threads und
tutorials gelesen... ungefähr schon 4 Wochen...
von daher ist das erständnis eigentlich ganz gut.

Jetzt die frage..

ich möchte gerne den am AD-Eingang des atmega8 anliegenden dynamischen
Wert über den Usart per Tx verschicken.

eine Umwandlung oder Verarbeitung soll nicht IM mc stattfinden, auch
Interrupts sofern möglich sollen vermieden werden. Timer / sleep /watch
dog functions ebenfalls...

die simpleste form der datenübergabe, aus varibale AD wandler in
varibale Usart.. würde ich gerne verwirklichen!

worüber ich jetzt nicht soviel weis ist die reinfolge der abarbeitung
der prog teile... wenn dazu auch jemand was sagen könnte wäre klasse.


Die arbeitsumgebung ist das Stk500 ...und AVRstudio4.12 funktioniert
auch alles super... per usart kann ich schon beliebige werte
verschicken.
wie im GCC tutorial erklärt gut erklärt worden ist.

und das AD-wandler beipspiel ist auch einwandfrei und funzt...
nur die datenübergabe nicht..!!!

Vielleicht kann mir jemand dabei helfen... wäre super nett.
ein kurzes beispiel wäre klasse.

[johnny.m (Gast)]

WAS funktioniert denn an der Datenübergabe nicht???

[Sven K. (svenku81)]

ich bekomme aus der unteren AD-wandler funktion keinen wert raus...
den ich in der main weiter benutzten kann. alle variablen sind nur
intern verwendbar . wie result etc...
irgendwie  muss es doch gehen das ich result = XY setzte
und XY in der main wie z.B
buffer = XY ;

****************
wobei buffer der eingabewert für die Usart-funktion ist

void uart_send(uint16_t buffer){
/* Warten bis der Sendepuffer frei ist */
while ( !( UCSRA & (1<<UDRE)) );
/* Daten in den Puffer schreiben und damit senden */
UDR = (buffer);
while ( !( UCSRA & (1<<UDRE)) );
}
***************************




*************************************************
uint16_t ReadChannel(uint8_t mux)
{
  uint8_t i;
  uint16_t result = 0;         //Initialisieren wichtig, da lokale
Variablen
                               //nicht automatisch initialisiert werden
und
                               //zufällige Werte haben. Sonst kann
Quatsch rauskommen
  ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0);    // Frequenzvorteiler

                               // setzen auf 8 (1) und ADC aktivieren
(1)

  ADMUX = mux;                      // Kanal waehlen
  ADMUX |= (1<<REFS1) | (1<<REFS0); // interne Referenzspannung nutzen


  /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man
liest
     also einen Wert und verwirft diesen, um den ADC "warmlaufen zu
lassen" */
  ADCSRA |= (1<<ADSC);              // eine ADC-Wandlung
  while ( ADCSRA & (1<<ADSC) ) {
     ;     // auf Abschluss der Konvertierung warten
  }

  /* Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden
Wandlungen */
  for(i=0;i<4;i++)
  {
    ADCSRA |= (1<<ADSC);            // eine Wandlung "single
conversion"
    while ( ADCSRA & (1<<ADSC) ) {
      ;   // auf Abschluss der Konvertierung warten
    }
    result += ADCW;        // Wandlungsergebnisse aufaddieren
  }
  ADCSRA &= ~(1<<ADEN);             // ADC deaktivieren (2)

  result /= 4;                     // Summe durch vier teilen = arithm.
Mittelwert

  return result;
}

[johnny.m (Gast)]

Ich glaub, da fehlen einige Grundlagen, was die Übergabe von Werten an
Funktionen oder die Rückgabe von Werten aus Funktionen angeht. Da Du
Deine main nicht mitgeschickt hast, weiß ich nicht, was Du da machst,
aber warum nicht irgendwas in der Art wie

int main(void)
{
    uint16_t ADWert;
    //...irgendwelcher Unfug
    ADWert = ReadChannel(0); //liest Wert von Kanal 0
    uart_send(ADWert);
}

Allerdings kannst Du per UART nur 8 Bits auf einmal verschicken, so
dass Du entweder in main oder in der uart_send den 16-Bit-AD-Wert auf
zwei 8-Bit-Werte aufteilen musst. Also z.B.

void uart_send(uint8_t buffer)
{
    //Wie oben
}
//...
int main(void)
{
    uint16_t ADWert;
    //...irgendwelcher Unfug
    ADWert = ReadChannel(0); //liest Wert von Kanal 0
    uart_send((uint8_t) ADWert); //Sendet Low-Byte
    uart_send((uint8_t)(ADWert >> 8); //Sendet High-Byte
}

[Sven K. (svenku81)]

das hat soweit gut geklappt
eine klammer hat gefehlt aber ansonsten ganz großen dank..



uart_send((uint8_t)(ADWert >> 8));
statt....
uart_send((uint8_t)(ADWert >> 8);

[johnny.m (Gast)]

Glückwunsch! Wollte ja nur sehen, ob Du auch selber drauf kommst und
nicht nur einfach vorgegebenen Code zusammenstückelst ohne drüber
nachzudenken;-)