Selbstbau Synth mit Midi

[Synthbastler (Gast)]

Hallo Zusammen,

momentan versuche ich mit einem ATMEGA16 ein Rechtecksignal zu erzeugen, 
das von einem Midikeyboard angesteuert wird.
Das Ganze soll später mal ein Oszillator für einen Synthesizer werden, 
der die vier grundlegenden Wellenformen (Sinus, Dreieck, Sägezahn, 
Rechteck) generieren kann.
Das Erzeugen der Frequenz ist nicht das Problem, sondern die 
Midi-Schnittstelle will nicht so, wie ich will:
Ich habe mit erstmal ein Programm geschrieben, das wenn ich auf dem 
Keyboard das A4 drücke den entsprechenden Ton mit 440Hz generieren soll. 
Das klappt bis zu einem gewissen Grad auch gut, allerdings nur, so lange 
ich die Taste nicht zu schnell drücke und wieder loslasse.
Dann scheint der ATMEGA nicht mehr schnell genug zu sein und somit 
manche Midi-Messages zu verpassen.

Zur Hardware:
Das Keyboard habe ich über die standart Midi-In Schaltung angeschlossen, 
die ich auch in den Anhang geladen habe.
Allerdings habe ich hinter den Optokoppler noch einen Schmitt-Trigger 
gesetzt, da die Signale am Optokoppler noch nicht sehr sauber waren.
Die Midi-Schnittstelle am Keyboard funktioniert an meinem PC 
einwandfrei, da liegt das Problem also nicht.
An PORTC liegt dann das generierte Signal an, wo ich dann zwei einfache 
PC Speaker angeschlossen habe.

Zur Software:
Das Programm wartet auf einen UART-Interrupt, prüft dann ob es sich um 
die Note-On Nachricht handelt und setzt dann einen int auf 1 oder 0, der 
dann in der Hauptschleife die Tonerzeugung ein - oder ausschaltet.
Ich habe mich bemüht alles gut zu kommentieren und leserlich zu 
gestalten, weshalb es einfach sein sollte das Program zu verstehen.

#define F_CPU 20000000UL

#include <avr/interrupt.h> 

#include "uart.h"


void generate_sound(uint8_t note, uint8_t velocity);
void silence();
void delay_us(uint16_t zeit);


uint8_t message = 0, rcvd = 0, note_on = 0, data_rcvd = 0;
uint8_t data_buf[2];  
volatile uint8_t play_note = 0;
volatile uint16_t dauer = 0;


ISR(USART_RXC_vect)
{
  rcvd = UDR;        // Empfangsregister auslesen

  if(rcvd > 0x7F)      // Status-Byte
  {
    message = rcvd >> 4;  // Die Nachricht = die oberen 4 Bit 
    
    if(message == 0b1001) // Note On
    {
      // Die nächsten beiden Interrupts sind die zwei Datenbytes
      // Also für die Aufzeichnung sorgen
      note_on = 1;
  }
  }
  else          // Daten-Byte
  {
    if(note_on)      // Gehört das Daten-Byte zur Note On Nachricht?
    {
      data_buf[data_rcvd] = rcvd;  // Daten-Byte ins Array schreiben
      data_rcvd++;      // Array-Index erhöhen

    if(data_rcvd == 2)  // Beide Daten-Bytes empfangen?
    {
      note_on = 0;    // Note On Nachricht zu Ende
      data_rcvd = 0;    // Array-Index resetten

      if(data_buf[1])    // velocity größer Null?
      {
        // Einen Klang mit der Note data_buf[0] und der
        // velocity data_buf[1] erzeugen
        generate_sound(data_buf[0], data_buf[1]);
      }
      else
      {
        // Sonderfall velocity = Null bedeutet Note Off
        // Also still sein!
      silence();
    }
    }
  }
  }
}

void generate_sound(uint8_t note, uint8_t velocity)
{
  uint16_t freq;  

  play_note = 1;  

  switch(note)
  {
    case 69:          // Kammerton A4 = 440Hz
    freq = 440;
    break;
  default:
    play_note = 0;
  }

  dauer = (1000000 / freq) / 2;  // Periodendauer / 2 in µS berechnen;
  
}

void silence()
{
  play_note = 0;
}


// Wartet bei 20MHz Takt die vorgegebende Anzahl an µS
void delay_us(uint16_t zeit)
{
  for(uint16_t i = 0; i < zeit - 1; i++)
  {
  asm volatile("nop");
  asm volatile("nop");
  asm volatile("nop");
  asm volatile("nop");
  asm volatile("nop");
  asm volatile("nop");
  asm volatile("nop");
  asm volatile("nop");
  asm volatile("nop");
  asm volatile("nop");
  asm volatile("nop");
  asm volatile("nop");
  asm volatile("nop");
  asm volatile("nop");
  }
}

