How to get most accurate readings from photoresistors

krwawy_hegemon · August 12, 2024, 3:29pm

Hello
For some reasons I have build device to measure clinginess of U-shaped Pipes.
There are two mounts for pipe ends.
In one there is couple connected photoresistors.
In second there are RGB LEDs and another set of photoresistors installed in this way that light from LED can hit photoresistor only after reflecting from pipe inside.
No external light reaches photoresistors.

Arduino is powered from good quality 9V stabilized transistor power generator thru barrel port.
LEDs (circular adafriut) are powered from 5V power supply board (I have bridged two channel from one board and put big capacitor, so two 5V power regulators are created stable 5V for LEDs ) Power supply board is powered by second good quality 9V stabilized transistor power generator thru barrel port.

Photoresistors connect analog inputs to GND. Analog inputs are also connected to pul up outputs, so when high intensity light reaches photoresistors, more V is drained to GND and readings are lowered

When device is working first Pipe calibrator is connected to ports, and calibration measurements are collected. Measurements are compared with measurements from the same pipe written in program, and calibration factors are generated.
Measurements in each condition (color and intensity) are performed as a mean from many readings.
After 10 min calibration Pipe is replaced with pipe for measurement and similar measurements are performed.
Calibrated and Raw data are printed thru serial port

My problem is that in series of measurements I don’t receive the same readings.
After turning on and first readings i see increase in signal. I Conclude that maybe LEDs temperature is increasing so I have put delays between readings, and readings series. Also, I have put initial couple minute of light to warm up. But I was unable to receive the same signal each time after turning on.
Table from couple series of measurement show that standard deviation is bellow 1% of arithmetic mean.
Are some ways to increase accuracy?
Do is possible to have better accuracy with Arduino?
Does external reference V can perform better than internal Arduinos?

White 100% Raw Raw
Test Sensor 1 Sensor 2
1 703,45 765,95
2 708,1 769,35
3 709,75 771,2
4 710 772,25
5 710,5 773,2
6 710 768
7 716,9 774,05
8 719,25 777
9 712,2 772,1
10 713,75 774,1
11 715,25 777,1
12 715,8 777,9
13 701,35 769,25
14 704,75 772,2
15 707,9 774,15
16 710,45 775,2
17 711,65 776,1
18 711,75 776,2
Mean 710,7111 773,0722
SD 4,6 3,4

SD % Mean 0,650884 0,435204

My coding skils are low and i would like to not cause stroke to any one who will try to read it. But i se that code is working as i intend it to do.

I am looking for best practice to achieve moust accurate voltage readings.

I would be greatfull for help


#include <EEPROM.h>
#include <Adafruit_NeoPixel.h>

#define LED_PIN 6
#define LED_COUNT 8
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

int probeTime = 30000; // Time of lighting between measurments cycles Czas świecenia między cyklami pomiarów // Po testach ustaw 30000 After tests should be 30000
int probingDelay = 100; // Czas zwłoki między poszczególnymi pomiarami do średniej. Time of delay between specyfic measurments to mean
int CIC = 30000; // czas chłodzenia między cyklami pomiarów (zmianami intensywności) Po testach ustaw na 30000. Time of cooling between measurments cycles (intensitivity changes) After tests should be 30000
int buttonState = 0;
int buttonPin = 36;
int sensor = A0; 
int sensor2 = A10; 
int sensorPower = 1; 
int sensorPower2 = 10; 
int LEDReady = 5;
int LEDPomiar = 18;
int warmUpDetector = 2;
int warmUpEmiter = 9;
int warmUpPause  = 5;



int numbersOfTests = 3;
int brightness[] = { 50, 75, 100};
int delayPower = 5000;
long coolingMinutes = 10; // Czas świecenia przed pomiarami. Time of lighting petween measurments
int probingSecunds = 2 ; // in secunds. Czas zbierania pomiarów do średniej. Time of taking measurments for mean
      int numReadings = 0;
      float numforDividion;
      long total1 = 0;              // the running total1
      float average1 = 0;            // the average1
      long total2 = 0;              // the running total2
      float average2 = 0;            // the average2
      long totalLight = 0;              // the running total Light
      float averageLight = 0;            // the average Light
      long totalDark = 0;              // the running total Dark
      float averageDark = 0;            // the average Dark

//SEKCJA DANYCH Data section-------------------------------------------------------------------------------------------------------------------------------------------------
int kolor ; // 1 = Red ; 2 = Green ; 3 = Blue ; 4 = White
int procent ; 

