Show Posts
Pages: [1]
1  Development / Other Software Development / EcoSleep - a library for low power sleeping and waiting on: March 25, 2013, 02:04:47 pm
have built a small library for low Power Sleeping on a ATMega328P-PU, to easily save some Energy on projects running 24/7.

There are three different Modes you can use, each putting the 328 to Sleep until a Interrupt wakes it, or for a given time in seconds.
The most power saving mode puts the 328P-PU to sleep at 0,00015mA only (with 16MHz external Osciallator; no Watchdog timer, no Clocks running, Outputs disabled, BrownOut disabled). Right. less than one microampere at 5V Power Supply.
There are a lot of different Options how to use this library to fit most used needs on a easy way, easy enough to be used by everyone... at least i hope so =D. See the Example on how to use them.

This library still could be optimized. Right now it only supports ATMega 328P-PU (like Arduino UNO), but if there is some help through the community, i think it could be extended to fit a ATMega as well (i dont have one, so i couldnt test anything).

If you want to use this library, refer to the scematic i have added on how to wire the external interrupts.


2  International / Deutsch / Re: Wie glättet man am elegantesten eine Wertetabelle? on: January 11, 2013, 08:43:32 am
Teil 2:
Code:
void calculate(){
  int startbyte;
  int endbyte;
  int length;
  float divisor;
  boolean result = false;
  int startbytecount = 0;
  int inttemp;
  float floattemp;
  float floattemp2;
  float maxdrift = 0.2;
 
 
 
 
  Serial.println();
  Serial.println();
  Serial.println("Calculation");
  Serial.println("===========");
  Serial.println();
 
  Serial.print("loading Data... ");
  for (int i=0; i<=256; i++) Values[i] = Measurement[i];
  Serial.println("Done.");
 
  Serial.println("current Data:"); 
  Serial.print("byte Values[256] = {");   
  for (int i=0; i<=255; i++){
    Serial.print(Values[i]);
    if (i!=255) Serial.print(",");
  }
  Serial.println("};");
 
 
 
  Serial.println();
  Serial.println();
  Serial.println("Calculation 1/4 (compensate drift/errors):");
  Serial.println("------------------------------------------");
  Serial.println();
 
  length = 5;
 
  Serial.print("filter width: \t");
  Serial.println(length);
  Serial.println();
 
  for (startbyte=length/2; startbyte <=255-length/2; startbyte++){
    Serial.print("[");
    Serial.print(startbyte);
    Serial.print("]\t(");
    Serial.print(Values[startbyte]);
    Serial.print(")\t");
    result = true;
    floattemp = 0;
    for (int actbyte = startbyte-length/2; actbyte<=startbyte+length/2;actbyte++){
      if (Values[actbyte] == 0xff){
        result = false;
        break;
      } else if (actbyte!=startbyte){
        floattemp = floattemp + (float(Values[actbyte])/(length-1));
      }
    }
    if (result){
      floattemp2 = (float(Values[startbyte])-floattemp)/(float(Values[startbyte])+0.01);
      if (floattemp2 > maxdrift || floattemp2 < maxdrift*-1) Values[startbyte] = floattemp;
      result = false;
      Serial.print("average: ");
      Serial.print(floattemp);
      Serial.print("\t");
      Serial.print("=> drift: ");
      Serial.print(floattemp2*100);
      Serial.print("% \t");
      Serial.print("=> valid value: ");
      Serial.print(Values[startbyte]);
    }
    Serial.println();
  }
 
 
 
 
  Serial.println("current Data:");
  Serial.print("byte Values[256] = {");   
  for (int i=0; i<=255; i++){
    Serial.print(Values[i]);
    if (i!=255) Serial.print(",");
  }
  Serial.println("};");
 
 
 
 
 
  Serial.println();
  Serial.println();
  Serial.println("Calculation 2/4 (fill values):");
  Serial.println("------------------------------");
  Serial.println();
 
  length = 8;
 
  Serial.print("filter width: \t");
  Serial.println(length);
  Serial.println();
 
  for (startbyte=0; startbyte <=255-length; startbyte++){
    Serial.print(startbyte);
    Serial.print("\t(");
    Serial.print(Values[startbyte]);
    Serial.print(")\t");
    if (Values[startbyte] != 0xff){
      if (Values[startbyte+1] == 0xff){
        for (endbyte = startbyte+2; endbyte<=startbyte+length;endbyte++){
          if (Values[endbyte] != 0xff){
            result = true;
            break;
          }
        }     
        if (result == true){
          Serial.print("Valid row found:\t");
          for (byte i =startbyte; i<=endbyte;i++){
           
            Serial.print("[");
            Serial.print(i);
            Serial.print("]-old:");
            Serial.print(Measurement[i]);
           
            Values[i] = float(endbyte-i)/float(endbyte-startbyte)*Values[startbyte] + float(i-startbyte)/float(endbyte-startbyte)*Values[endbyte]+0.5;
         
            Serial.print("-new:");
            Serial.print(Values[i]);
            Serial.print(" / ");
       
          }
          result = false;
        }
      }
    }
    Serial.println();
  }
 
 
  Serial.println("current Data:");
  Serial.print("byte Values[256] = {");   
  for (int i=0; i<=255; i++){
    Serial.print(Values[i]);
    if (i!=255) Serial.print(",");
  }
  Serial.println("};");
 
 
 
 

 
  Serial.println();
  Serial.println();
  Serial.println("Calculation 3/4 (moving average):");
  Serial.println("---------------------------------");
  Serial.println();
 
  length=8;
 
  if (length%2) length--;
  Serial.print("filter width: \t");
  Serial.println(length);
 
  divisor = (pow(2,length/2)*3)-2;
  Serial.print("divisor:      \t");
  Serial.println(divisor); 
 
  Serial.println();
 
  for (startbyte=0; startbyte <=255; startbyte++){
    if (Values[startbyte] != 0xff){
      for (endbyte=startbyte+1; endbyte <=255; endbyte++){
        if (Values[endbyte] == 0xff){
          endbyte = endbyte--;
          result=true;
          break;
        }
      }
      if (result == true && endbyte-startbyte+1 >=length){
       
        Serial.print("Valid row found:\t");
        Serial.print(startbyte);
        Serial.print("...");
        Serial.println(endbyte);
        for (startbyte; startbyte<=endbyte-length; startbyte++){
          floattemp=0;
          for (int i=startbyte; i<=startbyte+length;i++){
            if(i-startbyte <= length/2){
              inttemp=i-startbyte;
            } else {
              inttemp=length-i+startbyte;
            } 
            Serial.print("[");
            if (i-startbyte==length/2) Serial.print("#");
            else Serial.print("+");
            Serial.print(i);
            Serial.print("] (");
            Serial.print(Values[i]);
            Serial.print(")");
            Serial.print("\t inttemp:");
            Serial.print(inttemp);
            Serial.print("\t powered:");         
            floattemp2=pow(2,inttemp);
            Serial.print(floattemp2);
            Serial.println();
            floattemp = floattemp + float(Values[i])*floattemp2/divisor;
         
          }
         
          Serial.print("Values2[");
          Serial.print(startbyte+length/2);
          Serial.print("] = ");
          Serial.println(byte(floattemp));
         
          Values2[startbyte+length/2] = byte(floattemp);
         
         
          Serial.println();
          result=false;
        }
      } 
    }
  }
 
 
 
  for (int i=0; i<=255; i++){
    if (Values2[i] == 0x00 & Values[i] != 0x00 ) Values2[i]=Values[i];
  }

  Serial.println("final Data:");
  Serial.print("byte Values2[256] = {");   
  for (int i=0; i<=255; i++){
    Serial.print(Values2[i]);
    if (i!=255) Serial.print(",");
  }
  Serial.println("};");
 
 
}

