event_logger.h

[詳解]

 
#ifndef EVENT_LOGGER_H_
#define EVENT_LOGGER_H_
 
// TODO: FALSHメモリ等の大容量不揮発ボリュームへの書き込み
// TODO: EL そのもの全体をビルドする，しないをえらべる ifdef を追加（メモリのため）
// TODO: ObcTime の初期化が OBCT_clear ではなく memset 0x00 である（現状問題ないが，今後問題になるかも）
 
#include <stddef.h>
#include <stdint.h>
#include "../../TlmCmd/common_cmd_packet.h"
#include "../TimeManager/obc_time.h"
 
// EL_GROUP (uint32_t を想定) をここで定義する
#include <src_user/Settings/System/event_logger_group.h>
 
#define EL_TLOG_TLM_PAGE_SIZE         (28)    
#define EL_TLOG_TLM_PAGE_MAX_HIGH     (4)     
#define EL_TLOG_TLM_PAGE_MAX_MIDDLE   (4)     
#define EL_TLOG_TLM_PAGE_MAX_LOW      (4)     
#define EL_CLOG_TLM_PAGE_SIZE         (18)    
#define EL_CLOG_TLM_PAGE_MAX_HIGH     (4)     
#define EL_CLOG_TLM_PAGE_MAX_MIDDLE   (4)     
#define EL_CLOG_TLM_PAGE_MAX_LOW      (4)     
 
#define EL_TLOG_LOG_SIZE_MAX_EL       (16)    
#define EL_CLOG_LOG_SIZE_MAX_EL       (8)     
#define EL_TLOG_LOG_SIZE_MAX_EH       (16)    
#define EL_CLOG_LOG_SIZE_MAX_EH       (8)     
 
#define EL_IS_ENABLE_TLOG                     
#define EL_IS_ENABLE_CLOG                     
// #define EL_IS_ENABLE_NVLOG                 //!< TODO: NvLog (不揮発Log) を有効にするか？
#define EL_IS_ENABLE_EVENT_NOTE               
#define EL_IS_ENABLE_MIDDLE_ERROR_LEVEL       
#define EL_IS_ENABLE_EL_ERROR_LEVEL           
#define SIZE_OF_EL_CLOG_COUNTER_T      (2)    
 
// 以下 event_logger_params.h にて，以下のような設定を定義する．主にメモリインパクトのために調整可能にしている．
// なお，きちんと動作確認されているのは，EL_IS_ENABLE_MIDDLE_ERROR_LEVEL のみ無効なモードのとき
// #define EL_IS_ENABLE_TLOG: TLog を有効にする？
// #define EL_IS_ENABLE_CLOG: CLog を有効にする？
// #define EL_IS_ENABLE_EVENT_NOTE: EL_Event.note を有効にする？
// #define EL_IS_ENABLE_MIDDLE_ERROR_LEVEL: EL_ERROR_LEVEL_MIDDLE を使えるようにするか？
// #define EL_IS_ENABLE_EL_ERROR_LEVEL: EL_ERROR_LEVEL_EL を使えるようにするか？
// SIZE_OF_EL_CLOG_COUNTER_T: el_clog_counter_t の型サイズ
// 上部で定義されている，各種tableサイズ
#include <src_user/Settings/System/event_logger_params.h>
 
#define EL_LOG_MINIMUM_REQUIRED           (2)   
#define EL_LOG_MINIMUM_REQUIRED_EL_LOG    (4)   
 
#ifdef EL_IS_ENABLE_TLOG
 
#if EL_TLOG_TLM_PAGE_SIZE < EL_LOG_MINIMUM_REQUIRED
#error EL_TLOG_TLM_PAGE_SIZE must be >= EL_LOG_MINIMUM_REQUIRED
#endif
 
