Bitte um Hilfe beim Xmega a1

Status
Für weitere Antworten geschlossen.
Der Prescaler ist auf DIV4 damit ich das maximum erziehle.
Die Frequenz habe ich mir am Oszilloskop angeschaut indem ich immer ein Port indemfall habe ich das port K auf low und high abwechselnd geschaltet.
auf das ergebnis komme ich mit RESH beim Debuggen. Mir fällt auf das es dauernd 0 dann 64 dann 128 und immer wieder von vorne aufnimmt.

Code:
#include <avr/io.h> 
#include "clksys_driver.h"

int main()
{ 

	//Oszi Configure
	/******************************************************************
	* System Clock 32MHz (XOSC Quarz 16MHz, PLL Faktor 2)
	******************************************************************/
 
	/* Nach dem Reset ist die Quelle des Systemtaktes der interne
	   2MHz RC-Oszillator (System Clock Selection: RC2MHz)
	*/
 
	// Oszillator XOSC konfigurieren (12..16MHz, 256 clocks startup time)
	CLKSYS_XOSC_Config( OSC_FRQRANGE_12TO16_gc, false, OSC_XOSCSEL_XTAL_256CLK_gc );
 
	// Oszillator XOSC enable
	CLKSYS_Enable( OSC_XOSCEN_bm );
 
	// Warten bis der Oszillator bereit ist
	do {} while ( CLKSYS_IsReady( OSC_XOSCRDY_bm ) == 0 );
 
	// PLL source ist XOSC, Multiplikator x2
	CLKSYS_PLL_Config( OSC_PLLSRC_XOSC_gc, 2 );
 
	// Enable PLL
	CLKSYS_Enable( OSC_PLLEN_bm );
 
	// Prescalers konfigurieren
	CLKSYS_Prescalers_Config( CLK_PSADIV_1_gc, CLK_PSBCDIV_1_1_gc );
 
	// Warten bis PLL locked
	do {} while ( CLKSYS_IsReady( OSC_PLLRDY_bm ) == 0 );
 
	// Main Clock Source ist Ausgang von PLL
	CLKSYS_Main_ClockSource_Select( CLK_SCLKSEL_PLL_gc );
 
	// Nun ist der System Clock 32MHz !

	

	//Variablen 
	uint16_t temp=0; 
	uint16_t max=0;
	//uint16_t offset=0;

	// Alle Pins des PORTE werden als Ausgang definiert
	PORTK.DIR=0xFF; // Alle Pins des PORTE werden als Ausgang definiert
	PORTK.OUT=0x00;

	//ADC CONIFIGURE
	ADCA.CTRLB = 0x08; //ADC_RESOLUTION_12BIT_gc; 
	ADCA.REFCTRL = 0x00; //internal 1.0V Reference 
	ADCA.PRESCALER = 0x00; 	// maximal clk/4 (2MHz/4=500kHz)
	ADCA.CH0.CTRL = ADC_CH_INPUTMODE_SINGLEENDED_gc; //single ended 
	ADCA.CH0.MUXCTRL = ADC_CH_MUXPOS_PIN0_gc; //PORTA:0 input

	ADCA.CTRLA = 0x01; //enable adc 
	//ADCA.CALCTRL = 0x01; //calibrate adc MAL SCHAUN OB ES AUCH VOR ENABLE CTRLA
	

	/*// trigger single conversion
  	ADCA.CTRLA |= 0x4; 
 	// wait for result
  	while(!ADCA.CH0.INTFLAGS);                           // wait for conversion complete flag
  	ADCA.CH0.INTFLAGS=ADC_CH_CHIF_bm;                    // clear int flags (cleared by writing 1)
  	offset = ADCA.CH0RES;                   // read 12 bit value and save as zero offset
	*/

	//eine Conversationszeit abwarten(24ADC-Clocks), hier kann auch eine feste Zeit gewartet werden
	while(!ADCA.CH0.INTFLAGS) { }; //eine Conversationszeit abwarten(24ADC-Clocks)
	// IF wieder löschen
	ADCA.CH0.INTFLAGS = ADC_CH_CHIF_bm;
	//dummy lesen
	temp= ADCA_CH0RES-offset;

	while(1){

		/*while(!ADCA.CH0.INTFLAGS) { }; //eine Conversationszeit abwarten(24ADC-Clocks)
		PORTK.OUT = ~PORTK.OUT;
		// IF wieder löschen
		ADCA.CH0.INTFLAGS = ADC_CH_CHIF_bm;*/

		// Wert entnehmen
		temp = ADCA_CH0RES;
		
		if(temp > max)
			max = temp;

		PORTK.OUT = ~PORTK.OUT; /*Alle Bits werden auf High gesetzt*/

	}
	return 0;
}
 
