NRF9160 Disable UART and RX pin into an interrupt pin

RE: NRF9160 Disable UART and RX pin into an interrupt pin

Kazi Afroza Sultana — Wed, 14 Jun 2023 13:51:58 GMT

Thanks for sharing the code. I am glad that you have fixed the issue.

RE: NRF9160 Disable UART and RX pin into an interrupt pin

Lamdev — Tue, 13 Jun 2023 09:16:30 GMT

Hello,

Thanks for your help,

I found a solution that was the following, if this can help someone.

void button_pressed(const struct device *dev, struct gpio_callback *cb,
		    uint32_t pins)
{
	int ret;

	printk("Button pressed\r\n");

	ret = gpio_pin_interrupt_configure(button.port,button.pin,GPIO_INT_DISABLE);		//GPIO_INT_EDGE_BOTH
	if (ret != 0) {
		printk("Error disable INT\r\n");
		return;
	}
	
	//restart_uart();
	k_work_submit(&button_action_work);
	//flag_interrupt = 1;
}

//gpio for UART interrupt definition
void configure_int_rx(void){
	int ret;

	printk("configure interrupt\r\n");

	if (!device_is_ready(button.port)) {
		printk("Error config INT 1\r\n");
		return;
	}
	
	ret = gpio_pin_configure(button.port,button.pin,GPIO_INPUT);
	if (ret != 0) {
		printk("Error config INT 2\r\n");
		return;
	}

	ret = gpio_pin_interrupt_configure(button.port,button.pin,GPIO_INT_EDGE_TO_ACTIVE);		//GPIO_INT_EDGE_BOTH
	if (ret != 0) {
		printk("Error config INT 3\r\n");
		return;
	}

	gpio_init_callback(&button_cb_data, button_pressed, BIT(button.pin));

	ret = gpio_add_callback(button.port, &button_cb_data);
	if (ret != 0) {
		printk("Error config INT 4\r\n");
		return;
	}

	printk("Config INT OK\r\n");
}

void timer_disable_uart_work_fn(struct k_work *work)
{
	disable_uart();
    configure_int_rx();
}

void process_work_timer_uart_disable(void){
	//scehdule a time to disable uart
    //cancel last schedule
    if(k_work_delayable_busy_get(&timer_disable_uart_work) != 0 ){
        k_work_cancel_delayable(&timer_disable_uart_work);
		while(k_work_delayable_busy_get(&timer_disable_uart_work) != 0 );	//wait until cancelation finnish
    }
    //enable new schedule
    k_work_schedule(&timer_disable_uart_work, K_SECONDS(WAIT_UART_DISABLE));
}

/* other code line to use to work */
#define SWIN3_NODE	DT_ALIAS(swin3)
#if !DT_NODE_HAS_STATUS(SWIN3_NODE, okay)
#error "Unsupported board: SWIN3 devicetree alias is not defined"
#endif


static const struct gpio_dt_spec button = GPIO_DT_SPEC_GET_OR(SWIN3_NODE, gpios,0); 
static struct gpio_callback button_cb_data;

K_WORK_DEFINE(button_action_work, button_action_work_handler);
void button_action_work_handler(struct k_work *work) {
    //do_something_because_a_button_was_pressed();
	restart_uart();
}

static struct k_work_delayable timer_disable_uart_work;

k_work_init_delayable(&timer_disable_uart_work,timer_disable_uart_work_fn);

RE: NRF9160 Disable UART and RX pin into an interrupt pin

Kazi Afroza Sultana — Mon, 05 Jun 2023 09:46:29 GMT

Hello,

We think the problem lies where it is starting and stopping the UART. Can you check this (+) How can I enable and disable UART devices at run time on nRF9160? - Nordic Q&A - Nordic DevZone - Nordic DevZone (nordicsemi.com) case? You may need to check the RXTO event.

Thanks.

Kazi

RE: NRF9160 Disable UART and RX pin into an interrupt pin

Lamdev — Wed, 17 May 2023 16:23:41 GMT

