Atmega32 ADC

[cube4 (Gast)]

Hallo,

ich habe einen Fototransistor über den PA0 (ADC0) an meinem Atmega 32 
angeschlossen.
Die Werte werden ausgelesen und an das Display von Pollin TC1602A-09 
ausgegeben.
Das Display funktioniert einwandfrei nur meine Werte "spinnen" etwas, 
meistens kann ich nur die ersten beiden Ziffern des 10bit Wertes 
erkennen, die restlichen werden meiner Meinung nach zu schnell hin und 
her gewechselt so dass man es nicht vom Display ablesen kann. Auch ein 
Kondensator am AREF Pin gegen VCC brachte keinen Unterschied.

Testweise habe ich ein Poti(1MOhm) angeschlossen und ein Delay von 
1000ms eingefügt bis zum nächsten anzeigen eines neuen Wertes.
Die Werte gingen von 0 bis ca. 800 dann über in einen negativen Wert von 
300 und mehr.
Was mache ich falsch ?

Danke

hier mein Code:

#include <avr/io.h>
#include <avr/interrupt.h>
#include "LCD.h"

int main(void)
{
InitializeLCD(); 
Send_A_StringToLCDWithLocation(1,1,"ADC Result:");
ADCSRA |= 1<<ADPS2;
ADMUX |= (1<<REFS0) | (1<<REFS1);
ADCSRA |= 1<<ADIE;
ADCSRA |= 1<<ADEN;

sei();

ADCSRA |= 1<<ADSC;

while (1)
{
}
}
ISR(ADC_vect)
{
uint8_t LowADC = ADCL;
uint16_t theTenBitResults = ADCH<<8 | LowADC;
Send_An_IntegerToLCD(1,2,theTenBitResults, 4);

ADCSRA |= 1<<ADSC; 
}

[Karl H. (kbuchegg)]

Wozu der ganze Hackmack mit Interrupts? Gerade bei einem ADC ist das 
meistens nicht wirklich sinnvoll.
Als Faustregel kannst du dir merken: IN dem Moment, in dem du eine 
Ausgabe in einer ISR auf LCD oder UART hast, hast du falsch designed. So 
etwas macht man niemals.

> uint8_t LowADC = ADCL;
> uint16_t theTenBitResults = ADCH<<8 | LowADC;

Auf einem AVR mit gcc brauchst du dich nicht darum kümmern, dass du 2 
Register auslesen musst um ein 16 Bit Ergebnis zu erhalten. Das ist ein 
Detail um das sich der COmpiler kümmert

uint16_t Result = ADC;


fertig.


Und den eigentlich spannenden Teil, nämlich die Funktion 
Send_An_IntegerToLCD, den hast du natürlich unterschlagen.


Nciht lesbare Warte am LCD haben 2 Ursachen
* zum einen ist die Update Frequenz viel zu hoch. Du kannst als Mensch 
nicht mehr als 3 oder 4 Werte pro Sekunde ablesen. Es ist daher völlig 
sinnlos, wenn du 100-tausend Updates pro Sekunde am LCD machst
* aber selbst wenn deine UPdate-Frequenz angepasst ist, dann ist es für 
uns Menschen sehr hilfreich, wenn zb die Einerstelle einer Zahl immer an 
derselben Position am LCD aufscheint, so dass die Zahl nicht ständig 
links rechts wandert. D.h. es ist sinnvoll eine formatierte Ausgabe in 
ein Feld mit konstanter Größe zu machen.
Ob du das tust und wie du das tust, kann man nicht sagen, denn die 
Funktion selbst zeigst du ja nicht her. Dass aber mit der was nicht 
stimmt, folgt schon daraus, dass ein uint16_t als unsigned WErt per 
Definition schon kein  Vorzeichen und damit immer positiv ist, was aber 
deine Ausgabefunktion anscheinend nicht so beeindruckt. Ok, bei 
maximalen Werten von 0 bis 1023 sollte das keinen Unterschied machen ob 
signed oder unsigned. In diesem Wertebereeich gibt es kein BItmuster, 
welches als signed interpretiert jemals als negative Zahl aufgefasst 
werden könnte.

[Karl H. (kbuchegg)]

>  Auch ein Kondensator am AREF Pin gegen VCC brachte keinen Unterschied.

