Roy_01
700 lines
19 KiB
C
700 lines
19 KiB
C
#include "app_config.h"
|
|
#include "app_error.h"
|
|
|
|
#include "elite_board.h"
|
|
#include "pel.h"
|
|
|
|
#include "elite_def.h"
|
|
|
|
#include "nrf_delay.h"
|
|
#include "nrf_gpio.h"
|
|
#include "nrf_log.h"
|
|
|
|
#include "adc_drv.h"
|
|
|
|
#if (DEF_ELITE_MODEL == DEF_ELITE_PEL_V2_0)
|
|
|
|
typedef struct
|
|
{
|
|
float val;
|
|
uint32_t pin;
|
|
uint32_t mask;
|
|
} input_pin_t;
|
|
|
|
typedef struct
|
|
{
|
|
uint16_t pattern_id;
|
|
uint32_t pattern;
|
|
} resistor_combination_t;
|
|
|
|
typedef struct __PACKED
|
|
{
|
|
uint32_t notify_period;
|
|
uint32_t total_notify_count;
|
|
} characteristic_param_t;
|
|
|
|
static bool data_char_notify_running;
|
|
TaskHandle_t test_gpio_task_Handle = NULL;
|
|
static pel_output_t output_data = { 0 };
|
|
static resistor_combination_t global_resis = { 0 };
|
|
|
|
const input_pin_t input_pin_tab[] = {
|
|
{ 0.5, INPUT_1_PIN, PEL_0P5R_MASK},
|
|
{ 1.0, INPUT_2_PIN, PEL_1P0R_MASK},
|
|
{ 2.0, INPUT_3_PIN, PEL_2P0R_MASK},
|
|
{ 4.0, INPUT_4_PIN, PEL_4P0R_MASK},
|
|
{ 8.0, INPUT_5_PIN, PEL_8P0R_MASK},
|
|
{ 16.2, INPUT_6_PIN, PEL_16P2R_MASK},
|
|
{ 32.4, INPUT_7_PIN, PEL_32P4R_MASK},
|
|
{ 63.4, INPUT_8_PIN, PEL_63P4R_MASK},
|
|
{ 127.0, INPUT_9_PIN, PEL_127R_MASK},
|
|
{ 255.0, INPUT_10_PIN, PEL_255R_MASK},
|
|
{ 511.0, INPUT_11_PIN, PEL_511R_MASK},
|
|
{1000.0, INPUT_12_PIN, PEL_1000R_MASK},
|
|
};
|
|
|
|
static float _load_set(uint32_t mask)
|
|
{
|
|
float ohms = 0;
|
|
global_resis.pattern = mask;
|
|
|
|
for (int32_t i = COUNTOF(input_pin_tab) - 1; i >= 0; i--)
|
|
{
|
|
if (input_pin_tab[i].mask & mask)
|
|
{
|
|
nrf_gpio_pin_clear(input_pin_tab[i].pin);
|
|
ohms += input_pin_tab[i].val;
|
|
NRF_LOG_INFO("enable R%-2d(" NRF_LOG_FLOAT_MARKER "ohm)", i + 1, NRF_LOG_FLOAT(input_pin_tab[i].val));
|
|
}
|
|
else
|
|
{
|
|
nrf_gpio_pin_set(input_pin_tab[i].pin);
|
|
}
|
|
}
|
|
return ohms;
|
|
}
|
|
|
|
void set_high_z_state(void)
|
|
{
|
|
NRF_LOG_INFO("high_z_state");
|
|
_load_set(0);
|
|
}
|
|
|
|
void set_pattern_resistor(uint16_t pattern_id)
|
|
{
|
|
const resistor_combination_t pattern_tab[] = {
|
|
{ 1, 0b111},
|
|
{ 2, 0b011},
|
|
{ 3, 0b101},
|
|
{ 4, 0b001},
|
|
{ 5, 0b111 << 1},
|
|
{ 6, 0b011 << 1},
|
|
{ 7, 0b101 << 1},
|
|
{ 8, 0b001 << 1},
|
|
{ 9, 0b111 << 2},
|
|
{10, 0b011 << 2},
|
|
{11, 0b101 << 2},
|
|
{12, 0b001 << 2},
|
|
{13, 0b111 << 3},
|
|
{14, 0b011 << 3},
|
|
{15, 0b101 << 3},
|
|
{16, 0b001 << 3},
|
|
{17, 0b111 << 4},
|
|
{18, 0b011 << 4},
|
|
{19, 0b101 << 4},
|
|
{20, 0b001 << 4},
|
|
{21, 0b111 << 5},
|
|
{22, 0b011 << 5},
|
|
{23, 0b101 << 5},
|
|
{24, 0b001 << 5},
|
|
{25, 0b111 << 6},
|
|
{26, 0b011 << 6},
|
|
{27, 0b101 << 6},
|
|
{28, 0b001 << 6},
|
|
{29, 0b111 << 7},
|
|
{30, 0b011 << 7},
|
|
{31, 0b101 << 7},
|
|
{32, 0b001 << 7},
|
|
{33, 0b111 << 8},
|
|
{34, 0b011 << 8},
|
|
{35, 0b101 << 8},
|
|
{36, 0b001 << 8},
|
|
{37, 0b111 << 9},
|
|
{38, 0b011 << 9},
|
|
{39, 0b101 << 9},
|
|
{40, 0b001 << 9},
|
|
{41, 0b11 << 10},
|
|
{42, 0b01 << 10},
|
|
{43, 0b1 << 11},
|
|
};
|
|
|
|
global_resis.pattern_id = pattern_id;
|
|
|
|
for (int32_t i = 0; i < ARRAY_SIZE(pattern_tab); i++)
|
|
{
|
|
if (pattern_tab[i].pattern_id == pattern_id)
|
|
{
|
|
NRF_LOG_INFO("pattern_id[%d] = pattern:0x%08X", pattern_tab[i].pattern_id, pattern_tab[i].pattern);
|
|
_load_set(pattern_tab[i].pattern);
|
|
}
|
|
}
|
|
}
|
|
|
|
void set_manual_resistor(uint16_t manual_val)
|
|
{
|
|
typedef union
|
|
{
|
|
struct
|
|
{
|
|
uint32_t R1_en : 1;
|
|
uint32_t R2_en : 1;
|
|
uint32_t R3_en : 1;
|
|
uint32_t R4_en : 1;
|
|
uint32_t R5_en : 1;
|
|
uint32_t R6_en : 1;
|
|
uint32_t R7_en : 1;
|
|
uint32_t R8_en : 1;
|
|
uint32_t R9_en : 1;
|
|
uint32_t R10_en : 1;
|
|
uint32_t R11_en : 1;
|
|
uint32_t R12_en : 1;
|
|
};
|
|
uint32_t val;
|
|
} resis_t;
|
|
|
|
resis_t resis = { 0 };
|
|
|
|
resis.R1_en = (manual_val >> 11) & 1;
|
|
resis.R2_en = (manual_val >> 10) & 1;
|
|
resis.R3_en = (manual_val >> 9) & 1;
|
|
resis.R4_en = (manual_val >> 8) & 1;
|
|
resis.R5_en = (manual_val >> 7) & 1;
|
|
resis.R6_en = (manual_val >> 6) & 1;
|
|
resis.R7_en = (manual_val >> 5) & 1;
|
|
resis.R8_en = (manual_val >> 4) & 1;
|
|
resis.R9_en = (manual_val >> 3) & 1;
|
|
resis.R10_en = (manual_val >> 2) & 1;
|
|
resis.R11_en = (manual_val >> 1) & 1;
|
|
resis.R12_en = (manual_val >> 0) & 1;
|
|
|
|
_load_set(resis.val);
|
|
}
|
|
|
|
static void _sample_measure_out_is_low(void)
|
|
{
|
|
nrf_gpio_pin_set(ANODE_PIN);
|
|
nrf_gpio_pin_clear(CATHODE_PIN);
|
|
nrf_gpio_pin_clear(SAMPLE_R_PIN);
|
|
nrf_gpio_pin_clear(SAMPLE_V_PIN);
|
|
nrf_delay_us(10);
|
|
|
|
nrf_gpio_pin_toggle(ANODE_PIN);
|
|
nrf_gpio_pin_toggle(CATHODE_PIN);
|
|
nrf_delay_us(3);
|
|
|
|
nrf_gpio_pin_toggle(SAMPLE_R_PIN);
|
|
nrf_gpio_pin_toggle(SAMPLE_V_PIN);
|
|
nrf_delay_us(5);
|
|
|
|
nrf_gpio_pin_toggle(SAMPLE_R_PIN);
|
|
nrf_gpio_pin_toggle(SAMPLE_V_PIN);
|
|
nrf_gpio_pin_toggle(CATHODE_PIN);
|
|
nrf_gpio_pin_toggle(ANODE_PIN);
|
|
}
|
|
|
|
static void _sample_measure_out_is_high(void)
|
|
{
|
|
nrf_gpio_pin_clear(ANODE_PIN);
|
|
nrf_gpio_pin_set(CATHODE_PIN);
|
|
nrf_gpio_pin_clear(SAMPLE_R_PIN);
|
|
nrf_gpio_pin_clear(SAMPLE_V_PIN);
|
|
nrf_delay_us(10);
|
|
|
|
nrf_gpio_pin_toggle(ANODE_PIN);
|
|
nrf_gpio_pin_toggle(CATHODE_PIN);
|
|
nrf_delay_us(3);
|
|
|
|
nrf_gpio_pin_toggle(SAMPLE_R_PIN);
|
|
nrf_gpio_pin_toggle(SAMPLE_V_PIN);
|
|
nrf_delay_us(5);
|
|
|
|
nrf_gpio_pin_toggle(SAMPLE_R_PIN);
|
|
nrf_gpio_pin_toggle(SAMPLE_V_PIN);
|
|
nrf_gpio_pin_toggle(CATHODE_PIN);
|
|
nrf_gpio_pin_toggle(ANODE_PIN);
|
|
}
|
|
|
|
void pel_relays_set(uint32_t measure_out)
|
|
{
|
|
if (measure_out)
|
|
{
|
|
nrf_gpio_pin_set(RELAY1_PIN);
|
|
nrf_gpio_pin_clear(RELAY2_PIN);
|
|
}
|
|
else
|
|
{
|
|
nrf_gpio_pin_clear(RELAY1_PIN);
|
|
nrf_gpio_pin_set(RELAY2_PIN);
|
|
}
|
|
/* delay 30ms */
|
|
vTaskDelay(pdMS_TO_TICKS(30));
|
|
}
|
|
|
|
pel_output_t pel_smaple_and_convt_all(uint32_t measure_out, uint32_t load_mask)
|
|
{
|
|
uint32_t ch_list[] = {
|
|
[OUTPUT_R1_IDX] = OUTPUT_R1_CHANNEL,
|
|
[OUTPUT_R2_IDX] = OUTPUT_R2_CHANNEL,
|
|
[OUTPUT_VO_IDX] = OUTPUT_VO_CHANNEL,
|
|
[OUTPUT_VC_IDX] = OUTPUT_VC_CHANNEL,
|
|
[OUTPUT_VE_IDX] = OUTPUT_VE_CHANNEL
|
|
};
|
|
int32_t results[COUNTOF(ch_list)];
|
|
float f_results[COUNTOF(ch_list)];
|
|
/* config E-load */
|
|
_load_set(0);
|
|
_load_set(load_mask);
|
|
/* send a pulse to sample and then read ADC channels */
|
|
if (measure_out)
|
|
{
|
|
adc_read_mutiple_channels_ex(ch_list, results, COUNTOF(ch_list), _sample_measure_out_is_high);
|
|
adc_read_multiple_milivolt_ex(ch_list, f_results, COUNTOF(ch_list), _sample_measure_out_is_high);
|
|
}
|
|
else
|
|
{
|
|
adc_read_mutiple_channels_ex(ch_list, results, COUNTOF(ch_list), _sample_measure_out_is_low);
|
|
adc_read_multiple_milivolt_ex(ch_list, f_results, COUNTOF(ch_list), _sample_measure_out_is_low);
|
|
}
|
|
/* copy results */
|
|
output_data.output_r1 = results[OUTPUT_R1_IDX];
|
|
output_data.output_r2 = results[OUTPUT_R2_IDX];
|
|
output_data.output_vo = results[OUTPUT_VO_IDX];
|
|
output_data.output_vc = results[OUTPUT_VC_IDX];
|
|
output_data.output_ve = results[OUTPUT_VE_IDX];
|
|
{
|
|
char str[128];
|
|
snprintf(str, sizeof(str), "%s: 0x%04lX, %.3fmV", "output_r1", output_data.output_r1, f_results[OUTPUT_R1_IDX]);
|
|
NRF_LOG_INFO("%s", str);
|
|
snprintf(str, sizeof(str), "%s: 0x%04lX, %.3fmV", "output_r2", output_data.output_r2, f_results[OUTPUT_R2_IDX]);
|
|
NRF_LOG_INFO("%s", str);
|
|
snprintf(str, sizeof(str), "%s: 0x%04lX, %.3fmV", "output_vo", output_data.output_vo, f_results[OUTPUT_VO_IDX]);
|
|
NRF_LOG_INFO("%s", str);
|
|
snprintf(str, sizeof(str), "%s: 0x%04lX, %.3fmV", "output_vc", output_data.output_vc, f_results[OUTPUT_VC_IDX]);
|
|
NRF_LOG_INFO("%s", str);
|
|
snprintf(str, sizeof(str), "%s: 0x%04lX, %.3fmV", "output_ve", output_data.output_ve, f_results[OUTPUT_VE_IDX]);
|
|
NRF_LOG_INFO("%s", str);
|
|
}
|
|
return output_data;
|
|
}
|
|
|
|
#define VERSION_DATE_YEAR 24
|
|
#define VERSION_DATE_MONTH 12
|
|
#define VERSION_DATE_DAY 10
|
|
#define VERSION_DATE_HOUR 10
|
|
#define VERSION_DATE_MINUTE 8
|
|
static void cis_version(uint8_t *ins, uint16_t size)
|
|
{
|
|
NRF_LOG_INFO("%s", __FUNCTION__);
|
|
uint8_t cis_ver[] = {
|
|
CIS_VERSION,
|
|
VERSION_DATE_YEAR,
|
|
VERSION_DATE_MONTH,
|
|
VERSION_DATE_DAY,
|
|
VERSION_DATE_HOUR,
|
|
VERSION_DATE_MINUTE,
|
|
};
|
|
extern ret_code_t le_data_update(uint8_t * p_value, uint16_t len);
|
|
le_data_update((void *)cis_ver, sizeof(cis_ver));
|
|
}
|
|
|
|
static void vis_rst(uint8_t *ins, uint16_t size)
|
|
{
|
|
NRF_LOG_INFO("%s", __FUNCTION__);
|
|
}
|
|
|
|
void test_gpio_task(void *pArg)
|
|
{
|
|
const uint32_t pel_pins[] = {
|
|
INPUT_1_PIN,
|
|
INPUT_2_PIN,
|
|
INPUT_3_PIN,
|
|
INPUT_4_PIN,
|
|
INPUT_5_PIN,
|
|
INPUT_6_PIN,
|
|
INPUT_7_PIN,
|
|
INPUT_8_PIN,
|
|
INPUT_9_PIN,
|
|
INPUT_10_PIN,
|
|
INPUT_11_PIN,
|
|
INPUT_12_PIN,
|
|
ANODE_PIN,
|
|
CATHODE_PIN,
|
|
SAMPLE_R_PIN,
|
|
SAMPLE_V_PIN,
|
|
RELAY1_PIN,
|
|
RELAY2_PIN
|
|
};
|
|
|
|
for (;;)
|
|
{
|
|
|
|
NRF_LOG_INFO("[test] all output pin set low");
|
|
for (int i = 0; i < COUNTOF(pel_pins); i++)
|
|
{
|
|
nrf_gpio_pin_clear(pel_pins[i]);
|
|
}
|
|
vTaskDelay(1000);
|
|
|
|
NRF_LOG_INFO("[test] all output pin set high");
|
|
for (int i = 0; i < COUNTOF(pel_pins); i++)
|
|
{
|
|
nrf_gpio_pin_set(pel_pins[i]);
|
|
}
|
|
vTaskDelay(1000);
|
|
|
|
NRF_LOG_INFO("[test] alternating high and low signals on all output pins");
|
|
for (int i = 0; i < COUNTOF(pel_pins); i++)
|
|
{
|
|
nrf_gpio_pin_clear(pel_pins[i]);
|
|
}
|
|
vTaskDelay(1000);
|
|
for (int i = 0; i < COUNTOF(pel_pins); i++)
|
|
{
|
|
nrf_gpio_pin_set(pel_pins[i]);
|
|
vTaskDelay(100);
|
|
nrf_gpio_pin_clear(pel_pins[i]);
|
|
}
|
|
vTaskDelay(1000);
|
|
}
|
|
}
|
|
|
|
static void decode_and_set_resistor_pattern(uint8_t *param)
|
|
{
|
|
uint16_t pattern_id = u8_to_u16(param[0], param[1]);
|
|
|
|
set_pattern_resistor(pattern_id);
|
|
}
|
|
|
|
static void decode_and_set_manual_resistor(uint8_t *param)
|
|
{
|
|
uint16_t manual_val = u8_to_u16(param[0], param[1]);
|
|
|
|
set_manual_resistor(manual_val);
|
|
}
|
|
|
|
static void dev_mode_input_resistor(uint8_t *ins)
|
|
{
|
|
NRF_LOG_INFO("[DEV MODE] %s", __FUNCTION__);
|
|
|
|
struct __PACKED
|
|
{
|
|
uint8_t id : 4;
|
|
uint8_t ins_type : 4;
|
|
uint8_t pkg_size;
|
|
uint8_t mode;
|
|
uint8_t func_id;
|
|
uint8_t opcode;
|
|
uint8_t param[];
|
|
} *p_ins = (void *)ins;
|
|
|
|
switch (p_ins->opcode)
|
|
{
|
|
case 0x00:
|
|
set_high_z_state();
|
|
break;
|
|
|
|
case 0x01:
|
|
decode_and_set_resistor_pattern(p_ins->param);
|
|
break;
|
|
|
|
case 0x02:
|
|
decode_and_set_manual_resistor(p_ins->param);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void data_char_update_once(void)
|
|
{
|
|
ret_code_t le_data_update(uint8_t * p_value, uint16_t len);
|
|
|
|
typedef struct __PACKED
|
|
{
|
|
int32_t val_1;
|
|
int32_t val_2;
|
|
int32_t val_3;
|
|
int32_t val_4;
|
|
int32_t val_5;
|
|
float val_6_f;
|
|
float val_7_f;
|
|
float val_8_f;
|
|
float val_9_f;
|
|
float val_10_f;
|
|
} test_val_t;
|
|
|
|
static test_val_t data = {
|
|
.val_1 = 0,
|
|
.val_2 = 100,
|
|
.val_3 = 1000,
|
|
.val_4 = 10000,
|
|
.val_5 = 100000,
|
|
.val_6_f = 1.0,
|
|
.val_7_f = 5.0,
|
|
.val_8_f = 10.0,
|
|
.val_9_f = 15.0,
|
|
.val_10_f = 20.0,
|
|
};
|
|
|
|
{
|
|
char str[128];
|
|
snprintf(str, sizeof(str), "val_1: 0x%08X, %d", data.val_1, data.val_1);
|
|
NRF_LOG_INFO("%s", str);
|
|
snprintf(str, sizeof(str), "val_2: 0x%08X, %d", data.val_2, data.val_2);
|
|
NRF_LOG_INFO("%s", str);
|
|
snprintf(str, sizeof(str), "val_3: 0x%08X, %d", data.val_3, data.val_3);
|
|
NRF_LOG_INFO("%s", str);
|
|
snprintf(str, sizeof(str), "val_4: 0x%08X, %d", data.val_4, data.val_4);
|
|
NRF_LOG_INFO("%s", str);
|
|
snprintf(str, sizeof(str), "val_5: 0x%08X, %d", data.val_5, data.val_5);
|
|
NRF_LOG_INFO("%s", str);
|
|
|
|
snprintf(str, sizeof(str), "val_6_f: %.7f", data.val_6_f, data.val_6_f);
|
|
NRF_LOG_INFO("%s", str);
|
|
snprintf(str, sizeof(str), "val_7_f: %.7f", data.val_7_f, data.val_7_f);
|
|
NRF_LOG_INFO("%s", str);
|
|
snprintf(str, sizeof(str), "val_8_f: %.7f", data.val_8_f, data.val_8_f);
|
|
NRF_LOG_INFO("%s", str);
|
|
snprintf(str, sizeof(str), "val_9_f: %.7f", data.val_9_f, data.val_9_f);
|
|
NRF_LOG_INFO("%s", str);
|
|
snprintf(str, sizeof(str), "val_10_f: %.7f", data.val_10_f, data.val_10_f);
|
|
NRF_LOG_INFO("%s", str);
|
|
}
|
|
|
|
le_data_update((void *)&data, sizeof(data));
|
|
|
|
data.val_1++;
|
|
data.val_2++;
|
|
data.val_3++;
|
|
data.val_4++;
|
|
data.val_5++;
|
|
data.val_6_f += 0.01;
|
|
data.val_7_f += 0.01;
|
|
data.val_8_f += 0.01;
|
|
data.val_9_f += 0.01;
|
|
data.val_10_f += 0.01;
|
|
}
|
|
|
|
static ret_code_t _send_data_char_notify_start_packet(void *p_buf, uint16_t p_buf_size, uint32_t loops)
|
|
{
|
|
memset(p_buf, 0x00, sizeof(p_buf));
|
|
|
|
for (uint32_t i = 0; i < loops; i++)
|
|
{
|
|
ret_code_t le_data_notify(uint8_t * p_value, uint16_t len);
|
|
ret_code_t ret = le_data_notify((void *)p_buf, p_buf_size);
|
|
|
|
if (ret != NRF_SUCCESS)
|
|
{
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return NRF_SUCCESS;
|
|
}
|
|
|
|
static void start_data_char_notify_task(void *p_arg)
|
|
{
|
|
typedef struct __PACKED
|
|
{
|
|
uint8_t mem_board_id;
|
|
uint32_t notify_time;
|
|
uint8_t packet_seq;
|
|
int32_t val_1;
|
|
int32_t val_2;
|
|
int32_t val_3;
|
|
int32_t val_4;
|
|
int32_t val_5;
|
|
float val_6_f;
|
|
float val_7_f;
|
|
float val_8_f;
|
|
float val_9_f;
|
|
float val_10_f;
|
|
uint16_t pattern_id;
|
|
uint32_t pattern;
|
|
} data_char_packet_t;
|
|
|
|
bool first_data = true;
|
|
data_char_packet_t packet_buf;
|
|
characteristic_param_t *data_char_notify_param = (characteristic_param_t *)p_arg;
|
|
data_char_notify_running = true;
|
|
|
|
memset(&packet_buf, 0x00, sizeof(packet_buf));
|
|
_send_data_char_notify_start_packet(&packet_buf, sizeof(packet_buf), 4);
|
|
|
|
for (;;)
|
|
{
|
|
if (data_char_notify_running)
|
|
{
|
|
if (first_data)
|
|
{
|
|
packet_buf.mem_board_id = 5;
|
|
packet_buf.notify_time = xTaskGetTickCount();
|
|
packet_buf.packet_seq = 0;
|
|
packet_buf.val_1 = 0;
|
|
packet_buf.val_2 = 100;
|
|
packet_buf.val_3 = 1000;
|
|
packet_buf.val_4 = 10000;
|
|
packet_buf.val_5 = 100000;
|
|
packet_buf.val_6_f = 1.0;
|
|
packet_buf.val_7_f = 5.0;
|
|
packet_buf.val_8_f = 10.0;
|
|
packet_buf.val_9_f = 15.0;
|
|
packet_buf.val_10_f = 20.0;
|
|
packet_buf.pattern_id = global_resis.pattern_id;
|
|
packet_buf.pattern = global_resis.pattern;
|
|
first_data = false;
|
|
}
|
|
else
|
|
{
|
|
packet_buf.mem_board_id = 5;
|
|
packet_buf.notify_time = xTaskGetTickCount();
|
|
packet_buf.packet_seq += 1;
|
|
packet_buf.val_1 += 1;
|
|
packet_buf.val_2 += 1;
|
|
packet_buf.val_3 += 1;
|
|
packet_buf.val_4 += 1;
|
|
packet_buf.val_5 += 1;
|
|
packet_buf.val_6_f += 0.01;
|
|
packet_buf.val_7_f += 0.01;
|
|
packet_buf.val_8_f += 0.01;
|
|
packet_buf.val_9_f += 0.01;
|
|
packet_buf.val_10_f += 0.01;
|
|
packet_buf.pattern_id = global_resis.pattern_id;
|
|
packet_buf.pattern = global_resis.pattern;
|
|
}
|
|
|
|
ret_code_t le_data_notify(uint8_t * p_value, uint16_t len);
|
|
ret_code_t ret = le_data_notify((void *)&packet_buf, sizeof(packet_buf));
|
|
|
|
{
|
|
char str[128];
|
|
snprintf(str, sizeof(str), "{%d, %d, %d, %d, %d, %d, %d, %d, %.7f, %.7f, %.7f, %.7f, %.7f, %d, 0x%08X}", packet_buf.mem_board_id, packet_buf.notify_time, packet_buf.packet_seq, packet_buf.val_1, packet_buf.val_2, packet_buf.val_3, packet_buf.val_4, packet_buf.val_5, packet_buf.val_6_f, packet_buf.val_7_f, packet_buf.val_8_f, packet_buf.val_9_f, packet_buf.val_10_f, packet_buf.pattern_id, packet_buf.pattern);
|
|
NRF_LOG_INFO("%s", str);
|
|
}
|
|
|
|
vTaskDelay(pdMS_TO_TICKS(data_char_notify_param->notify_period));
|
|
}
|
|
else // stop data update process
|
|
{
|
|
free(data_char_notify_param);
|
|
vTaskDelete(NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void decode_start_data_char_notify(uint8_t *param)
|
|
{
|
|
characteristic_param_t *data_char_notify_param = malloc(sizeof(characteristic_param_t));
|
|
|
|
if (data_char_notify_param == NULL)
|
|
{
|
|
NRF_LOG_ERROR("Failed to allocate memory for data_char_notify_param");
|
|
return;
|
|
}
|
|
|
|
data_char_notify_param->notify_period = u8_to_u32(param[0], param[1], param[2], param[3]);
|
|
data_char_notify_param->total_notify_count = u8_to_u32(param[0], param[1], param[2], param[3]);
|
|
data_char_notify_param->notify_period = 100;
|
|
data_char_notify_param->total_notify_count = 5;
|
|
|
|
xTaskCreate(start_data_char_notify_task, "start_data_char_notify_task", 2048, (void *)data_char_notify_param, 3, NULL);
|
|
}
|
|
|
|
static void stop_data_char_notify(void)
|
|
{
|
|
data_char_notify_running = false;
|
|
}
|
|
|
|
static void dev_mode_characteristic(uint8_t *ins)
|
|
{
|
|
NRF_LOG_INFO("[DEV MODE] %s", __FUNCTION__);
|
|
|
|
struct __PACKED
|
|
{
|
|
uint8_t id : 4;
|
|
uint8_t ins_type : 4;
|
|
uint8_t pkg_size;
|
|
uint8_t mode;
|
|
uint8_t func_id;
|
|
uint8_t opcode;
|
|
uint8_t param[];
|
|
} *p_ins = (void *)ins;
|
|
|
|
switch (p_ins->opcode)
|
|
{
|
|
case 0x00:
|
|
data_char_update_once();
|
|
break;
|
|
|
|
case 0x01:
|
|
decode_start_data_char_notify(p_ins->param);
|
|
break;
|
|
|
|
case 0x02:
|
|
stop_data_char_notify();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void dev_mode(uint8_t *ins, uint16_t size)
|
|
{
|
|
struct __PACKED
|
|
{
|
|
uint8_t id : 4;
|
|
uint8_t ins_type : 4;
|
|
uint8_t pkg_size;
|
|
uint8_t mode;
|
|
uint8_t func_id;
|
|
uint8_t opcode;
|
|
uint8_t param[];
|
|
} *p_ins = (void *)ins;
|
|
|
|
switch (p_ins->func_id)
|
|
{
|
|
case 0x00:
|
|
dev_mode_input_resistor(ins);
|
|
break;
|
|
|
|
case 0xA3:
|
|
dev_mode_characteristic(ins);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
const elite_instance_t pel_elite_instance = {
|
|
.cis_func = {
|
|
[CIS_VERSION] = cis_version,
|
|
},
|
|
.vis_func = {
|
|
[VIS_RST] = vis_rst,
|
|
},
|
|
.ris_func = {
|
|
[DEV_MODE] = dev_mode,
|
|
}
|
|
};
|
|
|
|
const elite_instance_t *pel_init(void)
|
|
{
|
|
return &pel_elite_instance;
|
|
}
|
|
|
|
#endif
|