Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

RE: Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

Ethan.Shi — Wed, 05 Jan 2022 12:18:22 GMT

Hi Simon

To improve factory efficiency,

I have checked some materials and now Timeslot can work normally. Thanks again for the suggestion of using Timeslot,

I'm now ready to refine the code

Best regards,

Ethan

RE: Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

Simonr — Wed, 05 Jan 2022 11:42:56 GMT

Hi again Ethan

I'm struggling to see the use case you're going for here. Is there a reason you need both the radio test and the co-processor application as one sample rather than having two separate applications that you flash onto the device as needed?

According to mpsl_timeslot.h, the maximum timeslot length that can be set is 100ms. Do you need the timeslot to be longer than this during the radio testing? If so you need to extend it by requesting an extension using MPSL_TIMESLOT_SIGNAL_ACTION_EXTEND withing the timeslot event. MPSL_TIMESLOT_SIGNAL_SESSION_IDLE indicates that the timeout session has no more pending requests and is executed in the same context as mpsl_low_priority_process();

Best regards,

Simon

RE: Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

Ethan.Shi — Wed, 05 Jan 2022 06:54:49 GMT

I'm sorry，The previous description might have been confusing.Ignore the previous code.

I am currently working on merging the radio_test sample with the Coprocessor sample，I think timeslot can accomplish this task. I want to be free from the influence of OpenThread when conducting radio test.

I plan to extend timeslot to realize radio test normally. The delay process always receives the signal MPSL_TIMESLOT_SIGNAL_SESSION_IDLE and will not continue to delay. Is there any example of extending timeslot? The other examples I refer to are too old.

Best regards,

Ethan

RE: Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

Simonr — Wed, 05 Jan 2022 06:28:36 GMT

Hi Ethan

I need some more information on what exactly is failing in your OpenThread test, as it's hard to tell what's causing this error by just looking at your main file. I would suggest making the timeslots smaller however, to see if that helps at all.

Best regards,

Simon

RE: Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

Ethan.Shi — Tue, 04 Jan 2022 13:24:03 GMT

I want the RX port to always print F0，I configured the enum transmit_pattern pattern = TRANSMIT_PATTERN_11110000 in the radio_tx function.

Today, I solved this problem with the following code, causing the OpenThread test to fail.Using the Wpantund tool to test OpenThread, I think this has something to do with timeslot taking up time all the time. Is there any suggestion for modification.

#include <kernel.h>
#include <console/console.h>
#include <string.h>
#include <sys/printk.h>
#include <zephyr/types.h>
#include <irq.h>

#include <mpsl_timeslot.h>
#include <mpsl.h>
#include <hal/nrf_timer.h>

#include <shell/shell_uart.h>
#include <drivers/uart.h>
#include <init.h>


#define TIMESLOT_REQUEST_DISTANCE_US (1000000)
#define TIMESLOT_LENGTH_US           (20000)
#define TIMER_EXPIRY_US (TIMESLOT_LENGTH_US - 50)

#define MPSL_THREAD_PRIO             CONFIG_MPSL_THREAD_COOP_PRIO
#define STACKSIZE                    CONFIG_MAIN_STACK_SIZE
#define THREAD_PRIORITY              K_LOWEST_APPLICATION_THREAD_PRIO


extern void radio_tx(void);



static uint32_t extension_count;

/* MPSL API calls that can be requested for the non-preemptible thread */
enum mpsl_timeslot_call {
	OPEN_SESSION,
	MAKE_REQUEST,
	CLOSE_SESSION,
};

/* Timeslot requests */
static mpsl_timeslot_request_t timeslot_request_earliest = {
	.request_type = MPSL_TIMESLOT_REQ_TYPE_EARLIEST,
	//.params.earliest.hfclk = MPSL_TIMESLOT_HFCLK_CFG_NO_GUARANTEE,
    .params.normal.hfclk = MPSL_TIMESLOT_HFCLK_CFG_XTAL_GUARANTEED,
	//.params.earliest.priority = MPSL_TIMESLOT_PRIORITY_NORMAL,
    .params.normal.priority = MPSL_TIMESLOT_PRIORITY_HIGH,
	.params.earliest.length_us = TIMESLOT_LENGTH_US,
	.params.earliest.timeout_us = 1000000
};
static mpsl_timeslot_request_t timeslot_request_normal = {
	.request_type = MPSL_TIMESLOT_REQ_TYPE_NORMAL,
	//.params.normal.hfclk = MPSL_TIMESLOT_HFCLK_CFG_NO_GUARANTEE,
	.params.normal.hfclk = MPSL_TIMESLOT_HFCLK_CFG_XTAL_GUARANTEED,
    //.params.normal.priority = MPSL_TIMESLOT_PRIORITY_NORMAL,
	.params.normal.priority = MPSL_TIMESLOT_PRIORITY_HIGH,
    .params.normal.distance_us = TIMESLOT_REQUEST_DISTANCE_US,
	.params.normal.length_us = TIMESLOT_LENGTH_US
};

