i2c-opc.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 _I2C_OPC_H
#define _I2C_OPC_H
 
#include "i2c-opc-config.h"
#include <debug.h>
#include <i2c_config.h>
#include <avr/sleep.h>
#include <avr/power.h>
#include <avr/wdt.h>
#include <i2c_utility.h>
#include <rmap_utility.h>
#if (USE_JSON)
#include <json_utility.h>
#endif
#include <eeprom_utility.h>
#include <Wire.h>
#include <TimeLib.h>
#include <typedef.h>
#include <registers-opc.h>
#include <opcxx.h>
#include <debug_config.h>
#include <SdFat.h>
#include <StreamUtils.h>
#include <ArduinoLog.h>
 
 
/*********************************************************************
* TYPEDEF
*********************************************************************/
typedef struct {
   uint8_t module_version;             
   uint8_t module_type;                
   uint8_t i2c_address;                
   bool is_oneshot;                    
   bool is_continuous;                 
   // uint8_t configuration_variables[OPCXX_CONFIGURATION_VARIABLES_LENGTH];
   // uint8_t configuration_variables_2[OPCXX_CONFIGURATION_VARIABLES_2_LENGTH];
} configuration_t;
 
#if (USE_SENSOR_OE3)
typedef struct {
  float sample; 
  // float med60;  //!< last observation
  float med;    
  // float max;    //!< maximum values of observations
  // float min;    //!< minium values of observations
  float sigma;  
} temperature_value_t;
 
typedef struct {
  float sample; 
  // float med60;  //!< last observation
  float med;    
  // float max;    //!< maximum values of observations
  // float min;    //!< minium values of observations
  float sigma;  
} humidity_value_t;
#endif
 
typedef struct {
  float sample; 
  // float med60;  //!< last observation
  float med;    
  // float max;    //!< maximum values of observations
  // float min;    //!< minium values of observations
  float sigma;  
} pm_value_t;
 
typedef struct {
  uint16_t sample; 
  // uint16_t med60;  //!< last observation
  uint16_t med;    
  // uint16_t max;    //!< maximum values of observations
  // uint16_t min;    //!< minium values of observations
  uint16_t sigma;  
} bin_value_t;
 
typedef struct {
   uint8_t module_type;                 
   uint8_t module_version;              
 
   float pm_sample[OPCXX_PM_LENGTH];
   float pm_med[OPCXX_PM_LENGTH];
   float pm_sigma[OPCXX_PM_LENGTH];
 
   uint16_t bins_med[OPCN3_BINS_LENGTH];
   uint16_t bins_sigma[OPCN3_BINS_LENGTH];
 
   #if (USE_SENSOR_OE3)
   float temperature_sample;
   float humidity_sample;
 
   float temperature_med;
   float humidity_med;
   #endif
 
   pm_value_t pm1;                      
   pm_value_t pm25;                     
   pm_value_t pm10;                     
   bin_value_t bins[OPC_BINS_LENGTH];   
 
   #if (USE_SENSOR_OE3)
   temperature_value_t temperature;
   humidity_value_t humidity;
   #endif
} readable_data_t;
 
typedef struct {
   uint8_t i2c_address;                
   bool is_oneshot;                    
   bool is_continuous;                 
} writable_data_t;
 
typedef struct {
  float values;          
  uint8_t count;         
  uint8_t error_count;   
} sample_t;
 
typedef struct {
   float med[OBSERVATION_COUNT];        
   uint16_t count;                      
   float *read_ptr;                     
   float *write_ptr;                    
} float_observation_t;
 
typedef struct {
   uint16_t med[OBSERVATION_COUNT];        
   uint16_t count;                      
   uint16_t *read_ptr;                     
   uint16_t *write_ptr;                    
} uint16_observation_t;
 
/*********************************************************************
* TYPEDEF for Finite State Machine
*********************************************************************/
typedef enum {
   INIT,                      
   #if (USE_POWER_DOWN)
   ENTER_POWER_DOWN,          
   #endif
   TASKS_EXECUTION,           
   END                        
} state_t;
 
typedef enum {
  OPC_INIT,
  OPC_SWITCH_ON,
  OPC_SEND_COMMAND_FAN_DAC,
  OPC_WAIT_RESULT_FAN_DAC,
  OPC_SEND_COMMAND_FAN_ON,
  OPC_WAIT_RESULT_FAN_ON,
  OPC_SEND_COMMAND_LASER_ON,
  OPC_WAIT_RESULT_LASER_ON,
  OPC_SEND_COMMAND_READ_HISTOGRAM,
  OPC_WAIT_RESULT_READ_HISTOGRAM,
  OPC_READ_HISTOGRAM,
  OPC_END,             
  OPC_WAIT_STATE       
} opc_state_t;
 
