hitec_reg.h

Go to the documentation of this file.

 
#ifndef HITEC_REG_H
#define HITEC_REG_H
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "hitec_wire.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* --- image ---------------------------------------------------------------- */

#define HITEC_MEM_SIZE 256u
 
/* Classic cells. */
#define HITEC_C_SUM_LAST   0x1Cu  
#define HITEC_C_FACTORY    0x30u  
#define HITEC_C_BLOCK_LEN  0x24u  
#define HITEC_C_NAME       0x60u  
#define HITEC_C_NAME_LEN   16u    
#define HITEC_C_DATE       0x70u  
#define HITEC_C_SERIAL     0x80u  
#define HITEC_C_SERIAL_LEN 7u     
 
/* D series registers that code outside the table names. */
#define HITEC_D_REG_MODEL   0x00u  
#define HITEC_D_REG_FACTORY 0x6Eu  
#define HITEC_D_REG_SAVE    0x70u  
#define HITEC_D_REG_REBOOT  0x46u  
#define HITEC_D_FACTORY_KEY 0x0F0Fu  
#define HITEC_D_SAVE_KEY    0xFFFFu  
#define HITEC_D_POS_MAX     16383u

typedef struct {
    uint8_t mem[HITEC_MEM_SIZE];
    uint8_t known[HITEC_MEM_SIZE / 8u];  
    uint8_t series;       
    uint8_t version;      
    uint8_t has_version;  
} hitec_image_t;

void hitec_image_init(hitec_image_t *img, uint8_t series);

bool hitec_image_put_cell(hitec_image_t *img, uint8_t cell, uint8_t value);

bool hitec_image_put_reg(hitec_image_t *img, uint8_t addr, uint16_t value);

bool hitec_image_put_version(hitec_image_t *img, uint8_t version);

bool hitec_image_forget(hitec_image_t *img, uint8_t addr);

bool hitec_image_known(const hitec_image_t *img, uint8_t addr);

uint8_t hitec_image_cell(const hitec_image_t *img, uint8_t cell);

uint16_t hitec_image_reg(const hitec_image_t *img, uint8_t addr);
 
/* --- what to read --------------------------------------------------------- */

typedef struct {
    uint8_t first;  
    uint8_t count;  
} hitec_range_t;

const uint8_t *hitec_d_read_list(size_t *n);

const hitec_range_t *hitec_c_read_ranges(size_t *n);
 
/* --- checksum and mirror -------------------------------------------------- */

uint8_t hitec_c_eeprom_sum(const hitec_image_t *img);

uint8_t hitec_c_balance(const hitec_image_t *img);

bool hitec_c_rebalance(hitec_image_t *img);

bool hitec_d_mirror(uint16_t pos, uint16_t *out);
 
/* --- models --------------------------------------------------------------- */

typedef enum {
    HITEC_LAYOUT_D = 0,   
    HITEC_LAYOUT_HS5,     
    HITEC_LAYOUT_HS7,     
    HITEC_LAYOUT_COUNT
} hitec_layout_t;

#define HITEC_LAYOUT_BIT(l) ((uint8_t)(1u << (l)))

uint8_t hitec_layout_series(uint8_t layout);

typedef enum {
    HITEC_SRC_RCBENCH = 0,
    HITEC_SRC_CAPTURED,
    HITEC_SRC_READ,
    HITEC_SRC_DOC,
} hitec_src_t;

typedef enum {
    HITEC_MODEL_NONE = 0,  
    HITEC_MODEL_D485HW,    
    HITEC_MODEL_D645MW,    
    HITEC_MODEL_D_OTHER,   
    HITEC_MODEL_HS5645MG,  
    HITEC_MODEL_HS5955TG,  
    HITEC_MODEL_HS7955TG,  
    HITEC_MODEL_HS5_OTHER, 
    HITEC_MODEL_HS7_OTHER, 
    HITEC_MODEL_C_OTHER,   
    HITEC_MODEL_COUNT
} hitec_model_id_t;

typedef struct {
    uint8_t  model;    
    uint8_t  layout;   
    uint8_t  src;      
    uint16_t number;   
    char     name[HITEC_C_NAME_LEN + 1u];
} hitec_model_t;

bool hitec_identify(const hitec_image_t *img, hitec_model_t *out);

const char *hitec_model_name(uint8_t model);
 
/* --- parameters ----------------------------------------------------------- */