float RedNormaEmi[] = {966.65 , 940.20 , 917.25 } ;
float GreenNormaEmi[] = {978.25 , 963.75 , 949.05} ;
float BlueNormaEmi[] = {986.15 , 976.60 , 967.70} ;
float WhiteNormaEmi[] = {887.50 , 846.85 , 814.00} ;

float RedNormaDet[] = {898.65 , 844.20 , 795.35 } ;
float GreenNormaDet[] = {967.75 , 946.95 , 925.65} ;
float BlueNormaDet[] = {986.10 , 974.40 , 962.00} ;
float WhiteNormaDet[] = {815.25 , 740.35 , 686.25} ;

float darkKorekta = 1.00;
float lightKorekta = 1.00;

float darkDane = 1012.00;
float lightDane = 14.00;


float RedKorektaEmi[3] ;
float GreenKorektaEmi[3] ;
float BlueKorektaEmi[3] ;
float WhiteKorektaEmi[3] ;

float RedDaneEmi[3] ;
float GreenDaneEmi[3] ;
float BlueDaneEmi[3] ;
float WhiteDaneEmi[3] ;

float RedKorektaDet[3] ;
float GreenKorektaDet[3] ;
float BlueKorektaDet[3] ;
float WhiteKorektaDet[3] ;

float RedDaneDet[3] ;
float GreenDaneDet[3] ;
float BlueDaneDet[3] ;
float WhiteDaneDet[3] ;

//Arrays to Epprom
int eeAddress = 0;
/*
float Red50[3] ;
float Red75[3] ;
float Red100[3] ;
float Green50[3] ;
float Green75[3] ;
float Green100[3] ;
float Blue50[3] ;
float Blue75[3] ;
float Blue100[3] ;
float White50[3] ;
float White75[3] ;
float White100[3] ;
*/
int arrayAdress = 0;
float eppromArray[48];
//Array to EPPROM



void setup() 
{
for (int i = 0; i <= numbersOfTests; i ++)
  {
    RedKorektaEmi[i] = 1;
    GreenKorektaEmi[i] = 1;
    BlueKorektaEmi[i] = 1;
    WhiteKorektaEmi[i] = 1;

    RedKorektaDet[i] = 1;
    GreenKorektaDet[i] = 1;
    BlueKorektaDet[i] = 1;
    WhiteKorektaDet[i] = 1;
  }

strip.begin();

Serial.begin(9600);
pinMode(sensorPower, OUTPUT);
pinMode(sensorPower2, OUTPUT);
pinMode(sensor, INPUT);
pinMode(sensor2, INPUT_PULLUP);
/* Te komendy spowodują że na pin analogowy podane będzie GND i widoczny będzie odczyt minimalny. These comend caus that on aanalog 
pinMode(warmUpDetector, OUTPUT); 
pinMode(warmUpEmiter, OUTPUT);
*/
pinMode(buttonPin, INPUT_PULLUP);
digitalWrite(sensorPower, LOW); // Zasilanie detektora
digitalWrite(sensorPower2, LOW);
pinMode(LEDReady, OUTPUT);
pinMode(LEDPomiar, OUTPUT);
digitalWrite(LEDReady, HIGH);
digitalWrite(LEDPomiar, LOW);

numReadings = probingSecunds * 1000 / probingDelay ;
numforDividion = numReadings;
//Serial.println(numReadings); //do debugowania


}

void loop() 
{

strip.clear();
strip.show();


if (digitalRead(buttonPin) == 0)
  
  
  
  {
    buttonState = 1;

  }

if (buttonState == 1)
    {

    printEEPROM();

    Serial.println("Kalibracja w toku.....................................................");
    digitalWrite(LEDReady, HIGH);
    digitalWrite(LEDPomiar, HIGH);
    blankCalibration(); //wyłączone z powodu niepoprawności użycia dwóch metod kalibracji na raz. Wyłączona kalibracja ale zczytywanie parametrów pozostawione. Blank callibration omited
    cooling(HIGH, LOW);
    digitalWrite(LEDReady, LOW);
    digitalWrite(LEDPomiar, LOW);
    FRedCal();
    FGreenCal();
    FBlueCal();
    FWhiteCal();
    Dane();
    digitalWrite(LEDPomiar, HIGH);
    digitalWrite(LEDReady, HIGH);
    Serial.println();
    Serial.println("Kalibracja kompletna. Zdemontuj kalibrator. Zamontuj element do pomiaru.......");
    cooling(LOW, HIGH);
    digitalWrite(LEDReady, LOW);
    digitalWrite(LEDPomiar, HIGH);
    Serial.println("Pomiary w toku.....................................................");
    Serial.println("Kolor  ; Intensywnosc  ;  Det/Cal ;  Deat/Raw  ;  Emi/Cal ;  Emi/Raw");
    FRed();
    FGreen();
    FBlue();
    FWhite();
    writeEEPROM();
    arrayAdress = 0;
    buttonState = 0;
    digitalWrite(LEDPomiar, LOW);
    digitalWrite(LEDReady, HIGH);
    }

}

