VIDEO f. Einst.

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
http://arduino.cc/de/Guide/Windows


Einsteiger Video Tutorials auf Youtube

https://www.youtube.com/watch?v=avOZaRoKVgg&list=PLAB63281B90FB376E  




MaxTechTV
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



Teil - 4. Variablen (#4)

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)

GBG 1000

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