Startseite‎ > ‎

Licht-LDR-Dämmerung

http://sites.prenninger.com/arduino-uno-r3/home/licht-ldr-daemmerung

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                          Wels, am 2017-02-08

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-home-licht.ldr.daemmerung (xx Seiten)_1a.pdf

Suchbegriffe
LDR
Fotodiode
Fototransistor
Reflexlichtschranke
Lichtsensor
auf der ARDUINO UNO R3 Seite  http://sites.prenninger.com/arduino-uno-r3

Zeitschalter -
Ausschaltverzögerung - Stiegenhaus-Zeitschalter - WC-Lüfternachlauf mirLDR
Nachtlicht mit RGB-LED - Dämmerungs-Schalter -
Belichtungsmesser - Luxmeter
Lichtalarm - Lichtänderung - Lichtautomatik
Poti RG-LED
Pulsmesser - Herzschlag-Sensor - Fingerkuppen-Herzschlagfühler - Herzfrequenzmessung von der Fingerspitze




********************************************************I*
704_d_ARDUINO-x_Dämmerungs-Schalter LDR-Sensoren_1a.opd

Sensoren im Einsatz mit Arduino

3.1.1 Praxisbeispiel: Lichtmesser mit LDR . 46
buch_sensor_kap2_ldr.ino
3.1.2 Praxisbeispiel: Nachtlampe mit LDR . 47
buch_sensor_kap2_ldr-pwm-led.ino
3.4 UV-Strahlung messen mit UV-Sensor. . 60§ ML8511
3.4.1 Praxisbeispiel: UV-Index-Monitor. . 63
buch_sensor_kap3_uv_index.ino

http://sites.prenninger.com/arduino-uno-r3/sensoren-im-einsatz-mit-arduino





********************************************************I*

BUCH  Arduino Handbuch    € 34,95

5.04_Lichtschranke_1a.zip
Wir bauen eine Lichtschranke, die eine Kamera auslöst.

5.4    Lichtschranke        189                                          Lichtschranke.ino

http://sites.prenninger.com/arduino-uno-r3/arduino-handbuch




********************************************************I*

BUCH Arduino für Einsteiger      Getting Started with Arduino

Kapitel 5   Erweiterter Input und Output

Einsatz eines Lichtsensors anstelle eines Drucktasters 61 § LDR Dm 5mm Maker Shed JM169578

http://sites.prenninger.com/arduino-uno-r3/arduino-einsteiger



********************************************************I*
SainSmart UNO Starter Kits Tutorials_1a.pdf

Lektion 4: LED mit Fotowiderstand LDR05

Der Quellcode (Sketch)


Sketch: Helligkeits-Wert.ino
int fotoZellePin = 2; //Bestimmt das der Fotowiderstand an PIN2 angeschlossen ist
int ledPin = 12;      //Bestimmt das die LED an den Ausgang des PIN12 angeschlossen ist
int value = 0;        //Bestimmt den aktuell gelesenen Wert
void setup() {
   pinMode(ledPin, OUTPUT);           //Setzt den Ausgang für die LED
}

void loop() {
   value = analogRead(fotoZellePin); //Ließt den Wert des Sensors vom Analogen PIN2
   if(value<=512){                   //512=2.5V, Wenn Sie den Sensor sensibler haben möchten
                                     // erhöhen Sie diesen Wert, oder verringern Sie diesen.
     digitalWrite(ledPin, HIGH);     //Wenn der Wert < 512 ist dann soll die LED aufleuchten.
    } else{
      digitalWrite(ledPin, LOW);     //andernfalls soll diese ausgeschaltet sein.
    }
}


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




********************************************************I*

46) Home > Arduino Projects > Photocell (LDR) Sensor with Arduino
LDR05 10k Dämmerungs-Schalter
(pin-A2) - LED (pin-11) - Serial
Dämmerungsschalter / Helligkeitsschalter / Lichtschranke (LDR) mit Arduino
Arduino Lichtschranke (LDR) Sensor-Sketch / Code:


Sketch: Dämmerungs-Schalter.ino
/*    www.theorycircuit.com  */
int ledPin = 3;
int photocell = 0;

void setup() {
pinMode
(ledPin, OUTPUT);
Serial.begin(9600);
}

void loop() {
photocell
= (analogRead(0)/4); // Divides input 0-1023 to resemble to 0-255

analogWrite
(ledPin, photocell);
Serial.print(photocell);
// The delay can be change to get the desired dimming effect
delay
(20); // Pause 20ms
}



http://www.theorycircuit.com/photocell-ldr-sensor-with-arduino/
http://sites.prenninger.com/arduino-uno-r3/theorycircuit/sketch-4




********************************************************I*
Hobby Electronics Components Supplier for ARDUINO
http://sites.prenninger.com/arduino-uno-r3/anleitung-tutorial/hobbytronics
http://sites.prenninger.com/arduino-uno-r3/anleitung-tutorial/tutorial

Arduino UNO Tutorial 08 - NightLight

In diesem Arduino UNO Tutorial werden wir einen Lichtabhängigen Widerstand (LDR) verwenden,
um ein einfaches Kinderzimmernachtlicht zu schaffen,
das automatisch einschaltet, wenn es dunkel wird und schaltet sich aus, wenn es Licht erhält


Ändern Sie den Wert in dem Code, in dem die LED eingeschaltet ist, auf einen geeigneten Wert.


