NRF_FAULT_ID_SDK_ASSEART using 802_15_4 ( wireless_uart ).

[SKV]

Hello,

I started working on 802_15_4 to create a TSCH ( Time SYNC channel hopping ), and it is working as expected. The problem is when i integrated the TSCH TX and TSCH RX in a single program it shows an ERROR, while debug i came across NRF_FAULT_ID_SDK_ASSEART. when i comment out the RX part of the code TX is working as expected. When i test both RX and TX the TX part the code is giving an error. Using SEGGER Embedded Studio with windows 10.The error s shown in the below picture.

The TSCH TX code as follows:

#ifdef __cplusplus
extern "C" {
#endif
#include "802_15_4_config.h"

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "ral_irq_handlers.h"

#include "nrf_drv_clock.h"

#include "boards.h"
#include "mac_mcps_data.h"
#include "sys_init.h"
#include "sys_task_scheduler.h"

#include "mac_common.h"
#include "mac_mlme_beacon_notify.h"
#include "mac_mlme_comm_status.h"
#include "mac_mlme_pib.h"
#include "mac_mlme_associate.h"
#include "mac_mlme_poll.h"
#include "mac_mlme_scan.h"
#include "mac_mlme_start.h"
#include "mac_security.h"
#include "nrf_delay.h"
#include "time.h"
#ifdef __cplusplus
}
#endif

#include "SEGGER_RTT.h"
#include "SEGGER_RTT_Conf.h"

#define CONFIG_POOL_SIZE 0x2000
static __ALIGN(ALIGN_VALUE) uint8_t m_heap[CONFIG_POOL_SIZE];
#define CONFIG_ERROR_PIN LED_4

#define C11 (1 << 11)
#define C12 (1 << 12)
#define C13 (1 << 13)
#define C14 (1 << 14)
#define C15 (1 << 15)
#define C16 (1 << 16)
#define C17 (1 << 17)
#define C18 (1 << 18)
#define C19 (1 << 19)
#define C20 (1 << 20)
#define C21 (1 << 21)
#define C22 (1 << 22)
#define C23 (1 << 23)
#define C24 (1 << 24)
#define C25 (1 << 25)
#define C26 (1 << 26)

static void out_of_memory_callback(const void* data);
static void memory_freed_callback(const void* data);

#ifdef __cplusplus
constexpr sys_event_desc_t gen_sys_event_desc_t(sys_event_id_t event_id,
                                                void(callback)(const void*)) {
    return sys_event_desc_t{sys_queue_item_t{}, event_id, callback};
}
static sys_event_desc_t m_out_of_memory_desc =
    gen_sys_event_desc_t(SYS_EVENT_OUT_OF_MEMORY, out_of_memory_callback);
static sys_event_desc_t m_memory_freed_desc =
    gen_sys_event_desc_t(SYS_EVENT_MEMORY_FREED, memory_freed_callback);
#else
static sys_event_desc_t m_out_of_memory_desc = {
    .event_id = SYS_EVENT_OUT_OF_MEMORY, .callback = out_of_memory_callback};
static sys_event_desc_t m_memory_freed_desc = {
    .event_id = SYS_EVENT_MEMORY_FREED, .callback = memory_freed_callback};
#endif

void wait_ms(const uint32_t count) {
    SEGGER_RTT_printf(0, "dummy wait: ");
    for(volatile uint32_t i=0; i<2432u*count; i++) {
        uint32_t j = i%(2432u*100u);
        if(j == 0) {
            SEGGER_RTT_printf(0, ".", j);
        }
    }
    SEGGER_RTT_printf(0, "\n");
}

static void out_of_memory_callback(const void* data) {
    LEDS_ON(BIT(CONFIG_ERROR_PIN));
}

static void memory_freed_callback(const void* data) {
    LEDS_OFF(BIT(CONFIG_ERROR_PIN));
}

static void app_task_init(void) {
    LEDS_CONFIGURE(LEDS_MASK);
    LEDS_OFF(LEDS_MASK);

    sys_init(m_heap, CONFIG_POOL_SIZE);

    sys_event_subscribe(&m_out_of_memory_desc);
    sys_event_subscribe(&m_memory_freed_desc);
}

static void clock_init(void) {
    ret_code_t err_code = nrf_drv_clock_init();
    ASSERT((err_code == NRF_SUCCESS) ||
           (err_code == NRF_ERROR_MODULE_ALREADY_INITIALIZED));

    nrf_drv_clock_hfclk_request(NULL);
    while (!nrf_drv_clock_hfclk_is_running()) {
        // spin lock
    }

    nrf_drv_clock_lfclk_request(NULL);
    while (!nrf_drv_clock_lfclk_is_running()) {
        // spin lock
    }
}

void print_mac_status(const mac_status_t status) {
    switch (status) {
        case MAC_NO_BEACON:
            SEGGER_RTT_printf(0, "MAC_NO_BEACON");
            break;
        case MAC_SUCCESS:
            SEGGER_RTT_printf(0, "MAC_SUCCESS");
            break;
        case MAC_LIMIT_REACHED:
            SEGGER_RTT_printf(0, "MAC_LIMIT_REACHED");
            break;
        default:
            SEGGER_RTT_printf(0, "0x%x", status);
            break;
    }
}

void print_addr(const mac_addr_t* addr, const mac_addr_mode_t addr_mode,
                const char* field) {
    SEGGER_RTT_printf(0, "%s: ", field);
    switch (addr_mode) {
        case MAC_ADDR_NONE:
            SEGGER_RTT_printf(0, "NONE");
            break;
        case MAC_ADDR_SHORT:
            SEGGER_RTT_printf(0, "0x%04x (short)", addr->short_address);
            break;
        case MAC_ADDR_LONG:
        default:
            SEGGER_RTT_printf(0, "0x%08x%08x (long)",
                              (uint32_t)(addr->long_address >> 32),
                              (uint32_t)(addr->long_address));
            break;
    }
}

void print_pan_desc(const mac_pan_descriptor_t* pan) {
    SEGGER_RTT_printf(0, "{coord_pan_id: 0x%04x, ", pan->coord_pan_id);
    print_addr(&(pan->coord_address), pan->coord_addr_mode, "address");
    SEGGER_RTT_printf(0,
                      ", logical_channel: %u, timestamp: 0x%x, link_quality: "
                      "%u, superframe_spec: 0x%x, gts: %s}",
                      pan->logical_channel, pan->timestamp, pan->link_quality,
                      pan->superframe_spec, pan->gts_permit ? "true" : "false");
}

void print_scan_conf(const mlme_scan_conf_t* sc) {
    SEGGER_RTT_printf(0, "{status: ");
    print_mac_status(sc->status);
    SEGGER_RTT_printf(0, ", scan_type: ");
    switch (sc->scan_type) {
        case ED_SCAN:
            SEGGER_RTT_printf(0, "ED_SCAN");
            break;
        case ACTIVE_SCAN:
            SEGGER_RTT_printf(0, "ACTIVE_SCAN");
            break;
        case PASSIVE_SCAN:
            SEGGER_RTT_printf(0, "PASSIVE_SCAN");
            break;
        case ORPHAN_SCAN:
            SEGGER_RTT_printf(0, "ORPHAN_SCAN");
            break;
        default:
            SEGGER_RTT_printf(0, "Unknown(%x)", sc->scan_type);
            break;
    }
    SEGGER_RTT_printf(0, ", unscanned_channels: %x", sc->unscanned_channels);
    SEGGER_RTT_printf(0, ", result_list_size: %u, results: {",
                      sc->result_list_size);
    for (size_t i = 0; i < sc->result_list_size; i++) {
        const mac_pan_descriptor_t* pan = &(sc->pan_descriptor_list[i]);
        SEGGER_RTT_printf(0, "Result %u: {pan_descriptor: ", i);
        print_pan_desc(pan);

        //for an active scan, the content of the energy_detect_list must not be read.
        //const uint8_t energy = sc->energy_detect_list[i];
        //(void)energy;
        //SEGGER_RTT_printf(0, ", energy: %x",  energy);
        SEGGER_RTT_printf(0, "}, ");
    }
    SEGGER_RTT_printf(0, "}\n");
}

bool callback_called = false;
void scan_callback(mlme_scan_conf_t* sc) { callback_called = true; };
void start_callback(mlme_start_conf_t* sc) { callback_called = true; };

