Ower_Monitor_Ok

  ///////////////////////////////////////////
  // TCC - USF Campinas/SP - Eng. Elétrica //
  //         Qualidade de Energia          //
  //---------------------------------------//
  // Denis Eduardo Donadon Torres          //
  ///////////////////////////////////////////

  #include <Arduino.h>
  #include "EmonLibPro.h"
  #include <DS1307.h>     // Carrega a biblioteca do RTC DS1307 (Real Time Clock)
  //#include <SD.h>         // Carrega a biblioteca SD
  #include <SdFat.h>         // Carrega a biblioteca SD
  int userCommand;
  DS1307 rtc(A4, A5);        // Modulo RTC DS1307 ligado as portas A4 e A5 do Arduino
  const int chipSelect = 10;  // Pino do Arduino conectado ao pino CS do modulo
  float Q; // Potência Reativa

  EmonLibPro Emon;
  SdFat SD;
  //------------------------------------------------------------
  void setup()
  {
    Serial.begin(9600);

    /////////////////////////////////////////////////////////////
    // Testa se o cartão cartão SD está encaixado corretamente //
    /////////////////////////////////////////////////////////////
    if (!SD.begin(chipSelect))
    {
      Serial.println();
      Serial.println("Falha ao acessar o cartao SD!");
      Serial.println("Verifique o cartao e reinicie o Analisador...");
      Serial.println();
      return;
    }
    Serial.println();
    Serial.println("Cartao iniciado corretamente!");
    Serial.println();

    Emon = EmonLibPro();    // Required
    Emon.begin();           // Required

    printMenu();
  }
  //------------------------------------------------------------------------------
  void loop()
  {
    if((userCommand == 1)  && (Emon.FlagCALC_READY))
    {
      Emon.calculateResult();
      for (byte i=0;i<CURRENTCOUNT;i++)
      {
        printResults(i);
      }
    }
    if((userCommand == 2) && (Emon.FlagCYCLE_FULL)) {
      for (byte i=0; i<VOLTSCOUNT + CURRENTCOUNT;i++){
        Serial.print("ADC");
        Serial.print(0+i);
        Serial.print(",");
        serialDataTable(i);
      }
      Emon.FlagCYCLE_FULL = false;  //Must reset after read to know next batch.
    }

    if((userCommand == 3) && (Emon.FlagCALC_READY)) {
      Emon.printStatus();
      userCommand = 0;
    }

    if ((userCommand == 4) && (EmonLibPro::FlagOutOfTime)) { // This should never be true.  Reduce sampling rate if it is!
      Serial.println("$");         // Alarm that previous ADC processing has run out of time before timer event. Must decrease SAMPLESPSEC
    }

    if(Serial.available())
    {
      userCommand=Serial.parseInt();
      Serial.print("Voce digitou: ");
      Serial.println(userCommand);
      Serial.println();
      Serial.println("Ok, seguem abaixo:");
      Serial.println();
      Serial.println("Dados: ");
      Serial.println();
    }
  }
  //--------------------------------------------------------------------------
  void printMenu()
  {
    Serial.println("ANALISADOR DE QUALIDADE DE ENERGIA");
    Serial.println();
    Serial.println("Digite o n 1 e tecle ENTER para iniciar!");
    Serial.println("Aguardando seu comando...");
  }
  //----------------------------------------------------------------------------
  // Print calculated results
  void printResults(byte i)
  {
    Q = sqrt(Emon.ResultP[i].P * Emon.ResultP[i].P + Emon.ResultP[i].S * Emon.ResultP[i].S); // Calcula a Potêcia Reativa ( Q = RAIZ(Potência Ativa² + Potência Aparente² ).

    Serial.print(rtc.getDOWStr(FORMAT_LONG));
    Serial.print(", ");
    Serial.print(rtc.getDateStr(FORMAT_SHORT));
    Serial.print(", ");
    Serial.print("as ");
    Serial.print(rtc.getTimeStr());
    Serial.print(" hrs");
    Serial.println();

    Serial.print("FP: ");
    Serial.print(Emon.ResultP[i].F);
    Serial.print("\t");

    Serial.print("Freq: ");
    Serial.print(Emon.ResultV[0].HZ);
    Serial.print(" Hz\t");

    Serial.print("Volts: ");
    Serial.print(Emon.ResultV[0].U);
    Serial.print(" Vac\t");

    Serial.print("Corrente: ");
    Serial.print(Emon.ResultP[i].I);
    Serial.print(" A\t");

    Serial.print("Pot Ativa: ");
    Serial.print(Emon.ResultP[i].P);
    Serial.print(" W\t");

    Serial.print("Pot Aparente: ");
    Serial.print(Emon.ResultP[i].S);
    Serial.print(" VA\t");

    Serial.print("Pot Reativa: ");
    Serial.print(Q);
    Serial.println(" var");

    //////////////////////////////////////////////
    // Cria o arquivo arquivo .xls no cartão SD //
    //////////////////////////////////////////////

    File dataFile = SD.open("Analise.txt", FILE_WRITE);   // * Atenção, o nome do arquivo não pode ter caracteres inválidos como ()/{}[].,;* nem com acentos!!! *
    if (dataFile) // Grava os dados no arquivo
    {
      dataFile.print(rtc.getDOWStr(FORMAT_LONG));
      dataFile.print(", ");
      dataFile.print(rtc.getDateStr(FORMAT_SHORT));
      dataFile.print(", ");
      dataFile.print("as ");
      dataFile.print(rtc.getTimeStr());
      dataFile.print(" hrs");
      dataFile.println();

      dataFile.print("FP: ");
      dataFile.print(Emon.ResultP[i].F);
      dataFile.print("\t");

      dataFile.print("Freq: ");
      dataFile.print(Emon.ResultV[0].HZ);
      dataFile.print(" Hz\t");

      dataFile.print("Volts: ");
      dataFile.print(Emon.ResultV[0].U);
      dataFile.print(" V\t");

      dataFile.print("Corrente: ");
      dataFile.print(Emon.ResultP[i].I);
      dataFile.print(" A\t");

      dataFile.print("Pot Ativa: ");
      dataFile.print(Emon.ResultP[i].P);
      dataFile.print(" W\t");

      dataFile.print("Pot Aparente: ");
      dataFile.print(Emon.ResultP[i].S);
      dataFile.print(" VA\t");

      dataFile.print("Potencia Reativa: ");
      dataFile.print(Q);
      dataFile.print(" var");
      dataFile.println(); // pula a linha
      dataFile.println(); // pula a linha

      dataFile.close();
    }
    else
    {
      // Mensagem de erro caso ocorra algum problema na criação do arquivo
      Serial.println("Erro ao criar o arquivo .txt!");
      Serial.println("Verifique o cartao e reinicie o Analisador...");
      Serial.println();
    }

  #ifdef USEPLL
    if(!Emon.pllUnlocked) Serial.print(" Locked");
  #endif
    Serial.println("\t");
  }
  //-----------------------------------------------------------------------------------
  // Exposes the internal sampled values for all samples on a cycle
  // Usefull to display the signal on a graph.
  void serialDataTable(byte b)
  {
    int sizearr = (Emon.SamplesPerCycleTotal/Emon.CyclesPerTotal);
    if (sizearr > CYCLEARRSIZE) sizearr = CYCLEARRSIZE;
    for (byte i=0;i<=sizearr;i++)
    {
      Serial.print(Emon.Sample[b].CycleArr[i]);
      Serial.print(",");
    }
    Serial.println("\t");
  }