prod_line_tool_dll.h

Go to the documentation of this file.

 
#ifndef _PLTD_H_
#define _PLTD_H_
 
/*************************************************************************/
/* INCLUDE FILES                                                                        */
/*************************************************************************/
#include <stdint.h>
#include "p_dll.h"
#include "u_dll.h"
#include "dbg_dll.h"
 
#ifndef __bool_true_false_are_defined
    #define __bool_true_false_are_defined 1
    #ifndef __cplusplus /* In C++, 'bool', 'true' and 'false' and keywords */
        #define bool char
        #define true 1
        #define false 0
    #else
        #ifdef __GNUC__
            /* GNU C++ supports direct inclusion of stdbool.h to provide C99
                compatibility by defining _Bool */
            #define BOOL bool
        #endif
    #endif
#endif /* __bool_true_false_are_defined */
 
#define PLTD_EXPORTS
#ifdef PLTD_EXPORTS
    #define PLTD_API __declspec(dllexport)
#else
    #define PLTD_API __declspec(dllimport)
#endif
 
#define PLTD_MAX_DEVICES                16                                              
#define LOG_PARAM_STR_SIZE              32                                              
#define PLTD_CLBK_DATA_SIZE             UDLL_CLBK_DATA_SIZE                             
#define MAX_SUPPORTED_FLASH_ER_TESTS    10                                              
#define MAX_SUPPORTED_FLASH_WR_TESTS    10                                              
#define MAX_SUPPORTED_FLASH_CHK_TESTS   10                                              
#define MAX_SUPPORTED_MEM_RD_TESTS      10                                              
#define MAX_SUPPORTED_RF_TESTS          10                                              
#define MAX_SUPPORTED_PERIPH_TESTS      10                                              
#define MAX_SUPPORTED_GPIO_TESTS        10                                              
#define MAX_SUPPORTED_GPIO_CONN_TESTS   20                                              
#define MAX_SUPPORTED_BLE_TESTS         10                                              
#define MAX_SUPPORTED_CUR_TESTS         10                                              
#define MAX_SUPPORTED_SENS_TESTS        10                                              
#define MAX_SUPPORTED_CUSTOM_TESTS      10                                              
#define PLTD_INSTR_MAX_NAME_SIZE        256                                             
#define PLTD_INSTR_MAX_STR_SIZE         256                                             
#define PLTD_SUCCESS                    0                                                
#define PLTD_ERROR                      1                                                
#define PLTD_ALL_DUTS_FAILED            2                                                
#define PLTD_WRONG_DEV_PARAMS           3                                                
#define PLTD_WRONG_GEN_PARAMS           4                                                
#define PLTD_DBG_ERROR                  5                                                
#define PLTD_INSTR_ERROR                6                                                
typedef enum __DUT_RES
{
    DUT_NOT_ACTIVE                      = 0,
    DUT_INTERNAL_SYSTEM_ERROR,
    DUT_COM_PORT_IDENTIFY_STARTED,
    DUT_COM_PORT_IDENTIFY_OK,
    DUT_COM_PORT_IDENTIFY_FAILED,           /* Not an actual device error. This is a PC system error (Windows did not enumerated the USB COM ports) or a PLT HW error (no correct loopback). */
 
    // TEMPERATURE MEASURE START
    DUT_TEMPERATURE_MEASUREMENT_INIT,
    DUT_TEMPERATURE_MEASUREMENT_OK,
    DUT_TEMPERATURE_MEASUREMENT_ERROR,      /* Not an actual device error. External instrument error. */
    // TEMPERATURE MEASURE END
 
    // UDLL START
    DUT_UDLL_FW_DOWNLOAD_INIT,
    DUT_UDLL_FW_DOWNLOAD_STARTED,
    DUT_UDLL_FW_DOWNLOAD_RETRY,
    DUT_UDLL_FW_DOWNLOAD_OK,
    DUT_UDLL_FW_DOWNLOAD_FAILED,            /* Not an actual device error. To reach that point, device has already communicated with the PLT and PC. */
    // UDLL END
 
    DUT_UDLL_FW_VER_GET_INIT,
    DUT_UDLL_FW_VER_GET_STARTED,
    DUT_UDLL_FW_VER_GET_OK,
    DUT_UDLL_FW_VER_GET_FAILED,
 
    DUT_UDLL_GPIO_WD_INIT,
    DUT_UDLL_GPIO_WD_STARTED,
    DUT_UDLL_GPIO_WD_OK,
    DUT_UDLL_GPIO_WD_FAILED,
 
    DUT_UDLL_RAM_FW_DOWNLOAD_INIT,
    DUT_UDLL_RAM_FW_DOWNLOAD_STARTED,
    DUT_UDLL_RAM_FW_DOWNLOAD_OK,
    DUT_UDLL_RAM_FW_DOWNLOAD_FAILED,
 
    // PDLL START
    DUT_PDLL_NO_ERROR,
    DUT_PDLL_PARAMS_ERROR,
    DUT_PDLL_RX_TIMEOUT,
    DUT_PDLL_TX_TIMEOUT,
    DUT_PDLL_UNEXPECTED_EVENT,
    DUT_PDLL_CANNOT_ALLOCATE_MEMORY,
    DUT_PDLL_INTERNAL_ERROR,
    DUT_PDLL_THREAD_CREATION_ERROR,
    DUT_PDLL_INVALID_DBG_PARAMS,
    DUT_PDLL_DBG_DLL_ERROR,
 
    DUT_PDLL_COM_PORT_INIT,
    DUT_PDLL_COM_PORT_START,
    DUT_PDLL_COM_PORT_OK,
    DUT_PDLL_COM_PORT_FAILED,
 
    DUT_PDLL_FW_VERSION_GET_START,
    DUT_PDLL_FW_VERSION_GET_OK,
    DUT_PDLL_FW_VERSION_GET_FAILED,
 
    DUT_PDLL_GPIO_WD_INIT,
    DUT_PDLL_GPIO_WD_START,
    DUT_PDLL_GPIO_WD_OK,
    DUT_PDLL_GPIO_WD_FAILED,
 
    DUT_PDLL_TIMESTAMP_RD_INIT,
    DUT_PDLL_TIMESTAMP_RD_START,
    DUT_PDLL_TIMESTAMP_RD_OK,
    DUT_PDLL_TIMESTAMP_RD_FAILED,
 
    DUT_PDLL_ADC_VBAT_INIT,
    DUT_PDLL_ADC_VBAT_START,
    DUT_PDLL_ADC_VBAT_OK,
    DUT_PDLL_ADC_VBAT_FAILED,
 
    DUT_PDLL_SET_TX_PWR_INIT,
    DUT_PDLL_SET_TX_PWR_START,
    DUT_PDLL_SET_TX_PWR_OK,
    DUT_PDLL_SET_TX_PWR_FAILED,
 
    DUT_PDLL_XTAL_TRIM_INIT,
    DUT_PDLL_XTAL_TRIM_START,
    DUT_PDLL_XTAL_TRIM_OK,
    DUT_PDLL_XTAL_TRIM_OUT_OF_RANGE,
    DUT_PDLL_XTAL_TRIM_FREQ_CAL_NOT_CONNECTED,
    DUT_PDLL_XTAL_TRIM_WRITE_FAILED,
    DUT_PDLL_XTAL_TRIM_FAILED,
 
    DUT_PDLL_XTAL_TRIM_READ_INIT,
    DUT_PDLL_XTAL_TRIM_READ_START,
    DUT_PDLL_XTAL_TRIM_READ_OK,
    DUT_PDLL_XTAL_TRIM_READ_FAILED,
 
    DUT_PDLL_UART_RESYNC_INIT,
    DUT_PDLL_UART_RESYNC_START,
    DUT_PDLL_UART_RESYNC_OK,
    DUT_PDLL_UART_RESYNC_FAILED,
 
    // SCAN WITH HCI BLE ADVERTISMENTS START
    DUT_PDLL_BLE_HCI_ADV_START_INIT,
    DUT_PDLL_BLE_HCI_ADV_START,
    DUT_PDLL_BLE_HCI_ADV_START_OK,
    DUT_PDLL_BLE_HCI_ADV_START_FAILED,
 
    DUT_PDLL_BLE_HCI_ADV_STOP_INIT,
    DUT_PDLL_BLE_HCI_ADV_STOP_START,
    DUT_PDLL_BLE_HCI_ADV_STOPPED_OK,
    DUT_PDLL_BLE_HCI_ADV_STOP_FAILED,
 
    DUT_PDLL_BLE_HCI_ADV_SCAN_START,
    DUT_PDLL_BLE_HCI_ADV_NOT_YET_FOUND,
    DUT_PDLL_BLE_HCI_ADV_FOUND,
    DUT_PDLL_BLE_HCI_ADV_RSSI_FAILED,
    DUT_PDLL_BLE_HCI_ADV_FAILED,
    // SCAN WITH HCI BLE ADVERTISMENTS END
 
    DUT_PDLL_PKT_TX_START_INIT,
    DUT_PDLL_PKT_TX_START,
    DUT_PDLL_PKT_TX_STARTED_OK,
    DUT_PDLL_PKT_TX_STARTED_FAILED,
    DUT_PDLL_PKT_TX_ENDED_START,
    DUT_PDLL_PKT_TX_ENDED_OK,
    DUT_PDLL_PKT_TX_ENDED_FAILED,
 
    // BLE TESTER TX POWER MEASURE START
    DUT_BLE_TESTER_TX_PWR_PASSED,
    DUT_BLE_TESTER_TX_PWR_FAILED,
    // BLE TESTER TX POWER MEASURE END
 
    // BLE TESTER TX CARRIER OFFSET MEASURE START
    DUT_BLE_TESTER_TX_OFFS_PASSED,
    DUT_BLE_TESTER_TX_OFFS_FAILED,
    // BLE TESTER TX CARRIER OFFSET MEASURE END
 
    // BLE TESTER TX MODULATION INDEX MEASURE START
    DUT_BLE_TESTER_TX_MOD_IDX_PASSED,
    DUT_BLE_TESTER_TX_MOD_IDX_FAILED,
    // BLE TESTER TX MODULATION INDEX MEASURE END
 
    DUT_PDLL_PKT_RX_STATS_START_INIT,
    DUT_PDLL_PKT_RX_STATS_START,
    DUT_PDLL_PKT_RX_STATS_STARTED_OK,
    DUT_PDLL_PKT_RX_STATS_START_FAILED,
 
    DUT_PDLL_PKT_RX_STATS_STOP_INIT,
    DUT_PDLL_PKT_RX_STATS_STOP_START,
    DUT_PDLL_PKT_RX_STATS_STOPPED_OK,
    DUT_PDLL_PKT_RX_STATS_STOP_FAILED,
 
    // BLE TESTER RX TEST START
    DUT_BLE_TESTER_RX_TEST_PASSED,
    DUT_BLE_TESTER_RX_TEST_FAILED,
    // BLE TESTER RX TEST END
 
    DUT_PDLL_HCI_STANDARD_ERROR,
 
    DUT_PDLL_GU_RF_RX_TEST_PASSED,
    DUT_PDLL_GU_RF_RX_TEST_FAILED,
 
    DUT_PDLL_GPIO_TOGGLE_INIT,
    DUT_PDLL_GPIO_TOGGLE_START,
    DUT_PDLL_GPIO_TOGGLE_FINISHED_OK,
    DUT_PDLL_GPIO_TOGGLE_ERROR,
    DUT_PDLL_GPIO_TOGGLE_FAILED,
    DUT_PDLL_GPIO_TOGGLE_PASSED,
 
    DUT_PDLL_GPIO_CONNECTION_INIT,
    DUT_PDLL_GPIO_SET_START,
    DUT_PDLL_GPIO_SET_ERROR,
    DUT_PDLL_GPIO_SET_FINISHED_OK,
    DUT_PDLL_GPIO_GET_START,
    DUT_PDLL_GPIO_GET_ERROR,
    DUT_PDLL_GPIO_GET_FINISHED_OK,
    DUT_PDLL_GPIO_CONNECTION_ERROR,
    DUT_PDLL_GPIO_CONNECTION_FAILED,
    DUT_PDLL_GPIO_CONNECTION_PASSED,
 
    DUT_PDLL_SENSOR_TEST_INIT,
    DUT_PDLL_SENSOR_TEST_START,
    DUT_PDLL_SENSOR_TEST_OK,
    DUT_PDLL_SENSOR_TEST_FAILED,
    DUT_PDLL_SENSOR_TEST_DATA_MATCH_OK,
    DUT_PDLL_SENSOR_TEST_DATA_MATCH_FAILED,
 
    DUT_PDLL_CUSTOM_ACTION_INIT,
    DUT_PDLL_CUSTOM_ACTION_START,
    DUT_PDLL_CUSTOM_ACTION_OK,
    DUT_PDLL_CUSTOM_ACTION_FAILED,
    DUT_PDLL_CUSTOM_ACTION_DATA_MATCH_OK,
    DUT_PDLL_CUSTOM_ACTION_DATA_MATCH_FAILED,
 
    DUT_PDLL_UART_LOOP_INIT,
    DUT_PDLL_UART_LOOP_START,
    DUT_PDLL_UART_LOOP_OK,
    DUT_PDLL_UART_LOOP_FAILED,
 
    // SLEEP CURRENT MEASURE START
    DUT_SLEEP_CURRENT_MEASURE_INIT,
    DUT_SLEEP_CURRENT_MEASURE_START,
    DUT_SLEEP_DEVICE_SLEPT_OK,
    DUT_SLEEP_CURRENT_MEASURE_ERROR,
    DUT_SLEEP_CURRENT_MEASURE_PASSED,
    DUT_SLEEP_CURRENT_MEASURE_FAILED,
    // SLEEP CURRENT MEASURE END
 
    DUT_PDLL_EXT32KHz_TEST_INIT,
    DUT_PDLL_EXT32KHz_TEST_START,
    DUT_PDLL_EXT32KHz_TEST_OK,
    DUT_PDLL_EXT32KHz_TEST_FAILED,
 
    DUT_PDLL_PERIPH_AMMETER_TEST_INIT,
    DUT_PDLL_PERIPH_AMMETER_TEST_START,
    DUT_PDLL_PERIPH_AMMETER_TEST_ERROR,
    DUT_PDLL_PERIPH_AMMETER_TEST_PASSED,
    DUT_PDLL_PERIPH_AMMETER_TEST_FAILED,
    // PDLL END
 
    // UDLL START
    DUT_UDLL_SUCCESS,
    DUT_UDLL_ACTION_RESPONSE_ERROR,
    DUT_UDLL_UART_RX_TIMEOUT_ERROR,
    DUT_UDLL_NO_CRC_MATCH_ERROR,
 
    DUT_UDLL_PROG_PARAMS_ERROR,
    DUT_UDLL_DEVICE_PARAMS_ERROR,
    DUT_UDLL_UART_WRITE_ERROR,
    DUT_UDLL_UART_READ_ERROR,
    DUT_UDLL_INTERNAL_ERROR,
    DUT_UDLL_COM_PORT_INIT_ERROR,
    DUT_UDLL_COM_PORT_ERROR,
    DUT_UDLL_CANNOT_ALLOCATE_MEMORY,
    DUT_UDLL_READ_FILE_SIZE_ERROR,
    DUT_UDLL_CANNOT_OPEN_FW_FILE,
    DUT_UDLL_CANNOT_OPEN_IMAGE_FILE,
    DUT_UDLL_UART_PINS_PATCH_ERROR,
    DUT_UDLL_INVALID_DBG_PARAMS,
    DUT_UDLL_DBG_DLL_ERROR,
 
    DUT_UDLL_FLASH_INIT_INIT,
    DUT_UDLL_FLASH_INIT_STARTED,
    DUT_UDLL_FLASH_INIT_OK,
    DUT_UDLL_FLASH_INIT_FAILED,
 
    DUT_UDLL_FLASH_ERASE_INIT,
    DUT_UDLL_FLASH_ERASE_STARTED,
    DUT_UDLL_FLASH_ERASE_OK,
    DUT_UDLL_FLASH_ERASE_FAILED,
 
    DUT_UDLL_FLASH_IMG_WR_INIT,
    DUT_UDLL_FLASH_IMG_WR_STARTED,
    DUT_UDLL_FLASH_IMG_WR_OK,
    DUT_UDLL_FLASH_IMG_WR_FAILED,
 
    DUT_UDLL_OTP_CHECK_EMPTY_INIT,
    DUT_UDLL_OTP_CHECK_EMPTY_STARTED,
    DUT_UDLL_OTP_CHECK_EMPTY_STATUS,
    DUT_UDLL_OTP_CHECK_EMPTY_OK,
    DUT_UDLL_OTP_CHECK_INPUT_DATA_EMPTY_OK,
    DUT_UDLL_OTP_CHECK_SAME_DATA_OK,
    DUT_UDLL_OTP_CHECK_SKIP_IF_WRITTEN_OK,
    DUT_UDLL_OTP_CHECK_DIFFERENT_DATA_FAILED,
    DUT_UDLL_OTP_CHECK_EMPTY_FAILED,
 
    DUT_UDLL_OTP_BIN_WR_INIT,
    DUT_UDLL_OTP_BIN_WR_STARTED,
    DUT_UDLL_OTP_BIN_WR_OK,
    DUT_UDLL_OTP_BIN_WR_FAILED,
 
    DUT_UDLL_OTP_CS_WRITE_INIT,
    DUT_UDLL_OTP_CS_WRITE_STARTED,
    DUT_UDLL_OTP_CS_WRITE_NUM_OF_ENTRIES,
    DUT_UDLL_OTP_CS_WRITE_STATUS,
    DUT_UDLL_OTP_CS_WRITE_RDBK_STARTED,
    DUT_UDLL_OTP_CS_WRITE_RDBK_STATUS,
    DUT_UDLL_OTP_CS_WRITE_OK,
    DUT_UDLL_OTP_CS_WRITE_FAILED,
 
    DUT_UDLL_MEM_DATA_WR_INIT,
    DUT_UDLL_MEM_DATA_WR_STARTED,
    DUT_UDLL_MEM_DATA_WR_STATUS,
    DUT_UDLL_MEM_DATA_WR_OK,
    DUT_UDLL_MEM_DATA_WR_FAILED,
 
    DUT_UDLL_MEM_RD_INIT,
    DUT_UDLL_MEM_RD_STARTED,
    DUT_UDLL_MEM_RD_OK,
    DUT_UDLL_MEM_RD_FAILED,
    // UDLL END
 
    // SCAN START
    DUT_PDLL_BLE_SCAN_INIT,
    DUT_PDLL_BLE_SCAN_START,
    DUT_PDLL_BLE_SCAN_NOT_YET_FOUND,
    DUT_PDLL_BLE_SCAN_FOUND,
    DUT_PDLL_BLE_SCAN_RSSI_FAILED,
    DUT_PDLL_BLE_SCAN_FAILED,
    // SCAN END
 
    DUT_GU_ERROR,
    INVALID_DUT_RES
}_DUT_RES;
 
