cmdfuncs.hpp

Go to the documentation of this file.

// ╭─╮╭─╴╷╭─╮┌─╮
// ╰─╯╵  ╵╰─╯╵ ╵
#pragma once
 
#include "itk/logger.hpp"
#include "itk/utils.hpp"
#include "cmdluts.hpp"
 
 
namespace itk::itkpix::cmd {
  extern itk::Logger log;
 
  const uint16_t SYNC = 0x817E; 
  const uint16_t IDLE = 0xAAAA; 
 
  constexpr uint8_t TAG_CALIB   = 32; 
  constexpr uint8_t TAG_CLEAR   = 33; 
  constexpr uint8_t TAG_GLOBAL  = 34; 
  constexpr uint8_t TAG_PLLLOCK = 35; 
  constexpr uint8_t TAG_REGRD   = 36; 
  constexpr uint8_t TAG_TRIGRD  = 37; 
  constexpr uint8_t TAG_REGWR   = 53; 
 
  constexpr uint8_t TAG_TRIG0   = 37; 
  constexpr uint8_t TAG_TRIG1   = 38; 
  constexpr uint8_t TAG_TRIGF   = TAG_TRIG1 + 15; 
 
  inline uint8_t enc_data(uint8_t data5) {
    assert(data5 < 32);
    return enc_symb[data5];
  }
 
  inline uint8_t enc_trig(uint8_t trig) {
    assert(trig != 0 && trig < 16);
    return enc_symb[TAG_TRIG0 + trig];
  }
 
  inline uint8_t enc_tag(uint8_t tag) {
    assert(tag < 54);
    return enc_symb[tag];
  }
 
  constexpr uint8_t PLLLOCK = enc_symb[TAG_PLLLOCK]; 
  constexpr uint8_t TRIGRD  = enc_symb[TAG_TRIGRD];  
  constexpr uint8_t CLEAR   = enc_symb[TAG_CLEAR];   
  constexpr uint8_t GLOBAL  = enc_symb[TAG_GLOBAL];  
  constexpr uint8_t CALIB   = enc_symb[TAG_CALIB];   
  constexpr uint8_t REGWR   = enc_symb[TAG_REGWR];   
  constexpr uint8_t REGRD   = enc_symb[TAG_REGRD];   
 
  // static validation
  static_assert(PLLLOCK == 0xAA);
  static_assert(TRIGRD  == 0x69);
  static_assert(CLEAR   == 0x5A);
  static_assert(GLOBAL  == 0x5C);
  static_assert(CALIB   == 0x63);
  static_assert(REGWR   == 0x66);
  static_assert(REGRD   == 0x65);
 
  inline bool is_data_tag(uint8_t tag) {
    return (tag < 32);
  }
 
  inline bool is_trig_tag(uint8_t tag) {
    return (TAG_TRIG1 <= tag and tag <= TAG_TRIGF);
  }
 
  inline bool is_cmd_tag(uint8_t tag) {
    return (TAG_CALIB <= tag and tag <= TAG_TRIGRD) or (tag == TAG_REGWR);
  }
 
  inline bool is_data(uint8_t code) { return is_data_tag(dec_symb[code]); }
 
  inline bool is_trig(uint8_t code) { return is_trig_tag(dec_symb[code]); }
 
  inline bool is_cmd(uint8_t code)  { return is_cmd_tag(dec_symb[code]); }
 
  inline uint8_t encode5b(uint8_t data5) {
    trunc_bits<5>(data5);
    return enc_data(data5);
  }
 
  inline uint16_t encode10b(uint8_t data5a, uint8_t data5b) {
    trunc_bits<5>(data5a);
    trunc_bits<5>(data5b);
    return encode5b(data5a) << 8 | encode5b(data5b);
  }
 
  inline uint16_t encode10b(uint32_t data) {
    return encode10b(0x1F & (data >> 5), 0x1F & data);
  }
 
  inline uint8_t decode8b(uint8_t code) {
    return dec_symb[code];
  }
 
  inline auto decode16b(uint16_t frame) {
    return std::make_tuple(decode8b(frame >> 8), decode8b(frame & 0xFF));
  }
 
  inline uint32_t decode_data(uint16_t frame) {
    auto [data0, data1] = decode16b(frame);
    assert(data0 < 32 && data1 < 32);
    return data0 << 5 | data1;
  }
 
