#include <Separador.

h>
#include <TimeLib.h>
#include <EEPROM.h>
#include <Time.h>
#include <math.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <DHT.h>
//DHT
#define DHTPIN 6
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
//HX711
#include <HX711_ADC.h>

#define ONE_WIRE_BUS_0 4
#define ONE_WIRE_BUS_1 8
//1-Wire
//const int pinDatosDQ = 4;
OneWire oneWireObjeto(ONE_WIRE_BUS_0);
DallasTemperature sensorDS18B20(&oneWireObjeto);

////1-Wire
//const int pinDatosDQ_2 = 8;
OneWire oneWireObjeto_2(ONE_WIRE_BUS_1);
DallasTemperature sensorDS18B20_2(&oneWireObjeto_2);
float temp5 = 0;

Separador s;// instancia libreria separar

//PARAMETROS BASCULA
const int HX711_dout = 2; //mcu > HX711 dout pin
const int HX711_sck = 3; //mcu > HX711 sck pin
long t;
long tarevalue = 0 ;
long factor = 1 ;
long stabilizingtime = 2000;
boolean _tare = false;
HX711_ADC LoadCell(HX711_dout, HX711_sck);
float weight;
float cell_value;
float m_lcell = 1;
float b_lcell = 0;
float tempCompressor;//1-WIRE
float humidityDht11;//DHT
float temperatureDht11;//DHT

float temperatureFIFOTemp3;
float temperatureFIFOTemp4;

//ALARMAS
const int door_sensor = 5;
const int alarmOutPin = 7;
int alarms[20];
int currentValueAlarm=1;
int counterAlarm=0;
int lastValueAlarm=0;
int recognizeAlarms=0;

//Registro control de temperatura evaporador

const int sensorPinA2 = A2;
float VoA2 = 0.0;
float sensorValueA2 = 0.0;
float temperatureA2 = 0.0;
float lastvalueA2 =0.0;
float vinValueA2 =0.0;
float newvalueA2 =0.0;
long coldChainTimerA2=0;
long timeLimitA2=60;
long timeFIFO1A2=0;
long timeOpA2=0;
long timeFIFO2A2=0;
long timeOpfinA2=0;
float temperatureFIFOA2=0.0;
float inMinA2;
float inMaxA2;
float vfA2;
float vsA2;
//PARAMETROS ANALOG A2
float c1A2=0;
float c2A2=1;
float c3A2=0;

//Registro control de temperatura defrost

const int sensorPinA3 = A3;
float VoA3 = 0.0;
float sensorValueA3 = 0.0;
float temperatureA3 = 0.0;
float lastvalueA3 =0.0;
float vinValueA3 =0.0;
float newvalueA3 =0.0;
long coldChainTimerA3=0;
long timeLimitA3=60;
long timeFIFO1A3=0;
long timeOpA3=0;
long timeFIFO2A3=0;
long timeOpfinA3=0;
float temperatureFIFOA3=0.0;
float inMinA3;
float inMaxA3;
float vfA3;
float vsA3;
//PARAMETROS ANALOG A3
float c1A3=0;
float c2A3=1;
float c3A3=0;

// filter weight
float pf =0.0;
float timeK=45.0;
float scanCycle=2.0;
int counterAverage=1;
int initialvalue=1;

//Registro Consumo Congelador ANALOG A1

unsigned long timeOpA1;//captura de estampa de tiempo flanco subida
unsigned long timeOpfinA1; //captura de estampa de tiempo flanco bajada
const int sensorPinA1 = A1;// entrada sensor
int sensorValueA1; // variable valor raw (0 - 1023)
long fanTimerOffA1;//tiempo off fan
long secondFIFOA1;
int stateSequenceA1;//secuencia de control
int cycleCounterA1;//contador ciclos
int consumptionWOpA1;//consumo tipo float
int cycleCounterFIFOA1;//dato ciclos fifo
float currentValueA1; //almacenamiento valor sensor (0.0 a 50.0)
float lastValueA1;// valor anterior
float resultValueA1;//diferencia
float fanlastValueA1;//valor anterior fan
float fanresultValueA1;//diferencia valor fan
float accumulatedPowerA_A1;//consumo almacenado total
float accumulatedPowerB_A1;//consumo almacenado ciclo
float wattA1, whA1;
long timeFIFO1A1, timeFIFO2A1;//datetime flanco subida y bajada precalentamiento fifo
long timerCompressorA1;
//PARAMETROS A1
float deadBandA1=0;//banda muerta no operacion
int timeLimitA1=300; //1800;
float positiveRangeA1=10;//rango variacion valor anterior actual +
float negativeRangeA1=-8;
float inMinA1=0;
float inMaxA1=51.5;
float c1A1=0;
float c2A1=1;
float c3A1=0;
float k_A1=1;
float v_A1=1;

