Hardware/dInfrastructure/qPowerMeasurment: PowerSensingCode.ino

/*
 Web Server
 
 A simple web server that shows the value of the analog input pins.
 using an Arduino Wiznet Ethernet shield. 
 
 Circuit:
 * Ethernet shield is attached to the top of the Power Sensing Platform and Arduino is on the bottom of the Power Sensing Platform.
 * Toroid current sensors are inputed through the Power Sensing Platform and are outputed through the Arduino analog pins A0 through A11.
 * The ouput reading from the Arduino analog pins is a power reading measured in Watts. 
 
 The Webserver Template 
 Created 18 Dec 2009
 By David A. Mellis
 Modified 9 Apr 2012
 By Tom Igoe
 Modified 12 Jun 2013
 By: Pavan A. Desai 
 
 */

#include <SPI.h>
#include <Ethernet.h>    

// Enter a MAC address for your controller below.
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
  byte mac[] = { 0x90, 0xA2, 0xDA, 0x0D, 0x05, 0x52 }; // Mac address from Ethernet shield used for this project. 

  EthernetClient client;  //Creates a client which can connect to a specified internet IP address and port (defined in the client.connect() function).

// Initialize the Ethernet client library
// with the IP address and port of the server 
// that you want to connect to (port 80 is default for HTTP):

  EthernetServer server(80); // Port 80 default for HTTP 

  void setup() {
// Open serial communications and wait for port to open:
  Serial.begin(9600);  // Used for communication between the Arduino board and a computer or other devices, for more info please visit the Arduino Webservser website. 

// Start the Ethernet connection:
   /*
      DHCP should auto assign the Arduino an IP Address 
      DHCP-based IP printer
      This sketch uses the DHCP extensions to the Ethernet library
      to get an IP address via DHCP and print the address obtained.
      using an Arduino Wiznet Ethernet shield. 
      created 12 April 2011
      modified 9 Apr 2012
      By Tom Igoe
      modified 26 Jun 2013
      By Pavan Desai
   */
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    // no point in carrying on, so do nothing forevermore:
    for(;;)
      ;
  }
  // print your local IP address:
  Serial.print("My IP Address: ");
  for (byte thisByte = 0; thisByte < 4; thisByte++) {
    // print the value of each byte of the IP address:
    Serial.print(Ethernet.localIP()[thisByte], DEC);
    Serial.print("."); 
  }
  Serial.println();        // The IP address assign to the Arduino by the webserver in Orbit Network is 10.41.250.19. 

  } 



 void loop() {
  
  analogReference(INTERNAL1V1);   //Built in 1.1 voltage 
   
  EthernetClient client = server.available();  // Try to get client 
  if (client) {    // Checks to see if there is a client.
    Serial.println("new client");
    // An http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {   // Client data available to read
        char c = client.read();   // Read 1 byte (character) from client
                                  // Last line of client request is blank and ends with \n 
                                  // Respond to client only after last line received     
        Serial.write(c);
        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank) {
          // send a standard http response header
       
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/xml");    //Changed from html to xml
          client.println("Connection: close");
          
       //add a meta refresh tag, so the browser pulls again every 5 seconds:
       // client.println("<meta http-equiv=\"refresh\" content=\"5\">");
          client.println("Refresh: 1");
        
          client.println();
          client.println("<?xml version=\"1.0\"?>");  // Start of the XML output code, for more info on XML visit W3Schools website   
          
       //Output the value of each analog input pin
          client.println("<Data>"); // The XML Root Element 
          for (int analogChannel = 0; analogChannel < 12; analogChannel++) //Only using the first 12 analog pins out of 16 total. 
          {
             int sensorReading = analogRead(analogChannel); // analogRead reads the reading at the analog channel (pins A0-A11) and outputs a resolution reading between 0 to 1023
                                                            // the Arduino has a 10-bit analog to digital converter so it will map input voltages between 0 and 5 volts into 
                                                            // integer values between 0 and 1023.  
             client.println("<Reading>");    // The XML child element start and end 
             client.println("<AnalogPin>");                     
             client.print(analogChannel);   
             client.println("</AnalogPin>");              
             client.println("<Output>");
              
             // If there is no input signal given to any Arduino pin, the output will still display a resolution reading due to the internal circuit noise. 
             // The following if statment will eliminate that noise, if the analog pin has no signal in the input then the if-statement will output a "0."
                    if (sensorReading == 0)     //Displays a "0" for any analog pin that has to signal applied to its input      
                       {client.print(sensorReading);} // prints the reading 
                    else   
                       { 
                        if (analogChannel == 0)   
                                {double d= 0.0;
                                 d = static_cast<double>(sensorReading);                                                  
                                 double power = 42 * square((((((((sensorReading/1024.0)*1100.0)/4.700)+2.468)/42)*40)/0.02623)/1000);   
                                 client.print(power); // Prints out Power Reading in Watts 
                                 
                               //double voltage = (((sensorReading/1024.0)*1100.0)/4.700+2.468);  //Prints out Voltage Reading 
                               //client.print(voltage); // Prints out Voltage Reading in Volts
                                }
                        else if (analogChannel == 1) 
                                {double d= 0.0;
                                 d = static_cast<double>(sensorReading);                                         
                                 double power = 42 * square((((((((sensorReading/1024.0)*1100.0)/4.700)+3.784)/42)*40)/0.02623)/1000);   
                                 client.print(power); // Prints out Power Reading in Watts
                                 
                               //double voltage = (((sensorReading/1024.0)*1100.0)/4.700+3.784); 
                               //client.print(voltage); // Prints out Voltage Reading in Volts
                                } 
                        else if (analogChannel == 2) 
                                {double d= 0.0;
                                 d = static_cast<double>(sensorReading);                                                                  
                                 double power = 42 * square((((((((sensorReading/1024.0)*1100.0)/4.700)+3.841)/42)*40)/0.02623)/1000);   
                                 client.print(power); // Prints out Power Reading in Watts
                                 
                               //double voltage = (((sensorReading/1024.0)*1100.0)/4.700+3.841);
                               //client.print(voltage); // Prints out Voltage Reading in Volts
                                } 
                        else if (analogChannel == 3) 
                                {double d= 0.0;
                                 d = static_cast<double>(sensorReading);                                                                  
                                 double power = 42 * square((((((((sensorReading/1024.0)*1100.0)/4.700)+3.208)/42)*40)/0.02623)/1000);  
                                 client.print(power); // Prints out Power Reading in Watts
                                 
                               //double voltage = (((sensorReading/1024.0)*1100.0)/4.700+3.208); 
                               //client.print(voltage); // Prints out Voltage Reading in Volts
                                } 
                        else if (analogChannel == 4) 
                                {double d= 0.0;
                                 d = static_cast<double>(sensorReading);                                                                  
                                 double power = 42 * square((((((((sensorReading/1024.0)*1100.0)/4.700)+4.443)/42)*40)/0.02623)/1000);    
                                 client.print(power); // Prints out Power Reading in Watts
                                 
                               //double voltage = (((sensorReading/1024.0)*1100.0)/4.700+4.443); 
                               //client.print(voltage); // Prints out Voltage Reading in Volts  
                                } 
                        else if (analogChannel == 5) 
                                {double d= 0.0;
                                 d = static_cast<double>(sensorReading);                                                                  
                                 double power = 42 * square((((((((sensorReading/1024.0)*1100.0)/4.700)+2.643)/42)*40)/0.02623)/1000);     
                                 client.print(power); // Prints out Power Reading in Watts
                                 
                               //double voltage = (((sensorReading/1024.0)*1100.0)/4.700+2.643);
                               //client.print(voltage); // Prints out Voltage Reading in Volts  
                                }
                       else if (analogChannel == 6) 
                                {double d= 0.0;
                                 d = static_cast<double>(sensorReading);                                                                   
                                 double power = 42 * square((((((((sensorReading/1024.0)*1100.0)/4.700)+4.347)/42)*40)/0.02623)/1000);   
                                 client.print(power); // Prints out Power Reading in Watts
                                 
                               //double voltage = (((sensorReading/1024.0)*1100.0)/4.700+4.347);
                               //client.print(voltage); // Prints out Voltage Reading in Volts
                                } 
                       else if (analogChannel == 7) 
                                {double d= 0.0;
                                 d = static_cast<double>(sensorReading);                                                                    
                                 double power = 42 * square((((((((sensorReading/1024.0)*1100.0)/4.700)+3.093)/42)*40)/0.02623)/1000);    
                                 client.print(power); // Prints out Power Reading in Watts
                                 
                               //double voltage = (((sensorReading/1024.0)*1100.0)/4.700+3.093); 
                               //client.print(voltage); // Prints out Voltage Reading in Volts  
                                } 
                       else if (analogChannel == 8) 
                                {double d= 0.0;
                                 d = static_cast<double>(sensorReading);                                                                    
                                 double power = 42 * square((((((((sensorReading/1024.0)*1100.0)/4.700)+3.309)/42)*40)/0.02623)/1000);     
                                 client.print(power); // Prints out Power Reading in Watts
                                 
                               //double voltage = (((sensorReading/1024.0)*1100.0)/4.700+3.309);
                               //client.print(voltage); // Prints out Voltage Reading in Volts
                                } 
                       else if (analogChannel == 9) 
                                {double d= 0.0;
                                 d = static_cast<double>(sensorReading);                                                                   
                                 double power = 42 * square((((((((sensorReading/1024.0)*1100.0)/4.700)+2.964)/42)*40)/0.02623)/1000);     
                                 client.print(power); // Prints out Power Reading in Watts
                                 
                               //double voltage = (((sensorReading/1024.0)*1100.0)/4.700+2.964); 
                               //client.print(voltage); // Prints out Voltage Reading in Volts 
                                } 
                       else if (analogChannel == 10) 
                                {double d= 0.0;
                                 d = static_cast<double>(sensorReading);                                                                   
                                 double power = 42 * square((((((((sensorReading/1024.0)*1100.0)/4.700)+3.330)/42)*40)/0.02623)/1000);  
                                 client.print(power); // Prints out Power Reading in Watts
                                 
                               //double voltage = (((sensorReading/1024.0)*1100.0)/4.700+3.330); 
                               //client.print(voltage); // Prints out Voltage Reading in Volts  
                                } 
                       else if (analogChannel == 11) 
                                {double d= 0.0;
                                 d = static_cast<double>(sensorReading);                                                                     
                                 double power = 42 * square((((((((sensorReading/1024.0)*1100.0)/4.700)+2.935)/42)*40)/0.02623)/1000);     
                                 client.print(power); // Prints out Power Reading in Watts
                                 
                               //double voltage = (((sensorReading/1024.0)*1100.0)/4.700+2.935);  
                               //client.print(voltage); // Prints out Voltage Reading in Volts
                                }          
                            }
             client.println("</Output>"); //The XML Child Element tags end
             client.println("</Reading>");
          }  
             client.println("</Data>"); // The XML Root Element Tag ends
             break;
        }    
       
        if (c == '\n') {
          // you're starting a new line
          currentLineIsBlank = true;
        } 
        else if (c != '\r') {
          // you've gotten a character on the current line
          currentLineIsBlank = false;
        }
      }
    }
    // give the web browser time to receive the data
    delay(1);
    // close the connection:
    client.stop();
    Serial.println("client disonnected");
  }
}