Was heißt da AUCH?

Der Kondensator gehört da mindestens hin.
Genauso wie ein 100nF Kondensator an VCC/GND bzw. AVcc/GND.

Ohne diese 3 Kondensatoren brauchen wir erst mal gar nicht weiter 
diskutieren

[Dietrich L. (dietrichl)]

cube4 schrieb:
> Testweise habe ich ein Poti(1MOhm) angeschlossen

Das ist zu hochohmig. Nimm 10kOhm oder weniger.

[cube4 (Gast)]

Erstmal Danke !
also Kondensatoren sind alle dran,

Meine Code sieht jetzt so aus:

#include <avr/io.h>
#include "MrLCD.h"
#include <util/delay.h>


int main(void)
{
  
  InitializeMrLCD(); //LCD Initialisieren

  Send_A_String("ADC Result:"); 

  //ADC Initialisieren
  
  ADCSRA = (1<<ADPS2) | (1<<ADEN); // Prescaler 16 | ADC-An 
  ADMUX  = (1<<REFS0);        // AVCC als Referenz Kondensator bei AREF
  
  uint16_t Ergebnis = 0;
  

while (1)
  {
  
  //Messung starten
  
  ADCSRA = (1<<ADSC);
  while (ADCSRA & (1<<ADSC) ) {}  // auf Abschluss der Konvertierung warten
  
  Ergebnis = ADC;      // Ergebnis 
  
  Send_An_IntegerToMrLCD(1, 2, Ergebnis, 4); //Ergebnis an Display senden
    
  }
}

und die MrLCD.h :

#ifndef MrLCD
#define MrLCD

#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>

#define MrLCDsCrib PORTB
#define DataDir_MrLCDsCrib DDRB
#define MrLCDsControl PORTD
#define DataDir_MrLCDsControl DDRD
#define LightSwitch 5
#define ReadWrite 7
#define BiPolarMood 2

char firstColumnPositionsForMrLCD[4] = {0, 64, 20, 84};

void Check_IF_MrLCD_isBusy(void);
void Peek_A_Boo(void);
void Send_A_Command(unsigned char command);
void Send_A_Character(unsigned char character);
void Send_A_String(char *StringOfCharacters);
void GotoMrLCDsLocation(uint8_t x, uint8_t y);
void InitializeMrLCD(void);
void Send_A_StringToMrLCDwithLocation(uint8_t x, uint8_t y, char *StringOfCharacters);
void Send_An_IntegerToMrLCD(uint8_t x, uint8_t y, int IntegerToDisplay, char NumberofDigits);


void Check_IF_MrLCD_isBusy()
{
  DataDir_MrLCDsCrib = 0;
  MrLCDsControl |= 1<<ReadWrite;
  MrLCDsControl &= ~1<<BiPolarMood;

  while (MrLCDsCrib >= 0x80)
  {
  Peek_A_Boo();
  }

  DataDir_MrLCDsCrib = 0xFF; //0xFF means 0b11111111
}

void Peek_A_Boo()
{
  MrLCDsControl |= 1<<LightSwitch;
  asm volatile ("nop");
  asm volatile ("nop");
  MrLCDsControl &= ~1<<LightSwitch;
}

void Send_A_Command(unsigned char command)
{
  Check_IF_MrLCD_isBusy();
  MrLCDsCrib = command;
  MrLCDsControl &= ~ ((1<<ReadWrite)|(1<<BiPolarMood));
  Peek_A_Boo();
  MrLCDsCrib = 0;
}

void Send_A_Character(unsigned char character)
{
  Check_IF_MrLCD_isBusy();
  MrLCDsCrib = character;
  MrLCDsControl &= ~ (1<<ReadWrite);
  MrLCDsControl |= 1<<BiPolarMood;
  Peek_A_Boo();
  MrLCDsCrib = 0;
}

void Send_A_String(char *StringOfCharacters)
{
  while(*StringOfCharacters > 0)
  {
  Send_A_Character(*StringOfCharacters++);
  }
}

void Send_A_StringToMrLCDwithLocation(uint8_t x, uint8_t y, char *StringOfCharacters)
{
  GotoMrLCDsLocation(x, y);
  Send_A_String(StringOfCharacters);
}