Die Funktion "LEDaction()" vergleicht die Werte, entscheidet im konkreten Fall ob Licht angeschaltet werden soll und schreibt ggf. aktuelle Werte ins array Measurement[], und habe ich zwischenzeitlich "entsorgt".
Spielt für die hin- und herrechnerei gerade keine Rolle, solange genügend Werte in Measurement[] (händisch) definiert sind.

füttert man die Ergebnisse dieses Sketches in eine Tabellenkalkulation, so ergibt sich eine Wertereihe wie in der angehängten Grafik dargestellt. die rote Linie beschreibt die Eingangs-Messwerte, die grüne das Ergebniss nach der linearen Ergänzung der Messwerte und die lilane das Ergebiss nach der Glättung.
Hier erkennt man relativ schnell, dass Ausreisser der Messwertreihe (pos 237,215,169...) nicht ausreichend erkannt und kompensiert werden.  smiley-roll

es gibt noch zu tun, aber für den Anfang denke ich auf dem richtigen Weg zu sein, oder was meint Ihr?
3  International / Deutsch / Re: Wie glättet man am elegantesten eine Wertetabelle? on: January 11, 2013, 08:43:18 am
ein kleines update, nein, ein Zwischenstand smiley-wink


nachdem ich gestern ein wenig Zeit gefunden hatte, habe ich mich wieder mit meinen Wertetabellen und ein paar Formelbüchern eingegraben.
Die Tiefpassfilter-Idee habe ich wieder verworfen, denn wer weiss, ob eine Wertetabelle immer auf einen Tiefpass passt? smiley-wink Im aktuellen Fall wäre das eine Möglichkeit, aber wenn schon denn schon wollte ich es ein wenig universeller gestalten.