Sketch: NightLight.ino
/*
** 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);  
}

Quelle:
http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial8-nightlight





********************************************************I*

elektor BUCH  ARDUINO entdecken  4.7 Retriggerbarer Zeitschalter Seite 53
4.7 Retriggerbarer Zeitschalter
Dieses Projekt beschreibt einen monostabilen Multivibraton
Man drückt einmal eine Taste und eine LED leuchtet daraufhin für eine gewisse Zeit.
Da wir nun wissen, wie man einen Taster auslesen und eine LED ein- und ausschalten kann, sollte es uns nicht schwer fallen, einen Zeitschalter zu programmieren.
Wenn der Taster gedrückt wird, soll die LED aufleuchten und nach einer bestimmten Zeit (wir wählen 5s) wieder dunkel werden.
Dazu setzen wir einen If-Befehl mit einem Delay von 5000 Millisekunden ein.

4.7\timer1
Sketch: Timer1.ino
int button = 8;
int led = 2;

void setup() {
  pinMode(led, OUTPUT);
  pinMode(button, INPUT);
}

void loop(){
  if (digitalRead(button) == HIGH) {
    digitalWrite(led, HIGH);
    delay(5000);
    digitalWrite(led, LOW);

  }
}

Während der Zeit, in der die LED leuchtet, schaut der Sketch nicht nach dem Taster.
Das ist auch nicht nötig, denn wenn die LED leuchtet, leuchtet sie ja.
Aber es wäre durchaus sinnvoll, dass das Intervall neu startet, wenn der Anwender bei leuchtender LED die Taste drückt, beispielsweise bei einer Treppenhausbeleuchtung.
Bei jedem Stockwerk drückt der Anwender eine Taste, damit die Beleuchtung wieder für fünf Sekunden aktiviert wird.
Das wäre viel praktischer, als wenn der Anwender auf jedem Stockwerk beim Taster stehen bleiben müsste, um zu warten, bis das Licht verlischt und er den Taster erneut drücken könnte, um damit den Timer wieder neu zu starten.
Die Lösung ist, den Sketch nicht 5 Sekunden, sondern 500 mal 10 ms warten zu lassen.
Das dauert insgesamt genau so lange, aber der Sketch überprüft den Taster im 10ms Takt.
So kurz kann ein Druck auf den Taster gar nicht sein, als dass es der Sketch nicht merken würde.
Wenn der Taster gedrückt wird, springt der Zähler wieder zurück auf 500.
Solange der Zähler größer ist als 0, wird er um 1 verringert, dann 10 ms gewartet.
Ist der Zähler nicht mehr größer als null, dann endet der Sketch und das Licht geht aus.


4.7\timer2

Sketch: Timer2.ino
int button = 8;
int led = 2;
int counter = 0;

void setup() {
  pinMode(led, OUTPUT);
  pinMode(button, INPUT);
}

void loop() {
  if (digitalRead(button) == HIGH) {
    counter=500;
    digitalWrite(led, HIGH);
  }
  if (counter>0){
    counter--;
    delay(10);
  }
  eise{
    digitalWrite(led, LOW);
  }
}


Die Hardware für dieses Projekt besteht aus dem Arduino mit den LEDs und den Tastern auf dem Shield.




********************************************************I*
elektor BUCH  ARDUINO entdecken  5.3 Nachtlicht (DämmerungsSchalter) Seite 69
5.3 Nachtlicht (Dämmerungsschalter)
In diesem Projekt wird in der Dämmerung eine LED als Nachtlicht im Kinderzimmer eingeschaltet.
In Projekt 6.9 lernen wir noch, wie eine richtige Lampe oder auch die Eingangsbeleuchtung ein- und ausgeschaltet werden kann
Um die Lichtstärke zu messen, verwenden wir einen LDR (Light Dependent Resistor), dessen Wert von der Lichtmenge abhängt.

Der Widerstand berechnet sich üblicherweise nach folgender Formel:

R = 500 / L [Formel 8]
mit R = Widerstand des LDR (in kOhm)
L = Beleuchtungsstärke (in Lux)
Lux = Lumen/m2, wobei 1 Lumen der Lichtstrom einer 1,464 mW starken gelbgrünen Lichtquelle ist.


Je mehr Licht auf einen LDR fällt, desto geringer ist sein Widerstand.
Die Tabelle zeigt, welche Lux-Werte in der Praxis anzutreffen sind.

Situation                 Lux
direktes Sonnenlicht  100.000
indirektes Sonnenlicht 10.000
bewölkter Tag           1.000
Raum mit Lampe            350
Raum mit Kerze             50

Tabelle 16. Beleuchtungsstärke bei verschiedenen Situationen.



Die Werte selbst baugleicher LDRs können um 50 % voneinander abweichen, so dass eine Kalibrierung und ein Poti zur Feinabstimmung unumgänglich sind.
Wir verbinden den LDR an einer Seite mit Pin A3 des Arduino, an der anderen mit +5 Volt.
Wir brauchen einen zweiten Widerstand für einen Spannungsteiler, da der Arduino nun mal keine Widerstände, sondern nur Spannungen messen kann.
Der Widerstand ist zwischen Pin A3 und Erde geschaltet.
Wir erwarten im Schlafzimmer eine Beleuchtungsstärke von ungefähr 50 lux.
Dies entspricht einem LDR-Widerstand von ungefähr 10k Ohm.
Deshalb verwenden wir für den zweiten Widerstand auch den gleichen Wert von 10k Ohm.
Normalerweise liegt dann die Spannung am Arduino-Eingang in der Mitte des Versorgungsspannungsbereichs des Arduinos.
Für einen LDR ist eine Leistungsaufnahme von 50...80 mW typisch, was bei 5 Volt einem Strom von 10...16 mA entspricht.
Der 10k Ohm-Widerstand begrenzt allerdings den Strom auf 0,5mA, so dass der LDR nicht an seine Grenzen stößt.
Dies gilt, wenn der Pin A2 ein Eingang ist und der Strom über den LDR und den Widerstand fließt.
Solle der Anschluss A0 aus Versehen auf Ausgang und Low geschaltet werden, liegen die vollen 5 Volt ohne Schutzwiderstand über dem LDR.
Dann brennt der LDR durch, sein Widerstand wird unendlich hoch.

Bild 31. Der Anschluss des LDRs an den Arduino.

Der LDR ist gut an seiner flachen, durchsichtigen Oberfläche mit Zickzack-Spur zu erkennen.
Es ist egal, wie Sie den LDR anschließen, es gibt keine Plus- oder Minusseite, nur die Zickzack-Spur muss ins Helle weisen.
Der 10k Ohm-Widerstand ist am Farbcode (braun-schwarz-orange  br-sw-or) zu erkennen.
Der LDR wird mit Plus verbunden, der Widerstand mit Minus.
Wir bringen den LDR mit seinem Widerstand links neben dem Trimmpoti an.


Im Sketch führen wir zwei analoge Messungen durch.
Mit der einen messen wir die Spannung des Trimmpotis an pin-A0 und überführen sie in die Variable treshold (Schwellwert).
Mit der anderen wird die Beleuchtungsstärke ermittelt und diese der Variablen LDR übergeben.
Durch einen Vergleich der beiden Variablen kann der Sketch entscheiden, ob die LED ein- oder ausgeschaltet werden muss.

5.3\lightswitch
Sketch: Lightswitch.ino
int pot = A0;
int ldr = A2;
int led = 2;
int light, threshold;

void setup() {
  pinMode(led, OUTPUT);
}

void loop() {
  threshold = analogRead(pot);
  light = analogRead(ldr);
  if (light<threshold){
  digitalWrite(led, HIGH);
  }
  if (light>threshold+10){
  digitalWrite(led, LOW);
  }
  delay(500);
}


Sie hätten vielleicht dies erwartet:
if (light<threshold){
  digitalWrite(led, HIGH);
}
eise {
  digitalWrite(led, LOW);
}


Doch die analoge Messung schwankt immer ein klein wenig.
Wenn sich die Beleuchtungsstärke am Schwellwert befindet, liegt sie bei einer Messung gerade darüber, bei der nächsten darunter.
Um ein Blinken der LED zu verhindern, werden Einschalt- und Ausschaltwert auseinander gezogen.
So etwas nennt man Hysterese.
Wenn es dunkler wird und der Punkt erreicht ist, bei dem die LED eingeschaltet werden soll, drehen Sie einfach langsam am Trimmpoti, bis die LED aufleuchtet.
Von nun an geht sie automatisch an und aus.
Wenn Sie nicht die Geduld haben, können Sie auch mit der Hand den LDR abschatten.





********************************************************I*
elektor BUCH  ARDUINO entdecken  5.4 Belichtungsmesser Seite 72
5.4 Belichtungsmesser - Luxmeter
Das Projekt ist ein einfaches Luxmeter, bei dem der gemessene Wert auf dem PC im HyperTerminal angezeigt wird.

Wir verwenden einen LDR, um die Beleuchtungsstärke zu ermitteln.
Die Werte selbst baugleicher LEDs können um 50 % voneinander abweichen, so dass wir mit der Kalibrierung beginnen.

Mit einem Belichtungsmesser als Referenz können Sie den LDR am besten kalibrieren.

Haben wir keinen Belichtungsmesser zum Vergleich parat, orientieren wir uns an den Werten in Tabelle 16.
Anhand der Lux-Werte können wir den Widerstand nach der Formel vom Beginn des Kapitels 5.3 abschätzen:
R = 500 / L

Situation               Rgemessen    Rberechnet      Lux
direktes Sonnenlicht     37,2         5              100.000
indirektes Sonnenlicht  178,0        25               10.000

Tabelle 17. Messungen an meinem LDR.

Die gemittelte Abweichung zwischen meinen Messungen (Rgemessen) und den Berechnungen aus dem letzten Kapitel (Rberechnet) besitzt den Faktor 7,28, so dass sich für meinen LDR folgende Formel ergibt (mit Widerstand in Ohm, nicht in kOhm):

L =    3.640.000 / R     (Formel 9)

Wie genau das ist, wird man sehen. Sie müssen auf jeden Fall Ihren eigenen LDR kalibrieren, weil dieser mit Sicherheit nicht die gleichen Werte aufweist.
Der LDR wird als Spannungsteiler geschaltet, um den Widerstandswert in eine Spannung umzusetzen.


Bild 33. Spannungsteiler mit LDR am Arduino.



Die Spannung, die den Arduino erreicht (UArduino), kann wie folgt berechnet werden:



Die analoge Messung (AD) liefert ein Resultat zwischen 0 und 1023, wobei 1023 dem Wert +5 Volt entspricht. In der Formel:




Jetzt setzen wir die Formel in C++ um.
Es sind drei Berechnungen auszuführen, in denen die Variable L natürlich als float definiert werden muss:
Schauen Sie im Projekt 5.2 nach, wenn Sie nicht wissen, warum wir 10230.0 statt 10230 verwenden.

L = 10230.0 / AD    [Formel 17]
L = L - 10          [Formel 18]
L = 3640 / L        [Formel 19]


Nach dieser komplizierten Berechnung ist der folgende Sketch beinahe eine Erfrischung.
Wir messen den analogen Wert an pin-A2, berechnen mit der soeben erarbeiteten Formel die Beleuchtungsstärke in Lux
und schicken das Ergebnis in säuberlicher Form zum Hyper-Terminal.


5.4\luxmeter
Sketch: Luxmeter.ino
int ldr = A2;
int AD;
float L;

void setup()
  Serial.begin(9600);

}

void loop(){
  // measure and calculate
  AD = analogRead(ldr);
  L = 10230.0 / AD;
  L = L - 10;
  L = 3640 / L;
  // display
  Serial.write(27);
  Serial.print("[4;5H");
  Serial.print("Light intensity ");
  Serial.print(L);
  Serial.print(" lux ");
  delay(500);
}


Im letzten Kapitel finden Sie eine (Tabelle 16) mit einigen Lux-Werten.
So können Sie sehen, ob Ihre Messungen einigermaßen stimmen.
Da das Kalibrieren ohne Referenzgerät natürlich nicht genau sein kann, muss man die Resultate mit Vorsicht genießen.


Arduino4 - HyperTerrninal
Light intensity 1444.97 lux

Bild 34. Messung an einem bewölkten Tag.






********************************************************I*
elektor BUCH  ARDUINO entdecken  5.5 Kinderzimmer-Lichtalarm Seite 75
5.5 Kinderzimmer-Lichtalarm
Dieses Projekt kontrolliert, ob das Licht im Kinderzimmer unerwartet aufleuchtet, beispielsweise, wenn die Kinderheimlich im Bett lesen.

Auf den ersten Blick könnten wir für diesen Zweck das Nachtlicht einsetzen, beidem die LED leuchtet, wenn es hell ist.
Genau betrachtet aber nicht, denn die LED würde tagsüber unnötig leuchten und in der Nacht nicht reagieren, wenn nur eine kleine Lampe eingeschaltet wird.

Wir müssen die Beleuchtungsstärke kontinuierlich messen, aber nur reagieren, wenn sie abrupt zunimmt.
Nimmt die Beleuchtungsstärke in der Morgendämmerung nur langsam zu, ist alles in Ordnung und die LED kann dunkel bleiben.
So erhält man einen sich selbst nachstellenden Sketch, der sich immer an die mittlere Beleuchtungsstärke anpasst.

Wir messen die Beleuchtungsstärke und vergleichen sie mit der vorherigen Messung.
Diese vorherige Messung dient als Schwellwert.
Wenn der Unterschied zu groß ist, leuchtet die LED auf. Wenn nicht, dann wird die aktuelle Messung als neue Schwelle übernommen.
Die LED verlischt wieder, wenn der Anwender auf eine Taste drückt.

Wenn die Schaltung zum ersten Mal eingesetzt wird, soll sie nicht reagieren.
Als Startwert setzen wir deshalb 1023 ein, ein Wert, der nicht übertroffen werden kann.
Der Messwert muss mindestens 20 Einheiten höher sein als die Schwelle, damit der Sketch reagiert.


5.5\lightalarm

Sketch: Lichtalarm.ino
int ldr = A2;
int led = 2;
int button = 8;
int threshold=1023, value;

void setup() {
  Serial.begin(9600);
  pinMode(button, INPUT);
  pinMode(led, OUTPUT);

}

void loop() {
  value = analogRead(ldr);
  if (value>threshold+20){
    digitalWrite(led, HIGH);
  }
  threshold=value;
  if (digitalRead(button)==HIGH){
    digitalWrite(led, LOW);
  }
  delay(500);

}

Die Hardware ist die gleiche wie im vorherigen Projekt.
Sie können die Schaltung testen, indem Sie zum Beispiel mit einer Taschenlampe den LDR beleuchten.




********************************************************I*
fritzing BUCH  Einführung in den kreativen Umgang mir Elektronik  Nachtlicht Seite 70
F:\fritz-Sketche\fritzing-CREATOR-Kit\Nachtlicht_1a.ino


                  Nachtlicht mit RGB-LED

Schaltung:  Fritzing / Nachtlicht .fzz
Code       :  Sketchbook / Fritzing Creator Kit / Nachtlicht
www.fritzing.org/creator-kit/fritzing_Nachtlicht_1a.ino

Das nächste Projekt ist ein Nachtlicht, das langsam seine Farbe ändert.
Realisiert wird es mit einer RGB-LED.
Eine RGB-LED ist ein LED-Gehäuse, in dem drei LEDs eingelassen sind (Rot, Grün und Blau).
Sie teilen sich ein gemeinsames Beinchen.
Bei der RGB-LED aus dem Kit ist das gemeinsame Beinchen die Kathode (Minus).
Die drei übrigen Beinchen (Anoden) sind jeweils einer Farbe zugeordnet.
Jede integrierte LED benötigt einen eigenen Vorwiderstand.
Um eine gute Farbmischung zu erhalten, kannst Du ein Stück weißes Papier um die LED wickeln oder einen Tischtennisball darauf stecken (5mm Bohrloch).




fritzing BUCH  Einführung in den kreativen Umgang mir Elektronik  Potentiometer Seite 80
F:\fritz-Sketche\fritzing-CREATOR-Kit\Potentiometer_1a.ino







********************************************************I*
                  Potentiometer  RG-LED

Schaltung:  Fritzing / Potentiometer .fzz
Code       : 
Sketchbock / Fritzing Creator Kit / Potentiometer
www.fritzing.org/creator-kit/fritzing_Potentiometer_1a.ino




Im Gegensatz zu der 8-bit- PWM -Ausgabe(siehe Seite 67) ist die Auflösung der analogen Eingabe höher:
2hoch10 = -1024 Zustände, also 0 bis 1023.

Ein Potentiometer ist ein regelbarer Widerstand.
Es hat ein kreisförmig angeordnetes Widerstandsmaterial integriert, das von einem Abgriff elektronisch in zwei Teile geteilt wird.
Wird der Abgriff auf dem Widerstandsmaterial bewegt, ändert sich das Verhältnis der beiden Teilwiderstände.
Das Arduino-Board kann dieses Verhältnis auslesen und somit die Position bestimmen.

Die äußeren Anschlüsse des Potentiometers werden mit 5V+ und dem GND verbunden, der mittlere Anschluss mit einem analogen Eingang.

Eingelesen werden Werte zwischen 0 und 1023.
In der Beispielschaltung wird dieser Wert mit der map-Funktion in den Wertebereich von 0 bis 255 umgerechnet und als analoge Ausgabe (PWM) an eine LED übertragen.


Programmtext / Sketch

Sketch: Potentiometer.ino
  int ledGreen = 6;
  int ledRed = 5;
  int potPin = 0;

void setup(){
}

void loop(){
  int value = analogRead(potPin);
  int redValue = map(value,0,1023,0,255);
  int greenValue = map(value,0,1023,255,0);
  analogWrite(ledRed,redValue);
  analogWrite(ledGreen,greenValue);
}



Sketch-Erklärung

map
Der map() Befehl rechnet einen eingehenden Wert von einem Wertebereich in einen anderen Wertebereich um.
In diesem Fall wird der Wertebereich des analogen Inputs (0 bis 1023)
     umgerechnet in den Wertebereich des analogen Outputs (0 bis 255).





********************************************************I*
fritzing BUCH  Einführung in den kreativen Umgang mir Elektronik  Referenzwiderstand Seite 84
                  Referenzwiderstand

Der analoge Input des Arduino-Boards wandelt eine Spannung zwischen 0 und 5V in einen Wert von 0 bis 1023 (10bit Analog-Digitalwandler).
Um diese Spannung messen zu können, benötigt man zu einem Sensor wie
z.B. dem Lichtwiderstand einen Referenzwiderstand.
Dieser wird mit dem Sensor in Reihe geschaltet.
Die eine Seite der Schaltung wird mit dem GND, die andere Seite mit dem 5V+ verbunden.
Die Verbindung zwischen beiden wird am analogen Eingang angeschlossen.


Anschfuss eines Potentiometers

Anschluß eines LDR mit Referenzwiderstand

Der Referenzwiderstand kann entweder ausprobiert oder berechnet werden.
Für die Berechnung musst Du den kleinst- und größtmöglichen Widerstand mit einem Messgerät ermitteln.
Nehmen wir an, Du willst einen Lichtwiderstand verwenden, dann miss den Widerstand in der dunkelsten und in der hellsten Situation.
Nun addiere beide Werte und teile das Ergebnis durch zwei.
Es ergibt sich der ideale Referenzwiderstand.
Da Widerstände aber nicht mit jedem Wert zu kaufen sind (E-Reihe`), nimm einfach den am nächsten liegenden.

Rref  =  (Rmin + Rmax) / 2





********************************************************I*
fritzing BUCH  Einführung in den kreativen Umgang mir Elektronik  Nachtlicht Seite 86
F:\fritz-Sketche\fritzing-CREATOR-Kit\Lichtautomatik_1a.ino


                  Lichtautomatik

Schaltung:  Fritzing / Lichtautomatik .fzz
Code       : 
Sketchbock / Fritzing Creator Kit / Lichtautomatik
www.fritzing.org/creator-kit/fritzing_Lichtautomatik_1a.ino



Ein Lichtwiderstand besteht aus einem Material, das je nach Lichteinfall seinen Widerstand ändert.
Je mehr Licht einfällt, desto kleiner wird er. In diesem Beispiel machen wir uns das zu Nutze, um die Scheinwerfer eines Autos automatisch einzuschalten.
Die Anschlüsse des Lichtwiderstands sind sehr lang. Achte darauf, dass sie sich nicht berühren.
Serielle Schnittstelle Um herauszufinden, welche Werte der Lichtwiderstand überhaupt sendet, kannst Du die serielle Schnittstelle benutzen.
Die serielle Schnittstelle stellt eine Datenverbindung zwischen Arduino und dem Computer her.
Sie wird im Setup mit dem Befehl Serial.begin(baudrate); initialisiert.
Bei der Baudrate handelt es sich um die Übertragungsgeschwindigkeit.
Sie kann z.B. 9600, 28800, 57600 oder 115200 bit pro Sekunde betragen.
Nach der Initialisierung können mit dem Befehl Serial.println(daten); Daten an die serielle Schnittstelle gesendet werden.
Es kann sich dabei um Variablen, aber auch um Text handeln.
Öffne in der Arduino-Soft-ware den seriellen Monitor: Tools > Serial Monitor.
Hier werden die Dateien angezeigt.
Die Baudrate muss die gleiche wie im Code sein.
In der unteren Zeile im seriellen Monitor kannst Du sie einstellen.


Beispiel: Lichtautomatik.ino
int lichtsensorPin = 0;
int scheinwerferPin = 2;
int schaltgrenze = 300;
int wartezeit = 1000;
long timer — 0;
int value;

void setup(){
Serial.begin(9600);
pinMode(scheinwerferPin,OUTPUT);
}

void loop(){
  value = analogRead(lichtsensorPin);
  Serial.println(value);
  if (value<schaltgrenze){
    timer=millis();
    digitalWrite(scheinwerferPin, HIGH);
}
  else if (millis(»wartezeit+timer){
  digitalWrite(scheinwerferPin, LOW);
  }
  delay(10);
}



Sketch-Erklärung
long
Der Variablentyp long ist vergleichbar mit iht jedoch können größere Zahlen verarbeitet werden. Diese werden für den Timer benötig.

Serial.begin(baud);
Startet die serielle Kommunikation.

Serial.println(daten);
endet den Inhalt der Variable value an die serielle Schnittstelle.

timer
Sobald der Lichteinfall kleiner als die Schaltgrenze wird, schaltet sich das Licht ein und eine Timer-Variable (timer) wird auf millis( ) gesetzt.
Der Befehl millis() liefert die Anzahl der Millisekunden zurück, die seit dem letzten Arduino-Reset verstrichen sind.
Sobald der Lichteinfall wieder größer als die Einschaltgrenze ist, wird geprüft, ob die Timer-Variable plus der Wartezeit kleiner als die aktuellen Millisekunden ist.
Ist das der Fall, werden die Scheinwerfer wieder abgeschaltet.





********************************************************I*
Franzis BUCH  Mikrocontroller-Programmierung mir ARDUINO  10.05 Ausschaltverzögerung Seite 144

10.5 Ausschaltverzögerung
Das Gegenstück zur Einschaltverzögerung ist die Ausschaltverzögerung.
Hier wird nach einem Tastendruck der Verbraucher nach einer vorgegeben Zeit ausgeschaltet.
Das Verfahren ist identisch mit dem der Einschaltverzögerung, nur dass hier die Variable i nicht inkrementiert, sondern dekrementiert (herab-gezählt) wird.

http://processing.org/
Beispiel: Ausschaltverzögerung.pde
// Franzis Arduino
// Ausschaltverzögerung
int SW1=12;
int value_1, value_2=0;
int LED=13;
byte Flag=O;
int i=3000;

void setup()
{
  pinMode(SW1,INPUT);
  digitalWrite(SW1,HIGH);
  pinMode(LED,OUTPUT);
  digitalWrite(LED,HIGH);
}

void loop(){
  value_1=digitalRead(SW1);
  if(!value_1)
  {
    delay(50);
    value_2=digitalRead(SW1);
    if(!value_2)
    {
      Flag=1;
      do{
      }whi1e(IdigitalRead(SW1));
    }
  }

  if(Flag==1)1--;
  if(i==0)
  {
    digitalWrite(LED,LOW);
    while(1);
  }

  delay(1);
}






********************************************************I*
Franzis BUCH  Mikrocontroller-Programmierung mir ARDUINO  10.14 Lüftersteuerung Seite 169

10.14 Lüftersteuerung  LDR

In vielen Toiletten findet man eine Lüftersteuerung vor. Kurz nachdem das Licht eingeschaltet wird, beginnt der Lüfter zu laufen.
Wenn man das Licht wieder ausschaltet, läuft der Lüfter noch eine Weile weiter.
In den meisten Fällen ist diese Steuerung in den Lüfter bereits eingebaut.
Der Lüfter hängt dazu einmal fest auf 230 V und zusätzlich an der Beleuchtung des Raums.
Wird nun das Licht eingeschaltet, wartet die Lüftersteuerung kurz für den Fall, dass das Licht nur versehentlich und kurz eingeschaltet wurde.
Der Lüfter startet meist nach ca. 30 Sekunden.
Sobald das Licht wieder ausgeschaltet wird, läuft ein Timer in der Elektronik des Lüfters ab und lässt diesen noch 1 bis 5 Minuten nachlaufen.

INFO:
Man sollte dieses Verhalten aber nur mit dem Experimentierboard simulieren, da man besser die Finger vom 230Vac Stromnetz lassen sollte.
Hierzu wäre eine eine Elektrofachkraft erforderlich.


Unsere Lüftersteuerung wird aber intelligenter als die in den meisten Lüftern.
Sie erkennt über einen Lichtsensor, ob das Licht an- oder ausgeschaltet wurde.
Ein Fotowiderstand ist ein Halbleiter, dessen Widerstandswert lichtabhängig ist.
Er wird auch LDR (engl.: Light dependent Resistor) genannt.
Alle Halbleitermaterialien sind lichtempfindlich und würden sich deshalb gut für einen Fotowiderstand eignen.
Da dieser Effekt nicht in jedem Halbleiter gleich stark in Erscheinung tritt, gibt es spezielle Halbleitermischungen, bei denen dieser Effekt besonders stark auftritt.
Ein LDR besteht aus zwei Kupferkämmen, die auf einer isolierten Unterlage (weiß) aufgebracht sind.
Dazwischen liegt das Halbleitermaterial in Form eines gewundenen Bands (rot).
Fällt das Licht (Photonen) auf das lichtempfindliche Halbleitermaterial, werden die Elektronen aus ihren Kristallen herausgelöst (Paarbildung).
Der LDR wird leitfähiger, d. h., sein Widerstandswert wird kleiner.
Je mehr Licht auf das Bauteil fällt, desto kleiner wird der Widerstand und desto größer wird der elektrische Strom.
Dieser Vorgang ist allerdings sehr träge.
Die Verzögerung dauert mehrere Millisekunden.
Dies reicht aber zur Hell-dunkel-Erkennung eines Raums völlig aus.



Bild 10.16: SchematischerAufbau der Lüftersteuerung

Verwendete Bauteile:
1x Arduino/ Freeduino-Board
1x Steckbrett
1x LDR
1x Trimmerwiderstand 10 kf)
1x Widerstand 68 kf)
6x Schaltlitze ca. 5 cm Länge
1x Schaltlitze ca. 10 cm Länge


http://processing.org/
Beispiel: Lüftersteurung.pde
// Franzis Arduino
// Lüftersteuerung
int LED=13;
int LDR=0;
int Poti=1;
int cnt=0;

void setup(){
pinMode(LED,OUTPUT); }

void loop(){
  if(analogRead(LDR)<analogRead(Poti))cnt++;
  if(analogRead(LDR)>analogRead(Poti))cnt=0;

  if(cnt>300) {
    digitalWrite(LFD,HIGH);
    do {
      delay(100);
    }while(analogRead(LDR)‹analogRead(Poti));
    cnt=0;
    delay(10000);
    digitalWrite(LED,LOW);
  }

  delay(10);
}



Mit dem Potenziometer kann man die Lichtempfindlichkeit einstellen und so festlegen, ab wann die Schaltung Licht »ein« erkennt.
Dreht man das Potenziometer mehr nach rechts, wird die Empfindlichkeit geringer.






********************************************************I*
Franzis BUCH  Mikrocontroller-Programmierung mir ARDUINO  10.15 DämmerungsSchalter Seite 172

10.15 Dämmerungsschalter
In der letzten Anwendung haben wir bereits den Fotowiderstand LDR kennengelernt.
Eine weitere Applikation, die ebenfalls oft benötigt wird, ist ein Dämmerungsschalter.
Sobald es dunkel ist, soll sich das Licht automatisch einschalten. Wir kennen das
z.B. bei den Straßenlaternen. Wenn es morgens hell wird, schalten sie sich automatisch wieder aus.
Das Programm vergleicht den Wert am Analogeingang 0, an dem der LDR angeschlossen ist, mit zwei Werten: dem Hell- und dem Dunkel-Wert, die wir im Programm vorgegeben.
Dadurch erhalten wir eine klare Ein-/Ausschalt-Hyste-rese, die dafür sorgt, dass kleine Lichtschwankungen dem Programm nichts anhaben können.
Dadurch wird das Licht nicht sofort ein- bzw. wieder ausgeschaltet, wenn es kurz hell oder dunkel wird.
Eine Wartezeit von mehreren Sekunden unterdrückt zuverlässig Störungen und macht das Programm robust gegen äußere Störfaktoren wie heranfahrende Autos mit eingeschaltetem Licht oder kurzes Abdecken des Sensors.



Bild 10.17: Schematischer Aufbau des Dämmerungsschalters



Diese Schaltung ist ähnlich wie die der Lüftersteuerung, nur dass hier der Festwiderstand gegen Masse angeschlossen und der LDR gegen +5 V ist.
Die Spannung am Analogeingang wird dadurch bei Hell größer und bei Dunkel kleiner.

Verwendete Bauteile:
1x Arduino/Freeduino-Board
1x Steckbrett
1x LDR
1x Trimmerwiderstand 10 k1-2
1x Widerstand 68 kO
5x Schaltlitze ca. 5 cm Länge
1x Schaltlitze ca. 10 cm Länge


http://processing.org/
Beispiel: Dämmerungsschalter.pde

// Franzis Arduino
// Dämmerungsschalter
int LED=13;
int LDR=0;
int Poti=1;
int cnt=0;

void setup()
)
   pinMode( LED ,OUTPUT);
}

void loop( )
{
  if(analogRead(LDR)>analogRead(Poti))cnt=0;
  if (anal ogRead(LDR)<anal ogRead( Poti ))cnt++;

  if(cnt>300)
  {
    digitalWrite(LED,HIGH);
    do
    {
       delay(5000);
    }whi 1 e( anal ogRead( LDR)<anal ogRead(Poti));
    cnt=0;
    digital Write( LED, LOW);
  }
                      
  delay(10);
}






********************************************************I*
Franzis BUCH  Mikrocontroller-Programmierung mir ARDUINO  10.16 Lichtänderung Alarmanlage Seite 174

10.16 Alarmanlage
Mithilfe des lichtempfindlichen Widerstands LDR, den wir in den letzten beiden Experimenten bereits erfolgreich verwendet haben, kann man eine Alarmanlage bauen, die auf kleinste Lichtänderungen reagiert.
Zu Beginn des Programms wird der aktuelle Spannungswert des LDR ermittelt, der als Mittelwert dient.
Wird der Spannungswert durch eine Lichtänderung (z.B. vorbeigehende Person) größer oder kleiner und dadurch die Schwelle unter- oder überschritten, löst der Alarm aus.
Da sich die Helligkeit im Raum bedingt durch den Tagesverlauf ändert, wird jede Minute automatisch ein neuer Wert (aktuelle Spannung) ermittelt, der als neuer Anhaltspunkt für die Messung dient.


Bild 10.18: SchematischerAufbau der Alarmanlage

Verwendete Bauteile:
1x Arduino-Board
1x Steckbrett
1x LDR05
1x Trimmerwiderstand 10k
1x Piezo-Schallwandler
1x Widerstand 68 kC)
5x Schaltlitze ca. 5 cm Länge
1x Schaltlitze ca. 10 cm Länge


http://processing.org/
Beispiel: Alarmanlage.pde
// Franzis Arduino
// Alarmanlage

int LED=13;
int LDR=0;
int Poti=1;
int Speaker=8;
int cnt=0;
int value,Schwelle=0;

void setup()
{
  pinMode(LED,OUTPUT);
  pinMode(Speaker,OUTPUT);
  value=analogRead(LDR);
}

void loop()
{

  cnt++;
  if(cnt>1000)
  {
    cnt=0;
    value=analogRead(LDR);
}

  Schwel1e=(analogRead(Poti)/10);
  if(value>(analogRead(LDR)+Schwelle)Ilvalue<analogRead(LDR-Schwelle))
  {
  digitalWrite(LED,HIGH);
  tone(Speaker,500);
  delay(2500);
  noTone(Speaker);
  digitalWrite(LED,LOW);
  value=analogRead(LDR);
  }

  delay(10);
}


http://sites.prenninger.com/arduino-uno-r3/arduino-praxisbuch



Lichtverfolgung mit dem Arduino – Arduino Light Follower


Irgendwo im Netz habe ich vor kurzem ein Video eines Roboters gesehen, der als bewegliche Plattform eine darauf abgestellte Zimmerpflanze immer an den hellsten Punkt im Raum bewegt. Ganz so anspruchsvoll ist dieser einfache Lichtverfolger nicht und mit nur einem Servo kann man ohnehin keine großen Sprünge machen.
Ziel dieses Projekts ist eine Schaltung und ein Arduino Sketch, mit dem ein Modellbauservo in der Lage ist, einer sich bewegenden Lichtquelle zu folgen.

Benötigte Bauteile

  • 1 x Arduino (Uno R3, in meinem Fall)
  • 2 x Widerstände 220 Ohm
  • 2 lichtempfindliche Widerstände (Photoresistoren)
  • 1 x Servo (beliebiger kleiner Modellbauservo)
  • 1 Breadboard und einige Kabel
  • Karton oder Hartschaumplatten, Kleber oder Heißklebepistole

Die lichtempflindlichen Widerstände sollten so auf den Servo montiert werden, dass sie möglichst getrennte Blickfelder haben. Ich hab das mit 2 kleinen Hartschaumstücken so gelöst. Die lichtempfindlichen Widerstände habe ich zuerst auf das Doppelklebeband gedrückt und dann noch mit Isolierband befestigt.

Achtung: Die beiden Beinchen eines Widerstands dürfen sich unter dem Klebeband nicht berühren!


Die Schaltung am Breadboard besteht aus zwei Spannungsteilern für die beiden lichtempfindlichen Widerstände. Diese werden an die Analogpins 0 und 1 geführt. Zum Thema Spannungsteiler und lichtempfindliche Widerstände habe ich schon einmal ein Video gemacht: Arduino: LED und Lichtsensor.
Im aktuellen Video ist der Aufbau samt Schaltung ebenfalls erklärt:

Und hier der benötigte Arduino Sketch.
Anpassen müsst ihr vielleicht den Toleranzwert im loop(). Ich hab hier 20 verwendet, abhängig von eurem Widerständen kann hier aber auch ein höherer oder niedrigerer Wert sinnvoll sein. Diese Toleranz gibt den maximalen Unterschied zwischen rechtem und linkem Messwert an, bei dem der Servo noch nicht bewegt wird. Steigt die Differenz der beiden Messungen über diesen Wert, dann wird der Servo in Schritten von 2 Grad in Richtung der helleren Seite bewegt. Je kleiner der Wert gewählt wird, desto nervöser wird der Servo.


// Servo-Library einbinden
#include <Servo.h>
 
// Servo-Objekt erzeugen
Servo myservo;
 
// Startwinkel für den Servo (Bereich 0-179 Grad)
int angle = 90;
 
 
void setup() {
// Serielle Schnittstelle initialisieren
Serial.begin(9600);
// Pin 3 als Ausgabe-Pin
pinMode(3, OUTPUT);
// Pin 3 ist Steuerpin für den Servo
myservo.attach(3);
}
 
 
void loop() {
 
// Helligkeit der beiden lichtempfindlichen Widerstände
int rightEye = analogRead(0);
int leftEye = analogRead(1);
 
// Differenz ausrechnen
int diff = (rightEye - leftEye);
 
// Wenn rechts deutlich heller als links -> 2 Grad nach rechts drehen
if (diff > 20) {
angle = angle+2;
}
 
// Wenn links deutlich heller als rechts -> 2 Grad nach links drehen
if (diff < -20) {
angle = angle-2;
}
 
// Servo max. bis 179 Grad drehen
if (angle > 179) {
angle = 179;
}
 
// Servo min. bis 0 Grad drehen
if (angle < 0) {
angle = 0;
}
 
// Grad an den Servo schicken
myservo.write(angle);
 
// Die beiden Helligkeitswerte zu Testzwecken an den PC übertragen
Serial.println(String(rightEye)+"-"+String(leftEye));
 
// Kurze Wartezeit, dann nächste Messung.
// Sollte es beim Testen der Einstellungen zu chaotisch werden,
// diesen Wert einfach auf 50 oder 100 erhöhen und damit den Vorgang verlangsamen
delay(20);
}

Hallo Adi, obwohl ich lange nach einfachen Möglichkeiten gesucht habe, als Mann im fortgeschrittenen Alter (62) in die Arduino-Welt einzusteigen, bin ich eher durch Zufall auf diesen wunderbaren Blog gestoßen. Alles ist so einfach erklärt, dass ein Nachbauen und -vollziehen fast sofort gelingt. So auch dieser einfache Lichtverfolger. Was ich gern machen würde ist, das Servo durch 2 Relais (Arduino-2-Relais-Karte) zu ersetzen, um einen etwas stärkeren (Getriebe-)Motor ansteuern zu können. Ich denke da an einen Scheibenwischermotor, an dessen Achse man das Poti koppeln könnte. Das müsste doch so machbar sein-oder? Theoretisch (meine Gedanken) könnte man das Poti aber auch weglassen, da das ja den Servoweg begrenzt.
Wenn jetzt z.B. ein Solarpanel auf die Getriebemotorachse montiert wird, mit den beiden Fotowiderständen, fährt das Panel in die Sonne und verfolgt die Sonne bis zum Untergang. In der Nacht reicht Mond oder Sternenlicht nicht aus, um das Panel auszurichten. Morgens müßte sich (theoretisch) das Panel wieder der Sonne (Osten) zuwenden… , auch wenn es immer noch vom Abend her nach Westen steht?
Ich hoffe, kein allzu großes Problem aufgeworfen zu haben. Gibt es für diese Variante einen Sketch? Auch wenn ich mich mühe, bin ich doch eher der Mechaniker…
Viele Grüße aus Mecklenburg,
Hans-Martin


Hallo Hans-Martin,
danke erstmal für das Lob. Einen Sketch genau für diesen Anwendungsfall habe ich nicht parat, aber das ist ein interessanter Anwendungsfall. Die Ansteuerung von Relais ist ja sehr einfach, der Aufbau wie von dir beschrieben könnte schon funktionieren. Was die Ansteuerung eines Scheibenwischermotors betrifft, da habe ich leider noch keine Erfahrung. Aber schau mal hier http://rn-wissen.de/wiki/index.php/Getriebemotoren_Ansteuerung fast ganz unten (Abschnitt „Noch mehr Power gewünscht?“), da wird speziell auf das Thema eingegangen.
Zur Software: Wie beim kleinen Lichtverfolger müsste man gewissen Toleranzschwellen einbauen, damit die Ausrichtung nur bei stärkeren Schwankungen passiert (und nicht mehr Strom verbraucht als erzeugt wird) und ab einer gewissen Untergrenze ganz stoppen und man kann halt nicht wie beim Servo mit Winkelangaben arbeiten und hat damit keinen fixen Anhaltspunkt bezüglich der aktuellen Position.
Wenn ich in den nächsten Tagen mal Zeit finde, dann mach ich einen kleinen Aufbau mit einem Gleichstrommotor statt des Servos, da wäre das Prinzip ja ähnlich wie bei deinem Projekt.
lg, Adi

https://www.makerblog.at/2014/11/lichtverfolgung-mit-dem-arduino/




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






Comments