Also wenn der Xmega nun mit 32MHz Systemtakt läuft ist der Prescaler DIV4 zu wenig. der ADC läuft dann mit 32MHz/4 = 8MHz, er darf höchstens mit 2MHz laufen!

In der while(1) Schleife, wartest du nicht mehr, bis das IF Bit im Register INTFLAGS vom Channel0 gesetzt ist. Erst wenn es gesetzt ist, ist die Wandlung fertig und das Ergebnis im Result-Register gültig.

Noch ein Tipp:
Einen Ausgangspin toggeln geht beim Xmega eleganter als bei anderen AVRs:

PORTA.OUTTGL = 1<<PIN0; // toggelt PA0

Dirk
 
Hallo

also ich habe nun den Prescaler auf DIV16 eingestellt so rennt der ADC auf 2MHz. aber es funktioniert noch immer nicht es kommen nur so niedriger werte raus 0.. 24 oder so.

wenn ich die die warteschleife reintue dann hängt es beim debuggen und kommt da nicht mehr raus..

eine Idee?
 
die Schleife sollte schon drin bleiben, sonst liest Du irgendwelche aber nicht die zuletzt gewandelten Werte.
Lass doch mal den Debugger raus und gibt mal Werte seriell an Deinen PC (den Rat hatten wir Dir beide schon gegeben). Offensichtlich stimmt mit Deinem debugger was nicht (zumindest kannst Du das dann ausschließen).

Michael
 
siehe frühere Beiträge - über Euren miniUSB oder so. Im Programm den zugehörigen seriellen Port initialisieren und die vom ADC gelesenen Werte formattiert ausgeben. Als Gegenstelle am PC geht z.B.: Hyperterminal.
Damit kannst Du auch sonstige Tracemeldungen ausgeben - eine Art debug-trace. So was erspart den doch recht teueren Debugger (den ich z.B.: nicht anschaffe).

Michael
 
also ich habe mich schon des öfteren versucht über den hyperTerminal mit meinen XMEGA über USB zu verbinden, hat aber nie geklappt.

Also es kann nur an einem kleinen Fehler liegen, den wenn ich die OSZI Einstellungen unter kommentar setzte funktioniert das Programm ohne Probleme. Erst wenn ich es auf 32MHz umstelle dann muss ich den DIV auf 16 stellen damit er ja mit 2MHz arbeitet, funktiert es nicht mehr.
 
also ich habe mich schon des öfteren versucht über den hyperTerminal mit meinen XMEGA über USB zu verbinden, hat aber nie geklappt.
Ich weiß immer noch nicht, welches Modul du hast. Unseres, Xmega-A1-USB?

Falls du es hast, könnte das folgende weiterhelfen, ansonsten einfach überspringen:
Ist das Modul auch auf VCP eingestellt? Ist es nicht auf VCP eingestellt, wird es natürlich von keinem Terminalprogramm erkannt. Umstellen kannst du einfach mit diesem Tool. Oder du verwendest die Einstellung USBxpress und nutzt unser Programmiertool, es gibt einen Tab "Monitor", hier hast du praktisch ein Terminal von MC zu PC, du kannst dir hier Werte ausgeben (Übertragungsrate ist 250kBit/s). So oder so, musst du natürlich den USART F0 initialisieren.


