ADC Programmierung bem AT32UC3B

[Berkay]

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

[seite5]

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

[Berkay]

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