Midilooper für Effekte - ein DiY-Baubericht

[tuckster]

Hallöchen zusammen,

ich bin großer Fan von Bauberichten und möchte heute als Hobbybastler selber mal einen starten.

Es geht um einen Midi Looper für die Effektgeräte. Quasi ein MKII meines M8 MCS MKI. Bei solchen Namenskreationen geht mir immer wieder voll einer ab.

Zu Beginn fasse ich alles aus meinem vorhandenen Kistchen aus dem Selbstbau-Thread inkl. Neuerungen zusammen:
https://www.musiker-board.de/threads/eure-selbstgebauten-effektgeraete.61531/page-232#post-8986165

M8 MCS (Midi Control System) MKII

• 8 Presets x 4 Banks für Midi PC und CC Befehle. Möglicherweise mehr, mal schauen.
  
• 8 Loops für eben 8 Effektgeräte.
• 2 Eingänge für Expression-Pedale.
• 1 Expression-Eingang für Verstärkerschaltung nutzbar (Fernschaltung meines Koch Jupiter über Stereobuchse).
  
• Empfängt Midi PC um die Loops zu schalten.
  
• Per Tasten menügeführt konfigurierbar. Tasterbelegungen werden automatisch gespeichert.
  
• In der "Theorie" einfach auf weitere 8 Schalter/Loops erweiterbar weil alles modular ist.
• Arduino Nano als Herzstück. Der kostet bei Abnahme von 3 Stück als Kopie genau 3,33€ und im Gegesatz zum vorherigen Atmega8 gibts onboard einen USB Programmer (minimal weniger Lötarbeit, mehr Komfort) und mehr Speicher.
  
• Keine Tunerfunktion
• Mutefunktion
  
• Kleines schönes OLED Display statt 7 Segmentanzeige

Mein erster Looper ist eine Platzverschwendung auf dem Pedalboard, daher kommt er diesmal in ein größeres, flacheres Gehäuse unter die Pedale.
Das bedeutet

• kleine Taster an die Front, keine Fußtaster verwenden
• Looper wird durch den ersten Looper per Midi gesteuert und das Pedalboard steht dann altersgerecht und rückenschonend auf einem Tisch.

Ja, mein erster Looper wird als simpler Midischalter mißbraucht. Was kostet die Welt? Eure Armut kotzt mich an!
Ich baue mir also meinen kürzlich erworbenen Rocktron PatchMate Loop 8 nach. Womöglich stecke ich mein Board und den Looper ja irgendwann in ein Rack...

Weiterhin verfolge ich die Theorie der Erweiterbarkeit, die mit dem Aufbau dieses Loopers Nr.2 bewiesen werden könnte. Darum nutze ich wieder simple Shiftregister in Verbindung mit dem Arduino.

Man beachte, dass vieles von den genannten Punkten erst im Laufe des Projektes wirklich realisiert werden. Im Plan sind sie schonmal drin. Evtl habe ich aber etwas vergessen oder bin zu unfähig, das alles in der Programmierung umzusetzen
Keine Angst, ich habe mir da nicht alles selbst ausgedacht, wozu gibt es das Internet und die vielen fremderfundenen Räder?


Noch mal die Erinnerung an MKI wecken:

Im Prinzip das ganze Gerät mit mehr Funktionen, flacher und natürlich mit weniger Verkabelung...

Eine fancy 3D Ansicht habe ich schon:

Eigentlich recht unspektakulär.
Hier mal der Plan und mein Routing. Man beachte die Rasterung für (ja genau) Lochrasterplatinen...
Der Schaltplan ist sehr unscharf, da ich ja nicht jede Peinlichkeit der unsauberen Beschriftung etc entblößen muss:

Das Projekt wird auf zwei Platinen verteilt. Eine so große Lochrasterplatine habe ich auf Anhieb nicht gefunden und es gibt zwei Möglichkeiten des Aufbaus (nebeneinander oder gestapelt).

