MIDI/UART lesen. Was mache ich falsch?

[T. S. (elektrowiesel)]

Hallo,
ich versuche mithilfe eines ATmega328 ein Midi Leser zu bauen.
Für den Anfang wollte ich die Richtigkeit der Empfangenen Daten 
feststellen.
Ich habe eine Standard Eingangsschaltung (siehe Wikipedia: Midi) 
verwendet und den Ausgang direkt auf den UART Pin geschaltet.

Immer wenn ein Byte empfangen wird, wird eine Interruptroutine 
ausgeführt, die einen Wert verändert und das Byte kopiert, sodass es in 
der Hauptschleife abgearbeitet werden kann.

Noch in der ISR überprüfe ich, ob das empfangene Byte ein Active Sense 
Signal (0xFE), was alle 200ms vom Keyboard geschickt wird, ist. Das 
funktioniert.
Deshalb glaube ich, dass alle Einstellungen richtig sein müssten (siehe 
Bild activeSense.jpg)

Wenn ich aber in der Hauptschleife mit dem Byte arbeite kommen immer 
falsche Dinge raus (siehe Bild note_on.jpg).

Immer wenn das Byte mit einer 1 anfängt sollte PB2 für 100µS an sein.

Lese ich die Daten vielleicht falsch herum?
Das kann eigentlich nicht sein, da ich die Active Sense Nachrichten per 
Vergleich ignorieren kann.

Einstellungen Logic analyzer UART decoder:
Baudrate: 31250
Datenbits: 8
Parität: keine
Parität prüfen: Nein
Stop bits: 1,0
Bit reihenfolge: LSB first
Invertiertes Signal: Nein


Code:

#define F_CPU 20000000

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

volatile uint8_t receiveComplete = 0;
volatile uint8_t recByte;


int main( void )
{
  // Port init.
  DDRB |= (1<<PB2);
  
  // UART init.
  UCSR0A = 0;
  UCSR0B = 0b10010000;
  UCSR0C = 0b00000110;
  UBRR0L = 39;
  UBRR0H = 0;
  
  sei();
  
    while( 1 )
    {
    if( receiveComplete )
    {
      if( (recByte & 0b10000000) )
      {
          PORTB |= (1<<PB2);
          _delay_us(100);
          PORTB &= ~(1<<PB2);
      }

      recByte = 0;
      receiveComplete = 0;
    }
    }
}

ISR( USART_RX_vect )
{
  // Ignore the active sense messages.
  if( UDR0 != 0xFE )
  {
    recByte = UDR0;
    receiveComplete = 1;
  }
}

[Elias K. (elik)]

Ich weiß nicht, wieso es nicht geht. Aber vielleicht hilft das bei der 
Fehlersuche: Ich würde in der ISR (wenn genug Zeit) eine Funktion 
machen, die das empfangene Datenwort mittel Bitbanging seriell zu einem 
freien Pin rausgibt. Dort den Logic Analyzer ran hängen und gucken, ob 
die Daten zusammen passen. Das hilft idR, um den Fehler zu lokalisieren.

Pseudo-Code:

char PinNr = ...;
char Data = vom UART gelesenes Datenwort;

setPin( PinNr, 0 ); 
wait(1us oder 10 Takte oder ähnlich);
for (int i=0; i<8;  i++) {
  setPin( PinNr, Data & 1); 
  Data = Data >> 1;
  wait(1us oder 10 Takte oder ähnlich);
}
setPin( PinNr, 1 );

[S. Landolt (Gast)]

Läuft der uC wirklich mit 20 MHz? Ich kann in den Bildern die 100 us 
nicht finden. Evtl. mal UCSR0A.FE0 abfragen.

[Mario M. (thelonging)]

S. Landolt schrieb:
> Läuft der uC wirklich mit 20 MHz?

Der angebliche 100µs-Impuls dauert ca. 6 Bitzeiten, also ungefähr 200µs. 
Im Übrigen ist das mehrfache Lesen von UDR0 zumindest schlechter Stil, 
also besser erst temporär speichern und dann auswerten.

[Maxim B. (max182)]

Hallo,
für mich ist gleich merkwürdig, daß du USART ohne Puffer machst.

Als Einregung möchte ich hier ein bißchen Code geben. Das ist für AT 
Mega 1284P, aber notwendige Anpassung ist unkompliziert.

// usart.h
#ifndef USART_H
#define USART_H 1