typedef enum __GU_RES
{
    GU_NOT_ACTIVE                       = 0,
    GU_INTERNAL_SYSTEM_ERROR,
 
    GU_COM_OPEN_OK,
    GU_COM_OPEN_FAILED,
 
    GU_RESET_START,
    GU_RESET_OK,
    GU_RESET_FAILED,
 
    GU_PDLL_NO_ERROR,
    GU_PDLL_PARAMS_ERROR,
    GU_PDLL_RX_TIMEOUT,
    GU_PDLL_TX_TIMEOUT,
    GU_PDLL_UNEXPECTED_EVENT,
    GU_PDLL_CANNOT_ALLOCATE_MEMORY,
    GU_PDLL_INTERNAL_ERROR,
    GU_PDLL_THREAD_CREATION_ERROR,
    GU_PDLL_DBG_DLL_ERROR,
    GU_PDLL_INVALID_DBG_PARAMS,
 
    GU_PDLL_COM_PORT_INIT,
    GU_PDLL_COM_PORT_START,
    GU_PDLL_COM_PORT_OK,
    GU_PDLL_COM_PORT_FAILED,
 
    GU_PDLL_FW_VERSION_GET_START,
    GU_PDLL_FW_VERSION_GET_OK,
    GU_PDLL_FW_VERSION_GET_FAILED,
    GU_PDLL_FW_VERSION_VALID,
    GU_PDLL_FW_VERSION_NOT_VALID,
 
    GU_PDLL_RDTESTER_INIT,
    GU_PDLL_RDTESTER_INIT_START,
    GU_PDLL_RDTESTER_INIT_OK,
    GU_PDLL_RDTESTER_INIT_FAILED,
 
    GU_PDLL_RDTESTER_UART_CONNECT_INIT,
    GU_PDLL_RDTESTER_UART_CONNECT_START,
    GU_PDLL_RDTESTER_UART_CONNECT_OK,
    GU_PDLL_RDTESTER_UART_CONNECT_FAILED,
 
    GU_PDLL_RDTESTER_UART_LOOPBACK_INIT,
    GU_PDLL_RDTESTER_UART_LOOPBACK_START,
    GU_PDLL_RDTESTER_UART_LOOPBACK_OK,
    GU_PDLL_RDTESTER_UART_LOOPBACK_FAILED,
 
    GU_PDLL_RDTESTER_VBAT_UART_CNTRL_INIT,
    GU_PDLL_RDTESTER_VBAT_UART_CNTRL_START,
    GU_PDLL_RDTESTER_VBAT_UART_CNTRL_OK,
    GU_PDLL_RDTESTER_VBAT_UART_CNTRL_FAILED,
 
    GU_PDLL_RDTESTER_VBAT_UART_RST_CNTRL_INIT,
    GU_PDLL_RDTESTER_VBAT_UART_RST_CNTRL_START,
    GU_PDLL_RDTESTER_VBAT_UART_RST_CNTRL_OK,
    GU_PDLL_RDTESTER_VBAT_UART_RST_CNTRL_FAILED,
 
    GU_PDLL_RDTESTER_VPP_CNTRL_INIT,
    GU_PDLL_RDTESTER_VPP_CNTRL_START,
    GU_PDLL_RDTESTER_VPP_CNTRL_OK,
    GU_PDLL_RDTESTER_VPP_CNTRL_FAILED,
 
    GU_PDLL_RDTESTER_RST_PULSE_INIT,
    GU_PDLL_RDTESTER_RST_PULSE_START,
    GU_PDLL_RDTESTER_RST_PULSE_OK,
    GU_PDLL_RDTESTER_RST_PULSE_FAILED,
 
    GU_PDLL_RDTESTER_UART_PULSE_INIT,
    GU_PDLL_RDTESTER_UART_PULSE_START,
    GU_PDLL_RDTESTER_UART_PULSE_OK,
    GU_PDLL_RDTESTER_UART_PULSE_FAILED,
 
    GU_PDLL_RDTESTER_XTAL_PULSE_INIT,
    GU_PDLL_RDTESTER_XTAL_PULSE_START,
    GU_PDLL_RDTESTER_XTAL_PULSE_OK,
    GU_PDLL_RDTESTER_XTAL_PULSE_FAILED,
 
    GU_PDLL_RDTESTER_PULSE_WIDTH_INIT,
    GU_PDLL_RDTESTER_PULSE_WIDTH_START,
    GU_PDLL_RDTESTER_PULSE_WIDTH_OK,
    GU_PDLL_RDTESTER_PULSE_WIDTH_FAILED,
 
    GU_PDLL_RDTESTER_VBAT_CNTRL_INIT,
    GU_PDLL_RDTESTER_VBAT_CNTRL_START,
    GU_PDLL_RDTESTER_VBAT_CNTRL_OK,
    GU_PDLL_RDTESTER_VBAT_CNTRL_FAILED,
 
    GU_PDLL_RDTESTER_INVALID_COMMAND,
 
    GU_PDLL_PKT_TX_START_INIT,
    GU_PDLL_PKT_TX_START,
    GU_PDLL_PKT_TX_STARTED_OK,
    GU_PDLL_PKT_TX_STARTED_FAILED,
 
    GU_PDLL_PKT_TX_ENDED_OK,
    GU_PDLL_PKT_TX_ENDED_FAILED,
 
    GU_PDLL_GPIO_TOGGLE_INIT,
    GU_PDLL_GPIO_TOGGLE_START,
    GU_PDLL_GPIO_TOGGLE_FINISHED_OK,
    GU_PDLL_GPIO_TOGGLE_FAILED,
 
    GU_PDLL_BLE_SCAN_INIT,
    GU_PDLL_BLE_SCAN_START,
    GU_PDLL_BLE_SCAN_RESET,
    GU_PDLL_BLE_SCAN_RETRY,
    GU_PDLL_BLE_SCAN_OK,
    GU_PDLL_BLE_SCAN_FAILED,
 
    GU_PDLL_HCI_STANDARD_ERROR,
 
    GU_ALL_DUT_FAILED,
    INVALID_GU_RES,
}_GU_RES;
 