int main()
{
  DDRC = 0xFF;
  uart_init();
  sei();

  while(1)
  {
    while(play_note)
    {
      PORTC = 0xFF;
      delay_us(dauer);
      PORTC = 0x00;
    delay_us(dauer);
    }
  }
}

Danke für Eure Hilfe!

[Knut B. (Firma: TravelRec.) (travelrec)]

Synthbastler schrieb:
> Das klappt bis zu einem gewissen Grad auch gut, allerdings nur, so lange
> ich die Taste nicht zu schnell drücke und wieder loslasse.
> Dann scheint der ATMEGA nicht mehr schnell genug zu sein und somit
> manche Midi-Messages zu verpassen.

Das möchte ich mal ausschließen. Wenn es etwas nicht schafft, dann Dein 
Programm.

Synthbastler schrieb:
> Allerdings habe ich hinter den Optokoppler noch einen Schmitt-Trigger
> gesetzt, da die Signale am Optokoppler noch nicht sehr sauber waren.

Ich denke, dass hier (auch) der Hase im Pfeffer liegt. Schalte an den 
Optokoppler einen solch niederohmigen Arbeitswiderstand (470R...1k), 
dass die Signale am Kollektor sauber sind und lass den Schmitt-Trigger 
weg, der verändert nur das Tastverhältnis der Bits.

EDIT:

Anstelle des 6N138 tut es ein normaler PC817 oder CNY17-1.

[avr (Gast)]

Synthbastler schrieb:
> while(play_note)
>     {
>       PORTC = 0xFF;
>       delay_us(dauer);
>       PORTC = 0x00;
>     delay_us(dauer);
>     }

Mit diesem Ansatz wirst du nicht über einen Kanal hinwegkommen. Für 
mehrere Kanäle braucht man fast zwingend einen Timer. Die Tonerzeugung 
für mehrere Kanäle gibt es übrigens recht effektiv hier: 
AVR-Synthesizer

[Hobbyorganist (Gast)]

Darf ich fragen, ob das Projekt fortgesetzt wurde? Ich würde auch MIDI 
implementieren wollen.

[Karl H. (kbuchegg)]

@Hobbyorganist

Ganz ehrlich.
Ich habe den Eindruck du solltest erst mal mit viel grundlegenderen 
Dingen anfangen.
Dein Projekt in allen Ehren, aber du übernimmst dich. So wird das 
nichts. Dein Können ist noch lange nicht an dem Punkt angelangt, an dem 
man einigermassen sinnvoll ein derartiges Projekt anfangen kann, wobei 
einige Dinge dann erst on-the-job gelernt werden.

Nix für ungut.

Der Anfang jedes µC-Progammierers besteht in
LED einschalten, LED ausschalten, LED blinken lassen.
Erst mit Zeitschleifen, dann mit Timern.
dann kommt irgendwann UART dazu, möglicherweise ein LCD

Und dann, erst dann, ist man auf einem Level, auf dem man sinnvoll 
darüber nachdenken kann, wie man eigentlich Tonerzeugung auf einem AVR 
macht. Wobei es dann immer noch viel zu lernen gibt. Die vorgenannten 
Punkte sind sozusagen die Einstiegshürde. Solange die nicht beherrscht 
werden (und natürlich die Programmiersprache einigermassen sicher 
beherrscht wird), braucht man über ein Synthi-Midi-Projekt gar nicht 
erst nachdenken.

[Thomas (Gast)]

Hallo,

ich habe mich auch schon mit MIDI beschäftigt. Um einen analogen 
Synthesizer an MIDI-Keyboards zu betreiben, braucht man einen MIDI-to-CV 
Konverter.

Wenn man diesen selbst baut, spart man eine Menge Geld und lernt 
Assemblern (oder C), umd den Mikrocontroller zu betreiben. Es empfiehlt 
sich, ein Flußdiagramm anzulegen, und diesen dann in Code umzusetzen. 
Dafür eignet sich das kostenlose Programm "Diagramm Designer" 
http://www.chip.de/downloads/Diagram-Designer_46463345.html.

Bei youtube 
http://www.youtube.com/watch?v=qOInnuqfsS0&list=UUnJGkAU29GWN9MdDnQ3zNWA 
kann man unter Anderem auch den Aufbau meines MIDI-to-CV Konverters 
Marke Eigenbau sehen.

Ich habe den 80C31, 74HC573, 27C512, DAC0808LCN, µA741 und 4N35 dafür 
verwendet. Taktfrequenz 12 MHz.

Gruß Thomas