ADC Programmierung bem AT32UC3B

Hallo an Alle!
Ich bin neu hier und hoffe, dass ich hier Tips für mein Problemchen bekomme. Ich bin etwas (seit ca. 20 Jahren) raus aus der C-Programmierung und versuche nun wieder einzusteigen. Genauer gesagt, in der Tiefe hatte ich eigentlich noch nie einen Atmel programmiert und hoffe, dass mir deswegen eventuelle Anfängerfragen verziehen werden.
Zum Thema:
Ich versuche einen AT32UC3B, bzw. dessen ADC zu benutzen. Und zwar mit folgendem Code:

adc_start(&AVR32_ADC);
adc_enable(&AVR32_ADC,0);
wind_speed_value = adc_get_value(&AVR32_ADC,0);

Das Problem: Keine Errors beim compilieren, die Software startet, aber bleibt hängen. Ich nutze AVR-Studio6 und einen STK600.
Habe ich die Base Adresse des ADC nicht korrekt deklariert ? Die genaue Adresse krieg ich nirgendwo raus, ich finde keine Literatur.
Ich würde mich sehr freuen, wenn mir jemand sagen könnte, wie ich den ADC auslesen kann oder einen Tip für Literatur hat.
Besten Dank im Voraus!
Berkay

Hallo liebe Forenmitglieder,

bin etwas weiter gekommen, aber noch folgendes Problem:
Die Codes ADCW, ADEN, ADMUX, ADPS1, ADP2, ADSC, REFS0 und REFS1 werden nicht erkannt mit "undeclarded (first use in this function)".
Ich vermute, dass ich irgendwas mit den includes verkehrt mache, kann mir jemand sagen, welche wo eingebunden werden müssen? Wenn jemand dieses Thema liest, würde ich mich über einen Tip sehr freuen.
Danke im Voraus !

Euer verzweifelter C-User
Berkay

Hi,
2 Fragen: Nutzt Du das ASF des AtmelStudio ? (Woher diese beide Funktionen ?) Wenn ja, brauchst Du Dich um ADCW,
ADEN ... gar nicht kümmern.
Nutzt Du ein ICE zum Debuggen ? Wenn ja, schau Dir mal die Register an, ob die überhaupt ordentlich initialisiert wurden,
wenn das Programm "hängt", scheints so als würde es auf das Setzen des "Ready-Flags" warten ...
Andere Möglichkeiten: Int disabled, Peripherie-Clock nicht konfiguriert
(Hab den ADC vom UC3LO mal "Registerweise" programmiert, wenn das hilft, könnt ich das mal posten.)
mfg
Achim

Hallo Achim,
danke für Deine Rückinfo.
Ganz ehrlich: bisher hab ich "blind" programmiert und noch nie mit dem Debugger gearbetet (ich weiss gar nicht, wie das geht).
Was ist "ASF" und "ICE" ? (sorry, bin echt lang raus...)
Ich arbeite mit dem Entwicklungsboard STK600 und programmiere über die JTAG-Schnittstelle die Zielhardware.
Die Register hab ich nicht genau bearbeitet, das sollte ja mit den o.g. Befehlen geht (dachte ich).
Hier ein Ausschnitt:

#include <MPU.h>
#include <PM.h>
#include <gpio.h>
#include <spi.h>
#include <tc.h> // Timer / Counter
#include <intc.h> // Interrupt controller
#include <spi.h>
#include <twi.h>
#include <stdio.h>
#include <flashc.h>
#include <string.h>
#include "globals.h"
#include "hwinit.h"
#include "lcd.h"
#include "sdcard.h"
#include "fat.h"
#include "KeyDispatch.h"
#include "DssModul.h"
#include "DssKey.h"
#include "dataflash.h"
#include "sdcard.h"
#include "control.h"
#include <avr32/io.h> //wird bereits im adc.c geladen
#include "adc.c"
#include <inttypes.h>

