return false;
  }
}

fap_modes_t fap_get_mode(void)
{
  return fap_mode;
}

bool fap_read_rx_fifo(fap_tx_rx_struct_t* return_struct)
{  
  uint16_t tempvalue;

  FAP_INTERRUPTS_DISABLE(); 
  
  if(fap_rx_dr_flag)
  {
    tempvalue = hal_nrf_read_rx_pload(&(return_struct -> pl[0])); 
    FAP_INTERRUPTS_ENABLE();          
    
    return_struct -> pipe=(uint8_t)(tempvalue>>8);   // MSByte, pipe
    return_struct -> pl_length=(uint8_t)(tempvalue); // LSByte=length       
    
    if(hal_nrf_rx_fifo_empty())
    {
      fap_rx_dr_flag = false;
    }
    
    return true;
  }
  else
  {
    FAP_INTERRUPTS_ENABLE();  
    return false;
  }
}

bool fap_tx_success(void)
{
  return FAP_GET_BIT(fap_status, FAP_TX_SUCCESS);
}

bool fap_select_radio_idle_mode(fap_radio_idle_modes_t mode)
{
  if(fap_mode==FAP_IDLE)
  {
    FAP_INTERRUPTS_DISABLE();
 
    if(mode == FAP_PDOWN_IDLE)
    {
      FAP_SET_BIT(fap_status, FAP_PDOWN_IDLE_EN);
  
      if(fap_mode==FAP_IDLE)
      {
        hal_nrf_set_power_mode(HAL_NRF_PWR_DOWN);
        FAP_CLEAR_BIT(fap_status, FAP_RADIO_PWR_UP);
      }
    }
    else
    {
      FAP_CLEAR_BIT(fap_status, FAP_PDOWN_IDLE_EN);  
    
      // Update radio power mode if FAP is in idle mode
      hal_nrf_set_power_mode(HAL_NRF_PWR_UP);
      FAP_SET_BIT(fap_status, FAP_RADIO_PWR_UP);
    }
    
    FAP_INTERRUPTS_ENABLE();
    
    return true;
  }
  else
  {
    return false;
  }
}

uint16_t fap_get_tries(void)
{
  return fap_try_counter;
}

uint16_t fap_get_ch_switches(void)
{
  return  fap_ch_switch_counter;
}

void fap_ch_sync_enable()
{ 
  FAP_INTERRUPTS_DISABLE();

  FAP_SET_BIT(fap_status, FAP_CH_SYNC_EN);

  FAP_INTERRUPTS_ENABLE();
}

void fap_ch_sync_disable()
{
  FAP_INTERRUPTS_DISABLE();

  FAP_CLEAR_BIT(fap_status, FAP_CH_SYNC_EN);

  FAP_INTERRUPTS_ENABLE();
}
 
uint8_t fap_get_ch_offset()
{
  int8_t sync_var;
  
  FAP_INTERRUPTS_DISABLE();
  
  sync_var = (fap_ch_tab_idx_tx - fap_rx_channel_guess); 
  
  if(FAP_GET_BIT(fap_status, FAP_PDOWN_IDLE_EN))
  {
    sync_var -= FAP_RADIO_PWR_UP_DELAY; 
  }
   
  if(sync_var < 0)
  {
    sync_var += FAP_CH_TAB_SIZE;
  }
  
  FAP_INTERRUPTS_ENABLE();  
  
  return sync_var;   
}

