AVR ADC macht Probleme und liefert keine Messwerte

[Funky C. (funky4computer)]

Hallo zusammen,

Ich komme bei meinem Projekt wirklich nicht mehr weiter. Ich habe 
wirklich alles schon mehrmals durchgecheckt, ohne einen konkreten Fehler 
zu finden.

Problem: Die Daten, die vom ADC kommen entsprechen gar keiner Messung 
-.-

Ich habe einen Beschleunigungssensor an Port F angeschlosse mit x an 
ADC0, y an ADC1 und z and ADC2

/************************************************************************/
/* imports & includes                                                   */
/************************************************************************/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <util/delay.h>
#include "lcd.h"
#include "uart.h"
#include "ZigBee.h"
#include "Utility.h"
#include "structs.h"

/************************************************************************/
/* parameters, constants & field variables                              */
/************************************************************************/
#define UART_BAUD_RATE 57600UL
#define F_CPU 8000000UL

#define STATE_READSENSORS 1
#define STATE_READSENSORS_ADXL330 2
#define STATE_READSENSORS_ADXL345 3
#define STATE_SENDOVERUART 4
unsigned char sensorMesh_state = STATE_READSENSORS;

#define NUMBER_OF_ADCVALUES 10
ADCVALUE adcValues[NUMBER_OF_ADCVALUES];
char adcValuesPointer = 0;

/************************************************************************/
/* functions, procedures & methods                                      */
/************************************************************************/
int main(void)
{
  init();
  //[debugging]
  //testSoftware();
  
  while(1)
  {
    //TODO:: Please write your application code
    
    //[debugging]
    //char rfDataFrame[5];
    //rfDataFrame[0] = 0x41;
    //rfDataFrame[1] = 0x41;
    //rfDataFrame[2] = 0x41;
    //rfDataFrame[3] = 0x41;
    //rfDataFrame[4] = 0x41;
    //ARRAY rfDataFrameArray;
    //rfDataFrameArray.elements = rfDataFrame;
    //rfDataFrameArray.size = 5;
    //sendDataOverZigbee(rfDataFrameArray);
    
    sensorMesh_stateMachine();
  }
}

/**************************************************************/
/* inits                                                      */
/**************************************************************/
void init()
{
  //initDisplay();
  initLeds();
  initUart();
  initAdc();
}

void initDisplay()
{
  lcd_init(LCD_DISP_ON);
  lcd_clrscr();
}

void initAdc()
{
  //Configure the ADC
  
  //Enable a prescaler - determinded by the internal/external clock
  //800/5 = 160, 80/2 = 40 prescaler khz must be between 50khz and 200khz
  ADCSRA |= (1<<ADPS2) | (1<<ADPS1);
  
  //Set reference voltage
  //ADMUX |= 1<<REFS0 | 1<<REFS1;
  ADMUX |= (1<<REFS0);
  
  //8-bit or 10-bit results (0 for 10 bit and 1 for 8 bit)
  ADMUX |= (1<<ADLAR);
  
  //Set default input channel to AD0 (by default). Nothing to do then.
  
  //Enable ADCConverter
  ADCSRA |= 1<<ADEN;
  
  //Enable interrupts function in ADC
  ADCSRA |= (1<<ADIE);
  
  //Enable global interrupts
  sei();
  
  //Start the first conversion
  ADCSRA |= 1<<ADSC;
}

void initUart()
{
  uart_init(UART_BAUD_SELECT(UART_BAUD_RATE, F_CPU));
  sei();
}

void initLeds()
{
  DDRD = 0xFF;
  
  // [debugging] check if LEDs work
  PORTD = 0x00;
}

/**************************************************************/
/* interrupt handlers                                         */
/**************************************************************/
ISR(ADC_vect){
  if(sensorMesh_state == STATE_READSENSORS_ADXL330)
  {
    //PORTD = 0xFF;

    //[debugging]
    ////LCD String variable declarration
    //char adcResultHigh[4];
    //itoa(ADCH, adcResultHigh, 10);
    //lcd_puts(adcResultHigh);
    //
    //char adcResultLow[4];
    //itoa(ADCL, adcResultLow, 10);
    //lcd_puts(adcResultLow);
    //
    //output to LEDs
    //char temp = ~ADCL;
    //PORTD = ADCH;
    //_delay_ms(100);
    //
    ////delay so that lcd is not flashing and clear lcd
    //_delay_ms(100);
    //lcd_clrscr();
    //[/debugging]
    
    //Write values to buffer until buffer limit is reached
    adcValues[adcValuesPointer].adcl = ADCL;
    adcValues[adcValuesPointer].adch = ADCH;
    adcValuesPointer++;
    
    //[debugging]
    PORTD = ~(adcValues[adcValuesPointer].adch);
    
    //Reset adcValuesPointer if end of buffer is reached and begin next state
    if(adcValuesPointer == NUMBER_OF_ADCVALUES)
    {
      adcValuesPointer = 0;
      sensorMesh_state = STATE_SENDOVERUART;
    }
  }
  //Start the next conversion
  ADCSRA |= 1<<ADSC;
}

