eeprom uart atmega8 was mache ich falsch!

[Penie L. (peniely)]

Hallo,
seit einige Woche will ich mein Kamera über mein uc (stk 500, mit 
atmega8) steuern, und habe mir ein Programm geschrieben (s. unten) 
leider am terminal bekomme ich dieses Fehler <-AsyErr1 Rahmen.

Ich verwende gerade das erste mal den EEPROM und begreiffe nicht warum
es nicht funktioniert

Ich danke euch für Ihre Hilfe
viele grüsse

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>

#ifndef F_CPU
#define F_CPU 4000000UL  //external clock from STK500
#endif

// 9600 baud 
#define UART_BAUD_RATE  9600 
/** 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  

/*
 *  constants and macros
 */
#define UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ((F_CPU)/((UART_BAUD_RATE)*16l)-1)


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

#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


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


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;
    
   //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
     UCSRB |= (0<<UDRIE);

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

    UBRRH = (unsigned char)(baudrate>>8);
    UBRRL = (unsigned char) baudrate;

  //Set data frame format: asynchronous mode,no parity, 1 stop bit, 8 bit size

  UCSRC=(1<<URSEL)|(0<<UMSEL)|(0<<UPM1)|(0<<UPM0)|

    (0<<USBS)|(0<<UCSZ2)|(1<<UCSZ1)|(1<<UCSZ0);  

  //Enable Transmitter and Receiver and Interrupt on receive complete

  UCSRB=(1<<RXEN)|(1<<TXEN)|(1<<RXCIE);  

}// uart_init 


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

    while (!(UCSRA & (1<<UDRE))); // Do nothing until data have been   
                                   //transmited 
    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;    
    UART0_DATA = UART_TxBuf[tmphead];  // Put data into Buffer, sends the  
                                       //data
    _delay_ms(10); 
    // enable UDRE interrupt 
    UCSRB |= (1<<UDRIE);

}// uart_putc

/* command sequences im EEPROM (first program Flash, then EEPROM) */ 
unsigned char eeMenue[] EEMEM = { 0x02, 0x21, 0x32, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x9D, 0x2A };
unsigned char eeExit[] EEMEM  = { 0x02, 0x21, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x5C, 0x2A };

unsigned int c, iState;
char cSend;

/* Sends a 19 character command found in EEPROM */
void SendCommand(unsigned int iNo)
{
  unsigned i;  
  for  (i = 19 * iNo; i <= 19 * iNo + 18; i++ )
  {
  cSend = eeprom_read_byte(&eeMenue[i]);
  uart_putc(cSend);
  }
}

int main(void)
{

  PORTD = 0x0C;    // pull ups for key inputs  PortD2 and portD3   
  DDRC = 0x03;     // outputs for LEDs 
  PORTC = 0x03;    /( LEDs off
 
  /*
   *  Initialize UART library, pass baudrate and AVR cpu clock
   *  with the macro 
   *  UART_BAUD_SELECT() (normal speed mode )
   */
  uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); 
  
  /*
   * now enable interrupt, since UART library is interrupt controlled
   */
  sei();
  
  
  iState = 0;
  for(;;)
    {  
  if (iState != PIND)  /* Key state changed ? */ 
  {
    _delay_ms(50);
    if ((PIND & 0x08) == 0x00)        /* one key */
    {
      PORTC = 1;
      SendCommand(0);
    }
          else
          {
      if ((PIND & 0x0C) == 0x0C)   /* no key */
        PORTC = 3;            
          }
    iState = PIND;
    _delay_ms(2000);  /* dirty "debounce" */ 
  }
    }
    return 0;
}

[Lutz (Gast)]

Hallo,

ohne tiefer in das Programm einzusteigen: Gibt es keine Compilermeldung 
wegen z.B.

cSend = eeprom_read_byte(&eeMenue[i]);

Die Funktion ist in der <avr/eeprom.h> enthalten, die Du nicht 
eingebunden hast.
Dafür hast Du die <avr/pgmspace.h> eingebunden, die für den 
FLASH-speicher zuständig ist.

[Penie L. (peniely)]

Hey,
danke für die Rückmeldung
Nein gibt keine Compilermeldung
und das Fehler ist immer da sogar mit "eeprom.h"
gruß

[Lutz (Gast)]

Hm, auf den zweiten Blick scheinen mir (aus dem Gedächtnis) die defines 
nicht zu stimmen.

#define UART0_STATUS   USR
#define UART0_CONTROL  UCR

Du mischst im Code auch defines mit direkten Angaben (was ja nicht 
verboten, aber uneinheitlich und daher unübersichtlicher ist) bzw. nutzt 
die defines nicht , z.B.

#define UART0_UDRIE    UDRIE
UCSRB |= (1<<UDRIE);

UCSRB |= (0<<UDRIE);

Ein bit löscht man so bestimmt nicht.
Interrupt-Enable am Ende der Funktion kommt mir auch komisch vor.
Welches Terminalprogramm ist das überhaupt genau? Verstehe es auch nicht 
so ganz, da ja der Controller die Steuerung machen soll? Warum auch 
überhaupt EEPROM? EEPROM ist ja sehr langsam.
Copy&Paste kann der Code auch nicht sein, da der Compiler z.B. bei

PORTC = 0x03;    /( LEDs off

meckern müßte.
Es steht auch
/* command sequences im EEPROM (first program Flash, then EEPROM) */
aber ich kann kein PROGMEM für das FLASH finden. Wie gesagt, ich bin 
nicht inhaltlich in das Programm eingestiegen, aber da scheint einiges 
an Basisproblemen zu sein.

[Penie L. (peniely)]

HAllo,
jetzt bekomme ich keinen Fehler mehr, aber meine Zeichen sind falsch
kann jemand mir helfen
für jede Befehl kommt nur <224><224><224><224><224><224><224><224>....
gruß

[Lutz (Gast)]

Und WAS hast Du geändert?

[penie lydos (Gast)]

Hallo,

Ich habe diese Beispiel von Fleury genommen und an meine Bedürfnis 
angepasst.

Durch das ich eine Kommando für meine Kamera sende, Am terminal bekomme 
ich dann für jeder Kommando (s. programm) nur 
<224><224><224><224><224><224><224><224><224><224><224><224><224><224><2 
24><224><224><224><224>

Bitte hat jemand Zeit meinem Code durchzucoocken und mir das Fehler 
sagen.

ICh benutze Stk500 mit Atmega8 on Bord Ext quarz crystal 4 Mhz

Danke und viele grüsse