llcp_minipix_messages.h

Go to the documentation of this file.

#ifndef LLCP_MINIPIX_MESSAGES_H
#define LLCP_MINIPIX_MESSAGES_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
#include <stdbool.h>
#include <assert.h>  // for assert checks of struct sizes
#include <string.h>  // for memset
#include <llcp_endian.h>
 
/* definition of message IDs //{ */
 
// I don't want to have 0 or 1, due to debugging
// also, 0 or 1 is too common to get by accident
//
// the ids are grouped by tens according to
// common usage
 
// status
#define LLCP_STATUS_MSG_ID 10
#define LLCP_GET_STATUS_REQ_MSG_ID 11
#define LLCP_TEMPERATURE_MSG_ID 12
#define LLCP_GET_TEMPERATURE_REQ_MSG_ID 13
 
// frame-based measurement
#define LLCP_FRAME_DATA_MSG_ID 20
#define LLCP_MEASURE_FRAME_REQ_MSG_ID 21
#define LLCP_FRAME_DATA_TERMINATOR_MSG_ID 22
#define LLCP_GET_FRAME_DATA_REQ_MSG_ID 23
#define LLCP_FRAME_MEASUREMENT_FINISHED_MSG_ID 24
 
// ack
#define LLCP_ACK_MSG_ID 40
 
// masking
#define LLCP_UPDATE_PIXEL_MASK_REQ_MSG_ID 50
 
// power
#define LLCP_PWR_REQ_MSG_ID 60
 
// threshold
#define LLCP_SET_THRESHOLD_REQ_MSG_ID 70
 
// configuration presets
#define LLCP_SET_CONFIGURATION_PRESET_REQ_MSG_ID 80
 
// error
#define LLCP_MINIPIX_ERROR_MSG_ID 90
 
//}
 
/* definition of error IDs //{ */
 
#define LLCP_MINIPIX_ERROR_COUNT 10
extern const char* LLCP_MinipixErrors[LLCP_MINIPIX_ERROR_COUNT];
 
#define LLCP_MINIPIX_ERROR_MEASUREMENT_FAILED 0
#define LLCP_MINIPIX_ERROR_POWERUP_FAILED 1
#define LLCP_MINIPIX_ERROR_POWERUP_TPX3_RESET_SYNC 2
#define LLCP_MINIPIX_ERROR_POWERUP_TPX3_RESET_RECVDATA 3
#define LLCP_MINIPIX_ERROR_POWERUP_TPX3_INIT_RESETS 4
#define LLCP_MINIPIX_ERROR_POWERUP_TPX3_INIT_CHIPID 5
#define LLCP_MINIPIX_ERROR_POWERUP_TPX3_INIT_DACS 6
#define LLCP_MINIPIX_ERROR_POWERUP_TPX3_INIT_PIXCFG 7
#define LLCP_MINIPIX_ERROR_POWERUP_TPX3_INIT_MATRIX 8
#define LLCP_MINIPIX_ERROR_INVALID_PRESET 9
 
//}
 
// | ----------------------- Pixel data ----------------------- |
 
/* LLCP_PixelData_t //{ */
 
typedef struct __attribute__((packed))
{
  uint8_t  value1 : 4;
  uint16_t value2 : 10;
  uint16_t value3 : 14;
  uint16_t address : 16;
  uint16_t header : 4;
} LLCP_PixelDataCommon_t;
 
typedef struct __attribute__((packed))
{
  uint8_t  ftoa : 4;
  uint16_t tot : 10;
  uint16_t toa : 14;
  uint16_t address : 16;
  uint16_t header : 4;
} LLCP_PixelDataToAToT_t;
 
typedef struct __attribute__((packed))
{
  uint8_t  ftoa : 4;
  uint16_t dummy : 10;
  uint16_t toa : 14;
  uint16_t address : 16;
  uint16_t header : 4;
} LLCP_PixelDataToA_t;
 
