tone_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 TONE_LINK_MINOR 8u

#define TONE_LINK_SETTLE_MS 500u

#define TONE_LINK_READ_MS 40u

#define TONE_LINK_RETRY_MS 5000u

#define TONE_LINK_STALE_MS 500u

#define TONE_LINK_WINDOW_STALE_MS 1500u

#define TONE_LINK_EVENT_GAP_MS 5000u

#define TONE_LINK_HISTORY 8u
#define TONE_LINK_SHOWN 4u

#define TONE_LINK_STATUS_COUNT \
    ((unsigned)LINK_TN_COUNT - (unsigned)LINK_TN_FLAGS)

#define TONE_LINK_BEEP_COUNT \
    ((unsigned)LINK_TN_EVT_FLAGS - (unsigned)LINK_TN_EVT_SEQ + 1u)

#define TONE_LINK_NO_ANSWER (-1)
#define TONE_LINK_ACK       0

typedef struct {
    bool     enable;          
    uint8_t  pin;             
    uint16_t f_min_hz;        
    uint16_t f_max_hz;        
    uint8_t  split_pct;       
    uint8_t  gap_ms;          
    uint8_t  min_periods;     
} tone_setup_t;

enum {
    TONE_LINK_EV_NO_PAGE      = 0x01,
    TONE_LINK_EV_PIN_REFUSED  = 0x02,
    TONE_LINK_EV_SETUP_REFUSED = 0x04,
    TONE_LINK_EV_PIN_BUSY     = 0x08,
    TONE_LINK_EV_OVERRUN      = 0x10,
};

#define TONE_LINK_EV_SETUP ((uint16_t)(TONE_LINK_EV_PIN_REFUSED           \
                                       | TONE_LINK_EV_SETUP_REFUSED       \
                                       | TONE_LINK_EV_PIN_BUSY))

typedef enum {
    TONE_LINK_OP_NONE = 0,
    TONE_LINK_OP_READ_SETUP,    
    TONE_LINK_OP_FRAME0,        
    TONE_LINK_OP_FRAME1,        
    TONE_LINK_OP_STATUS,        
    TONE_LINK_OP_SELECT,        
    TONE_LINK_OP_BEEP,          
} tone_link_op_kind_t;

typedef struct {
    tone_link_op_kind_t kind;
    bool     write;           
    uint8_t  page;            
    uint8_t off,                            
            n;                              
    uint16_t regs[4];         
} tone_link_op_t;

typedef struct {
    uint16_t seq;             
    uint32_t start_ms;        
    uint16_t len_dms;         
    uint16_t freq_dhz;        
    uint16_t bursts;          
    uint16_t carrier_hhz;     
    uint8_t  flags;           
} tone_beep_t;

typedef enum {
    TONE_STATE_OFF = 0,       
    TONE_STATE_NO_PAGE,       
    TONE_STATE_WAITING,       
    TONE_STATE_RUNNING,       
    TONE_STATE_REFUSED,       
    TONE_STATE_STOPPED,       
} tone_state_t;

typedef struct {
    tone_state_t state;
    bool     read;
    bool     overrun;         
    bool     tone;            
    bool     beep;            
    uint16_t win_freq_dhz;    
    uint16_t win_periods;     
    uint16_t lost;            
    uint16_t glitches;        
    uint32_t missed;          
    uint8_t  n;               
    tone_beep_t beeps[TONE_LINK_SHOWN];   
} tone_readout_t;

typedef struct {
    bool     up;              
    bool     page;            
 
    /* What is asked, as the page is to hold it. */
    bool     want_set;
    uint16_t want[LINK_TN_CONFIG_COUNT];
    uint32_t want_ms;         
 
    /* What the page holds, as read or written since the link came up. */
    bool     known;
    uint16_t held[LINK_TN_CONFIG_COUNT];
    bool     refused0, refused1;
    bool     retry0;          
    bool     busy_nack;       
    uint8_t  told;            
    uint32_t refused0_ms;
    uint32_t retry_ms;        
 
    /* The exchange in flight. */
    tone_link_op_kind_t pending;
    uint16_t out[4];
 
    /* The status read. */
    bool     asked_status;
    uint32_t status_asked_ms;
    bool     have_status;
    uint16_t status[TONE_LINK_STATUS_COUNT];
    uint32_t status_ms;
    uint16_t was_flags;       
    bool     win_seen;        
    uint16_t win_last;        
    uint32_t win_moved_ms;    
 
    /* The beeps. */
    bool     synced;          
    bool     ring_empty;      
    uint8_t  quiet;           
    uint16_t last;            
    uint32_t missed;
    bool     sel_ok;          
    uint16_t sel_num;
    tone_beep_t hist[TONE_LINK_HISTORY];
    uint8_t  hist_n;          
    uint8_t  hist_at;         
    uint32_t beeps_read;
 
    /* What has been said. */
    uint16_t events;
    bool     event_given;
    uint32_t event_ms;
} tone_link_t;

void tone_link_init(tone_link_t *t);

void tone_link_lost(tone_link_t *t);

void tone_link_came_up(tone_link_t *t, uint16_t minor, uint32_t now_ms);

void tone_link_want(tone_link_t *t, const tone_setup_t *w, uint32_t now_ms);

bool tone_link_next(tone_link_t *t, uint32_t now_ms, tone_link_op_t *op);

void tone_link_done(tone_link_t *t, int result, const uint16_t *regs,
                    uint32_t now_ms);

uint16_t tone_link_event(tone_link_t *t, uint32_t now_ms);

bool tone_link_event_stands(const tone_link_t *t, uint16_t ev);

void tone_link_event_back(tone_link_t *t, uint16_t ev);

bool tone_link_settled(const tone_link_t *t);

enum {
    TONE_LINK_ROWS_TAP  = 0x01,
    TONE_LINK_ROWS_BEEP = 0x02,
};

uint8_t tone_link_unheld(const tone_link_t *t);

unsigned tone_link_beeps(const tone_link_t *t, tone_beep_t *out,
                         unsigned max);

uint32_t tone_link_read_count(const tone_link_t *t);
uint32_t tone_link_missed(const tone_link_t *t);

uint16_t tone_link_flags(const tone_link_t *t);

void tone_link_readout(const tone_link_t *t, uint32_t now_ms,
                       tone_readout_t *r);

unsigned tone_link_pin(const tone_link_t *t);
unsigned tone_link_f_min(const tone_link_t *t);
unsigned tone_link_f_max(const tone_link_t *t);

bool tone_link_held_pin(const tone_link_t *t, int *pin);
 
#ifdef __cplusplus
}
#endif