#define EL_TLOG_LOG_SIZE_MAX_HIGH     (EL_TLOG_TLM_PAGE_SIZE * EL_TLOG_TLM_PAGE_MAX_HIGH)
#if EL_TLOG_TLM_PAGE_MAX_HIGH <= 0
#error EL_TLOG_TLM_PAGE_MAX_HIGH must be a positive number
#endif
#ifdef EL_IS_ENABLE_MIDDLE_ERROR_LEVEL
#define EL_TLOG_LOG_SIZE_MAX_MIDDLE   (EL_TLOG_TLM_PAGE_SIZE * EL_TLOG_TLM_PAGE_MAX_MIDDLE)
#if EL_TLOG_TLM_PAGE_MAX_MIDDLE <= 0
#error EL_TLOG_TLM_PAGE_MAX_MIDDLE must be a positive number
#endif
#else   // EL_IS_ENABLE_MIDDLE_ERROR_LEVEL
#undef EL_TLOG_TLM_PAGE_MAX_MIDDLE
#endif  // EL_IS_ENABLE_MIDDLE_ERROR_LEVEL
#define EL_TLOG_LOG_SIZE_MAX_LOW      (EL_TLOG_TLM_PAGE_SIZE * EL_TLOG_TLM_PAGE_MAX_LOW)
#if EL_TLOG_TLM_PAGE_MAX_LOW <= 0
#error EL_TLOG_TLM_PAGE_MAX_LOW must be a positive number
#endif
 
#ifdef EL_IS_ENABLE_EL_ERROR_LEVEL
#if EL_TLOG_LOG_SIZE_MAX_EL < EL_LOG_MINIMUM_REQUIRED_EL_LOG
#error EL_TLOG_LOG_SIZE_MAX_EL is too small
#endif
#else   // EL_IS_ENABLE_EL_ERROR_LEVEL
#undef EL_TLOG_LOG_SIZE_MAX_EL
#endif  // EL_IS_ENABLE_EL_ERROR_LEVEL
 
// FIXME: event_logger.h と event_handler.h が相互 include になってしまいビルドできないので，一時的にこのアサーションを無効化
// #include "event_handler.h"
// #if EL_TLOG_LOG_SIZE_MAX_EH <= EH_MAX_RULE_NUM_OF_EL_ID_DUPLICATES
// #error EL_TLOG_LOG_SIZE_MAX_EH is too small
// #endif
#if EL_TLOG_LOG_SIZE_MAX_EH <= 0
#error EL_TLOG_LOG_SIZE_MAX_EH must be a positive number
#endif
 
#else   // EL_IS_ENABLE_TLOG
 
#undef EL_TLOG_TLM_PAGE_SIZE
#undef EL_TLOG_TLM_PAGE_MAX_HIGH
#undef EL_TLOG_TLM_PAGE_MAX_MIDDLE
#undef EL_TLOG_TLM_PAGE_MAX_LOW
#undef EL_TLOG_LOG_SIZE_MAX_EL
#undef EL_TLOG_LOG_SIZE_MAX_EH
 
#endif  // EL_IS_ENABLE_TLOG
 
 
#ifdef EL_IS_ENABLE_CLOG
 
#if EL_CLOG_TLM_PAGE_SIZE < EL_LOG_MINIMUM_REQUIRED
#error EL_CLOG_TLM_PAGE_SIZE must be >= EL_LOG_MINIMUM_REQUIRED
#endif
 
