自学教程：C++ ASSERT_ERR函数代码示例

/** **************************************************************************************** * @brief Handles reception of the @ref GATTC_READ_IND message. * Generic event received after every simple read command sent to peer server. * @param[in] msgid Id of the message received (probably unused). * @param[in] param Pointer to the parameters of the message. * @param[in] dest_id ID of the receiving task instance (probably unused). * @param[in] src_id ID of the sending task instance. * @return If the message was consumed or not. **************************************************************************************** */static int gattc_read_ind_handler(ke_msg_id_t const msgid,                                    struct gattc_read_ind const *param,                                    ke_task_id_t const dest_id,                                    ke_task_id_t const src_id){    // Get the address of the environment    struct anpc_env_tag *anpc_env = PRF_CLIENT_GET_ENV(dest_id, anpc);    if (anpc_env != NULL)    {        ASSERT_ERR(anpc_env->operation != NULL);        // Prepare the indication to send to the application        struct anpc_value_ind *ind = KE_MSG_ALLOC(ANPC_VALUE_IND,                                                  anpc_env->con_info.appid,                                                  anpc_env->con_info.prf_id,                                                  anpc_value_ind);        ind->conhdl   = gapc_get_conhdl(anpc_env->con_info.conidx);        switch (((struct anpc_cmd *)anpc_env->operation)->operation)        {            // Read Supported New Alert Category Characteristic value            case (ANPC_ENABLE_RD_NEW_ALERT_OP_CODE):            {                ind->att_code = ANPC_RD_SUP_NEW_ALERT_CAT;                ind->value.supp_cat.cat_id_mask_0 = param->value[0];                // If cat_id_mask_1 not present, shall be considered as 0                ind->value.supp_cat.cat_id_mask_1 = (param->length > 1)                                                    ? param->value[1] : 0x00;            } break;            case (ANPC_ENABLE_RD_UNREAD_ALERT_OP_CODE):            {                ind->att_code = ANPC_RD_SUP_UNREAD_ALERT_CAT;                ind->value.supp_cat.cat_id_mask_0 = param->value[0];                // If cat_id_mask_1 not present, shall be considered as 0                ind->value.supp_cat.cat_id_mask_1 = (param->length > 1)                                                    ? param->value[1] : 0;            } break;            case (ANPC_READ_OP_CODE):            {                ind->att_code      = ((struct anpc_read_cmd *)anpc_env->operation)->read_code;                ind->value.ntf_cfg = co_read16(&param->value[0]);            } break;            default:            {                ASSERT_ERR(0);            } break;        }        // Send the indication        ke_msg_send(ind);    }    // else ignore the message    return (KE_MSG_CONSUMED);}

/** **************************************************************************************** * @brief Handles reception of the @ref GATTC_DISC_SVC_IND message. * The handler stores the found service details for service discovery. * @param[in] msgid Id of the message received (probably unused). * @param[in] param Pointer to the parameters of the message. * @param[in] dest_id ID of the receiving task instance (probably unused). * @param[in] src_id ID of the sending task instance. * @return If the message was consumed or not. **************************************************************************************** */static int gattc_disc_svc_ind_handler(ke_msg_id_t const msgid,                                      struct gattc_disc_svc_ind const *param,                                      ke_task_id_t const dest_id,                                      ke_task_id_t const src_id){    // Get the address of the environment    struct anpc_env_tag *anpc_env = PRF_CLIENT_GET_ENV(dest_id, anpc);    if (anpc_env != NULL)    {        ASSERT_ERR(anpc_env->operation != NULL);        ASSERT_ERR(((struct anpc_cmd *)anpc_env->operation)->operation == ANPC_ENABLE_OP_CODE);        // Keep only one instance of the service        if (anpc_env->nb_svc == 0)        {            // Keep the start handle and the end handle of the service            anpc_env->ans.svc.shdl = param->start_hdl;            anpc_env->ans.svc.ehdl = param->end_hdl;            anpc_env->nb_svc++;        }    }    return (KE_MSG_CONSUMED);}

/** **************************************************************************************** * @brief Handles reception of the APP_MODULE_INIT_CMP_EVT messgage * @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 * @param[in] src_id    ID of the sending task instance. * * @return If the message was consumed or not. **************************************************************************************** */int app_module_init_cmp_evt_handler(ke_msg_id_t const msgid,                                           const struct app_module_init_cmp_evt *param,                                           ke_task_id_t const dest_id,                                           ke_task_id_t const src_id){    if (ke_state_get(dest_id) == APP_DB_INIT)    {        if (param->status == CO_ERROR_NO_ERROR)        {            // Add next required service in the database            if (app_db_init())            {                // No more service to add in the database, start application                app_db_init_complete_func();            }        }        else        {            // An error has occurred during database creation            ASSERT_ERR(0);        }    }    else    {        // APP_DB_INIT state is used to wait the APP_MODULE_INIT_CMP_EVT message        ASSERT_ERR(0);    }        return (KE_MSG_CONSUMED);}

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);}

//##ModelId=48DC5D4603A0bool TiLib_OSD_Driver::Init(){// Init a big GraphicsDisplaySurface to draw.    if (gfxMap.uwWidth != 0) {    	return false;    }	//enable argb4444 surface to both Component & Composite out	ASSERT_ERR( (GI_NO_ERROR == GraphicsSurfaceCreate( HAL_GRAPHICS_MODE_ARGB8888, SCREEN_WIDTH, SCREEN_HEIGHT, &gfxMap)));    ASSERT_ERR( (GI_NO_ERROR == GraphicsDisplayDestRectSet( HAL_GRAPHICS_DISPLAY0, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT)));    ASSERT_ERR( (GI_NO_ERROR == GraphicsDisplayDestRectSet( HAL_GRAPHICS_DISPLAY1, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT)));    ASSERT_ERR( (GI_NO_ERROR == GraphicsDisplaySurfaceSet( HAL_GRAPHICS_DISPLAY_ALL, &gfxMap, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT)));    GraphicsDisplaySurfaceEnableSet(HAL_GRAPHICS_DISPLAY0, TRUE);    GraphicsDisplaySurfaceEnableSet(HAL_GRAPHICS_DISPLAY1, TRUE);     getSetOnScreenHandle(DO_SET, (PSURFACE) &gfxMap);    //set CURRENT_ONSCREEN to newSurf_FrontSurf    //init a pattern in the buffer:        ClearScreen();	    return true;    ERR_EXIT:     return false;}

/** **************************************************************************************** * @brief Handles reception of the @ref GATT_DISC_SVC_BY_UUID_CMP_EVT message. * @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. * @param[in] src_id ID of the sending task instance. * @return If the message was consumed or not. **************************************************************************************** */static int gatt_disc_svc_by_uuid_evt_handler(ke_msg_id_t const msgid,                                             struct gatt_disc_svc_by_uuid_cmp_evt const *param,                                             ke_task_id_t const dest_id,                                             ke_task_id_t const src_id){    // Get the address of the environment    struct cscpc_env_tag *cscpc_env = PRF_CLIENT_GET_ENV(dest_id, cscpc);    // Check if the environment exists    if (cscpc_env != NULL)    {        ASSERT_ERR(cscpc_env->operation != NULL);        ASSERT_ERR(((struct cscpc_cmd *)cscpc_env->operation)->operation == CSCPC_ENABLE_OP_CODE);        // Keep only one instance of the service        if (cscpc_env->nb_svc == 0)        {            // Keep the start handle and the end handle of the service            cscpc_env->cscs.svc.shdl = param->list[0].start_hdl;            cscpc_env->cscs.svc.ehdl = param->list[0].end_hdl;            cscpc_env->nb_svc++;        }    }    // else drop the message    return (KE_MSG_CONSUMED);}

	bool LoadFile(const char * path, std::vector<byte> * pDataOut, LFK lfk /*= LFK_Binary*/)	{		ASSERT_ERR(path);		ASSERT_ERR(pDataOut);		FILE * pFile = nullptr;		if (fopen_s(&pFile, path, (lfk == LFK_Text) ? "rt" : "rb") != 0)		{			WARN("Couldn't open file %s", path);			return false;		}		ASSERT_ERR(pFile);		// Determine file size		fseek(pFile, 0, SEEK_END);		size_t size = ftell(pFile);		// Read the whole file into memory		pDataOut->resize((lfk == LFK_Text) ? size+1 : size);		rewind(pFile);		size_t sizeRead = fread(&(*pDataOut)[0], sizeof(byte), size, pFile);		// Size can be smaller for text files, due to newline conversion		ASSERT_ERR(sizeRead == size || ((lfk == LFK_Text) && sizeRead <= size));		fclose(pFile);		// Automatically null-terminate text files so string functions can be used		if (lfk == LFK_Text)		{			pDataOut->resize(sizeRead + 1);			(*pDataOut)[sizeRead] = 0;		}		return true;	}

/** **************************************************************************************** * @brief Handles GAP manager command complete events. * * @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 gapm_cmp_evt_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){    switch(param->operation) {    // reset completed    case GAPM_RESET:        if(param->status != GAP_ERR_NO_ERROR) {            ASSERT_ERR(0); // unexpected error        }        else {            // set device configuration            struct gapm_set_dev_config_cmd* cmd = KE_MSG_ALLOC(GAPM_SET_DEV_CONFIG_CMD,                    TASK_GAPM, TASK_APP, gapm_set_dev_config_cmd);            app_configuration_func(dest_id, cmd);            ke_msg_send(cmd);        }        break;    // device configuration updated    case GAPM_SET_DEV_CONFIG:        if(param->status != GAP_ERR_NO_ERROR) {            ASSERT_ERR(0); // unexpected error        }        else {            app_set_dev_config_complete_func();        }        break;    // Advertising finished    case GAPM_ADV_UNDIRECT:        app_adv_undirect_complete(param->status);        break;    // Directed advertising finished    case GAPM_ADV_DIRECT:        app_adv_direct_complete(param->status);          break;    case GAPM_RESOLV_ADDR:    case GAPM_ADD_DEV_IN_WLIST:    case GAPM_RMV_DEV_FRM_WLIST:#if (USE_CONNECTION_FSM)        app_con_fsm_handle_cmp_evt(param);#endif        break;    case GAPM_CANCEL:        if(param->status != GAP_ERR_NO_ERROR) {            ASSERT_ERR(0); // unexpected error        }        break;    default:        ASSERT_ERR(0); // unexpected error        break;    }    return (KE_MSG_CONSUMED);}

/** **************************************************************************************** * @brief Handles reception of the @ref GATT_WRITE_CHAR_RESP message. * @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. * @param[in] src_id ID of the sending task instance. * @return If the message was consumed or not. **************************************************************************************** */static int gatt_write_char_rsp_handler(ke_msg_id_t const msgid,                                       struct gatt_write_char_resp const *param,                                       ke_task_id_t const dest_id,                                       ke_task_id_t const src_id){    // Get the address of the environment    struct cscpc_env_tag *cscpc_env = PRF_CLIENT_GET_ENV(dest_id, cscpc);    if (cscpc_env != NULL)    {        ASSERT_ERR(cscpc_env->operation != NULL);        // Retrieve the operation currently performed        uint8_t operation = ((struct cscpc_cmd *)cscpc_env->operation)->operation;        switch (operation)        {            case (CSCPC_CFG_NTF_IND_OP_CODE):            {                // Send the complete event status                cscpc_send_cmp_evt(cscpc_env, operation, param->status);            } break;            case (CSCPC_CTNL_PT_CFG_WR_OP_CODE):            {                if (param->status == PRF_ERR_OK)                {                    // Start Timeout Procedure                    ke_timer_set(CSCPC_TIMEOUT_TIMER_IND, dest_id, CSCPC_PROC_TIMEOUT_TIMER_VAL);                    // Wait for the response indication                    ((struct cscpc_cmd *)cscpc_env->operation)->operation = CSCPC_CTNL_PT_CFG_IND_OP_CODE;                }                else                {                    // Send the complete event status                    cscpc_send_cmp_evt(cscpc_env, operation, param->status);                }            } break;            default:            {                ASSERT_ERR(0);            } break;        }    }    // else ignore the message    return (KE_MSG_CONSUMED);}

/** **************************************************************************************** * @brief   User initialize **************************************************************************************** */void usr_init(void){    if(KE_EVENT_OK != ke_evt_callback_set(EVENT_BUTTON1_PRESS_ID,                                             app_event_button1_press_handler))    {        ASSERT_ERR(0);    }				//register event callback for accelerometer interrupt		if(KE_EVENT_OK != ke_evt_callback_set(EVENT_ACCEL_INT_ID,                                             app_event_accel_handler))    {        ASSERT_ERR(0);    }				//PROTOCOL		//testing protocol		char *data; 		data = malloc(sizeof(char)*14);		data[0] = 0x00;//PROTOCOL_COMMAND_ENABLE;		data[1] = 0x00;//PROTOCOL_BATT;				data[2] = 0x00;//PROTOCOL_COMMAND_ENABLE;		data[3] = 0x00;//PROTOCOL_TEMP;				data[4] = 0x00;//PROTOCOL_COMMAND_ENABLE;		data[5] = 0x00;//PROTOCOL_PED;				//data[4] = PROTOCOL_COMMAND_ENABLE;		//data[5] = PROTOCOL_PED;				//data[6] = 0x00;//PROTOCOL_COMMAND_ENABLE;		//data[7] = 0x00;//PROTOCOL_DISTANCE;				//for testing streaming ADC output set:		data[6] = PROTOCOL_COMMAND_ENABLE;		data[7] = PROTOCOL_ADC_SAMPLE;		//data[6] = 0x00;//PROTOCOL_COMMAND_ENABLE;		//data[7] = 0x00;//PROTOCOL_ADC_SAMPLE;				data[8] = PROTOCOL_COMMAND_RATE;		data[9] = 100;		data[10] = 0x00;   //4 int		data[11] = 0x00;		data[12] = 0x04;				data[13] = '/0';		receive_packet(13, data);		//print_list();}

/** **************************************************************************************** * @brief   User initialize **************************************************************************************** */void usr_init(void){    if(KE_EVENT_OK != ke_evt_callback_set(EVENT_BUTTON1_PRESS_ID,                                             app_event_button1_press_handler))    {        ASSERT_ERR(0);    }#if		(FB_JOYSTICKS)		 if(KE_EVENT_OK != ke_evt_callback_set(EVENT_ADC_KEY_SAMPLE_CMP_ID,                                           app_event_adc_key_sample_cmp_handler))		{				ASSERT_ERR(0);		}#endif}

/** **************************************************************************************** * @brief Initialise the database. * * @return If database initialization completed. **************************************************************************************** */bool app_db_init_func(void){      // Indicate if more services need to be added in the database    bool end_db_create = false;    // Check if another should be added in the database    if (app_env.next_prf_init < APP_PRF_LIST_STOP)    {        switch (app_env.next_prf_init)        {            default:            {                ASSERT_ERR(0);            } break;        }        // Select following service to add        app_env.next_prf_init++;    }    else    {        end_db_create = true;    }    return end_db_create;}

static void uart_rec_error_isr(void){    void (*callback) (uint8_t) = NULL;    // Reset RX parameters    uart_env.rx.size = 0;    uart_env.rx.bufptr = NULL;    // Disable RX interrupt    SetBits16(UART_IER_DLH_REG, ERBFI_dlh0, 0); // uart_rec_data_avail_setf(0);    // Reset RX FIFO    // uart_rxfifo_res_setf(1); @WIK commented    // Retrieve callback pointer    callback = uart_env.rx.callback;    if(callback != NULL)    {        // Clear callback pointer        uart_env.rx.callback = NULL;        // Call handler        callback(UART_STATUS_ERROR);    }    else    {        ASSERT_ERR(0);    }}

/** **************************************************************************************** * @brief Handles GAP controller command complete events. * * @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 gapc_cmp_evt_handler(ke_msg_id_t const msgid,                                struct gapc_cmp_evt const *param,                                ke_task_id_t const dest_id,                                ke_task_id_t const src_id){    switch(param->operation) {    // reset completed    case GAPC_UPDATE_PARAMS:        if (ke_state_get(dest_id) == APP_PARAM_UPD) {            if ((param->status != CO_ERROR_NO_ERROR)) {                // it's application specific what to do when the Param Upd request is rejected                app_update_params_rejected_func(param->status);            }            else {                // Go to Connected State                ke_state_set(dest_id, APP_CONNECTED);                // if state is APP_CONNECTED then the request was accepted                app_update_params_complete_func();            }        }        break;    default:        if(param->status != GAP_ERR_NO_ERROR) {            ASSERT_ERR(0); // unexpected error        }        break;    }    return (KE_MSG_CONSUMED);}

int app_entry_point_handler (ke_msg_id_t const msgid,                                         void const *param,                                         ke_task_id_t const dest_id,                                         ke_task_id_t const src_id){    int i=0;    enum ke_msg_status_tag process_msg_handling_result;        while (i<sizeof(app_process_handlers)/sizeof(process_event_func_t))    {        ASSERT_ERR(app_process_handlers[i]);         if (app_process_handlers[i](msgid,param,dest_id,src_id, &process_msg_handling_result)==PR_EVENT_HANDLED)               return (process_msg_handling_result);         i++;    }    //user cannot do anything else than consume the message    if (app_process_catch_rest_cb!=NULL)    {        app_process_catch_rest_cb(msgid,param,dest_id,src_id);    }        return (KE_MSG_CONSUMED);    };

void uart_sps_read(uint8_t *bufptr, uint32_t size, uint8_t *state, void (*callback) (uint8_t, uint32_t)){    // Sanity check    ASSERT_ERR(bufptr != NULL);    ASSERT_ERR(size != 0);    ASSERT_ERR(uart_sps_env.rx.bufptr == NULL);    // Prepare RX parameters    uart_sps_env.rx.size 		= size;    uart_sps_env.rx.bufptr 		= bufptr;	  uart_sps_env.rx.state 		= state;	  uart_sps_env.rx.callback 	= callback; 	    // Start data transaction    uart_rec_data_avail_setf(1); //=SetBits16(UART_IER_DLH_REG, ETBEI_dlh0, 1); }

const struct rwip_eif_api* rwip_eif_get_func(uint8_t type){    const struct rwip_eif_api* ret = NULL;    switch(type)    {        case RWIP_EIF_AHI:        case RWIP_EIF_HCIC:        {#ifdef CFG_HCI_BOTH_EIF            if (GPIO_GetPinStatus(HCI_EIF_SELECT_PORT,HCI_EIF_SELECT_PIN))                ret = &uart_api;            else                ret = &spi_api;#else  #ifdef CFG_HCI_SPI            ret = &spi_api;     // select spi api  #else            ret = &uart_api;    // select uart api  #endif#endif        }        break;        default:        {            ASSERT_ERR(0);        }        break;    }    return ret;}

void app_disconnect_func(ke_task_id_t task_id, struct gapc_disconnect_ind const *param){        uint8_t state = ke_state_get(task_id);    #if BLE_BATT_SERVER app_batt_poll_stop();#endif // BLE_BATT_SERVER        if ((state == APP_SECURITY) || (state == APP_CONNECTED)  || (state == APP_PARAM_UPD))    {        /**************************************************            Handle disconnection event***************************************************/            // Restart Advertising			 //app_adv_start();	    }    else    {        // We are not in a Connected State        ASSERT_ERR(0);    }      }    

static void uart_sps_rec_error_isr(void){    void (*callback) (uint8_t, uint32_t) = NULL;    // Reset RX parameters    uart_sps_env.rx.size = 0;    uart_sps_env.rx.bufptr = NULL;        // Disable RX interrupt    SetBits16(UART_IER_DLH_REG, ERBFI_dlh0, 0);        // Retrieve callback pointer    callback = uart_sps_env.rx.callback;    if(callback != NULL)    {        // Clear callback pointer        uart_sps_env.rx.callback = NULL;        // Call handler        callback(UART_STATUS_ERROR, NULL);    }    else    {        ASSERT_ERR(0);    }}

/** **************************************************************************************** * @brief Disconnection indication to ANPC. * @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 * @param[in] src_id    ID of the sending task instance. * @return If the message was consumed or not. **************************************************************************************** */static int gap_discon_cmp_evt_handler(ke_msg_id_t const msgid,                                      struct gap_discon_cmp_evt const *param,                                      ke_task_id_t const dest_id,                                      ke_task_id_t const src_id){    // Get the address of the environment    struct cscpc_env_tag *cscpc_env = PRF_CLIENT_GET_ENV(dest_id, cscpc);    ASSERT_ERR(cscpc_env != NULL);    // Free the stored operation if needed    if (cscpc_env->operation != NULL)    {        // Check if we were waiting for a SC Control Point indication        if (((struct cscpc_cmd *)cscpc_env->operation)->operation == CSCPC_CTNL_PT_CFG_IND_OP_CODE)        {            // Stop the procedure timeout timer            ke_timer_clear(CSCPC_TIMEOUT_TIMER_IND, dest_id);        }        ke_msg_free(ke_param2msg(cscpc_env->operation));        cscpc_env->operation = NULL;    }    PRF_CLIENT_DISABLE_IND_SEND(cscpc_envs, dest_id, CSCPC);    return (KE_MSG_CONSUMED);}

/** **************************************************************************************** * @brief Handles the temperature timer. * * @param[in] msgid     APP_HTPT_PERIOD_MEAS_TIMER * @param[in] param     None * @param[in] dest_id   TASK_APP * @param[in] src_id    TASK_APP * * @return If the message was consumed or not. * @description *  Handles the temperature timer. **************************************************************************************** */int app_htpt_period_meas_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){    bool start_meas = false;    // Measurement Ready - send if Client Configuration is Configured,    // and regardless of connected    if(usr_env.is_temp_meas_config)    {        ++usr_env.meas_counter;        ASSERT_ERR(app_htpt_env->meas_intv != 0);        //if interval is zero, don't send indication        if( usr_env.meas_counter % app_htpt_env->meas_intv == 0 )        {            start_meas = true;            usr_env.is_should_indicate = true;        }    }    if (usr_env.is_temp_imeas_config)        start_meas = true;    if(start_meas)        start_measure_temperature();    ke_timer_set(APP_HTPT_PERIOD_MEAS_TIMER, TASK_APP, HTPT_PERIOD_MEAS_TIME);    return (KE_MSG_CONSUMED);}

	/* 	 *	Init TX and RX buffers, they are in EM but not in the retainable part 	 *  so the pointers have to be programmed again	* 	 */	if(func_check_mem_flag)	{		if (func_check_mem_flag==2)		{	  //init TX/RX buffers after DEEPSLEEP			co_buf_init_deep_sleep();		// Set the first RX descriptor pointer into the HW        ble_currentrxdescptr_set(REG_BLE_EM_RX_ADDR_GET(co_buf_rx_current_get()));		}   	       //INIT NONE RET. HEAP after DEEPSLEEP	       	ke_mem_init(KE_MEM_NON_RETENTION, (uint8_t*)(jump_table_struct[rwip_heap_non_ret_pos]), jump_table_struct[rwip_heap_non_ret_size]);		func_check_mem_flag = 0;//false;			}     #endif //RW_BLE_SUPPORT#endif //DEEP_SLEEP}#endif //0// /*********************************************************************************//  *** SLP_INT ISR//  ***/void lld_sleep_compensate_func_patched(void){    uint32_t dur_us;    uint32_t slot_corr;    uint32_t fine_corr;        // Get the number of low power sleep period    uint32_t slp_period = ble_deepslstat_get();    // Sanity check: The duration of a sleep is limited    ASSERT_ERR(slp_period < LLD_EVT_MAX_SLEEP_DURATION);    // Convert sleep duration into us    dur_us = lld_sleep_lpcycles_2_us_sel_func(slp_period);    slot_corr = dur_us / 625;    fine_corr = 624 - (dur_us % 625);    if (fine_corr == 0)        fine_corr = 1;    // The correction values are then deduced from the sleep duration in us    ble_basetimecntcorr_set(slot_corr);    ble_finecntcorr_set(fine_corr);    // Start the correction    ble_deep_sleep_corr_en_setf(1);}

/** **************************************************************************************** * @brief Handles button press after cancel the jitter. * * @param[in] msgid     Id of the message received * @param[in] param     None * @param[in] dest_id   TASK_APP * @param[in] src_id    TASK_APP * * @return If the message was consumed or not. **************************************************************************************** */int app_button_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){    switch(msgid)    {        case APP_SYS_BUTTON_1_TIMER:            // make sure the button is pressed            if(gpio_read_pin(BUTTON1_PIN) == GPIO_LOW)            {                if(APP_IDLE == ke_state_get(TASK_APP))                {                    struct app_proxr_env_tag *app_proxr_env = &app_env.proxr_ev;                    if(!app_proxr_env->enabled)                    {                        // start adv                        app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,                                app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),                                app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),                                GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);#if (QN_DEEP_SLEEP_EN)                        // prevent entering into deep sleep mode                        sleep_set_pm(PM_SLEEP);#endif#if	(FB_OLED)		ke_timer_set(APP_OLED_STATE_DISPlAY_TIMER,TASK_APP,20);#endif                    }                }                else if(APP_ADV == ke_state_get(TASK_APP))                {                    // stop adv                    app_gap_adv_stop_req();#if (QN_DEEP_SLEEP_EN)                    // allow entering into deep sleep mode                    sleep_set_pm(PM_DEEP_SLEEP);#endif#if	(FB_OLED)		ke_timer_set(APP_OLED_STATE_DISPlAY_TIMER,TASK_APP,20);#endif                }            }            break;        case APP_SYS_BUTTON_2_TIMER:            if(gpio_read_pin(BUTTON2_PIN) == GPIO_LOW)            {                buzzer_off();            }            break;        default:            ASSERT_ERR(0);            break;    }    return (KE_MSG_CONSUMED);}

/** **************************************************************************************** * @brief Serves the receive data available interrupt requests. It clears the requests and *        executes the callback function. * * @return void **************************************************************************************** */static void uart_sps_rec_data_avail_isr(void){    void (*callback) (uint8_t, uint32_t) = NULL;    uint32_t sent_bytes = 0;        while (uart_data_rdy_getf())    {        // Read the received in the FIFO        readData = uart_rxdata_getf();#if (UART_SW_FLOW_ENABLED)        if(readData == UART_XON_BYTE)        {            //callback function will tell application that XOFF is received            *uart_sps_env.rx.state = UART_XON;        }        else if(readData == UART_XOFF_BYTE)        {            //callback function will tell application that XON is received            *uart_sps_env.rx.state = UART_XOFF;            app_override_ble_xoff();        }        else#endif /*UART_SW_FLOW_ENABLED*/        {            //put data in buffer            *uart_sps_env.rx.bufptr = readData;                        //update RX parameters            uart_sps_env.rx.size--;            sent_bytes++;            uart_sps_env.rx.bufptr++;        }        // Check if all expected data have been received        if (uart_sps_env.rx.size == 0)        {            // Reset RX parameters            uart_sps_env.rx.bufptr = NULL;                        // Retrieve callback pointer            callback = uart_sps_env.rx.callback;                        if(callback != NULL)            {                // Clear callback pointer                uart_sps_env.rx.callback = NULL;                                // Call handler                callback(UART_STATUS_OK, sent_bytes);            }            else            {                ASSERT_ERR(0);            }                        // Exit loop            break;        }    }}

/** **************************************************************************************** * @brief   User initialize **************************************************************************************** */void usr_init(void){    if(KE_EVENT_OK != ke_evt_callback_set(EVENT_BUTTON1_PRESS_ID,                                             app_event_button1_press_handler))    {        ASSERT_ERR(0);    }}

void app_gap_bond_cfm(struct gapc_bond_req_ind *param){    struct gapc_bond_cfm * cfm = BleMsgAlloc(GAPC_BOND_CFM, KE_BUILD_ID(TASK_GAPC, app_env.proxr_device.device.conhdl), TASK_APP,                                 sizeof(struct gapc_bond_cfm));    switch(param->request)    {    // Bond Pairing request    case GAPC_PAIRING_REQ:    {        cfm->request = GAPC_PAIRING_RSP;        cfm->accept = true;        // OOB information        cfm->data.pairing_feat.oob            = GAP_OOB_AUTH_DATA_NOT_PRESENT;        // Encryption key size        cfm->data.pairing_feat.key_size       = KEY_LEN;        // IO capabilities        cfm->data.pairing_feat.iocap          = GAP_IO_CAP_NO_INPUT_NO_OUTPUT;        // Authentication requirements        cfm->data.pairing_feat.auth           = GAP_AUTH_REQ_NO_MITM_BOND;        //cfm->data.pairing_feat.auth           = GAP_AUTH_REQ_MITM_NO_BOND;        //Initiator key distribution        //GZ cfm->data.pairing_feat.ikey_dist      = GAP_KDIST_NONE;        cfm->data.pairing_feat.ikey_dist      = GAP_KDIST_SIGNKEY;        //Responder key distribution        cfm->data.pairing_feat.rkey_dist      = GAP_KDIST_ENCKEY;        //Security requirements        cfm->data.pairing_feat.sec_req        = GAP_NO_SEC;    }    break;    // Used to retrieve pairing Temporary Key    case GAPC_TK_EXCH:    {        if(param->data.tk_type == GAP_TK_DISPLAY)        {            uint32_t pin_code = app_gen_tk();            cfm->request = GAPC_TK_EXCH;            cfm->accept = true;            memset(cfm->data.tk.key, 0, KEY_LEN);            cfm->data.tk.key[12] = (uint8_t)((pin_code & 0xFF000000) >> 24);            cfm->data.tk.key[13] = (uint8_t)((pin_code & 0x00FF0000) >> 16);            cfm->data.tk.key[14] = (uint8_t)((pin_code & 0x0000FF00) >>  8);            cfm->data.tk.key[15] = (uint8_t)((pin_code & 0x000000FF) >>  0);        }        else        {            ASSERT_ERR(0);        }    }

void uart_sps_write(uint8_t *bufptr, uint32_t size, uint8_t *state, void (*callback) (uint8_t)){   // Sanity check    ASSERT_ERR(bufptr != NULL);		if(*state == UART_NONE && !UART_SW_FLOW_ENABLED) //size could be 0 if only flow control must be send		{			ASSERT_ERR(size != 0);		}    ASSERT_ERR(uart_sps_env.tx.bufptr == NULL);    // Prepare TX parameters    uart_sps_env.tx.size 		= size;    uart_sps_env.tx.bufptr 		= bufptr;    uart_sps_env.tx.state 		= state;	uart_sps_env.tx.callback 	= callback; 			    uart_thr_empty_setf(1);}

static uint32_t rwip_slot_2_lpcycles_rcx(uint32_t slot_cnt){    volatile uint32_t lpcycles;    // Sanity check: The number of slots should not be too high to avoid overflow    ASSERT_ERR(slot_cnt < 1000000);    lpcycles = (uint32_t)(slot_cnt * rcx_slot_duration);        return(lpcycles);}

/** **************************************************************************************** * @brief Handles reception of the @ref GATTC_DISC_CHAR_DESC_IND message. * @param[in] msgid Id of the message received (probably unused). * @param[in] param Pointer to the parameters of the message. * @param[in] dest_id ID of the receiving task instance (probably unused). * @param[in] src_id ID of the sending task instance. * @return If the message was consumed or not. **************************************************************************************** */static int gattc_disc_char_desc_ind_handler(ke_msg_id_t const msgid,                                           struct gattc_disc_char_desc_ind const *param,                                           ke_task_id_t const dest_id,                                           ke_task_id_t const src_id){    // Get the address of the environment    struct anpc_env_tag *anpc_env = PRF_CLIENT_GET_ENV(dest_id, anpc);    if (anpc_env != NULL)    {        ASSERT_ERR(anpc_env->operation != NULL);        ASSERT_ERR(((struct anpc_cmd *)anpc_env->operation)->operation == ANPC_ENABLE_OP_CODE);        // Retrieve ANPS descriptors        prf_search_descs(ANPC_DESC_MAX, &anpc_env->ans.descs[0], &anpc_ans_char_desc[0],                         param, anpc_env->last_req);    }    return (KE_MSG_CONSUMED);}

/** **************************************************************************************** * @brief Handles reception of the @ref CSCPC_TIMEOUT_TIMER_IND message. This message is * received when the peer device doesn't send a SC Control Point indication within 30s * after reception of the write response. * @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. * @param[in] src_id ID of the sending task instance. * @return If the message was consumed or not. **************************************************************************************** */static int cscpc_timeout_timer_ind_handler(ke_msg_id_t const msgid,                                           void const *param,                                           ke_task_id_t const dest_id,                                           ke_task_id_t const src_id){    // Get the address of the environment    struct cscpc_env_tag *cscpc_env = PRF_CLIENT_GET_ENV(dest_id, cscpc);    if (cscpc_env != NULL)    {        ASSERT_ERR(cscpc_env->operation != NULL);        ASSERT_ERR(((struct cscpc_cmd *)cscpc_env->operation)->operation == CSCPC_CTNL_PT_CFG_IND_OP_CODE);        // Send the complete event message        cscpc_send_cmp_evt(cscpc_env, CSCPC_CTNL_PT_CFG_WR_OP_CODE, PRF_ERR_PROC_TIMEOUT);    }    // else drop the message    return (KE_MSG_CONSUMED);}