hitec_wire.h

Go to the documentation of this file.

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

typedef enum {
    HITEC_CLASSIC = 0,   
    HITEC_D       = 1,   
} hitec_family_t;

typedef enum {
    HITEC_DRIVE_OPEN_DRAIN = 0,
    HITEC_DRIVE_PUSH_PULL  = 1,
} hitec_drive_t;

#define HITEC_C_BIT_RATE 19200u
#define HITEC_D_BIT_RATE 115200u

uint32_t hitec_bit_rate(uint8_t family);

uint32_t hitec_bits_ns(uint8_t family, uint32_t bits);
 
/* --- classic frames ------------------------------------------------------- */

#define HITEC_C_FRAME_LEN 4u

#define HITEC_C_READ_EEPROM   0x61u   
#define HITEC_C_WRITE_EEPROM  0x62u   
#define HITEC_C_READ_RAM      0x63u   
#define HITEC_C_WRITE_RAM     0x64u   
#define HITEC_C_READ_POSITION 0x65u   
#define HITEC_C_MOVE          0x66u   
#define HITEC_C_FIRST         0x67u   
 
#define HITEC_C_ACK 0x2Bu   
#define HITEC_C_NAK 0x2Du   

uint8_t hitec_c_sum(uint8_t cmd, uint8_t p1, uint8_t p2);

void hitec_c_frame(uint8_t cmd, uint8_t p1, uint8_t p2,
                   uint8_t out[HITEC_C_FRAME_LEN]);

bool hitec_c_frame_ok(const uint8_t frame[HITEC_C_FRAME_LEN]);
 
/* --- D series frames ------------------------------------------------------ */

#define HITEC_D_HEADER_REQUEST 0x96u 
#define HITEC_D_HEADER_ANSWER  0x69u 
#define HITEC_D_READ_LEN       5u    
#define HITEC_D_WRITE_LEN      7u    
#define HITEC_D_ANSWER_LEN     7u    
#define HITEC_D_DATA_LEN       2u

uint8_t hitec_d_sum(const uint8_t *bytes, size_t n);

void hitec_d_read_frame(uint8_t id, uint8_t addr,
                        uint8_t out[HITEC_D_READ_LEN]);

void hitec_d_write_frame(uint8_t id, uint8_t addr, uint16_t value,
                         uint8_t out[HITEC_D_WRITE_LEN]);
 
/* --- transactions --------------------------------------------------------- */

typedef enum {
    HITEC_XFER_SEND = 0,
    HITEC_XFER_LISTEN,
    HITEC_XFER_LEVEL,
} hitec_kind_t;
 
#define HITEC_TX_MAX   8u   
#define HITEC_GAP_MAX  6u   
#define HITEC_RX_MAX  16u   
#define HITEC_TIME_MAX_US 4000000u

typedef struct {
    uint8_t  kind;          
    uint8_t  family;        
    uint8_t  n_tx;          
    uint8_t  gap_bits;      
    uint8_t  tx[HITEC_TX_MAX];  
    uint8_t  max_rx;        
    uint8_t  answer;        
    uint8_t  answer_byte;   
    uint8_t  level;         
    uint32_t lead_us;       
    uint32_t window_us;     
    uint32_t level_us;      
} hitec_xfer_t;

bool hitec_xfer_valid(const hitec_xfer_t *x);
 
/* --- classic transactions ------------------------------------------------- */

#define HITEC_C_GAP_BITS 1u
#define HITEC_C_ARM_BITS 9u
#define HITEC_C_REPLY_MIN_NS  494792u
#define HITEC_C_REPLY_MAX_NS 1000000u
#define HITEC_C_WINDOW_US 1500u
#define HITEC_C_REPLY_LEN 2u

void hitec_c_xfer(uint8_t cmd, uint8_t p1, uint8_t p2, hitec_xfer_t *out);
 
/* --- D series transactions ------------------------------------------------ */