//CONTROL VARIABLE
bool downloadA0, downloadA1, downloadA2, downloadA3;//estado descarga de datos
python
long lastDate;
long timerData;// temporizador general de reinicio de variables
long timerFIFO;// temporizador descarga de datos fifo
float voltage=110.0;
float fdp=0.9;
unsigned long timerSec;//tiempo arduino
unsigned long lastTimer;// seg anterior
unsigned long date;// fecha en segundos UNIX
unsigned long timeOp1, timeOp2, timeOp3, timeOp4; //datetime flanco subida y bajada
precalentamiento
String SerialRead;//valor de lectura Serial1
String dashboard;// cadena datos dashboard
String FIFO;//cadena de dato fifo
String chr44=",";//caracter de separacion de datos

//DATAPROCESSING
int strlenpython = 0;
int lenpython = 0;
int forCounter = 0;
float DSTable[50];
float currentData[50];
int DSIndex;
int Command=0;
String strData="";
String strChr="";
String strChrEnd="_";
int setParameters=0;
int eeAddress=0;
long nodata=0;
long timertemp = 0;
int nparameters=4; //numero de parametros + 1 posicion de corrimiento
int quantityData=30;
float parameters1[20];//A0 horno
float parameters2[20];//A1 consumo
float parameters3[20];//A2 cadena de frio
float parameters4[20];//A3 cadena de frio
int qParams1, qParams2, qParams3, qParams4;
int recognize=0;
int setConfig = 0;

float currentFIFOA1=0;
int count_A = 0;

long time_filter =0;

float offset_lcell = 0;
float w_factor = 1;
long p_anterior=0;
int count_val=0;
int z =0;

int door_state = 0;
int ctrl_door_state=0;
float door_p1=0;
float door_p2=0;
float door_p3=0;
float door_pe=0;
float door_pvar=0;
float door_pavg=0;

float p_val;
float p_estiba;
int estado;
float p_pack;
int n_pack;
int x= 5;
float k = 100;
float k2 = 0;
float val1=0;

//int time_filter=0;
float filt;
int xtime=1000;
float zero=0;
float p_caja;
float p_total=0;

float gross = 0;
int timermslimit = 500;

int LED=7;
int msTime=1000;
int blinkLed=0;
int status_led=0;
long timer_ms=0;
int mslimit = 11;

void setup()
{
pinMode(door_sensor, INPUT); //sensor de puerta
//OneWire oneWireObjeto(ONE_WIRE_BUS_0);
//DallasTemperature sensorDS18B20(&oneWireObjeto);
//analogReference(INTERNAL);
Serial1.begin(57600);
sensorDS18B20.begin();
sensorDS18B20.setResolution(10);
sensorDS18B20.setWaitForConversion(false);
sensorDS18B20.requestTemperatures();

sensorDS18B20_2.begin();
sensorDS18B20_2.setResolution(11);
sensorDS18B20_2.requestTemperatures();

dht.begin();
time_t date = now ();// get hora actual en segundos
timeOpA1=date; timeOpA2=date;
door_sensor =
LoadCell.begin();
boolean _tare = false; //set this to false if you don't want tare to be performed in the next
step
LoadCell.start(stabilizingtime, _tare);
LoadCell.setCalFactor(1.0);//-96134.00);
delay(1000);
}

