From e3ff2d0d95c7030e2512dd8d432ec8fb16f02615 Mon Sep 17 00:00:00 2001 From: Philippe Teuwen Date: Wed, 23 Aug 2023 00:22:22 +0200 Subject: [PATCH] C files: same style as for pm3 repo --- firmware/application/src/app_cmd.c | 181 +++++++------ firmware/application/src/app_cmd.h | 2 +- firmware/application/src/app_main.c | 60 +++-- firmware/application/src/ble_main.c | 130 ++++------ firmware/application/src/bsp/bsp_delay.c | 9 +- firmware/application/src/bsp/bsp_delay.h | 2 +- firmware/application/src/bsp/bsp_time.c | 11 +- firmware/application/src/bsp/bsp_time.h | 6 +- firmware/application/src/bsp/bsp_wdt.c | 5 +- firmware/application/src/bsp/bsp_wdt.h | 2 +- firmware/application/src/rfid/crc_utils.c | 66 ++--- firmware/application/src/rfid/crc_utils.h | 2 +- firmware/application/src/rfid/hex_utils.c | 6 +- firmware/application/src/rfid/hex_utils.h | 4 +- firmware/application/src/rfid/mf1_crypto1.c | 40 +-- .../application/src/rfid/nfctag/hf/nfc_14a.c | 15 +- .../application/src/rfid/nfctag/hf/nfc_14a.h | 16 +- .../application/src/rfid/nfctag/hf/nfc_mf1.c | 42 +-- .../application/src/rfid/nfctag/hf/nfc_mf1.h | 11 +- .../application/src/rfid/nfctag/hf/nfc_ntag.c | 54 ++-- .../application/src/rfid/nfctag/hf/nfc_ntag.h | 7 +- .../src/rfid/nfctag/lf/lf_tag_em.c | 142 +++++++--- .../src/rfid/nfctag/lf/lf_tag_em.h | 4 +- .../src/rfid/nfctag/tag_emulation.c | 13 +- .../src/rfid/nfctag/tag_emulation.h | 10 +- .../src/rfid/nfctag/tag_persistence.c | 6 +- .../src/rfid/nfctag/tag_persistence.h | 4 +- .../src/rfid/reader/hf/mf1_toolbox.c | 89 ++++--- .../src/rfid/reader/hf/mf1_toolbox.h | 4 +- .../application/src/rfid/reader/hf/rc522.c | 159 +++++------- .../application/src/rfid/reader/hf/rc522.h | 118 ++++----- .../src/rfid/reader/lf/data_utils.c | 44 ++-- .../src/rfid/reader/lf/data_utils.h | 2 +- .../src/rfid/reader/lf/lf_em410x_data.c | 244 +++++++----------- .../src/rfid/reader/lf/lf_em410x_data.h | 3 +- .../src/rfid/reader/lf/lf_reader_data.c | 8 +- .../src/rfid/reader/lf/lf_reader_data.h | 2 +- .../src/rfid/reader/lf/lf_reader_main.c | 12 +- .../src/rfid/reader/lf/lf_reader_main.h | 4 +- .../src/rfid/reader/lf/lf_t55xx_data.c | 60 ++--- firmware/application/src/rfid_main.c | 2 +- firmware/application/src/rgb_marquee.c | 184 +++++++------ firmware/application/src/rgb_marquee.h | 10 +- firmware/application/src/settings.c | 98 +++---- firmware/application/src/usb_main.c | 145 +++++------ firmware/application/src/utils/dataframe.c | 2 +- firmware/application/src/utils/dataframe.h | 4 +- .../application/src/utils/delayed_reset.c | 2 +- firmware/application/src/utils/fds_util.c | 32 ++- firmware/application/src/utils/fds_util.h | 4 +- firmware/application/src/utils/syssleep.c | 3 +- firmware/application/src/utils/timeslot.c | 22 +- firmware/bootloader/src/dfu_public_key.c | 3 +- firmware/bootloader/src/main.c | 44 ++-- firmware/common/hw_connect.c | 40 +-- firmware/common/hw_connect.h | 6 +- firmware/common/libc_nano_stubs.c | 30 +-- software/src/darkside.c | 17 +- software/src/mfkey64.c | 6 +- software/src/nested.c | 70 +++-- 60 files changed, 1107 insertions(+), 1216 deletions(-) diff --git a/firmware/application/src/app_cmd.c b/firmware/application/src/app_cmd.c index 4c71b21..9699c63 100644 --- a/firmware/application/src/app_cmd.c +++ b/firmware/application/src/app_cmd.c @@ -24,18 +24,18 @@ NRF_LOG_MODULE_REGISTER(); -data_frame_tx_t* cmd_processor_get_version(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_version(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint16_t version = FW_VER_NUM; - return data_frame_make(cmd, status, 2, (uint8_t*)&version); + return data_frame_make(cmd, status, 2, (uint8_t *)&version); } -data_frame_tx_t* cmd_processor_get_git_version(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { - return data_frame_make(cmd, status, strlen(GIT_VERSION), (uint8_t*)GIT_VERSION); +data_frame_tx_t *cmd_processor_get_git_version(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { + return data_frame_make(cmd, status, strlen(GIT_VERSION), (uint8_t *)GIT_VERSION); } -data_frame_tx_t* cmd_processor_change_device_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_change_device_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { #if defined(PROJECT_CHAMELEON_ULTRA) if (length == 1) { if (data[0] == 1) { @@ -52,70 +52,69 @@ data_frame_tx_t* cmd_processor_change_device_mode(uint16_t cmd, uint16_t status, #endif } -data_frame_tx_t* cmd_processor_get_device_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_device_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { device_mode_t mode = get_device_mode(); if (mode == DEVICE_MODE_READER) { status = 1; } else { status = 0; } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, (uint8_t*)&status); + return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, (uint8_t *)&status); } -data_frame_tx_t* cmd_processor_enter_bootloader(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_enter_bootloader(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { // restart to boot - #define BOOTLOADER_DFU_GPREGRET_MASK (0xB0) - #define BOOTLOADER_DFU_START_BIT_MASK (0x01) - #define BOOTLOADER_DFU_START (BOOTLOADER_DFU_GPREGRET_MASK | BOOTLOADER_DFU_START_BIT_MASK) - APP_ERROR_CHECK(sd_power_gpregret_clr(0,0xffffffff)); +#define BOOTLOADER_DFU_GPREGRET_MASK (0xB0) +#define BOOTLOADER_DFU_START_BIT_MASK (0x01) +#define BOOTLOADER_DFU_START (BOOTLOADER_DFU_GPREGRET_MASK | BOOTLOADER_DFU_START_BIT_MASK) + APP_ERROR_CHECK(sd_power_gpregret_clr(0, 0xffffffff)); APP_ERROR_CHECK(sd_power_gpregret_set(0, BOOTLOADER_DFU_START)); nrf_pwr_mgmt_shutdown(NRF_PWR_MGMT_SHUTDOWN_GOTO_DFU); // Never into here... while (1) __NOP(); } -data_frame_tx_t* cmd_processor_get_device_chip_id(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_device_chip_id(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint32_t chip_id[2]; chip_id[0] = NRF_FICR->DEVICEID[0]; chip_id[1] = NRF_FICR->DEVICEID[1]; - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 8, (uint8_t*)(&chip_id[0])); + return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 8, (uint8_t *)(&chip_id[0])); } -data_frame_tx_t* cmd_processor_get_device_address(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_device_address(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint32_t device_address[2]; device_address[0] = NRF_FICR->DEVICEADDR[0]; device_address[1] = NRF_FICR->DEVICEADDR[1]; - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 6, (uint8_t*)(&device_address[0])); + return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 6, (uint8_t *)(&device_address[0])); } -data_frame_tx_t* cmd_processor_save_settings(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_save_settings(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { status = settings_save_config(); return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_reset_settings(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_reset_settings(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { settings_init_config(); status = settings_save_config(); return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_set_animation_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_animation_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == 1) { status = STATUS_DEVICE_SUCCESS; settings_set_animation_config(data[0]); - } - else { + } else { status = STATUS_PAR_ERR; } return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_get_animation_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_animation_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t animation_mode = settings_get_animation_config(); return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, (uint8_t *)(&animation_mode)); } -data_frame_tx_t* cmd_processor_get_battery_info(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_battery_info(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t resp[3] = { 0x00 }; // set voltage num_to_bytes(batt_lvl_in_milli_volts, 2, resp); @@ -124,7 +123,7 @@ data_frame_tx_t* cmd_processor_get_battery_info(uint16_t cmd, uint16_t status, u return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, sizeof(resp), resp); } -data_frame_tx_t* cmd_processor_get_button_press_config(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_button_press_config(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t button_press_config; if (length == 1 && is_settings_button_type_valid(data[0])) { button_press_config = settings_get_button_press_config(data[0]); @@ -136,7 +135,7 @@ data_frame_tx_t* cmd_processor_get_button_press_config(uint16_t cmd, uint16_t st return data_frame_make(cmd, status, length, (uint8_t *)(&button_press_config)); } -data_frame_tx_t* cmd_processor_set_button_press_config(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_button_press_config(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == 2 && is_settings_button_type_valid(data[0])) { settings_set_button_press_config(data[0], data[1]); status = STATUS_DEVICE_SUCCESS; @@ -149,12 +148,12 @@ data_frame_tx_t* cmd_processor_set_button_press_config(uint16_t cmd, uint16_t st #if defined(PROJECT_CHAMELEON_ULTRA) -data_frame_tx_t* cmd_processor_14a_scan(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_14a_scan(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { picc_14a_tag_t taginfo; status = pcd_14a_reader_scan_auto(&taginfo); if (status == HF_TAG_OK) { length = sizeof(picc_14a_tag_t); - data = (uint8_t*)&taginfo; + data = (uint8_t *)&taginfo; } else { length = 0; data = NULL; @@ -162,22 +161,22 @@ data_frame_tx_t* cmd_processor_14a_scan(uint16_t cmd, uint16_t status, uint16_t return data_frame_make(cmd, status, length, data); } -data_frame_tx_t* cmd_processor_detect_mf1_support(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_detect_mf1_support(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { status = Check_STDMifareNT_Support(); return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_detect_mf1_nt_level(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_detect_mf1_nt_level(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { status = Check_WeakNested_Support(); return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_detect_mf1_darkside(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_detect_mf1_darkside(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { status = Check_Darkside_Support(); return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_mf1_darkside_acquire(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_mf1_darkside_acquire(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { DarksideCore dc; if (length == 4) { status = Darkside_Recover_Key(data[1], data[0], data[2], data[3], &dc); @@ -194,7 +193,7 @@ data_frame_tx_t* cmd_processor_mf1_darkside_acquire(uint16_t cmd, uint16_t statu return data_frame_make(cmd, status, length, data); } -data_frame_tx_t* cmd_processor_detect_nested_dist(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_detect_nested_dist(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { NestedDist nd; if (length == 8) { status = Nested_Distacne_Detect(data[1], data[0], &data[2], &nd); @@ -211,7 +210,7 @@ data_frame_tx_t* cmd_processor_detect_nested_dist(uint16_t cmd, uint16_t status, return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_mf1_nt_distance(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_mf1_nt_distance(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { NestedDist nd; if (length == 8) { status = Nested_Distacne_Detect(data[1], data[0], &data[2], &nd); @@ -228,7 +227,7 @@ data_frame_tx_t* cmd_processor_mf1_nt_distance(uint16_t cmd, uint16_t status, ui return data_frame_make(cmd, status, length, data); } -data_frame_tx_t* cmd_processor_mf1_nested_acquire(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_mf1_nested_acquire(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { NestedCore ncs[SETS_NR]; if (length == 10) { status = Nested_Recover_Key(bytes_to_num(&data[2], 6), data[1], data[0], data[9], data[8], ncs); @@ -245,7 +244,7 @@ data_frame_tx_t* cmd_processor_mf1_nested_acquire(uint16_t cmd, uint16_t status, return data_frame_make(cmd, status, length, data); } -data_frame_tx_t* cmd_processor_mf1_auth_one_key_block(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_mf1_auth_one_key_block(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == 8) { status = auth_key_use_522_hw(data[1], data[0], &data[2]); pcd_14a_reader_mf1_unauth(); @@ -255,7 +254,7 @@ data_frame_tx_t* cmd_processor_mf1_auth_one_key_block(uint16_t cmd, uint16_t sta return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_mf1_read_one_block(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_mf1_read_one_block(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t block[16] = { 0x00 }; if (length == 8) { status = auth_key_use_522_hw(data[1], data[0], &data[2]); @@ -276,7 +275,7 @@ data_frame_tx_t* cmd_processor_mf1_read_one_block(uint16_t cmd, uint16_t status, return data_frame_make(cmd, status, length, block); } -data_frame_tx_t* cmd_processor_mf1_write_one_block(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_mf1_write_one_block(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == 24) { status = auth_key_use_522_hw(data[1], data[0], &data[2]); if (status == HF_TAG_OK) { @@ -290,13 +289,13 @@ data_frame_tx_t* cmd_processor_mf1_write_one_block(uint16_t cmd, uint16_t status return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_em410x_scan(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_em410x_scan(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t id_buffer[5] = { 0x00 }; status = PcdScanEM410X(id_buffer); return data_frame_make(cmd, status, sizeof(id_buffer), id_buffer); } -data_frame_tx_t* cmd_processor_write_em410x_2_t57(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_write_em410x_2_t57(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length >= 13 && (length - 9) % 4 == 0) { status = PcdWriteT55XX(data, data + 5, data + 9, (length - 9) / 4); } else { @@ -315,7 +314,7 @@ static void change_slot_auto(uint8_t slot) { set_slot_light_color(0); } -data_frame_tx_t* cmd_processor_set_slot_activated(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_slot_activated(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == 1 && data[0] < TAG_MAX_SLOT_NUM) { change_slot_auto(data[0]); status = STATUS_DEVICE_SUCCESS; @@ -325,7 +324,7 @@ data_frame_tx_t* cmd_processor_set_slot_activated(uint16_t cmd, uint16_t status, return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_set_slot_tag_type(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_slot_tag_type(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == 2 && data[0] < TAG_MAX_SLOT_NUM && data[1] != TAG_TYPE_UNKNOWN) { uint8_t num_slot = data[0]; uint8_t tag_type = data[1]; @@ -337,7 +336,7 @@ data_frame_tx_t* cmd_processor_set_slot_tag_type(uint16_t cmd, uint16_t status, return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_delete_slot_sense_type(uint16_t cmd, uint16_t status, uint16_t length, uint8_t* data) { +data_frame_tx_t *cmd_processor_delete_slot_sense_type(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { status = STATUS_PAR_ERR; if (length == 2 && data[0] < TAG_MAX_SLOT_NUM && (data[1] == TAG_SENSE_HF || data[1] == TAG_SENSE_LF)) { uint8_t slot_num = data[0]; @@ -349,7 +348,7 @@ data_frame_tx_t* cmd_processor_delete_slot_sense_type(uint16_t cmd, uint16_t sta return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_set_slot_data_default(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_slot_data_default(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == 2 && data[0] < TAG_MAX_SLOT_NUM && data[1] != TAG_TYPE_UNKNOWN) { uint8_t num_slot = data[0]; uint8_t tag_type = data[1]; @@ -360,7 +359,7 @@ data_frame_tx_t* cmd_processor_set_slot_data_default(uint16_t cmd, uint16_t stat return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_set_slot_enable(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_slot_enable(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == 2 && data[0] < TAG_MAX_SLOT_NUM && (data[1] == 0 || data[1] == 1)) { uint8_t slot_now = data[0]; bool enable = data[1]; @@ -381,17 +380,17 @@ data_frame_tx_t* cmd_processor_set_slot_enable(uint16_t cmd, uint16_t status, ui return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_slot_data_config_save(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_slot_data_config_save(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { tag_emulation_save(); return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); } -data_frame_tx_t* cmd_processor_get_activated_slot(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_activated_slot(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t slot = tag_emulation_get_slot(); return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, &slot); } -data_frame_tx_t* cmd_processor_get_slot_info(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_slot_info(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t slot_info[16] = {}; tag_specific_type_t tag_type[2]; for (uint8_t slot = 0; slot < 8; slot++) { @@ -403,16 +402,16 @@ data_frame_tx_t* cmd_processor_get_slot_info(uint16_t cmd, uint16_t status, uint return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 16, slot_info); } -data_frame_tx_t* cmd_processor_wipe_fds(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_wipe_fds(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { bool success = fds_wipe(); status = success ? STATUS_DEVICE_SUCCESS : STATUS_FLASH_WRITE_FAIL; delayed_reset(50); return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_set_em410x_emu_id(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_em410x_emu_id(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == LF_EM410X_TAG_ID_SIZE) { - tag_data_buffer_t* buffer = get_buffer_by_tag_type(TAG_TYPE_EM410X); + tag_data_buffer_t *buffer = get_buffer_by_tag_type(TAG_TYPE_EM410X); memcpy(buffer->buffer, data, LF_EM410X_TAG_ID_SIZE); tag_emulation_load_by_buffer(TAG_TYPE_EM410X, false); status = STATUS_DEVICE_SUCCESS; @@ -422,15 +421,15 @@ data_frame_tx_t* cmd_processor_set_em410x_emu_id(uint16_t cmd, uint16_t status, return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_get_em410x_emu_id(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { - tag_data_buffer_t* buffer = get_buffer_by_tag_type(TAG_TYPE_EM410X); +data_frame_tx_t *cmd_processor_get_em410x_emu_id(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { + tag_data_buffer_t *buffer = get_buffer_by_tag_type(TAG_TYPE_EM410X); uint8_t responseData[LF_EM410X_TAG_ID_SIZE]; memcpy(responseData, buffer->buffer, LF_EM410X_TAG_ID_SIZE); status = STATUS_DEVICE_SUCCESS; return data_frame_make(cmd, status, LF_EM410X_TAG_ID_SIZE, responseData); } -data_frame_tx_t* cmd_processor_set_mf1_detection_enable(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_mf1_detection_enable(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == 1 && (data[0] == 0 || data[0] == 1)) { nfc_tag_mf1_detection_log_clear(); nfc_tag_mf1_set_detection_enable(data[0]); @@ -441,16 +440,16 @@ data_frame_tx_t* cmd_processor_set_mf1_detection_enable(uint16_t cmd, uint16_t s return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_get_mf1_detection_status(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_mf1_detection_status(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (nfc_tag_mf1_is_detection_enable()) { status = 1; } else { status = 0; } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, (uint8_t*)&status); + return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, (uint8_t *)&status); } -data_frame_tx_t* cmd_processor_get_mf1_detection_count(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_mf1_detection_count(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint32_t count = nfc_tag_mf1_detection_log_count(); if (count == 0xFFFFFFFF) { count = 0; @@ -459,11 +458,11 @@ data_frame_tx_t* cmd_processor_get_mf1_detection_count(uint16_t cmd, uint16_t st return data_frame_make(cmd, status, sizeof(uint32_t), (uint8_t *)&count); } -data_frame_tx_t* cmd_processor_get_mf1_detection_log(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_mf1_detection_log(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint32_t count; uint32_t index; uint8_t *resp = NULL; - nfc_tag_mf1_auth_log_t* logs = get_mf1_auth_log(&count); + nfc_tag_mf1_auth_log_t *logs = get_mf1_auth_log(&count); if (length == 4) { if (count == 0xFFFFFFFF) { length = 0; @@ -488,14 +487,14 @@ data_frame_tx_t* cmd_processor_get_mf1_detection_log(uint16_t cmd, uint16_t stat return data_frame_make(cmd, status, length, resp); } -data_frame_tx_t* cmd_processor_set_mf1_emulator_block(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_mf1_emulator_block(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length > 0 && (((length - 1) % NFC_TAG_MF1_DATA_SIZE) == 0)) { uint8_t block_index = data[0]; uint8_t block_count = (length - 1) / NFC_TAG_MF1_DATA_SIZE; if (block_index + block_count > NFC_TAG_MF1_BLOCK_MAX) { status = STATUS_PAR_ERR; } else { - tag_data_buffer_t* buffer = get_buffer_by_tag_type(TAG_TYPE_MIFARE_4096); + tag_data_buffer_t *buffer = get_buffer_by_tag_type(TAG_TYPE_MIFARE_4096); nfc_tag_mf1_information_t *info = (nfc_tag_mf1_information_t *)buffer->buffer; for (int i = 1, j = block_index; i < length; i += NFC_TAG_MF1_DATA_SIZE, j++) { uint8_t *p_block = &data[i]; @@ -509,15 +508,14 @@ data_frame_tx_t* cmd_processor_set_mf1_emulator_block(uint16_t cmd, uint16_t sta return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_get_mf1_emulator_block(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_mf1_emulator_block(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == 3) { uint8_t block_index = data[0]; uint16_t block_count = data[1] | (data[2] << 8); if (block_count == 0 || block_index + block_count > NFC_TAG_MF1_BLOCK_MAX) { status = STATUS_PAR_ERR; - } - else { - tag_data_buffer_t* buffer = get_buffer_by_tag_type(TAG_TYPE_MIFARE_4096); + } else { + tag_data_buffer_t *buffer = get_buffer_by_tag_type(TAG_TYPE_MIFARE_4096); nfc_tag_mf1_information_t *info = (nfc_tag_mf1_information_t *)buffer->buffer; uint16_t result_length = block_count * NFC_TAG_MF1_DATA_SIZE; uint8_t result_buffer[result_length]; @@ -528,22 +526,21 @@ data_frame_tx_t* cmd_processor_get_mf1_emulator_block(uint16_t cmd, uint16_t sta return data_frame_make(cmd, status, result_length, result_buffer); } - } - else { + } else { status = STATUS_PAR_ERR; } return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_set_mf1_anti_collision_res(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_mf1_anti_collision_res(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length > 13) { // sak(1) + atqa(2) + uid(10) status = STATUS_PAR_ERR; } else { uint8_t uid_length = length - 3; if (is_valid_uid_size(uid_length)) { - nfc_tag_14a_coll_res_referen_t* info = get_mifare_coll_res(); + nfc_tag_14a_coll_res_referen_t *info = get_mifare_coll_res(); // copy sak info->sak[0] = data[0]; // copy atqa @@ -560,7 +557,7 @@ data_frame_tx_t* cmd_processor_set_mf1_anti_collision_res(uint16_t cmd, uint16_t return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_set_slot_tag_nick_name(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_slot_tag_nick_name(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length > 34 || length < 3) { status = STATUS_PAR_ERR; } else { @@ -584,7 +581,7 @@ data_frame_tx_t* cmd_processor_set_slot_tag_nick_name(uint16_t cmd, uint16_t sta return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_get_slot_tag_nick_name(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_slot_tag_nick_name(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length != 2) { status = STATUS_PAR_ERR; } else { @@ -608,7 +605,7 @@ data_frame_tx_t* cmd_processor_get_slot_tag_nick_name(uint16_t cmd, uint16_t sta return data_frame_make(cmd, status, length, data); } -data_frame_tx_t* cmd_processor_get_mf1_info(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_mf1_info(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t mf1_info[5] = {}; mf1_info[0] = nfc_tag_mf1_is_detection_enable(); mf1_info[1] = nfc_tag_mf1_is_gen1a_magic_mode(); @@ -627,16 +624,16 @@ data_frame_tx_t* cmd_processor_get_mf1_info(uint16_t cmd, uint16_t status, uint1 return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 5, mf1_info); } -data_frame_tx_t* cmd_processor_get_mf1_gen1a_magic_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_mf1_gen1a_magic_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (nfc_tag_mf1_is_gen1a_magic_mode()) { status = 1; } else { status = 0; } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, (uint8_t*)&status); + return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, (uint8_t *)&status); } -data_frame_tx_t* cmd_processor_set_mf1_gen1a_magic_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_mf1_gen1a_magic_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == 1 && (data[0] == 0 || data[0] == 1)) { nfc_tag_mf1_set_gen1a_magic_mode(data[0]); status = STATUS_DEVICE_SUCCESS; @@ -646,16 +643,16 @@ data_frame_tx_t* cmd_processor_set_mf1_gen1a_magic_mode(uint16_t cmd, uint16_t s return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_get_mf1_gen2_magic_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_mf1_gen2_magic_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (nfc_tag_mf1_is_gen2_magic_mode()) { status = 1; } else { status = 0; } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, (uint8_t*)&status); + return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, (uint8_t *)&status); } -data_frame_tx_t* cmd_processor_set_mf1_gen2_magic_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_mf1_gen2_magic_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == 1 && (data[0] == 0 || data[0] == 1)) { nfc_tag_mf1_set_gen2_magic_mode(data[0]); status = STATUS_DEVICE_SUCCESS; @@ -665,16 +662,16 @@ data_frame_tx_t* cmd_processor_set_mf1_gen2_magic_mode(uint16_t cmd, uint16_t st return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_get_mf1_use_coll_res(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_mf1_use_coll_res(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (nfc_tag_mf1_is_use_mf1_coll_res()) { status = 1; } else { status = 0; } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, (uint8_t*)&status); + return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, (uint8_t *)&status); } -data_frame_tx_t* cmd_processor_set_mf1_use_coll_res(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_mf1_use_coll_res(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == 1 && (data[0] == 0 || data[0] == 1)) { nfc_tag_mf1_set_use_mf1_coll_res(data[0]); status = STATUS_DEVICE_SUCCESS; @@ -684,7 +681,7 @@ data_frame_tx_t* cmd_processor_set_mf1_use_coll_res(uint16_t cmd, uint16_t statu return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_get_mf1_write_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_mf1_write_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { nfc_tag_mf1_write_mode_t write_mode = nfc_tag_mf1_get_write_mode(); if (write_mode == NFC_TAG_MF1_WRITE_NORMAL) { status = 0; @@ -695,10 +692,10 @@ data_frame_tx_t* cmd_processor_get_mf1_write_mode(uint16_t cmd, uint16_t status, } else if (write_mode == NFC_TAG_MF1_WRITE_SHADOW) { status = 3; } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, (uint8_t*)&status); + return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, (uint8_t *)&status); } -data_frame_tx_t* cmd_processor_set_mf1_write_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_set_mf1_write_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { if (length == 1 && (data[0] >= 0 || data[0] <= 3)) { uint8_t mode = data[0]; if (mode == 0) { @@ -717,7 +714,7 @@ data_frame_tx_t* cmd_processor_set_mf1_write_mode(uint16_t cmd, uint16_t status, return data_frame_make(cmd, status, 0, NULL); } -data_frame_tx_t* cmd_processor_get_enabled_slots(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *cmd_processor_get_enabled_slots(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t slot_info[8] = {}; for (uint8_t slot = 0; slot < 8; slot++) { slot_info[slot] = tag_emulation_slot_is_enable(slot); @@ -733,7 +730,7 @@ data_frame_tx_t* cmd_processor_get_enabled_slots(uint16_t cmd, uint16_t status, * before reader run, reset reader and on antenna, * we must to wait some time, to init picc(power). */ -data_frame_tx_t* before_reader_run(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *before_reader_run(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { device_mode_t mode = get_device_mode(); if (mode == DEVICE_MODE_READER) { return NULL; @@ -747,8 +744,8 @@ data_frame_tx_t* before_reader_run(uint16_t cmd, uint16_t status, uint16_t lengt * before reader run, reset reader and on antenna, * we must to wait some time, to init picc(power). */ -data_frame_tx_t* before_hf_reader_run(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { - data_frame_tx_t* ret = before_reader_run(cmd, status, length, data); +data_frame_tx_t *before_hf_reader_run(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { + data_frame_tx_t *ret = before_reader_run(cmd, status, length, data); if (ret == NULL) { pcd_14a_reader_reset(); pcd_14a_reader_antenna_on(); @@ -760,7 +757,7 @@ data_frame_tx_t* before_hf_reader_run(uint16_t cmd, uint16_t status, uint16_t le /** * after reader run, off antenna, to keep battery. */ -data_frame_tx_t* after_hf_reader_run(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *after_hf_reader_run(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { pcd_14a_reader_antenna_off(); return NULL; } @@ -850,7 +847,7 @@ static cmd_data_map_t m_data_cmd_map[] = { * * @param resp data */ -void auto_response_data(data_frame_tx_t* resp) { +void auto_response_data(data_frame_tx_t *resp) { // TODO Please select the reply source automatically according to the message source, // and do not reply by checking the validity of the link layer by layer if (is_usb_working()) { @@ -866,7 +863,7 @@ void auto_response_data(data_frame_tx_t* resp) { /**@brief Function for prcoess data frame(cmd) */ void on_data_frame_received(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { - data_frame_tx_t* response = NULL; + data_frame_tx_t *response = NULL; bool is_cmd_support = false; // print info NRF_LOG_INFO("Data frame: cmd = %02x, status = %02x, length = %d", cmd, status, length); @@ -875,7 +872,7 @@ void on_data_frame_received(uint16_t cmd, uint16_t status, uint16_t length, uint if (m_data_cmd_map[i].cmd == cmd) { is_cmd_support = true; if (m_data_cmd_map[i].cmd_before != NULL) { - data_frame_tx_t* before_resp = m_data_cmd_map[i].cmd_before(cmd, status, length, data); + data_frame_tx_t *before_resp = m_data_cmd_map[i].cmd_before(cmd, status, length, data); if (before_resp != NULL) { // some problem found before run cmd. response = before_resp; @@ -884,7 +881,7 @@ void on_data_frame_received(uint16_t cmd, uint16_t status, uint16_t length, uint } if (m_data_cmd_map[i].cmd_processor != NULL) response = m_data_cmd_map[i].cmd_processor(cmd, status, length, data); if (m_data_cmd_map[i].cmd_after != NULL) { - data_frame_tx_t* after_resp = m_data_cmd_map[i].cmd_after(cmd, status, length, data); + data_frame_tx_t *after_resp = m_data_cmd_map[i].cmd_after(cmd, status, length, data); if (after_resp != NULL) { // some problem found after run cmd. response = after_resp; diff --git a/firmware/application/src/app_cmd.h b/firmware/application/src/app_cmd.h index a192db8..538c069 100644 --- a/firmware/application/src/app_cmd.h +++ b/firmware/application/src/app_cmd.h @@ -5,7 +5,7 @@ #include "dataframe.h" -typedef data_frame_tx_t* (*cmd_processor)(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data); +typedef data_frame_tx_t *(*cmd_processor)(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data); typedef struct { uint16_t cmd; diff --git a/firmware/application/src/app_main.c b/firmware/application/src/app_main.c index 1e6485e..8988c4a 100644 --- a/firmware/application/src/app_main.c +++ b/firmware/application/src/app_main.c @@ -201,11 +201,11 @@ static void system_off_enter(void) { // Configure RAM hibernation hold uint32_t ram8_retention = // RAM8 Each section has 32KB capacity - // POWER_RAM_POWER_S0RETENTION_On << POWER_RAM_POWER_S0RETENTION_Pos ; - // POWER_RAM_POWER_S1RETENTION_On << POWER_RAM_POWER_S1RETENTION_Pos | - // POWER_RAM_POWER_S2RETENTION_On << POWER_RAM_POWER_S2RETENTION_Pos | - // POWER_RAM_POWER_S3RETENTION_On << POWER_RAM_POWER_S3RETENTION_Pos | - // POWER_RAM_POWER_S4RETENTION_On << POWER_RAM_POWER_S4RETENTION_Pos | + // POWER_RAM_POWER_S0RETENTION_On << POWER_RAM_POWER_S0RETENTION_Pos ; + // POWER_RAM_POWER_S1RETENTION_On << POWER_RAM_POWER_S1RETENTION_Pos | + // POWER_RAM_POWER_S2RETENTION_On << POWER_RAM_POWER_S2RETENTION_Pos | + // POWER_RAM_POWER_S3RETENTION_On << POWER_RAM_POWER_S3RETENTION_Pos | + // POWER_RAM_POWER_S4RETENTION_On << POWER_RAM_POWER_S4RETENTION_Pos | POWER_RAM_POWER_S5RETENTION_On << POWER_RAM_POWER_S5RETENTION_Pos; ret = sd_power_ram_power_set(8, ram8_retention); APP_ERROR_CHECK(ret); @@ -222,7 +222,7 @@ static void system_off_enter(void) { } } else { // close all led. - uint32_t* p_led_array = hw_get_led_array(); + uint32_t *p_led_array = hw_get_led_array(); for (uint8_t i = 0; i < RGB_LIST_NUM; i++) { nrf_gpio_pin_clear(p_led_array[i]); } @@ -296,7 +296,7 @@ static void system_off_enter(void) { app_timer_stop_all(); // 检查是否存在低频场，解决休眠时有非常强的场信号一直使比较器处于高电平输入状态从而无法产生上升沿而无法唤醒系统的问题。 - if(lf_is_field_exists()) { + if (lf_is_field_exists()) { // 关闭比较器 nrf_drv_lpcomp_disable(); // 设置reset原因，重启后需要拿到此原因，避免误判唤醒源 @@ -357,8 +357,7 @@ static void check_wakeup_src(void) { // Button wake-up boot animation uint8_t animation_config = settings_get_animation_config(); - if (animation_config == SettingsAnimationModeFull) - { + if (animation_config == SettingsAnimationModeFull) { ledblink2(color, !dir, 11); ledblink2(color, dir, 11); ledblink2(color, !dir, dir ? slot : 7 - slot); @@ -476,12 +475,12 @@ static void offline_status_blink_color(uint8_t blink_color) { uint8_t color = get_color_by_slot(slot); - uint32_t* p_led_array = hw_get_led_array(); + uint32_t *p_led_array = hw_get_led_array(); set_slot_light_color(blink_color); for (uint8_t i = 0; i < RGB_LIST_NUM; i++) { - if(i == slot) { + if (i == slot) { continue; } nrf_gpio_pin_set(p_led_array[i]); @@ -508,7 +507,7 @@ static void btn_fn_copy_ic_uid(void) { tag_specific_type_t tag_type[2]; tag_emulation_get_specific_type_by_slot(slot_now, tag_type); - nfc_tag_14a_coll_res_entity_t* antres; + nfc_tag_14a_coll_res_entity_t *antres; bool is_reader_mode_now = get_device_mode() == DEVICE_MODE_READER; // first, we need switch to reader mode. @@ -519,14 +518,14 @@ static void btn_fn_copy_ic_uid(void) { NRF_LOG_INFO("Start reader mode to offline copy.") } - switch(tag_type[1]) { + switch (tag_type[1]) { case TAG_TYPE_EM410X: uint8_t status; uint8_t id_buffer[5] = { 0x00 }; status = PcdScanEM410X(id_buffer); - if(status == LF_TAG_OK) { - tag_data_buffer_t* buffer = get_buffer_by_tag_type(TAG_TYPE_EM410X); + if (status == LF_TAG_OK) { + tag_data_buffer_t *buffer = get_buffer_by_tag_type(TAG_TYPE_EM410X); memcpy(buffer->buffer, id_buffer, LF_EM410X_TAG_ID_SIZE); tag_emulation_load_by_buffer(TAG_TYPE_EM410X, false); NRF_LOG_INFO("Offline LF uid copied") @@ -546,8 +545,8 @@ static void btn_fn_copy_ic_uid(void) { offline_status_error(); } - tag_data_buffer_t* buffer = get_buffer_by_tag_type(tag_type[0]); - switch(tag_type[0]) { + tag_data_buffer_t *buffer = get_buffer_by_tag_type(tag_type[0]); + switch (tag_type[0]) { case TAG_TYPE_MIFARE_Mini: case TAG_TYPE_MIFARE_1024: case TAG_TYPE_MIFARE_2048: @@ -611,24 +610,23 @@ exit: /**@brief Execute the corresponding logic based on the functional settings of the buttons. */ static void run_button_function_by_settings(settings_button_function_t sbf) { - switch (sbf) - { - case SettingsButtonCycleSlot: - cycle_slot(false); - break; - case SettingsButtonCycleSlotDec: - cycle_slot(true); - break; + switch (sbf) { + case SettingsButtonCycleSlot: + cycle_slot(false); + break; + case SettingsButtonCycleSlotDec: + cycle_slot(true); + break; #if defined(PROJECT_CHAMELEON_ULTRA) - case SettingsButtonCloneIcUid: - btn_fn_copy_ic_uid(); - break; + case SettingsButtonCloneIcUid: + btn_fn_copy_ic_uid(); + break; #endif - default: - NRF_LOG_ERROR("Unsupported button function") - break; + default: + NRF_LOG_ERROR("Unsupported button function") + break; } } diff --git a/firmware/application/src/ble_main.c b/firmware/application/src/ble_main.c index acb74e3..a5abea5 100644 --- a/firmware/application/src/ble_main.c +++ b/firmware/application/src/ble_main.c @@ -83,8 +83,7 @@ volatile bool g_is_low_battery_shutdown = false; * @details This function will set up all the necessary GAP (Generic Access Profile) parameters of * the device. It also sets the permissions and appearance. */ -static void gap_params_init(void) -{ +static void gap_params_init(void) { uint32_t err_code; ble_gap_conn_params_t gap_conn_params; ble_gap_conn_sec_mode_t sec_mode; @@ -113,10 +112,8 @@ static void gap_params_init(void) * @param[in] p_bas Battery Service structure. * @param[in] p_evt Event received from the Battery Service. */ -static void on_bas_evt(ble_bas_t * p_bas, ble_bas_evt_t * p_evt) -{ - switch (p_evt->evt_type) - { +static void on_bas_evt(ble_bas_t *p_bas, ble_bas_evt_t *p_evt) { + switch (p_evt->evt_type) { case BLE_BAS_EVT_NOTIFICATION_ENABLED: break; // BLE_BAS_EVT_NOTIFICATION_ENABLED @@ -136,13 +133,11 @@ static void on_bas_evt(ble_bas_t * p_bas, ble_bas_evt_t * p_evt) * @param[in] p_evt Nordic UART Service event. */ /**@snippet [Handling the data received over BLE] */ -static void nus_data_handler(ble_nus_evt_t * p_evt) -{ - if (p_evt->type == BLE_NUS_EVT_RX_DATA) - { +static void nus_data_handler(ble_nus_evt_t *p_evt) { + if (p_evt->type == BLE_NUS_EVT_RX_DATA) { NRF_LOG_DEBUG("Received data from BLE NUS."); NRF_LOG_HEXDUMP_DEBUG(p_evt->params.rx_data.p_data, p_evt->params.rx_data.length); - data_frame_receive((uint8_t*)(p_evt->params.rx_data.p_data), p_evt->params.rx_data.length); + data_frame_receive((uint8_t *)(p_evt->params.rx_data.p_data), p_evt->params.rx_data.length); } } /**@snippet [Handling the data received over BLE] */ @@ -167,8 +162,8 @@ void nus_data_reponse(uint8_t *p_data, uint16_t length) { continue; } if ((err_code != NRF_ERROR_INVALID_STATE) && - (err_code != NRF_ERROR_RESOURCES) && - (err_code != NRF_ERROR_NOT_FOUND)) { + (err_code != NRF_ERROR_RESOURCES) && + (err_code != NRF_ERROR_NOT_FOUND)) { APP_ERROR_CHECK(err_code); } @@ -186,19 +181,16 @@ bool is_nus_working(void) { * * @param[in] nrf_error Error code containing information about what went wrong. */ -static void nrf_qwr_error_handler(uint32_t nrf_error) -{ +static void nrf_qwr_error_handler(uint32_t nrf_error) { APP_ERROR_HANDLER(nrf_error); } -__INLINE uint32_t map(uint32_t x, uint32_t in_min, uint32_t in_max, uint32_t out_min, uint32_t out_max) -{ +__INLINE uint32_t map(uint32_t x, uint32_t in_min, uint32_t in_max, uint32_t out_min, uint32_t out_max) { return (uint32_t)((x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min); } //电池电压到百分比计算 -uint32_t BATVOL2PERCENT(uint16_t VOL) -{ +uint32_t BATVOL2PERCENT(uint16_t VOL) { //100% 4.20V 1 //90 % 4.06V 80%-100% 白 //80 % 3.98V 1 @@ -238,33 +230,22 @@ uint32_t BATVOL2PERCENT(uint16_t VOL) #define P5VOL 3230 - if(VOL > P80VOL) - { + if (VOL > P80VOL) { //80-100 return map(VOL, P80VOL, P100VOL, 80, 100); - } - else if(VOL > P60VOL) - { + } else if (VOL > P60VOL) { //60-80 return map(VOL, P60VOL, P80VOL, 60, 80); - } - else if(VOL > P40VOL) - { + } else if (VOL > P40VOL) { //40-60 return map(VOL, P40VOL, P60VOL, 40, 60); - } - else if(VOL > P20VOL) - { + } else if (VOL > P20VOL) { //20-60 return map(VOL, P20VOL, P40VOL, 20, 40); - } - else if(VOL > P5VOL) - { + } else if (VOL > P5VOL) { //5-20 return map(VOL, P5VOL, P20VOL, 5, 20); - } - else - { + } else { //<5 return 0; } @@ -272,8 +253,7 @@ uint32_t BATVOL2PERCENT(uint16_t VOL) /**@brief Function for initializing services that will be used by the application. */ -static void services_init(void) -{ +static void services_init(void) { uint32_t err_code; // ------------------------------------------------------------- @@ -326,12 +306,10 @@ static void services_init(void) * * @param[in] p_evt Event received from the Connection Parameters Module. */ -static void on_conn_params_evt(ble_conn_params_evt_t * p_evt) -{ +static void on_conn_params_evt(ble_conn_params_evt_t *p_evt) { uint32_t err_code; - if (p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED) - { + if (p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED) { err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE); APP_ERROR_CHECK(err_code); } @@ -341,15 +319,13 @@ static void on_conn_params_evt(ble_conn_params_evt_t * p_evt) * * @param[in] nrf_error Error code containing information about what went wrong. */ -static void conn_params_error_handler(uint32_t nrf_error) -{ +static void conn_params_error_handler(uint32_t nrf_error) { APP_ERROR_HANDLER(nrf_error); } /**@brief Function for initializing the Connection Parameters module. */ -static void conn_params_init(void) -{ +static void conn_params_init(void) { uint32_t err_code; ble_conn_params_init_t cp_init; @@ -374,10 +350,8 @@ static void conn_params_init(void) * * @param[in] ble_adv_evt Advertising event. */ -static void on_adv_evt(ble_adv_evt_t ble_adv_evt) -{ - switch (ble_adv_evt) - { +static void on_adv_evt(ble_adv_evt_t ble_adv_evt) { + switch (ble_adv_evt) { case BLE_ADV_EVT_FAST: NRF_LOG_INFO("BLE_ADV_EVT_FAST"); break; @@ -394,12 +368,10 @@ static void on_adv_evt(ble_adv_evt_t ble_adv_evt) * @param[in] p_ble_evt Bluetooth stack event. * @param[in] p_context Unused. */ -static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context) -{ +static void ble_evt_handler(ble_evt_t const *p_ble_evt, void *p_context) { ret_code_t err_code; - switch (p_ble_evt->header.evt_id) - { + switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: sleep_timer_stop(); @@ -419,17 +391,16 @@ static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context) sleep_timer_start(SLEEP_DELAY_MS_BLE_DISCONNECTED); break; - case BLE_GAP_EVT_PHY_UPDATE_REQUEST: - { + case BLE_GAP_EVT_PHY_UPDATE_REQUEST: { NRF_LOG_DEBUG("PHY update request."); - ble_gap_phys_t const phys = - { + ble_gap_phys_t const phys = { .rx_phys = BLE_GAP_PHY_AUTO, .tx_phys = BLE_GAP_PHY_AUTO, }; err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys); APP_ERROR_CHECK(err_code); - } break; + } + break; case BLE_GAP_EVT_SEC_PARAMS_REQUEST: // Pairing not supported @@ -469,8 +440,7 @@ static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context) * * @details This function initializes the SoftDevice and the BLE event interrupt. */ -static void ble_stack_init(void) -{ +static void ble_stack_init(void) { ret_code_t err_code; err_code = nrf_sdh_enable_request(); @@ -492,10 +462,8 @@ static void ble_stack_init(void) /**@brief Function for handling events from the GATT library. */ -void gatt_evt_handler(nrf_ble_gatt_t * p_gatt, nrf_ble_gatt_evt_t const * p_evt) -{ - if ((m_conn_handle == p_evt->conn_handle) && (p_evt->evt_id == NRF_BLE_GATT_EVT_ATT_MTU_UPDATED)) - { +void gatt_evt_handler(nrf_ble_gatt_t *p_gatt, nrf_ble_gatt_evt_t const *p_evt) { + if ((m_conn_handle == p_evt->conn_handle) && (p_evt->evt_id == NRF_BLE_GATT_EVT_ATT_MTU_UPDATED)) { m_ble_nus_max_data_len = p_evt->params.att_mtu_effective - OPCODE_LENGTH - HANDLE_LENGTH; NRF_LOG_INFO("Data len is set to 0x%X(%d)", m_ble_nus_max_data_len, m_ble_nus_max_data_len); } @@ -506,8 +474,7 @@ void gatt_evt_handler(nrf_ble_gatt_t * p_gatt, nrf_ble_gatt_evt_t const * p_evt) /**@brief Function for initializing the GATT library. */ -void gatt_init(void) -{ +void gatt_init(void) { ret_code_t err_code; err_code = nrf_ble_gatt_init(&m_gatt, gatt_evt_handler); @@ -520,8 +487,7 @@ void gatt_init(void) /**@brief Function for initializing the Advertising functionality. */ -static void advertising_init(void) -{ +static void advertising_init(void) { uint32_t err_code; ble_advertising_init_t init; @@ -548,8 +514,7 @@ static void advertising_init(void) /** * @brief Function for starting advertising. */ -void advertising_start(void) -{ +void advertising_start(void) { uint32_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST); APP_ERROR_CHECK(err_code); } @@ -561,10 +526,8 @@ void advertising_start(void) * @details This function will fetch the conversion result from the ADC, convert the value into * percentage and send it to peer. */ -void saadc_event_handler(nrf_drv_saadc_evt_t const * p_event) -{ - if (p_event->type == NRF_DRV_SAADC_EVT_DONE) - { +void saadc_event_handler(nrf_drv_saadc_evt_t const *p_event) { + if (p_event->type == NRF_DRV_SAADC_EVT_DONE) { nrf_saadc_value_t adc_result; uint32_t err_code; @@ -581,12 +544,11 @@ void saadc_event_handler(nrf_drv_saadc_evt_t const * p_event) // if battery service is notification enable, we can send msg to device. err_code = ble_bas_battery_level_update(&m_bas, percentage_batt_lvl, BLE_CONN_HANDLE_ALL); if ((err_code != NRF_SUCCESS) && - (err_code != NRF_ERROR_INVALID_STATE) && - (err_code != NRF_ERROR_RESOURCES) && - (err_code != NRF_ERROR_BUSY) && - (err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING) - ) - { + (err_code != NRF_ERROR_INVALID_STATE) && + (err_code != NRF_ERROR_RESOURCES) && + (err_code != NRF_ERROR_BUSY) && + (err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING) + ) { APP_ERROR_HANDLER(err_code); } @@ -603,8 +565,7 @@ void saadc_event_handler(nrf_drv_saadc_evt_t const * p_event) /**@brief Function for configuring ADC to do battery level conversion. */ -static void adc_configure(void) -{ +static void adc_configure(void) { ret_code_t err_code = nrf_drv_saadc_init(NULL, saadc_event_handler); APP_ERROR_CHECK(err_code); @@ -627,8 +588,7 @@ static void adc_configure(void) * @param[in] p_context Pointer used for passing some arbitrary information (context) from the * app_start_timer() call to the timeout handler. */ -static void battery_level_meas_timeout_handler(void * p_context) -{ +static void battery_level_meas_timeout_handler(void *p_context) { UNUSED_PARAMETER(p_context); ret_code_t err_code; diff --git a/firmware/application/src/bsp/bsp_delay.c b/firmware/application/src/bsp/bsp_delay.c index 9ef1555..759fb19 100644 --- a/firmware/application/src/bsp/bsp_delay.c +++ b/firmware/application/src/bsp/bsp_delay.c @@ -4,20 +4,17 @@ //初始化延迟函数 -void bsp_delay_init(void) -{ +void bsp_delay_init(void) { } //延时nms //注意nms的范围 -void bsp_delay_ms(uint16_t nms) -{ +void bsp_delay_ms(uint16_t nms) { nrf_delay_us(nms * 1000); } //延时nus //nus为要延时的us数. -void bsp_delay_us(uint32_t nus) -{ +void bsp_delay_us(uint32_t nus) { nrf_delay_us(nus); } diff --git a/firmware/application/src/bsp/bsp_delay.h b/firmware/application/src/bsp/bsp_delay.h index 530ce51..d6aa307 100644 --- a/firmware/application/src/bsp/bsp_delay.h +++ b/firmware/application/src/bsp/bsp_delay.h @@ -4,7 +4,7 @@ #include "stdint.h" #ifdef __cplusplus - extern "C" { +extern "C" { #endif void bsp_delay_init(void); diff --git a/firmware/application/src/bsp/bsp_time.c b/firmware/application/src/bsp/bsp_time.c index 67da339..d701147 100644 --- a/firmware/application/src/bsp/bsp_time.c +++ b/firmware/application/src/bsp/bsp_time.c @@ -25,7 +25,7 @@ static volatile enum { * 1、会自动跑滴答 * 2、是空闲的 */ -autotimer* bsp_obtain_timer(uint32_t start_value) { +autotimer *bsp_obtain_timer(uint32_t start_value) { uint8_t i; for (i = 0; i < TIMER_BSP_COUNT; i++) { if (bsptimers[i].busy == 0) { @@ -40,8 +40,8 @@ autotimer* bsp_obtain_timer(uint32_t start_value) { /* * 设置定时器，该操作会操作目标定时器，修改当前值 */ -inline uint8_t bsp_set_timer(autotimer* timer,uint32_t start_value) { - if(timer->busy == 0) return 0; +inline uint8_t bsp_set_timer(autotimer *timer, uint32_t start_value) { + if (timer->busy == 0) return 0; timer->time = start_value; return 1; } @@ -50,7 +50,7 @@ inline uint8_t bsp_set_timer(autotimer* timer,uint32_t start_value) { * 归还定时器，该操作会自动释放定时器 * 并且对定时器归零 */ -inline void bsp_return_timer(autotimer* timer) { +inline void bsp_return_timer(autotimer *timer) { timer->busy = 0; timer->time = 0; } @@ -59,8 +59,7 @@ inline void bsp_return_timer(autotimer* timer) { * @param arg 回调参数 * @return 无 */ -void timer_app_callback(void *arg) -{ +void timer_app_callback(void *arg) { UNUSED_PARAMETER(arg); for (g_timer_fori = 0; g_timer_fori < TIMER_BSP_COUNT; g_timer_fori++) { if (bsptimers[g_timer_fori].busy == 1) { diff --git a/firmware/application/src/bsp/bsp_time.h b/firmware/application/src/bsp/bsp_time.h index 01d664a..d2a7101 100644 --- a/firmware/application/src/bsp/bsp_time.h +++ b/firmware/application/src/bsp/bsp_time.h @@ -27,9 +27,9 @@ void bsp_timer_uninit(void); void bsp_timer_start(void); void bsp_timer_stop(void); -void bsp_return_timer(autotimer* timer); -autotimer* bsp_obtain_timer(uint32_t start_value); -uint8_t bsp_set_timer(autotimer* timer,uint32_t start_value); +void bsp_return_timer(autotimer *timer); +autotimer *bsp_obtain_timer(uint32_t start_value); +uint8_t bsp_set_timer(autotimer *timer, uint32_t start_value); #endif diff --git a/firmware/application/src/bsp/bsp_wdt.c b/firmware/application/src/bsp/bsp_wdt.c index 5405bf2..8db0a23 100644 --- a/firmware/application/src/bsp/bsp_wdt.c +++ b/firmware/application/src/bsp/bsp_wdt.c @@ -4,10 +4,9 @@ static nrf_drv_wdt_channel_id m_channel_id; -static void wdt_event_handler(void) -{ +static void wdt_event_handler(void) { //NOTE: The max amount of time we can spend in WDT interrupt is two cycles of 32768[Hz] clock - after that, reset occurs - uint32_t* p_led_array = hw_get_led_array(); + uint32_t *p_led_array = hw_get_led_array(); for (uint8_t i = 0; i < RGB_LIST_NUM; i++) { nrf_gpio_pin_clear(p_led_array[i]); } diff --git a/firmware/application/src/bsp/bsp_wdt.h b/firmware/application/src/bsp/bsp_wdt.h index 0b19764..c51efb6 100644 --- a/firmware/application/src/bsp/bsp_wdt.h +++ b/firmware/application/src/bsp/bsp_wdt.h @@ -2,7 +2,7 @@ #define __BSP_WDT_H__ #ifdef __cplusplus - extern "C" { +extern "C" { #endif void bsp_wdt_init(void); diff --git a/firmware/application/src/rfid/crc_utils.c b/firmware/application/src/rfid/crc_utils.c index 33e9f33..6cc3f48 100644 --- a/firmware/application/src/rfid/crc_utils.c +++ b/firmware/application/src/rfid/crc_utils.c @@ -2,38 +2,38 @@ // CRC查表 static uint16_t crc_table[256] = { - 0x0000,0x1189,0x2312,0x329B,0x4624,0x57AD,0x6536,0x74BF, - 0x8C48,0x9DC1,0xAF5A,0xBED3,0xCA6C,0xDBE5,0xE97E,0xF8F7, - 0x1081,0x0108,0x3393,0x221A,0x56A5,0x472C,0x75B7,0x643E, - 0x9CC9,0x8D40,0xBFDB,0xAE52,0xDAED,0xCB64,0xF9FF,0xE876, - 0x2102,0x308B,0x0210,0x1399,0x6726,0x76AF,0x4434,0x55BD, - 0xAD4A,0xBCC3,0x8E58,0x9FD1,0xEB6E,0xFAE7,0xC87C,0xD9F5, - 0x3183,0x200A,0x1291,0x0318,0x77A7,0x662E,0x54B5,0x453C, - 0xBDCB,0xAC42,0x9ED9,0x8F50,0xFBEF,0xEA66,0xD8FD,0xC974, - 0x4204,0x538D,0x6116,0x709F,0x0420,0x15A9,0x2732,0x36BB, - 0xCE4C,0xDFC5,0xED5E,0xFCD7,0x8868,0x99E1,0xAB7A,0xBAF3, - 0x5285,0x430C,0x7197,0x601E,0x14A1,0x0528,0x37B3,0x263A, - 0xDECD,0xCF44,0xFDDF,0xEC56,0x98E9,0x8960,0xBBFB,0xAA72, - 0x6306,0x728F,0x4014,0x519D,0x2522,0x34AB,0x0630,0x17B9, - 0xEF4E,0xFEC7,0xCC5C,0xDDD5,0xA96A,0xB8E3,0x8A78,0x9BF1, - 0x7387,0x620E,0x5095,0x411C,0x35A3,0x242A,0x16B1,0x0738, - 0xFFCF,0xEE46,0xDCDD,0xCD54,0xB9EB,0xA862,0x9AF9,0x8B70, - 0x8408,0x9581,0xA71A,0xB693,0xC22C,0xD3A5,0xE13E,0xF0B7, - 0x0840,0x19C9,0x2B52,0x3ADB,0x4E64,0x5FED,0x6D76,0x7CFF, - 0x9489,0x8500,0xB79B,0xA612,0xD2AD,0xC324,0xF1BF,0xE036, - 0x18C1,0x0948,0x3BD3,0x2A5A,0x5EE5,0x4F6C,0x7DF7,0x6C7E, - 0xA50A,0xB483,0x8618,0x9791,0xE32E,0xF2A7,0xC03C,0xD1B5, - 0x2942,0x38CB,0x0A50,0x1BD9,0x6F66,0x7EEF,0x4C74,0x5DFD, - 0xB58B,0xA402,0x9699,0x8710,0xF3AF,0xE226,0xD0BD,0xC134, - 0x39C3,0x284A,0x1AD1,0x0B58,0x7FE7,0x6E6E,0x5CF5,0x4D7C, - 0xC60C,0xD785,0xE51E,0xF497,0x8028,0x91A1,0xA33A,0xB2B3, - 0x4A44,0x5BCD,0x6956,0x78DF,0x0C60,0x1DE9,0x2F72,0x3EFB, - 0xD68D,0xC704,0xF59F,0xE416,0x90A9,0x8120,0xB3BB,0xA232, - 0x5AC5,0x4B4C,0x79D7,0x685E,0x1CE1,0x0D68,0x3FF3,0x2E7A, - 0xE70E,0xF687,0xC41C,0xD595,0xA12A,0xB0A3,0x8238,0x93B1, - 0x6B46,0x7ACF,0x4854,0x59DD,0x2D62,0x3CEB,0x0E70,0x1FF9, - 0xF78F,0xE606,0xD49D,0xC514,0xB1AB,0xA022,0x92B9,0x8330, - 0x7BC7,0x6A4E,0x58D5,0x495C,0x3DE3,0x2C6A,0x1EF1,0x0F78, + 0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF, + 0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7, + 0x1081, 0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E, + 0x9CC9, 0x8D40, 0xBFDB, 0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876, + 0x2102, 0x308B, 0x0210, 0x1399, 0x6726, 0x76AF, 0x4434, 0x55BD, + 0xAD4A, 0xBCC3, 0x8E58, 0x9FD1, 0xEB6E, 0xFAE7, 0xC87C, 0xD9F5, + 0x3183, 0x200A, 0x1291, 0x0318, 0x77A7, 0x662E, 0x54B5, 0x453C, + 0xBDCB, 0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD, 0xC974, + 0x4204, 0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB, + 0xCE4C, 0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3, + 0x5285, 0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A, + 0xDECD, 0xCF44, 0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72, + 0x6306, 0x728F, 0x4014, 0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9, + 0xEF4E, 0xFEC7, 0xCC5C, 0xDDD5, 0xA96A, 0xB8E3, 0x8A78, 0x9BF1, + 0x7387, 0x620E, 0x5095, 0x411C, 0x35A3, 0x242A, 0x16B1, 0x0738, + 0xFFCF, 0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862, 0x9AF9, 0x8B70, + 0x8408, 0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E, 0xF0B7, + 0x0840, 0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF, + 0x9489, 0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036, + 0x18C1, 0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E, + 0xA50A, 0xB483, 0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5, + 0x2942, 0x38CB, 0x0A50, 0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD, + 0xB58B, 0xA402, 0x9699, 0x8710, 0xF3AF, 0xE226, 0xD0BD, 0xC134, + 0x39C3, 0x284A, 0x1AD1, 0x0B58, 0x7FE7, 0x6E6E, 0x5CF5, 0x4D7C, + 0xC60C, 0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1, 0xA33A, 0xB2B3, + 0x4A44, 0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72, 0x3EFB, + 0xD68D, 0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232, + 0x5AC5, 0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A, + 0xE70E, 0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1, + 0x6B46, 0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9, + 0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330, + 0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78, }; @@ -44,7 +44,7 @@ static uint16_t crc_table[256] = { * @param output 输出缓冲区，长度必须是大于等于两个字节 * */ -void calc_14a_crc_lut(uint8_t* data, int length, uint8_t* output) { +void calc_14a_crc_lut(uint8_t *data, int length, uint8_t *output) { // 取巧，强制指针类型转换 uint16_t *crc = (uint16_t *)output; // 赋予多项式初始值 diff --git a/firmware/application/src/rfid/crc_utils.h b/firmware/application/src/rfid/crc_utils.h index faeefee..4c23048 100644 --- a/firmware/application/src/rfid/crc_utils.h +++ b/firmware/application/src/rfid/crc_utils.h @@ -3,6 +3,6 @@ #include -void calc_14a_crc_lut(uint8_t* data, int length, uint8_t* output); +void calc_14a_crc_lut(uint8_t *data, int length, uint8_t *output); #endif diff --git a/firmware/application/src/rfid/hex_utils.c b/firmware/application/src/rfid/hex_utils.c index ad10542..b535368 100644 --- a/firmware/application/src/rfid/hex_utils.c +++ b/firmware/application/src/rfid/hex_utils.c @@ -9,8 +9,7 @@ * @retval : 无 * */ -void num_to_bytes(uint64_t n, uint8_t len, uint8_t* dest) -{ +void num_to_bytes(uint64_t n, uint8_t len, uint8_t *dest) { while (len--) { dest[len] = (uint8_t)n; n >>= 8; @@ -24,8 +23,7 @@ void num_to_bytes(uint64_t n, uint8_t len, uint8_t* dest) * @retval : 转换结果 * */ -uint64_t bytes_to_num(uint8_t* src, uint8_t len) -{ +uint64_t bytes_to_num(uint8_t *src, uint8_t len) { uint64_t num = 0; while (len--) { num = (num << 8) | (*src); diff --git a/firmware/application/src/rfid/hex_utils.h b/firmware/application/src/rfid/hex_utils.h index cf72e4a..fc96110 100644 --- a/firmware/application/src/rfid/hex_utils.h +++ b/firmware/application/src/rfid/hex_utils.h @@ -4,7 +4,7 @@ #include // num & bytes -void num_to_bytes(uint64_t n, uint8_t len, uint8_t* dest); -uint64_t bytes_to_num(uint8_t* src, uint8_t len); +void num_to_bytes(uint64_t n, uint8_t len, uint8_t *dest); +uint64_t bytes_to_num(uint8_t *src, uint8_t len); #endif diff --git a/firmware/application/src/rfid/mf1_crypto1.c b/firmware/application/src/rfid/mf1_crypto1.c index 7c45276..132ab4b 100644 --- a/firmware/application/src/rfid/mf1_crypto1.c +++ b/firmware/application/src/rfid/mf1_crypto1.c @@ -274,26 +274,26 @@ static const uint8_t TableC0[32] = { static const uint8_t TableC7[32] = { /* fc with Input {4,3,2,1,0} = (0,0,0,0,0) to (1,1,1,1,1) */ FC(0, 0, 0, 0, 0) << 7, FC(0, 0, 0, 0, 1) << 7, FC(0, 0, 0, 1, 0) << 7, FC(0, 0, 0, 1, 1) << 7, - FC(0, 0, 1, 0, 0) << 7, FC(0, 0, 1, 0, 1) << 7, FC(0, 0, 1, 1, 0) << 7, FC(0, 0, 1, 1, 1) << 7, - FC(0, 1, 0, 0, 0) << 7, FC(0, 1, 0, 0, 1) << 7, FC(0, 1, 0, 1, 0) << 7, FC(0, 1, 0, 1, 1) << 7, - FC(0, 1, 1, 0, 0) << 7, FC(0, 1, 1, 0, 1) << 7, FC(0, 1, 1, 1, 0) << 7, FC(0, 1, 1, 1, 1) << 7, - FC(1, 0, 0, 0, 0) << 7, FC(1, 0, 0, 0, 1) << 7, FC(1, 0, 0, 1, 0) << 7, FC(1, 0, 0, 1, 1) << 7, - FC(1, 0, 1, 0, 0) << 7, FC(1, 0, 1, 0, 1) << 7, FC(1, 0, 1, 1, 0) << 7, FC(1, 0, 1, 1, 1) << 7, - FC(1, 1, 0, 0, 0) << 7, FC(1, 1, 0, 0, 1) << 7, FC(1, 1, 0, 1, 0) << 7, FC(1, 1, 0, 1, 1) << 7, - FC(1, 1, 1, 0, 0) << 7, FC(1, 1, 1, 0, 1) << 7, FC(1, 1, 1, 1, 0) << 7, FC(1, 1, 1, 1, 1) << 7 + FC(0, 0, 1, 0, 0) << 7, FC(0, 0, 1, 0, 1) << 7, FC(0, 0, 1, 1, 0) << 7, FC(0, 0, 1, 1, 1) << 7, + FC(0, 1, 0, 0, 0) << 7, FC(0, 1, 0, 0, 1) << 7, FC(0, 1, 0, 1, 0) << 7, FC(0, 1, 0, 1, 1) << 7, + FC(0, 1, 1, 0, 0) << 7, FC(0, 1, 1, 0, 1) << 7, FC(0, 1, 1, 1, 0) << 7, FC(0, 1, 1, 1, 1) << 7, + FC(1, 0, 0, 0, 0) << 7, FC(1, 0, 0, 0, 1) << 7, FC(1, 0, 0, 1, 0) << 7, FC(1, 0, 0, 1, 1) << 7, + FC(1, 0, 1, 0, 0) << 7, FC(1, 0, 1, 0, 1) << 7, FC(1, 0, 1, 1, 0) << 7, FC(1, 0, 1, 1, 1) << 7, + FC(1, 1, 0, 0, 0) << 7, FC(1, 1, 0, 0, 1) << 7, FC(1, 1, 0, 1, 0) << 7, FC(1, 1, 0, 1, 1) << 7, + FC(1, 1, 1, 0, 0) << 7, FC(1, 1, 1, 0, 1) << 7, FC(1, 1, 1, 1, 0) << 7, FC(1, 1, 1, 1, 1) << 7 }; /* Special table for nibble processing (e.g. ack), feedback at bit 3 */ static const uint8_t TableC3[32] = { /* fc with Input {4,3,2,1,0} = (0,0,0,0,0) to (1,1,1,1,1) */ FC(0, 0, 0, 0, 0) << 3, FC(0, 0, 0, 0, 1) << 3, FC(0, 0, 0, 1, 0) << 3, FC(0, 0, 0, 1, 1) << 3, - FC(0, 0, 1, 0, 0) << 3, FC(0, 0, 1, 0, 1) << 3, FC(0, 0, 1, 1, 0) << 3, FC(0, 0, 1, 1, 1) << 3, - FC(0, 1, 0, 0, 0) << 3, FC(0, 1, 0, 0, 1) << 3, FC(0, 1, 0, 1, 0) << 3, FC(0, 1, 0, 1, 1) << 3, - FC(0, 1, 1, 0, 0) << 3, FC(0, 1, 1, 0, 1) << 3, FC(0, 1, 1, 1, 0) << 3, FC(0, 1, 1, 1, 1) << 3, - FC(1, 0, 0, 0, 0) << 3, FC(1, 0, 0, 0, 1) << 3, FC(1, 0, 0, 1, 0) << 3, FC(1, 0, 0, 1, 1) << 3, - FC(1, 0, 1, 0, 0) << 3, FC(1, 0, 1, 0, 1) << 3, FC(1, 0, 1, 1, 0) << 3, FC(1, 0, 1, 1, 1) << 3, - FC(1, 1, 0, 0, 0) << 3, FC(1, 1, 0, 0, 1) << 3, FC(1, 1, 0, 1, 0) << 3, FC(1, 1, 0, 1, 1) << 3, - FC(1, 1, 1, 0, 0) << 3, FC(1, 1, 1, 0, 1) << 3, FC(1, 1, 1, 1, 0) << 3, FC(1, 1, 1, 1, 1) << 3 + FC(0, 0, 1, 0, 0) << 3, FC(0, 0, 1, 0, 1) << 3, FC(0, 0, 1, 1, 0) << 3, FC(0, 0, 1, 1, 1) << 3, + FC(0, 1, 0, 0, 0) << 3, FC(0, 1, 0, 0, 1) << 3, FC(0, 1, 0, 1, 0) << 3, FC(0, 1, 0, 1, 1) << 3, + FC(0, 1, 1, 0, 0) << 3, FC(0, 1, 1, 0, 1) << 3, FC(0, 1, 1, 1, 0) << 3, FC(0, 1, 1, 1, 1) << 3, + FC(1, 0, 0, 0, 0) << 3, FC(1, 0, 0, 0, 1) << 3, FC(1, 0, 0, 1, 0) << 3, FC(1, 0, 0, 1, 1) << 3, + FC(1, 0, 1, 0, 0) << 3, FC(1, 0, 1, 0, 1) << 3, FC(1, 0, 1, 1, 0) << 3, FC(1, 0, 1, 1, 1) << 3, + FC(1, 1, 0, 0, 0) << 3, FC(1, 1, 0, 0, 1) << 3, FC(1, 1, 0, 1, 0) << 3, FC(1, 1, 0, 1, 1) << 3, + FC(1, 1, 1, 0, 0) << 3, FC(1, 1, 1, 0, 1) << 3, FC(1, 1, 1, 1, 0) << 3, FC(1, 1, 1, 1, 1) << 3 }; /* Filter Output Macros */ @@ -652,8 +652,8 @@ void Crypto1Auth(uint8_t EncryptedReaderNonce[NONCE_SIZE]) { /* Bit 0 */ Feedback = CRYPTO1_FILTER_OUTPUT_B0_24(Odd0, Odd1, Odd2); Feedback = Crypto1LFSRbyteFeedback(Even0, Even1, Even2, Odd0, Odd1, Odd2) - ^ Feedback - ^ In; + ^ Feedback + ^ In; In >>= 1; SHIFT24(Even0, Even1, Even2, Feedback); @@ -685,8 +685,8 @@ void Crypto1Auth(uint8_t EncryptedReaderNonce[NONCE_SIZE]) { /* Bit 4 */ Feedback = CRYPTO1_FILTER_OUTPUT_B0_24(Odd0, Odd1, Odd2); Feedback = Crypto1LFSRbyteFeedback(Even0, Even1, Even2, Odd0, Odd1, Odd2) - ^ Feedback - ^ In; + ^ Feedback + ^ In; In >>= 1; SHIFT24(Even0, Even1, Even2, Feedback); @@ -701,8 +701,8 @@ void Crypto1Auth(uint8_t EncryptedReaderNonce[NONCE_SIZE]) { /* Bit 6 */ Feedback = CRYPTO1_FILTER_OUTPUT_B0_24(Odd0, Odd1, Odd2); Feedback = Crypto1LFSRbyteFeedback(Even0, Even1, Even2, Odd0, Odd1, Odd2) - ^ Feedback - ^ In; + ^ Feedback + ^ In; In >>= 1; SHIFT24(Even0, Even1, Even2, Feedback); diff --git a/firmware/application/src/rfid/nfctag/hf/nfc_14a.c b/firmware/application/src/rfid/nfctag/hf/nfc_14a.c index 3d6cf72..7817562 100644 --- a/firmware/application/src/rfid/nfctag/hf/nfc_14a.c +++ b/firmware/application/src/rfid/nfctag/hf/nfc_14a.c @@ -360,12 +360,11 @@ void nfc_tag_14a_tx_nbit_delay_window(uint8_t data, uint32_t bits) { /** * 14a监听到PCD过来的数据处理的封装函数 */ -void nfc_tag_14a_data_process(uint8_t *p_data) -{ +void nfc_tag_14a_data_process(uint8_t *p_data) { // 统计一下当前收到的bit数 uint16_t szDataBits = (NRF_NFCT->RXD.AMOUNT & (NFCT_RXD_AMOUNT_RXDATABITS_Msk | NFCT_RXD_AMOUNT_RXDATABYTES_Msk)); // 防冲撞可能要用上的资源 - nfc_tag_14a_coll_res_referen_t* auto_coll_res = m_tag_handler.get_coll_res != NULL ? m_tag_handler.get_coll_res() : NULL; + nfc_tag_14a_coll_res_referen_t *auto_coll_res = m_tag_handler.get_coll_res != NULL ? m_tag_handler.get_coll_res() : NULL; // 我也不知道为什么，这里CPU必须要空跑一段周期，数据才能正常收到。 // 如果接收数据有任何问题，请尝试恢复此处，这个是2021年发现的问题，但是2022年又消失了 @@ -461,7 +460,7 @@ void nfc_tag_14a_data_process(uint8_t *p_data) } } // 匹配UID长度，为uid的返回数据做准备 - switch(*auto_coll_res->size) { + switch (*auto_coll_res->size) { case NFC_TAG_14A_UID_SINGLE_SIZE: { if (level == NFC_TAG_14A_CASCADE_LEVEL_1) { // 首次级联，只有一次 // 4字节的标签最多只能一次级联 @@ -655,7 +654,7 @@ void nfc_tag_14a_event_callback(nrfx_nfct_evt_t const *p_event) { } case NRFX_NFCT_EVT_ERROR: { // 根据错误原因，进行日志打印，以帮助开发时排查可能性的BUG - switch(p_event->params.error.reason) { + switch (p_event->params.error.reason) { case NRFX_NFCT_ERROR_FRAMEDELAYTIMEOUT: { // 如果我们在通信窗口中回应了标签但是却是没有及时回应，那就需要进行报错打印 // 如果此错误非常频繁的出现，则可能是MCU处理速度没跟上，此时开发者就需要优化代码了 @@ -690,7 +689,7 @@ void nfc_tag_14a_set_state(nfc_tag_14a_state_t state) { * 14A的处理器注册函数 * @param handler 处理器句柄 */ -void nfc_tag_14a_set_handler(nfc_tag_14a_handler_t* handler) { +void nfc_tag_14a_set_handler(nfc_tag_14a_handler_t *handler) { if (handler != NULL) { // 直接取出传入的实现赋值到我们的全局对象即可 m_tag_handler.cb_reset = handler->cb_reset; @@ -733,6 +732,6 @@ void nfc_tag_14a_sense_switch(bool enable) { bool is_valid_uid_size(uint8_t uid_length) { return uid_length == NFC_TAG_14A_UID_SINGLE_SIZE || - uid_length == NFC_TAG_14A_UID_DOUBLE_SIZE || - uid_length == NFC_TAG_14A_UID_TRIPLE_SIZE; + uid_length == NFC_TAG_14A_UID_DOUBLE_SIZE || + uid_length == NFC_TAG_14A_UID_TRIPLE_SIZE; } diff --git a/firmware/application/src/rfid/nfctag/hf/nfc_14a.h b/firmware/application/src/rfid/nfctag/hf/nfc_14a.h index 8c0c4f2..f0056ec 100644 --- a/firmware/application/src/rfid/nfctag/hf/nfc_14a.h +++ b/firmware/application/src/rfid/nfctag/hf/nfc_14a.h @@ -73,17 +73,17 @@ typedef struct { // 防冲突资源的封装引用，纯引用空间占用比较小 typedef struct { - nfc_tag_14a_uid_size* size; - uint8_t* atqa; - uint8_t* sak; - uint8_t* uid; - nfc_14a_ats_t* ats; + nfc_tag_14a_uid_size *size; + uint8_t *atqa; + uint8_t *sak; + uint8_t *uid; + nfc_14a_ats_t *ats; } nfc_tag_14a_coll_res_referen_t; // 通信接管需要实现的回调函数 typedef void (*nfc_tag_14a_reset_handler_t)(void); -typedef void (*nfc_tag_14a_state_handler_t)(uint8_t* data, uint16_t szBits); -typedef nfc_tag_14a_coll_res_referen_t* (*nfc_tag_14a_coll_handler_t)(void); +typedef void (*nfc_tag_14a_state_handler_t)(uint8_t *data, uint16_t szBits); +typedef nfc_tag_14a_coll_res_referen_t *(*nfc_tag_14a_coll_handler_t)(void); // 14a通信接管者需要实现的接口 typedef struct { @@ -106,7 +106,7 @@ uint8_t nfc_tag_14a_unwrap_frame(const uint8_t *pbtFrame, const size_t szFrameBi // 14a通信控制 void nfc_tag_14a_sense_switch(bool enable); -void nfc_tag_14a_set_handler(nfc_tag_14a_handler_t* handler); +void nfc_tag_14a_set_handler(nfc_tag_14a_handler_t *handler); void nfc_tag_14a_set_state(nfc_tag_14a_state_t state); void nfc_tag_14a_tx_bytes(uint8_t *data, uint32_t bytes, bool appendCrc); void nfc_tag_14a_tx_bytes_delay_freerun(uint8_t *data, uint32_t bytes, bool appendCrc); diff --git a/firmware/application/src/rfid/nfctag/hf/nfc_mf1.c b/firmware/application/src/rfid/nfctag/hf/nfc_mf1.c index ead8112..10110f8 100644 --- a/firmware/application/src/rfid/nfctag/hf/nfc_mf1.c +++ b/firmware/application/src/rfid/nfctag/hf/nfc_mf1.c @@ -181,11 +181,11 @@ static nfc_tag_mf1_std_state_machine_t m_mf1_state = MF1_STATE_UNAUTH; // 保存当前的GEN1A状态 static nfc_tag_mf1_gen1a_state_machine_t m_gen1a_state = GEN1A_STATE_DISABLE; // 指向标签信息的数据结构指针 -static nfc_tag_mf1_information_t* m_tag_information = NULL; +static nfc_tag_mf1_information_t *m_tag_information = NULL; // 定义并且使用影子防冲撞资源 static nfc_tag_14a_coll_res_referen_t m_shadow_coll_res; // 指向标签扇区中的尾部块（控制数据块） -static nfc_tag_mf1_trailer_info_t* m_tag_trailer_info = NULL; +static nfc_tag_mf1_trailer_info_t *m_tag_trailer_info = NULL; // 定义并且使用mf1专用通信缓冲区 static nfc_tag_mf1_tx_buffer_t m_tag_tx_buffer; // 保存当前正在模拟的MF1的具体类型 @@ -388,7 +388,7 @@ void append_mf1_auth_log_step3(bool is_auth_success) { /** @brief mf1获得验证日志 * @param count: 验证日志的统计个数 */ -nfc_tag_mf1_auth_log_t* get_mf1_auth_log(uint32_t* count) { +nfc_tag_mf1_auth_log_t *get_mf1_auth_log(uint32_t *count) { // 先传递验证的日志条目总数出去 *count = m_auth_log.count; // 直接返回日志数组的头部指针就好了 @@ -397,7 +397,7 @@ nfc_tag_mf1_auth_log_t* get_mf1_auth_log(uint32_t* count) { static int get_block_max_by_tag_type(tag_specific_type_t tag_type) { int block_max; - switch(tag_type) { + switch (tag_type) { case TAG_TYPE_MIFARE_Mini: block_max = 20; break; @@ -433,7 +433,7 @@ void mf1_prng_by_bytes(uint8_t *nonces, uint32_t n) { * @param szBits 数据的比特流长度 * @param state 有限状态机 */ -void nfc_tag_mf1_state_handler(uint8_t* p_data, uint16_t szDataBits) { +void nfc_tag_mf1_state_handler(uint8_t *p_data, uint16_t szDataBits) { // 处理特殊指令，比如兼容mifare gen1a标签 if (szDataBits <= 8) { // 只有启用了GEN1A模式的情况下才允许后门指令的响应 @@ -469,7 +469,7 @@ void nfc_tag_mf1_state_handler(uint8_t* p_data, uint16_t szDataBits) { case MF1_STATE_UNAUTH: { // 未验证状态，通信是开放性的 if (szDataBits == 32) { // 32位，可能是指令 if (nfc_tag_14a_checks_crc(p_data, 4)) { - switch(p_data[0]) { + switch (p_data[0]) { case CMD_AUTH_A: case CMD_AUTH_B: { uint8_t BlockAuth = p_data[1]; @@ -498,7 +498,7 @@ void nfc_tag_mf1_state_handler(uint8_t* p_data, uint16_t szDataBits) { KeyInUse = p_data[0] & 1; // 获得指定的扇区访问控制字节，此处我们直接取巧，将内存转为结构体，让编译器帮我们维护指针的指向 - m_tag_trailer_info = (nfc_tag_mf1_trailer_info_t*)m_tag_information->memory[BlockEnd]; + m_tag_trailer_info = (nfc_tag_mf1_trailer_info_t *)m_tag_information->memory[BlockEnd]; // 生成随机数 nfc_tag_mf1_random_nonce(CardNonce, false); @@ -549,9 +549,9 @@ void nfc_tag_mf1_state_handler(uint8_t* p_data, uint16_t szDataBits) { crypto1_deinit(pcs); // 加载密钥流 crypto1_init(pcs, - // 根据当前的指令类型选择验证A或者B秘钥 - bytes_to_num(KeyInUse ? m_tag_trailer_info->keyb : m_tag_trailer_info->keya, 6) - ); + // 根据当前的指令类型选择验证A或者B秘钥 + bytes_to_num(KeyInUse ? m_tag_trailer_info->keyb : m_tag_trailer_info->keya, 6) + ); // 设置密钥流 crypto1_word(pcs, bytes_to_num(UID_BY_CASCADE_LEVEL, 4) ^ bytes_to_num(CardNonce, 4), 0); #endif @@ -688,7 +688,7 @@ void nfc_tag_mf1_state_handler(uint8_t* p_data, uint16_t szDataBits) { // 清空一下buffer，避免缓存的数据影响到后续操作 memset(m_tag_tx_buffer.tx_raw_buffer, 0x00, sizeof(m_tag_tx_buffer.tx_raw_buffer)); // 让这块数据区域变成我们需要的尾部块类型 - nfc_tag_mf1_trailer_info_t* respTrailerInfo = (nfc_tag_mf1_trailer_info_t*)m_tag_tx_buffer.tx_raw_buffer; + nfc_tag_mf1_trailer_info_t *respTrailerInfo = (nfc_tag_mf1_trailer_info_t *)m_tag_tx_buffer.tx_raw_buffer; // 尾部块的读取有以下条件限制： // 1、要始终可以复制GPB（Global Public Byte）也就是控制位最后一个字节 // 2、秘钥A永远无法被读取！ @@ -792,9 +792,9 @@ void nfc_tag_mf1_state_handler(uint8_t* p_data, uint16_t szDataBits) { status = ACK_VALUE; } #ifdef NFC_MF1_FAST_SIM - nfc_tag_14a_tx_nbit(status ^ Crypto1Nibble(), 4); + nfc_tag_14a_tx_nbit(status ^ Crypto1Nibble(), 4); #else - nfc_tag_14a_tx_nbit(mf_crypto1_encrypt4bit(pcs, status), 4); + nfc_tag_14a_tx_nbit(mf_crypto1_encrypt4bit(pcs, status), 4); #endif break; } @@ -827,7 +827,7 @@ void nfc_tag_mf1_state_handler(uint8_t* p_data, uint16_t szDataBits) { KeyInUse = p_data[0] & 1; // 获得指定的扇区访问控制字节，此处我们直接取巧，将内存转为结构体，让编译器帮我们维护指针的指向 - m_tag_trailer_info = (nfc_tag_mf1_trailer_info_t*)m_tag_information->memory[BlockEnd]; + m_tag_trailer_info = (nfc_tag_mf1_trailer_info_t *)m_tag_information->memory[BlockEnd]; // 生成随机数 nfc_tag_mf1_random_nonce(CardNonce, true); @@ -884,9 +884,9 @@ void nfc_tag_mf1_state_handler(uint8_t* p_data, uint16_t szDataBits) { crypto1_deinit(pcs); // 加载密钥流 crypto1_init(pcs, - // 根据当前的指令类型选择验证A或者B秘钥 - bytes_to_num(KeyInUse ? m_tag_trailer_info->keyb : m_tag_trailer_info->keya, 6) - ); + // 根据当前的指令类型选择验证A或者B秘钥 + bytes_to_num(KeyInUse ? m_tag_trailer_info->keyb : m_tag_trailer_info->keya, 6) + ); // 进行随机数加密 uint8_t m_auth_nt_keystream[4]; num_to_bytes(bytes_to_num(UID_BY_CASCADE_LEVEL, 4) ^ bytes_to_num(CardNonce, 4), 4, m_auth_nt_keystream); @@ -1048,11 +1048,11 @@ void nfc_tag_mf1_state_handler(uint8_t* p_data, uint16_t szDataBits) { /** * @brief 提供mifare标签必要的防冲突资源（仅提供指针） */ -nfc_tag_14a_coll_res_referen_t* get_mifare_coll_res() { +nfc_tag_14a_coll_res_referen_t *get_mifare_coll_res() { // 根据当前的互通配置，选择性的返回其中配置的数据，假设开启了数据互通，那么我们还需要确保当前模拟的卡是4BYTE的 if (m_tag_information->config.use_mf1_coll_res && m_tag_information->res_coll.size == NFC_TAG_14A_UID_SINGLE_SIZE) { // 获得数据区域的厂商信息 - nfc_tag_mf1_factory_info_t* block0_factory_info = (nfc_tag_mf1_factory_info_t*)m_tag_information->memory[0]; + nfc_tag_mf1_factory_info_t *block0_factory_info = (nfc_tag_mf1_factory_info_t *)m_tag_information->memory[0]; m_shadow_coll_res.sak = block0_factory_info->sak; // 替换sak m_shadow_coll_res.atqa = block0_factory_info->atqa; // 替换atqa m_shadow_coll_res.uid = block0_factory_info->uid; // 替换uid @@ -1099,7 +1099,7 @@ static int get_information_size_by_tag_type(tag_specific_type_t type, bool auth_ * @param buffer 数据缓冲区 * @return 需要保存的数据的长度，为0时表示不保存 */ -int nfc_tag_mf1_data_savecb(tag_specific_type_t type, tag_data_buffer_t* buffer) { +int nfc_tag_mf1_data_savecb(tag_specific_type_t type, tag_data_buffer_t *buffer) { if (m_tag_type != TAG_TYPE_UNKNOWN) { if (m_tag_information->config.mode_block_write == NFC_TAG_MF1_WRITE_SHADOW) { NRF_LOG_INFO("The mf1 is shadow write mode."); @@ -1116,7 +1116,7 @@ int nfc_tag_mf1_data_savecb(tag_specific_type_t type, tag_data_buffer_t* buffer) * @param type 细化的标签类型 * @param buffer 数据缓冲区 */ -int nfc_tag_mf1_data_loadcb(tag_specific_type_t type, tag_data_buffer_t* buffer) { +int nfc_tag_mf1_data_loadcb(tag_specific_type_t type, tag_data_buffer_t *buffer) { // 确保外部容量足够转换为信息结构体 int info_size = get_information_size_by_tag_type(type, false); if (buffer->length >= info_size) { diff --git a/firmware/application/src/rfid/nfctag/hf/nfc_mf1.h b/firmware/application/src/rfid/nfctag/hf/nfc_mf1.h index 138c2c7..9b68627 100644 --- a/firmware/application/src/rfid/nfctag/hf/nfc_mf1.h +++ b/firmware/application/src/rfid/nfctag/hf/nfc_mf1.h @@ -83,7 +83,8 @@ typedef struct __attribute__((aligned(4))) { nfc_tag_14a_coll_res_entity_t res_coll; nfc_tag_mf1_configure_t config; uint8_t memory[NFC_TAG_MF1_BLOCK_MAX][NFC_TAG_MF1_DATA_SIZE]; -} nfc_tag_mf1_information_t; +} +nfc_tag_mf1_information_t; // 4Byte卡片的出厂固化的0块结构 typedef struct { @@ -135,15 +136,15 @@ typedef struct { } nfc_tag_mf1_auth_log_t; -nfc_tag_mf1_auth_log_t* get_mf1_auth_log(uint32_t* count); -int nfc_tag_mf1_data_loadcb(tag_specific_type_t type, tag_data_buffer_t* buffer); -int nfc_tag_mf1_data_savecb(tag_specific_type_t type, tag_data_buffer_t* buffer); +nfc_tag_mf1_auth_log_t *get_mf1_auth_log(uint32_t *count); +int nfc_tag_mf1_data_loadcb(tag_specific_type_t type, tag_data_buffer_t *buffer); +int nfc_tag_mf1_data_savecb(tag_specific_type_t type, tag_data_buffer_t *buffer); bool nfc_tag_mf1_data_factory(uint8_t slot, tag_specific_type_t tag_type); void nfc_tag_mf1_set_detection_enable(bool enable); bool nfc_tag_mf1_is_detection_enable(void); void nfc_tag_mf1_detection_log_clear(void); uint32_t nfc_tag_mf1_detection_log_count(void); -nfc_tag_14a_coll_res_referen_t* get_mifare_coll_res(void); +nfc_tag_14a_coll_res_referen_t *get_mifare_coll_res(void); void nfc_tag_mf1_set_gen1a_magic_mode(bool enable); bool nfc_tag_mf1_is_gen1a_magic_mode(void); void nfc_tag_mf1_set_gen2_magic_mode(bool enable); diff --git a/firmware/application/src/rfid/nfctag/hf/nfc_ntag.c b/firmware/application/src/rfid/nfctag/hf/nfc_ntag.c index 39a4b65..7244bda 100644 --- a/firmware/application/src/rfid/nfctag/hf/nfc_ntag.c +++ b/firmware/application/src/rfid/nfctag/hf/nfc_ntag.c @@ -70,7 +70,7 @@ const uint8_t ntagVersion[8] = {0x00, 0x04, 0x04, 0x02, 0x01, 0x00, 0x11, 0x03}; uint8_t ntagPwdOK[2] = {0x80, 0x80}; // 指向标签信息的数据结构指针 -static nfc_tag_ntag_information_t* m_tag_information = NULL; +static nfc_tag_ntag_information_t *m_tag_information = NULL; // 定义并且使用影子防冲撞资源 static nfc_tag_14a_coll_res_referen_t m_shadow_coll_res; // 定义并且使用ntag专用通信缓冲区 @@ -80,7 +80,7 @@ static tag_specific_type_t m_tag_type; static int get_block_max_by_tag_type(tag_specific_type_t tag_type) { int block_max; - switch(tag_type) { + switch (tag_type) { case TAG_TYPE_NTAG_213: block_max = NTAG213_PAGES; break; @@ -97,7 +97,7 @@ static int get_block_max_by_tag_type(tag_specific_type_t tag_type) { static int get_block_cfg_by_tag_type(tag_specific_type_t tag_type) { int block_max; - switch(tag_type) { + switch (tag_type) { case TAG_TYPE_NTAG_213: block_max = NTAG213_CONFIG_AREA_START_ADDRESS; break; @@ -112,31 +112,31 @@ static int get_block_cfg_by_tag_type(tag_specific_type_t tag_type) { return block_max; } -void nfc_tag_ntag_state_handler(uint8_t* p_data, uint16_t szDataBits) { +void nfc_tag_ntag_state_handler(uint8_t *p_data, uint16_t szDataBits) { uint8_t command = p_data[0]; uint8_t block_num = p_data[1]; - switch(command) { + switch (command) { case CMD_GET_VERSION: memcpy(m_tag_tx_buffer.tx_buffer, ntagVersion, 8); switch (m_tag_type) { - case TAG_TYPE_NTAG_213: - m_tag_tx_buffer.tx_buffer[6] = NTAG213_VERSION; - break; - default: - case TAG_TYPE_NTAG_215: - m_tag_tx_buffer.tx_buffer[6] = NTAG215_VERSION; - break; - case TAG_TYPE_NTAG_216: - m_tag_tx_buffer.tx_buffer[6] = NTAG216_VERSION; - break; + case TAG_TYPE_NTAG_213: + m_tag_tx_buffer.tx_buffer[6] = NTAG213_VERSION; + break; + default: + case TAG_TYPE_NTAG_215: + m_tag_tx_buffer.tx_buffer[6] = NTAG215_VERSION; + break; + case TAG_TYPE_NTAG_216: + m_tag_tx_buffer.tx_buffer[6] = NTAG216_VERSION; + break; } nfc_tag_14a_tx_bytes(m_tag_tx_buffer.tx_buffer, 8, true); break; case CMD_READ: if (block_num < get_block_max_by_tag_type(m_tag_type)) { for (int block = 0; block < 4; block++) { - memcpy(m_tag_tx_buffer.tx_buffer + block*4, m_tag_information->memory[block_num+block], NFC_TAG_NTAG_DATA_SIZE); + memcpy(m_tag_tx_buffer.tx_buffer + block * 4, m_tag_information->memory[block_num + block], NFC_TAG_NTAG_DATA_SIZE); } nfc_tag_14a_tx_bytes(m_tag_tx_buffer.tx_buffer, BYTES_PER_READ, true); } else { @@ -150,7 +150,7 @@ void nfc_tag_ntag_state_handler(uint8_t* p_data, uint16_t szDataBits) { break; } for (int block = block_num; block <= end_block_num; block++) { - memcpy(m_tag_tx_buffer.tx_buffer + (block - block_num)*4, m_tag_information->memory[block], NFC_TAG_NTAG_DATA_SIZE); + memcpy(m_tag_tx_buffer.tx_buffer + (block - block_num) * 4, m_tag_information->memory[block], NFC_TAG_NTAG_DATA_SIZE); } nfc_tag_14a_tx_bytes(m_tag_tx_buffer.tx_buffer, (end_block_num - block_num + 1) * NFC_TAG_NTAG_DATA_SIZE, true); break; @@ -171,7 +171,7 @@ void nfc_tag_ntag_state_handler(uint8_t* p_data, uint16_t szDataBits) { break; } /* Authenticate the user */ - //RESET AUTHLIM COUNTER, CURRENTLY NOT IMPLEMENTED + //RESET AUTHLIM COUNTER, CURRENTLY NOT IMPLEMENTED // TODO /* Send the PACK value back */ if (m_tag_information->config.mode_uid_magic) { @@ -189,7 +189,7 @@ void nfc_tag_ntag_state_handler(uint8_t* p_data, uint16_t szDataBits) { return; } -nfc_tag_14a_coll_res_referen_t* get_ntag_coll_res() { +nfc_tag_14a_coll_res_referen_t *get_ntag_coll_res() { // 使用单独的防冲突信息，而不是使用扇区中的信息 m_shadow_coll_res.sak = m_tag_information->res_coll.sak; m_shadow_coll_res.atqa = m_tag_information->res_coll.atqa; @@ -213,7 +213,7 @@ static int get_information_size_by_tag_type(tag_specific_type_t type) { * @param buffer 数据缓冲区 * @return 需要保存的数据的长度，为0时表示不保存 */ -int nfc_tag_ntag_data_savecb(tag_specific_type_t type, tag_data_buffer_t* buffer) { +int nfc_tag_ntag_data_savecb(tag_specific_type_t type, tag_data_buffer_t *buffer) { if (m_tag_type != TAG_TYPE_UNKNOWN) { // 根据当前标签类型保存对应大小的数据 return get_information_size_by_tag_type(type); @@ -222,7 +222,7 @@ int nfc_tag_ntag_data_savecb(tag_specific_type_t type, tag_data_buffer_t* buffer } } -int nfc_tag_ntag_data_loadcb(tag_specific_type_t type, tag_data_buffer_t* buffer) { +int nfc_tag_ntag_data_loadcb(tag_specific_type_t type, tag_data_buffer_t *buffer) { int info_size = get_information_size_by_tag_type(type); if (buffer->length >= info_size) { // 将数据缓冲区强转为ntag结构类型 @@ -231,8 +231,8 @@ int nfc_tag_ntag_data_loadcb(tag_specific_type_t type, tag_data_buffer_t* buffer m_tag_type = type; // 注册14a通信管理接口 nfc_tag_14a_handler_t handler_for_14a = { - .get_coll_res = get_ntag_coll_res, - .cb_state = nfc_tag_ntag_state_handler, + .get_coll_res = get_ntag_coll_res, + .cb_state = nfc_tag_ntag_state_handler, .cb_reset = nfc_tag_ntag_reset_handler, }; nfc_tag_14a_set_handler(&handler_for_14a); @@ -266,8 +266,8 @@ bool nfc_tag_ntag_data_factory(uint8_t slot, tag_specific_type_t tag_type) { memcpy(p_ntag_information->memory[block], default_p2, NFC_TAG_NTAG_DATA_SIZE); } } - - // default ntag auto ant-collision res + + // default ntag auto ant-collision res p_ntag_information->res_coll.atqa[0] = 0x44; p_ntag_information->res_coll.atqa[1] = 0x00; p_ntag_information->res_coll.sak[0] = 0x00; @@ -280,11 +280,11 @@ bool nfc_tag_ntag_data_factory(uint8_t slot, tag_specific_type_t tag_type) { p_ntag_information->res_coll.uid[6] = 0x64; p_ntag_information->res_coll.size = NFC_TAG_14A_UID_DOUBLE_SIZE; p_ntag_information->res_coll.ats.length = 0; - + // default ntag config p_ntag_information->config.mode_uid_magic = true; p_ntag_information->config.detection_enable = false; - + // save data to flash tag_sense_type_t sense_type = get_sense_type_from_tag_type(tag_type); fds_slot_record_map_t map_info; diff --git a/firmware/application/src/rfid/nfctag/hf/nfc_ntag.h b/firmware/application/src/rfid/nfctag/hf/nfc_ntag.h index 1fded7b..c1eea75 100644 --- a/firmware/application/src/rfid/nfctag/hf/nfc_ntag.h +++ b/firmware/application/src/rfid/nfctag/hf/nfc_ntag.h @@ -25,14 +25,15 @@ typedef struct __attribute__((aligned(4))) { nfc_tag_14a_coll_res_entity_t res_coll; nfc_tag_ntag_configure_t config; uint8_t memory[NFC_TAG_NTAG_BLOCK_MAX][NFC_TAG_NTAG_DATA_SIZE]; -} nfc_tag_ntag_information_t; +} +nfc_tag_ntag_information_t; typedef struct { uint8_t tx_buffer[NFC_TAG_NTAG_FRAME_SIZE]; } nfc_tag_ntag_tx_buffer_t; -int nfc_tag_ntag_data_loadcb(tag_specific_type_t type, tag_data_buffer_t* buffer); -int nfc_tag_ntag_data_savecb(tag_specific_type_t type, tag_data_buffer_t* buffer); +int nfc_tag_ntag_data_loadcb(tag_specific_type_t type, tag_data_buffer_t *buffer); +int nfc_tag_ntag_data_savecb(tag_specific_type_t type, tag_data_buffer_t *buffer); bool nfc_tag_ntag_data_factory(uint8_t slot, tag_specific_type_t tag_type); #endif diff --git a/firmware/application/src/rfid/nfctag/lf/lf_tag_em.c b/firmware/application/src/rfid/nfctag/lf/lf_tag_em.c index 0109644..891fe5c 100644 --- a/firmware/application/src/rfid/nfctag/lf/lf_tag_em.c +++ b/firmware/application/src/rfid/nfctag/lf/lf_tag_em.c @@ -53,54 +53,136 @@ uint64_t em410x_id_to_memory64(uint8_t id[5]) { uint64_t u64; struct { // 9 header bits - uint8_t h00: 1; uint8_t h01: 1; uint8_t h02: 1; uint8_t h03: 1; uint8_t h04: 1; uint8_t h05: 1; uint8_t h06: 1; uint8_t h07: 1; uint8_t h08: 1; + uint8_t h00: 1; + uint8_t h01: 1; + uint8_t h02: 1; + uint8_t h03: 1; + uint8_t h04: 1; + uint8_t h05: 1; + uint8_t h06: 1; + uint8_t h07: 1; + uint8_t h08: 1; // 8 version bits and 2 bit parity - uint8_t d00: 1; uint8_t d01: 1; uint8_t d02: 1; uint8_t d03: 1; uint8_t p0: 1; - uint8_t d10: 1; uint8_t d11: 1; uint8_t d12: 1; uint8_t d13: 1; uint8_t p1: 1; + uint8_t d00: 1; + uint8_t d01: 1; + uint8_t d02: 1; + uint8_t d03: 1; + uint8_t p0: 1; + uint8_t d10: 1; + uint8_t d11: 1; + uint8_t d12: 1; + uint8_t d13: 1; + uint8_t p1: 1; // 32 data bits and 8 bit parity - uint8_t d20: 1; uint8_t d21: 1; uint8_t d22: 1; uint8_t d23: 1; uint8_t p2: 1; - uint8_t d30: 1; uint8_t d31: 1; uint8_t d32: 1; uint8_t d33: 1; uint8_t p3: 1; - uint8_t d40: 1; uint8_t d41: 1; uint8_t d42: 1; uint8_t d43: 1; uint8_t p4: 1; - uint8_t d50: 1; uint8_t d51: 1; uint8_t d52: 1; uint8_t d53: 1; uint8_t p5: 1; - uint8_t d60: 1; uint8_t d61: 1; uint8_t d62: 1; uint8_t d63: 1; uint8_t p6: 1; - uint8_t d70: 1; uint8_t d71: 1; uint8_t d72: 1; uint8_t d73: 1; uint8_t p7: 1; - uint8_t d80: 1; uint8_t d81: 1; uint8_t d82: 1; uint8_t d83: 1; uint8_t p8: 1; - uint8_t d90: 1; uint8_t d91: 1; uint8_t d92: 1; uint8_t d93: 1; uint8_t p9: 1; + uint8_t d20: 1; + uint8_t d21: 1; + uint8_t d22: 1; + uint8_t d23: 1; + uint8_t p2: 1; + uint8_t d30: 1; + uint8_t d31: 1; + uint8_t d32: 1; + uint8_t d33: 1; + uint8_t p3: 1; + uint8_t d40: 1; + uint8_t d41: 1; + uint8_t d42: 1; + uint8_t d43: 1; + uint8_t p4: 1; + uint8_t d50: 1; + uint8_t d51: 1; + uint8_t d52: 1; + uint8_t d53: 1; + uint8_t p5: 1; + uint8_t d60: 1; + uint8_t d61: 1; + uint8_t d62: 1; + uint8_t d63: 1; + uint8_t p6: 1; + uint8_t d70: 1; + uint8_t d71: 1; + uint8_t d72: 1; + uint8_t d73: 1; + uint8_t p7: 1; + uint8_t d80: 1; + uint8_t d81: 1; + uint8_t d82: 1; + uint8_t d83: 1; + uint8_t p8: 1; + uint8_t d90: 1; + uint8_t d91: 1; + uint8_t d92: 1; + uint8_t d93: 1; + uint8_t p9: 1; // 5 bit end. - uint8_t pc0: 1; uint8_t pc1: 1; uint8_t pc2: 1; uint8_t pc3: 1; uint8_t s0: 1; + uint8_t pc0: 1; + uint8_t pc1: 1; + uint8_t pc2: 1; + uint8_t pc3: 1; + uint8_t s0: 1; } bit; } memory; // 好了，到了目前最关键的时候了，现在需要赋值和计算奇偶校验位了 // 1、先把前导码给赋值了 memory.bit.h00 = memory.bit.h01 = memory.bit.h02 = - memory.bit.h03 = memory.bit.h04 = memory.bit.h05 = - memory.bit.h06 = memory.bit.h07 = memory.bit.h08 = 1; + memory.bit.h03 = memory.bit.h04 = memory.bit.h05 = + memory.bit.h06 = memory.bit.h07 = memory.bit.h08 = 1; // 2、把8bit的版本或者自定义ID给赋值了 - memory.bit.d00 = GETBIT(id[0], 7); memory.bit.d01 = GETBIT(id[0], 6); memory.bit.d02 = GETBIT(id[0], 5); memory.bit.d03 = GETBIT(id[0], 4); + memory.bit.d00 = GETBIT(id[0], 7); + memory.bit.d01 = GETBIT(id[0], 6); + memory.bit.d02 = GETBIT(id[0], 5); + memory.bit.d03 = GETBIT(id[0], 4); memory.bit.p0 = memory.bit.d00 ^ memory.bit.d01 ^ memory.bit.d02 ^ memory.bit.d03; - memory.bit.d10 = GETBIT(id[0], 3); memory.bit.d11 = GETBIT(id[0], 2); memory.bit.d12 = GETBIT(id[0], 1); memory.bit.d13 = GETBIT(id[0], 0); + memory.bit.d10 = GETBIT(id[0], 3); + memory.bit.d11 = GETBIT(id[0], 2); + memory.bit.d12 = GETBIT(id[0], 1); + memory.bit.d13 = GETBIT(id[0], 0); memory.bit.p1 = memory.bit.d10 ^ memory.bit.d11 ^ memory.bit.d12 ^ memory.bit.d13; // 3、把32bit的数据给赋值了 // - byte1 - memory.bit.d20 = GETBIT(id[1], 7); memory.bit.d21 = GETBIT(id[1], 6); memory.bit.d22 = GETBIT(id[1], 5); memory.bit.d23 = GETBIT(id[1], 4); + memory.bit.d20 = GETBIT(id[1], 7); + memory.bit.d21 = GETBIT(id[1], 6); + memory.bit.d22 = GETBIT(id[1], 5); + memory.bit.d23 = GETBIT(id[1], 4); memory.bit.p2 = memory.bit.d20 ^ memory.bit.d21 ^ memory.bit.d22 ^ memory.bit.d23; - memory.bit.d30 = GETBIT(id[1], 3); memory.bit.d31 = GETBIT(id[1], 2); memory.bit.d32 = GETBIT(id[1], 1); memory.bit.d33 = GETBIT(id[1], 0); + memory.bit.d30 = GETBIT(id[1], 3); + memory.bit.d31 = GETBIT(id[1], 2); + memory.bit.d32 = GETBIT(id[1], 1); + memory.bit.d33 = GETBIT(id[1], 0); memory.bit.p3 = memory.bit.d30 ^ memory.bit.d31 ^ memory.bit.d32 ^ memory.bit.d33; // - byte2 - memory.bit.d40 = GETBIT(id[2], 7); memory.bit.d41 = GETBIT(id[2], 6); memory.bit.d42 = GETBIT(id[2], 5); memory.bit.d43 = GETBIT(id[2], 4); + memory.bit.d40 = GETBIT(id[2], 7); + memory.bit.d41 = GETBIT(id[2], 6); + memory.bit.d42 = GETBIT(id[2], 5); + memory.bit.d43 = GETBIT(id[2], 4); memory.bit.p4 = memory.bit.d40 ^ memory.bit.d41 ^ memory.bit.d42 ^ memory.bit.d43; - memory.bit.d50 = GETBIT(id[2], 3); memory.bit.d51 = GETBIT(id[2], 2); memory.bit.d52 = GETBIT(id[2], 1); memory.bit.d53 = GETBIT(id[2], 0); + memory.bit.d50 = GETBIT(id[2], 3); + memory.bit.d51 = GETBIT(id[2], 2); + memory.bit.d52 = GETBIT(id[2], 1); + memory.bit.d53 = GETBIT(id[2], 0); memory.bit.p5 = memory.bit.d50 ^ memory.bit.d51 ^ memory.bit.d52 ^ memory.bit.d53; // - byte3 - memory.bit.d60 = GETBIT(id[3], 7); memory.bit.d61 = GETBIT(id[3], 6); memory.bit.d62 = GETBIT(id[3], 5); memory.bit.d63 = GETBIT(id[3], 4); + memory.bit.d60 = GETBIT(id[3], 7); + memory.bit.d61 = GETBIT(id[3], 6); + memory.bit.d62 = GETBIT(id[3], 5); + memory.bit.d63 = GETBIT(id[3], 4); memory.bit.p6 = memory.bit.d60 ^ memory.bit.d61 ^ memory.bit.d62 ^ memory.bit.d63; - memory.bit.d70 = GETBIT(id[3], 3); memory.bit.d71 = GETBIT(id[3], 2); memory.bit.d72 = GETBIT(id[3], 1); memory.bit.d73 = GETBIT(id[3], 0); + memory.bit.d70 = GETBIT(id[3], 3); + memory.bit.d71 = GETBIT(id[3], 2); + memory.bit.d72 = GETBIT(id[3], 1); + memory.bit.d73 = GETBIT(id[3], 0); memory.bit.p7 = memory.bit.d70 ^ memory.bit.d71 ^ memory.bit.d72 ^ memory.bit.d73; // - byte4 - memory.bit.d80 = GETBIT(id[4], 7); memory.bit.d81 = GETBIT(id[4], 6); memory.bit.d82 = GETBIT(id[4], 5); memory.bit.d83 = GETBIT(id[4], 4); + memory.bit.d80 = GETBIT(id[4], 7); + memory.bit.d81 = GETBIT(id[4], 6); + memory.bit.d82 = GETBIT(id[4], 5); + memory.bit.d83 = GETBIT(id[4], 4); memory.bit.p8 = memory.bit.d80 ^ memory.bit.d81 ^ memory.bit.d82 ^ memory.bit.d83; - memory.bit.d90 = GETBIT(id[4], 3); memory.bit.d91 = GETBIT(id[4], 2); memory.bit.d92 = GETBIT(id[4], 1); memory.bit.d93 = GETBIT(id[4], 0); + memory.bit.d90 = GETBIT(id[4], 3); + memory.bit.d91 = GETBIT(id[4], 2); + memory.bit.d92 = GETBIT(id[4], 1); + memory.bit.d93 = GETBIT(id[4], 0); memory.bit.p9 = memory.bit.d90 ^ memory.bit.d91 ^ memory.bit.d92 ^ memory.bit.d93; // 4、计算纵向的偶校验 memory.bit.pc0 = memory.bit.d00 ^ memory.bit.d10 ^ memory.bit.d20 ^ memory.bit.d30 ^ memory.bit.d40 ^ memory.bit.d50 ^ memory.bit.d60 ^ memory.bit.d70 ^ memory.bit.d80 ^ memory.bit.d90; @@ -117,14 +199,14 @@ uint64_t em410x_id_to_memory64(uint8_t id[5]) { /** * @brief 判断场状态 */ - bool lf_is_field_exists(void) { +bool lf_is_field_exists(void) { nrf_drv_lpcomp_enable(); bsp_delay_us(20); // 延迟一段时间再采样，避免误判 nrf_lpcomp_task_trigger(NRF_LPCOMP_TASK_SAMPLE); // 触发一次采样 return nrf_lpcomp_result_get() == 1; // 判断LF场状态的采样结果 } -void timer_ce_handler(nrf_timer_event_t event_type, void* p_context) { +void timer_ce_handler(nrf_timer_event_t event_type, void *p_context) { bool mod; switch (event_type) { // 因为我们配置的是使用CC通道2，所以事件回调 @@ -156,8 +238,8 @@ void timer_ce_handler(nrf_timer_event_t event_type, void* p_context) { // measure field only during no-mod half of last bit of last broadcast if ((! mod) && - (m_bit_send_position + 1 >= LF_125KHZ_EM410X_BIT_SIZE) && - (m_send_id_count + 1 >= LF_125KHZ_BORADCAST_MAX)) { + (m_bit_send_position + 1 >= LF_125KHZ_EM410X_BIT_SIZE) && + (m_send_id_count + 1 >= LF_125KHZ_BORADCAST_MAX)) { nrfx_timer_disable(&m_timer_send_id); // 关闭广播场的定时器 // 我们不需要任何的事件，仅仅需要检测一下场的状态 NRF_LPCOMP->INTENCLR = LPCOMP_INTENCLR_CROSS_Msk | LPCOMP_INTENCLR_UP_Msk | LPCOMP_INTENCLR_DOWN_Msk | LPCOMP_INTENCLR_READY_Msk; @@ -294,7 +376,7 @@ void lf_tag_125khz_sense_switch(bool enable) { * @param type 细化的标签类型 * @param buffer 数据缓冲区 */ -int lf_tag_em410x_data_loadcb(tag_specific_type_t type, tag_data_buffer_t* buffer) { +int lf_tag_em410x_data_loadcb(tag_specific_type_t type, tag_data_buffer_t *buffer) { // 确保外部容量足够转换为信息结构体 if (buffer->length >= LF_EM410X_TAG_ID_SIZE) { // 此处直接转换ID卡号为对应的bit数据流 @@ -312,7 +394,7 @@ int lf_tag_em410x_data_loadcb(tag_specific_type_t type, tag_data_buffer_t* buffe * @param buffer 数据缓冲区 * @return 需要保存的数据的长度，为0时表示不保存 */ -int lf_tag_em410x_data_savecb(tag_specific_type_t type, tag_data_buffer_t* buffer) { +int lf_tag_em410x_data_savecb(tag_specific_type_t type, tag_data_buffer_t *buffer) { // 确保加载了此标签才允许保存 if (m_tag_type != TAG_TYPE_UNKNOWN) { // 直接保存原本的卡包即可 diff --git a/firmware/application/src/rfid/nfctag/lf/lf_tag_em.h b/firmware/application/src/rfid/nfctag/lf/lf_tag_em.h index 2650429..7117c55 100644 --- a/firmware/application/src/rfid/nfctag/lf/lf_tag_em.h +++ b/firmware/application/src/rfid/nfctag/lf/lf_tag_em.h @@ -17,8 +17,8 @@ void lf_tag_125khz_sense_switch(bool enable); -int lf_tag_em410x_data_loadcb(tag_specific_type_t type, tag_data_buffer_t* buffer); -int lf_tag_em410x_data_savecb(tag_specific_type_t type, tag_data_buffer_t* buffer); +int lf_tag_em410x_data_loadcb(tag_specific_type_t type, tag_data_buffer_t *buffer); +int lf_tag_em410x_data_savecb(tag_specific_type_t type, tag_data_buffer_t *buffer); bool lf_tag_em410x_data_factory(uint8_t slot, tag_specific_type_t tag_type); bool lf_is_field_exists(void); diff --git a/firmware/application/src/rfid/nfctag/tag_emulation.c b/firmware/application/src/rfid/nfctag/tag_emulation.c index 848856e..b7217b7 100644 --- a/firmware/application/src/rfid/nfctag/tag_emulation.c +++ b/firmware/application/src/rfid/nfctag/tag_emulation.c @@ -141,7 +141,7 @@ tag_sense_type_t get_sense_type_from_tag_type(tag_specific_type_t type) { /** * 根据类型获取缓冲区信息 */ -tag_data_buffer_t* get_buffer_by_tag_type(tag_specific_type_t type) { +tag_data_buffer_t *get_buffer_by_tag_type(tag_specific_type_t type) { for (int i = 0; i < ARRAY_SIZE(tag_base_map); i++) { if (tag_base_map[i].tag_type == type) { return tag_base_map[i].data_buffer; @@ -309,13 +309,15 @@ void tag_emulation_delete_data(uint8_t slot, tag_sense_type_t sense_type) { // 删除数据 delete_data_by_tag_type(slot, sense_type); // 关闭对应的卡槽的模拟卡类型 - switch(sense_type) { + switch (sense_type) { case TAG_SENSE_HF: { slotConfig.group[slot].tag_hf = TAG_TYPE_UNKNOWN; - } break; + } + break; case TAG_SENSE_LF: { slotConfig.group[slot].tag_lf = TAG_TYPE_UNKNOWN; - } break; + } + break; default: break; } @@ -545,7 +547,8 @@ void tag_emulation_change_type(uint8_t slot, tag_specific_type_t tag_type) { slotConfig.group[slot].tag_hf = tag_type; break; } - default: break; // 永远不能发生 + default: + break; // 永远不能发生 } NRF_LOG_INFO("tag type = %d", tag_type); // 更新完成之后，我们需要通知更新内存中的相关数据 diff --git a/firmware/application/src/rfid/nfctag/tag_emulation.h b/firmware/application/src/rfid/nfctag/tag_emulation.h index 789424f..c451f5c 100644 --- a/firmware/application/src/rfid/nfctag/tag_emulation.h +++ b/firmware/application/src/rfid/nfctag/tag_emulation.h @@ -16,16 +16,16 @@ extern bool g_is_tag_emulating; // 标签的数据缓冲区 typedef struct { uint16_t length; - uint8_t* buffer; - uint16_t* crc; + uint8_t *buffer; + uint16_t *crc; } tag_data_buffer_t; // 场感应使能与闭能切换函数 typedef void (*tag_sense_switch_t)(bool enable); // flash数据加载到RAM后通知给注册者 -typedef int (*tag_datas_loadcb_t)(tag_specific_type_t type, tag_data_buffer_t* buffer); +typedef int (*tag_datas_loadcb_t)(tag_specific_type_t type, tag_data_buffer_t *buffer); // 数据要保存到flash之前通知给注册者 -typedef int (*tag_datas_savecb_t)(tag_specific_type_t type, tag_data_buffer_t* buffer); +typedef int (*tag_datas_savecb_t)(tag_specific_type_t type, tag_data_buffer_t *buffer); // 数据的工厂初始化函数 typedef bool (*tag_datas_factory_t)(uint8_t slot, tag_specific_type_t type); @@ -86,7 +86,7 @@ void tag_emulation_change_type(uint8_t slot, tag_specific_type_t tag_type); bool tag_emulation_load_by_buffer(tag_specific_type_t tag_type, bool update_crc); tag_sense_type_t get_sense_type_from_tag_type(tag_specific_type_t type); -tag_data_buffer_t* get_buffer_by_tag_type(tag_specific_type_t type); +tag_data_buffer_t *get_buffer_by_tag_type(tag_specific_type_t type); // 设置当前使用的卡槽 void tag_emulation_set_slot(uint8_t index); diff --git a/firmware/application/src/rfid/nfctag/tag_persistence.c b/firmware/application/src/rfid/nfctag/tag_persistence.c index dbfa15e..0703b2f 100644 --- a/firmware/application/src/rfid/nfctag/tag_persistence.c +++ b/firmware/application/src/rfid/nfctag/tag_persistence.c @@ -9,7 +9,7 @@ NRF_LOG_MODULE_REGISTER(); -static void get_fds_map_by_slot_auto_inc_id(uint16_t id, uint8_t slot, tag_sense_type_t sense_type, fds_slot_record_map_t* map) { +static void get_fds_map_by_slot_auto_inc_id(uint16_t id, uint8_t slot, tag_sense_type_t sense_type, fds_slot_record_map_t *map) { if ((sense_type == TAG_SENSE_NO) || (slot > 7)) { APP_ERROR_CHECK(NRF_ERROR_INVALID_PARAM); } @@ -20,13 +20,13 @@ static void get_fds_map_by_slot_auto_inc_id(uint16_t id, uint8_t slot, tag_sense /** * Obtain the KEY and ID of the corresponding data in FDS according to the card slot and the field type specified in the card slot */ -void get_fds_map_by_slot_sense_type_for_dump(uint8_t slot, tag_sense_type_t sense_type, fds_slot_record_map_t* map) { +void get_fds_map_by_slot_sense_type_for_dump(uint8_t slot, tag_sense_type_t sense_type, fds_slot_record_map_t *map) { get_fds_map_by_slot_auto_inc_id(FDS_SLOT_TAG_DUMP_FILE_ID_BASE, slot, sense_type, map); } /** * Obtain the KEY and ID of the corresponding data in FDS according to the card slot and the field type specified in the card slot */ -void get_fds_map_by_slot_sense_type_for_nick(uint8_t slot, tag_sense_type_t sense_type, fds_slot_record_map_t* map) { +void get_fds_map_by_slot_sense_type_for_nick(uint8_t slot, tag_sense_type_t sense_type, fds_slot_record_map_t *map) { get_fds_map_by_slot_auto_inc_id(FDS_SLOT_TAG_NICK_NAME_FILE_ID_BASE, slot, sense_type, map); } diff --git a/firmware/application/src/rfid/nfctag/tag_persistence.h b/firmware/application/src/rfid/nfctag/tag_persistence.h index 21b51d0..7d6a9cb 100644 --- a/firmware/application/src/rfid/nfctag/tag_persistence.h +++ b/firmware/application/src/rfid/nfctag/tag_persistence.h @@ -13,11 +13,11 @@ typedef struct { /** * 根据指定的卡槽和卡片场类型，获得其对应的卡片数据的FDS信息的映射对象 */ -void get_fds_map_by_slot_sense_type_for_dump(uint8_t slot, tag_sense_type_t sense_type, fds_slot_record_map_t* map); +void get_fds_map_by_slot_sense_type_for_dump(uint8_t slot, tag_sense_type_t sense_type, fds_slot_record_map_t *map); /** * 根据指定的卡槽和卡片场类型，获得其对应的卡片数据的昵称的FDS信息的映射对象 */ -void get_fds_map_by_slot_sense_type_for_nick(uint8_t slot, tag_sense_type_t sense_type, fds_slot_record_map_t* map); +void get_fds_map_by_slot_sense_type_for_nick(uint8_t slot, tag_sense_type_t sense_type, fds_slot_record_map_t *map); #endif diff --git a/firmware/application/src/rfid/reader/hf/mf1_toolbox.c b/firmware/application/src/rfid/reader/hf/mf1_toolbox.c index e3178ab..25cbb85 100644 --- a/firmware/application/src/rfid/reader/hf/mf1_toolbox.c +++ b/firmware/application/src/rfid/reader/hf/mf1_toolbox.c @@ -115,23 +115,23 @@ uint8_t sendcmd(struct Crypto1State *pcs, uint8_t crypted, uint8_t cmd, uint8_t par[pos] = filter(pcs->odd) ^ oddparity8(dcmd[pos]); } *status = pcd_14a_reader_bits_transfer( - ecmd, - 32, - par, - answer, - answer_parity, - &len, - answer_max_bit - ); + ecmd, + 32, + par, + answer, + answer_parity, + &len, + answer_max_bit + ); } else { *status = pcd_14a_reader_bytes_transfer( - PCD_TRANSCEIVE, - dcmd, - 4, - answer, - &len, - answer_max_bit - ); + PCD_TRANSCEIVE, + dcmd, + 4, + answer, + &len, + answer_max_bit + ); } // 通信有问题，不继续接下来的任务 @@ -268,7 +268,7 @@ uint8_t Darkside_Select_Nonces(picc_14a_tag_t *tag, uint8_t block, uint8_t keyty crc_14a_append(tag_auth, 2); // 进行随机数采集 - for(i = 0; i < NT_COUNT; i++) { + for (i = 0; i < NT_COUNT; i++) { // 在进行天线重置时，我们必须要确保 // 1、天线断电足够久，以此确保卡片完全断电，否则无法重置卡片的伪随机数生成器 // 2、断电时间适中，不要太长，会影响效率，也不要太短，会无法无法重置卡片 @@ -291,9 +291,9 @@ uint8_t Darkside_Select_Nonces(picc_14a_tag_t *tag, uint8_t block, uint8_t keyty } // 对随机数进行取重 - for(i = 0; i < NT_COUNT; i++) { + for (i = 0; i < NT_COUNT; i++) { uint32_t nt_a = nt_list[i]; - for(m = i + 1; m < NT_COUNT; m++) { + for (m = i + 1; m < NT_COUNT; m++) { uint32_t nt_b = nt_list[m]; if (nt_a == nt_b) { nt_count[i] += 1; @@ -304,8 +304,8 @@ uint8_t Darkside_Select_Nonces(picc_14a_tag_t *tag, uint8_t block, uint8_t keyty // 对取重后的最大次数值进行取值 max = nt_count[0]; m = 0; - for(i = 1; i < NT_COUNT; i++) { - if(nt_count[i] > max) { + for (i = 1; i < NT_COUNT; i++) { + if (nt_count[i] > max) { max = nt_count[i]; m = i; } @@ -313,7 +313,7 @@ uint8_t Darkside_Select_Nonces(picc_14a_tag_t *tag, uint8_t block, uint8_t keyty // 最终，我们判定一下max次数是否大于0， // 如果不大于0，说明无法同步时钟。 - if(max == 0) { + if (max == 0) { NRF_LOG_INFO("Can't sync nt.\n"); return DARKSIDE_CANT_FIXED_NT; } @@ -332,7 +332,7 @@ uint8_t Darkside_Select_Nonces(picc_14a_tag_t *tag, uint8_t block, uint8_t keyty * */ uint8_t Darkside_Recover_Key(uint8_t targetBlk, uint8_t targetTyp, - uint8_t firstRecover, uint8_t ntSyncMax, DarksideCore* dc) { + uint8_t firstRecover, uint8_t ntSyncMax, DarksideCore *dc) { // 被固定使用的卡片信息 static uint32_t uid_ori = 0; @@ -507,7 +507,7 @@ uint8_t Darkside_Recover_Key(uint8_t targetBlk, uint8_t targetTyp, par = ((par & 0x1F) + 1) | par_low; } } - } while(1); + } while (1); mf_nr_ar[3] &= 0x1F; @@ -703,8 +703,7 @@ uint8_t Check_WeakNested_Support() { * @retval : 距离值 * */ -uint32_t measure_nonces(uint32_t from, uint32_t to) -{ +uint32_t measure_nonces(uint32_t from, uint32_t to) { // 给出初始的坐标值 uint32_t msb = from >> 16; uint32_t lsb = to >> 16; @@ -729,10 +728,10 @@ uint32_t measure_medin(uint32_t *src, uint32_t length) { return src[0]; } - for (i = 0;i < len;i++) { + for (i = 0; i < len; i++) { // i是已排列的序列的末尾 minIndex = i; - for (int j = i + 1;j < len;j++) { + for (int j = i + 1; j < len; j++) { if (src[j] < src[minIndex]) { minIndex = j; } @@ -772,12 +771,12 @@ uint8_t Measure_Distance(uint64_t u64Key, uint8_t block, uint8_t type, uint32_t return HF_TAG_NO; } // 进行第一次验证，以便获取未经加密的NT1 - if(authex(pcs, uid, block, type, u64Key, AUTH_FIRST, &nt1) != HF_TAG_OK) { + if (authex(pcs, uid, block, type, u64Key, AUTH_FIRST, &nt1) != HF_TAG_OK) { NRF_LOG_INFO("Auth failed 1\r\n"); return MF_ERRAUTH; } // 进行嵌套验证，以便获取经过加密的NT2_ENC - if(authex(pcs, uid, block, type, u64Key, AUTH_NESTED, &nt2) != HF_TAG_OK) { + if (authex(pcs, uid, block, type, u64Key, AUTH_NESTED, &nt2) != HF_TAG_OK) { NRF_LOG_INFO("Auth failed 2\r\n"); return MF_ERRAUTH; } @@ -791,7 +790,7 @@ uint8_t Measure_Distance(uint64_t u64Key, uint8_t block, uint8_t type, uint32_t // 测量完成之后存放到buffer中 distances[index++] = measure_nonces(nt1, nt2); // dbg_block_printf("dist = %"PRIu32"\n\n", distances[index - 1]); - } while(index < DIST_NR); + } while (index < DIST_NR); // 最终计算两个NT的距离并且直接传出 *distance = measure_medin(distances, DIST_NR); @@ -826,7 +825,7 @@ uint8_t Nested_Recover_Core(NestedCore *pnc, uint64_t keyKnown, uint8_t blkKnown return HF_TAG_NO; } // 第一步验证，基础验证不需要嵌套加密 - if(authex(pcs, uid, blkKnown, typKnown, keyKnown, AUTH_FIRST, &nt1) != HF_TAG_OK) { + if (authex(pcs, uid, blkKnown, typKnown, keyKnown, AUTH_FIRST, &nt1) != HF_TAG_OK) { return MF_ERRAUTH; } // 然后就是嵌套验证 @@ -860,19 +859,19 @@ uint8_t Nested_Recover_Key(uint64_t keyKnown, uint8_t blkKnown, uint8_t typKnown uint8_t m, res; // 先寻卡，所有的操作都要基于有卡的情况 res = pcd_14a_reader_scan_auto(p_tag_info); - if (res!= HF_TAG_OK) { + if (res != HF_TAG_OK) { return res; } // 然后采集指定个数的随机数组 for (m = 0; m < SETS_NR; m++) { res = Nested_Recover_Core( - &(ncs[m]), - keyKnown, - blkKnown, - typKnown, - targetBlock, - targetType - ); + &(ncs[m]), + keyKnown, + blkKnown, + typKnown, + targetBlock, + targetType + ); if (res != HF_TAG_OK) { return res; } @@ -902,11 +901,11 @@ uint8_t Nested_Distacne_Detect(uint8_t block, uint8_t type, uint8_t *key, Nested } // 获取距离，为接下来的攻击做准备 status = Measure_Distance( - bytes_to_num(key, 6), - block, - type, - &distance - ); + bytes_to_num(key, 6), + block, + type, + &distance + ); // 一切正常，我们需要将距离值放入结果中 if (status == HF_TAG_OK) { num_to_bytes(distance, 4, nd->distance); @@ -919,7 +918,7 @@ uint8_t Nested_Distacne_Detect(uint8_t block, uint8_t type, uint8_t *key, Nested * @retval : 验证结果 * */ -uint8_t auth_key_use_522_hw(uint8_t block, uint8_t type, uint8_t* key) { +uint8_t auth_key_use_522_hw(uint8_t block, uint8_t type, uint8_t *key) { // 每次验证一个block都要重新寻卡 if (pcd_14a_reader_scan_auto(p_tag_info) != HF_TAG_OK) { return HF_TAG_NO; diff --git a/firmware/application/src/rfid/reader/hf/mf1_toolbox.h b/firmware/application/src/rfid/reader/hf/mf1_toolbox.h index dcac380..c5354eb 100644 --- a/firmware/application/src/rfid/reader/hf/mf1_toolbox.h +++ b/firmware/application/src/rfid/reader/hf/mf1_toolbox.h @@ -50,7 +50,7 @@ uint8_t Darkside_Recover_Key( uint8_t targetTyp, uint8_t firstRecover, uint8_t ntSyncMax, - DarksideCore* dc + DarksideCore *dc ); uint8_t Nested_Distacne_Detect( uint8_t block, @@ -70,7 +70,7 @@ uint8_t Check_Darkside_Support(void); uint8_t Check_WeakNested_Support(void); uint8_t Check_STDMifareNT_Support(void); void Atenna_Switch_Delay(uint32_t delay_ms); -uint8_t auth_key_use_522_hw(uint8_t block, uint8_t type, uint8_t* key); +uint8_t auth_key_use_522_hw(uint8_t block, uint8_t type, uint8_t *key); #ifdef __cplusplus } diff --git a/firmware/application/src/rfid/reader/hf/rc522.c b/firmware/application/src/rfid/reader/hf/rc522.c index defdd86..ee23e56 100644 --- a/firmware/application/src/rfid/reader/hf/rc522.c +++ b/firmware/application/src/rfid/reader/hf/rc522.c @@ -32,7 +32,7 @@ static bool m_reader_is_init = false; // 通信超时 static uint16_t g_com_timeout_ms = DEF_COM_TIMEOUT; -static autotimer* g_timeout_auto_timer; +static autotimer *g_timeout_auto_timer; // RC522使用的SPI #define SPI_INSTANCE 0 /**< SPI instance index. */ @@ -45,19 +45,18 @@ static const nrf_drv_spi_t s_spiHandle = NRF_DRV_SPI_INSTANCE(SPI_INSTANCE); * @param ：Address：寄存器地址 * @retval ：寄存器内的值 */ -uint8_t read_register_single(uint8_t Address) -{ +uint8_t read_register_single(uint8_t Address) { RC522_DOSEL; Address = (uint8_t)(((Address << 1) & 0x7E) | 0x80); NRF_SPI0->TXD = Address; - while ( NRF_SPI0->EVENTS_READY == 0 ); + while (NRF_SPI0->EVENTS_READY == 0); NRF_SPI0->EVENTS_READY = 0; (void)NRF_SPI0->RXD; NRF_SPI0->TXD = Address; - while ( NRF_SPI0->EVENTS_READY == 0 ); + while (NRF_SPI0->EVENTS_READY == 0); NRF_SPI0->EVENTS_READY = 0; Address = NRF_SPI0->RXD; @@ -66,14 +65,13 @@ uint8_t read_register_single(uint8_t Address) return Address; } -void read_register_buffer(uint8_t Address, uint8_t *pInBuffer, uint8_t len) -{ +void read_register_buffer(uint8_t Address, uint8_t *pInBuffer, uint8_t len) { RC522_DOSEL; Address = (((Address << 1) & 0x7E) | 0x80); NRF_SPI0->TXD = Address; - while ( NRF_SPI0->EVENTS_READY == 0 ); // 等待传输结束 + while (NRF_SPI0->EVENTS_READY == 0); // 等待传输结束 NRF_SPI0->EVENTS_READY = 0; (void)NRF_SPI0->RXD; // 读取一次，给一个电平 @@ -81,10 +79,10 @@ void read_register_buffer(uint8_t Address, uint8_t *pInBuffer, uint8_t len) do { // 然后开始收数据 NRF_SPI0->TXD = Address; - while ( NRF_SPI0->EVENTS_READY == 0 ); // 等待传输结束 + while (NRF_SPI0->EVENTS_READY == 0); // 等待传输结束 NRF_SPI0->EVENTS_READY = 0; pInBuffer[i] = NRF_SPI0->RXD; // 读取一次，给一个电平 - } while(++i < len); + } while (++i < len); RC522_UNSEL; } @@ -94,35 +92,33 @@ void read_register_buffer(uint8_t Address, uint8_t *pInBuffer, uint8_t len) * @param ：Address：寄存器地址 * value: 将要写入的值 */ -void ONCE_OPT write_register_single(uint8_t Address, uint8_t value) -{ +void ONCE_OPT write_register_single(uint8_t Address, uint8_t value) { RC522_DOSEL; Address = ((Address << 1) & 0x7E); // 先传地址 NRF_SPI0->TXD = Address; - while ( NRF_SPI0->EVENTS_READY == 0 ); + while (NRF_SPI0->EVENTS_READY == 0); NRF_SPI0->EVENTS_READY = 0; (void)NRF_SPI0->RXD; // 再传要写的值 NRF_SPI0->TXD = value; - while ( NRF_SPI0->EVENTS_READY == 0 ); + while (NRF_SPI0->EVENTS_READY == 0); NRF_SPI0->EVENTS_READY = 0; (void)NRF_SPI0->RXD; RC522_UNSEL; } -void write_register_buffer(uint8_t Address, uint8_t *values, uint8_t len) -{ +void write_register_buffer(uint8_t Address, uint8_t *values, uint8_t len) { RC522_DOSEL; Address = ((Address << 1) & 0x7E); NRF_SPI0->TXD = Address; - while ( NRF_SPI0->EVENTS_READY == 0 ); + while (NRF_SPI0->EVENTS_READY == 0); NRF_SPI0->EVENTS_READY = 0; (void)NRF_SPI0->RXD; @@ -130,10 +126,10 @@ void write_register_buffer(uint8_t Address, uint8_t *values, uint8_t len) do { // 然后疯狂发数据 NRF_SPI0->TXD = values[i]; - while ( NRF_SPI0->EVENTS_READY == 0 ); + while (NRF_SPI0->EVENTS_READY == 0); NRF_SPI0->EVENTS_READY = 0; (void)NRF_SPI0->RXD; - } while(++i < len); + } while (++i < len); RC522_UNSEL; } @@ -143,8 +139,7 @@ void write_register_buffer(uint8_t Address, uint8_t *values, uint8_t len) * @param ：reg：寄存器地址 * mask: 开关范围 */ -inline void set_register_mask(uint8_t reg, uint8_t mask) -{ +inline void set_register_mask(uint8_t reg, uint8_t mask) { write_register_single(reg, read_register_single(reg) | mask); // set bit mask } @@ -153,8 +148,7 @@ inline void set_register_mask(uint8_t reg, uint8_t mask) * @param ：reg：寄存器地址 * mask: 开关范围 */ -inline void clear_register_mask(uint8_t reg, uint8_t mask) -{ +inline void clear_register_mask(uint8_t reg, uint8_t mask) { write_register_single(reg, read_register_single(reg) & ~mask); // clear bit mask } @@ -162,8 +156,7 @@ inline void clear_register_mask(uint8_t reg, uint8_t mask) * @brief 初始化读卡器 * @retval 无 */ -void pcd_14a_reader_init(void) -{ +void pcd_14a_reader_init(void) { // 确保只初始化一次 if (!m_reader_is_init) { // 标志为已经初始化状态 @@ -196,8 +189,7 @@ void pcd_14a_reader_init(void) * @brief ：重置读卡器 * @retval ：状态值HF_TAG_OK，成功 */ -void pcd_14a_reader_reset(void) -{ +void pcd_14a_reader_reset(void) { // 确保已经初始化再进行通信与软重置 if (m_reader_is_init) { // 软重置 522 @@ -226,8 +218,7 @@ void pcd_14a_reader_reset(void) * @brief 反初始化读卡器 * @retval 无 */ -void pcd_14a_reader_uninit(void) -{ +void pcd_14a_reader_uninit(void) { // 确保已经初始化过设备了，再进行反初始化 if (m_reader_is_init) { m_reader_is_init = false; @@ -242,8 +233,7 @@ void pcd_14a_reader_uninit(void) * * @retval 无 */ -void pcd_14a_reader_timeout_set(uint16_t timeout_ms) -{ +void pcd_14a_reader_timeout_set(uint16_t timeout_ms) { g_com_timeout_ms = timeout_ms; } @@ -265,8 +255,7 @@ uint16_t pcd_14a_reader_timeout_get() { * pOutLenBit：返回数据的位长度 * @retval ：状态值MI_OK，成功 */ -uint8_t pcd_14a_reader_bytes_transfer(uint8_t Command, uint8_t* pIn, uint8_t InLenByte, uint8_t* pOut, uint16_t* pOutLenBit, uint16_t maxOutLenBit) -{ +uint8_t pcd_14a_reader_bytes_transfer(uint8_t Command, uint8_t *pIn, uint8_t InLenByte, uint8_t *pOut, uint16_t *pOutLenBit, uint16_t maxOutLenBit) { uint8_t status = HF_ERRSTAT; uint8_t waitFor = 0x00; uint8_t lastBits = 0; @@ -276,7 +265,7 @@ uint8_t pcd_14a_reader_bytes_transfer(uint8_t Command, uint8_t* pIn, uint8_t In // 重置接收到的数据的长度 *pOutLenBit = 0; - switch(Command) { + switch (Command) { case PCD_AUTHENT: // Mifare认证 waitFor = 0x10; // 认证寻卡等待时候 查询空闲中断标志位 break; @@ -299,7 +288,7 @@ uint8_t pcd_14a_reader_bytes_transfer(uint8_t Command, uint8_t* pIn, uint8_t In if (pOut == NULL) { // 如果开发者不需要接收数据，那么在发送完成后直接返回！ - while((read_register_single(Status2Reg) & 0x07) == 0x03); + while ((read_register_single(Status2Reg) & 0x07) == 0x03); return HF_TAG_OK; } @@ -401,8 +390,7 @@ uint8_t pcd_14a_reader_bytes_transfer(uint8_t Command, uint8_t* pIn, uint8_t In * @retval ：成功的时候返回卡片回应的数据的比特长度， 失败的时候返回对应的错误码。 */ -uint8_t pcd_14a_reader_bits_transfer(uint8_t* pTx, uint16_t szTxBits, uint8_t* pTxPar, uint8_t* pRx, uint8_t* pRxPar, uint16_t* pRxLenBit, uint16_t szRxLenBitMax) -{ +uint8_t pcd_14a_reader_bits_transfer(uint8_t *pTx, uint16_t szTxBits, uint8_t *pTxPar, uint8_t *pRx, uint8_t *pRxPar, uint16_t *pRxLenBit, uint16_t szRxLenBitMax) { static uint8_t buffer[DEF_FIFO_LENGTH]; uint8_t status = 0, @@ -418,20 +406,20 @@ uint8_t pcd_14a_reader_bits_transfer(uint8_t* pTx, uint16_t szTxBits, uint8_t* // 多出对应字节个数的bit的数据 modulus = dataLen = szTxBits / 8; buffer[1] = (pTxPar[0] | (pTx[1] << 1)); - for( i = 2; i < dataLen; i++ ) { + for (i = 2; i < dataLen; i++) { // add the remaining prev byte and parity buffer[i] = ((pTxPar[i - 1] << (i - 1)) | (pTx[ i - 1] >> (9 - i))); // add next byte and push i bits buffer[i] |= (pTx[i] << i); } // add remainder of last byte + end parity - buffer[dataLen] = ((pTxPar[dataLen - 1] << (i - 1)) | (pTx[dataLen-1] >> (9 - i))); + buffer[dataLen] = ((pTxPar[dataLen - 1] << (i - 1)) | (pTx[dataLen - 1] >> (9 - i))); dataLen += 1; } else { modulus = szTxBits % 8; dataLen = modulus > 0 ? (szTxBits / 8 + 1) : (szTxBits / 8); // 不需要合并奇偶校验位，就当做是外部已经做好了此处理 - for( i = 1; i < dataLen; i++ ) { + for (i = 1; i < dataLen; i++) { buffer[i] = pTx[i]; } } @@ -444,13 +432,13 @@ uint8_t pcd_14a_reader_bits_transfer(uint8_t* pTx, uint16_t szTxBits, uint8_t* set_register_mask(MfRxReg, 0x10); // 需要关闭奇偶校验位的使能 status = pcd_14a_reader_bytes_transfer( - PCD_TRANSCEIVE, - buffer, - dataLen, // 数据的字节计数 - buffer, // 接收缓冲区 - pRxLenBit, // 接收到的数据的长度，注意，是比特流的长度 - U8ARR_BIT_LEN(buffer) // 能收的数据的上限长度 - ); + PCD_TRANSCEIVE, + buffer, + dataLen, // 数据的字节计数 + buffer, // 接收缓冲区 + pRxLenBit, // 接收到的数据的长度，注意，是比特流的长度 + U8ARR_BIT_LEN(buffer) // 能收的数据的上限长度 + ); clear_register_mask(BitFramingReg, modulus); clear_register_mask(MfRxReg, 0x10); // 使能奇偶校验位 @@ -480,14 +468,14 @@ uint8_t pcd_14a_reader_bits_transfer(uint8_t* pTx, uint16_t szTxBits, uint8_t* } // 最终的奇偶校验与数据的分离解包过程 - for(i = 1; i < dataLen - 1; i++) { + for (i = 1; i < dataLen - 1; i++) { if (pRxPar != NULL) { pRxPar[i - 1] = (buffer[i] & (1 << (i - 1))) >> (i - 1); } pRx[i] = (buffer[i] >> i) | (buffer[i + 1] << (8 - i)); } if (pRxPar != NULL) { - pRxPar[i - 1] = (buffer[i] & (1 << (i - 1)) ) >> (i - 1); + pRxPar[i - 1] = (buffer[i] & (1 << (i - 1))) >> (i - 1); } } return HF_TAG_OK; @@ -678,8 +666,7 @@ uint8_t pcd_14a_reader_atqa_request(uint8_t *resp, uint8_t *resp_par, uint16_t r * * @retval ：状态值 HF_TAG_OK，解锁成功，其他状态值表示解锁失败 */ -uint8_t pcd_14a_reader_gen1a_unlock(void) -{ +uint8_t pcd_14a_reader_gen1a_unlock(void) { // 初始化变量 uint8_t unlock, status; uint16_t rx_length = 0; @@ -717,8 +704,7 @@ uint8_t pcd_14a_reader_gen1a_unlock(void) * @retval ：状态值 HF_TAG_OK，封卡或者存在封卡后门， 其他状态值表示封卡失败或者没有封卡后门 */ -uint8_t pcd_14a_reader_gen1a_uplock(void) -{ +uint8_t pcd_14a_reader_gen1a_uplock(void) { uint8_t status; uint16_t rx_length = 0; @@ -759,8 +745,7 @@ uint8_t pcd_14a_reader_gen1a_uplock(void) * pSnr：卡片序列号，4字节 * @retval ：状态值HF_TAG_OK成功，TAG_ERRAUTH失败，其他的返回值表示一些通信错误相关的异常！ */ -uint8_t pcd_14a_reader_mf1_auth(picc_14a_tag_t *tag, uint8_t type, uint8_t addr, uint8_t* pKey) -{ +uint8_t pcd_14a_reader_mf1_auth(picc_14a_tag_t *tag, uint8_t type, uint8_t addr, uint8_t *pKey) { uint8_t dat_buff[12] = { type, addr }; uint16_t data_len = 0; @@ -793,7 +778,7 @@ void pcd_14a_reader_mf1_unauth(void) { * p ：读出的数据，16字节 * @retval ：状态值HF_TAG_OK，成功 */ -uint8_t pcd_14a_reader_mf1_read_by_cmd(uint8_t cmd, uint8_t addr, uint8_t* p) { +uint8_t pcd_14a_reader_mf1_read_by_cmd(uint8_t cmd, uint8_t addr, uint8_t *p) { uint8_t status; uint16_t len; uint8_t dat_buff[MAX_MIFARE_FRAME_SIZE] = { cmd, addr }; @@ -803,8 +788,7 @@ uint8_t pcd_14a_reader_mf1_read_by_cmd(uint8_t cmd, uint8_t addr, uint8_t* p) { crc_14a_append(dat_buff, 2); // 然后发起通信 status = pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, dat_buff, 4, dat_buff, &len, U8ARR_BIT_LEN(dat_buff)); - if (status == HF_TAG_OK) - { + if (status == HF_TAG_OK) { if (len == 0x90 /* 0x90 = 144bits */) { // 16字节长度的CRC数据，为了不浪费CPU性能， // 我们可以让 522 去计算 @@ -831,8 +815,7 @@ uint8_t pcd_14a_reader_mf1_read_by_cmd(uint8_t cmd, uint8_t addr, uint8_t* p) { * p ：读出的数据，16字节 * @retval ：状态值HF_TAG_OK，成功 */ -uint8_t pcd_14a_reader_mf1_read(uint8_t addr, uint8_t* p) -{ +uint8_t pcd_14a_reader_mf1_read(uint8_t addr, uint8_t *p) { // 标准的M1规范内的读卡 return pcd_14a_reader_mf1_read_by_cmd(PICC_READ, addr, p); } @@ -845,7 +828,7 @@ uint8_t pcd_14a_reader_mf1_read(uint8_t addr, uint8_t* p) * * @retval ：状态值HF_TAG_OK，成功 */ -uint8_t pcd_14a_reader_mf1_write_by_cmd(uint8_t cmd, uint8_t addr, uint8_t* p) { +uint8_t pcd_14a_reader_mf1_write_by_cmd(uint8_t cmd, uint8_t addr, uint8_t *p) { uint8_t status; uint16_t dat_len; @@ -897,8 +880,7 @@ uint8_t pcd_14a_reader_mf1_write_by_cmd(uint8_t cmd, uint8_t addr, uint8_t* p) { * p：写入的数据，16字节 * @retval ：状态值HF_TAG_OK，成功 */ -uint8_t pcd_14a_reader_mf1_write(uint8_t addr, uint8_t* p) -{ +uint8_t pcd_14a_reader_mf1_write(uint8_t addr, uint8_t *p) { // 标准的M1规范内的写卡 return pcd_14a_reader_mf1_write_by_cmd(PICC_WRITE, addr, p); } @@ -908,8 +890,7 @@ uint8_t pcd_14a_reader_mf1_write(uint8_t addr, uint8_t* p) * @param ：无 * @retval ：状态值 TAG_NOTAG，成功 */ -uint8_t pcd_14a_reader_halt_tag(void) -{ +uint8_t pcd_14a_reader_halt_tag(void) { uint8_t status; uint16_t unLen; // 直接准备好成型的数据了，还计算个鬼的CRC @@ -923,8 +904,7 @@ uint8_t pcd_14a_reader_halt_tag(void) * @param ：无 * @retval ：无 */ -void pcd_14a_reader_fast_halt_tag(void) -{ +void pcd_14a_reader_fast_halt_tag(void) { uint8_t data[] = { PICC_HALT, 0x00, 0x57, 0xCD }; pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, data, 4, NULL, NULL, U8ARR_BIT_LEN(data)); } @@ -936,8 +916,7 @@ void pcd_14a_reader_fast_halt_tag(void) * pOut：存放计算结果存放的首地址 * @retval ：状态值HF_TAG_OK，成功 */ -void pcd_14a_reader_calc_crc(uint8_t* pbtData, size_t szLen, uint8_t* pbtCrc) -{ +void pcd_14a_reader_calc_crc(uint8_t *pbtData, size_t szLen, uint8_t *pbtCrc) { uint8_t i, n; // 重置状态机 @@ -951,8 +930,7 @@ void pcd_14a_reader_calc_crc(uint8_t* pbtData, size_t szLen, uint8_t* pbtCrc) // 等待计算完成 i = szLen * 2; - do - { + do { n = read_register_single(Status1Reg); i--; } while ((i != 0) && !(n & 0x20)); @@ -965,16 +943,14 @@ void pcd_14a_reader_calc_crc(uint8_t* pbtData, size_t szLen, uint8_t* pbtCrc) /** * @brief ：开启天线 */ -inline void pcd_14a_reader_antenna_on(void) -{ +inline void pcd_14a_reader_antenna_on(void) { set_register_mask(TxControlReg, 0x03); } /** * @brief ：关闭天线 */ -inline void pcd_14a_reader_antenna_off(void) -{ +inline void pcd_14a_reader_antenna_off(void) { clear_register_mask(TxControlReg, 0x03); } @@ -1002,10 +978,9 @@ inline void pcd_14a_reader_parity_off(void) { * @retval : 转换结果 * */ -uint8_t cascade_to_cmd(uint8_t cascade) -{ +uint8_t cascade_to_cmd(uint8_t cascade) { uint8_t ret = PICC_ANTICOLL1; - switch(cascade) { + switch (cascade) { case 1: ret = PICC_ANTICOLL1; break; @@ -1033,10 +1008,9 @@ uint8_t cascade_to_cmd(uint8_t cascade) * 此地址根据 tag 处于的内存位置决定生命周期。 * */ -uint8_t* get_4byte_tag_uid(picc_14a_tag_t *tag, uint8_t *pUid) -{ +uint8_t *get_4byte_tag_uid(picc_14a_tag_t *tag, uint8_t *pUid) { uint8_t *p_TmpUid = NULL; - switch(tag->cascade) { + switch (tag->cascade) { case 1: p_TmpUid = tag->uid; break; @@ -1064,8 +1038,7 @@ uint8_t* get_4byte_tag_uid(picc_14a_tag_t *tag, uint8_t *pUid) * @retval : 转换结果 * */ -uint32_t get_u32_tag_uid(picc_14a_tag_t *tag) -{ +uint32_t get_u32_tag_uid(picc_14a_tag_t *tag) { uint8_t uid_buf[4] = { 0x00 }; // 直接调用封装好的函数拷贝目标值 get_4byte_tag_uid(tag, uid_buf); @@ -1076,14 +1049,16 @@ uint32_t get_u32_tag_uid(picc_14a_tag_t *tag) * @brief 在选中的平台上上计算CRC * */ -inline void crc_14a_calculate(uint8_t* pbtData, size_t szLen, uint8_t* pbtCrc) { - switch(m_crc_computer) { +inline void crc_14a_calculate(uint8_t *pbtData, size_t szLen, uint8_t *pbtCrc) { + switch (m_crc_computer) { case 0: { calc_14a_crc_lut(pbtData, szLen, pbtCrc); - } break; + } + break; case 1: { pcd_14a_reader_calc_crc(pbtData, szLen, pbtCrc); - } break; + } + break; default: { // } break; @@ -1095,14 +1070,16 @@ inline void crc_14a_calculate(uint8_t* pbtData, size_t szLen, uint8_t* pbtCrc) { * @brief 向数据结尾追加计算后的CRC * */ -inline void crc_14a_append(uint8_t* pbtData, size_t szLen) { - switch(m_crc_computer) { +inline void crc_14a_append(uint8_t *pbtData, size_t szLen) { + switch (m_crc_computer) { case 0: { calc_14a_crc_lut(pbtData, szLen, pbtData + szLen); - } break; + } + break; case 1: { pcd_14a_reader_calc_crc(pbtData, szLen, pbtData + szLen); - } break; + } + break; default: { } break; diff --git a/firmware/application/src/rfid/reader/hf/rc522.h b/firmware/application/src/rfid/reader/hf/rc522.h index 9ceebc1..1d4f3c1 100644 --- a/firmware/application/src/rfid/reader/hf/rc522.h +++ b/firmware/application/src/rfid/reader/hf/rc522.h @@ -162,74 +162,74 @@ typedef struct { #ifdef __cplusplus extern "C" { #endif - // Device control - void pcd_14a_reader_init(void); - void pcd_14a_reader_uninit(void); - void pcd_14a_reader_reset(void); - void pcd_14a_reader_antenna_on(void); - void pcd_14a_reader_antenna_off(void); +// Device control +void pcd_14a_reader_init(void); +void pcd_14a_reader_uninit(void); +void pcd_14a_reader_reset(void); +void pcd_14a_reader_antenna_on(void); +void pcd_14a_reader_antenna_off(void); - // Device register - uint8_t read_register_single(uint8_t Address); - void write_register_single(uint8_t Address, uint8_t value); - void clear_register_mask(uint8_t reg, uint8_t mask); - void set_register_mask(uint8_t reg, uint8_t mask); +// Device register +uint8_t read_register_single(uint8_t Address); +void write_register_single(uint8_t Address, uint8_t value); +void clear_register_mask(uint8_t reg, uint8_t mask); +void set_register_mask(uint8_t reg, uint8_t mask); - // Device comunication control - uint16_t pcd_14a_reader_timeout_get(void); - void pcd_14a_reader_timeout_set(uint16_t timeout_ms); +// Device comunication control +uint16_t pcd_14a_reader_timeout_get(void); +void pcd_14a_reader_timeout_set(uint16_t timeout_ms); - // Device comunication interface - uint8_t pcd_14a_reader_bytes_transfer(uint8_t Command, - uint8_t* pIn, - uint8_t InLenByte, - uint8_t* pOut, - uint16_t* pOutLenBit, - uint16_t maxOutLenBit); - uint8_t pcd_14a_reader_bits_transfer(uint8_t* pTx, - uint16_t szTxBits, - uint8_t* pTxPar, - uint8_t* pRx, - uint8_t* pRxPar, - uint16_t* pRxLenBit, - uint16_t szRxLenBitMax); +// Device comunication interface +uint8_t pcd_14a_reader_bytes_transfer(uint8_t Command, + uint8_t *pIn, + uint8_t InLenByte, + uint8_t *pOut, + uint16_t *pOutLenBit, + uint16_t maxOutLenBit); +uint8_t pcd_14a_reader_bits_transfer(uint8_t *pTx, + uint16_t szTxBits, + uint8_t *pTxPar, + uint8_t *pRx, + uint8_t *pRxPar, + uint16_t *pRxLenBit, + uint16_t szRxLenBitMax); - // Device auto append and check 14443-A parity enable or disable. - void pcd_14a_reader_parity_on(void); - void pcd_14a_reader_parity_off(void); +// Device auto append and check 14443-A parity enable or disable. +void pcd_14a_reader_parity_on(void); +void pcd_14a_reader_parity_off(void); - // 14443-A tag operation - uint8_t pcd_14a_reader_scan_auto(picc_14a_tag_t *tag); - uint8_t pcd_14a_reader_ats_request(uint8_t *pAts, uint16_t *szAts, uint16_t szAtsBitMax); - uint8_t pcd_14a_reader_atqa_request(uint8_t *resp, uint8_t *resp_par, uint16_t resp_max_bit); +// 14443-A tag operation +uint8_t pcd_14a_reader_scan_auto(picc_14a_tag_t *tag); +uint8_t pcd_14a_reader_ats_request(uint8_t *pAts, uint16_t *szAts, uint16_t szAtsBitMax); +uint8_t pcd_14a_reader_atqa_request(uint8_t *resp, uint8_t *resp_par, uint16_t resp_max_bit); - // M1 tag operation - uint8_t pcd_14a_reader_mf1_auth(picc_14a_tag_t *tag, uint8_t type, uint8_t addr, uint8_t* pKey); - void pcd_14a_reader_mf1_unauth(void); - // 写卡操作 - uint8_t pcd_14a_reader_mf1_write_by_cmd(uint8_t cmd, uint8_t addr, uint8_t* p); - uint8_t pcd_14a_reader_mf1_write(uint8_t addr, uint8_t* pData); - // 读卡操作 - uint8_t pcd_14a_reader_mf1_read_by_cmd(uint8_t cmd, uint8_t addr, uint8_t* p); - uint8_t pcd_14a_reader_mf1_read(uint8_t addr, uint8_t* pData); - // 休眠卡操作 - uint8_t pcd_14a_reader_halt_tag(void); - void pcd_14a_reader_fast_halt_tag(void); +// M1 tag operation +uint8_t pcd_14a_reader_mf1_auth(picc_14a_tag_t *tag, uint8_t type, uint8_t addr, uint8_t *pKey); +void pcd_14a_reader_mf1_unauth(void); +// 写卡操作 +uint8_t pcd_14a_reader_mf1_write_by_cmd(uint8_t cmd, uint8_t addr, uint8_t *p); +uint8_t pcd_14a_reader_mf1_write(uint8_t addr, uint8_t *pData); +// 读卡操作 +uint8_t pcd_14a_reader_mf1_read_by_cmd(uint8_t cmd, uint8_t addr, uint8_t *p); +uint8_t pcd_14a_reader_mf1_read(uint8_t addr, uint8_t *pData); +// 休眠卡操作 +uint8_t pcd_14a_reader_halt_tag(void); +void pcd_14a_reader_fast_halt_tag(void); - // UID & UFUID tag operation - uint8_t pcd_14a_reader_gen1a_unlock(void); - uint8_t pcd_14a_reader_gen1a_uplock(void); +// UID & UFUID tag operation +uint8_t pcd_14a_reader_gen1a_unlock(void); +uint8_t pcd_14a_reader_gen1a_uplock(void); - // CRC calulate - void pcd_14a_reader_calc_crc(uint8_t* pbtData, size_t szLen, uint8_t* pbtCrc); - void crc_14a_calculate(uint8_t* pbtData, size_t szLen, uint8_t* pbtCrc); - void crc_14a_append(uint8_t* pbtData, size_t szLen); - void pcd_14a_reader_crc_computer(uint8_t use522CalcCRC); +// CRC calulate +void pcd_14a_reader_calc_crc(uint8_t *pbtData, size_t szLen, uint8_t *pbtCrc); +void crc_14a_calculate(uint8_t *pbtData, size_t szLen, uint8_t *pbtCrc); +void crc_14a_append(uint8_t *pbtData, size_t szLen); +void pcd_14a_reader_crc_computer(uint8_t use522CalcCRC); - // other - uint8_t cascade_to_cmd(uint8_t cascade); - uint32_t get_u32_tag_uid(picc_14a_tag_t *tag); - uint8_t* get_4byte_tag_uid(picc_14a_tag_t *tag, uint8_t *out); +// other +uint8_t cascade_to_cmd(uint8_t cascade); +uint32_t get_u32_tag_uid(picc_14a_tag_t *tag); +uint8_t *get_4byte_tag_uid(picc_14a_tag_t *tag, uint8_t *out); #ifdef __cplusplus } #endif diff --git a/firmware/application/src/rfid/reader/lf/data_utils.c b/firmware/application/src/rfid/reader/lf/data_utils.c index a40b818..927c162 100644 --- a/firmware/application/src/rfid/reader/lf/data_utils.c +++ b/firmware/application/src/rfid/reader/lf/data_utils.c @@ -2,10 +2,8 @@ #include //向raw写入2bit数据，datab存0bit，dataa存1bit -void writebit(uint8_t *dataa, uint8_t *datab, uint8_t pos, uint8_t adata) -{ - if (adata >= 4) - { +void writebit(uint8_t *dataa, uint8_t *datab, uint8_t pos, uint8_t adata) { + if (adata >= 4) { return; } static uint8_t aimbyte = 0; @@ -17,22 +15,19 @@ void writebit(uint8_t *dataa, uint8_t *datab, uint8_t pos, uint8_t adata) } //输出raw的2bit组合数据 -uint8_t readbit(uint8_t *dataa, uint8_t *datab, uint8_t pos) -{ +uint8_t readbit(uint8_t *dataa, uint8_t *datab, uint8_t pos) { static uint8_t aimbyte = 0; static uint8_t aimbit = 0; aimbyte = pos / 8; aimbit = pos % 8; return ( - (getbit(dataa[aimbyte], aimbit) << 1) | - (getbit(datab[aimbyte], aimbit))); + (getbit(dataa[aimbyte], aimbit) << 1) | + (getbit(datab[aimbyte], aimbit))); } //向raw写入2bit数据(大端方法，每个byte的第8位写数据的第1位)，datab存0bit，dataa存1bit -void writebit_msb(uint8_t *dataa, uint8_t *datab, uint8_t pos, uint8_t adata) -{ - if (adata >= 4) - { +void writebit_msb(uint8_t *dataa, uint8_t *datab, uint8_t pos, uint8_t adata) { + if (adata >= 4) { return; } static uint8_t aimbyte = 0; @@ -44,24 +39,21 @@ void writebit_msb(uint8_t *dataa, uint8_t *datab, uint8_t pos, uint8_t adata) } //输出raw的2bit组合数据(大端方法，每个byte的第8位读数据的第1位) -uint8_t readbit_msb(uint8_t *dataa, uint8_t *datab, uint8_t pos) -{ +uint8_t readbit_msb(uint8_t *dataa, uint8_t *datab, uint8_t pos) { static uint8_t aimbyte = 0; static uint8_t aimbit = 0; aimbyte = pos / 8; aimbit = 7 - (pos % 8); return ( - (getbit(dataa[aimbyte], aimbit) << 1) | - (getbit(datab[aimbyte], aimbit))); + (getbit(dataa[aimbyte], aimbit) << 1) | + (getbit(datab[aimbyte], aimbit))); } //高低位翻转 -uint8_t invert_num(uint8_t num) -{ +uint8_t invert_num(uint8_t num) { uint8_t temp = 0, sh = 0xf; uint8_t i = 0; - for (i = 0; i < sizeof(uint8_t); i++) - { + for (i = 0; i < sizeof(uint8_t); i++) { temp |= (num & (sh << ((sizeof(uint8_t) - 1 - i) << 2))) << ((i << 3) + 4); temp |= (num & (sh << ((sizeof(uint8_t) + i) << 2))) >> ((i << 3) + 4); } @@ -72,12 +64,10 @@ uint8_t invert_num(uint8_t num) } //原始数据转换为2倍长度的hex字符数组 -void ByteToHexStr(uint8_t *source, uint8_t *dest, uint8_t sourceLen) -{ +void ByteToHexStr(uint8_t *source, uint8_t *dest, uint8_t sourceLen) { uint8_t i, highByte, lowByte; - for (i = 0; i < sourceLen; i++) - { + for (i = 0; i < sourceLen; i++) { highByte = source[i] >> 4; lowByte = source[i] & 0x0f; @@ -97,12 +87,10 @@ void ByteToHexStr(uint8_t *source, uint8_t *dest, uint8_t sourceLen) return; } -void HexStrToByte(uint8_t *source, uint8_t *dest, uint8_t sourceLen) -{ +void HexStrToByte(uint8_t *source, uint8_t *dest, uint8_t sourceLen) { uint8_t i, highByte, lowByte; - for (i = 0; i < sourceLen; i += 2) - { + for (i = 0; i < sourceLen; i += 2) { highByte = toupper(source[i]); lowByte = toupper(source[i + 1]); diff --git a/firmware/application/src/rfid/reader/lf/data_utils.h b/firmware/application/src/rfid/reader/lf/data_utils.h index e930a18..1463761 100644 --- a/firmware/application/src/rfid/reader/lf/data_utils.h +++ b/firmware/application/src/rfid/reader/lf/data_utils.h @@ -5,7 +5,7 @@ #ifdef __cplusplus - extern "C" { +extern "C" { #endif #define DEBUG_READ_BUFF_CHAR(WATCH, PDATA, LENG) \ diff --git a/firmware/application/src/rfid/reader/lf/lf_em410x_data.c b/firmware/application/src/rfid/reader/lf/lf_em410x_data.c index 8ecfa18..792a829 100644 --- a/firmware/application/src/rfid/reader/lf/lf_em410x_data.c +++ b/firmware/application/src/rfid/reader/lf/lf_em410x_data.c @@ -27,57 +27,52 @@ uint8_t datatest[256] = { 0x00 }; //处理卡片数据，输入raw buffer的起始位置2的位置（2111。。。。） //处理完卡片数据放cardbuf，返回5正常解析 //Pdata为rawbuffer -uint8_t mcst(RAWBUF_TYPE_S *Pdata) -{ +uint8_t mcst(RAWBUF_TYPE_S *Pdata) { uint8_t sync = 1; //当前间隔处理完后，是否在判定线上 uint8_t cardindex = 0; //记录变化次数 - for (int i = Pdata->startbit; i < rawbufsize * 8; i++) - { + for (int i = Pdata->startbit; i < rawbufsize * 8; i++) { uint8_t thisbit = readbit(Pdata->rawa, Pdata->rawb, i); - switch (sync) - { - case 1: //同步状态 - switch (thisbit) - { - case 0: //同步状态的1T，添加1位0，依然同步 - writebit(Pdata->hexbuf, Pdata->hexbuf, cardindex, 0); - cardindex++; + switch (sync) { + case 1: //同步状态 + switch (thisbit) { + case 0: //同步状态的1T，添加1位0，依然同步 + writebit(Pdata->hexbuf, Pdata->hexbuf, cardindex, 0); + cardindex++; + break; + case 1: //同步状态的1.5T，添加1位1，切换到非同步状态 + writebit(Pdata->hexbuf, Pdata->hexbuf, cardindex, 1); + cardindex++; + sync = 0; + break; + case 2: //同步状态的2T，添加2位10，依然同步 + writebit(Pdata->hexbuf, Pdata->hexbuf, cardindex, 1); + cardindex++; + writebit(Pdata->hexbuf, Pdata->hexbuf, cardindex, 0); + cardindex++; + break; + default: + return 0; + } break; - case 1: //同步状态的1.5T，添加1位1，切换到非同步状态 - writebit(Pdata->hexbuf, Pdata->hexbuf, cardindex, 1); - cardindex++; - sync = 0; + case 0: //非同步状态 + switch (thisbit) { + case 0: //非同步状态的1T，添加1位1，依然非同步 + writebit(Pdata->hexbuf, Pdata->hexbuf, cardindex, 1); + cardindex++; + break; + case 1: //非同步状态的1.5T，添加2位10，切换到同步状态 + writebit(Pdata->hexbuf, Pdata->hexbuf, cardindex, 1); + cardindex++; + writebit(Pdata->hexbuf, Pdata->hexbuf, cardindex, 0); + cardindex++; + sync = 1; + break; + case 2: //非同步状态的2T，不可能出现的情况，报错。 + return 0; + default: + return 0; + } break; - case 2: //同步状态的2T，添加2位10，依然同步 - writebit(Pdata->hexbuf, Pdata->hexbuf, cardindex, 1); - cardindex++; - writebit(Pdata->hexbuf, Pdata->hexbuf, cardindex, 0); - cardindex++; - break; - default: - return 0; - } - break; - case 0: //非同步状态 - switch (thisbit) - { - case 0: //非同步状态的1T，添加1位1，依然非同步 - writebit(Pdata->hexbuf, Pdata->hexbuf, cardindex, 1); - cardindex++; - break; - case 1: //非同步状态的1.5T，添加2位10，切换到同步状态 - writebit(Pdata->hexbuf, Pdata->hexbuf, cardindex, 1); - cardindex++; - writebit(Pdata->hexbuf, Pdata->hexbuf, cardindex, 0); - cardindex++; - sync = 1; - break; - case 2: //非同步状态的2T，不可能出现的情况，报错。 - return 0; - default: - return 0; - } - break; } if (cardindex >= cardbufsize * 8) break; @@ -86,10 +81,8 @@ uint8_t mcst(RAWBUF_TYPE_S *Pdata) } //处理卡片，寻找校验位并且判断是否正常 -uint8_t em410x_decoder(uint8_t *pData, uint8_t size, uint8_t *pOut) -{ - if (size != 8) - { +uint8_t em410x_decoder(uint8_t *pData, uint8_t size, uint8_t *pOut) { + if (size != 8) { //NRF_LOG_INFO("size err %d!\n", size); return 0; } @@ -103,13 +96,11 @@ uint8_t em410x_decoder(uint8_t *pData, uint8_t size, uint8_t *pOut) // 快速校验头部 uint8_t head_check = 1; - for (int i = 0; i < 9; i++) - { + for (int i = 0; i < 9; i++) { head_check &= getbit(pData[i / 8], i % 8); } // 一起快速校验尾部 - if ((!head_check) || getbit(pData[7], 7)) - { + if ((!head_check) || getbit(pData[7], 7)) { //NRF_LOG_INFO("head or tail err!\n"); return 0; } @@ -119,21 +110,17 @@ uint8_t em410x_decoder(uint8_t *pData, uint8_t size, uint8_t *pOut) // 先校验X轴的数据 // X轴校验，每隔 5个bit 校验一次， // 校验完成后保存为 半个byte - for (int i = 9; i < size * 8 - 5; i += 5) - { + for (int i = 9; i < size * 8 - 5; i += 5) { uint8_t count_bit_x = 0; - for (int j = i; j < i + 5; j++) - { + for (int j = i; j < i + 5; j++) { // 收集偶数据个数 - if (getbit(pData[j / 8], j % 8) == 1) - { + if (getbit(pData[j / 8], j % 8) == 1) { count_bit_x += 1; } - if (j != i + 4) - { + if (j != i + 4) { // 合并bit数据到 uint8缓冲区中 // 需要加上左对齐坐标，如果是高位部分 uint8_t first_merge_offset = (iteration % 2) ? 0 : 4; @@ -143,19 +130,15 @@ uint8_t em410x_decoder(uint8_t *pData, uint8_t size, uint8_t *pOut) } // 如果在第一行，我们还可以直接去校验 Y 轴的校验位 - if (iteration == 0 && j != i + 4) - { + if (iteration == 0 && j != i + 4) { uint8_t count_bit_y = 0; - for (int m = j; m < j + 51; m += 5) - { + for (int m = j; m < j + 51; m += 5) { // NRF_LOG_INFO("当前的m坐标是 %d, 数据是 %d\n", m, pData[m]); - if (getbit(pData[m / 8], m % 8) == 1) - { + if (getbit(pData[m / 8], m % 8) == 1) { count_bit_y += 1; } } - if (count_bit_y % 2) - { + if (count_bit_y % 2) { //NRF_LOG_INFO("bit even parity err at Y-axis from %d to %d!\n", j, j + 51); return 0; } @@ -168,14 +151,12 @@ uint8_t em410x_decoder(uint8_t *pData, uint8_t size, uint8_t *pOut) // 如果取余数不为0 // 说明进入了新的数据处理循环 // 我们需要递增存放合并字节需要的下标 - if (!(iteration % 2)) - { + if (!(iteration % 2)) { merge_pos += 1; // NRF_LOG_INFO("\n"); } - if (count_bit_x % 2) - { + if (count_bit_x % 2) { //NRF_LOG_INFO("bit even parity err at X-axis from %d to %d!\n", i, i + 5); return 0; } @@ -188,8 +169,7 @@ uint8_t em410x_decoder(uint8_t *pData, uint8_t size, uint8_t *pOut) * @param: pData 卡号 - ID，固定5个长度的byte * @param: pOut 输出缓冲区，固定8个长度的byte */ -void em410x_encoder(uint8_t *pData, uint8_t *pOut) -{ +void em410x_encoder(uint8_t *pData, uint8_t *pOut) { //#define EM410X_Encoder_NRF_LOG_INFO // 为了节省代码空间，我们可以在规律内限制死数据长度 @@ -206,7 +186,7 @@ void em410x_encoder(uint8_t *pData, uint8_t *pOut) pOut[1] = 0x80; // 没啥好说的，第二个Byte的msb也要是一个 1 ，这样就凑够了 1 * 9 的前导码 //重置数据为空 - for(i = 2;i < 8;i++){ + for (i = 2; i < 8; i++) { pOut[i] = 0x00; } @@ -216,11 +196,9 @@ void em410x_encoder(uint8_t *pData, uint8_t *pOut) count1 = 0; // X轴 迭代 5个Byte的卡号，拼凑bit到缓冲区中并且计算奇偶校验位 - for (i = 0; i < 5; i++) - { + for (i = 0; i < 5; i++) { // 迭代处理每个bit - for (j = 7; j >= 0; j--) - { + for (j = 7; j >= 0; j--) { // 取出单个bit bit = ((pData[i] >> j) & 0x01); @@ -233,14 +211,12 @@ void em410x_encoder(uint8_t *pData, uint8_t *pOut) pos += 1; // 统计偶校验计数 - if (bit) - { + if (bit) { count1 += 1; } // 奇偶校验位放入到输出缓冲区 - if (j == 4 || j == 0) - { + if (j == 4 || j == 0) { #ifdef EM410X_Encoder_NRF_LOG_INFO NRF_LOG_INFO(" <- 比特RAW : 奇偶校验 -> %d\n", count1 % 2); @@ -259,21 +235,17 @@ void em410x_encoder(uint8_t *pData, uint8_t *pOut) #endif // EM410X_Encoder_NRF_LOG_INFO // Y轴 迭代 5个byte的卡号，生成4个bit的奇偶校验位 - for (i = 0; i < 4; i++) - { + for (i = 0; i < 4; i++) { count1 = 0; - for (j = 0; j < 5; j++) - { + for (j = 0; j < 5; j++) { // 高位计数 bit = ((pData[j] >> (7 - i)) & 0x01); - if (bit) - { + if (bit) { count1 += 1; } // 低位计数 bit = ((pData[j] >> (3 - i)) & 0x01); - if (bit) - { + if (bit) { count1 += 1; } } @@ -293,19 +265,15 @@ void em410x_encoder(uint8_t *pData, uint8_t *pOut) } //读卡函数,需要不停调用，返回0为没读到卡，1为读到了 -uint8_t em410x_acquire(void) -{ - if (dataindex >= rawbufsize * 8) - { +uint8_t em410x_acquire(void) { + if (dataindex >= rawbufsize * 8) { #ifdef debug410x { - for (int i = 0; i < rawbufsize * 8; i++) - { + for (int i = 0; i < rawbufsize * 8; i++) { NRF_LOG_INFO("%d ", readbit(carddata.rawa, carddata.rawb, i)); } NRF_LOG_INFO("///raw data\r\n"); - for (int i = 0; i < rawbufsize * 8; i++) - { + for (int i = 0; i < rawbufsize * 8; i++) { NRF_LOG_INFO("%d ", datatest[i]); } NRF_LOG_INFO("///time data\r\n"); @@ -313,46 +281,38 @@ uint8_t em410x_acquire(void) #endif //寻找目标0 1111 1111 carddata.startbit = 255; - for (int i = 0; i < (rawbufsize * 8) - 8; i++) - { - if (readbit(carddata.rawa, carddata.rawb, i) == 1) - { + for (int i = 0; i < (rawbufsize * 8) - 8; i++) { + if (readbit(carddata.rawa, carddata.rawb, i) == 1) { carddata.startbit = 0; - for (int j = 1; j < 8; j++) - { + for (int j = 1; j < 8; j++) { carddata.startbit += (uint8_t)readbit(carddata.rawa, carddata.rawb, i + j); } - if (carddata.startbit == 0) - { + if (carddata.startbit == 0) { carddata.startbit = i; break; - } - else - { + } else { carddata.startbit = 255; } } } // 如果找到了合适的开头，进行处理 - if (carddata.startbit != 255 && carddata.startbit < (rawbufsize * 8) - 64) - { //保证卡片数据可以完整解析 + if (carddata.startbit != 255 && carddata.startbit < (rawbufsize * 8) - 64) { + //保证卡片数据可以完整解析 //NRF_LOG_INFO("do mac,start: %d\r\n",startbit); - if (mcst(&carddata) == 1) - { //卡片正常解析 + if (mcst(&carddata) == 1) { + //卡片正常解析 #ifdef debug410x { - for (int i = 0; i < cardbufsize; i++) - { + for (int i = 0; i < cardbufsize; i++) { NRF_LOG_INFO("%02X", carddata.hexbuf[i]); } NRF_LOG_INFO("///card data\r\n"); } #endif - if (em410x_decoder(carddata.hexbuf, cardbufsize, cardbufbyte)) - { //卡片数据检查通过 + if (em410x_decoder(carddata.hexbuf, cardbufsize, cardbufbyte)) { + //卡片数据检查通过 #ifdef debug410x - for (int i = 0; i < 5; i++) - { + for (int i = 0; i < 5; i++) { NRF_LOG_INFO("%02X", (int)cardbufbyte[i]); } NRF_LOG_INFO("///card dataBYTE\r\n"); @@ -369,29 +329,19 @@ uint8_t em410x_acquire(void) } //gpio中断回调函数，用于检测下降沿 -void GPIO_INT0_callback(void) -{ +void GPIO_INT0_callback(void) { static uint32_t thistimelen = 0; thistimelen = get_lf_counter_value(); - if (thistimelen > 47) - { + if (thistimelen > 47) { static uint8_t cons_temp = 0; - if (dataindex < rawbufsize * 8) - { - if (48 <= thistimelen && thistimelen <= 80) - { + if (dataindex < rawbufsize * 8) { + if (48 <= thistimelen && thistimelen <= 80) { cons_temp = 0; - } - else if (80 <= thistimelen && thistimelen <= 112) - { + } else if (80 <= thistimelen && thistimelen <= 112) { cons_temp = 1; - } - else if (112 <= thistimelen && thistimelen <= 144) - { + } else if (112 <= thistimelen && thistimelen <= 144) { cons_temp = 2; - } - else - { + } else { cons_temp = 3; } writebit(carddata.rawa, carddata.rawb, dataindex, cons_temp); @@ -404,15 +354,13 @@ void GPIO_INT0_callback(void) } uint16_t counter = 0; - do - { + do { __NOP(); } while (counter++ > 1000); } //启动定时器和初始化相关外设，启动低频读卡 -void init_em410x_hw(void) -{ +void init_em410x_hw(void) { //注册读卡器io中断回调 register_rio_callback(GPIO_INT0_callback); } @@ -420,20 +368,18 @@ void init_em410x_hw(void) /** * 在指定的超时内读取EM410X卡的卡号 */ -uint8_t em410x_read(uint8_t *uid, uint32_t timeout_ms) -{ +uint8_t em410x_read(uint8_t *uid, uint32_t timeout_ms) { uint8_t ret = 0; init_em410x_hw(); // 初始化下降沿采样回调函数 start_lf_125khz_radio(); // 启动125khz调制 // 在超时中读卡 - autotimer* p_at = bsp_obtain_timer(0); + autotimer *p_at = bsp_obtain_timer(0); // NO_TIMEOUT_1MS(p_at, timeout_ms) - while(NO_TIMEOUT_1MS(p_at, timeout_ms)) { + while (NO_TIMEOUT_1MS(p_at, timeout_ms)) { //执行读卡，读到就退出 - if (em410x_acquire()) - { + if (em410x_acquire()) { stop_lf_125khz_radio(); uid[0] = cardbufbyte[0]; uid[1] = cardbufbyte[1]; diff --git a/firmware/application/src/rfid/reader/lf/lf_em410x_data.h b/firmware/application/src/rfid/reader/lf/lf_em410x_data.h index b1a0091..1bdf708 100644 --- a/firmware/application/src/rfid/reader/lf/lf_em410x_data.h +++ b/firmware/application/src/rfid/reader/lf/lf_em410x_data.h @@ -15,8 +15,7 @@ extern "C" #define rawbufsize 24 // 最大记录buffer #define cardbufsize 8 // 卡片大小 -typedef struct -{ +typedef struct { uint8_t rawa[rawbufsize]; // 记录变化沿之间的时间差 uint8_t rawb[rawbufsize]; // 记录变化沿之间的时间差 uint8_t hexbuf[cardbufsize]; // 解析后的卡数据 diff --git a/firmware/application/src/rfid/reader/lf/lf_reader_data.c b/firmware/application/src/rfid/reader/lf/lf_reader_data.c index a0539be..d524ef9 100644 --- a/firmware/application/src/rfid/reader/lf/lf_reader_data.c +++ b/firmware/application/src/rfid/reader/lf/lf_reader_data.c @@ -6,8 +6,7 @@ RIO_CALLBACK_S RIO_callback; // 创建实例 uint8_t RIO_callback_state; // 记录状态 -void register_rio_callback(RIO_CALLBACK_S P) // 注册回调函数 -{ +void register_rio_callback(RIO_CALLBACK_S P) { // 注册回调函数 RIO_callback = P; RIO_callback_state = 1; } @@ -23,9 +22,8 @@ void unregister_rio_callback(void) { } // GPIO中断，就是RIO引脚 -void GPIO_INT0_IRQHandler(void) -{ - if(RIO_callback_state == 1){ +void GPIO_INT0_IRQHandler(void) { + if (RIO_callback_state == 1) { RIO_callback(); } } diff --git a/firmware/application/src/rfid/reader/lf/lf_reader_data.h b/firmware/application/src/rfid/reader/lf/lf_reader_data.h index 9593034..941874c 100644 --- a/firmware/application/src/rfid/reader/lf/lf_reader_data.h +++ b/firmware/application/src/rfid/reader/lf/lf_reader_data.h @@ -6,7 +6,7 @@ // #define debug410x #ifdef __cplusplus - extern "C" { +extern "C" { #endif typedef void(*RIO_CALLBACK_S)(void); // 调用函数格式 diff --git a/firmware/application/src/rfid/reader/lf/lf_reader_main.c b/firmware/application/src/rfid/reader/lf/lf_reader_main.c index 6a8b478..7c3e1f3 100644 --- a/firmware/application/src/rfid/reader/lf/lf_reader_main.c +++ b/firmware/application/src/rfid/reader/lf/lf_reader_main.c @@ -18,7 +18,7 @@ uint32_t g_timeout_readem_ms = 500; /** * 搜索EM410X标签 */ -uint8_t PcdScanEM410X(uint8_t* uid) { +uint8_t PcdScanEM410X(uint8_t *uid) { uint8_t ret = EM410X_TAG_NO_FOUND; init_em410x_hw(); if (em410x_read(uid, g_timeout_readem_ms) == 1) { @@ -30,20 +30,20 @@ uint8_t PcdScanEM410X(uint8_t* uid) { /** * 检测当前的场内是否有指定的UID的标签 */ -uint8_t check_write_ok(uint8_t* uid, uint8_t* newuid, uint8_t on_uid_diff_return) { +uint8_t check_write_ok(uint8_t *uid, uint8_t *newuid, uint8_t on_uid_diff_return) { // 写卡完成后，我们需要进行一次回读， // 如果回读的数据不正确，说明写入失败 - if(PcdScanEM410X(newuid) != LF_TAG_OK) { + if (PcdScanEM410X(newuid) != LF_TAG_OK) { return EM410X_TAG_NO_FOUND; } // 如果回读到的卡号一样 // 说明写入成功了（或许吧） - if( + if ( uid[0] == newuid[0] && uid[1] == newuid[1] && uid[2] == newuid[2] && uid[3] == newuid[3] && - uid[4] == newuid[4] ) { + uid[4] == newuid[4]) { return LF_TAG_OK; } // 如果发现卡，但是卡号不对， @@ -54,7 +54,7 @@ uint8_t check_write_ok(uint8_t* uid, uint8_t* newuid, uint8_t on_uid_diff_return /** * 写T55XX标签 */ -uint8_t PcdWriteT55XX(uint8_t* uid, uint8_t* newkey, uint8_t* old_keys, uint8_t old_key_count) { +uint8_t PcdWriteT55XX(uint8_t *uid, uint8_t *newkey, uint8_t *old_keys, uint8_t old_key_count) { uint8_t datas[8] = { 255 }; uint8_t i; diff --git a/firmware/application/src/rfid/reader/lf/lf_reader_main.h b/firmware/application/src/rfid/reader/lf/lf_reader_main.h index cd6547d..d7fe118 100644 --- a/firmware/application/src/rfid/reader/lf/lf_reader_main.h +++ b/firmware/application/src/rfid/reader/lf/lf_reader_main.h @@ -12,7 +12,7 @@ extern uint32_t g_timeout_readem_ms; void SetEMScanTagTimeout(uint32_t ms); -uint8_t PcdScanEM410X(uint8_t* uid); -uint8_t PcdWriteT55XX(uint8_t* uid, uint8_t* newkey, uint8_t* old_keys, uint8_t old_key_count); +uint8_t PcdScanEM410X(uint8_t *uid); +uint8_t PcdWriteT55XX(uint8_t *uid, uint8_t *newkey, uint8_t *old_keys, uint8_t old_key_count); #endif diff --git a/firmware/application/src/rfid/reader/lf/lf_t55xx_data.c b/firmware/application/src/rfid/reader/lf/lf_t55xx_data.c index 3b32ad1..654aa43 100644 --- a/firmware/application/src/rfid/reader/lf/lf_t55xx_data.c +++ b/firmware/application/src/rfid/reader/lf/lf_t55xx_data.c @@ -92,21 +92,18 @@ void empty_callback() { } //启动定时器和初始化相关外设，启动低频读卡 -void init_t55xx_hw(void) -{ +void init_t55xx_hw(void) { //注册读卡器io中断回调 register_rio_callback(empty_callback); } -void T55xx_SendGap(unsigned int tm) -{ +void T55xx_SendGap(unsigned int tm) { stop_lf_125khz_radio(); // 关闭pwm输出 bsp_delay_us(tm); start_lf_125khz_radio(); // 启动pwm输出 } -void TxBitRfid(uint8_t data) -{ +void TxBitRfid(uint8_t data) { if (data & 1) bsp_delay_us(54 * 8); else @@ -114,10 +111,8 @@ void TxBitRfid(uint8_t data) T55xx_SendGap(9 * 8); //write gap } -void TxByteRfid(uint8_t data) -{ - for (uint8_t n_bit = 0; n_bit < 8; n_bit++) - { +void TxByteRfid(uint8_t data) { + for (uint8_t n_bit = 0; n_bit < 8; n_bit++) { TxBitRfid(data & 1); data = data >> 1; } @@ -134,32 +129,26 @@ void T55XX_Timeslot_Callback() { //指令为00时不需要发送后面的东西了 if (t55xx_cmd.opcode != 0) { //指令后如果有需要才发密码 - if (t55xx_cmd.usepassword) - { - for (uint8_t i = 0; i < 32; i++) - { + if (t55xx_cmd.usepassword) { + for (uint8_t i = 0; i < 32; i++) { TxBitRfid((t55xx_cmd.password >> (31 - i)) & 1); } } //处理锁定位 - if (t55xx_cmd.lockBit == 0 || t55xx_cmd.lockBit == 1) - { + if (t55xx_cmd.lockBit == 0 || t55xx_cmd.lockBit == 1) { TxBitRfid(t55xx_cmd.lockBit & 1); } //有需求才发数据 - if (t55xx_cmd.usedata) - { - for (uint8_t i = 0; i < 32; i++) - { + if (t55xx_cmd.usedata) { + for (uint8_t i = 0; i < 32; i++) { TxBitRfid((t55xx_cmd.data >> (31 - i)) & 1); } } //处理地址位 - if (t55xx_cmd.blokAddr != 255) - { + if (t55xx_cmd.blokAddr != 255) { TxBitRfid(t55xx_cmd.blokAddr >> 2); TxBitRfid(t55xx_cmd.blokAddr >> 1); TxBitRfid(t55xx_cmd.blokAddr & 1); @@ -178,8 +167,7 @@ void T55XX_Timeslot_Callback() { * @param data 数据，32个bit，从下标0开始传输 * @param blokAddr 块编号，3个bit 0-7块，输入255代表不使用该位（用于密码唤醒模式） */ -void T55xx_Send_Cmd(uint8_t opcode, uint8_t usepassword, uint32_t password, uint8_t lockBit, uint8_t usedata, uint32_t data, uint8_t blokAddr) -{ +void T55xx_Send_Cmd(uint8_t opcode, uint8_t usepassword, uint32_t password, uint8_t lockBit, uint8_t usedata, uint32_t data, uint8_t blokAddr) { //密码读取模式， 2op(1+bck) 32pw 1(0) 3addr //密码写入模式， 2op(1+bck) 32pw 1l 32data 3addr //密码唤醒模式， 2op(1+0) 32pw @@ -216,37 +204,34 @@ void T55xx_Send_Cmd(uint8_t opcode, uint8_t usepassword, uint32_t password, uint * @param passwd 用于最后加密的密码（也是卡片当前密码）(是一个指针，4字节宽度小端byte序存储) * @param datas em410x运算后的数据，需要调用EM410X_Encoder计算 */ -void T55xx_Write_data(uint8_t *passwd, uint8_t *datas) -{ +void T55xx_Write_data(uint8_t *passwd, uint8_t *datas) { uint32_t blk1data = 0, blk2data = 0, u32passwd = 0; //提取两个block的数据和密码 - for (uint8_t dataindex = 0; dataindex < 4; dataindex++) - { + for (uint8_t dataindex = 0; dataindex < 4; dataindex++) { blk1data = blk1data << 8; blk1data |= (uint8_t)datas[dataindex]; u32passwd = u32passwd << 8; u32passwd |= (uint8_t)passwd[dataindex]; } - for (uint8_t dataindex = 4; dataindex < 8; dataindex++) - { + for (uint8_t dataindex = 4; dataindex < 8; dataindex++) { blk2data = blk2data << 8; blk2data |= (uint8_t)datas[dataindex]; } - //先写入密码区 + //先写入密码区 T55xx_Send_Cmd(2, 1, u32passwd, 0, 1, u32passwd, 7); //0区 7块 用当前密码写当前密码（密码） T55xx_Send_Cmd(2, 1, u32passwd, 0, 1, u32passwd, 7); //0区 7块 用当前密码写当前密码（密码） - //然后写入控制区 + //然后写入控制区 T55xx_Send_Cmd(2, 1, u32passwd, 0, 1, 0X00148050, 0); //0区 0块 用当前密码写00148050（控制区） - //然后写入数据 + //然后写入数据 T55xx_Send_Cmd(2, 1, u32passwd, 0, 1, blk1data, 1); //0区 1块 用当前密码写blk1data（数据） T55xx_Send_Cmd(3, 1, u32passwd, 0, 1, blk1data, 1); //1区 1块 用当前密码写blk1data（数据） T55xx_Send_Cmd(2, 1, u32passwd, 0, 1, blk2data, 2); //0区 2块 用当前密码写blk2data（数据） T55xx_Send_Cmd(3, 1, u32passwd, 0, 1, blk2data, 2); //1区 2块 用当前密码写blk2data（数据） - //然后写入射频参数 + //然后写入射频参数 // 2021-12-15 fix：写此数据会导致小卡无法重复写 // T55xx_Send_Cmd(3, 1, u32passwd, 0, 1, 0X60000800, 3); //1区 3块 用当前密码写60000800（射频参数） - //然后用无密码指令再写一遍 + //然后用无密码指令再写一遍 T55xx_Send_Cmd(2, 0, 0, 0, 1, 0X00148050, 0); //0区 0块 写00148050（控制区） T55xx_Send_Cmd(2, 0, 0, 0, 1, blk1data, 1); //0区 1块 写blk1data（数据） T55xx_Send_Cmd(2, 0, 0, 0, 1, blk2data, 2); //0区 2块 写blk2data（数据） @@ -259,11 +244,10 @@ void T55xx_Write_data(uint8_t *passwd, uint8_t *datas) * @param oldpasswd 卡片当前密码(是一个指针，4字节宽度小端byte序存储) * @param newpasswd 用于最后加密的密码(是一个指针，4字节宽度小端byte序存储) */ -void T55xx_Reset_Passwd(uint8_t *oldpasswd, uint8_t *newpasswd){ +void T55xx_Reset_Passwd(uint8_t *oldpasswd, uint8_t *newpasswd) { uint32_t u32oldpasswd = 0, u32newpasswd = 0; //提取两个block的数据和密码 - for (uint8_t dataindex = 0; dataindex < 4; dataindex++) - { + for (uint8_t dataindex = 0; dataindex < 4; dataindex++) { u32oldpasswd = u32oldpasswd << 8; u32oldpasswd |= (uint8_t)oldpasswd[dataindex]; u32newpasswd = u32newpasswd << 8; diff --git a/firmware/application/src/rfid_main.c b/firmware/application/src/rfid_main.c index 5c189f3..430396e 100644 --- a/firmware/application/src/rfid_main.c +++ b/firmware/application/src/rfid_main.c @@ -68,7 +68,7 @@ void tag_mode_enter(void) { * @brief Function for light up led by slot index */ void light_up_by_slot(void) { - uint32_t* led_pins = hw_get_led_array(); + uint32_t *led_pins = hw_get_led_array(); // 目前的亮灯逻辑并没有非常大的变动，因此我们暂时只需要亮起指定的位置的灯即可 uint8_t slot = tag_emulation_get_slot(); for (int i = 0; i < RGB_LIST_NUM; i++) { diff --git a/firmware/application/src/rgb_marquee.c b/firmware/application/src/rgb_marquee.c index f949a8b..49a90a5 100644 --- a/firmware/application/src/rgb_marquee.c +++ b/firmware/application/src/rgb_marquee.c @@ -17,15 +17,13 @@ NRF_LOG_MODULE_REGISTER(); #define LIGHT_LEVEL_MAX 99 // 亮度级别最大值 static nrf_drv_pwm_t pwm0_ins = NRF_DRV_PWM_INSTANCE(1); nrf_pwm_values_individual_t pwm_sequ_val;//独立模式下的PWM控制4通道的占空比 -nrf_pwm_sequence_t const seq = //配置pwm输出用的结构体 -{ +nrf_pwm_sequence_t const seq = { //配置pwm输出用的结构体 .values.p_individual = &pwm_sequ_val, .length = 4, .repeats = 0, .end_delay = 0 }; -nrf_drv_pwm_config_t pwm_config = //PWM配置结构体 -{ +nrf_drv_pwm_config_t pwm_config = { //PWM配置结构体 .irq_priority = APP_IRQ_PRIORITY_LOWEST, .base_clock = NRF_PWM_CLK_1MHz, .count_mode = NRF_PWM_MODE_UP, @@ -39,11 +37,11 @@ static uint8_t ledblink1_step = 0; extern bool g_usb_led_marquee_enable; -void rgb_marquee_init(void){ +void rgb_marquee_init(void) { timer = bsp_obtain_timer(0); } -void rgb_marquee_stop(void){ +void rgb_marquee_stop(void) { nrfx_pwm_stop(&pwm0_ins, true); nrfx_pwm_uninit(&pwm0_ins); //关闭pwm输出 ledblink6_step = 0; @@ -51,22 +49,22 @@ void rgb_marquee_stop(void){ } // reset RGB state machines to force a refresh of the LED color -void rgb_marquee_reset(void){ +void rgb_marquee_reset(void) { ledblink6_step = 0; ledblink1_step = 0; } // 亮度转PWM值 -uint16_t get_pwmduty(uint8_t light_level){ - return PWM_MAX-(PWM_MAX*pow(((double)light_level/LIGHT_LEVEL_MAX),2.2)); +uint16_t get_pwmduty(uint8_t light_level) { + return PWM_MAX - (PWM_MAX * pow(((double)light_level / LIGHT_LEVEL_MAX), 2.2)); } //4灯同亮度水平移动循环（不返回） //COLOR 0-R,1-G,2-B -void ledblink1(uint8_t color, uint8_t dir){ +void ledblink1(uint8_t color, uint8_t dir) { static uint8_t startled = 0; static uint8_t setled = 0; - uint32_t* led_pins_arr; + uint32_t *led_pins_arr; if (!g_usb_led_marquee_enable && ledblink1_step != 0) { startled = 0; @@ -76,9 +74,9 @@ void ledblink1(uint8_t color, uint8_t dir){ } //处理方向 - if(dir == 0){ + if (dir == 0) { led_pins_arr = hw_get_led_array(); - } else{ + } else { led_pins_arr = hw_get_led_reversal_array(); } @@ -98,16 +96,16 @@ void ledblink1(uint8_t color, uint8_t dir){ if (ledblink1_step == 1) { setled = startled; - for(uint8_t i=0;i<4;i++){ + for (uint8_t i = 0; i < 4; i++) { pwm_config.output_pins[i] = led_pins_arr[setled]; setled++; - if(setled>7)setled=0; + if (setled > 7)setled = 0; } startled++; - if(startled>7)startled = 0; + if (startled > 7)startled = 0; nrfx_pwm_uninit(&pwm0_ins); nrf_drv_pwm_init(&pwm0_ins, &pwm_config, NULL); - nrf_drv_pwm_simple_playback(&pwm0_ins, &seq, 1,NRF_DRV_PWM_FLAG_LOOP); + nrf_drv_pwm_simple_playback(&pwm0_ins, &seq, 1, NRF_DRV_PWM_FLAG_LOOP); bsp_set_timer(timer, 0); ledblink1_step = 2; @@ -123,17 +121,16 @@ void ledblink1(uint8_t color, uint8_t dir){ //4灯拖尾水平移动循环（不返回），包含尾部消失和头部缓入 //dir 0-从1卡槽到8卡槽，1-从8卡槽到1卡槽 (方向，结束点由end参数决定) //end 要扫描的灯数量，和方向一起决定最终动画区域 -void ledblink2(uint8_t color,uint8_t dir, uint8_t end){ +void ledblink2(uint8_t color, uint8_t dir, uint8_t end) { uint8_t startled = 0; uint8_t setled = 0; uint8_t leds2turnon = 0; uint8_t i = 0; - uint32_t * led_pins_arr; + uint32_t *led_pins_arr; //处理方向 - if(dir == 0){ + if (dir == 0) { led_pins_arr = hw_get_led_array(); - } - else{ + } else { led_pins_arr = hw_get_led_reversal_array(); } @@ -143,7 +140,7 @@ void ledblink2(uint8_t color,uint8_t dir, uint8_t end){ pwm_sequ_val.channel_2 = 600; pwm_sequ_val.channel_1 = 880; pwm_sequ_val.channel_0 = 980;//最暗的 - while(1) { + while (1) { //关闭所有通道 pwm_config.output_pins[0] = NRF_DRV_PWM_PIN_NOT_USED; pwm_config.output_pins[1] = NRF_DRV_PWM_PIN_NOT_USED; @@ -151,51 +148,51 @@ void ledblink2(uint8_t color,uint8_t dir, uint8_t end){ pwm_config.output_pins[3] = NRF_DRV_PWM_PIN_NOT_USED; setled = startled; - if(setled<3){//正向期间，0，1，2的时候只能点亮前几个led + if (setled < 3) { //正向期间，0，1，2的时候只能点亮前几个led //首先确定能点亮几个灯 - leds2turnon = setled+1;//1，2，3 + leds2turnon = setled + 1; //1，2，3 //然后设置pwm输出通道 - for(i=0;i7&&setled<=10){//正向期间，8.9.10的时候只能点亮后几个led + } else if (setled > 7 && setled <= 10) { //正向期间，8.9.10的时候只能点亮后几个led //首先确定能点亮几个灯 - leds2turnon = 11-setled; + leds2turnon = 11 - setled; //然后设置pwm输出通道 - for(i=0;i=end){ + if (startled >= end) { //计算需要隐藏几个灯 - leds2turnon = startled-end; + leds2turnon = startled - end; //把超出去的都隐藏了 - for(i=0;i=4)break; - if(startled>11)break; + if (startled - end >= 4)break; + if (startled > 11)break; } } @@ -205,64 +202,64 @@ void ledblink2(uint8_t color,uint8_t dir, uint8_t end){ //led_down 要熄灭的led //color_led_down 要熄灭的led的颜色 0-R,1-G,2-B volatile bool callback_waiting = 0; -static void ledblink3_pwm_callback(nrfx_pwm_evt_type_t event_type){ +static void ledblink3_pwm_callback(nrfx_pwm_evt_type_t event_type) { if (event_type == NRF_DRV_PWM_EVT_FINISHED) { callback_waiting = 1; } } -void ledblink3(uint8_t led_down,uint8_t color_led_down, uint8_t led_up, uint8_t color_led_up){ - int16_t light_level= 99;//led亮度值 - uint32_t* led_pins = hw_get_led_array(); - if(led_down>=0 &&led_down<=7){ +void ledblink3(uint8_t led_down, uint8_t color_led_down, uint8_t led_up, uint8_t color_led_up) { + int16_t light_level = 99; //led亮度值 + uint32_t *led_pins = hw_get_led_array(); + if (led_down >= 0 && led_down <= 7) { //先处理要熄灭的 pwm_config.output_pins[0] = led_pins[led_down]; pwm_config.output_pins[1] = NRF_DRV_PWM_PIN_NOT_USED; pwm_config.output_pins[2] = NRF_DRV_PWM_PIN_NOT_USED; pwm_config.output_pins[3] = NRF_DRV_PWM_PIN_NOT_USED; - while(light_level >= 0){ + while (light_level >= 0) { //处理亮度 pwm_sequ_val.channel_0 = get_pwmduty(light_level); nrfx_pwm_uninit(&pwm0_ins); //关闭pwm输出 - if(led_up>=0 &&led_up<=7){ + if (led_up >= 0 && led_up <= 7) { nrf_gpio_pin_clear(led_pins[led_up]); } set_slot_light_color(color_led_down); nrf_drv_pwm_init(&pwm0_ins, &pwm_config, ledblink3_pwm_callback); - nrf_drv_pwm_simple_playback(&pwm0_ins, &seq, 1,NRF_DRV_PWM_FLAG_LOOP); + nrf_drv_pwm_simple_playback(&pwm0_ins, &seq, 1, NRF_DRV_PWM_FLAG_LOOP); - while(callback_waiting == 0);//等待pwm模块输出完成 + while (callback_waiting == 0); //等待pwm模块输出完成 bsp_delay_us(1234); callback_waiting = 0; light_level --; } } - if(led_up>=0 &&led_up<=7){ + if (led_up >= 0 && led_up <= 7) { //处理要点亮的 pwm_config.output_pins[0] = led_pins[led_up]; pwm_config.output_pins[1] = NRF_DRV_PWM_PIN_NOT_USED; pwm_config.output_pins[2] = NRF_DRV_PWM_PIN_NOT_USED; pwm_config.output_pins[3] = NRF_DRV_PWM_PIN_NOT_USED; light_level = 0; - while(light_level < 99){ + while (light_level < 99) { //处理亮度 pwm_sequ_val.channel_0 = get_pwmduty(light_level); nrfx_pwm_uninit(&pwm0_ins); //关闭pwm输出 - if(led_down>=0 &&led_down<=7){ + if (led_down >= 0 && led_down <= 7) { nrf_gpio_pin_clear(led_pins[led_down]); } set_slot_light_color(color_led_up); nrf_drv_pwm_init(&pwm0_ins, &pwm_config, ledblink3_pwm_callback); - nrf_drv_pwm_simple_playback(&pwm0_ins, &seq, 1,NRF_DRV_PWM_FLAG_LOOP); + nrf_drv_pwm_simple_playback(&pwm0_ins, &seq, 1, NRF_DRV_PWM_FLAG_LOOP); - while(callback_waiting == 0);//等待pwm模块输出完成 + while (callback_waiting == 0); //等待pwm模块输出完成 bsp_delay_us(1234); callback_waiting = 0; light_level ++; @@ -274,32 +271,31 @@ void ledblink3(uint8_t led_down,uint8_t color_led_down, uint8_t led_up, uint8_t //dir 0-从1卡槽到8卡槽，1-从8卡槽到1卡槽 (方向，结束点由end参数决定) //end 要扫描的灯数量，和方向一起决定最终动画区域 //start_light stop_light 0-99 表示渐变亮度 -void ledblink4(uint8_t color,uint8_t dir, uint8_t end,uint8_t start_light,uint8_t stop_light){ +void ledblink4(uint8_t color, uint8_t dir, uint8_t end, uint8_t start_light, uint8_t stop_light) { uint8_t startled = 0; uint8_t setled = 0; uint8_t leds2turnon = 0; uint8_t i = 0; - uint32_t * led_pins_arr; + uint32_t *led_pins_arr; volatile double light_cnd; //处理方向 - if(dir == 0){ + if (dir == 0) { led_pins_arr = hw_get_led_array(); - } - else{ + } else { led_pins_arr = hw_get_led_reversal_array(); } //调整颜色 set_slot_light_color(color); - while(1) { + while (1) { //设置亮度 //当前亮度系数 //start经过end次数达到stop - light_cnd = (((double)stop_light-(double)start_light)/end)*startled+start_light; - pwm_sequ_val.channel_3 = get_pwmduty((uint8_t)(0.99*light_cnd));//1; //最亮的 - pwm_sequ_val.channel_2 = get_pwmduty((uint8_t)(0.60*light_cnd));//600; - pwm_sequ_val.channel_1 = get_pwmduty((uint8_t)(0.30*light_cnd));//880; - pwm_sequ_val.channel_0 = get_pwmduty((uint8_t)(0.01*light_cnd));//980;//最暗的 + light_cnd = (((double)stop_light - (double)start_light) / end) * startled + start_light; + pwm_sequ_val.channel_3 = get_pwmduty((uint8_t)(0.99 * light_cnd)); //1; //最亮的 + pwm_sequ_val.channel_2 = get_pwmduty((uint8_t)(0.60 * light_cnd)); //600; + pwm_sequ_val.channel_1 = get_pwmduty((uint8_t)(0.30 * light_cnd)); //880; + pwm_sequ_val.channel_0 = get_pwmduty((uint8_t)(0.01 * light_cnd)); //980;//最暗的 //关闭所有通道 pwm_config.output_pins[0] = NRF_DRV_PWM_PIN_NOT_USED; pwm_config.output_pins[1] = NRF_DRV_PWM_PIN_NOT_USED; @@ -307,41 +303,41 @@ void ledblink4(uint8_t color,uint8_t dir, uint8_t end,uint8_t start_light,uint8_ pwm_config.output_pins[3] = NRF_DRV_PWM_PIN_NOT_USED; setled = startled; - if(setled<3){//正向期间，0，1，2的时候只能点亮前几个led + if (setled < 3) { //正向期间，0，1，2的时候只能点亮前几个led //首先确定能点亮几个灯 - leds2turnon = setled+1;//1，2，3 + leds2turnon = setled + 1; //1，2，3 //然后设置pwm输出通道 - for(i=0;i7&&setled<=10){//正向期间，8.9.10的时候只能点亮后几个led + } else if (setled > 7 && setled <= 10) { //正向期间，8.9.10的时候只能点亮后几个led //首先确定能点亮几个灯 - leds2turnon = 11-setled; + leds2turnon = 11 - setled; //然后设置pwm输出通道 - for(i=0;i=4)break; - if(startled>11)break; + if (startled - end >= 4)break; + if (startled > 11)break; } } @@ -349,9 +345,9 @@ void ledblink4(uint8_t color,uint8_t dir, uint8_t end,uint8_t start_light,uint8_ //color 要点亮的led的颜色 0-R,1-G,2-B //start 启动灯位 //stop 停止灯位 -void ledblink5(uint8_t color,uint8_t start, uint8_t stop){ +void ledblink5(uint8_t color, uint8_t start, uint8_t stop) { uint8_t setled = start; - uint32_t * led_pins = hw_get_led_array(); + uint32_t *led_pins = hw_get_led_array(); //设置亮度 pwm_sequ_val.channel_3 = 0; pwm_sequ_val.channel_2 = 0; @@ -359,7 +355,7 @@ void ledblink5(uint8_t color,uint8_t start, uint8_t stop){ pwm_sequ_val.channel_0 = get_pwmduty(99); //调整颜色 set_slot_light_color(color); - while(setled < (start < stop ? stop + 1 : stop - 1)) { + while (setled < (start < stop ? stop + 1 : stop - 1)) { //关闭所有通道 pwm_config.output_pins[0] = NRF_DRV_PWM_PIN_NOT_USED; pwm_config.output_pins[1] = NRF_DRV_PWM_PIN_NOT_USED; @@ -368,7 +364,7 @@ void ledblink5(uint8_t color,uint8_t start, uint8_t stop){ pwm_config.output_pins[0] = led_pins[setled]; nrfx_pwm_uninit(&pwm0_ins); nrf_drv_pwm_init(&pwm0_ins, &pwm_config, NULL); - nrf_drv_pwm_simple_playback(&pwm0_ins, &seq, 1,NRF_DRV_PWM_FLAG_LOOP); + nrf_drv_pwm_simple_playback(&pwm0_ins, &seq, 1, NRF_DRV_PWM_FLAG_LOOP); bsp_delay_ms(50); setled = start < stop ? setled + 1 : setled - 1; } @@ -378,13 +374,13 @@ void ledblink5(uint8_t color,uint8_t start, uint8_t stop){ //充电动画 //perc 电池当前百分比 0-4 4代表满电呼吸灯 volatile bool callback_waiting6 = 0; -void ledblink6_pwm_callback(nrfx_pwm_evt_type_t event_type){ +void ledblink6_pwm_callback(nrfx_pwm_evt_type_t event_type) { if (event_type == NRF_DRV_PWM_EVT_FINISHED) { callback_waiting6 = 1; } } -void ledblink6(void){ - uint32_t* led_array = hw_get_led_array(); +void ledblink6(void) { + uint32_t *led_array = hw_get_led_array(); const uint16_t delay_time = 25; static int16_t light_level = 99; //led亮度值 @@ -426,7 +422,7 @@ void ledblink6(void){ nrfx_pwm_uninit(&pwm0_ins); //关闭pwm输出 set_slot_light_color(1); nrf_drv_pwm_init(&pwm0_ins, &pwm_config, ledblink6_pwm_callback); - nrf_drv_pwm_simple_playback(&pwm0_ins, &seq, 1,NRF_DRV_PWM_FLAG_LOOP); + nrf_drv_pwm_simple_playback(&pwm0_ins, &seq, 1, NRF_DRV_PWM_FLAG_LOOP); ledblink6_step = 3; } if (ledblink6_step == 3) { //等待pwm模块输出完成 @@ -453,7 +449,7 @@ void ledblink6(void){ } if (ledblink6_step == 6 || ledblink6_step == 7 || ledblink6_step == 8) { - if (light_level >=0) { + if (light_level >= 0) { if (ledblink6_step == 6) { //处理亮度 pwm_sequ_val.channel_0 = get_pwmduty(light_level); @@ -463,7 +459,7 @@ void ledblink6(void){ nrfx_pwm_uninit(&pwm0_ins); //关闭pwm输出 set_slot_light_color(1); nrf_drv_pwm_init(&pwm0_ins, &pwm_config, ledblink6_pwm_callback); - nrf_drv_pwm_simple_playback(&pwm0_ins, &seq, 1,NRF_DRV_PWM_FLAG_LOOP); + nrf_drv_pwm_simple_playback(&pwm0_ins, &seq, 1, NRF_DRV_PWM_FLAG_LOOP); ledblink6_step = 7; } if (ledblink6_step == 7) { //等待pwm模块输出完成 diff --git a/firmware/application/src/rgb_marquee.h b/firmware/application/src/rgb_marquee.h index 0af8a41..edfa70e 100644 --- a/firmware/application/src/rgb_marquee.h +++ b/firmware/application/src/rgb_marquee.h @@ -9,11 +9,11 @@ void rgb_marquee_init(void); void rgb_marquee_stop(void); void rgb_marquee_reset(void); bool is_rgb_marquee_enable(void); -void ledblink1(uint8_t color,uint8_t dir); -void ledblink2(uint8_t color,uint8_t dir, uint8_t end); -void ledblink3(uint8_t led_down,uint8_t color_led_down, uint8_t led_up, uint8_t color_led_up); -void ledblink4(uint8_t color,uint8_t dir, uint8_t end,uint8_t start_light,uint8_t stop_light); -void ledblink5(uint8_t color,uint8_t start, uint8_t stop); +void ledblink1(uint8_t color, uint8_t dir); +void ledblink2(uint8_t color, uint8_t dir, uint8_t end); +void ledblink3(uint8_t led_down, uint8_t color_led_down, uint8_t led_up, uint8_t color_led_up); +void ledblink4(uint8_t color, uint8_t dir, uint8_t end, uint8_t start_light, uint8_t stop_light); +void ledblink5(uint8_t color, uint8_t start, uint8_t stop); void ledblink6(void); #endif diff --git a/firmware/application/src/settings.c b/firmware/application/src/settings.c index 20ed57b..18bbe15 100644 --- a/firmware/application/src/settings.c +++ b/firmware/application/src/settings.c @@ -15,13 +15,11 @@ static settings_data_t config; static uint16_t m_config_crc; -static void update_config_crc(void) -{ +static void update_config_crc(void) { calc_14a_crc_lut((uint8_t *)&config, sizeof(config), (uint8_t *)&m_config_crc); } -static bool config_did_change(void) -{ +static bool config_did_change(void) { uint16_t new_calc_crc; calc_14a_crc_lut((uint8_t *)&config, sizeof(config), (uint8_t *)&new_calc_crc); return new_calc_crc != m_config_crc; @@ -36,15 +34,13 @@ void settings_init_button_press_config(void) { config.button_b_press = SettingsButtonCycleSlotDec; } -void settings_init_config(void) -{ +void settings_init_config(void) { settings_update_version_for_config(); config.animation_config = SettingsAnimationModeFull; settings_init_button_press_config(); } -void settings_migrate(void) -{ +void settings_migrate(void) { switch (config.version) { case 0: NRF_LOG_ERROR("Unexpected configuration version detected!"); @@ -77,8 +73,7 @@ void settings_migrate(void) } } -void settings_load_config(void) -{ +void settings_load_config(void) { bool ret = fds_read_sync(FDS_SETTINGS_FILE_ID, FDS_SETTINGS_RECORD_KEY, sizeof(config), (uint8_t *)&config); if (ret) { NRF_LOG_INFO("Load config done."); @@ -101,8 +96,7 @@ void settings_load_config(void) } } -uint8_t settings_save_config(void) -{ +uint8_t settings_save_config(void) { // We are saving the configuration, we need to calculate the crc code of the current configuration to judge whether the following data is updated if (config_did_change()) { // Before saving, make sure that the configuration has changed NRF_LOG_INFO("Save config start."); @@ -110,9 +104,7 @@ uint8_t settings_save_config(void) if (ret) { NRF_LOG_INFO("Save config success."); update_config_crc(); - } - else - { + } else { NRF_LOG_ERROR("Save config error."); return STATUS_FLASH_WRITE_FAIL; } @@ -123,13 +115,11 @@ uint8_t settings_save_config(void) return STATUS_DEVICE_SUCCESS; } -uint8_t settings_get_animation_config() -{ +uint8_t settings_get_animation_config() { return config.animation_config; } -void settings_set_animation_config(uint8_t value) -{ +void settings_set_animation_config(uint8_t value) { config.animation_config = value; } @@ -141,15 +131,14 @@ void settings_set_animation_config(uint8_t value) * @return false Button type Invalid. */ bool is_settings_button_type_valid(char type) { - switch (type) - { - case 'a': - case 'b': - case 'A': - case 'B': - return true; - default: - return false; + switch (type) { + case 'a': + case 'b': + case 'A': + case 'B': + return true; + default: + return false; } } @@ -159,22 +148,20 @@ bool is_settings_button_type_valid(char type) { * @param which 'a' or 'b' * @return uint8_t @link{ settings_button_function_t } */ -uint8_t settings_get_button_press_config(char which) -{ - switch (which) - { - case 'a': - case 'A': - return config.button_a_press; +uint8_t settings_get_button_press_config(char which) { + switch (which) { + case 'a': + case 'A': + return config.button_a_press; - case 'b': - case 'B': - return config.button_b_press; + case 'b': + case 'B': + return config.button_b_press; - default: - // can't to here. - APP_ERROR_CHECK_BOOL(false); - break; + default: + // can't to here. + APP_ERROR_CHECK_BOOL(false); + break; } // can't to here. return SettingsButtonDisable; @@ -187,21 +174,20 @@ uint8_t settings_get_button_press_config(char which) * @param value @link{ settings_button_function_t } */ void settings_set_button_press_config(char which, uint8_t value) { - switch (which) - { - case 'a': - case 'A': - config.button_a_press = value; - break; + switch (which) { + case 'a': + case 'A': + config.button_a_press = value; + break; - case 'b': - case 'B': - config.button_b_press = value; - break; + case 'b': + case 'B': + config.button_b_press = value; + break; - default: - // can't to here. - APP_ERROR_CHECK_BOOL(false); - break; + default: + // can't to here. + APP_ERROR_CHECK_BOOL(false); + break; } } diff --git a/firmware/application/src/usb_main.c b/firmware/application/src/usb_main.c index afe365f..20a26c4 100644 --- a/firmware/application/src/usb_main.c +++ b/firmware/application/src/usb_main.c @@ -47,92 +47,92 @@ static void cdc_acm_user_ev_handler(app_usbd_class_inst_t const *p_inst, app_usb // app_usbd_cdc_acm_t const *p_cdc_acm = app_usbd_cdc_acm_class_get(p_inst); switch (event) { - case APP_USBD_CDC_ACM_USER_EVT_PORT_OPEN: { - /* - * 整个USB接收数据的大概关键之处就是 app_usbd_cdc_acm_read - * app_usbd_cdc_acm_read函数其实不是正经的接收，是给了一个指针，然后等USB的buffer填充到此处 - * 所以需要在 APP_USBD_CDC_ACM_USER_EVT_PORT_OPEN 时先初始化设置头部指针，达到预先设置接收缓冲区的效果 - * 如果在 APP_USBD_CDC_ACM_USER_EVT_RX_DONE 使用下标 0 去访问缓冲区，将会导致丢失第一个发送过来的字节。。 - */ - ret_code_t ret = app_usbd_cdc_acm_read(&m_app_cdc_acm, cdc_data_buffer, 1); - UNUSED_VARIABLE(ret); - NRF_LOG_INFO("CDC ACM port opened"); - g_usb_port_opened = true; - break; - } + case APP_USBD_CDC_ACM_USER_EVT_PORT_OPEN: { + /* + * 整个USB接收数据的大概关键之处就是 app_usbd_cdc_acm_read + * app_usbd_cdc_acm_read函数其实不是正经的接收，是给了一个指针，然后等USB的buffer填充到此处 + * 所以需要在 APP_USBD_CDC_ACM_USER_EVT_PORT_OPEN 时先初始化设置头部指针，达到预先设置接收缓冲区的效果 + * 如果在 APP_USBD_CDC_ACM_USER_EVT_RX_DONE 使用下标 0 去访问缓冲区，将会导致丢失第一个发送过来的字节。。 + */ + ret_code_t ret = app_usbd_cdc_acm_read(&m_app_cdc_acm, cdc_data_buffer, 1); + UNUSED_VARIABLE(ret); + NRF_LOG_INFO("CDC ACM port opened"); + g_usb_port_opened = true; + break; + } - case APP_USBD_CDC_ACM_USER_EVT_PORT_CLOSE: - NRF_LOG_INFO("CDC ACM port closed"); - g_usb_port_opened = false; - g_usb_led_marquee_enable = true; - break; + case APP_USBD_CDC_ACM_USER_EVT_PORT_CLOSE: + NRF_LOG_INFO("CDC ACM port closed"); + g_usb_port_opened = false; + g_usb_led_marquee_enable = true; + break; - case APP_USBD_CDC_ACM_USER_EVT_TX_DONE: - break; + case APP_USBD_CDC_ACM_USER_EVT_TX_DONE: + break; - case APP_USBD_CDC_ACM_USER_EVT_RX_DONE: { - ret_code_t ret; - // 先取出第一个字节 - data_frame_receive(cdc_data_buffer, 1); - do { - ret = app_usbd_cdc_acm_read(&m_app_cdc_acm, cdc_data_buffer, 1); - if (ret == NRF_SUCCESS) { - // 成功取到之后的字节 - data_frame_receive(cdc_data_buffer, 1); - } - } while (ret == NRF_SUCCESS); - break; - } - default: - break; + case APP_USBD_CDC_ACM_USER_EVT_RX_DONE: { + ret_code_t ret; + // 先取出第一个字节 + data_frame_receive(cdc_data_buffer, 1); + do { + ret = app_usbd_cdc_acm_read(&m_app_cdc_acm, cdc_data_buffer, 1); + if (ret == NRF_SUCCESS) { + // 成功取到之后的字节 + data_frame_receive(cdc_data_buffer, 1); + } + } while (ret == NRF_SUCCESS); + break; + } + default: + break; } } static void usbd_user_ev_handler(app_usbd_event_type_t event) { switch (event) { - case APP_USBD_EVT_DRV_SUSPEND: - NRF_LOG_INFO("USB SUSPEND"); - break; + case APP_USBD_EVT_DRV_SUSPEND: + NRF_LOG_INFO("USB SUSPEND"); + break; - case APP_USBD_EVT_DRV_RESUME: - NRF_LOG_INFO("USB RESUME"); - break; + case APP_USBD_EVT_DRV_RESUME: + NRF_LOG_INFO("USB RESUME"); + break; - case APP_USBD_EVT_STARTED: - NRF_LOG_INFO("USB STARTED"); - break; + case APP_USBD_EVT_STARTED: + NRF_LOG_INFO("USB STARTED"); + break; - case APP_USBD_EVT_STOPPED: - NRF_LOG_INFO("USB STOPPED"); - app_usbd_disable(); - break; + case APP_USBD_EVT_STOPPED: + NRF_LOG_INFO("USB STOPPED"); + app_usbd_disable(); + break; - case APP_USBD_EVT_POWER_DETECTED: - sleep_timer_stop(); - NRF_LOG_INFO("USB power detected"); - if (!nrf_drv_usbd_is_enabled()) { - app_usbd_enable(); - } - g_usb_led_marquee_enable = true; - break; + case APP_USBD_EVT_POWER_DETECTED: + sleep_timer_stop(); + NRF_LOG_INFO("USB power detected"); + if (!nrf_drv_usbd_is_enabled()) { + app_usbd_enable(); + } + g_usb_led_marquee_enable = true; + break; - case APP_USBD_EVT_POWER_REMOVED: - sleep_timer_start(SLEEP_DELAY_MS_USB_POWER_DISCONNECTED); - NRF_LOG_INFO("USB power removed"); - g_usb_connected = false; - g_usb_led_marquee_enable = false; - app_usbd_stop(); - break; + case APP_USBD_EVT_POWER_REMOVED: + sleep_timer_start(SLEEP_DELAY_MS_USB_POWER_DISCONNECTED); + NRF_LOG_INFO("USB power removed"); + g_usb_connected = false; + g_usb_led_marquee_enable = false; + app_usbd_stop(); + break; - case APP_USBD_EVT_POWER_READY: - NRF_LOG_INFO("USB ready"); - g_usb_connected = true; - app_usbd_start(); - break; + case APP_USBD_EVT_POWER_READY: + NRF_LOG_INFO("USB ready"); + g_usb_connected = true; + app_usbd_start(); + break; - default: - // NRF_LOG_INFO("Other usb event: %d", event); - break; + default: + // NRF_LOG_INFO("Other usb event: %d", event); + break; } } @@ -141,7 +141,8 @@ static void usbd_user_ev_handler(app_usbd_event_type_t event) { void usb_cdc_init(void) { ret_code_t ret; static const app_usbd_config_t usbd_config = { - .ev_state_proc = usbd_user_ev_handler}; + .ev_state_proc = usbd_user_ev_handler + }; app_usbd_serial_num_generate(); diff --git a/firmware/application/src/utils/dataframe.c b/firmware/application/src/utils/dataframe.c index e69a67c..3ee2d77 100644 --- a/firmware/application/src/utils/dataframe.c +++ b/firmware/application/src/utils/dataframe.c @@ -50,7 +50,7 @@ static data_frame_tx_t m_frame_tx_buf_info = { * @param length: 应答数据长度 * @param data: 应答数据 */ -data_frame_tx_t* data_frame_make(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { +data_frame_tx_t *data_frame_make(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t lrc_tx = 0x00; uint16_t i, j; // sof diff --git a/firmware/application/src/utils/dataframe.h b/firmware/application/src/utils/dataframe.h index 592724a..d0e22f5 100644 --- a/firmware/application/src/utils/dataframe.h +++ b/firmware/application/src/utils/dataframe.h @@ -13,7 +13,7 @@ typedef void (*data_frame_cbk_t)(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data); // TX buffer typedef struct { - uint8_t* const buffer; + uint8_t *const buffer; uint16_t length; } data_frame_tx_t; @@ -22,7 +22,7 @@ void data_frame_receive(uint8_t *data, uint16_t length); void data_frame_process(void); void on_data_frame_complete(data_frame_cbk_t callback); -data_frame_tx_t* data_frame_make( +data_frame_tx_t *data_frame_make( uint16_t cmd, uint16_t status, uint16_t length, diff --git a/firmware/application/src/utils/delayed_reset.c b/firmware/application/src/utils/delayed_reset.c index 1dc4c89..129621c 100644 --- a/firmware/application/src/utils/delayed_reset.c +++ b/firmware/application/src/utils/delayed_reset.c @@ -7,7 +7,7 @@ APP_TIMER_DEF(m_reset_timer); -static void delayed_reset_event_handler(void* ctx) { +static void delayed_reset_event_handler(void *ctx) { while (NRF_LOG_PROCESS()); ret_code_t ret = sd_nvic_SystemReset(); APP_ERROR_CHECK(ret); diff --git a/firmware/application/src/utils/fds_util.c b/firmware/application/src/utils/fds_util.c index c7223fa..586ede7 100644 --- a/firmware/application/src/utils/fds_util.c +++ b/firmware/application/src/utils/fds_util.c @@ -50,7 +50,7 @@ bool fds_is_exists(uint16_t id, uint16_t key) { /** * 读取记录 */ -bool fds_read_sync(uint16_t id, uint16_t key, uint16_t max_length, uint8_t* buffer) { +bool fds_read_sync(uint16_t id, uint16_t key, uint16_t max_length, uint8_t *buffer) { ret_code_t err_code; // 操作的结果码 fds_flash_record_t flash_record; // 指向flash中的实际信息 fds_record_desc_t record_desc; // 记录的句柄 @@ -75,7 +75,7 @@ bool fds_read_sync(uint16_t id, uint16_t key, uint16_t max_length, uint8_t* buff /** * 没有GC过程的写入操作函数的实现 */ -static ret_code_t fds_write_record_nogc(uint16_t id, uint16_t key, uint16_t data_length_words, void* buffer) { +static ret_code_t fds_write_record_nogc(uint16_t id, uint16_t key, uint16_t data_length_words, void *buffer) { ret_code_t err_code; // 操作的结果码 fds_record_desc_t record_desc; // 记录的句柄 fds_record_t record = { // 记录的实体，写和更新操作时用的上 @@ -101,7 +101,7 @@ static ret_code_t fds_write_record_nogc(uint16_t id, uint16_t key, uint16_t data /** * 写入记录 */ -bool fds_write_sync(uint16_t id, uint16_t key, uint16_t data_length_words, void* buffer) { +bool fds_write_sync(uint16_t id, uint16_t key, uint16_t data_length_words, void *buffer) { // Make only one task running APP_ERROR_CHECK_BOOL(!fds_operation_info.waiting); // write result @@ -115,7 +115,7 @@ bool fds_write_sync(uint16_t id, uint16_t key, uint16_t data_length_words, void* // 调用无自动GC的写实现函数 ret_code_t err_code = fds_write_record_nogc(id, key, data_length_words, buffer); if (err_code == NRF_SUCCESS) { - while(!fds_operation_info.success) { + while (!fds_operation_info.success) { __NOP(); }; // 等待操作完成 } else if (err_code == FDS_ERR_NO_SPACE_IN_FLASH) { // 确保还有空间可以操作，否则需要GC @@ -128,7 +128,7 @@ bool fds_write_sync(uint16_t id, uint16_t key, uint16_t data_length_words, void* fds_operation_info.success = false; err_code = fds_write_record_nogc(id, key, data_length_words, buffer); if (err_code == NRF_SUCCESS) { - while(!fds_operation_info.success) { + while (!fds_operation_info.success) { __NOP(); }; // 等待操作完成 } else if (err_code == FDS_ERR_NO_SPACE_IN_FLASH) { @@ -156,13 +156,13 @@ int fds_delete_sync(uint16_t id, uint16_t key) { int delete_count = 0; fds_record_desc_t record_desc; ret_code_t err_code; - while(fds_find_record(id, key, &record_desc)) { + while (fds_find_record(id, key, &record_desc)) { fds_operation_info.success = false; fds_record_id_from_desc(&record_desc, &fds_operation_info.record_id); err_code = fds_record_delete(&record_desc); APP_ERROR_CHECK(err_code); delete_count++; - while(!fds_operation_info.success) { + while (!fds_operation_info.success) { __NOP(); }; // 等待操作完成 } @@ -172,7 +172,7 @@ int fds_delete_sync(uint16_t id, uint16_t key) { /** * FDS事件回调 */ -static void fds_evt_handler(fds_evt_t const * p_evt) { +static void fds_evt_handler(fds_evt_t const *p_evt) { // To process fds event switch (p_evt->id) { case FDS_EVT_INIT: { @@ -181,7 +181,8 @@ static void fds_evt_handler(fds_evt_t const * p_evt) { } else { APP_ERROR_CHECK(p_evt->result); } - } break; + } + break; case FDS_EVT_WRITE: case FDS_EVT_UPDATE: { if (p_evt->result == NRF_SUCCESS) { @@ -193,7 +194,8 @@ static void fds_evt_handler(fds_evt_t const * p_evt) { } else { APP_ERROR_CHECK(p_evt->result); } - } break; + } + break; case FDS_EVT_DEL_RECORD: { if (p_evt->result == NRF_SUCCESS) { NRF_LOG_INFO( @@ -208,14 +210,16 @@ static void fds_evt_handler(fds_evt_t const * p_evt) { } else { APP_ERROR_CHECK(p_evt->result); } - } break; + } + break; case FDS_EVT_GC: { if (p_evt->result == NRF_SUCCESS) { fds_operation_info.success = true; } else { APP_ERROR_CHECK(p_evt->result); } - } break; + } + break; default: { // nothing to do... } break; @@ -240,7 +244,7 @@ void fds_gc_sync(void) { fds_operation_info.success = false; ret_code_t err_code = fds_gc(); APP_ERROR_CHECK(err_code); - while(!fds_operation_info.success) { + while (!fds_operation_info.success) { __NOP(); }; } @@ -263,7 +267,7 @@ static bool fds_next_record_delete_sync() { return false; } - while(!fds_operation_info.success) { + while (!fds_operation_info.success) { __NOP(); } diff --git a/firmware/application/src/utils/fds_util.h b/firmware/application/src/utils/fds_util.h index df1b832..feb477a 100644 --- a/firmware/application/src/utils/fds_util.h +++ b/firmware/application/src/utils/fds_util.h @@ -4,8 +4,8 @@ #include "fds.h" -bool fds_read_sync(uint16_t id, uint16_t key, uint16_t max_length, uint8_t* buffer); -bool fds_write_sync(uint16_t id, uint16_t key, uint16_t data_length_words, void* buffer); +bool fds_read_sync(uint16_t id, uint16_t key, uint16_t max_length, uint8_t *buffer); +bool fds_write_sync(uint16_t id, uint16_t key, uint16_t data_length_words, void *buffer); int fds_delete_sync(uint16_t id, uint16_t key); bool fds_is_exists(uint16_t id, uint16_t key); void fds_util_init(void); diff --git a/firmware/application/src/utils/syssleep.c b/firmware/application/src/utils/syssleep.c index cecfd63..b94adba 100644 --- a/firmware/application/src/utils/syssleep.c +++ b/firmware/application/src/utils/syssleep.c @@ -18,8 +18,7 @@ extern bool g_is_tag_emulating; // 标志模拟卡的状态 * @param 无 * @return 无 */ -static void timer_sleep_event_handle(void *arg) -{ +static void timer_sleep_event_handle(void *arg) { // 休眠条件达到，设置标志位，让main中处理即可 m_system_off_enter = true; } diff --git a/firmware/application/src/utils/timeslot.c b/firmware/application/src/utils/timeslot.c index ecf77e6..5af2a72 100644 --- a/firmware/application/src/utils/timeslot.c +++ b/firmware/application/src/utils/timeslot.c @@ -23,8 +23,7 @@ static volatile bool m_is_timeslot_working = false; /**@brief Configure next timeslot event in earliest configuration */ -void configure_next_event_earliest(void) -{ +void configure_next_event_earliest(void) { m_timeslot_request.request_type = NRF_RADIO_REQ_TYPE_EARLIEST; // 首次请求timeslot必须要 m_timeslot_request.params.earliest.hfclk = NRF_RADIO_HFCLK_CFG_NO_GUARANTEE; // 不必自动使能外部高频晶振 m_timeslot_request.params.earliest.priority = NRF_RADIO_PRIORITY_HIGH; // 必须使用高优先级 @@ -34,8 +33,7 @@ void configure_next_event_earliest(void) /**@brief Request next timeslot event in earliest configuration */ -uint32_t request_next_event_earliest(void) -{ +uint32_t request_next_event_earliest(void) { configure_next_event_earliest(); return sd_radio_request(&m_timeslot_request); } @@ -43,8 +41,7 @@ uint32_t request_next_event_earliest(void) /**@brief Timeslot signal handler */ -static void t55xx_soc_evt_handler(uint32_t evt_id, void * p_context) -{ +static void t55xx_soc_evt_handler(uint32_t evt_id, void *p_context) { //NRF_LOG_INFO("t55xx_soc_evt_handler: %d", evt_id); uint32_t err_code; switch (evt_id) { @@ -74,10 +71,9 @@ NRF_SDH_SOC_OBSERVER(m_sys_obs, 0, t55xx_soc_evt_handler, NULL); /**@brief Timeslot event handler */ -nrf_radio_signal_callback_return_param_t * radio_callback(uint8_t signal_type) -{ +nrf_radio_signal_callback_return_param_t *radio_callback(uint8_t signal_type) { //NRF_LOG_INFO("radio_callback: %d", signal_type); - switch(signal_type) { + switch (signal_type) { case NRF_RADIO_CALLBACK_SIGNAL_TYPE_START: signal_callback_return_param.params.request.p_next = NULL; signal_callback_return_param.callback_action = NRF_RADIO_SIGNAL_CALLBACK_ACTION_NONE; @@ -115,7 +111,7 @@ void request_timeslot(uint32_t time_us, timeslot_callback_t callback, bool wait_ APP_ERROR_CHECK(err_code); // 堵塞等待时序请求成功 - while(!m_is_timeslot_working) { + while (!m_is_timeslot_working) { NRF_LOG_PROCESS(); } @@ -141,7 +137,7 @@ void request_timeslot(uint32_t time_us, timeslot_callback_t callback, bool wait_ // 关闭会话并且等待关闭完成 err_code = sd_radio_session_close(); APP_ERROR_CHECK(err_code); - while(m_is_timeslot_working) { + while (m_is_timeslot_working) { __NOP(); } @@ -172,7 +168,7 @@ void timeslot_start(uint32_t time_us) { APP_ERROR_CHECK(err_code); // 堵塞等待时序请求成功 - while(!m_is_timeslot_working) { + while (!m_is_timeslot_working) { NRF_LOG_PROCESS(); } @@ -204,7 +200,7 @@ void timeslot_stop(void) { // 关闭会话并且等待关闭完成 err_code = sd_radio_session_close(); APP_ERROR_CHECK(err_code); - while(m_is_timeslot_working) { + while (m_is_timeslot_working) { __NOP(); } diff --git a/firmware/bootloader/src/dfu_public_key.c b/firmware/bootloader/src/dfu_public_key.c index 03ad9ae..c6a9881 100644 --- a/firmware/bootloader/src/dfu_public_key.c +++ b/firmware/bootloader/src/dfu_public_key.c @@ -5,8 +5,7 @@ #include "compiler_abstraction.h" /** @brief Public key used to verify DFU images */ -__ALIGN(4) const uint8_t pk[64] = -{ +__ALIGN(4) const uint8_t pk[64] = { 0x7c, 0x06, 0xab, 0x89, 0x78, 0xfc, 0x8e, 0xc5, 0xe1, 0xfe, 0x45, 0x44, 0x47, 0x99, 0xb6, 0x42, 0x41, 0xf2, 0x85, 0x27, 0x24, 0xd4, 0xda, 0x20, 0x99, 0x96, 0x6b, 0x88, 0xb4, 0xd0, 0x43, 0xc6, 0x5f, 0xfc, 0xa2, 0xdb, 0x3f, 0x7c, 0x36, 0x30, 0x29, 0x8a, 0x63, 0x71, 0x5d, 0xd0, 0x46, 0xc5, 0x51, 0x4b, 0xc0, 0x5b, 0x2d, 0xdf, 0xbf, 0x6f, 0x53, 0x3e, 0x9b, 0xe5, 0x11, 0xef, 0xad, 0xe9 }; diff --git a/firmware/bootloader/src/main.c b/firmware/bootloader/src/main.c index 5850fe4..f1fe07c 100644 --- a/firmware/bootloader/src/main.c +++ b/firmware/bootloader/src/main.c @@ -65,8 +65,7 @@ #include "hw_connect.h" -static void on_error(void) -{ +static void on_error(void) { NRF_LOG_FINAL_FLUSH(); #if NRF_MODULE_ENABLED(NRF_LOG_BACKEND_RTT) @@ -80,22 +79,19 @@ static void on_error(void) } -void app_error_handler(uint32_t error_code, uint32_t line_num, const uint8_t * p_file_name) -{ +void app_error_handler(uint32_t error_code, uint32_t line_num, const uint8_t *p_file_name) { NRF_LOG_ERROR("%s:%d", p_file_name, line_num); on_error(); } -void app_error_fault_handler(uint32_t id, uint32_t pc, uint32_t info) -{ +void app_error_fault_handler(uint32_t id, uint32_t pc, uint32_t info) { NRF_LOG_ERROR("Received a fault! id: 0x%08x, pc: 0x%08x, info: 0x%08x", id, pc, info); on_error(); } -void app_error_handler_bare(uint32_t error_code) -{ +void app_error_handler_bare(uint32_t error_code) { NRF_LOG_ERROR("Received an error: 0x%08x!", error_code); on_error(); } @@ -109,18 +105,17 @@ void flash_led(void *p_event_data, uint16_t event_size) { set_slot_light_color(m_led_flash_state); int led_flash_speed; - switch (m_led_flash_state) - { - case 0: - default: - led_flash_speed = 250000; - break; - case 1: - led_flash_speed = 150000; - break; - case 2: - led_flash_speed = 50000; - break; + switch (m_led_flash_state) { + case 0: + default: + led_flash_speed = 250000; + break; + case 1: + led_flash_speed = 150000; + break; + case 2: + led_flash_speed = 50000; + break; } if (m_led_flash_setp == 0) { @@ -146,10 +141,8 @@ void flash_led(void *p_event_data, uint16_t event_size) { /** * @brief Function notifies certain events in DFU process. */ -static void dfu_observer(nrf_dfu_evt_type_t evt_type) -{ - switch (evt_type) - { +static void dfu_observer(nrf_dfu_evt_type_t evt_type) { + switch (evt_type) { case NRF_DFU_EVT_DFU_INITIALIZED: nrfx_systick_init(); m_led_flash_state = 0; @@ -180,8 +173,7 @@ static void dfu_observer(nrf_dfu_evt_type_t evt_type) */ /**@brief Function for application main entry. */ -int main(void) -{ +int main(void) { ret_code_t ret_val; // Must to init hardware connect. diff --git a/firmware/common/hw_connect.c b/firmware/common/hw_connect.c index f61dd16..8a3151a 100644 --- a/firmware/common/hw_connect.c +++ b/firmware/common/hw_connect.c @@ -81,8 +81,8 @@ void board_lite_high_voltage_set(void) { NRF_POWER->DCDCEN = 0; NRF_POWER->DCDCEN0 = 0; #endif - // if the chameleon lite is powered from USB (high voltage mode), GPIO output voltage is set to 1.8 volts by - // default and that is not enough to turn the green and blue LEDs on. Increase GPIO voltage to 3.0 volts. + // if the chameleon lite is powered from USB (high voltage mode), GPIO output voltage is set to 1.8 volts by + // default and that is not enough to turn the green and blue LEDs on. Increase GPIO voltage to 3.0 volts. if (((NRF_UICR->REGOUT0 & UICR_REGOUT0_VOUT_Msk) == (UICR_REGOUT0_VOUT_DEFAULT << UICR_REGOUT0_VOUT_Pos))) { NRF_NVMC->CONFIG = NVMC_CONFIG_WEN_Wen << NVMC_CONFIG_WEN_Pos; while (NRF_NVMC->READY == NVMC_READY_READY_Busy); @@ -106,18 +106,18 @@ void hw_connect_init(void) { #if defined(PROJECT_CHAMELEON_ULTRA) if (m_hw_ver == 1) { - LED_FIELD = (NRF_GPIO_PIN_MAP(1, 1)); - LED_R = (NRF_GPIO_PIN_MAP(0, 24)); - LED_G = (NRF_GPIO_PIN_MAP(0, 22)); - LED_B = (NRF_GPIO_PIN_MAP(1, 0)); - LED_1 = (NRF_GPIO_PIN_MAP(0, 20)); - LED_2 = (NRF_GPIO_PIN_MAP(0, 17)); - LED_3 = (NRF_GPIO_PIN_MAP(0, 15)); - LED_4 = (NRF_GPIO_PIN_MAP(0, 13)); - LED_5 = (NRF_GPIO_PIN_MAP(0, 12)); - LED_6 = (NRF_GPIO_PIN_MAP(1, 9)); - LED_7 = (NRF_GPIO_PIN_MAP(0, 8)); - LED_8 = (NRF_GPIO_PIN_MAP(0, 6)); + LED_FIELD = (NRF_GPIO_PIN_MAP(1, 1)); + LED_R = (NRF_GPIO_PIN_MAP(0, 24)); + LED_G = (NRF_GPIO_PIN_MAP(0, 22)); + LED_B = (NRF_GPIO_PIN_MAP(1, 0)); + LED_1 = (NRF_GPIO_PIN_MAP(0, 20)); + LED_2 = (NRF_GPIO_PIN_MAP(0, 17)); + LED_3 = (NRF_GPIO_PIN_MAP(0, 15)); + LED_4 = (NRF_GPIO_PIN_MAP(0, 13)); + LED_5 = (NRF_GPIO_PIN_MAP(0, 12)); + LED_6 = (NRF_GPIO_PIN_MAP(1, 9)); + LED_7 = (NRF_GPIO_PIN_MAP(0, 8)); + LED_8 = (NRF_GPIO_PIN_MAP(0, 6)); RGB_LIST_NUM = 8; RGB_CTRL_NUM = 3; @@ -190,15 +190,15 @@ void hw_connect_init(void) { sprintf(g_extern_product_str, "%s: hw_v%d, fw_v%d", DEVICE_NAME_STR, m_hw_ver, FW_VER_NUM); } -uint32_t* hw_get_led_array(void) { +uint32_t *hw_get_led_array(void) { return m_led_array; } -uint32_t* hw_get_led_reversal_array(void) { +uint32_t *hw_get_led_reversal_array(void) { return m_led_reversal_array; } -uint32_t* hw_get_rgb_array(void) { +uint32_t *hw_get_rgb_array(void) { return m_rgb_array; } @@ -212,8 +212,8 @@ uint8_t hw_get_version_code(void) { // 初始化设备的LED灯珠 void init_leds(void) { - uint32_t* led_pins = hw_get_led_array(); - uint32_t* led_rgb_pins = hw_get_rgb_array(); + uint32_t *led_pins = hw_get_led_array(); + uint32_t *led_rgb_pins = hw_get_rgb_array(); // 初始化卡槽那几颗LED灯的GPIO（其他的LED由其他的模块控制） for (uint8_t i = 0; i < RGB_LIST_NUM; i++) { @@ -240,7 +240,7 @@ void set_slot_light_color(uint8_t color) { nrf_gpio_pin_set(LED_R); nrf_gpio_pin_set(LED_G); nrf_gpio_pin_set(LED_B); - switch(color) { + switch (color) { case 0: nrf_gpio_pin_clear(LED_R); break; diff --git a/firmware/common/hw_connect.h b/firmware/common/hw_connect.h index 45b53e7..ecc3518 100644 --- a/firmware/common/hw_connect.h +++ b/firmware/common/hw_connect.h @@ -92,9 +92,9 @@ extern uint32_t g_reader_power; void hw_connect_init(void); void init_leds(void); -uint32_t* hw_get_led_array(void); -uint32_t* hw_get_led_reversal_array(void); -uint32_t* hw_get_rgb_array(void); +uint32_t *hw_get_led_array(void); +uint32_t *hw_get_led_reversal_array(void); +uint32_t *hw_get_rgb_array(void); chameleon_device_type_t hw_get_device_type(void); uint8_t hw_get_version_code(void); void set_slot_light_color(uint8_t color); diff --git a/firmware/common/libc_nano_stubs.c b/firmware/common/libc_nano_stubs.c index 0558de5..49c1353 100644 --- a/firmware/common/libc_nano_stubs.c +++ b/firmware/common/libc_nano_stubs.c @@ -12,40 +12,40 @@ See also https://stackoverflow.com/questions/73742774/gcc-arm-none-eabi-11-3-is- extern int errno; int _close(int file) { - errno = EINVAL; - return -1; + errno = EINVAL; + return -1; } int _fstat(int file, struct stat *st) { - errno = EINVAL; - return -1; + errno = EINVAL; + return -1; } int _getpid(void) { - return 1; + return 1; } int _isatty(int file) { - errno = EINVAL; - return 0; + errno = EINVAL; + return 0; } int _kill(int pid, int sig) { - errno = EINVAL; - return -1; + errno = EINVAL; + return -1; } int _lseek(int file, int ptr, int dir) { - errno = EINVAL; - return -1; + errno = EINVAL; + return -1; } int _read(int file, char *ptr, int len) { - errno = EINVAL; - return -1; + errno = EINVAL; + return -1; } int _write(int file, char *ptr, int len) { - errno = EINVAL; - return -1; + errno = EINVAL; + return -1; } diff --git a/software/src/darkside.c b/software/src/darkside.c index 9efda7a..21cdc11 100644 --- a/software/src/darkside.c +++ b/software/src/darkside.c @@ -18,7 +18,7 @@ typedef struct { } DarksideParam; // 转换字符串为U32类型 -uint64_t atoui(const char* str) { +uint64_t atoui(const char *str) { uint64_t result = 0; for (int i = 0; str[i] != '\0'; ++i) { @@ -29,15 +29,14 @@ uint64_t atoui(const char* str) { return result; } -void num_to_bytes(uint64_t n, uint32_t len, uint8_t* dest) -{ +void num_to_bytes(uint64_t n, uint32_t len, uint8_t *dest) { while (len--) { dest[len] = (uint8_t)n; n >>= 8; } } -int main(int argc, char* argv[]) { +int main(int argc, char *argv[]) { if (((argc - 2) % 5) != 0) { printf("Unexcepted param count\n"); @@ -47,8 +46,8 @@ int main(int argc, char* argv[]) { uint32_t uid = (uint32_t)atoui(argv[1]); uint32_t count = 0, i = 0; uint32_t keycount = 0; - uint64_t* keylist = NULL, * last_keylist = NULL; - DarksideParam* dps = NULL; + uint64_t *keylist = NULL, * last_keylist = NULL; + DarksideParam *dps = NULL; bool no_key_recover = true; for (i = 1; i + 5 < argc;) { @@ -106,8 +105,7 @@ int main(int argc, char* argv[]) { for (i = 0; i < keycount; i++) { if (par_list == 0) { num_to_bytes(last_keylist[i], 6, key_tmp); - } - else { + } else { num_to_bytes(keylist[i], 6, key_tmp); } printf("Key%d: %02X%02X%02X%02X%02X%02X\r\n", i + 1, key_tmp[0], key_tmp[1], key_tmp[2], key_tmp[3], key_tmp[4], key_tmp[5]); @@ -121,8 +119,7 @@ int main(int argc, char* argv[]) { if (last_keylist == keylist && last_keylist != NULL) { free(keylist); - } - else { + } else { if (last_keylist) { free(last_keylist); } diff --git a/software/src/mfkey64.c b/software/src/mfkey64.c index 2935dcd..9659ef9 100644 --- a/software/src/mfkey64.c +++ b/software/src/mfkey64.c @@ -30,12 +30,12 @@ int main(int argc, char *argv[]) { if (enclen == NULL) { return 1; } - uint8_t **enc = (uint8_t**)malloc(encc * sizeof(uint8_t*)); + uint8_t **enc = (uint8_t **)malloc(encc * sizeof(uint8_t *)); if (enc == NULL) { return 1; } for (int i = 0; i < encc; i++) { - *(enc + i) = (uint8_t*)malloc(120 * sizeof(uint8_t*)); + *(enc + i) = (uint8_t *)malloc(120 * sizeof(uint8_t *)); if (*(enc + i) == NULL) { return 1; } @@ -49,7 +49,7 @@ int main(int argc, char *argv[]) { for (int i = 0; i < encc; i++) { *(enclen + i) = strlen(argv[i + 6]) / 2; - for (int i2 = 0; i2 < *(enclen + i); i2++) { + for (int i2 = 0; i2 < * (enclen + i); i2++) { sscanf(argv[i + 6] + i2 * 2, "%2hhx", &enc[i][i2]); } } diff --git a/software/src/nested.c b/software/src/nested.c index e77fa35..2e8be0a 100644 --- a/software/src/nested.c +++ b/software/src/nested.c @@ -29,10 +29,10 @@ typedef struct { } NtpKs1; typedef struct { - NtpKs1* pNK; + NtpKs1 *pNK; uint32_t authuid; - uint64_t* keys; + uint64_t *keys; uint32_t keyCount; uint32_t startPos; @@ -40,20 +40,20 @@ typedef struct { } RecPar; -int compar_int(const void* a, const void* b) { - return (*(uint64_t*)b - *(uint64_t*)a); +int compar_int(const void *a, const void *b) { + return (*(uint64_t *)b - * (uint64_t *)a); } // Compare countKeys structure -int compar_special_int(const void* a, const void* b) { - return (((countKeys*)b)->count - ((countKeys*)a)->count); +int compar_special_int(const void *a, const void *b) { + return (((countKeys *)b)->count - ((countKeys *)a)->count); } // keys qsort and unique. -countKeys* uniqsort(uint64_t* possibleKeys, uint32_t size) { +countKeys *uniqsort(uint64_t *possibleKeys, uint32_t size) { unsigned int i, j = 0; int count = 0; - countKeys* our_counts; + countKeys *our_counts; qsort(possibleKeys, size, sizeof(uint64_t), compar_int); @@ -66,8 +66,7 @@ countKeys* uniqsort(uint64_t* possibleKeys, uint32_t size) { for (i = 0; i < size; i++) { if (possibleKeys[i + 1] == possibleKeys[i]) { count++; - } - else { + } else { our_counts[j].key = possibleKeys[i]; our_counts[j].count = count; j++; @@ -78,7 +77,7 @@ countKeys* uniqsort(uint64_t* possibleKeys, uint32_t size) { return (our_counts); } -uint32_t atoui(const char* str) { +uint32_t atoui(const char *str) { uint32_t result = 0; for (int i = 0; str[i] != '\0'; ++i) { @@ -90,8 +89,8 @@ uint32_t atoui(const char* str) { } // nested decrypt -static void nested_revover(RecPar* rp) { - struct Crypto1State* revstate, * revstate_start = NULL; +static void nested_revover(RecPar *rp) { + struct Crypto1State *revstate, * revstate_start = NULL; uint64_t lfsr = 0; uint32_t i, kcount = 0; @@ -113,14 +112,14 @@ static void nested_revover(RecPar* rp) { if (((kcount % MEM_CHUNK) == 0) || (kcount >= rp->keyCount)) { rp->keyCount += MEM_CHUNK; // printf("New chunk by %d, sizeof %lu\n", kcount, key_count * sizeof(uint64_t)); - void* tmp = realloc(rp->keys, rp->keyCount * sizeof(uint64_t)); + void *tmp = realloc(rp->keys, rp->keyCount * sizeof(uint64_t)); if (tmp == NULL) { printf("Memory allocation error for pk->possibleKeys"); // exit(EXIT_FAILURE); rp->keyCount = 0; return; } - rp->keys = (uint64_t*)tmp; + rp->keys = (uint64_t *)tmp; } rp->keys[kcount] = lfsr; kcount++; @@ -132,7 +131,7 @@ static void nested_revover(RecPar* rp) { // Truncate if (kcount != 0) { rp->keyCount = --kcount; - void* tmp = (uint64_t*)realloc(rp->keys, rp->keyCount * sizeof(uint64_t)); + void *tmp = (uint64_t *)realloc(rp->keys, rp->keyCount * sizeof(uint64_t)); if (tmp == NULL) { printf("Memory allocation error for pk->possibleKeys"); // exit(EXIT_FAILURE); @@ -146,11 +145,11 @@ static void nested_revover(RecPar* rp) { return; } -uint64_t* nested(NtpKs1* pNK, uint32_t sizePNK, uint32_t authuid, uint32_t* keyCount) { +uint64_t *nested(NtpKs1 *pNK, uint32_t sizePNK, uint32_t authuid, uint32_t *keyCount) { *keyCount = 0; uint32_t i; - RecPar* pRPs = malloc(sizeof(RecPar)); + RecPar *pRPs = malloc(sizeof(RecPar)); if (pRPs == NULL) { return NULL; } @@ -164,7 +163,7 @@ uint64_t* nested(NtpKs1* pNK, uint32_t sizePNK, uint32_t authuid, uint32_t* keyC nested_revover(pRPs); *keyCount = pRPs->keyCount; - uint64_t* keys = NULL; + uint64_t *keys = NULL; if (*keyCount != 0) { keys = malloc(*keyCount * sizeof(uint64_t)); if (keys != NULL) { @@ -174,9 +173,9 @@ uint64_t* nested(NtpKs1* pNK, uint32_t sizePNK, uint32_t authuid, uint32_t* keyC } free(pRPs); - countKeys* ck = uniqsort(keys, *keyCount); + countKeys *ck = uniqsort(keys, *keyCount); free(keys); - keys = (uint64_t*)NULL; + keys = (uint64_t *)NULL; *keyCount = 0; if (ck != NULL) { @@ -185,36 +184,34 @@ uint64_t* nested(NtpKs1* pNK, uint32_t sizePNK, uint32_t authuid, uint32_t* keyC // This key can be found here two or more times if (ck[i].count > 0) { *keyCount += 1; - void* tmp = realloc(keys, sizeof(uint64_t) * (*keyCount)); + void *tmp = realloc(keys, sizeof(uint64_t) * (*keyCount)); if (tmp != NULL) { keys = tmp; keys[*keyCount - 1] = ck[i].key; - } - else { + } else { printf("Cannot allocate memory for keys on merge."); free(keys); break; } } } - } - else { + } else { printf("Cannot allocate memory for ck on uniqsort."); } return keys; } // Return 1 if the nonce is invalid else return 0 -static uint8_t valid_nonce(uint32_t Nt, uint32_t NtEnc, uint32_t Ks1, uint8_t* parity) { +static uint8_t valid_nonce(uint32_t Nt, uint32_t NtEnc, uint32_t Ks1, uint8_t *parity) { return ( - (oddparity8((Nt >> 24) & 0xFF) == ((parity[0]) ^ oddparity8((NtEnc >> 24) & 0xFF) ^ BIT(Ks1, 16))) && \ - (oddparity8((Nt >> 16) & 0xFF) == ((parity[1]) ^ oddparity8((NtEnc >> 16) & 0xFF) ^ BIT(Ks1, 8))) && \ - (oddparity8((Nt >> 8) & 0xFF) == ((parity[2]) ^ oddparity8((NtEnc >> 8) & 0xFF) ^ BIT(Ks1, 0))) - ) ? 1 : 0; + (oddparity8((Nt >> 24) & 0xFF) == ((parity[0]) ^ oddparity8((NtEnc >> 24) & 0xFF) ^ BIT(Ks1, 16))) && \ + (oddparity8((Nt >> 16) & 0xFF) == ((parity[1]) ^ oddparity8((NtEnc >> 16) & 0xFF) ^ BIT(Ks1, 8))) && \ + (oddparity8((Nt >> 8) & 0xFF) == ((parity[2]) ^ oddparity8((NtEnc >> 8) & 0xFF) ^ BIT(Ks1, 0))) + ) ? 1 : 0; } -int main(int argc, char* const argv[]) { - NtpKs1* pNK = NULL; +int main(int argc, char *const argv[]) { + NtpKs1 *pNK = NULL; uint32_t i, j, m; uint32_t nt1, nt2, nttest, ks1, dist; uint8_t par_int; @@ -233,8 +230,7 @@ int main(int argc, char* const argv[]) { for (m = 0; m < 3; m++) { par_arr[m] = (par_int >> m) & 0x01; } - } - else { + } else { memset(par_arr, 0, 3); } // Try to recover the keystream1 @@ -244,7 +240,7 @@ int main(int argc, char* const argv[]) { if (valid_nonce(nttest, nt2, ks1, par_arr)) { ++j; // append to list - void* tmp = realloc(pNK, sizeof(NtpKs1) * j); + void *tmp = realloc(pNK, sizeof(NtpKs1) * j); if (tmp == NULL) { goto error; } @@ -256,7 +252,7 @@ int main(int argc, char* const argv[]) { } } uint32_t keyCount = 0; - uint64_t* keys = nested(pNK, j, authuid, &keyCount); + uint64_t *keys = nested(pNK, j, authuid, &keyCount); if (keyCount > 0) { for (i = 0; i < keyCount; i++) {