srsRAN_4G/srsapps/ue/phy/test/ue_itf_test_prach.cc

/**
 *
 * \section COPYRIGHT
 *
 * Copyright 2013-2015 The srsLTE Developers. See the
 * COPYRIGHT file at the top-level directory of this distribution.
 *
 * \section LICENSE
 *
 * This file is part of the srsLTE library.
 *
 * srsLTE is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of
 * the License, or (at your option) any later version.
 *
 * srsLTE is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * A copy of the GNU Affero General Public License can be found in
 * the LICENSE file in the top-level directory of this distribution
 * and at http://www.gnu.org/licenses/.
 *
 */

#include <unistd.h>

#include "srslte/utils/debug.h"
#include "srsapps/ue/phy/phy.h"
#include "srsapps/common/log_stdout.h"
#include "srsapps/radio/radio_uhd.h"

/**********************************************************************
 *  Program arguments processing
 ***********************************************************************/
typedef struct {
  float uhd_rx_freq;
  float uhd_tx_freq; 
  float uhd_rx_gain;
  float uhd_tx_gain;
  bool  continous; 
}prog_args_t;

prog_args_t prog_args; 
uint32_t srsapps_verbose = 0; 

void args_default(prog_args_t *args) {
  args->uhd_rx_freq = -1.0;
  args->uhd_tx_freq = -1.0;
  args->uhd_rx_gain = -1; // set to autogain
  args->uhd_tx_gain = -1; 
  args->continous = false; 
}

void usage(prog_args_t *args, char *prog) {
  printf("Usage: %s [gGcv] -f rx_frequency -F tx_frequency (in Hz)\n", prog);
  printf("\t-g UHD RX gain [Default AGC]\n");
  printf("\t-G UHD TX gain [Default same as RX gain (AGC)]\n");
  printf("\t-c Run continuously [Default only once]\n");
  printf("\t-v [increase verbosity, default none]\n");
}

void parse_args(prog_args_t *args, int argc, char **argv) {
  int opt;
  args_default(args);
  while ((opt = getopt(argc, argv, "gGfFcv")) != -1) {
    switch (opt) {
    case 'g':
      args->uhd_rx_gain = atof(argv[optind]);
      break;
    case 'G':
      args->uhd_tx_gain = atof(argv[optind]);
      break;
    case 'f':
      args->uhd_rx_freq = atof(argv[optind]);
      break;
    case 'F':
      args->uhd_tx_freq = atof(argv[optind]);
      break;
    case 'c':
      args->continous = true; 
      break;
    case 'v':
      srsapps_verbose++;
      break;
    default:
      usage(args, argv[0]);
      exit(-1);
    }
  }
  if (args->uhd_rx_freq < 0 || args->uhd_tx_freq < 0) {
    usage(args, argv[0]);
    exit(-1);
  }
}



typedef enum{
    rar_header_type_bi = 0,
    rar_header_type_rapid,
    rar_header_type_n_items,
}rar_header_t;
static const char rar_header_text[rar_header_type_n_items][8] = {"BI", "RAPID"};

typedef struct {
  rar_header_t      hdr_type;
  bool              hopping_flag;
  uint32_t          tpc_command;
  bool              ul_delay;
  bool              csi_req;
  uint16_t          rba; 
  uint16_t          timing_adv_cmd;
  uint16_t          temp_c_rnti;
  uint8_t           mcs; 
  uint8_t           RAPID;
  uint8_t           BI;
}rar_msg_t; 


int rar_unpack(uint8_t *buffer, rar_msg_t *msg)
{
    int ret = SRSLTE_ERROR;
    uint8_t *ptr = buffer; 
    
    if(buffer != NULL &&
          msg != NULL)
    {
      ptr++;
      msg->hdr_type = (rar_header_t) *ptr++;
      if(msg->hdr_type == rar_header_type_bi) {
        ptr += 2; 
        msg->BI = srslte_bit_unpack(&ptr, 4);
        ret = SRSLTE_SUCCESS; 
      } else if (msg->hdr_type == rar_header_type_rapid) {
        msg->RAPID = srslte_bit_unpack(&ptr, 6);
        ptr++;
        
        msg->timing_adv_cmd = srslte_bit_unpack(&ptr, 11);
        msg->hopping_flag   = *ptr++;
        msg->rba            = srslte_bit_unpack(&ptr, 10); 
        msg->mcs            = srslte_bit_unpack(&ptr, 4);
        msg->tpc_command    = srslte_bit_unpack(&ptr, 3);
        msg->ul_delay       = *ptr++;
        msg->csi_req        = *ptr++;
        msg->temp_c_rnti    = srslte_bit_unpack(&ptr, 16);
        ret = SRSLTE_SUCCESS;
      } 
    }

    return(ret);
}



srslte::ue::phy my_phy;
bool bch_decoded = false; 

