ADC Ausgabe zu UART viel zu schnell

[Ulli B. (Gast)]

Hi,

ich habe mir aus dem Web folgendes Programm gefischt.

/*###########################################################################
#            Spannungsmessung über A/D-Wandlung          #
#                                      #
#  Hardware:  Controller ATMega16                      #
#        Takt 3,6864MHz                        #
#        Baudrate 9600                        #
#        UART an PortD (PIN D0 und D1)                #
#        AGND mit GND verbunden                    #
#        AVCC und AREF mit VCC verbunden                #
#        folgender Spannungsteiler an PC05              #
#      VCC                                #
#       |                                #
#      R1(Poti)            R1=10k              #
#       |     --> PA5                        #
#      R2                R2=1k              #
#       |                                #
#      GND                                #
#        Hyperterminal auf dem PC (Baudrate 9600)          #
#          (ENTER->Start der Messung|andere Taste->Messung stoppen)#
#        oder das beigefügte Windows-Programm            #
#                                      #
#  Funktion:  Misst die am Port anliegende Spannnung mit Hilfe des    #
#        eingebautem Analog-Digital-Converters.            # 
#        Das Messergebnis wird über das UART weitergemeldet.      #
#                                      #
#  WinAVR:    gcc version 3.3 20030421 (prerelease)            #
#                                      #
#  Autor:    Swod                            #
#  Kontakt:  [e-mail]  http://www.thelastinstance.de    #
#                                      #
###########################################################################*/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <inttypes.h>
#include <stdlib.h>
// #include <delay.h>

#define CLK 3686400
#define BAUD 9600
#define USARTSPEED (CLK/(BAUD*16L)-1)        // Formel zur Berechnung der Werte für UBBRH/UBBRL
#define LOW(x)  ((x) & 0xFF)            // Makro zum Lowbyte Zugriff eines Word
#define HIGH(x)   (((x)  >> 8) & 0xFF)        // Makro zum Highbyte Zugriff eines Word

div_t dividend;
volatile uint8_t zeichen;                  //definiere zeichen als unsigned integer 8bit
volatile uint8_t lowByte;                  //definiere lowByte als unsigned integer 8bit
volatile uint8_t highByte;                  //definiere highByte als unsigned integer 8bit
volatile uint16_t ergebnis;                //definiere ergebnis als unsigned integer 16Bit

SIGNAL (SIG_UART_RECV)                  //Uart Receive Interrupt wurde ausgelöst
{
  zeichen = UDR;                    //den empfangenen Wert nach temp holen
}

void UART_SendByte(uint8_t data)            //sendet ein Byte über das Uart
{
  while(bit_is_clear(UCSRA, UDRE));          //warten bis UART bereit ist zum senden
  UDR = data;                      //data ausgeben
}

//sendet einen String über das Uart
void putstring(char *s)                //setze den Pointer s an den Anfang des übergebenen chararrays
{  
  while (*s != 0)                  //ist der Pointer des Zeichens=0 dann chararray zu Ende
  {
    UART_SendByte(*s);                //übergibt das Zeichen an UART_SendByte
    *s++;                      //zeigt auf das nächste Zeichen
  }
}

//initialisieren des UART
void uartinit (void)
{
  UBRRH = HIGH(USARTSPEED);              //Baudrate einstellen
  UBRRL = LOW(USARTSPEED);              //Baudrate einstellen
  UCSRB = _BV(TXEN) | _BV(RXEN) | _BV(RXCIE);    //senden, empfangen, receiveint aktivieren
  UCSRC = (1<<URSEL)|(3<<UCSZ0);            //Frame Format setzen:8data, 1stop bit (URSEL=1 -> UCSRC->Settings werden genutzt)
}

//initialisieren der I/O-schnittstellen
void ioinit (void)
{
  DDRD = 0xFF;                    //PortD als Ausgang konfigurieren
  PORTD = 0xFF;                    //Alle Ausgänge abschalten
}

//initialisieren des Analog-Digital-Converters
void adcinit (void)
{
  ADMUX = 0x05;                    //Spannungsmessung an PA5
  ADCSRA = (_BV(ADEN) | _BV(ADSC) | _BV(ADATE)) +7;  //ADC Enable|ADC Start Conversion|ADC Free Run Select + Vorteiler 128
}

