Arduino Tutorials

/* Blinkende OnBoard-LED an pin-13 * ------------ * Schaltet die OnBoard-Leuchtdiode (LED an pin-13) * in Abständen von 2 Sekunden ein und aus */int ledPin = 13;                 // OnBoard-LED connected to digital pin-13
void setup(){  pinMode(ledPin, OUTPUT);      // pin-13 als Ausgang setzen}
void loop(){  digitalWrite(ledPin, HIGH);   // schaltet die OnBoard-LED ein  delay(1000);                  // Warte 1000ms  digitalWrite(ledPin, LOW);    // schaltet die OnBoard-LED aus  delay(1000);                  // Warte 1000ms}

/*Arduino Servo Test sketch*/#include <Servo.h>Servo servoMain; // Deffiniert das Servovoid setup(){   servoMain.attach(10); // Servo an digital pin-10}void loop(){   servoMain.write(45);  // Turn Servo Left to 45 degrees   delay(1000);          // Wait 1 second   servoMain.write(0);   // Turn Servo Left to 0 degrees   delay(1000);          // Wait 1 second   servoMain.write(90);  // Turn Servo back to center position (90 degrees)   delay(1000);          // Wait 1 second   servoMain.write(135); // Turn Servo Right to 135 degrees   delay(1000);          // Wait 1 second   servoMain.write(180); // Turn Servo Right to 180 degrees   delay(1000);          // Wait 1 second   servoMain.write(90);  // Turn Servo back to center position (90 degrees)   delay(1000);          // Wait 1 second   }

/* Flashing LED * ------------ * Schaltet eine Leuchtdiode (LED) auf einen digitalen verbunden 
 * Stift, in Abständen von 2 Sekunden.   */ int ledPin = 13; // OnBoard-LED connected to digital pin-13 void setup() {   pinMode(ledPin, OUTPUT); // setzt den pin-13 als Ausgang } void loop() {   digitalWrite(ledPin, HIGH); // sets the LED on   delay(1000);                // waits for a second   digitalWrite(ledPin, LOW);  // sets the LED off   delay(1000);                // waits for a second }

First, lets make a quick change to the loop() function. We will replace the two pairs of statements which turn the LED on and off with just one pair. Instead of setting the value to HIGH and then to LOW we will read it's current value and set it to the opposite using the NOT function !

Erstens können machen einen schnellen Wechsel auf die Schleife)-Funktion (.

Wir werden die beiden Paare von Aussagen, die die LED an und aus mit nur einem Paar drehen ersetzen.

Anstatt den Wert auf HIGH und dann auf LOW wir lesen es ist aktuellen Wert und stellen Sie ihn mit der NICHT funktionieren in die entgegengesetzte!

void loop(){  digitalWrite(ledPin, !digitalRead(ledPin));   // toggles the LED on/off  delay(1000);                                  // waits for a second}

OK, now lets improve on the delay() functions. Instead we will use the Arduino millis() function.
The millis() function returns the number of milliseconds since the Arduino board began running the current program. This number will overflow (go back to zero), after approximately 50 days. So, as long as you are not leaving your device on for more than 50 days, this is a great way to perform timing functions. If your device is intended to be left on for longer than 50 days, you will have to account for the rollover in your code.

Alternatively for faster timings the micros() function can be used. This returns the number of microseconds since the Arduino board began running the current program. This number will overflow (go back to zero), after approximately 70 minutes.

We will use the millis() function to control our LED as before. The code for this is shown below

OK, jetzt können verbessern die Verzögerung ()-Funktionen.

Stattdessen werden wir die Arduino Millis ()-Funktion verwenden.
Die Funktion Millis () gibt die Anzahl der Millisekunden seit dem Arduino-Board begann der Ausführung des aktuellen Programms.

Diese Zahl wird überlaufen (gehen Sie zurück auf Null), nach ca. 50 Tagen haben.

Also, so lange Sie nicht sich von Ihrem Gerät für mehr als 50 Tage, ist dies eine gute Möglichkeit, Zeitfunktionen durchzuführen.

Wenn Ihr Gerät soll über die für länger als 50 Tage sein, die Sie haben werden, um für den Rollover in Ihrem Code berücksichtigen.

Alternativ zur schnelleren Timings Micros ()-Funktion verwendet werden.

Diese gibt die Anzahl der Mikrosekunden seit dem Arduino-Board begann der Ausführung des aktuellen Programms.

Diese Zahl wird überlaufen (gehen Sie zurück auf Null), nach ca. 70 Minuten.

Wir werden die Millis ()-Funktion nutzen, um unsere LED nach wie vor zu kontrollieren. Der Code für dieses ist unten gezeigt

/* Flashing LED Version 2 * ------------------------ * * Turns on and off a light emitting diode(LED) connected to a digital   * pin, in intervals of 2 seconds using millis() function * */int ledPin = 13;                 // LED connected to digital pin-13unsigned long currentTime;unsigned long loopTime;void setup(){  pinMode(ledPin, OUTPUT);      // sets the digital pin as output  currentTime = millis();  loopTime = currentTime;  }void loop(){  currentTime = millis();  if(currentTime >= (loopTime + 1000)){      digitalWrite(ledPin, !digitalRead(ledPin));   // toggles the LED on/off    loopTime = currentTime;                       // Updates loopTime  }  // Other processing can be done here}

This sketch uses two additional variables currentTime and loopTime.
In the setup() function both variables are initially set to the same value
In the main loop() function, currentTime is updated everytime through the loop.
Only when at least one second has passed and the currentTime variable is greater than loopTime + 1000 (1000 milliseconds = 1 second) does it then toggle the ledPin value and also reset loopTime to the same value as currentTime.

Notice there is no use of the delay() function so the processor is not tied up waiting and can carry out any additional processing in the main loop that is needed

Diese Skizze verwendet zwei zusätzliche Variablen current und LOOPTIME.
Im Setup ()-Funktion sowohl Variablen werden zunächst auf den gleichen Wert eingestellt
In der Hauptschleife ()-Funktion, wird current jedes Mal durch die Schleife aktualisiert.
Nur dann, wenn mindestens eine Sekunde vergangen ist,

und die current Variable größer als LOOPTIME + 1000 (1000 Millisekunden = 1 Sekunde) ist,

dann wechseln die ledPin Wert und LOOPTIME auf den gleichen Wert wie current zurückgesetzt.

Beachten Sie, gibt es keine Verwendung der Verzögerung ()-Funktion, so wird der Prozessor nicht warten gebunden

und kann in der Hauptschleife, die benötigt wird nehmen alle zusätzlichen Verarbeitungs

In this Arduino UNO tutorial, we are expanding on our simple LED flash tutorial. We will use 5 LEDs to create a simple Cylon roving eye effect. To do this we will make life easier for ourselves and use direct port manipulation. That is we will write directly to one of the Arduino UNO ports rather than writing to individual pins. This allows us to set the values for each of the LEDs in one operation.

The Arduino UNO has 3 ports

• B (digital pin 8 to 13)
• C (analog input pins)
• D (digital pins 0 to 7)

Each port is controlled by three registers, which are also defined variables in the arduino language. The DDR register, determines whether the pin is an INPUT or OUTPUT. The PORT register controls whether the pin is HIGH or LOW, and the PIN register reads the state of INPUT pins set to input with pinMode()

We will use port B for our Cylon eye sketch. First we need to set all the port B pins as digital outputs. Port B has only six pins allocated to it. The bits in the port B register (DDRB) control whether each of the pins in PORTB are configured as inputs or outputs, Setting a pin to 1 makes it an OUTPUT whilst setting it to 0 makes it an INPUT. Port pins are numbered from 0 to 7 but not all ports have 8 pins. So, for example:

In diesem Tutorial Arduino UNO, werden wir uns auf unsere einfache LED-Flash-Tutorial erweitert.

Wir werden 5 LEDs verwenden, um eine einfache Zylonen Roving-Augen-Effekt zu erzeugen.

Um dies zu tun, werden wir uns selbst das Leben leichter machen und mit direktem Anschluss Manipulation.

Das ist werden wir direkt zu einem der Arduino UNO-Ports zu schreiben, anstatt schriftlich an einzelnen Pins.

Dies ermöglicht es, die Werte für jede der LEDs in einem Vorgang eingestellt.

Das Arduino UNO hat 3 Ports

     B (digitale pin-8 bis pin-13)
     C (analoge Eingangs-Pins)
     D (digital pin-0 bis pin-7)

Jeder Port wird durch drei Register, die auch definiert sind Variablen in der Arduino Sprache gesteuert.

Das DDR-Register, ob der Stift ist ein Eingang oder Ausgang.

Die Port-Register steuert, ob der Stift hoch oder niedrig ist, und die PIN-Register liest den Zustand der Eingangs-Pins zur Eingabe mit pinMode set ()

Wir werden für unsere B-Port Zylonen Auge Skizze zu verwenden.

Zunächst müssen wir alle B-Port-Pins als digitale Ausgänge.

Port B nur sechs Stifte zugeordnet. Die Bits im Port B-Register (DDRB) Kontrolle, ob jeder der Stifte in PORTB als Eingänge oder Ausgänge konfiguriert, der Einstellung des pin-1 macht er eine Leistung, während es auf 0 ist es eine Eingabe. Port-Pins sind von 0 bis 7 durchnummeriert, aber nicht alle Ports haben 8 pins.

So zum Beispiel:

DDRB = B00111110; // sets Arduino port B pins 1 to 5 as outputs, pin 0 as input

DDRB = B00011111; // sets Arduino port B pins 0 to 4 as outputs

To write to our port we use the PORTB register. We can turn on just the first LED with

PORTB = B00000001;

or we can turn on alternate LEDs with

PORTB = B00010101;

See how much easier this is than turning on/off each LED. Now for some easy binary Bit Shift Operators

There are two bit shift operators: the left shift operator << and the right shift operator >>. These operators cause the bits in the left operand to be shifted left or right by the number of positions specified by the right operand.

DDRB = B00011111; // Setzt Arduino Port B  pin-0 bis pin-4 als Ausgänge

Um zu unserem Hafen zu schreiben verwenden wir die PORTB Register.

Wir können schalten Sie nur die erste LED mit

PORTB = B00000001;

oder wir können auf alternative LEDs mit drehen

PORTB = B00010101;

Sehen Sie, wie viel einfacher das ist als das Ein / Ausschalten jeder LED. Jetzt einige einfache binäre Bit Shift-Operatoren

Es gibt zwei Bit-Schiebeoperatoren : links zu verschieben operator << und die rechte Shift-Operator >>.

Diese Operatoren bewirken, daß die Bits in der linken Operanden zu der Anzahl von Positionen des rechten Operanden spezifiziert links oder rechts verschoben werden.

E.g.
variableA = 1;      // 00000001
variableA = 1 << 0; // 00000001
variableA = 1 << 1; // 00000010
variableA = 1 << 2; // 00000100

/*  Simple Cylon  5 LEDs die hin und her fahren   */unsigned char upDown=1;    // Beginnen hinauf    unsigned char cylon=0;  // Bestimmt, welche LED ist auf 0 bis 4 void setup() {                  // Die digitalen Pins als Ausgänge initialisieren.   DDRB = B00011111;  // Setzt Arduino Port B pin-0 bis pin-4 als Ausgänge           }void loop() {  if(upDown==1){    cylon++;    if(cylon>=4) upDown=0;      // Erreicht maximale LED, das nächste Mal müssen wir nach unten gehen   }  else {    cylon--;    if(cylon==0) upDown=1;      // Erreicht min LED, das nächste Mal müssen wir gehen   }  PORTB = 1 << cylon;  delay(150);                   // 150ms Wartezeit}

Here is the circuit laid out on a breadboard

Die Schaltung wurde auf einem Steckbrett aufgebaut.

/* Fade 

 */int brightness = 0;    // Wie hell die LED istint fadeAmount = 5;    // how many points to fade the LED byunsigned long currentTime;unsigned long loopTime;
void setup()  {   pinMode(9, OUTPUT);   // pin-9 soll Ausgang sein  currentTime = millis();  loopTime = currentTime; } 
void loop()  {   currentTime = millis();  if(currentTime >= (loopTime + 20)){          analogWrite(9, brightness);  // setze die Helligkeit von pin-9       // change the brightness for next time through the loop:    brightness = brightness + fadeAmount;    // Umkehr der Richtung des Fading an den Enden des Fades    if (brightness == 0 || brightness == 255) {      fadeAmount = -fadeAmount ;     }         loopTime = currentTime;  // Updates loopTime  }  // anderer Sketch kann ab da angefügt werden                           }

We have written a tutorial for Rotary Encoders using a Microchip microcontroller but now would be a good time to make an Arduino UNO version.

Wir haben eine Anleitung für Drehgeber mit einem Microchip Mikrocontroller geschrieben, aber jetzt wäre ein guter Zeitpunkt, um einen Arduino UNO-Version zu machen.

With a rotary encoder we have two square wave outputs (A and B) which are 90 degrees out of phase with each other. The number of pulses or steps generated per complete turn varies. The Sparkfun Rotary Encoder has 12 steps but others may have more or less. The diagram below shows how the phases A and B relate to each other when the encoder is turned clockwise or counter clockwise.

Every time the A signal pulse goes from positive to zero, we read the value of the B pulse. We see that when the encoder is turned clockwise the B pulse is always positive. When the encoder is turned counter-clockwise the B pulse is negative. By testing both outputs with a microcontroller we can determine the direction of turn and by counting the number of A pulses how far it has turned. Indeed, we could go one stage further and count the frequency of the pulses to determine how fast it is being turned. We can see that the rotary encoder has a lot of advantages over a potentiometer.

We will now use the rotary encoder in the simplest of applications, we will use it to control the brightness of an led by altering a pwm signal. We will use the easiest method to read the encoder, that is the use of a timer interrupt to check on the values.

We will use the sparkfun encoder as discussed above. The first thing is to determine how fast we need our timer to operate. If you imagine that at best we could turn the encoder through 180 degrees in 1/10th of a second, that would give us 6 pulses in 1/10th second or 60 pulse per second. In reality its never likely to be this fast. As we need to detect both high and low values this gives us a minimum frequency of 120Hz. Lets go for 200Hz just to be sure. (Note: as these units are mechanical switches, there is the possibility of switch bounce. Using a fairly low frequency allows us to effectively filter out any switch bounce)

Each time our timer code triggers, we compare the value of our A pulse with its previous value. If it has gone from positive to zero, we then check the value of the B pulse to see if it is positive or zero. Depending on the outcome we can increment of decrement a counter. We then use this to control the PWM value to increase or decrease the brightness of the LED

The schematic is shown below

Jedes Mal, wenn der Signalimpuls geht von positiv zu null liest man den Wert des B-Pulses.

Wir sehen, dass, wenn der Geber im Uhrzeigersinn der B Takt gedreht ist immer positiv.

Wenn der Geber gegen den Uhrzeigersinn gedreht die B Impuls ist negativ.

Durch Testen beide Ausgänge mit einem Mikrocontroller kann man die Drehrichtung und durch Zählen der Anzahl der Impulse A, wie weit sie eingeschaltet wurde zu bestimmen.

In der Tat konnten wir einen Schritt weiter gehen und zählen Sie die Frequenz der Impulse, um festzustellen, wie schnell es eingeschaltet ist.

Wir können sehen, dass der Drehgeber hat viele Vorteile gegenüber einem Potentiometer.

Wir werden nun die Drehgeber in der einfachsten Anwendungen, werden wir sie nutzen, um die Helligkeit eines durch die Veränderung ein PWM-Signal führte zu steuern.

Wir werden die einfachste Methode verwenden, um den Encoder, die die Verwendung eines Timer-Interrupt auf die Werte zu überprüfen, ist zu lesen.

Wir werden die sparkfun Encoder, wie oben diskutiert.

Die erste Sache ist, um zu bestimmen, wie schnell wir brauchen unsere Timer zu bedienen.

Wenn Sie sich vorstellen, dass im besten Fall könnten wir den Encoder um 180 Grad in 1/10 einer Sekunde drehen, dass uns in 1/10 Sekunde oder 60 Impulse pro Sekunde geben würde 6 Impulse. In Wirklichkeit seine wohl nie so schnell sein.

Wie wir brauchen, um hohe und niedrige Werte erkennen das gibt uns eine Mindestfrequenz von 120Hz.

Lässt für 200 Hz gehen, nur um sicher zu sein.

(Anmerkung: Da diese Einheiten sind mechanische Schalter, es ist die Möglichkeit der Verwendung von Schalterprellen eine ziemlich niedrige Frequenz ermöglicht es uns, effektiv herauszufiltern jede Schalterprellen.)

Jedes Mal, wenn unsere Timer-Code löst, vergleichen wir den Wert unserer Ein-Impuls mit seinem vorherigen Wert.

Wenn es sich von positiv auf Null gegangen, wir prüfen dann den Wert der B-Impuls, um zu sehen, ob es positiv oder Null ist.

Je nach Ergebnis können wir der Abnahme einen Zähler. Wir haben dann verwenden Sie diese, um die PWM-Wert zu steuern, erhöhen oder verringern die Helligkeit der LED-

Das Schaltbild ist unten dargestellt

Die Schaltung auf einem BreadBoard

And the source code for the sketch is shown below. It builds on the previous tutorial where we used the millis() function to give us a timing interval. We use the same idea here but use 5ms as the elapsed time check (5ms  = 200Hz). Hopefully, the code should be easy enough to understand and easily modifyable to put the Rotary Encoder to other uses.

Und der Quellcode für die Skizze ist unten dargestellt.

Es baut auf dem vorherigen Tutorial, in dem wir die Millis ()-Funktion verwendet, uns ein Zeitintervall zu geben.

Wir verwenden die gleiche Idee, aber hier verwenden 5ms, wie die abgelaufene Zeit Prüfung (5 ms = 200 Hz).

Hoffentlich, sollte der Code leicht zu verstehen und einfach modifizierbar, um die Drehgeber für andere Zwecke verwendet werden.

/*** Rotary Encoder Example** Verwenden Sie die ** Sparkfun Drehschalter, um die Helligkeit der LED-variieren **** Probieren Sie die Encoder bei 200Hz mit den Millis ()-Funktion */int brightness = 120;    // wie hell die LED, beginnen bei halber Helligkeitint fadeAmount = 10;     //wie viele Punkte zu verblassen die LED durchunsigned long currentTime;unsigned long loopTime;const int pin_A = 12;  // pin-12const int pin_B = 11;  // pin-11unsigned char encoder_A;unsigned char encoder_B;unsigned char encoder_A_prev=0;void setup()  {  pinMode(9, OUTPUT);   // declare pin 9 to be an output:  pinMode(pin_A, INPUT);  pinMode(pin_B, INPUT);  currentTime = millis();  loopTime = currentTime; } void loop()  {  currentTime = millis();   // die seit dem Start verstrichene Zeit  if(currentTime >= (loopTime + 5)){    // 5 ms seit dem letzten Check der Encoders = 200Hz      encoder_A = digitalRead(pin_A);    // Lese encoder-pin    encoder_B = digitalRead(pin_B);       if((!encoder_A) && (encoder_A_prev)){      // A has gone from high to low       if(encoder_B) {        // B is high so clockwise        // increase the brightness, dont go over 255        if(brightness + fadeAmount <= 255) brightness += fadeAmount;                     }         else {        // B is low so counter-clockwise              // decrease the brightness, dont go below 0        if(brightness - fadeAmount >= 0) brightness -= fadeAmount;                     }       }       encoder_A_prev = encoder_A;     // Store value of A for next time            // set the brightness of pin 9:    analogWrite(9, brightness);          loopTime = currentTime;  // Updates loopTime  }  // Other processing can be done here                           }

In this easy Arduino UNO tutorial, we are going to use a simple Piezo Transducer to create some beeps. Piezo Transducers are similar to speakers in that an applied voltage causes the piezo crystal to move and make a sound. In order to get a tone a square wave needs to be applied usually in the range 20Hz to 20kHz.

Don't confuse piezo transducers with piezo sounders or piezo buzzers. These behave in the same way as buzzers and have a built in oscillator and are switched on by a d.c. signal voltage. They are therefore limited to one frequency

We will use the PWM functionality of the Arduino to create a tone on the piezo transducer.

Note: For this tutorial we will not use the Arduino function tone() as this has a number of restrictions

• Can only be used on one pin at one time
• Use of the tone() function will interfere with PWM output on pins 3 and 11

The tone() function should be used if you require a different frequency and/or you are not using PWM on pins 3 and 11

The Arduino PWM runs at 500Hz so will produce a nice audible tone. We use the Piezo Transducer available here.

In diesem einfachen Arduino UNO-Tutorial, werden wir eine einfache Piezo Transducer verwenden, um einige Töne zu erzeugen.

Piezowandler sind ähnlich zu den Lautsprechern, dass eine angelegte Spannung bewirkt, dass die Piezo-Kristall zu bewegen und einen Ton.

Um einen Ton ein Rechteck muss im Bereich 20 Hz bis 20 kHz in der Regel angewendet werden erhalten.

Nicht zu verwechseln Piezowandler mit Piezo-Signalgeber oder Piezo-Summer.

Diese verhalten sich in der gleichen Weise wie Summer und haben ein Oszillator aufgebaut und werden durch eine DC Schalt Signalspannung.

Sie werden daher auf eine Frequenz beschränkt

Wir werden die PWM-Funktionalität des Arduino verwenden, um einen Ton auf der Piezo-Wandler zu schaffen.

Hinweis: Für dieses Tutorial werden wir nicht mit dem Arduino-Funktion Ton (), da dies eine Reihe von Einschränkungen

     Kann nur auf einem Stift auf einmal verwendet werden
     Verwendung des Tons ()-Funktion wird mit PWM-Ausgang auf den pin-3 und pin-11 stören

Die Funktion Ton () verwendet werden sollten, wenn Sie eine andere Frequenz erforderlich und / oder Sie sich nicht mit PWM auf den pin-3 und pin-11

Das Arduino PWM läuft mit 500 Hz, so wird eine schöne hörbaren Ton zu erzeugen.

Wir verwenden hier die Piezo Transducer zur Verfügung.

Connect the transducer to pin 9 and 0V on the Arduino

In the Arduino Sketch shown below we have created a separate function beep() which sends the PWM signal to the transducer, waits for a small delay, then turns the transducer off, then has another small delay. Thus, it beeps once. The delay (in milliseconds) is passed as a parameter. The PWM pulse duration (20 in sketch below) should not be important as it is the frequency that matters; set it to somewhere in the middle of the PWM range.

The sketch below beeps 3 times at startup and then beeps continuously at a slower rate.

Verbinden Sie den Wandler auf dem Arduino Pin 9 und 0 V

In dem unten gezeigten Arduino Sketch haben wir eine separate Funktion Signalton (), die das PWM-Signal an den Wandler sendet, wartet auf eine kleine Verzögerung erstellt, dann dreht den Wandler aus, hat dann eine weitere kleine Verzögerung.

So, piepst es einmal. Die Verzögerung (in Millisekunden) wird als Parameter übergeben.

Die PWM-Impulsdauer (20 in Skizze unten) sollte nicht wichtig sein, da es die Frequenz, was zählt; setzen Sie ihn auf irgendwo in der Mitte des PWM-Bereich.

Die folgende Skizze piept 3 mal beim Start und dann bei langsamer piept ununterbrochen.

/* Piezo  This example shows how to run a Piezo Buzzer on pin-9 using the analogWrite() function.  It beeps 3 times fast at startup, waits a second then beeps continuously at a slower pace  */void setup()  {   // declare pin-9 to be an output:  pinMode(9, OUTPUT);  beep(50);  beep(50);  beep(50);  delay(1000);} void loop()  {   beep(200); }void beep(unsigned char delayms){  analogWrite(9, 20);      // Almost any value can be used except 0 and 255                           // experiment to get the best tone  delay(delayms);          // wait for a delayms ms  analogWrite(9, 0);       // 0 turns it off  delay(delayms);          // wait for a delayms ms   }  

In this Arduino UNO tutorial, we are going to use a Light Dependent Resistor (LDR) to create a simple childrens bedroom nightlight which turns on automatically when it gets dark and turns off when it gets light.

An LDR's resistance changes depending upon the amount of light hitting the sensor.  For the LDR we are going to use the resistance reduces as the light falling on the device increases. Used in conjunction with a 4.7K resistor this forms a simple voltage divider where the voltage across the LDR changes dependent upon the light.

We can then input this into one of the Analog to Digital inputs in the Arduino to measure the voltage. Then its a simple matter of checking whether the value is above or below a threshold value and to turn one of the outputs on or off.

The LDR we are using is available here

In diesem Arduino UNO-Tutorial, werden wir eine Lichtabhängige Widerstände (LDR) verwenden, um eine einfache Kinderschlafzimmer Nacht, die sich automatisch auf, wenn es dunkel wird und schaltet sich aus, wenn es hell wird erstellen.

Eines LDR Widerstandsänderungen von der Menge an Licht auf den Sensor ab. Für die LDR werden wir verwenden, der Widerstand verringert, wie das Licht auf dem Gerät erhöht fallen. In Verbindung mit einem 4.7k Dies bildet eine einfache Spannungsteiler, wo die Spannung am LDR ändert abhängig von der Licht.

Wir können dann diese Eingabe in eine der Analog-Digital-Eingänge in der Arduino, um die Spannung zu messen.

Dann seine einfach eine Frage der Kontrolle, ob der Wert über oder unter einem Schwellenwert und zu einem der Ausgänge ein oder aus.

Die LDR wir verwenden hier erhältlich

The circuit diagram is shown below. As the light increases, the LDR's resistance drops and hence the voltage across it drops. Thus the voltage across the resistor increases, so the voltage into the Arduino ADC increases. The opposite is true as it gets darker.

Der Schaltplan ist unten gezeigt. Als Licht steigt, fällt der LDR Widerstand und damit die Spannung über der Preis fällt.

Somit ist die Spannung über den Widerstand erhöht, so dass die Spannung in den Arduino ADC erhöht.

Das Gegenteil ist wahr, wie es dunkler wird.

Here is the circuit laid out on a breadboard. 5V and 0V are taken from the Arduino. The input goes to pin A0

Hier ist die Schaltung auf einem Steckbrett gelegt. 5V und 0V aus dem Arduino gemacht. Der Eingang geht an pin-A0

Below is the Arduino Sketch. In this sketch we are simply turning on the built-in LED if the ADC value drops below a specific value. To make a nightlight, a brighter led (with limiting resistor ~220 ohms) can be connected to the pin 13 output.

In the code you will notice that there are some serial output statements that are commented out. If you uncomment these you will see on the serial monitor the current value of the voltage being read by the Arduino ADC input. This value is between 0 and 1024. Cover the LDR with your hand and shine a light on it to see the effect.

Change the value in the code where the LED is switched on to an appropriate value.

/*** Nightlight LDR test program** Created 06 Feb 2010**** This example code is in the public domain.** www.hobbytronics.co.uk*/int sensorPin = A0;            // select the input pin for the ldrunsigned int sensorValue = 0;  // variable to store the value coming from the ldrvoid setup(){  pinMode(13, OUTPUT);  //Start Serial port  Serial.begin(9600);          // start serial for output - for testing}void loop(){  // read the value from the ldr:  sensorValue = analogRead(sensorPin);       if(sensorValue<400) digitalWrite(13, HIGH);   // set the LED on  else digitalWrite(13, LOW);   // set the LED on    // For DEBUGGING - Print out our data, uncomment the lines below  //Serial.print(sensorValue, DEC);            // print the value (0 to 1024)  //Serial.println("");                        // print carriage return    //delay(500);  }

09-Arduino UNO Tutorial - Power

Ok, we've played around with dimming led's in a previous Arduino UNO tutorial, but the same code can be used to control more powerful components like high power led's and electric motors. The arduino can't provide enough power for these items though and quite often they also run at much higher voltages. Powerful motors often used in robotics may be run at 12, 24 or even 36 volts.

There is an easy way to provide the power switching that these items need and that is via the MOSFET transistor. These come in different types and power capabilities, but we will look at one particular MOSFET for this tutorial. The ST microelectronics 95N2LH5 N-Channel Power MOSFET

This MOSFET is capable of handling a continuous current of 80 Amps (with heatsink of course) and can be easily switched on with only 1V applied to its gate. We can thus switch this MOSFET fully on by connecting on of the Arduino digital output pins directly to the MOSFET gate pin. When switched on fully the MOSFET has a Source to Drain resistance of only 0.0049 ohm. Therefore, if the MOSFET were powering an electric motor at 12V taking 10 Amps the mosfet would only drop 0.049 volts and be using 0.49 watts of power.

The diagram below shows how we would connect the MOSFET to the motor and to the Arduino

Important Note: Do not try to run high power motors through the connections on a breadboard. They cannot handle the power and you will burn out the tracks underneath.

Ok, wir haben spielte mit Dimm-LEDs in einem früheren Arduino UNO-Tutorial, aber die gleiche Code kann verwendet werden, um leistungsfähigere Komponenten wie High-Power LED-und Elektromotoren zu steuern.

Das Arduino kann nicht genügend Strom für diese Artikel aber ziemlich oft und sie bei viel höheren Spannungen führen auch. Leistungsstarke Motoren oft in der Robotik verwendet wird, kann bei 12V, 24V oder sogar 36 Volt betrieben werden.

Es ist eine einfache Möglichkeit, um die Leistungsschalt, dass diese Elemente brauchen und das ist über die MOSFET-Transistor.

Diese kommen in verschiedenen Typen und Leistungsfähigkeiten zu kommen, aber wir werden an einem bestimmten MOSFET für dieses Tutorial freuen.

Die ST Microelectronics 95N2LH5 n-Kanal-Leistungs-MOSFET

Dieser MOSFET ist in der Lage einen kontinuierlichen Strom von 80 Ampere (mit Kühlkörper natürlich) und können leicht eingeschaltet werden, mit seinem Gate nur 1 V angelegt.

Wir können also schalten Sie diese MOSFET voll auf, indem Sie auf der Arduino digitalen Ausgangs-Pins direkt an den MOSFET-Gate-Pin.

Wenn auf voll eingeschalteter MOSFET hat eine Quelle, um den Widerstand von nur 0,0049 Ohm ablassen.

Deshalb, wenn der MOSFET wurden ein Elektromotor die Stromversorgung bei 12V unter 10 Ampere der MOSFET nur fallen 0,049 Volt und sein mit 0,49 Watt Leistung.

Das folgende Diagramm zeigt, wie wir den MOSFET an den Motor und an den Arduino anschließen

Wichtiger Hinweis: Versuchen Sie nicht, Hochleistungsmotoren durch die Verbindungen auf einem Steckbrett laufen.

Sie können die Leistung nicht, und Sie werden unter burn out die Spuren ..

By using the pulse width modulation (PWM) outputs from the Arduino we can control the power (and thus the speed) of the electric motor.

Try it out using the sketch from Arduino Tutorial 5 and a 12V car bulb and 12V battery. The 0V line will also need to be connected to one of the 0V connections on the Arduino, but the +12V only goes to the bulb.

Durch die Verwendung der Pulsbreitenmodulation (PWM) Ausgangssignale von dem Arduino können wir den Strom (und somit die Geschwindigkeit) des Elektromotors zu steuern.

Probieren Sie es aus mit der Skizze von Arduino Tutorial 5V und 12V Autobirne und 12V-Batterie.

Die 0V Leitung müssen auch zu einem der 0V Verbindungen auf dem Arduino verbunden werden, aber die +12V geht nur auf die bulb.tracks unter

We are now going to add an LCD display to our Arduino. The Arduino IDE comes with an example LCD sketch which uses an Hitachi HD44780 compatible LCD. We will use a similar LCD (Pololu 16x2 Character LCD 773 or 772)

Just to be different, we will make a small enhancement and do away with the Potentiometer that is normally required to adjust the screen contrast. Instead we will use one of the Arduino PWM outputs, smoothed by a capacitor, to create a simple Digital to Analog output which will allow us to control the screen contrast digitally from within our program. Pin 9 is used as the PWM output and this connects to the Vo contrast pin on the LCD (pin 3). A 100uF capacitor is connected between the PWM output and ground.

The contrast pin on the LCD requires a fairly small voltage for ideal display conditions. The lower the voltage the higher the contrast and vice versa. A voltage of approx 0.5V to 1V is about right, but depends on the ambient temperature. We have set the PWM output initially to 50 (output is ON about 20% of the time) to give a value approximating 1V. You may want to increase or decrease this figure to get the correct contrast on your LCD screen.

Here are the pinouts from the LCD and the corresponding pin connection on the Arduino

Wir werden jetzt ein LCD-Display, um unsere Arduino hinzuzufügen.

Die Arduino IDE kommt mit einem Beispiel LCD-Skizze, die eine Hitachi HD44780 kompatible LCD verwendet.

Wir werden eine ähnliche LCD verwenden (Pololu 16x2 Zeichen LCD 773 oder 772)

Nur anders zu sein, werden wir eine kleine Verbesserung zu machen und tun, weg mit dem Potentiometer, die normalerweise erforderlich ist, um den Kontrast des Bildschirms einstellen.

Stattdessen werden wir eine der Arduino PWM-Ausgänge, durch einen Kondensator geglättet zu verwenden, um eine einfache Digital-Analog-Ausgang, der es uns ermöglichen, den Kontrast des Bildschirms digital aus unserem Programm zu steuern schaffen. Pin 9 wird als PWM-Ausgang verwendet und dies verbindet sich auf dem LCD (Pin 3) der Vo Gegensatz Pin. A 100 uF-Kondensator ist zwischen dem PWM-Ausgang und Masse geschaltet.

Auf dem LCD der Kontrast Stift erfordert eine ziemlich kleine Spannung für optimale Handhabung.

Je niedriger die Spannung umso höher der Kontrast und umgekehrt. Eine Spannung von etwa 0,5 V bis 1 V ist etwa rechts, sondern hängt von der Umgebungstemperatur.

Wir haben die PWM-Ausgang zunächst auf 50 gesetzt (Ausgang auf ca. 20% der Zeit), um einen Wert annähert 1V geben.

Sie können zu erhöhen oder verringern diese Zahl, um die richtige Kontrast auf dem LCD-Bildschirm zu bekommen.

Hier sind die Pinbelegung von der LCD und der entsprechende Pin-Anschluss auf dem Arduino.

Below is a mockup of the wiring connections and the output displayed on the screen

And here we have a more detailed view

Und hier haben wir eine detailliertere Ansicht

And here is the Arduino Sketch. The PWM output to control the contrast is done in the setup routine, however, if you wanted to be able to control the contrast manually, then the addition of two push buttons and a bit more coding would allow you to increase and decrease the contrast in simple steps within the program.

Und hier ist die Arduino-Skizze. Der PWM-Ausgang, um den Kontrast zu steuern, ist in der Setup-Routine durchgeführt,

jedoch, wenn Sie in der Lage sein, um den Kontrast manuell zu steuern sein wollte, dann die Zugabe von zwei Tasten

und ein bisschen mehr Codierung erlaubt es dir, zu erhöhen und den Kontrast zu verringern einfachen Schritten innerhalb des Programms.

/* LiquidCrystal Library - Hobbytronics Demonstriert die Verwendung ein 16x2 LCD-Display. die Liquid 
  Bibliothek arbeitet mit allen LCD-Displays, die mit dem kompatibel sind 
  Hitachi HD44780-Treiber. Es gibt viele von ihnen gibt, und du 
  können in der Regel sagen, von der 16-Pin-Schnittstelle. 
 
  Diese Skizze druckt "Hobbytronics" auf dem LCD-
  und zeigt die Zeit. 
  Diese Skizze ist auf die Probe Skizze Arduino an der Basis 
  http://www.arduino.cc/en/Tutorial/LiquidCrystal 
  aber mit Modifikationen an der LCD-Kontrast ist zu machen 
  über Software einstellbar   The circuit: * LCD RS pin to digital pin 12 * LCD Enable pin to digital pin 11 * LCD R/W pin to Ground  * LCD VO pin (pin 3) to PWM pin 9 * LCD D4 pin to digital pin 5 * LCD D5 pin to digital pin 4 * LCD D6 pin to digital pin 3 * LCD D7 pin to digital pin 2 */// include the library code:#include <LiquidCrystal.h>// initialize the library with the numbers of the interface pinsLiquidCrystal lcd(12, 11, 5, 4, 3, 2);void setup() {  // declare pin 9 to be an output:  pinMode(9, OUTPUT);    analogWrite(9, 50);     // set up the LCD's number of columns and rows:   lcd.begin(16, 2);  // Print a message to the LCD.  lcd.print("  HobbyTronics");}void loop() {  // set the cursor to column 0, line 1  // (note: line 1 is the second row, since counting begins with 0):  lcd.setCursor(0, 1);  // print the number of seconds since reset:  lcd.print(millis()/1000);}

Note on 16x4 displays. There is a well documented bug in the Arduino LCD library with regard to all 16x4 displays.  The problem is that the 16x4 has different starting addresses for lines 3 and 4 than the 20x4 for which the library is written.This means that the lcd.setCursor command doesn't work correctly for lines 3 and 4.

There is fortunately a simple fix. Instead of lcd.setCursor(0,3) to set position at the beginning of line 3 you should use lcd.setCursor(-4,3). The same applies to line 4.

Hinweis zum 16x4-Displays. Es gibt eine gut dokumentierte Fehler in der Arduino LCD Bibliothek in Bezug auf alle 16x4-Displays.

Das Problem ist, dass die 16x4 hat unterschiedliche Startadressen für die Linien 3 und 4 als die 20x4, für die die Bibliothek ist written.

This bedeutet, dass der Befehl lcd.setCursor nicht richtig für die Linien 3 und 4 zu arbeiten.

Es gibt zum Glück eine einfache Lösung. Statt der lcd.setCursor (0,3) in die Position zu Beginn der Linie 3, sollten Sie lcd.setCursor verwenden (-4,3) gesetzt.

Das gleiche gilt für die Linie 4.

11-Arduino UNO Tutorial - Hall Effect Switch

Ok, this is an easy one to make. We are going to use a hall effect switch to turn the Arduino UNO's built-in led on and off with a magnet.

We will be using the Allegro Microsystems A1120EUA Hall Effect Switch

• Connect pin 1 of the switch to the Arduino +5V supply (red wire)
• Connect pin 2 to 0V (black wire)
• Connect pin 3 to Arduino input pin 12 (orange wire)

A pull-up resistor is required between pin 1 and pin 3 to pull-up the switch's output to +5V.

When the switch detects a magnet, it will pull it's output pin low, which we can easily detect on the Arduino board.

Ok, das ist ganz leicht zu machen. Wir werden einen Hall-Effekt-Schalter verwenden, um schalten Sie die Arduino UNO integrierten LED an und aus mit einem Magneten.

Wir werden mit dem Allegro Microsystems A1120EUA Hall-Effekt-Schalter

     Verbinden Sie pin-1 des Schalter in die Arduino + 5V-Versorgung (rotes Kabel)
     pin-2 auf 0V (schwarzer Draht)
     Verbinden Sie Pin 3 Arduino Eingang pin-12 (orange Draht)

Ein Pull-up-Widerstand zwischen pin-1 und pin-3 auf + 5V Pull-up-Ausgang des Schalters erforderlich.

Wenn der Switch erkennt einen Magneten, wird es zu ziehen, es ist Ausgangs-Pin niedrig, die wir einfach auf dem Arduino-Board zu erkennen.

Here is the Arduino sketch

/* Hall Effect Switch Schaltet ein und aus einer Leuchtdiode (LED), um digitale verbunden 
  pin-13, als Hall-Effekt-Sensor angebracht an pin-2 wird von einem Magneten angesteuert 
 
  Hall-Effekt-Sensor verwendet wird, ist die A1120EUA von Allegro Microsystems 
 
  Dieses Beispiel-Code ist in der Public Domain. 
 
  http://www.hobbytronics.co.uk/arduino-tutorial8-Hall-Effekt*/// constants won't change. They're used here to set pin numbers:const int hallPin = 12;     // the number of the hall effect sensor pinconst int ledPin =  13;     // the number of the LED pin// variables will change:int hallState = 0;          // variable for reading the hall sensor statusvoid setup() {  // initialize the LED pin as an output:  pinMode(ledPin, OUTPUT);        // initialize the hall effect sensor pin as an input:  pinMode(hallPin, INPUT);     }void loop(){  // read the state of the hall effect sensor:  hallState = digitalRead(hallPin);  if (hallState == LOW) {         // turn LED on:        digitalWrite(ledPin, HIGH);    }   else {    // turn LED off:    digitalWrite(ledPin, LOW);   }}