www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik AtMega ehwiges Fuse Thema 16 Mhz Quarz


Autor: Metrix (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

Ich bin entweder blöd, oder mein UART will mich veräppeln!

Und zwar hab in der "never ending loop" eine Pause von 1000ms 
(_delay_ms(1000)); somit müsste er mir jede Sekunde per UART ein Text 
ausgeben.. tut er aber nicht, er tut danach einfach nichts mehr :/

Nutze die Lib von Peter Fleury:
#define UART_BAUD_RATE      57600
#define F_CPU  16000000UL

Ich hab ein AtMega8515 mit Grundbeschaltung und einem externen Quarz, 
(Nein kein Quarzoscilator) die Fuses sind im AVRStudio eingestellt wie 
im Screenshot (Ext. Crystal/Resonator High Freq.;Start-up time: 16K + 
64ms);

Vielleicht kann mir ja jemand helfen. :)

Autor: Christopher G. (cbg)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Im Buildlog sind Warnings. Poste mal den Buildlog und deinen Sourcecode.

Autor: Daniel Steiner (sany)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "uart.h"

#define UART_BAUD_RATE      57600

int main(void)
{

  uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );
   
  sei();

  const char *text1 = "\f\a\n Diagnose Mobile Terminal V0.1 \r\n";
  const char *text2 = "** Kernel: 0.0.0.1\r\n";
  const char *text3 = "** Firmware: 0.0.0.1\r\n";

  uart_puts(text1);
  _delay_ms(1000);
  uart_puts(text2);
  _delay_ms(1000);
  uart_puts(text3);
  _delay_ms(1000);
  uart_puts("OK\r\n");
}


Der Warning war noch ein doppel definiertes F_CPU

Autor: Malte M. (maltem)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich sehe da keine Loop.

Wenn main abgearbeitet ist, bleibt der µC normalerweise stehen (eine 
endlose NOP-Loop) oder macht irgendwas komisches, je nach Compiler. Mach 
um den Block den du wiederholen willst noch ein while(1){ ... }, dann 
tuts auch.

Und sei() würde ich weglassen, wenn du keine Interrupts verwendest.

Autor: Daniel Steiner (sany)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das hat doch jetzt Primär mit dem Loop nichts zu tun,
Fakt ist das nach uart_puts(text1) gar nichts mehr passiert, keine 
weiteren Texte!

Autor: Malte M. (maltem)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das drück dich bitte nächstes mal präziser aus, wenn ich "loop" und 
"danach" lese, aber keine Schleife sehe, ist das natürlich der erste 
Gedanke.

Ich vermute mal, das der nicht im delay hängenbleibt, sondern in der 
uart-Routine. Poste die mal.

Gehts übrigens, wenn du statt
uart_puts(text1);
  _delay_ms(1000);
  uart_puts(text2);
  _delay_ms(1000);

folgendes
uart_puts("bla");
  _delay_ms(1000);
  uart_puts("blubb");
  _delay_ms(1000);

machst? Und was empfängt die Gegenstelle überhaupt, den kompletten 
text1, oder nur Teile?

Autor: Daniel Steiner (sany)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hey ;)

Also es steht im Terminal immer der volle Text,
 Diagnose Mobile Terminal V0.1 <\r><\n>

Ab danach kommt nichts mehr ebenfalls wenn ich das ich "bla" änder:
?bla

Die UART Routine ist die von Fleury im Original.
/*************************************************************************
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.6.2.2 2009/11/29 08:56:12 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

#if defined(__AVR_AT90S2313__) \
 || defined(__AVR_AT90S4414__) || defined(__AVR_AT90S4434__) \
 || defined(__AVR_AT90S8515__) || defined(__AVR_AT90S8535__) \
 || defined(__AVR_ATmega103__)
 /* old AVR classic or ATmega103 with one UART */
 #define AT90_UART
 #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV
 #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA
 #define UART0_STATUS   USR
 #define UART0_CONTROL  UCR
 #define UART0_DATA     UDR  
 #define UART0_UDRIE    UDRIE
#elif defined(__AVR_AT90S2333__) || defined(__AVR_AT90S4433__)
 /* old AVR classic with one UART */
 #define AT90_UART
 #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV
 #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA
 #define UART0_STATUS   UCSRA
 #define UART0_CONTROL  UCSRB
 #define UART0_DATA     UDR 
 #define UART0_UDRIE    UDRIE
