Usart (Fleury) Übertragungsprobleme.

/*************************************************************************

Title:    example program for the Interrupt controlled UART library

Author:   Peter Fleury <pfleury@gmx.ch>   http://jump.to/fleury

File:     $Id: test_uart.c,v 1.4 2005/07/10 11:46:30 Peter Exp $

Software: AVR-GCC 3.3

Hardware: any AVR with built-in UART, tested on AT90S8515 at 4 Mhz

DESCRIPTION:

          This example shows how to use the UART library uart.c

*************************************************************************/

#include <stdlib.h>

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/signal.h>

#include <util/delay.h>

#include <avr/pgmspace.h>

#include "glcd-Display3000-211.h"

#include "uart.h"

/* define CPU frequency in Mhz here if not defined in Makefile */

#ifndef F_CPU

#define F_CPU 16000000UL

#endif

/* 9600 baud */

#define UART_BAUD_RATE      9600      

int main(void)

{

    unsigned int c;

    char buffer[7];

    int  num=134;

    LCD_Init();  // caution: this also defines SPI for the display and also PortB (all ports but MISO are output)   

  Orientation = Portrait180;

  LCD_Cls(black); 

    /*

     *  Initialize UART library, pass baudrate and AVR cpu clock

     *  with the macro 

     *  UART_BAUD_SELECT() (normal speed mode )

     *  or 

     *  UART_BAUD_SELECT_DOUBLE_SPEED() ( double speed mode)

     */

    uart1_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); 

    /*

     * now enable interrupt, since UART library is interrupt controlled

     */

    sei();

    /*

     *  Transmit string to UART

     *  The string is buffered by the uart library in a circular buffer

     *  and one character at a time is transmitted to the UART using interrupts.

     *  uart_puts() blocks if it can not write the whole string to the circular 

     *  buffer

     */

    uart1_puts("String stored in SRAM\n");

    /*

     * Transmit string from program memory to UART

     */

    uart1_puts_P("String stored in FLASH\n");

    /* 

     * Use standard avr-libc functions to convert numbers into string

     * before transmitting via UART

     */     

    itoa( num, buffer, 10);   // convert interger into string (decimal format)         

    uart1_puts(buffer);        // and transmit string to UART

    /*

     * Transmit single character to UART

     */

    uart1_putc('\r');

    LCD_Print("Höhe:", 1, 160, 2, 1, 1, green, black);

    for(;;)

    {

        /*

         * Get received character from ringbuffer

         * uart_getc() returns in the lower byte the received character and 

         * in the higher byte (bitmask) the last receive error

         * UART_NO_DATA is returned when no data is available.

         *

         */

        c = uart1_getc();

        if ( c & UART_NO_DATA )

        {

            /* 

             * no data available from UART 

             */

        }

        else

        {

            /*

             * new data available from UART

             * check for Frame or Overrun error

             */

            if ( c & UART_FRAME_ERROR )

            {

                /* Framing Error detected, i.e no stop bit detected */

                uart_puts_P("UART Frame Error: ");

            }

            if ( c & UART_OVERRUN_ERROR )

            {

                /* 

                 * Overrun, a character already present in the UART UDR register was 

                 * not read by the interrupt handler before the next character arrived,

                 * one or more received characters have been dropped

                 */

                uart1_puts_P("UART Overrun Error: ");

            }

            if ( c & UART_BUFFER_OVERFLOW )

            {

                /* 

                 * We are not reading the receive buffer fast enough,

                 * one or more received character have been dropped 

                 */

                uart1_puts_P("Buffer overflow error: ");

            }

            /* 

             * send received character back

             */

            uart1_putc( (unsigned char)c );

        }

    }

}

//  Enhanced delay-routine (wait) as as the standard delay routine (_delay_ms) is not able to delay

//  more than 17 ms maximum as of the used 8-bit-timer (depending on used crystal)

void delay_ms(uint16_t period)   //delay routine (milliseconds)

{

  for(unsigned int i=0; i<=period; i++)

    _delay_ms(1);

}

###############################################################################

# Makefile for the project uarttest

###############################################################################

## General Flags

PROJECT = uarttest

MCU = atmega128

TARGET = uarttest.elf

CC = avr-gcc

## Options common to compile, link and assembly rules

COMMON = -mmcu=$(MCU)

## Compile options common for all C compilation units.

CFLAGS = $(COMMON)

CFLAGS += -Wall -gdwarf-2 -std=gnu99 -DF_CPU=16000000UL -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums

