RE: MPU FAULT

Einarh — Wed, 06 Apr 2022 09:27:25 GMT

Have you confirmed that it crashes before it is able to return to main?

If not, could you place similar prints before and after the k_sem_take call, and in your while loop, to get a better idea of exactly how far your program reaches?

Looking at similar cases, it seems like this could be related to running out of space in your stack, but I'm not sure what in your program would cause this.

I'm not able to easily see how you've set up your data processing stuff, is it running in its own thread that's started by initiate_modules()?

In that case, could it be that some thread keeps adding data to some queue that ends up overflowing?

-Einar

RE: MPU FAULT

Khuong Huynh — Wed, 06 Apr 2022 07:40:47 GMT

Here is a picture of the nRF terminal of the code running

As you can see the code runs according to my expectations until the "search" is done and then crashes.

RE: MPU FAULT

Khuong Huynh — Tue, 05 Apr 2022 14:26:49 GMT

The code crashes when after the LOG_INF("Asimuth search done"); in search.c line 36. When it tries to return to the main.c.

RE: MPU FAULT

Einarh — Tue, 05 Apr 2022 14:10:14 GMT

Thank you for explaining.

Do you know exactly what line of code your program crashes on?

-Einar

RE: MPU FAULT

Khuong Huynh — Tue, 05 Apr 2022 13:55:27 GMT

Hi!

I am trying to create an algorithm that uses an observer with an accept list to get the rssi value of an beacon(another NRF52DK). We are using an antenna switch that are giving us the possibility to measure the rssi value of two antennas.

The algorithm are supposed to activate the observer which send the rssi values to a data processor, alternating between the antennas. Here I have used an semaphore to wait until the observer have processed x numbers of rssi values. After the observer have processed the rssi values it releases the semaphore which lets our algorithm "get" the values from the data processor. The algorithm does this x-amount of times before it ends.

The error occurs after the algorithm are done, which makes the system to restart.

When running the code, i get the correct values from the Logging i have implemented in the code.

Main c

#include "initiater.h"
#include "search.h"


#define LOG_MODULE_NAME app

K_SEM_DEFINE(my_sem,0,1);
LOG_MODULE_REGISTER(LOG_MODULE_NAME);

int azimuth_reading[20][3];
int nulls_azimuth[1];
int min_encoder_search = 0;
int16_t max_encoder_search = 20;
int increment = 1;

void main(void)
{
	LOG_INF("Hello World! %s\n", CONFIG_BOARD);
	initiate_modules();
	k_sem_give(&my_sem);
	sweep_search(0, min_encoder_search, max_encoder_search,increment);
	k_sem_take(&my_sem, K_FOREVER);
	// if(err){
	// 	LOG_ERR("err:%d", err);
	// }
	while(1){

	}
}

Search.c

#include "search.h"

#define LOG_MODULE_NAME SEARCHER
LOG_MODULE_REGISTER(LOG_MODULE_NAME);

extern struct k_sem my_sem;

void sweep_search(bool state, int min_encoder_search, int16_t max_encoder_search, int increment){
    LOG_INF("Starting to search in Azimuth");
    int16_t readings[][3] = {0};
    int16_t index = 0;
    for (int i = 0; i < 10; i+= 1){
        //move_servo(state, i) bevege servo enten i asimuth til enkoder verdi i (ikke implementert enda)
        int16_t *buffer_data;
        LOG_INF("started");
        set_observer(true);
        LOG_INF("waiting");
        k_sem_take(&my_sem, K_FOREVER);
        LOG_INF("next");
        buffer_data = get_data();
        for (int i = 0; i < 3; i++){
            readings[index][i] = buffer_data[i];
        }
        int16_t encoder = readings[index][0];
        int16_t delta = readings[index][1];
        int16_t zigma = readings[index][2];
        LOG_INF("Encoder: %d, Delta: %d, Zigma %d, i: %d: ",encoder, delta, zigma, index);
        index+=1;
       

    }

    k_sem_give(&my_sem);
    LOG_INF("Azimuth search done");
}

Observer.c

#include "observer.h"
#define LOG_MODULE_NAME Observer
#define average_counter 5
LOG_MODULE_REGISTER(LOG_MODULE_NAME);

extern struct k_sem my_sem; 
bool send_data_state = true;

int set_observer(bool state){
	int err = 1;
	send_data_state = state;
	LOG_INF("Observer state changed to %d", send_data_state);
	return err = 0;

}

void set_switch(int state){
	//set gpio switch to value;
}