Mein derzeitiger Versuch: eine dreistufige Bearbeitung der Wertetabelle für die Messwerte und Generieren einer neuen Wertetabelle mit dem Rechenergebniss. Dadurch können die Messwerte im weiteren Verlauf über einen gleitenden Mittelwert (Messwert[n] = (Messwert[n] + neuerWert) / 2) korrigiert werden.
Achja, ich sprach von drei Stufen der Bearbeitung:
  • Messfehler ermitteln. Derzeit wird über eine feste Breite um jeden Messwert der Durchschnittswert ermittelt und mit dem jeweiligen Messwert verglichen. Liegen in diesem Bereich nicht vollständige Messdaten vor wird abgeborchen, dadurch liefert diese Analyse leider nur bei sehr vielen Messwerten akzeptable Ergebnisse. (verbesserungswürdig)
  • Auffüllen kleinerer Messwert-Lücken anhand einer linearen Ergänzung zwischen den zwei angrenzenden Messwerten. Ist der angrenzende Wert ein unentdeckter Messfehler führt das im weiteren Verlauf zu lustigen Effekten. Ich bin mir noch nicht sicher ob es ausreicht zu warten bis sich über erneute Messungen und die Mittelwert-Funktion der Fehler ausgleicht, oder ob eine Einbeziehung weiterer Werte in diese Funktion notwendig wird
  • Ein gleitender gewichteter Mittelwert über die Bereiche mit ausreichender Anzahl von (reellen oder generierten) Messwerten soll die ausgegebene Kennlinie weiter begradigen.

Der Sketch hierfür sieht wie folgt aus: Leider noch unkommentiert, aber die unsagbare Anzahl der Serial.print Befehle gibt sicherlich Aufschluss wenn ihn jemand nchvollziehen will smiley-wink
Teil 1:
Code:
#define LDRpin A0                      
#define PIRpin 3                      
#define LEDpin 5

#define LDRmin 0
#define LDRmax 1023

byte Measurement[256] = {255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,255,255,255,0,255,0,1,255,0,0,1,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,5,255,6,11,5,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,10,11,10,255,255,255,255,255,2,12,13,255,255,255,255,255,255,15,255,16,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,255,255,255,255,255,255,255,255,255,36,255,255,37,255,255,255,255,255,39,255,26,255,255,255,40,255,255,255,44,255,255,255,255,43,255,45,45,255,255,255,255,255,44,255,255,48,52,255,255,255,255,255,255,255,52,255,255,255,255,255,255,255,255,55,255,55,78,56,59,255,255,58,62,60,255,62,54,255,56,63,61,58,57,59,255,255,57,255,56,12,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255};