uint8_t payload[10240]; 
uint8_t payload_bits[10240]; 
const uint8_t conn_request_msg[] = {0x20, 0x06, 0x1F, 0x5C, 0x2C, 0x04, 0xB2, 0xAC, 0xF6, 0x00, 0x00, 0x00};

enum mac_state {RA, RAR, CONNREQUEST, CONNSETUP} state = RA; 

uint32_t preamble_idx = 0; 
rar_msg_t rar_msg;

uint32_t nof_rtx_connsetup = 0; 
uint32_t rv_value[4] = {0, 2, 3, 1}; 

void config_phy() {
  my_phy.set_param(srslte::ue::phy_interface_params::PRACH_CONFIG_INDEX, 0);
  my_phy.set_param(srslte::ue::phy_interface_params::PRACH_FREQ_OFFSET, 0);
  my_phy.set_param(srslte::ue::phy_interface_params::PRACH_HIGH_SPEED_FLAG, 0);
  my_phy.set_param(srslte::ue::phy_interface_params::PRACH_ROOT_SEQ_IDX, 0);
  my_phy.set_param(srslte::ue::phy_interface_params::PRACH_ZC_CONFIG, 11);

  my_phy.set_param(srslte::ue::phy_interface_params::DMRS_GROUP_HOPPING_EN, 0);
  my_phy.set_param(srslte::ue::phy_interface_params::DMRS_SEQUENCE_HOPPING_EN, 0);
  my_phy.set_param(srslte::ue::phy_interface_params::PUSCH_HOPPING_N_SB, 2);
  my_phy.set_param(srslte::ue::phy_interface_params::PUSCH_RS_CYCLIC_SHIFT, 0);
  my_phy.set_param(srslte::ue::phy_interface_params::PUSCH_RS_GROUP_ASSIGNMENT, 0);
  my_phy.set_param(srslte::ue::phy_interface_params::PUSCH_HOPPING_OFFSET, 0);

  my_phy.set_param(srslte::ue::phy_interface_params::PUCCH_DELTA_SHIFT, 2);
  my_phy.set_param(srslte::ue::phy_interface_params::PUCCH_CYCLIC_SHIFT, 0);
  my_phy.set_param(srslte::ue::phy_interface_params::PUCCH_N_PUCCH_1, 1);
  my_phy.set_param(srslte::ue::phy_interface_params::PUCCH_N_RB_2, 2);

  my_phy.configure_prach_params();
  my_phy.configure_ul_params();

}

srslte_softbuffer_rx_t softbuffer_rx; 
srslte_softbuffer_tx_t softbuffer_tx; 

uint16_t temp_c_rnti; 

/******** MAC Interface implementation */
class testmac : public srslte::ue::mac_interface_phy
{
public:
  
  testmac() { 
    rar_rnti_set = false; 
  }
  
  bool rar_rnti_set;
  
  void tti_clock(uint32_t tti) {
    if (!rar_rnti_set) {
      int prach_tti = my_phy.prach_tx_tti();
      if (prach_tti > 0) {
        my_phy.pdcch_dl_search(SRSLTE_RNTI_RAR, 1+prach_tti%10, prach_tti+3, prach_tti+13);
        rar_rnti_set = true; 
      }
    }
  }
  
  void new_grant_ul(mac_grant_t grant, tb_action_ul_t *action) {
    printf("New grant UL\n");
    memcpy(payload, conn_request_msg, grant.n_bytes*sizeof(uint8_t));
    action->current_tx_nb = nof_rtx_connsetup;
    action->rv = rv_value[nof_rtx_connsetup%4];
    action->softbuffer = &softbuffer_tx;     
    action->rnti = temp_c_rnti; 
    action->expect_ack = (nof_rtx_connsetup < 5)?true:false;
    action->payload_ptr = payload;
    memcpy(&action->phy_grant, &grant.phy_grant, sizeof(srslte_phy_grant_t));
    memcpy(&last_grant, &grant, sizeof(mac_grant_t));
    action->tx_enabled = true; 
    if (action->rv == 0) {
      srslte_softbuffer_tx_reset(&softbuffer_tx);      
    }
    my_phy.pdcch_dl_search(SRSLTE_RNTI_USER, temp_c_rnti);
  }
  
  void new_grant_ul_ack(mac_grant_t grant, bool ack, tb_action_ul_t *action) {
    printf("New grant UL ACK\n");    
  }

