int app_batt_alert_timer_handler(ke_msg_id_t const msgid,
void const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
//Read LED GPIO state
if(bat_lvl_alert_used)
{
#if 0
if (bat_led_state)
{
if(GPIO_GetPinStatus(GPIO_ALERT_PWR_PORT,GPIO_ALERT_PWR_PIN)==false)
{
//正在充电
}
else
{
GPIO_SetActive( bat_led_port, bat_led_pin); //V3.2版本后将黄灯逻辑电平反向
bat_led_state = 0;
}
app_timer_set(APP_BATT_ALERT_TIMER, dest_id, 50);//20,电池电量低,报警灯闪烁速度,,delay延时
}
else
{
GPIO_SetInactive( bat_led_port, bat_led_pin);//V3.2版本后将黄灯逻辑电平反向
bat_led_state = 1;
app_timer_set(APP_BATT_ALERT_TIMER, dest_id, 50);//5,电池电量低,报警灯闪烁速度,delay延时
}
#endif
}
return (KE_MSG_CONSUMED);
}
/**
****************************************************************************************
* @brief Read from 3-wire SPI
* @param[in] registerIndex: Target address (A6..A0)
*
* @return byte read
****************************************************************************************
*/
uint8_t read_from_3wire_SPI_register(uint8_t registerIndex, uint8_t is_last_transaction)
{
static uint8_t i, dataRead;
GPIO_SetInactive(cs.port, cs.pin); // pull CS low
GPIO_SetPinFunction( sdio.port, sdio.pin, OUTPUT, PID_SPI_DO); // configure SDIO as output
SetWord16(SPI_RX_TX_REG0, (uint16_t)(registerIndex) ); // MSB set to HIGH - A6..A0 Address of register to write to
do {
} while (GetBits16(SPI_CTRL_REG,SPI_INT_BIT)==0); // polling to wait for spi transmission
SetWord16(SPI_CLEAR_INT_REG, 0); //Clear SPI_CTRL_REG[SPI_INT_BIT] interrupt
GPIO_SetPinFunction( sdio.port, sdio.pin, INPUT, PID_SPI_DI); // configure SDIO as input
for (i=0; i<TsradCounter; i++); // {DEV.NOTE#: For Mouse sensor Delay > Tsrad = 4us <-- suitable counter is 6}
SetWord16(SPI_RX_TX_REG0, (uint16_t)0x00 ); // dummy write data - read data
do {
} while (GetBits16(SPI_CTRL_REG,SPI_INT_BIT)==0); // polling to wait for spi transmission
SetWord16(SPI_CLEAR_INT_REG, 0); //Clear SPI_CTRL_REG[SPI_INT_BIT] interrupt
dataRead = GetWord16(SPI_RX_TX_REG0); // read received byte
SetWord16(SPI_CLEAR_INT_REG, 0x01); // clear pending flag
if(is_last_transaction)
GPIO_SetActive(cs.port, cs.pin); // set CS high
return dataRead;
}
void uart_write_ext_wkup_func(uint8_t *bufptr, uint32_t size, void (*callback) (uint8_t))
{
// Sanity check
ASSERT_ERR(bufptr != NULL);
ASSERT_ERR(size != 0);
ASSERT_ERR(uart_env.tx.bufptr == NULL);
GPIO_SetActive (EXT_WAKEUP_PORT, EXT_WAKEUP_PIN);
// Prepare TX parameters
uart_env.tx.size = size;
uart_env.tx.bufptr = bufptr;
uart_env.tx.callback = callback;
/* start data transaction
* first isr execution is done without interrupt generation to reduce
* interrupt load
*/
uart_thr_empty_isr();
if (uart_env.tx.bufptr != NULL)
{
uart_thr_empty_setf(1);
}
GPIO_SetInactive (EXT_WAKEUP_PORT, EXT_WAKEUP_PIN);
}
int app_batt_alert_timer_handler(ke_msg_id_t const msgid,
void const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
//Read LED GPIO state
if(bat_lvl_alert_used)
{
if (bat_led_state)
{
GPIO_SetInactive( bat_led_port, bat_led_pin);
bat_led_state = 0;
app_timer_set(APP_BATT_ALERT_TIMER, dest_id, 20);
#ifdef CUSTOM_BATTERY_LEVEL_MEASUREMENTS___BOOST_MODE_CONFIGURATION
if (app_get_sleep_mode())
app_force_active_mode(); // prevent sleep only if enabled
#endif //CUSTOM_BATTERY_LEVEL_MEASUREMENTS___BOOST_MODE_CONFIGURATION
}
else
{
GPIO_SetActive( bat_led_port, bat_led_pin);
bat_led_state = 1;
app_timer_set(APP_BATT_ALERT_TIMER, dest_id, 5);
#ifdef CUSTOM_BATTERY_LEVEL_MEASUREMENTS___BOOST_MODE_CONFIGURATION
app_restore_sleep_mode();
#endif //CUSTOM_BATTERY_LEVEL_MEASUREMENTS___BOOST_MODE_CONFIGURATION
}
}
return (KE_MSG_CONSUMED);
}
/**
****************************************************************************************
* @brief Sets the Red LED to blink
*
* @param None
*
* @return void
****************************************************************************************
*/
void red_led_blink()
{
if (LED_STATE_OFF) {
GPIO_SetInactive(KBD_RED_LED_PORT, KBD_RED_LED_PIN); // red: low - on
} else {
GPIO_SetActive (KBD_RED_LED_PORT, KBD_RED_LED_PIN); // red: high - on
}
}
/**
****************************************************************************************
* @brief Sets the Green LED to blink
*
* @param None
*
* @return void
****************************************************************************************
*/
static void green_led_blink()
{
if (LED_STATE_OFF) {
GPIO_SetInactive(KBD_GREEN_LED_PORT, KBD_GREEN_LED_PIN); // green: low - on
} else {
GPIO_SetActive (KBD_GREEN_LED_PORT, KBD_GREEN_LED_PIN); // green: high - on
}
green_led_st = BLINK_LED_IS_ON__TURN_OFF;
}
/**
****************************************************************************************
* @brief Sets the Green LED to on
*
* @param None
*
* @return void
****************************************************************************************
*/
static void green_led_on()
{
if (LED_STATE_OFF) {
GPIO_SetInactive(KBD_GREEN_LED_PORT, KBD_GREEN_LED_PIN); // green: low - on
} else {
GPIO_SetActive (KBD_GREEN_LED_PORT, KBD_GREEN_LED_PIN); // green: high - on
}
green_led_st = LED_ON;
}
/**
****************************************************************************************
* @brief Sets the Red LED to on
*
* @param None
*
* @return void
****************************************************************************************
*/
static void red_led_on()
{
if (LED_STATE_OFF) {
GPIO_SetInactive(KBD_RED_LED_PORT, KBD_RED_LED_PIN); // red: low - on
} else {
GPIO_SetActive (KBD_RED_LED_PORT, KBD_RED_LED_PIN); // red: high - on
}
red_led_st = LED_ON;
}
/**
****************************************************************************************
* @brief Sets the Red LED to off
*
* @param None
*
* @return void
****************************************************************************************
*/
static void red_led_off()
{
high_priority_indications_active = false;
if (LED_STATE_OFF) {
GPIO_SetActive (KBD_RED_LED_PORT, KBD_RED_LED_PIN); // red: high - off
} else {
GPIO_SetInactive(KBD_RED_LED_PORT, KBD_RED_LED_PIN); // red: low - off
}
red_led_st = LED_OFF;
}
void app_proxr_port_reinit(GPIO_PORT port, GPIO_PIN pin)
{
app_proxr_init(port, pin);
if(alert_state.blink_toggle == 1){
GPIO_SetActive( alert_state.port, alert_state.pin);
}
else{
GPIO_SetInactive( alert_state.port, alert_state.pin);
}
}
void app_proxr_alert_stop(void)
{
alert_state.lvl = PROXR_ALERT_NONE; //level;
alert_state.blink_timeout = 0;
alert_state.blink_toggle = 0;
GPIO_SetInactive( alert_state.port, alert_state.pin);
ke_timer_clear(APP_PXP_TIMER, TASK_APP);
}
int app_proxr_timer_handler(ke_msg_id_t const msgid,
void const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
if (alert_state.lvl != PROXR_ALERT_NONE)
{
if (alert_state.lvl == PROXR_ALERT_HIGH)
{
alert_state.blink_toggle = 1;
app_timer_set(APP_PXP_TIMER, dest_id, alert_state.blink_timeout);
GPIO_SetActive( alert_state.port, alert_state.pin);
app_proxr_beep();
GPIO_SetInactive(alert_state.port, alert_state.pin);
alert_state.blink_toggle = 0;
}
else
{
if (alert_state.blink_toggle)
{
GPIO_SetInactive( alert_state.port, alert_state.pin);
alert_state.blink_toggle = 0;
app_timer_set(APP_PXP_TIMER, dest_id, alert_state.blink_timeout);
}
else
{
GPIO_SetActive( alert_state.port, alert_state.pin);
alert_state.blink_toggle = 1;
app_timer_set(APP_PXP_TIMER, dest_id, 2);
}
}
app_timer_set(APP_PXP_TIMER, dest_id, alert_state.blink_timeout);
}
return (KE_MSG_CONSUMED);
}
void app_sample128_start_leds(void)
{
if(1 == leds_state.flag)
{
//GPIO_SetActive( leds_state.port_led3, leds_state.pin_led3);
GPIO_SetActive(leds_state.port_led4, leds_state.pin_led4);
//GPIO_SetInactive(leds_state.port_led4, leds_state.pin_led4);
GPIO_SetInactive( leds_state.port_led3, leds_state.pin_led3);
//GPIO_ConfigurePin( GPIO_LED3_PORT, GPIO_LED3_PIN, OUTPUT, PID_GPIO, true );
}
else if(0 == leds_state.flag)
{
GPIO_SetInactive(leds_state.port_led4, leds_state.pin_led4);
//GPIO_SetInactive( leds_state.port_led3, leds_state.pin_led3);
GPIO_SetActive( leds_state.port_led3, leds_state.pin_led3);
//GPIO_ConfigurePin( GPIO_LED3_PORT, GPIO_LED3_PIN, OUTPUT, PID_GPIO, false );
//GPIO_ConfigurePin( GPIO_LED3_PORT, GPIO_LED3_PIN, OUTPUT, PID_GPIO, false );
//GPIO_ConfigurePin( GPIO_LED4_PORT, GPIO_LED4_PIN, OUTPUT, PID_GPIO, false );
}
}
void app_batt_port_reinit(void)
{
if (bat_lvl_alert_used)
{
if(bat_led_state == 1){
GPIO_SetActive( bat_led_port, bat_led_pin);
}
else{
GPIO_SetInactive( bat_led_port, bat_led_pin);
}
}
}
/*
* Name : GPIO_ConfigurePin - Combined function to set the state
* and the type and mode of the GPIO pin
*
* Scope : PUBLIC
*
* Arguments : port - GPIO port
* pin - pin
* mode - pin mode (input, output...)
* function - pin usage (GPIO, UART, SPI...)
* high - set to TRUE to set the pin into high else low
*
* Description : Sets the GPIO state and then its type and mode
*
* Returns : void
*
*/
void GPIO_ConfigurePin( GPIO_PORT port, GPIO_PIN pin, GPIO_PUPD mode, GPIO_FUNCTION function,
const bool high )
{
#if DEVELOPMENT__NO_OTP
if ( !(GPIO_status & ( ((uint64_t)1 << pin) << (port * 16) )) )
__asm("BKPT #0\n"); // this pin has not been previously reserved!
#endif
if (high)
GPIO_SetActive( port, pin );
else
GPIO_SetInactive( port, pin );
GPIO_SetPinFunction( port, pin, mode, function );
}
/**
****************************************************************************************
* @brief Write to 3-wire SPI
* @param[in] registerIndex: Target address (A6..A0)
* @param[in] valueToWrite: Value to write
*
* @return Number of read bytes
****************************************************************************************
*/
void write_to_3wire_SPI_register(uint8_t registerIndex, uint8_t valueToWrite)
{
GPIO_SetInactive(cs.port, cs.pin); // pull CS low
GPIO_SetPinFunction( sdio.port, sdio.pin, OUTPUT, PID_SPI_DO); // configure SDIO as output
SetWord16(SPI_RX_TX_REG0, (uint16_t)(registerIndex | 0x80) ); // MSB set to HIGH - A6..A0 Address of register to write to
do {
} while (GetBits16(SPI_CTRL_REG,SPI_INT_BIT)==0); // polling to wait for spi transmission
SetWord16(SPI_CLEAR_INT_REG, 0); //Clear SPI_CTRL_REG[SPI_INT_BIT] interrupt
SetWord16(SPI_RX_TX_REG0, (uint16_t)valueToWrite ); // write data
do {
} while (GetBits16(SPI_CTRL_REG,SPI_INT_BIT)==0); // polling to wait for spi transmission
SetWord16(SPI_CLEAR_INT_REG, 0); // Clear SPI_CTRL_REG[SPI_INT_BIT] interrupt
GPIO_SetActive(cs.port, cs.pin); // set CS high
}
/**
****************************************************************************************
* @brief Handles timer timeout
* @return If the message was consumed or not.
****************************************************************************************
*/
int sample128_timer_handler(ke_msg_id_t const msgid,
struct gapm_cmp_evt const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
//uint8_t Tmpi;
//my_newer2_addChar Tmp_Buff;
//ke_timer_set(APP_SAMPLE128_TIMER,TASK_APP,Sample_LED_Blink);
//sample128_placeholder++;
/*
struct sample128_upd_char2_req *req = KE_MSG_ALLOC(
SAMPLE128_UPD_CHAR2_REQ,
TASK_SAMPLE128,
TASK_APP,
sample128_upd_char2_req
);
*/
sample128_LED++;
if(sample128_LED%2==0)
{
GPIO_SetActive(GPIO_PORT_1,GPIO_PIN_0);
}
else
{
GPIO_SetInactive(GPIO_PORT_1,GPIO_PIN_0);
}
uart2_write("Hello",strlen("Hello"),NULL);
//user_uart_write(&sample128_LED,1,NULL);
/*
for(Tmpi=0;Tmpi<characristic2_length;Tmpi++)
{
Tmp_Buff[Tmpi]=(uint8_t)(sample128_LED+Tmpi);
}
memcpy(&req->val,Tmp_Buff,sizeof(my_newer2_addChar));
req->val = sample128_placeholder;
req->conhdl = app_env.conhdl;
ke_msg_send(req);
*/
return (KE_MSG_CONSUMED);
}
int app_proxr_timer_handler(ke_msg_id_t const msgid,
void const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
if (alert_state.blink_toggle)
{
GPIO_SetInactive( alert_state.port, alert_state.pin);
alert_state.blink_toggle = 0;
}
else
{
GPIO_SetActive( alert_state.port, alert_state.pin);
alert_state.blink_toggle = 1;
}
ke_timer_set(APP_PXP_TIMER, dest_id, alert_state.blink_timeout);
return (KE_MSG_CONSUMED);
}
void app_batt_alert_stop(void)
{
batt_alert_en = 0;
if (bat_lvl_alert_used)
{
#ifdef CUSTOM_BATTERY_LEVEL_MEASUREMENTS___LED_IS_ACTIVE_LOW
GPIO_SetActive( bat_led_port, bat_led_pin);
#else
GPIO_SetInactive( bat_led_port, bat_led_pin);
#endif //CUSTOM_BATTERY_LEVEL_MEASUREMENTS___LED_IS_ACTIVE_LOW
}
ke_timer_clear(APP_BATT_ALERT_TIMER, TASK_APP);
#ifdef CUSTOM_BATTERY_LEVEL_MEASUREMENTS___BOOST_MODE_CONFIGURATION
if (bat_led_state == 0)
app_restore_sleep_mode();
#endif //CUSTOM_BATTERY_LEVEL_MEASUREMENTS___BOOST_MODE_CONFIGURATION
bat_led_state = 0;
}
/**
****************************************************************************************
* @brief Handles Battery Alert timer
*
* @param[in] msgid Id of the message received.
* @param[in] param Pointer to the parameters of the message.
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
* @param[in] src_id ID of the sending task instance.
*
* @return If the message was consumed or not.
****************************************************************************************
*/
int app_batt_alert_timer_handler(ke_msg_id_t const msgid,
void const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
//Read LED GPIO state
if(bat_lvl_alert_used)
{
if (bat_led_state)
{
GPIO_SetInactive( bat_led_port, bat_led_pin);
bat_led_state = 0;
app_timer_set(APP_BATT_ALERT_TIMER, dest_id, 20);
}
else
{
GPIO_SetActive( bat_led_port, bat_led_pin);
bat_led_state = 1;
app_timer_set(APP_BATT_ALERT_TIMER, dest_id, 5);
}
}
return (KE_MSG_CONSUMED);
}
/**
****************************************************************************************
* @brief SPI_439 initialization
*
* Should only be called once after power reset of 439, do not call this twice.
*
* @return void
****************************************************************************************
*/
void spi_439_init()
{
#if ( DESIGN_0 || DESIGN_1 )
GPIO_SetInactive( GPIO_PORT_2, GPIO_PIN_2 ); // Power on the 439, by setting MUTE_LDO = 0
#elif ( DESIGN_2 || DESIGN_3 )
GPIO_SetInactive( GPIO_PORT_1, GPIO_PIN_3 ); // Power on the 439, by setting MUTE_LDO = 0
#endif
SetBits16(SPI_CTRL_REG, SPI_ON, 0); // switch off SPI block
SPI_Pad_t spi_cs_pad;
#if ( DESIGN_0 || DESIGN_1 )
spi_cs_pad.port = GPIO_PORT_0;
spi_cs_pad.pin = GPIO_PIN_3;
#elif ( DESIGN_2 || DESIGN_3 )
spi_cs_pad.port = GPIO_PORT_0;
spi_cs_pad.pin = GPIO_PIN_2;
#endif
spi_init(&spi_cs_pad, SPI_MODE_16BIT, SPI_ROLE_MASTER,
SPI_CLK_IDLE_POL_LOW, SPI_PHA_MODE_0, SPI_MINT_DISABLE, SPI_XTAL_DIV_14); // SPI_XTAL_DIV_2=8MHZ, SPI_XTAL_DIV_8=2MHZ
/*
** First try to read our magic word. It should be 1A30. If so, skip the clock initializations.
** Otherwise, we are coming from cold boot.
*/
{
#ifdef JOH_CLK_SETTINGS
/*
** clk=16 Mhz from the 580 => set 439 PLL for Fsys = 46.08 MHz
** This means:
** - SC14439_CLK_CTRL_REG=0,0x12, 0x1A
** - SC14439_PLL_DIV_REG = 0x2A19, so VD/VX=(72/25)*16Mhz = 46.08 Mhz Fsys clock
** - SC14439_CLK_CTRL_REG , turn on PLL
** - SC14439_PER_DIV_REG = 4
** - SC14439_CODEC_DIV_REG = 20, so ClodecClk=46.08/20=2.304 Mhz
*/
SetWord439(SC14439_CLK_CTRL_REG, 0);
SetWord439(SC14439_PLL_DIV_REG, 0x2A19); /* VD/XD=(72/25)*16MHz = 46.08 Mhz Fsys. VD=72=6x12=01.0101; XD=25=00.11001, total = 0010.1010.0001.1001 */
SetWord439(SC14439_CLK_CTRL_REG, 0x12);
SetWord439(SC14439_PER_DIV_REG, 4); /* see calculation in DS SC14439, per_div<4 */
#else
/*
** clk=16 Mhz from the 580 => set 439 PLL for Fsys = 39.183 MHz
** This means:
** - SC14439_CLK_CTRL_REG=0,0x12, 0x1A
** - SC14439_PLL_DIV_REG = 0x2A19, so VD/VX=(120/49)*16Mhz = 39.183 Mhz Fsys clock
** - SC14439_CLK_CTRL_REG , turn on PLL
** - SC14439_PER_DIV_REG = 4
** - SC14439_CODEC_DIV_REG = 20, so ClodecClk=46.08/20=2.304 Mhz
*/
SetWord439(SC14439_CLK_CTRL_REG, 0);
SetWord439(SC14439_PLL_DIV_REG, 0x3631); /* VD/XD=(120/49)*16MHz = 39.183 Mhz Fsys. VD=120=10x12=01.1011; XD=49=01.10001 */
SetWord439(SC14439_CLK_CTRL_REG, 0x12);
SetWord439(SC14439_PER_DIV_REG, 4); /* see calculation in DS SC14439, per_div<4 */
#endif
SetWord439(SC14439_BAT_CTRL_REG, 2); /* VDDIO 2.25..2.75V gr: ok up to 3.45 V Not required - default value is valid */
SetWord439(SC14439_CODEC_VREF_REG, 0x0000); //make VREF settle faster TODO CHECK
SetWord439(SC14439_CODEC_ADDA_REG, 0x040e);
#if ( DESIGN_0 || DESIGN_1 )
SetWord439(SC14439_CODEC_MIC_REG, 0x1081); /* Amplifier Active*/
#elif ( DESIGN_2 || DESIGN_3 )
SetWord439(SC14439_CODEC_MIC_REG, 0x1041); /* Amplifier Active - Less Gain */
#endif
#if ( DESIGN_0 || DESIGN_1 )
spi439_delay(1500); //wait for PLL to settle
SetWord439(SC14439_CLK_CTRL_REG, 0x1A);
spi439_delay(100); //wait 16 spi cycles
#elif ( DESIGN_2 || DESIGN_3 )
spi439_delay(2000); //wait for PLL to settle
SetWord439(SC14439_CLK_CTRL_REG, 0x1A);
spi439_delay(100); //wait 16 spi cycles
#endif
}
/*
** 439 Codec initialization
**
*/
#ifdef JOH_CLK_SETTINGS
SetWord439(SC14439_CODEC_DIV_REG, 0x14); /* codec clk divider 46.08/20 = 2.304 MHz */
#else
SetWord439(SC14439_CODEC_DIV_REG, 0x11); /* codec clk divider Fsys/17 = 2.304 MHz */
#endif
spi439_delay(100); //wait a while
SetWord439(SC14439_CODEC_ADDA_REG, 0x0006);
SetWord439(SC14439_CODEC_VREF_REG, 0x0000);
/*
** Setup DMA on 439
** DMA will collect 80 samples from CODEC and put them in Shared RAM at address 0x0CD8, in circular buffer
** and continue indefenitely.
**
** The DMA buffer on the 439 is set to 80 samples = 160 bytes (Note hat DMA0_LEN is in bytes)
** Start address is 0xCD8. Second part of buffer starts at 0xD28
**
*/
SetWord439(SC14439_DMA0_LEN_REG,SC14439_DMA_LEN);
SetWord439(SC14439_DMA0_A_STARTL_REG,SC14439_DMA_DST_ADDR);
SetWord439(SC14439_DMA0_A_IDX_REG,0);
SetWord439(SC14439_DMA0_B_STARTL_REG,SC14439_CODEC_IN_OUT_REG);
SetWord439(SC14439_DMA0_B_IDX_REG,0);
SetWord439(SC14439_DMA0_CTRL_REG,0x062D); // SYNC_SEL=0, DREQ_LEVEL=0,CIRUCLAR=1., AINC=10,BINC=00 DREQ_MODE=1, RSRV, IND=1, DIR=1, RSRVD, DMA_ON=1 = 0000.0110.0010.1101
NVIC_SetPriority(SPI_IRQn,1);
NVIC_EnableIRQ(SPI_IRQn);
}
void spi3wire_cs_low (void)
{
GPIO_SetInactive(cs.port, cs.pin); // set CS low
}