Also es kann nur an einem kleinen Fehler liegen, den wenn ich die OSZI Einstellungen unter kommentar setzte funktioniert das Programm ohne Probleme. Erst wenn ich es auf 32MHz umstelle dann muss ich den DIV auf 16 stellen damit er ja mit 2MHz arbeitet, funktiert es nicht mehr.

Mich würde mal interessieren, was passiert, wenn du einen Systemtakt von 32MHz hast aber den ADC Prescaler noch größer einstellst, vielleicht so, dass der ADC mit 500kHz läuft. Das Interruptflag musst du natürlich immer abfragen, bevor du die Werte aus dem Result-Register übernimmst.

Dirk
 
Also ich habe das XMEGA A1 modul. Und es ist auf VCP umgestellt.

In diesem Beispiel habe ich nun den DIV auf 64 eingestellt und dann liest er keine Werte aus bzw. er zeigt immer nur 0 an.

So sieht nun mei Code zurzeit aus.

Code:
#include <avr/io.h> 
#include "clksys_driver.h"

int main()
{ 

	//Oszi Configure
	/******************************************************************
	* System Clock 32MHz (XOSC Quarz 16MHz, PLL Faktor 2)
	******************************************************************/
 
	/* Nach dem Reset ist die Quelle des Systemtaktes der interne
	   2MHz RC-Oszillator (System Clock Selection: RC2MHz)
	*/
 
	// Oszillator XOSC konfigurieren (12..16MHz, 256 clocks startup time)
	CLKSYS_XOSC_Config( OSC_FRQRANGE_12TO16_gc,
	                      false,
	                      OSC_XOSCSEL_XTAL_256CLK_gc );
 
    // Oszillator XOSC enable
	CLKSYS_Enable( OSC_XOSCEN_bm );
 
	// Warten bis der Oszillator bereit ist
	do {} while ( CLKSYS_IsReady( OSC_XOSCRDY_bm ) == 0 );
 
	// PLL source ist XOSC, Multiplikator x2
	CLKSYS_PLL_Config( OSC_PLLSRC_XOSC_gc, 2 );
 
	// Enable PLL
	CLKSYS_Enable( OSC_PLLEN_bm );
 
	// Prescalers konfigurieren
	CLKSYS_Prescalers_Config( CLK_PSADIV_1_gc, CLK_PSBCDIV_1_1_gc );
 
	// Warten bis PLL locked
	do {} while ( CLKSYS_IsReady( OSC_PLLRDY_bm ) == 0 );
 
	// Main Clock Source ist Ausgang von PLL
	CLKSYS_Main_ClockSource_Select( CLK_SCLKSEL_PLL_gc );
 
	// Nun ist der System Clock 32MHz !


	//Variablen 
	uint16_t temp=0; 
	uint16_t max=0;
	//uint16_t offset=0;

	// Alle Pins des PORTE werden als Ausgang definiert
	PORTK.DIR=0xFF; // Alle Pins des PORTE werden als Ausgang definiert
	PORTK.OUT=0x00;

	//ADC CONIFIGURE
	ADCA.CTRLB = 0x08; //ADC_RESOLUTION_12BIT_gc; 
	ADCA.REFCTRL = 0x00; //internal 1.0V Reference 
	ADCA.PRESCALER = 0x04; 	// maximal clk/64 (32MHz/64=500kHz)
	ADCA.CH0.CTRL = ADC_CH_INPUTMODE_SINGLEENDED_gc; //single ended 
	ADCA.CH0.MUXCTRL = ADC_CH_MUXPOS_PIN0_gc; //PORTA:0 input

	ADCA.CTRLA = 0x01; //enable adc 
	//ADCA.CALCTRL = 0x01; //calibrate adc MAL SCHAUN OB ES AUCH VOR ENABLE CTRLA
	

	//eine Conversationszeit abwarten(24ADC-Clocks), hier kann auch eine feste Zeit gewartet werden
	while(!ADCA.CH0.INTFLAGS) { }; //eine Conversationszeit abwarten(24ADC-Clocks)
	// IF wieder löschen
	ADCA.CH0.INTFLAGS = ADC_CH_CHIF_bm;
	//dummy lesen
	temp= ADCA_CH0RES;

	
	while(1){

		while(!ADCA.CH0.INTFLAGS) { }; //eine Conversationszeit abwarten(24ADC-Clocks)
		// IF wieder löschen
		ADCA.CH0.INTFLAGS = ADC_CH_CHIF_bm;
		// Wert entnehmen
		temp = ADCA_CH0RES;
		
		if(temp > max)
			max = temp;

		//PORTA.OUTTGL = 1<<PIN0; // toggelt PA0
		//PORTK.OUT = ~PORTK.OUT; /*Alle Bits werden auf High gesetzt*/

	}
	return 0;
}
 