byte Values[256];
byte Values2[256];

byte MinDifference = 25;              

byte LDRold;                            
long MotionTimeout;                  
boolean MotionDetected = false;
boolean LED = false;
unsigned int MotionDuration = 2000;


void setup(){
  pinMode(LDRpin, INPUT);
  pinMode(LEDpin, HIGH);
  digitalWrite(LDRpin, HIGH);
  Serial.begin(9600);
  attachInterrupt(1, Motion, FALLING);
}

void loop(){
  //if (MotionDetected){  
  //  LEDaction();
  // }    
  
  if((long)(millis()-MotionTimeout)>=0 && LED){
    LED = false;
    digitalWrite(LEDpin, LED);
  }

  byte SerialCommand = Serial.read();
  
  if (SerialCommand == 'S'){
    Serial.println();
    Serial.println();
    Serial.println("Statistics:");
    Serial.println("-----------");
    Serial.println();
    for (int i=0; i<=255; i++){
      Serial.print("LDR Value (scaled): ");
      Serial.print(i);
      Serial.print("\t");
      Serial.print("  Measurement: ");
      Serial.print(Measurement[i]);
      Serial.print("\t");
      Serial.print("Values: ");
      Serial.print(Values[i]);
      Serial.print("\t");
      Serial.print("Values2: ");
      Serial.println(Values2[i]);
    }
  }
  
 
  if (SerialCommand == 'E'){
    Serial.println();
    Serial.println();
    Serial.println("Export:");
    Serial.println("-------");
    Serial.println();
    Serial.print("byte Measurement[256] = {");  
    for (int i=0; i<=255; i++){
      Serial.print(Measurement[i]);
      if (i!=255) Serial.print(",");
    }
    Serial.println("};");
  }
  
  if (SerialCommand == 'C'){
    calculate();
  }
      
  delay(100);
  
}



4  International / Deutsch / Re: Wie glättet man am elegantesten eine Wertetabelle? on: January 07, 2013, 05:39:52 pm
ich muss zugeben, diese Funktion bereitet mir noch ordentlich Kopfschmerzen.  Mathematik, die ich noch nicht so ganz nachvollziehen kann... aber ich hab es mir als Herausforderung gesetzt und bleibe dran. smiley-wink
Über den Wikipedia-link in dem Code bin ich auf Umwegen irgendwie noch über ein "gleitendes Binomialfilter" gestolpert. Nicht, dass ich das schon programmiert bekommen hätte, aber das sieht (zumindest auf den erklärenden Diagrammen) auch nicht so unpassend für mein Problem aus.

Eine "einfache" Bastelei am Wochenende beginnt nun wohl auszuarteten....  smiley-yell
5  Community / Exhibition / Gallery / OptiloaderBoard on: January 07, 2013, 04:22:20 pm
it just happened that i have blown up some ATMega328s on a Breadboard due to too high Voltage on the Input. Shame on me!
Looking over the mess, i recognized that one of the ATMega was still sort of working, but i have  destroyed digitalPin 0 (RX)...

Well, i have needed some new 328 with Bootloader, so i decided to build a Board around the "non-RX-Pin-328", dedicated to "burn" the Optiloader Bootloader to factory-new ATMega328s. Not that i would need it every day (hopefully  smiley-wink), but just for fun. It is based on the OptiLoader sketch which can be found here: https://github.com/WestfW/OptiLoader