#elif  defined(__AVR_ATmega8__)  || defined(__AVR_ATmega16__) || defined(__AVR_ATmega32__) \
  || defined(__AVR_ATmega8515__) || defined(__AVR_ATmega8535__) \
  || defined(__AVR_ATmega323__)
  /* ATmega with one USART */
 #define ATMEGA_USART
 #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV
 #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA
 #define UART0_STATUS   UCSRA
 #define UART0_CONTROL  UCSRB
 #define UART0_DATA     UDR
 #define UART0_UDRIE    UDRIE
#elif defined(__AVR_ATmega163__) 
  /* ATmega163 with one UART */
 #define ATMEGA_UART
 #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV
 #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA
 #define UART0_STATUS   UCSRA
 #define UART0_CONTROL  UCSRB
 #define UART0_DATA     UDR
 #define UART0_UDRIE    UDRIE
#elif defined(__AVR_ATmega162__) 
 /* ATmega with two USART */
 #define ATMEGA_USART0
 #define ATMEGA_USART1
 #define UART0_RECEIVE_INTERRUPT   SIG_USART0_RECV
 #define UART1_RECEIVE_INTERRUPT   SIG_USART1_RECV
 #define UART0_TRANSMIT_INTERRUPT  SIG_USART0_DATA
 #define UART1_TRANSMIT_INTERRUPT  SIG_USART1_DATA
 #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
#elif defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__) 
 /* ATmega with two USART */
 #define ATMEGA_USART0
 #define ATMEGA_USART1
 #define UART0_RECEIVE_INTERRUPT   SIG_UART0_RECV
 #define UART1_RECEIVE_INTERRUPT   SIG_UART1_RECV
 #define UART0_TRANSMIT_INTERRUPT  SIG_UART0_DATA
 #define UART1_TRANSMIT_INTERRUPT  SIG_UART1_DATA
 #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
#elif defined(__AVR_ATmega161__)
 /* ATmega with UART */
 #error "AVR ATmega161 currently not supported by this libaray !"
#elif defined(__AVR_ATmega169__) 
 /* ATmega with one USART */
 #define ATMEGA_USART
 #define UART0_RECEIVE_INTERRUPT   SIG_USART_RECV
 #define UART0_TRANSMIT_INTERRUPT  SIG_USART_DATA
 #define UART0_STATUS   UCSRA
 #define UART0_CONTROL  UCSRB
 #define UART0_DATA     UDR
 #define UART0_UDRIE    UDRIE
#elif defined(__AVR_ATmega48__) ||defined(__AVR_ATmega88__) || defined(__AVR_ATmega168__) || defined(__AVR_ATmega48P__) || defined(__AVR_ATmega88P__) || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328P__)
 /* ATmega with one USART */
 #define ATMEGA_USART0
 #define UART0_RECEIVE_INTERRUPT   SIG_USART_RECV
 #define UART0_TRANSMIT_INTERRUPT  SIG_USART_DATA
 #define UART0_STATUS   UCSR0A
 #define UART0_CONTROL  UCSR0B
 #define UART0_DATA     UDR0
 #define UART0_UDRIE    UDRIE0
#elif defined(__AVR_ATtiny2313__)
 #define ATMEGA_USART
 #define UART0_RECEIVE_INTERRUPT   SIG_USART0_RX 
 #define UART0_TRANSMIT_INTERRUPT  SIG_USART0_UDRE
 #define UART0_STATUS   UCSRA
 #define UART0_CONTROL  UCSRB
 #define UART0_DATA     UDR
 #define UART0_UDRIE    UDRIE
#elif defined(__AVR_ATmega329__) ||defined(__AVR_ATmega3290__) ||\
      defined(__AVR_ATmega649__) ||defined(__AVR_ATmega6490__) ||\
      defined(__AVR_ATmega325__) ||defined(__AVR_ATmega3250__) ||\
      defined(__AVR_ATmega645__) ||defined(__AVR_ATmega6450__)
  /* ATmega with one USART */
  #define ATMEGA_USART0
  #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV
  #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA
  #define UART0_STATUS   UCSR0A
  #define UART0_CONTROL  UCSR0B
  #define UART0_DATA     UDR0
  #define UART0_UDRIE    UDRIE0
#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   SIG_USART0_RECV
  #define UART1_RECEIVE_INTERRUPT   SIG_USART1_RECV
  #define UART0_TRANSMIT_INTERRUPT  SIG_USART0_DATA
  #define UART1_TRANSMIT_INTERRUPT  SIG_USART1_DATA
  #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  
