Hi All,
I want to configure 64 MHz internal oscillator (HFINT) on my nRF9160 DK to reduce the wakeup time of nRF9160 chip from system-off mode. Is there any example available to answer this issue.
Thank You
Ubaid
Hi All,
I want to configure 64 MHz internal oscillator (HFINT) on my nRF9160 DK to reduce the wakeup time of nRF9160 chip from system-off mode. Is there any example available to answer this issue.
Thank You
Ubaid
Hi,
The modem would turn on the HFXO, which uses a very small time to start up compared to the LF clk (typ. 200 ms).
To minimize the startup time, disable all printing in both SPM and your application.
In SPM prj.conf, try adding:
CONFIG_SPM_BOOT_SILENTLY=y
CONFIG_SERIAL=n
In your application prj.conf, try adding:
CONFIG_SERIAL=n
Then try to measure the time from wakeup in SystemOFF mode (essentially, the time from reset to main).
Kind regards,
Håkon
Hakon,
Application: My application goes to system-off mode normally when there is nothing to do. Whenever there is something on UART Rx(sense on UART Rx pin), it wakes up and read that data from UART Rx and send acknowledgment. I am calculating the time by taking the difference between receiving something on UART Rx line and set one pin high before doing anything in main program.
Problem: There are two type of delays whenever it receives on UART Rx(wakeup from system-off mode) 410ms and 1.8s. I can bear the delay upto 410ms but I don't understand why it takes too long to wakeup. What is the reason behind getting two delays?
Here are my observations,
1. Actually, my application wakeups by recieving some messages on UART(configured on external lines). Therefore, turning UART off doesn't wakeup from systemoff mode as sense didn't work while UART off.
2. I also tried CONFIG_SPM_BOOT_SILENTLY=y but it increases the response time. That is why I wanted to speed up the response by configuring fast clock. Please suggest, Is there any way to configure 64MHz clock and run my program on it?
3. I also tried while turing off all the print statments in SPM and in my application but doesn't change the response time.
4. I also tried to change clock to RC Oscillator(as its startup time is 600us) but at the end it increases the response time.
possible reasons behind the problem are
a. Program goes to someother files before starting reading from main.c file e.g. init.c, stack.h, cmiss_gcc.h, core_cm33.h, exc.h, kernel_arch_func.h etc. Can I cut down this startup code or bypass it somehow?
b. How can I bypass k_cpu_idol() or wakeup from this mode?
Thank you
Ubaid
Hi,
Ubaid said:1. Actually, my application wakeups by recieving some messages on UART(configured on external lines). Therefore, turning UART off doesn't wakeup from systemoff mode as sense didn't work while UART off.
You should disable the UART, and prepare the GPIOs to wake up. If you just enter systemoff, the GPIOs will be latched in its current configuration, and you then have a GPIO conflict.
Ubaid said:I also tried CONFIG_SPM_BOOT_SILENTLY=y but it increases the response time. That is why I wanted to speed up the response by configuring fast clock. Please suggest, Is there any way to configure 64MHz clock and run my program on it?
Did you disable serial in SPM .conf file and reconfigure the project?
The 64M clock doesn't require many hundred micro seconds to start up. The LFCLK uses typ. 200 ms, so there is something else, like debug logging or similar that
Ubaid said:
3. I also tried while turing off all the print statments in SPM and in my application but doesn't change the response time.
What does your application do? Do you wait for the LTE link before entering main? Please share your prj.conf file.
Ubaid said:Program goes to someother files before starting reading from main.c file e.g. init.c, stack.h, cmiss_gcc.h, core_cm33.h, exc.h, kernel_arch_func.h etc. Can I cut down this startup code or bypass it somehow?
No. Those are standard headers, and include initialization of your memory, the rtos kernel, etc.
Ubaid said:b. How can I bypass k_cpu_idol() or wakeup from this mode?
Where is this called from? k_cpu_idle() will awake the CPU when a interrupt occurs.
Kind regards,
Håkon
Hi,
My application is a card reader application using a UART port. Therefore, I need to read the data from the card when presented and otherwise stays low power mode.
How can I read from UART by disabling it at first? Is there any way to enable it within program when required?
Did you disable serial in SPM .conf file and reconfigure the project?
Yes, but I got error while building again defined UART interface gives the error.
Where is this called from? k_cpu_idle() will awake the CPU when a interrupt occurs.
As, I mentioned earlier, I got two delays. short 410 ms (my application works in this delay) and long 1.8s (doesn't work in this delay). Therefore, Is there any chance of program goes into system off mode while it is in k_cpu_idle() condition? Can it cause long delays?
main.c
#include <zephyr.h>
#include <uart.h>
#include <device.h>
#include <gpio.h>
#include <hal/nrf_regulators.h>
#include <hal/nrf_gpio.h>
#include <hal/nrf_power.h>
#include <lte_lc.h>
#include <bsd.h>
#define WAKEUP_PIN NRF_GPIO_PIN_MAP(0,12)
static u8_t uart_rx_buf[40];
int uart_rx_lth;
static u8_t uart_buf[40];
static u8_t *uart_tx_buf_ptr;
static u8_t uart_ack[] = {0x02,0x02};
int uart_tx_lth=0;
static u8_t comp_buf[] = {0x12,0x20,0x93,0x23,0x32} ;
static u8_t savi_buf1 = 0x00;
static u8_t RxFlag = 0x00;
struct k_timer my_timer;
int uart_ptr;
int uart_tx_idx;
int sleep = 0;
int counter = 0;
struct device *uart;
struct device *dev;
int uartreg = 2;
/**@brief Recoverable BSD library error. */
void bsd_recoverable_error_handler(uint32_t err)
{
//printk("bsdlib recoverable error: %u\n", err);
}
/**@brief Irrecoverable BSD library error. */
void bsd_irrecoverable_error_handler(uint32_t err)
{
//printk("bsdlib irrecoverable error: %u\n", err);
__ASSERT_NO_MSG(false);
}
void my_expiry_function(struct k_timer *timer_id){
if (uart_ptr==14)
{
uart_irq_rx_disable(uart);
uart_rx_lth=uart_ptr;
int i;
for (i=0; i< uart_rx_lth; i++)
{
uart_rx_buf[i]=uart_buf[i];
}
RxFlag = 0x01;
uart_tx_idx=0;
uart_tx_lth=2;
uart_tx_buf_ptr=uart_ack;
gpio_pin_write(dev, 16, 1);
uart_irq_tx_enable(uart);
}
else
{
}
uart_ptr = 0;
}
void uart_cb(struct device *x)
{
uart_irq_update(x);
int data_length = 0;
if(uart_irq_rx_ready(x)){
k_timer_stop(&my_timer);
k_timer_start(&my_timer, K_MSEC(3), 0);
while (uart_irq_rx_ready(x)) {
data_length = uart_fifo_read(x, &(uart_buf[uart_ptr]), sizeof(uart_buf));
uart_ptr+= data_length;
}
}
if (uart_irq_tx_ready(x)) {
if (uart_tx_idx<uart_tx_lth){
uart_tx_idx+=uart_fifo_fill(x,(u8_t *)uart_tx_buf_ptr, 1);
uart_tx_buf_ptr++;
}
else{
/* If we transmitted everything, stop IRQ stream,
* otherwise main app might never run.
*/
uart_irq_tx_disable(x);
gpio_pin_write(dev, 16, 0);
uart_irq_rx_enable(uart);
}
}
sleep = 1;
}
void main(void)
{
dev= device_get_binding("GPIO_0");
gpio_pin_configure(dev, 17, GPIO_DIR_OUT); // Pin17
gpio_pin_write(dev, 17, 1);
k_sleep(5);
gpio_pin_write(dev, 17, 0);
/* gpio_pin_configure(dev, 2, GPIO_DIR_OUT); // LED1
gpio_pin_configure(dev, 3, GPIO_DIR_OUT); // LED2
gpio_pin_configure(dev, 4, GPIO_DIR_OUT); // LED3*/
gpio_pin_configure(dev, 16, GPIO_DIR_OUT); // Pin17
k_timer_init(&my_timer, my_expiry_function, NULL);
uart_ptr = 0;
uint32_t rr = nrf_power_resetreas_get();
if(rr & POWER_RESETREAS_OFF_Msk)
{
//Clear all RESETREAS when waking up from System OFF sleep by GPIO.
nrf_power_resetreas_clear(0x70017);
uart = device_get_binding("UART_1");
uart_irq_callback_set(uart, uart_cb);
uart_irq_rx_enable(uart);
}
// Due to errata 4, Always configure PIN_CNF[n].INPUT before PIN_CNF[n].SENSE.
nrf_gpio_cfg_input(WAKEUP_PIN,NRF_GPIO_PIN_PULLUP);
nrf_gpio_cfg_sense_set(WAKEUP_PIN,NRF_GPIO_PIN_SENSE_LOW);
// We readback the pin config, and print it.
uint32_t cnf = NRF_P0_NS->PIN_CNF[WAKEUP_PIN];
NRF_P0_NS->PIN_CNF[WAKEUP_PIN] = cnf | (GPIO_PIN_CNF_SENSE_Low << GPIO_PIN_CNF_SENSE_Pos);
while (1) {
// The LTE modem also needs to be stopped,
// by issuing a command through the modem API, before entering System OFF mode.
// Once the command is issued, one should wait for the modem to respond that it actually has stopped
// as there may be a delay until modem is disconnected from the network.
if(sleep == 0){
gpio_pin_write(dev, 3, 1);
lte_lc_power_off();
bsd_shutdown(); // Method to gracefully shutdown the BSD library.
nrf_regulators_system_off(NRF_REGULATORS_NS);
}
gpio_pin_write(dev, 4, 1);
k_sleep(50);
gpio_pin_write(dev, 4, 0);
k_sleep(50);
gpio_pin_write(dev, 3, 0);
counter++;
if(counter == 10)
{
sleep = 0;
counter = 0;
}
RxFlag = 0x00;
uart_ptr = 0;
sleep = 0;
counter = 0;
}
}
UART pins are Rx P.0.12 and Tx P.0.11
It is difficult to recreate the project but this code will help you understand what I want to do.
prj.conf
CONFIG_GPIO=y CONFIG_SERIAL=y CONFIG_TRUSTED_EXECUTION_NONSECURE=y CONFIG_UART_INTERRUPT_DRIVEN=y CONFIG_UART_0_NRF_UARTE=y CONFIG_UART_1_NRF_UARTE=y CONFIG_BSD_LIBRARY=y CONFIG_ASSERT=y CONFIG_TEST_RANDOM_GENERATOR=y # Network CONFIG_NETWORKING=y CONFIG_NET_SOCKETS=y CONFIG_NET_SOCKETS_OFFLOAD=y CONFIG_AT_HOST_LIBRARY=y CONFIG_LTE_LINK_CONTROL=y CONFIG_LTE_AUTO_INIT_AND_CONNECT=n CONFIG_MAIN_STACK_SIZE=4096 CONFIG_HEAP_MEM_POOL_SIZE=1024
Hi,
Ubaid said:My application is a card reader application using a UART port. Therefore, I need to read the data from the card when presented and otherwise stays low power mode.
That is fine, the important part is to disable serial in SPM, as that prints pages worth of data. You'll likely add a bit of delay by having printing in the boot up, but that should not be many milliseconds, unless you print alot.
How are you testing this (ie: what GPIOs etc)? Instead of entering system off, as you then have to sample both the wakeup signal, and the GPIO, could you try to do something like this?
int main(void)
{
/* Configure GPIOs etc*/
gpio_pin_write(dev, my_pin, 1);
/* Rest of init*/
...
while(1) {
if (1) {
k_sleep(1000);
gpio_pin_write(dev, my_pin, 0);
sys_reboot(0);
}
}
}This should eliminate any delay in the wake up signal, ie the time the nRF is in systemoff.
Kind regards,
Håkon
Hi,
Ubaid said:My application is a card reader application using a UART port. Therefore, I need to read the data from the card when presented and otherwise stays low power mode.
That is fine, the important part is to disable serial in SPM, as that prints pages worth of data. You'll likely add a bit of delay by having printing in the boot up, but that should not be many milliseconds, unless you print alot.
How are you testing this (ie: what GPIOs etc)? Instead of entering system off, as you then have to sample both the wakeup signal, and the GPIO, could you try to do something like this?
int main(void)
{
/* Configure GPIOs etc*/
gpio_pin_write(dev, my_pin, 1);
/* Rest of init*/
...
while(1) {
if (1) {
k_sleep(1000);
gpio_pin_write(dev, my_pin, 0);
sys_reboot(0);
}
}
}This should eliminate any delay in the wake up signal, ie the time the nRF is in systemoff.
Kind regards,
Håkon