http://sites.schaltungen.at/arduino-uno-r4/video-f-einst
http://www.linksammlung.info/
http://www.schaltungen.at/
Wels, am 2015-12-24
BITTE nützen Sie doch rechts OBEN das Suchfeld
[ ] [ Diese Site durchsuchen]
DIN A3 oder DIN A4 quer ausdrucken
*********************************************************************************************
DIN A4 ausdrucken (Heftrand 15mm / 5mm)
****************************************************************
Video für Einsteiger
geändert auf Windows 8 und mit meinem Kommentar ergänzt
www.maxtechtv.de
Fa. watterott electronic
http://www.watterott.com/de/Boards-Kits/Arduino
Arduino Tutorial
http://arduino.cc/de/Main/ArduinoBoardUno
http://arduino.cc/de/Guide/Windows
http://arduino.cc/de/Reference/HomePage
http://arduino.cc/de/Main/ArduinoBoardEthernet
http://arduino.cc/de/Reference/AnalogWrite
http://arduino.cc/de/Reference/AnalogRead
http://arduino.cc/de/Reference/AttachInterrupt
Deutsche Übersetzungen einiger Arduino Tutorials sind hier zu finden:
http://playground.arduino.cc/Deutsch/HomePage
Teil - 1. Einführung Win 8.1 (#1)
ADUINO UNO R3 in Windows 8.1 installieren.
board model r3
UNO R3 mit USB-B auf USB-A Verbindungskabel am PC anschließen.
Eine LED ohne Vorwiderstand am Pin 13 anzuschließen ist todlich für pin.13.
pin.13 hat keinen Vorwiderstand.
Man braucht an pin.13 (= auch Pin SCK) keine Led anschließen da auf dem Board R3 über SCK (= pin.13) über einen Op-Amp schon eine eingbaute LED (L) vorhanden ist.
ACHTUNG: LEDs immer mit Vorwiderstand anschließen z.B. rote LED 1,7V U=IxR R=U/I R=(5V-1,7V) / 20mA = mind. 165 Ohm wir nehmen 220Ohm
ODER rote LED 2,2V U=IxR R=U/I R=(5V-2,2V) / 15mA = mind. 186 Ohm wir nehmen 220Ohm
ODER rote LED low current 2,1V U=IxR R=U/I R=(5V-2,1V) / 2mA = mind. 1.450 Ohm wir nehmen 1,5kOhm
Mein Tipp: Spannung und Strom der Leds sind sehr unterschiedlich wegen der versch. Halbleiter-Materialien und LED-Farben,
Besser immer die Daten des Datenblattes verwenden.
Oder für Ungeduldige mit 2,2kOhm beginnen und bie 56 Ohm reduzieren dies alle kann bei 5V und div. LEDs passieren.
ADUINO-Software und ADUINO-Treiber downloaden von www.arduino.cc
MENU > Download > Windows (ZIP file) > arduino-1.0.5-r2-windows-zip
ZIP-Datei entpacken im ORDNER "ADUINO R3"
dann
mit rechter Maustaste auf START (Fenster-Logo links unten) Geräte-Manager klicken
Andere Geräte > Arduino Uno wird angezeigt
Doppelklick auf den Eintrag "Arduino Uno" im Eigenschaftsfenster den Reiter Treiber auswählen > Treiber aktualisieren > nach Treibersoftware suchen in der entpackten ZIP-Datei
ORDNER arduino-1.0.5-r2 > drivers
"dpinst-x86.exe" for 32-bit Windows 7; "dpinst-amd64.exe" for 64-bit Windows 8.1.
Sicherheitswarnung ignorieren
Treibersoftware trotzdem installieren dann die Datei aduino.exe doppelklicken das ist die ADUINO Entwicklungsumgebung in der man die ARDUINO-Sketches erstellen und editieren kann.
MENU > Tools > Board > Arduino Uno
MENU > Tools > Serieller Port > COM3
MENU > Datei > Beispiele > 01.Basics > Blink (Sketch-Datei)
Den im Editor stehenden Code mit (Symbol Pfeil nach rechts = Upload ) auf den uC übertragen
Ein Wunder die LED blinkt
Anschlüsse (COM & LPT)
Arduino Uno (Com3)
Arduino-Programmiersprache - Arduino-Processing auf Wiring aufbauend ähnlich C/C++
ACHTUNG: Groß und Kleinschreibung beachten
/*
Blink | Arduino 1.0.5-r2 | UNO R3
Schaltet die eingebaute LED (L) UNO R3 (pin.13 = SCK) für eine Sekunde ein, dann für eine Sekunde aus wiederholt sich ewig.
Dieser Beispiel-Code ist in der Public Domain.
*/
//
pin.13 verfügt über eine vorhandene LED (über Op-Amp) auf den Arduino-Board UNO Rev.3.
//
pin.13 den Namen "led" geben:
int led = 13;
//
1. Teil setup-Teil = Infos über die pin-Nutzung = Variablen benennen
void setup() {
pinMode(led, OUTPUT); //
Initialisiert den digitalen pin.13 als Ausgang
}
//
2. Teil loop-Teil = Schleifen-Teil = Hauptprg. (Dauer-Schleifenroutine läuft immer)
void loop() {
digitalWrite(led, HIGH); //
pin.13 geht auf +5V
delay(1000); // Wartezeit 1 Sekunde
digitalWrite(led, LOW); //
pin.13 geht auf GND
delay(500); // Wartezeit 0,5 Sekunde
}
(Hackerl) = Überprüfen - Kompilierung abgeschlossen
(Pfeil) = Upload - den im Editor stehenden Code auf den uC übertragen
Teil - 2. Erste Schritte (#2)
Arduino-Programmiersprache - Arduino-Processing auf Wiring aufbauend ähnlich C/C++
Die Sprache heißt "C / C++" und basiert kein bischen auf Java. C gibt es seit 1972. Java seit 1995.
Es wurde kein "S O S" nur nur "S O" programiert,
Die Länge der Dits entspricht nicht der Norm
Zwischen den Buchstabe fehlt Leerzeichen mit 3 Dits.
So denke ich könnte es sein
/*
SOS_Notsignal_1a (Save Our Souls) | Arduino 1.0.5-r2 | UNO R3
eingebaute LED (L) UNO R3 (pin.13 = SCK) sendet S-O-S Code
Länge eines Dits 240ms Übertragungsrate 5WpM = Wörter / Minute entspricht ungefähr 25BpM = Buchstaben / Minute
*/
// pin.13 verfügt über eine vorhandene LED (über Op-Amp) auf den Arduino-Board UNO Rev.3.
int led = 13; // pin.13 den Namen "led" geben
// 1. Teil setup-Teil = Infos über die pin-Nutzung = Variablen benennen
void setup()
{
pinMode(led, OUTPUT); // Initialisiert den digitalen pin.13 als Ausgang
}
// 2. Teil loop-Teil = Schleifen-Teil = Hauptprg. (Dauer-Schleifenroutine läuft immer)
void loop() {
digitalWrite(led, HIGH); // pin.13 geht auf +5V
delay(240); // Wartezeit 200ms
digitalWrite(led, LOW); // pin.13 geht auf GND
delay(240); // Wartezeit 200ms
digitalWrite(led, HIGH);
delay(240);
digitalWrite(led, LOW);
delay(240);
digitalWrite(led, HIGH);
delay(240);
digitalWrite(led, LOW);
delay(720);
digitalWrite(led, HIGH);
delay(720);
digitalWrite(led, LOW);
delay(720);
digitalWrite(led, HIGH);
delay(720);
digitalWrite(led, LOW);
delay(720);
digitalWrite(led, HIGH);
delay(720);
digitalWrite(led, LOW);
delay(720);
digitalWrite(led, HIGH);
delay(240);
digitalWrite(led, LOW);
delay(240);
digitalWrite(led, HIGH);
delay(240);
digitalWrite(led, LOW);
delay(240);
digitalWrite(led, HIGH);
delay(240);
digitalWrite(led, LOW);
delay(2160);
}
(Hackerl) = Überprüfen - Kompilierung abgeschlossen
(Pfeil) = Upload - den im Editor stehenden Code auf den uC übertragen
Speichern in Arduino > libraries > SOS-Notsignal_1a
Teil - 3. Einfacher Input (#3)
In der ADUINO Entwicklungsumgebung eien neuen Sketch programmieren
Entgegen dem Video soll man sich angewöhnen auf Steckbrettern auch die genormten Kabel-Farben zu verwenden
+5V (Vcc) = rot
GND = schwarz
-5V = blau
gelb / weis Schalter-Eingänge
orange / grün LED Ausgänge
/*
Taster_Anzeige_am_Serial_Monitor_1a | Arduino 1.0.5-r2 | UNO R3
Ausgabe von 0 und 1 im ARDUNO-Serial-Monitor
10k Widerstand auf GND und pin.2
Taster auf +5V und pin.2
*/
//
1. Teil setup-Teil = Infos über die pin-Nutzung = Variablen benennen
void setup()
{
Serial.begin(115200); // Baudrate der Übertragung muß auf beiden Seiten übereinstimmen da es sonst zu Lesefehlern kommt
pinMode(2,INPUT); // definiert pin.2 als Eingang
}
// 2. Teil loop-Teil = Schleifen-Teil = Hauptprg. (Dauer-Schleifenroutine läuft immer)
void loop()
{
int Taster; // Variable integer - Variablen-Name Taster
Taster = digitalRead(2); // pin.2 Tastereingang auslesen
Serial.println(Taster,DEC); // print line - Dezimalzahl wird an den Serial Monitor (am PC) seriell übertragen
}
Upload
Serial Monitor
MENU > Tools > Serial Monitor (Strg+Umschalt+M)
Taster nicht gedrückt offen pin.2 über 10k auf GND Im Video wird genau das Gegenteil behauptet
0
0
0
Taster gedrückt Kontakte geschlossen pin.2 +5V
1
1
1
Wenns nicht geht siehe HIER
Arduino Uno (COM3) rechte Maustaste "Eigenschaften"
MENU > Tools > Serial Monitor > COM3 > 115200 baud
im Video heißt es -32,769 bis +32767 das ist natürlich FALSCH
- int (von -32768 bis 32767) - boolean (true oder false) - Byte (8bit = 0 bis 255 = 0000 1111)
- char (8bit ASCII-Zeichen z.B. 65=A) - long (- / +2,1 Milliarden) - float (Kommazahlen - nicht verwenden !)
- String (Wörter speichern - besser char verwenden) -
*.ino
/*
Taster_Anzeige_am_Serial_Monitor_2a | Arduino 1.0.5-r2 | UNO R3
Ausgabe von 0 und 1 im ARDUNO-Serial-Monitor
10k Widerstand auf GND und pin.2
Taster auf +5V und pin.2
*/
//
1. Teil setup-Teil = Infos über die pin-Nutzung = Variablen benennen
int Taster;
int DE2 = 2; // Variabletyp
integer - Variablen-
Name DE2 -
Wert 2
void setup()
{
Serial.begin(115200); // Baudrate der Übertragung muß auf beiden Seiten übereinstimmen da es sonst zu Lesefehlern kommt
pinMode(DE2,INPUT); // definiert pin.2 als Eingang
}
// 2. Teil loop-Teil = Schleifen-Teil = Hauptprg. (Dauer-Schleifenroutine läuft immer)
void loop()
{
Taster = digitalRead(DE2); // pin.2 Tastereingang auslesen
Serial.println(Taster,DEC); // print line - Dezimalzahl (0 od. 1) wird an den Serial Monitao (am Computer) seriell übertragen
}
(Hackerl) = Überprüfen - Kompilierung abgeschlossen
(Pfeil) = Upload - den im Editor stehenden Code auf den uC übertragen
Teil - 5. if-Bedingung (#5)
x == y x gleich y
x != y x ungleich y
x < y x kleiner y
x > y x größer y
x <= y x kleiner gleich y
x >= y x größer gleich y
/*
Taster_schaltet_LED ein_aus_1a | Arduino 1.0.5-r2 | UNO R3
Taster
schaltet eingebaute LED (L) UNO R3 (pin.13 = SCK) nichtgedrückt AUS - gedrückt EIN,
10k Widerstand auf GND und pin.2 - Taster auf +5V und pin.2
*/
//
1. Teil setup-Teil = Infos über die pin-Nutzung = Variablen benennen
int Taster;
int DE2 = 2; // Variabletyp
integer - Variablen-
Name DE2 -
Wert 2 (pin.2)
int Led = 13; //
pin.13 den Namen "Led" geben
void setup() {
Serial.begin(115200); // Baudrate der Übertragung muß auf beiden Seiten übereinstimmen da es sonst zu Lesefehlern kommt
pinMode(DE2,INPUT); // definiert pin.2 als Eingang
pinMode(Led,OUTPUT); // definiert pin.13 als Ausgang
}
// 2. Teil loop-Teil = Schleifen-Teil = Hauptprg. (Dauer-Schleifenroutine läuft immer)
void loop() {
Taster = digitalRead(DE2); // pin.2 Tastereingang auslesen
Serial.println(Taster,DEC); // print line - Dezimalzahl (0 od. 1) wird an den Serial Monitao (am Computer) seriell übertragen
if (Taster == 1)
{
digitalWrite(Led,HIGH);
}
if (Taster == 0)
{
digitalWrite(Led,LOW);
}
}
(Hackerl) = Überprüfen - Kompilierung abgeschlossen
(Pfeil) = Upload - den im Editor stehenden Code auf den uC übertragen
/*
Taster_schaltet_LED ein_aus_2a | Arduino 1.0.5-r2 | UNO R3
Taster
schaltet eingebaute LED (L) UNO R3 (pin.13 = SCK) nichtgedrückt AUS - gedrückt EIN,
10k Widerstand auf GND und pin.2 - Taster auf +5V und pin.2
*/
const int Led = 13;
const int DE2 = 2;
int val = 0;
void setup() {
pinMode(Led, OUTPUT);
pinMode(DE2, INPUT);
}
void loop() {
val = digitalRead(DE2);
if (val == HIGH) {
digitalWrite(Led, HIGH);
} else {
digitalWrite(Led, LOW);
}
}
Teil - 6. While-Schleife (#6)
TRUE FALSE
/*
LED_blinkt_10mal_dann_3sec_aus_1a | Arduino 1.0.5-r2 | UNO R3
Eingebaute LED (L) UNO R3 (pin.13 = SCK) blinkt 10 mal dann 3 Sekunden aus und ewig weiter so
*/
int Led = 13; // pin.13 den Namen "Led" geben
void setup()
{
pinMode(Led,OUTPUT); // definiert pin.13 als Ausgang
}
void loop()
{
int i = 0;
while (i<10)
{
digitalWrite(Led,HIGH);
delay(500);
digitalWrite(Led,LOW);
delay(1000);
i++; // Wert wird um 1 erhöht
}
delay(2000); // Wartezeit 2s
}
(Hackerl) = Überprüfen - Kompilierung abgeschlossen
(Pfeil) = Upload - den im Editor stehenden Code auf den uC übertragen
Teil - 7. RGB - LED Tl.1 (#7)
http://maxtechtv.de/arduino-tutorial-7-die-rgb-led-teil-i-7/
RGB-LED Common Anode (Tri-Color) 4-pin (
1. rotK -
2. gem Anode = der lange pin -
3. grünK -
4. blauK)
rot R= (5,0V-1,9V) / 0,02A = 155 Ohm praktisch 150..220 Ohm
grün R= (5,0V-2,9V) / 0,02A = 105 Ohm praktisch 100 Ohm
blau R= (5,0V-2,9V) / 0,03A = 70 Ohm praktisch 68..100 Ohm
/*
RGB-LEDs_blinken_1a | Arduino 1.0.5-r2 | UNO R3
rotK über 150R an pin.9 | langer pin gem.A an +5V | grünK über 100R an pin.10 | blauK über 68R an pin.11
*/
int LedR = 9;
int LedG = 10;
int LedB = 11;
void setup()
{
pinMode(LedR,
OUTPUT);
pinMode(LedG,
OUTPUT);
pinMode(LedB,
OUTPUT);
}
void loop()
{
digitalWrite(LedR,
LOW);
digitalWrite(LedG,
HIGH);
digitalWrite(LedB,
HIGH);
delay(1000); // Wartezeit 1s
digitalWrite(LedR,
HIGH);
digitalWrite(LedG,
LOW);
digitalWrite(LedB,
HIGH);
delay(1500);
digitalWrite(LedR,
HIGH);
digitalWrite(LedG,
HIGH);
digitalWrite(LedB,
LOW);
delay(500);
}
(Hackerl) = Überprüfen - Kompilierung abgeschlossen
(Pfeil) = Upload - den im Editor stehenden Code auf den uC übertragen
Teil - 8. RGB - LED Tl.2 (#8)
http://maxtechtv.de/arduino-tutorial-8-die-rgb-led-teil-ii-8/
Mischfarben yellow (rot-grün), magenta (rot-blau), cyan (grün-blau)
/*
RGB-LEDs_blinken_in_Mischfarben_2a | Arduino 1.0.5-r2 | UNO R3
rotK über 150R an pin.9 | langer pin gem.A an +5V | grünK über 100R an pin.10 | blauK über 68R an pin.11
*/
int LedR = 9;
int LedG = 10;
int LedB = 11;
void setup()
{
pinMode(LedR,
OUTPUT);
pinMode(LedG,
OUTPUT);
pinMode(LedB,
OUTPUT);
}
void loop()
{
digitalWrite(LedR,
LOW);
digitalWrite(LedG,
LOW);
digitalWrite(LedB,
HIGH);
delay(4000); // Wartezeit 4s
digitalWrite(LedR,
LOW);
digitalWrite(LedG,
HIGH);
digitalWrite(LedB,
LOW);
delay(2500);
digitalWrite(LedR,
HIGH);
digitalWrite(LedG,
LOW);
digitalWrite(LedB,
LOW);
delay(1000);
digitalWrite(LedR,
HIGH);
digitalWrite(LedG,
HIGH);
digitalWrite(LedB,
HIGH);
delay(2000);
}
analogWrite (pin,wert); Wert = 0..255
PWM = Pulse Width Modulation (Puls Weiten Modulation)
25% Duty Cycle Wert = 64 50% Duty Cycle Wert = 127 75% Duty Cycle Wert = 191
/*
RGB-LEDs_mit PWM_fading_1a | Arduino 1.0.5-r2 | UNO R3
rotK über 150R an pin.9 | langer pin gem.A an +5V | grünK über 100R an pin.10 | blauK über 68R an pin.11
*/
int LedR = 9; // pin-Variablen
int LedG = 10;
int LedB = 11;
int valR = 0; // Farbe An integer-Variable
int valG = 255; // Farbe Aus
int valB = 255;
void setup()
{
pinMode(LedR,
OUTPUT);
pinMode(LedG,
OUTPUT);
pinMode(LedB,
OUTPUT);
}
void loop()
{
while (valR != 255)
{
analogWrite(LedR,valR);
analogWrite(LedG,valG);
valR++; // roter Wert wird um 1 erhöht
valG--; // grüner Wert wird um 1 vweringert
delay(10); // Wartezeit 10ms
}
while (valG != 255)
{
analogWrite(LedG,valG);
analogWrite(LedB,valB);
valG++;
valB--;
delay(10);
}
while (valB != 255)
{
analogWrite(LedB,valB);
analogWrite(LedR,valR);
valB++;
valR--;
delay(10);
}
}
Teil - 9. Der Servo (#9)
http://maxtechtv.de/arduino-tutorial-9-der-servo-9/
Micro Servo 9G Typ SG90 Fa. Tower Pro
Winkel 0..180°
GND = schwarz/braun +5V = rot Steuerleitung = orange / weis / gelb
analogWrite (pin,wert); Wert = 0..255
PWM = Pulse Width Modulation (Puls Weiten Modulation)
25% Duty Cycle Wert = 64 50% Duty Cycle Wert = 127 75% Duty Cycle Wert = 191
Servo.attach(Pin);
Servo.write(Winkel); 0..180°
/*
MicroServo_innerhalb_von_1s_Pos30_Pos120_1a | Arduino 1.0.5-r2 | UNO R3
SERVO-Kabel schwarz an GND | rot an +5V | weis an pin.9 (PWM-pin)
ARDUINO Entwicklungsumgebung - MENU > Sketch > Library importieren > Servo
*/
#include <Servo.h>
Servo MicroServo1;
void setup()
{
MicroServo1.attach(9);
}
void loop()
{
MicroServo1.write(30);
delay(2000);
MicroServo1.write(120);
delay(2000);
}
MENU > Datei > Beispiele > Servo > Sweep
// Sweep
// by BARRAGAN <
http://barraganstudio.com>
// This example code is in the public domain.
#include <
Servo.h>
Servo myservo; // create servo object to control a servo
// a maximum of eight servo objects can be created
int pos = 0; // variable to store the servo position
void setup()
{
myservo.
attach(9); // attaches the servo on pin 9 to the servo object
}
void loop()
{
for(pos = 0; pos < 180; pos += 1) // goes from 0 degrees to 180 degrees
{ // in steps of 1 degree
myservo.
write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
for(pos = 180; pos>=1; pos-=1) // goes from 180 degrees to 0 degrees
{
myservo.
write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
}
Teil - 10. Der Schrittmotor (mit Adafruit Shield) (#10)
http://maxtechtv.de/arduino-tutorial-10-der-schrittmotor/
Schritmotoren nie direkt am ARDUINO anschließen
NEMA 14 bipolaren Hybrid Schrittmotor mit Ub= 4,5V bis 1,8° pro Schritt (200 Schritte / Umdr.) 4 Kabel
rot blau
schwarz grün
Fa. Adafruit Bausatz
Motor/Stepper/Servo Shield for Arduino V2.0 Kit
http://www.adafruit.com/products/1438
Fa. Adafruit Motor/Stepper/Servo Shield V1.0 for Arduino kit (ALT)
http://www.adafruit.com/products/81
Schrittarten: SINGLE (1 Spule) - DOUBLE (2 Spulen ) - INTERLEAVE (Halbe Schritte) - MICROSTEP ( PWM glättet)
zum Test 100 Schritte
#include <AFMotor.h>
AF_Stepper motor(200,1);
void setup()
{
motor.setSpeed(8);
Serial.begin(115200); // Baudrate der Übertragung muß auf beiden Seiten übereinstimmen da es sonst zu Lesefehlern kommt
}
void loop()
{
Serial.println("SINGLE");
motor.step(100, FORWARD,SINGLE);
motor.
step(100,
BACKWARD,
SINGLE);
Serial.println("DOUBLE");
motor.step(100, FORWARD,DOUBLE);
motor.
step(100,
BACKWARD,
DOUBLE);
Serial.println("INTERLAVE");
motor.step(100, FORWARD,INTERLAVE);
motor.
step(100,
BACKWARD,
INTERLAVE);
Serial.println("MICROSTEP");
motor.step(100, FORWARD,MICROSTEP);
motor.
step(100,
BACKWARD,
MICROSTEP);
}
Teil - 11. Der Fotowiderstand (mit Adafruit Shield) (#11)
http://maxtechtv.de/arduino-tutorial-11-der-fotowiderstand/
Fotowiderstand
Dunkelwiderstand 1..100MOhm
Hellwiderstand 1kOhm
/*
LDR 05 am AE0_1a | Arduino 1.0.5-r2 | UNO R3
LDR über 10k an GND | 10k & LDR an A0 | LDR an +5V |
*/
int sensorWert = 0;
void setup() {
Serial.begin(115200); // Baudrate der Übertragung muß auf beiden Seiten übereinstimmen da es sonst zu Lesefehlern kommt
}
void loop() {
sensorWert = analogRead(A0);
Serial.println(sensorWert);
delay(100); // jede 1/10Sekunde wird ein Meßwert seriell übertragen an MENU > Tools > Serial Monitor > COM3 > Meßwertanzeige
}
AE0 bis AE5 mit 10bit Werte von 0 bis 1023
Hell = Wert 1000
Dunkel = Wert unter 400
http://arduino.cc/en/Tutorial/ReadAnalogVoltage
/*
Lese_Analog_Spannung_von_0,00..5,00V_1a
Liest einen analogen Eingang an Pin 0, wandelt sie in Spannung und gibt das Ergebnis an den seriellen Monitor.
Befestigen Sie den Mittelstift ein Potentiometer bis A0 Pin und die Außenstifte bis +5 V und Masse.
*/
void setup() // die Setup-Routine läuft einmal zurückgesetzt, wenn Sie drücken:
{
Serial.begin(115200); // Baudrate der Übertragung muß auf beiden Seiten übereinstimmen da es sonst zu Lesefehlern kommt
}
void loop() // die Schleifenroutine läuft immer und immer wieder für immer:
{
int sensorValue = analogRead(A0); // Lesen Sie den Eingang am analogen Pin 0:
float voltage = sensorValue * (5.0 / 1023.0); // der Wert von 0..1023 wir umgerechnet in eine Spannung von 0,00..5,00V
Serial.println(voltage); // Meßwert wird seriell übertragen an MENU > Tools > Serial Monitor > COM3 > Meßwertanzeige
delay(100); // 1/10SekundeWartezeit
}
AE0 bis AE5 mit 10bit Werte von 0 bis 1023
5V = Wert 1023
0V = Wert 0
/*
Poti_am_Analog-Eingang_1a
Analoge Sensoren an Analog-Eingang 0
Ein-und Ausschalten der eingebauten Leuchtdiode (LED) am pin.13
Die Zeitdauer, die LED ein-und ausgeschaltet wird, hängt von analogem Meß-Wert ab.
Die Schaltung: Potentiometer Abfrage am Analog-Eingang 0.
* Poti auf +5 V
* Mittelstift des Poti auf A0
* Poti auf GND
Dieses Beispiel-Code ist in der Public Domain. http://arduino.cc/en/Tutorial/AnalogInput
*/
int sensorPin = A0; //
Eingangs-Pin für Poti A0
int ledPin = 13; //
eingebaute LED pin.13
int sensorWert = 0; //
Variable, um den Wert zu speichern
void setup()
{
Serial.begin(115200); // Baudrate der Übertragung muß auf beiden Seiten übereinstimmen da es sonst zu Lesefehlern kommt
pinMode(ledPin, OUTPUT);
// LEDpin.13 als Ausgang
}
void loop()
{
sensorWert =
analogRead(sensorPin); //
Sensor-Wert einlesen
digitalWrite(ledPin, HIGH);
// LED auf +5V
delay(sensorWert); //
Wartezeit in ms für <sensorValue>
digitalWrite(ledPin, LOW); //
LED auf GND
Serial.println(sensorWert); // Meßwert wird seriell übertragen an MENU > Tools > Serial Monitor > COM3 > Meßwertanzeige
delay(sensorWert); //
Wartezeit in ms für <sensorValue>
}
AE0 bis AE5 mit 10bit Werte von 0 bis 1023
Hell = Wert 600 = langsames Blinken
Dunkel = Wert 350 = schnelles Blinken
Analog Write with 12 LEDs on an ARDUINO Mega (ACHTUNG: nicht UNO)
Kingbright Bargraph-Anzeige
rote Bargraph-Anzeige 10LEDs RBR1000 (2,0V-20mA)
gelbe Bargraph-Anzeige 12LEDs YBR1200 (2,1V-20mA)
grüne Bargraph-Anzeige 20LEDs GBR2000 (2,2V-20mA)
http://arduino.cc/en/Tutorial/AnalogWriteMega
/*
Mega analogWrite() test
This sketch fades LEDs up and down one at a time on digital pins 2 through 13.
This sketch was written for the Arduino Mega, and will not work on previous boards.
The circuit:
* LEDs attached from pins 2 through 13 to ground.
created 8 Feb 2009
by Tom Igoe
This example code is in the public domain.
*/
// These constants won't change. They're used to give names
// to the pins used:
const int lowestPin = 2;
const int highestPin = 13;
void setup() {
// set pins 2 through 13 as outputs:
for (int thisPin =lowestPin; thisPin <= highestPin; thisPin++) {
pinMode(thisPin, OUTPUT);
}
}
void loop() {
// iterate over the pins:
for (int thisPin =lowestPin; thisPin <= highestPin; thisPin++) {
// fade the LED on thisPin from off to brightest:
for (int brightness = 0; brightness < 255; brightness++) {
analogWrite(thisPin, brightness);
delay(2);
}
// fade the LED on thisPin from brithstest to off:
for (int brightness = 255; brightness >= 0; brightness--) {
analogWrite(thisPin, brightness);
delay(2);
}
// pause between LEDs:
delay(100);
}
}
DIN A4 ausdrucken
****************************************************************
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:
[email protected]
ENDE