/* * Copyright (c) 2019-2023 Beijing Hanwei Innovation Technology Ltd. Co. and * its subsidiaries and affiliates (collectly called MKSEMI). * * 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 an MKSEMI * 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 MKSEMI 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 * MKSEMI 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 MKSEMI "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 MKSEMI 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. */ #include "board.h" #include "mk_power.h" #include "mk_clock.h" #include "mk_calib.h" #include "mk_misc.h" #include "mk_uwb.h" #ifdef WSF_EN #include "wsf_nvm.h" #endif #if defined(UCI_INTF_PORT) #include "uci_tl_task.h" #endif #if TRACE_EN static enum TRACE_PORT_T user_trace_port; #endif #ifndef TRACE_BAUD_RATE #define TRACE_BAUD_RATE (BAUD_115200) #endif struct BOARD_PARAM_T board_param = {0}; static GPIO_IRQ_HANDLER_T button_irq_handler = NULL; static struct UWB_CONFIG_T uwb_config; static uint8_t tx_payload[20]; static uint16_t tx_len = 20; void board_clock_run(void) { // default load cap REG_WRITE(0x40000048, 76); clock_attach(CLOCK_48M_RO_TO_SYS_CLK); delay_us(50); // calibrate REFPLL calib_open(); calib_start(CALIB_PO_REFPLL_EN); calib_check(CALIB_REFPLL_DONE); calib_close(); /* SYSCLK comes from XTAL */ clock_attach(SYS_CLK_SOURCE); /* Configure AHB clock, AHBCLK = SYSCLK/(div) */ clock_set_divider(CLOCK_AHB_DIV, AHB_DIV); /* Configure APB clock, APBCLK = AHBCLK/(div) */ clock_set_divider(CLOCK_APB_DIV, APB_DIV); /* Select 32k clock source: 32768Hz XTAL or 32000Hz RCO */ clock_attach(CLK_32K_SOURCE); /* Select WDT clcok source: 32K or APBCLK */ clock_attach(CLOCK_32K_TO_WDT_CLK); #if SYS_TICK_EN /* Configure sys tick timer, 32768 / 100 = 10ms @ 32k */ sys_tick_start(328); #endif /* System timer */ sys_timer_open(); } void board_debug_console_open(enum TRACE_PORT_T port) { #if TRACE_EN trace_open(port, TRACE_BAUD_RATE); user_trace_port = port; #endif LOG_INFO(TRACE_MODULE_APP, "Hello from MKSEMI!\r\n"); LOG_INFO(TRACE_MODULE_APP, "Build information %s\r\n", mk_build_inf); } void board_calibration_params_default(void) { board_param.load_cap = 76; #ifdef UWB_EN board_param.tx_power_fcc[CALIB_CH9] = TX_POWER_LEVEL; board_param.tx_power_fcc[CALIB_CH5] = TX_POWER_LEVEL; board_param.tx_power_fcc[CALIB_CH2] = TX_POWER_LEVEL; board_param.ranging_session_id = 0; board_param.local_short_addr = 0; board_param.peer_short_addr = 0; #if (ANT_PATTERN == ANT_PATTERN_SQUARE) int16_t ant_delays_ch9[4] = {0, 0, 0, 36}; int16_t ant_delays_ch5[4] = {0, 0, 0, 36}; int16_t ant_delays_ch2[4] = {0, 0, 36, 0}; // 4-ANTs: 0, 1, 2, 3 int16_t pdoa_delays_ch9[4] = {52, -21, -8, 0}; int16_t pdoa_delays_ch5[4] = {52, -21, -8, 0}; // int16_t pdoa_delays_ch5[4] = {70, -2, -0, 0}; int16_t pdoa_delays_ch2[4] = {52, -21, -8, 0}; int16_t pdoa_gains_ch9[4] = {94, 99, 89, 88}; int16_t pdoa_gains_ch5[4] = {94, 99, 89, 88}; // int16_t pdoa_gains_ch5[4] = {94, 93, 89, 98}; int16_t pdoa_gains_ch2[4] = {94, 99, 89, 88}; int16_t pdoa_offsets[2] = {0, 0}; board_param.pdoa_ant_space = 180; #elif (ANT_PATTERN == ANT_PATTERN_TRIANGLE_REGULAR) int16_t ant_delays_ch9[4] = {0, 0, 0, 36}; int16_t ant_delays_ch5[4] = {0, 0, 0, 36}; int16_t ant_delays_ch2[4] = {0, 0, 36, 0}; // 3-ANTs: 3, 0, 1 int16_t pdoa_delays_ch9[4] = {0, -21, 52}; int16_t pdoa_delays_ch5[4] = {0, -21, 52}; int16_t pdoa_delays_ch2[4] = {0, -21, 52}; int16_t pdoa_gains_ch9[4] = {88, 94, 99}; int16_t pdoa_gains_ch5[4] = {88, 94, 99}; int16_t pdoa_gains_ch2[4] = {88, 94, 99}; int16_t pdoa_offsets[2] = {0, 0}; board_param.pdoa_ant_space = 180; #else // linear antenna array int16_t ant_delays_ch9[4] = {0, 0, 0, 122}; int16_t ant_delays_ch5[4] = {0, 0, 0, 122}; int16_t ant_delays_ch2[4] = {0, 0, 122, 0}; #if RX_ANT_PORTS_NUM == 4 // 4-ANTs: 0, 1, 2, 3 int16_t pdoa_delays_ch9[4] = {36, 47, 57, 0}; int16_t pdoa_delays_ch5[4] = {51, -73, -57, 0}; int16_t pdoa_delays_ch2[4] = {36, 47, 57, 0}; int16_t pdoa_gains_ch9[4] = {108, 99, 98, 100}; int16_t pdoa_gains_ch5[4] = {94, 103, 87, 100}; int16_t pdoa_gains_ch2[4] = {108, 99, 98, 100}; int16_t pdoa_offsets[2] = {0, 0}; board_param.pdoa_ant_space = 180; #elif RX_ANT_PORTS_NUM == 3 #if 0 // 3-ANTs: 3, 0, 1 int16_t pdoa_delays_ch9[4] = {0, 36, 47}; int16_t pdoa_delays_ch5[4] = {0, 51, -73}; int16_t pdoa_delays_ch2[4] = {0, 36, 47}; int16_t pdoa_gains_ch9[4] = {100, 108, 99}; int16_t pdoa_gains_ch5[4] = {100, 94, 103}; int16_t pdoa_gains_ch2[4] = {100, 108, 99}; #else // 3-ANTs: 1, 2, 3 int16_t pdoa_delays_ch9[4] = {47, 57, 0}; int16_t pdoa_delays_ch5[4] = {-73, -57, 0}; int16_t pdoa_delays_ch2[4] = {47, 57, 0}; int16_t pdoa_gains_ch9[4] = {99, 98, 100}; int16_t pdoa_gains_ch5[4] = {103, 87, 100}; int16_t pdoa_gains_ch2[4] = {99, 98, 100}; #endif int16_t pdoa_offsets[2] = {0, 0}; board_param.pdoa_ant_space = 180; #elif RX_ANT_PORTS_NUM == 2 #if 0 // 2-ANTs: 2, 3 int16_t pdoa_delays_ch9[4] = {57, 0}; int16_t pdoa_delays_ch5[4] = {-57, 0}; int16_t pdoa_delays_ch2[4] = {57, 0}; int16_t pdoa_gains_ch9[4] = {98, 100}; int16_t pdoa_gains_ch5[4] = {87, 100}; int16_t pdoa_gains_ch2[4] = {98, 100}; #else // 2-ANTs: 3, 0 int16_t pdoa_delays_ch9[4] = {0, 36}; int16_t pdoa_delays_ch5[4] = {0, 51}; int16_t pdoa_delays_ch2[4] = {0, 36}; int16_t pdoa_gains_ch9[4] = {100, 108}; int16_t pdoa_gains_ch5[4] = {100, 94}; int16_t pdoa_gains_ch2[4] = {100, 108}; #endif int16_t pdoa_offsets[2] = {0, 0}; board_param.pdoa_ant_space = 180; #endif #endif memcpy((uint8_t *)&board_param.ant_delays[CALIB_CH9], ant_delays_ch9, sizeof(ant_delays_ch9)); memcpy((uint8_t *)&board_param.ant_delays[CALIB_CH5], ant_delays_ch5, sizeof(ant_delays_ch5)); memcpy((uint8_t *)&board_param.ant_delays[CALIB_CH2], ant_delays_ch2, sizeof(ant_delays_ch2)); #if RX_ANT_PORTS_NUM > 1 memcpy((uint8_t *)&board_param.pdoa_delays[CALIB_CH9], pdoa_delays_ch9, sizeof(pdoa_delays_ch9)); memcpy((uint8_t *)&board_param.pdoa_delays[CALIB_CH5], pdoa_delays_ch5, sizeof(pdoa_delays_ch5)); memcpy((uint8_t *)&board_param.pdoa_delays[CALIB_CH2], pdoa_delays_ch2, sizeof(pdoa_delays_ch2)); memcpy((uint8_t *)&board_param.pdoa_gains[CALIB_CH9], pdoa_gains_ch9, sizeof(pdoa_gains_ch9)); memcpy((uint8_t *)&board_param.pdoa_gains[CALIB_CH5], pdoa_gains_ch5, sizeof(pdoa_gains_ch5)); memcpy((uint8_t *)&board_param.pdoa_gains[CALIB_CH2], pdoa_gains_ch2, sizeof(pdoa_gains_ch2)); memcpy((uint8_t *)&board_param.pdoa_offsets[0], pdoa_offsets, sizeof(pdoa_offsets)); #endif board_param.dev_role = 0; board_param.dev_role_idx = 0; #endif } void board_calibration_params_load(void) { board_calibration_params_default(); #ifdef WSF_EN if (TRUE == WsfNvmReadData(BOARD_LOAD_CAP, &board_param.load_cap, sizeof(board_param.load_cap), 0)) { board_param.flag |= (1 << BOARD_LOAD_CAP); } if (TRUE == WsfNvmReadData(BOARD_TX_POWER_FCC_LEVEL, &board_param.tx_power_fcc[0], sizeof(board_param.tx_power_fcc), 0)) { board_param.flag |= (1 << BOARD_TX_POWER_FCC_LEVEL); } if (TRUE == WsfNvmReadData(BOARD_RANGING_SESSION_ID, (uint8_t *)&board_param.ranging_session_id, sizeof(board_param.ranging_session_id), 0)) { board_param.flag |= (1 << BOARD_RANGING_SESSION_ID); } if (TRUE == WsfNvmReadData(BOARD_LOCAL_SHORT_ADDR, (uint8_t *)&board_param.local_short_addr, sizeof(board_param.local_short_addr), 0)) { board_param.flag |= (1 << BOARD_LOCAL_SHORT_ADDR); } if (TRUE == WsfNvmReadData(BOARD_PEER_SHORT_ADDR, (uint8_t *)&board_param.peer_short_addr, sizeof(board_param.peer_short_addr), 0)) { board_param.flag |= (1 << BOARD_PEER_SHORT_ADDR); } if (TRUE == WsfNvmReadData(BOARD_ANT_DELAYS, (uint8_t *)&board_param.ant_delays[0], sizeof(board_param.ant_delays), 0)) { board_param.flag |= (1 << BOARD_ANT_DELAYS); } if (TRUE == WsfNvmReadData(BOARD_PDOA_DELAYS, (uint8_t *)&board_param.pdoa_delays[0], sizeof(board_param.pdoa_delays), 0)) { board_param.flag |= (1 << BOARD_PDOA_DELAYS); } if (TRUE == WsfNvmReadData(BOARD_PDOA_GAINS, (uint8_t *)&board_param.pdoa_gains[0], sizeof(board_param.pdoa_gains), 0)) { board_param.flag |= (1 << BOARD_PDOA_GAINS); } if (TRUE == WsfNvmReadData(BOARD_PDOA_ANT_SPACE, (uint8_t *)&board_param.pdoa_ant_space, sizeof(board_param.pdoa_ant_space), 0)) { board_param.flag |= (1 << BOARD_PDOA_ANT_SPACE); } if (TRUE == WsfNvmReadData(BOARD_PDOA_OFFSETS, (uint8_t *)&board_param.pdoa_offsets[0], sizeof(board_param.pdoa_offsets), 0)) { board_param.flag |= (1 << BOARD_PDOA_OFFSETS); } if (TRUE == WsfNvmReadData(BOARD_DEV_ROLE, (uint8_t *)&board_param.dev_role, sizeof(board_param.dev_role), 0)) { board_param.flag |= (1 << BOARD_DEV_ROLE); } if (TRUE == WsfNvmReadData(BOARD_DEV_ROLE_IDX, (uint8_t *)&board_param.dev_role_idx, sizeof(board_param.dev_role_idx), 0)) { board_param.flag |= (1 << BOARD_DEV_ROLE_IDX); } if (TRUE == WsfNvmReadData(BOARD_X32K_LOAD_CAP, &board_param.x32k_load_cap, sizeof(board_param.x32k_load_cap), 0)) { board_param.flag |= (1 << BOARD_X32K_LOAD_CAP); } #endif } uint8_t board_calibration_param_write(uint8_t id, uint8_t *param, uint8_t param_len) { uint8_t ret = 0; #ifdef WSF_EN if (((id == BOARD_LOAD_CAP) && (param_len == sizeof(board_param.load_cap))) || ((id == BOARD_TX_POWER_FCC_LEVEL) && (param_len == sizeof(board_param.tx_power_fcc))) || ((id == BOARD_RANGING_SESSION_ID) && (param_len == sizeof(board_param.ranging_session_id))) || ((id == BOARD_LOCAL_SHORT_ADDR) && (param_len == sizeof(board_param.local_short_addr))) || ((id == BOARD_PEER_SHORT_ADDR) && (param_len == sizeof(board_param.peer_short_addr))) || ((id == BOARD_ANT_DELAYS) && (param_len == sizeof(board_param.ant_delays))) || ((id == BOARD_PDOA_DELAYS) && (param_len == sizeof(board_param.pdoa_delays))) || ((id == BOARD_PDOA_GAINS) && (param_len == sizeof(board_param.pdoa_gains))) || ((id == BOARD_PDOA_ANT_SPACE) && (param_len == sizeof(board_param.pdoa_ant_space))) || ((id == BOARD_PDOA_OFFSETS) && (param_len == sizeof(board_param.pdoa_offsets))) || ((id == BOARD_DEV_ROLE) && (param_len == sizeof(board_param.dev_role))) || ((id == BOARD_DEV_ROLE_IDX) && (param_len == sizeof(board_param.dev_role_idx))) || ((id == BOARD_X32K_LOAD_CAP) && (param_len == sizeof(board_param.x32k_load_cap)))) { ret = WsfNvmWriteData(id, param, param_len, 0); } #endif return ret; } void board_ranging_result_correct(uint16_t *distance, int16_t *azimuth, int16_t *elevation) { if ((distance == NULL) || (azimuth == NULL) || (elevation == NULL)) { return; } #if (ANT_PATTERN == ANT_PATTERN_SQUARE) // 3D #elif (ANT_PATTERN == ANT_PATTERN_TRIANGLE_REGULAR) // 3D #elif (ANT_PATTERN == ANT_PATTERN_LINEAR) // 2D -90 ~ 90 // azimuth correction float post_azimuth = mk_q7_to_f32(*azimuth); #if RX_ANT_PORTS_NUM == 4 post_azimuth = (int16_t)(1.1221f * post_azimuth + 0.2729f); #elif RX_ANT_PORTS_NUM == 3 post_azimuth = (int16_t)(1.2287f * post_azimuth + 1.3633f); #elif RX_ANT_PORTS_NUM == 2 if (post_azimuth < -13.1) { post_azimuth = (int16_t)(0.8719f * post_azimuth - 28.282f); } else if (post_azimuth < -4.6) { post_azimuth = (int16_t)(3.7137f * post_azimuth + 10.307f); } else { post_azimuth = (int16_t)(1.0492f * post_azimuth - 3.1928f); } #endif post_azimuth = ((post_azimuth > 90) ? 90 : ((post_azimuth < -90) ? -90 : post_azimuth)); *azimuth = mk_f32_to_q7(post_azimuth); #endif } void board_5V_input_init(GPIO_IRQ_HANDLER_T irq_handler) { button_irq_handler = irq_handler; gpio_pin_set_dir(INPUT_5V_Pin, GPIO_DIR_IN, 0); io_pull_set(INPUT_5V_Pin, IO_PULL_DOWN, IO_PULL_UP_LEVEL4); gpio_enable_irq(INPUT_5V_Pin, GPIO_IRQ_TYPE_RISING_EDGE, button_irq_handler); power_wakeup_enable((enum POWER_WAKEUP_SOURCE_T)INPUT_5V_Pin, POWER_WAKEUP_LEVEL_LOW); } void board_button_init(GPIO_IRQ_HANDLER_T irq_handler) { button_irq_handler = irq_handler; gpio_pin_set_dir(BOARD_SW_1, GPIO_DIR_IN, 0); io_pull_set(BOARD_SW_1, IO_PULL_UP, IO_PULL_UP_LEVEL4); gpio_enable_irq(BOARD_SW_1, GPIO_IRQ_TYPE_FALLING_EDGE, button_irq_handler); power_wakeup_enable((enum POWER_WAKEUP_SOURCE_T)BOARD_SW_1, POWER_WAKEUP_LEVEL_LOW); } #define CH_NUM 5 enum TEST_MODE_T { TEST_RF_CARRIER = 0, TEST_UWB_TX, TEST_UWB_RX, TEST_MCU_ACTIVE, TEST_MCU_SLEEP, TEST_MCU_POWER_DOWN, TEST_MCU_DEEP_POWER_DOWN, TEST_MCU_SHELF_MODE, }; static void app_power_mode_set(enum TEST_MODE_T pm) { enum POWER_MODE_T power_mode = POWER_MODE_ACTIVE; switch (pm) { case TEST_RF_CARRIER: power_mode = POWER_MODE_ACTIVE; uwb_open(); power_on_radio(1, 0); uwb_tx_carrier_only(1, CH_NUM, TX_POWER_LEVEL); LOG_INFO(TRACE_MODULE_APP, "==== RF Single Carrier ====\r\n"); break; case TEST_UWB_TX: power_mode = POWER_MODE_ACTIVE; uwb_tx_carrier_only(0, CH_NUM, TX_POWER_LEVEL); uwb_configure(PHY_TX | PHY_RX, TX_POWER_LEVEL, &uwb_config); LOG_INFO(TRACE_MODULE_APP, "==== UWB TX ====\r\n"); break; case TEST_UWB_RX: power_mode = POWER_MODE_ACTIVE; uwb_blocking_trx_stop(); power_off_radio(); power_on_radio(0, 1); LOG_INFO(TRACE_MODULE_APP, "==== UWB RX ====\r\n"); break; case TEST_MCU_ACTIVE: power_mode = POWER_MODE_ACTIVE; uwb_blocking_trx_stop(); LOG_INFO(TRACE_MODULE_APP, "==== MCU Active ====\r\n"); break; case TEST_MCU_SLEEP: power_mode = POWER_MODE_SLEEP; LOG_INFO(TRACE_MODULE_APP, "==== MCU Sleep ====\r\n"); break; case TEST_MCU_POWER_DOWN: power_mode = POWER_MODE_POWER_DOWN; LOG_INFO(TRACE_MODULE_APP, "==== MCU Power-down ====\r\n"); break; case TEST_MCU_DEEP_POWER_DOWN: power_mode = POWER_MODE_DEEP_POWER_DOWN; LOG_INFO(TRACE_MODULE_APP, "==== MCU Deep Power-down ====\r\n"); break; case TEST_MCU_SHELF_MODE: power_mode = POWER_MODE_SHELF; LOG_INFO(TRACE_MODULE_APP, "==== MCU Shelf Mode ====\r\n"); break; } power_mode_request(POWER_UNIT_APP, power_mode); // app_led_set(pm); } void LED_PA_change(void) { io_pin_mux_set(IO_PIN_9, IO_FUNC0); io_pin_mux_set(IO_PIN_10, IO_FUNC0); gpio_pin_set_dir(IO_PIN_9, GPIO_DIR_OUT, 0); io_pull_set(IO_PIN_9, IO_PULL_DOWN, IO_PULL_UP_LEVEL4); } void uwb_power_init(void) { uwb_config.ch_num = CH_NUM; uwb_config.code_index = 9; uwb_config.mean_prf = MEAN_PRF_64M; uwb_config.data_bit_rate = DATA_BR_6M8; uwb_config.sync_sym = PREAM_LEN_64; uwb_config.sfd_sym = BPRF_NSFD2_8; uwb_config.ranging_bit = 0; uwb_config.trx_mode = TRX_MODE_15_4Z_BPRF; uwb_config.sts_pkt_cfg = STS_PKT_CFG_0; uwb_config.sts_segnum = STS_SEGNUM_BPRF_1; uwb_config.sts_seglen = STS_SEGLEN_BPRF_64; uwb_config.rx_ant_id = UWB_RX_ANT_3; uwb_rx_antenna_open(uwb_config.rx_ant_id); for (uint32_t i = 0; i < sizeof(tx_payload); i++) { tx_payload[i] = 0x55; } uwb_open(); power_on_radio(1, 0); uwb_tx_carrier_only(1, CH_NUM, TX_POWER_LEVEL); app_power_mode_set(TEST_UWB_TX); delay_us(65535); gpio_pin_set(IO_PIN_9);//²âÊÔ; gpio_pin_clr(IO_PIN_10);//²âÊÔ; uwb_blocking_tx_start(tx_payload, tx_len, 0); gpio_pin_clr(IO_PIN_9);//²âÊÔ; gpio_pin_clr(IO_PIN_10);//²âÊÔ; } void board_led_init(void) { //µÆ io_pin_mux_set(LED_PIN, IO_FUNC0); gpio_pin_set_dir( LED_PIN, GPIO_DIR_OUT, 0); io_pull_set(LED_PIN , IO_PULL_DOWN, IO_PULL_UP_LEVEL4); //5VÊäÈë¼ì²â io_pin_mux_set(INPUT_5V_Pin, IO_FUNC0); gpio_pin_set_dir(INPUT_5V_Pin, GPIO_DIR_IN, 0); io_pull_set(INPUT_5V_Pin, IO_PULL_DOWN, IO_PULL_UP_LEVEL2); // power_wakeup_enable((enum POWER_WAKEUP_SOURCE_T)INPUT_5V_Pin, POWER_WAKEUP_LEVEL_LOW); } void board_led_on(enum IO_PIN_T idx) { gpio_pin_set(idx); } void board_led_off(enum IO_PIN_T idx) { gpio_pin_clr(idx); } void board_led_toggle(enum IO_PIN_T idx) { gpio_pin_toggle(idx); } void board_configure(void) { } extern struct UART_CFG_T test_uart_cfg; void board_prepare_for_power_down(void) { #if !defined(CELL_PHONE_EN) board_led_off(BOARD_LED_1); #endif } void board_restore_from_power_down(void) { //uart_open(UART_ID0, &test_uart_cfg); #if defined(UCI_INTF_PORT) uci_tl_resume(); #else // button - restore interrupt type if (button_irq_handler) { gpio_enable_irq(BOARD_SW_1, GPIO_IRQ_TYPE_FALLING_EDGE, button_irq_handler); } #endif #if !defined(CELL_PHONE_EN) board_led_on(BOARD_LED_1); #endif // system timer sys_timer_open(); #if TRACE_EN trace_open(user_trace_port, TRACE_BAUD_RATE);//¼ÇµÃ»Ø¸´ #endif }