typedef enum __INSTR_RES
{
    INSTR_NOT_USED                      = 0,
    INSTR_ONLINE,
    INSTR_ERROR,
    INSTR_INIT,
    INSTR_MEAS_START,
    INSTR_MEAS_PASSED,
    INSTR_MEAS_FAILED,
    INSTR_MEAS_END_OK,
    INVALID_INSTR_RES
}_INSTR_RES;
 
typedef enum __DUT_NUM
{
    DUT_1                       = 1,
    DUT_2                       = 2,
    DUT_3                       = 3,
    DUT_4                       = 4,
    DUT_5                       = 5,
    DUT_6                       = 6,
    DUT_7                       = 7,
    DUT_8                       = 8,
    DUT_9                       = 9,
    DUT_10                      = 10,
    DUT_11                      = 11,
    DUT_12                      = 12,
    DUT_13                      = 13,
    DUT_14                      = 14,
    DUT_15                      = 15,
    DUT_16                      = 16
}_DUT_NUM;
 
typedef enum __periph_test_type
{
    PERIPH_USE_GPIO = 0,
    PERIPH_USE_CUSTOM_TEST,
    INVALID_PERIPH_TEST
}_periph_test_type;
typedef struct __pltd_dbg_params
{
    _dbg_params                 dbg_params_pltd;                                        
    _dbg_params                 dbg_params_udll;                                        
    _dbg_params                 dbg_params_pdll;                                        
    _dbg_params                 dbg_params_cur;                                         
    _dbg_params                 dbg_params_temp;                                        
    _dbg_params                 dbg_params_ble;                                         
    _dbg_params                 dbg_params_volt;                                        
}_pltd_dbg_params;
 