typedef struct __attribute__((packed))
{
  uint8_t  dummy : 4;
  uint16_t mpx : 10;
  uint16_t itot : 14;
  uint16_t address : 16;
  uint16_t header : 4;
} LLCP_PixelDataMpxiToT_t;
 
typedef struct __attribute__((packed))
{
  // * the data in this form are in a form that can not be easily interpreted
  // * the data needs to put through functions that decode the real values (not done by mui atm.)
  uint8_t data[6];
} LLCP_PixelData_t;
 
void hton_LLCP_PixelData_t(LLCP_PixelData_t* data);
 
void ntoh_LLCP_PixelData_t(LLCP_PixelData_t* data);
 
void init_LLCP_PixelData_t(LLCP_PixelData_t* data);
 
//}
 
// | ------------- Frame data (integrated images) ------------- |
 
/* LLCP_FrameDataMsg_t //{ */
 
/* struct LLCP_FrameData_t //{ */
 
#define LLCP_FRAME_DATA_N_PIXELS 41
 
#define LLCP_TPX3_PXL_MODE_TOA_TOT 0
#define LLCP_TPX3_PXL_MODE_TOA 1
#define LLCP_TPX3_PXL_MODE_MPX_ITOT 2
 
typedef struct __attribute__((packed))
{
  uint16_t         frame_id;          // a unique identifier of the frame, can be used to stitch the packets together
  uint16_t         packet_id;         // should be incremented for each packet of the frame
  uint8_t          mode;              // will determine the measurement mode
  uint8_t          n_pixels;          // how many pixels are filled in
  uint8_t          checksum_matched;  // 1 if the messages was received by MUI with correct checksum
  LLCP_PixelData_t pixel_data[LLCP_FRAME_DATA_N_PIXELS];
} LLCP_FrameData_t;
 
void hton_LLCP_FrameData_t(LLCP_FrameData_t* data);
 
void ntoh_LLCP_FrameData_t(LLCP_FrameData_t* data);
 
void init_LLCP_FrameData_t(LLCP_FrameData_t* data);
 
//}
 
typedef struct __attribute__((packed))
{
  uint8_t          message_id;
  LLCP_FrameData_t payload;
} LLCP_FrameDataMsg_t;
 
void hton_LLCP_FrameDataMsg_t(LLCP_FrameDataMsg_t* msg);
 
void ntoh_LLCP_FrameDataMsg_t(LLCP_FrameDataMsg_t* msg);
 
void init_LLCP_FrameDataMsg_t(LLCP_FrameDataMsg_t* msg);
 
static_assert((sizeof(LLCP_FrameDataMsg_t) > 255) == 0, "LLCP_FrameDataMsg_t is too large");
 
//}
 
/* LLCP_FrameDataTerminatorMsg_t //{ */
 
/* struct LLCP_FrameDataTerminator_t //{ */
 
typedef struct __attribute__((packed))
{
  uint16_t frame_id;   // a unique identifier of the frame, can be used to stitch the packets together
  uint16_t n_packets;  // how many packets were sent
} LLCP_FrameDataTerminator_t;
 
void hton_LLCP_FrameDataTerminator_t(LLCP_FrameDataTerminator_t* data);
 
void ntoh_LLCP_FrameDataTerminator_t(LLCP_FrameDataTerminator_t* data);
 
void init_LLCP_FrameDataTerminator_t(LLCP_FrameDataTerminator_t* data);
 
//}
 
typedef struct __attribute__((packed))
{
  uint8_t                    message_id;
  LLCP_FrameDataTerminator_t payload;
} LLCP_FrameDataTerminatorMsg_t;
 
void hton_LLCP_FrameDataTerminatorMsg_t(LLCP_FrameDataTerminatorMsg_t* msg);
 
void ntoh_LLCP_FrameDataTerminatorMsg_t(LLCP_FrameDataTerminatorMsg_t* msg);
 
void init_LLCP_FrameDataTerminatorMsg_t(LLCP_FrameDataTerminatorMsg_t* msg);
 