/*********************************************************************
* GLOBAL VARIABLE
*********************************************************************/
 
#if (ENABLE_SDCARD_LOGGING)   
SdFat SD;
 
File logFile;
 
WriteLoggingStream loggingStream(logFile,Serial);
#endif
 
configuration_t configuration;
 
volatile readable_data_t readable_data_1;
 
volatile readable_data_t readable_data_2;
 
volatile readable_data_t *readable_data_read_ptr;
 
volatile readable_data_t *readable_data_write_ptr;
 
volatile readable_data_t *readable_data_temp_ptr;
 
writable_data_t writable_data;
 
writable_data_t *writable_data_ptr;
 
volatile uint8_t readable_data_address;
 
volatile uint8_t readable_data_length;
 
volatile uint8_t i2c_rx_data[I2C_MAX_DATA_LENGTH];
 
volatile uint8_t i2c_error;
 
volatile uint8_t ready_tasks_count;
 
uint32_t awakened_event_occurred_time_ms;
 
bool is_start;
 
bool is_stop;
 
bool is_oneshot;
 
bool is_continuous;
 
// bool is_read_configuration_variable;
 
// sample_t opc_samples;
sample_t pm1_samples;
sample_t pm25_samples;
sample_t pm10_samples;
sample_t bins_samples[OPC_BINS_LENGTH];
#if (USE_SENSOR_OE3)
sample_t temperature_samples;
sample_t humidity_samples;
#endif
 
float_observation_t pm1_observations;
float_observation_t pm25_observations;
float_observation_t pm10_observations;
uint16_observation_t bins_observations[OPC_BINS_LENGTH];
#if (USE_SENSOR_OE3)
float_observation_t temperature_observations;
float_observation_t humidity_observations;
#endif
 
uint8_t samples_count;
 
bool do_buffers_reset;
 
volatile uint16_t timer_counter;
 
state_t state;
 
opc_state_t opc_state;
 
bool is_opc_setted;
bool is_opc_first_read;
uint8_t histogram_error_count;
 
#if (USE_SENSOR_OA2 || USE_SENSOR_OB2 || USE_SENSOR_OC2 || USE_SENSOR_OD2)
Opcn2 opcn(OPC_CHIP_SELECT, OPC_POWER_PIN, OPC_SPI_POWER_PIN, SENSORS_SAMPLE_TIME_MS / 1000);
#endif
 
#if (USE_SENSOR_OA3 || USE_SENSOR_OB3 || USE_SENSOR_OC3 || USE_SENSOR_OD3 || USE_SENSOR_OE3)
Opcn3 opcn(OPC_CHIP_SELECT, OPC_POWER_PIN, OPC_SPI_POWER_PIN, SENSORS_SAMPLE_TIME_MS / 1000);
#endif
 
/*********************************************************************
* FUNCTIONS
*********************************************************************/
 
void init_logging();
 
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_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 init_sensors(void);
 
void print_configuration(void);
 
void load_configuration(void);
 
void save_configuration(bool);
 
void commands(void);
 
void reset_samples_buffer(void);
 
// void reset_observations_buffer(void);
 
void exchange_buffers(void);
 
template<typename sample_g, typename observation_g, typename values_v, typename value_v> void addSample(sample_g *sample, observation_g *observation, values_v *values, value_v value);
 
template<typename observation_g, typename value_v> value_v readCurrentObservation(observation_g *buffer);
template<typename observation_g, typename value_v> void writeCurrentObservation(observation_g *buffer, value_v value);
template<typename observation_g, typename length_v> void resetObservation(observation_g *buffer, length_v length);
template<typename observation_g, typename length_v> void resetBackPmObservation(observation_g *buffer, length_v length);
template<typename observation_g, typename length_v> void incrementObservation(observation_g *buffer, length_v length);
template<typename observation_g, typename length_v, typename value_v> void addObservation(observation_g *buffer, length_v length, value_v value);
template<typename observation_g, typename length_v, typename value_v> value_v readBackObservation(observation_g *buffer, length_v length);
 
 
void samples_processing(bool is_force_processing);
 
bool observations_processing(void);
 
template<typename sample_g, typename observation_g> bool make_observation_from_samples(bool is_force_processing, sample_g *sample, observation_g *observation);
 
 
template<typename sample_g, typename observation_g, typename value_v, typename val_v> bool make_value_from_samples_and_observations(sample_g *sample, observation_g *observation, value_v *value);
 
/*********************************************************************
* TASKS
*********************************************************************/
volatile bool is_event_opc_task;
 
void opc_task(void);
 
volatile bool is_event_command_task;
 
void command_task(void);
 
/*********************************************************************
* INTERRUPTS HANDLER
*********************************************************************/
void i2c_request_interrupt_handler(void);
 
void i2c_receive_interrupt_handler(void);
 
#endif