http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                          Wels, am 2014-08-10

arduino uno tutorial Bestseller Test

Arduino Starter Kit - English Edition  95,80 €

Beschreibung

Ks0069(72, 73) keyestudio Basic Starter Kit for Arduino Starters

keyestudio Basic Starter Kit for UNO and Mega

1. Kit-Einführung

Dies ist das grundlegende Starter Kit, das speziell für Anfänger entwickelt wurde, die sich für Arduino interessieren. Sie verfügen über eine Reihe von Arduinos am häufigsten verwendeten und nützlichsten elektronischen Komponenten. Was ist mehr. Wir bieten Ihnen ausführliche Tutorials mit Projekteinführung und deren Quellcodes an. Sie können Arduino durch die Verwendung dieser grundlegenden Projekte kennen lernen. Dieses Kit hilft Ihnen, die physische Welt mit Sensoren zu steuern.

2.Kit Inhalt

3. Projektliste

1. Hallo Welt
2. LED blinkt
3. PWM
4. Verkehr Licht
5. LED Chase-Effekt
6. Tastengesteuerte LED
7. Aktiver Summer
8. Passiver Summer
9.RGB LED
10. Fotowiderstand
11.Flammensensor
12.LM35 Temperatursensor
13. Neigungsschalter
14. IR Fernbedienung
15.Analog-Wertablesung
16.74HC595
17.1-stellige LED-Segmentanzeige
18,4-stellige LED-Segmentanzeige
19,8 * 8 LED-Matrix
20.1602 LCD
21,9 g Servosteuerung

4. Projektdetails

Projekt 1: Hello World

Einführung:

Für den Anfang beginnen wir mit etwas Einfachem. In diesem Projekt benötigen Sie nur ein Arduino und ein USB-Kabel, um die "Hello World!" Zu starten. Experiment. Dies ist ein Kommunikationstest für Ihr Arduino und Ihren PC, auch ein Primer-Projekt für Sie, um Ihren ersten Versuch mit der Arduino-Welt zu machen!

Hardware erforderlich:
1. Arduino-Board x1
2. USB-Kabel x1

Beispielcode:
Öffnen Sie nach der Installation des Treibers für Arduino die Arduino-Software und kompilieren Sie den Code, mit dem Arduino "Hello World!" Drucken kann. unter deiner Anweisung. Natürlich können Sie Code für Arduino kompilieren, um ständig "Hello World!" Zu wiederholen. ohne Anweisung. Eine einfache If () - Anweisung führt den Befehlstrick aus. Wenn die integrierte LED an Pin 13 angeschlossen ist, können Sie die LED anweisen, zuerst zu blinken, wenn Arduino eine Anweisung erhält, und dann "Hello World!" Zu drucken.

int val;//define variable valint ledpin=13;// define digital interface 13void setup(){  Serial.begin(9600);// set the baud rate at 9600 to match the software set up. When connected to a specific device, (e.g. bluetooth), the baud rate needs to be the same with it.  pinMode(ledpin,OUTPUT);// initialize digital pin 13 as output. When using I/O ports on an Arduino, this kind of set up is always needed.}void loop(){  val=Serial.read();// read the instruction or character from PC to Arduino, and assign them to Val.  if(val=='R')// determine if the instruction or character received is “R”.  {  // if it’s “R”,        digitalWrite(ledpin,HIGH);// set the LED on digital pin 13 on.     delay(500);digitalWrite(ledpin,LOW);// set the LED on digital pin 13 off.    delay(500);    Serial.println("Hello World!");// display“Hello World！”string.  }}

Result:
Screenshot

Klicken Sie auf Monitor für serielle Schnittstelle
Eingabe R
LED 13 blinkt einmal ；
Der PC erhält Informationen von Arduino: Hello World

Nachdem Sie den richtigen Port ausgewählt haben, sollte das Experiment leicht für Sie sein!

Projekt 2: LED blinkt

Einführung:

Blinkendes LED-Experiment ist ziemlich einfach. In der "Hallo Welt!" Programm sind wir auf LED gestoßen. Diesmal werden wir eine LED an einen der digitalen Pins anschließen, anstatt LED13 zu verwenden, die auf die Platine gelötet ist. Außer einem Arduino und einem USB-Kabel benötigen wir zusätzliche Teile wie folgt:

Hardware erforderlich:
1. Rote M5-LED * 1
2. 220Ω Widerstand * 1
3. Brotschneidebrett * 1
4. Breadboard-Überbrückungsdrähte * mehrere

Wir folgen dem Diagramm des experimentellen Schaltplans. Hier verwenden wir den digitalen Pin 10. Wir verbinden die LED mit einem 220-Ohm-Widerstand, um zu vermeiden, dass die LED durch hohen Strom beschädigt wird.

Connection for UNO R3:

Connection for 2560 R3:

Sample Code:  Beispielcode: Sketch

int ledPin = 10; // define digital pin 10.void setup(){pinMode(ledPin, OUTPUT);// define pin with LED connected as output.}void loop(){digitalWrite(ledPin, HIGH); // set the LED on.delay(1000); // wait for a second.digitalWrite(ledPin, LOW); // set the LED off.delay(1000); // wait for a second}

Projekt 3: PWM

Einführung:

PWM, kurz für Pulse Width Modulation, ist eine Technik, mit der analoge Signalpegel in digitale Pegel umgewandelt werden. Ein Computer kann keine analoge Spannung ausgeben, sondern nur digitale Spannungswerte wie 0 V oder 5 V. Daher verwenden wir einen Zähler mit hoher Auflösung, um einen bestimmten analogen Signalpegel zu codieren, indem das Tastverhältnis von PMW moduliert wird. Das PWM-Signal wird auch digitalisiert, da die Gleichstromversorgung zu einem bestimmten Zeitpunkt entweder 5 V (EIN) oder 0 V (AUS) beträgt. Die Spannung oder der Strom wird der analogen Last (dem Gerät, das den Strom verwendet) zugeführt, indem die Impulsfolge wiederholt wird (EIN oder AUS). Wenn er eingeschaltet ist, wird der Strom der Last zugeführt; aus sein ist es nicht. Bei ausreichender Bandbreite kann jeder analoge Wert mit PWM codiert werden. Der Ausgangsspannungswert wird über die Ein- und Ausschaltzeit berechnet. Ausgangsspannung = (Einschaltzeit / Impulszeit) * maximaler Spannungswert

PWM hat viele Anwendungen: Lampenhelligkeitsregelung, Motordrehzahlregelung, Geräuschentwicklung usw. Im Folgenden werden die drei grundlegenden Parameter von PMW aufgeführt:

1. Die Amplitude der Impulsbreite (Minimum / Maximum)
2. Die Pulsperiode (Der Kehrwert der Pulsfrequenz in 1 Sekunde)
3. Der Spannungspegel （wie 0 0V-5V
Auf Arduino gibt es 6 PMW-Schnittstellen, nämlich digitale Pins 3, 5, 6, 9, 10 und 11. In früheren Experimenten haben wir "knopfgesteuerte LED" mit digitalem Signal zur Steuerung des digitalen Pins, auch eines über Potentiometer, durchgeführt . Diesmal verwenden wir ein Potentiometer, um die Helligkeit der LED zu regeln.

Hardware erforderlich:
1. Potentiometer * 1
2. Rote M5-LED * 1
3. 220Ω Widerstand
4. Brotschneidebrett * 1
5. Breadboard-Überbrückungsdrähte * mehrere
Der Eingang des Potentiometers ist analog, also verbinden wir ihn mit dem analogen Port und die LED mit dem PWM-Port. Unterschiedliches PWM-Signal kann die Helligkeit der LED regeln.

Anschluss für UNO R3:

Connection for 2560 R3:

Beispielcode:
Bei der Programmkompilierung verwenden wir die Funktion analogWrite (PWM-Schnittstelle, Analogwert). In diesem Experiment lesen wir den analogen Wert des Potentiometers und weisen den Wert dem PWM-Port zu. Daher ändert sich die Helligkeit der LED entsprechend. Ein letzter Teil wird den Analogwert auf dem Bildschirm anzeigen. Sie können dies als das Projekt "Analogwert lesen" betrachten, indem Sie den PWM-Analogwertzuweisungsteil hinzufügen. Nachfolgend finden Sie ein Beispielprogramm für Ihre Referenz.

int potpin=0;// initialize analog pin 0int ledpin=11;//initialize digital pin 11（PWM output）int val=0;// Temporarily store variables' value from the sensorvoid setup(){pinMode(ledpin,OUTPUT);// define digital pin 11 as “output”Serial.begin(9600);// set baud rate at 9600// attention: for analog ports, they are automatically set up as “input”}void loop(){val=analogRead(potpin);// read the analog value from the sensor and assign it to valSerial.println(val);// display value of valanalogWrite(ledpin,val/4);// turn on LED and set up brightness（maximum output of PWM is 255）delay(10);// wait for 0.01 second}

Ergebnis:
Nach dem Herunterladen des Programms können wir, wenn wir den Potentiometer-Knopf drehen, Änderungen des Anzeigewerts und auch offensichtliche Änderungen der LED-Helligkeit auf dem Steckbrett sehen.