the PCB has the dimensoins of an Arduino-PCB, but ist neither a Arduino-Clone nor a Shield.
It supports 5V Power Supply via USB-B or a USB2SERIAL compatible FTDI-Style 6pin header, which also allows Serial communication for monitoring.
If you solder in C1, the autoReset functionality for the 6pin header is enabled, which would even allow to upload a sketch to the Master ATMega via USB2SERIAL.
To support feedback during the progress without Serial Communication, i have added a Power-ON statusLED for the Master ant the Target, a ERROR-LED and one for each function called in the loop() of the OptiLoadersketch.
I have soldered a basic 28pin socket for the Target ATMega on my PCB, but there shoud be enough space to use a 28pin ZIF Socket smiley-wink.

If anyone is interested, i have attached the Eagle files. Feel free to use it, reproduce it or modify it, but it would be great if you leave some feedback smiley-wink

The Optiloader sketch needs to be a little bit modified inside the setup() and loop() in order to control the LEDs to something like the following:
Code:
void setup () {
  Serial.begin(19200); /* Initialize serial for status msgs */
  pinMode(13, OUTPUT); /* Blink the pin13 LED a few times */
  pulse(13,20);
  pinMode(A0, OUTPUT);
  pinMode(A1, OUTPUT);
  pinMode(A2, OUTPUT);
  pinMode(A3, OUTPUT);
  pinMode(A4, OUTPUT);
  pinMode(A5, OUTPUT);
}

void loop (void) {
  boolean error = false;
  fp("\nOptiLoader Bootstrap programmer.\n2011 by Bill Westfield (WestfW)\n\n");
  if (target_poweron()) { /* Turn on target power */
    do {
     if (!target_identify()){ /* Figure out what kind of CPU */
       error = true;
       break;
     } else digitalWrite(A5, HIGH);
     if (!target_findimage()){ /* look for an image */
       error = true;
       break;
     } else digitalWrite(A4, HIGH);
     if (!target_progfuses()){ /* get fuses ready to program */
       error = true;
       break;
     } else digitalWrite(A3, HIGH);
     if (!target_program()){ /* Program the image */
       error = true;
       break;
     } else digitalWrite(A2, HIGH);
      (void) target_normfuses(); /* reset fuses to normal mode */
      digitalWrite(A1, HIGH);
   }
   while (0);
  }
  else {
   error = true;
   Serial.println();
  }
 target_poweroff(); /* turn power off */

  digitalWrite(A0, error);
  
  fp ("\nType 'G' or hit RESET for next chip\n")
    while (1) {
      if (Serial.read() == 'G'){
        digitalWrite(A5, LOW);
        digitalWrite(A4, LOW);
        digitalWrite(A3, LOW);
        digitalWrite(A2, LOW);
        digitalWrite(A1, LOW);
        digitalWrite(A0, LOW);
        break;
      }
    }
}

i know, the Hardware could be optimized. A polyfuse to protect the USB port would be nice. I think it would be not that bad to power the target 328 throug a transistor istead of the Master digital Pin 9, and the next time i would etch the PCB with bigger Pads for the Resistors , LEDs and Capacitors...  smiley-roll-blue
but after all... it is working!  smiley-cool
6  International / Deutsch / Re: Im Programm weiterschalten bei Flanke Low-High an Pin ? on: January 06, 2013, 02:58:58 pm
nur als Idee... Pin2 ist ja (zum Glück  smiley-wink ) ein Interrupt-Pin am 328. Kannst Du per attachInterrupt(0, aufzurufende_Funktion, RISING); eine Funktion aufrufen, die z.B. ein Flag setzt, das Du dann weiter verwenden kannst?
7  International / Deutsch / Re: Stromverbrauch Monitor on: January 06, 2013, 12:02:51 pm
Halleffektsensoren sind meines Wissens "Schalter", die auf ein Magnetfeld reagieren. So ganz fit bin ich da zugegebenermaßen auch nicht.
Jedoch werden Ströme in der Regel wenn berührungslos, dann induktiv gemessen. Kennst Du das OpenEnergyMonitor-Projekt? Ist vielleicht ein interessanter Ansatz für Dich!  smiley-wink
http://openenergymonitor.org/emon/
8  International / Deutsch / Wie glättet man am elegantesten eine Wertetabelle? on: January 06, 2013, 11:39:37 am
Hallo miteinander,