Ich gehe davon aus, dass es unser Mikrocontrollermodul ist, also das Xmega-A1-USB.

Wir schauen erst mal, ob dein Clocksystem richtig läuft:

In den Projekteinstellungen stellst du den richtigen Systemclock ein:
Menü: Project/Configuration Options
Systemclock: 32000000


Direkt zu Beginn von main() initialisierst du den IO Pin für die StatusLED:
(Output, high, LED aus)

Code:
  PORTQ.DIRSET = 1<<PIN3;
  PORTQ.OUTSET = 1<<PIN3;
Direkt nach der Systemclock-Einstellung und vor deiner ADC Initialisierung verwendest du folgenden code:

Code:
  while(1)
  {
    _delay_ms(500);
    PORTQ.OUTTGL = 1<<PIN3;
  }
Blinkt die LED mit einer Periodendauer von 1s?


Dirk
 
Also komischerweise funktioniert es heute obwohl ich nichts geändert habe

Wenn ich die led blinken lasse und unter Projekt--> Configuration Options--> General die Frequenz nicht als auch auf 32.000.000Hz einstelle blinkt die LED im Sekundentakt.

Jetzt hätt ich die Frage wie ich temp über USART ausgeben kann??
Und was ich noch nicht zusammengebracht habe ist den offsetWert zu bekommen um ihn bei temp abzuziehen?

Schönen Dienstag
Feno
 
Jetzt hätt ich die Frage wie ich temp über USART ausgeben kann??

Ein Beispiel ist in der Appnote AVR1313 oder für das Xmega-A1-USB Mikrocontrollermodul im Support-Forum: Xmega-A1-USB Schnellstart
oder ohne Atmel-Routinen ganz kurz für unser Mikrocontrollermodul wie folgt:

USARTF0, 250kBit/s, 8N1. Wenn du andere Baudraten benötigst, hilft das Datenblatt und unser Tool Xmega-Usart-Calculator.

Initialisierung:
Code:
  uint8_t i;

  /******************************************************************
   * USARTF0 initialisieren, 8N1 250kBit
   ******************************************************************/

  PORTF.DIRSET = 1<<PIN3;  // Pin3 von PortF (TXD0) ist Ausgang
  PORTF.DIRCLR = 1<<PIN2;  // Pin2 von PortF (RXD0) ist Eingang

  // USARTF0, 8 Data bits, No Parity, 1 Stop bit.
  USARTF0.CTRLC = USART_CHSIZE_8BIT_gc | USART_PMODE_DISABLED_gc;

  // 250kBit/s
  USARTF0.CTRLA = 0;
  USARTF0.BAUDCTRLA = 7;  // BSEL
  USARTF0.BAUDCTRLB = 0,  // SCALE, BSEL

  USARTF0.CTRLB = USART_RXEN_bm | USART_TXEN_bm; // Enable RXD TXT

  i = USARTF0.STATUS;  // Flush Buffer
  i = USARTF0.DATA;
Senden:
Code:
  while ((USARTF0.STATUS & USART_DREIF_bm) == 0);  // warten bis Tx Buffer leer
  USARTF0.DATA = i;    // Start
Empfangen:
Code:
  while ((USARTF0.STATUS & USART_RXCIF_bm) == 0);  // warten bis Daten empfangen wurden
  i = USARTF0.DATA;
