Atmega spinnt, weil er nichts zu tun hat??

[Carsten (Gast)]

Hallo,
ich zweifle gerade an meinem logischen Denken.. Folgendes:
Poti an ATMEGA, Ausgabe des Wertes (0-1023) auf ein LCD Display.
Wenn ich diesen Code so ausführe, zeigt mir mein Display immer den 
korrekten Wert des ADC.

Jetzt will ich aber, dass das Display nur refresht wird, wenn sich der 
Wert ändert. Ich füge also die mit 1 bis 3 markierten Zeilen in die 
if-Abfrage (Sternchen) ein.

Aber jetzt friert mein Controller nach wenigen Zyklen ein, dh. es wird 
ein Wert angezeigt, aber am Poti drehen bewirkt gar nichts mehr.
Wenn ich schnell genug drehe, kann ich den Zeitpunkt hinauszögern...

Kann es sein, dass der Controller spinnt, weil er nichts zu tun hat??

Für Tips wäre ich sehr dankbar!

while(1){

aktuellerAdcWert = ADC_auslesen(0);

lcdClear();                          // 1
lcdWriteString("Wert: ");            // 2
lcdWriteNumber(aktuellerAdcWert);    // 3

if(aktuellerAdcWert != alterWert){
     alterWert = aktuellerAdcWert;
     // ***********
     }

}

[Paul P. (dorpreuss)]

Hallo,

alterWert = aktuellerAdcWert muss außerhalb der Bedingung stehen.

[bitte löschen (Gast)]

Er hat ja zu tun. Er liest ständig ADC-Werte ein.

Zeig' doch mal das ganze Listing und einen Schaltplan, dass man Deinen 
Aufbau exakt reproduzieren kann. Meist liegt der Fehler doch ganz 
woanders..

[Chris D. (m8nix)]

Nur so ne Idee.....

kann es sein das die Funktion " ADC_auslesen(0)" schon eine neue 
Wandlung startet bevor die alte beendet ist ???

Gruß
Chris

[Carsten G. (carry)]

Hi,

wie genau sieht denn 'ADC_auslesen' aus?

Ich könnte mir Vorstellen, dass der ständige Aufruf in der 
While-Schleife zu einem Fehler führt, da evtl. nicht korrekt gewartet 
wird bis der ADC fertig ist. Durch die LCD Routinen (außerhalb der 
IF-Abfrage) wird wahrscheinlich der Aufruf genügend lange verzögert, so 
dass der Fehler nicht auffält.


Carsten G.

[bitte löschen (Gast)]

Paul P. schrieb:
> alterWert = aktuellerAdcWert muss außerhalb der Bedingung stehen.

Und das ändert .., weil ..?

[Paul P. (dorpreuss)]

Hehe,

das ändert wirklich nichts... Ich hatte mal so ein ähnliches Beispiel 
und da war es so, wie ich geschrieben hatte. Vergesst es einfach, ich 
habe nicht richtig hingeschaut und bitte um Entschuldigung.

Wenn das ganze aber vorher funktioniert hat, denke ich nicht, dass es an 
irgend einem Timing liegt. Man kann zwar in die ADC_auslesen-Funktion 
nicht reinschauen...

Vielleicht ist alterWert nur ein 8-Bit Typ und es hängt da irgendwo.

[Carsten (Gast)]

Danke für die Antworten schonmal!

Hier ist der gesamte Code.
Der ADC-Wert wird erst ausgelesen, wenn er fertig ist. Von daher glaube 
ich nicht, dass es für den ADC zu schnell geht..

#include <avr/io.h>
#include <avr/interrupt.h>
#define F_CPU 1000000
#include <util/delay.h>

#define  DB4     PD0 //Datenbit 5 
#define  DB5     PD1  
#define  DB6     PD2  
#define  DB7     PD3 
#define RegSelect   PD4
#define RW      PD5
#define Enable     PD6 
#define LCD_Port   PORTD
#define enableDelay  1000 //µs
 
#define  Poti1    PC0
#define Backlight  PC5

//Variablen----------------------------------
char AusgabeString[];
uint8_t Interrupt0Zaehler =0 ;
uint8_t sekunde = 0;

uint16_t alterAdcWert =0;
uint16_t aktuellerAdcWert=0; 