mlme_scan_req_t gen_mac_scan_req_t(
    mac_scan_type_t scan_type, uint32_t scan_channels, uint8_t scan_duration,
    mac_pan_descriptor_t* pan_desc_buf, size_t pan_desc_size,
    uint8_t* energy_detect_buf, size_t energy_detect_size) {

    mlme_scan_req_t ret;
    ret.scan_type = scan_type;
    ret.scan_channels = scan_channels;
    ret.scan_duration = scan_duration;
    ret.pan_descriptors_buf = pan_desc_buf;
    ret.pan_descriptors_buf_size = pan_desc_size;
    ret.energy_detect_buf = energy_detect_buf;
    ret.energy_detect_buf_size = energy_detect_size;
    return ret;
}

const mlme_scan_conf_t* scan_req(mac_scan_type_t scan_type,
                                 uint32_t scan_channels,
                                 uint8_t scan_duration) {
#define _ENERGY_DET_SIZE 8
#define _PAN_DESC_SIZE 8
    static mac_pan_descriptor_t pd[_PAN_DESC_SIZE];
    static uint8_t ed[_ENERGY_DET_SIZE];

    static mlme_scan_req_t scan_req;
    scan_req = gen_mac_scan_req_t(scan_type, scan_channels, scan_duration, pd,
                                  _PAN_DESC_SIZE, ed, _ENERGY_DET_SIZE);

    callback_called = false;

    mlme_scan_req(&scan_req, scan_callback);

    while (!callback_called) {
        sys_task_run();
    }

    return &scan_req.confirm;
}

void gen_mac_key_descr_t(mac_key_descr_t* key_descr) {
    mac_table_init(&key_descr->id_lookup_list);
    mac_table_init(&key_descr->key_device_list);
    mac_table_init(&key_descr->key_usage_list);
}

mac_device_descr_t gen_mac_device_descr_t(uint16_t pan_id,
                                          uint16_t short_address,
                                          uint64_t extended_address,
                                          uint32_t frame_counter, bool exempt) {
    mac_device_descr_t ret;
    ret.pan_id = pan_id;
    ret.short_address = short_address;
    ret.extended_address = extended_address;
    ret.frame_counter = frame_counter;
    ret.exempt = exempt;
    return ret;
}

mac_security_level_descr_t gen_mac_security_level_descr_t(
    uint8_t frame_type, uint8_t cmd_frame_id, uint8_t security_min,
    uint8_t override_min) {
    mac_security_level_descr_t ret;
    ret.security_min = security_min;
    ret.override_min = override_min;
    ret.frame_type = frame_type;
    ret.cmd_frame_id = cmd_frame_id;
    return ret;
}

mac_key_id_lookup_descr_t gen_mac_key_id_lookup_descr_t(
    mac_key_lookup_size_t size) {
    mac_key_id_lookup_descr_t ret;
    ret.size = size;
    return ret;
}

mac_key_device_descr_t gen_mac_key_device_descr_t(uint8_t device_handle,
                                                  uint8_t unique_device,
                                                  uint8_t blacklisted) {
    mac_key_device_descr_t ret;
    ret.device_handle = device_handle;
    ret.blacklisted = blacklisted;
    ret.unique_device = unique_device;
    return ret;
}

mac_key_usage_descr_t gen_mac_key_usage_descr_t(uint8_t frame_type,
                                                uint8_t cmd_frame_id) {
    mac_key_usage_descr_t ret;
    ret.frame_type = frame_type;
    ret.cmd_frame_id = cmd_frame_id;
    return ret;
}

pib_id_t gen_pib_id_t_plme(plme_pib_attr_id_t id) {
    pib_id_t ret;
    ret.plme_id = id;
    return ret;
}

pib_id_t gen_pib_id_t(mlme_pib_attr_id_t id) {
    pib_id_t ret;
    ret.mlme_id = id;
    return ret;
}

const char* pib_id_str(pib_id_t id) {
    switch(id.mlme_id) {
        case MAC_PAN_ID:
            return "MAC_PAN_ID";
        case MAC_PAN_COORD_EXTENDED_ADDRESS:
            return "MAC_PAN_COORD_EXTENDED_ADDRESS";
        case MAC_PROMISCUOUS_MODE:
            return "MAC_PROMISCUOUS_MODE";
        case MAC_EXTENDED_ADDRESS:
            return "MAC_EXTENDED_ADDRESS";
        case MAC_SHORT_ADDRESS:
            return "MAC_SHORT_ADDRESS";
        case MAC_BEACON_PAYLOAD_LENGTH:
            return "MAC_BEACON_PAYLOAD_LENGTH";
        case MAC_BEACON_PAYLOAD:
            return "MAC_BEACON_PAYLOAD";
        case MAC_BEACON_ORDER:
            return "MAC_BEACON_ORDER";
        case MAC_RX_ON_WHEN_IDLE:
            return "MAC_RX_ON_WHEN_IDLE";
        case MAC_BATT_LIFE_EXT:
            return "MAC_BATT_LIFE_EXT";
        case MAC_IS_PAN_COORD:
            return "MAC_IS_PAN_COORD";
        case MAC_ASSOCIATION_PERMIT:
            return "MAC_ASSOCIATION_PERMIT";
        case MAC_GTS_PERMIT:
            return "MAC_GTS_PERMIT";
        case PHY_CURRENT_CHANNEL_ID:
            return "PHY_CURRENT_CHANNEL";
        default:
            return "**************UNKNOWN****************";
    }
}

void print_pib_get_request(const uint8_t* value, uint16_t size,
                           const char* name) {
    SEGGER_RTT_printf(0, "mlme_get: %s: 0x", name);
    for (uint16_t i = 0; i < size; i++) {
        SEGGER_RTT_printf(0, "%02x", value[i]);
    }
    SEGGER_RTT_printf(0, "\n");
}

const uint8_t* pib_get_request(pib_id_t id) {
    static uint8_t value[256];
    mac_status_t res = mlme_get(id, 0, value);
    const char* name = pib_id_str(id);
    if (res != MAC_SUCCESS) {
        SEGGER_RTT_printf(0, "failure in pib-get request(%s): ", name);
        print_mac_status(res);
        SEGGER_RTT_printf(0, "\n");
      
        return NULL;
    }
    print_pib_get_request(value, mlme_pib_attr_size_calc(id, 0), name);
    return value;
}

void pib_set_request(pib_id_t id, void * data) {
    mac_status_t state = mlme_set(id, 0, data);
    if (state != MAC_SUCCESS) {
        SEGGER_RTT_printf(0, "failure in pib-set request(%s): ", pib_id_str(id));
        print_mac_status(state);
        SEGGER_RTT_printf(0, "\n");
       
    }
}

const uint8_t* pib_set_get_request(pib_id_t id, void * data) {
    pib_set_request(id, data);
    return pib_get_request(id);
}

void print_beacon_notify_ind(const mlme_beacon_notify_ind_t* ind) {
    SEGGER_RTT_printf(0, "{bsn: %u, pan_descriptor: ", ind->bsn);
    print_pan_desc(&(ind->pan_descriptor));
    SEGGER_RTT_printf(0, ", sdu_length: %u, sdu: 0x", ind->sdu_length);
    for (size_t i = 0u; i < ind->sdu_length; i++) {
        SEGGER_RTT_printf(0, "%02x", ind->sdu.p_payload[i]);
    }
    SEGGER_RTT_printf(0, ", pend_addr_spec: %x}\n", ind->pend_addr_spec);
}

//void print_data_ind(const mcps_data_ind_t* ind) {
//    SEGGER_RTT_printf(0, "{src_pan_id: 0x%04x, ", ind->src_pan_id);
//    print_addr(&(ind->src_addr), ind->src_addr_mode, "src_addr");
//    SEGGER_RTT_printf(0, ", dst_pan_id: 0x%04x, ", ind->dst_pan_id);
//    print_addr(&(ind->dst_addr), ind->dst_addr_mode, "dst_addr");
//    SEGGER_RTT_printf(0, ", msdu_length: %u, sdu: 0x", ind->msdu_length);
//    for (size_t i = 0u; i < ind->msdu_length; i++) {
//        SEGGER_RTT_printf(0, "%02x", ind->msdu.p_payload[i]);
//    }
//    SEGGER_RTT_printf(0, ", mpdu_link_quality: %u", ind->mpdu_link_quality);
//    SEGGER_RTT_printf(0, ", dsn: %u", ind->dsn);
//    SEGGER_RTT_printf(0, ", timestamp: %u}\n", ind->timestamp);
//    SEGGER_RTT_printf(0, "\n");
//}
//
//void mlme_beacon_notify_ind(mlme_beacon_notify_ind_t* _ind) {
//    SEGGER_RTT_printf(0, "Received Beacon:\n");
//    print_beacon_notify_ind(_ind);
//}

void mlme_poll_ind(mlme_poll_ind_t* _ind) {
    SEGGER_RTT_printf(0, "Received Poll:\n");
}