void loop(){
time_t date = now ();// get hora actual en segundos

/*_____________________FUNCION DE LECTURA SERIAL Y SEPARADOR DE

DATOS_____________________
Esta funcion realiza la lectura de puerto serial entre arduino y rpi, despues de recibir el
dato realiza
la separacion por el caracter ',' y lo almacena en la tabla 'DSTable' como valores flotantes.
de una cadena ej: 'Set_,7,123,4321,#' se elimina el indicador 'Set_', los valores siguientes
se almacenan
en la tabla DSTable[0]=7, [1]=123 y [2] = 4321. le index [0]=7 se mueve a variable
'Command'
 */

if(Serial1.available()>0){//espera de comandos enviado por RPI

SerialRead= Serial1.readString();// lectura de Serial1
Serial1.flush (); // limpieza de buffer
lenpython = SerialRead.indexOf("Set_");// validacion de comando 'Set_', esto se utiliza
como verificacion de cadena string correcta
if(lenpython >= 0 ){
setConfig = 1;
lenpython=-1;// se coloca -1 ya que el cero tambien es considerado como verdadero

for (forCounter = 0; forCounter <30; forCounter++) { // Separacion de datos

strData = s.separa(SerialRead, ',',forCounter);
if(forCounter>0){ // inicio mayor a cero, para omitir el indicador 'Set_;'
DSTable[forCounter-1]=strData.toFloat(); // conversion dato string a float
}
}
}
strData="";
delay(200);

/*_______________________EJECUCION DE COMANDOS_____________________
la variable 'lenpython' es > o = a cero si la palabra 'Set_t' se encuentra correctamente en
el string
validado el comando se procede a validar que tipo de comando es con el valor
almacenado en DSTable[0]
0 = NA, 1 = NA, 2 = NA, 3=Estados de descarga, 4=actualizacion hora, 5= parametros
A2, 6=parametros A3
7 = inicializacion alarmas, 8= calibracion bascula, 9= parametros generales
*/
strData=""; SerialRead=""; // inicializacion
if(setConfig ==1){
setConfig = 0;
Command=int(DSTable[0]);// movimiento comando
if(Command==3){ // reset estados de descarga de datos
if(DSTable[1]==1) { DSTable[1]=0, downloadA0=0;}//
if(DSTable[2]==1) { DSTable[2]=0, downloadA1=0, currentFIFOA1 = 0;}//
if(DSTable[3]==1) { DSTable[3]=0, downloadA2=0;}//
if(DSTable[4]==1) { DSTable[4]=0, downloadA3=0;}// =0 envia estado actual de
arduino =1 dato habilitado para descarga
Command=0;
}
if(Command==4){ // establecimiento de hora
time_t lastDate = now ();// get hora actual en hora anterior segundos
date=DSTable[1];//movimiento de index hora a variable hora
setTime(date); //establecimiento de hora
 timeOpfinA1=date-(lastDate-timeOpfinA1);
timeOpfinA2=date-(lastDate-timeOpfinA2); // actualizacion de todos los registros de
hora
timeOpA1=date-(lastDate-timeOpA1);
timeOpA2=date-(lastDate-timeOpA2);
timeOp1=date-(lastDate-timeOp1);
timeOp2=date-(lastDate-timeOp2);
timeOp3=date-(lastDate-timeOp3);
timeOp4=date-(lastDate-timeOp4);
Command=0;
Serial1.println("SetHour_ok, " + String(date) + "," +String(lastDate)+ "," + "#" );
}
if(Command==5){ //parametros evaporador
c1A2=DSTable[1];
c2A2=DSTable[2];
c3A2=DSTable[3];
Command=0;
}
if(Command==6){ //parametros defrost
c1A3=DSTable[1];
c2A3=DSTable[2];// codigo para parametro de otra entrada analoga
c3A3=DSTable[3];//
Command=0;
}
if(Command==7){//recognize alarm
Command=0;
m_lcell = DSTable[1];
b_lcell = DSTable[2];
offset_lcell = DSTable[3];
w_factor = DSTable[4];
}
if(Command==8){//recognize alarm
Command=0;
recognize=0;
}
if(Command==9){//parametros generales
Command=0;
timeK=DSTable[1];
scanCycle=DSTable[2];
timeLimitA2=DSTable[3];
timeLimitA1=DSTable[4];
//x= DSTable[5];
//xtime = DSTable[6];
}
if(Command==10){//parametros generales
Command=0;
k_A1=DSTable[3];
v_A1=DSTable[4];
 }

if(Command==11){//parametros generales
//Serial1.println("configure 2 , " + String(DSTable[4]) );
xtime=DSTable[1];
x=DSTable[2];
timermslimit=DSTable[3];
mslimit = DSTable[4];
//w_factor = DSTable[5];
k = DSTable[6];
}
}

timerSec = millis();// cronometro de arduino, base para todos los temporizadores del codigo
timerSec = timerSec/1000; //base en segundos
time_filter++;

//float door_p1=0;
//float door_p2=0;
//float door_p3=0;
//float door_pe=0;
//float door_pvar=0;
//float door_pavg=0;

if(time_filter>xtime){
time_filter=0;
cell_value = LoadCell.getData(); // Celda de carga
LoadCell.update();
weight=abs((((m_lcell*cell_value)+b_lcell)*w_factor)+(offset_lcell));
door_state = digitalRead(door_sensor); //lectura digital de pin

if(door_state==1 == ctrl_door_state==0){
ctrl_door_state=1;
door_p1= gross;
}

if(door_state==1 == ctrl_door_state==1){
ctrl_door_state=0;
door_p2 = weight;
door_pvar = abs(door_p2 - door_p1);
door_pe = abs(door_p3 - door_p1);

if(ctrl_door_state==1){

if(inRange(abs(weight-p_anterior), 0,k)==0){
 count_val++;
if (z == 0){
p_val = weight;
z=1;
status_led=0;
}

if(count_val>x and inRange(abs(p_val-weight), 0,k)==1){

k2 = weight - p_anterior;
gross = weight - p_anterior;
p_anterior=weight;
count_val=0;
status_led=2;
}
if(count_val>x){
z=0; count_val=0;
}
}
}

//temporizadores
if(timerSec != lastTimer) // diferencia de dato para incremental de un segundo
{

// Actualizacion de variables celda de carga y temperatura compresor (DS18B20)

//cell_value = LoadCell.getData(); // Celda de carga
//LoadCell.update();
tempCompressor = sensorDS18B20.getTempCByIndex(0);// sensor temperatura motor
temp5 = sensorDS18B20_2.getTempCByIndex(0);// sensor temperatura motor
sensorDS18B20.requestTemperatures();
sensorDS18B20_2.requestTemperatures();

lastTimer=timerSec; //actualizacion de estado de seg

timerCompressorA1++; timerFIFO++; timerData++; coldChainTimerA2++;
if(timerFIFO>30000){timerFIFO=0;}
if(timerData>30000){timerData=0; timertemp=0;}

//CONTROL LECTURA DE VARIABLE ANALOGA--------------------------------

temperatureDht11 = dht.readTemperature(); //temperatura ambiente

humidityDht11 = dht.readHumidity(); // humedad

pf= (timeK+scanCycle)/scanCycle;// filtro para temperatura

sensorValueA1 = analogRead(sensorPinA1); //lectura entrada analoga ct nevera
currentValueA1 = fmap(sensorValueA1, 0, 1023, 0.0, 5); // configuracion escala
 sensorValueA2 = analogRead(sensorPinA2); // lectura entrada analoga sensor
evaporador
vinValueA2 = fmap(sensorValueA2, 0, 1023, 0.0, 5); // configuracion de escala de
acuerdo a voltaje de referencia 2.56
newvalueA2 = ((vinValueA2 - lastvalueA2) / pf) + lastvalueA2; //filtro sansor evaporador
lastvalueA2=newvalueA2; // aplicacion de filtro
VoA2=newvalueA2; //aplicacion de filtro
temperatureA2 = (c1A2 * (VoA2 * VoA2)) + (c2A2 * VoA2) + c3A2; // coeficiente para valor
final de temp

sensorValueA3 = analogRead(sensorPinA3); // lectura entrada analoga sensor

evaporador
vinValueA3 = fmap(sensorValueA3, 0, 1023, 0.0, 5); // configuracion de escala de acuerdo
a voltaje de referencia 2.56
newvalueA3 = ((vinValueA3 - lastvalueA3) / pf) + lastvalueA3; //filtro sansor evaporador
lastvalueA3=newvalueA3; // aplicacion de filtro
VoA3=newvalueA3; //aplicacion de filtro
temperatureA3 = (c1A3 * (VoA3 * VoA3)) + (c2A3 * VoA3) + c3A3;

wattA1=((voltage*v_A1) * currentValueA1 * k_A1 * fdp);// medicion de consumo

if(wattA1>deadBandA1) {whA1=wattA1/3600;
accumulatedPowerB_A1=whA1+accumulatedPowerB_A1;}
}
// variables de procesamiento para alarmas y estados de operacion.
if(( downloadA1==0 && downloadA2==0 && downloadA3==0) && timerData>5)
{
dashboard = "R_," +
String(date)+chr44+String(temperatureA2)+chr44+String(temperatureA3)+chr44+String(tem
pCompressor)+chr44+String(temperatureDht11)+chr44+String(humidityDht11)+chr44+String
(weight)+chr44+String(temp5)+chr44+String(VoA2,3)+chr44+String(VoA3,3)+chr44+String(9
999)+chr44+String(currentValueA1,3)+chr44+String(cell_value)+chr44+String(m_lcell)+chr4
4+String(b_lcell)+chr44+String(v_A1)+chr44+String(k_A1)+chr44+String(wattA1)+chr44+Stri
ng(accumulatedPowerB_A1)+chr44+String(p_anterior)+chr44+String(gross)+chr44;//+String(
weight)+chr44+String(tempCompressor,1)+chr44;
Serial1.println(dashboard);
timerData=0;
}

//FIFO
if((downloadA1==1 || downloadA2==1 || downloadA3==1) && timerFIFO>23)
{
FIFO= "D_,"+String(downloadA1) + ",1"
+chr44+String(timeFIFO1A1)+chr44+String(timeFIFO2A1)+",0,0"+chr44+String(currentFIFO
A1)+chr44+String(consumptionWOpA1)+chr44+String(cycleCounterFIFOA1)+",%," +
String(downloadA2) + ",2"
+chr44+String(timeFIFO1A2)+chr44+String(timeFIFO2A2)+chr44+String(temperatureFIFOA
2,1)+chr44+String(temperatureFIFOA3,1)+chr44+ String(temperatureFIFOTemp3,1)+
chr44+String(temperatureFIFOTemp4,1) +chr44+ String(weight)
+chr44+String(humidityDht11,1)+",_";
Serial1.println(FIFO);
timerFIFO=0;
//Serial1.flush ();
}

resultValueA1=currentValueA1;//resultado de consumo actual con anterior para deteccion

de operacion
if(resultValueA1 >= 0.6)
{ count_A++;

if(stateSequenceA1 == 0){
stateSequenceA1 = 1;
cycleCounterA1++;
}

if(count_A > 10 && stateSequenceA1 == 1){

currentFIFOA1 = currentValueA1;
stateSequenceA1 = 2;
}
}

if(resultValueA1 < 0.6 && stateSequenceA1 == 1){

stateSequenceA1 = 0;
count_A = 0;
}

//POTENCIA ACUMULADA A1
if(stateSequenceA1 == 1 && resultValueA1 < 0.5)
{
stateSequenceA1 = 0;
lastValueA1 = 0;
timeOpfinA1 = date;
accumulatedPowerA_A1 = accumulatedPowerA_A1+accumulatedPowerB_A1;
accumulatedPowerB_A1 = 0;
}

//FIFO REFRIGEERADOR consumo

if(timerCompressorA1>timeLimitA1){
timeOpfinA1=date;
timeFIFO1A1=timeOpA1;
timeFIFO2A1=timeOpfinA1;
accumulatedPowerA_A1=accumulatedPowerA_A1+accumulatedPowerB_A1;
accumulatedPowerB_A1=0;
consumptionWOpA1=accumulatedPowerA_A1;
secondFIFOA1=timerCompressorA1;
cycleCounterFIFOA1=cycleCounterA1;
 timerCompressorA1=0;
cycleCounterA1=0;
accumulatedPowerA_A1=0;
accumulatedPowerB_A1=0;
downloadA1=1;
timeOpA1=date;}
delay(50);
}

// cambio de escala entre floats

float fmap(float x, float in_min, float in_max, float out_min, float out_max)
{
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
bool inRange(int val, int minimum, int maximum)
{
return ((minimum <= val) && (val <= maximum));
}