Auf dem oberen Teil des Layouts (Platine 1) befindet sich der Arduino und die Bereiche, die für die Taster, die LEDs und die Midianschlüsse zuständig sind.
Auf dem unteren Teil (Platine 2) befinden sich die Bereiche, die für die Relays und somit die Ein-/Ausgänge zuständig sind, sowie die Bereiche für die Mute- und für die Verstärkerschaltfunktion.
Beide wird über Stiftleisten verbunden und kann somit bei Bedarf gestapelt werden. Dann benötigt man allerdings bei einer Platine eine Buchsenleiste statt einer Stiftleiste

Ich lerne mich gerade in Kicad ein, irgendwann könnte wohl alles eleganter darstellen. Schließlich gibt es für alles Konventionen

In diesem Sinne: an den Lötkolben!!
--- Beiträge wurden zusammengefasst ---
Ich hätte jetzt gern ein Bild mit allen Bauteilen auf einem Haufen gezeigt. Die vielen Tütchen finde ich immer imposant
Da bei mir alles schon sortiert wurde, gibts das nicht...

Aktueller Stand:

Ist das Display nicht süß? Möglicherweise zu klein.

 

[thorwin]

Hmm, gar nicht mal so unähnlich zu dem, was ich hier suche. Subbed!

 

[DerThorsten]

und.... aboniert. Ich bastle ja auch gerne, aber da wird es mir doch zu unübersichtlich. Der letzte Looper wurde einfach gekauft. Deshalb: Hut ab!

 

[tuckster]

Mir war letzte Woche noch eine Routingfunktionalität durch den Kopf gegangen aber ich habe die Idee dann gestrichen.
Alleine um es mal zu bauen wäre das reizvoll aber das sind dann viele Relays oder teure andereweitige Lösungen.
Wenn man sowas benötigt, dann solte es der Boss ES_8 werden
https://www.boss.info/global/promos/es-8_deep_dive/
Hammer Gerät!

 

[thorwin]

Hammer Gerät!

Jaja schon, aber es geht doch beim DIY so ein Bisschen um den Spaß am Lötkolben, oder? ;-)

 

[tuckster]

Genau. Ich hoffe nur, dass ich nicht wieder Jahre brauche, wie beim ersten Looper

 

[tuckster]

Langsam geht es voran.
Diesmal mit etwas mehr Draht. Das letzte mal hatte ich alle Leiterbahnen mit Lötzinn realisiert.
Geht schnell, macht das ganze Platinchen aber unnötig schwer.
Leider habe ich die billigste Lochrasterplatine gekauft. auch mit schmiergeln und Aceton etc sind die Lötaugen teilweise schlecht lötbar. Sowas hatte ich noch nie...

 

[boisdelac]

Habe Dein Projekt gerade gesehen ...

Schalte noch parallel zu den Relais-Spulen Freilaufdioden. 1n4148 genügt. Die Kathode der Diode an den Anschluss der Spule mit positivem Potential, die Anode an den anderen Anschluss.
Die Dioden schließen Spannungsspitzen durch die Selbstinduktion innerhalb der Relais-Spulen kurz.

Deine Halbleiter-Treiber-Bausteine werden es Dir danken, und es gibt beim Schalten weniger Übersprechen auf den Analogteil Deiner Schaltung.

 

[Monsieur Hulot]

Hi tuckster,

danke für die Vorstellung. Sieht gut aus!

Was ich (und evtl. andere User) noch interessant finden würde/n, wäre ein Blick in deine Arduino-Sketch. Wäre schon interessant, wie du das softwareseitig gelöst hast. Ganz besonders den Teil mit Midi und Expression. Ich könnte aber auch verstehen, wenn du das nicht veröffentlichen willst.

KiCad! Cool!

Manchmal glaube ich, das wir hier noch eine DIY-Gitarrenelektronik-Effektgeräte-Sparte bräuchten.
Auch wenn man mal in den "Selbstgebaute-Geräte-Thread" schaut, merkt man, dass es hier schon ne Menge Potential dafür geben würde.

 

[tuckster]

Habe Dein Projekt gerade gesehen ...

Schalte noch parallel zu den Relais-Spulen Freilaufdioden