static_assert((sizeof(LLCP_FrameDataTerminatorMsg_t) > 255) == 0, "LLCP_FrameDataTerminatorMsg_t is too large");
 
/* char (*terminator_size_check)[sizeof( LLCP_FrameDataTerminatorMsg_t )] = 1; */
 
//}
 
/* LLCP_MeasureFrameReqMsg_t //{ */
 
/* LLCP_MeasureFrameReq_t //{ */
 
typedef struct __attribute__((packed))
{
  uint16_t acquisition_time_ms;
  uint8_t  mode;
} LLCP_MeasureFrameReq_t;
 
void hton_LLCP_MeasureFrameReq_t(LLCP_MeasureFrameReq_t* data);
 
void ntoh_LLCP_MeasureFrameReq_t(LLCP_MeasureFrameReq_t* data);
 
void init_LLCP_MeasureFrameReq_t(LLCP_MeasureFrameReq_t* data);
 
//}
 
typedef struct __attribute__((packed))
{
  uint8_t                message_id;
  LLCP_MeasureFrameReq_t payload;
} LLCP_MeasureFrameReqMsg_t;
 
void hton_LLCP_MeasureFrameReqMsg_t(LLCP_MeasureFrameReqMsg_t* msg);
 
void ntoh_LLCP_MeasureFrameReqMsg_t(LLCP_MeasureFrameReqMsg_t* msg);
 
void init_LLCP_MeasureFrameReqMsg_t(LLCP_MeasureFrameReqMsg_t* msg);
 
static_assert((sizeof(LLCP_MeasureFrameReqMsg_t) > 255) == 0, "LLCP_MeasureFrameReqMsg_t is too large");
 
//}
 
/* LLCP_FrameMeasurementFinishedMsg_t //{ */
 
typedef struct __attribute__((packed))
{
  uint8_t message_id;
} LLCP_FrameMeasurementFinishedMsg_t;
 
void hton_LLCP_FrameMeasurementFinishedMsg_t(LLCP_FrameMeasurementFinishedMsg_t* msg);
 
void ntoh_LLCP_FrameMeasurementFinishedMsg_t(LLCP_FrameMeasurementFinishedMsg_t* msg);
 
void init_LLCP_FrameMeasurementFinishedMsg_t(LLCP_FrameMeasurementFinishedMsg_t* msg);
 
static_assert((sizeof(LLCP_FrameMeasurementFinishedMsg_t) > 255) == 0, "LLCP_FrameMeasurementFinishedMsg_t is too large");
 
/* char (*measurement_finished_size_check)[sizeof( LLCP_FrameMeasurementFinishedMsg_t) ] = 1; */
 
//}
 
/* LLCP_GetFrameDataReqMsg_t //{ */
 
typedef struct __attribute__((packed))
{
  uint8_t message_id;
} LLCP_GetFrameDataReqMsg_t;
 
void hton_LLCP_GetFrameDataReqMsg_t(LLCP_GetFrameDataReqMsg_t* msg);
 
void ntoh_LLCP_GetFrameDataReqMsg_t(LLCP_GetFrameDataReqMsg_t* msg);
 
void init_LLCP_GetFrameDataReqMsg_t(LLCP_GetFrameDataReqMsg_t* msg);
 
static_assert((sizeof(LLCP_GetFrameDataReqMsg_t) > 255) == 0, "LLCP_GetFrameDataReqMsg_t is too large");
 
//}
 
// | ---------------------- Pixel masking --------------------- |
 
/* LLCP_UpdatePixelMaskReqMsg_t //{ */
 
/* struct LLCP_UpdatePixelMaskReq_t //{ */
 
typedef struct __attribute__((packed))
{
  uint8_t x_coordinate;
  uint8_t y_coordinate;
  uint8_t masked;
} LLCP_UpdatePixelMaskReq_t;
 
void hton_LLCP_UpdatePixelMaskReq_t(LLCP_UpdatePixelMaskReq_t* data);
 