static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
			 struct net_buf_simple *ad)
{	
	if(send_data_state){
    	// rssi = KALMAN(rssi);
		static int counter = 0;
		static bool delta_zigma_state = false; // 0 = delta, 1 = zigma, 2 = done
		if(!delta_zigma_state){
			LOG_INF("counter: %d, rssi: %d, zigma: %d",counter,rssi,delta_zigma_state);
			send_data_delta(rssi, counter);
			counter +=1;
			if(counter >= average_counter){
				counter = 0;
				delta_zigma_state = true;
				
			}
		}
		else if(delta_zigma_state){
			LOG_INF("counter: %d, rssi: %d, zigma: %d ",counter,rssi, delta_zigma_state);
			send_data_zigma(rssi, counter);
			counter += 1;
			if(counter >= average_counter){
				delta_zigma_state = false;
				counter = 0;
				set_observer(false);
				k_sem_give(&my_sem);
				LOG_INF("given");
				
			}
		}

	}

	else{LOG_INF("rssi: %d", rssi);}

	





}


int add_filter_accept_list_from_string(const char *addr_str,const char *type){
    int err;
	bt_addr_le_t addr_le = {.a = BT_ADDR_LE_ANY, .type = BT_ADDR_LE_RANDOM};
	err = bt_addr_le_from_str(addr_str, type, &addr_le);
	if (err){
		LOG_ERR("error: %d", err);
	}
	err = bt_le_filter_accept_list_add(&addr_le);
	if (err){
		LOG_ERR("Could not add to acceptlist (error: %d)", err);
		return err;
	}
    return err;
}


int init_bluethooth_scan(){

	struct bt_le_scan_param scan_param = {
		.type       = BT_LE_SCAN_TYPE_ACTIVE,
		.options    = BT_LE_SCAN_OPT_FILTER_ACCEPT_LIST,
		.interval   = BT_GAP_SCAN_FAST_INTERVAL,
		.window     = BT_GAP_SCAN_FAST_WINDOW,
	};
	int err;
	LOG_INF("Starting Observer\n");
	/* Initialize the Bluetooth Subsystem */
	err = bt_enable(NULL);
	if (err) {
		LOG_ERR("Bluetooth init failed (err %d)\n", err);
		return err;
	}
    err = add_filter_accept_list_from_string("C8:4A:E6:23:F5:13", "(random)");
	if (err){
		LOG_ERR("Could not add to acceptlist (error: %d)", err);
		return err;
	}    
	LOG_INF("Bluetooth initialized\n");

	err = bt_le_scan_start(&scan_param, device_found);
	if (err) {
		LOG_ERR("Starting scanning failed (err %d)\n", err);
		return err;
	}
	return err;
}

Dataprocessor.c

#include "data_processor.h"

#define LOG_MODULE_NAME DATA_PROCESSOR
#define average_counter 5
LOG_MODULE_REGISTER(LOG_MODULE_NAME);


int8_t data_delta[average_counter];
int8_t data_zigma[average_counter];

void send_data_delta(int8_t rssi, int index){
    data_delta[index] = rssi;
}
void send_data_zigma(int8_t rssi, int index){
    data_zigma[index] = rssi;
}

int16_t *get_data(){

    static int16_t buffer_data[3];
    buffer_data[0] = (int16_t) get_encoder();
    buffer_data[1] = (int16_t) get_average(data_delta);
    buffer_data[2] = (int16_t) get_average(data_zigma);

    return buffer_data;

}

int8_t get_average(int8_t *list){
    int16_t average = 0;
    int8_t size = average_counter;
    for(int i = 0; i < size; i++){
        average += list[i];
    }
    average = average/size;
    return (int8_t) average;
}

prj.conf

# Configure logger
CONFIG_LOG=y
CONFIG_USE_SEGGER_RTT=n
CONFIG_LOG_BACKEND_UART=y
CONFIG_LOG_DEFAULT_LEVEL=3

#From observer
CONFIG_BT=y
CONFIG_BT_OBSERVER=y

# Configure buttons and LEDs
CONFIG_GPIO=y
CONFIG_DK_LIBRARY=y

# Enable the BLE modules from NCS
CONFIG_BT_NUS_CLIENT=y
CONFIG_BT_CENTRAL=y
CONFIG_BT_SCAN=y
CONFIG_BT_SCAN_FILTER_ENABLE=y
CONFIG_BT_SCAN_UUID_CNT=1
CONFIG_BT_GATT_DM=y
CONFIG_HEAP_MEM_POOL_SIZE=2048
CONFIG_BT_FILTER_ACCEPT_LIST=y
CONFIG_BT_SCAN_NAME_CNT=1

#Servomotors
CONFIG_GPIO=y
CONFIG_DK_LIBRARY=y


# Enable math.h
CONFIG_NEWLIB_LIBC=y

#vet ikke
CONFIG_MAIN_STACK_SIZE=1024
CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=4096

Hope this gives a better picture of what I am trying to implement.

Thanks in advance.

RE: MPU FAULT

Einarh — Tue, 05 Apr 2022 13:22:24 GMT

Hello!

It would probably help with a bit more context.

What are you trying to do?

Are your semaphores properly defined when you use them?

Best regards,

Einar