#elif defined(__AVR_ATmega644__)
 /* ATmega with one USART */
 #define ATMEGA_USART0
 #define UART0_RECEIVE_INTERRUPT   SIG_USART_RECV
 #define UART0_TRANSMIT_INTERRUPT  SIG_USART_DATA
 #define UART0_STATUS   UCSR0A
 #define UART0_CONTROL  UCSR0B
 #define UART0_DATA     UDR0
 #define UART0_UDRIE    UDRIE0
#elif defined(__AVR_ATmega164P__) || defined(__AVR_ATmega324P__) || defined(__AVR_ATmega644P__)
 /* ATmega with two USART */
 #define ATMEGA_USART0
 #define ATMEGA_USART1
 #define UART0_RECEIVE_INTERRUPT   SIG_USART_RECV
 #define UART1_RECEIVE_INTERRUPT   SIG_USART1_RECV
 #define UART0_TRANSMIT_INTERRUPT  SIG_USART_DATA
 #define UART1_TRANSMIT_INTERRUPT  SIG_USART1_DATA
 #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
#else
 #error "no UART definition for MCU available"
#endif


/*
 *  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



SIGNAL(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;   
}


SIGNAL(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];
    
    return (UART_LastRxError << 8) + 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 )

SIGNAL(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;   
}


SIGNAL(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];
    
    return (UART1_LastRxError << 8) + 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

#ifndef UART_H
#define UART_H
/************************************************************************
Title:    Interrupt UART library with receive/transmit circular buffers
Author:   Peter Fleury <pfleury@gmx.ch>   http://jump.to/fleury
File:     $Id: uart.h,v 1.8.2.1 2007/07/01 11:14:38 peter Exp $
Software: AVR-GCC 4.1, AVR Libc 1.4
Hardware: any AVR with built-in UART, tested on AT90S8515 & ATmega8 at 4 Mhz
License:  GNU General Public License 
Usage:    see Doxygen manual

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.
    
************************************************************************/

/** 
 *  @defgroup pfleury_uart UART Library
 *  @code #include <uart.h> @endcode
 * 
 *  @brief Interrupt UART library using the built-in UART with transmit and receive circular buffers. 
 *
 *  This library can be used to transmit and receive data through the built in UART. 
 *
 *  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 constants define
 *  the size of the circular buffers in bytes. Note that these constants must be a power of 2.
 *  You may need to adapt this constants to your target and your application by adding 
 *  CDEFS += -DUART_RX_BUFFER_SIZE=nn -DUART_RX_BUFFER_SIZE=nn to your Makefile.
 *
 *  @note Based on Atmel Application Note AVR306
 *  @author Peter Fleury pfleury@gmx.ch  http://jump.to/fleury
 */
 
/**@{*/


#if (__GNUC__ * 100 + __GNUC_MINOR__) < 304
#error "This library requires AVR-GCC 3.4 or later, update to newer AVR-GCC compiler !"
#endif


/*
** constants and macros
*/

/** @brief  UART Baudrate Expression
 *  @param  xtalcpu  system clock in Mhz, e.g. 4000000L for 4Mhz          
 *  @param  baudrate baudrate in bps, e.g. 1200, 2400, 9600     
 */
#define UART_BAUD_SELECT(baudRate,xtalCpu) ((xtalCpu)/((baudRate)*16l)-1)

/** @brief  UART Baudrate Expression for ATmega double speed mode
 *  @param  xtalcpu  system clock in Mhz, e.g. 4000000L for 4Mhz           
 *  @param  baudrate baudrate in bps, e.g. 1200, 2400, 9600     
 */
#define UART_BAUD_SELECT_DOUBLE_SPEED(baudRate,xtalCpu) (((xtalCpu)/((baudRate)*8l)-1)|0x8000)


/** Size of the circular receive buffer, must be power of 2 */
#ifndef UART_RX_BUFFER_SIZE
#define UART_RX_BUFFER_SIZE 32
#endif
/** Size of the circular transmit buffer, must be power of 2 */
#ifndef UART_TX_BUFFER_SIZE
#define UART_TX_BUFFER_SIZE 32
#endif

