Tutorial

http://sites.prenninger.com/arduino-uno-r3/anleitung-tutorial/tutorial

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                         Wels, am 2015-04-12

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4  ausdrucken   siehe     http://sites.prenninger.com/drucker/sites-prenninger
********************************************************I*
~015_b_PrennIng-a_arduino.uno.r3-anleitung.tutorial-tutorial (xx Seiten)_2a.pdf




Untergeordnete Seiten (1):




Arduinotutorials

Hast du von einem Arduino gehört oder hast du schon mal ein cooles Projekt mit einem Arduino gesehen?
Du möchtest lernen wie du selber mit dem Arduino coole Projekte verwirklichst?
Hier erfährst du alles was du wissen musst um mit dem Arduino durchzustarten!
Alle Projekte wurden mit der Arduino IDE Version 1.6.8 durchgeführt!

1. Einsteigertutorial

2. Zur Programmierung

3. Sensoren

4. Aktoren

5. Porterweiterung

6. Displays

7. Kommunikation

8. Kleine Projekte




Quelle:
https://www.mymakerstuff.de/arduinotutorials-1/





********************************************************I*
hobbytronics.co.uk  tutorials-code arduino-tutorials
                     HobbyTronics Ltd.


Skizze = Sketch

https://www.arduino.cc/en/Tutorial/HomePage

Arduino Tutorials

http://www.arduino-tutorial.de/




BÜCHER
Arduino – Physical Computing für Bastler, Designer und Geeks   Verlag O REILLY

Programming Arduino Next Steps: Going Further with Sketches    Simon Monk

Arduino für Einsteiger     Verlag O REILLY  Massimo Banzi, Michael Shiloh

Arduino für Dummies  John Nussey

30 Arduino Projects for the Evil Genius  Simon Monk

Arduino in der Praxis


Die wichtigsten Anleitungen zur Arduino-Programmierung

Harold Timmis
Erik Bartmann:
Die elektronische Welt mit Arduino entdecken.
Mit dem Arduino messen, steuern und spielen, Elektronik leicht verstehen, kreativ programmieren lernen. O’Reilly, Köln 2011,
ISBN 978-3-89721-319-7 (behandelt Arduino 1.0).


Thomas Brühlmann:
Arduino: Praxiseinstieg. mitp, Heidelberg 2012,
ISBN 978-3-8266-9116-4.

Michael Margolis:
Arduino Kochbuch. O’Reilly, Köln 2012,
ISBN 978-3-86899-353-0.


Simon Monk:
30 Arduino Selbstbau-Projekte, Franzis, Haar 2012,
ISBN 978-3-645-65136-3.

Manuel Odendahl, Julian Finn, Alex Wenger:
Arduino – Physical Computing für Bastler, Designer und Geeks. O’Reilly, Köln 2009,
ISBN 978-3-89721-893-2.

Mike Riley: O’Reillys basics:
Das intelligente Haus – Heimautomation mit Arduino, Android und PC. O’Reilly, Köln 2012,
ISBN 978-3-86899-363-9.

Maik Schmidt:
Arduino Ein schneller Einstieg in die Microcontroller-Entwicklung. dpunkt, Heidelberg 2011,
ISBN 978-3-89864-764-9.

Ulli Sommer:
Arduino: Mikrocontroller-Programmierung mit Arduino, Freeduino. Franzis, Poing 2010,
ISBN 978-3-645-65034-2.

Günter Spanner:
Arduino: Schaltungsprojekte für Profis. Elektor, Aachen 2012,
ISBN 978-3-89576-257-4.

Harold Timmis:
Arduino in der Praxis. Franzis, Haar 2012,
ISBN 978-3-645-65132-5.

Dale Wheat:
Arduino Internals. Apress, New York NY 2011,
ISBN 978-1-4302-3882-9 (englisch).


https://de.wikipedia.org/wiki/Arduino_(Plattform)




*********************************************************

hobbytronics.co.uk  tutorials-code arduino-tutorials

                     HobbyTronics Ltd.