void cooling(int i, int blinking)
  {
    int bri ;
    if (i == HIGH)
    {
    bri = 255;
    }
    if(i == LOW)
    {
    bri = 0;
    }

    strip.setPixelColor(0, bri, bri, bri);
    strip.setPixelColor(1, bri, bri, bri);
    strip.setPixelColor(2, bri, bri, bri);
    strip.setPixelColor(3, bri, bri, bri);
    strip.setPixelColor(4, bri, bri, bri);
    strip.setPixelColor(5, bri, bri, bri);
    strip.setPixelColor(6, bri, bri, bri);
    strip.setPixelColor(7, bri, bri, bri);
    strip.show();
   // Serial.println(coolingMinutes * 1000 * 60);
   if(blinking == HIGH)
    {
    int blinks = coolingMinutes*1000*60/500;
    for (int i = 0; i <= blinks; i ++)
    {
    digitalWrite(LEDPomiar, HIGH);
    digitalWrite(LEDReady, HIGH);
    delay(250);
    digitalWrite(LEDPomiar, LOW);
    digitalWrite(LEDReady, LOW);
    delay(250);
    }
    }
   else
    {
    delay(coolingMinutes * 1000 * 60);
    }
  }



void FRed()
  {
    kolor = 1;
for (int i = 0; i < numbersOfTests; i ++)
    {
    int bri = 255 * brightness[i] / 100;
    strip.setPixelColor(0, bri, 0, 0);
    strip.setPixelColor(1, bri, 0, 0);
    strip.setPixelColor(2, bri, 0, 0);
    strip.setPixelColor(3, bri, 0, 0);
    strip.setPixelColor(4, bri, 0, 0);
    strip.setPixelColor(5, bri, 0, 0);
    strip.setPixelColor(6, bri, 0, 0);
    strip.setPixelColor(7, bri, 0, 0);
    strip.show();
    delay(probeTime);
    Serial.print("Red ");
    Serial.print(brightness[i]);
    Serial.print("% ");
    assay(i);
    }
    kolor = 0;
  }

void FGreen()
  {
    kolor = 2;
for (int i = 0; i < numbersOfTests; i ++)
    {
    int bri = 255 * brightness[i] / 100;
    strip.setPixelColor(0, 0, bri, 0);
    strip.setPixelColor(1, 0, bri, 0);
    strip.setPixelColor(2, 0, bri, 0);
    strip.setPixelColor(3, 0, bri, 0);
    strip.setPixelColor(4, 0, bri, 0);
    strip.setPixelColor(5, 0, bri, 0);
    strip.setPixelColor(6, 0, bri, 0);
    strip.setPixelColor(7, 0, bri, 0);
    strip.show();
    delay(probeTime);
    Serial.print("Green ");
    Serial.print(brightness[i]);
    Serial.print("% ");
    assay(i);
    }
    kolor = 0;
    }
void FBlue()
  {
    kolor = 3;
for (int i = 0; i < numbersOfTests; i ++)
    {
    int bri = 255 * brightness[i] / 100;
    strip.setPixelColor(0, 0, 0, bri);
    strip.setPixelColor(1, 0, 0, bri);
    strip.setPixelColor(2, 0, 0, bri);
    strip.setPixelColor(3, 0, 0, bri);
    strip.setPixelColor(4, 0, 0, bri);
    strip.setPixelColor(5, 0, 0, bri);
    strip.setPixelColor(6, 0, 0, bri);
    strip.setPixelColor(7, 0, 0, bri);
    strip.show();
    delay(probeTime);
    Serial.print("Blue ");
    Serial.print(brightness[i]);
    Serial.print("% ");
    assay(i);
    }
    kolor = 0;
    }
