static void gzp_preload_ack(uint8_t* src, uint8_t length, uint8_t pipe) { gzll_goto_idle(); gzll_tx_fifo_flush(); gzll_ack_payload_write(src, length, pipe); gzll_rx_start(); }
void gzp_pairing_enable(bool enable) { gzll_states_t temp_gzll_state; temp_gzll_state = gzll_get_state(); if(gzp_pairing_enabled_f != enable) { gzll_goto_idle(); if(enable) { gzll_set_param(GZLL_PARAM_RX_PIPES, gzll_get_param(GZLL_PARAM_RX_PIPES) | (1 << GZP_PAIRING_PIPE)); } else { gzll_set_param(GZLL_PARAM_RX_PIPES, gzll_get_param(GZLL_PARAM_RX_PIPES) & ~(1 << GZP_PAIRING_PIPE)); gzp_id_req_stat = GZP_ID_REQ_IDLE; } gzp_pairing_enabled_f = enable; if(temp_gzll_state == GZLL_HOST_ACTIVE) { gzll_rx_start(); } } }
static void gzp_preload_ack(uint8_t* src, uint8_t length, uint8_t pipe) { gzll_goto_idle(); gzll_tx_fifo_flush(); (void)nrf_gzll_add_packet_to_tx_fifo(pipe, src, length); gzll_rx_start(); }
void gzll_rx_start(void) { if(nrf_gzll_get_mode() != NRF_GZLL_MODE_HOST) { gzll_goto_idle(); (void)nrf_gzll_set_mode(NRF_GZLL_MODE_HOST); } if(!nrf_gzll_is_enabled()) { (void)nrf_gzll_enable(); } }
void gzll_rx_start() { uint8_t i; uint32_t flag; gzll_goto_idle(); if(gzll_rx_setup_modified) { flag = gzll_interupts_save(); gzll_rx_setup_modified = false; gzll_tx_setup_modified = true; /* Restore pipe 0 address (this may have been altered during transmission) */ hal_nrf_set_address(HAL_NRF_PIPE0, gzll_p0_adr); /* Enable the receive pipes selected by gzll_set_param() */ hal_nrf_close_pipe(HAL_NRF_ALL); for(i = 0; i < 6; i++) { if(gzll_dyn_params[GZLL_PARAM_RX_PIPES] & (1 << i)) { hal_nrf_open_pipe((hal_nrf_address_t)i, EN_AA); } } hal_nrf_set_operation_mode(HAL_NRF_PRX); } gzll_set_radio_power_on(true); gzll_timeout_counter = 0; gzll_state_var = GZLL_HOST_ACTIVE; GZLL_RFCE_HIGH(); gzll_interupts_restore(flag); }
void gzp_pairing_enable(bool enable) { if(gzp_pairing_enabled_f != enable) { gzll_goto_idle(); if(enable) { (void)nrf_gzll_set_rx_pipes_enabled(nrf_gzll_get_rx_pipes_enabled() | (1 << GZP_PAIRING_PIPE)); } else { (void)nrf_gzll_set_rx_pipes_enabled(nrf_gzll_get_rx_pipes_enabled() & ~(1 << GZP_PAIRING_PIPE)); gzp_id_req_stat = GZP_ID_REQ_IDLE; } gzp_pairing_enabled_f = enable; gzll_rx_start(); } }
static void gzp_process_address_req(uint8_t* gzp_req) { uint8_t temp_rx_pipes, temp_host_mode; uint8_t pairing_resp[GZP_CMD_HOST_ADDRESS_RESP_PAYLOAD_LENGTH]; gzp_address_exchanged_f = false; gzll_goto_idle(); temp_rx_pipes = gzll_get_param(GZLL_PARAM_RX_PIPES); temp_host_mode = gzll_get_param(GZLL_PARAM_HOST_MODE); // If requesting Device within close proximity if(gzll_rx_power_high()) { gzll_set_param(GZLL_PARAM_RX_PIPES, 0); gzll_set_param(GZLL_PARAM_HOST_MODE, 0); gzll_set_param(GZLL_PARAM_RX_TIMEOUT, GZP_CLOSE_PROXIMITY_BACKOFF_RX_TIMEOUT); gzll_rx_fifo_flush(); // Start "proximity" back off period gzll_rx_start(); while(gzll_get_state() != GZLL_IDLE) ; // Build pairing response packet pairing_resp[0] = GZP_CMD_HOST_ADDRESS_RESP; gzp_host_chip_id_read(&pairing_resp[GZP_CMD_HOST_ADDRESS_RESP_ADDRESS], GZP_SYSTEM_ADDRESS_WIDTH); gzll_ack_payload_write(&pairing_resp[0], GZP_CMD_HOST_ADDRESS_RESP_PAYLOAD_LENGTH, 0); gzll_set_param(GZLL_PARAM_RX_TIMEOUT, GZP_STEP1_RX_TIMEOUT); // Enable only pairing pipe when waiting for pairing request step 1 gzll_set_param(GZLL_PARAM_RX_PIPES, (1 << GZP_PAIRING_PIPE)); gzll_rx_start(); while(gzll_get_state() != GZLL_IDLE) { if(gzll_rx_fifo_read(&gzp_req[0], NULL, NULL)) { // Validate step 1 of pairing request if(gzp_req[0] == GZP_CMD_HOST_ADDRESS_FETCH) { gzp_address_exchanged_f = true; } } } gzll_tx_fifo_flush(); gzll_rx_fifo_flush(); gzll_set_param(GZLL_PARAM_RX_TIMEOUT, 0); gzll_set_param(GZLL_PARAM_RX_PIPES, temp_rx_pipes); gzll_set_param(GZLL_PARAM_HOST_MODE, temp_host_mode); // Return to normal operation gzll_rx_start(); } else { gzll_set_param(GZLL_PARAM_RX_PIPES, temp_rx_pipes & ~(1 << GZP_PAIRING_PIPE)); gzll_set_param(GZLL_PARAM_RX_TIMEOUT, GZP_NOT_PROXIMITY_BACKOFF_RX_TIMEOUT); // Start "not proximity" backoff period gzll_rx_start(); } }
static void gzp_process_address_req(uint8_t* gzp_req) { uint8_t temp_rx_pipes; uint8_t pairing_resp[GZP_CMD_HOST_ADDRESS_RESP_PAYLOAD_LENGTH]; uint32_t rx_payload_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH; gzp_address_exchanged_f = false; gzll_goto_idle(); ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); temp_rx_pipes = nrf_gzll_get_rx_pipes_enabled(); ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); // If requesting Device within close proximity if(prev_gzp_rx_info.rssi >= GZP_HOST_RX_POWER_THRESHOLD) { (void)nrf_gzll_set_rx_pipes_enabled(0); ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); gzll_set_rx_timeout(GZP_CLOSE_PROXIMITY_BACKOFF_RX_TIMEOUT); ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); gzll_rx_fifo_flush(); ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); // Start "proximity" back off period gzll_rx_start(); ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); while(nrf_gzll_is_enabled()) {} // Build pairing response packet pairing_resp[0] = (uint8_t)GZP_CMD_HOST_ADDRESS_RESP; gzp_host_chip_id_read(&pairing_resp[GZP_CMD_HOST_ADDRESS_RESP_ADDRESS], GZP_SYSTEM_ADDRESS_WIDTH); (void)nrf_gzll_add_packet_to_tx_fifo(0, &pairing_resp[0], GZP_CMD_HOST_ADDRESS_RESP_PAYLOAD_LENGTH); ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); gzll_set_rx_timeout(GZP_STEP1_RX_TIMEOUT); // Enable only pairing pipe when waiting for pairing request step 1 (void)nrf_gzll_set_rx_pipes_enabled((1 << GZP_PAIRING_PIPE)); gzll_rx_start(); while(nrf_gzll_is_enabled()) { if(nrf_gzll_get_rx_fifo_packet_count(GZP_PAIRING_PIPE)) { (void)nrf_gzll_fetch_packet_from_rx_fifo(GZP_PAIRING_PIPE, &gzp_req[0], &rx_payload_length); // Validate step 1 of pairing request if(gzp_req[0] == (uint8_t)GZP_CMD_HOST_ADDRESS_FETCH) { gzp_address_exchanged_f = true; } } } gzll_tx_fifo_flush(); gzll_rx_fifo_flush(); gzll_set_rx_timeout(0); (void)nrf_gzll_set_rx_pipes_enabled(temp_rx_pipes); // Return to normal operation gzll_rx_start(); } else { (void)nrf_gzll_set_rx_pipes_enabled(temp_rx_pipes & ~(1 << GZP_PAIRING_PIPE)); gzll_set_rx_timeout(GZP_NOT_PROXIMITY_BACKOFF_RX_TIMEOUT); // Start "not proximity" backoff period gzll_rx_start(); } }
bool gzll_tx_data(const uint8_t *src, uint8_t length, uint8_t pipe) { uint8_t temp_address[GZLL_ADDRESS_WIDTH]; uint16_t temp; uint32_t flag; ASSERT(length <= GZLL_MAX_FW_PAYLOAD_LENGTH && length > 0); ASSERT(pipe <= 5); /* Length check to prevent memory corruption. (Note, assertion will capture this as well). */ if(length == 0 || length > GZLL_MAX_FW_PAYLOAD_LENGTH) { return false; } gzll_current_tx_payload_length = length; if(gzll_state_var == GZLL_HOST_ACTIVE) { gzll_goto_idle(); } flag = gzll_interupts_save(); /* If the specified pipe is different from the previous TX pipe, the TX setup must be updated */ if(pipe != gzll_current_tx_pipe) { gzll_current_tx_pipe = pipe; gzll_tx_setup_modified = true; } /* Here, state can be GZLL_IDLE or GZLL_DEVICE_ACTIVE */ if(gzll_state_var == GZLL_IDLE) { if(gzll_tx_setup_modified) // TX setup has to be restored? { gzll_tx_setup_modified = false; gzll_rx_setup_modified = true; hal_nrf_set_operation_mode(HAL_NRF_PTX); hal_nrf_open_pipe(HAL_NRF_PIPE0, EN_AA); //Read out the full RX address for pipe number "pipe" if(pipe == HAL_NRF_PIPE0) { hal_nrf_set_address(HAL_NRF_TX, gzll_p0_adr); hal_nrf_set_address(HAL_NRF_PIPE0, gzll_p0_adr); } else { //lint -esym(550,bytes_in_buffer) "variable not accessed" //lint -esym(438,bytes_in_buffer) "last assigned value not used" uint8_t bytes_in_buffer; bytes_in_buffer = hal_nrf_get_address(HAL_NRF_PIPE1, temp_address); if(pipe != HAL_NRF_PIPE1) { switch(pipe) { default: case HAL_NRF_PIPE2: bytes_in_buffer = hal_nrf_get_address(HAL_NRF_PIPE2, temp_address); break; case HAL_NRF_PIPE3: bytes_in_buffer = hal_nrf_get_address(HAL_NRF_PIPE3, temp_address); break; case HAL_NRF_PIPE4: bytes_in_buffer = hal_nrf_get_address(HAL_NRF_PIPE4, temp_address); break; case HAL_NRF_PIPE5: bytes_in_buffer = hal_nrf_get_address(HAL_NRF_PIPE5, temp_address); break; } bytes_in_buffer = bytes_in_buffer; } //Here, temp_address will contain the full TX address hal_nrf_set_address(HAL_NRF_PIPE0, temp_address); hal_nrf_set_address(HAL_NRF_TX, temp_address); /* Change seed for random generator. Will prevent different devices transmitting to the same host from using the same channel hopping sequence. */ //lint -esym(534, gzll_lfsr_get) "return value ignored" gzll_lfsr_get(pipe, 1); } } // Prepare for new transmission gzll_timeout_counter = 0; gzll_channel_switch_counter = 0; gzll_try_counter = 0; hal_nrf_flush_tx(); GZLL_UPLOAD_PAYLOAD_TO_RADIO(); gzll_tx_success_f = false; // Transmission by default "failure" temp = gzll_dyn_params[GZLL_PARAM_DEVICE_MODE]; gzll_set_radio_power_on(true); if(gzll_sync_on) { switch(temp) { case GZLL_DEVICE_MODE_2: default: gzll_start_new_tx(GZLL_CHANNEL_PREVIOUS_SUCCESS); break; case GZLL_DEVICE_MODE_3: gzll_start_new_tx(GZLL_CHANNEL_RANDOM); break; case GZLL_DEVICE_MODE_4: gzll_start_new_tx(GZLL_CHANNEL_ESTIMATED); break; } } else { switch(temp) { case GZLL_DEVICE_MODE_0: case GZLL_DEVICE_MODE_2: gzll_start_new_tx(GZLL_CHANNEL_PREVIOUS_SUCCESS); break; default: gzll_start_new_tx(GZLL_CHANNEL_RANDOM); break; } } gzll_state_var = GZLL_DEVICE_ACTIVE; gzll_interupts_restore(flag); return true; // Payload successfully written to TX FIFO } else // Else TRANSMIT state { /* Check if criteria for starting new transmission when already transmitting is fulfilled */ if(!gzll_tx_setup_modified && !hal_nrf_tx_fifo_full() ) { GZLL_UPLOAD_PAYLOAD_TO_RADIO(); gzll_interupts_restore(flag); return true; // Payload successfully written to TX FIFO } else { gzll_interupts_restore(flag); return false; // Payload not written to TX FIFO } } }
void app_execute(uint8_t buttons) { static xdata main_menu = 0; xdata uint8_t lcd_line0[17], lcd_line1[17], i; /*----------------------------------------------------------------------------- Evaluate menu independent buttons -----------------------------------------------------------------------------*/ if(buttons & (MAIN_MENU_INC | MAIN_MENU_DEC)) { if(buttons & MAIN_MENU_INC) { main_menu = inc_mod(main_menu, MM_LAST_PAGE - 1); } if(buttons & MAIN_MENU_DEC) { main_menu = dec_mod(main_menu, MM_LAST_PAGE - 1); } lcd_update(main_menu_header[main_menu], " "); delay_ms(DELAY_SHORT_MESSAGE); } if(buttons & RUN_STOP) { if(radio_run) { radio_run = false; gzll_goto_idle(); lcd_update(MESSAGE_STOP_L0, MESSAGE_STOP_L1); delay_ms(DELAY_SHORT_MESSAGE); } else { if(!device_mode) { gzll_rx_start(); } radio_run = true; lcd_update(MESSAGE_RUN_L0, MESSAGE_RUN_L1); delay_ms(DELAY_SHORT_MESSAGE); } } if(buttons & CLEAR_STATISTICS) { lcd_update(MESSAGE_STATISTICS_CLR_L0, MESSAGE_STATISTICS_CLR_L1); delay_ms(DELAY_SHORT_MESSAGE); for(i = 0; i < STATISTICS_SIZE; i++) { statistics[i] = 0; } } /*----------------------------------------------------------------------------- Run submenu dependent operations -----------------------------------------------------------------------------*/ switch(main_menu) { case MM_MODE_SELECT: mm_mode_select(lcd_line0, lcd_line1, buttons); break; case MM_TEST_APP_SETUP: mm_test_app_setup(lcd_line0, lcd_line1, buttons); break; case MM_GZLL_PARAMS: mm_gzll_params(lcd_line0, lcd_line1, buttons); break; case MM_STATISTICS: mm_statistics(lcd_line0, lcd_line1, buttons); break; case MM_CHANNEL_SETUP: mm_channel_setup(lcd_line0, lcd_line1, buttons); break; } lcd_update(lcd_line0, lcd_line1); }