//Prototypen der Funktionen------------------
void adcInit(void);
void lcdInit(void);
void enable(void);
void lcdClear(void);
void schreibeZeichen(unsigned char temp1);
void lcdWriteString(char *data);
void lcdWriteNumber(uint16_t z);
uint16_t ADC_auslesen(uint8_t adcSource);

//ISR-------------------------------------------
ISR (TIMER0_COMPA_vect){
Interrupt0Zaehler++;
}



int main (void) {
DDRB  =  0b00;      // Taster
DDRC  =  0b00100000;    // ADC und Backlight
PORTC  =  0x00;
DDRD  =  0xff;        // LCD (Ausgang) 


//Timer für Sekunden
TCCR0A    |=  (1<<WGM01);        //löscht timer wert bei interrupt
TCCR0B    |=  ((1<<CS01)|(1<<CS00));  // Prescaler 64
OCR0A     =  0x7D;          //8 Bit Register mit Wert, bei dem der Compare Match etzeugt wird
TIMSK0    |=  (1<<OCIE0A);       //Timer Interrupt Mask Register, Enable Compare Match Interrupt
TIFR0    |=  (1<<OCF1A);        //Flag (durch setzen von 1!) löschen, damit nicht sofort in ISR(comp_vect) gesprungen wird



//------------------
adcInit();
lcdInit();
sei();

while(1){

aktuellerAdcWert = ADC_auslesen(0)*5;

lcdClear();
lcdWriteString("Wert: ");
lcdWriteNumber(aktuellerAdcWert);


if(aktuellerAdcWert != alterAdcWert){
alterAdcWert = aktuellerAdcWert;
}


}//while..
}//main






//Funktionen------------------------------------
void adcInit(void){
//AD Wandler
ADMUX  = 0x00;
ADMUX  |=  (1<<REFS0); //interne Referenz Vcc
ADCSRA  |=  ((1<<ADEN)|(1<<ADSC)|(1<<ADPS0)|(1<<ADPS2)|(1<<ADPS1));//AD enable, AD Prescaler (ADC sollte zw. 50 und 100 kHz liegen, hier PSC=64)
//ERGEBNIS STEHT IN ADCH und ADCL (10Bit)

//Dummyreadout
while ( ADCSRA & (1<<ADSC) ) {} // auf Abschluss der Konvertierung warten}
uint16_t dummyResult = ADCW;
}


void lcdInit(void){
  LCD_Port  =  0x00;
  _delay_ms(20);    //Boot Zeit

  LCD_Port  |=  ((1<<DB4)|(1<<DB5));
  _delay_ms(5);
  enable();

  _delay_ms(5);
  enable();

  _delay_ms(5);
  enable();

  _delay_ms(5);

  //--------------------------------------------------------
  LCD_Port  = 0x00;
  LCD_Port  |=  (1<<DB5); //4 Bit Ansteuerung
  _delay_ms(5);
  enable();
  //--------------------------------------------------------
//  LCD_Port  |=  (1<<DB5); //2-zeilig, 5x8
  _delay_ms(5);
  enable();
  LCD_Port  |=  (1<<DB7); 
  _delay_ms(5);
  enable();
  //--------------------------------------------------------



  LCD_Port  = 0x00;
  _delay_ms(5);
  enable();
  LCD_Port  |= ((1<<DB7)|(1<<DB6));//|(1<<DB5)|(1<<DB4));
  _delay_ms(5);
  enable();
  _delay_ms(10);

}

void enable(void) {  
        
  LCD_Port    |= (1<<Enable);
  _delay_us(enableDelay);
  LCD_Port    &= ~(1<<Enable);
  _delay_us(enableDelay);
}



void lcdClear(void){
  LCD_Port &=~(1<<RegSelect);      //jetzt kommt Steuerbefehl
  _delay_us(10);
  LCD_Port  =  0x00;  //Display löschen
  enable();
  LCD_Port  |=  (1<<DB4); 
  enable();

}