void FWhite()
  {
    kolor = 4;
for (int i = 0; i < numbersOfTests; i ++)
    {
    int bri = 255 * brightness[i] / 100;
    strip.setPixelColor(0, bri, bri, bri);
    strip.setPixelColor(1, bri, bri, bri);
    strip.setPixelColor(2, bri, bri, bri);
    strip.setPixelColor(3, bri, bri, bri);
    strip.setPixelColor(4, bri, bri, bri);
    strip.setPixelColor(5, bri, bri, bri);
    strip.setPixelColor(6, bri, bri, bri);
    strip.setPixelColor(7, bri, bri, bri);
    strip.show();
    delay(probeTime);
    Serial.print("White ");
    Serial.print(brightness[i]);
    Serial.print("% ");
    assay(i);
    }
    kolor = 0;
    }

  void assay(int procent)
    {
    //digitalWrite(sensorPower, LOW);// JEśli działa INPUT_PULLUP na sensorze to powinno był LOW When input pullup on sensot these should be low
    pinMode(sensor2, INPUT_PULLUP);
    digitalWrite(warmUpDetector, HIGH);
    pinMode(warmUpDetector, OUTPUT);
    delay(delayPower);



    pinMode(warmUpDetector, INPUT);
    digitalWrite(warmUpDetector, LOW);
    delay(warmUpPause);

    total1 = 0.00;

    average1 = 0.00;

        for (int i = numReadings; i > 0; i-- )
        {
          float analogR = analogRead(sensor2);
        total1 = total1 + analogR;

        delay(probingDelay);
        }
        
    average1 = total1 / numforDividion;
    //digitalWrite(sensorPower, LOW);
    pinMode(sensor2, INPUT);
    pinMode(sensor, INPUT_PULLUP);
    digitalWrite(warmUpEmiter, HIGH);
    pinMode(warmUpEmiter, OUTPUT);
    delay(delayPower);



    pinMode(warmUpEmiter, INPUT);
    digitalWrite(warmUpEmiter, LOW);
    delay(warmUpPause);

    total2 = 0.00;

    average2 = 0.00;

        for (int i = numReadings; i > 0; i-- )
        {
          float analogR = analogRead(sensor);
        total2 = total2 + analogR;

        delay(probingDelay);
        }
        
    average2 = total2 / numforDividion;
    int line = 0;
    pinMode(sensor, INPUT);
    if (kolor == 1)
        {

          Serial.print(average1 / RedKorektaDet[procent]/darkKorekta);
          Serial.print(" ") ;
          Serial.print(average1);
          Serial.print(" ") ;
          Serial.print(average2 / RedKorektaEmi[procent]/darkKorekta);
          Serial.print(" ") ;
          Serial.println(average2);

          switch (procent) 
          {
          case 0:
          eppromArray[arrayAdress] = average1 / RedKorektaDet[procent]/darkKorekta; 
          arrayAdress++;
          eppromArray[arrayAdress] = average1 ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2 / RedKorektaEmi[procent]/darkKorekta ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2  ; 
          arrayAdress++;
          break;
          case 1:
          eppromArray[arrayAdress] = average1 / RedKorektaDet[procent]/darkKorekta; 
          arrayAdress++;
          eppromArray[arrayAdress] = average1 ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2 / RedKorektaEmi[procent]/darkKorekta ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2  ; 
          arrayAdress++;
          break;
          case 2:
          eppromArray[arrayAdress] = average1 / RedKorektaDet[procent]/darkKorekta; 
          arrayAdress++;
          eppromArray[arrayAdress] = average1 ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2 / RedKorektaEmi[procent]/darkKorekta ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2  ; 
          arrayAdress++;
          break;
          }

        }
    else if (kolor == 2)
        {

          Serial.print(average1 / GreenKorektaDet[procent]/darkKorekta); 
          Serial.print(" ") ;
          Serial.print(average1); 
          Serial.print(" ") ; 
          Serial.print(average2 / GreenKorektaEmi[procent]/darkKorekta); 
          Serial.print(" ") ; 
          Serial.println(average2);
          
          switch (procent) 
          {
          case 0:
          eppromArray[arrayAdress] = average1 / GreenKorektaDet[procent]/darkKorekta; 
          arrayAdress++;
          eppromArray[arrayAdress] = average1 ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2 / GreenKorektaEmi[procent]/darkKorekta ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2  ; 
          arrayAdress++;
          break;
          case 1:
          eppromArray[arrayAdress] = average1 / GreenKorektaDet[procent]/darkKorekta; 
          arrayAdress++;
          eppromArray[arrayAdress] = average1 ; 
          arrayAdress++;
          eppromArray[arrayAdress]= average2 / GreenKorektaEmi[procent]/darkKorekta ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2  ; 
          arrayAdress++;
          break;
          case 2:
          eppromArray[arrayAdress] = average1 / GreenKorektaDet[procent]/darkKorekta; 
          arrayAdress++;
          eppromArray[arrayAdress] = average1 ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2 / GreenKorektaEmi[procent]/darkKorekta ; 
          arrayAdress++;
          eppromArray[arrayAdress]= average2  ; 
          arrayAdress++;
          break;
          }

        }
    else if (kolor == 3)
        {
          Serial.print(average1 / BlueKorektaDet[procent]/darkKorekta); 
          Serial.print(" ") ; 
          Serial.print(average1); 
          Serial.print(" ") ; 
          Serial.print(average2 / BlueKorektaEmi[procent]/darkKorekta); 
          Serial.print(" ") ; 
          Serial.println(average2);


          switch (procent) 
          {
          case 0:
          eppromArray[arrayAdress] = average1 / BlueKorektaDet[procent]/darkKorekta; 
          arrayAdress++;
          eppromArray[arrayAdress] = average1 ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2 / BlueKorektaEmi[procent]/darkKorekta ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2  ; 
          arrayAdress++;
          break;
          case 1:
          eppromArray[arrayAdress]= average1 / BlueKorektaDet[procent]/darkKorekta; 
          arrayAdress++;
          eppromArray[arrayAdress] = average1 ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2 / BlueKorektaEmi[procent]/darkKorekta ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2  ; 
          arrayAdress++;
          break;
          case 2:
          eppromArray[arrayAdress] = average1 / BlueKorektaDet[procent]/darkKorekta; 
          arrayAdress++;
          eppromArray[arrayAdress] = average1 ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2 / BlueKorektaEmi[procent]/darkKorekta ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2  ; 
          arrayAdress++;
          break;
          }

        }   
    else if (kolor == 4)
        {
          Serial.print(average1 / WhiteKorektaDet[procent]/darkKorekta); 
          Serial.print(" ") ; 
          Serial.print(average1); 
          Serial.print(" ") ; 
          Serial.print(average2 / WhiteKorektaEmi[procent]/darkKorekta); 
          Serial.print(" ") ; 
          Serial.println(average2);

          switch (procent) 
          {
          case 0:
          eppromArray[arrayAdress] = average1 / WhiteKorektaDet[procent]/darkKorekta; 
          arrayAdress++;
          eppromArray[arrayAdress] = average1 ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2 / WhiteKorektaEmi[procent]/darkKorekta ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2  ; 
          arrayAdress++;
          break;
          case 1:
          eppromArray[arrayAdress] = average1 / WhiteKorektaDet[procent]/darkKorekta; 
          arrayAdress++;
          eppromArray[arrayAdress] = average1 ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2 / WhiteKorektaEmi[procent]/darkKorekta ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2  ; 
          arrayAdress++;
          break;
          case 2:
          eppromArray[arrayAdress] = average1 / WhiteKorektaDet[procent]/darkKorekta; 
          arrayAdress++;
          eppromArray[arrayAdress] = average1 ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2 / WhiteKorektaEmi[procent]/darkKorekta ; 
          arrayAdress++;
          eppromArray[arrayAdress] = average2  ; 
          arrayAdress++;
          break;
          }

        }   
    else if (kolor == 0)
        {
          Serial.println("Kolor = 0 Error");
        }



strip.clear();
strip.show();


    delay(CIC);

    }

