FIFO Implementierung (Array vs Pointer)

Etwas wie ?

(Warum nicht 2 buffers ?)

BYTE fifo_putbuff[SIZE_UART_SENDBUFFER];
BYTE fifo_getbuff[SIZE_UART_SENDBUFFER];
BYTE *fifo_putptr = fifo_putbuff;  //need to be global
BYTE *fifo_getptr = fifo_getbuff;  //need to be global

...

//Funktionsprototypen
void put_uart(BYTE);
BYTE GET_UART(void);

uart.c:

#include "uart.h"

...

void put_uart(BYTE sendbyte){
  //write data to fifo
  *fifo_putptr++ = sendbyte;
  if (fifo_putptr >= (fifo_pubuff + SIZE_UART_SENDBUFFER))
    fifo_putptr = fifo_pubuff;
};

****

Variables im Groß es ist keine gute Idee (nur Konstanten, Macros), auch 
Funktionennamen,

Wenn die Index-Rechnung "unsigned" erfolgt, dann sollte jeder brauchbare 
Compiler aus einer Modulo-Operation mit 2^N schon selber eine einfache 
AND-Operation machen, die manuelle Optimierung ist dann überflüssig. 
Ähnlich ist es mit 256 Bytes, auch hier sollte man die Optimierung eher 
dem Compiler überlassen.

Wobei Rechnungen mit "unsigned char" als "int", also mit Vorzeichen 
durchgeführt werden, und diese AND-Optimierung dann nicht so einfach 
ist. Es kann also sinnvoll sein, explizit nach "unsigned" zu casten:
   index = (unsigned)(index + 1) % BUFSIZE;

Optimierung von Datentypen lässt sich recht ubersichtlich 
bewerkstelligen, indem man dort wo die Grösse des Puffers festgelegt 
wird, auch gleich den passenden "typedef" für die Index-Variablen 
unterbringt:
  #define UART_BUFSIZE 100
  typedef unsigned char uart_index_t;
Man vermeidet so spätere Probleme.

Hej Jungs ihr seid super

Viele Gute Tips - danke. Hab das mal soweit ich konnte umgesetzt. Diese 
verunderei mit den Indexvariablen habe ich genutzt, um schön den Inhalt 
des FIFOs zu berechnen. Allerdings scheint die Optimierung, wie A.K. sie 
vorschlägt nicht zu funktionieren (BYTE ist unsigned und gecastet hab 
ich, wo's nur geht), denn ob ich als SIZE_UART_SENDBUFFER eine Potenz 
von 2 eingebe oder nicht, ist der Codegröße völlig egal! Dabei sollte ja 
bei einer zweierpotenz als Größe des Buffers ein kleinerer Code 
rauskommen, weil, wie Peter schrieb, dann der "Array-Ende-Test" 
optimiert werden kann. Muss ich dafür im AVR Studio eine bestimmte 
Optimierung eingeben (O0, O1... oder Os??) Bei mir hat das zwar extremen 
Einfluss auf die Codegröße im Allgemeinen, sie ist aber in jedem Fall 
unabhängig von SIZE_UART_SENDBUFFER.

Hier kommt stolz mein neuer Code für die beiden Routinen. Kommentare 
sind natürlich nochmal erwünscht!



void put_uart(BYTE sendbyte){
  cli();
  //write payload to send_fifo
  fifo_uart[uart_put_index]=sendbyte;
  //increment index for next wite access
  if (uart_put_index < SIZE_UART_SENDBUFFER-1) 
(unsigned)uart_put_index++;
  else  uart_put_index = 0;
  content_uart_fifo=(unsigned)(uart_put_index-uart_get_index-1)&(SIZE_UART 
_SENDBUFFER-1);
  if (content_uart_fifo==0) content_uart_fifo=SIZE_UART_SENDBUFFER; 
//FIFO is full!!!
  sei();
};


BYTE get_uart(){
  cli();
  //increment index before read access
  if (uart_get_index < SIZE_UART_SENDBUFFER-1) 
(unsigned)uart_get_index++;
  else  uart_get_index = 0;
  content_uart_fifo=(unsigned)(uart_put_index-uart_get_index-1)&(SIZE_UART 
_SENDBUFFER-1);
  sei();
  return fifo_uart[uart_get_index];
};

Compiler?

unsigned f(unsigned x)
{
    return (x + 1) % 64;
}

unsigned g(unsigned x)
{
    return (x + 1) % 100;
}

GCC:

f:  adiw r24,1
  andi r24,lo8(63)
  andi r25,hi8(63)
  ret

g:  adiw r24,1
  ldi r22,lo8(100)
  ldi r23,hi8(100)
  rcall __udivmodhi4
  ret