typedef struct __pltd_dut_results
{
    _DUT_RES                    dut_res[PLTD_MAX_DEVICES];                              
    _GU_RES                     gu_res;
    _INSTR_RES                  ble_instr_res;                                          
    _INSTR_RES                  temp_instr_res;                                         
    _INSTR_RES                  ammeter_res;                                            
    uint8_t                     data[PLTD_MAX_DEVICES][PLTD_CLBK_DATA_SIZE];            
}_pltd_dut_results;
 
typedef struct __pltd_versions
{
    _udll_fw_versions           udll_fw_versions;                                       
    _pdll_fw_versions           pdll_fw_versions;                                       
    char                        pltd_ver[LOG_PARAM_STR_SIZE];                           
}_pltd_versions;
 
typedef struct __clbk_data_array
{
    uint8_t                     data[PLTD_MAX_DEVICES][PLTD_CLBK_DATA_SIZE];            
}_clbk_data_array;
 
typedef void (_stdcall *_user_callback_pltd) (_pltd_dut_results *pltd_dut_results_t);
 
typedef struct __pltd_dev_params
{
    _DUT_NUM                    dut_num;                                                
    bool                        is_active;                                              
    uint8_t                     bd_addr[BD_ADDR_SIZE];                                  
    char                        sn[LOG_PARAM_STR_SIZE];                                 
    float                       path_loss;                                              
    uint32_t                    com_port;                                               
    uint8_t                     mem_data[MAX_MEM_DATA_SIZE];                            
}_pltd_dev_params;
 
