#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128     // OLED display width, in pixels
#define SCREEN_HEIGHT 64     // OLED display height, in pixels
#define OLED_RESET -1        // Reset pin # (or -1 if sharing Arduino reset pin)
#define SCREEN_ADDRESS 0x3C  ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

#define analogPin      0          // analog pin for measuring capacitor voltage
#define chargePin      13         // pin to charge the capacitor - connected to one end of the charging resistor
#define dischargePin   11         // pin to discharge the capacitor
#define resistorValue  10000.0F   // change this to whatever resistor value you are using

unsigned long startTime;
unsigned long elapsedTime;
long microFarads;                // floating point variable to preserve precision, make calculations
long nanoFarads;

enum Scale {uf, nf};
//1uf (microfarad)=1000nf (nanofarad)
//unsigned int CommonValues[]={10,15,22,33,47,68,100,150,200,220,300,330,400,470,500,560,680,700,800,820,1000,1200,1500,1600,1800,2000,2100,2200,2400,2500,2700,3000,3300,3500,3600,3900,4000,4300,4700,5000,5300,5600,6000,6800,7200,7500,8200,8800,10000,10800,12000,12400,13000,14000,14500,15000,16100,17000,18000,18900,20000,21000,21600,22000,23000,23300,24000,24300,25000,27000,30000,32000,32400,33000,34000,35000,37000,37800,38000,39000,40000,42000,43000,45000,46000,47000,48000,50000,51000,52000,54000,55000,56000,59000,62000,64500,65000,68000,70000,70800,73000,80000,82000,85000,86000,100000,110000,120000,130000,140000,150000,160000,170000,180000,200000,210000,220000,250000,260000,270000,280000,290000,300000,310000,330000,340000,350000,360000,370000,390000,400000,410000,420000,430000,460000,470000,480000,500000};
unsigned int CommonValues[]={10,15,22,33,47,68,100,150,200,220,300,330,400,470,500,560,680,700,800,820,1000,1200,1500,1600,1800,2000,2100,2200,2400,2500,2700,3000,3300,3500,3600,3900,4000,4300,4700,5000,5300,5600,6000,6800,7200,7500,8200,8800,10000,10800,12000,12400,13000,14000,14500,15000,16100,17000,18000,18900,20000,21000,21600,22000,23000,23300,24000,24300,25000,27000,30000,32000,32400,33000,34000,35000,37000,37800,38000,39000,40000,42000,43000,45000,46000,47000,48000,50000,51000,52000,54000,55000,56000,59000,62000,64500,65000,68000,70000,70800,73000,80000,82000,85000,86000,100000,110000,120000,130000,140000};
float CommonValuesMultiplier=.01;
Scale CommonValues_Scale= nf;
int CommonValuesCount =sizeof CommonValues/sizeof CommonValues[0];
float Tolerance=0.2; //+-20%
float Actual_Value_nf;
float CommonValue_nf;
float Min=0;
float Max=0;

void setup()
{
  Serial.begin(9600); 
  pinMode(chargePin, OUTPUT);     // set chargePin to output
  digitalWrite(chargePin, LOW);
  Serial.println (CommonValues[0]); 
  // initialize serial transmission for debugging

  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) 
  {
      Serial.println(F("SSD1306 allocation failed"));
      for(;;); // Don't proceed, loop forever
  }
 
  // Show initial display buffer contents on the screen --
  // the library initializes this with an Adafruit splash screen.
  display.display();
  delay(2000); // Pause for 2 seconds

  // Clear the buffer
  display.clearDisplay();

  display.setTextSize(2);             // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE);        // Draw white text
  display.setCursor(0,0);             // Start at top-left corner
  display.println("System"); 
  display.println(" Ready..."); 
  display.display();
/*
label: 100uf
0 mS    0 microFarads
936 mS    93 microFarads
915 mS    91 microFarads
909 mS    90 microFarads
80 mS    8 microFarads
912 mS    91 microFarads
903 mS    90 microFarads
902 mS    90 microFarads
900 mS    90 microFarads
897 mS    89 microFarads
0 mS    0 microFarads
0 mS    0 microFarads

*/
 //312 microfarads

    Serial.begin(Get_LabelValue(93,uf));
        Serial.begin(Get_LabelValue(90,uf));
            Serial.begin(Get_LabelValue(91,uf));
                   //119 microfarads
                   //Get_LabelValue(119,uf);
//                   300µf
//320 T:62.4 min 257.6 max 382.4
//324 T:64.8  min 259.2 max 388.8
//330 T:66  min 264  max 396
                  // Get_LabelValue(312,uf);//312 microfarads

//label: 330
//registered values
//    221 microFarads
//   336 microFarads
//    227 microFarads
//   339 microFarads
//1123/4=280.75
//get the average???? ergo, if it isn't 0, add to array, if 0, then end array,

//take average then get computer label value
//330*0.2=66
//(66)+330=396
//330-66=264

//Get_LabelValue(5800,nf);
}

void loop()
{
  
  digitalWrite(chargePin, HIGH);  // set chargePin HIGH and capacitor charging
  startTime = millis();
  // 647 is 63.2% of 1023, which corresponds to full-scale voltage
  while(analogRead(analogPin) < 648){   }

  elapsedTime= millis() - startTime;

 // convert milliseconds to seconds ( 10^-3 ) and Farads to microFarads ( 10^6 ),  net 10^3 (1000)

  microFarads = ((float)elapsedTime / resistorValue) * 1000;
  Serial.print(elapsedTime);       // print the value to serial port
  Serial.print(" mS    ");         // print units and carriage return


//1uf=1000nf
//1 microfarad=1000 nanofarad
  if (microFarads > 1)
  {
    display.clearDisplay();
    display.setCursor(0,0);  
    display.println("Actual:"); 
    display.print(" ");
    display.print(microFarads); 
    display.println("uf"); 
    display.display();      
  }
  else
  {
    display.clearDisplay();
    display.setCursor(0,0);  
    // if value is smaller than one microFarad, convert to nanoFarads (10^-9 Farad).
    // This is  a workaround because Serial.print will not print floats
    nanoFarads = microFarads * 1000.0;      // multiply by 1000 to convert to nanoFarads (10^-9 Farads)
    if(nanoFarads>0)
    {      
      display.println("Actual:"); 
      display.print(" "); 
      display.print(nanoFarads); 
      display.println("nf");      
      display.display();
    }
    else
    {
      display.clearDisplay();
    } 
  }
  
  Serial.print((long)microFarads);       // print the value to serial port
  Serial.println(" microFarads"); 
    
  /* discharge the capacitor  */
  digitalWrite(chargePin, LOW);             // set charge pin to  LOW
  pinMode(dischargePin, OUTPUT);            // set discharge pin to output
  digitalWrite(dischargePin, LOW);          // set discharge pin LOW
  while(analogRead(analogPin) > 0){ }        // wait until capacitor is completely discharged

  pinMode(dischargePin, INPUT);            // set discharge pin back to input

   //display.println("Label Value:"); 
   //display.println(Get_LabelValue(microFarads,uf)); 
   //display.println("uf"); 

   delay(6000);
}

//1000nf (nanofarad)=1uf (microfarad)
 float Get_LabelValue(float Actual_Value,Scale scale)
  {
    if(Actual_Value == 0){return 0;}
    if(scale==nf) { Actual_Value_nf= Actual_Value * 1000; }else if(scale==uf) {Actual_Value_nf= Actual_Value;}else{ return 0;}

    for (int i=0; i<CommonValuesCount; i++) 
    {
      if(CommonValues_Scale==uf)
      { 
        CommonValue_nf=CommonValues[i]*1000; 
      }
      else if ( CommonValues_Scale==nf) 
      {
        CommonValue_nf=CommonValues[i]; 
      } 
      else 
      { 
        return 0;
      }
      
      CommonValue_nf=CommonValue_nf * CommonValuesMultiplier;
         
      Max=(CommonValue_nf + (Tolerance* CommonValue_nf));
      Min=CommonValue_nf - (Tolerance* CommonValue_nf);
          
      if(Actual_Value_nf>=Min && Actual_Value_nf<=Max)
      //if(Actual_Value_nf>=CommonValues[i] - (Tolerance* CommonValues[i]) && Actual_Value_nf<=(CommonValues[i] + (Tolerance* CommonValues[i])))
      {
        
        return CommonValue_nf * CommonValuesMultiplier;
      }   
    }
               Serial.print("LabelValue: UNKNOWN");
    return Actual_Value_nf;
 
  }