driver_super.h

[詳解]

 
#ifndef DRIVER_SUPER_H_
#define DRIVER_SUPER_H_
 
#include <src_user/IfWrapper/if_list.h>
#include <stdint.h>
#include "../../Library/endian.h"        // パスが不定な自動生成コード類で使えるように
#include "../../System/TimeManager/time_manager.h"
 
#define DS_STREAM_MAX                 (3)         
#define DS_IF_RX_BUFFER_SIZE          (1024)      
#include <src_user/Settings/DriverSuper/driver_super_params.h>
 
typedef struct DriverSuper DriverSuper;
typedef struct DS_StreamConfig DS_StreamConfig;
 
typedef enum
{
  DS_DRIVER_ERR_CODE_OK = 0,                
  DS_DRIVER_ERR_CODE_ILLEGAL_CONTEXT,       
  DS_DRIVER_ERR_CODE_ILLEGAL_PARAMETER,     
  DS_DRIVER_ERR_CODE_ILLEGAL_LENGTH,        
  DS_DRIVER_ERR_CODE_UNKNOWN_ERR = 255      
} DS_DRIVER_ERR_CODE;
 
typedef enum
{
  DS_INIT_OK = 0,               
  DS_INIT_DS_INIT_ERR,          
  DS_INIT_PARAMETER_ERR,        
  DS_INIT_OTHER_ERR,            
  DS_INIT_UNKNOWN_ERR = 255     
} DS_INIT_ERR_CODE;
 
typedef enum
{
  DS_REC_OK = 0,                
  DS_REC_DS_RECEIVE_ERR,        
  DS_REC_ANALYZE_ERR,           
  DS_REC_OTHER_ERR,             
  DS_REC_UNKNOWN_ERR = 255      
} DS_REC_ERR_CODE;
 
typedef enum
{
  DS_CMD_OK                 = 0,   
  DS_CMD_ILLEGAL_CONTEXT    = 1,   
  DS_CMD_ILLEGAL_PARAMETER  = 2,   
  DS_CMD_ILLEGAL_LENGTH     = 3,   
  DS_CMD_DRIVER_SUPER_ERR   = 4,   
  DS_CMD_UNKNOWN_ERR        = 255
} DS_CMD_ERR_CODE;
 
typedef enum
{
  DS_ERR_CODE_OK   = 0,     
  DS_ERR_CODE_ERR  = 1
} DS_ERR_CODE;
 
typedef enum
{
  DS_RX_DISRUPTION_STATUS_OK   = 0,  
  DS_RX_DISRUPTION_STATUS_LOST = 1   
} DS_RX_DISRUPTION_STATUS_CODE;
 
typedef struct
{
  int                          ret_from_if_rx;       
  DS_RX_DISRUPTION_STATUS_CODE rx_disruption_status; 
} DS_RecStatus;
 
typedef enum
{
  DS_STREAM_SEND_STATUS_OK,
  DS_STREAM_SEND_STATUS_DISABLE,
  DS_STREAM_SEND_STATUS_TX_ERR,                
  DS_STREAM_SEND_STATUS_VALIDATE_ERR,          
  DS_STREAM_SEND_STATUS_OTHER_ERR
} DS_STREAM_SEND_STATUS_CODE;
 
typedef struct
{
  DS_STREAM_SEND_STATUS_CODE status_code;       
  int                        ret_from_if_tx;    
  // 今後詳細情報を拡張するなら，ここに入れる
} DS_StreamSendStatus;
 
typedef enum
{
  DS_STREAM_REC_STATUS_FINDING_HEADER,
  DS_STREAM_REC_STATUS_RECEIVING_HEADER,
  DS_STREAM_REC_STATUS_RECEIVING_FRAMELENGTH, 
  DS_STREAM_REC_STATUS_RECEIVING_DATA,
  DS_STREAM_REC_STATUS_RECEIVING_FOOTER,
  DS_STREAM_REC_STATUS_FIXED_FRAME,
  DS_STREAM_REC_STATUS_DISABLE,
  DS_STREAM_REC_STATUS_HEADER_MISMATCH,
  DS_STREAM_REC_STATUS_FOOTER_MISMATCH,
  DS_STREAM_REC_STATUS_RX_FRAME_TOO_LONG,
  DS_STREAM_REC_STATUS_RX_FRAME_TOO_SHORT,
  DS_STREAM_REC_STATUS_RX_ERR,                
  DS_STREAM_REC_STATUS_VALIDATE_ERR,          
  DS_STREAM_REC_STATUS_OTHER_ERR
} DS_STREAM_REC_STATUS_CODE;
 