  inline uint16_t make_head(uint8_t cmd, uint8_t chip_id) {
    return cmd << 8 | encode5b(chip_id);
  }
 
  inline auto parse_head(uint16_t frame) {
    uint8_t cmd     = decode8b(frame >> 8);
    uint8_t chip_id = decode8b(frame & 0xFF);
    
    struct res { uint8_t cmd; uint8_t chip_id; };
    return res { cmd, chip_id };
  }
 
  inline std::array<uint16_t, 1>
  make_idle() { return { cmd::IDLE }; }
 
  inline std::array<uint16_t, 1>
  make_sync() { return { cmd::SYNC }; }
 
 
  inline std::array<uint16_t, 1>
  make_trig(uint8_t bc, uint8_t tag) {
    trunc_bits<4>(bc);
    assert(tag < 54);
    if (bc == 0 || tag >= 54) return { cmd::IDLE };
    uint16_t trig = enc_trig(bc) << 8 | enc_symb[tag];
    return { trig };
  }
 
  inline auto parse_trig(std::array<uint16_t, 1> frames) {
    auto [bc_tag, tag] = decode16b(frames[0]);
    uint8_t status = 0;
    status |= (is_trig(bc_tag) ? 0x0 : 0x1);
    uint8_t bc = bc_tag - TAG_TRIG0;
    struct res { uint8_t status; uint8_t bc; uint8_t tag; };
    return res { status, bc, tag };
  }
 
 
  inline std::array<uint16_t, 1>
  make_clear(uint8_t chip_id) {
    trunc_bits<5>(chip_id);
    return { make_head(CLEAR, chip_id) };
  }
 
  inline auto parse_clear(std::array<uint16_t, 1> frames) {
    auto [cmd, chip_id] = decode16b(frames[0]);
    uint8_t status = (cmd == TAG_CLEAR ? 0x0 : 0x1);
    struct res { uint8_t status; uint8_t cmd; uint8_t chip_id; };
    return res { status, cmd, chip_id };
  }
 
 
  inline std::array<uint16_t, 2>
  make_read_trig(uint8_t chip_id, uint8_t ext_tag) {
    trunc_bits<5>(chip_id);
    return { make_head(cmd::TRIGRD, chip_id), encode10b(ext_tag) };
  }
 
  inline auto parse_read_trig(std::array<uint16_t, 2> frames) {
    auto [cmd, chip_id] = decode16b(frames[0]);
    auto data = decode_data(frames[1]);
    uint8_t ext_tag = data & 0xFF;
    uint8_t status = 0;
    status |= (cmd == TAG_TRIGRD ? 0x0 : 0x1);
    status |= (data & 0x300      ? 0x0 : 0x2);
    struct res { uint8_t status; uint8_t cmd; uint8_t chip_id; uint8_t ext_tag; };
    return res { status, cmd, chip_id, ext_tag };
  }
 
 
  inline std::array<uint16_t, 1>
  make_global(uint8_t chip_id) {
    trunc_bits<5>(chip_id);
    return { make_head(cmd::GLOBAL, chip_id) };
  }
 
  inline auto parse_global(std::array<uint16_t, 1> frames) {
    auto [cmd, chip_id] = parse_head(frames[0]);
    uint8_t status = (cmd == TAG_GLOBAL ? 0x0 : 0x1);
    struct res { uint8_t status; uint8_t cmd; uint8_t chip_id; };
    return res { status, cmd, chip_id };
  }
 
 
 
  inline std::array<uint16_t, 3>
  make_calib(uint8_t chip_id, uint8_t edg_mode, uint8_t edg_delay, uint8_t edg_width,
    uint8_t aux_mode, uint8_t aux_delay) {
 
    trunc_bits<5>(chip_id);
    trunc_bits<1>(edg_mode);
    trunc_bits<5>(edg_delay);
    trunc_bits<8>(edg_width);
    trunc_bits<1>(aux_mode);
    trunc_bits<5>(aux_delay);
 
    // i - id[5]
    // m - edge_mode, d - edge_delay[5], w - edge_width[8]
    // a - aux_mode,  b - aux_delay[5]
    // [cmd].iiiii mdddd.dwwww wwwwa.bbbbb
    uint32_t buff = edg_mode << 19 | edg_delay << 14 | edg_width << 6 | aux_mode << 5 | aux_delay;
    return { make_head(cmd::CALIB, chip_id), encode10b(buff >> 10), encode10b(buff) };
  }
 
