log_writer.h

Go to the documentation of this file.

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

typedef struct {
    int (*write)(void *ctx, const void *data, size_t len);
    bool (*flush)(void *ctx);
    void *ctx;
} log_sink_t;

#define LOG_WRITER_LINE_MAX 256

typedef struct {
    log_sink_t sink;
    uint32_t   rows;
    uint32_t   pending;      
    float      last_s;       
    float      committed_s;  
    bool       header_done;             
    bool       failed;     
    bool       by_map;
    log_cols_t cols;
    char       line[LOG_WRITER_LINE_MAX];
} log_writer_t;
 
/*
 * What a power cut costs.
 *
 * The writer commits every LOG_WRITER_FLUSH_ROWS rows, and again once
 * LOG_WRITER_FLUSH_S have passed on the run's own clock, whichever comes
 * first.  At the panel's 20Hz sample rate the two are the same point: 20
 * rows is 1000ms of run.
 *
 * A run interrupted at any moment therefore loses at most 20 rows, spanning
 * less than 1.0s of its own clock.  Twenty and not nineteen: the count
 * reaches LOG_WRITER_FLUSH_ROWS before the commit is attempted and is
 * cleared only once the commit has succeeded, so those twenty rows are not
 * durable for as long as the sink takes.  The price is one commit per second per
 * run.
 */
#define LOG_WRITER_FLUSH_ROWS 20u
#define LOG_WRITER_FLUSH_S    1.0f

#define LOG_WRITER_SEP ';'

#define LOG_WRITER_SRC_MEASURED "measured"
#define LOG_WRITER_SRC_MODEL    "model"

void log_writer_init(log_writer_t *w, const log_sink_t *sink);

void log_writer_set_cols(log_writer_t *w, const log_cols_t *cols);

bool log_writer_header(log_writer_t *w);

bool log_writer_row(log_writer_t *w, float t_s, const bench_state_t *b);

typedef struct {
    float   v;           
    float   i;           
    float   p;           
    float   charge_mah;  
    float   energy_wh;   
    uint8_t ok;          
    uint8_t counted;     
    bool    withheld;    
} log_rail_t;

void log_rail_take(log_rail_t *out, const supply_state_t *s,
                   bool row_modelled);

void log_rail_count(bench_totals_t *t, log_rail_t *r, float dt_s,
                    bool driving);

void log_rail_take_ina(log_rail_t *out, const sense_link_win_t *win,
                       bool row_modelled);

typedef struct {
    float    angle_deg;  
    uint16_t pulse_us;   
    bool     pulse_ok;   
    bool     angle_ok;   
} log_servo_t;

uint32_t log_servo_pack(bool pulse_ok, uint16_t pulse_us, bool angle_ok,
                        float angle_deg);

void log_servo_unpack(uint32_t packed, bool row_modelled, log_servo_t *out);

bool log_writer_servo_row(log_writer_t *w, float t_s, const bench_state_t *b,
                          const log_rail_t *rail, const log_servo_t *sv);

bool log_writer_supply_row(log_writer_t *w, float t_s,
                           const supply_state_t *s);

bool log_writer_commit(log_writer_t *w);

static inline uint32_t log_writer_pending(const log_writer_t *w)
{
    return (w == NULL) ? 0u : w->pending;
}

static inline bool log_writer_failed(const log_writer_t *w)
{
    return w == NULL || w->failed;
}
 
#ifdef __cplusplus
}
#endif