typedef struct __plt_log_info
{
    char                        station_num[LOG_PARAM_STR_SIZE];                        
    char                        caller_name[LOG_PARAM_STR_SIZE];                        
    char                        caller_ver[LOG_PARAM_STR_SIZE];                         
    char                        tester_id[LOG_PARAM_STR_SIZE];                          
}_plt_log_info;
 
typedef struct __pltd_ble_tester
{
    bool                        en;                                                     
    char                        instr_name[PLTD_INSTR_MAX_NAME_SIZE];                   
    char                        instr_iface[PLTD_INSTR_MAX_NAME_SIZE];                  
}_pltd_ble_tester;
 
typedef struct __pltd_ble_test_tx_pwr
{
    bool                        en;                                                     
    char                        name[TEST_NAME_STR_SIZE];                               
    uint32_t                    freq;                                                   
    uint8_t                     tx_pwr_range;                                           
    _pdll_tx_pwr_lvl            tx_pwr;                                                 
    float                       avg_high_limit;                                         
    float                       avg_low_limit;                                          
    float                       pk_avg_limit;                                           
}_pltd_ble_test_tx_pwr;
 
typedef struct __pltd_ble_test_freq_offs
{
    bool                        en;                                                     
    char                        name[TEST_NAME_STR_SIZE];                               
    uint32_t                    freq;                                                   
    uint8_t                     tx_pwr_range;                                           
    _pdll_tx_pwr_lvl            tx_pwr;                                                 
    uint32_t                    pos_freq_limit;                                         
    uint32_t                    neg_freq_limit;                                         
    uint32_t                    drift_pkt_limit;                                        
    uint32_t                    drift_rate_limit;                                       
}_pltd_ble_test_freq_offs;
 