  inline auto parse_calib(std::array<uint16_t, 3> frames) {
    auto [cmd, chip_id] = parse_head(frames[0]);
    auto buff = decode_data(frames[1]) << 10 | decode_data(frames[2]);
    uint8_t aux_delay  = buff & 0x1F; buff = buff >> 5;
    uint8_t aux_mode   = buff & 0x1;  buff = buff >> 1;
    uint8_t edge_width = buff & 0xFF; buff = buff >> 8;
    uint8_t edge_delay = buff & 0x1F; buff = buff >> 5;
    uint8_t edge_mode  = buff & 0x1;  buff = buff >> 1;
 
    uint8_t status = (cmd == TAG_CALIB ? 0x0 : 0x1);
    struct res {
      uint8_t status; uint8_t cmd; uint8_t chip_id;
      uint8_t edge_mode; uint8_t edge_delay; uint8_t edge_width;
      uint8_t aux_mode; uint8_t aux_delay;
    };
    return res { status, cmd, chip_id, edge_mode, edge_delay, edge_width, aux_mode, aux_delay };
  }
 
 
  inline std::array<uint16_t, 2>
  make_read_reg(uint8_t chip_id, uint16_t addr) {
    trunc_bits<5>(chip_id);
    trunc_bits<9>(addr);
 
    // i - id[5], a - addr[9]
    // [cmd].iiiii 0aaaa.aaaaa
    return { make_head(cmd::REGRD, chip_id), encode10b(addr) };
  }
 
  inline auto parse_read_reg(std::array<uint16_t, 2> frames) {
    auto [cmd, chip_id] = parse_head(frames[0]);
    uint16_t addr = decode_data(frames[1]);
    uint8_t status = 0;
    status |= (cmd == TAG_REGRD ? 0x0 : 0x1);
    status |= (addr < 0x200 ? 0x0 : 0x2);
    struct res { uint8_t status; uint8_t cmd; uint8_t chip_id; uint16_t addr; };
    return res { status, cmd, chip_id, addr };
  }
 
 
  inline std::array<uint16_t, 4>
  make_write_reg(uint8_t chip_id, uint16_t addr, uint16_t data) {
    trunc_bits<5>(chip_id);
    trunc_bits<9>(addr);
 
  // [cmd].iiiii 0aaaa.aaaaa ddddd.ddddd ddddd.d0000
  uint32_t buff = addr << 20 | data << 4;
 
    return { make_head(cmd::REGWR, chip_id),
             encode10b(buff >> 20), encode10b(buff >> 10), encode10b(buff) };
  }
 
  inline auto parse_write_reg(std::array<uint16_t, 4> frames) {
    auto [cmd, chip_id] = parse_head(frames[0]);
    auto buff = decode_data(frames[1]) << 20 | decode_data(frames[2]) << 10 | decode_data(frames[3]);
    uint16_t addr = (buff >> 20) & 0x1FF;
    uint16_t data = (buff >> 4) & 0xFFFF;
    uint8_t status = 0;
    status |= (cmd == REGWR ? 0x0 : 0x1);
    status |= (buff >> 29   ? 0x0 : 0x2);
    status |= (buff & 0xF   ? 0x0 : 0x4);
    struct res { uint8_t status; uint8_t cmd; uint8_t chip_id; uint16_t addr; uint16_t data; };
    return res { status, cmd, chip_id, addr, data };
  }
 
 
 
  inline std::array<uint16_t, 2>
  make_write_pix_start(uint8_t chip_id) {
    trunc_bits<5>(chip_id);
    return { make_head(REGWR, chip_id), encode10b(0x200) };
  }
 
  inline auto
  parse_write_pix_start(std::array<uint16_t, 2> frames) {
    auto [cmd, chip_id] = parse_head(frames[0]);
    uint16_t data = decode_data(frames[1]);
    
    uint8_t status = 0;
    status |= (cmd == cmd::REGWR ? 0x0 : 0x1);
    status |= (data == 0x200     ? 0x0 : 0x2);
    struct res { uint8_t status; uint8_t cmd; };
    return res { status, cmd };
  }
 
 
  inline uint16_t make_write_pix_next(uint16_t data) {
    return encode10b(data);
  }
 
} // itk::itkpix::cmd