stima.h

Go to the documentation of this file.

 
/*********************************************************************
Copyright (C) 2017  Marco Baldinetti <m.baldinetti@digiteco.it>
authors:
Paolo Patruno <p.patruno@iperbole.bologna.it>
Marco Baldinetti <m.baldinetti@digiteco.it>
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
**********************************************************************/
 
#ifndef _STIMA_H
#define _STIMA_H
 
#include <stima_module.h>
#include "stima-config.h"
#include <typedef.h>
#include <registers.h>
#include <registers.h>
#include <registers-master.h>
#include <debug.h>
#include <ArduinoLog.h>
#include <StreamUtils.h>
 
#include <i2c_config.h>
#include <json_config.h>
#include <ntp_config.h>
#include <constantdata_config.h>
#include <gsm_config.h>
 
#if (USE_LCD)
#include <Wire.h>
#include <lcd_config.h>
#include <hd44780.h>
#include <hd44780ioClass/hd44780_I2Cexp.h> // i2c LCD i/o class header
#endif
 
#ifdef ARDUINO_ARCH_AVR
#include <avr/sleep.h>
#include <avr/power.h>
#include <avr/wdt.h>
#endif
 
#include <SPI.h>
#include <Wire.h>
 
#if (USE_SDCARD)
#include <sdcard_utility.h>
#endif
 
#include <pcf8563.h>
 
#if (USE_NTP)
#include <ntp.h>
#endif
 
#include <rmap_utility.h>
#if (USE_JSON)
#include <json_utility.h>
#endif
#include <TimeLib.h>
#include <SensorDriver.h>
#include <i2c_utility.h>
#include <arduinoJsonRPC.h>
 
#if (MODULE_TYPE == STIMA_MODULE_TYPE_SAMPLE_ETH || MODULE_TYPE == STIMA_MODULE_TYPE_REPORT_ETH || MODULE_TYPE == STIMA_MODULE_TYPE_PASSIVE_ETH)
#include <ethernet_config.h>
#include <Ethernet2.h>
#if (USE_MQTT)
#include <IPStack.h>
#endif
 
#elif (MODULE_TYPE == STIMA_MODULE_TYPE_SAMPLE_GSM || MODULE_TYPE == STIMA_MODULE_TYPE_REPORT_GSM || MODULE_TYPE == STIMA_MODULE_TYPE_PASSIVE_GSM)
#include <gsm_config.h>
#include <sim800Client.h>
#if (USE_MQTT)
#include <Sim800IPStack.h>
#endif
 
#endif
 
#if (USE_MQTT)
#include <Countdown.h>
#include <MQTTClient.h>
 
#endif
 
/*********************************************************************
* TYPEDEF
*********************************************************************/
 
typedef struct {
   char btable[CONSTANTDATA_BTABLE_LENGTH];                 
   char value[CONSTANTDATA_VALUE_LENGTH];                   
} constantdata_t;
 