typedef struct __pltd_ble_test_mod_idx
{
    bool                        en;                                                     
    char                        name[TEST_NAME_STR_SIZE];                               
    uint32_t                    freq;                                                   
    uint8_t                     tx_pwr_range;                                           
    _pdll_tx_pwr_lvl            tx_pwr;                                                 
    uint32_t                    f1_min_limit;                                           
    uint32_t                    f1_max_limit;                                           
    uint32_t                    f2_max_limit;                                           
    float                       f1f2_ratio_limit;                                       
}_pltd_ble_test_mod_idx;
 
typedef struct __pltd_ble_test_rx_sens
{
    bool                        en;                                                     
    char                        name[TEST_NAME_STR_SIZE];                               
    uint32_t                    freq;                                                   
    uint8_t                     pattern;                                                
    uint16_t                    spacing;                                                
    uint16_t                    num_of_pkts;                                            
    float                       tx_power;                                               
    bool                        dirty;                                                  
    bool                        crc_state;                                              
    float                       per_lim;                                                
    float                       rssi_lim;                                               
}_pltd_ble_test_rx_sens;
 
typedef struct __pltd_temp_meas
{
    bool                        en;                                                     
    char                        instr_name[PLTD_INSTR_MAX_NAME_SIZE];                   
    char                        instr_iface[PLTD_INSTR_MAX_NAME_SIZE];                  
}_pltd_temp_meas;
 