void schreibeZeichen(unsigned char temp1)
{
   unsigned char temp2 = temp1;
 
   LCD_Port |= (1<<RegSelect);        // RS auf 1 setzen
 
   temp1 = temp1 >> 4;        // übergebenes Byte wird um 4 Stellen nach rechts verschoben, links 4 Nullen
   temp1 = temp1 & 0x0F;      // Obere 4 Bit bleiben wie sie sind, untere werden gelöscht
   LCD_Port &= 0xF0;        // Untere 4 Bit werden gesetzt zur Übertragung der ersten 4 Bit
   LCD_Port |= temp1;               // setzen
   enable();
   //Das Selbe für die zweiten 4 Bit
   temp2 = temp2 & 0x0F;
   LCD_Port &= 0xF0;
   LCD_Port |= temp2;               // setzen
   enable();
   
   _delay_us(5);
}


// Schreibt einen String auf das LCD
 
void lcdWriteString(char *data){
  char *data_2;
  data_2=data;//String merken

// Schreibt die ersten 16 zeichen des Strings
  
  while(*data){
  schreibeZeichen(*data);
    data++;
  }
}


void lcdWriteNumber(uint16_t z)
{
    uint16_t i;
  uint16_t temp;
  uint16_t Dez;
    uint8_t k;                      // Merker ob vorne 0 ist
    k=0;
    Dez=100;                  // Dezimalstellen, z.B. bei 2 Stellen 10 eintragen
    while (Dez)                 // Solange Dezimalstelle nicht 0 ist
    {
        if(Dez==1) k=1;         // Um ein einzige 0 anzeigen können
        i=z/Dez;                // Wert der jeweilige Dezimalstelle bestimmen
        temp=i*Dez;
        z=z-temp;
        if(i||k)                // Damit wir vorne keine Nullen stehen haben.
        {
            schreibeZeichen((char)i+0x30);
            k=1;                // es gab schon eine Zahl die nicht 0 ist
        }
        else                    // wen 0 ist und vorne keine Zahl war, dann
        {
            schreibeZeichen(' ');  // Leerzeichen ausgeben
        }
        Dez=Dez/10;
    }
}

uint16_t ADC_auslesen(uint8_t adcSource){

uint16_t adcResult =0;
ADMUX = (ADMUX & ~(0x1F)) | (adcSource & 0x1F);

for (uint8_t i=0;i<8;i++){
ADCSRA  |=  (1<<ADSC); //Start
while  ((ADCSRA & (1<<ADSC))==0){}

adcResult += ADCW;}
return (uint16_t)(adcResult/128);


}

[Chris D. (m8nix)]

> Hi,

> wie genau sieht denn 'ADC_auslesen' aus?

> Ich könnte mir Vorstellen, dass der ständige Aufruf in der
> While-Schleife zu einem Fehler führt, da evtl. nicht korrekt gewartet
> wird bis der ADC fertig ist. Durch die LCD Routinen (außerhalb der
> IF-Abfrage) wird wahrscheinlich der Aufruf genügend lange verzögert, so
> dass der Fehler nicht auffält.

.... möglich :-)
Bau doch mal zu Versuchszwecken ein Delay ausserhalb Deiner Schleife 
ein, was länger ist als die Wandlungszeit.


öhm Edit..... Ausserhalb der if-Bedingung..

[bitte löschen (Gast)]

Ich weiß, dass sich der entsprechende Schaltplan aus dem Listing 
extrapolieren lässt, aber es ist sicher einfacher für alle, wenn Du ihn 
schnell hier herein stellst.

Wenn Du noch einen Pin frei hast, könntest Du den am Anfang von 
ADC_auslesen high und am Ende auf low setzten, und schauen, was das Oszi 
an dem Pin sagt.

Vielleicht baue ich das morgen mal nach..

[Carsten (Gast)]

Super!

Hat geklappt!!


DANKE!


ich dachte eigentlich, dass man mit der zeile
while  ((ADCSRA & (1<<ADSC))==0){}

wartet, bis die conversion fertig ist...  verstehe ich irgendwie nicht.
Aber schön dass es geht!

[Paul P. (dorpreuss)]

((ADCSRA & (1<<ADSC))==0){} ?

ADSC will read as one as long as a conversion is in progress. When the 
conversion is complete,  it returns to zero. Writing zero to this bit 
has no effect.

Das kann doch vorher nie funktioniert haben!?

[Chris D. (m8nix)]

Wieso nicht?

vorher war immer die LCD-Routine mit entsprechendem Delay im Weg.

[Paul P. (dorpreuss)]

