Arduino, Sensoren und MIDI

16 Schritt:Schritt 1: Seriell-zu-MIDI-Konverter Schritt 2: MIDI-Protokoll Schritt 3: Erstellen von MIDI mit Arduino Schritt 4: Arduino analoge Eingänge und MIDI- Schritt 5: Lösen Sie eine MIDI-Note mit einem Knopf Schritt 6: Arduino und Tilt Switch Schritt 7: Arduino und Light Sensitive Widerstände Schritt 8: Arduino und Drucksensor Schritt 9: Arduino und Flex-Sensor Schritt 10: Arduino und Piezo Sensor Schritt 11: Pitchbend MIDI-Befehle mit Arduino Schritt 12: Arduino und Proximity (Ping) Sensor Schritt 13: Arduino und Touch-Screen- Schritt 14: Sensoren zum Selberbauen Schritt 15: Sonstige Sensoren für Arduino und Projektideen Schritt 16: Arduino MIDI IN

Arduino, Sensoren und MIDI

Nun, da Sie sich auf die Beschleunigung mit Ein- und Ausgängen Arduino sind, wird diese Instructable geben Ihnen alles, was Sie brauchen, um mit Hilfe von Sensoren auslösen MIDI-Noten von Arduino loszulegen. Dieser Beitrag ist die letzte Rate in einer Reihe von Workshops ich führte Frauen-Audio Mission . Die ersten beiden Klassen sind Intro zu Arduino und Arduino Arbeiten mit Ein- und Ausgänge.
Liste der Einzelteile:
(1x) Arduino Uno Amazon oder Sie können eine bis auf lokaler abholen Radioshack
(1x) USB-Kabel Amazon
(1x) Steckbrett Amazon
(1x) Schaltdrähte Amazon
(1x) 220Ohm-Widerstände Digikey CF14JT220RCT-ND
(1x) geleitet Digikey C503B-RCN-CW0Z0AA1-ND

(1x) 10kOhm Widerstand Digikey CF14JT10K0CT-ND
(1x) Takt-Taste Digikey 450-1650-ND
(1x) Neigungsschalter Adafruit 173
(1x) 10kOhm Potentiometer Digikey PDB181-K420K-103B-ND
(1x) lichtempfindlichen Widerstand Digikey PDV-P8103-ND
(1x) 33kOhm-Widerstand Digikey 33KQBK-ND
(1x) 1MOhm Widerstand Digikey 1.0MQBK-ND
(1x) Piezosensor Sparkfun SEN-10293

Schritt 1: Seriell-zu-MIDI-Konverter

  1. Serien-
    Arduino, Sensoren und MIDI

    Arduino, Sensoren und MIDI

    In dieser Klasse werden wir mit der Ardiuno die USB-Verbindung zu senden Serielle Nachrichten an Sie Computer, dann werden wir eine Anwendung laufen wie Hairless MIDI Dazu ist die Serien-Nachrichten an MIDI und sie an andere Anwendungen auf Ihrem Computer (Ableton konvertieren, Garageband, etc). Ich wählte dieses Software-Lösung, weil es am einfachsten und günstigsten Setup für eine ganze Klasse, können Sie auch einen Draht verwenden einen 5-poligen MIDI Stecker direkt in andere MIDI-Instrumente anschließen. Es gibt ein paar Dinge, die Sie müssen sich bewusst sein, mit diesem Setup:
    Seien Sie sicher, dass die Baudrate Sie in Serial.begin () in Ihrem Arduino Skizze angeben ist die gleiche Nummer, unter Hairless MIDI ausgewählt >> Einstellungen >> Baudrate (Ich habe 9600 so habe ich den Befehl Serial.begin (9600) in allen Beispiel Arduino Skizzen finden Sie in den ersten beiden Bilder oben). Wenn Sie sich bis zum FAQ zu blättern, müssen Sie die Baudrate auf 31250 gesetzt, aber wenn Sie über USB-Verbindung zu einer Seriell-zu-MIDI-Anwendung, die Sie verwenden können, was auch immer Baudrate Sie möchten.
    Um Hairless MIDI verwenden, müssen Sie Ihre Karte (so etwas wie usbmodemfd121) vom Serial Port Menü und wählen Sie den MIDI-Kanal, den Sie möchten, senden oder empfangen MIDI / nach. Stellen Sie sicher, dass Sie den gleichen MIDI-Kanal in den Einstellungen, was auch immer andere MIDI-Anwendungen, die Sie auf Ihrem Computer ausgeführt werden ausgewählt haben. Ich schickte meine MIDI zu IAC-Treiber Bus 1, und dann Setup Garage Band oder Ableton MIDI auf dieser gleichen Kanal empfangen. Wenn Sie MIDI-Ausgabeoptionen in Hairless MIDI nicht sehen, scrollen Sie nach unten, um die FAQ und Problembehandlung Setup.
    Sie können die Arduino nicht programmieren, während er an Hairless MIDI angeschlossen ist, da die beiden Anwendungen werden im Wettbewerb um den gleichen Port (siehe den Fehler in dem zweiten Bild). Eine schnelle Möglichkeit, dies ohne Hairless MIDI jedes Mal, wenn Sie Ihren Code ändern möchte aufhören zu umgehen ist, um einen anderen seriellen Port vom Hairless MIDI-Schnittstelle wählen, laden Sie Ihre neue Arduino-Code, und legen Sie den Serial Port in Hairless MIDI zurück zu die richtige ist.