01-Arduino UNO Tutorial - Flashing LED
02-Arduino UNO Tutorial - Servos
03-Arduino UNO Tutorial - Timing
04-Arduino UNO Tutorial - Simple Cylon
05-Arduino UNO Tutorial - Fade
06-Arduino UNO Tutorial - Rotary Encoder
07-Arduino UNO Tutorial - Piezo Beep
08-Arduino UNO Tutorial - NightLight
09-Arduino UNO Tutorial - Power
10-Arduino UNO Tutorial - LCD
11-Arduino UNO Tutorial - Hall Effect Switch


01-Arduino UNO Tutorial - Flashing LED

This Arduino UNO Flashing LED tutorial is a basic 'Introduction to Arduino' tutorial and shows how to simply flashes the LED that is on the Arduino UNO board. 

The Arduino UNO already has an led and resistor connected to output pin 13, so we will use that. No other components are required.

Das Arduino UNO blinkende LED-Tutorial ist eine grundlegende "Einführung in Arduino 

und zeigt, wie einfach die LED blinkt, die auf dem Arduino UNO Board schon vorhanden ist.

Das Arduino UNO Rev3 hat bereits eine LED an pin-13 OnBoard. Sind keine  Komponenten erforderlich.
 

/* 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 }



*********************************************************

02-Arduino UNO Tutorial - Servos

Radio Control Servos are great pieces of kit. They are essential in pretty much every robot build, from controlling arms and legs to driving wheels and tracks. Servos normally rotate up 180 degrees with the 90 degree mid-point being the center position, and can be positioned at any point in-between. By replacing the positional feedback potentiometer inside a servo can be made to fully rotate in either direction and be made to drive wheels for your robot. (this modification is for a later tutorial)

So, lets get used to driving a servo with the Arduino Uno

Load the following arduino sketch program. We start off by including the <Servo.h> file. This file contains all the coding required for controlling servos to make our life really easy. Next we need to create our servo object. Our servo is to be called servoMain (but it can be called anything you like). Next comes the setup() function and inside we attach our servo object to pin 10.

We are now ready to send commands to our servo. In the main loop() function we issue a number of commands to rotate the servo to various positions, with a 1 second delay between each command.

Radio Control Servos (RC-Servos) sind Bestandteil des KIT.

Sie sind wichtig in so ziemlich jedem Roboter, um Arme und Beine bewegen zu können auf die Antriebsräder konnen damit angetrieben werden.

Servos drehen in der Regel 0..180 Grad mit der 90 Grad = Mittelstellung.

Ein Servo kann an jedem beliebigen Punkt dazwischen positioniert werden.

Durch den Austausch der Positionsrückmeldung Potentiometer in einem Servo können Servos auch zum Antrieb von Rädern für Roboter verwendet werden.

(Diese Änderung der Servos in einen späteren Tutorial)

Laden Sie die folgenden Arduino Sketch-Programm.

Wir starten, indem Sie die <Servo.h> Datei aufrufen.

Diese Datei enthält alle für die Steuerung Servos unser Leben einfach zu machen, benötigt Codierung.

Als nächstes müssen wir unsere Servo Objekt zu erstellen.

Unsere Servo aufgerufen werden servoMain (aber es kann alles, was Sie gerne haben).

Als nächstes kommt die setup ()-Funktion und daran haben wir unsere Servo Objekt angehängt an pin-10.

Wir sind nun bereit, um Befehle an unsere Servo senden.

In der Hauptschleife ()-Funktion erstellen wir eine Reihe von Befehlen an den Servo in verschiedene Positionen drehen, mit einer Verzögerung von 1 Sekunde zwischen jedem Befehl.


/*
Arduino Servo Test sketch
*/
#include <Servo.h>
Servo servoMain; // Deffiniert das Servo

void 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   
}

Servo  haben 3 Leitungen. Normalerweise schwarz, rot (Mitte) und entweder orange oder weiß.

Servo

Using some single strand hook up wire, connect the black wire to one of the Arduino 0V pins. Connect the red wire (center wire) to the Arduino 5V pin. And finally connect the orange/white wire to pin 10.

Try it out, and play around with the settings

Mit einigen 0,65mm Schaltdraht, verbinden Sie das schwarze Kabel an eine der Arduino pin-0V (GND).
Das rote Kabel (Mittet) mit dem Arduino pin +5V.
Und schließlich verbinden die orange bzw. weiße Kabel an pin-10.





