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);
}