Schritt 2: MIDI-Protokoll


  1. Befehle und Daten Bytes MIDI-Meldungen werden aus zwei Komponenten zusammen. Das Kommando-Byte teilt dem MIDI-Instrument, welche Art von Nachricht, die gesendet und auf dem MIDI-Kanal und die nachfolgenden Daten-Byte (s) speichern die tatsächlichen Daten. Zum Beispiel: ein Befehlsbyte kann ein MIDI-Instrument zu sagen, dass sie Informationen über eine Note, und die folgende Datenbytes beschreibt, welche Note und wie laut. Ein Kommando-Byte kann auch ein MIDI-Instrument zu sagen, dass sie gehen, um Informationen über Pitchbend senden, dann würde die folgenden Datenbytes wie viel Pitchbend beschreiben. Ein Kommando-Byte und die Datenbytes folgenden es bilden eine "MIDI-Meldung".
    Ein Byte ist ein Datentyp (andere Datentypen, die wir bisher gesehen sind int , boolean und lange ). Bytes store positive ganze Zahlen zwischen 0 und 255 MIDI-Nachrichten werden aus einer Reihe von Bytes gemacht, und sie können auf der Grundlage ihrer Wert zu verstehen, was sie bedeuten, decodiert werden.
    Hier ist eine Liste von gemeinsamen Befehlsbytes in ihrer dezimal (Basis zehn) Form:
    Hinweis Aus = 128
    Hinweis: Auf = 144
    Pitchbend = 224
    Befehlsbytes immer größer sind als 127, und Datenbytes immer zwischen 0 und 127, in der Tat ist, wie ein MIDI-Instrument kann den Unterschied zwischen einem Befehlsbyte und einem Datenbyte zu berichten. Hier ist, wie wir eine MIDI-Nachricht, auf Middle C mit hoher Lautstärke zu senden:
    144, 60, 127
    Die erste Zahl, 144, ist das Kommando-Byte, das MIDI-Instrument, dass dieser MIDI-Nachricht ist eine Note On Nachricht erzählt. Die zweite Zahl, 60, ist ein Daten-Byte. Das erste Datenbyte in einer MIDI-Note-On-Nachricht "Hinweis" - diese Note On Befehl schaltet MIDI-Note 60 (Middle C, können Sie einen Merkzettel / MIDI Konvertierungen finden Arduino, Sensoren und MIDI


    ). Die letzte Zahl ist auch ein Daten-Byte, das zweite Datenbyte in einer MIDI-Note-On-Nachricht ist "Geschwindigkeit", die verwendet wird, um die Lautstärke einer Note zu steuern. Da Datenbytes zwischen 0 und 127, 127 ist die maximale Lautstärke für eine Notiz.
    Jede MIDI-Note startet mit einer Note-On-Nachricht und endet mit einer Note Off Nachricht. Einige perkussive Instrumente klingen wie sie ausgeschaltet haben, wenn Sie sie halten für eine lange Zeit, aber das wird nicht wirklich weg, bis Sie eine Notiz Nachricht abzuschicken. Es ist wichtig, sich daran zu erinnern, um eine Notiz ausschalten, bevor Sie versuchen, es wieder einzuschalten, um widersprüchliche Ergebnisse zu vermeiden. Es gibt zwei Möglichkeiten, um eine MIDI-Note ausschalten, ist diese erste mit einer Note-Off-Befehl ein:
    128, 60, 0
    Dieser Befehl schaltet Anmerkung 60 ab, es beginnt mit dem Kommando-Byte für Note off setzt note = 60, und die Geschwindigkeit = 0 (Geschwindigkeit ist in der Regel nicht sehr auffällig für Note Off, was auch immer Nummer, die Sie wählen ist in Ordnung wollen). Sie können auch drehen Sie eine Notiz aus, indem er eine Note On Nachricht mit Velocity = 0:
    144, 60, 0
    Dies ist eine gemeinsame Vorgehensweise in MIDI (aus meiner Erfahrung), so ist es, wie wir mit Note Off zu tun haben in dieser Klasse.

    Wenn Sie Interesse an weiteren Informationen über MIDI-Protokoll, binär, und Bits sind, lesen Sie in dieser Tabelle und in dieser Tabelle .

Schritt 3: Erstellen von MIDI mit Arduino


  1. Den folgenden Code auf das Arduino Laden stellt sich MIDI-Note 60 (mittleres C) auf, wartet 300 ms, dann schaltet sie aus und wartet auf weitere 200 ms.

      Byte NoteOn = 144; // Hinweis auf Befehl
    
     Leere setup () {
       Serial.begin (9600);
     }
    
     Leere Schleife () {
       Midimessage (NoteOn, 60, 100); // abbiegen beachten Sie auf
       Verzögerung (300); // hold Hinweis für 300ms
       Midimessage (NoteOn, 60, 0); // drehen Note aus (beachten Sie auf mit der Geschwindigkeit 0)
       Verzögerung (200); // 200ms warten, bis Auslösung nächste Note
     }
    
     // Senden MIDI-Meldung
     Leere Midimessage (byte Befehl Byte data1, Byte data2) {
       Serial.write (Befehl);
       Serial.write (data1);
       Serial.write (Daten2);
     } 

    In dieser Skizze habe ich eine Hilfsfunktion namens Midimessage, dass ein Befehl übernimmt die beiden Daten-Bytes und sendet sie aus der Arduino USB-Verbindung mit Hilfe Serial.write () . Serial.write ist wie Serial.print, aber es wandelt, was drin ist es, um binäre bevor wir es versenden.
    Versuchen Umschreiben der Skizze, eine Reihe von Noten zu spielen, Radtouren durch MIDI-Noten von 50-79, Drehen jede Note auf und dann ab:

      Byte NoteOn = 144; // Hinweis auf Befehl
    
     Leere setup () {
       Serial.begin (9600);
     }
    
     Leere Schleife () {
       für (byte note = 50; note <80; beachten Sie, ++) {// von Note 50 (D3) zu beachten, 79 (G5)
         Midimessage (NoteOn, note, 100); // schalten beachten Sie auf
         Verzögerung (300); // hold Hinweis für 300ms
         Midimessage (NoteOn, note, 0); // drehen Note aus (beachten Sie auf mit der Geschwindigkeit 0)
         Verzögerung (200); // 200ms warten, bis Auslösung nächste Note
       }
     }
    
     // Senden MIDI-Meldung
     Leere Midimessage (byte Befehl Byte data1, Byte data2) {
       Serial.write (Befehl);
       Serial.write (data1);
       Serial.write (Daten2);
     } 