#define USART_BAUD_MIDI (((F_CPU/16)/31250)-1)
#define USART0_SIZE_RX   16
#define USART0_SIZE_TX   16
void usart0_rxpuff_null(void); // RX puffer => 0
void usart0_txpuff_null(void); // TX puffer => 0
unsigned char usart0_rxsymbol_count(); // Zustand von RX Puffer
unsigned char usart0_txsymbol_count(); // Zustand von TX Puffer
void usart0_rxpuffein(unsigned char data); // byte aus RX0 in puffer lesen
unsigned char usart0_rxpuffaus(void);  // byte aus Puffer lesen
void usart0_txpuff_null(void); // TX puffer = 0
void usart0_txpuffein(unsigned char data); // byte in TX puffer lesen
void usart0_txpuffaus(void);// byte aus TX Puffer senden, in interrupt tx

static inline void usart0_init(void){
  UBRR0H = (uint8_t)(USART_BAUD_MIDI>>8);
  UBRR0L = (uint8_t)USART_BAUD_MIDI;
  UCSR0A = 0;
  UCSR0B = (1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0);
  UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);
  usart0_rxpuff_null();
  usart0_txpuff_null();
}

#endif  /* USART_H */

// usart.c
#include <avr/io.h>      // Muss immer sein
#include <inttypes.h>     // Fuer Datentyp
#include <avr/pgmspace.h>   // Fuer Flash 

#include "main.h"   // Allgemeine Programmablauf 
#include "usart.h"   // USART 
#include "lcd.h"  // LCD

static unsigned char rx_kopf;
static unsigned char rx_schwanz;
static unsigned char rx_symbol_count;
static unsigned char rx_puffer[USART0_SIZE_RX];

static unsigned char tx_kopf;
static unsigned char tx_schwanz;
static unsigned char tx_symbol_count;
static unsigned char tx_puffer[USART0_SIZE_TX];

void usart0_rxpuff_null(void){ // puffer = 0
  
  rx_schwanz = 0; 
  rx_kopf = 0;
  rx_symbol_count = 0;
}

void usart0_txpuff_null(void){ // puffer = 0
  
  tx_schwanz = 0; 
  tx_kopf = 0;
  tx_symbol_count = 0;  
}

unsigned char usart0_rxsymbol_count(){

  return rx_symbol_count;
}

unsigned char usart0_txsymbol_count(){

  return tx_symbol_count;
}

static void count_inc(unsigned char *count, unsigned char wert){
  (*count)++;
  if(*count >= wert){
      *count = 0;
    }
}

void usart0_rxpuffein(unsigned char data){ // byte aus RX0 in puffer lesen

  if(rx_symbol_count < USART0_SIZE_RX){  
  // Wenn puffer noch Platz hat

    rx_puffer[rx_schwanz] = data;  
    rx_symbol_count++;

    count_inc(&rx_schwanz, USART0_SIZE_RX);
  }  
  FLAGG &= ~(1<<F_RX0);  // Flag fuer Empfang auf Null
}

void usart0_txpuffein(unsigned char data){ // byte in TX puffer legen

  if(tx_symbol_count < USART0_SIZE_TX){  
  // Wenn puffer noch Platz hat

    tx_puffer[tx_schwanz] = data;  
    tx_symbol_count++;

    count_inc(&tx_schwanz, USART0_SIZE_TX);
  }
}

unsigned char usart0_rxpuffaus(void){  // byte aus RX Puffer lesen

  unsigned char data = 0;
  data = rx_puffer[rx_kopf];
  rx_symbol_count--;
  count_inc(&rx_kopf, USART0_SIZE_RX);

  return data;;
}

void usart0_txpuffaus(void){  // byte aus TX Puffer senden

  UDR0 = tx_puffer[tx_kopf];
  tx_symbol_count--;
  count_inc(&tx_kopf, USART0_SIZE_TX);
}

// midi.h
#ifndef MIDI_H
#define MIDI_H 1

#define ACTIVE_SENSING 0xfe

void midi_lcd(unsigned char midi_byte); 
// Gibt auf Indikator Leerzeichen und Ziffer

void midi_puff_schieb(unsigned int data ); 
// schieben fuer MIDI: int=2x char und Leerzeichen
#endif  /* MIDI_H */ 

// midi.c
#include <avr/io.h>      // Muss immer sein
#include <inttypes.h>     // Fuer Datentyp
#include <avr/pgmspace.h>   // Fuer Flash 

#include "main.h"   // Allgemeine Programmablauf
#include "lcd.h"  // LCD
#include "midi.h"   // MIDI
#include "led.h"  // LED, fuer LED_F_NUM

