LED Matrix steuern mit RN-Control 1.4 (atmega32)

[Céd G. (kampfsoletti)]

hallo zusammen...

jetzt häng ich hier schon mindestens 10 stunden drin und such eine 
lösung für mein problem doch find ich keine :/ ich hab' zwar schon einen 
gefunden der ein ähnliches problem hatte, half mir aber nicht wirklich 
weiter...

mein ziel ist es eine 5x10 led matrix anzusteuern, einfarbig ganz schnöd 
und normal :) .. hab sie schon gebaut verkabelt und an das RN-Control 
v1.4 angesteckt .. hab mich in verschiedene themen eingearbeitet wie zb. 
Uart und wie das da funktioniert, hab mir das was ich brauche 
zusammengebastelt, auch mit hilfe von diesem forum, doch komm ich jetzt 
einfach nicht drauf warum das ding nicht funktionieren will...


also ich habe eine zeilenfolge von [E][x][y][#] wobei die raute als 
stopbit fungiert...und ich will jetzt je nachdem was sich in dem 
empfangenen string befindet die led die für die 2 koordinaten steht zum 
leuchten bringen...

wär toll wenn sich das vll der eine oder andere zu gemüte führt... kann 
nicht garantiern dasses nicht totaler krampf ist... so hoffe ich bei 
eurem urteil auf milde ..

#define F_CPU 16000000L            
// "Morsedauer" für ein Bit in Millisekunden
#define BITZEIT 100     
 
#include <string.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>


// Baudrate, das L am Ende ist wichtig, NICHT UL verwenden!
#define BAUD 9600L          
 
// Berechnungen
// clever runden
#define UBRR_VAL  ((F_CPU+BAUD*8)/(BAUD*16)-1)  
// Reale Baudrate
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     
// Fehler in Promille 
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD-1000) 
 
#if ((BAUD_ERROR>10) || (BAUD_ERROR<-10))
  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch! 
#endif
 
// globale Variablen für den UART
 
// Puffergrösse in Bytes, RX und TX sind gleich gross
#define uart_buffer_size 32             
 
volatile uint8_t uart_rx_flag=0;            // Flag, String komplett empfangen
volatile uint8_t uart_tx_flag=1;            // Flag, String komplett gesendet
char uart_rx_buffer[uart_buffer_size];      // Empfangspuffer
char uart_tx_buffer[uart_buffer_size];      // Sendepuffer
 
// lange, variable Wartezeit, Einheit in Millisekunden
void long_delay(uint16_t ms) {
    for (; ms>0; ms--) _delay_ms(1);
}
 
// einen String senden
// vor Aufruf der Funktion muss man prüfen, ob uart_t_flag==1 ist
// nur dann kann ein neuer String gesendet werden
 
void put_string(char *daten) {
 
   if (uart_tx_flag==1) {
      // String daten in den Sendepuffer kopieren
      strcpy(uart_tx_buffer, daten);      
      // Flag für 'Senden ist komplett' löschen, 
      uart_tx_flag = 0;                    
      // UDRE Interrupt einschalten, los gehts
      UCSRB |= (1<<UDRIE); 
   }
}

// einen empfangenen String kopieren
// vor Aufruf der Funktion muss man prüfen, ob uart_rx_flag==1 ist
// anderenfalls ist der RX Buffer noch ungültig
 
void get_string(char *daten) {
 
   if (uart_rx_flag==1)
   {
      // String kopieren
      strcpy(daten, uart_rx_buffer);      
      // Flag löschen
      uart_rx_flag = 0;                    
   }
}
 

// Hauptprogramm
 
int main (void) {



    char stringbuffer[64];  // Allgemeiner Puffer für Strings
    uint8_t buffer_full=0;  // noch ein Flag, aber nur in der Hauptschleife
//    char * charpointer;     // Hilfszeiger
    
// IO konfigurieren
 
    DDRA = 0xFF;
    DDRB = 0xFF;
    DDRC = 0xFF;
    DDRD = 0xFF;

  PORTB = 0xff;
  PORTD = 0xff;
  PORTA = 0xff;
  
 
// UART konfigurieren
 
    UBRRH = UBRR_VAL >> 8;
    UBRRL = UBRR_VAL & 0xFF;
    UCSRB = (1<<RXCIE) | (1<<RXEN) | (1<<TXEN); 
  UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); //8N1 8 bit parity none 1 stopbit 
//  UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0) | (0 << UPM1);
//  UCSRC = (1<<URSEL)|(3<<UCSZ0);
//  UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0); 

   
// Stringpuffer initialisieren

 
    stringbuffer[0] = '\n';
    stringbuffer[1] = '\r';
 


//variablen
int x;
int y;
// Interrupts freigeben
 
    sei();

// Endlose Hauptschleife

    while(1) 
  {

 
        // Wurde ein kompletter String empfangen 
        // und der Buffer ist leer?
        if (uart_rx_flag==1 && buffer_full==0)
    {    
            // ja, dann String lesen, 
            get_string(stringbuffer);             
            buffer_full=1;
    
      x = stringbuffer[1];
      y = stringbuffer[2];
      

    
  if(stringbuffer[0] == 'E'|| stringbuffer[0] == 'e')
      {    
        x = stringbuffer[1];
        y= stringbuffer [2];
      
        if(stringbuffer[1]<7)
        {
          PORTB |= (1 << x);
          PORTA &= ~(1 << y);
        }

        else
        {  if(stringbuffer[1]>=7)
          {
            PORTD |= (1 << x);
            PORTA &= ~(1 << y);
          }
        
        }
      }  
      
  else
  {    

            
    if(stringbuffer[0] == 'A'|| stringbuffer[0] == 'a')
        {    
          x = stringbuffer[1];
          y = stringbuffer[2];

          if(stringbuffer[1]<7)
          {
            PORTB &= ~(1 << x);
            PORTA |= (1 << y);
          }

          else
          {  if(stringbuffer[1]>=7)
            {
              PORTD &= ~(1 << x);
              PORTA |= (1 << y);
            }
          }
         }



  }
      
    
    
    
    
    
      }