Processing‎ > ‎

LED Sensing

http://sites.prenninger.com/arduino-uno-r3/processing/led-sensing

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2015-01-28

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************

                           LED Sensing

Eine wenig verbreitete Technik ist die Verwendung einer LED als einen Lichtsender oder einem Lichtdetektor.

Theorie

Es ist eine wenig bekannte Tatsache, dass eine LED nicht nur verwendet werden kann, um Licht zu erzeugen, sondern auch, um Licht zu erfassen.

Aus der Festkörperphysik Sicht ist eine Diode jedoch einfach nur ein pn-Übergang.
Gleichrichterdiode, Leuchtdiode und Fotodiode sind im Grunde alle dasselbe.



Praxis

Also lassen Sie uns sehen, wie wir diesen Effekt zu machen. Der Fotostrom wird in einem LED sehr klein, da die Geometrie des Übergangs nicht entwickelt, um es zu maximieren, wie es in einer Fotodiode ist. Was wir tun müssen, ist, einen Weg zu integrieren (eine vornehme Art zu sagen, addieren) all die kleinen Fotoströme über eine bestimmte Zeit finden. Dazu verwenden wir einen Trick tun, stellen wir die Diode Blick wie ein Kondensator, jene conducing Regionen durch einen Isolator Blick wie ein Kondensator getrennt. So berechnen wir es auf und dann, wie lange es dauert, den Photostrom, um es zu entladen, genau wie dieser: -


Dies beinhaltet ein bisschen elektronischen Gymnastik mit den Enden der LED, sondern als die Arduino hat konfigurierbare Stifte dies leicht in Software durchgeführt. Der andere Trick ist anstatt zu warten, der Kondensator entladen genug, um eine logische Null, die eine lange Zeit sein kann geben, messen Sie einfach die Spannung über sie, nachdem Sie es eine kurze Zeit, um zu entladen gegeben haben. Ich nenne dies die Integrationszeit, weil es die Integration (Addition) all die kleinen Photonenströme.

Die LED ist eine ideale Vorrichtung, das heißt, nicht alle von der Entladung durch Photonen verursacht wird, sind andere Ursachen thermische Rauschen und Leckage. Also genug Zeit, die Gebühr ohne Licht zerfallen gegeben. Schließlich, wie LEDs werden nicht als Lichtsensoren entwickelt, variiert die Lichterfassungsfähigkeit von LED zu LED. Es gibt einige Arten, die besser sind als andere. Rote LEDs sind die besten, da sie empfindlich für alle Farben des Lichtes, wo als blaue LEDs empfindlich auf nur blaues Licht zu sein. Das Schlimmste von allem sind weiße LEDs einige Arten nur mit UV-Licht reagieren. Die Verbindungsgröße ist wichtig, damit der kleinere eine LED ist, desto empfindlicher wird es als die Kapazität ist geringer, und es dauert weniger Photonen, um es zu entladen. Endlich ein klares Paket wird mehr Licht in als einem farbigen ein zu lassen. Wenn Sie LED-Licht-Sensoren verwenden möchten, wie Berührungssensoren dann Oberflächenmontage LEDs sind wahrscheinlich am besten.


Hardware

Draht bis die LED, so daß die Anode mit einem digitalen Stift verbunden ist und die Kathode mit einem ein analoges Eingangsstift verbunden ist. Vergessen Sie nicht, einen Strombegrenzungswiderstand in jeder LED. So, das reicht einfach.


Software

Zunächst in der setup () müssen Sie global die internen Pull-up-Widerstände zu deaktivieren mit: -

  _SFR_IO8(0x35) |= 0x10;  // Globale disable Pullup Widerstände

Wenn Sie dies nicht tun, dann wird es nicht funktionieren.


Die einzelnen Schritte die zu ergreifen sind.

