tone.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 TONE_BLOCK 4u
#define TONE_OUTLIER_PCT 45u
#define TONE_BEEP_QUEUE 16u

#define TONE_WINDOW_US_MAX 100000u   
#define TONE_GAP_US_MAX    1000000u  
#define TONE_GLITCH_NS_MAX 10000u    
#define TONE_HOLD_NS_MAX   100000u   

typedef struct {
    uint32_t tick_hz;        
    uint32_t window_us;      
    uint32_t f_min_hz;       
    uint32_t f_max_hz;       
    uint32_t carrier_min_hz;
    uint32_t glitch_ns;
    uint32_t hold_ns;
    uint32_t gap_us;
    uint32_t split_pct;
    uint32_t min_periods;    
    uint32_t window_min_periods; 
} tone_cfg_t;

typedef struct {
    uint64_t t;
    bool     level;
} tone_edge_t;

typedef struct {
    uint64_t index;          
    bool     present;        
    float    freq_hz;        
    uint32_t periods;        
    uint32_t bursts;         
} tone_window_t;
 
typedef enum {
    TONE_BEEP_AFTER_CHANGE  = 1u << 0,
    TONE_BEEP_BEFORE_CHANGE = 1u << 1,
} tone_beep_flag_t;
 
typedef struct {
    uint64_t start;          
    uint64_t end;            
    float    freq_hz;        
    float    carrier_hz;
    uint32_t bursts;
    uint32_t periods;        
    uint8_t  flags;          
} tone_beep_t;

typedef struct {
    uint32_t edges;          
    uint32_t glitches;       
    uint32_t out_of_order;   
    uint32_t beeps;          
    uint32_t rejected;
    uint32_t lost;           
} tone_stats_t;

typedef struct {
    uint64_t p;              
    uint64_t s_open;         
    uint64_t e_before;       
    bool     good;           
} tone_pend_t;

typedef struct {
    tone_cfg_t c;
    uint64_t win_ticks, per_min, per_max, car_max, glitch, gap;
    uint64_t start_low;      
    uint64_t spacing;
 
    bool     seen;           
    uint64_t now;            
    bool     have_edge;                 
    uint64_t last_edge;                 
    bool     high;           
    uint64_t last_rise,                     
             last_fall;                     
 
    /* The run: bursts with no silence of gap between them. */
    bool     in_run;
    uint64_t car_low;        
    uint64_t car_high;       
    uint64_t car_rise;       
    bool     rise_started;   
    uint64_t burst_start, burst_e_before;
 
    /* The beep under way. */
    uint64_t b_start;
    uint64_t b_sum;
    uint32_t b_n, b_bursts;
    uint8_t  b_flags;
    tone_pend_t pend[TONE_BLOCK];
    uint32_t n_pend;
 
    /* The window under way, and the last one finished. */
    uint64_t w_index, w_end, w_sum;
    uint32_t w_n, w_bursts;
    bool     have_window;
    tone_window_t window;
 
    tone_beep_t q[TONE_BEEP_QUEUE];
    uint32_t q_head, q_len;
    tone_stats_t st;
} tone_t;

void tone_cfg_defaults(tone_cfg_t *c, uint32_t tick_hz);

bool tone_init(tone_t *d, const tone_cfg_t *c);

void tone_edge(tone_t *d, uint64_t t, bool level);

void tone_feed(tone_t *d, const tone_edge_t *e, size_t n);

void tone_advance(tone_t *d, uint64_t now);

void tone_flush(tone_t *d);

bool tone_window(const tone_t *d, tone_window_t *w);

bool tone_next_beep(tone_t *d, tone_beep_t *b);

bool tone_busy(const tone_t *d);

const tone_stats_t *tone_stats(const tone_t *d);

uint64_t tone_ns_ticks(uint64_t tick_hz, uint64_t ns);

uint64_t tone_ticks_us(const tone_t *d, uint64_t ticks);
 
/* ------------------------------------------------------------ hold-off */

typedef struct {
    uint64_t hold;           
    bool     line;           
    bool     pending;        
    uint64_t fall;           
    uint64_t out_t;          
} tone_holdoff_t;

void tone_holdoff_init(tone_holdoff_t *h, uint32_t tick_hz, uint32_t hold_ns);

size_t tone_holdoff_edge(tone_holdoff_t *h, uint64_t t, bool level,
                         tone_edge_t out[2]);

size_t tone_holdoff_advance(tone_holdoff_t *h, uint64_t now,
                            tone_edge_t out[1]);

uint64_t tone_holdoff_horizon(const tone_holdoff_t *h, uint64_t now);
 
#ifdef __cplusplus
}
#endif