Danke für deinen scharfen Blick darauf. Als Relaytreiber verwende ich einen ULN2803A, da ist neben dem Transitor die Freilaufdiode ebenfalls enthalten. Weniger Bauteile

Hi tuckster,

danke für die Vorstellung. Sieht gut aus!

Was ich (und evtl. andere User) noch interessant finden würde/n, wäre ein Blick in deine Arduino-Sketch. Wäre schon interessant, wie du das softwareseitig gelöst hast. Ganz besonders den Teil mit Midi und Expression. Ich könnte aber auch verstehen, wenn du das nicht veröffentlichen willst.

KiCad! Cool!

Manchmal glaube ich, das wir hier noch eine DIY-Gitarrenelektronik-Effektgeräte-Sparte bräuchten.
Auch wenn man mal in den "Selbstgebaute-Geräte-Thread" schaut, merkt man, dass es hier schon ne Menge Potential dafür geben würde.

Danke, danke!
Es gibt keinen Arduino-Sketch, es ist alles in C geschrieben. Der Expressionteil fehlt noch...
Was genau willst du bzgl. Midi wissen?

 

[Monsieur Hulot]

Hi,

wie du softwareseitig die Midi-Schnittstelle implementiert hast.
"Midi PC und CC Befehle"
Das C-Praktikum samt Schein ist allerdings schon 20 Jahre her, aber wen mich was interessiert, ist das kein Hindernis.

 

[tuckster]

Edit: kurzer Hinweis, das alles bezieht sich auf den Atmega8, für den Arduino habe ich noch nichts angepasst. Ich bin mir nicht sicher, ob die Register dort auch so heissen wie unten angegeben (UCSA, UDR etc).

Senden

static void sendSwMsg(uint8_t status, uint8_t data1, uint8_t last) {
// send midi message with uart; only PC and CC messages for now

        uartSend(status);                                  // send status byte
        uartSend(data1);                                   // send data1 byte (PC or CC number)
        if(status == conf.cc_status){                      // if cc send additional data2 byte (0 or 127)
            uartSend(!last ? SW_ON_CC_VAL : SW_OFF_CC_VAL); // toggle the status depending on what .last of the selected switch is holding
        }
}

static inline void uartSend(uint8_t byte) {
// sent byte to Uart Data Register
  while (!(UCSRA & _BV(UDRE))) {};  // wait until UART is ready to send data
  UDR = byte;
}

sendSwMsg weil es bei Betätigung des "Sw"itches gesendet wird.

An die Funktion wird übergeben:

"status"
ist zu Begin das PC oder CC Byte oder Verknüpft mit dem Midi Kanal.
Aus config.h
#define PC_BYTE 0xc0
#define CC_BYTE 0xb0
#define PC_STATUS_INIT (PC_BYTE | MIDI_CHAN_INIT)
#define CC_STATUS_INIT (CC_BYTE | MIDI_CHAN_INIT)

"data1"
ist die oder PC/CC Nummer

"last"
ist der letzte Zustand der CC Nummer.

Gesendet werden genau diese Parameter. Zuerts das Status (oder Command Byte), dann das Data 1 Byte und bei CC noch das Data 2 Byte. Das Data 2 Byte ist immer 0 oder 127, je nachdem welchen Status (an oder aus) die Funktion im Zielgerät hat.
In Arduinosprache ist es dann ein Serial.write() statt uartSend().

Der Empfang sieht etwas komplexer aus. Dazu schreibe ich morgen was.
Kurz: Interrupt Funktion schreibt etwas in einen Ringbuffer. Sobald dort Daten verfügbar sind, werden sie gelesen und zur Midi Nachricht zusammengesetzt. Ist diese fertig, kann man damit tun was man möchte.

 

[tuckster]

Interrupt Service Funktion (ISR) schreibt empfangene Daten in einen Ringpuffer.

https://www.mikrocontroller.net/articles/FIFO
https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART

Von hier habe ich den Code für den Interrupt übernommen
http://www.einedigitalewelt.de/?p=352

Sorry für die Formatierung, im Forum sind die Einrückungen etc. nicht korrekt dargestellt.