typedef enum
{
  DS_STREAM_TLM_DISRUPTION_STATUS_OK   = 0,  
  DS_STREAM_TLM_DISRUPTION_STATUS_LOST = 1   
} DS_STREAM_TLM_DISRUPTION_STATUS_CODE;
 
typedef struct
{
  DS_STREAM_REC_STATUS_CODE            status_code;                   
  uint16_t                             fixed_frame_len;               
  DS_STREAM_TLM_DISRUPTION_STATUS_CODE tlm_disruption_status;         
  uint32_t                             count_of_carry_over_failures;  
  // 今後詳細情報を拡張するなら，ここに入れる（ref. EQU Driver Super の DRIVE_Super_rec など）
} DS_StreamRecStatus;
 
typedef struct
{
  uint8_t* buffer;                        
  uint16_t capacity;                      
  uint16_t size;                          
  uint16_t pos_of_frame_head_candidate;   
  uint16_t confirmed_frame_len;           
  uint8_t  is_frame_fixed;                
  uint16_t pos_of_last_rec;               
} DS_StreamRecBuffer;
 
typedef struct
{
  struct
  {
    uint16_t rx_buffer_size_in_if_rx_;                        
    uint8_t  should_monitor_for_rx_disruption_;               
    uint32_t time_threshold_for_rx_disruption_;               
  } settings;       
 
  struct
  {
    DS_RecStatus rec_status_;                                 
 
    uint32_t rx_count_;                                       
    uint32_t rx_call_count_;                                  
 
    ObcTime  rx_time_;                                        
  } info;           
 
  struct
  {
    DS_ERR_CODE (*load_init_setting)(DriverSuper* p_super);   
  } internal;       
} DS_Config;
 
struct DS_StreamConfig
{
  struct
  {
    uint8_t  is_enabled_;                                     
    uint8_t  is_strict_frame_search_;                         
    uint8_t* tx_frame_;                                       
    uint16_t tx_frame_size_;                                  
    int16_t  tx_frame_buffer_size_;                           
    DS_StreamRecBuffer* rx_buffer_;                           
    const uint8_t* rx_header_;                                
    uint16_t rx_header_size_;                                 
    const uint8_t* rx_footer_;                                
    uint16_t rx_footer_size_;                                 
    int16_t  rx_frame_size_;                                  
    uint16_t max_rx_frame_size_;                              
    int16_t  rx_framelength_pos_;                             
    uint16_t rx_framelength_type_size_;                       
    uint16_t rx_framelength_offset_;                          
    ENDIAN_TYPE rx_framelength_endian_;                       
    uint8_t  should_monitor_for_tlm_disruption_;              
    uint32_t time_threshold_for_tlm_disruption_;              
    DS_ERR_CODE (*data_analyzer_)(DS_StreamConfig* p_stream_config, void* p_driver);
  } settings;       
 
  struct
  {
    DS_StreamSendStatus send_status_;                         
    DS_StreamRecStatus  rec_status_;                          
 
    uint32_t general_cmd_tx_count_;                           
    uint32_t req_tlm_cmd_tx_count_;                           
    uint32_t req_tlm_cmd_tx_count_after_last_tx_;             
    uint32_t rx_frame_fix_count_;                             
 
    ObcTime  general_cmd_tx_time_;                            
    ObcTime  req_tlm_cmd_tx_time_;                            
    ObcTime  rx_frame_fix_time_;                              
 
    DS_ERR_CODE ret_from_data_analyzer_;                      
  } info;           
 
  struct
  {
    uint8_t  is_validation_needed_for_send_;                  
    uint8_t  is_validation_needed_for_rec_;                   
  } internal;       
};
// TODO: Protocol 用に data_link_layer_ を追加
 
struct DriverSuper
{
  // 【継承先まで公開】
  IF_LIST_ENUM      interface;                              
  void*             if_config;                              
 
  DS_Config         config;                                 
 
  DS_StreamConfig   stream_config[DS_STREAM_MAX];           
};
 
 
// ###### DriverSuper 基本関数 ######
 