void fap_nrf_isr_function(void)
{
  static uint8_t random_seed;

  FAP_TIMER_IRQ_DISABLE();                      

  fap_general_byte=hal_nrf_get_irq_flags(); // Get/clear IRQ flags
  
  if(fap_mode != FAP_IDLE)
  {
    if(fap_general_byte & ((1<<MAX_RT)))
    {
      fap_try_counter += (FAP_NRF_AUTO_RETRIES+1);
        
      fap_retry_extend_counter= (fap_retry_extend_counter+1) % FAP_AUTO_RETRIES_EXTEND;
    
      if(fap_retry_extend_counter==0)
      {
        if(((fap_ch_switch_counter+1)%FAP_CH_TAB_SIZE) == 0)
        { 
          fap_ch_tab_idx_tx = fap_lfsr_get(random_seed, FAP_CH_TAB_SIZE);  
        }
        else
        {
          fap_ch_tab_idx_tx = fap_lfsr_get(0, FAP_CH_TAB_SIZE);    
        }   
        
        CE_LOW();                      
        hal_nrf_set_rf_channel(fap_ch_tab[fap_ch_tab_idx_tx]);                  
        fap_ch_switch_counter++;
      }

      fap_latency_counter -= (FAP_NRF_AUTO_RETRIES+1); 
      if(fap_latency_counter<1 && !FAP_GET_BIT(fap_status, FAP_TX_RX_INFINITE_TIMEOUT_EN))    
      {
        FAP_CLEAR_BIT(fap_status, FAP_TX_SUCCESS);
        CE_LOW();
        hal_nrf_clear_irq_flag(MAX_RT); 
        fap_set_system_idle();
      }
      else
      {
        hal_nrf_clear_irq_flag(MAX_RT);
        CE_HIGH();                     
      }
    }
    else
    {
      if(fap_general_byte & ((1<<TX_DS)))
      {
        hal_nrf_clear_irq_flag(TX_DS);
        if(fap_mode==FAP_TRANSMITTING) 
        { 
       
           // Adjusts "guess counter" 
          fap_rx_channel_guess = (fap_ch_tab_idx_tx + 1) % FAP_CH_TAB_SIZE;                  
          fap_modify_timer_period();
        
          // Get number of tries. Add 1 for 1st attempt.                   
          fap_try_counter += (hal_nrf_get_transmit_attempts()+1);  
        
          // Get "random" seed fom number of sent packages
          // Used when altering channel search order
          random_seed = random_seed+fap_try_counter;  
             
          FAP_SET_BIT(fap_status, FAP_TX_SUCCESS);
       
          if(hal_nrf_tx_fifo_empty())
          {
            fap_set_system_idle();
          }
          else
          {
            fap_retry_extend_counter = 0;
            fap_try_counter = 0;
            fap_latency_counter = fap_latency_setup;
          }
                                             
          // Get "random" seed fom number of sent packages
          // Used when altering channel search order             
        } 
      }

      if(fap_general_byte & ((1<<RX_DR)))
      {
        hal_nrf_clear_irq_flag(RX_DR);
        fap_rx_dr_flag = true;
        fap_hold_rx_channel = FAP_RX_CH_HOLD_PERIODS;  // Applies in RX mode only
      }
    }     
  }
  
  FAP_TIMER_IRQ_ENABLE();  
}