#define EL_CLOG_LOG_SIZE_MAX_HIGH     (EL_CLOG_TLM_PAGE_SIZE * EL_CLOG_TLM_PAGE_MAX_HIGH)
#if EL_CLOG_TLM_PAGE_MAX_HIGH <= 0
#error EL_CLOG_TLM_PAGE_MAX_HIGH must be a positive number
#endif
#ifdef EL_IS_ENABLE_MIDDLE_ERROR_LEVEL
#define EL_CLOG_LOG_SIZE_MAX_MIDDLE   (EL_CLOG_TLM_PAGE_SIZE * EL_CLOG_TLM_PAGE_MAX_MIDDLE)
#if EL_CLOG_TLM_PAGE_MAX_MIDDLE <= 0
#error EL_CLOG_TLM_PAGE_MAX_MIDDLE must be a positive number
#endif
#else   // EL_IS_ENABLE_MIDDLE_ERROR_LEVEL
#undef EL_CLOG_TLM_PAGE_MAX_MIDDLE
#endif  // EL_IS_ENABLE_MIDDLE_ERROR_LEVEL
#define EL_CLOG_LOG_SIZE_MAX_LOW      (EL_CLOG_TLM_PAGE_SIZE * EL_CLOG_TLM_PAGE_MAX_LOW)
#if EL_CLOG_TLM_PAGE_MAX_LOW <= 0
#error EL_CLOG_TLM_PAGE_MAX_LOW must be a positive number
#endif
 
#ifdef EL_IS_ENABLE_EL_ERROR_LEVEL
#if EL_CLOG_LOG_SIZE_MAX_EL < EL_LOG_MINIMUM_REQUIRED_EL_LOG
#error EL_CLOG_LOG_SIZE_MAX_EL is too small
#endif
#else   // EL_IS_ENABLE_EL_ERROR_LEVEL
#undef EL_CLOG_LOG_SIZE_MAX_EL
#endif  // EL_IS_ENABLE_EL_ERROR_LEVEL
 
#if EL_CLOG_LOG_SIZE_MAX_EH <= 0
#error EL_CLOG_LOG_SIZE_MAX_EH must be a positive number
#endif
 
#if SIZE_OF_EL_CLOG_COUNTER_T == 1
typedef uint8_t el_clog_counter_t;
#elif SIZE_OF_EL_CLOG_COUNTER_T == 2
typedef uint16_t el_clog_counter_t;
#elif SIZE_OF_EL_CLOG_COUNTER_T == 4
typedef uint32_t el_clog_counter_t;
#else
#error Illegal value for SIZE_OF_EL_CLOG_COUNTER_T
#endif
 
#else    // EL_IS_ENABLE_CLOG
 
#undef EL_CLOG_TLM_PAGE_SIZE
#undef EL_CLOG_TLM_PAGE_MAX_HIGH
#undef EL_CLOG_TLM_PAGE_MAX_MIDDLE
#undef EL_CLOG_TLM_PAGE_MAX_LOW
#undef EL_CLOG_LOG_SIZE_MAX_EL
#undef EL_CLOG_LOG_SIZE_MAX_EH
 
