Fotowiderstand (LDR) GL55xx

Ein Fotowiderstand oder LDR (von engl. "Light Dependent Resistor") ist ein lichtempfindliches elektrisches Bauelement. Die lichtempfindliche Schicht besteht bei der GL55xx-Serie aus Cadmiumsulfid (CdS), welche etwa die gleiche Farbempfindlichkeitskurve wie das menschliche Auge oder Fotofilme hat. Cadmiumsulfid weist bei einer Wellenlänge von 520nm die maximale Empfindlichkeit auf.

Verwendete Bauteile

• Grundlegende Werkzeuge und Hilfsmittel
• Arduino UNO (oder kompatibles Board)
• Fotowiderstand der GL55xx-Serie
• LED (hier: 5mm rot)
• 330Ω Widerstand
• 10kΩ Widerstand
• Steckkabel ("Jumperkabel")
• Steckbrett ("Breadboard")

Aufbau

Zu beachten ist bei der Schaltung, dass der LDR keinen Kurzschluß verursachen kann, in diesem Fall also mit einem Pulldown-Widerstand von 10kΩ verschaltet wird.

Helligkeit mit einer LED darstellen

#define PIN_PHOTO_RESISTOR A0
#define PIN_LED 9

int brightness = 0, lastBrightness = 0;
bool isLedActive = false;

const byte SENSITIVITY          = 10;
const byte DARKNESS_THRESHOLD   = 150;
const byte BRIGHTNESS_THRESHOLD = 250;

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

void loop()
{
    brightness = analogRead(PIN_PHOTO_RESISTOR);

    if (abs(brightness - lastBrightness) >= SENSITIVITY) {
        lastBrightness = brightness;
        Serial.println("Brightness change to: " + String(brightness));
    }

    if (!isLedActive && brightness < DARKNESS_THRESHOLD) {
        isLedActive = true;
        digitalWrite(PIN_LED, HIGH);
        Serial.println("   Lights on");
    }
    if (isLedActive && brightness > BRIGHTNESS_THRESHOLD) {
        isLedActive = false;
        digitalWrite(PIN_LED, LOW);
        Serial.println("   Lights OFF");
    }
}

Nach dem Hochladen des Sketches leuchtet die LED auf, sobald es dunkel genug wird und erlischt wieder, wenn genug Helligkeit von außen auf dem LDR trifft. Gleichzeitig werden in der seriellen Konsole folgende Ausgaben gezeigt:

Graphische Auswertung mit "Processing"

Die gemessene Helligkeit am LDR kann man auch nach Processing übertragen und dort in Echtzeit mit einem Graphen visualisieren. Zunächst benötigt man einen Arduino-Sketch, der die gemessenen Daten am LDR über die serielle Schnittstelle ausgibt:

Arduino-Sketch

#define PIN_SENSOR A0

void setup()
{
    Serial.begin(9600);
}

void loop()
{
    Serial.println(analogRead(PIN_SENSOR));
    delay(10);
}

In Processing wird nun der serielle Port (mit übereinstimmender Baudrate) geöffnet und die Werte ausgelesen. Sie werden nun nur noch auf das Ausgabe-Fenster angepasst und dann als kleine Punkte visualisiert. Zusätzlich wird der empfangene Wert als Zahl oben auf dem Ausgabefenster dargestellt.

Processing-Sketch

Der folgende Processing-Sketch nimmt ASCII-kodierte Zeichenketten (Strings) von der seriellen Schnittstelle mit einem Wertebereich von 0-1023 entgegen. Dabei wird davon ausgegangen, dass diese Werte mit einem "\n" voneinander getrennt sind.

import processing.serial.*;

Serial myPort;
int xPos = 1, yPos = 0;
String sensorValue;

void setup ()
{
    size(640, 400);
    background(0);
    stroke(255);
    textSize(15);

    myPort = new Serial(this, Serial.list()[0], 9600);
    myPort.clear();
    myPort.bufferUntil('\n');
}

// everything happens in the serialEvent()
void draw ()
{
    circle(xPos, yPos, 1);

    fill(0);
    stroke(0);
    rect(0, 0, width, 25);

    stroke(255);
    fill(127);
    text("Sensor value = " + sensorValue.toString(), 5, 20);

    if (xPos >= width) {
        xPos = 0;
        background(0);
    } else {
        xPos++;
    }
}

void serialEvent (Serial myPort)
{
    sensorValue = myPort.readStringUntil('\n');
    if (sensorValue != null) {
        yPos = height-int(map(float(sensorValue), 0, 1023, 1, height-25));
    }
}