static mpsl_timeslot_signal_return_param_t signal_callback_return_param;

/* Message queue for printing the signal type from timeslot callback */
//K_MSGQ_DEFINE(callback_msgq, sizeof(uint32_t), 100, 4);

/* Message queue for requesting MPSL API calls to non-preemptible thread */
K_MSGQ_DEFINE(mpsl_api_msgq, sizeof(enum mpsl_timeslot_call), 10, 4);

static void error(void)
{
	printk("ERROR!\n");
	while (true) {
		/* Spin for ever */
		k_sleep(K_MSEC(1000));
	}
}


static mpsl_timeslot_signal_return_param_t *mpsl_timeslot_callback(
	mpsl_timeslot_session_id_t session_id,
	uint32_t signal_type)
{
        //printk("sig=%d\n",signal_type);
	(void) session_id; /* unused parameter */
        
	mpsl_timeslot_signal_return_param_t *p_ret_val = NULL;

	switch (signal_type) {

	case MPSL_TIMESLOT_SIGNAL_START:
		/* No return action */
                
                printk("START11\n");              
               // if(tx_flag==1)
               // {
                  //printk("start radio_tx\n");
                radio_tx();//Fixed parameter Radio tx function 
               // }
                //NRF_RADIO->POWER                = (RADIO_POWER_POWER_Enabled << RADIO_POWER_POWER_Pos);
                //NVIC_EnableIRQ(RADIO_IRQn);
                
		signal_callback_return_param.callback_action =
			MPSL_TIMESLOT_SIGNAL_ACTION_NONE;
		p_ret_val = &signal_callback_return_param;

		/* Setup timer to trigger an interrupt (and thus the TIMER0
		 * signal) before timeslot end.
		 */
		nrf_timer_cc_set(NRF_TIMER0, NRF_TIMER_CC_CHANNEL0,
			TIMER_EXPIRY_US);
		nrf_timer_int_enable(NRF_TIMER0, NRF_TIMER_INT_COMPARE0_MASK);

		break;
        case MPSL_TIMESLOT_SIGNAL_RADIO:
                
                break;

               
	case MPSL_TIMESLOT_SIGNAL_TIMER0:

		/* Clear event */
		
		
                /* Request new timeslot when callback returns */
                if (extension_count)
                {
                    extension_count--;
                    signal_callback_return_param.params.extend.length_us = TIMESLOT_LENGTH_US;
                    signal_callback_return_param.callback_action = MPSL_TIMESLOT_SIGNAL_ACTION_EXTEND;  //End the current timeslot and request a new one            
                }
                else
                {
                    signal_callback_return_param.callback_action = MPSL_TIMESLOT_SIGNAL_ACTION_END;  //End the current timeslot and request a new one
                }
        
                
		p_ret_val = &signal_callback_return_param;

		break;
        case MPSL_TIMESLOT_SIGNAL_EXTEND_FAILED:
                signal_callback_return_param.params.request.p_next = &timeslot_request_earliest;
                signal_callback_return_param.callback_action = MPSL_TIMESLOT_SIGNAL_ACTION_EXTEND;
                p_ret_val = &signal_callback_return_param;
                break;
                break;
        case MPSL_TIMESLOT_SIGNAL_EXTEND_SUCCEEDED:
                NRF_TIMER0->EVENTS_COMPARE[0]=0;
                NRF_TIMER0->TASKS_CLEAR = 1;
                //signal_callback_return_param.params.request.p_next = &timeslot_request_normal;
                signal_callback_return_param.callback_action = MPSL_TIMESLOT_SIGNAL_ACTION_EXTEND;
                p_ret_val = &signal_callback_return_param;
                break;
	case MPSL_TIMESLOT_SIGNAL_SESSION_IDLE:
		break;
	case MPSL_TIMESLOT_SIGNAL_SESSION_CLOSED:
		break;
	default:
		printk("unexpected signal: %u", signal_type);
		//error();
		break;
	}

	

	return p_ret_val;
}