Und was ich noch nicht zusammengebracht habe ist den offsetWert zu bekommen um ihn bei temp abzuziehen?
Hier hilft die Appnote AVR1300, die du bereits schon nutzt.

So ist die Vorgehensweise für die Messung des Offsets:
  • Du initialisierst einen Kanal (CH0..CH3),
  • stellst den auf Differential Mode,
  • stellst Verstärkung 1 ein
  • wählst in MUXCTRL MUXPOS und MUXNEG des selben Pins aus
  • in CTRLB setzt du das Bit SignedConversion
  • aktivierst den ADC, wartest etwas oder machst Dummy Conversion
  • machst eine SingleConversion (oder mehrere und summierst zwecks Mittelwertbildung)
  • Jetzt hast du den Offset (int16_t)
(Beispielcode habe ich jetzt nicht bereit)

Vor der Offsetmessung schreibst du noch das Kalibrierungsbyte:
Code:
  NVM_CMD = NVM_CMD_READ_CALIB_ROW_gc;
  ADCA.CALL = pgm_read_byte(offsetof(NVM_PROD_SIGNATURES_t, ADCACAL0));
  ADCA.CALH = pgm_read_byte(offsetof(NVM_PROD_SIGNATURES_t, ADCACAL1));
  NVM_CMD = NVM_CMD_NO_OPERATION_gc;
Probiere vielleicht erst mal die Sache mit dem USART und übertrage einen Wert, dessen Größe du kennst, damit du die Funktion validieren kannst. Wenn das funktioniert, würde ich mich an die AD-Wandlung machen.

Dirk
 
Hallo

Also das Senden und Empfangen funktioniert perfekt.

Nun bäuchte ich einen Timer oder Counter weis nicht was besser ist?
Bekommen nähmlich einen Wert der 16bit ist, den Wandle ich dann in dezimal um. Dieser Wert ist die Länge der Messzeit, d.h. ich will den Counter solange laufen lassen und dann soll die Messung nach dieser Zeit abgebrochen werden.

Kann mir wer helfen ?

Schönen Nachmittag
Feno
 
hallo jungs

ich bin nach langem suchen drauf gekommen das mein auslesen eines Wertes von meine ADC nicht richtig funktioniert..
Wenn ich es Zeile für Zeile durchdebugge kommt schon das richtige ergebnis, doch wenn ich ihn laufen lasse schickt er mir dauernd "0".

was kann da falsch sein?
Gibt es eine andere Art vom auslesen?

Code:
while(!ADCA.CH0.INTFLAGS) { };
// IF wieder löschen
ADCA.CH0.INTFLAGS = ADC_CH_CHIF_bm; 
// Wert entnehmen
temp = ADCA_CH0RES;

Bitte um Unterstützung

Danke
 
Hallo fenomaen,
doch wenn ich ihn laufen lasse schickt er mir dauernd "0".

wie "schickt" es denn der Xmega,
  • über USART an ein Terminalprogramm
  • oder liest du ein Register/Speicherstelle mit dem Debugger aus?
Dirk
 
Hallo.

Ich weiss nicht mehr genau, ob du die USART-Übertragung schon einmal überprüft hast. Wenn nicht, dann unbedingt mal machen, vielleicht liegt der Fehler nicht im Bereich des ADC und man sucht an falscher Stelle. Am besten ein Zeichen zum Xmega senden (z.B. ein 'A'), im Xmega 1 addieren und zurücksenden (sollte beim Terminalprogramm ein 'B' geben).