Schritt 4: Arduino analoge Eingänge und MIDI-

  1. Arduino, Sensoren und MIDI

    Lassen Sie verdrahten ein Potentiometer zur analogen pin 0 und verwenden Sie die Daten aus, um die Tonhöhe eines MIDI-Note zu steuern:

      Byte NoteOn = 144; // Hinweis auf Befehl
     int potPin = A0;
    
     Leere setup () {
       Serial.begin (9600);
     }
    
     Leere Schleife () {
      
       int potVal = analogRead (potPin); // Daten vom Potentiometer lesen
      
       // Wir müssen die Potentiometer Daten skalieren, um zwischen 0 und 127 passen (dies ist der Bereich der MIDI-Noten)
       Byte note = map (potVal, 0, 1023, 0, 127);
      
       Midimessage (NoteOn, note, 100); // schalten beachten Sie auf
       Verzögerung (300); // hold Hinweis für 300ms
       Midimessage (NoteOn, note, 0); // drehen Note aus (beachten Sie auf mit der Geschwindigkeit 0)
       Verzögerung (200); // 200ms warten, bis Auslösung nächste Note
     }
    
     // Senden MIDI-Meldung
     Leere Midimessage (byte Befehl Byte data1, Byte data2) {
       Serial.write (Befehl);
       Serial.write (data1);
       Serial.write (Daten2);
     } 

    Versuchen Sie nun mit dem Potentiometer, um die Geschwindigkeit eines MIDI-Note zu steuern:

      Byte NoteOn = 144; // Hinweis auf Befehl
     int potPin = A0;
    
     Leere setup () {
       Serial.begin (9600);
     }
    
     Leere Schleife () {
      
       int potVal = analogRead (potPin); // Daten vom Potentiometer lesen
      
       // Wir müssen die Potentiometer Daten skalieren, um zwischen 0 und 127 passen (dies ist der Bereich der MIDI-Noten)
       Byte-Geschwindigkeit = map (potVal, 0, 1023, 0, 127);
       Byte note = 60;
      
       Midimessage (NoteOn, note, Geschwindigkeit); // wiederum Notiz auf
       Verzögerung (300); // hold Hinweis für 300ms
       Midimessage (NoteOn, note, 0); // drehen Note aus (beachten Sie auf mit der Geschwindigkeit 0)
       Verzögerung (200); // 200ms warten, bis Auslösung nächste Note
     }
    
     // Senden MIDI-Meldung
     Leere Midimessage (byte Befehl Byte data1, Byte data2) {
       Serial.write (Befehl);
       Serial.write (data1);
       Serial.write (Daten2);
     } 

    Das wird klingen unterschiedlich, je nachdem, welche Art von Gerät Sie Ihr MIDI angeschlossen an, aber in der Regel sollte es lauter klingen. Der Klang kann auch schärfer sein, als ob Sie auf Tastenfest oder bläst in ein Blasinstrument mit viel Kraft.

