jh.chun/firmware-test
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a8ba31871e0244f52ded39415f7d836d82be7dc9
firmware-test/project/ble_peripheral/ble_app_bladder_patch/cmd_parse.c
Charles Kwon a8ba31871e Initial commit: MT firmware project 
- BLE peripheral applications
- dr_piezo and bladder_patch projects

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-25 17:26:39 +09:00

2207 lines
56 KiB
C
Raw Blame History

/***********************************************
EEPROM ADDRESS
HW_NO[12]
SERIAL_NO[12]
v1.17 p1,p2 parssurer
***********************************************/
#include <cmd_parse.h>
#include "debug_print.h"
#define DEVICE_VERSION "FW25LIT2B102"
#define DEVICE_NAME "MEDIDEV_2004"
#define err_code1 65535 //length
#define err_code2 65534 //activate
#define err_code3 65533 //param
#define err_code4 65532 //? missing
#define err_code5 65531 //CMD wrong
#define err_code6 65530 //CRC wrong
#define SERIAL_NO_LENGTH 12
#define LED_NUM 24 //25/10/28 cj chun ==<old value is 48
#include "i2c_manager.h"
#include "app_timer.h"
#include "parser.h"
// 0x0060 bonding address.....
extern uint8_t m_reset_status;
char SERIAL_NO[12]; //for eeprom r/write 30
bool bond_data_delete; //for eeprom r/write 50
char m_static_passkey[6] = "123456";//uint8_t static_passkey[6]; eeprom r/write 20
uint8_t m_pd_adc_cnt; //for eeprom r/write 70
uint16_t m_pd_delay_us; //for eeprom r/write 80
uint32_t m_life_cycle; //for eeprom r/write 90
uint8_t resetCount = 0; //cj add
char HW_NO[12]; //for eeprom r/write 10
bool info4;
extern uint8_t ADC_PD_MODE;
extern bool motion_raw_data_enabled;
extern char ble_tx_buffer[BLE_NUS_MAX_DATA_LEN];
extern bool device_status; /* true : Device has been activated, false : Device entered sleep mode */
extern bool device_reset;
//static uint32_t processing_start_time=0;
static uint32_t processing_start_tick = 0;
//ble_status_t ble_connection_st = BLE_DISCONNECTED_ST;
extern volatile bool ble_connection_st;
extern volatile bool data_tx_in_progress;
extern uint16_t led_pd_dac_v[LED_NUM];
extern uint8_t pd_adc_count;
extern uint16_t sel_led_index0;
extern uint16_t sel_led_index1;
extern uint16_t sel_led_index2;
extern uint16_t sel_led_index3;
extern uint16_t b_t_cnt; //buffer mode
extern uint16_t bsel_led_index0;
extern uint16_t bsel_led_index1;
extern uint16_t bsel_led_index2;
extern uint16_t bsel_led_index3;
extern bool lock_check;
extern int8_t pd_adc_counts[4] = {8, 16, 24, 32};
extern int8_t c_max;
extern uint8_t simple_samples_in_buffer;
extern uint8_t half_samples_in_buffer;
extern uint8_t full_samples_in_buffer;
extern uint8_t custom_samples_in_buffer;
extern uint8_t m48_samples_in_buffer;
extern bool con_single;
//extern bool pd_adc_half_a_start;
//extern bool pd_adc_full_a_start;
extern bool pd_adc_custom_a_start;
extern bool pd_adc_custom_start;
extern bool pd_adc_imm_start;
extern bool pd_adc_buff_start;
extern bool pd_adc_buff_running;
extern bool full_agc_a_start;
uint8_t ble_bin_buffer[BLE_NUS_MAX_DATA_LEN] = {0};
extern bool go_device_power_off;
extern bool go_sleep_mode_enter;
extern bool go_NVIC_SystemReset;
extern bool go_temp;
extern bool go_batt;
extern bool ble_got_new_data;
extern bool motion_data_once;
extern bool adc_enabled;
extern bool pd_adc_m48_start;
extern bool go_pdread;
extern uint16_t led_off_dac_v; // use FAST mode at 99 state
extern uint8_t led_off_pd;
extern dr_platform_if_t g_plat;
extern bool g_log_enable;
extern int dr_cmd_parser(const uint8_t *buf, uint8_t len);
//extern uint8_t m48_samples_in_buffer;
//extern bool prestatus;
uint16_t imsi_value;
//uint16_t cnt_s;
uint8_t led_sc_index=99;
ParsedCmd scmd;
/**@brief Function for handling app_uart events.
*
* @details This function will receive a single character from the app_uart module and append it to
* a string. The string will be be sent over BLE when the last character received was a
* 'new line' '\n' (hex 0x0A) or if the string has reached the maximum data length.
*/
/**@snippet [Handling the data received over UART & BLE] */
bool is_valid_serial_no(const char *serial)
{
// Check for all same characters (e.g., all 'F' or all '0')
bool all_same = true;
for (int i = 1; i < SERIAL_NO_LENGTH; i++) {
if (serial[i] != serial[0]) {
all_same = false;
break;
}
}
if (all_same) {
return false; // reject "FFFFFFFF..." or "00000000..."
}
// Check all characters are alphanumeric
for (int i = 0; i < SERIAL_NO_LENGTH; i++) {
char c = serial[i];
if (c == '\0' || c == (char)0xFF || !isalnum((unsigned char)c)) {
return false;
}
}
return true;
}
bool is_valid_passkey(const char *passkey)
{
for(uint8_t i = 0 ; i<6 ;i++)
{
DBG_PRINTF("check passkey :%2X \r\n",passkey[i]);
}
// Check for NULL pointer
if (passkey == NULL) {
return false;
}
// Check that the length is exactly 6 and all characters are digits
for (int i = 0; i < 6; i++) {
if (passkey[i] == '\0' || !isdigit((unsigned char)passkey[i])) {
return false;
}
}
// Ensure the 7th character is null terminator
// if (passkey[6] != '\0') {
// return false;
// }
return true;
}
bool crc16_check(uint8_t const * p_data, uint32_t data_len, uint16_t expected_crc)
{
uint16_t computed_crc = crc16_compute(p_data, data_len, NULL);
return (computed_crc == expected_crc);
}
bool crc16_check_packet(uint8_t const * packet, uint32_t packet_len)
{
if (packet_len < 2) return false;
uint32_t data_len = packet_len - 2;
uint16_t expected_crc = (packet[packet_len - 1] << 8) | packet[packet_len - 2]; // Big endian
//DBG_PRINTF("\r\n expecterrrd_data_delete :%02X \n", expected_crc);
return crc16_check(packet, data_len, expected_crc);
}
bool parse_cmd(const uint8_t *buffer, ParsedCmd *cmd_out, uint8_t length) {
// Extract 4-character command
for (int i = 0; i < 4; i++) {
cmd_out->tag[i] = (char)buffer[i];
}
cmd_out->tag[4] = '\0'; // Null-terminate
// Extract 16-bit value (little-endian)
cmd_out->value0 = (uint16_t)buffer[5] | ((uint16_t)buffer[4] << 8);
cmd_out->value1 = (uint16_t)buffer[7] | ((uint16_t)buffer[6] << 8);
cmd_out->value2 = (uint16_t)buffer[9] | ((uint16_t)buffer[8] << 8);
cmd_out->value3 = (uint16_t)buffer[11] | ((uint16_t)buffer[10] << 8);
cmd_out->value4 = (uint16_t)buffer[13] | ((uint16_t)buffer[12] << 8);
for (int i = 0; i < length; i++) {
cmd_out->values[i] = buffer[i];
}
for (int i = 0; i < 12; i++) {
cmd_out->value_ascii[i] = (char)buffer[i+4];
}
cmd_out->value_ascii[12]= '\0'; // Null-terminate
return true; // You could return false on validation failure
}
bool length_error(const char *cmd , uint8_t target_length, uint8_t length)
{
if (target_length == length)
{
return true;
}
else
{
char resp_error[4];
resp_error[0] = 'r';
resp_error[1] = cmd[1]; // 2nd letter (index 1)
resp_error[2] = cmd[2]; // 3rd letter (index 2)
resp_error[3] = '!';
single_format_data(ble_bin_buffer, resp_error, err_code1);
binary_tx_handler(ble_bin_buffer,3);
return false;
}
}
bool activate_error(const char *cmd , bool device_status)
{
if (device_status == true)
{
return true;
}
else
{
char resp_error[4];
resp_error[0] = 'r';
resp_error[1] = cmd[1]; // 2nd letter (index 1)
resp_error[2] = cmd[2]; // 3rd letter (index 2)
resp_error[3] = '!';
single_format_data(ble_bin_buffer, resp_error, err_code2);
binary_tx_handler(ble_bin_buffer,3);
return false;
}
}
void param_error(const char *cmd )
{
char resp_error[4];
resp_error[0] = 'r';
resp_error[1] = cmd[1]; // 2nd letter (index 1)
resp_error[2] = cmd[2]; // 3rd letter (index 2)
resp_error[3] = '!';
single_format_data(ble_bin_buffer, resp_error, err_code3);
binary_tx_handler(ble_bin_buffer,3);
}
void quest_error(const char *cmd )
{
char resp_error[4];
const char pass_init[6] = "123456";
if( (cmd[0] == '*') && (cmd[1] == '*') && (cmd[2] == '*') && (cmd[3] == '*')){
if(eeprom_write_encrypted(0x0020, (uint8_t *)pass_init, 6)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_passkey 6\r\n\r\n");;
}
resp_error[0] = '*';
resp_error[1] = cmd[1]; // 2nd letter (index 1)
resp_error[2] = cmd[2]; // 3rd letter (index 2)
resp_error[3] = '*';
single_format_data(ble_bin_buffer, resp_error, err_code4);
binary_tx_handler(ble_bin_buffer,3);
}
else{
resp_error[0] = 'r';
resp_error[1] = cmd[1]; // 2nd letter (index 1)
resp_error[2] = cmd[2]; // 3rd letter (index 2)
resp_error[3] = '!';
single_format_data(ble_bin_buffer, resp_error, err_code4);
binary_tx_handler(ble_bin_buffer,3);
}
}
//uint32_t serial_to_passkey_hash(const char *input)
//{
// uint32_t hash = 1026;
// while (*input)
// {
// hash = ((hash << 5) + hash) + (uint8_t)(*input++); // hash * 33 + c
// }
// return hash % 1000000; // 6-digit range
//}
//void test_eeprom_page_rw(void)
//{
// uint8_t tx_data[EEPROM_PAGE_SIZE];
// uint8_t rx_data[EEPROM_PAGE_SIZE];
// // Fill tx_data with example values
// for (int i = 0; i < EEPROM_PAGE_SIZE; i++) {
// tx_data[i] = i*10;
// }
// uint16_t test_address = 0x0000;
// if (eeprom_write_page(test_address, tx_data) == NRF_SUCCESS) {
// DBG_PRINTF("Write OK\r\n");
// }
// if (eeprom_read_page(test_address, rx_data) == NRF_SUCCESS) {
// DBG_PRINTF("Read OK\n");
// }
// // Verify
// for (int i = 0; i < EEPROM_PAGE_SIZE; i++) {
// if (rx_data[i] != tx_data[i]) {
// DBG_PRINTF("Mismatch at %d: wrote %02X, read %02X\n", i, tx_data[i], rx_data[i]);
// }
// }
//}
ret_code_t eeprom_read_bool(uint16_t mem_address, bool *value_out)
{
uint8_t raw;
ret_code_t ret = eeprom_read_byte(mem_address, &raw);
if (ret != NRF_SUCCESS) {
return ret;
}
*value_out = (raw != 0);
return NRF_SUCCESS;
}
ret_code_t eeprom_init_values_read(void)
{
ret_code_t err_code;
//uint8_t *data_bond;
// Read 11 bytes from EEPROM
err_code = eeprom_read_decrypted(0x0030, (uint8_t *)SERIAL_NO, 12);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
else
{
DBG_PRINTF("\r\n SN:%s \r\n", SERIAL_NO);
}
err_code = eeprom_read_decrypted(0x0020, (uint8_t *)m_static_passkey, 6);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
else
{
DBG_PRINTF("\r\n passkey-0 :%s \n", m_static_passkey);
}
eeprom_read_uint16_array(0x0480, led_pd_dac_v, 48); //AGC_Gain int16(48ea)
// DBG_PRINTF("Firth Tagc,");
// for(uint16_t j = 0; j < LED_NUM; j++){
// DBG_PRINTF("%d, ", led_pd_dac_v[j]);
// }
if (err_code != NRF_SUCCESS)
{
DBG_PRINTF("AGC Gain Read data fail! \r\n");
return err_code;
}
//DBG_PRINTF("AGC_Gain Read data \r\n");
//SERIAL_NO[12] = '\0'; // Ensure null-terminated if using as string
//err_code = eeprom_read_bytes(0x0060, data_bond,16);
err_code = eeprom_read_bool(0x0060, &bond_data_delete);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
else
{
// bond_data_delete = data_bond[0];
DBG_PRINTF("\r\n bond_data_delete :%d \n", bond_data_delete);
}
err_code = eeprom_read_byte(0x0065, &m_reset_status);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
else
{
if(m_reset_status){
//DBG_PRINTF("\r\n status :%d \n", m_reset_status);
}
}
err_code = eeprom_read_byte(0x0070, &m_pd_adc_cnt);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
else
{
if(m_pd_adc_cnt){
if(m_pd_adc_cnt>=255)
{
m_pd_adc_cnt=8;
}
}
}
err_code = eeprom_read_word(0x0080, &m_pd_delay_us);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
else
{
if(m_pd_delay_us<5000){
m_pd_delay_us=8000;
DBG_PRINTF("\r\n m_pd_delay :%d \n", m_pd_delay_us);
}
}
DBG_PRINTF("m_life_cycle eprom read\n"); //ad cj
err_code = eeprom_read_uint32(0x0090, &m_life_cycle);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
else
{
if(m_life_cycle){
DBG_PRINTF("\r\n m_life_cycle :%1u,m_pd_delay_us :%1u,m_pd_adc_cnt :%1u \r\n", m_life_cycle,m_pd_delay_us,m_pd_adc_cnt);
}
}
return NRF_SUCCESS;
}
static void log_printf(const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
}
void received_command_process (uint8_t const *data_array, which_cmd_t cmd_t, uint8_t length )
{
uint8_t r_data[BLE_NUS_MAX_DATA_LEN]={0,};
uint8_t led_index = 0, pd_index = 0;
uint16_t result = 0;
uint16_t result_data[BLE_NUS_MAX_DATA_LEN];
uint16_t led_power = 0, dac_value = 0;
int parser_result; // ? ??
ble_got_new_data = true;
memset( ble_tx_buffer, 0, BLE_NUS_MAX_DATA_LEN);
for( uint16_t i = 0; i < length ; i++ ) {
r_data[i] = data_array[i];
}
DBG_PRINTF("data : %s\r\n",r_data);
DBG_PRINTF("Length : %d\r\n",length);
// ========================================
// Initialize parser (once)
// ========================================
static bool parser_initialized = false;
if (!parser_initialized) {
// Setup platform interface
g_plat.log = log_printf; // printf
g_plat.tx_bin = binary_tx_handler;
g_plat.crc_check = true; // CRC
g_log_enable = true;
parser_initialized = true;
DBG_PRINTF(">>> NEW parser initialized\r\n");
}
// ========================================
// NEW PARSER: Try first
// ========================================
parser_result = dr_cmd_parser(r_data, length);
if (parser_result > 0) {
// Success - handled by new parser
DBG_PRINTF(">>> Handled by NEW parser\r\n");
return;
}
//
parse_cmd(r_data, &scmd,length);
DBG_PRINTF("parsed.tag ? %s,%d,%d,%d\r\n",scmd.tag,scmd.value0,scmd.value1,scmd.value2);
if(scmd.tag[3] != '?' )
{
quest_error(scmd.tag );
return;
}
else if(!crc16_check_packet(data_array , length)){
char resp_error[4];
resp_error[0] = 'c';
resp_error[1] = 'r'; // 2nd letter (index 1)
resp_error[2] = 'c'; // 3rd letter (index 2)
resp_error[3] = '!';
single_format_data(ble_bin_buffer, resp_error, err_code6);
binary_tx_handler(ble_bin_buffer,3);
return ;
}
else if(processing == true)
{
// DBG_PRINTF("mmm....\r\n");
uint32_t now = app_timer_cnt_get();
if (processing_start_tick == 0)
{
processing_start_tick = now;
}
//
if (app_timer_cnt_diff_compute(now, processing_start_tick) > APP_TIMER_TICKS(5000)) //add cj
{
processing = false;
processing_start_tick = 0;
DBG_PRINTF("processing timeout -> force reset to false\r\n");
}
else
{
DBG_PRINTF("mmm....\r\n");
}
return;
}
else
{
#if 0 //spas
// if((data_array[0] == 'p')&&(data_array[1] == 'a')&&(data_array[2] == 's')&&(data_array[3] == 's')&&(data_array[4] == 'k')&&(data_array[5] == 'e')&&(data_array[6] == 'y')) { // Write, Passkey
//
// if(data_array[7] == '='){
//
//
//
// if ((data_array[8] >=0x30 && data_array[8] <=0x39) //only number is available
// &&(data_array[9] >=0x30 && data_array[9] <=0x39)
// &&(data_array[10] >=0x30 && data_array[10] <=0x39)
// &&(data_array[11] >=0x30 && data_array[11] <=0x39)
// &&(data_array[12] >=0x30 && data_array[12] <=0x39)
// &&(data_array[13] >=0x30 && data_array[13] <=0x39))
//
// {
// memcpy(m_config.static_passkey, data_array+8, 6);
//
// DBG_PRINTF("m_config.static_passkey = %s\r\n", m_config.static_passkey);
//
// if(cmd_t == CMD_UART) {
// DBG_PRINTF("Passkey Ok\r\n");
// } else if(cmd_t == CMD_BLE) {
// sprintf(ble_tx_buffer, "Passkey Ok\r\n");
// data_tx_handler(ble_tx_buffer);
// }
// }
// else{ DBG_PRINTF("Nondigit!! \r\n");
//
// }
//
// }else if(data_array[7] == '?'){
// if(cmd_t == CMD_UART) {
// DBG_PRINTF("Passkey: %s\r\n", m_config.static_passkey);
// } else if(cmd_t == CMD_BLE) {
// sprintf(ble_tx_buffer, "Passkey: %s\r\n", m_config.static_passkey);
// data_tx_handler(ble_tx_buffer);
// }
// }else {
// if(cmd_t == CMD_UART) {
// DBG_PRINTF("ERR!!! Passkey failed!\r\n\r\n");
// } else if(cmd_t == CMD_BLE) {
// sprintf(ble_tx_buffer, "ERR!!! Passkey failed!\r\n\r\n");
// data_tx_handler(ble_tx_buffer);
// }
// }
// } else
//if((data_array[0] == 's')&&(data_array[1] == 't')&&(data_array[2] == 'a')&&(data_array[3] == '?')) {
#endif //sta sta `
// sta
if((scmd.tag[0] == 's')&&(scmd.tag[1] == 't')&&(scmd.tag[2] == 'a')&&(scmd.tag[3] == '?')) {
//sta sta sta sta
resetCount=0; //reset hear cj chun
if(length_error(scmd.tag,8,length)==false)
{
return;
}
if(scmd.value0 == 1) {
if(device_activated() == 0) {
device_status = true;
}
}else if(scmd.value0 == 0) {
if(device_status == true) {
if(device_sleep_mode() == 0) {
device_status = false;
}
}
}else if(data_array[6] == '?') {
/* Nothing to do */
}else {
if(cmd_t == CMD_UART) {
DBG_PRINTF("ERR!!! Status failed!\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag );
}
}
if(cmd_t == CMD_UART) {
DBG_PRINTF("Return%d\r\n\r\n", device_status);
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "rta:", scmd.value0);
binary_tx_handler(ble_bin_buffer,3);
}
}
// str
else if((scmd.tag[0] == 's')&&(scmd.tag[1] == 't')&&(scmd.tag[2] == 'r')&&(scmd.tag[3] == '?')) {
if(length_error(scmd.tag,6,length)==false)
{
return;
}
// else {
// if(cmd_t == CMD_UART) {
// DBG_PRINTF("ERR!!! Status failed!\r\n\r\n");
// } else if(cmd_t == CMD_BLE) {
// param_error(scmd.tag );
// }
// }
if(cmd_t == CMD_UART) {
DBG_PRINTF("Return%d\r\n\r\n", device_status);
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "rtr:", (uint8_t)device_status);
binary_tx_handler(ble_bin_buffer,3);
}
}
// sag
else if((scmd.tag[0] == 's')&&(scmd.tag[1] == 'a')&&(scmd.tag[2] == 'g')) {
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
processing = true ;
DBG_PRINTF("full_agc_mesurement start \r\n");
full_agc_mesurement_start();
}
// sar
else if((scmd.tag[0] == 's')&&(scmd.tag[1] == 'a')&&(scmd.tag[2] == 'r')) {
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
// processing = true ;
// led_pd_gain_array_printout();
else if(cmd_t == CMD_UART) {
DBG_PRINTF("\r\nLED-PD Gain Array =\r\n");
// for(uint16_t i = 0; i < PD_NUM; i++){
for(uint16_t j = 0; j < LED_NUM; j++){
DBG_PRINTF("%d,\t", led_pd_dac_v[j]);
}
DBG_PRINTF("\r\n");
//CJ ADD
sw_i2c_init_once();
eeprom_read_uint16_array(0x0480, led_pd_dac_v, 48); //AGC_Gain int16(48ea)
DBG_PRINTF("\r\n");
DBG_PRINTF("Tagc :");
for(uint16_t j = 0; j < LED_NUM; j++){
DBG_PRINTF("%d, ", led_pd_dac_v[j]);
}
DBG_PRINTF("AGC_Gain EEPROM Read Done\r\n");
}
else if(cmd_t == CMD_BLE) {
format_data(ble_bin_buffer, "rar:", led_pd_dac_v, 96);
binary_tx_handler(ble_bin_buffer,50);
}
else{
param_error(scmd.tag );
}
}else if(scmd.tag[0] == 's') {
// ssa
if((scmd.tag[1] == 's') && (scmd.tag[2] == 'a')){ // ssa LED Power(DP Value) Reading, LED index = 0~23, Power "00"~"FF" m_config.pd_delay_us //ssa
//
led_index = (uint8_t)scmd.value0;
if(length_error(scmd.tag,8,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else if(led_index <= 47)
{
led_power = led_power_read(led_index);
if(led_power <= 255){
if(cmd_t == CMD_UART) {
DBG_PRINTF("Ta%d,%d\r\n\r\n", led_index, led_power);
}
else if(cmd_t == CMD_BLE) {
//ble_tx_buffer[8]= {0};
//led_index16 = (int16_t)led_index;
result_data[0] = scmd.value0;
result_data[1] = (int16_t)led_power;
format_data(ble_bin_buffer, "rsa:", result_data,4);
binary_tx_handler(ble_bin_buffer,4);
}
}
}else{
if(cmd_t == CMD_UART) {
DBG_PRINTF("ERR!!! led_index failed!\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
//
param_error(scmd.tag);
}
}
}
// sab
else if((scmd.tag[1] == 'a') && (scmd.tag[2] == 'b')){
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else if(m_pd_delay_us>= 1) {
uint16_t pre_data[98];
uint16_t led_read_all[48]={0,};
led_power_read_48(led_read_all);
if(m_pd_delay_us>= 1) {
if(cmd_t == CMD_UART) {
} else if(cmd_t == CMD_BLE) {
//
pre_data[0]= m_pd_adc_cnt;
pre_data[1]= m_pd_delay_us; //
DBG_PRINTF("m_pd_adc_cnt=%d\r\n", m_pd_adc_cnt); ////
DBG_PRINTF("m_pd_delay_us=%d\r\n", m_pd_delay_us); ////
#if 0 //48 cout
// for(uint8_t i=0; i<48 ; i++){
// pre_data[i+2] = led_pd_dac_v[i];
// }
// for(uint8_t i=0; i<48 ; i++){
// pre_data[i+50] = led_read_all[i];
// }
#endif //48 ocut
for(uint8_t i=0; i<48 ; i++){
pre_data[i+2] = led_pd_dac_v[i];
}
for(uint8_t i=0; i<48 ; i++){
pre_data[i+50] = led_read_all[i];
}
format_data(ble_bin_buffer, "rab:", pre_data,98);
DBG_PRINTF("Tb%s\r\n\r\n", ble_bin_buffer);
binary_tx_handler(ble_bin_buffer,100);
}
}
}else{
if(cmd_t == CMD_UART) {
DBG_PRINTF("ERR!!! led_index and(or) led_power failed!\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag );
}
}
}
// ssb
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'b')){
// LED Power(DP Value) Setting, LED index = 01~24, Power "000"~"3FF"
led_index = (uint8_t)scmd.value0;
led_power = (uint8_t)scmd.value1;
DBG_PRINTF("Tb%d\r\n\r\n", led_index);
if(length_error(scmd.tag,10,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else if((led_index <= 47)&&(led_power <= 255)) {
DBG_PRINTF("Tb%d\r\n\r\n", led_index);
hw_i2c_init_once();
if(NRF_SUCCESS == led_power_save_mem(led_index, led_power)) {
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tb%d\r\n\r\n", led_index);
} else if(cmd_t == CMD_BLE) {
// sprintf(ble_tx_buffer, "Tb%d\r\n", led_index);
// data_tx_handler(ble_tx_buffer);
result_data[0] = scmd.value0;
result_data[1] = scmd.value1;
format_data(ble_bin_buffer, "rsb:", result_data, 4);
DBG_PRINTF("Tb%s\r\n\r\n", ble_bin_buffer);
binary_tx_handler(ble_bin_buffer,4);
}
}
}else{
if(cmd_t == CMD_UART) {
DBG_PRINTF("ERR!!! led_index and(or) led_power failed!\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag );
}
}
}
// srb
else if((scmd.tag[1] == 'r') && (scmd.tag[2] == 'b')){ //read current all LED DP Values
// LED Power(DP Value) Setting, LED index = 01~24, Power "000"~"3FF"
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
uint16_t led_read_all[48]={0,};
led_power_read_48(led_read_all);
if(led_read_all[47]<=255) {
format_data(ble_bin_buffer, "rrb:", led_read_all, 48);
DBG_PRINTF("Tb%s\r\n\r\n", ble_bin_buffer);
binary_tx_handler(ble_bin_buffer,50);
}
else{
if(cmd_t == CMD_UART) {
DBG_PRINTF("ERR!!! led_index and(or) led_power failed!\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag );
}
}
}
// ssc
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'c')){ // LED On/Off, LED index = 01~24, Off = 99
// if(device_status == false) {
// DBG_PRINTF("ERR!!! Status = 0\r\n");
// return;
// }
led_index = (uint8_t)scmd.value0;
if(length_error(scmd.tag,8,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else if(led_index <= 47){
if(NRF_SUCCESS == led_on(led_index)) {
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tc%d\r\n\r\n", led_index);
} else if(cmd_t == CMD_BLE) {
result = scmd.value0;
//DBG_PRINTF("Tc%d\r\n\r\n", led_index);
single_format_data(ble_bin_buffer, "rsc:", result);
binary_tx_handler(ble_bin_buffer,3);
}
}
}else if(led_index == 99 || led_index == 98 ){
if(NRF_SUCCESS == led_off(led_index)) {
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tc%d\r\n\r\n", led_index);
} else if(cmd_t == CMD_BLE) {
result = 99;
single_format_data(ble_bin_buffer, "rsc:", result);
binary_tx_handler(ble_bin_buffer,3);
// sprintf(ble_tx_buffer, "Tc%d\r\n", led_index);
// data_tx_handler(ble_tx_buffer);
}
}
}else{
if(cmd_t == CMD_UART) {
DBG_PRINTF("ERR!!! led_index_ failed!\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag );
}
}
}
// ssd
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'd')){ // AGC mode On/Off, On:1, Off:0
if(length_error(scmd.tag,8,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else if( scmd.value0 == 0) {
AGC_GAIN_SW(false);
if(cmd_t == CMD_UART) {
DBG_PRINTF("Td0\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
result = 0;
single_format_data(ble_bin_buffer, "rsd:", result);
binary_tx_handler(ble_bin_buffer,3);
}
}else if(scmd.value0 == 1) {
AGC_GAIN_SW(true);
if(cmd_t == CMD_UART) {
DBG_PRINTF("Td1\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
result = 1;
single_format_data(ble_bin_buffer, "rsd:", result);
binary_tx_handler(ble_bin_buffer,3);
}
}else{
if(cmd_t == CMD_UART) {
DBG_PRINTF("ERR!!! adc_mode_on/off failed!\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag );
}
}
}
// sse
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'e')){ // Measure GAIN: ADC_GAIN Voltage Measuring, LED index = 01~24, PD:1~20
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
mcp4725_voltage_level_meas();
}
// ssf
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'f')){ // Writing GAIN: VGA_DP Voltage setting to DAC ssf
led_index = (uint8_t)scmd.value0;
//pd_index = strtol(end, &end, 10);
dac_value = scmd.value1;
if(length_error(scmd.tag,10,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else if((led_index <= 47)&&(dac_value<= 1360)&&(dac_value>= 125)) {
led_pd_dac_v[led_index] = dac_value;
led_pd_matching_value_set(led_index);
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tf\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
result_data[0] = scmd.value0;
result_data[1] = scmd.value1;
format_data(ble_bin_buffer, "rsf:", result_data, 4);
DBG_PRINTF("Tb%s\r\n\r\n", ble_bin_buffer);
binary_tx_handler(ble_bin_buffer,4);
}
}else{
if(cmd_t == CMD_UART) {
DBG_PRINTF("ERR!!!led_index and(or) pd_index and(or) dac_value failed! %d %d %d\r\n\r\n", led_index, pd_index, dac_value);
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag );
}
}
}
// sif
else if((scmd.tag[1] == 'i') && (scmd.tag[2] == 'f')){ // Writing GAIN: VGA_DP Voltage setting to DAC sif
dac_value = scmd.value0;
if(length_error(scmd.tag,8,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else if((dac_value<= 1360)&&(dac_value>= 125)) {
sw_i2c_init_once();
imm_gain_set(dac_value);
if(cmd_t == CMD_UART) {
DBG_PRINTF("rif\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "rif:", dac_value);
DBG_PRINTF("rif%s\r\n\r\n", ble_bin_buffer);
binary_tx_handler(ble_bin_buffer,3);
}
}else{
if(cmd_t == CMD_UART) {
DBG_PRINTF("ERR!!!led_index and(or) pd_index and(or) dac_value failed! %d %d %d\r\n\r\n", led_index, pd_index, dac_value);
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag );
}
}
}
// ssg
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'g')){ // Setting PD, PD : 1~20
pd_index = (uint8_t)scmd.value0;
if(length_error(scmd.tag,8,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else if(pd_index <= 3) {
if(NRF_SUCCESS == pd_on(pd_index)) { //2: mod signal 3: off
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tg%d\r\n\r\n", pd_index);
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "rsg:", scmd.value0);
binary_tx_handler(ble_bin_buffer,3);
}
}
}else{
if(cmd_t == CMD_UART) {
DBG_PRINTF("ERR!!! pd_index failed!\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag );
}
}
}
// ssh
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'h')){ // PD_ADC simple, Measuring PD for above PD
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else{
simple_samples_in_buffer = m_pd_adc_cnt;
con_single=false;
lock_check = false;
simple_mesurement_start();
}
}
// scj
else if((scmd.tag[1] == 'c') && (scmd.tag[2] == 'j')){ // PD_ADC Full, Loop for Sector 1,2,3,4,5,6,7,8 scj
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else{
ADC_PD_MODE = 2;
info4 = true; //true ad edit
ble_got_new_data =false;
processing = true ;
pressure_all_level_meas(); // pressure1 + pressure2
AGC_GAIN_SW(false);
m48_samples_in_buffer = m_pd_adc_cnt;
//DBG_PRINTF("scj m_pd_adc_cnt= %d\r\n",m_pd_adc_cnt);
pd_adc_m48_start = true;
battery_timer_stop();
go_batt = true;// BATT.TEMP IMU
motion_data_once = true;
main_timer_start();
}
}
// sdj
else if((scmd.tag[1] == 'd') && (scmd.tag[2] == 'j')){ // PD_ADC Full, Loop for Sector 1,2,3,4,5,6,7,8
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else{
ADC_PD_MODE = 3;
info4 = false;
ble_got_new_data =false;
processing = true ;
AGC_GAIN_SW(false);
m48_samples_in_buffer = m_pd_adc_cnt;
pd_adc_m48_start = true;
battery_timer_stop();
// motion_raw_data_enabled = true;//IMU
// go_batt = true;// BATT.TEMP IMU
// go_temp = true;
// motion_data_once = true;
// motion_raw_data_enabled = true;//
// main_timer_start();
m48_adc_start_init();
//
}
}
// sej
else if((scmd.tag[1] == 'e') && (scmd.tag[2] == 'j')){ // PD_ADC Full, Loop for Sector 1,2,3,4,5,6,7,8 sej
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else{
ADC_PD_MODE = 4;
info4 = true;
ble_got_new_data =false;
processing = true ;
AGC_GAIN_SW(false);
m48_samples_in_buffer = m_pd_adc_cnt;
pd_adc_m48_start = true;
battery_timer_stop();
// motion_raw_data_enabled = true;//IMU
go_batt = true;// BATT.TEMP IMU
// go_temp = true;
// motion_data_once = true;
// motion_raw_data_enabled = true;//
main_timer_start();
}
}
// sfj
else if((scmd.tag[1] == 'f') && (scmd.tag[2] == 'j')){ // PD_ADC Full, Loop for Sector 1,2,3,4,5,6,7,8
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else{
ADC_PD_MODE = 5;
info4 = false;
ble_got_new_data =false;
processing = true ;
AGC_GAIN_SW(false);
m48_samples_in_buffer = m_pd_adc_cnt;
pd_adc_m48_start = true;
battery_timer_stop();
// motion_raw_data_enabled = true;//IMU
// go_batt = true;// BATT.TEMP IMU
// go_temp = true;
// motion_data_once = true;
// motion_raw_data_enabled = true;//
// main_timer_start();
m48_adc_start_init();
}
}
// ssj
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'j')){ // PD_ADC Full, Loop for Sector 1,2,3,4,5,6,7,8
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else{
ADC_PD_MODE = 0;
info4 = true;
ble_got_new_data =false;
processing = true ;
AGC_GAIN_SW(false);
m48_samples_in_buffer = m_pd_adc_cnt;
pd_adc_m48_start = true;
battery_timer_stop();
// motion_raw_data_enabled = true;//IMU
go_batt = true;// BATT.TEMP IMU
// go_temp = true;
motion_data_once = true;
// motion_raw_data_enabled = true;
main_timer_start();
}
}
// szj
else if((scmd.tag[1] == 'z') && (scmd.tag[2] == 'j')){ // use FAST mode at 99 state
if(length_error(scmd.tag,10,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else{
led_off_dac_v = scmd.value0; // use FAST mode at 99 state
led_off_pd = (uint8_t)scmd.value1;
if(cmd_t == CMD_UART) {
DBG_PRINTF("rzj0\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
result_data[0] = scmd.value0;
result_data[1] = scmd.value1;
format_data(ble_bin_buffer, "rzj:", result_data, 4);
binary_tx_handler(ble_bin_buffer,4);
}
}
}
// saj
else if((scmd.tag[1] == 'a') && (scmd.tag[2] == 'j')){ // PD_ADC Full, Loop for Sector 1,2,3,4,5,6,7,8 saj saj saj
if(length_error(scmd.tag,14,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else
{
sel_led_index0 = scmd.value0;
sel_led_index1 = scmd.value1;
sel_led_index2 = scmd.value2;
sel_led_index3 = scmd.value3;
processing = true ;
battery_timer_stop();
AGC_GAIN_SW(false);
pd_adc_imm_start = true;
ble_got_new_data =false;
imm_adc_start_init();
}
}
// ssk
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'k')){ // Set the number of times of PD_ADC
//ret_code_t err_code;
if(length_error(scmd.tag,8,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else{
imsi_value = scmd.value0;
for(uint8_t i = 0; i <= 4; i++ ) {
if(i == 4) {
DBG_PRINTF("ERR!!! pd_adc_cnt failed!\r\n\r\n");
break;
}
if(pd_adc_counts[i] == imsi_value) {
m_pd_adc_cnt = imsi_value;
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tk0\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
result = scmd.value0;
single_format_data(ble_bin_buffer, "rsk:", scmd.value0);
binary_tx_handler(ble_bin_buffer,3);
//err_code =
eeprom_write_byte(0x0070, m_pd_adc_cnt);
}
break;
}
}
}
}
// srk
else if((scmd.tag[1] == 'r') && (scmd.tag[2] == 'k')){ // Set the number of times of PD_ADC
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else{
//imsi_value = scmd.value0;
uint16_t rk_value;
rk_value = (uint16_t)m_pd_adc_cnt;
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tk0\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
result = scmd.value0;
single_format_data(ble_bin_buffer, "rrk:", rk_value);
binary_tx_handler(ble_bin_buffer,3);
}
}
}
// ssl
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'l')){ // Set the delay for PD stabilization. 0<>s ~ FFFF(65535)<29>s
// ret_code_t err_code;
imsi_value = scmd.value0;
if(length_error(scmd.tag,8,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else if((imsi_value >= 1)&&(imsi_value <= 65535)) {
m_pd_delay_us = imsi_value;
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tl0\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
eeprom_write_word(0x0080, m_pd_delay_us);
DBG_PRINTF("m_pd_delay_us=%d\r\n",m_pd_delay_us);
single_format_data(ble_bin_buffer, "rsl:", scmd.value0);
binary_tx_handler(ble_bin_buffer,3);
}
}else{
if(cmd_t == CMD_UART) {
DBG_PRINTF("ERR!!! pd_delay_us failed!\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag );
}
}
}
// srl
else if((scmd.tag[1] == 'r') && (scmd.tag[2] == 'l')){ // Set the delay for PD stabilization. 0<>s ~ FFFF(65535)<29>s
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else {
uint16_t rl_value;
rl_value = m_pd_delay_us;
if(cmd_t == CMD_UART) {
DBG_PRINTF("rrl:\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "rrl:", rl_value);
binary_tx_handler(ble_bin_buffer,3);
}
}
}
// ssn
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'n')){ // Measuring the Battery level
battery_level_meas();
}
// spn
else if((scmd.tag[1] == 'p') && (scmd.tag[2] == 'n')){ // Measuring the pressure1 level read
pressure_all_level_meas(); // pressure1 + pressure2
}
// sso
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'o')){ // Measuring the Temperature of LED
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else{
tmp235_voltage_level_meas();
}
}
// ssp
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'p')){ // Measuring the raw data of 6-axis motion sensor
hw_i2c_init_once();
motion_raw_data_enabled = true;
hw_i2c_init_once();
ble_got_new_data =false;
if(data_array[2] == 'c')
{
motion_data_once = false;
}
else
{
motion_data_once = true;
}
main_timer_start();
// }else if((scmd.tag[1] == 'P') && (scmd.tag[2] == 'p')){ // Measuring the raw data of 6-axis motion sensor
// motion_raw_data_enabled = true;
// ble_got_new_data =false;
//
//
// motion_data_once = false;
//
// main_timer_start();
}
// ssq
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'q')){ // Device power off
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tq\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "rsq:", scmd.value0);
binary_tx_handler(ble_bin_buffer,2);
// sprintf(ble_tx_buffer, "Tq\r\n");
// data_tx_handler(ble_tx_buffer);
}
go_device_power_off = true;
main_timer_start();
#if FEATURE_SECURE_CONNECTION
}
// ssr
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'r')){ // Bond Info Delete
// ret_code_t err_code;
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tr\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "rsr:", scmd.value0);
binary_tx_handler(ble_bin_buffer,2);
}
bond_data_delete = true;
eeprom_write_byte(0x0060, (uint8_t)bond_data_delete);
//m_config.reset_status = 2;
m_reset_status = 2;
eeprom_write_byte(0x0065, m_reset_status);
//config_save();
nrf_delay_ms(5);
go_NVIC_SystemReset = true;
main_timer_start();
#endif
}
// sss
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 's')){ //Device reset(Reboot)
// ret_code_t err_code;
// err_code = eeprom_write_byte(0x0060, 0x00);
//ret_code_t err_code;
if(cmd_t == CMD_UART) {
DBG_PRINTF("Ts\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "rss:", scmd.value0);
binary_tx_handler(ble_bin_buffer,2);
}
go_NVIC_SystemReset = true;
//m_config.reset_status = 2;
m_reset_status = 2;
eeprom_write_byte(0x0065, m_reset_status);
// config_save();
nrf_delay_ms(5);
go_NVIC_SystemReset = true;
main_timer_start();
}
// sst
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 't')){ // Auto Gain Control
if(cmd_t == CMD_UART) {
DBG_PRINTF("Ready\r\n\r\nREADY\r\n");
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "rst:", scmd.value0);
binary_tx_handler(ble_bin_buffer,2);
}
}
// ssv
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'v')){ // Auto Gain Control
if(cmd_t == CMD_UART) {
DBG_PRINTF("%s\r\n",DEVICE_VERSION);
} else if(cmd_t == CMD_BLE) {
ascii_format_data(ble_bin_buffer, "rsv:", DEVICE_VERSION,12);
binary_tx_handler(ble_bin_buffer,8);
//test_eeprom_page_rw();
}
}
// ssz
else if((scmd.tag[1] == 's') && (scmd.tag[2] == 'z')){ //Write, Serial Number
if(length_error(scmd.tag,18,length)==false)
{
return;
}
uint8_t tx_data[EEPROM_PAGE_SIZE];
uint8_t rx_data[EEPROM_PAGE_SIZE];
uint8_t raw_data[EEPROM_PAGE_SIZE];
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tz0\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
//eeprom_write_encrypted(0x0000, secret_data, strlen((char *)secret_data));
//eeprom_read_decrypted(0x0000, decrypted, strlen((char *)secret_data));
//DBG_PRINTF("Decrypted: %s\n", decrypted);
memcpy(SERIAL_NO, scmd.value_ascii, 12);
//eeprom_write_bytes(uint16_t mem_address, const uint8_t *data, size_t length)
for (uint8_t i=0 ; i<12 ;i++)
{
tx_data[i] = (uint8_t)(scmd.value_ascii[i]);
}
// if (eeprom_write_bytes(0x0030 , tx_data ,12) !=NRF_SUCCESS)
// {
// DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");
// }
if(eeprom_write_encrypted(0x0030, tx_data, 12)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");;
}
if(eeprom_read_bytes(0x0030, raw_data, 12)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");;
}
nrf_delay_ms(10);
DBG_PRINTF("encrypted: %s\n", raw_data);
if(eeprom_read_decrypted(0x0030, rx_data, 12)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");;
}
DBG_PRINTF("Decrypted: %s\n", rx_data);
ascii_format_data(ble_bin_buffer, "rsz:", scmd.value_ascii,12);
binary_tx_handler(ble_bin_buffer,8);
}
else{
DBG_PRINTF("ERR!!! Serial_number 12\r\n\r\n");
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tz0FF\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag );
}
}
}
// spz
else if((scmd.tag[1] == 'p') && (scmd.tag[2] == 'z')){ //Write, passkey
if(length_error(scmd.tag,12,length)==false)
{
return;
}
uint8_t tx_data[EEPROM_PAGE_SIZE];
uint8_t rx_data[EEPROM_PAGE_SIZE];
uint8_t raw_data[EEPROM_PAGE_SIZE];
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tz0\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
//memcpy(SERIAL_NO, scmd.value_ascii, 6);
//eeprom_write_bytes(uint16_t mem_address, const uint8_t *data, size_t length)
for (uint8_t i=0 ; i<6 ;i++)
{
tx_data[i] = (uint8_t)(scmd.value_ascii[i]);
}
if(eeprom_write_encrypted(0x0020, tx_data, 6)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_passkey 6\r\n\r\n");;
}
if(eeprom_read_bytes(0x0020, raw_data, 6)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_passkey 6\r\n\r\n");;
}
nrf_delay_ms(10);
DBG_PRINTF("encrypted: %s\n", raw_data);
if(eeprom_read_decrypted(0x0020, rx_data, 6)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_passkey 6\r\n\r\n");;
}
DBG_PRINTF("Decrypted: %s\n", rx_data);
ascii_format_data(ble_bin_buffer, "rpz:", scmd.value_ascii,6);
binary_tx_handler(ble_bin_buffer,5);
}
else{
DBG_PRINTF("ERR!!! passkey 6\r\n\r\n");
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tpz0FF\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag );
}
}
}
// sqz
else if((scmd.tag[1] == 'q') && (scmd.tag[2] == 'z')){ // Read, Serial Number
uint8_t rx_data[EEPROM_PAGE_SIZE];
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tz1,%s\r\n\r\n", SERIAL_NO);
} else if(cmd_t == CMD_BLE) {
hw_i2c_init_once();
if(eeprom_read_decrypted(0x0020, rx_data, 6)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");;
}
DBG_PRINTF("Decrypted: %s\n", rx_data);
// if (eeprom_read_bytes(0x0030 , rx_data ,12) !=NRF_SUCCESS)
// {
// DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");
// }
// sprintf(ble_tx_buffer, "Tz1,%s\r\n", m_config.serial_number);
// data_tx_handler(ble_tx_buffer);
for (uint8_t i=0 ; i<6 ;i++)
{
(m_static_passkey[i]) = (char)rx_data[i] ;
}
ascii_format_data(ble_bin_buffer, "rqz:", m_static_passkey,6);
binary_tx_handler(ble_bin_buffer,5);
}
}
// srz
else if((scmd.tag[1] == 'r') && (scmd.tag[2] == 'z')){ // Read, Serial Number
uint8_t rx_data[EEPROM_PAGE_SIZE];
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tz1,%s\r\n\r\n", SERIAL_NO);
} else if(cmd_t == CMD_BLE) {
if(eeprom_read_decrypted(0x0030, rx_data, 12)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");;
}
DBG_PRINTF("Decrypted: %s\n", rx_data);
// if (eeprom_read_bytes(0x0030 , rx_data ,12) !=NRF_SUCCESS)
// {
// DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");
// }
// sprintf(ble_tx_buffer, "Tz1,%s\r\n", m_config.serial_number);
// data_tx_handler(ble_tx_buffer);
for (uint8_t i=0 ; i<12 ;i++)
{
(SERIAL_NO[i]) = (char)rx_data[i] ;
}
ascii_format_data(ble_bin_buffer, "rrz:", SERIAL_NO,12);
binary_tx_handler(ble_bin_buffer,8);
}
#if 0 // ===== EEPROM start block =====
// }else if((scmd.tag[1] == 'a') && (scmd.tag[2] == 'z')){ // write bytes
//
//
// uint8_t write_data[64];
//
// memcpy(write_data,scmd.value_ascii,12);
// eeprom_write_bytes(scmd.value0,write_data,12);
// if(cmd_t == CMD_UART) {
// DBG_PRINTF("Tz2,%s\r\n\r\n",write_data);
// } else if(cmd_t == CMD_BLE) {
// sprintf(ble_tx_buffer, "Tz22,%s\r\n", write_data);
// data_tx_handler(ble_tx_buffer);
// }
// }else if((scmd.tag[1] == 'b') && (scmd.tag[2] == 'z')){
//
// unsigned char *read_data;
//
// eeprom_read_bytes(scmd.value0,read_data,12);
//
// if(cmd_t == CMD_UART) {
// DBG_PRINTF("Tz3,%s,%s\r\n\r\n", read_data,read_data);
// } else if(cmd_t == CMD_BLE) {
// sprintf(ble_tx_buffer, "Tz3,%s\r\n",read_data);
// data_tx_handler(ble_tx_buffer);
// }
// }else if((scmd.tag[1] == 'c') && (scmd.tag[2] == 'z')){ // write page
//
// //unsigned char read_data[EEPROM_PAGE_SIZE];
// uint8_t write_data[64];
// for(uint8_t i=0 ; i<64 ;i++){
// write_data[i] = scmd.values[i+6];
// }
//
// //memcpy(write_data,scmd.value_ascii,12);
// eeprom_write_page (scmd.value0,write_data);
//
// if(cmd_t == CMD_UART) {
// DBG_PRINTF("Tz3,%s\r\n\r\n", write_data);
// } else if(cmd_t == CMD_BLE) {
//// sprintf(ble_tx_buffer, "Tz3,%s\r\n",read_data
// ascii_format_data(ble_bin_buffer, "rcz:", "ok",3);
// binary_tx_handler(ble_bin_buffer,5);
//// data_tx_handler(ble_tx_buffer);
// }
//
//
//
//
//
// }else if((scmd.tag[1] == 'd') && (scmd.tag[2] == 'z')){ // Read page
//
// uint8_t read_data[64];
// eeprom_read_page (scmd.value0,read_data);
//
// if(cmd_t == CMD_UART) {
// // DBG_PRINTF("Tz3,%s,%s\r\n\r\n", read_data,read_data);
// } else if(cmd_t == CMD_BLE) {
// for (int i = 0; i < EEPROM_PAGE_SIZE; i++) {
//
// DBG_PRINTF("%02X,", read_data[i]);
// }
//
//
// format_data_byte(ble_bin_buffer, "rdz:", read_data,64);
// binary_tx_handler(ble_bin_buffer,34);
// }
//ret_code_t eeprom_write_uint16_array(uint16_t start_address, const uint16_t *data, size_t count)
#endif // ===== EEPROM block End =====
}
// sez
else if((scmd.tag[1] == 'e') && (scmd.tag[2] == 'z')){ // Read, Serial Number
hw_i2c_init_once();
uint16_t write_data[64];
for (int i = 0; i < 48; i++) {
write_data[i]= (uint16_t)(scmd.values[i*2+7] | (uint16_t)(scmd.values[i*2+6] << 8));
}
eeprom_write_uint16_array(scmd.value0,write_data,48);
if(cmd_t == CMD_UART) {
DBG_PRINTF("rez,%s\r\n\r\n", scmd.value_ascii);
} else if(cmd_t == CMD_BLE) {
format_data(ble_bin_buffer, "rez:", write_data,48);
binary_tx_handler(ble_bin_buffer,50);
}
}
// sfz
else if((scmd.tag[1] == 'f') && (scmd.tag[2] == 'z')){ // Read, Serial Number sfz arry eeprom read
if(length_error(scmd.tag,8,length)==false)
{
return;
}
// else if(activate_error(scmd.tag,device_status)==false)
// {
// return;
// }
else{
hw_i2c_init_once();
uint16_t read_data[64];
//uint8_t EEPread_data[64];
eeprom_read_uint16_array(scmd.value0,read_data,48); //int16(48ea) DP Preset 0~6
// for (int i = 0; i < 48; i++) {
// EEPread_data[i]= (uint8_t)(read_data[i]);
// }
if(cmd_t == CMD_UART) {
DBG_PRINTF("ref,%s\r\n\r\n", scmd.value_ascii);
} else if(cmd_t == CMD_BLE) {
format_data(ble_bin_buffer, "rfz:", read_data,48);
binary_tx_handler(ble_bin_buffer,50);
}
}
}
// sgz
else if((scmd.tag[1] == 'g') && (scmd.tag[2] == 'z')){ // Read, DCP r sgz
if(length_error(scmd.tag,8,length)==false)
{
return;
}
else if(activate_error(scmd.tag,device_status)==false)
{
return;
}
else{
hw_i2c_init_once();
uint16_t read_data[64];
uint8_t EEPread_data[64];
eeprom_read_uint16_array(scmd.value0,read_data,48);
for (int i = 0; i < 48; i++) {
EEPread_data[i]= (uint8_t)(read_data[i]);
}
if(cmd_t == CMD_UART) {
DBG_PRINTF("ref,%s\r\n\r\n", scmd.value_ascii);
} else if(cmd_t == CMD_BLE) {
if(led_power_save_mem_48( EEPread_data)){
DBG_PRINTF("error,%s\r\n\r\n", scmd.value_ascii);
}
format_data(ble_bin_buffer, "rgz:", read_data,48);
binary_tx_handler(ble_bin_buffer,50);
}
}
}
// siz
else if((scmd.tag[1] == 'i') && (scmd.tag[2] == 'z')){ // Read, HW
hw_i2c_init_once();
uint8_t rx_data[EEPROM_PAGE_SIZE];
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tz1,%s\r\n\r\n", HW_NO);
} else if(cmd_t == CMD_BLE) {
if(eeprom_read_decrypted(0x0010, rx_data, 12)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");;
}
DBG_PRINTF("Decrypted: %s\n", rx_data);
// if (eeprom_read_bytes(0x0030 , rx_data ,12) !=NRF_SUCCESS)
// {
// DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");
// }
// sprintf(ble_tx_buffer, "Tz1,%s\r\n", m_config.serial_number);
// data_tx_handler(ble_tx_buffer);
for (uint8_t i=0 ; i<12 ;i++)
{
(HW_NO[i]) = (char)rx_data[i] ;
}
ascii_format_data(ble_bin_buffer, "riz:", HW_NO,12);
binary_tx_handler(ble_bin_buffer,8);
}
}
// shz
else if((scmd.tag[1] == 'h') && (scmd.tag[2] == 'z')){ //Write, HW
if(length_error(scmd.tag,18,length)==false)
{
return;
}
hw_i2c_init_once();
uint8_t tx_data[EEPROM_PAGE_SIZE];
uint8_t rx_data[EEPROM_PAGE_SIZE];
uint8_t raw_data[EEPROM_PAGE_SIZE];
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tz0\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
memcpy(HW_NO, scmd.value_ascii, 12);
//eeprom_write_bytes(uint16_t mem_address, const uint8_t *data, size_t length)
for (uint8_t i=0 ; i<12 ;i++)
{
tx_data[i] = (uint8_t)(scmd.value_ascii[i]);
}
if(eeprom_write_encrypted(0x0010, tx_data, 12)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");;
}
if(eeprom_read_bytes(0x0010, raw_data, 12)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");;
}
nrf_delay_ms(10);
DBG_PRINTF("encrypted: %s\n", raw_data);
if(eeprom_read_decrypted(0x0010, rx_data, 12)!= NRF_SUCCESS)
{
DBG_PRINTF("ERR!!! EEP_Serial_number 12\r\n\r\n");;
}
DBG_PRINTF("Decrypted: %s\n", rx_data);
ascii_format_data(ble_bin_buffer, "rhz:", scmd.value_ascii,12);
binary_tx_handler(ble_bin_buffer,8);
}
else{
DBG_PRINTF("ERR!!! passkey 6\r\n\r\n");
if(cmd_t == CMD_UART) {
DBG_PRINTF("Tpz0FF\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag );
}
}
}
// sxz
else if((scmd.tag[1] == 'x') && (scmd.tag[2] == 'z')){ // Set the delay for PD stabilization. 0<>s ~ FFFF(65535)<29>s
m_life_cycle = ((uint16_t)scmd.value0 << 16) | ((uint16_t)scmd.value1 & 0xFFFF);
result_data[0] = scmd.value0;
result_data[1] = scmd.value1;
if(length_error(scmd.tag,10,length)==false)
{
return;
}
else if((m_life_cycle > 0)||(m_life_cycle <= 99999999)) {
if(cmd_t == CMD_UART) {
DBG_PRINTF("rxz\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
hw_i2c_init_once();
eeprom_write_uint32(0x0090, m_life_cycle);
format_data(ble_bin_buffer, "rxz:", result_data,2);
binary_tx_handler(ble_bin_buffer,4);
}
}else{
if(cmd_t == CMD_UART) {
DBG_PRINTF("ERR!!! pd_delay_us failed!\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
param_error(scmd.tag );
}
}
}
// syz
else if((scmd.tag[1] == 'y') && (scmd.tag[2] == 'z')){ //
if(length_error(scmd.tag,6,length)==false)
{
return;
}
else {
eeprom_read_uint32(0x0090, &m_life_cycle); //thnk cj
result_data[0] = (uint16_t)(m_life_cycle >> 16);
result_data[1] = (uint16_t)(m_life_cycle & 0xFFFF);
if(cmd_t == CMD_UART) {
DBG_PRINTF("ryz:\r\n\r\n");
} else if(cmd_t == CMD_BLE) {
format_data(ble_bin_buffer, "ryz:", result_data,4);
binary_tx_handler(ble_bin_buffer,4);
}
}
//ret_code_t eeprom_write_uint32(uint16_t mem_address, uint32_t data);
}else {
if(cmd_t == CMD_UART) {
DBG_PRINTF("ERR!!! UART Command Failed, %c%c%c%c\r\n",data_array[0], data_array[1], data_array[2], data_array[3]);
} else if(cmd_t == CMD_BLE) {
single_format_data(ble_bin_buffer, "err!", err_code5);
binary_tx_handler(ble_bin_buffer,3);
}
}
}
}
}
/**
* @}
*/
//0x0A
Reference in New Issue View Git Blame Copy Permalink