termopar SPI e amperimetro trifasico nao invasivo saida i2c

/* www.copacabana.io
 *  Parte 2: inclusão da comunicação i2c
 *  inclusão de leitura SPI de termopar
 TA12-100 medidor trifasico não invasivo
 feito em Arduino Pro Mini 328 16MHz 5V
*/
#include "max6675.h"  // biblioteca do chip do termopar K SPI

int termoSPISO = 8;  // pino MISO
int termoSPICS = 9;  // pino CS/SS
int termoSPICLK = 7; // pino CLK
MAX6675 termoSPI(termoSPICLK, termoSPICS, termoSPISO);

byte temperatura; // vai ler soh a parte inteira da temperatura que eh float



#include <Wire.h> // inclusão do i2c lib
int address = 4;  // endereço escolhido i2c deste slave

int sensorR = A0; // pino analogico do sensor R
int sensorS = A1; // pino analogico do sensor S
int sensorT = A2; // pino analogico do sensor T



float voltagemResistorR;   // Voltagem medida atraves do resistor
float correntePicoResistorR; // Corrente de pico medida atraves do resistor
float correnteRMSresistorR; // Corrente RMS atraves do resistor
float correnteRMSnoFioR;     // Corrente Real no fio R

float voltagemResistorS;   // Voltagem medida atraves do resistor
float correntePicoResistorS; // Corrente de pico medida atraves do resistor
float correnteRMSresistorS; // Corrente RMS atraves do resistor
float correnteRMSnoFioS;     // Corrente Real no fio S

float voltagemResistorT;   // Voltage measured across resistor
float correntePicoResistorT; // Peak Current Measured Through Resistor
float correnteRMSresistorT; // RMS current through Resistor
float correnteRMSnoFioT;     // Corrente Real no fio T

int i2cIntRmsR; // criamos variaveis para o payload i2c
int i2cFracRmsR;
int i2cIntRmsS;
int i2cFracRmsS;
int i2cIntRmsT;
int i2cFracRmsT;


void setup()
{
  Wire.begin(address); // inicializa o i2c
  Wire.onRequest(onRequest); // engatilha para recepçao i2c de requests (interrupt)

  Serial.begin(9600);  // inicializa comunicação com serial monitor a 9600 8n1 cr/lf
  pinMode(sensorR, INPUT);
  pinMode(sensorS, INPUT);
  pinMode(sensorT, INPUT);
}

void onRequest() {  // interrupção i2c atendida aqui:

     /* Para transmitir por i2c, byte a byte, escolhi mudar de mA para
 amperes, com apenas 1 casa decimal. A saida serial permanece com a precisão original
 Então dois bytes por medida serão suficientes. ex: 1.2567 = 1 int + 2 fracionario = (1,2)
 */
i2cIntRmsR = (int) (correnteRMSnoFioR / 1000); // inteiro R  ... byte 1
i2cFracRmsR = 10*(correnteRMSnoFioR/1000 - i2cIntRmsR); // fracionario R ...  byte 2
i2cIntRmsS = (int) (correnteRMSnoFioS/1000); // inteiro S ... byre 3
i2cFracRmsS = 10*(correnteRMSnoFioS/1000 - i2cIntRmsS); // fracionario S ... byte 4
i2cIntRmsT = (int) correnteRMSnoFioT/1000; //inteiro T ... byte 5
i2cFracRmsT = 10*(correnteRMSnoFioT/1000 - i2cIntRmsT); // fracionario R ... byte 6
 // TEMOS AGORA UM PAYLOAD DE APENAS 6 BYTES PARA TRANSMITIR AS 3 CORRENTES
// multiplicamos *10 a conta fracionaria para acomodar decimos num byte

  // crio um buffer para acomodar um payload de 7 bytes
  byte buffer[7] = {i2cIntRmsR,i2cFracRmsR,i2cIntRmsS,i2cFracRmsS,i2cIntRmsT,i2cFracRmsT,temperatura};
  Wire.write(buffer, 7); // envio o payload ao master que pediu

Serial.print("AMPERES ");
Serial.print(correnteRMSnoFioR);
Serial.print(" ");
Serial.println(i2cFracRmsR);
}