void fap_timer_isr_function(void)
{
  FAP_NRF_IRQ_DISABLE();                    
  
  if(fap_mode==FAP_TRANSMITTING) 
  { 
    if(fap_radio_startup_counter>0)      
    {
      fap_radio_startup_counter--;
    }
    else
    if(FAP_GET_BIT(fap_status, FAP_START_NEW_TX))
    {
      CE_HIGH();                             
      FAP_CLEAR_BIT(fap_status, FAP_START_NEW_TX);
    }     
  }
  else  
  if(fap_mode==FAP_RECEIVING)
  {   
    if(FAP_GET_BIT(fap_status, FAP_TX_RX_INFINITE_TIMEOUT_EN) || (!FAP_GET_BIT(fap_status, FAP_TX_RX_INFINITE_TIMEOUT_EN) && fap_latency_counter>0))
    {     
      fap_latency_counter--;
      if(!FAP_GET_BIT(fap_status, FAP_LP_RX_EN))    
      {  
        fap_ch_tab_idx_rx = (fap_ch_tab_idx_rx+1) % FAP_CH_TAB_SIZE;             
          
        if(fap_hold_rx_channel == 0)
        {     
          CE_LOW();
          hal_nrf_set_rf_channel(fap_ch_tab[fap_ch_tab_idx_rx]);   
          CE_HIGH();
        }
        else
        {
          fap_hold_rx_channel--;
        } 
      } 
      else
      {
        if(fap_timer_period==0)
        {
          // Change channel
          if(fap_timer_period==0) 
          {
            fap_ch_tab_idx_rx = (fap_ch_tab_idx_rx+1) % FAP_CH_TAB_SIZE;          
            hal_nrf_set_rf_channel(fap_ch_tab[fap_ch_tab_idx_rx]);
          }
          hal_nrf_set_power_mode(HAL_NRF_PWR_UP);
          FAP_SET_BIT(fap_status, FAP_RADIO_PWR_UP);
        }

        if(fap_timer_period==FAP_RX_FULL_CH_REV)
        {
          CE_LOW();
          hal_nrf_set_power_mode(HAL_NRF_PWR_DOWN);
          FAP_CLEAR_BIT(fap_status, FAP_RADIO_PWR_UP);
        }

        if(fap_timer_period < FAP_RX_FULL_CH_REV)
        {
          // RX on
          if( ( (fap_timer_period-FAP_RADIO_PWR_UP_DELAY) % FAP_RX_SINGLE_CH_REV) == 0)          
          {
            CE_HIGH();    
          }
          // RX off  
          if( ( (fap_timer_period-FAP_RADIO_PWR_UP_DELAY-FAP_LP_RX_LISTEN_PERIODS) % FAP_RX_SINGLE_CH_REV) == 0) 
          {
            CE_LOW();
          }
        }
      }
    }
    else
    {
      fap_set_system_idle();  
    }
    
    if(FAP_GET_BIT(fap_status, FAP_LP_RX_EN))     
    {
      fap_timer_period = (fap_timer_period + 1) % FAP_LP_RX_POLL_PERIOD;
    }
    else
    {
      fap_timer_period = (fap_timer_period + 1) % FAP_CH_TAB_SIZE;
    }
  } 
  fap_rx_channel_guess = (fap_rx_channel_guess + 1) % FAP_CH_TAB_SIZE;
  
  FAP_NRF_IRQ_ENABLE();                      
}

void fap_flush_rx_fifo(void)
{
    FAP_INTERRUPTS_DISABLE();

    hal_nrf_flush_rx();

    fap_rx_dr_flag = false;

    FAP_INTERRUPTS_ENABLE();
}

void fap_goto_idle_mode()
{
  FAP_INTERRUPTS_DISABLE();

  FAP_CLEAR_BIT(fap_status, FAP_TX_RX_INFINITE_TIMEOUT_EN);
  
  FAP_INTERRUPTS_ENABLE();

  fap_latency_counter=0; 
  while(fap_mode!=FAP_IDLE);
}

//***************************************************************************** 
// Function bodies, internal
//*****************************************************************************

static uint8_t fap_lfsr_get(uint8_t seed, uint8_t max_limit)
{
  static uint8_t pseudoreg=0xff; // Can never be zero  
  uint8_t shiftbit;
  
  if(seed > 0)
  {
    pseudoreg = seed;      
  }
      
  shiftbit = (pseudoreg << 7) & 0x80;
  shiftbit ^= (pseudoreg << 6) & 0x80;
  shiftbit ^= (pseudoreg << 5) & 0x80;
  shiftbit ^= (pseudoreg & 0x80);
    
  pseudoreg = (shiftbit | (pseudoreg >> 1));      

  return pseudoreg % max_limit;
}

static void fap_set_system_idle(void)
{ 
  CE_LOW();
  fap_mode=FAP_IDLE;
  if(FAP_GET_BIT(fap_status, FAP_PDOWN_IDLE_EN))
  {
    hal_nrf_set_power_mode(HAL_NRF_PWR_DOWN);
    FAP_CLEAR_BIT(fap_status, FAP_RADIO_PWR_UP);
  }  
}

/**
@}
*/