Hi
I am using ADXL362 moving sensor in my nrf5340 custom board. In a previous ticket I could achieve to read its registers by modifying the overlay file
according to my hardware design. Now I want to know how can I write to its registers by SPI commands. For example I want to increase its g measurement
range from 1g to 8g. For your information I am using nRF connect for Desktop software for writing and programing my custom board.
Thank you in advance for your support.
Best Regards
Saeed Mahvis
saeed mahvis said:adxl362_set_range(dev,8);
Did you include appropriate header files / libraries for using these functions?
Please send complete minimal project as a zip file so that I could compile it and reproduce the error you are facing.
It seems that you are missing library include etc.
Hi Naeem
Below is my main code:
/*
* Copyright (c) 2018 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
*/
/** @file
* @brief Nordic UART Bridge Service (NUS) sample
*/
#include <zephyr/types.h>
#include <zephyr.h>
#include <drivers/uart.h>
#include <drivers/gpio.h>
#include <device.h>
#include <soc.h>
#include <drivers/sensor.h>
//#include <bluetooth/bluetooth.h>
//#include <bluetooth/uuid.h>
//#include <bluetooth/gatt.h>
//#include <bluetooth/hci.h>
//#include <bluetooth/services/nus.h>
#include <dk_buttons_and_leds.h>
#include <settings/settings.h>
#include <stdio.h>
#include <logging/log.h>
#include <stdlib.h>
#include <kernel.h>
#include <devicetree.h>
#include <math.h>
#include <string.h>
#include <init.h>
#include <sys/byteorder.h>
#include <sys/__assert.h>
#include <drivers/spi.h>
#include <logging/log.h>
// #include <pm/device.h>
#define LOG_MODULE_NAME peripheral_uart
LOG_MODULE_REGISTER(LOG_MODULE_NAME);
#define STACKSIZE CONFIG_BT_NUS_THREAD_STACK_SIZE
#define PRIORITY 7
//#define DEVICE_NAME CONFIG_BT_DEVICE_NAME
//#define DEVICE_NAME_LEN (sizeof(DEVICE_NAME) - 1)
//#define RUN_STATUS_LED1 DK_LED1
//#define RUN_STATUS_LED2 DK_LED2
//#define RUN_STATUS_LED3 DK_LED3
//#define RUN_STATUS_LED4 DK_LED4
static uint8_t led1flg;
#define led5 28 // pin number for led5
#define rscon 12 // pin number for rscon
#define pwkey 8 // pin number for pwkey of quictell
#define gprson 7 // pin number for gprs power off command
#define st0 15 // status0 pin of harvester
#define st1 13 // status1 pin of harvester
#define st2 23 // statue3 pin of harvester
#define temp_cut 17 // pin number for temperature cut command
#define rs0_connect_led DK_LED1
#define UART_BUF_SIZE CONFIG_BT_NUS_UART_BUFFER_SIZE
#define UART_WAIT_FOR_BUF_DELAY K_MSEC(50)
#define UART_WAIT_FOR_RX CONFIG_BT_NUS_UART_RX_WAIT_TIME
//#define baudrate38400 NRF_UARTE0->BAUDRATE = UARTE_BAUDRATE_BAUDRATE_Baud38400
//#define baudrate9600 NRF_UARTE0->BAUDRATE = UARTE_BAUDRATE_BAUDRATE_Baud9600
//#define baudrate115200 NRF_UARTE0->BAUDRATE = UARTE_BAUDRATE_BAUDRATE_Baud115200
static const struct device *uart;
uint8_t datarx[512];
uint8_t rxupdate0 = 0;
uint8_t rxdatalen0;
static struct k_work_delayable uart_work;
struct uart_data_t {
void *fifo_reserved;
uint8_t data[UART_BUF_SIZE];
uint16_t len;
};
// static K_FIFO_DEFINE(fifo_uart_tx_data);
// static K_FIFO_DEFINE(fifo_uart_rx_data);
static void uart_cb(const struct device *dev, struct uart_event *evt, void *user_data)
{
int k;
ARG_UNUSED(dev);
// static uint8_t *current_buf;
// static size_t aborted_len;
bool buf_release;
struct uart_data_t *buf;
// static uint8_t *aborted_buf;
switch (evt->type) {
case UART_RX_RDY:
buf = CONTAINER_OF(evt->data.rx.buf, struct uart_data_t, data);
buf->len += evt->data.rx.len;
buf_release = false;
if (led1flg == 0) {
led1flg = 1;
dk_set_led_on(rs0_connect_led);
} else {
led1flg = 0;
dk_set_led_off(rs0_connect_led);
}
// dk_set_led_on(rs0_connect_led);
rxdatalen0 = buf->len;
for (k = 0; k < buf->len; k++) {
datarx[k] = buf->data[k]; // buf->data[k];
}
// k_fifo_put(&fifo_uart_rx_data, buf);
buf->len = 0;
buf_release = true;
// uart_rx_disable(uart);
uart_rx_enable(uart, buf->data, sizeof(buf->data), 10);
rxupdate0 = 1;
break;
}
}
static void uart_work_handler(struct k_work *item)
{
// dk_set_led_on(rs0_connect_led);
struct uart_data_t *buf;
buf = k_malloc(sizeof(*buf));
if (buf) {
buf->len = 0;
} else {
LOG_WRN("Not able to allocate UART receive buffer");
k_work_reschedule(&uart_work, UART_WAIT_FOR_BUF_DELAY);
return;
}
uart_rx_enable(uart, buf->data, sizeof(buf->data), 10);
}
static int uart_init(void)
{
uart_irq_rx_enable(uart);
int err;
struct uart_data_t *rx;
uart = device_get_binding(DT_LABEL(DT_NODELABEL(uart0)));
rx = k_malloc(256); // k_malloc(sizeof(*rx));
if (rx) {
rx->len = 0;
} else {
return -ENOMEM;
}
k_work_init_delayable(&uart_work, uart_work_handler);
err = uart_callback_set(uart, uart_cb, NULL);
if (err) {
return err;
}
return uart_rx_enable(uart, rx->data, sizeof(rx->data), 10);
}
/*
static K_SEM_DEFINE(ble_init_ok, 0, 1); //
static uint8_t adv_array[29] = { 0 };
static struct bt_data ad[] = {
BT_DATA(BT_DATA_MANUFACTURER_DATA, adv_array, sizeof(adv_array)),
};
static uint8_t adv_array1[29];
void bluetoothupdate(void)
{
struct bt_data ad[] = {
BT_DATA(BT_DATA_MANUFACTURER_DATA, adv_array1, sizeof(adv_array1)),
};
bt_le_adv_update_data(ad, ARRAY_SIZE(ad), 0, 0); // sd, ARRAY_SIZE(sd));
}
*/
const struct uart_config uart_cfg115200 = { .baudrate = 115200,
.parity = UART_CFG_PARITY_NONE,
.stop_bits = UART_CFG_STOP_BITS_1,
.data_bits = UART_CFG_DATA_BITS_8,
.flow_ctrl = UART_CFG_FLOW_CTRL_NONE };
uint8_t threeminute_flg = 1;
uint8_t sch_Evt = 1;
/////////////////////////////////////////////////////////////////////////////////////
void schEvt_thread(void)
{
while (1) {
k_msleep(1000 * 60 * 60);
sch_Evt = 1;
}
}
K_THREAD_DEFINE(schEvt_id, 256, schEvt_thread, NULL, NULL, NULL, PRIORITY, 0, 0);
///////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
void minute3_thread(void)
{
// const struct device *port0 = device_get_binding("GPIO_0"); // get the device address of port0
while (1) {
// threeminute_flg = 1; //
k_msleep(1000 * 60*1.5);
threeminute_flg = 0;
// gpio_pin_toggle(port0, led5);
k_sleep(K_FOREVER);
}
}
K_THREAD_DEFINE(threeminute_id, 256, minute3_thread, NULL, NULL, NULL, PRIORITY, 0, 0);
///////////////////////////////////////////////////////////////////////////////////////////
void gprs_thread(void)
{
//uint8_t data[100],qmtflg = 0,wh_end=0;
uint64_t time_stamp;
int64_t delta_time;
char cmd_string[50];
const struct device *port0 = device_get_binding("GPIO_0"); // get the device address of port0
uart_init();
uart_configure(uart, &uart_cfg115200);
gpio_pin_set( port0,gprson,1);
k_msleep(3000);
while(strncmp("AT\r\r\nOK\r\n",datarx,9)){
strcpy( cmd_string,"AT\r\n");
uart_tx(uart,cmd_string,strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(300);
}
strcpy( cmd_string,"AT+IPR=115200\r\n");
uart_tx(uart,cmd_string,strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(1000);
strcpy( cmd_string,"AT&W\r\n");
uart_tx(uart,cmd_string,strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(10000);
//gpio_pin_set( port0,gprson,0); //Quectell off
//0x0D = \r = <CR>
//0x0A = \n = <LF>
//0x1A = <SUB>
//gpio_pin_set(port0, led5,0);
while (1) {
NRF_UARTE0->ENABLE = 8; // uart enable
k_msleep(100);
NRF_UARTE0->TASKS_STARTTX = 1;
k_msleep(100);
NRF_UARTE0->TASKS_STARTRX = 1;
k_msleep(100);
gpio_pin_set(port0, gprson, 1); // Quectel on
k_msleep(3000); // 3s delay
strcpy( cmd_string,"AT\r\n");
uart_tx(uart,cmd_string,strlen(cmd_string), SYS_FOREVER_MS);
time_stamp = k_uptime_get(); // time Stamp
while((strncmp("AT\r\r\nOK\r\n",datarx,9)) && (threeminute_flg==1)&& ( k_uptime_delta(&time_stamp)<= 5000) ){ // for auto synic
strcpy( cmd_string,"AT\r\n");
uart_tx(uart,cmd_string,strlen(cmd_string), SYS_FOREVER_MS);
k_sleep(K_MSEC(300));
}
///////////////////////////////////AT+CPIN?
time_stamp = k_uptime_get();
while (threeminute_flg == 1 && ( strncmp("AT+CPIN?\r\r\n+CPIN: READY\r\n\r\nOK\r\n",datarx,31) !=0) ) { // Sim card check insert or not
strcpy(cmd_string, "AT+CPIN?\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(300);
if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}
/////////////////////////////////AT+QIFGCNT=2
time_stamp = k_uptime_get();
while (threeminute_flg == 1 && ( strncmp("AT+QIFGCNT=2\r\r\nOK\r\n",datarx,19) !=0) ) { //
strcpy(cmd_string, "AT+QIFGCNT=2\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(300);
if((k_uptime_get() - time_stamp) >= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}
/////////////////////////////////'AT+QICSGP=1,"mtnirancell
time_stamp = k_uptime_get();
while (threeminute_flg == 1 && ( strncmp("AT+QICSGP=1,\"mtnirancell\"\r\r\nOK\r\n",datarx,32) !=0) ) { //
strcpy(cmd_string,"AT+QICSGP=1,\"mtnirancell\"\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(200);
if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}
/////////////////////////////////CGREG
time_stamp = k_uptime_get(); // home register // Roaming
while (threeminute_flg == 1 && ( strncmp("AT+CGREG?\r\r\n+CGREG: 0,1\r\n\r\nOK\r\n",datarx,31) !=0) && ( strncmp("AT+CGREG?\r\r\n+CGREG: 0,5\r\n\r\nOK\r\n",datarx,31) !=0) ) { //
strcpy(cmd_string,"AT+CGREG?\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(1000);
if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}
/////////////////////////////////CGDCONT
time_stamp = k_uptime_get(); //
while (threeminute_flg == 1 && ( strncmp("AT+CGDCONT=1,\"IP\",\"mtnirancell\",\"0.0.0.0\",0,0\r\r\nOK\r\n",datarx,52) !=0) ) { //
strcpy(cmd_string,"AT+CGDCONT=1,\"IP\",\"mtnirancell\",\"0.0.0.0\",0,0\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(200);
if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}
/////////////////////////////////AT+CGATT=1
time_stamp = k_uptime_get(); //
while (threeminute_flg == 1 && ( strncmp("AT+CGATT=1\r\r\nOK\r\n",datarx,17) !=0) ) { //
strcpy(cmd_string,"AT+CGATT=1\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(200);
if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}
/////////////////////////////////AT+CGATT?
time_stamp = k_uptime_get(); //
while (threeminute_flg == 1 && ( strncmp("AT+CGATT?\r\r\n+CGATT: 1\r\n\r\nOK\r\n",datarx,29) !=0) ) { //
strcpy(cmd_string,"AT+CGATT?\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(200);
if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}
/////////////////////////////////AT+CGACT
time_stamp = k_uptime_get(); //
do { //
strcpy(cmd_string,"AT+CGACT=1,1\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(200);
if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}while (threeminute_flg == 1 && ( strncmp("AT+CGACT=1,1",datarx,12) !=0) );
//////////////////////////////////// AT+CGPADDR=1
strcpy(cmd_string,"AT+CGPADDR=1\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(3000);
////////////////////////////////////// AT+CGDCONT?
time_stamp = k_uptime_get(); //
do { //
strcpy(cmd_string,"AT+CGDCONT?\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(300);
if(k_uptime_delta(&time_stamp)>= 10000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}while (threeminute_flg == 1 && ( strncmp("AT+CGDCONT?\r\r\n+CGDCONT: 1,\"IP\"",datarx,30) !=0) );
////////////////////////////////////// AT+QGNSSTS?
time_stamp = k_uptime_get(); //
do { //
strcpy(cmd_string,"AT+QGNSSTS?\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(200);
if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}while (threeminute_flg == 1 && ( strncmp("AT+QGNSSTS?\r\r\n+QGNSSTS: 1\r\n\r\nOK\r\n",datarx,32) !=0) );
// ////////////////////////////////////// AT+QCELLLOC=1
// time_stamp = k_uptime_get();
// strcpy(cmd_string,"AT+QCELLLOC=1\r\n");
//uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
//k_msleep(300); //
//do { //
// if( strncmp("\r\n+CME ERROR: 3826\r\n",datarx,13) ==0){
// strcpy(cmd_string,"AT+QCELLLOC=1\r\n");
// uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
// }
//
//}while (threeminute_flg == 1 && ( strncmp("\r\n+QCELLLOC: 51.414337,35.725136<CR><LF>",datarx,12) !=0) && k_uptime_delta(&time_stamp)<= 3000);
/////////////////////////////////'AT+QGREFLOC=35.727047,51.410278';
time_stamp = k_uptime_get(); //
while (threeminute_flg == 1 && ( strncmp("AT+QGREFLOC=35.727047,51.410278<CR><CR><LF>OK<CR><LF",datarx,11) !=0) ) { //
strcpy(cmd_string,"AT+QGREFLOC=35.727047,51.410278\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(200);
if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}
///////////////////////////////// AT+QGNSSEPO=1
time_stamp = k_uptime_get(); //
while (threeminute_flg == 1 && ( strncmp("AT+QGNSSEPO=1\r\r\nOK\r\n",datarx,20) !=0) ) { //
strcpy(cmd_string,"AT+QGNSSEPO=1\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(200);
if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}
///////////////////////////////// 'AT+QGNSSC=1' GNSS on
time_stamp = k_uptime_get(); //
while (threeminute_flg == 1 && ( strncmp("AT+QGNSSC=1\r\r\nOK\r\n",datarx,18) !=0) ) { //
strcpy(cmd_string,"AT+QGNSSC=1\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(200);
if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}
// ///////////////////////////////// AT+QGNSSRD="NMEA/RMC
// k_msleep(2000);
// time_stamp = k_uptime_get(); //
//while (threeminute_flg == 1 && ( strncmp("A+QGNSSC=1\r\r\nOK\r\n",datarx,18) !=0) ) { //
// strcpy(cmd_string,"AT+QGNSSRD=\"NMEA/RMC\"\r\n");
// uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
// k_msleep(2000);
// if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
//}
///////////////////////////////// AT+QMTOPEN=1,"37.221.21.101",1883 tcp request
startReconnect:
time_stamp = k_uptime_get();
strcpy(cmd_string,"AT+QMTOPEN=1,\"37.221.21.101\",1883\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
do {
if(strncmp("\r\n+QMTOPEN: 1,-1\r\n",datarx,18) == 0){ // can not open tcp connection and try again
strcpy(cmd_string,"AT+QMTOPEN=1,\"37.221.21.101\",1883\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
}
if(strncmp("\r\n+QMTSTAT: 1,1\r\n",datarx,17) == 0){ // QMTSTAT: 1,1 TIME OUT and try again
strcpy(cmd_string,"AT+QMTOPEN=1,\"37.221.21.101\",1883\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
}
if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}while (threeminute_flg == 1 && ( strncmp("\r\n+QMTOPEN: 1,0\r\n",datarx,17) !=0) );
///////////////////////////////// AT+QMTCONN=1,"1111","bayat","1qaz!QAZ" mqtt connection request
time_stamp = k_uptime_get();
strcpy(cmd_string,"AT+QMTCONN=1,\"1111\",\"bayat\",\"1qaz!QAZ\"\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
do {
if(strncmp("\r\n+QMTSTAT: 1,3\r\n\r\n+QMTCONN: 1,2\r\n>",datarx,34) == 0){ //time out for connectio to mqtt so shoud do tcp command again
goto startReconnect;
}
if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}while (threeminute_flg == 1 && ( strncmp("\r\n+QMTCONN: 1,0,0\r\n",datarx,19) !=0) );
///////////////////////////////// 'AT+QMTPUB=1,10,2,0,"topic/upload" publish to topic address
time_stamp = k_uptime_get();
strcpy(cmd_string,"AT+QMTPUB=1,10,2,0,\"topic/upload\",5\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
do {
// if(strncmp("\r\n+QMTSTAT: 1,3\r\n\r\n+QMTCONN: 1,2\r\n>",datarx,34) == 0){ //time out for connectio to mqtt so shoud do tcp command again
// goto startReconnect;
// }
gpio_pin_toggle(port0, led5);
k_msleep(300);
if(k_uptime_delta(&time_stamp)>= 5000){threeminute_flg = 0;} // check for time out 5s then swich off quectel
}while (threeminute_flg == 1 && ( strncmp("AT+QMTPUB=1,10,2,0,\"topic/upload\",5\r\r\n>",datarx,39) !=0) );
//////////////////////////////////////////
k_msleep(1000);
strcpy(cmd_string,"bayatnasser");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(100);
cmd_string[0]= 0x1a; //<sub> charcter sent
uart_tx(uart, cmd_string, 1, SYS_FOREVER_MS);
k_msleep(100);
if (threeminute_flg == 1) {
strcpy(cmd_string, "ATI\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(1000);
}
if (threeminute_flg == 1) {
strcpy(cmd_string, "C\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(1000);
}
if (threeminute_flg == 1) {
strcpy(cmd_string, "D\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(1000);
}
if (threeminute_flg == 1) {
strcpy(cmd_string, "E\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(1000);
}
if (threeminute_flg == 1) {
strcpy(cmd_string, "F\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(1000);
}
if (threeminute_flg == 1) {
strcpy(cmd_string, "G\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(1000);
}
if (threeminute_flg == 1) {
strcpy(cmd_string, "H\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(1000);
}
if (threeminute_flg == 1) {
strcpy(cmd_string, "I\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(1000);
}
if (threeminute_flg == 1) {
strcpy(cmd_string, "J\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(1000);
}
if (threeminute_flg == 1) {
strcpy(cmd_string, "K\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(1000);
}
if (threeminute_flg == 1) {
strcpy(cmd_string, "L\r\n");
uart_tx(uart, cmd_string, strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(1000);
}
strcpy( cmd_string,"AT\r\n");
uart_tx(uart,cmd_string,strlen(cmd_string), SYS_FOREVER_MS);
k_msleep(1000);
gpio_pin_set(port0, gprson, 0);
gpio_pin_set(port0, led5,1);
led1flg = 0;
dk_set_led_off(rs0_connect_led);
k_msleep(100);
NRF_UARTE0->ENABLE = 0;
uart_rx_disable(uart);
k_msleep(100);
k_sleep(K_FOREVER);
}
}
//K_THREAD_DEFINE(quectel_id, STACKSIZE, gprs_thread, NULL, NULL, NULL, PRIORITY, 0, 0);
////////////////////////////////////////////////////////////////////
void reverse(char* str, int len)
{
int i = 0, j = len - 1, temp;
while (i < j) {
temp = str[i];
str[i] = str[j];
str[j] = temp;
i++;
j--;
}
}
// Converts a given integer x to string str[].
// d is the number of digits required in the output.
// If d is more than the number of digits in x,
// then 0s are added at the beginning.
int intToStr(int x, char str[], int d)
{
int i = 0;
while (x) {
str[i++] = (x % 10) + '0';
x = x / 10;
}
// If number of digits required is more, then
// add 0s at the beginning
while (i < d)
str[i++] = '0';
reverse(str, i);
str[i] = '\0';
return i;
}
// Converts a floating-point/double number to a string.
void ftoa(float n, char* res, int afterpoint)
{
uint8_t sign_flg[52];
uint8_t temp[52];
if( n < 0 ){
sign_flg[0] = '-';
n = -n;
}
else{
sign_flg[0] = ' ';
}
sign_flg[1] ='\0';
// Extract integer part
int ipart = (int)n;
// Extract floating part
float fpart = n - (float)ipart;
// convert integer part to string
int i = intToStr(ipart, res, 0);
// check for display option after point
if (afterpoint != 0) {
res[i] = '.'; // add dot
// Get the value of fraction part upto given no.
// of points after dot. The third parameter
// is needed to handle cases like 233.007
//fpart = fpart * pow (10, afterpoint);
for(int j = 0; j< afterpoint;++j){
fpart = fpart * 10;
}
intToStr((int)fpart, res + i + 1, afterpoint);
if( n < 1 ){
for ( int j = 0; j < strlen(res); ++j){
temp[j+1] = res[j];
}
temp[0] = 0x30;
strcpy(res,temp);
res[strlen(res) + 1] ='\0';
}
strcat(sign_flg,res);
strcpy(res,sign_flg);
res[strlen(res) + 1] ='\0';
}
}
//////////////////////////////////////////////////////////////////////////////
K_SEM_DEFINE(sem, 0, 1);
static void trigger_handler(const struct device *dev,
const struct sensor_trigger *trig)
{
switch (trig->type) {
case SENSOR_TRIG_DATA_READY:
if (sensor_sample_fetch(dev) < 0) {
printf("Sample fetch error\n");
return;
}
k_sem_give(&sem);
break;
case SENSOR_TRIG_THRESHOLD:
printf("Threshold trigger\n");
break;
default:
printf("Unknown trigger\n");
}
}
///////////////////////////////////////////////////////////////////////////////
void adxl362_thread(void)
{
char res[50];
double ax,ay,az,ambient_temp;
struct sensor_value accel[3],temp[1];
const struct device *dev = device_get_binding(DT_LABEL(DT_INST(0, adi_adxl362)));
if (IS_ENABLED(CONFIG_ADXL362_TRIGGER)) {
struct sensor_trigger trig = { .chan = SENSOR_CHAN_ACCEL_XYZ };
trig.type = SENSOR_TRIG_THRESHOLD;
if (sensor_trigger_set(dev, &trig, trigger_handler)) {
printf("Trigger set error\n");
return;
}
trig.type = SENSOR_TRIG_DATA_READY;
if (sensor_trigger_set(dev, &trig, trigger_handler)) {
printf("Trigger set error\n");
}
}
///////// system reset command __NVIC_SystemReset();
adxl362_set_range(dev,8);
while(1) {
/*
if (IS_ENABLED(CONFIG_ADXL362_TRIGGER)) {
k_sem_take(&sem, K_FOREVER);
} else {
k_msleep(1000);
if (sensor_sample_fetch(dev) < 0) {
printf("Sample fetch error\n");
return;
}
}*/
sensor_sample_fetch(dev);
//k_msleep(100);
sensor_channel_get(dev, SENSOR_CHAN_ACCEL_X, &accel[0]);
ax = sensor_value_to_double(&accel[0]);
if( ax > 12.5 ){
strcpy(res,"Ax =");
uart_tx(uart,res,strlen(res), SYS_FOREVER_MS);
k_msleep(2);
ftoa(ax,res,4);
uart_tx(uart,res,strlen(res), SYS_FOREVER_MS);
k_msleep(2);
strcpy(res,"\r\n");
uart_tx(uart,res,strlen(res), SYS_FOREVER_MS);
k_msleep(2);
}
sensor_channel_get(dev, SENSOR_CHAN_ACCEL_Y, &accel[1]);
ay = sensor_value_to_double(&accel[1]);
if ( ay > 12.5 ) {
strcpy(res,"Ay =");
uart_tx(uart,res,strlen(res), SYS_FOREVER_MS);
k_msleep(2);
ftoa(ay,res,4);
uart_tx(uart,res,strlen(res), SYS_FOREVER_MS);
k_msleep(2);
strcpy(res,"\r\n");
uart_tx(uart,res,strlen(res), SYS_FOREVER_MS);
k_msleep(2);
}
sensor_channel_get(dev, SENSOR_CHAN_ACCEL_Z, &accel[2]);
az = sensor_value_to_double(&accel[2]);
if( az > 12.5 ) {
strcpy(res,"Az =");
uart_tx(uart,res,strlen(res), SYS_FOREVER_MS);
k_msleep(2);
ftoa(az,res,4);
uart_tx(uart,res,strlen(res), SYS_FOREVER_MS);
k_msleep(2);
strcpy(res,"\r\n");
uart_tx(uart,res,strlen(res), SYS_FOREVER_MS);
k_msleep(2);
}
/*
sensor_channel_get(dev,SENSOR_CHAN_DIE_TEMP,&temp[0]);
ambient_temp = sensor_value_to_double(&temp[0]) + 22 ;
strcpy(res,"Temperature = ");
uart_tx(uart,res,strlen(res), SYS_FOREVER_MS);
k_msleep(20);
ftoa(ambient_temp,res,2);
uart_tx(uart,res,strlen(res), SYS_FOREVER_MS);
k_msleep(20);
strcpy(res,"\r\n");
uart_tx(uart,res,strlen(res), SYS_FOREVER_MS);
k_msleep(20);
*/
// __NVIC_SystemReset();
}
}
K_THREAD_DEFINE(adxl362_id, 1024, adxl362_thread, NULL, NULL, NULL, PRIORITY, 0, 0);
///////////////////////////////////////////////////
void main()
{
uint64_t j, k;
const struct device *port0 = device_get_binding("GPIO_0"); // get the device address of port0
gpio_pin_configure(port0, led5,GPIO_OUTPUT | GPIO_OUTPUT_INIT_HIGH); // set the pin for led5 as output high
gpio_pin_configure(port0, rscon, GPIO_INPUT); // set the pin for rscon as input high z
gpio_pin_configure(port0, pwkey,GPIO_OUTPUT | GPIO_OUTPUT_INIT_LOW); // set the pin for pwkey as output low
gpio_pin_configure(port0, gprson,GPIO_OUTPUT| GPIO_OUTPUT_INIT_LOW); // set the pin for gprsoff as output low
gpio_pin_configure(port0,temp_cut,GPIO_OUTPUT| GPIO_OUTPUT_INIT_LOW); // set the pin for temp_cut as output low
gpio_pin_configure(port0, st0, GPIO_INPUT); // set the pin for st0 as input high z
gpio_pin_configure(port0, st1, GPIO_INPUT); // set the pin for st1 as input high z
gpio_pin_configure(port0, st2, GPIO_INPUT); // set the pin for st2 as input high z
dk_leds_init();
//k_msleep(1000 * 60);
threeminute_flg = 0;
uart_init();
uart_configure(uart, &uart_cfg115200);
while (1) {
/*
if (sch_Evt == 1) {
threeminute_flg = 1;
k_wakeup(quectel_id);
k_wakeup(threeminute_id);
sch_Evt = 0;
}
*/
gpio_pin_toggle(port0, led5);
//gpio_pin_set(port0,led5,0);
k_msleep(500);
}
}
B.R.
Saeed
Hi Naeem
Please tell me how can I send you a Zip file sample of my project.
I tried to send it via Email but it has been blocked.
The SDK version which I am using is v.1.8.0.
B.R.
Please click on Insert--> Image/video/file and then on the "Upload" under the File/URL bar.
This will allow you to browse, select and upload your zip file.
Please also mention:
Which SDK version you are using?
What error you are getting?
And how to reproduce the error.
Please send the minimal project.
Hi Naeem
I sent you a zip sample of my project.
the problematic command is:
//adxl362_set_range(dev,8);
which has been commented on.
the error is:
undefined reference to `adxl362_set_range'
ld returned 1 exit status
Hi Naeem
I sent you a zip sample of my project.
the problematic command is:
//adxl362_set_range(dev,8);
which has been commented on.
the error is:
undefined reference to `adxl362_set_range'
ld returned 1 exit status
Hello Saeed,
I have received your project in zip file.
I will let you know when I go through it and have more information.
Regards,