/* test if the size of the circular buffers fits into SRAM */
#if ( (UART_RX_BUFFER_SIZE+UART_TX_BUFFER_SIZE) >= (RAMEND-0x60 ) )
#error "size of UART_RX_BUFFER_SIZE + UART_TX_BUFFER_SIZE larger than size of SRAM"
#endif

/* 
** high byte error return code of uart_getc()
*/
#define UART_FRAME_ERROR      0x0800              /* Framing Error by UART       */
#define UART_OVERRUN_ERROR    0x0400              /* Overrun condition by UART   */
#define UART_BUFFER_OVERFLOW  0x0200              /* receive ringbuffer overflow */
#define UART_NO_DATA          0x0100              /* no receive data available   */


/*
** function prototypes
*/

/**
   @brief   Initialize UART and set baudrate 
   @param   baudrate Specify baudrate using macro UART_BAUD_SELECT()
   @return  none
*/
extern void uart_init(unsigned int baudrate);


/**
 *  @brief   Get received byte from ringbuffer
 *
 * Returns in the lower byte the received character and in the 
 * higher byte the last receive error.
 * UART_NO_DATA is returned when no data is available.
 *
 *  @param   void
 *  @return  lower byte:  received byte from ringbuffer
 *  @return  higher byte: last receive status
 *           - \b 0 successfully received data from UART
 *           - \b UART_NO_DATA           
 *             <br>no receive data available
 *           - \b UART_BUFFER_OVERFLOW   
 *             <br>Receive ringbuffer overflow.
 *             We are not reading the receive buffer fast enough, 
 *             one or more received character have been dropped 
 *           - \b UART_OVERRUN_ERROR     
 *             <br>Overrun condition by UART.
 *             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.
 *           - \b UART_FRAME_ERROR       
 *             <br>Framing Error by UART
 */
extern unsigned int uart_getc(void);


/**
 *  @brief   Put byte to ringbuffer for transmitting via UART
 *  @param   data byte to be transmitted
 *  @return  none
 */
extern void uart_putc(unsigned char data);


/**
 *  @brief   Put string to ringbuffer for transmitting via 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.
 *  Blocks if it can not write the whole string into the circular buffer.
 * 
 *  @param   s string to be transmitted
 *  @return  none
 */
extern void uart_puts(const char *s );


/**
 * @brief    Put string from program memory to ringbuffer for transmitting via 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.
 * Blocks if it can not write the whole string into the circular buffer.
 *
 * @param    s program memory string to be transmitted
 * @return   none
 * @see      uart_puts_P
 */
extern void uart_puts_p(const char *s );

/**
 * @brief    Macro to automatically put a string constant into program memory
 */
#define uart_puts_P(__s)       uart_puts_p(PSTR(__s))



/** @brief  Initialize USART1 (only available on selected ATmegas) @see uart_init */
extern void uart1_init(unsigned int baudrate);
/** @brief  Get received byte of USART1 from ringbuffer. (only available on selected ATmega) @see uart_getc */
extern unsigned int uart1_getc(void);
/** @brief  Put byte to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_putc */
extern void uart1_putc(unsigned char data);
/** @brief  Put string to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_puts */
extern void uart1_puts(const char *s );
/** @brief  Put string from program memory to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_puts_p */
extern void uart1_puts_p(const char *s );
/** @brief  Macro to automatically put a string constant into program memory */
#define uart1_puts_P(__s)       uart1_puts_p(PSTR(__s))

/**@}*/


#endif // UART_H 



gruß daniel