#define HITEC_D_LEAD_US 88u
#define HITEC_D_SETTLE_BITS 1u
#define HITEC_D_ANSWER_MIN_NS  2000000u
#define HITEC_D_ANSWER_MAX_NS 20000000u
#define HITEC_D_WINDOW_US 25000u
#define HITEC_D_READ_RX 8u

void hitec_d_read_xfer(uint8_t id, uint8_t addr, hitec_xfer_t *out);

void hitec_d_write_xfer(uint8_t id, uint8_t addr, uint16_t value,
                        hitec_xfer_t *out);
 
/* --- listen and level ----------------------------------------------------- */

bool hitec_listen_xfer(uint8_t family, uint32_t window_us, uint8_t max_rx,
                       bool answer, uint8_t answer_byte, hitec_xfer_t *out);

bool hitec_level_xfer(uint8_t family, uint8_t level, uint32_t time_us,
                      hitec_xfer_t *out);
 
/* --- capture -------------------------------------------------------------- */

typedef struct {
    uint32_t at_ns;
    uint8_t  value;         
    uint8_t  framing;   
} hitec_rx_byte_t;

typedef struct {
    hitec_rx_byte_t byte[HITEC_RX_MAX];  
    uint32_t window_ns;  
    uint8_t  family;     
    uint8_t  n;          
    uint8_t  full;       
    uint8_t  answered;   
    uint8_t  overflow;   
    uint8_t  aborted;    
} hitec_capture_t;
 
/* --- decoders ------------------------------------------------------------- */

typedef enum {
    HITEC_RX_OK = 0,        
    HITEC_RX_ERR_ARG,       
    HITEC_RX_ERR_ABORTED,   
    HITEC_RX_ERR_OVERFLOW,  
    HITEC_RX_ERR_SILENT,    
    HITEC_RX_ERR_EARLY,     
    HITEC_RX_ERR_LATE,      
    HITEC_RX_ERR_NAK,       
    HITEC_RX_ERR_LENGTH,    
    HITEC_RX_ERR_FRAMING,   
    HITEC_RX_ERR_GAP,       
    HITEC_RX_ERR_ACK,       
    HITEC_RX_ERR_HEADER,    
    HITEC_RX_ERR_ADDRESS,   
    HITEC_RX_ERR_SUM,       
} hitec_rx_t;

#define HITEC_NEXT_MIN_HALF_BITS 19u
#define HITEC_NEXT_MAX_HALF_BITS 30u

typedef enum {
    HITEC_C_EXPECT_VALUE = 0,   
    HITEC_C_EXPECT_ACK,         
    HITEC_C_EXPECT_WORD,        
} hitec_c_expect_t;

bool hitec_c_expect_of(uint8_t cmd, hitec_c_expect_t *out);

typedef struct {
    uint16_t value;     
    uint8_t  id;        
    uint8_t  n;         
    uint32_t delay_ns;
} hitec_reply_t;

hitec_rx_t hitec_c_decode(const hitec_capture_t *cap, hitec_c_expect_t expect,
                          hitec_reply_t *out);

hitec_rx_t hitec_d_decode(const hitec_capture_t *cap, uint8_t addr,
                          hitec_reply_t *out);

hitec_rx_t hitec_listen_decode(const hitec_capture_t *cap, uint8_t want,
                               hitec_reply_t *out);
 
/* --- driver --------------------------------------------------------------- */

typedef struct {
    void *ctx;                 
    bool (*start)(void *ctx, const hitec_xfer_t *xfer);  
    bool (*poll)(void *ctx, hitec_capture_t *out);
    uint32_t (*now_us)(void *ctx);                       
} hitec_driver_t;

uint32_t hitec_elapsed_us(uint32_t now, uint32_t since);

bool hitec_due(uint32_t now, uint32_t since, uint32_t span_us);
 
#ifdef __cplusplus
}
#endif
 
#endif /* HITEC_WIRE_H */