I have a better answer now,

void button_pressed(const struct device *dev, struct gpio_callback *cb,
		    uint32_t pins)
{
	int ret;
	ret = gpio_pin_interrupt_configure_dt(&button,GPIO_INT_DISABLE);		//GPIO_INT_EDGE_BOTH
	if (ret != 0) {
		printk("Error disable INT\r\n");
		return;
	}
	printk("Button pressed\r\n");
	restart_uart();

}

uint8_t restart_uart(void){

    NRF_UARTE0_NS->PSEL.RXD = 6;
    NRF_UARTE0_NS->PSEL.TXD = 7;
    NRF_UARTE0_NS->ENABLE = 8;
    NRF_UARTE0_NS->TASKS_STARTRX = 1;
    NRF_UARTE0_NS->TASKS_STARTTX = 1;

    send_uart_data_char("UART RESTARTED\r\n");

    //initControlUart();

    printk("restart uart\r\n");
}

I correctly have an answer from my UART, i correctly receive "UART RESTARTED".

But 2 errors messages stay :

- ERROR : uart_rx_buf_rsp Failed

- UART_TX_ABORTED

The first one come from uart libray and the other one come from my uart callback function

static void uart_callback(const struct device *dev, struct uart_event *evt, struct uart_info_struct *user_data){
    uint8_t *buffer, error;
	switch(evt->type){
		case UART_RX_RDY:
		    //printk("RCV %d bytes\n", evt->data.rx.len);
            if(user_data->cmd_buffer_len < CMD_BUFF_LEN){
                if((user_data->cmd_buffer_len + evt->data.rx.len) <= CMD_BUFF_LEN){
                    //case of new data less than remaining space in cmd_buffer
                    memcpy(user_data->cmd_buffer + user_data->cmd_buffer_len, evt->data.rx.buf + evt->data.rx.offset, evt->data.rx.len);
                    user_data->cmd_buffer_len += evt->data.rx.len;
                }else{
                    //case of new data more than remaining space
                    memcpy(user_data->cmd_buffer + user_data->cmd_buffer_len, evt->data.rx.buf + evt->data.rx.offset, CMD_BUFF_LEN - user_data->cmd_buffer_len);
                    user_data->cmd_buffer_len += CMD_BUFF_LEN - user_data->cmd_buffer_len;
                }
            }
            process_buffer(user_data);
		break;
		case UART_TX_ABORTED:
		    printk("UART_TX_ABORTED\n");
		break;
		case UART_TX_DONE:
		    //printk("UART_TX_DONE\n");
            //printk("+SEM=%d\n",k_sem_count_get(user_data->tx_semaphore));
            k_sem_give(user_data->tx_semaphore);
            //printk("+SEM=%d\n",k_sem_count_get(user_data->tx_semaphore));
		break;
		case UART_RX_BUF_REQUEST:
            //printk("UART_RX_BUF_REQUEST\n");
            buffer = k_malloc(RX_BUFF_LEN);
            if(buffer == NULL){
                printk("ERROR : RX_BUF_REQUEST Failed to allocate buffer\n");
                return;
            }
            error = uart_rx_buf_rsp(uart_info.dev, buffer, RX_BUFF_LEN);
            if(error != 0){
                printk("ERROR : uart_rx_buf_rsp Failed\n");
                return;
            }
		break;
            case UART_RX_BUF_RELEASED:
            k_free(evt->data.rx_buf.buf);
            //printk("UART_RX_BUF_RELEASED\n");
		break;
		case UART_RX_DISABLED:
		    printk("UART_RX_DISABLED\n");
		break;
		case UART_RX_STOPPED:
		    printk("UART_RX_STOPPED\n");
		break;
	}
}

I think i'm on the right way,

do you have advice about that ?

Best regards,

Lam

RE: NRF9160 Disable UART and RX pin into an interrupt pin

Lamdev — Wed, 17 May 2023 10:19:47 GMT

