Mega8 @ 1MHz, Midi IO und Buffer - Performance Probleme

[Chris (Gast)]

Da ich zu Zeit ein wenig am verzweifeln bin suche ich hier Hilfe um zu 
erfahren, ob ich das ganze einfach falsch angehe oder ob die 
Möglichkeiten eine ATMega 8, laufend mit internem Takt, wirklich schon 
ausgeschöpft sind.

Das Programm ergibt zunächst einmal nicht viel Sinn, da es nur ein Teil 
von dem darstellt, was es mal werden sollte. Im Groben geht es bis jetzt 
darum:

- Midi Daten empfangen
- Schreiben in einen Eingangspuffer
- Sobald mindestens 3 Bytes im Puffer vorhanden sind:
- Schreiben in einen Ausgangspuffer
- Midi Daten wieder versenden

Dabei ist die Art, einen vollen uint8_t als Puffer-Index zu verwenden, 
um sich Abfragen etc. wegen der Rücksprünge auf den Index 0 zu sparen, 
schon mehr als dirty, und das nur, um sich ein paar einfache logische 
Operationen zu sparen ( auskommentiert ).

Anspruchsvollere Midi-Files sind jetzt schon nur mit Compileroptimierung 
auf Geschwindigkeit am Eingang sowie Ausgang identisch, ohne dass es 
merkbare Timingverluste gibt.

Was soll ich noch tun? Hilft wirklich nur eine Erhöhung des Taktes ?

/* MIDI RECEIVE AND TRANSMIT WITH BUFFERS */

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

void midi_init(void);
void TXbuf_to_UDR(void);
void SEND(uint8_t byte1, uint8_t byte2, uint8_t byte3);


/* Transmit Buffer */

volatile uint8_t TXbuf[256];
volatile uint8_t TXbuf_write_pointer=0;
volatile uint8_t TXbuf_read_pointer=0;

/* Receive Buffer */

volatile uint8_t RXbuf[256];
volatile uint8_t RXbuf_write_pointer=0;
volatile uint8_t RXbuf_read_pointer=0;



int main(void)
{
    sei();                  // Global Interupt Enable
  midi_init();
  
  uint8_t byte1, byte2, byte3;  


  while (1)
  {
    if ((abs(RXbuf_write_pointer - RXbuf_read_pointer))>2)
    {

    byte1=RXbuf[RXbuf_read_pointer];  // Read 3 bytes of receive buffer
    RXbuf_read_pointer++;
    //RXbuf_read_pointer &= 63;

    byte2=RXbuf[RXbuf_read_pointer];
    RXbuf_read_pointer++;
    //RXbuf_read_pointer &= 63;

    byte3=RXbuf[RXbuf_read_pointer];
    RXbuf_read_pointer++;
    //RXbuf_read_pointer &= 63;
    
    SEND(byte1,byte2,byte3);  
    
    }    
  }
}


void SEND(uint8_t byte1, uint8_t byte2, uint8_t byte3)
{
  TXbuf[TXbuf_write_pointer]=byte1;    // Write 3 bytes to transmit buffer
  TXbuf_write_pointer++;
  //TXbuf_write_pointer &= 63;    

  TXbuf[TXbuf_write_pointer]=byte2;
  TXbuf_write_pointer++;
  //TXbuf_write_pointer &= 63;  

  TXbuf[TXbuf_write_pointer]=byte3;
  TXbuf_write_pointer++;
  //TXbuf_write_pointer &= 63;

  UCSRB |= (1<<UDRIE);          // UDR Empty Interupt enable
}


void midi_init(void)                // settings for MIDI
{  
  
  UCSRC |= (1<<UCSZ1) | (1<<UCSZ0);         // 8 Data Bits

  UBRRH = 0;
  UBRRL=1;                    // 32500 BAUD
  
  UCSRB |= (1<<RXCIE) | (1<<RXEN) | (1<<TXEN);  // reciever and transmitter enable, receive interupt enable
  
}



ISR (USART_RXC_vect)          // receive interupt
{
  RXbuf[RXbuf_write_pointer] = UDR;
  RXbuf_write_pointer++;
  //RXbuf_write_pointer &= 63;
}



ISR (USART_UDRE_vect)          // UDR emty interupt      
{
  TXbuf_to_UDR();
}


void TXbuf_to_UDR(void)        // write 1 byte of transmit buffer to UDR
{
  
  UCSRB &= (~(1<<UDRIE));      // UDR emty interupt disable
  
  if (TXbuf_read_pointer ^ TXbuf_write_pointer)    // if size of buffer != 0
  {
  UDR=TXbuf[TXbuf_read_pointer];
  TXbuf_read_pointer++;
  //TXbuf_read_pointer &= 127;
  
  UCSRB |= (1<<UDRIE);      // UDR emty interupt enable
  }

}