ISR( USART_RXC_vect ){
  // read data from buffer
  rx_buffer[rx_write_index++] = UDR;  // get received byte from USART, increase write index
  if (rx_write_index >= RX_BUFFER_SIZE){  // ring buffer write index reached max size -> reset to zero
  rx_write_index = 0;
  }
  if (rx_write_index == rx_read_index){  // ring buffer overflow TODO: Report Error
  sendDebugString("overflow");  
  }
}

Variablen für den Empfang

uint8_t  cmd;
uint8_t  data1;
uint8_t  data2;
uint8_t  rx_message;
uint8_t  rx_midi_complete = 0;
uint8_t  rx_buffer[RX_BUFFER_SIZE];
volatile uint8_t  rx_write_index = 0;
volatile uint8_t  rx_read_index = 0;
uint8_t  rx_midi_msg_complete = 0;
enum  rx_message_bytes{CMD, DATA1, DATA2} rx_message_byte;   // for state machine in readMidi()

readMidi wird in main() aufgerufen.
Midi hat keine Data Header oder ähnliches. Man knan also nicht sehen, ob die gerade empfangenen Daten jetzt z.B. das Command (Status) Byte oder das Data 2 Byte für CC darstellen.
Die Daten kommen nacheinander in einem Rutsch. Darum habe ich eine kleine State Machine, die bei jedem Empfang durchgearbeitet wird --> switch(rx_message_byte).
Beim Start des Loopers beinhaltet rx_message_byte CMD, es wird also beim Empfang von Daten immer zuerst geprüft, ob es ein PC oder CC Command ist.

static void readMidi(void){
  if(mode == LOOP){                             // receive Midi only in loop mode
  if(rx_read_index != rx_write_index){                 // read when data is available
  rx_message = rx_buffer[rx_read_index++];
  if (rx_read_index >= RX_BUFFER_SIZE){             // reset read index
  rx_read_index = 0;

  }

  switch(rx_message_byte){                           // state machine   
  case CMD:                                 // first step CMD as the first received byte is the command byte
  if(rx_message == PC_STATUS_INIT || rx_message == CC_STATUS_INIT){   // check if command byte is PC or CC, no other command is used right now
  cmd = rx_message;
  rx_message_byte = DATA1;                     // following data in buffer will be data 1 byte
  }
  break;
  case DATA1:
  if(cmd == PC_STATUS_INIT){
  data1 = rx_message;
  rx_midi_msg_complete = 1;                     // PC has no data 2 byte
  }else if(cmd == CC_STATUS_INIT){
  data1 = rx_message;
  rx_message_byte = DATA2;                     // for CC the following data in buffer will be data 2 byte
  }
  break;
  case DATA2:
  if(cmd == CC_STATUS_INIT){
  data2 = rx_message;
  rx_midi_msg_complete = 1;
  }
  }
  
       if(rx_midi_msg_complete){
  
         // hier stand mein Text zur Relaissteuerung.
         // Bsp PC 4 schaltet das 4. Relais etc


         // reset all variables
  rx_midi_msg_complete = 0;
  rx_message = 0;
  cmd = 0;
  data1 = 0;
  data2 = 0;
  rx_message_byte = CMD;     // next data in buffer will be command byte for the next midi command

  }
  }
  }
}

 

[Monsieur Hulot]

Mal wirklich vielen Dank, dass du den Quelltext auszugsweise hier teilst. Hab ein kleineres Midi-Projekt im Hinterkopf und dieser Thread wird mir bzgl. der notwendigen Schritte möglicherweise noch eine große Hilfe sein, auch wenn ich es beizeiten dann mit der Arduino-Ide versuchen werde. Danke!

 

[tuckster]

Platine 1 ist fertig

 

[tuckster]

Es geht voran.
Langsam und langsamer. Beim nächsten Projekt bestelle ich die Platinen....

 

[tuckster]

Die langen Leiterbahnen sind durchgehende Drähte. Wie sich herausgestellt hatte war das keine gute Idee. Der Draht war mehr oder weniger schön warm beim Löten und hatte sich beim Abkühlen so zusammengezogen, dass die Platine jetzt leicht gebogen ist...

Aktueller Stand