i2c-wind.h

/*********************************************************************
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_WIND_H
#define _I2C_WIND_H
 
#include "i2c-wind-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>
#include <sdcard_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-wind.h>
#include <debug_config.h>
#include <SdFat.h>
#include <StreamUtils.h>
#include <ArduinoLog.h>
#include <CircularBuffer.h>
 
/*********************************************************************
* TYPEDEF
*********************************************************************/
typedef struct {
   uint8_t module_main_version;        
   uint8_t module_configuration_version;   
   uint8_t module_type;                
   uint8_t i2c_address;                
   bool is_oneshot;                    
   float adc_voltage_offset_1;
   float adc_voltage_offset_2;
   float adc_voltage_min;
   float adc_voltage_max;
} configuration_t;
 
typedef struct {
  uint16_t sample_speed;           // B11002   254,0,0
  uint16_t sample_direction;       // B11001   254,0,0
 
  // DWA
  uint16_t vavg10_speed;           // B11002   254,0,0
  uint16_t vavg10_direction;       // B11001   254,0,0
 
  // DWB
  uint16_t vavg_speed;             // B11002   200,0,900
  uint16_t vavg_direction;         // B11001   200,0,900
 
  // DWC
  uint16_t peak_gust_speed;        // B11041   2,0,900
  uint16_t long_gust_speed;        // B11209   2,0,900
 
  // DWD
  uint16_t avg_speed;              // B11002   0,0,900
 
  // DWE
  uint8_t class_1;                // B11211   9,0,900
  uint8_t class_2;                // B11212   9,0,900
  uint8_t class_3;                // B11213   9,0,900
  uint8_t class_4;                // B11214   9,0,900
  uint8_t class_5;                // B11215   9,0,900
  uint8_t class_6;                // B11216   9,0,900
  // dtable={"51":["B11211","B11212","B11213","B11214","B11215","B11216"]}
 
  // DWF
  uint16_t peak_gust_direction;    // B11043   205,0,900
  uint16_t long_gust_direction;    // B11210   205,0,900
 
} report_t;
 
typedef struct {
   uint8_t module_type;                
   uint8_t module_main_version;        
   uint8_t module_minor_version;       
  report_t wind;
} readable_data_t;
 
typedef struct {
   uint8_t i2c_address;                
   bool is_oneshot;                    
   float adc_voltage_offset_1;
   float adc_voltage_offset_2;
   float adc_voltage_min;
   float adc_voltage_max;
} writable_data_t;
 
/*********************************************************************
* TYPEDEF for Finite State Machine
*********************************************************************/
typedef enum {
   INIT,                      
   #if (USE_POWER_DOWN)
   ENTER_POWER_DOWN,          
   #endif
   TASKS_EXECUTION,           
   END                        
} state_t;
 
typedef enum {
  WIND_INIT,
  WIND_READING,
  WIND_ELABORATE,
  WIND_END,             
  WIND_WAIT_STATE       
} wind_state_t;
 
/*********************************************************************
* GLOBAL VARIABLE
*********************************************************************/
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 lastcommand;
 
volatile uint8_t i2c_error;
 
volatile uint8_t i2c_time;
 
volatile uint8_t ready_tasks_count;
 
uint32_t awakened_event_occurred_time_ms;
 
volatile bool inside_transaction;
 
volatile uint16_t transaction_time;
 
 
#if (USE_SENSOR_DES)
CircularBuffer<unsigned int, WMO_REPORT_SAMPLES_COUNT> cb_speed;
#endif
 
#if (USE_SENSOR_DED)
CircularBuffer<unsigned int, WMO_REPORT_SAMPLES_COUNT> cb_direction;
#endif
 
#if (USE_SENSOR_GWS)
CircularBuffer<unsigned int, WMO_REPORT_SAMPLES_COUNT> cb_speed;
CircularBuffer<unsigned int, WMO_REPORT_SAMPLES_COUNT> cb_direction;
#endif
 
volatile uint16_t timer_counter_ms;
 
#if (USE_SENSOR_DED || USE_SENSOR_DES || USE_SENSOR_GWS)
volatile bool is_wind_on;
#endif
 
#if (USE_SENSOR_DES)
volatile uint32_t wind_speed_count;
volatile uint16_t wind_speed;
#endif
 
state_t state;
 
wind_state_t wind_state;
 
 
#if (ENABLE_SDCARD_LOGGING)   
SdFat SD;
 
File logFile;
 
WriteLoggingStream loggingStream(logFile,Serial);
#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 tests(void);
 
void reset_samples_buffer(void);
 
// void reset_observations_buffer(void);
 
void reset_report_buffer(void);
 
void exchange_buffers(void);
 
/*
template<typename buffer_g, typename length_v, typename value_v> value_v bufferRead(buffer_g *buffer, length_v length);
template<typename buffer_g, typename length_v, typename value_v> value_v bufferReadBack(buffer_g *buffer, length_v length);
template<typename buffer_g, typename value_v> void bufferWrite(buffer_g *buffer, value_v value);
template<typename buffer_g> void bufferPtrReset(buffer_g *buffer);
template<typename buffer_g, typename length_v> void bufferPtrResetBack(buffer_g *buffer, length_v length);
template<typename buffer_g, typename length_v> void incrementBuffer(buffer_g *buffer, length_v length);
template<typename buffer_g, typename length_v, typename value_v> void bufferReset(buffer_g *buffer, length_v length);
template<typename buffer_g, typename length_v, typename value_v> void addValue(buffer_g *buffer, length_v length, value_v value);
*/
 
void make_report (bool init=false);
 
 
void elaborate_circular_buffer(void);
 
 
void getSDFromUV (float, float, float *, float *);
 
#if (USE_SENSOR_DED || USE_SENSOR_DES)
#define windDirectionRead()           (analogRead(WIND_DIRECTION_ANALOG_PIN))
#define isWindOn()                    (is_wind_on)
#define isWindOff()                   (!is_wind_on)
 
void windPowerOff(void);
void windPowerOn(void);
void wind_speed_interrupt_handler(void);
void calibrationOffset(uint8_t count, uint8_t delay_ms, float *offset, float ideal);
void calibrationValue(uint8_t count, uint8_t delay_ms, float *value);
float getWindMv(float adc_value);
float getWindDirection(float adc_value);
float getWindSpeed (float count);
#endif
 
#if (USE_SENSOR_GWS)
#define isWindOn()                    (is_wind_on)
#define isWindOff()                   (!is_wind_on)
 
void windPowerOff(void);
void windPowerOn(void);
void serial1_reset(void);
bool windsonic_interpreter (uint16_t *speed, uint16_t *direction);
 
uint16_t uart_rx_buffer_length;
uint8_t uart_rx_buffer[UART_RX_BUFFER_LENGTH];
#endif
 
/*********************************************************************
* TASKS
*********************************************************************/
 
volatile bool is_event_activate_wind_task;
 
volatile bool is_event_wind_task;
 
void wind_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