aus Neugierde wollte heute einen PIR-Bewegungsmelder bauen, der abhängig vom Umgebungslicht eine LED-Beleuchtung einschaltet. Im Laufe der zeit soll automatisch ermittelt werden, ab welcher Umgebungshelligkeit  es sich "lohnt" die Beleuchtung zu aktivieren.

Folgenden einfachen Ansatz habe ich dafür erstmal gewählt:
Ein Array mit 256 Bytes soll für unterschiedliche Helligkeitswerte (Umgebungslicht, von einem LDR ermittelt) die erreichte Helligkeitsdifferenz bei Zuschaltung  der Beleuchtung (erneute Messung per LDR kurz nach dem Einschalten) speichern.
Abhängig davon wird zukünftig entschieden, ob bei erneuter Bewegungserkennung ein Einschalten der Beleuchtung nötig ist oder nicht.

Das eigentliche Programm funktioniert soweit und spuckt mir nach einiger Zeit auch einige Daten aus. In der folgenden Tabelle ist das Werte-Array abgebildet. Jede Zeile entspricht einem Eintrag des Arrays, die erste Spalte ist das entsprechende Byte des Arrays, die zweite SPalte der Wert, wobei der Wert "255" für eine noch nicht ermittelte Differenz steht.
Code:
Statistics:
-----------