void mpsl_timeslot_demo(void)
{
	int err;
	
	enum mpsl_timeslot_call api_call;


    extension_count = 1000;
	api_call = OPEN_SESSION;
	err = k_msgq_put(&mpsl_api_msgq, &api_call, K_FOREVER);
	if (err) {
		error();
	}
        
	api_call = MAKE_REQUEST;
	err = k_msgq_put(&mpsl_api_msgq, &api_call, K_FOREVER);
	if (err) {
                printk("198error\n");
		error();
	}

}

/* To ensure thread safe operation, call all MPSL APIs from a non-preemptible
 * thread.
 */
static void mpsl_nonpreemptible_thread(void)
{
	int err;
	enum mpsl_timeslot_call api_call = 0;

	/* Initialize to invalid session id */
	mpsl_timeslot_session_id_t session_id = 0xFFu;

	while (1) {
		if (k_msgq_get(&mpsl_api_msgq, &api_call, K_FOREVER) == 0) {
			switch (api_call) {
			case OPEN_SESSION:
				err = mpsl_timeslot_session_open(
					mpsl_timeslot_callback,
					&session_id);
				if (err) {
					error();
				}
				break;
			case MAKE_REQUEST:
				err = mpsl_timeslot_request(
					session_id,
					&timeslot_request_earliest);
				if (err) {
                                        printk("237error\n");
					error();
				}
				break;
			case CLOSE_SESSION:
				err = mpsl_timeslot_session_close(session_id);
				if (err) {
					error();
				}
				break;
			default:
				error();
				break;
			}
		}
	}
}


K_THREAD_DEFINE(mpsl_nonpreemptible_thread_id, STACKSIZE,
		mpsl_nonpreemptible_thread, NULL, NULL, NULL,
		K_PRIO_COOP(MPSL_THREAD_PRIO), 0, 0);

Best regards,

Ethan.Shi

RE: Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

Simonr — Tue, 04 Jan 2022 12:58:47 GMT

I don't see what the issue here is. What are you expecting to receive on the RX side here? I think having such a large timeslot might cause issues on the Thread side if there are time critical tasks to take care of, but if it's only to be a thread node for example I think it should be fine.

Best regards,

Simon

RE: Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

Ethan.Shi — Tue, 04 Jan 2022 09:11:09 GMT

Do you have any problems with my timeslot

Best regards,

Ethan.Shi

RE: Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

Ethan.Shi — Tue, 04 Jan 2022 09:08:26 GMT

This is my current Timeslot code .I wanted to keep Radio TX on for a long time, but actually testing phenomenon RX was wrong

#include <kernel.h>
#include <console\console.h>
#include <string.h>
#include <sys\printk.h>
#include <zephyr\types.h>
#include <irq.h>

#include <mpsl_timeslot.h>
#include <mpsl.h>
#include <hal\nrf_timer.h>

#include <shell\shell_uart.h>
#include <drivers\uart.h>
#include <init.h>



#define TIMESLOT_REQUEST_DISTANCE_US (1000000)
#define TIMESLOT_LENGTH_US           (20000)
#define TIMER_EXPIRY_US (TIMESLOT_LENGTH_US - 50)

#define MPSL_THREAD_PRIO             CONFIG_MPSL_THREAD_COOP_PRIO
#define STACKSIZE                    CONFIG_MAIN_STACK_SIZE
#define THREAD_PRIORITY              K_LOWEST_APPLICATION_THREAD_PRIO

extern void radio_tx(void);

static uint32_t extension_count;

/* MPSL API calls that can be requested for the non-preemptible thread */
enum mpsl_timeslot_call {
	OPEN_SESSION,
	MAKE_REQUEST,
	CLOSE_SESSION,
};

/* Timeslot requests */
static mpsl_timeslot_request_t timeslot_request_earliest = {
	.request_type = MPSL_TIMESLOT_REQ_TYPE_EARLIEST,
	//.params.earliest.hfclk = MPSL_TIMESLOT_HFCLK_CFG_NO_GUARANTEE,
    .params.normal.hfclk = MPSL_TIMESLOT_HFCLK_CFG_XTAL_GUARANTEED,
	//.params.earliest.priority = MPSL_TIMESLOT_PRIORITY_NORMAL,
    .params.normal.priority = MPSL_TIMESLOT_PRIORITY_HIGH,
	.params.earliest.length_us = TIMESLOT_LENGTH_US,
	.params.earliest.timeout_us = 1000000
};
static mpsl_timeslot_request_t timeslot_request_normal = {
	.request_type = MPSL_TIMESLOT_REQ_TYPE_NORMAL,
	//.params.normal.hfclk = MPSL_TIMESLOT_HFCLK_CFG_NO_GUARANTEE,
	.params.normal.hfclk = MPSL_TIMESLOT_HFCLK_CFG_XTAL_GUARANTEED,
    //.params.normal.priority = MPSL_TIMESLOT_PRIORITY_NORMAL,
	.params.normal.priority = MPSL_TIMESLOT_PRIORITY_HIGH,
    .params.normal.distance_us = TIMESLOT_REQUEST_DISTANCE_US,
	.params.normal.length_us = TIMESLOT_LENGTH_US
};