1) Leuchtet die LED, indem die Anode positiv (logische Eins) und der Kathode negativ (logische Null) - dies vollständig entladen die LED als Kondensator.
2) Laden Sie den Kondensator, indem die Anode negativ und die Kathode positiv, da dies ein kleiner Kondensator wird es überhaupt keine Zeit mit anderen Worten für so kurze Zeit wie möglich zu nehmen.
3) Setzen die Diode in den Messmodus, indem die Anode negativ ist (es ist bereits) und die Kathode an einen analogen Eingang verbunden.
4) Stellen eine Messung der analogen Spannung, das ist eine Bezugsebene, die später verwendet werden.
5) Warten Sie, während das Photon Strom integriert - je länger desto mehr empfindlich, aber zu lange und Effekte außer Fotostrom dominieren.
6) Messen Sie die Spannung wieder und subtrahieren sie von dem Referenzwert Sie vor der Integration Mal stattfand. Diese Zahl ist Ihre leichte Lektüre.


Sie können dies nur eine LED über gelten oder, wie in der Schaltung, für viele. Allerdings habe ich festgestellt, dass, wenn Sie es zu vielen LEDs gelten sie interagieren können. Das ist vertuschen ein und die Messwerte von den anderen zu tun ein wenig nach unten. Diese Wechselwirkung kommt zustande, weil der Multiplexer innerhalb des Arduino, die separate Eingänge zu der einen Analog-Digital-Wandler (A / D) schaltet. Grundsätzlich gibt es kostenlos im System belassen aus der Bewertung des bisherigen Sensor vermasselt die nächste Lesung. Daher gibt es ein paar andere Tricks in den Code, um die Interaktion wie Jonglieren über mit der Reihenfolge, in der sie gescannt werden und Entladen des A / D-Eingang nach der Lesung gemacht worden zu minimieren. Die Skizze für den Arduino kann hier heruntergeladen werden Sensor_LEDs.pde .  http://www.thebox.myzen.co.uk/Workshop/LED_Sensing_files/Sensor_LEDs.pde

Es kann schwierig sein, um einen Effekt der wechselnden Lichtpegel von den Zahlen, so schrieb ich eine kleine Routine in Bearbeitung, um die Ergebnisse in grafischer Form anzeigen. Der Code dafür ist hier LED_Sensor.pde .

http://www.thebox.myzen.co.uk/Workshop/LED_Sensing_files/LED_Sensor.pde




Schließlich machte ich ein System, wo die LED würde zwischen hell oder dunkel, je ändern, wenn es bedeckt war oder nicht. Nicht ist es nicht nur eine Frage der Einstellung ist hell, wenn abgedeckt, müssen Sie diesen Zustand zu halten, bis er wieder vor dem Einschalten zu dimmen bedeckt. Diese fast arbeitete zuverlässig, wurde aber manchmal Glücksache. Jedoch erwies es sich als sehr schwierig, Video aufgrund der Helligkeit der LEDs und ihre Blink Natur. Die Ergebnisse sind besser als in dem Video gezeigt. Wenn Sie den Code erhalten wollen, dann laden müssen hier Sensor_Feedback.pde .

http://www.thebox.myzen.co.uk/Workshop/LED_Sensing_files/Sensor_Feedback.pde

Abschluss

Diese Arbeit zeigt, ist es möglich, eine LED als Lichtsensor zu verwenden. Allerdings würde ich nicht übernehmen diese in ein Abschlussprojekt, wie ich das Gefühl es ist nicht eine feste, zuverlässige Technik. Es kann auch bei Tageslicht, sondern unter künstlicher Beleuchtung Dinge funktionieren kann knifflig. Der Code geben hier bieten dem Experimentator eine Grundlage für die weitere Arbeit.


Weitere Arbeiten

Ich habe versucht, dies auf die Verwendung eines 5x7 Matrix LED ausbauen konnte aber nicht einen Licht Reaktion auf eine einzelne LED, nur Spalten oder Zeilen zu bekommen. Das deckt eine ganze Spalten zeigte Lichtempfindlichkeit ebenfalls vertuschen eine ganze Reihe auch gearbeitet, aber nur für eine einzige LED zeigte keine Wirkung. Ich weiß nicht, ob dies etwas mit der Art der LED-Matrix mit Licht undicht zwischen den Flecken zu tun war oder ob es die Tatsache, dass sie direkt von den Arduino Pins ohne Fahrern gefahren und so musste hohe Serienwiderstände haben.