// funkcja kalibracji ciemności dark callibration function...............................................................................................................................................................................
void blankCalibration()
    {
    strip.clear();
    strip.show();
    pinMode(sensor2, INPUT_PULLUP);
    pinMode(warmUpDetector, OUTPUT);
    digitalWrite(warmUpDetector, LOW);
    delay(delayPower);

    totalLight = 0.00;
    averageLight = 0.00;
        for (int i = numReadings; i > 0; i-- )
        {
        float analogR = analogRead(sensor2);
        totalLight = totalLight + analogR;
        delay(probingDelay);
        }
        
    averageLight = totalLight / numforDividion;

    digitalWrite(warmUpDetector, HIGH);
    delay(delayPower);

    totalDark = 0.00;
    averageDark = 0.00;
        for (int i = numReadings; i > 0; i-- )
        {
        float analogR = analogRead(sensor2);
        totalDark  = totalDark  + analogR;
        delay(probingDelay);
        }
        
    averageDark = totalDark  / numforDividion;

    pinMode(warmUpDetector, INPUT);
    digitalWrite(warmUpDetector, LOW);
    delay(warmUpPause);
    pinMode(sensor2, INPUT);
    
    //darkKorekta = averageDark / darkDane;
    //lightKorekta = averageLight / lightDane;

    Serial.print("Odczyt ciemnosci: ");
    Serial.print(averageDark);
    Serial.println();
    //Serial.print("Kalibracja ciemnosci: ");
   // Serial.print(darkKorekta);
    Serial.println();
    Serial.print("Odczyt jasnosci: ");
    Serial.print(averageLight);
    Serial.println();
    //Serial.print("Kalibracja jasnosci: ");
   // Serial.print(lightKorekta);
    Serial.println();


    }