void ntoh_LLCP_UpdatePixelMaskReq_t(LLCP_UpdatePixelMaskReq_t* data);
 
void init_LLCP_UpdatePixelMaskReq_t(LLCP_UpdatePixelMaskReq_t* data);
 
//}
 
typedef struct __attribute__((packed))
{
  uint8_t                   message_id;
  LLCP_UpdatePixelMaskReq_t payload;
} LLCP_UpdatePixelMaskReqMsg_t;
 
void hton_LLCP_UpdatePixelMaskReqMsg_t(LLCP_UpdatePixelMaskReqMsg_t* msg);
 
void ntoh_LLCP_UpdatePixelMaskReqMsg_t(LLCP_UpdatePixelMaskReqMsg_t* msg);
 
void init_LLCP_UpdatePixelMaskReqMsg_t(LLCP_UpdatePixelMaskReqMsg_t* msg);
 
static_assert((sizeof(LLCP_UpdatePixelMaskReqMsg_t) > 255) == 0, "LLCP_UpdatePixelMaskReqMsg_t is too large");
 
//}
 
// | ------------------------ Threshold ----------------------- |
 
/* LLCP_SetThresholdReqMsg_t //{ */
 
/* struct LLCP_SetThresholdReq_t //{ */
 
typedef struct __attribute__((packed))
{
  uint16_t threshold_coarse;
  uint16_t threshold_fine;
} LLCP_SetThresholdReq_t;
 
void hton_LLCP_SetThresholdReq_t(LLCP_SetThresholdReq_t* data);
 
void ntoh_LLCP_SetThresholdReq_t(LLCP_SetThresholdReq_t* data);
 
void init_LLCP_SetThresholdReq_t(LLCP_SetThresholdReq_t* data);
 
//}
 
typedef struct __attribute__((packed))
{
  uint8_t                message_id;
  LLCP_SetThresholdReq_t payload;
} LLCP_SetThresholdReqMsg_t;
 
void hton_LLCP_SetThresholdReqMsg_t(LLCP_SetThresholdReqMsg_t* msg);
 
void ntoh_LLCP_SetThresholdReqMsg_t(LLCP_SetThresholdReqMsg_t* msg);
 
void init_LLCP_SetThresholdReqMsg_t(LLCP_SetThresholdReqMsg_t* msg);
 
static_assert((sizeof(LLCP_SetThresholdReqMsg_t) > 255) == 0, "LLCP_SetThresholdReqMsg_t is too large");
 
//}
 
// | ---------------------- Configuration --------------------- |
 
/* LLCP_SetConfigurationPresetReqMsg_t //{ */
 
/* struct LLCP_SetConfigurationPresetReq_t //{ */
 
typedef struct __attribute__((packed))
{
  uint8_t preset;
} LLCP_SetConfigurationPresetReq_t;
 
void hton_LLCP_SetConfigurationPresetReq_t(LLCP_SetConfigurationPresetReq_t* data);
 
void ntoh_LLCP_SetConfigurationPresetReq_t(LLCP_SetConfigurationPresetReq_t* data);
 
void init_LLCP_SetConfigurationPresetReq_t(LLCP_SetConfigurationPresetReq_t* data);
 
//}
 
typedef struct __attribute__((packed))
{
  uint8_t                          message_id;
  LLCP_SetConfigurationPresetReq_t payload;
} LLCP_SetConfigurationPresetReqMsg_t;
 
void hton_LLCP_SetConfigurationPresetReqMsg_t(LLCP_SetConfigurationPresetReqMsg_t* msg);
 
void ntoh_LLCP_SetConfigurationPresetReqMsg_t(LLCP_SetConfigurationPresetReqMsg_t* msg);
 
void init_LLCP_SetConfigurationPresetReqMsg_t(LLCP_SetConfigurationPresetReqMsg_t* msg);
 
