/** * Copyright (c) 2016 - 2020, Nordic Semiconductor ASA * * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * * 2. Redistributions in binary form, except as embedded into a Nordic * Semiconductor ASA integrated circuit in a product or a software update for * such product, must reproduce the above copyright notice, this list of * conditions and the following disclaimer in the documentation and/or other * materials provided with the distribution. * * 3. Neither the name of Nordic Semiconductor ASA nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * 4. This software, with or without modification, must only be used with a * Nordic Semiconductor ASA integrated circuit. * * 5. Any software provided in binary form under this license must not be reverse * engineered, decompiled, modified and/or disassembled. * * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ /************************************************************************************* 2022/01/26 ¾÷µ¥ÀÌÆ® ÈÄ ¹Ù²ï ¹öÀüÁ¤º¸ È®ÀÎÀ» À§ÇØ ºÎÆýà ¼­¹ö¿¡ ¹öÀüÁ¤º¸ Àü´Þ *************************************************************************************/ #include #include #include #include "nordic_common.h" #include "app_error.h" #include "app_uart.h" #include "ble_db_discovery.h" #include "app_timer.h" #include "app_util.h" #include "bsp_btn_ble.h" #include "ble.h" #include "ble_gap.h" #include "ble_hci.h" #include "nrf_sdh.h" #include "nrf_sdh_ble.h" #include "nrf_sdh_soc.h" #include "ble_nus_c.h" #include "nrf_ble_gatt.h" #include "nrf_pwr_mgmt.h" #include "nrf_ble_scan.h" #include "peer_manager.h" #include "nrf_log.h" #include "nrf_log_ctrl.h" #include "nrf_log_default_backends.h" #include "our_service.h" #include "board_gpi.h" #include "nrf_spi.h" #include "nrf_drv_spi.h" #include "app_util_platform.h" #include "nrf_gpio.h" #include "nrf_delay.h" #include "boards.h" #include "app_error.h" #include #include "main.h" #include "sysmgr.h" #define APP_BLE_CONN_CFG_TAG 1 /**< Tag that refers to the BLE stack configuration set with @ref sd_ble_cfg_set. The default tag is @ref BLE_CONN_CFG_TAG_DEFAULT. */ #define APP_BLE_OBSERVER_PRIO 3 /**< BLE observer priority of the application. There is no need to modify this value. */ #define UART_TX_BUF_SIZE 256 /**< UART TX buffer size. */ #define UART_RX_BUF_SIZE 256 /**< UART RX buffer size. */ #define NUS_SERVICE_UUID_TYPE BLE_UUID_TYPE_VENDOR_BEGIN /**< UUID type for the Nordic UART Service (vendor specific). */ #define ECHOBACK_BLE_UART_DATA 1 /**< Echo the UART data that is received over the Nordic UART Service (NUS) back to the sender. */ BLE_NUS_C_DEF(m_ble_nus_c); /**< BLE Nordic UART Service (NUS) client instance. */ NRF_BLE_GATT_DEF(m_gatt); /**< GATT module instance. */ BLE_DB_DISCOVERY_DEF(m_db_disc); /**< Database discovery module instance. */ NRF_BLE_SCAN_DEF(m_scan); /**< Scanning Module instance. */ NRF_BLE_GQ_DEF(m_ble_gatt_queue, /**< BLE GATT Queue instance. */ NRF_SDH_BLE_CENTRAL_LINK_COUNT, NRF_BLE_GQ_QUEUE_SIZE); #define SPI_INSTANCE 0 /**< SPI instance index. */ //const nrf_drv_spi_t spi = NRF_DRV_SPI_INSTANCE(SPI_INSTANCE); /**< SPI instance. */ //const nrf_drv_spi_t spi = { 0, { .spi = spi0 }, false }; /**< SPI instance. */ volatile bool spi_xfer_done; /**< Flag used to indicate that SPI instance completed the transfer. */ APP_TIMER_DEF(m_our_char_timer_id); #define OUR_CHAR_TIMER_INTERVAL APP_TIMER_TICKS(1) // 1 ms intervals static uint16_t m_ble_nus_max_data_len = BLE_GATT_ATT_MTU_DEFAULT - OPCODE_LENGTH - HANDLE_LENGTH; /**< Maximum length of data (in bytes) that can be transmitted to the peer by the Nordic UART service module. */ static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; unsigned int gTimeCounter = 0; /**@brief NUS UUID. */ static ble_uuid_t const m_nus_uuid = { .uuid = BLE_UUID_NUS_SERVICE, .type = NUS_SERVICE_UUID_TYPE }; //static char my_addr[6] = {0xE9, 0xB1, 0x8D, 0xA2, 0xED, 0x07}; C static char my_addr[6] = {0x65, 0x7C, 0x2C, 0x69, 0xC1, 0xDB}; //P //static char my_addr_1[6] = {0x26, 0xAA, 0xEE, 0x75, 0x90, 0xCC}; //SAMPLE //static char my_addr[6] = {0x65, 0x7C, 0x2C, 0x69, 0xC1, 0xDD}; //P TEST Bad-Mac static char my_addr_1[6] = {0x26, 0xAA, 0xEE, 0x75, 0x90, 0xCd}; //SAMPLE bad-mac extern char ScanHSBuff[]; extern uint8_t m_tx_buf[]; /**< TX buffer. */ extern uint8_t m_rx_buf[]; /**< RX buffer. */ extern uint8_t m_length; /**< Transfer length. */ /* Flag to check fds initialization. */ static bool volatile m_fds_initialized; /* Array to map FDS events to strings. */ static char const * fds_evt_str[] = { "FDS_EVT_INIT", "FDS_EVT_WRITE", "FDS_EVT_UPDATE", "FDS_EVT_DEL_RECORD", "FDS_EVT_DEL_FILE", "FDS_EVT_GC", }; /* Keep track of the progress of a delete_all operation. */ static struct { bool delete_next; //!< Delete next record. bool pending; //!< Waiting for an fds FDS_EVT_DEL_RECORD event, to delete the next record. } m_delete_all; ble_gap_addr_t old_ble_addr; ble_gap_addr_t new_ble_addr; static void fds_evt_handler(fds_evt_t const * p_evt) { if (p_evt->result == NRF_SUCCESS) { NRF_LOG_INFO("Event: %s received (NRF_SUCCESS)", fds_evt_str[p_evt->id]); } else { NRF_LOG_INFO("Event: %s received (%s)", fds_evt_str[p_evt->id], fds_err_str(p_evt->result)); } switch (p_evt->id) { case FDS_EVT_INIT: if (p_evt->result == NRF_SUCCESS) { m_fds_initialized = true; } break; case FDS_EVT_WRITE: { if (p_evt->result == NRF_SUCCESS) { NRF_LOG_INFO("Record ID:\t0x%04x", p_evt->write.record_id); NRF_LOG_INFO("File ID:\t0x%04x", p_evt->write.file_id); NRF_LOG_INFO("Record key:\t0x%04x", p_evt->write.record_key); } } break; case FDS_EVT_DEL_RECORD: { if (p_evt->result == NRF_SUCCESS) { NRF_LOG_INFO("Record ID:\t0x%04x", p_evt->del.record_id); NRF_LOG_INFO("File ID:\t0x%04x", p_evt->del.file_id); NRF_LOG_INFO("Record key:\t0x%04x", p_evt->del.record_key); } m_delete_all.pending = false; } break; default: break; } } /**@brief Begin deleting all records, one by one. */ void delete_all_begin(void) { m_delete_all.delete_next = true; } /**@brief Process a delete all command. * * Delete records, one by one, until no records are left. */ void delete_all_process(void) { if (m_delete_all.delete_next & !m_delete_all.pending) { NRF_LOG_INFO("Deleting next record."); m_delete_all.delete_next = record_delete_next(); if (!m_delete_all.delete_next) { NRF_LOG_INFO("No records left to delete."); } } } /** * @brief SPI user event handler. * @param event */ void spi_event_handler(nrf_drv_spi_evt_t const * p_event, void * p_context) { spi_xfer_done = true; NRF_LOG_INFO("Transfer completed."); if (m_rx_buf[0] != 0) { NRF_LOG_INFO(" Received:"); NRF_LOG_HEXDUMP_INFO(m_rx_buf, strlen((const char *)m_rx_buf)); } } // 1ms tick (1ms interrupt) // ALREADY_DONE_FOR_YOU: This is a timer event handler static void timer_timeout_handler(void * p_context) { // Step 3.F, Update temperature and characteristic value. static int32_t sensor_value = 0; // sd_temp_get(&sensor_value); // *modify where sensor measurement function goes // our_sensor_characteristic_update(&m_our_service, &sensor_value); // make a call to characteristic update function // nrf_gpio_pin_toggle(LED_4); //printf("%d\r\n", sensor_value++); //SendData(); gTimeCounter++; SystemTimer.MS_1++; SystemTimer.UART_LAST_RECV_TIMER++; SystemTimer.SEND_TEST_TIMER++; SystemTimer.LED_TOGGLE_TIMER++; SystemTimer.TMR_CON_START++; SystemTimer.PARK_KEEP_TIMER++; SystemTimer.DEV_REG_TIMER++; SystemTimer.SVR_SEND_TIMER++; SystemManager.LedBlinkTimer--; if(!(SystemTimer.MS_1 % 10)){ SystemTimer.MS_10_TICK = 1; } if(!(SystemTimer.MS_1 % 100)){ SystemTimer.MS_100_TICK = 1; } if(!(SystemTimer.MS_1 % 1000)){ SystemTimer.MS_1000_TICK = 1; } if( SystemTimer.TMR_CON_START == 10000 ) { sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_LOCAL_HOST_TERMINATED_CONNECTION); } } /**@brief Function for starting timers. */ static void application_timers_start(void) { /* YOUR_JOB: Start your timers. below is an example of how to start a timer. ret_code_t err_code; err_code = app_timer_start(m_app_timer_id, TIMER_INTERVAL, NULL); APP_ERROR_CHECK(err_code); */ app_timer_start(m_our_char_timer_id, OUR_CHAR_TIMER_INTERVAL, NULL); } /**@brief Function for handling asserts in the SoftDevice. * * @details This function is called in case of an assert in the SoftDevice. * * @warning This handler is only an example and is not meant for the final product. You need to analyze * how your product is supposed to react in case of assert. * @warning On assert from the SoftDevice, the system can only recover on reset. * * @param[in] line_num Line number of the failing assert call. * @param[in] p_file_name File name of the failing assert call. */ void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name) { app_error_handler(0xDEADBEEF, line_num, p_file_name); } /**@brief Function for handling the Nordic UART Service Client errors. * * @param[in] nrf_error Error code containing information about what went wrong. */ static void nus_error_handler(uint32_t nrf_error) { APP_ERROR_HANDLER(nrf_error); } /**@brief Function to start scanning. */ static void scan_start(void) { ret_code_t ret; ret = nrf_ble_scan_start(&m_scan); APP_ERROR_CHECK(ret); ret = bsp_indication_set(BSP_INDICATE_SCANNING); APP_ERROR_CHECK(ret); } /**@brief Function for handling Scanning Module events. */ static void scan_evt_handler(scan_evt_t const * p_scan_evt) { ret_code_t err_code; switch(p_scan_evt->scan_evt_id) { case NRF_BLE_SCAN_EVT_CONNECTING_ERROR: { err_code = p_scan_evt->params.connecting_err.err_code; APP_ERROR_CHECK(err_code); } break; case NRF_BLE_SCAN_EVT_CONNECTED: { ble_gap_evt_connected_t const * p_connected = p_scan_evt->params.connected.p_connected; // Scan is automatically stopped by the connection. NRF_LOG_INFO("Connecting to target %02x%02x%02x%02x%02x%02x", p_connected->peer_addr.addr[0], p_connected->peer_addr.addr[1], p_connected->peer_addr.addr[2], p_connected->peer_addr.addr[3], p_connected->peer_addr.addr[4], p_connected->peer_addr.addr[5] ); } break; case NRF_BLE_SCAN_EVT_SCAN_TIMEOUT: { NRF_LOG_INFO("Scan timed out."); scan_start(); } break; default: break; } } /**@brief Function for initializing the scanning and setting the filters. */ static void scan_init(void) { ret_code_t err_code; nrf_ble_scan_init_t init_scan; memset(&init_scan, 0, sizeof(init_scan)); init_scan.connect_if_match = true; init_scan.conn_cfg_tag = APP_BLE_CONN_CFG_TAG; err_code = nrf_ble_scan_init(&m_scan, &init_scan, scan_evt_handler); APP_ERROR_CHECK(err_code); #if 0 err_code = nrf_ble_scan_filter_set(&m_scan, SCAN_ADDR_FILTER, my_addr); APP_ERROR_CHECK(err_code); err_code = nrf_ble_scan_filter_set(&m_scan, SCAN_ADDR_FILTER, my_addr_1); APP_ERROR_CHECK(err_code); err_code = nrf_ble_scan_filters_enable(&m_scan, NRF_BLE_SCAN_ADDR_FILTER, false); APP_ERROR_CHECK(err_code); #endif #if 1 err_code = nrf_ble_scan_filter_set(&m_scan, SCAN_UUID_FILTER, &m_nus_uuid); APP_ERROR_CHECK(err_code); err_code = nrf_ble_scan_filters_enable(&m_scan, NRF_BLE_SCAN_UUID_FILTER, false); APP_ERROR_CHECK(err_code); #endif } /**@brief Function for handling database discovery events. * * @details This function is a callback function to handle events from the database discovery module. * Depending on the UUIDs that are discovered, this function forwards the events * to their respective services. * * @param[in] p_event Pointer to the database discovery event. */ static void db_disc_handler(ble_db_discovery_evt_t * p_evt) { ble_nus_c_on_db_disc_evt(&m_ble_nus_c, p_evt); } /**@brief Function for handling characters received by the Nordic UART Service (NUS). * * @details This function takes a list of characters of length data_len and prints the characters out on UART. * If @ref ECHOBACK_BLE_UART_DATA is set, the data is sent back to sender. */ static void ble_nus_chars_received_uart_print(uint8_t * p_data, uint16_t data_len) { ret_code_t ret_val; NRF_LOG_DEBUG("Receiving data."); NRF_LOG_INFO("Receiving data."); NRF_LOG_RAW_INFO("Receiving data."); NRF_LOG_HEXDUMP_DEBUG(p_data, data_len); for (uint32_t i = 0; i < data_len; i++) { do { ret_val = app_uart_put(p_data[i]); if ((ret_val != NRF_SUCCESS) && (ret_val != NRF_ERROR_BUSY)) { NRF_LOG_ERROR("app_uart_put failed for index 0x%04x.", i); APP_ERROR_CHECK(ret_val); } } while (ret_val == NRF_ERROR_BUSY); } if (p_data[data_len-1] == '\r') { while (app_uart_put('\n') == NRF_ERROR_BUSY); } if (ECHOBACK_BLE_UART_DATA) { // Send data back to the peripheral. do { ret_val = ble_nus_c_string_send(&m_ble_nus_c, p_data, data_len); if ((ret_val != NRF_SUCCESS) && (ret_val != NRF_ERROR_BUSY)) { NRF_LOG_ERROR("Failed sending NUS message. Error 0x%x. ", ret_val); APP_ERROR_CHECK(ret_val); } } while (ret_val == NRF_ERROR_BUSY); } } void uart_event_handle(app_uart_evt_t * p_event) { static uint8_t data_array[BLE_NUS_MAX_DATA_LEN]; static uint16_t index = 0; uint32_t ret_val; switch (p_event->evt_type) { /**@snippet [Handling data from UART] */ case APP_UART_DATA_READY: // SystemTimer.UART1_LAST_RECV_TIMER = 0; USART_Handler(); break; case APP_UART_DATA: NRF_LOG_INFO("APP_UART_DATA"); break; /**@snippet [Handling data from UART] */ case APP_UART_COMMUNICATION_ERROR: NRF_LOG_ERROR("Communication error occurred while handling UART."); APP_ERROR_HANDLER(p_event->data.error_communication); break; case APP_UART_FIFO_ERROR: NRF_LOG_ERROR("Error occurred in FIFO module used by UART."); APP_ERROR_HANDLER(p_event->data.error_code); break; default: break; } } /**@brief Callback handling Nordic UART Service (NUS) client events. * * @details This function is called to notify the application of NUS client events. * * @param[in] p_ble_nus_c NUS client handle. This identifies the NUS client. * @param[in] p_ble_nus_evt Pointer to the NUS client event. */ /**@snippet [Handling events from the ble_nus_c module] */ // BLE Connect ÀÌÈÄ nus Event static void ble_nus_c_evt_handler(ble_nus_c_t * p_ble_nus_c, ble_nus_c_evt_t const * p_ble_nus_evt) { int i; ret_code_t err_code; switch (p_ble_nus_evt->evt_type) { case BLE_NUS_C_EVT_DISCOVERY_COMPLETE: // Connecting NRF_LOG_INFO("Discovery complete."); //printf("Discovery complete.\r\n"); err_code = ble_nus_c_handles_assign(p_ble_nus_c, p_ble_nus_evt->conn_handle, &p_ble_nus_evt->handles); APP_ERROR_CHECK(err_code); err_code = ble_nus_c_tx_notif_enable(p_ble_nus_c); APP_ERROR_CHECK(err_code); NRF_LOG_INFO("Connected to device with Nordic UART Service."); if( SystemManager.BandMode == AES_ENC_CAR ) { NRF_LOG_INFO("SystemManager.BandMode == AES_ENC_CAR\n"); CarEncryptEcb( AES_ENC_CAR ); ble_nus_c_string_send(&m_ble_nus_c, SystemManager.AesEncData, 16); }else if( SystemManager.BandMode == AES_ENC_EMG ) { CarEncryptEcb( AES_ENC_EMG ); ble_nus_c_string_send(&m_ble_nus_c, SystemManager.AesEncData, 16); }else if( SystemManager.BandMode == AES_ENC_PCA ) { CarEncryptEcb( AES_ENC_PCA ); ble_nus_c_string_send(&m_ble_nus_c, SystemManager.AesEncData, 16); } break; case BLE_NUS_C_EVT_NUS_TX_EVT: // BLE NUS Data Rx //ble_nus_chars_received_uart_print(p_ble_nus_evt->p_data, p_ble_nus_evt->data_len); //printf("Connected to device with Nordic UART Service. Len:%d\r\n", p_ble_nus_evt->data_len); for( i=0; idata_len; i++) { //NRF_LOG_RAW_INFO("%02x-", p_ble_nus_evt->p_data[i]); } NRF_LOG_RAW_INFO("Type %x\n", p_ble_nus_evt->p_data[0]); SystemManager.NusData = p_ble_nus_evt->p_data[12]; switch(p_ble_nus_evt->p_data[0]){ case TRANSFER_UNIT_EMG_SWITCH: // ¹«¼± ºñ»óº§ ½ÅÈ£ switch(p_ble_nus_evt->p_data[12]){ // ºñ»óº§ ¹öÆ° µ¿À۽à case DEV_NUS_EMG: NRF_LOG_INFO("TRANSFER SWITCH --- Emergency"); SystemManager.BatLevel = p_ble_nus_evt->p_data[13]; SystemManager.TransferVerHigh = p_ble_nus_evt->p_data[14]; SystemManager.TransferVerLow = p_ble_nus_evt->p_data[15]; switch(SystemManager.System_State){ case SYSTEM_EMERGENCY_SIREN: case SYSTEM_SERVER_COMM: case SYSTEM_SERVER_COMM_REQ: break; case SYSTEM_REGISTER: if( FindRegMac(ScanHSBuff) == 1 ) { SystemManager.RegRequst = 0; SystemManager.LedBlinkRun = 0; SystemManager.System_State = SYSTEM_NONE; ble_nus_c_string_send(&m_ble_nus_c, "tWESACK", 7); NRF_LOG_INFO("Device Registration Disable"); SystemManager.SwitchOn = 0; PKBuzzerOff(); PKLedOff(); err_code = sd_ble_gap_disconnect(p_ble_nus_c->conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); } break; case SYSTEM_NONE: SystemManager.LedBlinkRun = 1; SystemManager.LedBlinkTimer = 5000; SystemTimer.LED_TOGGLE_TIMER = 0; SystemManager.DevType = 0; err_code = sd_ble_gap_disconnect(p_ble_nus_c->conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); SendEmergency(); break; } break; // Å×½ºÆ® ¹öÆ° µ¿À۽à case DEV_NUS_TEST: NRF_LOG_INFO("TRANSFER SWITCH --- TEST"); SystemManager.BatLevel = p_ble_nus_evt->p_data[13]; SystemManager.TransferVerHigh = p_ble_nus_evt->p_data[14]; SystemManager.TransferVerLow = p_ble_nus_evt->p_data[15]; switch(SystemManager.System_State){ case SYSTEM_EMERGENCY_SIREN: case SYSTEM_SERVER_COMM: case SYSTEM_SERVER_COMM_REQ: break; case SYSTEM_REGISTER: if( FindRegMac(ScanHSBuff) == 1 ) { SystemManager.RegRequst = 0; SystemManager.LedBlinkRun = 0; SystemManager.System_State = SYSTEM_NONE; ble_nus_c_string_send(&m_ble_nus_c, "tWESACK", 7); NRF_LOG_INFO("Device Registration Disable"); SystemManager.SwitchOn = 0; PKBuzzerOff(); PKLedOff(); } err_code = sd_ble_gap_disconnect(p_ble_nus_c->conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); break; case SYSTEM_NONE: err_code = sd_ble_gap_disconnect(p_ble_nus_c->conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); AliveTest(); break; } break; // µî·Ï¹öÆ° µ¿À۽à case DEV_NUS_REG: NRF_LOG_INFO("TRANSFER SWITCH --- Device Registration"); SystemTimer.DEV_REG_TIMER = 0; SystemManager.BatLevel = p_ble_nus_evt->p_data[13]; SystemManager.TransferVerHigh = p_ble_nus_evt->p_data[14]; SystemManager.TransferVerLow = p_ble_nus_evt->p_data[15]; if(SystemManager.RegRequst) // ÇöÀç µî·Ï¸ðµåÀÏ °æ¿ì { // SystemManager.LedBlinkRun = COM_TYPE_SVR_RECV_REG+1; SystemManager.LedBlinkRun = COM_TYPE_SVR_RECV_REG_ANSWER; SystemManager.LedBlinkTimer = 2000; SystemTimer.LED_TOGGLE_TIMER = 0; for( i=0; i<6; i++) { NRF_LOG_INFO("0x%02x", SystemManager.PeerAddr[i]); } NRF_LOG_RAW_INFO("Reg Mac=>%s\n", SystemManager.PtrPeerAddrStr); NRF_LOG_RAW_INFO("\n"); SaveRegMac(SystemManager.PtrPeerAddrStr); ble_nus_c_string_send(&m_ble_nus_c, "tWESACK", 7); NRF_LOG_INFO("Send tWESACK"); SendCurrentRegDev(); err_code = sd_ble_gap_disconnect(p_ble_nus_c->conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); }else{ ; } break; // Alive µ¿À۽à case DEV_NUS_ALIVE: NRF_LOG_INFO("TRANSFER SWITCH --- Alive"); SystemManager.BatLevel = p_ble_nus_evt->p_data[13]; SystemManager.TransferVerHigh = p_ble_nus_evt->p_data[14]; SystemManager.TransferVerLow = p_ble_nus_evt->p_data[15]; SendAlive(); err_code = sd_ble_gap_disconnect(p_ble_nus_c->conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); break; } break; // ¹êµå ÁÖÂ÷ case TRANSFER_UNIT_BAND_PARKING: NRF_LOG_RAW_INFO("Band Parking %d\n", p_ble_nus_evt->data_len); SystemManager.SecondData = 1; SystemManager.BandType = 0x73; memcpy( SystemManager.TmpBuff, p_ble_nus_evt->p_data, p_ble_nus_evt->data_len ); CarDecryptEcb( &SystemManager.TmpBuff[1], SystemManager.AesEncData ); for( i=0; i<16; i++) { NRF_LOG_RAW_INFO("%02x ", SystemManager.AesEncData[i]); } SystemManager.Site[0] = SystemManager.AesEncData[4]; SystemManager.Site[1] = SystemManager.AesEncData[5]; SystemManager.Site[2] = SystemManager.AesEncData[6]; SystemManager.Site[3] = SystemManager.AesEncData[7]; SystemManager.Dong[0] = SystemManager.AesEncData[8]; SystemManager.Dong[1] = SystemManager.AesEncData[9]; SystemManager.Ho[0] = SystemManager.AesEncData[10]; SystemManager.Ho[1] = SystemManager.AesEncData[11]; break; // ¹êµå ºñ»ó case TRANSFER_UNIT_BAND_EMG: NRF_LOG_RAW_INFO("Band Alarm %d\n", p_ble_nus_evt->data_len); SystemManager.SecondData = 1; SystemManager.BandType = 0x72; memcpy( SystemManager.TmpBuff, p_ble_nus_evt->p_data, p_ble_nus_evt->data_len ); CarDecryptEcb( &SystemManager.TmpBuff[1], SystemManager.AesEncData ); for( i=0; i<16; i++) { NRF_LOG_RAW_INFO("%02x ", SystemManager.AesEncData[i]); } SystemManager.Site[0] = SystemManager.AesEncData[4]; SystemManager.Site[1] = SystemManager.AesEncData[5]; SystemManager.Site[2] = SystemManager.AesEncData[6]; SystemManager.Site[3] = SystemManager.AesEncData[7]; SystemManager.Dong[0] = SystemManager.AesEncData[8]; SystemManager.Dong[1] = SystemManager.AesEncData[9]; SystemManager.Ho[0] = SystemManager.AesEncData[10]; SystemManager.Ho[1] = SystemManager.AesEncData[11]; break; } //err_code = sd_ble_gap_disconnect(m_conn_handle, // BLE_HCI_LOCAL_HOST_TERMINATED_CONNECTION); //APP_ERROR_CHECK(err_code); //ble_nus_data_send(&m_ble_nus_c, data_array, &length, m_conn_handle); if( SystemManager.SecondData ) // µÎ¹ø° Packet { NRF_LOG_RAW_INFO("======== DEV_BAND\n"); //NRF_LOG_RAW_INFO("======== Car Information Second %d\n", p_ble_nus_evt->data_len); SystemManager.SecondData = 0; for( i=0; idata_len; i++) { // NRF_LOG_RAW_INFO("%02x ", p_ble_nus_evt->p_data[i]); } memcpy( SystemManager.TmpBuff, p_ble_nus_evt->p_data, p_ble_nus_evt->data_len ); #if 0 NRF_LOG_RAW_INFO("======== SystemManager.TmpBuff\n"); for( i=0; idata_len; i++) { NRF_LOG_RAW_INFO("%02x ",SystemManager.TmpBuff[i]); } NRF_LOG_RAW_INFO("\n"); #endif CarDecryptEcb( &SystemManager.TmpBuff[0], SystemManager.AesEncData ); for( i=0; i<16; i++) { NRF_LOG_RAW_INFO("%02x ", SystemManager.AesEncData[i]); } NRF_LOG_RAW_INFO("\n"); switch(SystemManager.BandType){ // BAND PARKING case TRANSFER_UNIT_BAND_PARKING: if( SystemManager.ServerCon == 0) { // CARACK ECB ¾Ïȣȭ Àü¼Û CarEncryptEcbACK(SystemManager.BandType); ble_nus_c_string_send(&m_ble_nus_c, SystemManager.AesEncData, 16); // Disconnect err_code = sd_ble_gap_disconnect(p_ble_nus_c->conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); SystemManager.BandMode = AES_ENC_NONE; SendParkingBand(); } break; // BAND EMG case TRANSFER_UNIT_BAND_EMG: if( SystemManager.ServerCon == 0) { #if 0 // CARACK ECB ¾Ïȣȭ Àü¼Û CarEncryptEcbACK(SystemManager.BandType); ble_nus_c_string_send(&m_ble_nus_c, SystemManager.AesEncData, 16); #endif // Disconnect err_code = sd_ble_gap_disconnect(p_ble_nus_c->conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); SystemManager.BandMode = AES_ENC_NONE; switch(SystemManager.System_State){ case SYSTEM_NONE: SendEmergencyBand(); break; case SYSTEM_REGISTER: case SYSTEM_EMERGENCY_SIREN: case SYSTEM_SERVER_COMM: case SYSTEM_SERVER_COMM_REQ: break; } err_code = sd_ble_gap_disconnect(p_ble_nus_c->conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); SystemManager.BandMode = 0; } break; // New iOS App case TRANSFER_UNIT_NEW_IOS_PARKING: if( SystemManager.ServerCon == 0) { CarEncryptEcbACK(SystemManager.BandType); ble_nus_c_string_send(&m_ble_nus_c, SystemManager.AesEncData, 16); // Disconnect err_code = sd_ble_gap_disconnect(p_ble_nus_c->conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); SystemManager.BandMode = AES_ENC_NONE; SendParkingApp(); } break; } } break; case BLE_NUS_C_EVT_DISCONNECTED: NRF_LOG_INFO("Disconnected --------------------\n"); // printf("Disconnected.\r\n"); scan_start(); break; } } /**@snippet [Handling events from the ble_nus_c module] */ /** * @brief Function for handling shutdown events. * * @param[in] event Shutdown type. */ static bool shutdown_handler(nrf_pwr_mgmt_evt_t event) { ret_code_t err_code; err_code = bsp_indication_set(BSP_INDICATE_IDLE); APP_ERROR_CHECK(err_code); switch (event) { case NRF_PWR_MGMT_EVT_PREPARE_WAKEUP: // Prepare wakeup buttons. err_code = bsp_btn_ble_sleep_mode_prepare(); APP_ERROR_CHECK(err_code); break; default: break; } return true; } NRF_PWR_MGMT_HANDLER_REGISTER(shutdown_handler, APP_SHUTDOWN_HANDLER_PRIORITY); /**@brief Function for handling BLE events. * * @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) { int i; ret_code_t err_code; ble_gap_evt_t const * p_gap_evt = &p_ble_evt->evt.gap_evt; switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_ADV_REPORT : //NRF_LOG_INFO("BLE_GAP_EVT_ADV_REPORT : %d", &p_gap_evt->params.adv_report.data.len); //NRF_LOG_INFO(&p_gap_evt->params.adv_report); break; case BLE_GAP_EVT_SCAN_REQ_REPORT: NRF_LOG_INFO("BLE_GAP_EVT_SCAN_REQ_REPORT"); break; case BLE_GAP_EVT_CONNECTED: NRF_LOG_INFO("BLE_GAP_EVT_CONNECTED"); err_code = ble_nus_c_handles_assign(&m_ble_nus_c, p_ble_evt->evt.gap_evt.conn_handle, NULL); APP_ERROR_CHECK(err_code); err_code = bsp_indication_set(BSP_INDICATE_CONNECTED); APP_ERROR_CHECK(err_code); // start discovery of services. The NUS Client waits for a discovery result err_code = ble_db_discovery_start(&m_db_disc, p_ble_evt->evt.gap_evt.conn_handle); APP_ERROR_CHECK(err_code); break; case BLE_GAP_EVT_DISCONNECTED: NRF_LOG_INFO("Disconnected. conn_handle: 0x%x, reason: 0x%x", p_gap_evt->conn_handle, p_gap_evt->params.disconnected.reason); break; case BLE_GAP_EVT_TIMEOUT: if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN) { NRF_LOG_INFO("Connection Request timed out."); } break; case BLE_GAP_EVT_SEC_PARAMS_REQUEST: // Pairing not supported. err_code = sd_ble_gap_sec_params_reply(p_ble_evt->evt.gap_evt.conn_handle, BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP, NULL, NULL); APP_ERROR_CHECK(err_code); break; case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST: // Accepting parameters requested by peer. err_code = sd_ble_gap_conn_param_update(p_gap_evt->conn_handle, &p_gap_evt->params.conn_param_update_request.conn_params); APP_ERROR_CHECK(err_code); break; case BLE_GAP_EVT_PHY_UPDATE_REQUEST: { NRF_LOG_DEBUG("PHY update request."); 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; case BLE_GATTC_EVT_TIMEOUT: // Disconnect on GATT Client timeout event. NRF_LOG_DEBUG("GATT Client Timeout."); err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); break; case BLE_GATTS_EVT_TIMEOUT: // Disconnect on GATT Server timeout event. NRF_LOG_DEBUG("GATT Server Timeout."); err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); APP_ERROR_CHECK(err_code); break; default: break; } } /**@brief Function for initializing the BLE stack. * * @details Initializes the SoftDevice and the BLE event interrupt. */ static void ble_stack_init(void) { ret_code_t err_code; err_code = nrf_sdh_enable_request(); APP_ERROR_CHECK(err_code); // Configure the BLE stack using the default settings. // Fetch the start address of the application RAM. uint32_t ram_start = 0; err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start); APP_ERROR_CHECK(err_code); // Enable BLE stack. err_code = nrf_sdh_ble_enable(&ram_start); APP_ERROR_CHECK(err_code); // Register a handler for BLE events. NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL); } /**@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 (p_evt->evt_id == NRF_BLE_GATT_EVT_ATT_MTU_UPDATED) { NRF_LOG_INFO("ATT MTU exchange completed."); m_ble_nus_max_data_len = p_evt->params.att_mtu_effective - OPCODE_LENGTH - HANDLE_LENGTH; //m_ble_nus_max_data_len = 244; NRF_LOG_INFO("Ble NUS max data length set to 0x%X(%d)", m_ble_nus_max_data_len, m_ble_nus_max_data_len); } } /**@brief Function for initializing the GATT library. */ void gatt_init(void) { ret_code_t err_code; err_code = nrf_ble_gatt_init(&m_gatt, gatt_evt_handler); APP_ERROR_CHECK(err_code); err_code = nrf_ble_gatt_att_mtu_central_set(&m_gatt, NRF_SDH_BLE_GATT_MAX_MTU_SIZE); APP_ERROR_CHECK(err_code); } /**@brief Function for handling events from the BSP module. * * @param[in] event Event generated by button press. */ void bsp_event_handler(bsp_event_t event) { ret_code_t err_code; switch (event) { case BSP_EVENT_SLEEP: nrf_pwr_mgmt_shutdown(NRF_PWR_MGMT_SHUTDOWN_GOTO_SYSOFF); break; case BSP_EVENT_DISCONNECT: err_code = sd_ble_gap_disconnect(m_ble_nus_c.conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); if (err_code != NRF_ERROR_INVALID_STATE) { APP_ERROR_CHECK(err_code); } break; default: break; } } /**@brief Function for initializing the UART. */ static void uart_init(void) { ret_code_t err_code; app_uart_comm_params_t const comm_params = { .rx_pin_no = RX_PIN_NUMBER, .tx_pin_no = TX_PIN_NUMBER, .rts_pin_no = RTS_PIN_NUMBER, .cts_pin_no = CTS_PIN_NUMBER, .flow_control = APP_UART_FLOW_CONTROL_DISABLED, .use_parity = false, .baud_rate = UART_BAUDRATE_BAUDRATE_Baud9600 }; APP_UART_FIFO_INIT(&comm_params, UART_RX_BUF_SIZE, UART_TX_BUF_SIZE, uart_event_handle, APP_IRQ_PRIORITY_LOWEST, err_code); APP_ERROR_CHECK(err_code); } /**@brief Function for initializing the Nordic UART Service (NUS) client. */ static void nus_c_init(void) { ret_code_t err_code; ble_nus_c_init_t init; init.evt_handler = ble_nus_c_evt_handler; init.error_handler = nus_error_handler; init.p_gatt_queue = &m_ble_gatt_queue; err_code = ble_nus_c_init(&m_ble_nus_c, &init); APP_ERROR_CHECK(err_code); } /**@brief Function for initializing buttons and leds. */ static void buttons_leds_init(void) { ret_code_t err_code; bsp_event_t startup_event; err_code = bsp_init(BSP_INIT_LEDS, bsp_event_handler); APP_ERROR_CHECK(err_code); err_code = bsp_btn_ble_init(NULL, &startup_event); APP_ERROR_CHECK(err_code); } /**@brief Function for initializing the timer. */ static void timer_init(void) { ret_code_t err_code = app_timer_init(); APP_ERROR_CHECK(err_code); app_timer_create(&m_our_char_timer_id, APP_TIMER_MODE_REPEATED, timer_timeout_handler); } /**@brief Function for initializing the nrf log module. */ static void log_init(void) { ret_code_t err_code = NRF_LOG_INIT(NULL); APP_ERROR_CHECK(err_code); NRF_LOG_DEFAULT_BACKENDS_INIT(); } /**@brief Function for initializing power management. */ static void power_management_init(void) { ret_code_t err_code; err_code = nrf_pwr_mgmt_init(); APP_ERROR_CHECK(err_code); } /** @brief Function for initializing the database discovery module. */ static void db_discovery_init(void) { ble_db_discovery_init_t db_init; memset(&db_init, 0, sizeof(ble_db_discovery_init_t)); db_init.evt_handler = db_disc_handler; db_init.p_gatt_queue = &m_ble_gatt_queue; ret_code_t err_code = ble_db_discovery_init(&db_init); APP_ERROR_CHECK(err_code); } /**@brief Function for handling the idle state (main loop). * * @details Handles any pending log operations, then sleeps until the next event occurs. */ static void idle_state_handle(void) { if (NRF_LOG_PROCESS() == false) { nrf_pwr_mgmt_run(); } } /**@brief Function for handling events from the button handler module. * * @param[in] pin_no The pin that the event applies to. * @param[in] button_action The button action (press/release). */ static void button_event_handler(uint8_t pin_no, uint8_t button_action) { ret_code_t err_code; uint32_t gpSts; switch (pin_no) { case LEDBUTTON_BUTTON: NRF_LOG_INFO("Send button data"); gpSts = nrf_gpio_pin_read(BSP_BUTTON_0); NRF_LOG_INFO("gpSts=%d\r\n", gpSts); if(gpSts == 0) // BTN_PRESSED=0 { nrf_gpio_pin_clear(LED_1); NRF_LOG_INFO("PRESSED\r\n"); SystemManager.SwitchOn = 1; SendEmergencyLocal(); }else{ nrf_gpio_pin_set(LED_1); NRF_LOG_INFO("Released\r\n"); } break; default: APP_ERROR_HANDLER(pin_no); break; } } /**@brief Function for initializing the button handler module. */ static void buttons_init(void) { ret_code_t err_code; //The array must be static because a pointer to it will be saved in the button handler module. static app_button_cfg_t buttons[] = { {LEDBUTTON_BUTTON, false, BUTTON_PULL, button_event_handler} }; err_code = app_button_init(buttons, ARRAY_SIZE(buttons), BUTTON_DETECTION_DELAY); APP_ERROR_CHECK(err_code); } static void GPOut_Init() { uint32_t i; for (i = 0; i < 4; ++i) { nrf_gpio_cfg_output(m_board_led_list[i]); } } void ble_get_mac(uint8_t addr[8]) { uint32_t err_code; ble_gap_addr_t ble_addr; err_code = sd_ble_gap_address_get(&ble_addr); APP_ERROR_CHECK(err_code); IPV6_EUI64_CREATE_FROM_EUI48(addr, ble_addr.addr, ble_addr.addr_type); } void _1000ms_timer_handle() { // NRF_LOG_RAW_INFO("_1000ms_timer_handle()\n"); switch(SystemManager.System_State){ case SYSTEM_NONE: SystemTimer.SYSTEM_REGISTER_CNT = 0; SystemTimer.SYSTEM_SERVER_COMM_CNT = 0; SystemTimer.SYSTEM_SERVER_COMM_REQ_CNT = 0; SystemTimer.SYSTEM_EMERGENCY_SIREN_CNT = 0; break; case SYSTEM_EMERGENCY_SIREN: SystemTimer.SYSTEM_EMERGENCY_SIREN_CNT++; NRF_LOG_RAW_INFO("_1000ms_timer_handle(SYSTEM_EMERGENCY_SIREN) -- [%d]\n", SystemTimer.SYSTEM_EMERGENCY_SIREN_CNT); if(SystemTimer.SYSTEM_EMERGENCY_SIREN_CNT >= 60*1){ SystemTimer.SYSTEM_EMERGENCY_SIREN_CNT = 0; SystemManager.System_State = SYSTEM_NONE; PKLedOff(); PKBuzzerOff(); SystemManager.LedBlinkRun = 0; SystemManager.Emg_Ack_Flag = 0; } if(SystemManager.Emg_Ack_Flag){ SystemManager.Emg_Resend_Cnt++; if(SystemManager.Emg_Resend_Cnt >= 10){ SystemManager.Emg_Resend_Cnt = 0; ReSendEmergency(); } } break; case SYSTEM_SERVER_COMM: SystemTimer.SYSTEM_SERVER_COMM_CNT++; NRF_LOG_RAW_INFO("_1000ms_timer_handle(SYSTEM_SERVER_COMM) -- [%d]\n", SystemTimer.SYSTEM_SERVER_COMM_CNT); if(SystemTimer.SYSTEM_SERVER_COMM_CNT >= 60*10){ SystemTimer.SYSTEM_SERVER_COMM_CNT = 0; SystemManager.System_State = SYSTEM_NONE; PKLedOff(); PKMicOff(); PKSpeakerOff(); SystemManager.LedBlinkRun = 0; } break; case SYSTEM_REGISTER: SystemTimer.SYSTEM_REGISTER_CNT++; NRF_LOG_RAW_INFO("_1000ms_timer_handle(SYSTEM_REGISTER) -- [%d]\n", SystemTimer.SYSTEM_REGISTER_CNT); if(SystemTimer.SYSTEM_REGISTER_CNT >= 60*1){ SystemTimer.SYSTEM_REGISTER_CNT = 0; SystemManager.RegRequst = 0; SystemManager.System_State = SYSTEM_NONE; PKLedOff(); SystemManager.LedBlinkRun = 0; } break; case SYSTEM_SERVER_COMM_REQ: SystemTimer.SYSTEM_SERVER_COMM_REQ_CNT++; NRF_LOG_RAW_INFO("_1000ms_timer_handle(SYSTEM_SERVER_COMM_REQ) -- [%d]\n", SystemTimer.SYSTEM_SERVER_COMM_REQ_CNT); if(SystemTimer.SYSTEM_SERVER_COMM_REQ_CNT >= 60*1){ SystemTimer.SYSTEM_SERVER_COMM_REQ_CNT = 0; SystemManager.RegRequst = 0; SystemManager.System_State = SYSTEM_NONE; PKLedOff(); PKBuzzerOff(); SystemManager.LedBlinkRun = 0; } break; } } int main(void) { uint8_t i; ret_code_t err_code; ble_gap_addr_t dd; dd.addr_id_peer = 0; dd.addr_type = BLE_GAP_ADDR_TYPE_PUBLIC; // Initialize. log_init(); /* Register first to receive an event when initialization is complete. */ (void) fds_register(fds_evt_handler); NRF_LOG_RAW_INFO("\n===========================================================\n\n"); NRF_LOG_RAW_INFO("BLE CENTRAL Program Start 2022/02/09-0\n"); NRF_LOG_RAW_INFO("\n===========================================================\n\n"); NRF_LOG_RAW_INFO("Initializing fds...\n"); err_code = fds_init(); APP_ERROR_CHECK(err_code); timer_init(); uart_init(); buttons_init(); GPOut_Init(); db_discovery_init(); power_management_init(); //sd_ble_gap_addr_get(&old_ble_addr); ble_stack_init(); sd_ble_gap_addr_get(&old_ble_addr); dd.addr[0] = IES200_1ST_MAC; dd.addr[1] = IES200_2ST_MAC; dd.addr[2] = IES200_3ST_MAC; dd.addr[3] = old_ble_addr.addr[3]; dd.addr[4] = old_ble_addr.addr[4]; dd.addr[5] = old_ble_addr.addr[5]; sd_ble_gap_addr_set(&dd); sd_ble_gap_addr_get(&new_ble_addr); gatt_init(); nus_c_init(); scan_init(); for(i=0; i<3; i++){ PKLedOn(); nrf_delay_ms(100); PKLedOff(); nrf_delay_ms(100); } // Start execution. //printf("BLE UART central example started.=====\r\n"); NRF_LOG_INFO("BLE UART central example started."); scan_start(); application_timers_start(); // Enabling the buttons. err_code = app_button_enable(); APP_ERROR_CHECK(err_code); PKLedOff(); //FlashTest(); LoadRegMac(); //TestAES(); //delete_all_begin(); Server_Answer_Version(); // Enter main loop. for (;;) { idle_state_handle(); USART_DataCheck(); ParseEventServer(); LedToggle(); delete_all_process(); if(SystemTimer.MS_1000_TICK){ SystemTimer.MS_1000_TICK = 0; _1000ms_timer_handle(); } } }