static mpsl_timeslot_signal_return_param_t signal_callback_return_param;

/* Message queue for printing the signal type from timeslot callback */
K_MSGQ_DEFINE(callback_msgq, sizeof(uint32_t), 10, 4);

/* Message queue for requesting MPSL API calls to non-preemptible thread */
K_MSGQ_DEFINE(mpsl_api_msgq, sizeof(enum mpsl_timeslot_call), 10, 4);

static void error(void)
{
	printk("ERROR!\n");
	while (true) {
		/* Spin for ever */
		k_sleep(K_MSEC(1000));
	}
}


static mpsl_timeslot_signal_return_param_t *mpsl_timeslot_callback(
	mpsl_timeslot_session_id_t session_id,
	uint32_t signal_type)
{
        printk("sig=%d\n",signal_type);
	(void) session_id; /* unused parameter */
        
	mpsl_timeslot_signal_return_param_t *p_ret_val = NULL;

	switch (signal_type) {

	case MPSL_TIMESLOT_SIGNAL_START:
		/* No return action */
      
        radio_tx();//Fixed parameter Radio tx function 
            
		signal_callback_return_param.callback_action =
			MPSL_TIMESLOT_SIGNAL_ACTION_NONE;
		p_ret_val = &signal_callback_return_param;

		/* Setup timer to trigger an interrupt (and thus the TIMER0
		 * signal) before timeslot end.
		 */
		nrf_timer_cc_set(NRF_TIMER0, NRF_TIMER_CC_CHANNEL0,
			TIMER_EXPIRY_US);
		nrf_timer_int_enable(NRF_TIMER0, NRF_TIMER_INT_COMPARE0_MASK);

		break;
        case MPSL_TIMESLOT_SIGNAL_RADIO:
                
                break;

               
	case MPSL_TIMESLOT_SIGNAL_TIMER0:

		/* Clear event */
		
                /* Request new timeslot when callback returns */
                
                if (extension_count)
                {
                    extension_count--;
                    signal_callback_return_param.params.extend.length_us = TIMESLOT_LENGTH_US;
                    signal_callback_return_param.callback_action = MPSL_TIMESLOT_SIGNAL_ACTION_EXTEND;  //End the current timeslot and request a new one         
                }
                else
                {
                    signal_callback_return_param.callback_action = MPSL_TIMESLOT_SIGNAL_ACTION_END;  //End the current timeslot and request a new one
                }
        
                
		p_ret_val = &signal_callback_return_param;

		break;
        case MPSL_TIMESLOT_SIGNAL_EXTEND_FAILED:
       
                break;
        case MPSL_TIMESLOT_SIGNAL_EXTEND_SUCCEEDED:
                NRF_TIMER0->EVENTS_COMPARE[0]=0;
                NRF_TIMER0->TASKS_CLEAR = 1;
                signal_callback_return_param.callback_action = MPSL_TIMESLOT_SIGNAL_ACTION_NONE;
                p_ret_val = &signal_callback_return_param;
                break;
	case MPSL_TIMESLOT_SIGNAL_SESSION_IDLE:
		break;
	case MPSL_TIMESLOT_SIGNAL_SESSION_CLOSED:
		break;
	default:
		printk("unexpected signal: %u", signal_type);
		error();
		break;
	}

	/* Put callback info in the message queue. */
	int err = k_msgq_put(&callback_msgq, &signal_type, K_NO_WAIT);

	if (err) {
                printk("164error\n");
		error();
	}

	return p_ret_val;
}

void mpsl_timeslot_demo(void)
{
	int err;
	
	enum mpsl_timeslot_call api_call;

    extension_count = 1000;
	api_call = OPEN_SESSION;
	err = k_msgq_put(&mpsl_api_msgq, &api_call, K_FOREVER);
	if (err) {
		error();
	}
        
	api_call = MAKE_REQUEST;
	err = k_msgq_put(&mpsl_api_msgq, &api_call, K_FOREVER);
	if (err) {
                printk("198error\n");
		error();
	}

}

/* To ensure thread safe operation, call all MPSL APIs from a non-preemptible
 * thread.
 */