Der Thread hat immer längere Pausen, so dass man sich immer wieder neu reinfinden muss ... ist nicht ganz einfach :(

Vielleicht setze den Sourcecode auch noch einmal in den Anhang.

Dirk
 
Code:
#include <avr/io.h>
//#include <util/delay.h>
#include "clksys_driver.h"
#include "usart_driver.h"
#include <stdint.h>
#include <stdio.h>

/* USART */
#define USART USARTF0

static int uart_getchar();
static int uart_putchar(char c, FILE *stream);

static FILE mystdio = FDEV_SETUP_STREAM(uart_putchar, uart_getchar, _FDEV_SETUP_RW);
   
int get_adc0();

int main (void) {

******************************************************************
	 * System Clock 32MHz (XOSC Quarz 16MHz, PLL Faktor 2)
	 ******************************************************************/

	/* Nach dem Reset ist die Quelle des Systemtaktes der interne
	     2MHz RC-Oszillator (System Clock Selection: RC2MHz)
	*/

	// Oszillator XOSC konfigurieren (12..16MHz, 256 clocks startup time)
	CLKSYS_XOSC_Config( OSC_FRQRANGE_12TO16_gc,
	                      false,
	                      OSC_XOSCSEL_XTAL_256CLK_gc );

	// Oszillator XOSC enable
	CLKSYS_Enable( OSC_XOSCEN_bm );

	// Warten bis der Oszillator bereit ist
	do {} while ( CLKSYS_IsReady( OSC_XOSCRDY_bm ) == 0 );

	// PLL source ist XOSC, Multiplikator x2
	CLKSYS_PLL_Config( OSC_PLLSRC_XOSC_gc, 2 );

	// Enable PLL
	CLKSYS_Enable( OSC_PLLEN_bm );

	// Prescalers konfigurieren
	CLKSYS_Prescalers_Config( CLK_PSADIV_1_gc, CLK_PSBCDIV_1_1_gc );

	// Warten bis PLL locked
	do {} while ( CLKSYS_IsReady( OSC_PLLRDY_bm ) == 0 );

	// Main Clock Source ist Ausgang von PLL
	CLKSYS_Main_ClockSource_Select( CLK_SCLKSEL_PLL_gc );
	

	// Nun ist der System Clock 32MHz !

	/* Hinweis:
	     32kHz TOSC kann nicht in Verbindung mit PLL genutzt werden, da
	     die minimale Eingangsfrequenz des PLLs 400kHz beträgt.
	*/
	PORTF.DIRSET = PIN3_bm;  // Pin3 von PortF (TXD0) ist Ausgang

	PORTF.DIRCLR = PIN2_bm;  // Pin2 von PortF (RXD0) ist Eingang

	// USARTF0, 8 Data bits, No Parity, 1 Stop bit.
	USART_Format_Set(&USART, USART_CHSIZE_8BIT_gc, USART_PMODE_DISABLED_gc, false);

  	/* Bitrate einstellen

     Beispiele BSEL in Abhängigkeit von der Bitrate, fck = 32MHz, Error < 0,8%
	 
	    7 = 250.000bps
	   30 = 128.000bps
       34 =  57.600bps
	   51 =  38.400bps
	   68 =  28.800bps
	  103 =  19.200bps
      138 =  14.400bps
	  207 =   9.600bps
      416 =   4.800bps
      832 =   2.400bps
     1666 =   1.200bps

    Bemerkung: Geprüft wurde mit 250.000bps im USBxpress Modus*/  

  	USART_Baudrate_Set(&USART, 207 , 0);  // 250.000bps (BSEL = 7)

  	/* Enable RX and TX. */
  	USART_Rx_Enable(&USART);
  	USART_Tx_Enable(&USART);

 	USART_GetChar(&USART);             // Flush Receive Buffer

	 // USART_PutChar(&USART, buffer[i]);

	 //ADC CONIFIGURE
	ADCA.CTRLA = 0x01; //enable adc 
	ADCA.CTRLB = 0x08; //ADC_RESOLUTION_12BIT_gc; 
	ADCA.REFCTRL = 0x00; //internal 1.0V Reference 
	ADCA.PRESCALER = 0x02; 	// maximal clk/64 (32MHz/64=500kHz)
	ADCA.CH0.CTRL = ADC_CH_INPUTMODE_SINGLEENDED_gc; //single ended 
	ADCA.CH0.MUXCTRL = ADC_CH_MUXPOS_PIN0_gc; //PORTA:0 input
	//ADCA.CALCTRL = 0x01; //calibrate adc MAL SCHAUN OB ES AUCH VOR ENABLE CTRLA
	
	int temp; 

  	stdout = stdin = &mystdio;
   
	temp=get_adc0();

	while (1)
  	{
		//temp=3000;

		temp=get_adc0();

    	printf("\nEingabe ... %d\r\n", temp);
  	}

	// da die Hauptschleife ständig durchlaufen wird, wird dieser Programmteil nie erreicht.
    return 0;
}

/*-----------------------------------------------------------------------------
  static int uart_putchar(char c, FILE *stream) ...
  Funktion: warten auf Bereitschaft und senden eines Zeichens über UART0
  Eingabe:
    char c ... zu sendendes Zeichen
	FILE *stream ... Ausgabe-Datenstrom
  Rückgabe: int uart_putchar() ... 0
-----------------------------------------------------------------------------*/
static int uart_putchar(char c, FILE *stream)
{
  if (c == '\n')
    uart_putchar('\r', stream);
  while ((USARTF0.STATUS & USART_DREIF_bm) == 0);
  USARTF0.DATA = c;
  return 0;
}

/*-----------------------------------------------------------------------------
  unsigned char uart_getchar() ...
  Funktion: warten auf und lesen eines Zeichens von UART0
  Eingabe: ---
  Rückgabe: unsigned char uart_getchar() ... empfangenes Zeichen
-----------------------------------------------------------------------------*/

static int uart_getchar()
{
  // Warten bis Daten empfangen wurden
  while ((USARTF0.STATUS & USART_RXCIF_bm) == 0);
  // Empfangsregister auslesens
  return(USARTF0.DATA);
}

int get_adc0(){
	
	while(!ADCA.CH0.INTFLAGS); //eine Conversationszeit abwarten(24ADC-Clocks)
	// IF wieder löschen
	ADCA.CH0.INTFLAGS =ADC_CH_CHIF_bm;
	// Wert entnehmen
	return (ADCA_CH0RES);
}

die USART Übertragung funktioniert das habe ich schon am terminal getestet.
 
Hallo.

Noch mal eine Frage, um den Fehler einzugrenzen:

Hast du die USART-Übertragung auch bei den 9.600bps und mit den Routinen getestet, die den Filestream verwenden (von stdio.h), oder hast du zum Testen nur die diskreten Routinen USART_GetChar und USART_PutChar verwendet?

Mit anderen Worten, erhältst du mit printf() die erwartete Ausgabe im Terminalprogramm ("Eingabe ...", ggf. für temp einfach auch mal einen bekannten Wert vorgeben)?

Wenn das soweit funktioniert, müssten wir beim ADC weiter suchen.

Dirk
 
Status
Für weitere Antworten geschlossen.

Über uns

  • Makerconnect ist ein Forum, welches wir ausschließlich für einen Gedankenaustausch und als Diskussionsplattform für Interessierte bereitstellen, welche sich privat, durch das Studium oder beruflich mit Mikrocontroller- und Kleinstrechnersystemen beschäftigen wollen oder müssen ;-)
  • Dirk
  • Du bist noch kein Mitglied in unserer freundlichen Community? Werde Teil von uns und registriere dich in unserem Forum.
  •  Registriere dich

User Menu

 Kaffeezeit

  • Wir arbeiten hart daran sicherzustellen, dass unser Forum permanent online und schnell erreichbar ist, unsere Forensoftware auf dem aktuellsten Stand ist und der Server regelmäßig gewartet wird. Auch die Themen Datensicherheit und Datenschutz sind uns wichtig und hier sind wir auch ständig aktiv. Alles in allem, sorgen wir uns darum, dass alles Drumherum stimmt :-)

    Dir gefällt das Forum und unsere Arbeit und du möchtest uns unterstützen? Unterstütze uns durch deine Premium-Mitgliedschaft!
    Wir freuen uns auch über eine Spende für unsere Kaffeekasse :-)
    Vielen Dank! :ciao:


     Spende uns! (Paypal)