#endif  // EL_IS_ENABLE_CLOG
 
 
typedef enum
{
  EL_CORE_GROUP_NULL = 0,             
  EL_CORE_GROUP_EVENT_LOGGER,         
  EL_CORE_GROUP_MODE_MANAGER,
  EL_CORE_GROUP_TASK_DISPATCHER,
  EL_CORE_GROUP_APP_MANAGER,
  EL_CORE_GROUP_TLCD_PAST_TIME,
  EL_CORE_GROUP_TLCD_DEPLOY_BLOCK,
  EL_CORE_GROUP_DCU,
  EL_CORE_GROUP_EVENT_HANDLER,        
  EL_CORE_GROUP_EH_MATCH_RULE,        
  EL_CORE_GROUP_EH_RESPOND_WITH_HIGHER_LEVEL_RULE,  
  EL_CORE_GROUP_COMMAND_ANALYZE,
  EL_CORE_GROUP_CDIS_INTERNAL_ERR,
  EL_CORE_GROUP_CDIS_EXEC_ERR_STS,
  EL_CORE_GROUP_CDIS_EXEC_ERR_CODE,
  // TODO: Driver Super
#ifdef EL_IS_ENABLE_EL_ERROR_LEVEL
  EL_CORE_GROUP_EL_DROP_CLOG1,        
  EL_CORE_GROUP_EL_DROP_CLOG2,        
#endif
  EL_CORE_GROUP_MAX
} EL_CORE_GROUP;
 
 
#ifdef EL_IS_ENABLE_EL_ERROR_LEVEL
typedef enum
{
  EL_EVENT_LOCAL_UNKNOWN_ERR,             
#ifdef EL_IS_ENABLE_TLOG
  EL_EVENT_LOCAL_TLOG_HIGH_HALF_FULL,     
  EL_EVENT_LOCAL_TLOG_HIGH_FULL,          
#ifdef EL_IS_ENABLE_MIDDLE_ERROR_LEVEL
  EL_EVENT_LOCAL_TLOG_MIDDLE_HALF_FULL,   
  EL_EVENT_LOCAL_TLOG_MIDDLE_FULL,        
#endif
  EL_EVENT_LOCAL_TLOG_LOW_HALF_FULL,      
  EL_EVENT_LOCAL_TLOG_LOW_FULL,           
#endif
  EL_EVENT_LOCAL_MAX
} EL_EVENT_LOCAL;
#endif
 
 
typedef enum
{
  EL_ERROR_LEVEL_HIGH = 0,
#ifdef EL_IS_ENABLE_MIDDLE_ERROR_LEVEL
  EL_ERROR_LEVEL_MIDDLE,
#endif
  EL_ERROR_LEVEL_LOW,
#ifdef EL_IS_ENABLE_EL_ERROR_LEVEL
  EL_ERROR_LEVEL_EL,
#endif
  EL_ERROR_LEVEL_EH,    
  EL_ERROR_LEVEL_MAX
} EL_ERROR_LEVEL;
 
 
typedef enum
{
  EL_ACK_OK,                    
  EL_ACK_ILLEGAL_GROUP,         
  EL_ACK_ILLEGAL_ERROR_LEVEL,   
  EL_ACK_DISABLE_LOGGING,       
  EL_ACK_TLOG_FULL,             
  EL_ACK_OTHER_ERR              
} EL_ACK;
 
 
typedef struct
{
  EL_GROUP group;             
  uint32_t local;             
  EL_ERROR_LEVEL err_level;   
  ObcTime  time;              
#ifdef EL_IS_ENABLE_EVENT_NOTE
  uint32_t note;              
#endif
} EL_Event;
 
 
typedef struct
{
  uint32_t record_counter_total;                
  uint32_t record_counters[EL_ERROR_LEVEL_MAX]; 
} EL_EventStatistics;
 
 
#ifdef EL_IS_ENABLE_TLOG
typedef struct
{
  EL_Event* events;               
  uint16_t  log_capacity;         
  uint16_t  log_wp;               
  uint8_t   is_enable_overwrite;  
  uint8_t   is_table_overflow;    
} EL_TimeSeriesLog;
#endif
 
 
#ifdef EL_IS_ENABLE_CLOG
typedef struct
{
  EL_Event          event;                  
  el_clog_counter_t count;                  
  ObcTime           delta_record_time;      
} EL_CLogElement;
 
 
typedef struct
{
  EL_CLogElement* logs;         
  uint16_t*       log_orders;   
  uint16_t        log_capacity; 
} EL_CumulativeLog;
#endif
 
 
typedef struct
{
#ifdef EL_IS_ENABLE_TLOG
  struct
  {
    uint8_t page_no;            
    EL_ERROR_LEVEL err_level;   
  } tlog;
#endif
#ifdef EL_IS_ENABLE_CLOG
  struct
  {
    uint8_t page_no;            
    EL_ERROR_LEVEL err_level;   
  } clog;
#endif
} EL_TlmInfo;
 
 
typedef struct
{
#ifdef EL_IS_ENABLE_TLOG
  EL_TimeSeriesLog tlogs[EL_ERROR_LEVEL_MAX];
#endif
#ifdef EL_IS_ENABLE_CLOG
  EL_CumulativeLog clogs[EL_ERROR_LEVEL_MAX];
#endif
 
  EL_EventStatistics statistics;    
  EL_TlmInfo tlm_info;              
 
  uint8_t is_logging_enable[EL_GROUP_MAX / 8 + 1];  
 
  EL_Event latest_event;
} EventLogger;
 
 
extern const EventLogger* const event_logger;
 
 
void EL_initialize(void);
 