Schade zu spät. Ich dachte schon ich könnte meinen Fauxpas ausbügeln.

Die Hauptsache ist, dass es jetzt funktioniert.

[Chris D. (m8nix)]

Das ist doch egal...

wichtig ist das Ergebnis

[Paul P. (dorpreuss)]

Chris D. schrieb:
> Wieso nicht?
>
> vorher war immer die LCD-Routine mit entsprechendem Delay im Weg.

Ja, aber in der for-Schleife wird der Mittelwert über 8 Wandlungen 
gebildet die aber eigentlich nur aus einer Messung besteht, weil das 
blockierende Polling nicht greift.

[Chris D. (m8nix)]

Hm.... also ich mache das immer so:

nachdem ich einen ADC-Wert eingelesen hab, starte ich schon die nächste 
Wandlung, ob ich die nun benötige oder nicht. Wenn ich sie benötige, 
erspare ich mir meist die Wartezeit bis das Wandlerflag gesetzt ist.

[Michel (Gast)]

Paul P. schrieb:
> alterWert = aktuellerAdcWert muss außerhalb der Bedingung stehen.

Wieso? Wenn die Werte gleich sind, sind sie schon gleich und alterWert 
muß nicht noch mal aktualisiert werden ;-)

[Vlad T. (vlad_tepesch)]

Carsten schrieb:
> Für Tips wäre ich sehr dankbar!
>
> while(1){
>
> aktuellerAdcWert = ADC_auslesen(0);
>
> lcdClear();                          // 1
> lcdWriteString("Wert: ");            // 2
> lcdWriteNumber(aktuellerAdcWert);    // 3
>
> if(aktuellerAdcWert != alterWert){
>      alterWert = aktuellerAdcWert;
>      // ***********
>      }
>
> }

das ganze ist ein bisschen sinnlos oder?
warum wird das LCD-Update nicht nur gemacht, wenn sie die Werte 
unterscheiden?
Bloß für die Zuweisung die If-Abfrage macht keinen Sinn, da die 
Zuweisung wahrscheinlich genauso schnell ist, wie die Abfrage und es 
auch nix schaded, wenn man eine Variable mit dem gleichen Wert 
nocheinmal beschreibt.

warum nicht einfach:

aktuellerAdcWert = ADC_auslesen(0);
if(aktuellerAdcWert != alterWert)
{
    lcdClear();                          // 1
    lcdWriteString("Wert: ");            // 2
    lcdWriteNumber(aktuellerAdcWert);    // 3    
    alterWert = aktuellerAdcWert;
}

[Felix (Gast)]

Hab ich auch zuerst gedacht, aber er schrieb

[Christian Erker (Gast)]

... lies dir das Ursprungsposting nochmal genau durch ... ;)

Gruß,
Christian

[Felix (Gast)]

Carsten schrieb:
> Ich füge also die mit 1 bis 3 markierten Zeilen in die
> if-Abfrage (Sternchen) ein.

Habe zuerst auch gedacht, dass das keinen Sinn ergibt.
Aber ich habe oben zitierte Zeile überlesen...

[Falk B. (falk)]

@  Vlad Tepesch (vlad_tepesch)

>warum nicht einfach:

>aktuellerAdcWert = ADC_auslesen(0);
>if(aktuellerAdcWert != alterWert)
>{
>    lcdClear();                          // 1
>    lcdWriteString("Wert: ");            // 2
>    lcdWriteNumber(aktuellerAdcWert);    // 3
>    alterWert = aktuellerAdcWert;
>}

lcd_clear() macht man bei einem zyklischen Update nicht, das flackert. 
Man überschreibt einfach die alten Werte, ggf. Leerzeichen einfügen.

MFG
Falk

[Vlad T. (vlad_tepesch)]

Falk Brunner schrieb:
> lcd_clear() macht man bei einem zyklischen Update nicht, das flackert.
> Man überschreibt einfach die alten Werte, ggf. Leerzeichen einfügen.
>
> MFG
> Falk

in meinem Code ist kein zyklisches clear, sondern nur eins bei 
Veränderung.
In seinem Ursprungsposting wird in jedem Zyklus ein clear gemacht.
die Abfrage, ob sich der Wert geändert hat, war vorher komplett umsonst.