示例#1
0
// 0 = success
// 1 = init failed
// 2 = set tx_power failed
// 3 = enabled failed
int RFduinoGZLL_begin(device_t device)
{
  _device = device;

  if (! nrf_gzll_init(device == HOST ? NRF_GZLL_MODE_HOST : NRF_GZLL_MODE_DEVICE))
    return 1;

  nrf_gzll_tx_power_t tx_power;
  if (RFduinoGZLL_tx_power_level <= -20)
    tx_power = NRF_GZLL_TX_POWER_N20_DBM;
  else if (RFduinoGZLL_tx_power_level <= -16)
    tx_power = NRF_GZLL_TX_POWER_N16_DBM;
  else if (RFduinoGZLL_tx_power_level <= -12)
    tx_power = NRF_GZLL_TX_POWER_N12_DBM;
  else if (RFduinoGZLL_tx_power_level <= -16)
    tx_power = NRF_GZLL_TX_POWER_N16_DBM;
  else if (RFduinoGZLL_tx_power_level <= -8)
    tx_power = NRF_GZLL_TX_POWER_N8_DBM;
  else if (RFduinoGZLL_tx_power_level <= -4)
    tx_power = NRF_GZLL_TX_POWER_N4_DBM;
  else if (RFduinoGZLL_tx_power_level <= 0)
    tx_power = NRF_GZLL_TX_POWER_0_DBM;
  else
    tx_power = NRF_GZLL_TX_POWER_4_DBM;

  if (! nrf_gzll_set_tx_power(tx_power))
    return 2;

  if (! nrf_gzll_enable())
    return 3;

  return 0;
}
/**@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();
    }
}
示例#3
0
// 0 = success
// 1 = init failed
// 2 = set tx_power failed
// 3 = enabled failed
// 4 = set channel selection policy failed
int RFduinoGZLL_begin(device_t device)
{
  _device = device;

  if (! nrf_gzll_init(device == HOST ? NRF_GZLL_MODE_HOST : NRF_GZLL_MODE_DEVICE))
    return 1;

  nrf_gzll_tx_power_t tx_power;
  if (RFduinoGZLL_tx_power_level <= -20)
    tx_power = NRF_GZLL_TX_POWER_N20_DBM;
  else if (RFduinoGZLL_tx_power_level <= -16)
    tx_power = NRF_GZLL_TX_POWER_N16_DBM;
  else if (RFduinoGZLL_tx_power_level <= -12)
    tx_power = NRF_GZLL_TX_POWER_N12_DBM;
  else if (RFduinoGZLL_tx_power_level <= -16)
    tx_power = NRF_GZLL_TX_POWER_N16_DBM;
  else if (RFduinoGZLL_tx_power_level <= -8)
    tx_power = NRF_GZLL_TX_POWER_N8_DBM;
  else if (RFduinoGZLL_tx_power_level <= -4)
    tx_power = NRF_GZLL_TX_POWER_N4_DBM;
  else if (RFduinoGZLL_tx_power_level <= 0)
    tx_power = NRF_GZLL_TX_POWER_0_DBM;
  else
    tx_power = NRF_GZLL_TX_POWER_4_DBM;

  if (! nrf_gzll_set_tx_power(tx_power))
    return 2;

  if (! nrf_gzll_set_device_channel_selection_policy(NRF_GZLL_DEVICE_CHANNEL_SELECTION_POLICY_USE_CURRENT))
    return 4;
 
  if (RFduinoGZLL_host_base_address ) {
   uint8_t msb = RFduinoGZLL_host_base_address >> 24;
   if (msb == 0x55 || msb == 0xAA)
     return 5;  // msb of base address should not be alternating 0s and 1s
	 if ( !nrf_gzll_set_base_address_0(RFduinoGZLL_host_base_address) )
		return 5;
  } 

  if (RFduinoGZLL_device_base_address) {
   uint8_t msb = RFduinoGZLL_device_base_address >> 24;
   if (msb == 0x55 || msb == 0xAA)
     return 6;  // msb of base address should not be alternating 0s and 1s
	 if ( !nrf_gzll_set_base_address_1(RFduinoGZLL_device_base_address) )
		return 6;
  }
	
  if (! nrf_gzll_enable())
    return 3;

  RFduinoGZLL_enabled = 1;

  return 0;
}
示例#4
0
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();    
  }
}
示例#5
0
int main(void)
{
    // Debug helper variables
    uint32_t length;

    // Data and acknowledgement payloads
    uint8_t payload[NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH]; ///< Payload to send to Host. 

    // Setup user interface (buttons and LEDs)
    ui_init();

    // Initialize Gazell Link Layer
    (void)nrf_gzll_init(NRF_GZLL_MODE_HOST);
    (void)nrf_gzll_set_timeslot_period(NRF_GZLLDE_RXPERIOD_DIV_2);  // Half RX period on nRF24Lxx device
    
    // Initialize Gazell Pairing Library
    gzp_init();
    (void)nrf_gzll_set_rx_pipes_enabled(nrf_gzll_get_rx_pipes_enabled() | (1 << UNENCRYPTED_DATA_PIPE));
    gzp_pairing_enable(true);

    (void)nrf_gzll_enable();

    for(;;)
    {
        gzp_host_execute();

        // If Host ID request received
        if(gzp_id_req_received())
        {
            // Always grant request
            gzp_id_req_grant();
        }

        length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH;
        
        if( nrf_gzll_get_rx_fifo_packet_count(UNENCRYPTED_DATA_PIPE) )
        {
            if(nrf_gzll_fetch_packet_from_rx_fifo(UNENCRYPTED_DATA_PIPE, payload, &length))
            {
                output_present(payload[0]);
            }
        }
        else if (gzp_crypt_user_data_received())
        {
            if(gzp_crypt_user_data_read(payload, (uint8_t*)&length))
            {
                output_present(payload[0]);
            }
        }
    }
}
示例#6
0
文件: nrf_gzp.c 项目: Abdellbar/nrf51
bool gzp_update_radio_params(const uint8_t* system_address)
{
    uint8_t i;
    uint8_t channels[NRF_GZLL_CONST_MAX_CHANNEL_TABLE_SIZE];
    uint32_t channel_table_size;
    uint32_t pairing_base_address_32, system_address_32;
    bool update_ok = true;
    bool gzll_enabled_state;

    gzll_enabled_state = nrf_gzll_is_enabled();

    // Configure "global" pairing address
    pairing_base_address_32 = (pairing_base_address[0])       + 
    ((uint32_t)pairing_base_address[1] <<  8) +
    ((uint32_t)pairing_base_address[2] << 16) +
    ((uint32_t)pairing_base_address[3] << 24) ;
    if(system_address != NULL)
    {
        system_address_32 = (system_address[0])       + 
        ((uint32_t)system_address[1] <<  8) +
        ((uint32_t)system_address[2] << 16) +
        ((uint32_t)system_address[3] << 24) ;
    }
    else
    { 
        return false;
    }

    nrf_gzp_disable_gzll();
    update_ok = update_ok && nrf_gzll_set_base_address_0(pairing_base_address_32);
    update_ok = update_ok && nrf_gzll_set_address_prefix_byte(GZP_PAIRING_PIPE, pairing_address_prefix_byte);
    update_ok = update_ok && nrf_gzll_set_base_address_1(system_address_32);

    // Configure address for pipe 1 - 5. Address byte set to equal pipe number.
    for(i = 1; i < NRF_GZLL_CONST_PIPE_COUNT; i++)
    {
        update_ok = update_ok && nrf_gzll_set_address_prefix_byte(i,i);
    }

    channel_table_size = nrf_gzll_get_channel_table_size();
    gzp_generate_channels(&channels[0], system_address, channel_table_size);

    // Write generated channel subset to Gazell Link Layer   
    update_ok = update_ok && nrf_gzll_set_channel_table(&channels[0], channel_table_size);
    if(gzll_enabled_state)
    {
        update_ok = update_ok && nrf_gzll_enable();
    }
    return update_ok;
}
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();
    }
}
示例#8
0
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();
    }
}
示例#9
0
static gzp_tx_rx_trans_result_t gzp_tx_rx_transaction(const uint8_t *tx_packet, uint8_t tx_length, uint8_t *rx_dst, uint32_t *rx_length, uint8_t pipe)
{

    gzp_tx_rx_trans_result_t retval;
    uint8_t fetch_packet[GZP_CMD_FETCH_RESP_PAYLOAD_LENGTH];
    bool tx_packet_success;
    bool fetch_success;
    uint32_t local_rx_length = GZP_MAX_ACK_PAYLOAD_LENGTH;
    uint32_t temp_lifetime;

    nrf_gzp_flush_rx_fifo(pipe);

    retval = GZP_TX_RX_FAILED_TO_SEND;
    
    (void)nrf_gzll_disable();
    while(nrf_gzll_is_enabled())
    {}
    temp_lifetime = nrf_gzll_get_sync_lifetime();
    (void)nrf_gzll_set_sync_lifetime(GZP_TX_RX_TRANS_DELAY * 3); // 3 = RXPERIOD * 2 + margin
    (void)nrf_gzll_enable();
        
    tx_packet_success = gzp_tx_packet(tx_packet, tx_length, pipe);
    
    if(tx_packet_success)
    {
        retval = GZP_TX_RX_NO_RESPONSE;

        nrf_gzp_flush_rx_fifo(pipe);

        fetch_packet[0] = (uint8_t)GZP_CMD_FETCH_RESP;

        gzp_tick_sleep_rx_periods(GZP_TX_RX_TRANS_DELAY);
        
        tx_packet_success = gzp_tx_packet(fetch_packet, GZP_CMD_FETCH_RESP_PAYLOAD_LENGTH, pipe);

        if(tx_packet_success)
        {
            if(nrf_gzll_get_rx_fifo_packet_count(pipe))
            {
                local_rx_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH;
                fetch_success = nrf_gzll_fetch_packet_from_rx_fifo(pipe, rx_dst, &local_rx_length);
            }
            else
            {
                fetch_success = false;
            }

            if(fetch_success)
            {
                retval = GZP_TX_RX_SUCCESS;
            }
            else
            {
                //print_string("GZP_TX_FETCH_FAILED\r\n");
            }
        }
        else
        {
            //print_string("GZP_TX_FETCH_NO_ACK\r\n");
        }
    }
    
    (void)nrf_gzll_disable();
    while(nrf_gzll_is_enabled())
    {}
    (void)nrf_gzll_set_sync_lifetime(temp_lifetime);
    (void)nrf_gzll_enable();
    
    return retval;
}
示例#10
0
bool gzp_address_req_send()
{
    //lint -save -e514 Unusual use of a Boolean expression (gzll_update_ok &= ...)
    uint8_t i;
    bool retval = false;
    bool success;
    uint8_t address_req[GZP_CMD_HOST_ADDRESS_REQ_PAYLOAD_LENGTH];
    uint8_t rx_payload[NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH];
    uint32_t rx_payload_length =  NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH;
    nrf_gzll_tx_power_t temp_power;
    uint32_t temp_max_tx_attempts;
    bool gzll_update_ok = true;


    // Store parameters that are temporarily changed
    temp_max_tx_attempts = nrf_gzll_get_max_tx_attempts();
    temp_power = nrf_gzll_get_tx_power();

    // Modify parameters
    nrf_gzp_disable_gzll();
    gzll_update_ok &= nrf_gzll_set_max_tx_attempts(GZP_REQ_TX_TIMEOUT);
    gzll_update_ok &= nrf_gzll_set_tx_power(GZP_POWER);

    // Flush RX FIFO
    gzll_update_ok &= nrf_gzll_flush_rx_fifo(GZP_PAIRING_PIPE);
    gzll_update_ok &= nrf_gzll_enable();
    // Build "request" packet
    address_req[0] = (uint8_t)GZP_CMD_HOST_ADDRESS_REQ;

    // Send a number of packets in order to broadcast that devices not within
    // close proximity must back off.
    for(i = 0; i < GZP_MAX_BACKOFF_PACKETS; i++)
    {
        success = gzp_tx_packet(address_req, GZP_CMD_HOST_ADDRESS_REQ_PAYLOAD_LENGTH, GZP_PAIRING_PIPE); 
        if(success)
        {
            nrf_gzp_flush_rx_fifo(GZP_PAIRING_PIPE);
        }
        else
        {
            break;
        }
    }

    gzp_delay_rx_periods(GZP_TX_ACK_WAIT_TIMEOUT);
    // Send message for fetching pairing response from host.
    address_req[0] = (uint8_t)GZP_CMD_HOST_ADDRESS_FETCH;

    success =  gzp_tx_packet(address_req, GZP_CMD_HOST_ADDRESS_REQ_PAYLOAD_LENGTH, GZP_PAIRING_PIPE);
    if(success  && latest_tx_info.payload_received_in_ack)
    {
        // If pairing response received
        if(nrf_gzll_get_rx_fifo_packet_count(GZP_PAIRING_PIPE) > 0)
        {
            rx_payload_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH;  //dummy placeholder
            if(nrf_gzll_fetch_packet_from_rx_fifo(GZP_PAIRING_PIPE, rx_payload, &rx_payload_length))
            {
                if(rx_payload[0] == (uint8_t)GZP_CMD_HOST_ADDRESS_RESP)
                {
                    memcpy(gzp_system_address, &rx_payload[GZP_CMD_HOST_ADDRESS_RESP_ADDRESS], GZP_SYSTEM_ADDRESS_WIDTH);
                    gzll_update_ok &= gzp_update_radio_params(&rx_payload[GZP_CMD_HOST_ADDRESS_RESP_ADDRESS]);
                    #ifndef GZP_NV_STORAGE_DISABLE
                    (void)gzp_params_store(false); // "False" indicates that only "system address" part of DB element will be stored
                    #endif
                    retval = true;
                }
            }
        }
    }
    else
    {
        gzp_delay_rx_periods(GZP_NOT_PROXIMITY_BACKOFF_RX_TIMEOUT - GZP_TX_ACK_WAIT_TIMEOUT);
    }
    gzp_delay_rx_periods(GZP_STEP1_RX_TIMEOUT);

    // Clean-up and restore parameters temporarily  modified
    nrf_gzp_disable_gzll();
    gzll_update_ok &= nrf_gzll_flush_rx_fifo(GZP_PAIRING_PIPE);
    gzll_update_ok &= nrf_gzll_flush_tx_fifo(GZP_PAIRING_PIPE);
    gzll_update_ok &= nrf_gzll_set_max_tx_attempts(temp_max_tx_attempts);
    gzll_update_ok &= nrf_gzll_set_tx_power(temp_power);
    gzll_update_ok &= nrf_gzll_enable();

    if(!gzll_update_ok)
    {
    /*
    The update of the Gazell parameters failed. Use nrf_gzll_get_error_code() 
    to investigate the cause.
    */
    }

    return retval;
    //lint -restore
}
int main()
{
     bool init_ok = false;
//lint -save -e514 Unusual use of a boolean expression (use of &= assignment).

    // Configure input pins
    nrf_gpio_pin_dir_set(BUTTON_SEND_MOUSE_DATA, NRF_GPIO_PIN_DIR_INPUT);
    nrf_gpio_pin_dir_set(BUTTON_SEND_KEYBOARD_DATA, NRF_GPIO_PIN_DIR_INPUT);
    nrf_gpio_port_dir_set(LED_PORT, NRF_GPIO_PORT_DIR_OUTPUT);

    // Initialize and enable "mouse sensor"
    init_ok = mouse_sensor_init(MOUSE_SENSOR_SAMPLE_PERIOD_8_MS);
    mouse_sensor_enable();

    // Initialize and enable Gazell
    init_ok &= nrf_gzll_init(NRF_GZLL_MODE_DEVICE);
    
    // Ensure Gazell parameters are configured.
    init_ok &= nrf_gzll_set_max_tx_attempts(150);
    init_ok &= nrf_gzll_set_device_channel_selection_policy(NRF_GZLLDE_DEVICE_CHANNEL_SELECTION_POLICY);
    init_ok &= nrf_gzll_set_timeslot_period(NRF_GZLLDE_RXPERIOD_DIV_2);
    init_ok &= nrf_gzll_set_sync_lifetime(0); // Asynchronous mode, more efficient for pairing.

    switch(gzp_get_pairing_status())    
    {
      case -2:
        host_id_received = false;
        system_addr_received = false;
        break;
      case -1: 
        host_id_received = false;
        system_addr_received = true;
        break;
      default:
        host_id_received = true;
        system_addr_received = true;
    }
    
    gzp_init();

    init_ok &= nrf_gzll_enable();

    if(init_ok)
    {
        while(1)
        {
            // If BUTTON_SEND_MOUSE_DATA button is pressed.
            if(nrf_gpio_pin_read(BUTTON_SEND_MOUSE_DATA) == 0)
            {
                read_mouse_and_send();
            }

            // If BUTTON_SEND_KEYBOARD_DATA button is pressed
            if(nrf_gpio_pin_read(BUTTON_SEND_KEYBOARD_DATA) == 0)
            {
                read_keyboard_and_send();
            }

            /*
            CPU sleep.
            We will wake up from all enabled interrupts, which here are the
            internal Gazell interrupts and the "mouse sensor" internal timer
            interrupt.
            */
            //__WFI();
            
        }
    }
    else
    {
        /*
        The initialization failed. Use nrf_gzll_get_error_code() 
        to investigate the cause.
        */
    }
//lint -restore
}
int main()
{
     bool init_ok = false;
     uint32_t err_code;
//lint -save -e514 Unusual use of a boolean expression (use of &= assignment).

    const app_uart_comm_params_t comm_params =
       {
           RX_PIN_NUMBER,
           TX_PIN_NUMBER,
           RTS_PIN_NUMBER,
           CTS_PIN_NUMBER,
           APP_UART_FLOW_CONTROL_ENABLED,
           false,
           UART_BAUDRATE_BAUDRATE_Baud38400
       };

    APP_UART_FIFO_INIT(&comm_params,
                          UART_RX_BUF_SIZE,
                          UART_TX_BUF_SIZE,
                          uart_error_handle,
                          APP_IRQ_PRIORITY_LOW,
                          err_code);

    (void)err_code;
    UNUSED_VARIABLE(bsp_init(BSP_INIT_BUTTONS,0,NULL));

    printf("Desktop emulator example\n");
    // Initialize and enable "mouse sensor"
    init_ok = mouse_sensor_init(MOUSE_SENSOR_SAMPLE_PERIOD_8_MS);
    mouse_sensor_enable();

    // Initialize and enable Gazell
    init_ok &= nrf_gzll_init(NRF_GZLL_MODE_DEVICE);
    
    // Ensure Gazell parameters are configured.
    init_ok &= nrf_gzll_set_max_tx_attempts(150);
    init_ok &= nrf_gzll_set_device_channel_selection_policy(NRF_GZLLDE_DEVICE_CHANNEL_SELECTION_POLICY);
    init_ok &= nrf_gzll_set_timeslot_period(NRF_GZLLDE_RXPERIOD_DIV_2);
    init_ok &= nrf_gzll_set_sync_lifetime(0); // Asynchronous mode, more efficient for pairing.

    switch(gzp_get_pairing_status())    
    {
      case -2:
        host_id_received = false;
        system_addr_received = false;
        break;
      case -1: 
        host_id_received = false;
        system_addr_received = true;
        break;
      default:
        host_id_received = true;
        system_addr_received = true;
    }
    
    gzp_init();

    init_ok &= nrf_gzll_enable();

    if(init_ok)
    {
        while(1)
        {
            // If BUTTON_SEND_MOUSE_DATA button is pressed.
            bool send_mouse_data_button_pressed;
            err_code = bsp_button_is_pressed(SEND_MOUSE_DATA_BUTTON_ID,&(send_mouse_data_button_pressed));
            if( send_mouse_data_button_pressed)
            {
                read_mouse_and_send();
            }
            else
            {
                //indicate mouse button not pressed
            }

            // If BUTTON_SEND_KEYBOARD_DATA button is pressed
            bool send_keyboard_data_button_pressed;
            err_code = bsp_button_is_pressed(SEND_KEYBOARD_DATA_BUTTON_ID,&(send_keyboard_data_button_pressed));
            if(send_keyboard_data_button_pressed)
            {
                read_keyboard_and_send();
            }
            else
            {
                //indicate keyboard button not pressed
            }

            error_report();
            /*
            CPU sleep.
            We will wake up from all enabled interrupts, which here are the
            internal Gazell interrupts and the "mouse sensor" internal timer
            interrupt.
            */
            //__WFI();
            
        }
    }
    else
    {
        /*
        The initialization failed. Use nrf_gzll_get_error_code() 
        to investigate the cause.
        */
    }
//lint -restore
}