DS_ERR_CODE DS_init(DriverSuper* p_super,
                    void* if_config,
                    DS_StreamRecBuffer* rx_buffer,
                    DS_ERR_CODE (*load_init_setting)(DriverSuper* p_super));
 
DS_ERR_CODE DS_init_streams(DriverSuper* p_super,
                            void* if_config,
                            DS_StreamRecBuffer* rx_buffers[DS_STREAM_MAX],
                            DS_ERR_CODE (*load_init_setting)(DriverSuper* p_super));
 
DS_ERR_CODE DS_reset(DriverSuper* p_super);
 
DS_ERR_CODE DS_validate_config(DriverSuper* p_super);
 
DS_ERR_CODE DS_clear_rx_buffer(DriverSuper* p_super);
 
DS_ERR_CODE DS_receive(DriverSuper* p_super);
 
DS_ERR_CODE DS_analyze_rec_data(DriverSuper* p_super, uint8_t stream, void* p_driver);
 
DS_ERR_CODE DS_send_general_cmd(DriverSuper* p_super, uint8_t stream);
 
DS_ERR_CODE DS_send_req_tlm_cmd(DriverSuper* p_super, uint8_t stream);
 
 
// ###### DS_Config Getter/Setter of Settings ######
uint16_t DSC_get_rx_buffer_size_in_if_rx(const DriverSuper* p_super);
DS_ERR_CODE DSC_set_rx_buffer_size_in_if_rx(DriverSuper* p_super,
                                            const uint16_t rx_buffer_size_in_if_rx);
uint8_t DSC_get_should_monitor_for_rx_disruption(const DriverSuper* p_super);
void DSC_enable_monitor_for_rx_disruption(DriverSuper* p_super);
void DSC_disable_monitor_for_rx_disruption(DriverSuper* p_super);
uint32_t DSC_get_time_threshold_for_rx_disruption(const DriverSuper* p_super);
void DSC_set_time_threshold_for_rx_disruption(DriverSuper* p_super,
                                              const uint32_t time_threshold_for_rx_disruption);
 
 
// ###### DS_Config Getter of Info ######
const DS_RecStatus* DSC_get_rec_status(const DriverSuper* p_super);
uint32_t DSC_get_rx_count(const DriverSuper* p_super);
uint32_t DSC_get_rx_call_count(const DriverSuper* p_super);
const ObcTime* DSC_get_rx_time(const DriverSuper* p_super);
 
DS_RX_DISRUPTION_STATUS_CODE DSC_get_rx_disruption_status(const DriverSuper* p_super);
 
 
// ###### DS_StreamConfig Getter/Setter of Settings ######
uint8_t DSSC_get_is_enabled(const DS_StreamConfig* p_stream_config);
void DSSC_enable(DS_StreamConfig* p_stream_config);
void DSSC_disable(DS_StreamConfig* p_stream_config);
 
uint8_t DSSC_get_is_strict_frame_search(const DS_StreamConfig* p_stream_config);
void DSSC_enable_strict_frame_search(DS_StreamConfig* p_stream_config);
void DSSC_disable_strict_frame_search(DS_StreamConfig* p_stream_config);
 
const uint8_t* DSSC_get_tx_frame(DS_StreamConfig* p_stream_config);
uint8_t* DSSC_get_tx_frame_as_non_const_pointer(DS_StreamConfig* p_stream_config);
void DSSC_set_tx_frame(DS_StreamConfig* p_stream_config,
                       uint8_t* tx_frame);
uint16_t DSSC_get_tx_frame_size(const DS_StreamConfig* p_stream_config);
void DSSC_set_tx_frame_size(DS_StreamConfig* p_stream_config,
                            const uint16_t tx_frame_size);
int16_t DSSC_get_tx_frame_buffer_size(DS_StreamConfig* p_stream_config);
void DSSC_set_tx_frame_buffer_size(DS_StreamConfig* p_stream_config,
                                   const int16_t tx_frame_buffer_size);
 
void DSSC_set_rx_buffer(DS_StreamConfig* p_stream_config,
                        DS_StreamRecBuffer* rx_buffer);
void DSSC_set_rx_header(DS_StreamConfig* p_stream_config,
                        const uint8_t* rx_header,
                        const uint16_t rx_header_size);
uint16_t DSSC_get_rx_header_size(const DS_StreamConfig* p_stream_config);
void DSSC_set_rx_footer(DS_StreamConfig* p_stream_config,
                        const uint8_t* rx_footer,
                        const uint16_t rx_footer_size);