/**************************************************************/
/* routines                                                   */
/**************************************************************/
void sendDataOverZigbee(ARRAY rfDataArray)
{
  //prepare result frame
  char resultFrame[18 + rfDataArray.size];
  ARRAY resultFrameArray;
  resultFrameArray.size = 23;
  resultFrameArray.elements = resultFrame;
  
  //set address
  char destinationAddress[8];
  destinationAddress[0] = 0x00;
  destinationAddress[1] = 0x13;
  destinationAddress[2] = 0xA2;
  destinationAddress[3] = 0x00;
  destinationAddress[4] = 0x40;
  destinationAddress[5] = 0xC2;
  destinationAddress[6] = 0x84;
  destinationAddress[7] = 0xEE;
  ARRAY destinationAddressArray;
  destinationAddressArray.size = 8;
  destinationAddressArray.elements = destinationAddress;

  //set 16 bit address
  char destination16BitAddress[2];
  destination16BitAddress[0] = 0xFF;
  destination16BitAddress[1] = 0xFF;
  ARRAY destination16BitAddressArray;
  destination16BitAddressArray.size = 2;
  destination16BitAddressArray.elements = destination16BitAddress;

  //set broadcast radius
  char broadcastRadius = 0x00;

  //set rf data from parameter
  
  //create zigbee transmit request message frame
  zigbee_createTransmitRequestMessageFrame(resultFrameArray, 0x01, destinationAddressArray, destination16BitAddressArray, broadcastRadius, 0x00, rfDataArray);

  //sending data over uart
  for(int i = 0; i < resultFrameArray.size; i++)
  {
    uart_putc(resultFrameArray.elements[i]);
  }
}

void sensorMesh_sendAllDataToZigbee()
{
  //Send all read values from ADXL330
  for(int i = 0; i < NUMBER_OF_ADCVALUES; i++)
  {
    char rfDataFrame[2];
    rfDataFrame[0] = adcValues[i].adcl;
    rfDataFrame[1] = adcValues[i].adch;
    ARRAY rfDataFrameArray;
    rfDataFrameArray.elements = rfDataFrame;
    rfDataFrameArray.size = 2;
    sendDataOverZigbee(rfDataFrameArray);
  }
  
  //Send all read values from ADXL345

}

void sensorMesh_stateMachine()
{
  switch(sensorMesh_state) {
    case STATE_READSENSORS:
    //Read values from sensors and write to buffer
    //---Read values from adxl 330 and write to buffer
    sensorMesh_state = STATE_READSENSORS_ADXL330;
    //---Read values from adxl 345 and write to buffer
    //sensorMesh_state = STATE_READSENSORS_ADXL345;
    //if all sensores are done, set machine state to send over uart
    break;
    
    case STATE_SENDOVERUART:
    //Send data from buffers over uart
    sensorMesh_sendAllDataToZigbee();
    //Set machine state to read sensor values
    sensorMesh_state = STATE_READSENSORS;
    break;
    
    default:
    //do nothing now
    break;
  }
}

void sensorMesh_nextState()
{
  sensorMesh_state++;
}

void sensorMesh_previousState()
{
  sensorMesh_state--;
}

/**************************************************************/
/* testing routines                                           */
/**************************************************************/
void testSoftware()
{
  testUartConnection();
}