Autor: Philipp (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Versuchs mal mit 38400 Baud, 57,xx kBaud liegt bei 16Mhz außerhalb der 
empfohlenen Toleranzgrenze.

PS.: Stell dich schon mal darauf ein, dass bald welche kommen und dir 
den Thread hier zerrupfen, weil du so viel Code zitiert hast...

Autor: Daniel Steiner (sany)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Philipp schrieb:
> Versuchs mal mit 38400 Baud, 57,xx kBaud liegt bei 16Mhz außerhalb der
> empfohlenen Toleranzgrenze.
>
> PS.: Stell dich schon mal darauf ein, dass bald welche kommen und dir
> den Thread hier zerrupfen, weil du so viel Code zitiert hast...

Nun, also mit 38400 Klaapts ebenfalls nicht....

Autor: Philipp (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hmm, vielleicht liegts an den ** im Text, sollte mich aber wundern. 
Ansonsten verkleiner doch mal die delays oder nimm sie ganz raus, dann 
lässt sich das problem ein wenig eingrenzen

Autor: Georg W. (gewe)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich würde mal sagen, Dein TX Puffer ist zu klein.

Du hast einen Puffer von 32 Bytes:

#define UART_TX_BUFFER_SIZE 32

Wie lang ist Dein erster Text ?

const char *text1 = "\f\a\n Diagnose Mobile Terminal V0.1 \r\n";
                                 1         2         3
                     1  2 345678901234567890123456789012345 6


Versuchs mal mit

#define UART_TX_BUFFER_SIZE 128

Außerdem liegen die Strings im RAM. Du kannst mit der Lib aber auch 
Texte aus dem Flash ausgeben. Das sollte mit uart1_puts_p(PSTR("STRING 
IM FLASH")) gehen.

cu
Georg

Autor: Malte M. (maltem)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Georg W. schrieb:
> Ich würde mal sagen, Dein TX Puffer ist zu klein.

Dann würde aber mein vorgeschlagener Test mit "bla" "blubb" tun....

Autor: Daniel Steiner (sany)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Philipp schrieb:
> Hmm, vielleicht liegts an den ** im Text, sollte mich aber wundern.
> Ansonsten verkleiner doch mal die delays oder nimm sie ganz raus, dann
> lässt sich das problem ein wenig eingrenzen

Wenn der AtMega8515 korrekt mit 16 Mhz läuft, müsste er genau 1sec bei 
1000ms warten, ist nur die Frage ob er das delay erreicht oder eben 
nicht. Das werde ich mal testen....
#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "uart.h"

#define UART_BAUD_RATE      38400

int main(void)
{

  uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );
   
  sei();

  const char *text1 = "\f\a\n Diagnose Mobile Terminal V0.1 \r\n";
  const char *text2 = "** Kernel: 0.0.0.1\r\n";
  const char *text3 = "** Firmware: 0.0.0.1\r\n";
  while(1)
  {
    uart_puts("bla\r\n");
    uart_puts("jetzt gehts zum delay!\r\n");
      _delay_ms(10);
      uart_puts("blubb\r\n");
      _delay_ms(100);
    uart_puts("OK\r\n");
    _delay_ms(200);
    uart_puts("blaaa\r\n");
  }
}

HTerminal:
?bla<\r><\n> 
jetzt gehts zum delay!<\r><\n> (Die 10ms werden eingehalten)
blubb<\r><\n> (Auch die 100ms werden noch eingeladen=
OK<\r><\n> (Ab 200ms ist dann ende!)

Autor: Ralph B. (rkhb)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Daniel Steiner schrieb:
> Das hat doch jetzt Primär mit dem Loop nichts zu tun,
> Fakt ist das nach uart_puts(text1) gar nichts mehr passiert, keine
> weiteren Texte!

Ich habe das mal mit einem ATmega8535 auf einem STK500 probiert - und es 
funktioniert. Es kann also nicht am Baudfehler, an zu kleinem SRAM oder 
an einem Programmierfehler liegen. Probier mal ein anderes 
Terminalprogramm und ein anderes Kabel aus.

Andererseits ist ein 16-MHz-Quarz für UART nicht ideal. Ideal für alle 
möglichen Baudraten sind:

1,8432 MHz, 3,6864 MHz, 7,3728 MHz, 11,0592 MHz und 14,7456 MHz

viele grüße
ralph

Autor: Georg W. (gewe)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Malte:

Stimmt. Aber hat er den Test auch wirklich gemacht?

@Daniel:

Wie viele Zeichen gehen in 110ms bei 57600Baud und 8N1 über die RS232 
raus?

Mach einfach doch mal den Test mit dem TX Puffer.

Ich hatte hier schon genau da selbe Problem.

cu
Georg

Autor: Daniel Steiner (sany)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So, also mit dem Puffer auf 128 Gesetzt, aber ebenfalls leider kein 
Erfolg.

Nun dachte ich mir teste ich das ganze mal in dem ich einfach Pro 
Sekunden ein "A" auf mein LCD Display zeichnen lasse...
  while(1)
  {
    for(i=0; i< 8; i++)
    {
      lcd_gotoxy(i,1);
      lcd_puts("A");
      _delay_ms(1000);      
    }
  }

So und alles unter 100ms funktioniert, bei 1000ms hängt alles.
So nun dachte ich das evtl. der Atmega ein Pfiff weg hat, ersetzt => 
selbiges Problem... ebenfalls schon die Kondensatoren neu eingelötet => 
selbes problem...

Evtl. stimmt was bei den fuses nicht?

Der Quarz hat die Bezeichnung 14-US16,000MHZ

Danke :)

Autor: Huch (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kannst Du bitte mal schreiben, welche WinAVR-Version oder welche Version 
welchen Compilers sonst Du verwendest und welche Version der avr lib?

Ich habe zwar keinen konkreten Anhaltspunkt, aber das delay bei 200ms 
noch geht und dann nicht mehr, war, glaube ich bis zu einer bestimmten 
Version der lib so. Habe das jetzt nicht mehr so im Kopf. Aber die Suche 
hier sollte einen Haufen Einträge dazu bringen.

Autor: Huch (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ausserdem muss beim Compiler die Optimierung eingeschaltet sein.

Autor: Daniel Steiner (sany)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hier mal die Einstellungen im Compiler und die aktuell Installierte 
WinAVR

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Georg W. schrieb:
> Ich würde mal sagen, Dein TX Puffer ist zu klein.

Spielt keine Rolle.
Die Fleury Lib ist so aufgebaut, dass das keine Rolle spielt.
Schlimmstenfalls wartet die put Routine, bis vom Sendeinterrupt die 
ersten Zeichen rausgeblasen wurden und so Platz im Buffer geschaffen 
wird


> Außerdem liegen die Strings im RAM. Du kannst mit der Lib aber auch
> Texte aus dem Flash ausgeben. Das sollte mit uart1_puts_p(PSTR("STRING
> IM FLASH")) gehen.

Das hab ich eher im Verdacht. Das ihm das SRAM ausgeht. 512 Bytes sind 
nicht allzuviel.
Obwohl es bei den delay Schleifen keine Rolle spielen sollte. Die werden 
komplett über Register abgewickelt.

Aber ich seh eigentlich auch nichts, ausser einer möglichen SRAM 
Überlastung. Aber das erklärt nicht, dass es bei kleinen _delays 
funktioniert. Seltsam.

Was sagt denn die Compiler-Statistik. Wie voll ist denn die .data 
Section?

Autor: Philipp (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich benutz die gleiche Compilerversion und bei mir steht in der delay.h

   The maximal possible delay is 262.14 ms / F_CPU in MHz.

   When the user request delay which exceed the maximum possible one,
   _delay_ms() provides a decreased resolution functionality. In this
   mode _delay_ms() will work with a resolution of 1/10 ms, providing
   delays up to 6.5535 seconds (independent from CPU frequency).  The
   user will not be informed about decreased resolution.

ich würd mir ne eigene funktion schreiben, die in ner schleife so lange 
_delay_ms(10) aufruft, wie du's braucht.

Autor: Georg W. (gewe)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Karl heinz Buchegger schrieb:

>> Ich würde mal sagen, Dein TX Puffer ist zu klein.
>
> Spielt keine Rolle.
>

Stimmt.

Ich habe den geposteten Code mal auf einen ATMEGA8515L, der in einem 
STK500 mit 16MHz Quarz läuft gespielt und ich bekomme die Texte im 
Hyperterminal angezeigt.


cu
Georg

Autor: Daniel Steiner (sany)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Georg W. schrieb:
> Karl heinz Buchegger schrieb:
>
>>> Ich würde mal sagen, Dein TX Puffer ist zu klein.
>>
>> Spielt keine Rolle.
>>
>
> Stimmt.
>
> Ich habe den geposteten Code mal auf einen ATMEGA8515L, der in einem
> STK500 mit 16MHz Quarz läuft gespielt und ich bekomme die Texte im
> Hyperterminal angezeigt.
>
>
> cu
> Georg

Der Puffer spielt doch keinerlei Rolle, habs jetzt ebenfalls mal mit der 
Ausgabe auf einem LCD versucht, hat leider den selbigen Erfolg, nämlich 
das mehr als 100 ms nicht drin sind.

(Die .data Section ist aktuell bei 32% Full.

Also das Problem beschränkt sich nicht mehr nur auf das UART.

Der Schaltplan zum Atmega8515 TQFP/MLF: 
http://www.datasheetcatalog.org/datasheet/atmel/2512S.pdf

*) Hab mittlerweile nun den dritten Atmega 8515 ohne erfolg getestet.

Aber ich habe die ganz normale Grundbeschaltung mit einem 16 MHZ Quarz, 
mit 22pF auf GND.

Hab mittlerweile schon die 22pF gegen 33pF getauscht, ebenfalls schon 
den Quarz.

JTAG ist deaktiviert, kann es eventuell sein, das evtl. ein Port belegt 
ist, der den Microprozessor lahm legt?

Welche Ports müsste ich den Überprüfen, die den Programmablauf 
"irritieren" könnten?

Am Atmega8515 hängt noch ein AD822, sowie noch ein RS232 Trans/Receiver, 
jedoch nicht von Maxim selbst.

Vielen dank für Infos!

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Daniel Steiner schrieb:

> *) Hab mittlerweile nun den dritten Atmega 8515 ohne erfolg getestet.
>
> Aber ich habe die ganz normale Grundbeschaltung mit einem 16 MHZ Quarz,
> mit 22pF auf GND.
>
> Hab mittlerweile schon die 22pF gegen 33pF getauscht, ebenfalls schon
> den Quarz.
>
> JTAG ist deaktiviert, kann es eventuell sein, das evtl. ein Port belegt
> ist, der den Microprozessor lahm legt?

Kannst du dir alles sparen.
Mit ziemlicher Sicherheit ist das kein Hardwareproblem.

Autor: Pete K. (pete77)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hast Du jetzt schon einmal in der delay.h nachgeschaut?

Begrenze delay.h mal auf 200ms, das sollte klappen.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Pete K. schrieb:
> Hast Du jetzt schon einmal in der delay.h nachgeschaut?
>
> Begrenze delay.h mal auf 200ms, das sollte klappen.

Die Beschränkung auf (2hundert_irgendwas durch Taktfrequenz) ist schon 
lange aufgehoben. Mein WinAVR ist um einiges älter und hat mit 1000ms 
keinerlei Probleme. Drum verblüfft das Ganze.

Man könnte das natürlich auf sich beruhen lassen, aber IMHO ist das ein 
Hinweis, das da irgendwas in der Konfiguration nicht ganz koscher ist. 
Von daher: Holzauge sei wachsam.

Autor: Huch (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Es sollte auch mit 1000 gehen.
Und bei einigen Leuten hier geht es ja auch.

Ich würde vorschlagen einfach mal ne LED mit 1Hz zu toggeln (also 0,5Hz 
blinken). Alles andere rauswerfen.

Autor: Pete K. (pete77)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Daniel Steiner schrieb:
> ?bla<\r><\n>
> jetzt gehts zum delay!<\r><\n> (Die 10ms werden eingehalten)
> blubb<\r><\n> (Auch die 100ms werden noch eingeladen=
> OK<\r><\n> (Ab 200ms ist dann ende!)

Den letzten String kannst Du nicht sehen, weil das Programm beendet 
wird, bevor die Interrupt-Ausgabe beendet ist.

Füge am Ende noch ein _delay_ms(30) ein.

Autor: Huch (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Pete K. schrieb:
> Daniel Steiner schrieb:
> Den letzten String kannst Du nicht sehen, weil das Programm beendet
> wird, bevor die Interrupt-Ausgabe beendet ist.
>
> Füge am Ende noch ein _delay_ms(30) ein.

Das Pgm. wird nicht beendet. Da ist eine while Schleife.

Autor: Daniel Steiner (sany)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hmm..

Ich werde das mal testen und ggf. diesen Beitrag nochmal öffnen.
Mich verblüfft das ganze nur, weil ich hab in jeder Schaltung die 
gleiche Grundbeschaltung, außer das alle Micro's i.d.R mit einem Oszi 
laufen, und nicht mehr mit einem Quarz.

Ich werde das ganze nochmal überprüfen.

Was ich aber sagen muss, die Platine war bereits schon fertig und wurde 
von mir "übernommen". D.h es war auf der Platine ein NXP 87xxx drauf, 
der mit dem Atmel 8515 TQPF Original 1:1 PIN Kompatibel ist, ebenfalls 
stimmen die 5,00V durch den 7085, dass kann ich auch ausschließen.

Weiter kann ich nur vermuten, das irgendwas das Programm beendet, habs 
bereits schon mit aktiviertem WatchDog probiert, aber sobald ich die 
Fuse setzte, läuft garkein Programm mehr :/

Zumal mir solch ein Problem völlig neu ist, da nun von 15 AtMegas es nur 
jetzt diese probleme gibt.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.