elaborate_data_task.h

Go to the documentation of this file.

 
#ifndef _ELABORATE_DATA_TASK_H
#define _ELABORATE_DATA_TASK_H
 
#include "debug_config.h"
#include "local_typedef.h"
#include "stima_utility.h"
#include "str.h"
 
#include <STM32FreeRTOS.h>
#include "thread.hpp"
#include "ticks.hpp"
#include "semaphore.hpp"
#include "queue.hpp"
#include "drivers/module_slave_hal.hpp"
 
#include "debug_F.h"
 
#include <STM32RTC.h>
 
using namespace cpp_freertos;
 
// Main TASK Switch Delay
#define ELABORATE_TASK_WAIT_DELAY_MS      (20)
#define ELABORATE_TASK_SLEEP_DELAY_MS     (850)
 
#define CLOGGED_TIMINGS_VERIFY            (28800)
 
typedef struct {
  rmapdata_t values[SAMPLES_COUNT_MAX];   
  uint16_t count;                         
  rmapdata_t *read_ptr;                   
  rmapdata_t *write_ptr;                  
} sample_t;
 
typedef struct {
  bool values[SAMPLES_COUNT_MAX];         
  uint16_t count;                         
  bool *read_ptr;                         
  bool *write_ptr;                        
} maintenance_t;
 
typedef struct {
  configuration_t *configuration;                       
  system_status_t *system_status;                       
  cpp_freertos::BinarySemaphore *configurationLock;     
  cpp_freertos::BinarySemaphore *systemStatusLock;      
  cpp_freertos::Queue *systemMessageQueue;              
  cpp_freertos::Queue *elaborateDataQueue;              
  cpp_freertos::Queue *requestDataQueue;                
  cpp_freertos::Queue *reportDataQueue;                 
  cpp_freertos::Queue *rainQueue;                       
} ElaborateDataParam_t;
 
class ElaborateDataTask : public cpp_freertos::Thread {
 
  typedef enum {
    ELABORATE_DATA_CREATE,
    ELABORATE_DATA_INIT,
    ELABORATE_DATA_RUN,
    ELABORATE_DATA_SUSPEND
  } State_t;
 
public:
  ElaborateDataTask(const char *taskName, uint16_t stackSize, uint8_t priority, ElaborateDataParam_t elaborateDataParam);
 
protected:
  virtual void Run();
 
private:
 
  #if (ENABLE_STACK_USAGE)
  void TaskMonitorStack();
  #endif
  void TaskWatchDog(uint32_t millis_standby);
  void TaskState(uint8_t state_position, uint8_t state_subposition, task_flag state_operation);
 
  void make_report(uint16_t report_time_s = REPORTS_TIME_S, uint8_t observation_time_s = OBSERVATIONS_TIME_S);
  uint8_t checkRain(void);
 
  // Rtc check event access
  STM32RTC &rtc = STM32RTC::getInstance();
 
  State_t state;
  ElaborateDataParam_t param;
 
  sample_t rain_samples;
 
  rain_t rain_elaborate;
  report_t report_last;
  report_t report;
};
 
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);
 
#endif