Beginner Arduino

15 Schritt:Schritt 1: Was ist Arduino Schritt 2: Wie man ein Steckbrett verwenden Schritt 3: Schalten Sie LED mit 5V Schritt 4: Anatomie einer Arduino Sketch Schritt 5: Arduino LED Blink Schritt 6: Controlling mehreren LEDs mit Arduino Schritt 7: Fade LEDs mit AnalogWrite Schritt 8: RGB-LED und Arduino Schritt 9: Arduino Funktionen Schritt 10: Button Schritt 11: Arduino Digitale Ein- und Ausgänge Schritt 12: Arduino Analog Input Schritt 13: Arbeiten mit analogen Eingangsdaten Schritt 14: Üben Sie mit Arduino Ein- und Ausgänge Schritt 15: Button Als Kippschalter

Beginner Arduino

Das Arduino ist ein Computer im Taschenformat (auch ein "genannt Mikrocontroller "), die Sie programmieren und zu verwenden, um Regelkreise. Es interagiert mit der Außen Wort über Sensoren, LEDs, Motoren, Lautsprecher ... auch im Internet; das macht es eine flexible Plattform für viele kreative Projekte. Einige beliebte Anwendungen umfassen:
- Programmierbare Lichtanzeigen, die Musik oder die menschliche Interaktion zu antworten
- Roboter, die Informationen von Sensoren zu verwenden, um zu navigieren oder andere Aufgaben
- Einzigartig, kundengerecht Steuerungen und Schnittstellen für Musik, Spiele und mehr
- Verbindungs ​​realer Objekte mit dem Internet (Twitter ist besonders beliebt)
- Alles interaktiv
- Automatisierung und Prototyping
Es gibt Unmengen von erstaunlichen Arduino Projekte online gebucht, hier sind einige meiner Favoriten:
Twitter-Stimmungs-Licht durch RandomMatrix, ein Licht, das je nachdem, welche Arten von emotionalen Worten Farbe wechselt auf Twitter Trending
Beginner Arduino

Nebulophone Synth von Bleep Labs:

Singen Plant von Mads Hobye:

Polargraph Drawing Machine von Sandy Edel:

Flammenwerfen Jack-O-Lantern von Randy Sarafan und Noah Weinstein:

Regen empfindlichen leuchten Sonnenschirm snl017

