Erstes C Programm UART - Warum wird zweimal "Hallo World" gesendet?

[dl9hda]

Moin,

also das Problem ist der ISP. Wenn ich den Abziehe, dann macht das Programmw was es soll...



Gruß
Holger










Moin,

ich möchte von Assembler auf C umsteigen und habe mein erstes Projekt mit ATMEL-Studio 6.1 angelegt. Ich möchte ganz einfach nur einen Text "Hallo Welt" via UART übertragen.

Als Anfänger habe ich mir dazu einiges von rn-wissen.de zusammengeklickt. Ich habe fifo.h und uart.h erstellt und mein .c-Datei mit dem Namen _20140117_UART_ATMEGA32.c.

Nach dem Build übertrage ich das fertige hex mit meinem AVR-ISP MKII in den ATMEGA32. Sowei alles gut. Aber wenn ich den Controller einschalte wird zweimal mit einer etwa 0,5 Sekunden Pause Hallo Welt übertragen.

Warum?


Gruß
Holger

/*
 * _20140117_UART_ATMEGA32.c
 *
 * Created: 17.01.2014 13:18:31
 *  Author: DL9HDA
 */ 


#include <avr/io.h>
#include <avr/interrupt.h>
#include "uart.h"
#include "fifo.h" 

#ifndef F_CPU
#define F_CPU 16000000UL
#endif

#ifndef BAUDRATE
#define BAUDRATE 9600UL
#endif

// FIFO-Objekte und Puffer für die Ein- und Ausgabe

#define BUFSIZE_IN  0x40
uint8_t inbuf[BUFSIZE_IN];
fifo_t infifo;

#define BUFSIZE_OUT 0x40
uint8_t outbuf[BUFSIZE_OUT];
fifo_t outfifo;

#define CR "\r\n"

char text[] = "Hallo Welt." CR;

void uart_puts (const char *s)
{
	do
	{
		uart_putc (*s);
	}
	while (*s++);
}


int main(void)
{
	sei();

	uart_init();

	uart_puts (text);
	
	while(1)
	{
		//TODO:: Please write your application code
	}
}






void uart_init (void)
{
	uint8_t sreg = SREG;
	uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/(16UL*BAUDRATE) - 1);

	UBRRH = (uint8_t) (ubrr>>8);
	UBRRL = (uint8_t) (ubrr);

	// Interrupts kurz deaktivieren
	cli();

	// UART Receiver und Transmitter anschalten, Receive-Interrupt aktivieren
	// Data mode 8N1, asynchron
	UCSRB = (1 << RXEN) | (1 << TXEN) | (1 << RXCIE);
	UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);

	// Flush Receive-Buffer (entfernen evtl. vorhandener ungültiger Werte)
	do
	{
		// UDR auslesen (Wert wird nicht verwendet)
		UDR;
	}
	while (UCSRA & (1 << RXC));

	// Rücksetzen von Receive und Transmit Complete-Flags
	UCSRA = (1 << RXC) | (1 << TXC);

	// Global Interrupt-Flag wieder herstellen
	SREG = sreg;

	// FIFOs für Ein- und Ausgabe initialisieren
	fifo_init (&infifo,   inbuf, BUFSIZE_IN);
	fifo_init (&outfifo, outbuf, BUFSIZE_OUT);
}



ISR (USART_RXC_vect)
{
	_inline_fifo_put (&infifo, UDR);
}

// Ein Zeichen aus der Ausgabe-FIFO lesen und ausgeben
// Ist das Zeichen fertig ausgegeben, wird ein neuer SIG_UART_DATA-IRQ getriggert
// Ist die FIFO leer, deaktiviert die ISR ihren eigenen IRQ.
ISR (USART_UDRE_vect)
{
	if (outfifo.count > 0)
	UDR = _inline_fifo_get (&outfifo);
	else
	UCSRB &= ~(1 << UDRIE);
}




int uart_putc (const uint8_t c)
{
	int ret = fifo_put (&outfifo, c);
	
	UCSRB |= (1 << UDRIE);
	
	return ret;
}

int uart_getc_nowait (void)
{
	return fifo_get_nowait (&infifo);
}

uint8_t uart_getc_wait (void)
{
	return fifo_get_wait (&infifo);
}

#ifndef UART_H
#define UART_H

#include <avr/io.h>

extern void uart_init (void);
extern int uart_putc (const uint8_t);
extern uint8_t uart_getc_wait (void);
extern int uart_getc_nowait (void);

static inline void uart_flush (void)
{
	while (UCSRB & (1 << UDRIE));
}

#endif /* UART_H */

#ifndef FIFO_H
#define FIFO_H

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

typedef struct
{
	uint8_t volatile count;       // # Zeichen im Puffer
	uint8_t size;                 // Puffer-Größe
	uint8_t *pread;               // Lesezeiger
	uint8_t *pwrite;              // Schreibzeiger
	uint8_t read2end, write2end;  // # Zeichen bis zum Überlauf Lese-/Schreibzeiger
} fifo_t;

extern void fifo_init (fifo_t*, uint8_t* buf, const uint8_t size);
extern uint8_t fifo_put (fifo_t*, const uint8_t data);
extern uint8_t fifo_get_wait (fifo_t*);
extern int fifo_get_nowait (fifo_t*);

static inline uint8_t
_inline_fifo_put (fifo_t *f, const uint8_t data)
{
	if (f->count >= f->size)
	return 0;
	
	uint8_t * pwrite = f->pwrite;
	
	*(pwrite++) = data;
	
	uint8_t write2end = f->write2end;
	
	if (--write2end == 0)
	{
		write2end = f->size;
		pwrite -= write2end;
	}
	
	f->write2end = write2end;
	f->pwrite = pwrite;

	uint8_t sreg = SREG;
	cli();
	f->count++;
	SREG = sreg;
	
	return 1;
}

static inline uint8_t
_inline_fifo_get (fifo_t *f)
{
	uint8_t *pread = f->pread;
	uint8_t data = *(pread++);
	uint8_t read2end = f->read2end;
	
	if (--read2end == 0)
	{
		read2end = f->size;
		pread -= read2end;
	}
	
	f->pread = pread;
	f->read2end = read2end;
	
	uint8_t sreg = SREG;
	cli();
	f->count--;
	SREG = sreg;
	
	return data;
}

#endif /* FIFO_H */




void fifo_init (fifo_t *f, uint8_t *buffer, const uint8_t size)
{
	f->count = 0;
	f->pread = f->pwrite = buffer;
	f->read2end = f->write2end = f->size = size;
}

uint8_t fifo_put (fifo_t *f, const uint8_t data)
{
	return _inline_fifo_put (f, data);
}

uint8_t fifo_get_wait (fifo_t *f)
{
	while (!f->count);
	
	return _inline_fifo_get (f);
}

int fifo_get_nowait (fifo_t *f)
{
	if (!f->count)		return -1;
	
	return (int) _inline_fifo_get (f);
}