typedef struct __pltd_ammeter
{
    bool                        en;                                                     
    char                        instr_name[PLTD_INSTR_MAX_NAME_SIZE];                   
    char                        instr_iface[PLTD_INSTR_MAX_NAME_SIZE];                  
    bool                        single_fail_test;                                       
}_pltd_ammeter;
 
typedef struct __pltd_ammeter_params
{
    bool                        en;                                                     
    bool                        single_dut;                                             
    _sleep_modes                mode;                                                   
    uint32_t                    sleep_time;                                             
    uint32_t                    wait_time;                                              
    float                       shunt_res;                                              
    double                      range;                                                  
    double                      resolution;                                             
    uint32_t                    samples;                                                
    double                      upper_lim;                                              
    double                      low_lim;                                                
    char                        gen_cmd[PLTD_INSTR_MAX_STR_SIZE];                       
}_pltd_ammeter_params;
 
typedef struct __pltd_gpio_led_test
{
    bool                        en;                                                     
    char                        name[TEST_NAME_STR_SIZE];                               
    _ic_gpio                    gpio;                                                   
    uint16_t                    time_low;                                               
    uint16_t                    time_high;                                              
    uint16_t                    retries;                                                
    _gpio_pwr_lvl               pwr_lvl;                                                
}_pltd_gpio_led_test;
 
typedef struct __pltd_gpio_connection_test
{
    bool                        en;                                                     
    char                        name[TEST_NAME_STR_SIZE];                               
    bool                        set_pin_en;                                             
    _ic_gpio                    set_pin;                                                
    _gpio_pwr_lvl               set_pin_pwr_lvl;                                        
    uint16_t                    set_pin_retries;                                        
    bool                        set_pin_check_short;                                    
    _ic_gpio                    get_pin;                                                
    bool                        get_pin_lvl;                                            
}_pltd_gpio_connection_test;
 
typedef struct __pltd_gpio_watchdog
{
    bool                        en;                                                     
    char                        name[TEST_NAME_STR_SIZE];                               
    _ic_gpio                    wd_gpio;                                                
    _gpio_pwr_lvl               pin_pwr_lvl;                                            
}_pltd_gpio_watchdog;
 
typedef struct __pltd_custom_test
{
    bool                        en;                                                     
    char                        name[TEST_NAME_STR_SIZE];                               
    uint8_t                     data;                                                   
}_pltd_custom_test;
 
typedef struct __pltd_adc_vbat_test
{
    bool                        en;                                                     
    char                        name[TEST_NAME_STR_SIZE];                               
}_pltd_adc_vbat_test;
 
typedef struct __pltd_timestamp_rd
{
    bool                        en;                                                     
    char                        name[TEST_NAME_STR_SIZE];                               
}_pltd_timestamp_rd;
 
typedef struct __pltd_periph_test
{
    bool                        en;                                                     
    char                        name[TEST_NAME_STR_SIZE];                               
    _pltd_ammeter_params        ammeter;                                                
    _periph_test_type           test_type;                                              
    uint8_t                     custom_data_start;                                      
    uint8_t                     custom_data_stop;                                       
    _ic_gpio                    gpio;                                                   
    uint8_t                     pwm;                                                    
    uint8_t                     pwm_duty;                                               
    _gpio_pwr_lvl               pwr_lvl;                                                
    _gpio_state                 gpio_state;                                             
}_pltd_periph_test;
 
typedef struct __pltd_ext32Khz_test
{
    bool                        en;                                                     
}_pltd_ext32Khz_test;
 
typedef struct __pltd_xtal_trim
{
    bool                        en;                                                     
    _ic_gpio                    gpio;                                                   
}_pltd_xtal_trim;
 
typedef struct __pltd_ble_scan
{
    bool                        en;                                                     
    bool                        fw_load_enable;                                         
    char                        fw_path[FILE_PATH_SIZE];                                
    uint8_t                     retries;                                                
    uint8_t                     dut_reboot;                                             
    uint8_t                     reboot_diff;                                            
    uint8_t                     reboot_time;                                            
}_pltd_ble_scan;
 
typedef struct __pltd_ble_hci_scan
{
    bool                        en;                                                     
    uint8_t                     retries;                                                
    _adv_channel                adv_channel;                                            
    _pdll_tx_pwr_lvl            tx_pwr;                                                 
    float                       rssi_lim;                                               
}_pltd_ble_hci_scan;
 
typedef struct __pltd_rssi_test
{
    bool                        en;                                                     
    char                        name[TEST_NAME_STR_SIZE];                               
    uint32_t                    freq;                                                   
    float                       per_lim;                                                
    float                       rssi_lim;                                               
}_pltd_rssi_test;
 
typedef struct __pltd_uart_test
{
    bool                        en;                                                     
    _baud_rate                  baud_rate;                                              
    uint32_t                    times;                                                  
}_pltd_uart_test;
 