uint16_t DSSC_get_rx_footer_size(const DS_StreamConfig* p_stream_config);
int16_t DSSC_get_rx_frame_size(const DS_StreamConfig* p_stream_config);
void DSSC_set_rx_frame_size(DS_StreamConfig* p_stream_config,
                            const int16_t rx_frame_size);
uint16_t DSSC_get_max_rx_frame_size(const DS_StreamConfig* p_stream_config);
void DSSC_set_max_rx_frame_size(DS_StreamConfig* p_stream_config,
                            const uint16_t max_rx_frame_size);
 
void DSSC_set_rx_framelength_pos(DS_StreamConfig* p_stream_config,
                                 const int16_t rx_framelength_pos);
void DSSC_set_rx_framelength_type_size(DS_StreamConfig* p_stream_config,
                                       const uint16_t rx_framelength_type_size);
void DSSC_set_rx_framelength_offset(DS_StreamConfig* p_stream_config,
                                    const uint16_t rx_framelength_offset);
void DSSC_set_rx_framelength_endian(DS_StreamConfig* p_stream_config,
                                    const ENDIAN_TYPE rx_framelength_endian);
 
uint8_t DSSC_get_should_monitor_for_tlm_disruption(const DS_StreamConfig* p_stream_config);
void DSSC_enable_monitor_for_tlm_disruption(DS_StreamConfig* p_stream_config);
void DSSC_disable_monitor_for_tlm_disruption(DS_StreamConfig* p_stream_config);
uint32_t DSSC_get_time_threshold_for_tlm_disruption(const DS_StreamConfig* p_stream_config);
void DSSC_set_time_threshold_for_tlm_disruption(DS_StreamConfig* p_stream_config,
                                                const uint32_t time_threshold_for_tlm_disruption);
 
void DSSC_set_data_analyzer(DS_StreamConfig* p_stream_config,
                            DS_ERR_CODE (*data_analyzer)(DS_StreamConfig* p_stream_config, void* p_driver));
 
 
// ###### DS_StreamConfig Getter of Info ######
const DS_StreamSendStatus* DSSC_get_send_status(const DS_StreamConfig* p_stream_config);
const DS_StreamRecStatus* DSSC_get_rec_status(const DS_StreamConfig* p_stream_config);
 
uint32_t DSSC_get_general_cmd_tx_count(const DS_StreamConfig* p_stream_config);
uint32_t DSSC_get_req_tlm_cmd_tx_count(const DS_StreamConfig* p_stream_config);
uint32_t DSSC_get_req_tlm_cmd_tx_count_after_last_tx(const DS_StreamConfig* p_stream_config);
uint32_t DSSC_get_rx_frame_fix_count(const DS_StreamConfig* p_stream_config);
 
const ObcTime* DSSC_get_general_cmd_tx_time(const DS_StreamConfig* p_stream_config);
const ObcTime* DSSC_get_req_tlm_cmd_tx_time(const DS_StreamConfig* p_stream_config);
const ObcTime* DSSC_get_rx_frame_fix_time(const DS_StreamConfig* p_stream_config);
 
DS_STREAM_TLM_DISRUPTION_STATUS_CODE DSSC_get_tlm_disruption_status(const DS_StreamConfig* p_stream_config);
 
DS_ERR_CODE DSSC_get_ret_from_data_analyzer(const DS_StreamConfig* p_stream_config);
 
 
// ###### Driver 汎用 Util 関数 ######
 
DS_ERR_CODE DS_init_stream_rec_buffer(DS_StreamRecBuffer* stream_rec_buffer,
                                      uint8_t* buffer,
                                      const uint16_t buffer_capacity);
 
void DS_nullify_stream_rec_buffers(DS_StreamRecBuffer* rx_buffers[DS_STREAM_MAX]);
 
CCP_CmdRet DS_conv_driver_err_to_ccp_cmd_ret(DS_DRIVER_ERR_CODE code);
 
CCP_CmdRet DS_conv_cmd_err_to_ccp_cmd_ret(DS_CMD_ERR_CODE code);
 
 
// ###### Driver Stream Config 汎用 Util 関数 ######
 
const uint8_t* DSSC_get_rx_frame(const DS_StreamConfig* p_stream_config);
 
uint16_t DSSC_get_fixed_rx_frame_size(const DS_StreamConfig* p_stream_config);
 
#endif