typedef struct {
   uint8_t module_main_version;                             
   uint8_t module_configuration_version;                    
   uint8_t module_type;                                     
 
   #if (USE_MQTT)
   uint16_t mqtt_port;                                      
   char mqtt_server[MQTT_SERVER_LENGTH];                    
   char mqtt_root_topic[MQTT_ROOT_TOPIC_LENGTH];            
   char mqtt_maint_topic[MQTT_MAINT_TOPIC_LENGTH];          
   char mqtt_rpc_topic[MQTT_RPC_TOPIC_LENGTH];              
   char mqtt_username[MQTT_USERNAME_LENGTH];                
   char mqtt_password[MQTT_PASSWORD_LENGTH];                
   char stationslug[STATIONSLUG_LENGTH];                    
   char boardslug[BOARDSLUG_LENGTH];                        
   #endif
 
   #if (USE_NTP)
   char ntp_server[NTP_SERVER_LENGTH];                      
   #endif
 
   sensor_t sensors[SENSORS_MAX];                           
   uint8_t sensors_count;                                   
   uint16_t report_seconds;                                 
 
   constantdata_t constantdata[USE_CONSTANTDATA_COUNT];     
   uint8_t constantdata_count;                              
  
   #if (MODULE_TYPE == STIMA_MODULE_TYPE_SAMPLE_ETH || MODULE_TYPE == STIMA_MODULE_TYPE_REPORT_ETH || MODULE_TYPE == STIMA_MODULE_TYPE_PASSIVE_ETH)
   bool is_dhcp_enable;                                     
   uint8_t ethernet_mac[ETHERNET_MAC_LENGTH];               
   uint8_t ip[ETHERNET_IP_LENGTH];                          
   uint8_t netmask[ETHERNET_IP_LENGTH];                     
   uint8_t gateway[ETHERNET_IP_LENGTH];                     
   uint8_t primary_dns[ETHERNET_IP_LENGTH];                 
 
   #elif (MODULE_TYPE == STIMA_MODULE_TYPE_SAMPLE_GSM || MODULE_TYPE == STIMA_MODULE_TYPE_REPORT_GSM || MODULE_TYPE == STIMA_MODULE_TYPE_PASSIVE_GSM)
   char gsm_apn[GSM_APN_LENGTH];                            
   char gsm_username[GSM_USERNAME_LENGTH];                  
   char gsm_password[GSM_PASSWORD_LENGTH];                  
 
   #endif
} configuration_t;
 
 
/*********************************************************************
* TYPEDEF for Finite State Machine
*********************************************************************/
 
typedef enum {
   INIT,                      
   #if (USE_POWER_DOWN)
   ENTER_POWER_DOWN,          
   #endif
   TASKS_EXECUTION,           
   END,                        
   REBOOT                     
} state_t;
 
typedef enum {
   SUPERVISOR_INIT,                          
   SUPERVISOR_CONNECTION_LEVEL_TASK,         
   SUPERVISOR_WAIT_CONNECTION_LEVEL_TASK,    
   SUPERVISOR_TIME_LEVEL_TASK,               
   SUPERVISOR_MANAGE_LEVEL_TASK,             
   SUPERVISOR_TEST_SDCARD,
   SUPERVISOR_END,                           
   SUPERVISOR_WAIT_STATE                     
} supervisor_state_t;
 
#if (MODULE_TYPE == STIMA_MODULE_TYPE_SAMPLE_ETH || MODULE_TYPE == STIMA_MODULE_TYPE_REPORT_ETH || MODULE_TYPE == STIMA_MODULE_TYPE_PASSIVE_ETH)
typedef enum {
   ETHERNET_INIT,             
   ETHERNET_CONNECT,          
   ETHERNET_OPEN_UDP_SOCKET,  
   ETHERNET_END,              
   ETHERNET_WAIT_STATE        
} ethernet_state_t;
 
#elif (MODULE_TYPE == STIMA_MODULE_TYPE_SAMPLE_GSM || MODULE_TYPE == STIMA_MODULE_TYPE_REPORT_GSM || MODULE_TYPE == STIMA_MODULE_TYPE_PASSIVE_GSM)
typedef enum {
   GSM_INIT,                  
   GSM_SWITCH_ON,             
   GSM_AUTOBAUD,              
   GSM_SETUP,                 
   GSM_START_CONNECTION,      
   GSM_CHECK_OPERATION,       
   GSM_OPEN_UDP_SOCKET,       
   GSM_SUSPEND,               
   GSM_STOP_CONNECTION,       
   GSM_WAIT_FOR_SWITCH_OFF,   
   GSM_SWITCH_OFF,            
   GSM_END,                   
   GSM_WAIT_STATE             
} gsm_state_t;
 
#endif
 
typedef enum {
   SENSORS_READING_INIT,            
   SENSORS_SETUP_CHECK,             
   SENSORS_READING_PREPARE,         
   SENSORS_READING_IS_PREPARED,     
   SENSORS_READING_GET,             
   SENSORS_READING_IS_GETTED,       
   SENSORS_READING_READ,            
   SENSORS_READING_NEXT,            
   SENSORS_READING_END,             
   SENSORS_READING_WAIT_STATE       
} sensors_reading_state_t;
 