//void mcps_data_ind(mcps_data_ind_t* _ind) {
//    SEGGER_RTT_printf(0, "Received Data:\n");
//    print_data_ind(_ind);
//}

void mlme_associate_ind(mlme_associate_ind_t* _ind) {
    SEGGER_RTT_printf(0, "Received Association:\n");
}

void dummy_wait() {
    SEGGER_RTT_printf(0, "dummy wait: ...");
    for(volatile size_t i=0; i<1024*1024*8; i++) {
        uint32_t j = (i + 10 )%(1024*1024*2);
        if(j+44 == 88) {
            SEGGER_RTT_printf(0, "%d,", j);
        }
    }
    SEGGER_RTT_printf(0, "\n");
}


uint32_t asn = 0;
uint8_t asn_f[4],time_sync_f[8];
uint8_t ch_offsetsel[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; // ChannelOffset
uint8_t beacon_payload[8];
uint64_t current_time=0,pervious_time=0;
uint32_t time_sync;
static uint8_t beacon_payload_length = sizeof(beacon_payload);
static const uint8_t ext_addr[] = {0xcau, 0xfeu, 0xbeu, 0xefu, 0x00u, 0x00u, 0xffu, 0xffu};
int i=0,k=0;


int main(void) {
    ral_irq_handler_import();

    SEGGER_RTT_Init();
    uint8_t rtt_buf_out[256u];
    SEGGER_RTT_ConfigUpBuffer(0, "OUT", rtt_buf_out, 256u,
                              SEGGER_RTT_MODE_NO_BLOCK_TRIM);

    app_task_init();
    sys_task_post(APP_TASK_ID);

    clock_init();

    SEGGER_RTT_printf(0, "....RESET COORD....\n");
#if (CONFIG_SECURE == 1)
    SEGGER_RTT_printf(0, "Compiled with CONFIG_SECURE\n");
#endif

    static uint8_t mac_association_permit = true;

    #define BEACON_ORDER 0x9u        // beacon interval = 7.68 sec   
    #define SUPERFRAME_ORDER 0x0u     
    
 
    static uint8_t mac_gts_permit = false;              
    static uint8_t rx_on_when_idle = true;              

    //static uint8_t beacon_payload[] = {0xabu, 0xabu, 0xabu, 0xabu, 0xbbu, 0xbbu, 0xbbu, 0xbbu,0x11,0x22,0x33,0xabu, 0xabu, 0xabu, 0xabu, 0xbbu, 0xbbu, 0xbbu, 0xbbu,0x11,0x22,0x33,0xabu, 0xabu, 0xabu, 0xabu, 0xbbu, 0xbbu, 0xbbu, 0xbbu,0x11,0x22,0x33,0xabu, 0xabu, 0xabu, 0xabu, 0xbbu, 0xbbu, 0xbbu, 0xbbu,0x11,0x22,0x33,12,12,12};
   // uint8_t hop_sequence[] = {11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26}; // available channels 
   uint8_t hop_sequence[]= {16,17,23,18,26,15,25,22,19,11,12,13,24,14,20,21}; //channels hop sequence is given by kaumudi singh
//    uint8_t ch_offset=ch_offsetsel[rand()%16];
    uint8_t ch_offset = 0;
    uint8_t ch_select;
    

    static uint16_t ext_addr_only = MAC_EXTENDED_ADDRESS_ONLY;


    pib_set_get_request(gen_pib_id_t(MAC_EXTENDED_ADDRESS), (void *)ext_addr);
    pib_set_get_request(gen_pib_id_t(MAC_SHORT_ADDRESS), &ext_addr_only);
    pib_set_get_request(gen_pib_id_t(MAC_BEACON_PAYLOAD_LENGTH), &beacon_payload_length);
    pib_set_get_request(gen_pib_id_t(MAC_BEACON_PAYLOAD), (void*)beacon_payload);
    pib_set_get_request(gen_pib_id_t(MAC_RX_ON_WHEN_IDLE), &rx_on_when_idle);
    pib_set_get_request(gen_pib_id_t(MAC_ASSOCIATION_PERMIT), &mac_association_permit);
    pib_get_request(gen_pib_id_t(MAC_GTS_PERMIT));
    pib_set_get_request(gen_pib_id_t(MAC_GTS_PERMIT), &mac_gts_permit);

 // start superframe structure 
    static mlme_start_req_t start_req =
	{
			.pan_id  = 0x1111,
			.logical_channel = 11,
			.start_time = 0x000000,
			.beacon_order = BEACON_ORDER,
			.superframe_order = SUPERFRAME_ORDER,
			.pan_coordinator = true,
			.battery_life_extension = false,
			.coord_realignment = false,
#if (CONFIG_SECURE == 1)
            .coord_realign_security_level = false,
            .beacon_security_level = false,
#endif
	};

    callback_called = false;
	mlme_start_req(&start_req, start_callback);
    while (!callback_called) {
        sys_task_run();
    }
   

    SEGGER_RTT_printf(0, "Sent the Start-Request: ");
    print_mac_status(start_req.confirm.status);
    SEGGER_RTT_printf(0, "\n");
    SEGGER_RTT_printf(0, " Channel : %u\n",start_req.logical_channel);
    SEGGER_RTT_printf(0,"Time :%u\n",sys_time_get()); 
    

 
  while(true)
  {
   SEGGER_RTT_printf(0, "cho: %d\n",ch_offset);
    for (i=0;;i++)
     {
          //channel = (ASN + ChannelOffset) % N , ASN-Absolute Slot Number,N-number of channels 
          
          ch_select = ((asn+ch_offset)%(16));
          start_req.logical_channel = hop_sequence[ch_select];
           
          callback_called = false;
	  mlme_start_req(&start_req, start_callback);
          while (!callback_called) {
                   sys_task_run();
          }
          

          SEGGER_RTT_printf(0, "Sent the Start-Request: ");
          print_mac_status(start_req.confirm.status);
          SEGGER_RTT_printf(0, "\n");
          asn=asn+505;

          asn_f[0]=((asn >> 24 ) & 0xFF);
          asn_f[1]=((asn >> 16 ) & 0xFF);
          asn_f[2]=((asn >> 8 ) & 0xFF);
          asn_f[3]=((asn ) & 0xFF);

          SEGGER_RTT_printf(0, " Channel : %u\n",start_req.logical_channel);
          printf("channel_select %u , asn %u , channel offset %u\n",ch_select,asn,ch_offset);
          printf("asn_f = %x%x%x%x\n",asn_f[0],asn_f[1],asn_f[2],asn_f[3]);

           current_time=sys_time_get();
           SEGGER_RTT_printf(0,"Time0 :%u\n",current_time);
           time_sync=current_time-pervious_time;
           SEGGER_RTT_printf(0,"Time_sy :%u\n",time_sync);
           pervious_time=current_time;
//           SEGGER_RTT_printf(0,"Time_pr :%u\n",pervious_time);

          SEGGER_RTT_printf(0, "\n");

          time_sync_f[0]=((time_sync >> 24) & 0xFF);
          time_sync_f[1]=((time_sync >> 16) & 0xFF);
          time_sync_f[2]=((time_sync >> 8) & 0xFF);
          time_sync_f[3]=((time_sync) & 0xFF);
          

          beacon_payload[0] =asn_f[0];
          beacon_payload[1] =asn_f[1];
          beacon_payload[2] =asn_f[2];
          beacon_payload[3] =asn_f[3];
          beacon_payload[4] =time_sync_f[0];
          beacon_payload[5] =time_sync_f[1];
          beacon_payload[6] =time_sync_f[2];
          beacon_payload[7] =time_sync_f[3];

          pib_set_get_request(gen_pib_id_t(MAC_BEACON_PAYLOAD_LENGTH), &beacon_payload_length);
          pib_set_get_request(gen_pib_id_t(MAC_BEACON_PAYLOAD), (void*)beacon_payload);
          
          
     }
     
    
  }


  while(true)
  {
     sys_task_run();
  }
}

The following code contains both TX and RX in a single program.

#ifdef __cplusplus
extern "C" {
#endif
#include "802_15_4_config.h"

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "ral_irq_handlers.h"

#include "nrf_drv_clock.h"

#include "boards.h"
#include "mac_mcps_data.h"
#include "sys_init.h"
#include "sys_task_scheduler.h"

#include "mac_common.h"
#include "mac_mlme_beacon_notify.h"
#include "mac_mlme_comm_status.h"
#include "mac_mlme_pib.h"
#include "mac_mlme_scan.h"
#include "mac_security.h"
#include "app_timer.h"
#include "nrf_drv_clock.h"
#include "nrfx_timer.h"
#ifdef __cplusplus
}
#endif

//for tx
#include "mac_mlme_associate.h"
#include "mac_mlme_poll.h"
#include "mac_mlme_start.h"
#include "nrf_delay.h"
#include "time.h"


#include "SEGGER_RTT.h"
#include "SEGGER_RTT_Conf.h"

#define CONFIG_POOL_SIZE 0x30000
static __ALIGN(ALIGN_VALUE) uint8_t m_heap[CONFIG_POOL_SIZE];
#define CONFIG_ERROR_PIN LED_4

#define NRF_PWR_MGMT_ENABLED 1

#define C11 (1 << 11)
#define C12 (1 << 12)
#define C13 (1 << 13)
#define C14 (1 << 14)
#define C15 (1 << 15)
#define C16 (1 << 16)
#define C17 (1 << 17)
#define C18 (1 << 18)
#define C19 (1 << 19)
#define C20 (1 << 20)
#define C21 (1 << 21)
#define C22 (1 << 22)
#define C23 (1 << 23)
#define C24 (1 << 24)
#define C25 (1 << 25)
#define C26 (1 << 26)

static int stat;
uint8_t sdu_length;
int scan_dur=-5; //scan_duration = scan network for 77ms
long int no_beacon_sleep=100; //1.82sec
long int beacon_sleep=7000000; //1.91sec
//int beacon_recieved=0;
uint8_t k;	//No. of frames received
uint32_t channel_hop_seq[] = {C16,C17,C23,C18,C26,C15,C25,C22,C19,C11,C12,C13,C24,C14,C20,C21};
//uint32_t channel_hop_seq[] = {16,17,23,18,26,15,25,22,19,11,12,13,24,14,20,21};
uint32_t channel_id=C16;



static void out_of_memory_callback(const void* data);
static void memory_freed_callback(const void* data);


#ifdef __cplusplus
constexpr sys_event_desc_t gen_sys_event_desc_t(sys_event_id_t event_id,
                                                void(callback)(const void*)) {
    return sys_event_desc_t{sys_queue_item_t{}, event_id, callback};
}
static sys_event_desc_t m_out_of_memory_desc =
    gen_sys_event_desc_t(SYS_EVENT_OUT_OF_MEMORY, out_of_memory_callback);
static sys_event_desc_t m_memory_freed_desc =
    gen_sys_event_desc_t(SYS_EVENT_MEMORY_FREED, memory_freed_callback);
#else
static sys_event_desc_t m_out_of_memory_desc = {
    .event_id = SYS_EVENT_OUT_OF_MEMORY, .callback = out_of_memory_callback};
static sys_event_desc_t m_memory_freed_desc = {
    .event_id = SYS_EVENT_MEMORY_FREED, .callback = memory_freed_callback};
#endif

//tx
void wait_ms(const uint32_t count) {
    SEGGER_RTT_printf(0, "dummy wait: ");
    for(volatile uint32_t i=0; i<2432u*count; i++) {
        uint32_t j = i%(2432u*100u);
        if(j == 0) {
            SEGGER_RTT_printf(0, ".", j);
        }
    }
    SEGGER_RTT_printf(0, "\n");
}
//end

//change

void timer2init(long int n)
{
    NRF_TIMER2->TASKS_STOP  = 1;
    NRF_TIMER2->MODE = TIMER_MODE_MODE_Timer << TIMER_MODE_MODE_Pos; //choose mode between timer and counter
    NRF_TIMER2->TASKS_CLEAR = 1;
    NRF_TIMER2->BITMODE =TIMER_BITMODE_BITMODE_32Bit << TIMER_BITMODE_BITMODE_Pos;
    NRF_TIMER2->PRESCALER =4 << TIMER_PRESCALER_PRESCALER_Pos;
    NRF_TIMER2->CC[0]=n;  //compare event to cc[0] register
    NRF_TIMER2->INTENSET = TIMER_INTENSET_COMPARE0_Enabled << TIMER_INTENSET_COMPARE0_Pos ;//enable interrupt
    NRF_TIMER2->SHORTS = TIMER_SHORTS_COMPARE0_STOP_Enabled <<TIMER_SHORTS_COMPARE0_STOP_Pos ;//shortcut path between tasks and local events
    NRF_TIMER2->TASKS_START = 1;
    NVIC_SetPriority( TIMER2_IRQn, 7);
    __DSB();
    NVIC_EnableIRQ(TIMER2_IRQn);
}

/*
void timer3init(long int n)
{
    NRF_TIMER3->TASKS_STOP  = 1;
    NRF_TIMER3->MODE = TIMER_MODE_MODE_Timer << TIMER_MODE_MODE_Pos;
    NRF_TIMER3->TASKS_CLEAR = 1;
    NRF_TIMER3->BITMODE =TIMER_BITMODE_BITMODE_32Bit << TIMER_BITMODE_BITMODE_Pos;
    NRF_TIMER3->PRESCALER =4 << TIMER_PRESCALER_PRESCALER_Pos;
    NRF_TIMER3->CC[0]=n;  
    NRF_TIMER3->INTENSET = TIMER_INTENSET_COMPARE0_Enabled << TIMER_INTENSET_COMPARE0_Pos ;
    NRF_TIMER3->SHORTS = TIMER_SHORTS_COMPARE0_STOP_Enabled <<TIMER_SHORTS_COMPARE0_STOP_Pos ;
    NRF_TIMER3->TASKS_START = 1;
   // NVIC_SetPriority( TIMER3_IRQn, 3);
   // __DSB();
   NVIC_EnableIRQ(TIMER3_IRQn);
}
*/
// Transmitter code start

uint8_t sdu_data[4];
uint32_t sdu_data_dec,asn;
uint8_t ch_offset=0,slotoffest=201;
int z;

static void out_of_memory_callback(const void* data) {
    LEDS_ON(BIT(CONFIG_ERROR_PIN));
}

static void memory_freed_callback(const void* data) {
    LEDS_OFF(BIT(CONFIG_ERROR_PIN));
}

static void app_task_init(void) {
    LEDS_CONFIGURE(LEDS_MASK);
    LEDS_OFF(LEDS_MASK);

    sys_init(m_heap, CONFIG_POOL_SIZE);

    sys_event_subscribe(&m_out_of_memory_desc);
    sys_event_subscribe(&m_memory_freed_desc);
}

static void clock_init(void) {
    ret_code_t err_code = nrf_drv_clock_init();
    ASSERT((err_code == NRF_SUCCESS) ||
           (err_code == NRF_ERROR_MODULE_ALREADY_INITIALIZED));

    nrf_drv_clock_hfclk_request(NULL);
    while (!nrf_drv_clock_hfclk_is_running()) {
        // spin lock
    }

    nrf_drv_clock_lfclk_request(NULL);
    while (!nrf_drv_clock_lfclk_is_running()) {
        // spin lock
    }
}

void print_mac_status(const mac_status_t status) {
    switch (status) {
        case MAC_NO_BEACON:
            SEGGER_RTT_printf(0, "MAC_NO_BEACON");
            break;
        case MAC_SUCCESS:
            SEGGER_RTT_printf(0, "MAC_SUCCESS");
            break;
        case MAC_LIMIT_REACHED:
            SEGGER_RTT_printf(0, "MAC_LIMIT_REACHED");
            break;
        default:
            SEGGER_RTT_printf(0, "0x%x", status);
            break;
    }
}


void print_addr(const mac_addr_t* addr, const mac_addr_mode_t addr_mode,
                const char* field) {
    SEGGER_RTT_printf(0, "%s: ", field);
    switch (addr_mode) {
        case MAC_ADDR_NONE:
            SEGGER_RTT_printf(0, "NONE");
            break;
        case MAC_ADDR_SHORT:
            SEGGER_RTT_printf(0, "0x%04x (short)", addr->short_address);
            break;
        case MAC_ADDR_LONG:
        default:
            SEGGER_RTT_printf(0, "0x%08x%08x (long)",
                              (uint32_t)(addr->long_address >> 32),
                              (uint32_t)(addr->long_address));
            break;
    }
}

void print_pan_desc(const mac_pan_descriptor_t* pan) {
    SEGGER_RTT_printf(0, "{coord_pan_id: 0x%04x, ", pan->coord_pan_id);
    print_addr(&(pan->coord_address), pan->coord_addr_mode, "address");
    SEGGER_RTT_printf(0,
                      ", logical_channel: %u, timestamp: 0x%x, link_quality: "
                      "%u, superframe_spec: 0x%x, gts: %s}",
                      pan->logical_channel, pan->timestamp, pan->link_quality,
                      pan->superframe_spec, pan->gts_permit ? "true" : "false");
}

int print_scan_conf_rx(const mlme_scan_conf_t* sc) {
    if((sc->status)==MAC_SUCCESS)
    return 1;
    else
    return 0;
}

//tx
void print_scan_conf(const mlme_scan_conf_t* sc) {
    SEGGER_RTT_printf(0, "{status: ");
    print_mac_status(sc->status);
    SEGGER_RTT_printf(0, ", scan_type: ");
    switch (sc->scan_type) {
        case ED_SCAN:
            SEGGER_RTT_printf(0, "ED_SCAN");
            break;
        case ACTIVE_SCAN:
            SEGGER_RTT_printf(0, "ACTIVE_SCAN");
            break;
        case PASSIVE_SCAN:
            SEGGER_RTT_printf(0, "PASSIVE_SCAN");
            break;
        case ORPHAN_SCAN:
            SEGGER_RTT_printf(0, "ORPHAN_SCAN");
            break;
        default:
            SEGGER_RTT_printf(0, "Unknown(%x)", sc->scan_type);
            break;
    }
    SEGGER_RTT_printf(0, ", unscanned_channels: %x", sc->unscanned_channels);
    SEGGER_RTT_printf(0, ", result_list_size: %u, results: {",
                      sc->result_list_size);
    for (size_t i = 0; i < sc->result_list_size; i++) {
        const mac_pan_descriptor_t* pan = &(sc->pan_descriptor_list[i]);
        SEGGER_RTT_printf(0, "Result %u: {pan_descriptor: ", i);
        print_pan_desc(pan);

        //for an active scan, the content of the energy_detect_list must not be read.
        //const uint8_t energy = sc->energy_detect_list[i];
        //(void)energy;
        //SEGGER_RTT_printf(0, ", energy: %x",  energy);
        SEGGER_RTT_printf(0, "}, ");
    }
    SEGGER_RTT_printf(0, "}\n");
}
//end

bool callback_called = false;
void scan_callback(mlme_scan_conf_t *sc) { callback_called = true;};
void start_callback(mlme_start_conf_t *sc) { callback_called = true;};

mlme_scan_req_t gen_mac_scan_req_t(
    mac_scan_type_t scan_type, uint32_t scan_channels, uint8_t scan_duration,
    mac_pan_descriptor_t* pan_desc_buf, size_t pan_desc_size,

    uint8_t* energy_detect_buf, size_t energy_detect_size) {
    mlme_scan_req_t ret;
    ret.scan_type = scan_type;
    ret.scan_channels = scan_channels;
    ret.scan_duration = scan_duration;
    ret.pan_descriptors_buf = pan_desc_buf;
    ret.pan_descriptors_buf_size = pan_desc_size;
    ret.energy_detect_buf = energy_detect_buf;
    ret.energy_detect_buf_size = energy_detect_size;
    return ret;
}
//changed to int from uint8_t for scan_duration
const mlme_scan_conf_t* scan_req(mac_scan_type_t scan_type,
                                 uint32_t scan_channels,
                                 int scan_duration) {
#define _ENERGY_DET_SIZE 8
#define _PAN_DESC_SIZE 8
    static mac_pan_descriptor_t pd[_PAN_DESC_SIZE];
    static uint8_t ed[_ENERGY_DET_SIZE];
    mcps_data_ind_t* ind;

    static mlme_scan_req_t scan_req;
    scan_req = gen_mac_scan_req_t(scan_type, scan_channels, scan_duration, pd,
                                  _PAN_DESC_SIZE, ed, _ENERGY_DET_SIZE);

    callback_called = false;

    mlme_scan_req(&scan_req, scan_callback);
   
   
    while (!callback_called) {
        sys_task_run();
        }
   return &scan_req.confirm;
}

void gen_mac_key_descr_t(mac_key_descr_t* key_descr) {
    mac_table_init(&key_descr->id_lookup_list);
    mac_table_init(&key_descr->key_device_list);
    mac_table_init(&key_descr->key_usage_list);
}

mac_device_descr_t gen_mac_device_descr_t(uint16_t pan_id,
                                          uint16_t short_address,
                                          uint64_t extended_address,
                                          uint32_t frame_counter, bool exempt) {
    mac_device_descr_t ret;
    ret.pan_id = pan_id;
    ret.short_address = short_address;
    ret.extended_address = extended_address;
    ret.frame_counter = frame_counter;
    ret.exempt = exempt;
    return ret;
}

mac_security_level_descr_t gen_mac_security_level_descr_t(
    uint8_t frame_type, uint8_t cmd_frame_id, uint8_t security_min,
    uint8_t override_min) {
    mac_security_level_descr_t ret;
    ret.security_min = security_min;
    ret.override_min = override_min;
    ret.frame_type = frame_type;
    ret.cmd_frame_id = cmd_frame_id;
    return ret;
}

mac_key_id_lookup_descr_t gen_mac_key_id_lookup_descr_t(
    mac_key_lookup_size_t size) {
    mac_key_id_lookup_descr_t ret;
    ret.size = size;
    return ret;
}

mac_key_device_descr_t gen_mac_key_device_descr_t(uint8_t device_handle,
                                                  uint8_t unique_device,
                                                  uint8_t blacklisted) {
    mac_key_device_descr_t ret;
    ret.device_handle = device_handle;
    ret.blacklisted = blacklisted;
    ret.unique_device = unique_device;
    return ret;
}

mac_key_usage_descr_t gen_mac_key_usage_descr_t(uint8_t frame_type,
                                                uint8_t cmd_frame_id) {
    mac_key_usage_descr_t ret;
    ret.frame_type = frame_type;
    ret.cmd_frame_id = cmd_frame_id;
    return ret;
}

pib_id_t gen_pib_id_t_plme(plme_pib_attr_id_t id) {
    pib_id_t ret;
    ret.plme_id = id;
    return ret;
}

pib_id_t gen_pib_id_t(mlme_pib_attr_id_t id) {
    pib_id_t ret;
    ret.mlme_id = id;
    return ret;
}

const char* pib_id_str(pib_id_t id) {
    switch(id.mlme_id) {
        case MAC_PAN_ID:
            return "MAC_PAN_ID";
        case MAC_PAN_COORD_EXTENDED_ADDRESS:
            return "MAC_PAN_COORD_EXTENDED_ADDRESS";
        case MAC_PROMISCUOUS_MODE:
            return "MAC_PROMISCUOUS_MODE";
        case MAC_EXTENDED_ADDRESS:
            return "MAC_EXTENDED_ADDRESS";
        case MAC_SHORT_ADDRESS:
            return "MAC_SHORT_ADDRESS";
        case MAC_BEACON_PAYLOAD_LENGTH:
            return "MAC_BEACON_PAYLOAD_LENGTH";
        case MAC_BEACON_PAYLOAD:
            return "MAC_BEACON_PAYLOAD";
        case MAC_BEACON_ORDER:
            return "MAC_BEACON_ORDER";
        case MAC_RX_ON_WHEN_IDLE:
            return "MAC_RX_ON_WHEN_IDLE";
        case MAC_BATT_LIFE_EXT:
            return "MAC_BATT_LIFE_EXT";
        case MAC_IS_PAN_COORD:
            return "MAC_IS_PAN_COORD";
        case MAC_ASSOCIATION_PERMIT:
            return "MAC_ASSOCIATION_PERMIT";
        case MAC_GTS_PERMIT:
            return "MAC_GTS_PERMIT";
        case PHY_CURRENT_CHANNEL_ID:
            return "PHY_CURRENT_CHANNEL";
        default:
            return "**************UNKNOWN****************";
    }
}

void print_pib_get_request(const uint8_t* value, uint16_t size,
                           const char* name) {
    SEGGER_RTT_printf(0, "mlme_get: %s: 0x", name);
    for (uint16_t i = 0; i < size; i++) {
        SEGGER_RTT_printf(0, "%02x", value[i]);
    }
    SEGGER_RTT_printf(0, "\n");
}

const uint8_t* pib_get_request_tx(pib_id_t id) {
    static uint8_t value[256];
    mac_status_t res = mlme_get(id, 0, value);
    const char* name = pib_id_str(id);
    if (res != MAC_SUCCESS) {
        SEGGER_RTT_printf(0, "failure in pib-get request(%s): ", name);
        print_mac_status(res);
        SEGGER_RTT_printf(0, "\n");
      
        return NULL;
    }
    print_pib_get_request(value, mlme_pib_attr_size_calc(id, 0), name);
    return value;
}

const uint8_t* pib_get_request(pib_id_t id, const char* name) {
    static uint8_t value[256];
    mac_status_t res = mlme_get(id, 0, value);
    if (res != MAC_SUCCESS) {
        SEGGER_RTT_printf(0, "failure in pib-get request: ");
        print_mac_status(res);
        SEGGER_RTT_printf(0, "\n");
        return NULL;
    }
    print_pib_get_request(value, mlme_pib_attr_size_calc(id, 0), name);
    return value;
}

void pib_set_request(pib_id_t id, void * data) {
    mac_status_t state = mlme_set(id, 0, data);
    if (state != MAC_SUCCESS) {
        SEGGER_RTT_printf(0, "failure in pib-set request(%s): ", pib_id_str(id));
        print_mac_status(state);
        SEGGER_RTT_printf(0, "\n");
       
    }
}

const uint8_t* pib_set_get_request(pib_id_t id, void * data) {
    pib_set_request(id, data);
    return pib_get_request_tx(id);
}

void print_beacon_notify_ind(const mlme_beacon_notify_ind_t* ind) {
    SEGGER_RTT_printf(0, "{bsn: %u, pan_descriptor: ", ind->bsn);
    print_pan_desc(&(ind->pan_descriptor));
    SEGGER_RTT_printf(0, ", sdu_length: %u, sdu: 0x", ind->sdu_length);
    for (size_t i = 0u; i < ind->sdu_length; i++) {
        SEGGER_RTT_printf(0, "%02x", ind->sdu.p_payload[i]);
    }
    SEGGER_RTT_printf(0, ", pend_addr_spec: %x}\n", ind->pend_addr_spec);
   
}

void print_data_ind_tx(const mcps_data_ind_t* ind) {
    SEGGER_RTT_printf(0, "{src_pan_id: 0x%04x, ", ind->src_pan_id);
    print_addr(&(ind->src_addr), ind->src_addr_mode, "src_addr");
    SEGGER_RTT_printf(0, ", dst_pan_id: 0x%04x, ", ind->dst_pan_id);
    print_addr(&(ind->dst_addr), ind->dst_addr_mode, "dst_addr");
    SEGGER_RTT_printf(0, ", msdu_length: %u, sdu: 0x", ind->msdu_length);
    for (size_t i = 0u; i < ind->msdu_length; i++) {
        SEGGER_RTT_printf(0, "%02x", ind->msdu.p_payload[i]);
    }
    SEGGER_RTT_printf(0, ", mpdu_link_quality: %u", ind->mpdu_link_quality);
    SEGGER_RTT_printf(0, ", dsn: %u", ind->dsn);
    SEGGER_RTT_printf(0, ", timestamp: %u}\n", ind->timestamp);
    SEGGER_RTT_printf(0, "\n");
}


void mlme_beacon_notify_ind(mlme_beacon_notify_ind_t* _ind) {
    SEGGER_RTT_printf(0, "Received Beacon:\n");
    print_beacon_notify_ind(_ind);
}

void mlme_poll_ind(mlme_poll_ind_t* _ind) {
    SEGGER_RTT_printf(0, "Received Poll:\n");
}

void mcps_data_ind_tx(mcps_data_ind_t* _ind) {
    SEGGER_RTT_printf(0, "Received Data:\n");
    print_data_ind_tx(_ind);
}

void mlme_associate_ind(mlme_associate_ind_t* _ind) {
    SEGGER_RTT_printf(0, "Received Association:\n");
}
//end


void dummy_wait() {
    SEGGER_RTT_printf(0, "dummy wait: ...");
    for(volatile size_t i=0; i<1024*1024*8; i++) {
        uint32_t j = (i + 10 )%(1024*1024*2);
        if(j+44 == 88) {
            SEGGER_RTT_printf(0, "%d,", j);
        }
    }
    SEGGER_RTT_printf(0, "\n");
}


static uint8_t security_enabled = true;
    static uint16_t pan_id = 0x1111;   // same as that of the transmitter
    static uint16_t other_address = 0xFFFEU;
    static uint64_t pan_external = 0x1122334455667788ULL;
    static uint8_t promiscuous_mode = true;   // receive all packets which are sent wirelessly
    static uint8_t rx_on_when_idle = true;
//    static uint32_t channel_id = C12;          // channel to receive packets
    static uint8_t key[MAC_SECURITY_KEY_SIZE] = {
        0x12u, 0x34u, 0x56u, 0x78u, 0x9Au, 0xBCu, 0xDEu, 0xF0u,
        0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u};
    static const uint8_t key_lookup_data[KEY_LOOKUP_SIZE_NINE_VAL] = {
        0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x03};
    static uint8_t default_source[KEY_LOOKUP_SIZE_NINE_VAL - 1] = {
        0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33};
    static uint8_t auto_request_security_level = MAC_SEC_OFF;
    static mac_security_level_descr_t sec_level_descr;
    static mac_key_id_lookup_descr_t key_id_lookup_descr;
    static mac_key_device_descr_t key_device_descr;
    static mac_device_descr_t device_descr;
    static mac_key_usage_descr_t key_usage_descr;
    static mac_key_descr_t key_descr;



void recieving_handle(void)
{
    sec_level_descr = gen_mac_security_level_descr_t(MAC_DATA, MAC_CMD_DATA_REQ,
                                                     MAC_SEC_OFF, false);

   
    key_id_lookup_descr = gen_mac_key_id_lookup_descr_t(KEY_LOOKUP_SIZE_NINE);
    memcpy(key_id_lookup_descr.data, key_lookup_data, KEY_LOOKUP_SIZE_NINE_VAL);
    key_device_descr = gen_mac_key_device_descr_t(0, false, false);
    key_device_descr.table_service.idx = 0;
    device_descr =
        gen_mac_device_descr_t(pan_id, other_address, pan_external, 0, false);
    key_usage_descr = gen_mac_key_usage_descr_t(MAC_DATA, MAC_CMD_DATA_REQ);

    // build the key_descr-table:
    gen_mac_key_descr_t(&key_descr);

    mac_status_t ret1 = mac_table_item_set(&key_descr.id_lookup_list,
                                           &key_id_lookup_descr.table_service,
                                           MAC_KEY_ID_LOOKUP_LIST, 0);

    mac_status_t ret2 = mac_table_item_set(&key_descr.key_device_list,
                                           &key_device_descr.table_service,
                                           MAC_KEY_DEVICE_LIST, 0);

    mac_status_t ret3 = mac_table_item_set(&key_descr.key_usage_list,
                                           &key_usage_descr.table_service,
                                           MAC_KEY_USAGE_LIST, 0);

    SEGGER_RTT_printf(0, "\n");

    memcpy(key_descr.key, key, MAC_SECURITY_KEY_SIZE);
//    channel_id=16u;

repeat:
// scan channel  
while(true)
{//change
    {
//        NVIC_EnableIRQ( RADIO_IRQn );

        SEGGER_RTT_printf(0, "\n\nstarting the scan\n");
        stat=print_scan_conf_rx(scan_req(ACTIVE_SCAN,channel_id,scan_dur));// scan duration formula=[aBaseSuperframeDuration * (2^n + 1)]
        SEGGER_RTT_printf(0, "Stat: %d\n",stat);
        SEGGER_RTT_printf(0, "channel: %u\n",channel_id);
        SEGGER_RTT_printf(0, "finished the scan\n");
//        NVIC_DisableIRQ( RADIO_IRQn );
        __DSB();
        if(stat)
          break;
        else if (sdu_length>=18)
          goto subrepeat;
        else
        {
         // NVIC_DisableIRQ( RADIO_IRQn );
         // __DSB();
          timer2init(no_beacon_sleep);
          //send system to sleep mode if beacon is not detected
          __SEV();        //sleep
          __WFE();               //mode
          __WFE();                        //called
          scan_dur=-5;     //scan channel for 77ms if scan_dur=2
         
        }
    }
}  

//NVIC_EnableIRQ( RADIO_IRQn );

{
    {
        mac_status_t state = mlme_set(gen_pib_id_t(MAC_PAN_ID), 0, &pan_id);
      /*  if (state != MAC_SUCCESS) {
            SEGGER_RTT_printf(0, "failure in pib-set request: ");
            print_mac_status(state);
            SEGGER_RTT_printf(0, "\n");
        }
*/
        pib_get_request(gen_pib_id_t(MAC_PAN_ID), "MAC_PAN_ID");
    }
    {
        mac_status_t state = mlme_set(
            gen_pib_id_t(MAC_PAN_COORD_EXTENDED_ADDRESS), 0, &pan_external);
/*        if (state != MAC_SUCCESS) {
            SEGGER_RTT_printf(0, "failure in pib-set request: ");
            print_mac_status(state);
            SEGGER_RTT_printf(0, "\n");
        }
*/
        pib_get_request(gen_pib_id_t(MAC_PAN_COORD_EXTENDED_ADDRESS),
                        "MAC_PAN_COORD_EXTENDED_ADDRESS");
    }
    {
        mac_status_t state =
            mlme_set(gen_pib_id_t(MAC_PROMISCUOUS_MODE), 0, &promiscuous_mode);
/*        if (state != MAC_SUCCESS) {
            SEGGER_RTT_printf(0, "failure in pib-set request: ");
            print_mac_status(state);
            SEGGER_RTT_printf(0, "\n");
        }
*/
        pib_get_request(gen_pib_id_t(MAC_PROMISCUOUS_MODE),
                        "MAC_PROMISCOUS_MODE");
    }



    {
        mac_status_t state =
            mlme_set(gen_pib_id_t(MAC_RX_ON_WHEN_IDLE), 0, &rx_on_when_idle);
/*        if (state != MAC_SUCCESS) {
            SEGGER_RTT_printf(0, "failure in pib-set request: ");
            print_mac_status(state);
            SEGGER_RTT_printf(0, "\n");
        }
*/
        pib_get_request(gen_pib_id_t(MAC_RX_ON_WHEN_IDLE),
                        "MAC_RX_ON_WHEN_IDLE");
    }
    {
        mac_status_t state =
            mlme_set(gen_pib_id_t_plme(PHY_CURRENT_CHANNEL_ID), 0, &channel_id);
/*        if (state != MAC_SUCCESS) {
            SEGGER_RTT_printf(0, "failure in pib-set request: ");
            print_mac_status(state);
            SEGGER_RTT_printf(0, "\n");
        }
*/
        pib_get_request(gen_pib_id_t_plme(PHY_CURRENT_CHANNEL_ID),
                        "PHY_CURRENT_CHANNEL_ID");
    }
    {
        mac_status_t state =
            mlme_set(gen_pib_id_t(MAC_KEY_TABLE), 0, &key_descr);
/*        if (state != MAC_SUCCESS) {
            SEGGER_RTT_printf(0, "failure in pib-set request: ");
            print_mac_status(state);
            SEGGER_RTT_printf(0, "\n");
        }
*/
                     
    }
    {
        mac_status_t state =
            mlme_set(gen_pib_id_t(MAC_DEVICE_TABLE), 0, &device_descr);
/*        if (state != MAC_SUCCESS) {
            SEGGER_RTT_printf(0, "failure in pib-set request: ");
            print_mac_status(state);
            SEGGER_RTT_printf(0, "\n");
        }
*/
    }
    {
        mac_status_t state = mlme_set(gen_pib_id_t(MAC_SECURITY_LEVEL_TABLE), 0,
                                      &sec_level_descr);
/*        if (state != MAC_SUCCESS) {
            SEGGER_RTT_printf(0, "failure in pib-set request: ");
            print_mac_status(state);
            SEGGER_RTT_printf(0, "\n");
        }
*/
    }

    {
        mac_status_t state =
            mlme_set(gen_pib_id_t(MAC_DEFAULT_KEY_SOURCE), 0, &default_source);
/*        if (state != MAC_SUCCESS) {
            SEGGER_RTT_printf(0, "failure in pib-set request: ");
            print_mac_status(state);
            SEGGER_RTT_printf(0, "\n");
        }
*/
    }
    {
        mac_status_t state =
            mlme_set(gen_pib_id_t(MAC_AUTO_REQUEST_SECURITY_LEVEL), 0,
                     &auto_request_security_level);
/*        if (state != MAC_SUCCESS) {
            SEGGER_RTT_printf(0, "failure in pib-set request: ");
            print_mac_status(state);
            SEGGER_RTT_printf(0, "\n");
        }

*/        
    }
    {
        mac_status_t state =
            mlme_set(gen_pib_id_t(MAC_SECURITY_ENABLED), 0, &security_enabled);
/*        if (state != MAC_SUCCESS) {
            SEGGER_RTT_printf(0, "failure in pib-set request: ");
            print_mac_status(state);
            SEGGER_RTT_printf(0, "\n");
        }
*/
        pib_get_request(gen_pib_id_t(MAC_SECURITY_ENABLED),
                        "MAC_SECURITY_ENABLED");
    }

 
    // received data
    mcps_data_ind_t* _ind;
    mcps_data_ind(_ind);
//change
subrepeat:
    while (true)
    {
        sys_task_run();
        //send system to sleep mode if sdu_length is detected
        if((sdu_length>=18))// && (k>=3))
        {
        //NVIC_DisableIRQ( RADIO_IRQn );
        //__DSB();
        timer2init(beacon_sleep);
        __SEV();
        __WFE();
        __WFE();
        sdu_length=0;
        scan_dur=-5;
        goto repeat; //go back to scanning the network
        }
       
    }
   
}
}    
//tx

//uint32_t asn = 0;
uint8_t asn_f[4],time_sync_f[8];
uint8_t ch_offsetsel[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; // ChannelOffset
uint8_t beacon_payload[8];
uint64_t current_time=0,pervious_time=0;
uint32_t time_sync;
static uint8_t beacon_payload_length = sizeof(beacon_payload);
static const uint8_t ext_addr[] = {0xcau, 0xfeu, 0xbeu, 0xefu, 0x00u, 0x00u, 0xffu, 0xffu};
int i=0,w=0;
uint8_t hop_sequence[]= {16,17,23,18,26,15,25,22,19,11,12,13,24,14,20,21}; //channels hop sequence is given by kaumudi singh
uint8_t ch_offset_tx = 0;
uint8_t ch_select;

void tx_main()
{


    static uint8_t mac_association_permit = true;
    static uint8_t mac_gts_permit = false;              
    static uint8_t rx_on_when_idle = true; 
    static uint16_t ext_addr_only = MAC_EXTENDED_ADDRESS_ONLY;

    pib_set_get_request(gen_pib_id_t(MAC_EXTENDED_ADDRESS), (void *)ext_addr);
    pib_set_get_request(gen_pib_id_t(MAC_SHORT_ADDRESS), &ext_addr_only);
    pib_set_get_request(gen_pib_id_t(MAC_BEACON_PAYLOAD_LENGTH), &beacon_payload_length);
    pib_set_get_request(gen_pib_id_t(MAC_BEACON_PAYLOAD), (void*)beacon_payload);
    pib_set_get_request(gen_pib_id_t(MAC_RX_ON_WHEN_IDLE), &rx_on_when_idle);
    pib_set_get_request(gen_pib_id_t(MAC_ASSOCIATION_PERMIT), &mac_association_permit);
    pib_get_request_tx(gen_pib_id_t(MAC_GTS_PERMIT));
    pib_set_get_request(gen_pib_id_t(MAC_GTS_PERMIT), &mac_gts_permit);

    #define BEACON_ORDER 0x9u        // beacon interval = 7.68 sec   
    #define SUPERFRAME_ORDER 0x0u

 // start superframe structure 
    static mlme_start_req_t start_req =
	{
			.pan_id  = 0x1111,
			.logical_channel = 11,
			.start_time = 0x000000,
			.beacon_order = BEACON_ORDER,
			.superframe_order = SUPERFRAME_ORDER,
			.pan_coordinator = true,
			.battery_life_extension = false,
			.coord_realignment = false,
#if (CONFIG_SECURE == 1)
            .coord_realign_security_level = false,
            .beacon_security_level = false,
#endif
	};

    callback_called = false;
	mlme_start_req(&start_req, start_callback);
    while (!callback_called) {
        sys_task_run();
    }
   

    SEGGER_RTT_printf(0, "Sent the Start-Request: ");
    print_mac_status(start_req.confirm.status);
    SEGGER_RTT_printf(0, "\n");
    SEGGER_RTT_printf(0, " Channel : %u\n",start_req.logical_channel);
    SEGGER_RTT_printf(0,"Time :%u\n",sys_time_get());
   
    
while(true)
{
 SEGGER_RTT_printf(0, "cho: %d\n",ch_offset_tx); 
  for (i=0;;i++)
     {
          //channel = (ASN + ChannelOffset) % N , ASN-Absolute Slot Number,N-number of channels 
          
          ch_select = ((asn+ch_offset_tx)%(16));
          start_req.logical_channel = hop_sequence[ch_select];
          
          callback_called = false;
	  mlme_start_req(&start_req, start_callback);
          while (!callback_called) {
                   sys_task_run();
          }
          
//          nrf_delay_us(7864324);

          SEGGER_RTT_printf(0, "Sent the Start-Request: ");
          print_mac_status(start_req.confirm.status);
          SEGGER_RTT_printf(0, "\n");
          if(i==0)
          {
          SEGGER_RTT_printf(0, "i=%d",i);
          asn=asn+202;
          }
          else{
          SEGGER_RTT_printf(0, "i=%d",i);
          asn=asn+505;
          }

          asn_f[0]=((asn >> 24 ) & 0xFF);
          asn_f[1]=((asn >> 16 ) & 0xFF);
          asn_f[2]=((asn >> 8 ) & 0xFF);
          asn_f[3]=((asn ) & 0xFF);

          SEGGER_RTT_printf(0, " Channel : %u\n",start_req.logical_channel);
          printf("channel_select %u , asn %u , channel offset %u\n",ch_select,asn,ch_offset);
//          printf("asn_f = %x%x%x%x\n",asn_f[0],asn_f[1],asn_f[2],asn_f[3]);

           current_time=sys_time_get();
           time_sync=current_time-pervious_time;
           SEGGER_RTT_printf(0,"Time_sy :%u\n",time_sync);
           pervious_time=current_time;

          SEGGER_RTT_printf(0, "\n");

          time_sync_f[0]=((time_sync >> 24) & 0xFF);
          time_sync_f[1]=((time_sync >> 16) & 0xFF);
          time_sync_f[2]=((time_sync >> 8) & 0xFF);
          time_sync_f[3]=((time_sync) & 0xFF);
          

          beacon_payload[0] =asn_f[0];
          beacon_payload[1] =asn_f[1];
          beacon_payload[2] =asn_f[2];
          beacon_payload[3] =asn_f[3];
          beacon_payload[4] =time_sync_f[0];
          beacon_payload[5] =time_sync_f[1];
          beacon_payload[6] =time_sync_f[2];
          beacon_payload[7] =time_sync_f[3];

          pib_set_get_request(gen_pib_id_t(MAC_BEACON_PAYLOAD_LENGTH), &beacon_payload_length);
          pib_set_get_request(gen_pib_id_t(MAC_BEACON_PAYLOAD), (void*)beacon_payload);
                
     }
}
while(true)
{ 
  sys_task_run();
}
}

void print_data_ind(const mcps_data_ind_t* ind) {
    SEGGER_RTT_printf(0, "{src_pan_id: 0x%04x, ", ind->src_pan_id);
    print_addr(&(ind->src_addr), ind->src_addr_mode, "src_addr");
    SEGGER_RTT_printf(0, ", dst_pan_id: 0x%04x, ", ind->dst_pan_id);
    print_addr(&(ind->dst_addr), ind->dst_addr_mode, "dst_addr");
    SEGGER_RTT_printf(0, ", msdu_length: %u, sdu: 0x", ind->msdu_length);
    sdu_length=ind->msdu_length;
    for (size_t i = 0u; i < ind->msdu_length; i++) {
        SEGGER_RTT_printf(0, "%02x", ind->msdu.p_payload[i]);
    }
     for(z=0;z<12;z++)
     {
        sdu_data[z]=ind->msdu.p_payload[z+17];
     }
    SEGGER_RTT_printf(0, ", mpdu_link_quality: %u", ind->mpdu_link_quality);
    SEGGER_RTT_printf(0, ", dsn: %u", ind->dsn);
    SEGGER_RTT_printf(0, ", timestamp: %u}\n", ind->timestamp);
    SEGGER_RTT_printf(0, "\n");
    SEGGER_RTT_printf(0, "Time: %u ",sys_time_get());
    SEGGER_RTT_printf(0,"sud_data: %x%x%x%x\n",sdu_data[0],sdu_data[1],sdu_data[2],sdu_data[3]);

    sdu_data_dec=sdu_data[3];
    sdu_data_dec=sdu_data_dec | (sdu_data[2] <<8);
    sdu_data_dec=sdu_data_dec | (sdu_data[1] <<16);
    sdu_data_dec=sdu_data_dec | (sdu_data[0] <<24);
    
    SEGGER_RTT_printf(0,"sud_data in dec: %d\n",sdu_data_dec);


    memset(ind->msdu.p_payload, 0, sizeof(ind->msdu.p_payload)); //Clearing the recieved data from the msdu.p_payload
    SEGGER_RTT_printf(0,"sdu: %02x", ind->msdu.p_payload);
    SEGGER_RTT_printf(0, "\t k: %d ",k);
    SEGGER_RTT_printf(0, "\n");
    nrf_gpio_pin_toggle(LED_3);
    k+=1;	//Everytime a frame is received, value is incremented.
    if(k>=1 | k<4)
    {
      asn=sdu_data_dec+505;
      channel_id=((asn+ch_offset)%16);
      channel_id= channel_hop_seq[channel_id];
//      channel_id = channel_hop_seq[rand()%sizeof(channel_hop_seq)];  
      no_beacon_sleep=7800000;
    }
// for restarting board when RAM is full
    if(k>=4)
    {
//     NRF_TIMER2->TASKS_STOP=1;
     SEGGER_RTT_printf(0, "in tx\n");   
     nrf_delay_us(7864324);
     tx_main();

    }

}

void mcps_data_ind(mcps_data_ind_t* _ind) {
//    SEGGER_RTT_printf(0, "Received Data: \n");
    print_data_ind(_ind);
}

int main(void) {
    ral_irq_handler_import();

    SEGGER_RTT_Init();
    uint8_t rtt_buf_out[1024u];
    SEGGER_RTT_ConfigUpBuffer(0, "OUT", rtt_buf_out, 1024u,
                              SEGGER_RTT_MODE_NO_BLOCK_TRIM);
 
    app_task_init();
    sys_task_post(APP_TASK_ID);

    clock_init();

    SEGGER_RTT_printf(0, "....RESET....\n");
#if (CONFIG_SECURE == 1)
    SEGGER_RTT_printf(0, "Compiled with CONFIG_SECURE\n");
#endif

recieving_handle();
tx_main();
SEGGER_RTT_printf(0, "out of first reciever handle \n");

while(true)
{
sys_task_run();
}

   
}
//change

//Timer 2 interrupt function
void TIMER2_IRQHandler(void)
{        

            if (NRF_TIMER2->EVENTS_COMPARE[0] == 1)
            {
//              SEGGER_RTT_printf(0, "in interrupt 2\n");
              //NVIC_EnableIRQ( RADIO_IRQn );     //Enable radio interrupt to start receiving data again
             // SEGGER_RTT_printf(0, "Time: %u ",sys_time_get());
              NRF_TIMER2->EVENTS_COMPARE[0] = 0;              
            }
}

/*void TIMER3_IRQHandler(void)
{        

            if (NRF_TIMER3->EVENTS_COMPARE[0] == 1)
            {
              SEGGER_RTT_printf(0, "in interrupt 3\n");
              NVIC_EnableIRQ( RADIO_IRQn );
              NRF_TIMER3->EVENTS_COMPARE[0] = 0;
             
             
            }
}
*/

The experiment setup as follows:

• The TX will be transmitting the packets for every 7.8 Sec. This is an continues process.( TX code)
• The RX will be in scan mode, once the packet is received the RX follows the TX for 3 channel hops ( TX and RX code). Then the TX part comes and transmit the packets for 7.8 Sec, this part is giving as issue. The line of code which gives error is mlme_start_req(&start_req, start_callback) which is uesd in for loop in TX code.

Any solution to solve the problem.

Thanks in Advance

[Marjeris Romero]

Hi,

The assert happens when calling mlme_start_req. Have you read the 802.15.4 specification for when to call MLME-START.req (section 7.1.114.1)?  Is there a reason you are calling mlme_start_req() inside an infinite for loop? Have you check is this is supported in the spec?

[SKV]

Hello,

Thanks for replying. Yes I want it in infinite loop otherwise i can't set the beacon_order and superframe_order after each cycle. While studying the nRF52840 data sheet I came across NRF_RADIO->STATE,while testing the code the register value was at RX state when i changed the function of 802.15.4 from RX-to-TX. Is there a way to change the radio state to TX state?

Thank You.

[SKV]

Hello,

I tried it in TX state then also it is giving the same error. In nRF52840 data sheet the section 6.20.12.6, I tried doing it but the EVENTS_CCAIDLE=0, not in the idle mode, when this event is triggered the it is clear to send. I want to know how to set the radio in idle mode.

Thanks you

[SKV]

Hi,

I was able put the radio in idle mode also, still the same error.

[Marjeris Romero]

Hi,

Sorry for the late reply. Could you share your code with us so we can try to reproduce the issue at our end?

Best regards,

Marjeris