void loop()
{

// a temperatura eh float, mas byte serve para ler sem virgula e transmitir
temperatura = (termoSPI.readCelsius());  // aqui le temperatura no dispositivo SPI
Serial.print("temperatura= ");
Serial.println(temperatura);


  voltagemResistorR = getVppR();
  voltagemResistorS = getVppS();
  voltagemResistorT = getVppT();

  /*
    Lei de ohm para calculo da corrente pelo resistor
    expressa em mA
  */

  correntePicoResistorR = (voltagemResistorR / 200.0) * 1000.0;
  correntePicoResistorS = (voltagemResistorR / 200.0) * 1000.0;
  correntePicoResistorT = (voltagemResistorR / 200.0) * 1000.0;

  /*
    Formula de conversao de onda senoidal
    para RMS
  */

  correnteRMSresistorR = correntePicoResistorR * 0.707;
  correnteRMSresistorS = correntePicoResistorS * 0.707;
  correnteRMSresistorT = correntePicoResistorT * 0.707;

  /*
   No modelo octopus TA12-100 a proporcao de
   corrente no transformados eh 1000/1...

    Entao a corrente atraves do resitor de 200 ohm
    eh multiplicada por 1000
  */


  correnteRMSnoFioR = correnteRMSresistorR * 1000;
  correnteRMSnoFioS = correnteRMSresistorS * 1000;
  correnteRMSnoFioT = correnteRMSresistorT * 1000;


  Serial.print("Corrente pelo fio R : ");
  Serial.print(correnteRMSnoFioR, 3);
  Serial.println(" mA RMS");
  Serial.println();

  Serial.print("Corrente pelo fio S : ");
  Serial.print(correnteRMSnoFioS, 3);
  Serial.println(" mA RMS");
  Serial.println();

  Serial.print("Corrente pelo fio T : ");
  Serial.print(correnteRMSnoFioT, 3);
  Serial.println(" mA RMS");
  Serial.println();


}


/************************************

  Para calculo da corrente RMS, temos que conhecer
  a voltagem pico a pico medida na saida atraves do
  resistor de 200 ohm
  A funcao a seguir toma amostras por 1/10 de segundo
  e retorna com o pico registrado no período
*************************************/

//-------------------------------------------- fase R
float getVppR()
{
  float resultadoR;
  int leuValorR;             //valor lido pelo sensor
  int maxValorR = 0;          // guarda o maximo registrado aqui
  uint32_t start_time = millis();
  while ((millis() - start_time) < 100) //sample for 1 Sec
  {
    leuValorR = analogRead(sensorR);
    // see if you have a new maxValorR
    if (leuValorR > maxValorR)
    {
      /*registra o valor maximo do sensor*/
      maxValorR = leuValorR;
    }
  }

  // Converte o dado digital em uma voltagem
  resultadoR = (maxValorR * 5.0) / 1024.0;

  return resultadoR;
}

/// ---------------------------------------------fase S

float getVppS()
{
  float resultadoS;
  int leuValorS;             // valor lido pelo sensor
  int maxValorS = 0;          // guarda o maximo registrado aqui
  uint32_t start_time = millis();
  while ((millis() - start_time) < 100) //sample for 1 Sec
  {
    leuValorS = analogRead(sensorS);
    // see if you have a new maxValorS
    if (leuValorS > maxValorS)
    {
      /*registra o valor maximo do sensor*/
      maxValorS = leuValorS;
    }
  }

  // Converte o dado digital em uma voltagem
  resultadoS = (maxValorS * 5.0) / 1024.0;

  return resultadoS;
}

// -------------------------------------------------- fase T

float getVppT()
{
  float resultadoT;
  int leuValorT;             //valor lido pelo sensor
  int maxValorT = 0;          // guarda o maximo registrado aqui
  uint32_t start_time = millis();
  while ((millis() - start_time) < 100) //sample for 1 Sec
  {
    leuValorT = analogRead(sensorT);
    // verifica se temos um novo valor maximo
    if (leuValorT > maxValorT)
    {
      /*registra o valor maximo do sensor*/
      maxValorT = leuValorT;
    }
  }

  // Converte o dado digital em uma voltagem
  resultadoT = (maxValorT * 5.0) / 1024.0;

  return resultadoT;
}