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