void ausgabe (void)
{
  dividend = div(ergebnis, 20.46);          //Messergebnis durch 20,46 teilen (max.Darstellungswert 10 Bit/Anzahl der gewünschten Einheiten=> 1023/50)
  dividend = div(dividend.quot, 10);          //nochmalige Teilung durch 10 um im Ergebnis als Rest nur noch eine Ziffer zu haben

  switch (dividend.quot)          //Überprüfen des Divisionsergebnisses
  {
    case 0  :  putstring("0.");    //gemessene Einerstelle ist 0
          break;
    case 1  :  putstring("1.");    //gemessene Einerstelle ist 1
          break;
    case 2  :  putstring("2.");    //gemessene Einerstelle ist 2
          break;
    case 3  :  putstring("3.");    //gemessene Einerstelle ist 3
          break;
    case 4  :  putstring("4.");    //gemessene Einerstelle ist 4
          break;
    case 5  :  putstring("5.");    //gemessene Einerstelle ist 5
          break;
    default:  putstring("Error");
          break;
  }
    
  switch (dividend.rem)        //Überprüfen des Restes der Division
  {
    case 0  :  putstring("0");    //gemessene Zehntelstelle ist 0
          break;
    case 1  :  putstring("1");    //gemessene Zehntelstelle ist 1
          break;
    case 2  :  putstring("2");    //gemessene Zehntelstelle ist 2
          break;
    case 3  :  putstring("3");    //gemessene Zehntelstelle ist 3
          break;
    case 4  :  putstring("4");    //gemessene Zehntelstelle ist 4
          break;
    case 5  :  putstring("5");    //gemessene Zehntelstelle ist 5
          break;
    case 6  :  putstring("6");    //gemessene Zehntelstelle ist 6
          break;
    case 7  :  putstring("7");    //gemessene Zehntelstelle ist 7
          break;
    case 8  :  putstring("8");    //gemessene Zehntelstelle ist 8
          break;
    case 9  :  putstring("9");    //gemessene Zehntelstelle ist 9
          break;
    default:  putstring("Error");
          break;
  }
    
  putstring("V\n\r");          //Anhängen der Einheit und des LF CR an das gesendete Messergebnis
}

void messung (void)
{
  while(zeichen == 0x0D)
  {
    sbi (ADCSR, ADIF);                //ADIF-Bit Setzen(Messzyklus starten)
    loop_until_bit_is_clear(ADCSR, ADIF);      //ersten Messwert verwerfen
    sbi (ADCSR, ADIF);                //ADIF-Bit Setzen(Messzyklus starten)
    loop_until_bit_is_clear(ADCSR, ADIF);      //warten bis Messung fertig
    lowByte = ADCL;                  //immer zuerst das LowByte auslesen
    highByte = ADCH;                //dann das mittlerweile gesperrte HighByte auslesen
    ergebnis = highByte * 256 + lowByte;      //Zusammenführung von HighByte und LowByte zu einem Messwert
    
    ausgabe();
  }
}

int main(void)
{
  ioinit();                      //I/O-Schnittstellen initialisieren
  uartinit();                      //I/Os einrichten
  adcinit();                      //ADC initialisieren mit "Free Run" und Vorteiler 128
  sei ();                        //enable globale interrupts
  
  putstring("Enter druecken\n");            //zum testen Hello World ausgeben

  for(;;)                      //Loop forever
  {
    if(zeichen==0x0D)                //Solange das letzte empfangene Zeichen ein ENTER war
    {
      messung();                  //wird die Messung durchgeführt
    }
  }
}

Das macht nichts anderes als an PA5 die Spannung zu messen und dann im 
Terminal auszugeben. Funktioniert auch soweit prima.
Das Problem welches ich jetzt habe, ich moechte das Programm als 
Datenlogger einsetzen und dazu schmeisst er mir einfach zu viele Daten 
aus. Nach etwas spielen, vielleicht 1min. hatte ich schon 23000 
Datensaetze welches Excel nicht mehr verarbeiten kann, oder mein Rechner 
zu schlapp dafuer ist.

Nun die Frage. Wie stelle ich es an, dass das Programm mir nur alle 1s 
oder 10s oder 60s einen Datensatz an das Terminal uebergibt ?

Schlau wie ich bin habe ich #include <delay.h> eingebaut und wollte ein 
_delay_ms(1000) einfuegen. Nur WO ?

Ich bin in C nicht sehr weit, fange gerade erst an, also bitte erspart 
mir Antworten wie "Lerne erst mal Grundlagen oder lies irgendwelche 
Tutorials". Das tue ich schon, aber bei fuer mich relativ komplexen 
Programmen bin ich noch gnadenlos ueberfordert.

[Marius W. (mw1987)]

In der main-Schleife unter

messung();

MfG
Marius

[Karl H. (kbuchegg)]

Marius Wensing schrieb:
> In der main-Schleife unter

messung();

Das wird nicht viel bringen.

@Ulli
Aber schau mal in die Funktion messung hinein

Im Prinzip sieht die so aus

void messung (void)
{
  solange vom UART nix neues gekommen ist
  {
    den ADC auslesen

    das Messergebnis über UART ausgeben
  }
}