CFLAGS += -MD -MP -MT $(*F).o -MF dep/$(@F).d 

## Assembly specific flags

ASMFLAGS = $(COMMON)

ASMFLAGS += $(CFLAGS)

ASMFLAGS += -x assembler-with-cpp -Wa,-gdwarf2

## Linker flags

LDFLAGS = $(COMMON)

LDFLAGS +=  -Wl,-Map=uarttest.map

## Intel Hex file production flags

HEX_FLASH_FLAGS = -R .eeprom -R .fuse -R .lock -R .signature

HEX_EEPROM_FLAGS = -j .eeprom

HEX_EEPROM_FLAGS += --set-section-flags=.eeprom="alloc,load"

HEX_EEPROM_FLAGS += --change-section-lma .eeprom=0 --no-change-warnings

## Objects that must be built in order to link

OBJECTS = uarttest.o uart.o glcd-Display3000-211.o font_f-5x8.o font_f-8x14.o 

## Objects explicitly added by the user

LINKONLYOBJECTS = 

## Build

all: $(TARGET) uarttest.hex uarttest.eep uarttest.lss size

## Compile

uarttest.o: ../uarttest.c

  $(CC) $(INCLUDES) $(CFLAGS) -c  $<

uart.o: ../uart.c

  $(CC) $(INCLUDES) $(CFLAGS) -c  $<

glcd-Display3000-211.o: ../glcd-Display3000-211.c

  $(CC) $(INCLUDES) $(CFLAGS) -c  $<

font_f-5x8.o: ../font_f-5x8.c

  $(CC) $(INCLUDES) $(CFLAGS) -c  $<

font_f-8x14.o: ../font_f-8x14.c

  $(CC) $(INCLUDES) $(CFLAGS) -c  $<

##Link

$(TARGET): $(OBJECTS)

   $(CC) $(LDFLAGS) $(OBJECTS) $(LINKONLYOBJECTS) $(LIBDIRS) $(LIBS) -o $(TARGET)

%.hex: $(TARGET)

  avr-objcopy -O ihex $(HEX_FLASH_FLAGS)  $< $@

%.eep: $(TARGET)

  -avr-objcopy $(HEX_EEPROM_FLAGS) -O ihex $< $@ || exit 0

%.lss: $(TARGET)

  avr-objdump -h -S $< > $@

size: ${TARGET}

  @echo

  @avr-size -C --mcu=${MCU} ${TARGET}

## Clean target

.PHONY: clean

clean:

  -rm -rf $(OBJECTS) uarttest.elf dep/* uarttest.hex uarttest.eep uarttest.lss uarttest.map

## Other dependencies

-include $(shell mkdir dep 2>/dev/null) $(wildcard dep/*)

/* Programmkopf mit Headerdateien*/

#include <stdlib.h>

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/pgmspace.h>

#include <util/delay.h>

#include <string.h>

#include <stdio.h>

#define F_CPU 16000000UL  //Quarzfrequenz

#define BAUD 38400UL      //Baudrate für UART Übertragung

#define MYUBRR F_CPU/16/BAUD-1

//****************************** UART

// UART Einstellung    

void uart_init(unsigned int ubrr)

{

  UBRR1H = (unsigned char)(ubrr>>8);

  UBRR1L = (unsigned char)ubrr;

  UCSR1B = (1<<RXEN1)|(1<<TXEN1);            //UART TX einschalten

  //UCSR1C = (1<<USBS1)|(3<<UCSZ10);

  UCSR0C = (0<<UMSEL1)|(0<<USBS1)|(3<<UCSZ11);    //Asynchron 8N1

}

void USART_Transmit( unsigned char data )

{

/* Wait for empty transmit buffer */

while ( !( UCSR1A & (1<<UDRE1)) )

;

/* Put data into buffer, sends the data */

UDR1 = data;

}

void put_s(const char *s )

{

    while (*s) 

      USART_Transmit(*s++);

}/* uart1_puts */

int main(void)

{

    uart_init( MYUBRR); 

    sei();

    for(;;)

    { 

    delay_ms(1000);

    put_s("Test");

    }

}

//    Enhanced delay-routine (wait) as as the standard delay routine (_delay_ms) is not able to delay

//    more than 17 ms maximum as of the used 8-bit-timer (depending on used crystal)

void delay_ms(uint16_t period)     //delay routine (milliseconds)

{

    for(unsigned int i=0; i<=period; i++)

        _delay_ms(1);

}