Schritt 5: Lösen Sie eine MIDI-Note mit einem Knopf

  1. einfachen Knopf debounce Code
    Verwenden der diese debounce Code aus der ersten Klasse (man könnte auch verwenden, während die verwendet millis (), um Zeit zu halten), verdrahten Sie eine Taste, um digitale Stift 7 und es verwenden, um eine MIDI-Note auslösen:

      Byte NoteOn = 144; // Hinweis auf Befehl
    
     int buttonPin = 7;
     boolean current = LOW; // stroage zur aktuellen Tastenzustand
     boolean lastState = LOW; // Speicher für letzten Tastenzustand
    
     Leere setup () {
       pinMode (buttonPin, INPUT); // dieses Mal werden wir das Pin als Eingang eingestellt
       Serial.begin (9600); // initialisieren Serielle Verbindung
     }
    
     Leere Schleife () {
       currentstate = digitalRead (buttonPin);
       if (current == HOCH && lastState == LOW) {// wenn Taste gerade gedrückt wurde
         Midimessage (NoteOn, 60, 127); // auf mit 127 Geschwindigkeit drehen Anmerkung 60
         Verzögerung (2); // Rohform der Taste Entprellung
       } Else if (current == LOW && lastState == HIGH) {
         Midimessage (NoteOn, 60, 0); // auszuschalten Anmerkung 60
         Verzögerung (2); // Rohform der Taste Entprellung
       }
       lastState = current;
     }
    
     // Senden MIDI-Meldung
     Leere Midimessage (byte Befehl Byte data1, Byte data2) {
       Serial.write (Befehl);
       Serial.write (data1);
       Serial.write (Daten2);
     } 

    In dieser Skizze, jedesmal, wenn die Taste gedrückt wird senden wir eine Note On Nachricht, und jedesmal, wenn die Taste losgelassen wird, gesendet werden wir eine Note Off. Versuchen Sie nun, das Hinzufügen in dem Potentiometer (A0 verbunden), um die Tonhöhe der Note steuern:

      Byte NoteOn = 144; // Hinweis auf Befehl
     Byte-Note; // Speicher für aktuell wiederNote
    
     int buttonPin = 7;
     int potPin = A0;
     boolean current = LOW; // stroage zur aktuellen Tastenzustand
     boolean lastState = LOW; // Speicher für letzten Tastenzustand
    
     Leere setup () {
       pinMode (buttonPin, INPUT); // dieses Mal werden wir das Pin als Eingang eingestellt
       Serial.begin (9600); // initialisieren Serielle Verbindung
     }
    
     Leere Schleife () {
       currentstate = digitalRead (buttonPin);
      
       if (current == HOCH && lastState == LOW) {// wenn Taste gerade gedrückt wurde
        
         int currentPotVal = analogRead (potPin);
         beachten = map (currentPotVal, 0, 1023, 0, 127);
      
         Midimessage (NoteOn, note, 127); // schalten beachten Sie auf mit 127 Geschwindigkeit
         Verzögerung (2); // Rohform der Taste Entprellung
       } Else if (current == LOW && lastState == HIGH) {
         Midimessage (NoteOn, note, 0); // drehen Note aus
         Verzögerung (2); // Rohform der Taste Entprellung
       }
       lastState = current;
     }
    
     // Senden MIDI-Meldung
     Leere Midimessage (byte Befehl Byte data1, Byte data2) {
       Serial.write (Befehl);
       Serial.write (data1);
       Serial.write (Daten2);
     } 

    Jetzt können wir noch ein paar Notizen in der Mischung hinzufügen, spielt diese Skizze eine drei note Phrase auf jedem Tastendruck. Sie können die Basisnote mit dem Potentiometer ändern:

      Byte NoteOn = 144; // Hinweis auf Befehl
     Byte-Note; // Speicher für aktuell wiederNote
    
     int buttonPin = 7;
     int potPin = A0;
     boolean current = LOW; // stroage zur aktuellen Tastenzustand
     boolean lastState = LOW; // Speicher für letzten Tastenzustand
    
     Leere setup () {
       pinMode (buttonPin, INPUT); // dieses Mal werden wir das Pin als Eingang eingestellt
       Serial.begin (9600); // initialisieren Serielle Verbindung
     }
    
     Leere Schleife () {
       currentstate = digitalRead (buttonPin);
      
       if (current == HOCH && lastState == LOW) {// wenn Taste gerade gedrückt wurde
        
         int currentPotVal = analogRead (potPin);
         beachten = map (currentPotVal, 0, 1023, 0, 127);
         int noteLength = 200;
         Byte noteVelocity = 127;
      
         Midimessage (NoteOn, note, noteVelocity); // Basisnote
         Verzögerung (noteLength);
         Midimessage (NoteOn, note, 0); // drehen Note aus
         Midimessage (NoteOn, note + 7, noteVelocity); // fünften
         Verzögerung (noteLength);
         Midimessage (NoteOn, note + 7, 0); // drehen Note aus
         Midimessage (NoteOn, note + 12, noteVelocity); // Oktave
         Verzögerung (noteLength);
         Midimessage (NoteOn, note + 12, 0);
       }
      
       lastState = current;
     }
    
     // Senden MIDI-Meldung
     Leere Midimessage (byte Befehl Byte data1, Byte data2) {
       Serial.write (Befehl);
       Serial.write (data1);
       Serial.write (Daten2);
     } 

    Schließlich können wir ein zu verwenden , während Schleife, um das Arpeggio so lange wir drücken Sie die Taste weiter. While-Schleifen sind im Grunde loopable, wenn Aussagen. Wenn das Argument in Klammern der while-Schleife, um wahr ausgewertet, werden die Befehle innerhalb der while-Schleife ausgeführt. Am Ende der while-Schleife, prüft das Arduino, um zu sehen, wenn das Argument innerhalb der While-Schleifen der Klammern ist wieder wahr. Wenn es immer noch wahr, die while-Schleife führt alle Befehle in der culy wieder verspannt, für immer so weitergeht, bis das Argument in Klammern der while-Schleife den Wert false. In dem folgenden Beispiel verwende ich die while-Schleife, um weiter spielen die drei note Phrase, solange digitalRead (buttonPin) == HOCH.

      Byte NoteOn = 144; // Hinweis auf Befehl
     Byte-Note; // Speicher für aktuell wiederNote
    
     int buttonPin = 7;
     int potPin = A0;
     boolean current = LOW; // stroage zur aktuellen Tastenzustand
     boolean lastState = LOW; // Speicher für letzten Tastenzustand
    
     Leere setup () {
       pinMode (buttonPin, INPUT); // dieses Mal werden wir das Pin als Eingang eingestellt
       Serial.begin (9600); // initialisieren Serielle Verbindung
     }
    
     Leere Schleife () {
       currentstate = digitalRead (buttonPin);
      
       if (current == HOCH && lastState == LOW) {// wenn Taste gerade gedrückt wurde
        
         int currentPotVal = analogRead (potPin);
         beachten = map (currentPotVal, 0, 1023, 0, 127);
         int noteLength = 200;
         Byte noteVelocity = 127;
        
         while (digitalRead (buttonPin) == HIGH) {// Solange die Taste gedrückt wird, wiederholen Sie den Arpeggio-
           Midimessage (NoteOn, note, noteVelocity); // Basisnote
           Verzögerung (noteLength);
           Midimessage (NoteOn, note, 0); // drehen Note aus
           Midimessage (NoteOn, note + 7, noteVelocity); // fünften
           Verzögerung (noteLength);
           Midimessage (NoteOn, note + 7, 0); // drehen Note aus
           Midimessage (NoteOn, note + 12, noteVelocity); // Oktave
           Verzögerung (noteLength);
           Midimessage (NoteOn, note + 12, 0);
         }
       }
      
       lastState = current;
     }
    
     // Senden MIDI-Meldung
     Leere Midimessage (byte Befehl Byte data1, Byte data2) {
       Serial.write (Befehl);
       Serial.write (data1);
       Serial.write (Daten2);
     } 

Schritt 6: Arduino und Tilt Switch


  1. Ein Neigungsschalter ist ein mechanischer Schalter, der geöffnet ist, wenn Sie es halten in der einen Richtung und geschlossen, wenn Sie es Flip upside. Es hat eine kleine Metallkugel auf der Innenseite davon, die um rollen kann, wenn man es in einer bestimmten Orientierung zu halten, erzeugt die Kugel eine elektrische Verbindung zwischen beiden Seiten des Schalters.
    Der Kippschalter hat zwei Leitungen aus der es kommen, können Sie die Drucktaste aus dem Kreislauf herausziehen und ersetzen Sie es mit einem Neigungsschalter, Ausrichtung der Schalter in der Schaltung (long vs kurze Liefer) spielt keine Rolle.