void midi_lcd(unsigned char midi_byte){ // Gibt auf Indikator Leerzeichen und Ziffer
  if(midi_byte != ACTIVE_SENSING){ // Synchro-Byte ausschliessen
    unsigned int midizif;
    midizif = lcd_ziffer(midi_byte);
    midi_puff_schieb(midizif);
  } else { // Led F kurz einschalten, wenn ACTIVE_SENSING
    led_ein_time((1<<LED_F_NUM),50);
  }
}

void midi_puff_schieb(unsigned int data ){ // schieben fuer MIDI: int=2x char und Leerzeichen
  unsigned int a;
  unsigned char b;
  a = (data >> 8);
  b = (unsigned char)a;
  lcd_puff_schieb_links(b);  // Dec
  b = (unsigned char)data;
  lcd_puff_schieb_links(b);  // Eins
  lcd_puff_schieb_links(' ');  // Leerzeichen
}

// main.h
#ifndef MAIN_H
#define MAIN_H 1

#ifndef  F_CPU  // Quarz 16 MHz.
#define F_CPU 16000000UL    // CPU_F fuer Verzoegerungen
#endif 

#ifndef FLAGG
  #define FLAGG GPIOR0 /* fuer Ereignisse */
  #define F_PULS 0  /* Puls 1000 Hz, timer 3 interrupt */
  #define F_RX0 1    /* MIDI-Nachricht gekommen */
  #define F_TX0 2    /* MIDI-Nachricht versandt */
#endif

/**********************************************************/


#endif  /* MAIN_H */

// main.c
#include <avr/io.h>  // Muss immer sein
#include <stdio.h>  // Die Ein- und Ausgabefunktionen, 
// Typen und Makros
#include <stdlib.h>  // Funktionen zur Umwandlung von Zahlen, 
// fuer Speicherverwaltung und aehnliche Aufgaben.
#include <string.h>  // Funktionen fuer Zeichenketten
#include <inttypes.h>     // Fuer Datentyp
#include <avr/interrupt.h>   // Fuer Interrupts
#include <avr/eeprom.h>    // Fuer EEPROM
#include <avr/pgmspace.h>   // Fuer Flash
#include <util/delay.h>    // Fuer Verzoegerungen

#include "main.h"   // Allgemeine Programmablauf
#include "led.h"  // LED
#include "knopf.h"   // Knopf
#include "drehgeber.h"   // Drehgeber
#include "timer.h"   // Systempuls
#include "spi.h"   // SPI
#include "lcv1024.h"   // NVRAM
#include "lcd.h"  // LCD
#include "usart.h"   // USART  
#include "midi.h"   // MIDI
#include "logik.h"  // Logik

ISR(USART0_RX_vect){ // USART0, Rx Complete

  FLAGG |= (1<<F_RX0);  // Flag fuer Empfang einsetzen
  usart0_rxpuffein(UDR0);  // In Puffer
}

int main(void){

/******* init *******/

  system_init();

  sei();  // Interrupts erlauben 

/* * * */

while(1){ 

  // Bedienung von Puls 1 ms
  if( FLAGG & (1<<F_PULS) ){

    FLAGG &= ~(1<<F_PULS); // Flag fuer Puls = 0
    
    /* * etwas, was jede 1 ms gemacht sein sollte * */
  }

  // Pruefen, ob TX-Puffer etwas hat.
  // Wenn TX-Puffer nicht leer und fruehere Sendung zu Ende
  if((usart0_txsymbol_count()) && (UCSR0A & (1<<UDRE0))){    
    usart0_txpuffaus();
  }

  

  /* RX bedienen */ 
  if(usart0_rxsymbol_count()){ // wenn rx-Puffer nicht leer
    unsigned char data;
    data = usart0_rxpuffaus();
    if(data != ACTIVE_SENSING){
      midi_puff_schieb(lcd_ziffer(data));
    } else {
      led_ein_time((1<<LED_F_NUM),70);
    }
  }

}
return 0;
}

[T. S. (elektrowiesel)]

Das Projekt ist ja offensichtlich noch lange nicht fertig :)
Puffer und so kommen später.

Der Controller läuft wirklich mit 20MHz ich habe das flasche Bild 
angehängt bzw. den flaschen Code gepostet. Der Puls auf PB2 ist 
tatsächlich 100µS lang.

Das testen des Frame Error Bits hat auch nichts ergeben. Das scheint zu 
funktionieren.

Ich werde jetzt versuchen die Daten wieder auszugeben.

[T. S. (elektrowiesel)]

Halt!
Ich habe schon wieder das falsche Programm in den Controller geladen.
Es liegt wirklich nicht an Frame Errors, sondern daran, dass UDR0 zwei 
mal gelesen wird.

Mit dem geänderten Code funktioniert es dann...