I found my error, lin 1, I define SWIN3_NODE and line 6 i use SWIN3. That wrong, i need to write on line 6 : "SWIN3_NODE"

I have add in "configure_int_rx" function,

if (!device_is_ready(button.port)) {
		printk("Error");
		return;
	}

At the top of the function

//gpio for UART interrupt definition
void configure_int_rx(void){
	int ret;

	printk("configure interrupt\r\n");

	if (!device_is_ready(button.port)) {
		printk("Error");
		return;
	}

	ret = gpio_pin_configure_dt(&button,GPIO_INPUT);
	if (ret != 0) {
		printk("Error");// %d: failed to configure %s pin %d\n",
		      // ret, button.port->name, button.pin);
		return;
	}

	printk("test1\r\n");

	ret = gpio_pin_interrupt_configure_dt(&button,GPIO_INT_EDGE_TO_ACTIVE);		//GPIO_INT_EDGE_BOTH
	if (ret != 0) {
		printk("Error");// %d: failed to configure interrupt on %s pin %d\n",
			//ret, button.port->name, button.pin);
		return;
	}

	printk("test2\r\n");

	gpio_init_callback(&button_cb_data, button_pressed, BIT(button.pin));
	gpio_add_callback(button.port, &button_cb_data);
	printk("Set up button");// at %s pin %d\n", button.port->name, button.pin);
}

No I'm trying to disable, my interrupt to reenable the uart when my interrupt occur.

When my interrupt occur, my callback function do that :

void button_pressed(const struct device *dev, struct gpio_callback *cb,
		    uint32_t pins)
{
	const struct device * gpio_dev = DEVICE_DT_GET(DT_NODELABEL(gpio0));
    gpio_pin_configure(gpio_dev,6, GPIO_DISCONNECTED);
	printk("Button pressed\r\n");
	restart_uart();

}

In my "restart_uart", i do that

uint8_t restart_uart(void){


   const struct device *uart = DEVICE_DT_GET(DT_NODELABEL(uart0));

    if (!device_is_ready(uart)) {
        printk("error device ready\r\n");
        return;
    }
    initControlUart();
    printk("restart uart\r\n");
}

When my initControlUart is executed, i have an error in this code:

 error = uart_rx_enable(uart_info.dev, buffer, RX_BUFF_LEN, RX_RCV_TIMEOUT);
    if(error != 0){
        printk("ERROR : Unable to init RX\n");
        return -1;
    }

That works great at init but when i try to restart that's not work. It seems that RX gpio stay unable to be configure in RX

Update below

Best regards,

lam

RE: NRF9160 Disable UART and RX pin into an interrupt pin

Lamdev — Wed, 17 May 2023 09:44:37 GMT

Hello,

I'm able to disable my uart with this part of code :

uint8_t disable_uart(void){

    //Disable uart0 which use to exchange message between modem and an external device
    NRF_UARTE0_NS->TASKS_STOPTX = 1;
    NRF_UARTE0_NS->TASKS_STOPRX = 1;
    NRF_UARTE0_NS->ENABLE = 0;

    //configure RX pin int o input gpio
    const struct device * gpio_dev = DEVICE_DT_GET(DT_NODELABEL(gpio0));
    gpio_pin_configure(gpio_dev,6, GPIO_INPUT);
   
}

And i obtain an power consumption arround 6uA.

Now i'm trying to convert my RX gpio into an interrupt GPIO but without success.

I have try this after checking information in the sample button in SDK

#define SWIN3_NODE	DT_ALIAS(swin3)
#if !DT_NODE_HAS_STATUS(SWIN3_NODE, okay)
#error "Unsupported board: SWIN3 devicetree alias is not defined"
#endif

static const struct gpio_dt_spec button = GPIO_DT_SPEC_GET_OR(SWIN3, gpios,{0}); 
static struct gpio_callback button_cb_data;

void button_pressed(const struct device *dev, struct gpio_callback *cb,
		    uint32_t pins)
{
	printk("Button pressed\r\n");
}