Schritt 7: Arduino und Light Sensitive Widerstände

  1. lichtempfindlichen Widerstand
    Ein lichtempfindlicher Widerstand (LSR) ist ein Typ des variablen Widerstands, die auf Licht reagiert. Die LSRs ich für diese Klasse hat eine Reichweite von 16-33kOhms von Widerstand, so in völliger Dunkelheit sie einen Widerstand von 33Kohms haben und in Licht, das sie einen Widerstand von 16kOhms haben. Der Schaltkreis, der misst der LSR erfordert eine weitere regelmäßige Widerstand wirkt der Widerstand als Maßstab, um festzustellen, wie die LSR ist im Wandel. Immer, wenn Sie Messgröße Widerstand einer Komponente (flex Sensor, Drucksensoren, und viele andere) sind Sie, es mit einem normalen Widerstand, der einen Widerstand, der etwa gleich der max Widerstand des variablen Widerstandskomponente hat koppeln möchten. Da bin ich mit einem 16-33kOhm LSR, werde ich einen 33kOhm Widerstand in meiner Schaltung zu verwenden.
    Die Schaltung sieht so aus:
    5V -> 33kOhm Widerstand -> lichtempfindlichen Widerstand -> Boden (siehe Bild oben)
    und das analoge Arduino Stift (Ich verwende A0) wird an der Verbindung zwischen dem LSR und dem Widerstand. Der LSR hat keine Polarität, so Ausrichtung der Komponente in der Schaltung ist nicht wichtig.
    Führen Sie den folgenden Code, um ein Gefühl für den Bereich der LSR zu bekommen:

      int analogPin = A0; // Übergang zwischen LSR und Widerstand angebracht, um A0 Stift
    
     Leere setup () {
       Serial.begin (9600);
     }
    
     Leere Schleife () {
       int LSR = analogRead (analogPin);
       Serial.println (LSR);
     } 

    Ich fand, dass mein Widerstand Lesungen im Bereich von etwa 0 in vollem Licht auf etwa 900 in der Dunkelheit. Jetzt anzeigen Dieses zu beachten Sie bemerken, wo ich in den Bereich von 0 bis 900 warf

      Byte NoteOn = 144; // Hinweis auf Befehl
     int analogPin = A0;
    
     Leere setup () {
       Serial.begin (9600);
     }
    
     Leere Schleife () {
      
       int analogVal = analogRead (analogPin); // Daten lesen
      
       // Wir müssen die LSR-Daten skalieren, um zwischen 0 und 127 passen (dies ist der Bereich der MIDI-Noten)
       Byte note = map (analogVal, 0, 900, 0, 127); // verwenden Sie den Bereich von 0 bis 900 I gemessen
      
       Midimessage (NoteOn, note, 100); // schalten beachten Sie auf
       Verzögerung (300); // hold Hinweis für 300ms
       Midimessage (NoteOn, note, 0); // drehen Note aus (beachten Sie auf mit der Geschwindigkeit 0)
       Verzögerung (200); // 200ms warten, bis Auslösung nächste Note
     }
    
     // Senden MIDI-Meldung
     Leere Midimessage (byte Befehl Byte data1, Byte data2) {
       Serial.write (Befehl);
       Serial.write (data1);
       Serial.write (Daten2);
     } 

    Dieser Aufbau schafft Noten mit höheren Tonlage in Dunkelheit und kleine Steigung in Licht. Wenn ich wollte, um die Beziehung zwischen Licht und Schiff Pech umzukehren würde ich nur meine Rückwärtsbereich in der Karte Funktion:
    Byte note = map (analogVal, 900, 0, 0, 127);
    Beachten Sie, wie ich mein Bereich von 0 bis 900 zu 900-0 umgekehrt, das macht mehr Licht erzeugen höhere schrillen Noten und wenig Licht zu schaffen tiefes Noten.
    Diese Skizze ist überspannt eine Menge Notizen gerade jetzt, wenn ich wollte, um gezieltere der Umfang der Notizen kann ich mit der Schaltung zu spielen, kann ich die folgende Zeile verwenden:
    Byte note = map (analogVal, 900, 0, 40, 90);
    Nun ist die breite Palette von Widerstand Lichtempfindlichkeit wird eine Reihe von Notizen zwischen 40 und 90 zurück.

Schritt 8: Arduino und Drucksensor


  1. Ich habe ein paar 1MOhm. Als leitfähiger Schaum komprimiert wird es weniger resistive, so dass es eine druckempfindliche variable Widerstand.
    Jeder variable Widerstand kann bis Draht nach dem Schema aus dem vorherigen Schritt. Ich habe ein Multimeter, um die max Widerstand meines Drucksensoren bei etwa messen 1MOhm , so dass ich eine verdrahteten 1MOhm Widerstand in Reihe mit dem Drucksensor (Ich habe genau die gleiche schematische wie die lichtempfindlichen Widerstand, anstelle der lichtempfindlichen Widerstand mit der Drucksensor und der 33kOhm-Widerstand mit dem Widerstand 1 MOhm). Dann habe ich den Code aus dem letzten Schritt, um den Bereich zu messen, der Messwerte bilden die Drucksensoren bei etwa 50-500. Von dort können Sie den gleichen Code ausführen, um die Tonhöhe einer Note mit dem Drucksensor zu ändern, aber ändern Sie die Zeile, die die Sensormesskarten zu beachten, um für den Bereich 50-500-Konto:
    Byte note = map (analogVal, 50, 500, 0, 127);

Schritt 9: Arduino und Flex-Sensor

  1. flex-Sensoren I in der Klasse verwendet
    Biegesensoren sind eine andere Art von variablen Widerstand, sie können in genau der gleichen Weise wie die lichtempfindlichen und druckempfindlichen Widerstände geschaltet werden. Die Flex-Sensoren I in der Klasse verwendet einen Widerstand zwischen 10kOhm-20kOhm, also sollten sie mit einem Widerstand auf ungefähr den gleichen Wert gepaart werden. Der Code aus dem lichtempfindlichen Widerstand Schritt wird mit einer Flex-Sensor arbeiten, aber denken Sie daran, das 0, 900 in der Linie einstellen:
    Byte note = map (analogVal, 0, 900, 0, 127);
    , was auch immer Sie für Ihren Bereich flex Sensor messen.