  void harq_recv(uint32_t tti, bool ack, tb_action_ul_t *action) {
    printf("harq recv hi=%d\n", ack?1:0);    
    if (!ack) {
      nof_rtx_connsetup++;
      action->current_tx_nb = nof_rtx_connsetup;
      action->rv = rv_value[nof_rtx_connsetup%4];
      action->softbuffer = &softbuffer_tx;     
      action->rnti = temp_c_rnti; 
      action->expect_ack = true; 
      memcpy(&action->phy_grant, &last_grant.phy_grant, sizeof(srslte_phy_grant_t));
      action->tx_enabled = true; 
      if (action->rv == 0) {
        srslte_softbuffer_tx_reset(&softbuffer_tx);      
      }
      printf("Retransmission %d, rv=%d\n", nof_rtx_connsetup, action->rv);
    } 
  }

  void new_grant_dl(mac_grant_t grant, tb_action_dl_t *action) {
    action->decode_enabled = true; 
    action->default_ack = false; 
    if (grant.rnti == 2) {
      action->generate_ack = false; 
    } else {
      action->generate_ack = true; 
    }
    action->payload_ptr = payload; 
    action->rnti = grant.rnti; 
    memcpy(&action->phy_grant, &grant.phy_grant, sizeof(srslte_phy_grant_t));
    memcpy(&last_grant, &grant, sizeof(mac_grant_t));
    action->rv = grant.rv;
    action->softbuffer = &softbuffer_rx;
    
    if (action->rv == 0) {
      srslte_softbuffer_rx_reset(&softbuffer_rx);
    }
  }
  
  void tb_decoded(bool ack, srslte_rnti_type_t rnti_type, uint32_t harq_pid) {
    if (ack) {
      if (rnti_type == SRSLTE_RNTI_RAR) {
        my_phy.pdcch_dl_search_reset();
        srslte_bit_pack_vector(payload, payload_bits, last_grant.n_bytes*8);
        rar_unpack(payload_bits, &rar_msg);
        if (rar_msg.RAPID == preamble_idx) {

          printf("Received RAR at TTI: %d\n", last_grant.tti);
          my_phy.set_timeadv_rar(rar_msg.timing_adv_cmd);
          
          temp_c_rnti = rar_msg.temp_c_rnti; 
          
          if (last_grant.n_bytes*8 > 20 + SRSLTE_RAR_GRANT_LEN) {
            uint8_t rar_grant[SRSLTE_RAR_GRANT_LEN];
            memcpy(rar_grant, &payload_bits[20], sizeof(uint8_t)*SRSLTE_RAR_GRANT_LEN);
            my_phy.set_rar_grant(last_grant.tti, rar_grant);          
          }
        } else {
          printf("Received RAR RAPID=%d\n", rar_msg.RAPID);        
        }
      } else {
        printf("Received Connection Setup\n");
        my_phy.pdcch_dl_search_reset();
      }
    }
  }

  void bch_decoded_ok(uint8_t *payload, uint32_t len) {
    printf("BCH decoded\n");
    bch_decoded = true; 
    srslte_cell_t cell; 
    my_phy.get_current_cell(&cell); 
    srslte_softbuffer_rx_init(&softbuffer_rx, cell.nof_prb);
    srslte_softbuffer_tx_init(&softbuffer_tx, cell.nof_prb);
  }
   
private: 
  mac_grant_t last_grant; 
};


testmac         my_mac;
srslte::radio_uhd radio_uhd; 
  
int main(int argc, char *argv[])
{
  srslte::log_stdout log("PHY");
  
  parse_args(&prog_args, argc, argv);

  // Init Radio and PHY
  if (prog_args.uhd_rx_gain > 0 && prog_args.uhd_tx_gain > 0) {
    radio_uhd.init();
    radio_uhd.set_rx_gain(prog_args.uhd_rx_gain);
    radio_uhd.set_tx_gain(prog_args.uhd_tx_gain);
    my_phy.init(&radio_uhd, &my_mac, &log);
  } else {
    radio_uhd.init_agc();
    radio_uhd.set_tx_rx_gain_offset(10);
    my_phy.init_agc(&radio_uhd, &my_mac, &log);
  }
  
  if (srsapps_verbose == 1) {
    log.set_level_info();
    printf("Log level info\n");
  }
  if (srsapps_verbose == 2) {
    log.set_level_debug();
    printf("Log level debug\n");
  }

  // Give it time to create thread 
  sleep(1);
  
  // Set RX freq
  radio_uhd.set_rx_freq(prog_args.uhd_rx_freq);
  radio_uhd.set_tx_freq(prog_args.uhd_tx_freq);
  
  // Instruct the PHY to configure PRACH parameters and sync to current cell 
  my_phy.sync_start();
  
  while(!my_phy.status_is_sync()) {
    usleep(20000);
  }

  // Setup PHY parameters
  config_phy();
    
  /* Instruct PHY to send PRACH and prepare it for receiving RAR */
  my_phy.prach_send(preamble_idx);
  
  /* go to idle and process each tti */
  bool running = true; 
  while(running) {
    sleep(1);
  }
  my_phy.stop();
  radio_uhd.stop_rx();
}