*********************************************************
03-Arduino UNO Tutorial - Timing

Moving on from Tutorial 1 where we flashed an LED on for a second then off for a second in a continuous loop.
The program is shown below and has one major flaw. We are using the delay() function to delay the processor for 1 second before toggling the LED on or off. While it is waiting, the microcontroller cannot perform any other functions in the main loop().


Geht man von Tutorial 1, wo wir blitzte für einen zweiten eine LED auf und dann für eine zweite in einer Endlosschleife.
Das Programm ist unten und hat eine große Schwachstelle.
Wir werden mit der Verzögerung ()-Funktion, um den Prozessor für 1 Sekunde, bevor die Umstellung von LED an oder aus zu verzögern.
Während er wartet, kann der Mikrocontroller keine weiteren Funktionen in der Hauptschleife durchzuführen ().


/* 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-13
unsigned 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






*********************************************************
04-Arduino UNO Tutorial - Simple Cylon

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


NOTE:If you have used any of Microchips microcontrollers they use the opposite strategy, where 0 is OUTPUT and 1 is INPUT
For our Cylon eye we will use port B pins 0 to 4, so we set them as outputs with


HINWEIS: Wenn Sie eine der Mikrochips Mikrocontroller verwendet haben sie die entgegengesetzte Strategie, wobei 0 und 1 OUTPUT INPUT verwenden
Für unsere Zylonen Auge werden wir Port B pin-0 bis pin-4 zu verwenden, so setzen wir sie als Ausgänge mit


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


Notice how the single digit 1 is moving up the number. This is the exact effect we need for our Arduino Cylon eye sketch
Now to the code, which is shown below. We need a couple of variables, one (upDown) to indicate whether we are moving up or down the port LEDs and another (cylon) to indicate which LED should be illuminated.
In setup() we define the port pins required as OUTPUTs.
In the main loop(), if we are going up the LEDs we increase the cylon variable by 1 and test to see if we have reached the last LED, if we have then we set the upDown variable to be going down. Similarly, if we are going down we decrease the cylon variable by 1 and test to see if we have reached the first LED, if we have then we set the upDown variable to be going up.
We then light up the correct LED and wait a sort while before starting again.

Beachten Sie, wie die einzelnen Ziffer 1 bewegt die Zahl. Dies ist die genaue Wirkung, die wir für unsere Arduino Zylonen Auge Skizze
Nun zum Code, der unten ist. Wir brauchen ein paar Variablen, ein (UPDOWN), um anzuzeigen, ob wir oben oder unten bewegt Port-LEDs und einem anderen (Zylonen), um anzuzeigen, die LED sollte leuchten.
In setup () definieren wir die Port-Pins als Ausgänge erforderlich.
In der Hauptschleife (), wenn wir bis die LEDs wir die Zylonen Variable um 1 erhöht und Test, um zu sehen, wenn wir die letzte LED erreicht, wenn wir dann setzen wir die Variable auf UPDOWN werden nach unten. Ebenso, wenn wir sinken wir die Zylonen variable verringern, indem 1 und Test, um zu sehen, wenn wir die erste LED erreicht, wenn wir dann setzen wir die UPDOWN variabel zu sein steigt.
Wir zünden dann die richtige LED und warten eine Art, während vor dem Start noch einmal.


/*
  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.


Arduino Simple Cylon Breadboard






*********************************************************
05-Arduino UNO Tutorial - Fade

Following on from our Arduino UNO tutorial 3 where we examined timing, here is an update to the standard Arduino Fade example. Instead of using the wasteful delay() function we use the timing functionality from tutorial 3 which allows other code to be run at the same time. The code should be self explanatory.
Simply connect an LED and 220 ohm series resistor between pin 9 and ground.


Im Anschluss an unsere Arduino UNO Tutorial 3, wo wir untersucht Timing, hier ist ein Update auf die Standard-Arduino Fade
Beispiel.
Statt mit der verschwenderischen Verzögerung ()-Funktion verwenden wir das Timing Funktionalität von Tutorial 3,
die anderen Code, um zur gleichen Zeit ausgeführt werden können. Der Code sollte selbsterklärend sein.
Verbinden Sie einfach eine LED und 220 Ohm Serienwiderstand zwischen Pin 9 und Boden.

/*
 Fade 
Dieses Beispiel zeigt, wie eine LED an Pin 9 verblassen
Verwendung der analogWrite ()-Funktion.
 
Dieses Beispiel basiert auf der Arduino Beispiel Fade Skizze
jedoch modifiziert, um die Zeitverzögerung statt der ()-Funktion
 */