//Funkcja kalibracji jasności Lihgt callibration Function...............................................................................................................................................................................

void calibration(int procent)
    {
    digitalWrite(sensorPower, LOW);      
    pinMode(sensor, INPUT_PULLUP);
    digitalWrite(warmUpEmiter, HIGH);
    pinMode(warmUpEmiter, OUTPUT);
    delay(delayPower);
    pinMode(warmUpEmiter, INPUT);
    digitalWrite(warmUpEmiter, LOW);
    delay(warmUpPause);
    total2 = 0.00;

    average2 = 0.00;

        for (int i = numReadings; i > 0; i-- )
        {
        float analogR = analogRead(sensor);
        total2 = total2 + analogR;

        delay(probingDelay);
        }
        
    average2 = total2 / numforDividion;
    pinMode(sensor, INPUT);
    

    digitalWrite(sensorPower2, LOW);      
    pinMode(sensor2, INPUT_PULLUP);
    digitalWrite(warmUpDetector, HIGH);
    pinMode(warmUpDetector, OUTPUT);
    delay(delayPower);
    pinMode(warmUpDetector, INPUT);
    digitalWrite(warmUpDetector, LOW);
    delay(warmUpPause);
    total1 = 0.00;

    average1 = 0.00;

        for (int i = numReadings; i > 0; i-- )
        {
        float analogR = analogRead(sensor2);
        total1 = total1 + analogR;

        delay(probingDelay);
        }
        
    average1 = total1 / numforDividion;
    pinMode(sensor2, INPUT);

    Serial.print("EmiterRaw :");
    Serial.print(average2);
    Serial.print(" ");
    Serial.print("EmiterCorrectionFactor:");
    Serial.print(" ");

    if (kolor == 1)
        {
          RedKorektaEmi[procent] = RedNormaEmi[procent] / average2 ;
          Serial.print(RedKorektaEmi[procent]);
          RedDaneEmi[procent] = average2 ;
        }
    else if (kolor == 2)
        {
          GreenKorektaEmi[procent] = GreenNormaEmi[procent] / average2 ;
          Serial.print(GreenKorektaEmi[procent]);
          GreenDaneEmi[procent] = average2 ;
        }
    else if (kolor == 3)
        {
          BlueKorektaEmi[procent] = BlueNormaEmi[procent] / average2 ;
          Serial.print(BlueKorektaEmi[procent]);
          BlueDaneEmi[procent] = average2 ;
        }   
    else if (kolor == 4)
        {
          WhiteKorektaEmi[procent] = WhiteNormaEmi[procent] / average2 ;
          Serial.print(WhiteKorektaEmi[procent]);
          WhiteDaneEmi[procent] = average2 ;
        }   
    else if (kolor == 0)
        {
          Serial.println("Kolor = 0 Error");
        }

    Serial.print(" ");
    Serial.print("DetectorRaw :");
    Serial.print(average1);
    Serial.print(" ");
    Serial.print("DetectorCorrectionFactor:");
    Serial.print(" ");

    if (kolor == 1)
        {
          RedKorektaDet[procent] = RedNormaDet[procent] / average1 ;
          Serial.println(RedKorektaDet[procent]);
          RedDaneDet[procent] = average1 ;
        }
    else if (kolor == 2)
        {
          GreenKorektaDet[procent] = GreenNormaDet[procent] / average1 ;
          Serial.println(GreenKorektaDet[procent]);
          GreenDaneDet[procent] = average1 ;
        }
    else if (kolor == 3)
        {
          BlueKorektaDet[procent] = BlueNormaDet[procent] / average1 ;
          Serial.println(BlueKorektaDet[procent]);
          BlueDaneDet[procent] = average1 ;
        }   
    else if (kolor == 4)
        {
          WhiteKorektaDet[procent] = WhiteNormaDet[procent] / average1 ;
          Serial.println(WhiteKorektaDet[procent]);
          WhiteDaneDet[procent] = average1 ;
        }   
    else if (kolor == 0)
        {
          Serial.println("Kolor = 0 Error");
        }


strip.clear();
strip.show();


    delay(CIC);

    }

    void Dane()
    {

      Serial.println("Surowe odczyty rury kalibracyjnej:");
      Serial.println();
      Serial.println("RedEmiter");
      for (int i = 0; i < numbersOfTests; i++ )
          {

            Serial.print(RedDaneEmi[i]);
            Serial.print(" , ");
          }
      Serial.println();
      Serial.println("GreenEmiter");
      for (int i = 0; i < numbersOfTests; i++ )
          {

            Serial.print(GreenDaneEmi[i]);
            Serial.print(" , ");
          }
      Serial.println();
      Serial.println("BlueEmiter");
      for (int i = 0; i < numbersOfTests; i++ )
          {

            Serial.print(BlueDaneEmi[i]);
            Serial.print(" , ");
          }
      Serial.println();
      Serial.println("WhiteEmiter");
      for (int i = 0; i < numbersOfTests; i++ )
          {

            Serial.print(WhiteDaneEmi[i]);
            Serial.print(" , ");
          }
      Serial.println();
      Serial.println("RedDetector");
      for (int i = 0; i < numbersOfTests; i++ )
          {

            Serial.print(RedDaneDet[i]);
            Serial.print(" , ");
          }
      Serial.println();
      Serial.println("GreenDetector");
      for (int i = 0; i < numbersOfTests; i++ )
          {

            Serial.print(GreenDaneDet[i]);
            Serial.print(" , ");
          }
      Serial.println();
      Serial.println("BlueDetector");
      for (int i = 0; i < numbersOfTests; i++ )
          {

            Serial.print(BlueDaneDet[i]);
            Serial.print(" , ");
          }
      Serial.println();
      Serial.println("WhiteDetector");
      for (int i = 0; i < numbersOfTests; i++ )
          {

            Serial.print(WhiteDaneDet[i]);
            Serial.print(" , ");
          }

      // Wpisanie kalibracji jasności i ciemności...............................................................................................................................................................................
    }

    void FRedCal()
  {
    kolor = 1;
for (int i = 0; i < numbersOfTests; i ++)
    {
    int bri = 255 * brightness[i] / 100;
    strip.setPixelColor(0, bri, 0, 0);
    strip.setPixelColor(1, bri, 0, 0);
    strip.setPixelColor(2, bri, 0, 0);
    strip.setPixelColor(3, bri, 0, 0);
    strip.setPixelColor(4, bri, 0, 0);
    strip.setPixelColor(5, bri, 0, 0);
    strip.setPixelColor(6, bri, 0, 0);
    strip.setPixelColor(7, bri, 0, 0);
    strip.show();
    delay(probeTime);
    Serial.print("Red ");
    Serial.print(brightness[i]);
    Serial.print("% ");
    calibration(i);
    }
    kolor = 0;
  }


void FGreenCal()
  {
    kolor = 2;
for (int i = 0; i < numbersOfTests; i ++)
    {
    int bri = 255 * brightness[i] / 100;
    strip.setPixelColor(0, 0, bri, 0);
    strip.setPixelColor(1, 0, bri, 0);
    strip.setPixelColor(2, 0, bri, 0);
    strip.setPixelColor(3, 0, bri, 0);
    strip.setPixelColor(4, 0, bri, 0);
    strip.setPixelColor(5, 0, bri, 0);
    strip.setPixelColor(6, 0, bri, 0);
    strip.setPixelColor(7, 0, bri, 0);
    strip.show();
    delay(probeTime);
    Serial.print("Green ");
    Serial.print(brightness[i]);
    Serial.print("% ");
    calibration(i);
    }
    kolor = 0;
  }

void FBlueCal()
  {
    kolor = 3;
for (int i = 0; i < numbersOfTests; i ++)
    {
    int bri = 255 * brightness[i] / 100;
    strip.setPixelColor(0, 0, 0, bri);
    strip.setPixelColor(1, 0, 0, bri);
    strip.setPixelColor(2, 0, 0, bri);
    strip.setPixelColor(3, 0, 0, bri);
    strip.setPixelColor(4, 0, 0, bri);
    strip.setPixelColor(5, 0, 0, bri);
    strip.setPixelColor(6, 0, 0, bri);
    strip.setPixelColor(7, 0, 0, bri);
    strip.show();
    delay(probeTime);
    Serial.print("Blue ");
    Serial.print(brightness[i]);
    Serial.print("% ");
    calibration(i);
    }
    kolor = 0;
  }

    void FWhiteCal()
  {
    kolor = 4;
for (int i = 0; i < numbersOfTests; i ++)
    {
    int bri = 255 * brightness[i] / 100;
    strip.setPixelColor(0, bri, bri, bri);
    strip.setPixelColor(1, bri, bri, bri);
    strip.setPixelColor(2, bri, bri, bri);
    strip.setPixelColor(3, bri, bri, bri);
    strip.setPixelColor(4, bri, bri, bri);
    strip.setPixelColor(5, bri, bri, bri);
    strip.setPixelColor(6, bri, bri, bri);
    strip.setPixelColor(7, bri, bri, bri);
    strip.show();
    delay(probeTime);
    Serial.print("White ");
    Serial.print(brightness[i]);
    Serial.print("% ");
    calibration(i);
    }
    kolor = 0;
  }


