atmega644 UART-Ringpufferlösung - vollständiger Code: Letzter Fehler- Immer nur drei bytes

[Alex V. (bastel_alex)]

Hallo,

ich hatte hier vor kurzem bereits Hilfe und dann auch eine (dachte ich) 
funktionierende Version. Nun gibt es ein kleines Problem, auf dessen 
Lösung ich einfach nicht komme:

Ich habe einen Ringpuffer umgesetzt, um interruptgesteuerte 
UART-Kommunikation mit meinem atmega644 aufzubauen. Das merkwürdige:

Der Ringpuffer funktioniert gut, wenn ich max. drei bytes hintereinander 
hineinschreibe. Sende ich mehr, werden die zwischenliegenden Bytes 
zwischen den ersten beiden und dem letzten irgendwie verschluckt. Als 
Beispiel in der Routine unten:

Ich möchte 00 FF AB CD EF 00 schicken.
Am terminal kommt dann aber an: 00 FF 00.

Der Code ist eigentlich recht übersichtlich und funktioniert soweit, er 
kann also gerne verwendet werden (dann hat vll. jemand auch etwas davon, 
sobald der fehler gefunden ist). Wenn ihr mir irgendwie helfen könntet 
wäre das super!!

*/ RINGPUFFER: circbuf.h */
#ifndef CIRCBUF_H_
#define CIRCBUF_H_

#include <stdbool.h>
#include <avr/io.h>
#include <stdlib.h>
#include <avr/interrupt.h>


#define buffer_size 16      

struct circ_buffer {
  uint8_t data[buffer_size];
  uint8_t read_ptr;      // points to last input data
  uint8_t write_ptr;      // always points to empty field
  };

void buffer_init (struct circ_buffer *buf);
void buffer_write(struct circ_buffer *buf, uint8_t byte);
uint8_t buffer_read(struct circ_buffer *buf);
uint8_t buffer_is_full (struct circ_buffer *buf);
uint8_t buffer_is_empty (struct circ_buffer *buf);

#endif /*CIRCBUF_H_*/
/* END circbuf.h */


/* RINGPUFFER FUNCTIONS  circbuf.c*/
#include "circbuf.h"

void buffer_init (struct circ_buffer *buf)          // Initialization of circular buffer values
{
  buf->read_ptr=0;
  buf->write_ptr=0;
}

void buffer_write(struct circ_buffer *buf, uint8_t byte)  // Write byte into buffer, increment fillcounter and write pointer
{
  cli();
  buf->data[buf->write_ptr] = byte;
  
  if (buf->write_ptr >= buffer_size-1){
    buf->write_ptr = 0;
  }
  else{
    buf->write_ptr = buf->write_ptr + 1;
  }
  sei();
}

uint8_t buffer_read(struct circ_buffer *buf)        // Read byte out of buffer, decrement fillcounter, increment read ptr
{
  cli();
  uint8_t returnval =0;
  
  if  (buf->read_ptr == buf->write_ptr){
    sei();
    return 0;
  }
  else 
  {
    returnval= buf->data[buf->read_ptr];
    
    if (buf->read_ptr >= buffer_size-1){
      buf->read_ptr = 0;
    }
    else{
      buf->read_ptr = buf->read_ptr + 1;
    }
    sei();
    return returnval;
  }

}

uint8_t buffer_is_full (struct circ_buffer *buf)
{
  if (buf->write_ptr + 1 == buf->read_ptr || buf->read_ptr == 0 && buf->write_ptr + 1 == buffer_size)
  return 1;
  else return 0;
}

uint8_t buffer_is_empty (struct circ_buffer *buf)
{
  if (buf->read_ptr == buf->write_ptr) return 1;
  else return 0;
}

/* END RINGPUFFER FUNCTIONS circbuf.c */



/* UART_functions.h */

  #ifndef _M_UART_functions_h_
  #define _M_UART_functions_h_
  
  #define F_CPU 20E6 //Systemtakt in Hz
  #include <util/delay.h>
  
  #include "circbuf.h"

  // FUNCTIONS
  void UART_Init();
  uint8_t uart_ReceiveByte( struct circ_buffer *buf );
  void uart_TransmitByte( struct circ_buffer *buf, uint8_t data );

  #endif /*_M_UART_functions_h_*/

/* END UART_functions.h */


/* UART_functions.c */

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>

#include "UART_functions.h"
#include <util/delay.h>


 void UART_Init()
 {
   // baud Calculation: baud = (fosc/ 16*Baudrate)-0.5
   // baud = (20 MHz / 16*9600)-0.5 = 129.708 --> = baud = 130
   unsigned int baud = 130;
   
   //* Set baud rate */
   UBRR0H = (unsigned char)(baud>>8);
   UBRR0L = (unsigned char)baud;
   /* Enable receiver and transmitter, Set Interrupts: RXCIE - RX-Complete */
   UCSR0B = (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0);
   /* Set frame format: 8data, 2stop bit */
   UCSR0C = (1<<USBS0)|(3<<UCSZ00);
 }
 
uint8_t uart_ReceiveByte( struct circ_buffer *buf )
{
  while ( buffer_is_empty(buf) );  /* wait for incoming data */
  return buffer_read(buf); /* return data */
}