LDR Value (scaled): 0 Difference with LED: 255
LDR Value (scaled): 1 Difference with LED: 255
LDR Value (scaled): 2 Difference with LED: 255
LDR Value (scaled): 3 Difference with LED: 255
LDR Value (scaled): 4 Difference with LED: 0
LDR Value (scaled): 5 Difference with LED: 0
LDR Value (scaled): 6 Difference with LED: 1
LDR Value (scaled): 7 Difference with LED: 255
LDR Value (scaled): 8 Difference with LED: 1
LDR Value (scaled): 9 Difference with LED: 0
LDR Value (scaled): 10 Difference with LED: 0
LDR Value (scaled): 11 Difference with LED: 0
LDR Value (scaled): 12 Difference with LED: 255
LDR Value (scaled): 13 Difference with LED: 0
LDR Value (scaled): 14 Difference with LED: 0
LDR Value (scaled): 15 Difference with LED: 255
LDR Value (scaled): 16 Difference with LED: 255
LDR Value (scaled): 17 Difference with LED: 255
LDR Value (scaled): 18 Difference with LED: 255
LDR Value (scaled): 19 Difference with LED: 3
LDR Value (scaled): 20 Difference with LED: 255
LDR Value (scaled): 21 Difference with LED: 255
LDR Value (scaled): 22 Difference with LED: 255
LDR Value (scaled): 23 Difference with LED: 255
LDR Value (scaled): 24 Difference with LED: 255
LDR Value (scaled): 25 Difference with LED: 255
LDR Value (scaled): 26 Difference with LED: 255
LDR Value (scaled): 27 Difference with LED: 255
LDR Value (scaled): 28 Difference with LED: 255
LDR Value (scaled): 29 Difference with LED: 255
LDR Value (scaled): 30 Difference with LED: 11                   <<< ein leichter Ausreisser
LDR Value (scaled): 31 Difference with LED: 255
LDR Value (scaled): 32 Difference with LED: 255
LDR Value (scaled): 33 Difference with LED: 255
LDR Value (scaled): 34 Difference with LED: 255
LDR Value (scaled): 35 Difference with LED: 255
LDR Value (scaled): 36 Difference with LED: 1
LDR Value (scaled): 37 Difference with LED: 1
LDR Value (scaled): 38 Difference with LED: 1
LDR Value (scaled): 39 Difference with LED: 3
LDR Value (scaled): 40 Difference with LED: 1
LDR Value (scaled): 41 Difference with LED: 3
LDR Value (scaled): 42 Difference with LED: 255
LDR Value (scaled): 43 Difference with LED: 1
LDR Value (scaled): 44 Difference with LED: 255
LDR Value (scaled): 45 Difference with LED: 4
LDR Value (scaled): 46 Difference with LED: 2
LDR Value (scaled): 47 Difference with LED: 0                 <<< beeinflussung des LDR durch Abschattung
LDR Value (scaled): 48 Difference with LED: 4
LDR Value (scaled): 49 Difference with LED: 4
LDR Value (scaled): 50 Difference with LED: 3
LDR Value (scaled): 51 Difference with LED: 3
LDR Value (scaled): 52 Difference with LED: 4
LDR Value (scaled): 53 Difference with LED: 7
LDR Value (scaled): 54 Difference with LED: 255
LDR Value (scaled): 55 Difference with LED: 255
LDR Value (scaled): 56 Difference with LED: 255
LDR Value (scaled): 57 Difference with LED: 255
LDR Value (scaled): 58 Difference with LED: 255
LDR Value (scaled): 59 Difference with LED: 255
LDR Value (scaled): 60 Difference with LED: 255
LDR Value (scaled): 61 Difference with LED: 255
LDR Value (scaled): 62 Difference with LED: 5
LDR Value (scaled): 63 Difference with LED: 255
LDR Value (scaled): 64 Difference with LED: 3
LDR Value (scaled): 65 Difference with LED: 5
LDR Value (scaled): 66 Difference with LED: 6
LDR Value (scaled): 67 Difference with LED: 5
LDR Value (scaled): 68 Difference with LED: 6
LDR Value (scaled): 69 Difference with LED: 255
LDR Value (scaled): 70 Difference with LED: 8
LDR Value (scaled): 71 Difference with LED: 255
LDR Value (scaled): 72 Difference with LED: 7
LDR Value (scaled): 73 Difference with LED: 6
LDR Value (scaled): 74 Difference with LED: 6
LDR Value (scaled): 75 Difference with LED: 7
LDR Value (scaled): 76 Difference with LED: 7
LDR Value (scaled): 77 Difference with LED: 8
LDR Value (scaled): 78 Difference with LED: 8
LDR Value (scaled): 79 Difference with LED: 8
LDR Value (scaled): 80 Difference with LED: 10
LDR Value (scaled): 81 Difference with LED: 255
LDR Value (scaled): 82 Difference with LED: 11
LDR Value (scaled): 83 Difference with LED: 255
LDR Value (scaled): 84 Difference with LED: 255
LDR Value (scaled): 85 Difference with LED: 255
LDR Value (scaled): 86 Difference with LED: 15
LDR Value (scaled): 87 Difference with LED: 255
LDR Value (scaled): 88 Difference with LED: 255
LDR Value (scaled): 89 Difference with LED: 255
LDR Value (scaled): 90 Difference with LED: 255
LDR Value (scaled): 91 Difference with LED: 255
LDR Value (scaled): 92 Difference with LED: 22
LDR Value (scaled): 93 Difference with LED: 255
LDR Value (scaled): 94 Difference with LED: 255
LDR Value (scaled): 95 Difference with LED: 255
LDR Value (scaled): 96 Difference with LED: 255
LDR Value (scaled): 97 Difference with LED: 255
LDR Value (scaled): 98 Difference with LED: 255
LDR Value (scaled): 99 Difference with LED: 255

wenn man sich die Werte so betrachtet, dann stellt man schnell eine gewisse Regemässigkeit fest (der Übesichtlichkeit halber habe ich nur die ersten der insgesamt 256 Zeilen eingefügt).

Ich suche nun verzweifelt nach einem Ansatz wie man diese Wertetabelle durch Interpolation am elegantesten vervollständigen kann, ohne für jeden Helligkeitswert eine reelle Messung vornehmen zu müssen. Ideal wäre auch eine gewisse Glättung, die einzelne Ausreisser beseitigen könnte.
Vielleicht hat jemand die zündende Idee, oder sogar einen link zu nem Lösungsansatz parat  smiley-wink
Pages: [1]