void testUartConnection()
{
  while(1)
  {
    //prepare result frame
    char resultFrame[23];
    ARRAY resultFrameArray;
    resultFrameArray.size = 23;
    resultFrameArray.elements = resultFrame;
    
    //set address
    char destinationAddress[8];
    destinationAddress[0] = 0x00;
    destinationAddress[1] = 0x13;
    destinationAddress[2] = 0xA2;
    destinationAddress[3] = 0x00;
    destinationAddress[4] = 0x40;
    destinationAddress[5] = 0xC2;
    destinationAddress[6] = 0x84;
    destinationAddress[7] = 0xEE;
    ARRAY destinationAddressArray;
    destinationAddressArray.size = 8;
    destinationAddressArray.elements = destinationAddress;

    //set 16 bit address
    char destination16BitAddress[2];
    destination16BitAddress[0] = 0xFF;
    destination16BitAddress[1] = 0xFF;
    ARRAY destination16BitAddressArray;
    destination16BitAddressArray.size = 2;
    destination16BitAddressArray.elements = destination16BitAddress;

    //set broadcast radius
    char broadcastRadius = 0x00;

    //set data
    char rfData[5];
    rfData[0] = 0x41;
    rfData[1] = 0x42;
    rfData[2] = 0x43;
    rfData[3] = 0x44;
    rfData[4] = 0x45;
    ARRAY rfDataArray;
    rfDataArray.size = 5;
    rfDataArray.elements = rfData;
    
    //create zigbee transmit request message frame
    zigbee_createTransmitRequestMessageFrame(resultFrameArray, 0x01, destinationAddressArray, destination16BitAddressArray, broadcastRadius, 0x00, rfDataArray);

    //sending data over uart
    for(int i = 0; i < resultFrameArray.size; i++)
    {
      uart_putc(resultFrameArray.elements[i]);
    }
  }
}

[jb (Gast)]

Sind die Messwerte logisch, wenn du statt des Beschleunigungssensors 
einfach mal Potentiometer anschließt?

Ansonsten ist es normal das die Werte da ziemlich schwanken und digital 
aufbearbeitet (filtern) werden müssen.

Gruß Jonas

[Andreas K. (andreasmc)]

Was für Werte kriegst du raus, was für Werte erwartest du?

Die restlichen Programmteile hast du mal mit festen Werten getestet und 
die kommen rüber wie erwartet?

Was für Werte kriegst du wenn du ein Trimmpoti statt dem 
Beschleunigungsmesser anschliesst?

[Funky C. (funky4computer)]

jb schrieb:
> Sind die Messwerte logisch, wenn du statt des Beschleunigungssensors
> einfach mal Potentiometer anschließt?
>
> Ansonsten ist es normal das die Werte da ziemlich schwanken und digital
> aufbearbeitet (filtern) werden müssen.
>
> Gruß Jonas

Die Werte ändern sich nicht mal, wenn ich den Sensor bewege. Ich habe 
Spaßes halber mein STK600 auf 5Volt gestellt (ganz kurz), da schien sich 
dann was zu tun... Ansonsten müssen die Komponenten mit 3,3V laufen.

Gruß

[Rolf M. (rmagnus)]

Funky Computer schrieb:
> Problem: Die Daten, die vom ADC kommen entsprechen gar keiner Messung

Was heißt das? Kommen zufällige Werte raus? Immer derselbe Wert? Ein 
Offset? Wo siehst du die falschen Werte? Kann vielleicht deine 
Senderoutine fehlerhaft sein?

> Ich habe einen Beschleunigungssensor an Port F angeschlosse mit x an
> ADC0, y an ADC1 und z and ADC2

Ich würde erstmal ein Poti anschließen, um zu schauen, ob's wirklich am 
ADC liegt. Erst wenn der richtig funktioniert, den Sensor anklemmen.

Ansonsten:
Welcher AVR?
Welcher Sensor?
Sind AVCC und AGND und alle GND-Pins korrekt beschaltet?
Schaltplan?

[Funky C. (funky4computer)]

Andreas K. schrieb:
> Was für Werte kriegst du raus, was für Werte erwartest du?
>

Ich bekomme da für ADCL (lower byte) einen zufälligen Wert raus. Ich 
hätte erwartet, dass sich beim Bewegen des Sensors ÜBERHAUPT etwas an 
den Werten verändert.

> Die restlichen Programmteile hast du mal mit festen Werten getestet und
> die kommen rüber wie erwartet?
>

UART funktioniert einwandfrei

> Was für Werte kriegst du wenn du ein Trimmpoti statt dem
> Beschleunigungsmesser anschliesst?

Müsste ich machen. Ich habe zusätzlich einen anderen ADXL330 
angeschlossen, um sicher zu gehen, dass der 1. Sensor nicht kaputt ist. 
Da gibt es dasselbe Problem...

[jb (Gast)]

>Die Werte ändern sich nicht mal, wenn ich den Sensor bewege.

Um einen defekten Sensor auszuschließen folge doch dem vielgesagten Tip 
und schließe einmal ein Potentiometer an und prüfe dann die Messwerte!