void uart_TransmitByte(struct circ_buffer *buf, uint8_t data )
{
  while ( buffer_is_full(buf) );
  buffer_write(buf,data);    /* store data in buffer */
  
  UCSR0B |= (1<<UDRIE0);      // Enable UDRIE- UART Data Register empty Interrupt - UDRE-ISR is going to put data in UDR
}

/* END UART_functions.c */


/* MAIN.c */

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include "stdbool.h"
#include <string.h>

#define F_CPU 20E6 //Systemtakt in Hz

#include "UART_functions.h"
#include "circbuf.h"
#include <util/delay.h>

// Global VARIABLES
unsigned char byte_buffer;
struct circ_buffer uart_rx_buffer;            // Receive-Circular-Buffer
struct circ_buffer uart_tx_buffer;            // Send-Circular-Buffer


// UART RX-Complete interrupt: 
// Receiving data + buffering (saving)
ISR(USART0_RX_vect) 
{
  unsigned char data;
  data = UDR0;
  buffer_write(&uart_rx_buffer, data);
}

// UART Data register empty interrupt:
// loading new data into UART sending register
ISR(USART0_UDRE_vect) 
{
  if (!buffer_is_empty(&uart_tx_buffer))          // Is buffer filled?
  {
    UDR0 = buffer_read(&uart_tx_buffer);
  }
  else
  {
    UCSR0B &= ~(1<<UDRIE0);              // Disable UDRIE- UART Data Register empty Interrupt 
  }
}

int main(void)
{
  /* Buffer Initialization */
  buffer_init(&uart_rx_buffer);
  buffer_init(&uart_tx_buffer);
  
  /* Variables */
  char controlbyte;
  uint8_t sendbuffer;  
  uint32_t adcrec;
      
  /*********************** Initialization ***********************/
  //Port Directions
  
  DDRA= 0b11011011;              
  DDRB= 0b10100110;                            
  DDRC= 0b01010001;        // SPI Slave select, LEDs                    
  DDRD= 0b00001010;        // UART
  
  UART_Init();          // UART initialization
  sei();              // Global Interrupt enable
  
  /*********** MAIN LOOP **************/
    while(1)
    {  
      
    if (!buffer_is_empty(&uart_rx_buffer))            // Received Commands?
    {
      controlbyte = uart_ReceiveByte(&uart_rx_buffer);
      
      switch (controlbyte)
      {
        case 0xAA: {
          sendbuffer =00;
          uart_TransmitByte(&uart_tx_buffer, sendbuffer);
          
          adcrec =  0xFFABCDEF;
          
          sendbuffer =(adcrec >>24);
          uart_TransmitByte(&uart_tx_buffer, sendbuffer);
          sendbuffer =(adcrec >>16);
          uart_TransmitByte(&uart_tx_buffer, sendbuffer);
          sendbuffer =(adcrec >>8);
          uart_TransmitByte(&uart_tx_buffer, sendbuffer);
          sendbuffer =adcrec;
          uart_TransmitByte(&uart_tx_buffer, sendbuffer);    
          sendbuffer =00;
          uart_TransmitByte(&uart_tx_buffer, sendbuffer);                          
          break;
        }
        case 0xBB: {
          break;
        }
        case 0xCC:{
          break;          
        }
      }
    }    
    }
}

/* END MAIN.C */

Die Mainloop wartet hier auf den Eingang eines Control-Chars über UART 
und sendet dann (im Falle von 0xAA) die Testsequenz.

Kann mir da jemand helfen? Ich habe die Files auch oben angehängt.

Beste Grüße

Alex

[jibi (Gast)]

>sendbuffer =00;

Wasn das`?

[Alex V. (bastel_alex)]

jibi schrieb:
>>sendbuffer =00;
>
> Wasn das`?

nen flüchtigkeitsfehler (0x00), daran liegts aber nicht ;)

Alles in der switch-case loop ist unter vorbehalt zu genießen, da habe 
ich jetzt dauernd herumgefummelt um auf den fehler zu kommen.

[jibi (Gast)]

>nen flüchtigkeitsfehler (0x00), daran liegts aber nicht ;)

>Alles in der switch-case loop ist unter vorbehalt zu genießen, da habe
>ich jetzt dauernd herumgefummelt um auf den fehler zu kommen.

Fürn Programmierer bist du aber schwer nachlässig ;).
Das musst du ändern.

Gruß Jonas

[Stefan F. (Gast)]

> struct circ_buffer uart_rx_buffer;
> struct circ_buffer uart_tx_buffer;

Mach diese beiden Puffer mal volatile und sorge dafür, dass cli() und 
sei() nicht aus dem Interrupt heraus aufgerufen werden.

Siehe FAX 1. und 8.

[jibi (Gast)]

Im Übrigen fehlt in deinem Zip ein File.

#include "Mainboard_UART_functions.h"

[Alex V. (bastel_alex)]

Stefan us schrieb:
> Mach diese beiden Puffer mal volatile und sorge dafür, dass cli() und
> sei() nicht aus dem Interrupt heraus aufgerufen werden.

DAS WARS!!
Vielen herzlichen Dank stefan! Mist ja klar, in den USART ISRs wurden 
über die ringpuffer-funktionen die interrupts global umgeschaltet. Hach 
super. ich danke dir.