Projekt 4: Ampel

Einleitung: Im vorherigen Programm haben wir das LED-Blinkexperiment mit einer LED durchgeführt. Jetzt ist es an der Zeit, die Einsätze zu erhöhen und kompliziertere Experiment-Ampeln zu machen. Eigentlich sind diese beiden Experimente ähnlich. In diesem Ampelexperiment verwenden wir 3 LEDs mit einer anderen Farbe als 1 LED.

Hardware erforderlich:
1. Arduino-Board * 1
2. USB-Kabel * 1
3. Rote M5-LED * 1
4. Gelbe M5-LED * 1
5. Grüne M5-LED * 1
6. 220Ω Widerstand * 3
7. Brotschneidebrett * 1
8. Breadboard-Überbrückungsdrähte * mehrere

Anschluss für UNO R3:

Anschluss Connection for 2560 R3:

Beispielcode:
Da es sich um eine Simulation von Ampeln handelt, sollte die Blinkzeit jeder LED dieselbe sein wie in Ampelsystemen. In diesem Programm verwenden wir die Arduino delay () - Funktion, um die Verzögerungszeit zu steuern, was viel einfacher ist als die Sprache C.

int redled =10; // initialize digital pin 8.int yellowled =7; // initialize digital pin 7.int greenled =4; // initialize digital pin 4.void setup(){pinMode(redled, OUTPUT);// set the pin with red LED as “output”pinMode(yellowled, OUTPUT); // set the pin with yellow LED as “output”pinMode(greenled, OUTPUT); // set the pin with green LED as “output”}void loop(){digitalWrite(greenled, HIGH);//// turn on green LEDdelay(5000);// wait 5 secondsdigitalWrite(greenled, LOW); // turn off green LEDfor(int i=0;i<3;i++)// blinks for 3 times{delay(500);// wait 0.5 seconddigitalWrite(yellowled, HIGH);// turn on yellow LEDdelay(500);// wait 0.5 seconddigitalWrite(yellowled, LOW);// turn off yellow LED} delay(500);// wait 0.5 seconddigitalWrite(redled, HIGH);// turn on red LEDdelay(5000);// wait 5 seconddigitalWrite(redled, LOW);// turn off red LED}

Ergebnis:
Wenn der Upload-Vorgang abgeschlossen ist, sehen wir Ampeln nach eigenem Design. Hinweis: Dieses Schaltungsdesign ist dem des LED-Chase-Effekts sehr ähnlich. Das grüne Licht leuchtet 5 Sekunden lang auf und ist dann aus. Anschließend blinkt das gelbe Licht dreimal und dann das rote Licht für 5 Sekunden, wodurch ein Zyklus entsteht. Zyklus wiederholt sich dann. Das Experiment ist jetzt abgeschlossen, danke.

Projekt 5: LED-Jagdeffekt

Einführung:
Wir sehen oft Werbetafeln aus bunten LEDs. Sie verändern sich ständig zu verschiedenen Effekten. In diesem Experiment erstellen wir ein Programm, um den Chase-Effekt zu simulieren.

Hardware erforderlich:
1. Led x6
2. 220 Ω Widerstand x6
3. Bunte Breadboard-Drähte

Anschluss für UNO R3:

Connection for 2560 R3:

Sample Code:

int BASE = 2 ;  // the I/O pin for the first LEDint NUM = 6;   // number of LEDsvoid setup(){   for (int i = BASE; i < BASE + NUM; i ++)    {     pinMode(i, OUTPUT);   // set I/O pins as output   }}void loop(){   for (int i = BASE; i < BASE + NUM; i ++)    {     digitalWrite(i, LOW);    // set I/O pins as “low”, turn off LEDs one by one.     delay(200);        // delay   }   for (int i = BASE; i < BASE + NUM; i ++)    {     digitalWrite(i, HIGH);    // set I/O pins as “high”, turn on LEDs one by one     delay(200);        // delay   }  }

Ergebnis:
Sie können sehen, dass die LEDs der Reihe nach blinken.

Projekt 6: Tastengesteuerte LED

Einführung:
E / A-Port bedeutet Schnittstelle für INPUT und OUTPUT. Bisher haben wir nur die OUTPUT-Funktion verwendet. In diesem Experiment versuchen wir, die Eingabefunktion zu verwenden, mit der der Ausgabewert des angeschlossenen Geräts gelesen wird. Wir verwenden 1 Taste und 1 LED mit Eingang und Ausgang, um die E / A-Funktion besser zu verstehen. Die meisten von uns bekannten Tastschaltern sind eine Schaltwertkomponente (digitaler Wert). Wenn er gedrückt wird, befindet sich der Stromkreis im geschlossenen (leitenden) Zustand.

Hardware erforderlich:
1. Tastenschalter * 1
2. Rote M5-LED * 1
3. 220Ω Widerstand * 1
4. 10 KΩ Widerstand * 1
5. Brotschneidebrett * 1
6. Breadboard-Überbrückungsdrähte * mehrere

Anschluss für UNO R3:

Connection for 2560 R3:

Beispielcode:
Beginnen wir mit dem Kompilieren. Wenn die Taste gedrückt wird, leuchtet die LED. Nach der vorherigen Studie sollte die Kodierung für Sie einfach sein. In diesem Programm fügen wir eine Beurteilung hinzu. Hier verwenden wir eine if () - Anweisung.
Arduino IDE basiert auf der C-Sprache, so dass Aussagen der C-Sprache wie while, switch usw. durchaus für das Arduino-Programm verwendet werden können.
Wenn wir die Taste drücken, gibt Pin 7 einen hohen Pegel aus. Wir können Pin 11 so programmieren, dass er einen hohen Pegel ausgibt und die LED einschalten. Wenn Pin 7 einen niedrigen Pegel ausgibt, gibt Pin 11 auch einen niedrigen Pegel aus und die LED bleibt aus.

int ledpin=11;// initialize pin 11int inpin=7;// initialize pin 7int val;// define valvoid setup(){pinMode(ledpin,OUTPUT);// set LED pin as “output”pinMode(inpin,INPUT);// set button pin as “input”}void loop(){val=digitalRead(inpin);// read the level value of pin 7 and assign if to valif(val==LOW)// check if the button is pressed, if yes, turn on the LED{ digitalWrite(ledpin,LOW);}else{ digitalWrite(ledpin,HIGH);}}

Projekt 7: Aktiver Summer

Einleitung: Aktive Summer ist weit verbreitet auf Computern, Druckern, Weckern, elektronischem Spielzeug, Telefon, Timer usw. als Soundelement. Es hat eine innere Schwingungsquelle. Schließen Sie es einfach an eine 5-V-Stromversorgung an, es kann ununterbrochen summt.

Hardware erforderlich:
1. Summer * 1
2. Schlüssel * 1
3. Brotschneidebrett * 1
4. Breadboard-Überbrückungsdrähte * mehrere

Anschluss für UNO R3:

Connection for 2560 R3:

Achten Sie beim Anschließen des Stromkreises auf die positiven und negativen Pole des Summers. Auf dem Foto sehen Sie rote und schwarze Linien. Wenn die Schaltung beendet ist, können Sie mit der Programmierung beginnen.

Beispielcode:
Das Programm ist einfach. Sie steuern den Summer durch Ausgabe eines hohen / niedrigen Pegels.

  int Summer = 8; // Initialisiert den digitalen IO-Pin, der den Summer steuert void setup ()  {    pinMode (Summer, OUTPUT); // Pin-Modus als "Ausgang" setzen }  Leere Schleife ()  { DigitalWrite (Summer, HIGH);  // Sound erzeugen } 

Ergebnis:
Nach dem Herunterladen des Programms ist das Summer-Experiment abgeschlossen. Sie können sehen, dass der Summer klingelt.

Projekt 8: Passiver Summer

Einleitung: Wir können Arduino verwenden, um viele interaktive Werke zu erstellen, von denen das am häufigsten verwendete akustisch-optische Display ist. Alle vorherigen Experimente haben etwas mit LED zu tun. Die Schaltung in diesem Experiment kann jedoch Ton erzeugen. Normalerweise wird das Experiment mit einem Summer oder Lautsprecher durchgeführt, während der Summer einfacher und benutzerfreundlicher ist. Der hier vorgestellte Summer ist ein passiver Summer. Es kann nicht von selbst betätigt werden, sondern durch externe Impulsfrequenzen. Unterschiedliche Frequenzen erzeugen unterschiedliche Klänge. Wir können Arduino verwenden, um die Melodie eines Songs zu codieren, was eigentlich ziemlich lustig und einfach ist.

Hardware erforderlich:
1. Passiver Summer * 1
2. Schlüssel * 1
3. Brotschneidebrett * 1
4. Breadboard-Überbrückungsdrähte * mehrere

Anschluss für UNO R3:

Connection for 2560 R3:

Sample Code:

