pdmini.h

Go to the documentation of this file.

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

#define PDMINI_V_MIN_MV   1000u
#define PDMINI_V_MAX_MV  20000u
#define PDMINI_I_MIN_MA     50u
#define PDMINI_I_MAX_MA   3000u
#define PDMINI_HEADROOM_MV  500u
#define PDMINI_CAP_MV       700u
 
#ifdef __cplusplus
static_assert(PDMINI_CAP_MV > PDMINI_HEADROOM_MV,
              "a set point at the cap lies above the sag cut line");
#else
_Static_assert(PDMINI_CAP_MV > PDMINI_HEADROOM_MV,
               "a set point at the cap lies above the sag cut line");
#endif

#define PDMINI_WHO "PD Power Mini"

enum {
    PDMINI_OUTPUT_EN    = 0x02,  
    PDMINI_OUTPUT_DATA  = 0x04,  
    PDMINI_SYSTEM_RESET = 0x40,  
    PDMINI_WHO_AM_I     = 0x81,  
    PDMINI_READ_STATE   = 0x82,  
    PDMINI_READ_ID      = 0x83,  
    PDMINI_READ_DATA    = 0x84,  
    PDMINI_READ_DISPLAY = 0x85,  
    PDMINI_READ_INPUT   = 0x8A,  
};

enum { PDMINI_MODE_NORMAL = 0, PDMINI_MODE_CC = 1, PDMINI_MODE_OC = 2 };

#define PDMINI_ATTACH_MS     5u    
#define PDMINI_REPLY_MS    400u    
#define PDMINI_BYTE_MS      60u    
#define PDMINI_TXN_MS      600u    
#define PDMINI_CONFIRM_MS  250u    
#define PDMINI_WATCH_MS   1000u    
#define PDMINI_GAP_MS       10u    
#define PDMINI_DISPLAY_MS  100u    
#define PDMINI_POLL_LATE_MS 400u  
#define PDMINI_STATE_MS    500u    
#define PDMINI_IDENTIFY_MS 1000u   
#define PDMINI_SLOT_MS     1000u   
#define PDMINI_RETRY_MS    2000u   
#define PDMINI_FAILS          3u   
#define PDMINI_ABSENT_TRIES  10u   
#define PDMINI_INPUT_MISSES   3u   
#define PDMINI_INPUT_RETRY_MS 5000u 
#define PDMINI_SAG_READS      2u   

uint8_t pdmini_crc8(const uint8_t *p, size_t n);

typedef enum {
    PDMINI_MORE = 0,   
    PDMINI_DONE,       
    PDMINI_BAD,        
} pdmini_frame_t;

pdmini_frame_t pdmini_reply_frame(uint8_t cmd, const uint8_t *buf, size_t n);

typedef struct {
    void (*attach)(void *ctx);                       
    void (*detach)(void *ctx);                       
    void (*send)(void *ctx, const uint8_t *p, size_t n);  
    void *ctx;                          
} pdmini_io_t;

typedef struct {
    bool     online;      
    bool     output;      
    uint8_t  mode;        
    uint16_t v_mv,                          
             i_ma;                          
    uint16_t set_mv;      
    uint16_t set_ma;                    
    uint8_t  in_state;    
    uint16_t vin_mv;                    
    bool     stuck;       
    bool     set_stuck;   
    bool     tripped;     
    bool     sagged;      
    uint32_t samples;     
    uint32_t errors;      
} pdmini_status_t;

typedef struct {
    pdmini_io_t     io;
    pdmini_status_t st;
 
    /* What is asked for. */
    bool     want_output;
    bool     want_set;       
    uint16_t want_mv, want_ma;
 
    /* What is known. */
    bool     identified;
    bool     answered;       
    bool     restored;       
    uint8_t  who_misses;     
    uint16_t who_failed;     /* WHO_AM_I without a valid answer: a count
                                to compare for a change, wrapping from
                                65535 to 0                              */
    bool     state_known;    
    int      slot;           
    bool     data_known;     
    uint8_t  on_value;       
    uint8_t  en_value;       
    bool     en_for;         
    bool     on_seen;        
    bool     on_confirmed;   
    bool     on_sent;        
    bool     reset_owed;     
    bool     held_off;       /* switched off for set points that would not
                                take; until an OFF is asked             */
    bool     off_owed;       
    bool     blind_due;      
    uint8_t  en_tries;       
    bool     en_pending;     
    uint32_t en_at;
    bool     data_pending;   
    uint8_t  data_tries;     
    uint32_t data_at;
    uint8_t  fails;          
    uint8_t  state_fails;    
    uint8_t  input_misses;   
    bool     input_known;    
    bool     input_seen;     
    uint8_t  on_step;        /* reads before an ON: 1 data asked, 2 data
                                seen, 3 slot asked, 4 slot seen          */
    bool     polled_late;    /* the last job a reading that went before
                                the set points: an overdue one, or the
                                input read before a set point or an ON  */
    uint8_t  sag_reads;      /* input reads in a row under a live output's
                                set point and the headroom              */
    uint8_t  check;          
 
    /* The transaction under way. */
    enum { PD_IDLE, PD_ATTACH, PD_WAIT, PD_GAP } phase;
    uint8_t  req[8];
    size_t   req_n;
    uint8_t  cmd;
    bool     write;          
    uint8_t  rx[72];
    size_t   rx_n;
    uint32_t t;              
    uint32_t deadline;
 
    uint32_t last_display, last_state, last_input, last_identify, last_slot;
} pdmini_t;

void pdmini_init(pdmini_t *d, const pdmini_io_t *io, uint32_t now_ms);

typedef enum {
    PDMINI_CHECK_NONE = 0,  
    PDMINI_CHECK_ASKED,     
    PDMINI_CHECK_SENT,      
    PDMINI_CHECK_OFF,       
    PDMINI_CHECK_NOT_OFF,   
} pdmini_check_t;

void pdmini_check_off(pdmini_t *d);

pdmini_check_t pdmini_checked(const pdmini_t *d);

void pdmini_want(pdmini_t *d, bool output, uint16_t set_mv, uint16_t set_ma);

void pdmini_restored(pdmini_t *d);

void pdmini_reset(pdmini_t *d);

void pdmini_want_off(pdmini_t *d);

void pdmini_rx(pdmini_t *d, uint8_t byte, uint32_t now_ms);

void pdmini_step(pdmini_t *d, uint32_t now_ms);

const pdmini_status_t *pdmini_status(const pdmini_t *d);

bool pdmini_may_be_on(const pdmini_t *d);

uint16_t pdmini_cap_mv(uint32_t vin_mv);
 
#ifdef __cplusplus
}
#endif