-
        

Ergebnis 1 bis 6 von 6

Thema: P.fleurys_Uartlib auf Mega2560 zum laufen bringen

  1. #1

    Idee P.fleurys_Uartlib auf Mega2560 zum laufen bringen

    Anzeige

    Hallo liebe Forengemeinde,

    wie aus der Überschrift zu erkennen ist, versuche ich gerade Peter fleurys Uartlib auf einem Mega 2560(Arduino) zum laufen zu bringen den ich mittels ISP und winAVR-GCC Beschreibe.
    Ich hatte die Lib schon mit Atmegas8-16-32 in Betrieb und frage mich nun warum das einfach nicht funktioniert.

    Hardwarefehler schließe ich mal aus.
    Hängt das vllt mit meinem Makefile zusammen...???

    dort ist ja eigentlich
    # MCU name
    MCU = atmega2560
    definiert?

    jedoch frage ich mich ob der compiler das auch mitbekommt damit in der uart.c
    PHP-Code:
    #elif defined(__AVR_ATmega2560__) || defined(__AVR_ATmega2561__) || defined(__AVR_ATmega1280__)  || defined(__AVR_ATmega1281__) || defined(__AVR_ATmega640__)
    /* ATmega with two USART */
      #define ATMEGA_USART0
      #define ATMEGA_USART1
      #define UART0_RECEIVE_INTERRUPT   USART0_RX_vect
      #define UART1_RECEIVE_INTERRUPT   USART1_RX_vect
      #define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
      #define UART1_TRANSMIT_INTERRUPT  USART1_UDRE_vect
      #define UART0_STATUS   UCSR0A
      #define UART0_CONTROL  UCSR0B
      #define UART0_DATA     UDR0
      #define UART0_UDRIE    UDRIE0
      #define UART1_STATUS   UCSR1A
      #define UART1_CONTROL  UCSR1B
      #define UART1_DATA     UDR1
      #define UART1_UDRIE    UDRIE1 
    die Register auch richtig benamst werden?


    ich verstehe das nicht ganz, kann mir jemand dabei helfen?

  2. #2
    Ich hab jetzt mal alle überflüssigen Defines aus der uart.c rausgeworfen aber es will einfach nicht funktionieren. Die LEDS am RX und TX bleiben aus....
    Ich benutzen in meiner main ebenfalls ISR (TIMER1_COMPA_vect) und ISR (TIMER4_COMPA_vect). Beißt sich der Code vllt mit den Timern?? Compilen klappt ohne Fehler uC zu Programmieren funktioniert auch Per ISP und das Programm läuft mit 16 MHZ. Hab den Arduino nicht umgefused(Ist im Auslieferungszustand).

    uart.c:
    Code:
    /*************************************************************************
    Title:    Interrupt UART library with receive/transmit circular buffers
    Author:   Peter Fleury <pfleury@gmx.ch>   http://jump.to/fleury
    File:     $Id: uart.c,v 1.8 2012/09/14 16:16:45 peter Exp $
    Software: AVR-GCC 4.1, AVR Libc 1.4.6 or higher
    Hardware: any AVR with built-in UART, 
    License:  GNU General Public License 
              
    DESCRIPTION:
        An interrupt is generated when the UART has finished transmitting or
        receiving a byte. The interrupt handling routines use circular buffers
        for buffering received and transmitted data.
        
        The UART_RX_BUFFER_SIZE and UART_TX_BUFFER_SIZE variables define
        the buffer size in bytes. Note that these variables must be a 
        power of 2.
        
    USAGE:
        Refere to the header file uart.h for a description of the routines. 
        See also example test_uart.c.
    
    NOTES:
        Based on Atmel Application Note AVR306
                        
    LICENSE:
        Copyright (C) 2006 Peter Fleury
    
        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        any later version.
    
        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
                            
    *************************************************************************/
    #include <avr/io.h>
    #include <avr/interrupt.h>
    #include <avr/pgmspace.h>
    #include "uart.h"
    
    
    /*
     *  constants and macros
     */
    
    /* size of RX/TX buffers */
    #define UART_RX_BUFFER_MASK ( UART_RX_BUFFER_SIZE - 1)
    #define UART_TX_BUFFER_MASK ( UART_TX_BUFFER_SIZE - 1)
    
    #if ( UART_RX_BUFFER_SIZE & UART_RX_BUFFER_MASK )
    #error RX buffer size is not a power of 2
    #endif
    #if ( UART_TX_BUFFER_SIZE & UART_TX_BUFFER_MASK )
    #error TX buffer size is not a power of 2
    #endif
    
    
    // NUR2560 SUPPORT-----------------------------------------------------------------------------------------------
      #define ATMEGA_USART0
      #define ATMEGA_USART1
      #define UART0_RECEIVE_INTERRUPT   USART0_RX_vect
      #define UART1_RECEIVE_INTERRUPT   USART1_RX_vect
      #define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
      #define UART1_TRANSMIT_INTERRUPT  USART1_UDRE_vect
      #define UART0_STATUS   UCSR0A
      #define UART0_CONTROL  UCSR0B
      #define UART0_DATA     UDR0
      #define UART0_UDRIE    UDRIE0
      #define UART1_STATUS   UCSR1A
      #define UART1_CONTROL  UCSR1B
      #define UART1_DATA     UDR1
      #define UART1_UDRIE    UDRIE1  
    
    
    
    /*
     *  module global variables
     */
    static volatile unsigned char UART_TxBuf[UART_TX_BUFFER_SIZE];
    static volatile unsigned char UART_RxBuf[UART_RX_BUFFER_SIZE];
    static volatile unsigned char UART_TxHead;
    static volatile unsigned char UART_TxTail;
    static volatile unsigned char UART_RxHead;
    static volatile unsigned char UART_RxTail;
    static volatile unsigned char UART_LastRxError;
    
    #if defined( ATMEGA_USART1 )
    static volatile unsigned char UART1_TxBuf[UART_TX_BUFFER_SIZE];
    static volatile unsigned char UART1_RxBuf[UART_RX_BUFFER_SIZE];
    static volatile unsigned char UART1_TxHead;
    static volatile unsigned char UART1_TxTail;
    static volatile unsigned char UART1_RxHead;
    static volatile unsigned char UART1_RxTail;
    static volatile unsigned char UART1_LastRxError;
    #endif
    
    
    
    ISR (UART0_RECEIVE_INTERRUPT)	
    /*************************************************************************
    Function: UART Receive Complete interrupt
    Purpose:  called when the UART has received a character
    **************************************************************************/
    {
        unsigned char tmphead;
        unsigned char data;
        unsigned char usr;
        unsigned char lastRxError;
     
     
        /* read UART status register and UART data register */ 
        usr  = UART0_STATUS;
        data = UART0_DATA;
        
        /* */
    #if defined( AT90_UART )
        lastRxError = (usr & (_BV(FE)|_BV(DOR)) );
    #elif defined( ATMEGA_USART )
        lastRxError = (usr & (_BV(FE)|_BV(DOR)) );
    #elif defined( ATMEGA_USART0 )
        lastRxError = (usr & (_BV(FE0)|_BV(DOR0)) );
    #elif defined ( ATMEGA_UART )
        lastRxError = (usr & (_BV(FE)|_BV(DOR)) );
    #endif
            
        /* calculate buffer index */ 
        tmphead = ( UART_RxHead + 1) & UART_RX_BUFFER_MASK;
        
        if ( tmphead == UART_RxTail ) {
            /* error: receive buffer overflow */
            lastRxError = UART_BUFFER_OVERFLOW >> 8;
        }else{
            /* store new index */
            UART_RxHead = tmphead;
            /* store received data in buffer */
            UART_RxBuf[tmphead] = data;
        }
        UART_LastRxError |= lastRxError;   
    }
    
    
    ISR (UART0_TRANSMIT_INTERRUPT)
    /*************************************************************************
    Function: UART Data Register Empty interrupt
    Purpose:  called when the UART is ready to transmit the next byte
    **************************************************************************/
    {
        unsigned char tmptail;
    
        
        if ( UART_TxHead != UART_TxTail) {
            /* calculate and store new buffer index */
            tmptail = (UART_TxTail + 1) & UART_TX_BUFFER_MASK;
            UART_TxTail = tmptail;
            /* get one byte from buffer and write it to UART */
            UART0_DATA = UART_TxBuf[tmptail];  /* start transmission */
        }else{
            /* tx buffer empty, disable UDRE interrupt */
            UART0_CONTROL &= ~_BV(UART0_UDRIE);
        }
    }
    
    
    /*************************************************************************
    Function: uart_init()
    Purpose:  initialize UART and set baudrate
    Input:    baudrate using macro UART_BAUD_SELECT()
    Returns:  none
    **************************************************************************/
    void uart_init(unsigned int baudrate)
    {
        UART_TxHead = 0;
        UART_TxTail = 0;
        UART_RxHead = 0;
        UART_RxTail = 0;
        
    #if defined( AT90_UART )
        /* set baud rate */
        UBRR = (unsigned char)baudrate; 
    
        /* enable UART receiver and transmmitter and receive complete interrupt */
        UART0_CONTROL = _BV(RXCIE)|_BV(RXEN)|_BV(TXEN);
    
    #elif defined (ATMEGA_USART)
        /* Set baud rate */
        if ( baudrate & 0x8000 )
        {
        	 UART0_STATUS = (1<<U2X);  //Enable 2x speed 
        	 baudrate &= ~0x8000;
        }
        UBRRH = (unsigned char)(baudrate>>8);
        UBRRL = (unsigned char) baudrate;
       
        /* Enable USART receiver and transmitter and receive complete interrupt */
        UART0_CONTROL = _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);
        
        /* Set frame format: asynchronous, 8data, no parity, 1stop bit */
        #ifdef URSEL
        UCSRC = (1<<URSEL)|(3<<UCSZ0);
        #else
        UCSRC = (3<<UCSZ0);
        #endif 
        
    #elif defined (ATMEGA_USART0 )
        /* Set baud rate */
        if ( baudrate & 0x8000 ) 
        {
       		UART0_STATUS = (1<<U2X0);  //Enable 2x speed 
       		baudrate &= ~0x8000;
       	}
        UBRR0H = (unsigned char)(baudrate>>8);
        UBRR0L = (unsigned char) baudrate;
    
        /* Enable USART receiver and transmitter and receive complete interrupt */
        UART0_CONTROL = _BV(RXCIE0)|(1<<RXEN0)|(1<<TXEN0);
        
        /* Set frame format: asynchronous, 8data, no parity, 1stop bit */
        #ifdef URSEL0
        UCSR0C = (1<<URSEL0)|(3<<UCSZ00);
        #else
        UCSR0C = (3<<UCSZ00);
        #endif 
    
    #elif defined ( ATMEGA_UART )
        /* set baud rate */
        if ( baudrate & 0x8000 ) 
        {
        	UART0_STATUS = (1<<U2X);  //Enable 2x speed 
        	baudrate &= ~0x8000;
        }
        UBRRHI = (unsigned char)(baudrate>>8);
        UBRR   = (unsigned char) baudrate;
    
        /* Enable UART receiver and transmitter and receive complete interrupt */
        UART0_CONTROL = _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);
    
    #endif
    
    }/* uart_init */
    
    
    /*************************************************************************
    Function: uart_getc()
    Purpose:  return byte from ringbuffer  
    Returns:  lower byte:  received byte from ringbuffer
              higher byte: last receive error
    **************************************************************************/
    unsigned int uart_getc(void)
    {    
        unsigned char tmptail;
        unsigned char data;
    
    
        if ( UART_RxHead == UART_RxTail ) {
            return UART_NO_DATA;   /* no data available */
        }
        
        /* calculate /store buffer index */
        tmptail = (UART_RxTail + 1) & UART_RX_BUFFER_MASK;
        UART_RxTail = tmptail; 
        
        /* get data from receive buffer */
        data = UART_RxBuf[tmptail];
        
        data = (UART_LastRxError << 8) + data;
        UART_LastRxError = 0;
        return data;
    
    }/* uart_getc */
    
    
    /*************************************************************************
    Function: uart_putc()
    Purpose:  write byte to ringbuffer for transmitting via UART
    Input:    byte to be transmitted
    Returns:  none          
    **************************************************************************/
    void uart_putc(unsigned char data)
    {
        unsigned char tmphead;
    
        
        tmphead  = (UART_TxHead + 1) & UART_TX_BUFFER_MASK;
        
        while ( tmphead == UART_TxTail ){
            ;/* wait for free space in buffer */
        }
        
        UART_TxBuf[tmphead] = data;
        UART_TxHead = tmphead;
    
        /* enable UDRE interrupt */
        UART0_CONTROL    |= _BV(UART0_UDRIE);
    
    }/* uart_putc */
    
    
    /*************************************************************************
    Function: uart_puts()
    Purpose:  transmit string to UART
    Input:    string to be transmitted
    Returns:  none          
    **************************************************************************/
    void uart_puts(const char *s )
    {
        while (*s) 
          uart_putc(*s++);
    
    }/* uart_puts */
    
    
    /*************************************************************************
    Function: uart_puts_p()
    Purpose:  transmit string from program memory to UART
    Input:    program memory string to be transmitted
    Returns:  none
    **************************************************************************/
    void uart_puts_p(const char *progmem_s )
    {
        register char c;
        
        while ( (c = pgm_read_byte(progmem_s++)) ) 
          uart_putc(c);
    
    }/* uart_puts_p */
    
    
    /*
     * these functions are only for ATmegas with two USART
     */
    #if defined( ATMEGA_USART1 )
    
    ISR(UART1_RECEIVE_INTERRUPT)
    /*************************************************************************
    Function: UART1 Receive Complete interrupt
    Purpose:  called when the UART1 has received a character
    **************************************************************************/
    {
        unsigned char tmphead;
        unsigned char data;
        unsigned char usr;
        unsigned char lastRxError;
     
     
        /* read UART status register and UART data register */ 
        usr  = UART1_STATUS;
        data = UART1_DATA;
        
        /* */
        lastRxError = (usr & (_BV(FE1)|_BV(DOR1)) );
            
        /* calculate buffer index */ 
        tmphead = ( UART1_RxHead + 1) & UART_RX_BUFFER_MASK;
        
        if ( tmphead == UART1_RxTail ) {
            /* error: receive buffer overflow */
            lastRxError = UART_BUFFER_OVERFLOW >> 8;
        }else{
            /* store new index */
            UART1_RxHead = tmphead;
            /* store received data in buffer */
            UART1_RxBuf[tmphead] = data;
        }
        UART1_LastRxError |= lastRxError;   
    }
    
    
    ISR(UART1_TRANSMIT_INTERRUPT)
    /*************************************************************************
    Function: UART1 Data Register Empty interrupt
    Purpose:  called when the UART1 is ready to transmit the next byte
    **************************************************************************/
    {
        unsigned char tmptail;
    
        
        if ( UART1_TxHead != UART1_TxTail) {
            /* calculate and store new buffer index */
            tmptail = (UART1_TxTail + 1) & UART_TX_BUFFER_MASK;
            UART1_TxTail = tmptail;
            /* get one byte from buffer and write it to UART */
            UART1_DATA = UART1_TxBuf[tmptail];  /* start transmission */
        }else{
            /* tx buffer empty, disable UDRE interrupt */
            UART1_CONTROL &= ~_BV(UART1_UDRIE);
        }
    }
    
    
    /*************************************************************************
    Function: UART1_init()
    Purpose:  initialize UART1 and set baudrate
    Input:    baudrate using macro UART_BAUD_SELECT()
    Returns:  none
    **************************************************************************/
    void UART1_init(unsigned int baudrate)
    {
        UART1_TxHead = 0;
        UART1_TxTail = 0;
        UART1_RxHead = 0;
        UART1_RxTail = 0;
        
    
        /* Set baud rate */
        if ( baudrate & 0x8000 ) 
        {
        	UART1_STATUS = (1<<U2X1);  //Enable 2x speed 
          baudrate &= ~0x8000;
        }
        UBRR1H = (unsigned char)(baudrate>>8);
        UBRR1L = (unsigned char) baudrate;
    
        /* Enable USART receiver and transmitter and receive complete interrupt */
        UART1_CONTROL = _BV(RXCIE1)|(1<<RXEN1)|(1<<TXEN1);
        
        /* Set frame format: asynchronous, 8data, no parity, 1stop bit */   
        #ifdef URSEL1
        UCSR1C = (1<<URSEL1)|(3<<UCSZ10);
        #else
        UCSR1C = (3<<UCSZ10);
        #endif 
    }/* uart_init */
    
    
    /*************************************************************************
    Function: UART1_getc()
    Purpose:  return byte from ringbuffer  
    Returns:  lower byte:  received byte from ringbuffer
              higher byte: last receive error
    **************************************************************************/
    unsigned int UART1_getc(void)
    {    
        unsigned char tmptail;
        unsigned char data;
    
    
        if ( UART1_RxHead == UART1_RxTail ) {
            return UART_NO_DATA;   /* no data available */
        }
        
        /* calculate /store buffer index */
        tmptail = (UART1_RxTail + 1) & UART_RX_BUFFER_MASK;
        UART1_RxTail = tmptail; 
        
        /* get data from receive buffer */
        data = UART1_RxBuf[tmptail];
        
        data = (UART1_LastRxError << 8) + data;
        UART_LastRxError = 0;
        return data;
    
    }/* UART1_getc */
    
    
    /*************************************************************************
    Function: UART1_putc()
    Purpose:  write byte to ringbuffer for transmitting via UART
    Input:    byte to be transmitted
    Returns:  none          
    **************************************************************************/
    void UART1_putc(unsigned char data)
    {
        unsigned char tmphead;
    
        
        tmphead  = (UART1_TxHead + 1) & UART_TX_BUFFER_MASK;
        
        while ( tmphead == UART1_TxTail ){
            ;/* wait for free space in buffer */
        }
        
        UART1_TxBuf[tmphead] = data;
        UART1_TxHead = tmphead;
    
        /* enable UDRE interrupt */
        UART1_CONTROL    |= _BV(UART1_UDRIE);
    
    }/* UART1_putc */
    
    
    /*************************************************************************
    Function: UART1_puts()
    Purpose:  transmit string to UART1
    Input:    string to be transmitted
    Returns:  none          
    **************************************************************************/
    void UART1_puts(const char *s )
    {
        while (*s) 
          UART1_putc(*s++);
    
    }/* UART1_puts */
    
    
    /*************************************************************************
    Function: UART1_puts_p()
    Purpose:  transmit string from program memory to UART1
    Input:    program memory string to be transmitted
    Returns:  none
    **************************************************************************/
    void UART1_puts_p(const char *progmem_s )
    {
        register char c;
        
        while ( (c = pgm_read_byte(progmem_s++)) ) 
          UART1_putc(c);
    
    }/* UART1_puts_p */
    
    
    #endif

    in der Main führ ich ganz einfach:


    #define F_CPU 16000000UL
    #define UART_BAUD_RATE 9600
    #define UBRR_VAL ((F_CPU+UART_BAUD_RATE*/(UART_BAUD_RATE*16)-1) // clever runden
    #define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1))) // Reale Baudrate
    #define BAUD_ERROR ((BAUD_REAL*1000)/UART_BAUD_RATE-1000) // Fehler in Promille

    uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );

    aus und dann das normale Uartprogramm das auf nem MEGA32 ja auch funktioniert...

    Code:
    c = uart_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
                     */
                    uart_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 
                     */
                    uart_puts_P("Buffer overflow error: ");
                }
                /* 
                 * send received character back
                uart_putc( (unsigned char)c );
                */
               
    		   if((unsigned char)c!=13)
    		   {
    				ch[index]=c;
    				index++;   
    		   }			
    			else
    			{/*MEIN CODE......*/}
    was mach ich nur falsch? bin für jeden heißen Tipp Dankbar.
    Ich hätt einfach gern eine anständige funktionsfähige c Lib für den 2560 und will mich nicht wirklich mit der Arduinoumgebung anfreunden.

    Danke schonmal.

  3. #3

    Hab den Fehler mitlerweile gefunden...

    falls es jemanden interessiert:

    ich hab in der main:
    PHP-Code:
    uart_initUART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); //F_CPU 
    welches

    PHP-Code:
    UART_BAUD_SELECT(baudRate,xtalCpu)  (((xtalCpu) + 8UL * (baudRate)) / (16UL * (baudRate)) -1UL
    darstellt und warscheinlich einen falschen Wert ausspuckt

    in

    PHP-Code:
    uart_init(MYUBRR_VAL); 
    umgeändert

    für MYUBRR_VAL habe ich
    PHP-Code:
    MYUBRR_VAL 16000000/16/UART_BAUD_RATE-
    eingesetzt und schon liefs wieder...
    Peters lib habe ich nicht modifiziert.


    Hier mal noch meine verwendeten Fusesettings
    Klicke auf die Grafik für eine größere Ansicht

Name:	mega2560Fuses.jpg
Hits:	4
Größe:	91,7 KB
ID:	26787

    trotzdem danke.

  4. #4

    Idee

    Ich bin beim Programmieren nun wieder bei meinem alten UARTPROBLEM mit dem UBRR Wert gelandet da ich die Baudrate erhöhen wollte.

    Kann es sein das MYUBRR_VAL 16000000/16/UART_BAUD_RATE-1 nur zufällig funktioniert?
    Sobald ich die Baudrate erhöhe funktioniert der Code schon nichtmehr.

    Defines... Fehlerhaft?
    PHP-Code:
    #define F_CPU 16000000UL
    #define UART_BAUD_RATE 9600     //9600
    #define UBRR_VAL ((F_CPU+UART_BAUD_RATE*8)/(UART_BAUD_RATE*16)-1)   // clever runden
    #define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
    #define BAUD_ERROR ((BAUD_REAL*1000)/UART_BAUD_RATE-1000) // Fehler in Promille 

    Makro nicht korrekt???
    PHP-Code:
    #define UART_BAUD_SELECT(baudRate,xtalCpu)  (((xtalCpu) + 8UL * (baudRate)) / (16UL * (baudRate)) -1UL) 
    Aufruf in der MAIN verkehrt???
    PHP-Code:
    uart_initUART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); 

    oder die Initfunktion von p.fleury ansich nicht geeignet???

    PHP-Code:
    void uart_init(unsigned int baudrate)
    {
        
    UART_TxHead 0;
        
    UART_TxTail 0;
        
    UART_RxHead 0;
        
    UART_RxTail 0;
        
    #if defined( AT90_UART )
        /* set baud rate */
        
    UBRR = (unsigned char)baudrate

        
    /* enable UART receiver and transmmitter and receive complete interrupt */
        
    UART0_CONTROL _BV(RXCIE)|_BV(RXEN)|_BV(TXEN);

    #elif defined (ATMEGA_USART)
        /* Set baud rate */
        
    if ( baudrate 0x8000 )
        {
             
    UART0_STATUS = (1<<U2X);  //Enable 2x speed 
             
    baudrate &= ~0x8000;
        }
        
    UBRRH = (unsigned char)(baudrate>>8);
        
    UBRRL = (unsigned charbaudrate;
       
        
    /* Enable USART receiver and transmitter and receive complete interrupt */
        
    UART0_CONTROL _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);
        
        
    /* Set frame format: asynchronous, 8data, no parity, 1stop bit */
        #ifdef URSEL
        
    UCSRC = (1<<URSEL)|(3<<UCSZ0);
        
    #else
        
    UCSRC = (3<<UCSZ0);
        
    #endif 
        
    #elif defined (ATMEGA_USART0 )
        /* Set baud rate */
        
    if ( baudrate 0x8000 //Baudrate
        
    {
               
    UART0_STATUS = (1<<U2X0);  //Enable 2x speed 
               
    baudrate &= ~0x8000//Baudrate
           
    }
        
    UBRR0H = (unsigned char)(baudrate>>8); //Baudrate
        
    UBRR0L = (unsigned charbaudrate;     //Baudrate

        /* Enable USART receiver and transmitter and receive complete interrupt */
        
    UART0_CONTROL _BV(RXCIE0)|(1<<RXEN0)|(1<<TXEN0);
        
        
    /* Set frame format: asynchronous, 8data, no parity, 1stop bit */
        #ifdef URSEL0
        
    UCSR0C = (1<<URSEL0)|(3<<UCSZ00);
        
    #else
        
    UCSR0C = (3<<UCSZ00);
        
    #endif 

    #elif defined ( ATMEGA_UART )
        /* set baud rate */
        
    if ( baudrate 0x8000 
        {
            
    UART0_STATUS = (1<<U2X);  //Enable 2x speed 
            
    baudrate &= ~0x8000;
        }
        
    UBRRHI = (unsigned char)(baudrate>>8);
        
    UBRR   = (unsigned charbaudrate;

        
    /* Enable UART receiver and transmitter and receive complete interrupt */
        
    UART0_CONTROL _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);

    #endif

    }/* uart_init */ 
    Ich verstehe einfach nicht wo das Problem liegen soll.... irgendwie ist es völlig unlogisch für mich das der Code so nicht funktioniert aber ich lass mich gerne eines besseren belehren...

    FUSES korrekt gesetz! DSOSC_16KCK_65MS_XOSXC_SLOWPWR
    und CKDIV 8 haken nicht gesetzt!

    Ich bin am verzweifeln.... hat keiner einen heißen Tipp für mich???

    VIELEN DANK

  5. #5
    Erfahrener Benutzer Robotik Visionär Avatar von Hubert.G
    Registriert seit
    14.10.2006
    Ort
    Pasching OÖ
    Beiträge
    6.183
    Du hast in einer Zeile, nach Makro nicht korrekt???, "xtalCPU" anstelle von "F_CPU" stehen.
    Ich komme allerdings mit deinen Codeschnippsel nicht ganz klar und der Compiler sollte auch meckern.
    Grüsse Hubert
    ____________

    Meine Projekte findet ihr auf schorsch.at

  6. #6
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    06.08.2008
    Ort
    Graz
    Beiträge
    500
    Hatte das gleiche Problem an einem anderem Atmega auch schon, da half nur die Werte direkt aus dem Atmega Datenblatt zu nehmen, etwa 19200Baud:
    UBRR0H = 0;//(unsigned char)(Funk_UBRR_BAUD>>;
    UBRR0L = 51;//(unsigned char)Funk_UBRR_BAUD;
    Das Makro ergibt bei Nachrechnen ebenso die Werte 0 und 51, aber anscheinend rechnet der Compiler falsch.
    LG!
    alles über meinen Rasenmäherroboter (wer Tippfehler findet darf sie gedanklich ausbessern, nur für besonders kreative Fehler behalte ich mir ein Copyright vor.)

Ähnliche Themen

  1. HILFE! rp6loader auf mac zum laufen bringen?
    Von Al freddo im Forum Robby RP6
    Antworten: 1
    Letzter Beitrag: 21.02.2012, 19:50
  2. RN-Mega2560 blaue LED an PortD5 zum leuchten bringen
    Von super-robman im Forum Schaltungen und Boards der Projektseite Mikrocontroller-Elektronik.de
    Antworten: 18
    Letzter Beitrag: 01.09.2011, 10:25
  3. Ringmagnet zum Schwimmen bringen
    Von Lordcyber im Forum Mechanik
    Antworten: 10
    Letzter Beitrag: 21.03.2008, 13:37
  4. Habe Probleme, die ISR zu meinem Timer zum laufen zu bringen
    Von LC-HC im Forum C - Programmierung (GCC u.a.)
    Antworten: 6
    Letzter Beitrag: 28.04.2006, 00:14
  5. LCD BATRON BT21605 zum laufen bringen
    Von Spurius im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 15
    Letzter Beitrag: 12.11.2004, 21:56

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •