// ------------
// Blink an LED, Monitor Tank Level
// ------------

/*-------------

We've heavily commented this code for you. If you're a pro, feel free to ignore it.

Comments start with two slashes or are blocked off by a slash and a star.
You can read them, but your device can't.
It's like a secret message just for you.

Every program based on Wiring (programming language used by Arduino, and Particle devices) has two essential parts:
setup - runs once at the beginning of your program
loop - runs continuously over and over

You'll see how we use these in a second. 

This program will blink an led on and off every second.
It blinks the D7 LED on your Particle device. If you have an LED wired to D0, it will blink that LED as well.

-------------*/

//If used, this causes 
//SYSTEM_MODE(SEMI_AUTOMATIC)

// First, we're going to make some variables.
// This is our "shorthand" that we'll use throughout the program:

int led1 = D0; // Instead of writing D0 over and over again, we'll write led1
// You'll need to wire an LED to this one to see it blink.

int led2 = D7; // Instead of writing D7 over and over again, we'll write led2
// This one is the little blue LED on your board. On the Photon it is next to D7, and on the Core it is next to the USB jack.


//Fresh
int tnk1 = A7;
int tnk1empty = 640;
int tnk1full = 1315;

//Grey
/*
int tnk1 = A0;
//true empty at 594
int tnk1empty = 1040;
int tnk1full = 1493;
*/

//Precalculate difference between tank empty and full values
int tnk1diff = tnk1full - tnk1empty;

//String variable that will store the text uploaded to Particle servers.
char resultstr[64];

// Having declared these variables, let's move on to the setup function.
// The setup function is a standard part of any microcontroller program.
// It runs only once when the device boots up or is reset.



void setup() {

  // We are going to tell our device that D0 and D7 (which we named led1 and led2 respectively) are going to be output
  // (That means that we will be sending voltage to them, rather than monitoring voltage that comes from them)

  // It's important you do this here, inside the setup() function rather than outside it or in the loop function.

  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(tnk1, INPUT); // setup A0 as analog input

  //Set up a cloud variable that can be read on command
  Particle.variable("result", resultstr, STRING); 

}

// Next we have the loop function, the other essential part of a microcontroller program.
// This routine gets repeated over and over, as quickly as possible and as many times as possible, after the setup function is called.
// Note: Code that blocks for too long (like more than 5 seconds), can make weird things happen (like dropping the network connection).  The built-in delay function shown below safely interleaves required background activity, so arbitrarily long delays can safely be done if you need them.

void loop() {
    int data1 = analogRead(tnk1);
    
    double pctfull = float(data1-tnk1empty)/float(tnk1diff)*100.0;
  
  //"Print" string of data with raw analog reading and percentage full to resultstr, which is the cloud variable we set up in the setup function
  sprintf(resultstr, "{\"data1\":%d,\"tnk1\":%f}", data1, pctfull); 
  
  
  //If connected, publish data; if not, try to establish connection.  Note that the connect routine is blocking--it won't proceed until the connect attempt is either successful or fails.  This generally takes less than 10-15 seconds.
  /*
  if(Particle.connected()) {
      Particle.publish("tank1",String(pctfull) + "");
  } else {
      Particle.connect();
  }
 */
  
  
  //Cycle LED on then off with 1-second delays.  This is useful as a means of showing that the loop section of code is running (or continues to run).
  // To blink the LED, first we'll turn it on...
  digitalWrite(led1, HIGH);
  digitalWrite(led2, HIGH);

  // We'll leave it on for 1 second...
//  delay(pctfull*5);
  delay(1000);

  // Then we'll turn it off...
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);

  // Wait 1 second...
  //delay(500-pctfull*5);
  delay(1000);
  
  //Blink 2-digit "code" for percentage full
  /*
  int numofblinks=pctfull/10.0;
  for(int i=1; i<numofblinks; i++) {
    digitalWrite(led2, HIGH);
    delay(250);
    digitalWrite(led2, LOW);
    delay(250);
  }

  delay(2000);
  */
  
  // And repeat!
}