static_assert((sizeof(LLCP_SetConfigurationPresetReqMsg_t) > 255) == 0, "LLCP_SetConfigurationPresetReqMsg_t is too large");
 
//}
 
// | ----------------------- Acknowledge ---------------------- |
 
/* LLCP_AckMsg_t //{ */
 
/* LLCP_Ack_t //{ */
 
typedef struct __attribute__((packed))
{
  uint8_t success;
} LLCP_Ack_t;
 
void hton_Ack_t(LLCP_Ack_t* data);
 
void ntoh_Ack_t(LLCP_Ack_t* data);
 
void init_Ack_t(LLCP_Ack_t* data);
 
//}
 
typedef struct __attribute__((packed))
{
  uint8_t    message_id;
  LLCP_Ack_t payload;
} LLCP_AckMsg_t;
 
void hton_LLCP_AckMsg_t(LLCP_AckMsg_t* msg);
 
void ntoh_LLCP_AckMsg_t(LLCP_AckMsg_t* msg);
 
void init_LLCP_AckMsg_t(LLCP_AckMsg_t* msg);
 
static_assert((sizeof(LLCP_AckMsg_t) > 255) == 0, "LLCP_AckMsg_t is too large");
 
/* char (*ack_size_check)[sizeof( LLCP_AckMsg_t )] = 1; */
 
//}
 
// | -------------------------- Power ------------------------- |
 
/* LLCP_PwrReqMsg_t //{ */
 
/* LLCP_PwrReq_t //{ */
 
typedef struct __attribute__((packed))
{
  uint8_t state;  // 1 = ON, 0 = OFF
} LLCP_PwrReq_t;
 
void hton_LLCP_PwrReq_t(LLCP_PwrReq_t* data);
 
void ntoh_LLCP_PwrReq_t(LLCP_PwrReq_t* data);
 
void init_LLCP_PwrReq_t(LLCP_PwrReq_t* data);
 
//}
 
typedef struct __attribute__((packed))
{
  uint8_t       message_id;
  LLCP_PwrReq_t payload;
} LLCP_PwrReqMsg_t;
 
void hton_LLCP_PwrReqMsg_t(LLCP_PwrReqMsg_t* msg);
 
void ntoh_LLCP_PwrReqMsg_t(LLCP_PwrReqMsg_t* msg);
 
void init_LLCP_PwrReqMsg_t(LLCP_PwrReqMsg_t* msg);
 
static_assert((sizeof(LLCP_PwrReqMsg_t) > 255) == 0, "LLCP_PwrReqMsg_t is too large");
 
//}
 
// | ------------------------- Status ------------------------- |
 
/* LLCP_StatusMsg_t //{ */
 
/* LLCP_Status_t //{ */
 
#define LLCP_STATUS_STR_LEN 128
 
typedef struct __attribute__((packed))
{
  uint16_t boot_count;
  uint8_t  status_str[LLCP_STATUS_STR_LEN];
} LLCP_Status_t;
 
void hton_LLCP_Status_t(LLCP_Status_t* data);
 
void ntoh_LLCP_Status_t(LLCP_Status_t* data);
 
void init_LLCP_Status_t(LLCP_Status_t* data);
 
//}
 
typedef struct __attribute__((packed))
{
  uint8_t       message_id;
  LLCP_Status_t payload;
} LLCP_StatusMsg_t;
 
void hton_LLCP_StatusMsg_t(LLCP_StatusMsg_t* msg);
 
void ntoh_LLCP_StatusMsg_t(LLCP_StatusMsg_t* msg);
 
void init_LLCP_StatusMsg_t(LLCP_StatusMsg_t* msg);
 
static_assert((sizeof(LLCP_StatusMsg_t) > 255) == 0, "LLCP_StatusMsg_t is too large");
 
/* char (*status_size_check)[sizeof( LLCP_StatusMsg_t )] = 1; */
 
//}
 
/* LLCP_GetStatusReqMsg_t //{ */
 