und da, in die Schleife, nach dem ausgeben, hängst du deinen delay rein

void messung (void)
{
  solange vom UART nix neues gekommen ist
  {
    den ADC auslesen

    das Messergebnis über UART ausgeben

    Warte 1 Sekunde
  }
}

PS: Wenn du C auf dem AVR lernen willst, dann solltest du diese Programm 
schnell ad acta legen. So programmiert man das heute nicht mehr. Schau 
ins AVR-GCC-Tutorial

[Ti Chris (Gast)]

Ich würde es gerade nicht in die Funktion packen. Denn wenn du dein 
Prog. erweiterst und es irgendwann sehr groß werden sollte, weist du 
nicht mehr warum du immer ein paar sek. stopst. Darum lieber in die 
main. Nur der Übersicht halber!

 while(1)
  {
    if(zeichen==0x0D)               
    {
      messung();                  
     _delay_ms(1000);
    }
  }

Aber Karl-Heinz hat schon recht. Das ist ein völlig veralteter Code 
(Interrupthandler).

[Karl H. (kbuchegg)]

Ti Chris schrieb:
> Ich würde es gerade nicht in die Funktion packen. Denn wenn du dein
> Prog. erweiterst und es irgendwann sehr groß werden sollte, weist du
> nicht mehr warum du immer ein paar sek. stopst.

Das Problem ist die Funktion messung() !
Die loopt solange, bis sie vom Benutzer per UART gestoppt wird!

> Darum lieber in die
> main. Nur der Übersicht halber!

Hast du recht. Dann sollte aber die while Schleife in der Funktion 
ersatzlos gestrichen weren. Die ist sowieso schlecht, weil die 
Hauptschleife diese Funktion sowieso schon erfüllt.

[spess53 (Gast)]

Hi

Der ADC kann im Free Running Mode auch durch Timer getriggert werden. 
Mit dem Timer1 lassen sich die Abstände zwischen 2 Messungen bis auf 
über 18s ausdehnen.

MfG Spess

[Ulli B. (Gast)]

Halt, Stop, Aus :)

Karl Heinz Buchegger schrieb:
> PS: Wenn du C auf dem AVR lernen willst, dann solltest du diese Programm
> schnell ad acta legen. So programmiert man das heute nicht mehr. Schau
> ins AVR-GCC-Tutorial

Ich befolge den Rat und loesche das Programm gleich aus meiner Sammlung. 
Um ein _delay_ms(); einzufuegen musste ich den compiler aktualisieren. 
Dann hat er bei dem delay zwar nicht mehr gemeckert, allerdings kennt er 
jetzt 3 andere Funktionen nicht mehr. sbi z.B.

Das AVR-GCC-Tutorial und auch das Andere habe ich schon mehrmals 
angefangen zu lesen, aber das ist fuer einen voelligen Neuling, der die 
Schule schon 20 Jahre hinter sich hat, nicht mehr ganz so einfach. Ich 
habe dazu aber auch noch ein paar Buecher besorgt und bei dem Wetter hat 
man doch sowieso mehr Lust zu hause zu bleiben.

Jedenfalls habe ich eingesehen, dass es keinen Sinn und auch keinen 
Spass macht, sich ohne Ahnung an solche Geschichten zu wagen. Denn 
weiter wie eine LED blinken zu lassen oder ein "Ich brauche Kaffee" auf 
der shell laufen zu lassen bin ich noch nicht. Ist also noch ein weiter 
Weg.

Ich danke Euch vielmals.

[Ti Chris (Gast)]

Karl Heinz Buchegger schrieb:
> Das Problem ist die Funktion messung() !
> Die loopt solange, bis sie vom Benutzer per UART gestoppt wird!

Sry. Die while habe ich garnicht gesehen. Die ist ja mal sowas von über 
:D.

[Karl H. (kbuchegg)]

Ti Chris schrieb:
> Karl Heinz Buchegger schrieb:
>> Das Problem ist die Funktion messung() !
>> Die loopt solange, bis sie vom Benutzer per UART gestoppt wird!
>
> Sry. Die while habe ich garnicht gesehen. Die ist ja mal sowas von über
> :D.

Du sagst es.
Da sind auch noch andere Sachen drinn, die man so heute einfach nicht 
mehr macht. zb die Funktion ausgabe()


Wenn ich nicht auf Flash schauen muss

void ausgabe( void )
{
  char buffer[10];
  uint16_t volt = ergebnis * 50 / 1024;

  sprintf( buffer, "%d.%0dV\n\r", volt / 10, volt % 10 );
  putstring( buffer );
}

Fertig. Ganze Bildschirmseite Code eingespart.

"Ja, aber das ist langsamer!"
Schon, aber er legt danach ja sowieso 1 Sekunde Däumchendrehen ein.