Commit f866cf6a authored by Francisco De Izaguirre Benia's avatar Francisco De Izaguirre Benia
Browse files

Última versión estable del módulo principal para el proyecto GIACA

parent 4da44f87
#ifndef ARQ_AUX
#ifdef DEMOQ
#define DELAY_RESP_N 10
#define DELAY_RESP_p 10
#define DELAY_RESP_T1 10
#define DELAY_RESP_T1 10
#define DELAY_RESP_LIMPIEZA 10
#define ESPERA_CICLO 1000
#define ESPERA_ADQN 100
#define ESPERA_ADQP 100
#define ESPERA_ADQT1 100
#define ESPERA_ADQT2 100
// #define CANT_CAR_ESTADO 9 //Cantidad
#define ESTADO_LIMPIEZA 1 //CANT_CAR_ESTADO caracteres
#define ESTADO_ADQUISICION_N 2
#define ESTADO_ADQUISICION_P 3
#define ESTADO_ADQUISICION_T1 4
#define ESTADO_ADQUISICION_T2 5
extern int estado;
extern long tick_ult_consulta;
#endif
#endif
\ No newline at end of file
/**************************************************************
For this example, you need to install PubSubClient library:
https://github.com/knolleary/pubsubclient
or from http://librarymanager/all#PubSubClient
TinyGSM Getting Started guide:
https://tiny.cc/tinygsm-readme
For more MQTT examples, see PubSubClient library
**************************************************************
Use Mosquitto client tools to work with MQTT
Ubuntu/Linux: sudo apt-get install mosquitto-clients
Windows: https://mosquitto.org/download/
Subscribe for messages:
mosquitto_sub -h test.mosquitto.org -t GsmClientTest/init -t GsmClientTest/ledStatus -q 1
Toggle led:s
mosquitto_pub -h test.mosquitto.org -t GsmClientTest/led -q 1 -m "toggle"
You can use Node-RED for wiring together MQTT-enabled devices
https://nodered.org/
Also, take a look at these additional Node-RED modules:
node-red-contrib-blynk-ws
node-red-dashboard
**************************************************************/
// Set serial for debug console (to the Serial Monitor, default speed 115200)
#include <Arduino.h>
#include "sarafunctions.h"
/************************************************************/
//////////////////////////////////////////////////////////////
/***********************************************************/
TinyGsm modem(SerialAT);
TinyGsmClient client(modem);
PubSubClient mqtt(client);
/***********************************************************************/
/***********************************************************************/
#ifdef DEMOQ
int estado;
long tick_ult_consulta;
#endif
// SETUP
void setup() {
pinMode(RTDPIN,OUTPUT);
digitalWrite(RTDPIN,HIGH);
SerialMonbegin(115200);
delay(100);
// Set GSM module baud rate
SerialAT.begin(115200);
SaraFInit();
if(!SD.begin(SD_CS)) {
SaraFFalloSD();
}
SerialMonln("Empieza el Loop");
SerialMonln("En el main la cnatidad de activos es: " + (String)cantidadActivos);
}
byte DirI2C = 2;
byte canal =1 ;
byte tipoMod = 1;
/********************************************/
/********************************************/
// LOOP
void loop() {
SerialMonln(freeMemory());
SaraFMain();
#ifdef DEMOQ
float N, P, T1, T2;
int largo = 1;
/********
* Estados de la maquina de estados de QUIMICA
* */
/** RECIBIR MENSAJE
float_t fMensaje[largo];
for (int i=RXI2C.largoDatos.i-1;i>=0;i--){
fMensaje[i/4].b[i%4]=RXI2C.datos[1+i];
}
*/
switch (estado)
{
case ESTADO_LIMPIEZA:
DirI2C = 2;
canal =1 ;
tipoMod = 1;
Serial.print("ESTADO: ");
Serial.println(estado);
if (SaraFSolicitarMedida(DirI2C,canal,tipoMod,MAX_REINTENTOS)){
byte largo = 1;
SerialMonln("Solicitar respuesta");
delay(DELAY_RESP_LIMPIEZA);
SaraFSolicitarRespuesta(DirI2C, canal, largo);
float_t fMensaje[largo]; // La medida que se recibe es un unico dato, por lo tanto largo = 1
for (int i=RXI2C.largoDatos.i -1;i>=0;i--){
fMensaje[i/4].b[i%4]=RXI2C.datos[1+i];
}
estado = ESTADO_ADQUISICION_P;
}
delay(ESPERA_ADQP);
// case ESTADO_ADQUISICION_N:
// DirI2C = 3;
// canal = 1 ;
// tipoMod = 1;
// Serial.print("ESTADO: ");
// Serial.println(estado);
// if (SaraFSolicitarMedida(DirI2C,canal,tipoMod,MAX_REINTENTOS)){
// byte largo = 1;
// SerialMonln("Solicitar respuesta");
// delay(ESPERA_ADQN);
// SaraFSolicitarRespuesta(DirI2C, canal, largo);
// float_t fMensaje[largo]; // La medida que se recibe es un unico dato, por lo tanto largo = 1
// for (int i=RXI2C.largoDatos.i -1;i>=0;i--){
// fMensaje[i/4].b[i%4]=RXI2C.datos[1+i];
// }
// N = fMensaje[0].f;
// estado = ESTADO_ADQUISICION_P;
// }
// delay(ESPERA_ADQP);
case ESTADO_ADQUISICION_P:
DirI2C = 2;
canal = 2 ;
tipoMod = 1;
Serial.print("ESTADO: ");
Serial.println(estado);
if (SaraFSolicitarMedida(DirI2C,canal,tipoMod,MAX_REINTENTOS)){
byte largo = 1;
SerialMonln("Solicitar respuesta");
delay(ESPERA_ADQP);
SaraFSolicitarRespuesta(DirI2C, canal, largo);
float_t fMensaje[largo]; // La medida que se recibe es un unico dato, por lo tanto largo = 1
for (int i=RXI2C.largoDatos.i -1;i>=0;i--){
fMensaje[i/4].b[i%4]=RXI2C.datos[1+i];
}
saraDespertarSim800();
P = fMensaje[0].f;
estado = ESTADO_ADQUISICION_T1; // Estado que no existe => default
SaraFdemoq(DirI2C, P,'P');
delay(ESPERA_ADQT1);
}
else
{
delay(ESPERA_ADQP);
}
// case ESTADO_ADQUISICION_T1:
// DirI2C = 2;
// canal = 2 ;
// tipoMod = 1;
// Serial.print("ESTADO: ");
// Serial.println(estado);
// if (SaraFSolicitarMedida(DirI2C,canal,tipoMod,MAX_REINTENTOS)){
// largo = 1;
// SerialMonln("Solicitar respuesta");
// delay(ESPERA_ADQP);
// SaraFSolicitarRespuesta(DirI2C, canal, largo);
// float_t fMensaje[largo]; // La medida que se recibe es un unico dato, por lo tanto largo = 1
// for (int i=RXI2C.largoDatos.i -1;i>=0;i--){
// fMensaje[i/4].b[i%4]=RXI2C.datos[1+i];
// }
// T1 = fMensaje[0].f;
// estado = ESTADO_ADQUISICION_T1;
// }
// delay(ESPERA_ADQT1);
// case ESTADO_ADQUISICION_T2:
// DirI2C = 2;
// canal = 3 ;
// tipoMod = 1;
// Serial.print("ESTADO: ");
// Serial.println(estado);
// if (SaraFSolicitarMedida(DirI2C,canal,tipoMod,MAX_REINTENTOS)){
// byte largo = 1;
// SerialMonln("Solicitar respuesta");
// delay(ESPERA_ADQT2);
// SaraFSolicitarRespuesta(DirI2C, canal, largo);
// float_t fMensaje[largo]; // La medida que se recibe es un unico dato, por lo tanto largo = 1
// for (int i=RXI2C.largoDatos.i -1;i>=0;i--){
// fMensaje[i/4].b[i%4]=RXI2C.datos[1+i];
// }
// T2 = fMensaje[0].f;
// estado = ESTADO_ADQUISICION_T1;
// }
// delay(ESPERA_ADQT2);
default:
if (SaraFSolicitarMedida(2,3,1,MAX_REINTENTOS)){
byte largo = 1;
SerialMonln("Solicitar respuesta");
delay(DELAY_RESP_LIMPIEZA);
SaraFSolicitarRespuesta(2, 3, largo);
float_t fMensaje[largo]; // La medida que se recibe es un unico dato, por lo tanto largo = 1
while (now() < long (tick_ult_consulta + ESPERA_CICLO)){
SaraFLPWM();
}
estado = ESTADO_LIMPIEZA;
}
}
#endif
}
/**
* @file registros.h
* @brief Registros para el protocolo de la interfaz I2C de SaraBee
*
* @author Marco Rolon <marco.rolon@fing.edu.uy>
* @version 1.0
* @date Julio-2019
*/
#ifndef REGISTROS_H
#define REGISTROS_H
/** Configuracion */
/**
* @def LEER_TIPO_MODULO
*
* Valor del registro para la consulta de tipo de modulo
*/
#define LEER_TIPO_MODULO 0
/**
* @def LEER_CANTIDAD_CANALES
*
* Valor del registo para la consulta de la cantidad de canales
*
*/
#define LEER_CANTIDAD_CANALES 2
/**
* @def LEER_LARGO_CANALES
*
* Valor del registro para la lectura del largo de canales
*
*/
#define LEER_LARGO_CANALES 4
/**
* @def LEER_AGENDA_CANAL
*
* Valor del registro para la lectura de la agenda del canal
*
*/
#define LEER_AGENDA_CANAL 6
/**
* @def ESCRIBIR_AGENDA_CANAL
*
* Valor del registro para la escritura de la agenda del canal
*
*/
#define ESCRIBIR_AGENDA_CANAL 8
/**
* @def LEER_CANTIDAD_PARAMETROS
*
* Valor del registro para la lectura de la cantidad de parametros del canal
*
*/
#define LEER_CANTIDAD_PARAMETROS 10
/**
* @def LEER_PARAMETROS_CANAL
*
* Valor del registro para la lectura de la del valor de los parametros del canal
*
*/
#define LEER_PARAMETROS_CANAL 12
/**
* @def ESCRIBIR_PARAMETROS_CANAL
*
* Valor del registro para la escritura del valor de un parametro del canal
*
*/
#define ESCRIBIR_PARAMETROS_CANAL 14
/** Adquisicion */
/**
* @def LANZAR_LECTURA
*
* Valor del registro para lanzar una lectura en un canal de un modulo esclavo
*/
#define LANZAR_LECTURA 32
/**
* @def CONSULTA_LECTURA_PRONTA
*
* Valor del registro para consultar si una medida esta pronta
*/
#define CONSULTA_LECTURA_PRONTA 34
/**
* @def OBTENER_LECTURA
*
* Valor del registro para solicitar que el esclavo envie la lectura obtenida
*
*/
#define OBTENER_LECTURA 36
/** Ahorro de energia*/
/**
* @def BAJO_CONSUMO
*
* Valor del registro para forzar a un modulo auxilar entrar en bajo consumo
*
*/
#define BAJO_CONSUMO 64
#endif
This diff is collapsed.
/** *********************************************************
*
* Proyecto de Fin de Carrera - SARA-Bee
*
* @file sarafunctions.h
* @brief Funciones generales de SARA
*
* @author Francisco de Izaguirre <Francisco.de.izaguirre@fing.edu.uy>
* @author Maite Gil <maite.gil@fing.edu.uy>
* @author Marco Rolón <marco.rolon@fing.edu.uy>
* @author S.A.R.A.
*
* @version 3.0
* @date 4 Octubre 2019
*
********************************************************** */
#ifndef SARAFUN_H
#define SARAFUN_H
#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/power.h>
#include <stdio.h>
#include <stdlib.h>
#include <MemoryFree.h>
#include <Time.h>
#include <string.h>
#include "types.h"
#include "Arduino.h"
#ifdef DEMOQ
#include "arqAuxiliar.h"
#endif
/******************************
* Select your arduino board
*/
/**
* @def MEGA
* @brief Eleccion de la placa de desarrollo
* De momento es la unica placa que se puede seleccionar.
*/
#define MEGA
/*********************************
* Data type
*/
#include <ArduinoJson.h>
/**
* @def JSON_ARRAY
* @brief Elegir como menejar los vectores de datos recibidos
* Utilizando este define se elije como tratar los vectores de datos reibidos al momento de armar el mensaje de MQTT.
* Si esta definido, todo vector recibido sera enviado como un array.
* Si no esta defino todo vector inferior a 32 será enviado uno valor <indice>:<valor>, y si es mayor como array
*/
// #define JSON_ARRAY // Si esta definido envia los datos como un vector, si no los envia con su indice (hasta 26 numeros)
/****************************************************************
*For SD Utility
* */
#include <SPI.h>
#include <SD.h>
/**
* @def SD_CS
* Valor del pin del Chip Select de la terjeta SD
*/
#define SD_CS 53
// extern File archivoError;
/**
* @def SEGUNDOS_TICKS
* @brief es la cantidad de segundos que es un tick
*/
#define SEGUNDOS_TICKS 5
/////////////////////////////////////////////////////////////////
/****************************************************************
*For Modules comunications
* */
#include "sarai2c.h"
//////////////////////////////////////////////////////////////////
/******************************************************************
*For MQTT
* */
#include "saramqtt.h"
#include "sscmp.h"
/*******************************************************
* Extenciones de archivos
*/
/**
* @def SARA_EXT Extencion de los arvhicos de log de cada canal.
* @def LOG_EXT Extencion del archivo de log
*/
#define SARA_EXT "SBP" // SARA_EXT Extencion de los arvhicos de log de cada canal.
#define LOG_EXT "LOG" // LOG_EXT Extencion del archivo de log
/***
* Tipos de modulos
* @def ALIMENTACION Modulo de alimentacion caracerizado por el numero 0
* @def MODULO_ADQ_MULTI Modulos de adquisicion multicanal caracerizado por el numero 1
* @def MODULO_ADQ_NOMULTI Modulos de adquisicion no-multicanal caracerizado por el numero 2
**/
//TIPOS DE MODULO
#define ALIMENTACION 0
#define MODULO_ADQ_MULTI 1
#define MODULO_ADQ_NOMULTI 2
/************
* DEBUGING
*/
/**
* @def DEBUGMEM Si esta definido, selecciona que se indique en mensajes y en la pantalla el valor de la cantidad de memoria libre
* @def DEBUG Si esta definido, permite desplegar mensajes por comunicacion Serial.
*/
#define DEBUGMEM /// DEBUGMEM
#define DEBUG
#define SerialMon Serial
#ifdef DEBUG
#define SerialMonln(x) SerialMon.println(x) //Utilizando SerialMonln y SerialMonpr puedo habilitar y deshabilitar el las comunicaciones seriales
#define SerialMonpr(x) SerialMon.print(x) //mediante la definición o no de DEBUG
#define SerialMonbegin(x) SerialMon.begin(x)
#define SerialMonwr(x,y) SerialMon.write(x,y) //mediante la definición o no de DEBUG
#else
#define SerialMonpr(x)
#define SerialMonln(x)
#define SerialMonwr(x,y)
#define SerialMonbegin(x)
#endif
extern File archivo;
/****************************
* Funciones para el manejo de los modulos esclavos, el almacenamiento y la transmisión de datos.
*/
extern float id;
//extern String mensajeMqtt;
/**
* @fn SaraFInit
* @brief SaraFInit función donde se realiza la inicialización del sistema
*
*/
void SaraFInit();
/**
* @fn SaraFDesconectar
* @brief Se apaga el El sim800 y se inicializa el timer para salir de bajo consumo
*
*/
void SaraFDesconectar();
/**
* @fn SaraFInitTimer
* @brief Este timer se utiliza en bajo consumo, interrumpe cada 5 segundos.
*
*/
void SaraFInitTimer();
/**
* @fn SaraFMain
* @brief Eje central para el funcionamiento del sistema. Se ejuta despues de la inicialización, y fuera de bajo consumo
*
*/
void SaraFMain();
/**
* @fn SaraFdemoq
* @brief Funcion para la solucion especifica del proyecto de facultad de Quimica donde se utiliza el servidor Losant para la recepcion de datos.
*
*/
//void SaraFdemoq(float N, float P, float T1, float T2);
void SaraFdemoq(byte i2c, float medida,char simbolo);
/**
* @fn SaraFSolicitarMedida
* @param dirI2C Direccion I2C del modulo que se desea solicitar que comience la medición
* @param canal Canal del modulo que se desea solicitar la medida
* @brief Funcion que solicita a un modulo de adquisición que comience su medición
*/
bool SaraFSolicitarMedida(byte dirI2C, byte canal,byte tipoDeMod, byte reintentos);
/**
* @fn SaraFMedidaPronta
* @brief Consultar al modulo de adquisicion si la medida solicitada esta pronta
* @param dirI2C Direccion I2C del modulo del cual se quiere adquirir
* @param nCanal Canal del modulo que se desea adquirir
* @return true La medida esta pronta
* @return false La medida no esta pronta
*/
bool SaraFMedidaPronta(byte dirI2C, byte nCanal);
/**
* @fn SaraFSolicitarRespuesta
* @param dirI2C Direccion I2C del modulo que se desea solicitar que comience la medición
* @param canal Canal del modulo que se desea solicitar la medida
* @param largo Largo en bytes de la medida
* @brief Función que consulta a un modulo de adquisición si termino su medida,y la almacena en una cola para su posterior guardado y enviado por MQTT
*/
bool SaraFSolicitarRespuesta(byte dirI2C, byte canal,int largo);
/**
* @fn SaraFGuardarSD
* @brief Funcion que guarda en la tarjeta SD los datos obtenidos de las mediciones almacenados en una cola
* @param mensaje Mensaje que debe ser guardado en la tarjeta SD
*/
void SaraFGuardarSD(T_mensaje mensaje);
/**
* @fn SaraFEnviarMensaje
* @brief Funcion que envía por MQTT los datos obtenidos
* @param mensaje Mensaje a ser transmitido al servidor y del cual se obtine la información para el topic
*/
void SaraFEnviarMensaje(T_mensaje mensaje);
/**
* @fn SaraFEnviarAlerta
* @brief Funcion que guarda las alertas en la SD y las envía por MQTT.
* @param mensaje Mensaje a ser transmitido
* @param topicR
*/
void SaraFEnviarAlerta(String mensaje, String topicR);
/**
* @fn SaraFEnviarPropiedades
* @brief Funcion que guarda las propiedades en la SD y las envía por MQTT.
* @param modID Indice del array de modulos no tiene porque coincidir con la direccion I2C
*/
void SaraFEnviarPropiedades(byte modID);
/**
* @fn saraEnviarDefaultProps
* @brief Envia las propiedades de todos los modulos del sistema
*
*/
void saraEnviarDefaultProps();
/**
* @fn SaraFModuloPerdido
* @brief Función para publicar en el broker una alerta por el módulo perdido
* @param dirI2C Direccion I2C del modulo perdido
*/
void SaraFModuloPerdido(byte dirI2C);
/**
* @fn SaraFModuloEncontrado
* @brief Función para publicar en el broker un alerta de que el modulo fue encontrado
* @param dirI2C Direccion I2C del modulo encontrado
*/
void SaraFModuloEncontrado(byte dirI2C);
/**
* @fn SaraFFalloSD
* @brief Función para publicar en el broker una alerta por que no se puedo inicializar la tarjeta SD
*/
void SaraFFalloSD();
/**
* @fn SaraFMedirCanal
* @brief Funcion en la que confirma si se debe solicitar una medida, o si ya se solicito entonces solicitar la respuesta. Seteo de banderas
*
* @param modulo Estructura del modulo que se va a medir
* @param nCanal Estructura del canal que se va a medir
*/
void SaraFMedirCanal(T_modulo* modulo,byte nCanal);
/**
* @fn SaraFComprobarTicks
* @brief Funcion utilizada para saber si hay canales donde o bien se debe solicitar el inicio de una medida, o se debe solicitar una respuesta
*
* @return true Se debe realizar tareas programadas de la agenda.
* @return false No se debe realizar ninguna tarea programada de la agenda.
*/
bool SaraFComprobarTicks();
/**