>Ich habe Spaßes halber mein STK600 auf 5Volt gestellt (ganz kurz), da >schien 
sich dann was zu tun... Ansonsten müssen die Komponenten mit 3,3V >laufen.

Hm, das hätte ich gelassen.

Gruß Jonas

[Funky C. (funky4computer)]

Rolf Magnus schrieb:
> Funky Computer schrieb:
>> Problem: Die Daten, die vom ADC kommen entsprechen gar keiner Messung
>
> Was heißt das? Kommen zufällige Werte raus? Immer derselbe Wert? Ein
> Offset? Wo siehst du die falschen Werte? Kann vielleicht deine
> Senderoutine fehlerhaft sein?
>

Wie gesagt scheinen die Werte sich NICHT mit der Bewegung des Sensors zu 
verändern. Es ist eher ein Randomwert (aber die meisten Werte sind 
"0x00"). Ich habe die Werte sowohl über UART gesendet und sehe es Per 
Terminal auf dem Laptop als auch auf den LEDs ausgegeben (Auch die LEDs 
reagieren nicht auf den Sensor!).

>> Ich habe einen Beschleunigungssensor an Port F angeschlosse mit x an
>> ADC0, y an ADC1 und z and ADC2
>
> Ich würde erstmal ein Poti anschließen, um zu schauen, ob's wirklich am
> ADC liegt. Erst wenn der richtig funktioniert, den Sensor anklemmen.
>
Ich habe einen 2. Sensor des gleichen Modells angeschlossen und hatte 
auch damit keinen Erfolg gehabt.

> Ansonsten:
> Welcher AVR?
Atmega2560 auf STK600 (Aref0 und Aref1 Jumper habe ich entfernt)

> Welcher Sensor?
ADXL330 (MEMS1)

> Sind AVCC und AGND und alle GND-Pins korrekt beschaltet?
Ja

> Schaltplan?
ADXL330       STK600
GND           GND(PortF)
Vcc           Vcc(PortF)
X             PinF0
Y             PinF1
Z             PinF2

[Karl H. (kbuchegg)]

> Ich würde erstmal ein Poti anschließen, um zu schauen, ob's wirklich am
> ADC liegt. Erst wenn der richtig funktioniert, den Sensor anklemmen.

Ich würde auch erst mal mit einem wesentlich simpleren Testprogramm 
anfangen als dieser dann doch schon relativ komplexen Statemachine mit 
Interruptbeteiligung.

int main()
{
  uint16_t value;

  DDRD = 0xFF;

  ADC_Init();

  while( 1 ) {
    value = ADC_Read( 0 );
    PORTD = value;
  }
}

das ist einfach genug, dass man davon ausgehen kann, dass eventuelle 
Fehler sich nur noch im Hardwareaufbau bzw. in einer falschen 
Referenzspannung manifestieren können. Die ADC Routinen finden sich hier

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Analoge_Ein-_und_Ausgabe#Der_interne_ADC_im_AVR


Es ist KEINE gute Idee, bei einer neuen Systemkomponente gleich mal mit 
einem komplexen Programm loszulegen. Die Devise heisst abspecken und 
erst mal so einfach wie nur möglich testen, ob die Hardware überhaupt 
funktioniert. Ein komplexes Programm ist dabei kontraproduktiv, weil du 
nie weisst, ob dieses neue Teilsystem das Problem verursacht, oder ob du 
im Rest noch irgendwo einen Bock hast. Die Zeit, die du in ein einfaches 
Testprogramm investierst, kriegst du in Folge 100-fach wieder rein.

[Funky C. (funky4computer)]

Mensch, ihr seid echt fix im Antworten.

Vielen Dank für die Tips! Ich werde erst nächste Woche das Material 
haben, um das Ganze umzusetzen.

[Stefan F. (Gast)]

Ich vermisse einen Zugriff auf den ADC Multiplexer. Wenn du drei ADC 
Eingänge beschaltest hast, dann musst du doch irgendwo zwischen diesen 
Eingängen umschalten.

Wie hast du dir das mit der Interrupt Routine und dem Array gedacht? 
Sollte der aktuelle Kanal fortlaufend gemessen werden, bis das Array 
voll ist, oder wolltest du, dass das Array einen Wert pro Eingang 
enthält?

[Funky C. (funky4computer)]

Stefan Us schrieb:
> Ich vermisse einen Zugriff auf den ADC Multiplexer. Wenn du drei ADC
> Eingänge beschaltest hast, dann musst du doch irgendwo zwischen diesen
> Eingängen umschalten.
>
> Wie hast du dir das mit der Interrupt Routine und dem Array gedacht?
> Sollte der aktuelle Kanal fortlaufend gemessen werden, bis das Array
> voll ist, oder wolltest du, dass das Array einen Wert pro Eingang
> enthält?