EL_ACK EL_record_event(EL_GROUP group, uint32_t local, EL_ERROR_LEVEL err_level, uint32_t note);
 
EL_ACK EL_enable_logging(EL_GROUP group);
 
EL_ACK EL_disable_logging(EL_GROUP group);
 
int EL_is_logging_enable(EL_GROUP group);
 
void EL_enable_all_logging(void);
 
void EL_disable_all_logging(void);
 
#ifdef EL_IS_ENABLE_TLOG
EL_ACK EL_enable_tlog_overwrite(EL_ERROR_LEVEL err_level);
 
EL_ACK EL_disable_tlog_overwrite(EL_ERROR_LEVEL err_level);
 
void EL_enable_tlog_overwrite_all(void);
 
void EL_disable_tlog_overwrite_all(void);
 
int EL_is_tlog_overwrite_enable(EL_ERROR_LEVEL err_level);
 
const EL_Event* EL_get_the_nth_tlog_from_the_latest(EL_ERROR_LEVEL err_level, uint16_t n);
#endif
 
CCP_CmdRet Cmd_EL_INIT(const CommonCmdPacket* packet);
 
CCP_CmdRet Cmd_EL_CLEAR_LOG_ALL(const CommonCmdPacket* packet);
 
CCP_CmdRet Cmd_EL_CLEAR_LOG_BY_ERR_LEVEL(const CommonCmdPacket* packet);
 
CCP_CmdRet Cmd_EL_CLEAR_STATISTICS(const CommonCmdPacket* packet);
 
#ifdef EL_IS_ENABLE_TLOG
CCP_CmdRet Cmd_EL_CLEAR_TLOG(const CommonCmdPacket* packet);
#endif
 
#ifdef EL_IS_ENABLE_CLOG
CCP_CmdRet Cmd_EL_CLEAR_CLOG(const CommonCmdPacket* packet);
#endif
 
CCP_CmdRet Cmd_EL_RECORD_EVENT(const CommonCmdPacket* packet);
 
#ifdef EL_IS_ENABLE_TLOG
CCP_CmdRet Cmd_EL_TLOG_SET_PAGE_FOR_TLM(const CommonCmdPacket* packet);
#endif
 
#ifdef EL_IS_ENABLE_CLOG
CCP_CmdRet Cmd_EL_CLOG_SET_PAGE_FOR_TLM(const CommonCmdPacket* packet);
#endif
 
CCP_CmdRet Cmd_EL_INIT_LOGGING_SETTINGS(const CommonCmdPacket* packet);
 
CCP_CmdRet Cmd_EL_ENABLE_LOGGING(const CommonCmdPacket* packet);
 
CCP_CmdRet Cmd_EL_DISABLE_LOGGING(const CommonCmdPacket* packet);
 
CCP_CmdRet Cmd_EL_ENABLE_LOGGING_ALL(const CommonCmdPacket* packet);
 
CCP_CmdRet Cmd_EL_DISABLE_LOGGING_ALL(const CommonCmdPacket* packet);
 
#ifdef EL_IS_ENABLE_TLOG
CCP_CmdRet Cmd_EL_ENABLE_TLOG_OVERWRITE(const CommonCmdPacket* packet);
 
CCP_CmdRet Cmd_EL_DISABLE_TLOG_OVERWRITE(const CommonCmdPacket* packet);
 
CCP_CmdRet Cmd_EL_ENABLE_TLOG_OVERWRITE_ALL(const CommonCmdPacket* packet);
 
CCP_CmdRet Cmd_EL_DISABLE_TLOG_OVERWRITE_ALL(const CommonCmdPacket* packet);
#endif
 
#endif