void GotoMrLCDsLocation(uint8_t x, uint8_t y)
{
  Send_A_Command(0x80 + firstColumnPositionsForMrLCD[y-1] + (x-1));
}

void InitializeMrLCD()
{
  DataDir_MrLCDsControl |= 1<<LightSwitch | 1<<ReadWrite | 1<<BiPolarMood;
  _delay_ms(15);

  Send_A_Command(0x01); //Clear Screen 0x01 = 00000001
  _delay_ms(2);
  Send_A_Command(0x38);
  _delay_us(50);
  Send_A_Command(0b00001110);
  _delay_us(50);
}

  void Send_An_IntegerToMrLCD(uint8_t x, uint8_t y, int IntegerToDisplay, char NumberofDigits)
{
  char StringToDisplay[NumberofDigits];
  itoa(IntegerToDisplay, StringToDisplay, 10);
  for (int i=0; i<NumberofDigits; i++) Send_A_String(" ");
  Send_A_StringToMrLCDwithLocation(x, y, StringToDisplay);
}

#endif

[Uwe (de0508)]

so so !  nicht ? oder doch?

ADCSRA = (1<<ADSC);

Was steht nun in diesem Register ?

[cube4 (Gast)]

ADCSRA |= 1<<ADSC;

[Karl H. (kbuchegg)]

Über die Funktion

  void Send_An_IntegerToMrLCD(uint8_t x, uint8_t y, int IntegerToDisplay, char NumberofDigits)
{
  char StringToDisplay[NumberofDigits];
  itoa(IntegerToDisplay, StringToDisplay, 10);
  for (int i=0; i<NumberofDigits; i++) Send_A_String(" ");
  Send_A_StringToMrLCDwithLocation(x, y, StringToDisplay);
}

solltest du nochmal nachdenken. Die ist ziemlicher Quatsch.
Vor allen Dingen erreichst du nicht das was du willst: eine 
rechtsbündige Ausgabe in einem Feld gewisser Größe. Diese Ausgabe ist 
wieder linksbündig und damit tanzen die Zahlen vor dem Benutzer je nach 
Größenordnung hin und her.
Wenn du es dir leisten kannst, dann nimm halt sprintf um dir das Leben 
erst mal leichter zu machen.

void Send_An_IntegerToMrLCD(uint8_t x, uint8_t y, int IntegerToDisplay, uint8_t NumberofDigits)
{
  char StringToDisplay[7];

  sprintf( StringToDisplay, "%0*d", NumberofDigits, IntegerToDisplay );
  Send_A_StringToMrLCDwithLocation(x, y, StringToDisplay);
}

[cube4 (Gast)]

Ok habe ich so verändert, sowie die stdio.h eingefügt.

Jetzt habe ich den Unterstrich in der 2 Zeile ganz links am Display aber 
keine Zahlen ?

Irgendwo kann noch etwas nicht stimmen in meinem Code :-(

[cube4 (Gast)]

Was ich vieleicht noch vergessen habe zu erwähnen ist das der Atmega32 
mit 1Mhz läuft.

[Karl H. (kbuchegg)]

cube4 schrieb:
> Ok habe ich so verändert, sowie die stdio.h eingefügt.
>
> Jetzt habe ich den Unterstrich in der 2 Zeile ganz links am Display aber
> keine Zahlen ?

Welchen UNterstrich?
Da wird nirgends ein UNterstrich ausgegeben.

[Karl H. (kbuchegg)]

OK.
Bin mir nicht sicher, ob die avr-libc den * in der Formatangabe kennt. 
Ist zwar eine C-Standardsache, aber auf dem AVR wurde da einiges 
abgespeckt.

Mach da erst mal eine Konstante rein

  sprintf( StringToDisplay, "%04d", IntegerToDisplay );

[cube4 (Gast)]

:-)))))) Sau stark funktioniert Einwandfrei !!!!

Vielen Dank ! Vorerst ! ;-)

[Karl H. (kbuchegg)]

Und?
Haben sich deine Ableseprobleme bzw. die seltsamen Zahlenwerte dadurch 
gegeben?

[cube4 (Gast)]

Also die ersten 3 Ziffern kann ich Einwandfrei ablesen die letzte 
"wackelt" schon noch etwas, außer das Poti das ich gerade angeschlossen 
habe ist auf 0 oder 1023 dann sind alle stabil.