typedef enum {
   TIME_INIT,                    
   TIME_SEND_ONLINE_REQUEST,     
   TIME_WAIT_ONLINE_RESPONSE,    
   TIME_SET_SYNC_NTP_PROVIDER,   
   TIME_SET_SYNC_RTC_PROVIDER,   
   TIME_END,                     
   TIME_WAIT_STATE               
} time_state_t;
 
#if (USE_SDCARD)
typedef enum {
   DATA_SAVING_INIT,          
   DATA_SAVING_OPEN_SDCARD,   
   DATA_SAVING_OPEN_FILE,     
   DATA_SAVING_SENSORS_LOOP,  
   DATA_SAVING_DATA_LOOP,     
   DATA_SAVING_WRITE_FILE,    
   DATA_SAVING_CLOSE_FILE,    
   DATA_SAVING_END,           
   DATA_SAVING_WAIT_STATE     
} data_saving_state_t;
#endif
 
#if (USE_MQTT)
typedef enum {
   MQTT_INIT,              
 
   MQTT_OPEN_SDCARD,       
   MQTT_OPEN_PTR_FILE,     
   MQTT_PTR_READ,          
   MQTT_PTR_FIND,          
   MQTT_PTR_FOUND,         
   MQTT_PTR_END,           
 
   MQTT_OPEN,              
   MQTT_CHECK,             
   MQTT_CONNECT,           
   MQTT_ON_CONNECT,        
   MQTT_SUBSCRIBE,         
   MQTT_CONSTANTDATA,      
 
   MQTT_OPEN_DATA_FILE,    
 
   MQTT_SENSORS_LOOP,      
   MQTT_DATA_LOOP,         
   MQTT_SD_LOOP,           
   MQTT_PUBLISH,           
 
   MQTT_CLOSE_DATA_FILE,   
 
   MQTT_DISCONNECT,        
   MQTT_RPC_DELAY,         
   MQTT_ON_DISCONNECT,     
 
   MQTT_PTR_UPDATE,        
   MQTT_CLOSE_PTR_FILE,    
   //   MQTT_CLOSE_SDCARD,      //!< close sdcard
 
   MQTT_END,               
   MQTT_WAIT_STATE,        
   MQTT_WAIT_STATE_RPC     
} mqtt_state_t;
#endif
 
typedef enum {
   RPC_INIT,            
   RPC_EXECUTE,         
   RPC_END              
} rpc_state_t;
 
/*********************************************************************
* GLOBAL VARIABLE
*********************************************************************/
 
uint8_t sensors_count = 0;
 
bool  is_datetime_set;
 
bool  have_to_reboot;
 
configuration_t readable_configuration;
 
configuration_t writable_configuration;
 
volatile uint8_t ready_tasks_count;
 
uint32_t awakened_event_occurred_time_ms;
 
JsonRPC streamRpc(false);
 
#if (USE_SDCARD)
SdFat SD;
 
#if (ENABLE_SDCARD_LOGGING)   
File logFile;
 
 
WriteLoggingStream loggingStream(logFile,Serial);
#endif
 
File read_data_file;
 
File write_data_file;
 
File test_file;
#endif
 
#if (USE_MQTT)
File mqtt_ptr_file;
 
bool is_mqtt_rpc_delay; 
 
char rpcpayload[MQTT_RPC_RESPONSE_LENGTH];
 
 
bool mqtt_session_present;
 
#endif
 
#if (MODULE_TYPE == STIMA_MODULE_TYPE_SAMPLE_ETH || MODULE_TYPE == STIMA_MODULE_TYPE_REPORT_ETH || MODULE_TYPE == STIMA_MODULE_TYPE_PASSIVE_ETH)
EthernetUDP eth_udp_client;
 
EthernetClient eth_tcp_client;
 
#if (USE_MQTT)
IPStack ipstack(eth_tcp_client);
#endif
 
#elif (MODULE_TYPE == STIMA_MODULE_TYPE_SAMPLE_GSM || MODULE_TYPE == STIMA_MODULE_TYPE_REPORT_GSM || MODULE_TYPE == STIMA_MODULE_TYPE_PASSIVE_GSM)
sim800Client s800;
 