static void mpsl_nonpreemptible_thread(void)
{
	int err;
	enum mpsl_timeslot_call api_call = 0;

	/* Initialize to invalid session id */
	mpsl_timeslot_session_id_t session_id = 0xFFu;

	while (1) {
		if (k_msgq_get(&mpsl_api_msgq, &api_call, K_FOREVER) == 0) {
			switch (api_call) {
			case OPEN_SESSION:
				err = mpsl_timeslot_session_open(
					mpsl_timeslot_callback,
					&session_id);
				if (err) {
					error();
				}
				break;
			case MAKE_REQUEST:
				err = mpsl_timeslot_request(
					session_id,
					&timeslot_request_earliest);
				if (err) {
                                        printk("237error\n");
					error();
				}
				break;
			case CLOSE_SESSION:
				err = mpsl_timeslot_session_close(session_id);
				if (err) {
					error();
				}
				break;
			default:
				error();
				break;
			}
		}
	}
}

static void console_print_thread(void)
{
	uint32_t signal_type = 0;

	while (1) {
		if (k_msgq_get(&callback_msgq, &signal_type, K_FOREVER) == 0) {
			switch (signal_type) {
			case MPSL_TIMESLOT_SIGNAL_START:
				printk("Callback: Timeslot start\n");
				break;
			case MPSL_TIMESLOT_SIGNAL_RADIO:
				printk("Callback: radio signal\n");
				break;
                        case MPSL_TIMESLOT_SIGNAL_TIMER0:
				printk("Callback: Timer0 signal\n");
				break;
			case MPSL_TIMESLOT_SIGNAL_SESSION_IDLE:
				printk("Callback: Session idle\n");
				break;
            case MPSL_TIMESLOT_SIGNAL_EXTEND_FAILED:
                    printk("Callback: extend failed\n");
                    break;
            case MPSL_TIMESLOT_SIGNAL_EXTEND_SUCCEEDED:
                   // printk("extension_count=%d\n",extension_count);
                    printk("Callback: extend succeed\n");
                    break;
			case MPSL_TIMESLOT_SIGNAL_SESSION_CLOSED:
				printk("Callback: Session closed\n");
				break;
			default:
				printk("Callback: Other signal: %d\n",
				       signal_type);
				break;
			}
		}
	}
}


K_THREAD_DEFINE(console_print_thread_id, STACKSIZE, console_print_thread,
		NULL, NULL, NULL, THREAD_PRIORITY, 0, 0);

K_THREAD_DEFINE(mpsl_nonpreemptible_thread_id, STACKSIZE,
		mpsl_nonpreemptible_thread, NULL, NULL, NULL,
		K_PRIO_COOP(MPSL_THREAD_PRIO), 0, 0);

RE: Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

Ethan.Shi — Tue, 04 Jan 2022 07:46:24 GMT

I now comment out SYS_INIT in radio_cmd.c, that is, radio_test_init is not called .

At this point, the shell echo on the emitter side is fine, but the sample code receiver receives the wrong data

This is one of my puzzles,Timeslot mechanism, I am trying to use it.

Happy New Year

Ethan.Shi

RE: Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

Simonr — Mon, 03 Jan 2022 08:54:55 GMT

I'm sorry, but I don't have much more specifics than that the shell module uses radio interrupts outside of the expected radio events, which is why the MPSL asserts. In order to use the radio_test functionalities you will have to port it to use timeslots instead, so that the radio has a specific time set for the radio_test to do what it's supposed to without interfering with thread/MPSL.

Best regards,

Simon

RE: Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

Ethan.Shi — Mon, 27 Dec 2021 09:36:55 GMT

Hi Simonr

The radio_test example includes shell init, which makes Openthrad not work properly,

I tried merging the code and found that the shell command line of audio_test was not displayed. Through testing, I found that the problem should be shell init priority. I am a novice, I want to know what is the specific reason of influence

Ethan.Shi

RE: Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

Ethan.Shi — Thu, 23 Dec 2021 11:49:54 GMT

Thank you very much for your tip,Simonr!

I'll try to fix it using TimesLots and get back to you.

Ethan.Shi

RE: Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

Simonr — Thu, 23 Dec 2021 06:58:33 GMT

This assert fails because your radio interrupts are only expected within a radio event. The radio_test is rather basic, and doesn't use the radio events that MPSL expects. I think it should be possible to port the radio_test sample to use timeslots instead, and make it work that way.

Best regards,

Simon

RE: Merge openThread and radio_test code, radio_test test MPSL assert:112,2235

Ethan.Shi — Wed, 22 Dec 2021 08:37:42 GMT

I use GPIO to control whether to enter OpenThread mode or Radio mode