typedef struct __attribute__((packed))
{
  uint8_t message_id;
} LLCP_GetStatusReqMsg_t;
 
void hton_LLCP_GetStatusReqMsg_t(LLCP_GetStatusReqMsg_t* msg);
 
void ntoh_LLCP_GetStatusReqMsg_t(LLCP_GetStatusReqMsg_t* msg);
 
void init_LLCP_GetStatusReqMsg_t(LLCP_GetStatusReqMsg_t* msg);
 
static_assert((sizeof(LLCP_GetStatusReqMsg_t) > 255) == 0, "LLCP_GetStatusReqMsg_t is too large");
 
//}
 
/* LLCP_TemperatureMsg_t //{ */
 
/* LLCP_Temperature_t //{ */
 
typedef struct __attribute__((packed))
{
  int16_t temperature;
} LLCP_Temperature_t;
 
void hton_LLCP_Temperature_t(LLCP_Temperature_t* data);
 
void ntoh_LLCP_Temperature_t(LLCP_Temperature_t* data);
 
void init_LLCP_Temperature_t(LLCP_Temperature_t* data);
 
//}
 
typedef struct __attribute__((packed))
{
  uint8_t            message_id;
  LLCP_Temperature_t payload;
} LLCP_TemperatureMsg_t;
 
void hton_LLCP_TemperatureMsg_t(LLCP_TemperatureMsg_t* msg);
 
void ntoh_LLCP_TemperatureMsg_t(LLCP_TemperatureMsg_t* msg);
 
void init_LLCP_TemperatureMsg_t(LLCP_TemperatureMsg_t* msg);
 
static_assert((sizeof(LLCP_TemperatureMsg_t) > 255) == 0, "LLCP_TemperatureMsg_t is too large");
 
/* char (*temperature_size_check)[sizeof( LLCP_TemperatureMsg_t )] = 1; */
 
//}
 
/* LLCP_GetTemperatureReqMsg_t //{ */
 
typedef struct __attribute__((packed))
{
  uint8_t message_id;
} LLCP_GetTemperatureReqMsg_t;
 
void hton_LLCP_GetTemperatureReqMsg_t(LLCP_GetTemperatureReqMsg_t* msg);
 
void ntoh_LLCP_GetTemperatureReqMsg_t(LLCP_GetTemperatureReqMsg_t* msg);
 
void init_LLCP_GetTemperatureReqMsg_t(LLCP_GetTemperatureReqMsg_t* msg);
 
static_assert((sizeof(LLCP_GetTemperatureReqMsg_t) > 255) == 0, "LLCP_GetTemperatureReqMsg_t is too large");
 
//}
 
// | ------------------------- Errors ------------------------- |
 
/* LLCP_MinipixErrorMsg_t //{ */
 
/* LLCP_MinipixError_t //{ */
 
typedef struct __attribute__((packed))
{
  uint8_t error_id;
} LLCP_MinipixError_t;
 
void hton_LLCP_MinipixError_t(LLCP_MinipixError_t* data);
 
void ntoh_LLCP_MinipixError_t(LLCP_MinipixError_t* data);
 
void init_LLCP_MinipixError_t(LLCP_MinipixError_t* data);
 
//}
 
typedef struct __attribute__((packed))
{
  uint8_t             message_id;
  LLCP_MinipixError_t payload;
} LLCP_MinipixErrorMsg_t;
 
void hton_LLCP_MinipixErrorMsg_t(LLCP_MinipixErrorMsg_t* msg);
 
void ntoh_LLCP_MinipixErrorMsg_t(LLCP_MinipixErrorMsg_t* msg);
 
void init_LLCP_MinipixErrorMsg_t(LLCP_MinipixErrorMsg_t* msg);
 
static_assert((sizeof(LLCP_MinipixErrorMsg_t) > 255) == 0, "LLCP_MinipixErrorMsg_t is too large");
 
//}
 
#ifdef __cplusplus
}
#endif
 
#endif  // LLCP_MINIPIX_MESSAGES_H