http://www.thebox.myzen.co.uk/Workshop/LED_Sensing_files/Sensor_Feedback.pde
/* LED Sensors + feedback - Mike Cook - December 2008
 *  
 * ----------------- Toggle the state of the LEDs when coverd
 * 
 
#######################################################################

HARDWARE NOTE: Anodes driven direct from pins 7, 6, 5 .....
               Cathodes through a resistor (220R) to analogue inputs A0, A1, ....
               Analogue inputs can be reprogrammed to be digital outputs

#######################################################################
*/

#define numSensors 6    // Number of LED sensors - 6 is the maximum you can wire up
//variables setup

  byte anodePin[] =  { 7, 6, 5, 4, 3, 2};
  byte cathodePin[] = { 14, 15, 16, 17, 18, 19}; // the analogue input pins 0 to 5 when used digitally
  int results[6];
  int refLevel[6];
  int ledState[6] = {0,0,0,0,0,0}; // all off
  int changeRef[6] = {0,0,0,0,0,0}; 
  int thresholdUp   = 800;
  int thresholdDown = 650;

//setup: declaring inputs and outputs and begin serial 
void setup() { 
    _SFR_IO8(0x35) |= 0x10;   // global disable pull up resistors
  for(int i=0; i<numSensors; i++){
  digitalWrite(anodePin[i],LOW); // ensure pins go low immediatly after initilising them to outputs
  pinMode(anodePin[i],OUTPUT);   // declare the anode pins as outputs
  pinMode(cathodePin[i],INPUT); // declare the cathode pins as inputs
  }
   //start serial with baud rate 38400
  Serial.begin(38400);          
}

//loop: light and then read LEDs 
void loop () {
  // turn all LEDs on
  for(int i=0; i<numSensors; i++){
    digitalWrite(anodePin[i],HIGH);
    pinMode(cathodePin[i],OUTPUT);    // Enable cathode pins as outputs
    if(ledState[i] != 0) digitalWrite(cathodePin[i],LOW); else digitalWrite(cathodePin[i],HIGH);  // Turn ON LED if indicated by state
  } 
  delay(5); // hold LEDs on
  for(int i=0; i<numSensors; i++){
    digitalWrite(cathodePin[i],LOW);  // now turn all irrespective of state
  }
  
   // charge up LEDs cathode = HIGH, anode = LOW
   for(int i=0; i<numSensors; i++){
    digitalWrite(cathodePin[i],HIGH); 
    digitalWrite(anodePin[i],LOW);    
  }
     // Put cathode pins into measuring state (analogue input)
    for(int i=0; i<numSensors; i++){
    pinMode(cathodePin[i],INPUT);
  }
  // Take a reading of the voltage level on the inputs to get a referance level before discharge
   for(int i=0; i<numSensors; i++){
     results[i] = analogRead(i);  // Store the referance level
  }
  //**********************************************************
  delay(40);  // LED discharge time or photon intergration time
              // The larger this is, the more sensitave is the system
  //**********************************************************
 
 // Read the sensors after discharge to measure the incedent light
  for(int i=numSensors-1; i>-1; i--){
     results[i] -= analogRead(i);     // subtract current reading from the referance to give the drop
     pinMode(cathodePin[i],OUTPUT);   // by discharging the LED immediatly 
     digitalWrite(cathodePin[i],LOW); // the cross talk between sensors is reduce
  }
  
    // print out the results or send it to Processing
    for(int i = 0; i<numSensors; i++){
    Serial.print(results[i],DEC);
    Serial.print(" ");
  } 
    Serial.println(" ");
    // work out the state of the LEDs
    for(int i = 0; i<numSensors; i++){
      if(results[i] < thresholdDown ){
          if(changeRef[i] > thresholdDown){
            ledState[i] = ! ledState[i];
            changeRef[i] = results[i];
          }
      }
       if(results[i] > thresholdUp ){
        if(changeRef[i] < thresholdUp){
          changeRef[i] = results[i];
          }
      }
    }
    
}




DIN A4 ausdrucken
*********************************************************

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







a
Comments