#if (USE_MQTT)
IPStack ipstack(s800);
#endif
 
#endif
 
#if (USE_MQTT)
MQTT::Client<IPStack, Countdown, MQTT_PACKET_SIZE, 1> mqtt_client = MQTT::Client<IPStack, Countdown, MQTT_PACKET_SIZE, 1>(ipstack, IP_STACK_TIMEOUT_MS);
 
#endif
 
#if (USE_LCD)
hd44780_I2Cexp lcd;
 
 
uint8_t display_set = 1;
 
#endif
 
SensorDriver *sensors[SENSORS_MAX];
 
bool is_first_run;
 
bool do_reset_first_run;
 
bool is_first_test;
 
bool is_test;
 
bool is_time_set;
 
bool is_time_for_sensors_reading_updated;
 
bool is_client_connected;
 
bool is_client_udp_socket_open;
 
bool is_event_client_executed;
 
bool is_event_time_executed;
 
bool do_ntp_sync;
 
time_t last_ntp_sync;
 
#if (USE_LCD)
time_t last_lcd_begin;
 
bool lcd_error;
 
#endif
 
#if (USE_SDCARD)
bool is_sdcard_open;
 
bool is_sdcard_error;
#endif
 
#if (USE_MQTT)
 
char client_id[MQTT_CLIENT_ID_LENGTH];
 
char maint_topic[MQTT_ROOT_TOPIC_LENGTH + MQTT_SENSOR_TOPIC_LENGTH];
#endif
 
char json_sensors_data[SENSORS_MAX][JSON_BUFFER_LENGTH];
 
char json_sensors_data_test[JSON_BUFFER_LENGTH];
 
volatile time_t system_time;
 
volatile time_t next_ptr_time_for_sensors_reading;
 
volatile time_t next_ptr_time_for_testing_sensors;
 
 
uint8_t sensor_reading_failed_count;
 
volatile tmElements_t sensor_reading_time;
 
time_t ptr_time_data;
 
char stima_name[20];
 
state_t state;
 
supervisor_state_t supervisor_state;
 
#if (MODULE_TYPE == STIMA_MODULE_TYPE_SAMPLE_ETH || MODULE_TYPE == STIMA_MODULE_TYPE_REPORT_ETH || MODULE_TYPE == STIMA_MODULE_TYPE_PASSIVE_ETH)
ethernet_state_t ethernet_state;
 
#elif (MODULE_TYPE == STIMA_MODULE_TYPE_SAMPLE_GSM || MODULE_TYPE == STIMA_MODULE_TYPE_REPORT_GSM || MODULE_TYPE == STIMA_MODULE_TYPE_PASSIVE_GSM)
gsm_state_t gsm_state;
 
#endif
 
uint8_t i2c_error;
 
time_state_t time_state;
 
sensors_reading_state_t sensors_reading_state;
 
#if (USE_SDCARD)
data_saving_state_t data_saving_state;
#endif
 
#if (USE_MQTT)
mqtt_state_t mqtt_state;
#endif
 
rpc_state_t rpc_state;
/*********************************************************************
* FUNCTIONS
*********************************************************************/
void realreboot();
time_t getSystemTime();
 
void init_logging(void);
 
void init_power_down(uint32_t *time_ms, uint32_t debouncing_ms);
 
void init_wdt(uint8_t wdt_timer);
 
void init_system(void);
 
void init_rpc(void);
 
void init_buffers(void);
 
void init_tasks(void);
 
void init_pins(void);
 
void init_wire(void);
 
void init_spi(void);
 
void init_rtc(void);
 
#if (USE_TIMER_1)
void init_timer1(void);
 
void start_timer(void);
 
void stop_timer(void);
#endif
 
void interrupt_task_1s(void);
 
void init_sensors(void);
 
void print_configuration(void);
 
void load_configuration(void);
 
void save_configuration(bool);
 
void set_default_configuration(void);
 
void setNextTimeForSensorReading(time_t *next_time, uint16_t time_s);
 