//gpio for UART interrupt definition
void configure_int_rx(void){
	int ret;

	printk("configure interrupt\r\n");

	ret = gpio_pin_configure_dt(&button,GPIO_INPUT);
	if (ret != 0) {
		printk("Error");// %d: failed to configure %s pin %d\n",
		      // ret, button.port->name, button.pin);
		return;
	}

	printk("test1\r\n");

	ret = gpio_pin_interrupt_configure_dt(&button,GPIO_INT_EDGE_TO_ACTIVE);		//GPIO_INT_EDGE_BOTH
	if (ret != 0) {
		printk("Error");// %d: failed to configure interrupt on %s pin %d\n",
			//ret, button.port->name, button.pin);
		return;
	}

	printk("test2\r\n");

	gpio_init_callback(&button_cb_data, button_pressed, BIT(button.pin));
	gpio_add_callback(button.port, &button_cb_data);
	printk("Set up button");// at %s pin %d\n", button.port->name, button.pin);

}

The resultat that i obtain is a reboot of my board every time the code start to execute "configure_int_rx" function.

Update below

thanks for your help,

Best regards,

Lam

RE: NRF9160 Disable UART and RX pin into an interrupt pin

Kazi Afroza Sultana — Tue, 16 May 2023 16:37:33 GMT

Hello,

''So i'm thinking to stop UART completely and waiting an interrupt on my RX line that i will have convert into interrupt GPIO. And when interrupt coming, i reactivate my uart to receive data.

This way is possible ?''

The work sequence of drive (Low power uART) is :

The transmitter initiates the transmission by calling uart_tx().
The driver reconfigures the REQ line to input with pull-up and enables the detection of high to low transition.
The line is set to high due to the pull-up register, and that triggers an interrupt on the RDY line.
On that interrupt, the driver starts the UART receiver.
When the receiver is ready, the driver reconfigures the RDY line to output low.
Then, the driver reconfigures the RDY line to input with pull-up and enables the interrupt on detection of high to low transition.
This sequence results in a short pulse on the line, as the line goes low and high.
The initiator detects the pulse and starts the standard UART transfer.
When the transfer is completed, the driver reconfigures the REQ line to the initial state: output set to low. This results in a line state change.
As the line goes low, the receiver detects the change. This indicates that the UART receiver can be stopped.'

So, I think this is possible.

RE: NRF9160 Disable UART and RX pin into an interrupt pin

Lamdev — Tue, 16 May 2023 07:21:16 GMT

Hello,

Thanks for your return,

It's connected to a specific board that i have develop.

My objectif is to reduce power consumption to 50uA.

So i'm thinking to stop UART completely and waiting an interrupt on my RX line that i will have convert into interrupt GPIO. And when interrupt coming, i reactivate my uart to receive data.

This way is possible ?

Best regards,

Lam

RE: NRF9160 Disable UART and RX pin into an interrupt pin

Kazi Afroza Sultana — Tue, 16 May 2023 06:59:18 GMT

Hello,

Which device are you connecting the nRF9160 to over UART? if it's another nordic device, you can use our low-power UART driver.

https://developer.nordicsemi.com/nRF_Connect_SDK/doc/latest/nrf/samples/peripheral/lpuart/README.html

''The low power UART driver implements the standard asynchronous UART API that can be enabled with the CONFIG_UART_ASYNC_API configuration option. Alternatively, you can also enable the interrupt-driven UART API using the CONFIG_NRF_SW_LPUART_INT_DRIVEN configuration option.

The protocol used by this driver implements two control lines, instead of standard hardware flow control lines, to allow for disabling the UART receiver during the idle period. This results in low power consumption, as you can shut down the high-frequency clock when UART is in idle state.''

Thanks.

Kazi

RE: NRF9160 Disable UART and RX pin into an interrupt pin

Kazi Afroza Sultana — Fri, 12 May 2023 15:11:15 GMT

Hello Lam,

I have been working in your case. I will get back to you shortly.

Thanks.

Kazi