int buzzer=8;// select digital IO pin for the buzzervoid setup() { pinMode(buzzer,OUTPUT);// set digital IO pin pattern, OUTPUT to be output } void loop() { unsigned char i,j;//define variablewhile(1) { for(i=0;i<80;i++)// output a frequency sound{ digitalWrite(buzzer,HIGH);// sounddelay(1);//delay1ms digitalWrite(buzzer,LOW);//not sounddelay(1);//ms delay } for(i=0;i<100;i++)// output a frequency sound{ digitalWrite(buzzer,HIGH);// sounddigitalWrite(buzzer,LOW);//not sounddelay(2);//2ms delay }} } 

Projekt 9: RGB-LED

Einleitung: Tricolor-Prinzip zur Anzeige verschiedener Farben
PWM-Steueranschlüsse für die Anzeige von Farbe
Kann direkt über Arduino PWM-Schnittstellen gesteuert werden

Hardware erforderlich:
Arduino-Controller × 1
USB-Kabel × 1
Vollfarb-LED-Modul × 1

Anschluss für UNO R3:

Connection for 2560 R3:

Sample Code:

int redpin = 11; //select the pin for the red LEDint bluepin =10; // select the pin for the blue LEDint greenpin =9;// select the pin for the green LEDint val;void setup() {  pinMode(redpin, OUTPUT);  pinMode(bluepin, OUTPUT);  pinMode(greenpin, OUTPUT);  Serial.begin(9600);}void loop() {for(val=255; val>0; val--)  {   analogWrite(11, val);   analogWrite(10, 255-val);   analogWrite(9, 128-val);   delay(1);   }for(val=0; val<255; val++)  {   analogWrite(11, val);   analogWrite(10, 255-val);   analogWrite(9, 128-val);   delay(1);   } Serial.println(val, DEC);}

Projekt 10: Fotowiderstand

Einführung: Nach Abschluss aller vorherigen Experimente haben wir ein grundlegendes Verständnis und Wissen über die Arduino-Anwendung erworben. Wir haben digitale Ein- und Ausgabe, analoge Eingabe und PWM gelernt. Nun können wir mit dem Erlernen von Sensoranwendungen beginnen.
Der Fotowiderstand (Photovaristor) ist ein Widerstand, dessen Widerstand sich je nach einfallender Lichtstärke ändert. Es basiert auf dem photoelektrischen Effekt von Halbleitern. Wenn das einfallende Licht intensiv ist, verringert sich sein Widerstand; Ist das einfallende Licht schwach, steigt der Widerstand. Der Photovaristor wird üblicherweise bei der Messung von Licht, Lichtsteuerung und Photovoltaik-Umwandlung (Umwandlung der Lichtänderung in die Änderung der Elektrizität) eingesetzt.
Fotowiderstand wird auch in großem Umfang auf verschiedene Lichtsteuerkreise angewendet, wie Lichtsteuerung und -einstellung, optische Schalter usw. Wir beginnen mit einem relativ einfachen Experiment bezüglich der Anwendung von Fotovaristoren. Der Fotovaristor ist ein Element, das seinen Widerstand ändert, wenn sich das Licht ändert. Wir müssen also die analogen Werte lesen. Wir können auf das PWM-Experiment verweisen, das das Potentiometer durch einen Fotovaristor ersetzt. Wenn sich die Lichtstärke ändert, ändert sich auch die LED.

Hardware erforderlich:
Fotowiderstand * 1
Rote M5-LED * 1
10KΩ Widerstand * 1
220 Ω-Widerstand * 1
Brotbrett * 1
Steckbrückendrähte der Brotplatine *

Anschluss für UNO R3:

Connection for 2560 R3:

Beispielcode:
Nach der Verbindung beginnen wir mit dem Kompilieren des Programms. Das Programm ähnelt dem von PWM. Einzelheiten zu den Änderungen finden Sie im nachstehenden Beispielprogramm.

int potpin=0;// initialize analog pin 0, connected with photovaristorint ledpin=11;// initialize digital pin 11, output regulating the brightness of LEDint val=0;// initialize variable vavoid setup(){pinMode(ledpin,OUTPUT);// set digital pin 11 as “output”Serial.begin(9600);// set baud rate at “9600”}void loop(){val=analogRead(potpin);// read the analog value of the sensor and assign it to valSerial.println(val);// display the value of valanalogWrite(ledpin,val);// turn on the LED and set up brightness（maximum output value 255）delay(10);// wait for 0.01}

Projekt 11: Flammensensor

Einleitung: Der Flammensensor (Infrarot-Empfangstriode) wird speziell bei Robotern verwendet, um die Feuerquelle zu finden. Dieser Sensor hat eine hohe Flammenempfindlichkeit. Unten ist ein Foto davon

Sensoranschluss:
Die kürzere Leitung der Empfangstriode ist für negativ, die andere für positiv. Schließen Sie das Negativ an den 5 V-Pin an, das Plus an den Widerstand. Verbinden Sie das andere Ende des Widerstands mit GND, verbinden Sie ein Ende eines Überbrückungskabels mit einer Klemme, die elektrisch mit dem positiven Sensor verbunden ist, und mit dem anderen Ende mit dem analogen Pin. Wie nachfolgend dargestellt:

Versuchsverbindung:
1） Summer anschließen:
Schließen Sie die Controller-Platine, die Prototyp-Platine, das Steckbrett und das USB-Kabel gemäß der Arduino-Anleitung an. Schließen Sie den Summer an den digitalen Pin 8 an.

2, Flammenfühler anschließen:
Verbinden Sie den Sensor mit Analog Pin 0.

Anschluss für UNO R3:

Connection for 2560 R3:

Beispielcode:

int flame=0;// select analog pin 0 for the sensor int Beep=9;// select digital pin 9 for the buzzer int val=0;// initialize variable void setup() {  pinMode(Beep,OUTPUT);// set LED pin as “output” pinMode(flame,INPUT);// set buzzer pin as “input” Serial.begin(9600);// set baud rate at “9600” } void loop() {   val=analogRead(flame);// read the analog value of the sensor   Serial.println(val);// output and display the analog value  if(val>=600)// when the analog value is larger than 600, the buzzer will buzz  {     digitalWrite(Beep,HIGH);    }else    {       digitalWrite(Beep,LOW);     }   delay(500); }

Projekt 12: LM35 Temperatursensor

Einleitung: LM35 ist ein gängiger und einfach zu verwendender Temperatursensor. Es ist keine andere Hardware erforderlich. Sie benötigen nur einen analogen Anschluss, damit es funktioniert. Die Schwierigkeit besteht darin, den Code zu kompilieren, um den gelesenen Analogwert in Celsius-Temperatur umzuwandeln.

Hardware erforderlich:
1. LM35 * 1
2. Brotschneidebrett * 1
3. Breadboard-Überbrückungsdrähte * mehrere

Anschluss für UNO R3:

Connection for 2560 R3:

Sample Code:

int potPin = 0; // initialize analog pin 0 for LM35 temperature sensorvoid setup(){Serial.begin(9600);// set baud rate at”9600”}void loop(){int val;// define variableint dat;// define variableval=analogRead(0);// read the analog value of the sensor and assign it to valdat=(125*val)>>8;// temperature calculation formulaSerial.print("Tep:");// output and display characters beginning with TepSerial.print(dat);// output and display value of datSerial.println("C");// display “C” charactersdelay(500);// wait for 0.5 second}

Ergebnis:
Nach dem Herunterladen des Programms können Sie das Überwachungsfenster öffnen, um die aktuelle Temperatur anzuzeigen.

Projekt 13: Neigungsschalter

Einleitung: Neigungsschalter zum Ein- und Ausschalten der LED

Hardware erforderlich:
1. Kugelschalter * 1
2. Led * 1
3. 220Ω Widerstand * 1
4. 10 KΩ Widerstand * 1
4. Breadboard-Überbrückungsdrähte: mehrere

Anschluss für UNO R3:

Connection for 2560 R3:

Versuchsprinzip: Wenn sich ein Ende des Schalters unterhalb der horizontalen Position befindet, ist der Schalter eingeschaltet. Die Spannung des Analoganschlusses beträgt ungefähr 5 V (1023 in binär). Die LED leuchtet auf. Wenn sich das andere Ende des Schalters unterhalb der horizontalen Position befindet, ist der Schalter ausgeschaltet. Die Spannung des Analoganschlusses beträgt ungefähr 0 V (0 in binär). Die LED erlischt. Im Programm bestimmen wir, ob der Schalter gemäß dem Spannungswert des analogen Anschlusses ein- oder ausgeschaltet ist, ob er über 2,5 V (512 in binär) liegt oder nicht.

Beispielcode:

void setup() {   pinMode(8,OUTPUT);// set digital pin 8 as “output” } void loop() { int i;// define variable i while(1) {   i=analogRead(5);// read the voltage value of analog pin 5   if(i>512)// if larger that 512（2.5V）   {     digitalWrite(8,LOW);// turn on LED   }   else// otherwise   {     digitalWrite(8,HIGH);// turn off LED   }  } }

Projekt 14: IR-Fernbedienung

Einleitung: Was ist ein Infrarotempfänger?
Das Signal von der Infrarot-Fernbedienung ist eine Reihe von binären Pulscodes. Um Interferenzen von anderen Infrarotsignalen während der drahtlosen Übertragung zu vermeiden, wird das Signal bei einer bestimmten Trägerfrequenz vormoduliert und dann von einer Infrarotemissionsdiode ausgesendet. Das Infrarotempfangsgerät muss andere Wellen ausfiltern und ein Signal mit dieser spezifischen Frequenz empfangen und es wieder in einen binären Pulscode (Demodulation) zurückmodulieren.

Arbeitsleiter:
Der eingebaute Empfänger wandelt das vom Sender empfangene Lichtsignal in ein schwaches elektrisches Signal um. Das Signal wird vom IC-Verstärker verstärkt. Nach der automatischen Verstärkungssteuerung, Bandpassfilterung, Demodulation und Wellenformung kehrt sie zum ursprünglichen Code zurück. Der Code wird dann durch den Signalausgangsstift des Empfängers in die Codeidentifikationsschaltung eingegeben. Der Stift und der Anschluss des Infrarotempfangskopfs.
Pin und Verdrahtung des Infrarotempfängers:

Hardware erforderlich:
Infrarot-Fernbedienung x1
Infrarotempfänger x1
LED x6
220 Ω Widerstand x6
Mehrfarbige Breadboard-Drähte x mehrere

Verbindung:

Verbinden Sie zuerst die Controller-Platine. Schließen Sie dann den Infrarotempfänger wie oben erwähnt an, verbinden Sie VOUT mit Digital Pin 11, verbinden Sie die LEDs mit Widerständen und verbinden Sie die Widerstände mit Pin 2,3,4,5,6,7.

Anschluss für UNO R3:

Connection for 2560 R3:

• Die Definition von logisch 0 und 1 ist wie folgt

• Der Impuls wird gesendet, wenn die Taste gedrückt und sofort losgelassen wird.

• Der Impuls wird gesendet, wenn die Taste gedrückt und nach einer bestimmten Zeit wieder losgelassen wird

• Impuls wiederholen

Beispielcode:

#include <IRremote.h>int RECV_PIN = 11;int LED1 = 2;int LED2 = 3;int LED3 = 4;int LED4 = 5;int LED5 = 6;int LED6 = 7;long on1  = 0x00FFA25D;long off1 = 0x00FFE01F;long on2 = 0x00FF629D;long off2 = 0x00FFA857;long on3 = 0x00FFE21D;long off3 = 0x00FF906F;long on4 = 0x00FF22DD;long off4 = 0x00FF6897;long on5 = 0x00FF02FD;long off5 = 0x00FF9867;long on6 = 0x00FFC23D;long off6 = 0x00FFB047;IRrecv irrecv(RECV_PIN);decode_results results;// Dumps out the decode_results structure.// Call this after IRrecv::decode()// void * to work around compiler issue//void dump(void *v) {//  decode_results *results = (decode_results *)vvoid dump(decode_results *results) {  int count = results->rawlen;  if (results->decode_type == UNKNOWN)     {     Serial.println("Could not decode message");    }   else    {    if (results->decode_type == NEC)       {       Serial.print("Decoded NEC: ");      }     else if (results->decode_type == SONY)       {       Serial.print("Decoded SONY: ");      }     else if (results->decode_type == RC5)       {       Serial.print("Decoded RC5: ");      }     else if (results->decode_type == RC6)       {       Serial.print("Decoded RC6: ");      }     Serial.print(results->value, HEX);     Serial.print(" (");     Serial.print(results->bits, DEC);     Serial.println(" bits)");   }     Serial.print("Raw (");     Serial.print(count, DEC);     Serial.print("): ");  for (int i = 0; i < count; i++)      {      if ((i % 2) == 1) {      Serial.print(results->rawbuf[i]*USECPERTICK, DEC);     }     else       {      Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC);     }    Serial.print(" ");     }      Serial.println("");     }void setup() {  pinMode(RECV_PIN, INPUT);     pinMode(LED1, OUTPUT);  pinMode(LED2, OUTPUT);  pinMode(LED3, OUTPUT);  pinMode(LED4, OUTPUT);  pinMode(LED5, OUTPUT);  pinMode(LED6, OUTPUT);    pinMode(13, OUTPUT);  Serial.begin(9600);   irrecv.enableIRIn(); // Start the receiver }int on = 0;unsigned long last = millis();void loop() {  if (irrecv.decode(&results))    {    // If it's been at least 1/4 second since the last    // IR received, toggle the relay    if (millis() - last > 250)       {       on = !on;//       digitalWrite(8, on ? HIGH : LOW);       digitalWrite(13, on ? HIGH : LOW);       dump(&results);      }    if (results.value == on1 )       digitalWrite(LED1, HIGH);    if (results.value == off1 )       digitalWrite(LED1, LOW);     if (results.value == on2 )       digitalWrite(LED2, HIGH);    if (results.value == off2 )       digitalWrite(LED2, LOW);     if (results.value == on3 )       digitalWrite(LED3, HIGH);    if (results.value == off3 )       digitalWrite(LED3, LOW);    if (results.value == on4 )       digitalWrite(LED4, HIGH);    if (results.value == off4 )       digitalWrite(LED4, LOW);     if (results.value == on5 )       digitalWrite(LED5, HIGH);    if (results.value == off5 )       digitalWrite(LED5, LOW);     if (results.value == on6 )       digitalWrite(LED6, HIGH);    if (results.value == off6 )       digitalWrite(LED6, LOW);            last = millis();          irrecv.resume(); // Receive the next value  }}

Dekodieren Sie das von der Fernbedienung ausgegebene codierte Impulssignal. entsprechende Aktion entsprechend den Ergebnissen der Dekodierung ausführen. Auf diese Weise können Sie Ihr Gerät mit der Fernbedienung steuern.

Ergebnis:
Bildschirmfoto

Projekt 15: Analogwertablesung

Einführung: In diesem Experiment beginnen wir mit dem Erlernen von analogen E / A-Schnittstellen. Auf einem Arduino gibt es 6 analoge Schnittstellen, die von 0 bis 5 nummeriert sind. Diese 6 Schnittstellen können auch als digitale Schnittstellen mit der Nummer 14-19 verwendet werden. Nach einer kurzen Einführung beginnen wir unser Projekt. Das hier verwendete Potentiometer ist eine typische uns bekannte Ausgangskomponente des Analogwerts.

Hardware erforderlich:
1.Potentiometer * 1
2.Schneidebrett * 1
3.Breadboard-Überbrückungskabel * mehrere

Verbindung:
In diesem Experiment werden wir den Widerstandswert des Potentiometers in analoge Werte umwandeln und auf dem Bildschirm anzeigen. Dies ist eine Anwendung, die wir für unsere zukünftigen Experimente gut beherrschen müssen.
Anschlussschaltung wie folgt:

Anschluss für UNO R3:

Connection for 2560 R3:

Beispielcode:

Das Programmieren ist einfach. Eine analogRead () - Anweisung kann den Wert der Schnittstelle lesen. Die A / D-Erfassung von Arduino 328 erfolgt in 10 Bit, der gelesene Wert liegt also zwischen 0 und 1023. Eine Schwierigkeit bei diesem Projekt besteht darin, den Wert auf dem Bildschirm anzuzeigen, was eigentlich leicht zu erlernen ist. Zuerst müssen wir die Baudrate in voidsetup () einstellen. Bei der Anzeige des Wertes handelt es sich um eine Kommunikation zwischen Arduino und PC, daher sollte die Baudrate des Arduino derjenigen in der PC-Software entsprechen, die eingerichtet ist. Andernfalls wird die Anzeige unordentlich oder überhaupt nicht angezeigt. In der rechten unteren Ecke des Monitorfensters der Arduino-Software befindet sich eine Schaltfläche zum Einstellen der Baudrate. Das Setup muss mit dem im Programm übereinstimmen. Die Anweisung im Programm lautet Serial.begin (); eingeschlossen ist der Baudratenwert, gefolgt von einer Anweisung zur Anzeige. Sie können entweder die Anweisung Serial.print () oder Serial.println () verwenden.

int potpin=0;// initialize analog pin 0int ledpin=13;// initialize digital pin 13int val=0;// define val, assign initial value 0void setup(){pinMode(ledpin,OUTPUT);// set digital pin as “output”Serial.begin(9600);// set baud rate at 9600}void loop(){digitalWrite(ledpin,HIGH);// turn on the LED on pin 13delay(50);// wait for 0.05 seconddigitalWrite(ledpin,LOW);// turn off the LED on pin 13delay(50);// wait for 0.05 secondval=analogRead(potpin);// read the analog value of analog pin 0, and assign it to val Serial.println(val);// display val’s value}

Ergebnis:
Das Beispielprogramm verwendet die eingebaute LED, die an Pin 13 angeschlossen ist. Jedes Mal, wenn das Gerät einen Wert liest, blinkt die LED.
Unten ist der analoge Wert, den es liest.

Projekt 16: 74HC595

Einleitung: Einfach ausgedrückt : 74HC595 ist eine Kombination aus 8-stelligem Schieberegister, Speicher und Tri-State-Ausgang. Hier steuern wir 8 LEDs. Sie fragen sich vielleicht, warum eine 74HC595 zur Steuerung von LEDs verwendet wird? Denken Sie darüber nach, wie viele E / A ein Arduino zur Steuerung von 8 LEDs benötigt. Ja, 8. Für einen Arduino 168 gibt es nur 20 E / A einschließlich analoger Ports. Um Portressourcen zu sparen, verwenden wir 74HC595, um die Anzahl der benötigten Ports zu reduzieren. Mit 74HC595 können wir 3 digitale E / A-Ports zur Steuerung von 8 LEDs verwenden!

Hardware erforderlich:
1.74HC595-Chip * 1
2. Rote M5 LED * 4
3. Grüne M5 LED * 4
4,220Ω Widerstand * 8
5.Schneidebrett * 1
6.Breadboard-Überbrückungskabel * mehrere
Hinweis: Für Pin 13 OE-Port des 74HC595 muss er mit GND verbunden werden

Anschluss für UNO R3:

Connection for 2560 R3:

Die Schaltung mag kompliziert erscheinen, aber wenn Sie einmal einen guten Blick darauf haben, werden Sie es leicht finden!

Sample Code:

int data = 2;// set pin 14 of 74HC595as data input pin SI int clock = 5;// set pin 11 of 74hc595 as clock pin SCKint latch = 4;// set pin 12 of 74hc595 as output latch RCK int ledState = 0;const int ON = HIGH;const int OFF = LOW;void setup(){pinMode(data, OUTPUT);pinMode(clock, OUTPUT);pinMode(latch, OUTPUT);}void loop(){for(int i = 0; i < 256; i++){updateLEDs(i);delay(500);}}void updateLEDs(int value){digitalWrite(latch, LOW);//shiftOut(data, clock, MSBFIRST, ~value);// serial data “output”, high level firstdigitalWrite(latch, HIGH);// latch}

Projekt 17: 1-stellige LED-Segmentanzeige

Einleitung: LED-Segmentanzeigen sind für die Anzeige numerischer Informationen üblich. Es wird häufig auf Anzeigen von Elektromagnetöfen, vollautomatischen Waschmaschinen, Wassertemperaturanzeigen, elektronischen Uhren usw. angewendet. Es ist notwendig, dass wir lernen, wie es funktioniert.
LED-Segmentanzeige ist eine Halbleiter-Leuchtvorrichtung. Die Basiseinheit ist eine Leuchtdiode (LED). Die LED-Segmentanzeige kann entsprechend der Anzahl der Segmente in eine 7-Segment-Anzeige und eine 8-Segment-Anzeige unterteilt werden. 8-Segment-Anzeige hat eine weitere LED-Einheit (für Dezimalpunktanzeige) als 7-Segment-Anzeige. In diesem Experiment verwenden wir eine 8-Segment-Anzeige. Entsprechend der Verdrahtungsart von LED-Einheiten können LED-Segmentanzeigen in Anzeigen mit gemeinsamer Anode und Anzeigen mit gemeinsamer Kathode unterteilt werden. Die Anzeige allgemeiner Anoden bezieht sich auf die Anzeige, die alle Anoden von LED-Einheiten in einer gemeinsamen Anode (COM) kombiniert.
Schließen Sie für die Anzeige der gemeinsamen Anode die gemeinsame Anode (COM) an + 5V an. Wenn der Kathodenpegel eines bestimmten Segments niedrig ist, ist das Segment eingeschaltet; Wenn der Kathodenpegel eines bestimmten Segments hoch ist, ist das Segment ausgeschaltet. Schließen Sie für die Anzeige der gemeinsamen Kathode die gemeinsame Kathode (COM) an GND an. Wenn der Anodenpegel eines bestimmten Segments hoch ist, ist das Segment eingeschaltet; Wenn der Anodenpegel eines bestimmten Segments niedrig ist, ist das Segment ausgeschaltet.

Hardware erforderlich:
1.Einsegmentanzeige * 1
2,220Ω Widerstand * 8
3.Schneidebrett * 1
4.Breadboard-Überbrücker * mehrere

Verbindung:
Siehe Schaltplan zum Anschluss des Stromkreises

Anschluss für UNO R3:

Connection for 2560 R3:

Beispielcode:
Es gibt sieben Segmente für die numerische Anzeige, eines für die Dezimalpunktanzeige. Die entsprechenden Segmente werden bei der Anzeige bestimmter Zahlen aktiviert. Bei der Anzeige von Nummer 1 werden beispielsweise die Segmente b und c aktiviert. Wir erstellen für jede Nummer ein Unterprogramm und kompilieren das Hauptprogramm so, dass alle 2 Sekunden eine Nummer angezeigt wird, wobei die Displaynummer von 0 bis 9 angezeigt wird. Die Anzeigezeit für jede Nummer unterliegt der Verzögerungszeit, je länger die Verzögerungszeit, desto länger Zeit anzeigen.

// set the IO pin for each segmentint a=7;// set digital pin 7 for segment aint b=6;// set digital pin 6 for segment bint c=5;// set digital pin 5 for segment cint d=10;// set digital pin 10 for segment dint e=11;// set digital pin 11 for segment eint f=8;// set digital pin 8 for segment fint g=9;// set digital pin 9 for segment gint dp=4;// set digital pin 4 for segment dpvoid digital_0(void) // display number 5{unsigned char j;digitalWrite(a,HIGH);digitalWrite(b,HIGH);digitalWrite(c,HIGH);digitalWrite(d,HIGH);digitalWrite(e,HIGH);digitalWrite(f,HIGH);digitalWrite(g,LOW);digitalWrite(dp,LOW);}void digital_1(void) // display number 1{unsigned char j;digitalWrite(c,HIGH);// set level as “high” for pin 5, turn on segment cdigitalWrite(b,HIGH);// turn on segment bfor(j=7;j<=11;j++)// turn off other segmentsdigitalWrite(j,LOW);digitalWrite(dp,LOW);// turn off segment dp}void digital_2(void) // display number 2{unsigned char j;digitalWrite(b,HIGH);digitalWrite(a,HIGH);for(j=9;j<=11;j++)digitalWrite(j,HIGH);digitalWrite(dp,LOW);digitalWrite(c,LOW);digitalWrite(f,LOW);}void digital_3(void) // display number 3{digitalWrite(g,HIGH);digitalWrite(a,HIGH);digitalWrite(b,HIGH);digitalWrite(c,HIGH);digitalWrite(d,HIGH);digitalWrite(dp,LOW);digitalWrite(f,LOW);digitalWrite(e,LOW);}void digital_4(void) // display number 4{digitalWrite(c,HIGH);digitalWrite(b,HIGH);digitalWrite(f,HIGH);digitalWrite(g,HIGH);digitalWrite(dp,LOW);digitalWrite(a,LOW);digitalWrite(e,LOW);digitalWrite(d,LOW);}void digital_5(void) // display number 5{unsigned char j;digitalWrite(a,HIGH);digitalWrite(b, LOW);digitalWrite(c,HIGH);digitalWrite(d,HIGH);digitalWrite(e, LOW);digitalWrite(f,HIGH);digitalWrite(g,HIGH);digitalWrite(dp,LOW);}void digital_6(void) // display number 6{unsigned char j;for(j=7;j<=11;j++)digitalWrite(j,HIGH);digitalWrite(c,HIGH);digitalWrite(dp,LOW);digitalWrite(b,LOW);}void digital_7(void) // display number 7{unsigned char j;for(j=5;j<=7;j++)digitalWrite(j,HIGH);digitalWrite(dp,LOW);for(j=8;j<=11;j++)digitalWrite(j,LOW);}void digital_8(void) // display number 8{unsigned char j;for(j=5;j<=11;j++)digitalWrite(j,HIGH);digitalWrite(dp,LOW);}void digital_9(void) // display number 5{unsigned char j;digitalWrite(a,HIGH);digitalWrite(b,HIGH);digitalWrite(c,HIGH);digitalWrite(d,HIGH);digitalWrite(e, LOW);digitalWrite(f,HIGH);digitalWrite(g,HIGH);digitalWrite(dp,LOW);}void setup(){int i;// set variablefor(i=4;i<=11;i++)pinMode(i,OUTPUT);// set pin 4-11as “output”}void loop(){while(1){digital_0();// display number 0delay(1000);// wait for 1sdigital_1();// display number 1delay(1000);// wait for 1sdigital_2();// display number 2delay(1000); // wait for 1sdigital_3();// display number 3delay(1000); // wait for 1sdigital_4();// display number 4delay(1000); // wait for 1sdigital_5();// display number 5delay(1000); // wait for 1sdigital_6();// display number 6delay(1000); // wait for 1sdigital_7();// display number 7delay(1000); // wait for 1sdigital_8();// display number 8delay(1000); // wait for 1sdigital_9();// display number 9delay(1000); // wait for 1s}}

Projekt 18: 4-stellige LED-Segmentanzeige

Einführung: In diesem Experiment verwenden wir ein Arduino, um eine 4-stellige 7-Segment-LED-Anzeige mit gemeinsamer Anode anzutreiben. Für die LED-Anzeige sind strombegrenzende Widerstände unverzichtbar. Es gibt zwei Verdrahtungsmethoden für den Strombegrenzungswiderstand. Einer besteht darin, einen Widerstand für jede Anode zu verbinden, insgesamt 4 für die Anode d1-d4. Ein Vorteil dieser Methode ist, dass nur weniger Widerstände erforderlich sind. Es kann jedoch keine gleichbleibende Helligkeit, 1 die hellste, 8 die geringste Helligkeit, aufrechterhalten werden. Eine andere Methode besteht darin, einen Widerstand an jeden Pin anzuschließen. Es garantiert eine konstante Helligkeit, erfordert jedoch mehr Widerstände. In diesem Experiment verwenden wir 8 220 Ω-Widerstände (wir verwenden 220 Ω-Widerstände, da kein 100 Ω-Widerstand verfügbar ist. Wenn Sie 100 Ω verwenden, wird die Anzeige heller).

4-stell 7-Segment LED-Display

Für 4-stellige Anzeigen gibt es insgesamt 12 Pins. Wenn Sie den Dezimalpunkt nach unten setzen (siehe untere Fotoposition), wird der Stift im unteren linken Teil als 1, der obere linke Teil als 12 bezeichnet.

Manual for LED segment display:

Connection for UNO R3:

Connection for 2560 R3:

Sample Code:

// display 1234      // select pin for cathode       int a = 1;      int b = 2;      int c = 3;      int d = 4;      int e = 5;      int f = 6;      int g = 7;      int dp = 8;     // select pin for anode int d4 = 9;     int d3 = 10;    int d2 = 11;    int d1 = 12;    // set variable long n = 1230;  int x = 100;    int del = 55;  // fine adjustment for clock             void setup()    {         pinMode(d1, OUTPUT);    pinMode(d2, OUTPUT);    pinMode(d3, OUTPUT);    pinMode(d4, OUTPUT);    pinMode(a, OUTPUT);     pinMode(b, OUTPUT);     pinMode(c, OUTPUT);     pinMode(d, OUTPUT);     pinMode(e, OUTPUT);     pinMode(f, OUTPUT);     pinMode(g, OUTPUT);     pinMode(dp, OUTPUT);  }/////////////////////////////////////////////////////////////void loop(){ Display(1, 1); Display(2, 2); Display(3, 3); Display(4, 4);}///////////////////////////////////////////////////////////////void WeiXuan(unsigned char n)//{    switch(n)     {       case 1:           digitalWrite(d1,LOW);           digitalWrite(d2, HIGH);         digitalWrite(d3, HIGH);         digitalWrite(d4, HIGH);        break;  case 2:          digitalWrite(d1, HIGH);         digitalWrite(d2, LOW);          digitalWrite(d3, HIGH);         digitalWrite(d4, HIGH);           break;        case 3:           digitalWrite(d1,HIGH);         digitalWrite(d2, HIGH);         digitalWrite(d3, LOW);          digitalWrite(d4, HIGH);          break;        case 4:          digitalWrite(d1, HIGH);         digitalWrite(d2, HIGH);         digitalWrite(d3, HIGH);         digitalWrite(d4, LOW);           break;        default :           digitalWrite(d1, HIGH);      digitalWrite(d2, HIGH);         digitalWrite(d3, HIGH);         digitalWrite(d4, HIGH);        break;          }}void Num_0(){  digitalWrite(a, HIGH);  digitalWrite(b, HIGH);  digitalWrite(c, HIGH);  digitalWrite(d, HIGH);  digitalWrite(e, HIGH);  digitalWrite(f, HIGH);  digitalWrite(g, LOW);  digitalWrite(dp,LOW);}void Num_1(){  digitalWrite(a, LOW);  digitalWrite(b, HIGH);  digitalWrite(c, HIGH);  digitalWrite(d, LOW);  digitalWrite(e, LOW);  digitalWrite(f, LOW);  digitalWrite(g, LOW);  digitalWrite(dp,LOW);}void Num_2(){  digitalWrite(a, HIGH);  digitalWrite(b, HIGH);  digitalWrite(c, LOW);  digitalWrite(d, HIGH);  digitalWrite(e, HIGH);  digitalWrite(f, LOW);  digitalWrite(g, HIGH);  digitalWrite(dp,LOW);}void Num_3(){  digitalWrite(a, HIGH);  digitalWrite(b, HIGH);  digitalWrite(c, HIGH);  digitalWrite(d, HIGH);  digitalWrite(e, LOW);  digitalWrite(f, LOW);  digitalWrite(g, HIGH);  digitalWrite(dp,LOW);}void Num_4(){  digitalWrite(a, LOW);  digitalWrite(b, HIGH);  digitalWrite(c, HIGH);  digitalWrite(d, LOW);  digitalWrite(e, LOW);  digitalWrite(f, HIGH);  digitalWrite(g, HIGH);  digitalWrite(dp,LOW);}void Num_5(){  digitalWrite(a, HIGH);  digitalWrite(b, LOW);  digitalWrite(c, HIGH);  digitalWrite(d, HIGH);  digitalWrite(e, LOW);  digitalWrite(f, HIGH);  digitalWrite(g, HIGH);  digitalWrite(dp,LOW);}void Num_6(){  digitalWrite(a, HIGH);  digitalWrite(b, LOW);  digitalWrite(c, HIGH);  digitalWrite(d, HIGH);  digitalWrite(e, HIGH);  digitalWrite(f, HIGH);  digitalWrite(g, HIGH);  digitalWrite(dp,LOW);}void Num_7(){  digitalWrite(a, HIGH);  digitalWrite(b, HIGH);  digitalWrite(c, HIGH);  digitalWrite(d, LOW);  digitalWrite(e, LOW);  digitalWrite(f, LOW);  digitalWrite(g, LOW);  digitalWrite(dp,LOW);}void Num_8(){  digitalWrite(a, HIGH);  digitalWrite(b, HIGH);  digitalWrite(c, HIGH);  digitalWrite(d, HIGH);  digitalWrite(e, HIGH);  digitalWrite(f, HIGH);  digitalWrite(g, HIGH);  digitalWrite(dp,LOW);}void Num_9(){  digitalWrite(a, HIGH);  digitalWrite(b, HIGH);  digitalWrite(c, HIGH);  digitalWrite(d, HIGH);  digitalWrite(e, LOW);  digitalWrite(f, HIGH);  digitalWrite(g, HIGH);  digitalWrite(dp,LOW);}void Clear()  // clear the screen{  digitalWrite(a, LOW);  digitalWrite(b, LOW);  digitalWrite(c, LOW);  digitalWrite(d, LOW);  digitalWrite(e, LOW);  digitalWrite(f, LOW);  digitalWrite(g, LOW);  digitalWrite(dp,LOW);}void pickNumber(unsigned char n)// select number{  switch(n)  {   case 0:Num_0();   break;   case 1:Num_1();   break;   case 2:Num_2();   break;   case 3:Num_3();   break;   case 4:Num_4();   break;   case 5:Num_5();   break;   case 6:Num_6();   break;   case 7:Num_7();   break;   case 8:Num_8();   break;   case 9:Num_9();   break;   default:Clear();   break;   }}void Display(unsigned char x, unsigned char Number)//  take x as coordinate and display number{  WeiXuan(x);  pickNumber(Number); delay(1); Clear() ; // clear the screen}

Projekt 19: 8 * 8 LED-Matrix

 Einführung:

Beim Scannen mit niedriger Spannung haben LED-Punktmatrix-Anzeigen Vorteile wie Energieeinsparung, lange Lebensdauer, niedrige Kosten, hohe Helligkeit, großer Sichtwinkel, großer Sichtbereich, wasserdicht und zahlreiche Spezifikationen. LED-Punktmatrix-Displays können die Anforderungen verschiedener Anwendungen erfüllen und haben daher einen breiten Entwicklungsausblick. Dieses Mal werden wir ein LED-Punktmatrix-Experiment durchführen, um seinen Charme hautnah zu erleben.

Hardware benötigt:

• 1 * Uno-Board
• 1 * 8 * 8 Punktmatrix
• 8 * Widerstand (220Ω)
• 1 * Brotschneidebrett
• 2 * 74HC595
• 1 * USB-Kabel
• Drahtbrücken

Verbindung:

Die Außenansicht einer Punktmatrix wird wie folgt dargestellt:

Das Anzeigeprinzip der 8 * 8-Punktmatrix:
Die 8 * 8-Punktmatrix besteht aus vierundsechzig LEDs, und jede LED befindet sich am Kreuzungspunkt einer Reihe und einer Spalte. Wenn der elektrische Pegel einer bestimmten Reihe 1 und der elektrische Pegel einer bestimmten Spalte 0 ist, leuchtet die entsprechende LED auf. Wenn Sie die LED am ersten Punkt leuchten möchten, sollten Sie Pin 9 auf High-Pegel und Pin 13 auf Low-Pegel setzen. Wenn Sie LEDs in der ersten Reihe leuchten möchten, sollten Sie Pin 9 auf High-Pegel und die Pins 13, 3, 4, 10, 6, 11, 15 und 16 auf Low-Pegel setzen. Wenn Sie die LEDs in der ersten Spalte leuchten möchten, setzen Sie Pin 13 auf Low-Pegel und die Pins 9, 14, 8, 12, 1, 7, 2 und 5 auf High-Pegel.
Die interne Ansicht einer Punktmatrix wird wie folgt dargestellt:

Schließen Sie die Schaltung wie in der folgenden Abbildung gezeigt an:

Anschluss für UNO R3:

Connection for 2560 R3:

Sample Code for Displaying “0”:

// set an array to store character of “0”unsigned char Text[]={0x00,0x1c,0x22,0x22,0x22,0x22,0x22,0x1c};void Draw_point(unsigned char x,unsigned char y)// point drawing function{ clear_();   digitalWrite(x+2, HIGH);   digitalWrite(y+10, LOW);   delay(1);}void show_num(void)// display function, call point drawing function{  unsigned char i,j,data;  for(i=0;i<8;i++)  {    data=Text[i];    for(j=0;j<8;j++)    {      if(data & 0x01)Draw_point(j,i);      data>>=1;    }    }}void setup(){ int i = 0 ; for(i=2;i<18;i++)  {    pinMode(i, OUTPUT);   }    clear_(); }void loop(){ show_num();    } void clear_(void)// clear screen{for(int i=2;i<10;i++)  digitalWrite(i, LOW);  for(int i=0;i<8;i++)  digitalWrite(i+10, HIGH);}

Result:
Burn the program into Uno board The dot-matrix will display 0.

Projekt 20: 1602 LCD

Einführung:

In diesem Experiment verwenden wir ein Arduino, um das 1602-LCD anzutreiben.
1602 LCD hat breite Anwendungen. Am Anfang des 1602 LCD wird ein HD44780-Controller verwendet. Inzwischen verwenden fast alle 1602 LCD-Module ein kompatibles IC, sodass ihre Funktionen im Wesentlichen gleich sind.

1602LCD-Hauptparameter:

• Anzeigekapazität: 16 × 2 Zeichen.
• Betriebsspannung des Chips: 4,5 ~ 5,5 V.
• Arbeitsstrom: 2,0 mA (5,0 V).
• Die optimale Betriebsspannung des Moduls beträgt 5,0 V.
• Zeichengröße: 2,95 * 4,35 (B * H) mm.

Pin-Beschreibung des 1602 LCD:

4 Grundfunktionen von 1602LCD:

Hardware erforderlich:

• 1 * Steuerplatine
• 1 * 1602 LCD
• 1 * Potentiometer
• 1 * Brotschneidebrett
• 1 * USB-Kabel
• Schaltdrähte

Verbindung & Beispielprogramm:

1602 kann direkt mit Arduino kommunizieren. Laut Produkthandbuch gibt es zwei Verbindungsmethoden: 8-Bit-Verbindung und 4-Bit-Verbindung.

8-Bit-Verbindungsmethode:

Connection for UNO R3:

Connection for 2560 R3:

Sample Code A :

int DI = 12;int RW = 11;int DB[] = {3, 4, 5, 6, 7, 8, 9, 10};// use array to select pin for busint Enable = 2;void LcdCommandWrite(int value) {// define all pinsint i = 0;for (i=DB[0]; i <= DI; i++) // assign value for bus{   digitalWrite(i,value & 01);// for 1602 LCD, it uses D7-D0( not D0-D7) for signal identification; here, it’s used for signal inversion.    value >>= 1;}digitalWrite(Enable,LOW);delayMicroseconds(1);digitalWrite(Enable,HIGH);delayMicroseconds(1);  // wait for 1msdigitalWrite(Enable,LOW);delayMicroseconds(1);  // wait for 1ms}void LcdDataWrite(int value) {// initialize all pinsint i = 0;digitalWrite(DI, HIGH);digitalWrite(RW, LOW);for (i=DB[0]; i <= DB[7]; i++) {   digitalWrite(i,value & 01);   value >>= 1;}digitalWrite(Enable,LOW);delayMicroseconds(1);digitalWrite(Enable,HIGH);delayMicroseconds(1);digitalWrite(Enable,LOW);delayMicroseconds(1);  // wait for 1ms}void setup (void) {int i = 0;for (i=Enable; i <= DI; i++) {   pinMode(i,OUTPUT);}delay(100);// initialize LCD after a brief pause// for LCD controlLcdCommandWrite(0x38);  // select as 8-bit interface, 2-line display, 5x7 character size delay(64);                      LcdCommandWrite(0x38);  // select as 8-bit interface, 2-line display, 5x7 character size delay(50);                      LcdCommandWrite(0x38);  // select as 8-bit interface, 2-line display, 5x7 character size             delay(20);                      LcdCommandWrite(0x06);  // set input mode                         // auto-increment, no display of shiftingdelay(20);                      LcdCommandWrite(0x0E);  // display setup                         // turn on the monitor, cursor on, no flickeringdelay(20);                      LcdCommandWrite(0x01);  // clear the scree, cursor position returns to 0delay(100);                      LcdCommandWrite(0x80);  //  display setup                         //  turn on the monitor, cursor on, no flickeringdelay(20);                      }void loop (void) {  LcdCommandWrite(0x01);  // clear the scree, cursor position returns to 0    delay(10);   LcdCommandWrite(0x80+3);   delay(10);                       // write in welcome message   LcdDataWrite('W');  LcdDataWrite('e');  LcdDataWrite('l');  LcdDataWrite('c');  LcdDataWrite('o');  LcdDataWrite('m');  LcdDataWrite('e');  LcdDataWrite(' ');  LcdDataWrite('t');  LcdDataWrite('o');  delay(10);  LcdCommandWrite(0xc0+1);  // set cursor position at second line, second position  delay(10);   LcdDataWrite('g');  LcdDataWrite('e');  LcdDataWrite('e');  LcdDataWrite('k');  LcdDataWrite('-');  LcdDataWrite('w');  LcdDataWrite('o');  LcdDataWrite('r');  LcdDataWrite('k');  LcdDataWrite('s');  LcdDataWrite('h');  LcdDataWrite('o');  LcdDataWrite('p');  delay(5000);  LcdCommandWrite(0x01);  // clear the screen, cursor returns to 0    delay(10);  LcdDataWrite('I');  LcdDataWrite(' ');  LcdDataWrite('a');  LcdDataWrite('m');  LcdDataWrite(' ');  LcdDataWrite('h');  LcdDataWrite('o');  LcdDataWrite('n');  LcdDataWrite('g');  LcdDataWrite('y');  LcdDataWrite('i');  delay(3000);  LcdCommandWrite(0x02); // set mode as new characters replay old ones, where there is no new ones remain the same  delay(10);  LcdCommandWrite(0x80+5); // set cursor position at first line, sixth position  delay(10);    LcdDataWrite('t');  LcdDataWrite('h');  LcdDataWrite('e');  LcdDataWrite(' ');  LcdDataWrite('a');  LcdDataWrite('d');  LcdDataWrite('m');  LcdDataWrite('i');  LcdDataWrite('n');  delay(5000);}

4-Bit-Verbindungsmethode:
Bei Verwendung dieses Moduls werden bei der 8-Bit-Verbindung alle digitalen Pins des Arduino verwendet, wobei für Sensoren keine Pins vorhanden sind. Was dann? Wir können eine 4-Bit-Verbindung verwenden.

Anschluss für 2560 R3: Laden Sie nach dem Anschluss den folgenden Code auf die Controller-Platine hoch und sehen Sie, wie es funktioniert.

Sample Code B :

int LCD1602_RS=12;   int LCD1602_RW=11;   int LCD1602_EN=10;   int DB[] = { 6, 7, 8, 9};char str1[]="Welcome to";char str2[]="geek-workshop";char str3[]="this is the";char str4[]="4-bit interface";void LCD_Command_Write(int command){int i,temp;digitalWrite( LCD1602_RS,LOW);digitalWrite( LCD1602_RW,LOW);digitalWrite( LCD1602_EN,LOW);temp=command & 0xf0;for (i=DB[0]; i <= 9; i++){   digitalWrite(i,temp & 0x80);   temp <<= 1;}digitalWrite( LCD1602_EN,HIGH);delayMicroseconds(1);digitalWrite( LCD1602_EN,LOW);temp=(command & 0x0f)<<4;for (i=DB[0]; i <= 10; i++){   digitalWrite(i,temp & 0x80);   temp <<= 1;}digitalWrite( LCD1602_EN,HIGH);delayMicroseconds(1); digitalWrite( LCD1602_EN,LOW);}void LCD_Data_Write(int dat){int i=0,temp;digitalWrite( LCD1602_RS,HIGH);digitalWrite( LCD1602_RW,LOW);digitalWrite( LCD1602_EN,LOW);temp=dat & 0xf0;for (i=DB[0]; i <= 9; i++){   digitalWrite(i,temp & 0x80);   temp <<= 1;}digitalWrite( LCD1602_EN,HIGH);delayMicroseconds(1);digitalWrite( LCD1602_EN,LOW);temp=(dat & 0x0f)<<4;for (i=DB[0]; i <= 10; i++){   digitalWrite(i,temp & 0x80);   temp <<= 1;}digitalWrite( LCD1602_EN,HIGH);delayMicroseconds(1); digitalWrite( LCD1602_EN,LOW);}void LCD_SET_XY( int x, int y ){  int address;  if (y ==0)    address = 0x80 + x;  else          address = 0xC0 + x;  LCD_Command_Write(address); }void LCD_Write_Char( int x,int y,int dat){  LCD_SET_XY( x, y );   LCD_Data_Write(dat);}void LCD_Write_String(int X,int Y,char *s){    LCD_SET_XY( X, Y );    // address setup     while (*s)             // write character string    {      LCD_Data_Write(*s);         s ++;    }}void setup (void) {  int i = 0;  for (i=6; i <= 12; i++)    {     pinMode(i,OUTPUT);   }  delay(100);  LCD_Command_Write(0x28);// 4 wires, 2 lines 5x7  delay(50);   LCD_Command_Write(0x06);  delay(50);   LCD_Command_Write(0x0c);  delay(50);   LCD_Command_Write(0x80);  delay(50);   LCD_Command_Write(0x01);  delay(50); }void loop (void){   LCD_Command_Write(0x01);   delay(50);   LCD_Write_String(3,0,str1);// line 1, start at the fourth address   delay(50);   LCD_Write_String(1,1,str2);// line 2, start at the second address   delay(5000);   LCD_Command_Write(0x01);   delay(50);   LCD_Write_String(0,0,str3);   delay(50);   LCD_Write_String(0,1,str4);   delay(5000);}

Projekt 21: 9g Servosteuerung

Einleitung: Der Servomotor ist ein Lageregler. Es besteht hauptsächlich aus Gehäuse, Leiterplatte, kernlosem Motor, Getriebe und Positionssensor. Der Empfänger oder die MCU gibt ein Signal an den Servomotor aus. Der Motor verfügt über eine eingebaute Referenzschaltung, die ein Referenzsignal, einen Zyklus von 20 ms und eine Breite von 1,5 ms ausgibt. Der Motor vergleicht die erfasste DC-Vorspannung mit der Spannung des Potentiometers und gibt eine Spannungsdifferenz aus. Der IC auf der Leiterplatte bestimmt die Drehrichtung entsprechend und treibt den kernlosen Motor an. Das Zahnrad überträgt dann die Kraft auf die Welle. Der Sensor ermittelt anhand des Rückmeldesignals, ob er die angeforderte Position erreicht hat. Servomotoren werden in Steuersystemen verwendet, die unterschiedliche Winkel haben und beibehalten müssen. Wenn die Motordrehzahl endgültig ist, wird das Potentiometer durch das Getriebe gedreht. Wenn sich die Spannungsdifferenz auf Null verringert, stoppt der Motor. Normalerweise liegt der Drehwinkelbereich zwischen 0 und 180 Grad.

Der Servomotor verfügt über viele Spezifikationen. Alle haben jedoch drei Anschlussdrähte, die sich durch die Farben Braun, Rot und Orange unterscheiden (unterschiedliche Marken können unterschiedliche Farben haben). Das braune ist für GND, das rote für die positive Leistung, das orange für die Signalleitung.

Der Drehwinkel des Servomotors wird durch Regelung des Tastverhältnisses des PWM-Signals (Pulse-Width Modulation) gesteuert. Der Standardzyklus des PWM-Signals beträgt 20 ms （50 Hz. Theoretisch ist die Breite zwischen 1 ms und 2 ms verteilt, tatsächlich liegt sie jedoch zwischen 0,5 ms und 2,5 ms. Die Breite entspricht dem Drehwinkel von 0 ° bis 180 °. Beachten Sie jedoch, dass das gleiche Signal bei einem anderen Markenmotor einen unterschiedlichen Drehwinkel haben kann.

Nach einigen Grundkenntnissen lernen wir, wie ein Servomotor gesteuert wird. Für dieses Experiment benötigen Sie nur einen Servomotor und mehrere Drahtbrücken.

Hardware erforderlich:

• RB-412 Servomotor * 1
• Breadboard-Überbrückungskabel * mehrere

Verbindung & Beispielprogramm:

Es gibt zwei Möglichkeiten, einen Servomotor mit Arduino zu steuern. Eine besteht darin, einen gemeinsamen digitalen Sensorport von Arduino zu verwenden, um eine Rechteckwelle mit unterschiedlichem Arbeitszyklus zu erzeugen, um ein PWM-Signal zu simulieren und dieses Signal zur Steuerung der Positionierung des Motors zu verwenden. Eine andere Möglichkeit ist die direkte Verwendung der Servofunktion des Arduino zur Steuerung des Motors. Auf diese Weise wird das Programm einfacher, es kann jedoch nur einen Zweikontaktmotor steuern, da für die Servofunktion nur der digitale Pin 9 Ang 10 verwendet werden kann. Der Arduino

Laufwerkskapazität ist begrenzt. Wenn Sie also mehr als einen Motor steuern müssen, benötigen Sie eine externe Stromversorgung.

Methode 1:

Anschluss für UNO R3:

Connection for 2560 R3:

Schließen Sie den Motor an den digitalen Pin 9 an. Kompilieren Sie ein Programm, um den Motor so zu steuern, dass er sich auf den vom Benutzer angegebenen Befehlswinkel dreht und den Winkel auf dem Bildschirm anzeigt.

Sample Code A :

int servopin=9;// select digital pin 9 for servomotor signal lineint myangle;// initialize angle variableint pulsewidth;// initialize width variableint val;void servopulse(int servopin,int myangle)// define a servo pulse function{pulsewidth=(myangle*11)+500;// convert angle to 500-2480 pulse widthdigitalWrite(servopin,HIGH);// set the level of servo pin as “high”delayMicroseconds(pulsewidth);// delay microsecond of pulse widthdigitalWrite(servopin,LOW);// set the level of servo pin as “low”delay(20-pulsewidth/1000);}void setup(){pinMode(servopin,OUTPUT);// set servo pin as “output”Serial.begin(9600);// connect to serial port, set baud rate at “9600”Serial.println("servo=o_seral_simple ready" ) ;}void loop()// convert number 0 to 9 to corresponding 0-180 degree angle, LED blinks corresponding number of time{val=Serial.read();// read serial port valueif(val>='0'&&val<='9'){val=val-'0';// convert characteristic quantity to numerical variableval=val*(180/9);// convert number to angleSerial.print("moving servo to ");Serial.print(val,DEC);Serial.println();for(int i=0;i<=50;i++) // giving the servo time to rotate to commanded position{servopulse(servopin,val);// use the pulse function}}}

Method 2::

Schauen wir uns zunächst die eingebaute Servofunktion von Arduino und einige ihrer allgemeinen Aussagen an.
1. Anschluss （Schnittstelle attach —— Pin für Servo auswählen, nur Pin 9 oder 10 verwenden.
2. write （angle） - - zur Steuerung des Drehwinkels des Servos kann den Winkel zwischen 0 Grad und 180 Grad einstellen.
3. read （） —— dient zum Lesen des Winkels des Servos, als Funktion zum Lesen des Werts in der Funktion write ().
4 、 Attached） — —— bestimmt, ob der Parameter des Servos an den Servo-Pin gesendet wird.
5 、 trennen （） - Trennen Sie das Servo und den Pin, und der Pin (Digital Pin 9 oder 10) kann für den PWM-Port verwendet werden.
Hinweis: Hinweis: Die geschriebene Form der obigen Anweisungen lautet "Servovariablenname. Spezifische Anweisung ()", z. B. myservo. Befestigen Sie (9).
Verbinden Sie das Servo weiterhin mit Pin 9.

Sample Code B :

#include <Servo.h>/* define a header file. Special attention here, you can call the servo function directly from Arduino's software menu  bar Sketch>Importlibrary>Servo, or input #include <Servo.h>. Make sure there is a space between #include and  <Servo.h>. Otherwise, it will cause compile error.*/Servo myservo;// define servo variable namevoid setup(){myservo.attach(9);// select servo pin(9 or 10)}void loop(){myservo.write(90);// set rotate angle of the motor}

Above are the two methods to control the servo. You can choose either one according to your liking or actual need. 

Resources

• Video:
  

http://video.keyestudio.com/KS0069/

• Download all the datasheet:
  

https://drive.google.com/open?id=1rq0BzIjfrSJL9DOdKW8xjqtbqMkk5TlP

Buy from

Official Website

Mit UNO http://www.keyestudio.com/keyestudio-basic-starter-kit-for-arduino-starter-with-uno-r3.html

No Board http://www.keyestudio.com/keyestudio-basic-starter-kit-for-arduino-starter-no-board.html

Mit 2560 R3 http://www.keyestudio.com/keyestuio-basic-starter-kit-for-arduino-starter-with-mega2560-r3.html