Schritt 10: Arduino und Piezo Sensor

  1. Piezo Sensoren
    Arduino, Sensoren und MIDI

    Piezo Sensoren schalten Druck oder Schwingungen in elektrische Ladung, die mit einer der Arduino die Analogeingänge gemessen werden kann. Die Schaltung benötigt eine 1MOhm Widerstand parallel zum Piezosensor verdrahtet, mit einer Seite tog Runde verbunden ist, und das andere verbunden das ein Arduino Analogstift (Bild # 1 oben). Überwachen Sie den Sensor mit dem folgenden Code:

      int piezo = A0;
    
     Leere setup () {
       Serial.begin (9600);
     }
    
     Leere Schleife () {
       int piezoVal = analogRead (Piezo);
       Serial.println (piezoVal);
     } 

    Ich sah, dass mein Piezo-Sensor war etwa um 0-1 stabil in der Regel, wenn ich dann traf es, sprang er bis zu etwa 150 (Bild # 2 oben). Wir können die piezo wie ein Schalter mit der Suche nach diesen Spitzen zu verwenden, in den Code unten ich jedes Mal, wenn das piezo Stift misst ein Signal über 50 erstellen eine MIDI-Note.

      int NoteOn = 144;
     int piezo = A0;
     int threshold = 50; // etwas mehr als fünfzig bedeutet, wir haben die piezo treffen
    
     Leere setup () {
       Serial.begin (9600);
     }
    
     Leere Schleife () {
       int piezoVal = analogRead (Piezo);
       if (piezoVal> Schwelle) {
         Midimessage (NoteOn, 60, 127);
         Verzögerung (300);
         Midimessage (NOTEON, 60, 0);
       }
     }
    
     // Senden MIDI-Meldung
     Leere Midimessage (byte Befehl Byte data1, Byte data2) {
       Serial.write (Befehl);
       Serial.write (data1);
       Serial.write (Daten2);
     } 

    Wir können auch die Kraft der Hit, die Kontrolle Geschwindigkeit zu verwenden:

      int NoteOn = 144;
     int piezo = A0;
     int threshold = 50; // etwas mehr als fünfzig bedeutet, wir haben die piezo treffen
    
     Leere setup () {
       Serial.begin (9600);
     }
    
     Leere Schleife () {
       int piezoVal = analogRead (Piezo);
       if (piezoVal> Schwelle) {
         int maxPiezoVal = getMaxVal (piezoVal);
         Byte-Geschwindigkeit = map (maxPiezoVal, 0, 1023, 50, 127); // Geschwindigkeit zwischen 50 und 127 basierend auf max val von piezo
         Midimessage (NoteOn, 60, Geschwindigkeit);
         Verzögerung (500);
         Midimessage (NOTEON, 60, 0);
       }
     }
    
     // Senden MIDI-Meldung
     Leere Midimessage (byte Befehl Byte data1, Byte data2) {
       Serial.write (Befehl);
       Serial.write (data1);
       Serial.write (Daten2);
     }
    
     int getMaxVal (int lastVal) {
       int currentVal = analogRead (Piezo);
       while (currentVal> lastVal) {
         lastVal = currentVal;
         currentVal = analogRead (Piezo);
       }
       zurück lastVal;
     } 

    In dem obigen Code, habe ich eine Hilfsfunktion namens getMaxVal, die eine while-Schleife verwendet, um die max Verschiebung des piezo aufnehmen, so dass es verwendet werden kann, um die Geschwindigkeit eines MIDI-Note eingestellt werden. Dieser Code funktioniert, indem die piezo und zu überprüfen, ob die Messung größer als die letzte Messung wird, wenn es dann wir auf die neue Messung zu halten, und wiederholen Sie den Vorgang. Sobald die neue Messung von der Piezo niedriger als die letzte aufgezeichnete Messung ist, wissen wir, dass das piezo seine max Verschiebung erreicht hat, und es wird auch weiterhin immer niedrigeren Zahlen von analogRead () geben, so liefert die Funktion den Wert max.
    Die Anzahl von getMaxVal () zurückgegeben wird, ist irgendwo zwischen 0 und 1023, so habe ich eine Karte () -Funktion, um es zu skalieren, um eine Geschwindigkeit zwischen 50 und 127.

Schritt 11: Pitchbend MIDI-Befehle mit Arduino


  1. Um eine Nachricht Pitchbend MIDI-Nachricht, den Befehl 224 nutzen zu können, wie Note On, Pitchbend-Meldungen haben zwei Datenbytes, die erste Daten-Byte feinen Pitchbend und die zweite ist groben Tonhöhenveränderung. Wie Noten- und Dynamik, Grob- und Fein Pitchbend sind Zahl zwischen 0 und 127. Wie Sie sich vorstellen würde, Grob Pitchbend gibt Ihnen natürlich Kontrolle und Fein Pitchbend gibt Ihnen die Feinsteuerung. Feine Pitchbend gibt Ihnen ein weiteres 128 Stufen der Kontrolle zwischen jedem benachbarten natürlich Schritt; Fein Pitchbend ist so fein, dass ich nicht finde mich oft benötigen, um es zu benutzen. Einstellen grober Pitchbend = 64 und Fein Pitchbend = 0 wird keine Pitchbend geben, etwas höher als die Pitch Bend wird Ihre Notizen auf, und alles, was niedriger wird Ihre Anmerkungen unten Pitchbend.
    Hier ist, wie Sie einen Pitchbend-Nachricht zu senden:
    Midimessage (pitchbendCmd, finePitchbend, coarsePitchbend);
    Ich habe den piezo aus dem letzten Schritt, um den Stift A1 Analog und ein Potentiometer zur analogen Pin A0 verdrahtet und lief den folgenden Code:

      Byte NoteOn = 144;
     Byte pitchbendCmd = 224;
    
     int piezo = A1;
     int analogPB = A0;
     int threshold = 50; // etwas mehr als fünfzig bedeutet, wir haben die piezo treffen
    
     Leere setup () {
       Serial.begin (9600);
     }
    
     Leere Schleife () {
       int piezoVal = analogRead (Piezo);
      
       if (piezoVal> Schwelle) {
         Midimessage (NoteOn, 60, 127);
         int Zeit = 0;
         while (time <300) {
           int analogPBVal = analogRead (analogPB);
           Byte Pitchbend = map (analogPBVal, 0, 1023, 0, 127);
           Midimessage (pitchbendCmd, 0, Pitchbend);
           Verzögerung (1);
           Zeit ++;
         }
         Midimessage (NOTEON, 60, 0);
       }
     }
    
     // Senden MIDI-Meldung
     Leere Midimessage (byte Befehl Byte data1, Byte data2) {
       Serial.write (Befehl);
       Serial.write (data1);
       Serial.write (Daten2);
     } 

    In dem obigen Code habe ich die folgenden Zeilen an Daten von meinem Potentiometer lesen, verkleinere sie auf einen Pitchbend Wert zwischen 0 und 127:
    int analogPBVal = analogRead (analogPB);
    Byte Pitchbend = map (analogPBVal, 0, 1023, 0, 127);
    Ich habe diesen Befehl, um einen Pitchbend Nachricht zu senden, habe ich meine Pitchbend val, um den groben Tonhöhenveränderung eingestellt wurde Fein Pitchbend auf 0 gesetzt.

    Midimessage (pitchbendCmd, 0, Pitchbend);

Schritt 12: Arduino und Proximity (Ping) Sensor


  1. Wird auch als Ping-Sensor, Näherungssensoren verwenden einen Ultraschallimpuls zu seiner Entfernung zu einem Hindernis messen Echoortung . Dieser Sensor ist einfach zu haben und läuft, es drei Verbindungen mit dem Arduino benötigt nur: Boden, 5 V, und eine Verbindung zu einem Arduino Digitalstift (I verwendet Pin 7). Arduino hat ein großes Stück Beispielcode auf ihrer Website , die ich weiter unten für das Erhalten der Näherungssensor und läuft wiederholt:
      int pingPin = 7;
    
     Leere setup () {
       Serial.begin (9600);
     }
    
     Leere Schleife () {
    
       // Trigger ping durch Pulsen pingPin HOCH für 2 Mikrosekunden
       pinMode (pingPin, OUTPUT);
       digital (pingPin, LOW);
       delayMicroseconds (2);
       digital (pingPin, HIGH);
       delayMicroseconds (5);
       digital (pingPin, LOW);
    
       // PingPin auf INPUT gesetzt und zählen Sie die Zeit, die es braucht, um ein Ping-zurück erhalten
       pinMode (pingPin, INPUT);
       lange Laufzeit = pulseIn (pingPin, HIGH);
    
       // Zeit in einem Abstand zu konvertieren
       Lang inches = microsecondsToInches (Dauer);
       Lang cm = microsecondsToCentimeters (Dauer);
     
       // Ausdrucken der Ergebnisse
       Serial.print (Zoll);
       Serial.print ("in");
       Serial.print (cm);
       Serial.print ("cm");
       Serial.println ();
     
       Verzögerung (100);
     }
    
     Lang microsecondsToInches (lange Mikrosekunden)
     {
       // Nach Parallax Datenblatt für den PING))), gibt es
       // 73,746 Mikrosekunden pro Zoll (dh Schall bei 1130 Fuß pro
       // Sekunde).  Dies gibt den Abstand vom Ping, Outbound gereist
       // Und zurück, so dass wir durch 2 teilen, um den Abstand des Hindernisses zu bekommen.
       // Siehe: <a href="http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf"> <a href = "http: //www.parallax .com / dl / docs / prod / acc / 28015-PI ... </ a "> <a href =" http://www.parallax.com/dl/docs/prod/acc/28015-PI .. . </ a "> http: //www.parallax.com/dl/docs/prod/acc/28015-PI ... </a> >>
       zurück Mikrosekunden / 74/2;
     }
    
     Lang microsecondsToCentimeters (lange Mikrosekunden)
     {
       // Die Schallgeschwindigkeit ist 340 m / s oder 29 Mikrosekunden pro Zentimeter.
       // Der Ping fährt hin und zurück, so, um den Abstand von der zu finden
       // Objekt nehmen wir die Hälfte der zurückgelegten Strecke.
       zurück Mikrosekunden / 29/2;
     }
    

    Eine ungewöhnliche an diesem Code ist, dass die pinMode von pingPin geändert wird, während die Arduino-Schleife () ausgeführt wird. Bis jetzt haben wir nur diesen Befehl im Setup. Da der Stift wird als Ausgang verwendet, um den Ultraschallimpuls zu senden, und dann als ein Eingangssignal für die Impulshören, ist es Modus hat, dynamisch ändern. Auch delayMicroseconds () wird verwendet, um eine Verzögerung für eine bestimmte Anzahl von Mikrosekunden (im Gegensatz zu verzögern (), die ein Argument in Millisekunden, um eine Verzögerung zu erstellen verwendet).
    Von hier ist es eine einfache Übung für die Verwendung der Karte () Funktion mad Entfernung zu welcher Art von MIDI-Daten die Sie sich interessieren, genau wie in den vorherigen Schritten. Hier sind einige Beispiele dafür, wie man einen Näherungssensor zu verwenden:

    Proximity gesteuert Chiptunes-style Summer:


    Hindernis vermeiden robot - Ich mag die Art, wie sie einen Motor auf den Ping-Sensor, um es ein wenig effektiver befestigt habe:

Schritt 13: Arduino und Touch-Screen-

  1. Steckverbinder
    Wenn Sie sich für Touch-Schnittstellen sind, gibt es eine relativ kostengünstige (€ 8 + 4 € Stecker ) resistiven Touchscreen oder (die teureren) Trackpad aus Adafruit, die X- und Y-Position und Druck, so dass Sie Projekte wie dieses machen kann misst:

    Der Touch-Screen eine Verbindung mit dem Arduino mit vier Stiften beschriftet X +, X-, Y + und Y-; Die Pinbelegung ist in dem folgenden Code angegeben. Ich habe Adafruit die Touchscreen-Bibliothek , mit der Screen-Interface ( hier, wie Sie eine Bibliothek, um Arduino hinzufügen ). Hier ist eine einfache Skizze zu beginnen:
      #include <stdint.h>
     #include "TouchScreen.h"
    
    
     int YPLUS = A0;  // Muss ein analoger Stift sein
     int xminus = A1;  // Muss ein analoger Stift sein
     int YMINUS = 8;  // Kann ein digitaler Stift sein
     int XPlus = 9;  // Kann ein digitaler Stift sein
    
     // Für bessere Druckgenauigkeit, müssen wir den Widerstand kennen
     // Zwischen X + und X-, verwenden Sie das Multimeter, es zu lesen
     // Für die, die ich bin mit, es ist 654 Ohm
     TouchScreen TouchScreen ts = (XPlus, YPLUS, xminus, YMINUS, 654);
    
     Leere Setup (void) {
       Serial.begin (9600);
     }
    
     Leere Schleife (void) {
       // Ein Punkt Objekt enthält xy und z-Koordinaten
       Punkt p = ts.getPoint (); // Daten vom Bildschirm zu bekommen
      
       if (pz> ts.pressureThreshhold) {// wenn der Druck über einem bestimmten Schwellenwert liegt
          Serial.print ("X =");  Serial.print (Pixel);
          Serial.print ("Y =");  Serial.print (py);
          Serial.print ("Pressure =");  Serial.println (pz);
       }
    
       Verzögerung (100);
     } 

    Hier ist eine wirklich einfache MIDI-Implementierung des Kaossilator, Mapping x Position zu beachten, und y-Position, Geschwindigkeit:

      #include <stdint.h>
     #include "TouchScreen.h"
    
     Byte NoteOn = 144; // Hinweis auf Befehl
    
     int YPLUS = A0;  // Muss ein analoger Stift sein, verwenden Sie "An" Schreibweise!
     int xminus = A1;  // Muss ein analoger Stift sein, verwenden Sie "An" Schreibweise!
     int YMINUS = 8;  // Kann ein digitaler Stift sein
     int XPlus = 9;  // Kann ein digitaler Stift sein
    
     // Für bessere Druckgenauigkeit, müssen wir den Widerstand kennen
     // Zwischen X + und X- Verwenden Sie eine Multimeter, es zu lesen
     // Für die, die wir gerade verwenden, seine 654 Ohm über die X-Platte
     TouchScreen TouchScreen ts = (XPlus, YPLUS, xminus, YMINUS, 654);
    
     Leere Setup (void) {
       Serial.begin (9600);
     }
    
     Leere Schleife (void) {
       // Ein Punkt Objekt enthält xy und z-Koordinaten
       Punkt p = ts.getPoint ();
      
       // Wir eine Mindestdruck haben wir für "gültig"
       // Druck von 0 bedeutet, dass keine Press!
       if (pz> ts.pressureThreshhold) {
        
         Byte note = map (px, 0, 1023, 0, 127);
         Byte-Geschwindigkeit = map (py, 0, 1023, 0, 127);
        
         Midimessage (NoteOn, note, Geschwindigkeit);
         Verzögerung (100);
         Midimessage (NoteOn, note, 0); // drehen Note aus
       }
     }
    
     // Senden MIDI-Meldung
     Leere Midimessage (byte Befehl Byte data1, Byte data2) {
       Serial.write (Befehl);
       Serial.write (data1);
       Serial.write (Daten2);
     } 

    Und hier ist ein Video:

Schritt 14: Sensoren zum Selberbauen


  1. Wenn Sie beginnen, Projekte mit vielen Eingängen zu bauen, können die Kosten für einige Sensoren in die Quere kommen. Hier einige Ideen für Ihre eigenen Sensoren von der preiswerten Materialien wie Bleistiftmine, Kupferband, leitfähige Stoffbahnen oder Gewinde, leitfähigen Farbe, und eine leitende Schaumstoff (Sie erhalten diese kostenlos, wenn Sie Chips wie der 595 von der letzten instructable bestellen, es ist Teil der der Verpackung).

    Zwingen Sensitive Resistor aus Leitender Schaum:


    Bend-Sensor aus leitendem Gewebe:

    Bend-Sensors mit Klebeband und leitfähigen Faden:
    Arduino, Sensoren und MIDI

    Hubsensor mit leitfähigen Faden:


    Leitfähigen Farbe Schieberegler:


    Color Detector mit einem RGB-LED und einem Fotosensor:


    Adafruit:

    Sparkfun:

Step 15: Other Sensors for Arduino and Project Ideas


  1. There are tons of other sensors out there to try out, Adafruit and Sparkfun are good places to look, and they have lots of example code for hooking up sensors to Arduino. You can find lots of Arduino project ideas on google, youtube, the Arduino website and blog , and you can find full step by step documentation for any of the Temperature Sensor.
    Here are some example projects that use sensors I didn't have time to cover in this class:
    Accelerometer :

    Temperature Sensor (used in Gas/Methane Sensor):
    Arduino, Sensoren und MIDI

    Magnetic Sensor :


    Gas/Methane Sensor , this is the randofo:
    Arduino, Sensoren und MIDI

Step 16: Arduino MIDI IN


  1. Finally, you can send MIDI into the Arduino and use it to control things connected to the Arduino's outputs. Here's a Serial.available(), made by my coworker, Serial.read().

    Also a hacked guitar hero that shoots flames:

    Here's a simple example of how you can parse an incoming MIDI message with Arduino and use the information to control the birghtness of an LED. In my example, I'll turn on an LED when note 60 (middle c) is triggered, and I'll scale the brightness of the LED according to the velocity of the incoming note:

     byte noteOn = 144;
    int ledPin = 9;
    
    byte noteToCheck = 60;
    
    //light up led at pin 13 when receiving noteON message with note = 60
    
    void setup(){
       Serial.begin (9600);
      pinMode(ledPin,OUTPUT);
     }   
    
    void loop(){
      checkForNote();
       Verzögerung (10);
     }
    
    void checkForNote(){
      while (Serial.available()){//while there is serial data availble
        
        byte incomingByte = Serial.read();//read first byte
        if (incomingByte>127){//if a command byte
        
          if (incomingByte == noteOn){//if note on message
          
            byte noteByte = Serial.read();//read next byte
            byte velocityByte = Serial.read();//read final byte
    
    
            if (noteByte == noteToCheck && velocityByte > 0){//note on
              int brightness = map(velocityByte, 0, 127, 0, 255);//map velocity to a number between 0 and 255
              analogWrite(ledPin,brightness);//turn on led w brightness relative to velocity
             }
    
    
            if (noteByte == noteToCheck && velocityByte == 0){//note off
              digitalWrite(ledPin,LOW);//turn off led
             }
           }
         }
       }
     } 

    There are a few new commands used here:
    Serial.available() returns the number of bytes available to read from the Arduino's serial port.
    Serial.read() is the opposite of Serial.print() , it returns the next available byte of data from the Arduino's serial port.
    In this code, the Arduino reads first available byte and checks to see if it is a command byte (remember, command bytes are always > 127)
    if (incomingByte>127)
    Then, since we're only looking for Note On commands, the Arduino checks to see if the command is a Note On command:
    if (incomingByte == noteOn)
    Then the Arduino reads in the next two bytes and stores them as noteByte and velocityByte:
    byte noteByte = Serial.read();
    byte velocityByte = Serial.read();

    Then the Arduino checks to see if the note we have is the note we're interested in, and if the velocity is greater than 0 (note on or note off). If it is Note On, the Arduino uses map() to scale the velocity (0-127) to a brightness between 0 and 255, and sends this brightness to analogWrite(). If it's a Note Off message, the Arduino turns the LED off.
    The one sneaky thing I added to this code is the delay(10) in the loop(). I found that the Arduino was able to read in the MIDI messages more reliably with this delay in there. You might also mess around with the baud rate to ensure that you never miss a MIDI message.