typedef struct __pltd_test_params
{
    _pltd_adc_vbat_test         adc_vbat_test;                                          
    _pltd_timestamp_rd          timestamp_rd;                                           
    _pltd_gpio_watchdog         gpio_wd;                                                
    _pltd_xtal_trim             xtal_trim;                                              
    _pltd_ble_hci_scan          ble_scan_hci;                                           
    _pltd_rssi_test             rssi_test[MAX_SUPPORTED_RF_TESTS];                      
    _pltd_ble_tester            ble_tester;                                             
    _pltd_ble_test_tx_pwr       ble_test_tx_pwr[MAX_SUPPORTED_BLE_TESTS];               
    _pltd_ble_test_freq_offs    ble_test_freq_offs[MAX_SUPPORTED_BLE_TESTS];            
    _pltd_ble_test_mod_idx      ble_test_mod_idx[MAX_SUPPORTED_BLE_TESTS];              
    _pltd_ble_test_rx_sens      ble_test_rx_sens[MAX_SUPPORTED_BLE_TESTS];              
    _pltd_gpio_led_test         gpio_led_test[MAX_SUPPORTED_GPIO_TESTS];                
    _pltd_gpio_connection_test  gpio_conn_test[MAX_SUPPORTED_GPIO_CONN_TESTS];          
    _pdll_sensor_test           sensor[MAX_SUPPORTED_SENS_TESTS];                       
    _pltd_custom_test           custom_test[MAX_SUPPORTED_CUSTOM_TESTS];                
    _pltd_ext32Khz_test         ext32Khz_test;                                          
    _pltd_ammeter               ammeter;                                                
    _pltd_ammeter_params        ammeter_sleep;                                          
    _pltd_periph_test           periph_test[MAX_SUPPORTED_PERIPH_TESTS];                
    _pltd_temp_meas             temp_meas;                                              
    _pltd_ble_scan              ble_scan;                                               
}_pltd_test_params;
 
typedef struct __pltd_mem_params
{
    _udll_fw_load               fw_load;                                                
    _udll_gpio_watchdog         gpio_wd;                                                
    _udll_flash_init            flash_init;                                             
    _udll_flash_er              flash_er[MAX_SUPPORTED_FLASH_ER_TESTS];                 
    _udll_flash_wr              flash_wr[MAX_SUPPORTED_FLASH_WR_TESTS];                 
    _udll_mem_wr                mem_wr;                                                 
    _udll_mem_rd                mem_rd[MAX_SUPPORTED_MEM_RD_TESTS];                     
    _udll_otp_wr                otp_wr;                                                 
    _udll_otp_cs_wr             otp_cs_wr;                                               
}_pltd_mem_params;
 
typedef struct __pltd_ic_params
{
    _dut_ic                     dut_ic;                                                 
    uint32_t                    baud_rate;                                              
    bool                        rst_polarity;                                           
    _pltd_test_params           tests;                                                  
    _pltd_mem_params            mem;                                                    
}_pltd_ic_params;
 
 
typedef union __pltd_params
{
    _dut_ic                     dut_ic;                                                 
    _pltd_ic_params             ic;                                                     
}_pltd_params;
 
typedef struct __pltd_general_params
{
    _plt_log_info               log_info;                                               
    _user_callback_pltd         user_callback_pltd;                                     
    uint32_t                    gu_com_port;                                            
    bool                        mem_wr_en;                                              
    bool                        tests_en;                                               
    bool                        vbat_uart_en;                                           
    bool                        vbat_uart_rst;                                          
    _vbat_rst_mode              vbat_rst_mode;                                          
    uint16_t                    vbat_low_time;                                          
    uint16_t                    reset_time;                                             
    uint8_t                     fw_load_retries;                                        
    char                        flash_prog_fw_dir[FILE_PATH_SIZE];                      
    char                        prod_test_fw_dir[FILE_PATH_SIZE];                       
    char                        gu_fw_version[LOG_PARAM_STR_SIZE];                      
    bool                        gu_fw_version_check;                                    
    bool                        use_programmer;                                         
    _pltd_params                params;                                                 
}_pltd_general_params;
 
#ifdef __cplusplus                                                                      // If used by C++ code,
extern "C" {                                                                            // we need to export the C interface
#endif
 
 
 
PLTD_API int pltd_init(void);
 
PLTD_API void pltd_close(void);
 
PLTD_API int pltd_set_device_params(const _pltd_dev_params *params);
 
PLTD_API int pltd_set_general_params(
    const _pltd_general_params *pltd_general_params_t);
 
PLTD_API int pltd_start(void);
 
PLTD_API int pltd_com_port_enum(uint32_t *com_port_dut);
 
PLTD_API int pltd_gu_com_find(int *gu_com_port);
 
PLTD_API int pltd_gu_check_led(void);
 
PLTD_API int pltd_dbg_init(const _pltd_dbg_params *pltd_dbg_params_t);
 
PLTD_API char *pltd_get_ble_tester_instr_names(const char *prev_name);
 
PLTD_API char *pltd_get_ammeter_instr_names(const char *prev_name);
 
PLTD_API char *pltd_get_temp_meas_instr_names(const char *prev_name);
 
PLTD_API int pltd_vbat_uart_set(bool start, uint16_t duts);
 
PLTD_API int pltd_uart_coms_test(const _pltd_uart_test *uart_test);
 
PLTD_API _pltd_versions *pltd_get_versions(void);
#ifdef __cplusplus
}
#endif
 // @defgroup pltd_api
 
#endif /* _PLTD_H_ */