/*
|
* 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 GPIO_IRQ_HANDLER_T accelerate_irq_handler=NULL;
|
GPIO_IRQ_HANDLER_T _4Gusart_irq_handler=NULL;
|
extern struct UART_CFG_T test_uart_cfg;
|
extern struct ADC_CFG_T usr_adc_cfg;
|
extern volatile int32_t m_EUART_DMA_RXPtr;
|
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_NONE);
|
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_acceleration_detection_init(GPIO_IRQ_HANDLER_T irq_handler)
|
{
|
accelerate_irq_handler=irq_handler;
|
gpio_pin_set_dir(ACCLERATE_DETECT_Pin , GPIO_DIR_IN, 0);
|
io_pull_set(ACCLERATE_DETECT_Pin, IO_PULL_DOWN, IO_PULL_UP_LEVEL4);
|
gpio_enable_irq(ACCLERATE_DETECT_Pin, GPIO_IRQ_TYPE_RISING_EDGE, accelerate_irq_handler);
|
|
}
|
void board_4GUsart_detection_init(GPIO_IRQ_HANDLER_T irq_handler) //4G ´®¿ÚÊäÈë¼ì²âÖжϣ¬ÏÂÀ´¥·¢
|
{
|
_4Gusart_irq_handler=irq_handler;
|
io_pin_mux_set(_4G_USART_RX_Pin,IO_FUNC0);//°ÑÔÏÈio ±äΪÆÕͨGPIO
|
gpio_pin_set_dir(_4G_USART_RX_Pin , GPIO_DIR_IN, 0);
|
io_pull_set(_4G_USART_RX_Pin, IO_PULL_UP, IO_PULL_UP_LEVEL2);
|
gpio_enable_irq(_4G_USART_RX_Pin, GPIO_IRQ_TYPE_FALLING_EDGE, _4Gusart_irq_handler);
|
power_wakeup_enable((enum POWER_WAKEUP_SOURCE_T)_4G_USART_RX_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_LEVEL3);
|
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);
|
}
|
|
void board_led_init(void)
|
{
|
gpio_pin_set_dir(BOARD_LED_1, GPIO_DIR_OUT, 0);
|
gpio_pin_set_dir(BOARD_LED_2, GPIO_DIR_OUT, 0);
|
}
|
|
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_output_init(void)
|
{
|
//adc²É¼¯gndĬÈÏÀ¸ß
|
io_pin_mux_set(ADC_GND_ENABLE, IO_FUNC0);
|
gpio_pin_set_dir(ADC_GND_ENABLE , GPIO_DIR_OUT, 1);
|
// io_open_drain_set(ADC_GND_ENABLE, 1);
|
io_pull_set(ADC_GND_ENABLE,IO_HIGH_Z,IO_PULL_UP_NONE);//3
|
|
}
|
void board_configure(void)
|
{
|
}
|
|
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_ID1, &test_uart_cfg);
|
AIR780EUartInit();
|
adc_open(&usr_adc_cfg);
|
|
m_EUART_DMA_RXPtr = 0;//Çå¿ÕÉϴλº´æÆ÷±ÜÃâÖظ´·¢
|
#if defined(UCI_INTF_PORT)
|
uci_tl_resume();
|
#else
|
// button - restore interrupt type
|
gpio_enable_irq(_4G_USART_RX_Pin, GPIO_IRQ_TYPE_FALLING_EDGE, _4Gusart_irq_handler);
|
gpio_enable_irq(ACCLERATE_DETECT_Pin, GPIO_IRQ_TYPE_RISING_EDGE, accelerate_irq_handler);
|
// 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
|
}
|