#if (USE_MQTT)
bool mqttConnect(char *username, char *password);
 
bool mqttPublish(const char *topic, const char *message, bool is_retained = false);
 
void mqttRxCallback(MQTT::MessageData &md);
#endif
 
bool extractSensorsParams(JsonObject &params, char *driver, char *type, uint8_t *address, uint8_t *node);
 
int configure(JsonObject &params, JsonObject &result);
 
int prepare(JsonObject &params, JsonObject &result);
 
int getjson(JsonObject &params, JsonObject &result);
 
int prepandget(JsonObject &params, JsonObject &result);
 
int reboot(JsonObject &params, JsonObject &result);
 
/*********************************************************************
* TASKS
*********************************************************************/
bool is_event_supervisor;
 
void supervisor_task(void);
 
volatile bool is_event_sensors_reading;
 
bool is_event_sensors_reading_rpc;
 
void sensors_reading_task (bool do_prepare = true, bool do_get = true, char *driver = NULL, char *type = NULL, uint8_t address = 0, uint8_t node = 0, uint8_t *sensor_index = 0, uint32_t *wait_time = NULL);
 
volatile bool is_event_rtc;
 
void rtc_task(void);
 
volatile bool is_event_time;
 
void time_task(void);
 
#if (MODULE_TYPE == STIMA_MODULE_TYPE_SAMPLE_ETH || MODULE_TYPE == STIMA_MODULE_TYPE_REPORT_ETH || MODULE_TYPE == STIMA_MODULE_TYPE_PASSIVE_ETH)
bool is_event_ethernet;
 
void ethernet_task(void);
 
#elif (MODULE_TYPE == STIMA_MODULE_TYPE_SAMPLE_GSM || MODULE_TYPE == STIMA_MODULE_TYPE_REPORT_GSM || MODULE_TYPE == STIMA_MODULE_TYPE_PASSIVE_GSM)
bool is_event_gsm;
 
void gsm_task(void);
 
#endif
 
#if (USE_SDCARD)
bool is_event_data_saving;
 
void data_saving_task(void);
#endif
 
#if (USE_MQTT)
bool is_event_mqtt;
 
bool is_event_mqtt_paused;
 
void mqtt_task(void);
#endif
 
bool is_event_rpc;
 
/*********************************************************************
* INTERRUPT HANDLER
*********************************************************************/
void rtc_interrupt_handler(void);
 
 
#ifndef ARDUINO_ARCH_AVR
#include <IWatchdog.h>
#include "STM32LowPower.h"
#include <STM32RTC.h>
#include <rtc.h>
 
/* Get the rtc object */
STM32RTC& rtc = STM32RTC::getInstance();
 
HardwareSerial Serial1(PB11, PB10);
 
void wdt_enable(int wdt_timer){
  IWatchdog.begin(wdt_timer*1000000);
};
void wdt_reset(){
  IWatchdog.reload();
};
void wdt_disable(){
  //WARNING: Once started the IWDG timer can not be stopped.
  IWatchdog.begin(32000000);  // set to maximum value
};
 
void power_adc_disable(){};
void power_spi_disable(){};
void power_timer0_disable(){};
void power_timer1_disable(){};
void power_timer2_disable(){};
void power_adc_enable(){};
void power_spi_enable(){};
void power_timer0_enable(){};
 
void power_timer1_enable(){};
void power_timer2_enable(){};
 
 
// To be done
// manage sleep mode: RTC and timer 1 ....
void set_sleep_mode(int SLEEP_MODE_PWR_DOWN){
  // Select RTC clock source: LSI_CLOCK, LSE_CLOCK or HSE_CLOCK.
  // By default the LSI is selected as source.
  /*
  rtc.setClockSource(STM32RTC::LSE_CLOCK);
  rtc.begin();
  LowPower.begin();
  */
};
void sleep_enable(){};
void sleep_cpu(){
  //LowPower.deepSleep(1000);
};
void sleep_disable(){};
 
#define WDTO_1S 1
#define SLEEP_MODE_PWR_DOWN 1
 
#endif
 
 
#endif