mip_cmdqueue.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdint.h>
 
#include "mip_types.h"
#include "mip_result.h"
#include "mip_packet.h"
 
#ifdef __cplusplus
namespace mip {
namespace C {
extern "C" {
#endif
 
 
 
 
 
 
typedef struct mip_pending_cmd
{
    struct mip_pending_cmd*     _next;                 
    uint8_t*                    _response_buffer;      
    union {                                            
        mip_timeout   _extra_timeout;        
        mip_timestamp _timeout_time;         
        mip_timestamp _reply_time;           
    };
    uint8_t                     _descriptor_set;       
    uint8_t                     _field_descriptor;     
    uint8_t                     _response_descriptor;  
    union {
        uint8_t                 _response_buffer_size; 
        uint8_t                 _response_length;      
    };                                                 
    volatile enum mip_cmd_result _status;              
} mip_pending_cmd;
 
void mip_pending_cmd_init(mip_pending_cmd* cmd, uint8_t descriptor_set, uint8_t field_descriptor);
void mip_pending_cmd_init_with_timeout(mip_pending_cmd* cmd, uint8_t descriptor_set, uint8_t field_descriptor, mip_timeout additional_time);
void mip_pending_cmd_init_with_response(mip_pending_cmd* cmd, uint8_t descriptor_set, uint8_t field_descriptor, uint8_t response_descriptor, uint8_t* response_buffer, uint8_t response_buffer_size);
void mip_pending_cmd_init_full(mip_pending_cmd* cmd, uint8_t descriptor_set, uint8_t field_descriptor, uint8_t response_descriptor, uint8_t* response_buffer, uint8_t response_size, mip_timeout additional_time);
 
enum mip_cmd_result mip_pending_cmd_status(const mip_pending_cmd* cmd);
uint8_t mip_pending_cmd_response_descriptor(const mip_pending_cmd* cmd);
const uint8_t* mip_pending_cmd_response(const mip_pending_cmd* cmd);
uint8_t mip_pending_cmd_response_length(const mip_pending_cmd* cmd);
 
int mip_pending_cmd_remaining_time(const mip_pending_cmd* cmd, mip_timestamp now);
bool mip_pending_cmd_check_timeout(const mip_pending_cmd* cmd, mip_timestamp now);
 
 
 
typedef struct mip_cmd_queue
{
    mip_pending_cmd* _first_pending_cmd;
    mip_timeout _base_timeout;
 
#ifdef MIP_ENABLE_DIAGNOSTICS
    uint16_t         _diag_cmds_queued;    
    uint16_t         _diag_cmds_acked;     
    uint8_t          _diag_cmds_nacked;    
    uint8_t          _diag_cmds_timedout;  
    uint8_t          _diag_cmds_failed;    
#endif // MIP_ENABLE_DIAGNOSTICS
 
} mip_cmd_queue;
 
void mip_cmd_queue_init(mip_cmd_queue* queue, mip_timeout base_reply_timeout);
void mip_cmd_queue_enqueue(mip_cmd_queue* queue, mip_pending_cmd* cmd);
void mip_cmd_queue_dequeue(mip_cmd_queue* queue, mip_pending_cmd* cmd);
 
void mip_cmd_queue_clear(mip_cmd_queue* queue);
 
void mip_cmd_queue_update(mip_cmd_queue* queue, mip_timestamp timestamp);
 
void mip_cmd_queue_set_base_reply_timeout(mip_cmd_queue* queue, mip_timeout timeout);
mip_timeout mip_cmd_queue_base_reply_timeout(const mip_cmd_queue* queue);
 
void mip_cmd_queue_process_packet(mip_cmd_queue* queue, const mip_packet* packet, mip_timestamp timestamp);
 
 
#ifdef MIP_ENABLE_DIAGNOSTICS
uint16_t mip_cmd_queue_diagnostic_cmds_queued(const mip_cmd_queue* queue);
uint16_t mip_cmd_queue_diagnostic_cmds_failed(const mip_cmd_queue* queue);
uint16_t mip_cmd_queue_diagnostic_cmds_successful(const mip_cmd_queue* queue);
 
uint16_t mip_cmd_queue_diagnostic_cmd_acks(const mip_cmd_queue* queue);
uint16_t mip_cmd_queue_diagnostic_cmd_nacks(const mip_cmd_queue* queue);
uint16_t mip_cmd_queue_diagnostic_cmd_timeouts(const mip_cmd_queue* queue);
uint16_t mip_cmd_queue_diagnostic_cmd_errors(const mip_cmd_queue* queue);
#endif // MIP_ENABLE_DIAGNOSTICS
 
 
#ifdef __cplusplus
} // namespace C
} // namespace mip
} // extern "C"
#endif