void printEEPROM ()
  {
eeAddress = 0;
Serial.println("Wyniki poprzedniego pomiaru................................................................. ");
Serial.println();
Serial.print("Red 50% ");
readEEPROM();
Serial.print("Red 75% ");
readEEPROM();
Serial.print("Red 100% ");
readEEPROM();
Serial.print("Green 50% ");
readEEPROM();
Serial.print("Green 75% ");
readEEPROM();
Serial.print("Green 100% ");
readEEPROM();
Serial.print("Blue 50% ");
readEEPROM();
Serial.print("Blue 75% ");
readEEPROM();
Serial.print("Blue 100% ");
readEEPROM();
Serial.print("White 50% ");
readEEPROM();
Serial.print("White 75% ");
readEEPROM();
Serial.print("White 100% ");
readEEPROM();
Serial.println();
eeAddress = 0;
  }

  void writeEEPROM()
{

  for (int i = 0; i < 48; i++)
  {
    EEPROM.put(eeAddress, eppromArray[i]);
    eeAddress = eeAddress + 4;
  }
eeAddress = 0;
}
void readEEPROM()
{
  for (int i = 0; i < 4; i++)
  {
    float f = 0.0 ;
    EEPROM.get(eeAddress, f);
    Serial.print(f);
    eeAddress = eeAddress + 4;
    Serial.print(" ");
  }
 Serial.println();
}

krwawy_hegemon · August 12, 2024, 3:32pm

It is older Version. Now callibration pipe is U-shaped, and power supplies are better

jim-p · August 12, 2024, 3:41pm

Big mistake. An I/O pin is not a power source, nor is it a constant voltage.
Which arduino are you using?

Should be done like this:

krwawy_hegemon · August 12, 2024, 4:18pm

For this project i have used some clon of arduino Mega board.

So if internal pull up resistors are not providing stable voltage i can be reason of shift in signal.

What if i bridge vcc and analog input thru ceramic resistor?
Does readings will be more accurate?
Or i should conect separate voltage regulator with 9v power suply thru resistor to analog input?

jim-p · August 12, 2024, 4:20pm

I included a schematic in my last post, go back and look

ZX80 · August 12, 2024, 4:42pm

https://wp.optics.arizona.edu/mnofziger/wp-content/uploads/sites/31/2016/05/APP_PhotocellIntroduction.pdf

"All photoconductive cells exhibit a phenomenon known as hysteresis,
light memory, or light history effect. Simply stated, a photocell tends to
remember its most recent storage condition (light or dark) and its
instantaneous conductance is a function of its previous condition. The
magnitude of the light history effect depends upon the new light level,
and upon the time spent at each of these light levels. this effect is
reversible."

davidefa · August 12, 2024, 5:03pm

I would not use a photoresistor for this task.
There are lots of digital light sensor that, I think, are better suited.
Also don't like the idea of using these addressable leds, each has its own controller with his oscillator ( rc oscillator I bet. and independent of each other ), different frequencies, no synchronization between them.
I prefer the idea of 3 hardware pwm controlling the 3 chains of leds.

jim-p · August 12, 2024, 6:09pm

Beside the new circuit, you may want to make some changes to the code.

I'm not sure how you code works but photoresistors do have a relatively slow response time. The cheap GL55 series have a response time of about 30ms. So for an accurate reading, I would wait at least 100ms after the LEDs are turned ON before you do an analogRead and wait another 100ms after they are turned OFF.
You should also take several readings and take the average, that will help reduce the noise.

Topic		Replies	Views
Measure distances with a laser, a phototransistor and an Arduino Nano General Guidance	42	333	June 4, 2026
Ardutester il ritorno Hardware	27	332	April 10, 2026
Capacitor and Resistance Tester problem General Guidance	40	649	May 24, 2025
Extinction de radiateur en cas d'ouverture de porte Français	19	181	January 10, 2026
Voltage divider and floating voltage read General Guidance	59	2283	July 7, 2024

How to get most accurate readings from photoresistors

Related topics