Geschrieben am

MIDI-Controller Teil 9 – Arduino Push Button Tutorial

Ihr habt’s so gewollt: Ein Button Tutorial für unseren Arduino MIDI-Controller. Wir schauen wie die Hardware angeschlossen wird und schreiben unseren ersten Code.

Der Code für diese Folge

int taste = LOW;
int tasteAlt = LOW;

void setup() {
 Serial.begin(9600);
 pinMode(2, INPUT);
}

void loop(){
 taste = digitalRead(2);
 
 if (taste == HIGH && tasteAlt == LOW) {
 Serial.write(144); // 1001 0000 = Note On Kanal 1
 Serial.write(36); //Note C1
 Serial.write(127);
 tasteAlt = taste;
 }
 if (taste == LOW && tasteAlt == HIGH) {
 Serial.write(144); // 1001 0000 = Note On Kanal 1
 Serial.write(36); //Note C1
 Serial.write(0);
 tasteAlt = taste;
 }
}

Schaltplan

arduino-push-button-anschliessen-tutorial-schaltung

 

38 Gedanken zu „MIDI-Controller Teil 9 – Arduino Push Button Tutorial

  1. Hi Götz,
    Ich bin begeistert! Du machst den Weg frei. Am liebsten würde ich sofort loslegen, nur der Bär tanzt hier gerade.
    Bis ganz bald
    Christof

  2. Hi Götz,
    Noch eine Frage, ist die Boudrate von 9600 ok, oder müsste da die 31tausend und ein paar zerquetschte stehen? Eine spezielle Übung zum Nachdenken für die Zuschauer, was natürlich die Oberliga der Vermittlung wäre, selber nachdenken?
    Grüße
    Christof

    1. Wenn du über USB + Serial Bridge übertragen willst ist die Geschwindigkeit egal, solange du in der Bridge die gleiche Geschwindigkeit eingestellt hast. 9600 nimmt man üblicherweise – warum weiß ich ehrlich gesagt gar nicht. Nur wenn du MIDI über eine klassische MIDI-Out Buchse schicken willst musst du dich an die Geschwindigkeit von 31250 Baud halten.

      Die spezielle Übung wäre eher, wie du mit einem Schalter die Geschwindigkeit im Arduino selber umschalten kannst… 😉

  3. Hallo Götz,
    deine Midi Implementierung ist nicht ganz richtig. Eigentlich müsste es so aussehen. Midi Note On oder Off is entweder 144 oder 128.

    noteON = 10010000 = 144
    noteOFF = 10000000 = 128

    Du musst zuerst ein noteON mit einem key und velocity senden und dann mit dem gleichen key einen noteOFF und einer velocity wobei die velocity bei einem noteOFF in den meisten Fällen keine Rolle spielt.

    Serial.write(144); -> noteOn
    Serial.write(48); -> c2
    Serial.write(0-127); -> velocity

    …..

    Serial.write(128); -> noteOFF
    Serial.write(48); -> c2
    Serial.write(0-127); -> velocity

    Vielen Dank für deine tollen Projekte,

    stiwi

    1. Hallo Stiwi,
      wir haben beide Recht!^^ Man kann einen NoteOn- mit einem NoteOff-Befehl beenden wie du sagst. Alternativ kann man genau so einen NoteOn mit der Velocity 0 senden, so wie ich das im Video auch erklärt habe.

      Die Idee dahinter ist, dass das MIDI-Protokoll eine Art Datensparmodus eingebaut hat, den sog. „Running Status“. Wenn mehrere Befehle hintereinander das gleiche Statusbyte haben, brauchst du das Statusbyte nur beim ersten Befehl senden und kannst es danach weglassen. Wenn man nun ständig zwischen NoteOn und NoteOff-Befehlen wechseln würde, spart das nicht viel. Da man NoteOff aber eben auch durch NoteOn mit Velocity 0 ersetzen kann, reduzierst du bei „normalem Klavierspielen“ die Datenmenge um rund 30%. Was bei der klassischen MIDI-Schnittstelle ohne USB mit schlappen 3,8 KB/s Durchsatz eine Menge ausmachen kann.

      Das hab ich mir nur im Video gespart, damit’s nicht zu kompliziert wird.
      VG
      Götz

  4. Servus!
    Liegts an mir oder liegt in deinem fritzing n fehler vor?
    das türkise kabel sollte doch noch eine reihe weiter runter. auf 5V gelegt werden–oder hab ich da nen gedankenfehler?

    lg roman

    1. Servus Roman,
      du hast völlig recht, da hat der Fehlerteufel zugeschlagen. Oder ich hab einfach nur gepennt… 😉
      Ich hab die Grafik korrigiert – vielen Dank für deinen Hinweis!
      LG
      Götz

  5. Hi Götz,
    Ich habe den Code copy paste eingesetzt, bekomme aber Probleme. Ist das eine if-if abfrage oder eine if-else? Ich hab mal das zweite If durch else ersetzt, bekomme dann aber noch ein : expected ´;`before `{`token – Meldung.
    Grüße
    Christof

  6. Hi Götz,
    Hilferuf!
    Ich habs übersprungen und war schon beim 4051. Jetzt probiere ich die Buttons bin aber am Ende vom Latein. was ich auch probiere, ich bekommen dieses Fehlermeldung. Eigentlich wollte ich acht Buttons als Array programmieren, bin aber direkt am Anfang hängengeblieben 🙁
    Grüße
    Christof

    1. Magst du mal deinen Sketch posten?

  7. Du hast recht (natürlich) zwei mal if, auch wenn das zur Zeit noch mein Verstehen arg strapaziert. Ein anderes Phänomen taucht auf, ich benutze einen stabilen Tast.Schalter, der prellt. in einem baselbuch hatte ich flüchtig was von „Bounce“ gehört. Kann ich das abstellen?
    Sorry für den Trouble.
    Christof

    1. Hallo Christof,

      erstmal zum if:
      Zwei Mal if ist richtig, da es ja zwei Bedingungen sind, die nichts miteinander zu tun haben. Trifft die Bedingung zu (z.B. Button gedrückt) sende den Befehl, trifft sie nicht zu mache einfach nichts.

      If else nimmst du, wenn es verschiedene Möglichkeiten gibt auf die Bedingung zu reagieren. Trifft die Bedingung zu, machst’e Möglichkeit A, trifft sie nicht zu machst du Möglichkeit B.

      Der Debounce kommt noch dran – ich hab ihn zur Vereinfachung erst einmal weggelassen. Oft wird das ja per „Warteschleife“ gelöst, aber das ist bei Musik und einem guten Timing gar nicht so schlau. Schau mal hier: http://dduino.blogspot.de/2012/03/arduino-button-debouncing.html

      VG
      Götz

      1. Hallo Götz,
        Ja das „Debounce“ ist ein Thema für sich. Da Schalter ja auch andere Probleme haben, habe mir Hall-Sensoren in mein Noten-Pedal eingebaut. Damit soll der Mixer auch auf die Füße erweitert werden, da man ja so selten drei Arme hat.
        Hier mein Sketch ohne Array, aber es klappt trotzdem nicht:
        int taste5 = LOW;
        int taste6 = LOW;
        int taste7 = LOW;
        int taste8 = LOW;
        int taste9 = LOW;
        int taste10 = LOW;
        int taste11 = LOW;
        int taste12 = LOW;
        int tasteAlt5 = LOW;
        int tasteAlt6 = LOW;
        int tasteAlt7 = LOW;
        int tasteAlt8 = LOW;
        int tasteAlt9 = LOW;
        int tasteAlt10 = LOW;
        int tasteAlt11 = LOW;
        int tasteAlt12 = LOW;

        void setup() {
        Serial.begin(9600);
        pinMode(5, INPUT); //acht Eingänge
        pinMode(6, INPUT);
        pinMode(7, INPUT);
        pinMode(8, INPUT);
        pinMode(9, INPUT);
        pinMode(10, INPUT);
        pinMode(11, INPUT);
        pinMode(12, INPUT);
        }

        void loop(){
        taste5 = digitalRead(5);
        if (taste5== HIGH && tasteAlt5== LOW) {
        Serial.write(144); // 1001 0000 = Note On Kanal 1
        Serial.write(36); //Note C1
        Serial.write(127);
        tasteAlt5 = taste5;
        }
        if (taste5== LOW && tasteAlt5== HIGH) {
        Serial.write(144); // 1001 0000 = Note On Kanal 1
        Serial.write(36); //Note C1
        Serial.write(0);
        tasteAlt5 = taste5;
        }
        taste6 = digitalRead(6);
        if (taste6== HIGH && tasteAlt6== LOW) {
        Serial.write(144); // 1001 0000 = Note On Kanal 1
        Serial.write(37); //Note D1
        Serial.write(127);
        tasteAlt6 = taste6;
        }
        if (taste6== LOW && tasteAlt6== HIGH) {
        Serial.write(144); // 1001 0000 = Note On Kanal 1
        Serial.write(37); //Note D1
        Serial.write(0);
        tasteAlt6 = taste6;
        ……….
        ………
        }
        }

        1. Hmmm, also mir fällt in deinem Sketch erst einmal kein Fehler auf. In meinem Arduino Programm kann ich ihn auch ohne Fehlermeldung kompilieren. Meist liegt ja dann der Fehler bei einem vergessenen Semikolon beim Kopieren und Einfügen oder einem unsichtbaren Steuerzeichen.
          Probier doch noch mal den Sketch aus deinem Post zu kopieren und in einen neuen, leeren Sketch einzufügen. Erst wenn du keine Fehlermeldung bekommst, fügst du den Code für weitere Taster hinzu.
          Viel Erfolg!
          Götz

      2. Bis der Debounce kommt könnt ihr einfach ein delay(3) oder delay(10) in jeden if befehl schreiben. Das ist kaum bis gar nicht bemerkbar.
        if (taste1…) {


        delay(3);
        }

  8. Hi Götz.

    Vielen Dank für die Tutorials !
    Ich hatte eine Frage …

    Wie kann ich diese code verkürzen? (Ich habe ein Arduino Mega und will 40 Tasten benutzen)

    ——————————————————
    int button2 = LOW;
    int button3 = LOW;

    int buttonAlt2 = LOW;
    int buttonAlt3 = LOW;

    void setup() {
    Serial.begin(9600);
    pinMode(2, INPUT); //acht Eingänge
    pinMode(3, INPUT);

    }

    void loop(){
    button2 = digitalRead(2);
    if (button2== HIGH && buttonAlt2== LOW) {
    Serial.write(144); // 1001 0000 = Note On Kanal 1
    Serial.write(36); //Note C1
    Serial.write(127);
    buttonAlt2 = button2;
    }
    if (button2== LOW && buttonAlt2== HIGH) {
    Serial.write(144); // 1001 0000 = Note On Kanal 1
    Serial.write(36); //Note C1
    Serial.write(0);
    buttonAlt2 = button2;
    }
    button3 = digitalRead(3);
    if (button3== HIGH && buttonAlt3== LOW) {
    Serial.write(144); // 1001 0000 = Note On Kanal 1
    Serial.write(37); //Note D1
    Serial.write(127);
    buttonAlt3 = button3;
    }
    if (button3== LOW && buttonAlt3== HIGH) {
    Serial.write(144); // 1001 0000 = Note On Kanal 1
    Serial.write(37); //Note D1
    Serial.write(0);
    buttonAlt3 = button3;
    ………..
    ………..
    ……….
    }
    }
    ————————————————————————-

  9. Hallo Götz,
    Du hast mich aufgeweckt, Was denkst du was ich alles an gestellt habe um Bedientasten in einer Selbstbau-Orgel zum laufen zu bekommen. Ich hab es mit ein Tastatur-Baustein einer PC-Tastatur gemacht und auf meiner Keyboard-Software eingelernt. Dies Funktionierte aber nur bei einer Software. Aber MIDI, das können sie alle. Jetzt ist der Weg frei um in Jeder Software auf meiner Selbstbau-Orgel die Bedientasten zu nutzen.

    Danke, Danke und nochmal Danke sagt

    Carsten

    PS:
    Du könntest auch mal Zeigen wie man mit einen Schieberegister die digitalen Eingänge erweitern kann. Das habe ich noch nicht so richtig verstanden.

    1. Hallo Carsten,
      dir auch vielen Dank und viel Erfolg!
      Schieberegister kommt bestimmt früher oder später mal dran – wenn auch nicht unbedingt für den Controller.
      VG
      Götz

  10. Hallo Götz,
    mal wieder ein sehr interessantes Video.
    Könnte man im Midicontoller auch größere Pads anstatt kleinen Tastern verbauen?
    Leider habe ich im Web keine einzelnen Pads gefunden (solche wie in vielen DJ Controllern)!

    Vielleicht hast du ja solche gesehen oder sogar ausprobiert!

    LG
    Konstantin

    1. Das einzige was ich jetzt spontan wüsste wären diese hier:
      https://www.sparkfun.com/products/7835
      Ich hoffe das hilft dir weiter! VG
      Götz

      1. Hallo Götz,
        vielen dank! 😀
        Ich habe mitlerweile auch das gefunden:
        https://www.adafruit.com/products/1929
        Aber irgendwie finde ich das schon etwas abzocke, 99€ für 9×8 Pads, oder was meinst du?

        LG Konstantin

      2. Naja, es ist ja auch ein Acrylgehäuse dabei, insofern finde ich das schon okay vom Preis. Was man ja auch oft sieht sind Arcade-Buttons – die sind groß, bunt, stabil und bezahlbar.

        1. Jo das is mal ne gute Idee,
          mal ne andere Frage.
          Kannst du mal ein Video zum Thema Homestrudio/Homerecording machen?

          Ich richte gerade ein Homestudio im Keller ein um mit Kumpels und so ein bischen aufzunehmen.

          Ich habe bisher schon als Equipment, ein AKG C1000S, ein beyerdynamik MC86 und zwei Shure SM 58-LC sowie einige Behringer Mikros und ein Shure Headset, als Audiointerface benutze ich ein Alesis iO4 das an meinen Mac geht und dort von Garageband aufgenommen wird.
          Ich hab auch Ableton Live 7 und Cubebase 6 LE.

          Was würdest du mir noch an Equipment empfehlen?
          Ich dachte schon an ein sE Electronics Z3300a als Großmembran Mikro.

          Wie könnte ich meine Aufnahmen noch verbessern?

          Vielen Dank für alle Tipps,
          Konstantin

          1. Ja, in die Richtung werde ich auch die eine oder andere Folge machen – ich helfe demnächst einem Freund bei seinem Studioumbau – ich hoffe da fällt ein wenig Futter für eine Folge ab.
            Je nachdem was ihr für Musik macht, sind da die Anforderungen ziemlich unterschiedlich. Wenn du z.B. Schlagzeug oder E-Gitarre aufnehmen willst, wirst du ein SM57 brauchen. Wenn du z.B. hauptsächlich Vocal-Aufnahme machst, brauchst du einen möglichst guten Monokanalzug, also ein Großmembran-Kondenser und einen richtig guten Preamp, am besten mit Kompressor/EQ.
            Ansonsten vergiss nicht die Akustik (sehr wichtig) und ein paar gute Monitorboxen.
            Viel Erfolg!
            Götz

  11. Hi Götz,
    Ich bin so begeistert von deinen DIY Videos, das ich mir gleich ein Arduino geholt habe. Mein Projekt ist mir ein Foot Controller zum Steuern von meinem Keyboard über MIDI zu bauen.
    Jetzt meine Frage, wie sende ich Program Change Meldungen z.B PC 86 und Bank Select MSB (CC#0),Bank Select LSB (CC#32).

    Hier so wie ich es mir vorstelle:

    int taste1 = LOW;
    int taste1Alt = LOW;

    void setup(){
    Serial.begin(9600); //31250 = Midi 9600 = USB Midi
    pinMode(2,INPUT);

    }

    void loop() {
    taste1 = digitalRead(2);

    if (taste1 == HIGH && taste1Alt == LOW) {
    Serial.write(207); //ProgrammChange Midi Kanal16 = 11001111
    Serial.write(86); //PC86 Fill 1
    Serial.write(0);
    taste1Alt = taste1;
    }
    }

    Währe cool wenn du mir dabei Helfen könntest 🙂
    zum Schluß sollen es mal min.Taster und 2 Potis(ExpresionsPedale) werden.

    Ps kann ich auch 50KOhm Potis benutzen oder müssen es 10KOhm sein.

    Gruß Bogy

    1. Hallo Boy und danke für Dein Lob!
      Im Grunde hast du dir deine Frage schon fast selbst beantwortet. Bank-Change-Befehle werden nicht von allen Geräten gleich behandelt, aber oft ist es tatsächlich so, wie du geschrieben hast eine Kombi aus CC0 und CC32. Ob dein Synth das so empfangen kann, kannst du im Handbuch nachlesen – dort müsste es einen MIDI Implementation Chart geben. Manchmal braucht der Bank-Change nachfolgend einen Programm-Change, manchmal nicht.

      Einfachster Fall:
      Serial.write(176); // Control Change MIDI Kanal 1
      Serial.write(0); // Bank Change MSB
      Serial.write(1); // Bank 2, also die Programme 129-256
      // Serial.write(176); kannst du meist weglassen; google mal „MIDI running status“
      Serial.write(32); // Bank Change LSB
      Serial.write(20); // Programm Nummer 21 + Bank 2 = Programmchange auf Preset 147

      50k Potis können funktionieren, werden aber vermutlich unzuverlässige Werte produzieren oder zittern. 10K (notfalls 20K) sind ideal.

  12. Hallo Götz
    ich bin ein weiterer Begeisterter Verfolger deiner Videos.
    Jetzt hab ich mir alles besorgt, Sunfounder Mega & Co, und den Buttons Part nach gebaut.
    Jetzt meine Frage:
    Warum erkennt Abelton das Gerät nicht bzw. warum kommt kein MIDI Signal dort an ??
    Ich habe Hairles Midi um Signale zu testen da kommt
    +4.418 – Error: got unexpected data byte 0x0.

    Kein Ahnung was das heist

    Lg

    Kai Kyas

  13. OK ein Teil hab ich hin bekommen.
    Folge 4 ich hatte den Hairles Midi falsch eingestellt.

    Was ich nicht hin bekommen habe…
    Ableton & Controller erkennen das System noch nicht.

    Wenn ich da weiter kommen würde hätte ich eine Große Hürde geschafft.

    Ich bin mit Spannung weiter dabei 🙂

    LG
    Kai

  14. Hallo Götz, vielen Dank zunächst einmal für dieses tolle Tutorial! Ich habe nun auch begonnen, mir einen Midi-Controller zu bauen. Es sind 9 Taster (solche hier: http://www.reichelt.de/Drucktaster-Druckschalter/T-250A-WS/3/index.html?&ACTION=3&LA=2&ARTICLE=19988&GROUPID=3277&artnr=T+250A+WS ), die ich jeweils mit GND und direkt (ohne zusätzliche Widerstände) per INPUT_PULLUP mit den digitalen Pins meines Arduino Pro Micro (so einer hier: https://www.sparkfun.com/products/12640 ) verbunde habe.

    Ich habe deinen Code etwas angepasst und bekomme in der Arduino-Software im Seriellen Monitor auch angezeigt, dass etwas passiert, Jedoch habe ich 2 Probleme:

    Zum einen sieht es so aus, als würden die Buttons die ich habe meistens 2 Signale von sich geben, beim Drücken und beim Loslassen. Wenn nicht sogar noch mehr.

    Außterdem scheitere ich momentan daran, z.B. über Hairless-Midi und LoopMidi meinen Controller auch in einer DAW zu nutzen. Wenn Hairless Midi läuft (manchmal aus irgendwelchen Gründen tut es das nicht) und ich die Buttons drücke, kommen immer solche Fehlermeldungen:

    +9.014 – Warning: got a status byte when we were expecting 2 more data bytes, sending possibly incomplete MIDI message 0x81
    +9.014 – Serial In: Ch 2: Note %2 off velocity %3
    +9.014 – Serial In: Ch 1: Note 40 on velocity 127
    +9.014 – Warning: got a status byte when we were expecting 1 more data bytes, sending possibly incomplete MIDI message 0x90

    Wähle ich bei MIDI OUT Microsoft GS Wavetable Synth aus, dann höre ich ein Piano, mit recht großer Latenz (grob geschätze halbe Sekunde).
    Setze ich MIDI OUT und MIDI IN auf loopMIDI Port, den ich zuvor gestartet habe, empfange ich in meiner DAW (in meinem Fall Cakewalk Sonar Platinum) leider nichts.

    Hier ist auch einmal der Code, den ich als absoluter Laie etwas angepasst habe.

    Für Hilfe wäre ich wirklich mehr als dankbar!

    int button2 = LOW;
    int button2Old = LOW;
    int button3 = LOW;
    int button3Old = LOW;
    int button4 = LOW;
    int button4Old = LOW;
    int button5 = LOW;
    int button5Old = LOW;
    int button6 = LOW;
    int button6Old = LOW;
    int button7 = LOW;
    int button7Old = LOW;
    int button8 = LOW;
    int button8Old = LOW;
    int button9 = LOW;
    int button9Old = LOW;
    int button10 = LOW;
    int button10Old = LOW;

    void setup() {
    Serial.begin(9600);
    pinMode(2, INPUT_PULLUP);
    pinMode(3, INPUT_PULLUP);
    pinMode(4, INPUT_PULLUP);
    pinMode(5, INPUT_PULLUP);
    pinMode(6, INPUT_PULLUP);
    pinMode(7, INPUT_PULLUP);
    pinMode(8, INPUT_PULLUP);
    pinMode(9, INPUT_PULLUP);
    pinMode(10, INPUT_PULLUP);
    }

    void loop(){
    button2 = digitalRead(2);

    if (button2 == HIGH && button2Old == LOW) {
    Serial.write(144); // 1001 0000 = Note On Kanal 1
    Serial.write(36); //Note C1
    Serial.write(127);
    button2Old = button2;
    }
    if (button2 == LOW && button2Old == HIGH) {
    Serial.write(144); // 1001 0000 = Note On Kanal 1
    Serial.write(36); //Note C1
    Serial.write(0-127);
    button2Old = button2;
    }

    button3 = digitalRead(3);

    if (button3 == HIGH && button3Old == LOW) {
    Serial.write(144);
    Serial.write(38);
    Serial.write(127);
    button3Old = button3;
    }
    if (button3 == LOW && button3Old == HIGH) {
    Serial.write(144);
    Serial.write(38);
    Serial.write(0-127);
    button3Old = button3;
    }

    button4 = digitalRead(4);

    if (button4 == HIGH && button4Old == LOW) {
    Serial.write(144);
    Serial.write(40);
    Serial.write(127);
    button4Old = button4;
    }
    if (button4 == LOW && button4Old == HIGH) {
    Serial.write(144);
    Serial.write(40);
    Serial.write(0-127);
    button4Old = button4;
    }

    button5 = digitalRead(5);

    if (button5 == HIGH && button5Old == LOW) {
    Serial.write(144);
    Serial.write(41);
    Serial.write(127);
    button5Old = button5;
    }
    if (button5 == LOW && button5Old == HIGH) {
    Serial.write(144);
    Serial.write(41);
    Serial.write(0-127);
    button5Old = button5;
    }

    button6 = digitalRead(6);

    if (button6 == HIGH && button6Old == LOW) {
    Serial.write(144);
    Serial.write(43);
    Serial.write(127);
    button6Old = button6;
    }
    if (button6 == LOW && button6Old == HIGH) {
    Serial.write(144);
    Serial.write(43);
    Serial.write(0-127);
    button6Old = button6;
    }

    button7 = digitalRead(7);

    if (button7 == HIGH && button7Old == LOW) {
    Serial.write(144);
    Serial.write(45);
    Serial.write(127);
    button7Old = button7;
    }
    if (button7 == LOW && button7Old == HIGH) {
    Serial.write(144);
    Serial.write(45);
    Serial.write(0-127);
    button7Old = button7;
    }

    button8 = digitalRead(8);

    if (button8 == HIGH && button8Old == LOW) {
    Serial.write(144);
    Serial.write(47);
    Serial.write(127);
    button8Old = button8;
    }
    if (button8 == LOW && button8Old == HIGH) {
    Serial.write(144);
    Serial.write(47);
    Serial.write(0-127);
    button8Old = button8;
    }

    button9 = digitalRead(9);

    if (button9 == HIGH && button9Old == LOW) {
    Serial.write(144);
    Serial.write(48);
    Serial.write(127);
    button9Old = button9;
    }
    if (button9 == LOW && button9Old == HIGH) {
    Serial.write(144);
    Serial.write(48);
    Serial.write(0-127);
    button9Old = button9;
    }

    button10 = digitalRead(10);

    if (button10 == HIGH && button10Old == LOW) {
    Serial.write(144);
    Serial.write(50);
    Serial.write(127);
    button10Old = button10;
    }
    if (button10 == LOW && button10Old == HIGH) {
    Serial.write(144);
    Serial.write(50);
    Serial.write(0-127);
    button10Old = button10;
    }
    }

  15. Hallo,

    ich baue gerade eine Orgel, benutze einen Arduino Mega, mit diesen Sketch nur mit mehrere Taster zur ansteuerung.
    Habe mir auch diesen „Kleinhack“ gemacht, funktoniert alles prima.
    Nun hatte ich einige “ Button“ die mit einer Controll LED funktionieren.
    Also einmal Taste drücken, LED geht an, noch mal taste drücken, LED geht aus.
    Leider bekomme ich das nicht hin.
    Kannst du mir anhand eines beispiels ein Code mit einsetzen, damit das funktioniert, gegebenen falls auch als Blinkende LED.
    Ich bedanke mich im vorraus.

    1. Hallo Wolfgang, schau mal in den Code der letzten Folge: http://goetzmd.de/diy/diy-midi-controller/schaltplan-und-arduino-sketch-diy-midi-controller-finale
      Hier mache ich genau das mit den beiden Tastern: Einmal drücken sendet einen Befehl und schaltet die LED an, ein zweites Mal drücken sendet einen anderen Befehl und schaltet die LED wieder aus.

      1. Hi Götz Da du in deinen Midicontroller nur Buttons und Potis benutzt
        würde ich gerne wissen wie sieht denn ein Sketch mit Schaltern aus.
        Ich würde gerne in meinen Midicontroller auch Schalter einbauen.

        1. Hallo Reiner,
          wie du einzelne Noten senden kannst, findest du ja in diesem Beispiel. Wenn du in den Sketch zum fertigen Projekt schaust, findest du dort auch zwei beleuchtete Buttons, die als Umschalter arbeiten und je nach Zustand einen unterschiedlichen MIDI-Befehl senden können. Wenn du sehr viele Buttons anschließen willst, schau dir mal das Arduino ShiftIn Tutorial an: https://www.arduino.cc/en/Tutorial/ShiftIn
          VG
          Götz

  16. Hallo Götz,

    besten Dank für das echt gute Tutorial. Als absoluter Einsteiger kommen ich Schritt-für-Schritt voran.

    Ich möchte ein sketch für ein Blasinstrument schreiben, mit ca. 8-10 Tastern, der bei verschiedenen Tastenkonstellationen entsprechende MIDI-Befehle sendet. Mit einer logischen Verknüpfung (an den Digitaleingängen) und der analogen Ausgabe ohne MIDI funktioniert das gut. Dort brauche ich nur am Ende des Programms in ´noTone´ zu setzen, um einen Ton zu stoppen. Allerdings komme ich jetzt bei der Programmierung für MIDI nicht voran. Du beschreibst die Abfrage eines Buttons mit einer MIDI-Ausgabe. Am Ende des sketch kommt es dann zu diesem Befehl: … Serial.write(0) und `tasteAlt = taste;, der zum Stopp des Tones führt. Bei einer Abfrage von 8 Tastern (die bei einer entsprechenden Konstellation dann einen Befehl zum Beginn eines Notenwertes auslösen), habe ich es mit kombinierten 8 Werten zu tun. Wie kann ich da die MIDI-Ausgabe stoppen? Vielleicht hast Du ja spontan eine Idee zur Umsetzung des Projektes (vielleicht auch eine andere Vorgehensweise, z.B. Widerstandsnetzwerk mit 8 Tastern an einem Analogeingang oder so?)?

    Schöne Grüße Dirk

    1. Danke Dirk!

      Ich vermute mal, du meinst etwa folgendes:
      Button 1 -> Note 1
      Button 2 -> Note 2
      Button 1+2 -> Note 3
      Und das ganze dann natürlich mit 8 Buttons, könnte also maximal 265 Kombinationen ergeben. Richtig?

      So spontan hätte ich folgende Gedanken: Widerstandsnetzwerk würde gehen, du könntest auch neben deine Buttons ein Shift-Register platzieren um diese über weniger Leitungen abzufragen. In jedem Fall müsstest du im Arduino ja irgendwie hinterlegen, was passiert, wenn welche Kombination an Buttons gedrückt wird. Das ginge über if-Bedingungen, spontan würde ich sagen, weise jedem Button einen Wert zu:
      Button 1 = 1
      Button 2 = 2
      Button 3 = 4
      Button 4 = 8
      Button 5 = 16 usw.
      Dann schreibst du ein kleines Programm, welches einfach die Werte der Buttons zusammenrechnet (z.B. Buttons 1+3+5 -> 1+4+16=21) und dann definierst du über switchCase (alternativ if-Statements) welche Note gesendet wird. Den Notenwert legst du in einer Variable ab, damit du bei der nächsten Note diesen Wert vorher als NoteOn mit Velocity 0 sendest, damit die vorherige Note beendet wird.

      Viel Erfolg
      GÖtz

  17. Hier ist mal der Sketch für die Analogausgabe (gekürzter sketch für 3 Taster und für 2 Töne):

    int i1 = 12; //Taste1 an Pin 12
    int i2 = 11; //Taste2 an Pin 11

    int i8 = 5; //Taste8 an Pin 5
    void setup(){
    pinMode(i1, INPUT_PULLUP); digitalWrite(i1, HIGH);
    pinMode(i2, INPUT_PULLUP); digitalWrite(i2, HIGH);
    ….
    pinMode(i8, INPUT_PULLUP); digitalWrite(i8, HIGH);
    }
    void loop(){
    if (digitalRead(i1)==LOW && digitalRead(i2)==HIGH && digitalRead(i3)==HIGH && digitalRead(i4)==HIGH && digitalRead(i5)==HIGH && digitalRead(i6)==HIGH && digitalRead(i7)==HIGH && digitalRead(i8)==LOW){
    tone(9, 440); //Ton …
    }
    else if (digitalRead(i1)==HIGH && digitalRead(i2)==LOW && digitalRead(i3)==HIGH && digitalRead(i4)==HIGH && digitalRead(i5)==HIGH && digitalRead(i6)==HIGH && digitalRead(i7)==HIGH && digitalRead(i8)==LOW){
    tone(9, 200); //Ton ….
    }
    else {
    noTone(9);
    }
    }

Kommentar verfassen