1. Ja, ich greife auf den Multiplexer, wenn ich erstmal Werte von 
zumindest einem Kanal bekomme.

2. Überlegung war: Ich habe irgendwo gelesen, dass unterschiedliche 
Interruptroutinen unterschiedliche Prioritäten hätten. D.h. wenn eine 
Routine zu lange dauert, kann es durchaus dazu kommen, dass andere 
Routinen erst gar nicht drankommen bzw. sehr unregelmäßig drankommen und 
das wollte ich nicht, da ich eine relativ gleichmäßige Übertragung 
möchte (z.B. "Hole 10 Werte und sende 10 Werte"). Ich speichere erst 
einen Array voll, bevor ich die Werte dieses Arrays per UART übertrage. 
Das ist zunächst mal die grobe Idee, später könnte ich die Daten aller 3 
Kanäle schön verpackt in einem struct abspeichern und einen Array aus 
diesem struct machen.

[Rolf M. (rmagnus)]

Funky Computer schrieb:
> 2. Überlegung war: Ich habe irgendwo gelesen, dass unterschiedliche
> Interruptroutinen unterschiedliche Prioritäten hätten.

Echte Prioritäten gibt es beim AVR nicht.

> D.h. wenn eine Routine zu lange dauert, kann es durchaus dazu kommen, dass
> andere Routinen erst gar nicht drankommen bzw. sehr unregelmäßig drankommen

Dazu muß die ISR aber sehr lang sein oder sehr häufig aufgerufen werden. 
Außerdem kommen dann nicht nur andere ISRs nicht mehr dran, sondern auch 
das Hauptprogramm.

> und das wollte ich nicht, da ich eine relativ gleichmäßige Übertragung
> möchte (z.B. "Hole 10 Werte und sende 10 Werte"). Ich speichere erst
> einen Array voll, bevor ich die Werte dieses Arrays per UART übertrage.

Die ISR ist dabei so ziemlich das, was am wenigsten Zeit braucht. Im 
Vergleich dazu braucht die UART-Übertragung ewig.

[Stefan F. (Gast)]

Hast du einen Kondensator an Aref angeschlossen? Hast du auch einen 
Abblockkondensator an VCC?

Du kannst zum Spass man den ADC0 Pin als Ausgang konfigurieren (Sensor 
abklemmenm!) und auf Low schalten. Dann müsste der ADC ungefähr den Wert 
0 liefern. Und bei High müsste er ungefähr den Wert 0x3FFF liefern.

[Funky C. (funky4computer)]

Stefan Us schrieb:
> Hast du einen Kondensator an Aref angeschlossen? Hast du auch einen
> Abblockkondensator an VCC?
>
> Du kannst zum Spass man den ADC0 Pin als Ausgang konfigurieren (Sensor
> abklemmenm!) und auf Low schalten. Dann müsste der ADC ungefähr den Wert
> 0 liefern. Und bei High müsste er ungefähr den Wert 0x3FFF liefern.

Korrigiere mich bitte, wenn ich falsch liege...
1. Soweit ich verstanden habe, waren die Kondensatoren eher optional, um 
das Rauschen des Signals einzudämmen?

2. Werde ich ausprobieren.

[Funky C. (funky4computer)]

Rolf Magnus schrieb:
>> D.h. wenn eine Routine zu lange dauert, kann es durchaus dazu kommen, dass
>> andere Routinen erst gar nicht drankommen bzw. sehr unregelmäßig drankommen
>
> Dazu muß die ISR aber sehr lang sein oder sehr häufig aufgerufen werden.
> Außerdem kommen dann nicht nur andere ISRs nicht mehr dran, sondern auch
> das Hauptprogramm.
>

Ich hatte vorher in der ISR die Routine für die UART-Übertragung 
aufgerufen und irgendwas schien da etwas blockiert zu sein...

[OldMan (Gast)]

Funky Computer schrieb:
> waren die Kondensatoren eher optional,

Sind ein MUSS!

[(prx) A. K. (prx)]

OldMan schrieb:
>> waren die Kondensatoren eher optional,
>
> Sind ein MUSS!

An (A)VCC ja, an AREF nicht.

[Stefan F. (Gast)]

An AREF ist der Kondensator optional. Da du aber kritisierst, dass die 
Messwerte micht plausibel sind, ist es einen Versuch wert.