static void read_mouse_and_send(void) { //lint -save -e514 Unusual use of a boolean expression (use of &= assignment). bool mouse_send_ok; // If the "mouse sensor" has data ready for read-out. if(mouse_sensor_data_is_ready()) { uint8_t mouse_packet[NRFR_MOUSE_MOV_PACKET_LENGTH]; // Get packet from "mouse sensor". if(mouse_sensor_read(mouse_packet)) { // Wait in case the FIFOs are full. while(!nrf_gzll_ok_to_add_packet_to_tx_fifo(NRFR_MOUSE_EP)) {} // Add mouse packet to the mouse pipe's TX FIFO. mouse_send_ok = nrf_gzll_add_packet_to_tx_fifo(NRFR_MOUSE_EP, mouse_packet, NRFR_MOUSE_MOV_PACKET_LENGTH); if(!mouse_send_ok) { /* Adding packet to the TX FIFO failed. Use nrf_gzll_get_error_code() to investigate the cause. */ } } } //lint -restore }
/**@brief Callback on Gazell Transmit failed. Resends the current packet. */ void nrf_gzll_device_tx_failed(uint32_t pipe, nrf_gzll_device_tx_info_t tx_info) { bool push_ok; uint8_t dummy[NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH]; uint32_t dummy_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH; // If the transmission failed, send a new packet. nrf_gpio_pin_set(GZLL_TX_FAIL_LED_PIN_NO); nrf_gpio_pin_clear(GZLL_TX_SUCCESS_LED_PIN_NO); if (tx_info.payload_received_in_ack) { // if data received attached to the ack, pop them. push_ok = nrf_gzll_fetch_packet_from_rx_fifo(pipe, dummy, &dummy_length); if (!push_ok) { GET_GAZELL_ERROR(); } } push_ok = nrf_gzll_add_packet_to_tx_fifo(0, gzll_packet, PAYLOAD_SIZE); if (!push_ok) { GET_GAZELL_ERROR(); } }
/**@brief Callback function for Gazell Transmit fail. Resends the current packet. */ void nrf_gzll_device_tx_failed(uint32_t pipe, nrf_gzll_device_tx_info_t tx_info) { bool push_ok; uint8_t dummy[NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH]; uint32_t dummy_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH; uint32_t err_code; // If the transmission failed, send a new packet. err_code = bsp_indication_set(BSP_INDICATE_SEND_ERROR); APP_ERROR_CHECK(err_code); if (tx_info.payload_received_in_ack) { // if data received attached to the ack, pop them. push_ok = nrf_gzll_fetch_packet_from_rx_fifo(pipe, dummy, &dummy_length); if (!push_ok) { GET_GAZELL_ERROR(); } } push_ok = nrf_gzll_add_packet_to_tx_fifo(0, m_gzll_packet, PAYLOAD_SIZE); if (!push_ok) { GET_GAZELL_ERROR(); } }
bool RFduinoGZLL_send_to_device(device_t device, const char *data, int len) { if (_device != HOST) return false; return nrf_gzll_add_packet_to_tx_fifo(device, data, len); }
/**@brief Start Gazell functionality. */ void gzll_app_start(void) { bool gzll_call_ok; gzll_call_ok = nrf_gzll_init(NRF_GZLL_MODE_DEVICE); if (!gzll_call_ok) { GET_GAZELL_ERROR(); } gzll_call_ok = nrf_gzll_set_max_tx_attempts(MAX_TX_ATTEMPTS); if (!gzll_call_ok) { GET_GAZELL_ERROR(); } gzll_call_ok = nrf_gzll_enable(); if (!gzll_call_ok) { GET_GAZELL_ERROR(); } // Add a packet to the TX FIFO to start the data transfer. // From here on more data will be added through the Gazell callbacks gzll_packet[0] = DUMMY_PACKET; gzll_call_ok = nrf_gzll_add_packet_to_tx_fifo(0, gzll_packet, PAYLOAD_SIZE); if (!gzll_call_ok) { GET_GAZELL_ERROR(); } }
static void read_mouse_and_send(void) { //lint -save -e514 Unusual use of a boolean expression (use of &= assignment). bool mouse_send_ok; // If the "mouse sensor" has data ready for read-out. if(mouse_sensor_data_is_ready()) { uint8_t mouse_packet[NRFR_MOUSE_MOV_PACKET_LENGTH]; // Get packet from "mouse sensor". if(mouse_sensor_read(mouse_packet)) { // Wait in case the FIFOs are full. while(!nrf_gzll_ok_to_add_packet_to_tx_fifo(NRFR_MOUSE_EP)) {} // Add mouse packet to the mouse pipe's TX FIFO. mouse_send_ok = nrf_gzll_add_packet_to_tx_fifo(NRFR_MOUSE_EP, mouse_packet, NRFR_MOUSE_MOV_PACKET_LENGTH); if (mouse_send_ok) { printf("Mouse sent OK\n"); } else { printf("Mouse sent FAILED\n"); } } } //lint -restore }
/* If the transmission failed, send a new packet. * This callback does not occur by default since NRF_GZLL_DEFAULT_MAX_TX_ATTEMPTS * is 0 (inifinite retransmits) */ void nrf_gzll_device_tx_failed(uint32_t pipe, nrf_gzll_device_tx_info_t tx_info) { tx_success = false; // Load data into TX queue data_payload[0] = input_get(); push_ok = nrf_gzll_add_packet_to_tx_fifo(pipe, data_payload, TX_PAYLOAD_LENGTH); }
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(); }
bool RFduinoGZLL_send_to_host(const char *data, int len) { if (_device == HOST) return false; // a zero byte load is valid, but data must be non-null if (!data && !len) data = &_device; return nrf_gzll_add_packet_to_tx_fifo(_device, data, len); }
/**@brief Callback function for Gazell Transmit Success. Transmits next packet. */ void nrf_gzll_device_tx_success(uint32_t pipe, nrf_gzll_device_tx_info_t tx_info) { bool push_ok; static int cpt = 0; uint8_t dummy[NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH]; uint32_t dummy_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH; uint32_t err_code; // If an ACK was received, we send another packet. err_code = bsp_indication_set(BSP_INDICATE_SENT_OK); APP_ERROR_CHECK(err_code); if (tx_info.payload_received_in_ack) { // if data received attached to the ack, pop them. push_ok = nrf_gzll_fetch_packet_from_rx_fifo(pipe, dummy, &dummy_length); if (!push_ok) { GET_GAZELL_ERROR(); } } cpt++; if (cpt > NB_TX_WITH_SAME_PAYLOAD) { cpt = 0; m_gzll_packet[0] = ~(m_gzll_packet[0]); if (m_gzll_packet[0] == DUMMY_PACKET) { m_gzll_packet[0] = 0x00; } m_gzll_packet[0] <<= 1; if (m_gzll_packet[0] == 0) { m_gzll_packet[0]++; } m_gzll_packet[0] = ~(m_gzll_packet[0]); } push_ok = nrf_gzll_add_packet_to_tx_fifo(0, m_gzll_packet, PAYLOAD_SIZE); if (!push_ok) { GET_GAZELL_ERROR(); } }
// If a data packet was received, we write the first byte to LEDS. void nrf_gzll_host_rx_data_ready(uint32_t pipe, nrf_gzll_host_rx_info_t rx_info) { uint32_t data_payload_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH; packet_received = true; // Pop packet and write first byte of the payload to the GPIO port. pop_ok = nrf_gzll_fetch_packet_from_rx_fifo(pipe, data_payload, &data_payload_length); if (data_payload_length > 0) { nrf_gpio_port_write(LEDS,~data_payload[0]); } // Read buttons and load ACK payload into TX queue ack_payload[0] = nrf_gpio_port_read(BUTTONS); // Button logic is inverted. push_ok = nrf_gzll_add_packet_to_tx_fifo(pipe, ack_payload, TX_PAYLOAD_LENGTH); }
static bool gzp_tx_packet(const uint8_t* tx_packet, uint8_t length, uint8_t pipe) { tx_complete = false; tx_success = false; if(nrf_gzll_add_packet_to_tx_fifo(pipe,(uint8_t *)tx_packet, length)) { while(tx_complete == false) { __WFI(); } return tx_success; } else { return false; } }
/**@brief Callback on Gazell Transmit Success. Transmits next packet. */ void nrf_gzll_device_tx_success(uint32_t pipe, nrf_gzll_device_tx_info_t tx_info) { bool push_ok; static int cpt = 0; uint8_t dummy[NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH]; uint32_t dummy_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH; // If an ACK was received, we send another packet. nrf_gpio_pin_set(GZLL_TX_SUCCESS_LED_PIN_NO); nrf_gpio_pin_clear(GZLL_TX_FAIL_LED_PIN_NO); if (tx_info.payload_received_in_ack) { // if data received attached to the ack, pop them. push_ok = nrf_gzll_fetch_packet_from_rx_fifo(pipe, dummy, &dummy_length); if (!push_ok) { GET_GAZELL_ERROR(); } } cpt++; if (cpt > NB_TX_WITH_SAME_PAYLOAD) { cpt = 0; gzll_packet[0] = ~(gzll_packet[0]); if (gzll_packet[0] == DUMMY_PACKET) { gzll_packet[0] = 0x00; } gzll_packet[0] <<= 1; if (gzll_packet[0] == 0) { gzll_packet[0]++; } gzll_packet[0] = ~(gzll_packet[0]); } push_ok = nrf_gzll_add_packet_to_tx_fifo(0, gzll_packet, PAYLOAD_SIZE); if (!push_ok) { GET_GAZELL_ERROR(); } }
// If an ACK was received, we send another packet. void nrf_gzll_device_tx_success(uint32_t pipe, nrf_gzll_device_tx_info_t tx_info) { uint32_t ack_payload_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH; tx_success = true; if (tx_info.payload_received_in_ack) { // Pop packet and write first byte of the payload to the GPIO port. pop_ok = nrf_gzll_fetch_packet_from_rx_fifo(pipe, ack_payload, &ack_payload_length); if (ack_payload_length > 0) { nrf_gpio_port_write(LEDS, ~ack_payload[0]); // Button press is active low. } } // Read buttons and load data payload into TX queue data_payload[0] = nrf_gpio_port_read(BUTTONS); push_ok = nrf_gzll_add_packet_to_tx_fifo(pipe, data_payload, TX_PAYLOAD_LENGTH); }
// If an ACK was received, we send another packet. void nrf_gzll_device_tx_success(uint32_t pipe, nrf_gzll_device_tx_info_t tx_info) { uint32_t ack_payload_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH; tx_success = true; if (tx_info.payload_received_in_ack) { // Pop packet and write first byte of the payload to the GPIO port. pop_ok = nrf_gzll_fetch_packet_from_rx_fifo(pipe, ack_payload, &ack_payload_length); if (ack_payload_length > 0) { output_present(ack_payload[0]); } } // Read buttons and load data payload into TX queue data_payload[0] = input_get(); push_ok = nrf_gzll_add_packet_to_tx_fifo(pipe, data_payload, TX_PAYLOAD_LENGTH); }
int main() { uint8_t debug_led_output; // Setup user interface (buttons and LEDs) ui_init(); // Initialize Gazell init_ok = nrf_gzll_init(NRF_GZLL_MODE_DEVICE); // Attempt sending every packet up to 100 times init_ok &= nrf_gzll_set_max_tx_attempts(100); // Load data into TX queue data_payload[0] = input_get(); push_ok = nrf_gzll_add_packet_to_tx_fifo(PIPE_NUMBER, data_payload, TX_PAYLOAD_LENGTH); // Enable Gazell to start sending over the air enable_ok = nrf_gzll_enable(); while(1) { // Error handling debug_led_output = ((uint8_t)tx_success << 4) | ((uint8_t)pop_ok << 3) | ((uint8_t)push_ok << 2) | ((uint8_t)enable_ok << 1) | (uint8_t)init_ok; // If an error has occured if(debug_led_output != 0x1F) { output_present(0xFF); nrf_delay_us(1000000); // 1 second delay output_present(0xFF); nrf_delay_us(1000000); // 1 second delay output_present(0xFF); //nrf_gzll_get_error_code()); nrf_delay_us(1000000); // 1 second delay } // Optionally send the CPU to sleep while waiting for a callback. // __WFI(); } }
int main() { uint8_t debug_led_output; // Setup port directions nrf_gpio_port_dir_set(BUTTONS, NRF_GPIO_PORT_DIR_INPUT); nrf_gpio_port_dir_set(LEDS, NRF_GPIO_PORT_DIR_OUTPUT); // Initialize Gazell init_ok = nrf_gzll_init(NRF_GZLL_MODE_DEVICE); // Attempt sending every packet up to 100 times init_ok &= nrf_gzll_set_max_tx_attempts(100); // Load data into TX queue data_payload[0] = nrf_gpio_port_read(BUTTONS); push_ok = nrf_gzll_add_packet_to_tx_fifo(PIPE_NUMBER, data_payload, TX_PAYLOAD_LENGTH); // Enable Gazell to start sending over the air enable_ok = nrf_gzll_enable(); while(1) { // Error handling debug_led_output = ((uint8_t)tx_success << 4) | ((uint8_t)pop_ok << 3) | ((uint8_t)push_ok << 2) | ((uint8_t)enable_ok << 1) | (uint8_t)init_ok; // If an error has occured if(debug_led_output != 0x1F) { nrf_gpio_port_write(LEDS,0xFF); nrf_delay_us(1000000); // 1 second delay nrf_gpio_port_write(LEDS, debug_led_output); nrf_delay_us(1000000); // 1 second delay nrf_gpio_port_write(LEDS,0xF0 + (uint32_t)nrf_gzll_get_error_code()); nrf_delay_us(1000000); // 1 second delay } // Optionally send the CPU to sleep while waiting for a callback. // __WFI(); } }
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(); } }