int brightness = 0;    // Wie hell die LED ist
int fadeAmount = 5;    // how many points to fade the LED by
unsigned 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                             }





*********************************************************
06-Arduino UNO Tutorial - Rotary Encoder

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.


Sparkfun Rotary Encoder

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.

Mit einem Drehgeber haben wir zwei Rechteckwellenausgänge (A und B), die 90 Grad außer Phase zueinander sind.
Die Anzahl von Impulsen
oder Schritten pro vollständige Umdrehung erzeugt variiert.
Der
Drehgeber hat Sparkfun 12 Stufen, aber andere können mehr oder weniger haben.
Das folgende Diagramm zeigt
, wie sich die Phasen A und B zueinander stehen, wenn der Geber im Uhrzeigersinn gedreht wird oder gegen den Uhrzeigersinn.


Rotary Encoder Phase Pulses

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


Arduino Rotary Encoder Schematic


Die Schaltung auf einem BreadBoard

Arduino Rotary Encoder 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 Helligkeit
int fadeAmount = 10;     //wie viele Punkte zu verblassen die LED durch
unsigned long currentTime;
unsigned long loopTime;
const int pin_A = 12;  // pin-12
const int pin_B = 11;  // pin-11
unsigned 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
                           
}






*********************************************************
07-Arduino UNO Tutorial - Piezo Beep

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.

Piezo Transducer

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   
}  




*********************************************************
08-Arduino UNO Tutorial - NightLight

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.


Arduino Nightlight circuit diagram

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


arduino Nightlight Breadboard

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.


Unten ist die Arduino-Skizze. In dieser Skizze sind wir einfach Einschalten der eingebauten LED, wenn der ADC-Wert unter einen bestimmten Wert fällt.
Um ein
Nachtlicht zu machen, ein heller (mit Begrenzungswiderstand ~ 220 Ohm) mit dem Ausgang Pin 13 angeschlossen werden geführt.

Im Code werden Sie feststellen, dass es einige Aussagen, die serielle Ausgabe auskommentiert werden.
Wenn Sie
diese auskommentieren Sie auf der seriellen Monitor der aktuelle Wert der Spannung von der Arduino ADC-Eingang lesen sehen.
Dieser Wert liegt zwischen
0 und 1024 abdecken LDR mit der Hand und werfen ein Licht auf sie, um den Effekt zu sehen.

Ändern Sie den Wert in der Code, wo die LED auf, um einen geeigneten Wert umgeschaltet.

/*
** 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 ldr
unsigned int sensorValue = 0;  // variable to store the value coming from the ldr

void 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 ..



Power Mosfet connection to Arduino


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





*********************************************************
10-Arduino UNO Tutorial - LCD

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.


LCD Pin Symbol Function Arduino Pin
1 Vss ground (0 V) ground (0V) GND
2 Vdd power (4.5 – 5.5 V) +5V
3 Vo contrast adjustment pin-9
4 RS H/L register select signal pin-12
5 R/W H/L read/write signal ground (0V) GND
6 E H/L enable signal pin-11
11 DB4 H/L data bus for 4-bit mode pin-5
12 DB5 H/L data bus for 4--bit mode pin-4
13 DB6 H/L data bus for 4-bit mode pin-3
14 DB7 H/L data bus for 4-bit mode pin-2

 

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


Unten ist ein Mockup der Kabelanschlüsse und die Ausgabe auf dem Bildschirm angezeigt


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 pins LiquidCrystal 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.

 

Arduino UNO and Hall Effect Switch


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 pin const int ledPin = 13; // the number of the LED pin // variables will change: int hallState = 0; // variable for reading the hall sensor status void 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);   } }

Quelle:
HOBBY ELECTRONICS

HobbyTronics Ltd
29 Beckside
Wilberfoss
York
YO41 5NS
UK

http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial1-flash-led





DIN A4  ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE




Untergeordnete Seiten (1): Lektion
Comments