unsigned short CheckTouch(void);
void ShowStatus(void);
void InitParameter(void);
void ShowStartScreen();
void GetConfig(void);
char BText[64];
void uhrzeit(void);
void windspeed(void);

int wind_speed_value=0;

//ADC initialisierung
void ADC_Init(void);
int ADCSRA;
//void uint16_t();

#define CHANNELOFFSET 4
.
.
.
.
uint16_t ADC_read(uint8_t kanal)
{
uint16_t result = readADC(0); //Auslesen der analogen Spannungen an Pin 0,
// also ADC0. In result steht das Ergebnis.
}


uint16_t ReadChannel(uint8_t channel)
{
uint8_t i;
uint16_t result = 0;

// Den ADC aktivieren und Teilungsfaktor auf 64 stellen
ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1);

// Kanal des Multiplexers waehlen
// Interne Referenzspannung verwenden (also 2,56 V)
ADMUX = channel | (1<<REFS1) | (1<<REFS0);

// Den ADC initialisieren und einen sog. Dummyreadout machen
ADCSRA |= (1<<ADSC);
while(ADCSRA & (1<<ADSC));

// Jetzt 3x die analoge Spannung and Kanal channel auslesen
// und dann Durchschnittswert ausrechnen.
for(i=0; i<3; i++)
{
// Eine Wandlung
ADCSRA |= (1<<ADSC);
// Auf Ergebnis warten...
while(ADCSRA & (1<<ADSC));

result += ADCW;
}

// ADC wieder deaktivieren
ADCSRA &= ~(1<<ADEN);

result /= 3;

return result;
}

Kannst Du etwas erkennen ?
Ich müsste den AD0 (PA03) benutzen.
Ich danke Dir im Voraus!

Gruss
Berkay

Hi,
ICE: inCircuitEmulator, ein Tool mit dem Du Dir Register und Variablen durch Stoppen des Programmlaufs ansehen kannst, sehr gute
Fehlersuche möglich (z.B. Atmel ICE-Basic, JTAG-ICE MK2).
ASF: Atmel Software Framework, quasi eine Sammlung von Treibern und APIs zu Programmierunterstützung, Atmel Studio, Project, ASF Wizard öffnen,
sollte man aber zu Beginn eines Projektes, nicht mittendrin verwenden.
Wenn Du Deinen µC mit JTAG programmierst, was nutzt Du für ein Tool, evtl. kannst Du damit debuggen (Mal probieren: Einfach im Atmel-Studio
den grünen Pfeil drücken, mittels "Pause" (II) kann dann das Programm angehalten werden, Add Watch erlaubt das Verifizieren von Variablen,
In IO-View kann man sich die Register des µC ansehen).
(Deinen geposteten Code muss ich mir erst mal ansehen, dauert etwas.
Vielleicht hilft Dir, wie es beim UC3LO läuft:
INI:

// ADC
AVR32_ADCIFB.cr=AVR32_ADCIFB_CR_EN_MASK;
AVR32_ADCIFB.mr=0;
AVR32_ADCIFB.acr= (3<<AVR32_ADCIFB_SHTIM_OFFSET)
| (3<<AVR32_ADCIFB_START_OFFSET)
| (5<<AVR32_ADCIFB_PRESCAL_OFFSET)
| (AVR32_ADCIFB_RES_12BIT<<AVR32_ADCIFB_RES_OFFSET);
AVR32_ADCIFB.trgr=0; // Software-Trigger
AVR32_ADCIFB.cher=1;

AUSLESEN:

uint16_t read_adc()
{
AVR32_ADCIFB.cr |= AVR32_ADCIFB_CR_START_MASK;
while(!(AVR32_ADCIFB.sr & AVR32_ADCIFB_SR_READY_MASK)) {}
return (uint16_t)AVR32_ADCIFB.lcdr;
}

mfg
Achim

Hi und danke für die Infos,
bin gespannt auf Deine nächste email.
LG/Berkay