Ich überlege noch einen Mittelwert über ein Array zu realisieren ?

[Karl H. (kbuchegg)]

cube4 schrieb:
> Also die ersten 3 Ziffern kann ich Einwandfrei ablesen die letzte
> "wackelt" schon noch etwas

Das ist ziemlich normal.
So um die +-2 ADC_Werte wackeln wirst du haben. Man müsste sonst 
wesentlich mehr Aufwand treiben um die Referenzspannung stabil zu halten 
bzw. die 'Sensorschaltung' wird etwas Rauschen einbringen. Kurz und gut: 
rechne damit, dass die letzte Stelle nicht wie festgenagelt stabil steht 
und du machst dir selber das Leben leichter.

>, außer das Poti das ich gerade angeschlossen
> habe ist auf 0 oder 1023 dann sind alle stabil.
>
> Ich überlege noch einen Mittelwert über ein Array zu realisieren ?

Wozu Array?
Brauchst du doch nicht.

Steck den ADC-Ausleseteil in eine Funktion, damit du ihn leicht 
handhabbar hast

uint16_t ReadADC()
{
  ADCSRA = (1<<ADSC);
  while (ADCSRA & (1<<ADSC) ) {}  // auf Abschluss der Konvertierung warten
  
  return ADC;
}

und mach dir daraus aufbauend eine Funktion, die zb 8 Messungen macht 
und daraus den Mittelwert errechnet

uint16_t ReadADCAverage()
{
  uint16_t Result = 0;
  uint8_t i;

  for( i = 0; i < 8; i++ )
    Result += ReadADC();

  return Result / 8;
}

und ruf die in deiner Hauptschleife auf

  ...
  while (1)
  {
    Ergebnis = ReadADCAverage();
    Send_An_IntegerToMrLCD(1, 2, Ergebnis, 4);
  }
}

Und schon siehst du auf deinem LCD jeweils den Mittelwert aus 8 
Messungen. Und das ganze in leicht handhabbaren Funktionen aufgeteilt.

[Karl H. (kbuchegg)]

Du könntest auch mal den Unterschied ausprobieren, den eine Änderung im 
Formatstring hier

  sprintf( StringToDisplay, "%4d", IntegerToDisplay );

ergibt. Jetzt gibt es keine führenden 0-en mehr, sondern das 4-stellige 
Feld wird links mit Leerzeichen aufgefüllt.

[cube4 (Gast)]

Also irgendwo ist der Hund begraben.

Wenn ich de Funktionen einfüge bekomme ich nur 0000 angezeigt.
Bin nochmal mein C++-Buch durchgegangen aber finde den Fehler nicht.

[cube4 (Gast)]

#include <avr/io.h>
#include "MrLCD.h"
#include <util/delay.h>

uint16_t Ergebnis = 0;

uint16_t ADCAuslesen(void);
uint16_t Mittelwert(void);



int main(void)
{

  InitializeMrLCD(); //LCD Initialisieren

  Send_A_String("ADC Result:");

  //ADC Initialisieren

  ADCSRA = (1<<ADPS2) | (1<<ADEN); // Prescaler 16 | ADC-An
  ADMUX  |= (1<<REFS0);        // AVCC als Referenz Kondensator bei AREF


    uint16_t ADCAuslesen(void)
  {
    ADCSRA = (1<<ADSC);
    while (ADCSRA & (1<<ADSC) ) {}  // auf Abschluss der Konvertierung 
warten

    return ADC;
  }

  // Mittelwert bilden

    uint16_t Mittelwert(void)
  {
    uint16_t Summe = 0;
    uint8_t i;

    for( i = 0; i < 8; i++ )
    Summe += ADCAuslesen();

    return Summe / 8;
}


while (1)
  {

  Ergebnis = ADCAuslesen();
    Send_An_IntegerToMrLCD(1, 2, Ergebnis, 4);

  }


}

[Karl H. (kbuchegg)]

Mein Fehler.
Ich habe deinen Code von weiter oben unkritisch runterkopiert

  ADCSRA = (1<<ADSC);

ist natürlich Blödsinn.

Das muss

  ADCSRA |= (1<<ADSC);

heißen.

[cube4 (Gast)]

Mist :-) auch mein Fehler ich kopiere zuviel !
Aber so läuft es

DANKE !!