In diesem Tutorial zeigen wir, wie man mit einem Arduino Licht erkennt. Die Lichtdetektion ist ein grundlegender Aspekt vieler Projekte, von automatischen Lichtschaltern bis hin zu geregelten Beleuchtungssystemen. Wenn du die Prinzipien der Lichtdetektion verstehst, kannst du innovative Anwendungen entwickeln, die auf Änderungen der Lichtverhältnisse reagieren.
Mit einem Arduino-Board können wir problemlos verschiedene Sensoren und Bauteile zur Lichtdetektion anschließen. Einer der am häufigsten verwendeten Sensoren dafür ist der Fotowiderstand, auch bekannt als lichtabhängiger Widerstand (LDR). Durch das Messen des Widerstands des Fotowiderstands können wir die Intensität des darauf fallenden Lichts bestimmen.
In diesem Blogbeitrag führen wir dich durch den Aufbau eines Lichtdetektors mit Arduino und Fotowiderstand. Außerdem zeigen wir, wie du dieses Grundsetup erweitern kannst, um fortgeschrittene Projekte wie einen automatischen Lichtschalter, geregelte Beleuchtung oder sogar einen lichtgesteuerten Servo zu realisieren.
Egal, ob du Anfänger oder erfahrener Arduino-Enthusiast bist, dieses Tutorial vermittelt dir das nötige Wissen, um mit der Lichtdetektion zu starten. Also, legen wir los!
Benötigte Teile
Nachfolgend findest du die Komponenten, die du für dieses Projekt benötigst. Wenn du bereits Widerstände, LEDs und Trimmer hast, brauchst du die Kits natürlich nicht. Andernfalls lohnt sich der Kauf, da es günstiger ist als der Einzelkauf der Bauteile.
Arduino Uno
Dupont-Kabelset
Breadboard
USB-Kabel für Arduino UNO
Widerstands- & LED-Kit
Trimmer-Set
Fotowiderstands-Set
Positionsservo
Arduino IDE
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Was ist ein Fotowiderstand oder LDR
Ein Fotowiderstand, auch lichtabhängiger Widerstand (LDR) genannt, ist ein Widerstand, dessen Wert sich je nach Lichtmenge, der er ausgesetzt ist, ändert. Er ist ein passives Bauteil, das in vielen Lichtdetektions- und Steuerungsanwendungen weit verbreitet ist. Das Bild unten zeigt einen typischen Fotowiderstand.
Beachte, dass der Fotowiderstand keine Polarität hat. Da es sich nur um einen Widerstand handelt, kannst du ihn in beliebiger Richtung verwenden. Für Arduino gibt es auch Module mit integrierter Schaltung, die die Empfindlichkeit des Sensors anpassen lassen, aber wir bauen das selbst.
Wie funktioniert ein Fotowiderstand?
Ein Fotowiderstand besteht aus einem halbleitenden, photoleitenden Material. Wenn Licht auf die Oberfläche fällt, regen die Photonen die Elektronen im Halbleitermaterial an, sich freier zu bewegen. Diese Bewegung verringert den Widerstand des Fotowiderstands.
Im Dunkeln oder bei geringer Lichtintensität ist der Widerstand des Halbleitermaterials höher. Diese Eigenschaft macht Fotowiderstände ideal zur Erkennung von Lichtintensitäten.
Spannungsteiler
Um den Widerstand eines Fotowiderstands zu messen und in eine messbare Spannung umzuwandeln, wird häufig ein voltage divider Schaltkreis verwendet, der aus zwei in Serie geschalteten Widerständen besteht. Einer davon ist der Fotowiderstand, der andere oft ein Potentiometer oder Trimmer, um die Empfindlichkeit oder den Schwellwert einzustellen. Es gibt auch einfachere Schaltungen mit festem Widerstand statt Trimmer.
Das Bild unten zeigt das Schaltbild des Spannungsteilers, den wir in den folgenden Abschnitten verwenden.
Man sieht, dass der Fotowiderstand (R1) und der Trimmer (R2) in Serie zwischen der Stromversorgung (5V) und Masse (GND) geschaltet sind. Der Verbindungspunkt zwischen R1 und R2 ist mit dem analogen Eingang A0 des Arduino verbunden. Da sich der Widerstand des Fotowiderstands mit der Lichtintensität ändert, beeinflusst das die Spannung am Verbindungspunkt.
Die Formel zur Berechnung der Ausgangsspannung eines Spannungsteilers lautet:
V_A0 = Vin * (R1 / (R1 + R2))
Wobei:
- V_A0 die Ausgangsspannung ist
- Vin (+5V) die Eingangsspannung ist
- R1 der Widerstand des Fotowiderstands ist
- R2 der Widerstand des Trimmers ist
Im nächsten Abschnitt lernst du, wie du mit dieser Schaltung und einem Arduino einen Lichtdetektor baust.
Einen Lichtdetektor bauen
In diesem Abschnitt zeige ich, wie man einen LDR an einen Arduino anschließt und die gemessenen Lichtintensitäten im Serial Monitor ausgibt.
Den Spannungsteiler aufbauen
Das folgende Diagramm zeigt, wie die Bauteile angeschlossen werden, um den oben beschriebenen Spannungsteiler zu bauen. Zuerst verbinden wir 5V mit der positiven Stromschiene des Breadboards (rotes Kabel). Dann verbinden wir Masse (GND) mit der negativen Stromschiene (blaues Kabel).
Jetzt der Spannungsteiler: Verbinde einen Pin des Fotowiderstands (LDR) mit der positiven Stromschiene (rotes Kabel). Der andere Pin wird mit dem mittleren Pin des Trimmers verbunden. Achte darauf, dass das richtig ist, sonst funktioniert das Einstellen nicht.
Für den Trimmer wählen wir einen Widerstandswert, der ungefähr dem Widerstand des LDR bei normalem Licht entspricht. In meinem Fall sind das etwa 20 kOhm. Der genaue Wert ist nicht kritisch.
Dann verbinden wir den Verbindungspunkt zwischen Trimmer und Fotowiderstand mit einem gelben Kabel mit dem analogen Eingang A0 am Arduino.
Die letzte Verbindung ist zwischen einem der anderen Trimmer-Pins und der negativen Stromschiene (blaues Kabel). Welchen Pin du dafür nimmst, ist egal. Zum Schluss drehst du den Trimmer in die Mittelstellung und wir beginnen mit der Software.
Code für den Lichtdetektor
Die Software für den Lichtdetektor ist sehr einfach. Wir definieren eine Konstante ldrPin für den Pin, an dem der LDR angeschlossen ist, und eine Variable ldrValue zum Speichern der gemessenen Helligkeit.
const int ldrPin = A0;
int ldrValue = 0;
void setup() {
Serial.begin(9600);
pinMode(ldrPin, INPUT);
}
void loop() {
ldrValue = analogRead(ldrPin);
Serial.print("LDR:");
Serial.println(ldrValue);
delay(100);
}
Im setup() -Abschnitt starten wir die Serial Kommunikation und setzen den Modus des ldrPin auf INPUT, da wir von diesem lesen wollen.
Im oop() -Abschnitt lesen wir den LDR-Wert mit analogRead() aus und geben ihn im Serial Monitor aus. Öffne nun den Serial Plotter und bewege deine Hand vor dem LDR, um die Lichtmenge zu verändern. Du solltest eine schwankende Kurve wie unten sehen.
Wenn du keine Signale (flache Linie) bekommst, überprüfe deine Schaltung und stelle sicher, dass der Trimmer in der Mittelstellung ist.
Der analoge Eingang liefert Werte im Bereich von 0 bis 1023 auf einem Arduino UNO. Normalerweise sieht man nicht den gesamten Bereich, solange der Sensor nicht völliger Dunkelheit oder extremer Helligkeit ausgesetzt ist.
Um eine gute Empfindlichkeit zu erreichen, experimentiere mit verschiedenen Helligkeitsstufen und justiere den Trimmer so, dass du weder den Minimalwert (0) noch den Maximalwert (1023) erreichst. Beachte, dass diese Werte nicht kalibriert sind. Wenn du z.B. die Lichtintensität in Lux messen möchtest, benötigst du eine Lichtquelle mit bekannter Intensität zur Kalibrierung.
Einen automatischen Lichtschalter bauen
Da wir nun Licht erkennen können, bauen wir einen automatischen Lichtschalter. Sobald es dunkel wird, schalten wir das Licht ein. Für dieses Beispiel fügen wir dem Schaltkreis eine LED mit Widerstand hinzu.
Wir behalten den Spannungsteiler bei und fügen die LED sowie einen 220-Ohm-Widerstand wie oben gezeigt auf dem Breadboard hinzu. Verbinde dann den langen Pin der LED mit einem orangen Kabel an Pin 9 des Arduino. Schließlich verbindest du den Widerstand mit einem blauen Kabel mit der negativen Stromschiene. Fertig!
Den Code zu erweitern ist ebenfalls sehr einfach. Füge einfach eine weitere Konstante ledPin für den Ausgangspin der LED hinzu und setze den pinMode im OUTPUT -Abschnitt auf setup().
const int ldrPin = A0;
const int ledPin = 9;
int ldrValue = 0;
void setup() {
Serial.begin(9600);
pinMode(ldrPin, INPUT);
pinMode(ledPin, OUTPUT);
}
void loop() {
ldrValue = analogRead(ldrPin);
digitalWrite(ledPin, ldrValue > 500 ? HIGH: LOW);
delay(1000);
}
Im loop() -Abschnitt lesen wir den ldrValue wie zuvor aus. Je nach Wert schalten wir die LED mit digitalWrite ein oder aus. Wenn der ldrValue größer als 500 ist, ist es ziemlich hell, und wir schalten die LED aus (LOW). Ist der Wert kleiner, ist es dunkel, und wir schalten die LED an (HIGH).
Fertig! Jetzt hast du ein automatisches Licht, das bei Dunkelheit angeht. Du kannst den Schwellwert anpassen, indem du den Wert 500 auf einen höheren oder niedrigeren Wert (zwischen 0 und 1023) änderst. Für hellere Lichter kannst du die LED durch ein Relais ersetzen und damit z.B. deine Raumbeleuchtung steuern.
Eine geregelte Lampe oder Dimmer bauen
Im vorherigen Abschnitt haben wir einen automatischen Lichtschalter gebaut, der die LED komplett an- oder ausschaltet. Hier zeige ich, wie du die Helligkeit der LED stufenlos regeln kannst, abhängig von der Umgebungshelligkeit. Statt die LED zu schalten, dimmen wir sie.
Hier ist der Code dazu. Wir fügen eine brightness Variable hinzu, lassen die setup() Funktion aber unverändert.
const int ldrPin = A0;
const int ledPin = 9;
int ldrValue = 0;
int brightness = 0;
void setup() {
Serial.begin(9600);
pinMode(ldrPin, INPUT);
pinMode(ledPin, OUTPUT);
}
void loop() {
ldrValue = analogRead(ldrPin);
brightness = map(ldrValue, 50, 300, 255, 0);
brightness = constrain(brightness, 0, 255);
analogWrite(ledPin, brightness);
delay(10);
}
Im loop() Abschnitt lesen wir den ldrValue wie zuvor, wandeln dann aber map seinen Wert in den Bereich 255 bis 0 um. Beachte, dass der Bereich invertiert ist (255 bis 0 statt 0 bis 255), weil die LED heller werden soll, je dunkler es ist.
Der ldrValue hat einen möglichen Bereich von 0 bis 1023. Im Code verwenden wir aber nur den Bereich von 50 bis 300. So reagiert die LED auf vergleichsweise kleine Änderungen der Lichtverhältnisse. Sonst müsste es sehr hell oder dunkel sein, um eine Änderung der Helligkeit zu sehen.
Das führt allerdings zu einem kleinen Problem: Die map-Funktion garantiert nicht, dass der Ausgabewert tatsächlich im Bereich 255 bis 0 liegt. Wenn es heller oder dunkler als 50 bzw. 300 wird, kann der Wert kleiner als 0 oder größer als 255 sein. Die analogWrite() Funktion unterstützt aber nur Werte von 0 bis 255. Deshalb verwenden wir constrain(), um den Bereich sicherzustellen.
Die analogWrite() Funktion nutzt PWM (Pulsweitenmodulation), um die Helligkeit der LED zu steuern. Wenn du mehr darüber erfahren möchtest, schau dir unser Tutorial zu How use Arduino to control an LED with a Potentiometer an.
Fertig! Jetzt hast du eine geregelte Lampe, die je nach Umgebungshelligkeit heller oder dunkler wird. Für mehr oder weniger Empfindlichkeit kannst du die Werte des Eingangsbereichs (50, 300) anpassen.
Einen Licht-Richtungsdetektor bauen
Wir können unseren Lichtdetektionskreis leicht modifizieren, um einen Licht- Richtungs- Detektor zu bauen. Dazu ersetzen wir einfach den Trimmer durch einen zweiten LDR. Wie unten zu sehen, ist die neue Schaltung immer noch ein Spannungsteiler, aber mit zwei LDRs.
Je nachdem, welcher LDR mehr Licht empfängt, steigt oder fällt die Spannung an A0. Dabei ist es egal, wie viel Licht die LDRs insgesamt bekommen. Hell oder dunkel – die Spannung an A0 bleibt ungefähr gleich. Entscheidend ist das Verhältnis. Je größer der Unterschied im Licht, desto stärker weicht A0 vom Mittelwert von etwa 2,5 V ab.
Bauen wir diese Schaltung auf dem Breadboard auf. Da es im Grunde die gleiche Schaltung wie zuvor ist, entfernen wir einfach den Trimmer und ersetzen ihn durch einen LDR.
Der Strom fließt von der positiven Stromschiene durch die in Serie geschalteten zwei LDRs zur negativen Stromschiene. Wie zuvor nehmen wir das Signal (gelbes Kabel) vom Verbindungspunkt und führen es an Pin A0 des Arduino.
Unten findest du den Code, den wir verwenden werden.
const int ldrPin = A0;
const int midValue = 500;
const int midRange = 10;
int ldrValue = 0;
void setup() {
Serial.begin(9600);
pinMode(ldrPin, INPUT);
}
void loop() {
ldrValue = analogRead(ldrPin);
Serial.print("LDR:");
Serial.println(ldrValue);
if (ldrValue > midValue + midRange) {
Serial.println("Left");
} else if (ldrValue < midValue - midRange) {
Serial.println("Right");
} else {
Serial.println("Middle");
}
delay(100);
}
Wir erweitern den einfachen Lichtdetektor-Code von zuvor um zwei Variablen. midValue ist der Wert, den wir erwarten, wenn A0 beide LDRs gleich viel Licht abbekommen. Theoretisch sollte dieser Wert 1023/2 = 512 (die Hälfte des Eingangsbereichs) sein. Praktisch sind die Widerstände der beiden LDRs nie exakt gleich, daher ist der tatsächliche Wert leicht abweichend.
const int midValue = 500; const int midRange = 10;
Um diesen Mittelwert zu finden, bringst du beide LDRs in gleichem Winkel und Abstand zu einer Lichtquelle und liest den ldrValue im Serial Monitor ab. Das ist dein Wert für midValue. Bei mir waren es etwa 500, was ziemlich nahe am theoretischen Wert liegt.
Die midRange Konstante definiert, wie viel Abweichung von midValue wir akzeptieren, bevor wir eine Richtung ausgeben. Sie definiert eine Toleranzzone. Werte innerhalb dieses Bereichs bedeuten, dass das Licht in der Mittelposition ist – weder links noch rechts.
Die setup() Funktion bleibt unverändert. Wir starten nur den Serial Monitor und setzen den Pin-Modus.
In der loop() Funktion lesen wir ldrValue wie zuvor und vergleichen es mit dem midValue.
if (ldrValue > midValue + midRange) {
Serial.println("Left");
} else if (ldrValue < midValue - midRange) {
Serial.println("Right");
} else {
Serial.println("Middle");
}
Ist der Sensorwert größer als der Mittelwert plus Toleranz, wissen wir, dass der linke LDR mehr Licht empfängt und geben „Links“ aus. Ist der Wert kleiner als Mittelwert minus Toleranz, geben wir „Rechts“ aus. Im übrigen Fall empfangen beide LDRs ungefähr gleich viel Licht und wir geben „Mitte“ aus. Beachte, dass „links“ und „rechts“ davon abhängen, wie deine Schaltung ausgerichtet ist.
Ein letzter Tipp: Du kannst die Richtungsgenauigkeit deutlich verbessern, indem du die LDRs in Röhren steckst, sodass sie nur gerichtetes Licht empfangen. Unten ist ein Bild meines einfachen Hacks zum Testen.
Mit den Röhren kann ich die Lichtquelle genau orten. Im nächsten Abschnitt zeige ich, wie man damit einen Servo steuert.
Einen lichtgesteuerten Servo bauen
Positionsservos sind dafür ausgelegt, sich auf einen bestimmten Winkel zu drehen. Das macht sie ideal, um unseren Licht-Richtungsdetektor auszuprobieren. Wir können den Winkel des Servos steuern und ihn in die Richtung des Lichts zeigen lassen.
Zuerst fügst du den Servo hinzu, indem du seine Stromversorgung an die Stromschienen anschließt (braun ist Masse, rot ist Plus). Dann verbindest du den Signaleingang des Servos (gelb) mit einem orangen Kabel an Pin 9 des Arduino. Fertig!
Unten findest du den Code zur Steuerung des Servos. Er ist eine kleine Erweiterung des obigen Codes. Wenn du Schwierigkeiten hast, den Code und seine Erklärung zu verstehen, schau dir unser Tutorial zu How to Control Servo Motors with Arduino an, das mehr Details zu Servos bietet.
#include "Servo.h"
#define IR_RECEIVE_PIN 8
const int ldrPin = A0;
const int servoPin = 9;
const int range = 780;
const int mid = 1600;
const int midValue = 500;
const int midRange = 10;
int ldrValue = 0;
int angle = 0;
Servo servo;
void rotate(int angle) {
angle = map(angle, 0, 180, mid - range, mid + range);
servo.writeMicroseconds(angle);
}
void setup() {
Serial.begin(9600);
pinMode(ldrPin, INPUT);
servo.attach(servoPin);
}
void loop() {
ldrValue = analogRead(ldrPin);
int angle = (ldrValue - midValue) * 0.8;
angle = constrain(angle, -90, +90);
if (angle > midRange) {
rotate(90 + angle);
} else if (angle < -midRange) {
rotate(90 + angle);
} else {
rotate(90);
}
delay(100);
}
Der Code enthält zusätzliche Konstanten wie range und mid, die in der rotate() Funktion verwendet werden, welche den Servo auf einen bestimmten Winkel dreht. Abgesehen von den Konstanten und Funktionen für den Servo ist der Rest des Codes ähnlich wie zuvor.
Das Interessante passiert in der loop() Funktion. Dort wandeln wir den ldrValue in einen Winkel um, indem wir den midValue vom ldrValue subtrahieren und mit dem Faktor 0,8 multiplizieren.
int angle = (ldrValue - midValue) * 0.8;
Der Faktor 0,8 muss an die Dimensionen/Physik deines Systems angepasst werden, insbesondere wie weit die LDRs auseinander liegen. Wie zuvor gibt es keine Garantie, dass der Winkel im Bereich von -90 bis +90 Grad liegt. Deshalb begrenzen wir ihn:
angle = constrain(angle, -90, +90);
Schließlich entscheiden wir, ob wir den Servo nach links oder rechts drehen, abhängig vom ermittelten Winkel. Ist die Winkeländerung klein (-midRange… +midRange), halten wir den Servo auf 90 Grad.
if (angle > midRange) {
rotate(90 + angle);
} else if (angle < -midRange) {
rotate(90 + angle);
} else {
rotate(90);
}
Mit dieser Schaltung und dem Code kannst du nun den Winkel des Servos je nach Lichtquelle steuern. Du könntest damit z.B. ein Auto bauen, das dem Licht folgt. Mit zwei dieser Licht-Richtungsdetektoren in rechtwinkliger Anordnung könntest du eine Solaranlage bauen, die der Sonne für optimale Leistung folgt.
Für Lichtfolgesysteme solltest du jedoch einen kontinuierlichen Servo einem Positionsservo vorziehen. Dieser kann sich in beide Richtungen drehen, bis der Mittelwert erreicht ist. Mehr dazu findest du in unserem Tutorial zu den Unterschieden von Positional versus Continuous Servos.
Einige weitere Anwendungen von Lichtdetektoren sind unten beschrieben.
Anwendungen
Hausautomation
Mit einem Lichtdetektor kannst du verschiedene Aufgaben im Haus automatisieren. Zum Beispiel kannst du deinen Arduino so programmieren, dass er das Licht einschaltet, wenn Dunkelheit erkannt wird, und ausschaltet, wenn Licht erkannt wird. Das spart Energie und erhöht den Komfort.
Sicherheitssysteme
Lichtdetektoren können in Sicherheitssystemen eingesetzt werden, um Alarme auszulösen oder Kameras zu aktivieren, wenn sich die Lichtintensität plötzlich ändert. So können Eindringlinge oder ungewöhnliche Aktivitäten erkannt werden.
Pflanzenüberwachung
Licht ist entscheidend für das Pflanzenwachstum. Mit einem Lichtdetektor kannst du die Lichtmenge überwachen, die deine Pflanzen erhalten, und sicherstellen, dass sie optimale Bedingungen haben. Besonders nützlich für Indoor-Gärten oder Gewächshäuser.
Wetterstationen
Lichtdetektoren können auch in Wetterstationen verwendet werden, um die Sonnenintensität zu messen. Diese Daten helfen bei der Analyse von Wetterlagen, der Berechnung von Solarstrahlung oder der Wettervorhersage.
Kunstinstallationen
Lichtdetektoren können in interaktive Kunstinstallationen eingebaut werden, um dynamische und reaktive Lichteffekte zu erzeugen. Durch die Erkennung von Änderungen im Umgebungslicht kann der Arduino Helligkeit, Farbe oder Muster der Beleuchtung steuern und so ein immersives Erlebnis schaffen.
Dies sind nur einige Beispiele für die vielfältigen Anwendungen der Lichtdetektion mit Arduino. Die Vielseitigkeit von Arduino und seine Kompatibilität mit verschiedenen Sensoren machen es zur idealen Wahl für lichtbasierte Projekte.
Zusammenfassung
In diesem Tutorial haben wir gelernt, wie man mit Arduino Licht erkennt und verschiedene Anwendungen von Lichtsensoren in Maker-Projekten erkundet. Mit einem Fotowiderstand können wir die Lichtintensität in unserer Umgebung einfach messen.
Wir begannen mit dem Grundprinzip des Fotowiderstands und seiner Funktionsweise. Ein Fotowiderstand ist ein Widerstand, dessen Wert sich je nach Lichtmenge ändert. Diese Eigenschaft macht ihn ideal für die Lichtdetektion.
Dann bauten wir einen einfachen Lichtdetektor mit Arduino und Fotowiderstand. Durch Anschluss des Fotowiderstands an einen analogen Pin des Arduino konnten wir den Widerstandswert auslesen und in einen entsprechenden Lichtintensitätswert umwandeln. So entstand ein einfaches Lichtmesssystem.
Anschließend zeigten wir fortgeschrittene Anwendungen von Lichtsensoren. Wir bauten einen automatischen Lichtschalter, der eine Lichtquelle je nach Umgebungslicht ein- oder ausschaltet. Das spart Energie durch automatische Lichtsteuerung.
Wir bauten auch ein geregeltes Lichtsystem, bei dem die Lichtintensität einer Lichtquelle an die Umgebungshelligkeit angepasst wird. Das hilft, eine konstante Beleuchtungsstärke in einem Bereich zu halten.
Zuletzt bauten wir ein lichtgesteuertes Servosystem. Mit den Lichtintensitätswerten des Fotowiderstands konnten wir die Bewegung eines Servomotors steuern. Das eröffnet Möglichkeiten für interaktive Projekte, die auf Lichtänderungen reagieren.
Wir hoffen, dieses Tutorial hat dir eine solide Grundlage für die Arbeit mit Lichtsensoren und Arduino gegeben. Erkunde gerne die hier genannten Anwendungen und lass deiner Kreativität freien Lauf!
Häufig gestellte Fragen
Hier einige häufig gestellte Fragen zur Lichtdetektion mit Arduino:
Kann ich statt Arduino auch ein anderes Mikrocontroller-Board verwenden?
Ja, du kannst auch andere Mikrocontroller wie ESP32, Raspberry Pi oder STM32 zur Lichtdetektion verwenden. Die hier beschriebenen Prinzipien und Techniken lassen sich auf jedes Board mit analogem Eingang übertragen.
Wie bestimme ich die Polarität eines Fotowiderstands?
Fotowiderstände (LDRs) sind unpolarisiert. Das heißt, sie haben keine feste Plus- oder Minus-Seite. Du kannst sie in beliebiger Richtung anschließen, ohne auf Polarität achten zu müssen.
Wie groß ist der Widerstandsbereich eines Fotowiderstands?
Der Widerstand eines Fotowiderstands variiert mit der Lichtintensität. Bei hellem Licht sinkt der Widerstand, bei Dunkelheit steigt er. Typischerweise reicht der Bereich von einigen hundert Ohm bei Helligkeit bis zu mehreren Megaohm im Dunkeln. Es ist wichtig, passende Widerstandswerte in der Schaltung zu wählen, um genaue Messungen zu gewährleisten.
Wie kalibriere ich die Lichtdetektionsschaltung?
Zur Kalibrierung kannst du die Widerstandswerte im Spannungsteiler anpassen. Indem du die Ausgangsspannung bei verschiedenen Lichtstärken misst, kannst du Schwellwerte für die Lichtdetektion bestimmen. So reagiert die Schaltung präzise auf gewünschte Lichtverhältnisse.
Kann ich mehrere Fotowiderstände in einem Projekt verwenden?
Ja, du kannst mehrere Fotowiderstände an verschiedene analoge Eingänge des Arduino oder anderer Mikrocontroller anschließen, um Lichtwerte aus verschiedenen Richtungen oder Orten zu überwachen. Das ist nützlich für Sicherheitssysteme, automatisierte Beleuchtung oder Umweltüberwachung.
Kann ich statt eines Fotowiderstands auch ein Lichtsensormodul verwenden?
Ja, es gibt Lichtsensormodule mit eingebauten Fotowiderständen oder anderen Sensoren. Diese Module bieten oft zusätzliche Funktionen wie einstellbare Empfindlichkeit oder digitale Ausgänge. Beachte beim Einsatz die Datenblätter und Dokumentation für Pinbelegung und Betrieb.
Worin unterscheiden sich Fotowiderstände von PIR-Bewegungssensoren?
Fotowiderstände und passive Infrarot-(PIR)-Sensoren erkennen Umweltveränderungen, arbeiten aber unterschiedlich. Fotowiderstände messen Lichtintensität, PIR-Sensoren erfassen Infrarotstrahlung von bewegten Objekten. Fotowiderstände eignen sich zur Lichtüberwachung, PIR-Sensoren zur Bewegungserkennung von Menschen oder Tieren.
Wenn du weitere Fragen hast oder Hilfe brauchst, schreibe gerne einen Kommentar unten.
Links
Hier einige nützliche Links für weiterführende Informationen
- Light Sensor (Photoresistor) With Arduino in Tinkercad
- How to Use Photoresistors to Detect Light on an Arduino
- Arduino Photo Resistor Tutorial (Step by Step) – YouTube
- Understanding this photoresistor circuit – General Electronics
- How to Use a Photoresistor (or Photocell) – Arduino Tutorial
- photoresistor how to use it – General Electronics
- Photoresistor: Basics and Arduino Tutorial
