ra8_epd_cal.h

Go to the documentation of this file.

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

typedef enum : uint16_t {
  k_ra8_epd_cal_blob_size      = 32U, 
  k_ra8_epd_cal_schema_version = 1U,  
  k_ra8_epd_cal_payload_len    = 2U,  
} ra8_epd_cal_limits_t;

typedef enum : uint8_t {
  k_ra8_epd_cal_off_magic       = 0U,  
  k_ra8_epd_cal_off_version     = 4U,  
  k_ra8_epd_cal_off_reserved0   = 5U,  
  k_ra8_epd_cal_off_payload_len = 6U,  
  k_ra8_epd_cal_off_vcom_mv     = 8U,  
  k_ra8_epd_cal_off_reserved1   = 10U, 
  k_ra8_epd_cal_off_crc32       = 28U, 
} ra8_epd_cal_layout_t;

typedef enum : uint8_t {
  k_ra8_epd_cal_magic_b0 = 0x45U, 
  k_ra8_epd_cal_magic_b1 = 0x56U, 
  k_ra8_epd_cal_magic_b2 = 0x43U, 
  k_ra8_epd_cal_magic_b3 = 0x4DU, 
} ra8_epd_cal_magic_t;

typedef enum : uint32_t {
  k_ra8_epd_cal_extra_mram_offset = 0x200U, 
} ra8_epd_cal_storage_t;

typedef enum : uint8_t {
  k_ra8_epd_cal_src_none        = 0U, 
  k_ra8_epd_cal_src_panel       = 1U, 
  k_ra8_epd_cal_src_record      = 2U, 
  k_ra8_epd_cal_src_provisioned = 3U, 
  k_ra8_epd_cal_src_bench       = 4U, 
} ra8_epd_cal_source_t;

typedef struct {
  uint16_t min_mv; 
  uint16_t max_mv; 
} ra8_epd_cal_limits_mv_t;

typedef struct {
  uint16_t vcom_mv;        
  uint8_t  schema_version; 
} ra8_epd_cal_record_t;

typedef ra8_err_t (*ra8_epd_cal_nv_read_fn_t)(void* ctx, uint8_t* dst, size_t len);

typedef ra8_err_t (*ra8_epd_cal_nv_write_fn_t)(void* ctx, const uint8_t* src, size_t len);

typedef struct {
  ra8_epd_cal_nv_read_fn_t  read;  
  ra8_epd_cal_nv_write_fn_t write; 
  void*                     ctx;   
} ra8_epd_cal_store_t;

typedef ra8_err_t (*ra8_epd_cal_panel_get_fn_t)(void* ctx, uint16_t* out_mv);

typedef ra8_err_t (*ra8_epd_cal_panel_set_fn_t)(void* ctx, uint16_t mv);

typedef struct {
  ra8_epd_cal_panel_get_fn_t get; 
  ra8_epd_cal_panel_set_fn_t set; 
  void*                      ctx; 
} ra8_epd_cal_panel_ops_t;

typedef struct {
  ra8_epd_cal_limits_mv_t limits;          
  ra8_epd_cal_panel_ops_t panel;           
  ra8_epd_cal_store_t     store;           
  uint16_t                provisioned_mv;  
  bool                    has_provisioned; 
} ra8_epd_cal_cfg_t;

typedef struct {
  uint16_t             vcom_mv; 
  ra8_epd_cal_source_t source;  
} ra8_epd_cal_result_t;
 
/* ===========================================================================
 * Record serialisation
 * ===========================================================================
 */

[[nodiscard]] bool ra8_epd_cal_vcom_in_range(uint16_t mv, const ra8_epd_cal_limits_mv_t* limits);

[[nodiscard]] ra8_err_t
ra8_epd_cal_serialize(const ra8_epd_cal_record_t* rec, uint8_t* dst, size_t dst_size);

[[nodiscard]] ra8_err_t
ra8_epd_cal_deserialize(const uint8_t* src, size_t src_size, ra8_epd_cal_record_t* out_rec);
 
/* ===========================================================================
 * Resolution + application
 * ===========================================================================
 */

[[nodiscard]] ra8_err_t ra8_epd_cal_resolve(const ra8_epd_cal_cfg_t* cfg,
                                            ra8_epd_cal_result_t*    out_result);

[[nodiscard]] ra8_err_t ra8_epd_cal_apply(const ra8_epd_cal_cfg_t*    cfg,
                                          const ra8_epd_cal_result_t* result);

[[nodiscard]] ra8_err_t ra8_epd_cal_provision(const ra8_epd_cal_cfg_t* cfg, uint16_t vcom_mv);
 
#ifdef __cplusplus
}
#endif