Es gibt durchaus ein paar Mikrocontroller auf dem Markt, aber die Arduino steht abgesehen von dem Rest becuase der aktiven Online-Community um ihn herum. Wenn Sie auf Suche Google oder Youtube , werden Sie Tonnen große Projektideen und Informationen um Ihnen den Einstieg zu finden. Auch wenn Sie möglicherweise nicht über irgendwelche Erfahrungen Programmierung oder arbeiten mit einem Mikrocontroller, der Arduino einfach zum Laufen zu bringen, und es ist eine tolle Möglichkeit, über Elektronik durch Experimentieren zu lernen.
Diese Instructable wurde für eine Intro geschrieben, um Klasse-I bin zu lehren Arduino Damen Audio Mission in diesem Monat. Ich werde Entsendung Instructables auf fortgeschrittenere Arduino Themen und auf den Aufbau von kunden MIDI-Controller mit Arduino in den nächsten Wochen, wie die Klasse weiter. Mehr Infos über Arduino kann auf der gefunden werden Arduino Referenzseite .
Für diese Klasse benötigen Sie:
(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
(4x) rote LEDs Digikey C503B-RCN-CW0Z0AA1-ND
(4x) 220Ohm-Widerstände Digikey CF14JT220RCT-ND
(1x) 10kOhm Widerstand Digikey CF14JT10K0CT-ND
(1x) Takt-Taste Digikey 450-1650-ND
(1x) 10kOhm Potentiometer Digikey PDB181-K420K-103B-ND
(1x) RGB LED (gemeinsame Kathode) Digikey WP154A4SUREQBFZGC
Tipps zur Bestellung stuff: Digikey ist in der Regel die günstigste Stelle können Sie Komponenten zu erhalten und sie zu versenden wirklich schnell, aber manchmal ist es schwer zu finden, was Sie, weil sie so viel Zeug haben suchen. Wenn Digikey gibt Ihnen zu viel Mühe versuchen Jameco , werden Sie ein paar Cent mehr pro Komponente zu bezahlen, aber es ist viel einfacher, ihr Inventar zu navigieren. Wenn Sie Sachen sofort, können Sie Komponenten, Montageplatten, Kabel und Arduinos bei Ihrem örtlichen finden Radioshack , aber Sie werden in der Regel ein bisschen mehr bezahlen. Adafruit und Sparkfun sind gute Online-Shop für die Suche nach Sensoren oder andere kühle Arduino Zubehör und sie in der Regel haben Tutorials und Beispielcode für ihre komplizierter Teile. Amazon ist auch ein guter Ort, um zu überprüfen, jetzt haben sie Arduino Unos für € 22, die die billigste, die ich je gesehen ist.
In diesem Instructable Ich werde mit 123D Schaltungen zu demonstrieren und zu simulieren, die Schaltungen arbeiten die eingebettete Schaltungssimulationen am besten mit dem Chrome-Browser .

Schritt 1: Was ist Arduino

  1. Beginner Arduino
    Zuerst werden wir einen Blick auf all die Teile des Arduino zu nehmen. Das Arduino ist im Wesentlichen eine winzige Computer, der mit elektrischen Schaltungen verbinden. Das Arduino Uno wird von einem Atmega 328P Chip angetrieben, ist es der größte Chip auf der Platine (siehe Bild Hinweis auf das Bild oben). Dieser Chip ist in der Lage, Programme in seinem (sehr begrenzt) Speicher gespeichert auszuführen.

    Wir können Programme auf den Chip via USB mit der Last Arduino IDE (download dies, wenn Sie nicht bereits haben). Der USB-Anschluss liefert auch die Stromversorgung des Arduino. Alternativ könnten wir eine programmierte Platine mit dem Netzanschluss, in diesem Fall wir eine USB-Verbindung nicht brauchen versorgen.

    Das Arduino hat ein paar Reihen von Stiften, die wir Drähte in Stecker. Die Power-Pins sind im Bild markiert. Das Arduino hat sowohl eine 3,3V oder 5V Versorgung; in dieser Klasse werden wir den 5V-Versorgung verwenden, aber Sie könnten ein paar Chips oder Komponenten, die 3,3 V benötigen, um ausgeführt zu finden, in diesem Fall die 3,3V-Versorgung von Nutzen sein wird. Sie werden auch einige Stifte mit "GND" auf der Arduino zu finden, sind diese Masse-Pins (Masse ist das gleiche wie 0 V). Elektrischer Strom fließt immer von einem gewissen positiven Spannung an Boden, so dass diese Stifte sind nützlich für das Ausfüllen Schaltungen, werden wir sie häufig verwenden.

    Das Arduino hat 14 digitale Stifte, beschriftet 0-14, die auf Schaltungen zu verbinden, um sie ein- oder auszuschalten oder um Schaltflächen und andere 2-Zustandsschaltungen messen (eine Taste zwei Staat, weil es entweder gepresst oder nicht gedrückt, im Gegensatz auf ein Zifferblatt, das eine Reihe von möglichen Zuständen hat). Diese Stifte können entweder als Ein- oder Ausgänge dienen, dh sie können einen Schaltkreis kontrolliert messen es.

    Weiter zu den Leistungsanschlüssen sind die Analog-Eingangspins, beschriftet A0-A5. Diese Stifte werden verwendet, um analoge Messungen von Sensoren oder andere Komponenten zu machen. Analogeingänge sind besonders gut für die Messung Dinge mit einem Bereich möglicher Werte. Zum Beispiel wird ein analoges Eingangsstift lassen Sie uns die Menge an flex einer Flex-Sensor oder die Menge, die ein Zifferblatt gedreht worden zu messen. Sie können einen analogen Eingang verwenden, um eine digitale Komponente (wie eine Taste) zu messen, oder sogar wie ein Digitalausgang wirken, sind sie im Grunde digitalen Stifte mit zusätzlichen Befugnisse.

Schritt 2: Wie man ein Steckbrett verwenden

  1. Beginner Arduino

    Beginner Arduino

    Beginner Arduino

    Beginner Arduino

    Beginner Arduino

    Breadboards lassen Sie uns temporäre elektrische Verbindungen zwischen den Komponenten, so dass wir Schaltungen zu testen, bevor wir sie dauerhaft miteinander zu verlöten. Diese ganze Klasse wird auf ein Steckbrett getan werden, so dass wir Komponenten wieder zu verwenden und stellen Sie schnelle Änderungen an einem Stromkreis.

    Breadboards haben Reihen von Löchern, die Sie Drähten oder anderen elektrischen Komponenten in die Stecker. Einige dieser Löcher sind elektrisch miteinander durch Metallstreifen auf der Unterseite des Steckbrett verbunden ist. Hier ist, wie die Verbindungen funktionieren:

    Eines auf jeder Seite des Steckbrett sind zwei Lochreihen über die gesamte Länge der Platte verbunden (Bilder 1 und 2). Im Allgemeinen werden Sie diese lange "Schienen" auf 0 V (auch "Boden") und was Spannungs Sie für Leistung (in dieser Klasse werden wir 5V aus dem Arduino zu verwenden) zu verbinden, so dass diese Verbindungen verfügbar sind überall auf dem Brett . In diesem Fall ist das erste, was Sie tun möchten, ist Draht bis diese Verbindungen zu Ihrem Arduino, wie in Bild 4 dargestellt ist, bemerkt, wie ich zu der Zeile markiert verbunden Masse "-" und 5 V zu der Reihe "+" gekennzeichnet, kann Ihr Steckbrett oder kann nicht markiert werden. Anmerkung: Manchmal sind diese Seitenstreifen wird nur zur Hälfte erstrecken sich über einen längeren Steckbrett, Verwendung Drähte, um die Verbindung (Bild 5) abzuschließen.

    Der Rest der Löcher im Lochraster werden in Fünferreihen in der Mitte des Steckbrett (Bild 3) gruppiert. Dies ist, wo man elektrische Komponenten miteinander zu verbinden, um Schaltkreise zu bilden.

Schritt 3: Schalten Sie LED mit 5V

  1. Beginner Arduino

    Beginner Arduino

    Beginner Arduino

    Beginner Arduino

    Beginner Arduino

    Wie ich bereits erläutert, fließt elektrischer Strom von Hochspannung in Niedrigspannung. In dieser Klasse werden wir die Stromversorgung alles aus der 5 V aus dem Arduino, so fließt Strom von 5 V in der Arduino die "Masse" Stift fließen aus dem Arduino, durch unsere Schaltung, und wieder zurück. Das erste, was wir hochgefahren ist eine LED .

    Die Schaltung, die auf einem LED schaltet umfaßt zwei Komponenten: einen Widerstand und eine Leuchtdiode. Die schematische Darstellung der Schaltung ist in Bild 4 oben gezeigt. Der Widerstand wird durch einen rechteckigen Kasten dargestellt (Möglicherweise sehen Sie auch durch ein vertreten Beginner Arduino


    ). Die LED wird durch ein Dreieck mit einer Linie, und in der Regel einige Pfeile nach außen zeigen, dass Licht aus dem Bauteil kommen repräsentieren vertreten.

    Also warum brauchen wir den Widerstand in dieser Schaltung? Dieser Widerstand wird als Strombegrenzungswiderstand , das bedeutet, der Widerstand begrenzt die Menge des elektrischen Stroms, der durch die LED fließt. Jede LED wird für eine bestimmte Menge an Strom gelesen, wenn Sie über diesen Betrag müssen Sie wahrscheinlich die LED beschädigen zu gehen. Verwendung Ohms Law, können wir den Wert des Strombegrenzungswiderstand wir mit unseren LED verwenden sollten zu berechnen.

    Das Ohmsche Gesetz ist sehr einfach, es heißt, dass es eine lineare Beziehung zwischen Strom und Spannung in einem Widerstand: Erhöhen der Spannung an einem Widerstand den Strom zu erhöhen, der durch sie fließt. Konkret heißt es:

    V = I * R
    wo
    V = Spannung über dem Widerstand
    I = Strom durch den Widerstand
    R = Widerstand - das ist, was wir berechnen möchten
    so dass, wenn wir wissen, die Werte von V und I, können wir das richtige R für unsere Schaltung berechnen

    Zuerst müssen wir die Spannung über den Widerstand zu berechnen. Bei dem in Bild 4 dargestellten Schaltung wird ein insgesamt 5 V an die Schaltung angelegt. Die meisten der 3mm oder 5mm LEDs von Ihnen verwendeten 3V zu leuchten, so dass die verbleibende 2V (5 V - 3 V = 2 V) wird über den Widerstand aufgebracht.

    Als nächstes werden wir die Berechnung der Strom, der durch den Widerstand. Die meisten 3mm oder 5mm LEDs bei voller Helligkeit bei etwa 20 mA Strom laufen; gehen über dies die LED beschädigt und gehen unter das macht die LED leuchten Dimmer (aber nicht schadet). Unter der Annahme, wir laufen unsere LED bei 20 mA wollen, wissen wir, dass die gleiche Menge an Strom durch den Widerstand laufen, da die Komponenten miteinander verdrahtet in Serie . Dies lässt uns mit:

    2V = 20mA * R
    2V = 0,02A * R
    R = 100 Ohm

    So 100 Ohm ist das absolute Minimum Widerstand müssen wir sicherstellen, dass wir die LED nicht beschädigen. Um sicher zu sein, ist es eine gute Idee, etwas, ein wenig höher zu verwenden, nur für den Fall Ihrer LED hat leicht unterschiedliche Bewertungen, dass das, was ich hier verwendet. Ich mag zu 220ohms verwenden, weil ich immer scheint eine Menge von Menschen in Ihrer Umgebung zu haben. Wenn Ihnen die Bewertungen Ihrer LED (können Sie es auf die LED-Datenblatt zu finden), und Sie müssen diese Berechnung selbst tun wollen, können Sie auch versuchen, mit Hilfe eines Online-Kalkulator .

    Als Nächstes werden wir verdrahten die LED auf dem Steckbrett. Stecker der Widerstand und der LED, die in dem zentralen Teil des Schaltbrettes, so dass der längere Draht der LED ist elektrisch mit einem der Anschlüsse des Widerstands (Bild 3) verbunden ist. Schließen Sie dann das andere Ende des Widerstands auf 5 V und das andere Ende des LED mit Masse. Sie sollten die LED leuchten sehen.

    Einige Dinge zu versuchen:

    Bemerken, wie die LED-Leitungen sind nicht die gleiche Länge haben, ist dies, weil LEDs müssen in einer Schaltung in einer bestimmten Orientierung in einer Schaltung sein. Strom fließt immer durch die LEDs von der langen Führung der kurzen Leitung (in der schematischen Darstellung ist, fließt Strom in der gleichen Richtung, die die Dreieckspunkte, Beginner Arduino


    ist eine schöne Grafik, dass). Versuchen Sie spiegeln die Ausrichtung des LED - sollten Sie feststellen, dass die LED leuchtet nicht, wenn es in der Schaltung nach hinten gestellt wird.

    Widerstände, auf der anderen Seite, haben keine Orientierung, werden Sie feststellen, dass ihre Leitungen gleich lang sind (die schematische Darstellung zeigt diese Symmetrie auch). Spiegeln die Ausrichtung eines Widerstands in einer Schaltung wird keine Auswirkungen auf die Schaltung haben - probieren Sie es.

    Versuchen Sie nun, tauschen die Position der LED und der Widerstand in der Schaltung (Bild 5). Sie sollten feststellen, dass dies auch nicht, den Stromkreis zu bewirken. Es spielt keine Rolle, wenn der Strombegrenzungswiderstand ist auf einer Seite der LED oder der anderen, wird es noch einen wirksamen Schutz der LED vor Überstrom sein.

Schritt 4: Anatomie einer Arduino Sketch

  1. Programme in der Arduino Sprache werden als "Skizzen". Der Setup-Funktion und der Loop-Funktion: Ein Arduino Sketch wird aus zwei Hauptteilen besteht.

    setup () - das Setup () Funktion wird automatisch am Anfang eines Arduino Programm ausgeführt. Innerhalb dieser Funktion werden Variablen, Anstecknadeln und alle Bibliotheken, die Sie verwenden werden in Ihrer Skizze zu initialisieren. Die Funktion Setup () wird nur während eines Arduino Sketch einmal ausgeführt, rechts, wenn das Board mit Strom versorgt wird oder zurückzusetzen.

    Schleife () - die Schleife () ist, wo der Großteil des Programms wird leben. Diese Funktion wird nach dem Setup () ausgeführt ist abgeschlossen. Das Arduino wird die Befehle innerhalb der Schleife immer wieder ausführen, bis die Platine ausgeschaltet ist.

    Von hier an, die Arduino Referenzseite wird sehr nützlich für Dokumenation über die Arduino Sprache und Programmierumgebung.

Schritt 5: Arduino LED Blink

  1. In diesem Beispiel werden wir verkabeln unsere LED-Schaltung zu einem der Arduino digitale Stifte und schalten Sie die LED ein und aus mit Code. Dieses Beispiel stellt ein paar nützliche Funktionen in die Arduino Sprache gebaut, sie sind:

    pinMode (Pin-Nummer, Modus) - pinMode wird während des Setup () Teil der Skizze, um jeden Stift verwenden wir entweder als Eingang oder Ausgang zu initialisieren. Wir können nicht lesen und schreiben mit einem Stift vor pinMode gesetzt wurde. pinMode () zwei Argumente - eine PIN-Nummer (jeder der Arduino Pins wird mit einer Nummer versehen) und der Modus, die wir wollen, dass die Zapfen (entweder "INPUT" oder "OUTPUT"). Im Falle der Wimper zu LED sind wir Daten aus dem Arduino Senden, um den Zustand der LED zu kontrollieren, so verwenden wir "OUTPUT" als zweites Argument.

    digital (Pin-Nummer, Zustand) - digital ist ein Befehl, uns setzen Sie die Spannung von einem Stift, um entweder 5 V oder Masse (erinnern "Masse" ist gleichbedeutend mit 0 Volt) können. Im letzten Beispiel oben angespannt wir eine LED mit einem 5V-Versorgung und sah, sie zu aktivieren, wenn wir hook up die LED zu einem der Arduino digitale Stifte statt, wir drehen, indem Sie den Stift auf 5V und Ausschalten der LED an, indem Sie der Stift an Masse. digital () nimmt zwei Argumente - eine Pin-Nummer und den Zustand der Stift ("HIGH" für 5V und "LOW" für Erde).

    Verzögerung (timeInMs) - Verzögerung pausiert das Programm für eine bestimmte Zeit. Zum Beispiel Verzögerung (2000) wird das Programm für 2000 Millisekunden (2000 Millisekunden = 2 Sekunden), Verzögerung (100) so zu unterbrechen das Programm für 100 Millisekunden (1/10 einer Sekunde) zu unterbrechen, und ...

    Unten ist die LED-Blinkcode, diesen Code auf Ihrer Arduino laufen.

      // LED Blink
    
     int ledPin = 7; // das Arduino Pin, der zu der LED verbunden ist
    
     Leere setup () {                
       pinMode (ledPin, OUTPUT); // initialisieren den Stift als Ausgang
     }
    
     Leere Schleife () {
       digital (ledPin, HIGH); // LED einzuschalten
       Verzögerung (1000); // abwarten 1000 Millisekunden (eine Sekunde)
       digital (ledPin, LOW); // LED aus abbiegen
       Verzögerung (1000); // warten 1 Sekunde
     }
    


    Ein paar Anmerkungen zu dem Code:

    Zeilen, die mit "//" beginnen, sind Kommentare - Arduino ignoriert diese.

    Sie werden bemerkt haben alle Semikolons werden Semikolons am Ende jeder Befehl im Arduino Sprache verwendet. Wenn Sie ein Semikolon vergessen haben, werden Sie eine Fehlermeldung. Sie werden feststellen, dass viele andere Programmiersprachen verwenden Semikolons am Ende jeder Zeile.

    In diesem Code "ledPin" ist eine Variable . Variablen werden verwendet, um Informationen in Programme zu speichern, in dieser Skizze, ich bin mit der Variable "ledPin", um die Nummer 7. Später im Programm zu speichern, wenn der Arduino trifft eine Zeile mit der Variablen "ledPin", wird die variable bewerten anhand ihrer derzeitigen gespeicherten Wert. So der Linie:

    pinMode (ledPin, OUTPUT);

    wird von Arduino als bewertet:

    pinMode (7, Ausgang);

    In der Tat, wir alle Verwendungen von pinMode mit der Nummer 7 ersetzen und das Programm würde genau die gleiche Arbeit, aber mit Hilfe der variablen hilft uns leichter zu lesen und zu verstehen, den Code.

    "Int" von der ersten Zeile ist ein Datentyp - in der Arduino Sprache, müssen Sie immer Variablen zu initialisieren, indem er erklärt ihr Typ. Es gibt viele verschiedene Arten (Sie über alle von ihnen lesen können Sie hier ), für jetzt alles, was Sie wissen müssen, ist, dass int Variablen sind positive oder negative ganze Zahlen - Sie werden sie häufig verwenden.

    Unten ist eine Simulation der Skizze, drücken Sie die Play-Taste, um zu sehen, wie es funktioniert (am besten funktioniert in Chrome )

    Wie erwartet, leuchtet die LED für eine Sekunde, dann erlischt für eine Sekunde. Versuchen Sie, die Länge der Verzögerung () um zu sehen, wie sie sich auf die LED-Blinkzeit.

    Eine andere Sache, wo sie nach - ein Fehler, dass die Menschen oft machen, ist die letzte Verzögerung in der Schleife weglassen () (). Probieren Sie es aus - Sie werden feststellen, dass die LED leuchtet, ohne zu blinken. Dies kann verwirrend für Sie sein, denn wir haben noch eine digital (ledPin, LOW) Befehl in das Programm. Was hier passiert, ist die LED ausgeschaltet ist, aber die Arduino trifft sofort das Ende der Schleife () und beginnt mit der Ausführung der ersten Zeile der Schleife () wieder (Drehen die LED an). Dies geschieht so schnell, dass das menschliche Auge nicht sehen können, die LED ausgeschaltet für diesen kurzen Moment, während die Schleife neu zu starten.

Schritt 6: Controlling mehreren LEDs mit Arduino


  1. In diesem Beispiel werden wir Draht bis drei weitere LEDs, wie wir im letzten Beispiel getan hat, und sie mit mehreren digitalen Stifte zu steuern. Erste Draht bis drei weitere LEDs und Strombegrenzungswiderstände, wie unten dargestellt:

    Wenn wir wollen, um durch all die LEDs und schalten Sie sie ein, und einer nach dem anderen können wir unsere Arduino Sketch wie folgt schreiben:

      // Multi LED Blink
    
     int led1Pin = 4;
     int led2Pin = 5;
     int led3Pin = 6;
     int led4Pin = 7;
    
     Leere setup () {    
       // Initialisierung der LED-Pins als ein Ausgänge
       pinMode (led1Pin, OUTPUT);
       pinMode (led2Pin, OUTPUT);
       pinMode (led3Pin, OUTPUT);
       pinMode (led4Pin, OUTPUT);
     }
    
     Leere Schleife () {
       digital (led1Pin, HIGH); // LED einzuschalten
       Verzögerung (1000); // abwarten 1000 Millisekunden (eine Sekunde)
       digital (led1Pin, LOW); // LED aus abbiegen
       Verzögerung (1000); // warten 1 Sekunde
    
       // Das gleiche zu tun für die anderen 3 LEDs
       digital (led2Pin, HIGH); // LED einzuschalten
       Verzögerung (1000); // abwarten 1000 Millisekunden (eine Sekunde)
       digital (led2Pin, LOW); // LED aus abbiegen
       Verzögerung (1000); // warten 1 Sekunde
    
       digital (led3Pin, HIGH); // LED einzuschalten
       Verzögerung (1000); // abwarten 1000 Millisekunden (eine Sekunde)
       digital (led3Pin, LOW); // LED aus abbiegen
       Verzögerung (1000); // warten 1 Sekunde
    
       digital (led4Pin, HIGH); // LED einzuschalten
       Verzögerung (1000); // abwarten 1000 Millisekunden (eine Sekunde)
       digital (led4Pin, LOW); // LED aus abbiegen
       Verzögerung (1000); // warten 1 Sekunde
     }
    


    Dies funktioniert, und wir konnten lassen Sie es mögen und alles funktionieren würde großartig, aber es ist nicht der effizienteste Weg, um unseren Code zu schreiben. Stattdessen werden wir eine Struktur namens eine for-Schleife, um durch die LEDs zu verwenden. Zum Schleifen sind nützlich für die Wiederholung ein Stück Code über und über. In dem Fall, über die wir die Wiederholung der Zeilen:

    digital (led4Pin, HIGH);
    Verzögerung (1000);
    digital (led4Pin, LOW);
    Verzögerung (1000);

    hier ist, wie wir die for-Schleife schreiben:

    for (int ledPin = 4; ledPin <8; ledPin ++) {

    digital (ledPin, HIGH);
    Verzögerung (1000);
    digital (ledPin, LOW);
    Verzögerung (1000);
    }

    In der ersten Zeile werden wir eine Variable initialisiert "ledPin" als 4 und erzählt die Arduino, dass wir bis 7 mag, um durch die Werte der Variablen Ausgangs bei 4 bis (ledPin <8). Die ledPin ++ erzählt die Arduino, um den Wert um 1 ledPin jedes Mal, wenn wir die Schleife wiederholen, zu erhöhen. Dann führen wir die Linien innerhalb der Schleife unter Verwendung des variablen ledPin. So das erste Mal ledPin = 4 und Pin 4 auf dann drehte ausgeschaltet, dann ledPin auf 5 erhöht und startet die for-Schleife erneut, dieses Mal drehen Stift 5 auf dann ab, und so weiter ... Das Ergebnis ist genau das, die gleiche wie die ausführlichere Skizze oben, wo wir wiederholt die digital und Verzögerungsbefehle oft. Hier ist die vollständige Skizze:

      // Multi LED Blink
    
     int led1Pin = 4;
     int led2Pin = 5;
     int led3Pin = 6;
     int led4Pin = 7;
    
     Leere setup () {    
       // Initialisierung der LED-Pins als ein Ausgänge
       pinMode (led1Pin, OUTPUT);
       pinMode (led2Pin, OUTPUT);
       pinMode (led3Pin, OUTPUT);
       pinMode (led4Pin, OUTPUT);
     }
    
     Leere Schleife () {
       for (int ledPin = 4; ledPin <8; ledPin ++) {// für Stifte 4-7
         digital (ledPin, HIGH); // LED einzuschalten
         Verzögerung (1000); // abwarten 1000 Millisekunden (eine Sekunde)
         digital (ledPin, LOW); // LED aus abbiegen
         Verzögerung (1000); // warten 1 Sekunde
       }
     } 

Schritt 7: Fade LEDs mit AnalogWrite

  1. Manchmal werden wir möchten, um die Helligkeit einer LED-Steuerung, in diesem Fall können wir einen Befehl namens verwenden analogWrite () . analogWrite arbeitet, indem eine LED auf, und sehr schnell, so schnell, daß die Augen nicht das Flimmern wahrnimmt. Wenn eine LED die Hälfte seiner Zeit aus und die Hälfte seiner Zeit auf verbringt, dann wird es halb so hell erscheinen. Diese Technik wird Pulsweitenmodulation (PWM), ist es immer in der Elektronik verwendet werden, da es uns ermöglicht, eine Komponente in einem "analogen" Weise unter Verwendung eines digitalen Pins zu steuern. Nicht alle digitalen Stiften auf der Arduino kann PWM tun, wenn Sie genau auf Ihre Arduino schauen, sehen Sie, dass einige der Stifte haben ein "~" neben ihnen (Pins 3, 5, 6, 9, 10, 11) sind das PWM aktiviert Pins.

    Verdrahten Sie eine Ihrer LEDs an einen PWM aktiviert pin, habe ich Stift 9. Versuchen Sie, das blink Skizze aus der Zeit vor, aber verwenden analogWrite statt digital, um die LED einzuschalten (siehe Skizze unten). analogWrite () nimmt zwei Argumente: die Pin-Nummer und der Helligkeit (von 0 bis 255).

      // LED Blink (halbe Helligkeit)
    
     int ledPin = 9; // das Arduino Pin, der zu der LED verbunden ist
    
     Leere setup () {                
       pinMode (ledPin, OUTPUT); // initialisieren den Stift als Ausgang
     }
    
     Leere Schleife () {
       analogWrite (ledPin, 255); // bei voller Helligkeit LED einzuschalten (255/255 = 1)
       Verzögerung (1000); // abwarten 1000 Millisekunden (eine Sekunde)
       digital (ledPin, LOW); // LED aus abbiegen
       Verzögerung (1000); // warten 1 Sekunde
    
       analogWrite (ledPin, 191); // bei 3/4 Helligkeit LED einzuschalten (191/255 ~ = 0,75)
       Verzögerung (1000); // abwarten 1000 Millisekunden (eine Sekunde)
       digital (ledPin, LOW); // LED aus abbiegen
       Verzögerung (1000); // warten 1 Sekunde
    
       analogWrite (ledPin, 127); // bei halber Helligkeit LED einzuschalten (127/255 ~ = 0,5)
       Verzögerung (1000); // abwarten 1000 Millisekunden (eine Sekunde)
       digital (ledPin, LOW); // LED aus abbiegen
       Verzögerung (1000); // warten 1 Sekunde
    
       analogWrite (ledPin, 63); // bei einem Viertel der Helligkeit LED einzuschalten (63/255 ~ = 0,25)
       Verzögerung (1000); // abwarten 1000 Millisekunden (eine Sekunde)
       digital (ledPin, LOW); // LED aus abbiegen
       Verzögerung (1000); // warten 1 Sekunde
     } 


    Versuchen Sie, die Helligkeit im analogWrite Befehle, um zu sehen, wie sie die Helligkeit des LED wirkt.
    Als Nächstes werden wir den Code, so dass die Helligkeit Rampen glatt von den ganzen Weg aus, um die volle Helligkeit zu schreiben. Wir könnten das gleiche Stück Code kopieren:
    analogWrite (ledPin, Helligkeit);
    Verzögerung (5); // kurzen Verzögerung
    Helligkeit Helligkeit = + 1;
    Immer und immer (255-mal), die Erhöhung der Helligkeit von einem jedes Mal. Hier ist, was, dass würde so aussehen:

      // LED Blink (halbe Helligkeit)
    
     int ledPin = 9; // das Arduino Pin, der zu der LED verbunden ist
    
     Leere setup () {                
       pinMode (ledPin, OUTPUT); // initialisieren den Stift als Ausgang
     }
    
     Leere Schleife () {
       int Helligkeit = 0;
    	
       analogWrite (ledPin, Helligkeit); // Helligkeit = 0
       Verzögerung (5); // kurzen Verzögerung
       Helligkeit + = 1;
    
       analogWrite (ledPin, Helligkeit); // Helligkeit = 1
       Verzögerung (5); // kurzen Verzögerung
       Helligkeit + = 1;
    
       analogWrite (ledPin, Helligkeit); // Helligkeit = 2
       Verzögerung (5); // kurzen Verzögerung
       Helligkeit + = 1;
    
       analogWrite (ledPin, Helligkeit); // Helligkeit = 3
       Verzögerung (5); // kurzen Verzögerung
       Helligkeit + = 1;
    
       analogWrite (ledPin, Helligkeit); // Helligkeit = 4
       Verzögerung (5); // kurzen Verzögerung
       Helligkeit + = 1;
    
       analogWrite (ledPin, Helligkeit); // Helligkeit = 5
       Verzögerung (5); // kurzen Verzögerung
       Helligkeit + = 1;
    
       analogWrite (ledPin, Helligkeit); // Helligkeit = 6
       Verzögerung (5); // kurzen Verzögerung
       Helligkeit + = 1;
    
       // Immer wiederholen, bis Helligkeit = 255 (volle Helligkeit)
     } 

    Oder wir können eine for-Schleife wieder zu verwenden, um der Code viel übersichtlicher zu machen. In der folgenden Skizze habe ich zwei Schleifen, die ersten Rampen up aus dem Off die LED (0) bis zur vollen Helligkeit (255):

    for (int Helligkeit = 0; Helligkeit <256; Helligkeit ++) {

    analogWrite (ledPin, Helligkeit);
    Verzögerung (5);
    }

    Die zweite for-Schleife fährt herunter von voller Helligkeit auf off:

    for (int Helligkeit = 255; Helligkeit> = 0; Helligkeit -) {

    analogWrite (ledPin, Helligkeit);
    Verzögerung (5);
    }

    (Die Verzögerung (5) verwendet, um die Überblendung zu verlangsamen, so dauert es 5 * 256 = 1280ms = 1,28 Sekunden)

    In der ersten Zeile, verwenden wir "brightness--", um die for-Schleife zu sagen, den Wert der Helligkeit um 1 bei jedem Schleifenwiederholungen zu verringern. Beachten Sie auch, wie die Schleife, bis Helligkeit> = 0 ausführen, indem Sie> = anstelle von> wir sind die Nummer 0 in dem Bereich.

      // LED-verblassen
    
     int ledPin = 9; // das Arduino Pin, der zu der LED verbunden ist
    
     Leere setup () {                
       pinMode (ledPin, OUTPUT); // initialisieren den Stift als Ausgang
     }
    
     Leere Schleife () {
       // Rampe bis zur vollen Helligkeit LED (0 bis 255)
       for (int Helligkeit = 0; Helligkeit <256; Helligkeit ++) {
         analogWrite (ledPin, Helligkeit);
         Verzögerung (5);
       }
    
       Verzögerung (1000); // warten 1 Sekunde
    
       // Rampe ab bis gar keine Helligkeit LED (255-0)
       for (int Helligkeit = 255; Helligkeit> = 0; Helligkeit -) {
         analogWrite (ledPin, Helligkeit);
         Verzögerung (5);
       }
    
       Verzögerung (1000); // warten 1 Sekunde
     }
    


    Und hier ist, wie es aussehen sollte (Diese Simulation ist nicht ganz so gut, aber Sie bekommen die Idee). Editieren Sie die Verzögerungen zu sehen, wie es die Geschwindigkeit der Rampen wirkt.

Schritt 8: RGB-LED und Arduino

  1. Beginner Arduino

    Beginner Arduino

    Beginner Arduino

    RGB-LEDs sind wirklich Spaß, wie Sie im ersten Bild oben sehen können, wird jede RGB LED tatsächlich aus drei LEDs: eine rote, eine grüne und eine blaue. Wenn Sie das Gerät auf ein paar von den LEDs auf einmal werden sie mischen, um neue Farben zu bilden.

    Die RGB-LEDs wir in dieser Klasse sind mit sind gemeinsame Kathode, dh alle drei LEDs den gleichen Erdungsstift (einige RGB-LEDs, die so genannte gemeinsame Anode, eine gemeinsame Versorgungsstift und verfügen über separate Gelände). Wir werden wie das erste Bild oben verkabeln unsere Kreis hat jede LED in der RGB-LED ein 220Ohm Widerstand in Serie mit, die sie bis zu einem PWM verdrahtet ist Arduino Pin aktiviert (Ich habe Pins 9-11). Auf diese Weise können wir selektiv drehen jede LED in der RGB-LED ein und aus einzeln.

    Siehe das zweite Bild oben, um herauszufinden, welche der RGB LED führt entsprechen Rot, Grün, Blau und Boden (sie sind nummeriert 1-4).

    Diese erste Skizze schaltet durch jede Farbe in der LED:

      // RGB LED - Test
    
     // Stiftverbindungen
     int rot = 9;
     int grün = 10;
     int blau = 11; 
    
     Leere setup () {
       pinMode (rot, Ausgang);
       pinMode (blau, OUTPUT);
       pinMode (grün, OUTPUT);
     }
    
     Leere Schleife () {
       // Rot führte auf
       digital (rot, HIGH);
       Verzögerung (500);
       digital (rot, LOW);
       Verzögerung (500);
      
       // Drehen grüne LED an
       digital (grün, HIGH);
       Verzögerung (500);
       digital (grün, LOW);
       Verzögerung (500);
    
       // Drehen blaue LED auf
       digital (blau, HIGH);
       Verzögerung (500);
       digital (blau, LOW);
       Verzögerung (500);
     }
    

    Dann nutzen Sie analogWrite () und random () , um eine zufällige Helligkeitsstufen für jede der Farben in der LED eingestellt. Die drei Farben werden in unterschiedlichen Anteilen (je nach Helligkeit) mischen, um eine Vielzahl von Farben (255 ^ 3 = 16.581.375 mögliche Farben) zu machen.

      // RGB LED - zufällige Farben
    
     // Stiftverbindungen
     int rot = 9;
     int grün = 10;
     int blau = 11;
     Leere setup () {
       pinMode (rot, Ausgang);
       pinMode (blau, OUTPUT);
       pinMode (grün, OUTPUT);
     }
     Leere Schleife () {
       // Eine zufällige Farbe wählen
       analogWrite (rot, random (256));
       analogWrite (blau, zufällig (256));
       analogWrite (grün, gelegentlich (256));
       Verzögerung (1000); // warten 1 Sekunde
     }
    


    random (256); // gibt eine Zahl zwischen 0 und 255

Schritt 9: Arduino Funktionen

  1. Die folgende Skizze verblasst LED von rot auf grün zu blau zu rot zu grün und so weiter ...

      // RGB LED - Fading zwischen Farben
     // Stiftverbindungen
     int rot = 9;
     int grün = 10;
     int blau = 11;
     Leere setup () {
       pinMode (rot, Ausgang);
       pinMode (blau, OUTPUT);
       pinMode (grün, OUTPUT);
     }
     Leere Schleife () {
       for (int Helligkeit = 0; Helligkeit <256; Helligkeit ++) {
         analogWrite (rot, 255-Helligkeit);
         analogWrite (grün, Helligkeit);
         Verzögerung (10);
       }
       for (int Helligkeit = 0; Helligkeit <256; Helligkeit ++) {
         analogWrite (grün, 255-Helligkeit);
         analogWrite (blau, Helligkeit);
         Verzögerung (10);
       }
       for (int Helligkeit = 0; Helligkeit <256; Helligkeit ++) {
         analogWrite (blau, 255-Helligkeit);
         analogWrite (rot, Helligkeit);
         Verzögerung (10);
       }
     }
    


    Die Skizze oben funktioniert, aber es gibt eine Menge von wiederholten Code. Wir können durch das Schreiben eigener Helfer-Funktion, die von einer Farbe in eine andere Farbe verblasst zu vereinfachen. Hier ist, was die Funktion wird wie folgt aussehen:

    Leere Fader (int color1, int color2) {

    for (int Helligkeit = 0; Helligkeit <256; Helligkeit ++) {
    analogWrite (color1, 255-Helligkeit);
    analogWrite (color2, Helligkeit);
    Verzögerung (10);
    }

    }

    Betrachten wir diese Funktion Definition Stück für Stück. Die Funktion wird als "Fader", und es nimmt zwei Argumente. Jedes Argument wird durch ein Komma getrennt und hat einen Typ in der ersten Zeile der Funktionsdefinition deklariert:

    Leere Fader (int color1, int color2) {

    Wir sehen, dass sowohl der Argumente Fader übernimmt ints sind, und wir sind mit den Namen "color1" und "color2" als Dummy-Variablen für unsere Funktionsdefinition. Die "Leere" bezieht sich auf den Datentyp, der die Funktion zurück, da unsere Funktion nichts zurückgibt (es ist einfach führt Befehle), setzen wir den Rückgabetyp auf void. Wenn wir eine Funktion, die zwei Zahlen multipliziert erstellen und kehrte das Produkt könnten wir es wie folgt zu definieren:

    int Multiplikator (int number1, number2 int) {

    int product = number1 number2 *;
    zurück Produkt;

    }

    Beachten Sie, wie wir int als Rückgabetyp hier statt nichtig erklärt.

    Die Eingeweide der Funktion ist Sachen, die wir bisher gesehen haben. Es ist das gleiche für die Schleife waren wir in unserem letzten Skizze zu wiederholen, aber die Pin-Nummern sind mit den color1 und color2 Variablen ersetzt. Nennen wir:

    Fader (rot, grün);

    aus der Arduino-Schleife (), wertet das Arduino den Fader-Funktion mit color1 = rot und color2 = grün.

    Setzen Sie diese alle zusammen können wir die Skizze mit dieser Funktion wie folgt neu zu schreiben, wird dies genau das gleiche wie der Skizze an der Spitze dieses Schrittes zu arbeiten.

      // RGB LED - Fading zwischen Farben
     // Stiftverbindungen
     int rot = 9;
     int grün = 10;
     int blau = 11;
     Leere setup () {
       pinMode (rot, Ausgang);
       pinMode (blau, OUTPUT);
       pinMode (grün, OUTPUT);
     }
     Leere Schleife () {
       Fader (rot, grün);
       Fader (grün, blau);
       Fader (blau, rot);
     }
     Leere Fader (int color1, int color2) {
         for (int Helligkeit = 0; Helligkeit <256; Helligkeit ++) {
             analogWrite (color1, 255-Helligkeit);
             analogWrite (color2, Helligkeit);
             Verzögerung (10);
         }
     }
    

Schritt 10: Button

  1. Beginner Arduino

    Beginner Arduino

    Zeit für eine neue Art der Schaltung, jetzt werden wir auf, wie man Drucktasten mit Arduino nutzen suchen. Schaltflächen sind eine Art Schalter, die Art der Taste wir verwenden, wird als "Schließer Taster". "Schließer" bedeuten, wenn die Taste nicht gedrückt wird, wird kein Strom durch die Taste fließen, weil die beiden Seiten nicht miteinander verbunden sind - sie als offener Stromkreis bildet (siehe das erste Bild oben). "Momentary" bezieht sich auf die Tatsache, dass dieser Schalter nur so lange geschlossen, wie Sie es mit dem Finger drücken; dies macht es deutlich von einen Kippschalter, der jedes Mal, wenn Sie es drücken zwischen einer offenen und geschlossenen Zustand schaltet.

    Einen Druckknopf und einem Widerstand - die Taste Kreis wir benutzen ist aus zwei Komponenten zusammen. Im Gegensatz zu der LED-Schaltung, wir sind nicht besorgt über die Menge an Strom, die durch die Taste (bei sehr hohen Stromstärken haben wir vielleicht über das Schmelzen der Taste sorgen, aber das Arduino ist nicht so mächtig), so dass der Widerstand nicht handeln wie der Strombegrenzungswiderstand in der LED-Schaltung. Statt dieser Widerstand als wirkende Ziehwiderstand . Ein Pull-Down-Widerstand verknüpft einen Knopf zu erden, so daß die Messung der Spannung an der Verbindung zwischen dem Knopf und dem Widerstand wird immer auf 0 V (Masse), wenn die Taste nicht gedrückt wird (und die Schaltung geöffnet ist). In dieser Schaltung ist der Wert des Pull-down-Widerstand ist nicht wirklich wichtig, wie ich, um etwas in der Umgebung von 10kOhm verwenden.

    Hier ist die Schaltfläche Skizze:

      // Taste Drücken Erkennung
     int buttonPin = 7;
     Leere setup () {
       pinMode (buttonPin, INPUT); // dieses Mal werden wir das Pin als Eingang eingestellt
       Serial.begin (9600); // initialisieren Serielle Verbindung
     }
     Leere Schleife () {
       if (digitalRead (buttonPin) == HIGH) {// Wenn Taste gedrückt
         Serial.println ("gedrückt");
       } Else {
         Serial.println ("unverpressten");
       }
     }
    


    Die Schaltfläche Skizze stellt ein paar neue Ideen:

    digitalRead (Pin-Nummer) - ähnlich wie digital (), aber verwendet werden, um einen Wert von HIGH oder LOW in unseren Kreislauf zu messen. digitalRead () nimmt ein Argument - die Pin-Nummer, die wir von gerade lesen. Wir müssen auch sicherstellen, dass an den Eingangsstift richtig initialisiert:

    pinMode (buttonPin, INPUT);

    Serielle Kommunikation - Serielle Kommunikation lässt die Arduino-Nachrichten an den Computer senden, während ein Programm läuft, ist es nützlich für die Fehlersuche, das Senden von Nachrichten an andere Geräte oder Anwendungen, oder einfach ein besseres Gefühl dafür, was los ist in Ihrer Schaltung. To enable serial communication in your sketch, you have to initialize the serial connection in the Arduino's setup() function with the command Serial.begin() . Serial.begin() takes one argument, the baud rate, which is the rate of data transfer between the Arduino and your computer, 9600 is a good baud rate for now. In the following sketch we'll use Serial.println() to print messages in the Arduino IDE (Tools>>Serial Monitor).

    if/else - If/else statements gives us more control over which commands are executed when. In the button sketch I used the following if/else statement:

    if (digitalRead(buttonPin)==HIGH){

    Serial.println("pressed");

    } else {

    Serial.println("unpressed");

    }

    if the result of digitalRead(buttonPin) returns HIGH then the Arduino prints the word "pressed", if digitalRead(buttonPin) returns something other than HIGH (like LOW), the Arduino prints the word "unpressed". If statements can check for == ("equal to"), != ("not equal to"), >, <, >=, and <=. Try running the following if statement in the Arduino's loop():

    if (4>3){

    Serial.println("true");
    } else {

    Serial.println("false");
    }

    Try changing the if statement to evaluate other things.

Step 11: Arduino Digital Inputs and Outputs

  1. Now we can use the data from the button press to turn an LED on and off. Modify the sketch from the last step to turn on an LED connected to pin 8:

     //button press detection with LED output
     int buttonPin = 7;
    int ledPin = 8;
     Leere setup () {
      pinMode(buttonPin, INPUT);//this time we will set button pin as INPUT
      pinMode(ledPin, OUTPUT);
       Serial.begin (9600);
     }
     Leere Schleife () {
      if (digitalRead(buttonPin)==HIGH){
         digital (ledPin, HIGH);
        Serial.println("pressed");
       } Else {
        digitalWrite(ledPin,LOW);
        Serial.println("unpressed");
       }
     }
    


    Here is what it should look like:

Step 12: Arduino Analog Input

  1. Beginner Arduino

    Beginner Arduino

    analogRead(pinNumber) - analogRead() reads from one of the Arduino's analog pins and outputs a value between 0 (voltage at the pin = 0V) and 1023 (voltage at the pin = 5V), if the analog pin voltage was 2.5V, then it would print:

    2.5/5*1023 = 512

    analogRead() takes one argument - the name of the analog pin (A0-A5) to read from.

    A potentiometer is a resistor with a pin in the middle that connects to some point along the resistor's length. As you turn the potentiometer you move the center pin along the resistor and change the ratio of resistive materials on either side of the pin. This allows the potentiometer to act as a variable voltage divider .

    Connect the potentiometer so that the outside pins connect to 5V and ground (orientation does not matter), and the center pin connects to pin A0 on the Arduino. Run the following code and watch the output from the Serial Monitor.

     //analog input
    
    int potPin = A0;//center pin of the potentiometer is attached to pin A0
    
     Leere setup () {
      //analog pins are initilized as INPUT by default, no need for pinMode() command
       Serial.begin (9600);
     }
    
     Leere Schleife () {
      int potVal = analogRead(potPin);//potVal is a number between 0 and 1023
      Serial.println(potVal);
     } 

    Now turn the pot and see how the printed value of potVal changes. You should see the arduino print 1023 when you turn the pot all the way to the side that is connected to 5V, and 0 when you turn the pot all the way to the other side. You should also see a range of values printed in between those two extremes..

Step 13: Working with Analog Input Data

  1. Before using analog data to control other things in your program, you might need to scale it or constrain it between some min and max. For example, imagine you want to use the reading from your analog input to control the brightness of an LED with analogWrite(). analogRead() returns numbers between 0 and 1023, but analogWrite() only accepts numbers between 0 and 255. In this case you can use map() to scale the range of values coming out of analogRead() to something appropriate for analogWrite();

    map(value, fromLow, fromHigh, toLow, toHigh) - scale one range to another. map() accepts four inputs: the value we're trying to scale, the min of the range we're scaling from, the max of the range we're scaling from, the min of the range we're scaling to, and the max of the range we're scaling to.

    Here is an example:

     //analog input with map
    
    int potPin = A0;
    int ledPin = 9;
    
     Leere setup () {
      pinMode(ledPin, OUTPUT);
       Serial.begin (9600);
     }
    
     Leere Schleife () {
      int analogVal = analogRead(potPin);//analogVal is between 0 and 1023
      int scaledVal = map(analogVal, 0, 1023, 0, 255);//scaled val is between 0 and 255
      Serial.print("analogVal = ");
      Serial.print(analogVal);
      Serial.print(" scaledVal = ");
      Serial.print(scaledVal);
      analogWrite(ledPin, scaledVal);
     }
    


    Also check out constrain(x, a, b) - constrains a number x between a and b. If x is less than a constrain returns a, is x is greater than b constrain returns b, otherwise constrain returns x.

Step 14: Practice with Arduino Inputs and Outputs


  1. This next example combines the button detection sketch with the analog LED control sketch. Wire up a push button to pin 7, as shown in the schematic from step 10, and connect a pot to A0 and an LED to pin 9, as shown in step 13. Then upload the following code:

     //button press detection with LED output and variable intensity
     int buttonPin = 7;
    int ledPin = 9;
    int potPin = A0;
     Leere setup () {
       pinMode (buttonPin, INPUT);
      pinMode(ledPin, OUTPUT);
       Serial.begin (9600);
     }
     Leere Schleife () {
      if (digitalRead(buttonPin)==HIGH){//if button pressed
        int analogVal = analogRead(potPin);
        int scaledVal = map(analogVal, 0, 1023, 0, 255);
        analogWrite(ledPin, scaledVal);//turn on led with intensity set by pot
        Serial.println("pressed");
       } Else {
        digitalWrite(ledPin, LOW);//turn off if button is not pressed
        Serial.println("unpressed");
       }
     }
    

    This sketch turns an LED off and on depending on the state of the button (pressed/unpressed), and at the same time uses the potentiometer to control the brightness of the LED when it is in the "on" state.

Step 15: Button As Toggle Switch

  1. Sometimes you will be interested in the exact moment a button is pressed or released, so you can trigger an event in your sketch. In this case you will need to store the currentState of the button and compare it with the last recorded state. If the currentState is HIGH and the lastState is LOW, then you know the button has just been pressed. Take a look at the code below:

     //Button Press Detection - single message
    
     int buttonPin = 7;
    boolean currentState = LOW;//stroage for current button state
    boolean lastState = LOW;//storage for last button state
    
     Leere setup () {
      pinMode(buttonPin, INPUT);//this time we will set the pin as INPUT
      Serial.begin(9600);//initialize Serial connection
     }
    
     Leere Schleife () {
      currentState = digitalRead(buttonPin);
      if (currentState == HIGH && lastState == LOW){//if button has just been pressed
        Serial.println("pressed");
        delay(1);//crude form of button debouncing
      } else if(currentState == LOW && lastState == HIGH){
        Serial.println("released");
        delay(1);//crude form of button debouncing
       }
      lastState = currentState;
     }
    


    I used something new in my if statement:

    if (currentState == HIGH && lastState == LOW)

    this reads as "if currentState is HIGH and lastState is LOW", && allows us to check the truth of many things in the same if statement. You can also use || ("or") to test is one thing or the other is true. Read more here .

    You'll also notice the following line appears twice in the code above:

    delay(1);

    This delay was put in there to give the button time to settle to steady voltage before we start measuring it again, this is called button debouncing ; it prevents us from counting a single press as two presses due to button chatter . Using a delay to do button debouncing is fine for this simple example, but if you were measuring a lot of buttons the delays will add up and make your code execute very slow. This might end up giving your hardware a lagging feeling. I'll address some better techniques to do debouncing later in this class.
    This code also introduces a new data type: boolean . Booleans are used to store 1 bit pieces of information, things like true/false, on/off, 1/0, of HIGH/LOW. In my code I used it to store the current and last state of the button (HIGH or LOW).
    Here's how we could use this to toggle an LED on and off each time the button is pressed:

     //Button Toggle LED
    
    int ledPin = 9;
     int buttonPin = 7;
    boolean currentState = LOW;//stroage for current button state
    boolean lastState = LOW;//storage for last button state
    boolean ledState = LOW;//storage for the current state of the LED (off/on)
    
     Leere setup () {
      pinMode(buttonPin, INPUT);//this time we will set the pin as INPUT
      pinMode(ledPin, OUTPUT);
      Serial.begin(9600);//initialize Serial connection
     }
    
     Leere Schleife () {
      currentState = digitalRead(buttonPin);
      if (currentState == HIGH && lastState == LOW){//if button has just been pressed
        Serial.println("pressed");
        delay(1);//crude form of button debouncing
        
        //toggle the state of the LED
        if (ledState == HIGH){
          digitalWrite(ledPin, LOW);
          ledState = LOW;
         } Else {
           digital (ledPin, HIGH);
          ledState = HIGH;
         }
       }
      
      lastState = currentState;
     } 

    In the code above I set up a variable called "ledState" to store the current state of the LED, then each time the button was pressed, I used digitalWrite to set the LED to the opposite state and saved a new ledState.
    Going even further, you can use the button toggle code with the fader code from the RGB LED example for the following:

     //Button Press Detection - single message
    
    //pin connections
    int red = 9;
    int green = 10;
    int blue = 11;
     int buttonPin = 7;
    
    boolean currentState = LOW;//stroage for current button state
    boolean lastState = LOW;//storage for last button state
    int currentColor = red;//storage for current color
    
     Leere setup () {
      pinMode(buttonPin, INPUT);//this time we will set the pin as INPUT
       pinMode (rot, Ausgang);
       pinMode (blau, OUTPUT);
       pinMode (grün, OUTPUT);
      Serial.begin(9600);//initialize Serial connection
      digitalWrite(currentColor, HIGH);//initialize with currentColor on (full brightness)
     }
    
     Leere Schleife () {
      currentState = digitalRead(buttonPin);
      if (currentState == HIGH && lastState == LOW){//if button has just been pressed
        Serial.println("pressed");
        delay(1);//crude form of button debouncing
    
        int nextColor = getNextColor(currentColor);
        fader(currentColor, nextColor);
        currentColor = nextColor;
    
       }
    
      lastState = currentState;
    
     }
    
    int getNextColor(int color){//helper function that gives us the next color to fade to
      if (color == red) return green;
      if (color == green) return blue;
      if (color == blue) return red;
     }
    
    void fader(int color1, int color2){
        for (int brightness=0;brightness<256;brightness++){
            analogWrite(color1, 255-brightness);
            analogWrite(color2, brightness);
            delay(2);
         }
     }
    


    I added an extra helper function in the code above to help choose the next color to fade to:

    int getNextColor(int color){

    if (color == red) return green;
    if (color == green) return blue;
    if (color == blue) return red;

    }

    I declared the function with an int to tell Arduino that it should expect the function to return a number (in this case, the number of the Arduino pin that's connected to one of the RGB LED's pins. The if statements look a little different that what we've seen before, I could have written the function like this:

     int getNextColor(int color){
      if (color == red) {
        return green;
       }
      if (color == green) {
        return blue;
       }
      if (color == blue) {
        return red;
       }
     }
    

    ....and it would work in the exact same way. If you only need to execute one line in an if statement, you can use the shorthand:
    if (something) doSomething;
    without any curly braces or linebreaks.
    Continue to part 2 of this series here, or learn how to hook up MIDI to the Arduino's inputs and outputs.