sense_limit_link.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
#include <stdint.h>
 
#include "link_pages.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define SENSE_LIMIT_LINK_SETTLE_MS  500u
#define SENSE_LIMIT_LINK_READ_MS    200u
#define SENSE_LIMIT_LINK_GAP_MS     5000u
#define SENSE_LIMIT_LINK_REPEAT_MS  30000u

#define SENSE_LIMIT_LINK_ACK       0
#define SENSE_LIMIT_LINK_NO_ANSWER (-1)

typedef enum {
    SENSE_LIMIT_LINK_OP_NONE = 0,
    SENSE_LIMIT_LINK_OP_READ,     
    SENSE_LIMIT_LINK_OP_WRITE,    
    SENSE_LIMIT_LINK_OP_OVER,     
} sense_limit_link_op_kind_t;

typedef struct {
    sense_limit_link_op_kind_t kind;   
    bool            write;    
    uint8_t         off;      
    uint8_t         n;        
    const uint16_t *regs;     
} sense_limit_link_op_t;

typedef enum {
    SENSE_LIMIT_LINK_EV_NONE = 0,
    SENSE_LIMIT_LINK_EV_OVER,     
    SENSE_LIMIT_LINK_EV_LOST,     
    SENSE_LIMIT_LINK_EV_REFUSED,  
} sense_limit_link_ev_t;

typedef enum {
    SENSE_LIMIT_ST_UNKNOWN = 0,   
    SENSE_LIMIT_ST_HELD,          
    SENSE_LIMIT_ST_PENDING,       
    SENSE_LIMIT_ST_REFUSED,       
    SENSE_LIMIT_ST_OLD,           
} sense_limit_st_t;

typedef struct {
    bool     up;              
    bool     page;            
    bool     known;           
 
    bool     want_set;        
    uint16_t want[LINK_SL_KEPT]; 
    uint32_t want_ms;         
    uint16_t held[LINK_SL_KEPT]; 
    bool     refused;         
 
    sense_limit_link_op_kind_t pending; 
    bool     asked;           
    uint32_t asked_ms;        
    bool     pre_read;        
    bool     flushed;         
    bool     bad_page;        
    bool     have_count;      
    uint16_t count;           
 
    uint16_t over;            
    uint16_t ch_lim[LINK_SL_KEPT]; 
    bool     lost;            
    bool     ev_refused;      
    bool     told;            
    uint32_t told_ms;         
    uint16_t told_ch;         
    uint32_t ch_ms[LINK_SL_KEPT]; 
    uint8_t  turn;            
} sense_limit_link_t;

void sense_limit_link_init(sense_limit_link_t *s);

void sense_limit_link_lost(sense_limit_link_t *s);

void sense_limit_link_came_up(sense_limit_link_t *s, uint16_t minor,
                              uint32_t now_ms);

void sense_limit_link_want(sense_limit_link_t *s, const uint16_t *ma,
                           uint32_t now_ms);

bool sense_limit_link_next(sense_limit_link_t *s, uint32_t now_ms,
                           sense_limit_link_op_t *op);

void sense_limit_link_done(sense_limit_link_t *s, int result,
                           const uint16_t *regs, uint32_t now_ms);

sense_limit_link_ev_t sense_limit_link_event(sense_limit_link_t *s,
                                             uint32_t now_ms, unsigned *ch,
                                             uint16_t *ma);

uint16_t sense_limit_link_held_ma(const sense_limit_link_t *s, unsigned ch);

sense_limit_st_t sense_limit_link_status(const sense_limit_link_t *s);

uint16_t sense_limit_link_unheld(const sense_limit_link_t *s);
 
#ifdef __cplusplus
}
#endif