typedef enum {
    HITEC_P_D_MODEL = 0,     
    HITEC_P_D_POSITION,      
    HITEC_P_D_ID,            
    HITEC_P_D_DIRECTION,     
    HITEC_P_D_NEUTRAL,       
    HITEC_P_D_LEFT_END,      
    HITEC_P_D_RIGHT_END,     
    HITEC_P_D_DEAD_BAND,     
    HITEC_P_D_SPEED,         
    HITEC_P_D_FAILSAFE,      
    HITEC_P_D_SOFT_START,    
    HITEC_P_D_OVERLOAD,      
    HITEC_P_D_SMART_SENSOR,  
    HITEC_P_D_SENSITIVITY,   
    HITEC_P_D_R04,           
    HITEC_P_D_R22,           
    HITEC_P_D_R8A,           
    HITEC_P_D_R8C,           
    HITEC_P_D_RD4,           
    HITEC_P_D_RD6,           
    HITEC_P_C_VERSION,       
    HITEC_P_C_DATE,          
    HITEC_P_C_SERIAL,        
    HITEC_P_C_CHECKSUM,      
    HITEC_P_C_DEAD_BAND,     
    HITEC_P_C_SPEED,         
    HITEC_P_C_CENTRE,        
    HITEC_P_C_LEFT_END,      
    HITEC_P_C_RIGHT_END,     
    HITEC_P_C_DIRECTION,     
    HITEC_P_C_FAILSAFE,      
    HITEC_P_C_FS_POSITION,   
    HITEC_P_C_OVERLOAD,      
    HITEC_P_C_RESOLUTION,    
    HITEC_P_COUNT
} hitec_param_t;

typedef enum {
    HITEC_UNIT_RAW = 0,     
    HITEC_UNIT_COUNTS,      
    HITEC_UNIT_PERCENT,     
    HITEC_UNIT_STEP,        
    HITEC_UNIT_CHOICE,      
    HITEC_UNIT_FS_US,       
    HITEC_UNIT_OVERLOAD,    
    HITEC_UNIT_QUARTER_US,  
    HITEC_UNIT_DATE,        
    HITEC_UNIT_NUMBER,      
} hitec_unit_t;

typedef enum {
    HITEC_CW = 0,           
    HITEC_CCW = 1,          
    HITEC_OFF = 0,          
    HITEC_ON = 1,           
    HITEC_RES_NORMAL = 0,   
    HITEC_RES_HIGH = 1,     
    HITEC_SUM_BAD = 0,      
    HITEC_SUM_OK = 1,       
} hitec_choice_t;
 
#define HITEC_FS_LIMP 0   
#define HITEC_FS_OFF  1   

#define HITEC_OVERLOAD_OFF 0

typedef enum {
    HITEC_RO = 0,   
    HITEC_RW,       
} hitec_access_t;

#define HITEC_ADDR_NONE 0xFFu

typedef struct {
    uint8_t id;       
    uint8_t layouts;  
    uint8_t addr;     
    uint8_t addr2;    
    uint8_t size;     
    uint8_t enc;      
    uint8_t unit;     
    uint8_t access;   
    uint8_t src;      
    uint8_t step;     
    int32_t min;      
    int32_t max;      
} hitec_param_info_t;

const hitec_param_info_t *hitec_param(uint8_t layout, uint8_t id);

typedef enum {
    HITEC_GET_OK = 0,     
    HITEC_GET_RAW,        
    HITEC_GET_UNKNOWN,    
    HITEC_GET_ERR_ARG,    
} hitec_get_t;

typedef struct {
    int32_t  value;  
    uint32_t raw;
} hitec_value_t;

hitec_get_t hitec_param_get(const hitec_image_t *img, uint8_t layout,
                            uint8_t id, hitec_value_t *out);

typedef enum {
    HITEC_SET_OK = 0,      
    HITEC_SET_ERR_ARG,     
    HITEC_SET_ERR_RO,      
    HITEC_SET_ERR_RANGE,   
    HITEC_SET_ERR_RAW,
    HITEC_SET_ERR_UNKNOWN, 
    HITEC_SET_ERR_MIRROR,  
    HITEC_SET_ERR_ORDER,   
} hitec_set_t;

hitec_set_t hitec_param_set(hitec_image_t *img, uint8_t layout, uint8_t id,
                            int32_t value);

bool hitec_param_ok(uint8_t layout, uint8_t id, int32_t value);

int32_t hitec_param_clamp(uint8_t layout, uint8_t id, int32_t value);

bool hitec_c_factory(hitec_image_t *img);
 
/* --- write plans ---------------------------------------------------------- */

typedef enum {
    HITEC_STEP_C_CELL = 0,  
    HITEC_STEP_C_SUM,       
    HITEC_STEP_D_WRITE,     
    HITEC_STEP_D_SAVE,      
    HITEC_STEP_D_REBOOT,    
} hitec_step_kind_t;

typedef struct {
    uint8_t  kind;     
    uint8_t  addr;     
    uint16_t value;    
    uint16_t wait_ms;  
} hitec_step_t;

#define HITEC_D_WRITE_GAP_MS  20u
#define HITEC_D_SAVE_GAP_MS   100u
#define HITEC_D_REBOOT_WAIT_MS 1000u

#define HITEC_PLAN_MAX 56u

typedef struct {
    uint8_t      n;                     
    hitec_step_t step[HITEC_PLAN_MAX];  
} hitec_plan_t;

typedef enum {
    HITEC_PLAN_OK = 0,       
    HITEC_PLAN_ERR_ARG,      
    HITEC_PLAN_ERR_UNKNOWN,  
} hitec_plan_result_t;

bool hitec_writable(uint8_t series, uint8_t addr);

hitec_plan_result_t hitec_plan(const hitec_image_t *from,
                               const hitec_image_t *to, hitec_plan_t *out);

void hitec_d_factory_plan(hitec_plan_t *out);
 
#ifdef __cplusplus
}
#endif
 
#endif /* HITEC_REG_H */