Questions and discussions about the software that runs on the TD RF module itself.
escalanterj
 
Posts: 30
Joined: Sun Jan 22, 2017 3:37 pm

program hanging if I move the TD1205P before it starts up

by escalanterj Mon Jun 12, 2017 11:34 pm

Hello,

Does anybody know why if I move my module before it starts completely, it hangs?

Prg:

/******************************************************************************
* @file
* @brief Simple GPS periodic fix application for the TDxxxx RF modules.
* @author Telecom Design S.A.
* @version 1.1.0
******************************************************************************
* @section License
* <b>(C) Copyright 2014-2015 Telecom Design S.A., http://www.telecomdesign.fr</b>
******************************************************************************
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
* DISCLAIMER OF WARRANTY/LIMITATION OF REMEDIES: Telecom Design SA has no
* obligation to support this Software. Telecom Design SA is providing the
* Software "AS IS", with no express or implied warranties of any kind,
* including, but not limited to, any implied warranties of merchantability
* or fitness for any particular purpose or warranties against infringement
* of any proprietary rights of a third party.
*
* Telecom Design SA will not be liable for any consequential, incidental, or
* special damages, or any other relief, or for any claim by any third party,
* arising from your use of this Software.
*
******************************************************************************/

#include "config.h"

#include <stdint.h>
#include <stdbool.h>

#include <efm32.h>

#include <td_core.h>
#include <td_uart.h>
#include <td_printf.h>
#include <td_stream.h>
#include <td_flash.h>
#include <td_scheduler.h>
#include <td_watchdog.h>
#include <td_gpio.h>
#include <td_utils.h>
#include <td_measure.h>

#include <td_sensor.h>
#include <sensor_data_geoloc.h>

#include <td_accelero.h>
#include <td_geoloc.h>
#include <td_sigfox.h>

#include <td_config.h>

/*******************************************************************************
****************************** DEFINES ****************************
******************************************************************************/

/** Flash variable version ID */
#define VARIABLES_VERSION 1

// Interval at which position is reported (in seconds)
#define FIX_INTERVAL 1*900 // Send a Sigfox message every 1 hour

/** Acceptable minimum horizontal accuracy, 800 to be very accurate */
#define FIX_HDOP 800

/** Boot monitoring, 1 to enable */
#define BOOT_MONITORING 1

/** Keepalive monitoring interval in hours, 0 to disable
* If you wish to send a keepalive frame remember to add a scheduler as well in the setup function */
#define KEEPALIVE_INTERVAL 1

#define DEBUG_USE_PRINTF 1 //trace on serial
#if DEBUG_USE_PRINTF
#define DEBUG_PRINTF(...) tfp_printf(__VA_ARGS__);
#else
#define DEBUG_PRINTF(...)
#endif

TD_GEOLOC_Fix_t CurrentGPSPosition;
int timeout;
//tfp_printf("The value of timeout is: %d\r\n", timeout);



uint8_t fixIntervalSchedulerId;

//Configure the downlink request every maxCounter sigfox message
int downlinkCounter;
int downlinkMaxCounter;
bool encrypt = false;
int gpsSleepMode = TD_GEOLOC_OFF;
int precision = TD_GEOLOC_2D_FIX;

/*******************************************************************************
****************************** GLOBAL FUNCTIONS ****************************
******************************************************************************/

void encryption(uint8_t * bytes, uint8_t * cryptMessage, int size){

//Here you can insert your own encryption method - This function does nothing

int i=0;

for(i=0;i<size;i++){
cryptMessage[i] = bytes[i];
}
}

/***************************************************************************//**
* @brief
* GPS fix callback
*
* @param[in] fix
* The GPS fix data structure.
*
* @param[in] timeout
* Flag that indicates whether a timeout occurred if set to true.
******************************************************************************/
static void GPSFix(TD_GEOLOC_Fix_t * fix, bool timeout)
{
int i;

tfp_printf("I'm in GPSFix \r\n");
uint8_t bytes[12];
uint8_t cryptMessage[12];
uint8_t timeoutMessage[1];

unsigned long latitude, longitude;
char latitude_direction, longitude_direction;
int hdop, nbSat, acqTime, speed, size;

//Message init - Set to zero not to get random unwanted values
for(i=0;i<12;i++){
bytes[i] = 0x00;
tfp_printf("the variable 'i' of the 1st for in static void GPSFix is: %d\r\n",i);
}

//
if (fix->type >= precision && fix->hard.rtc_calibrated) {
uint32_t mv = TD_MEASURE_VoltageTemperatureExtended(false);

DEBUG_PRINTF("Voltage: %d\r\n", mv);
DEBUG_PRINTF("Lat: %d - %08lX\r\n", fix->position.latitude, fix->position.latitude);
DEBUG_PRINTF("Long: %d - %08lX\r\n", fix->position.longitude, fix->position.longitude);
DEBUG_PRINTF("Hdop: %d \r\n", fix->quality.hdop);
DEBUG_PRINTF("nb sat: %d \r\n", fix->quality.sat);
DEBUG_PRINTF("acquisition time: %d \r\n", fix->duration);
DEBUG_PRINTF("speed: %d \r\n", fix->speed.speed_kmh);

tfp_printf("I'm inside the 1st IF of static void GPSFix function\r\n");

//Stop GPS
TD_GEOLOC_StopFix(gpsSleepMode);

//Now we add the received data in the bytes array:

//Latitude
//Hint: divide the return value by 10 will make it understandable by Sigfox backend
if (fix->position.latitude < 0) {
latitude = (int32_t)(-1)* ((int32_t)fix->position.latitude / 10) ;
latitude_direction = 'S';
latitude = latitude| 0x80000000;
} else {
latitude = fix->position.latitude / 10;
latitude_direction = 'N';
}
bytes[0] = (latitude >> 24) & 0xFF;
bytes[1] = (latitude >> 16) & 0xFF;
bytes[2] = (latitude >> 8) & 0xFF;
bytes[3] = latitude & 0xFF;

//Longitude
if (fix->position.longitude < 0) {
longitude = (int32_t)(-1)* ((int32_t)fix->position.longitude / 10) ;
longitude_direction = 'W';
longitude = longitude| 0x80000000;
} else {
longitude = fix->position.longitude / 10;
longitude_direction = 'E';
}
bytes[4] = (longitude >> 24) & 0xFF;
bytes[5] = (longitude >> 16) & 0xFF;
bytes[6] = (longitude >> 8) & 0xFF;
bytes[7] = longitude & 0xFF;

//Battery
for(i=0; i<255; i++){
if(mv>=i*15 && mv<=(i+1)*15){
bytes[8] = bytes[8] | i;
}else if(mv>3825){
bytes[8] = bytes[8] | 0xFF;
}
}

//Hdop
/*
* On the byte 9, we will encode both quality (hdop) and number of satellites
* h h s s (h for hdop and s for the number of satellites)
* Byte : _ _ _ _ _ _ _ _
*/
hdop = fix->quality.hdop / 100;
if(hdop > 5){
//Set the 2 first bits to 3
bytes[9] = 0xC0;
} else if(hdop >= 2 && hdop <=5){
//Set the 2 first bits to 2
bytes[9] = 0x80;
} else if(hdop >= 1 && hdop <2){
//Set the 2 first bits to 1
bytes[9] = 0x04;
}

//Satellites number
nbSat = fix->quality.sat;
if(nbSat >=8){
bytes[9] = bytes[9] | 0x30;
}else if(nbSat >=6 && nbSat <= 8){
bytes[9] = bytes[9] | 0x20;
}else if(nbSat >=4 && nbSat <= 6){
bytes[9] = bytes[9] | 0x10;
}

//Acquisition time
/*
* On the byte 10, we will encode both acquisition (a) time and the speed (s)
* a a a a s s s s
* Byte : _ _ _ _ _ _ _ _
*/
uint8_t mask;
acqTime = fix->duration;
for(i=0; i<15; i++){
if(acqTime>=i*5 && acqTime<=(i+1)*5){
mask = i << 4 ;
bytes[10] = bytes[10] | mask;
}else if(acqTime>75){
bytes[10] = bytes[10] | 0xF0;
}
}

//Speed
speed = fix->speed.speed_kmh;
for(i=0; i<15; i++){
if(speed>=i*5 && speed<=(i+1)*5){
bytes[10] = bytes[10] | i;
}else if(speed>75){
bytes[10] = bytes[10] | 0x0F;
}
}

//DEBUG
size = sizeof(bytes)/sizeof(bytes[0]);
for(i=0;i<size;i++){
DEBUG_PRINTF("bytes[%d]: %x\r\n", i, bytes[i]);
}
//TD_GEOLOC_PrintfFix(fix);
//encryption(&bytes, &cryptMessage, size);
for(i=0;i<size;i++){
DEBUG_PRINTF("crypt[%d]: %x\r\n", i, cryptMessage[i]);
}

//Send data
/*
* If downlinkMaxCounter is reached, send a downlink request with the sigfox message
*/
//DEBUG_PRINTF("Downlink counter: %d / %d\r\n", downlinkCounter, downlinkMaxCounter);
if(downlinkCounter >= downlinkMaxCounter){
TD_SIGFOX_SendV1(MODE_FRAME, false,encrypt?cryptMessage:bytes, size, 2, true, false);
downlinkCounter = 0;
}else{
TD_SIGFOX_Send(encrypt?cryptMessage:bytes, size, 2);
downlinkCounter++;
}

} else if (timeout) {
//If no GPS fix has been found, we still send the voltage
uint32_t mv = TD_MEASURE_VoltageTemperatureExtended(false);
DEBUG_PRINTF("Voltage: %d\r\n", mv);
for(i=0; i<255; i++){
if(mv>=i*15 && mv<=(i+1)*15){
timeoutMessage[0] = timeoutMessage[0] | i;
}else if(mv>3825){
timeoutMessage[0] = timeoutMessage[0] | 0xFF;
}
}
//Set the device in its sleep mode
TD_GEOLOC_StopFix(gpsSleepMode);
DEBUG_PRINTF("device set to sleep mode\r\n");
DEBUG_PRINTF("Fix Timeout\r\n");
DEBUG_PRINTF("Time: %d \r\n", fix->duration);
TD_GEOLOC_PrintfFix(fix);
DEBUG_PRINTF("Downlink counter: %d / %d\r\n", downlinkCounter, downlinkMaxCounter);
if(downlinkCounter >= downlinkMaxCounter){
TD_SIGFOX_SendV1(MODE_FRAME, false, timeoutMessage, 1, 2, true, false);
downlinkCounter = 0;
}else{
TD_SIGFOX_Send((uint8_t *) timeoutMessage, 1, 2);
downlinkCounter++;
}



}
}

/***************************************************************************//**
* @brief
* Call-back function for SIGFOX downlink.
*
* @param[in] rx_frame
* Pointer to the received frame or null if timeout occurred.
*
* @param[in] length
* Length in bytes of the received frame.
*
* @return
* Returns the buffer length if OK, -1 if an error occurred.
******************************************************************************/
static int DownlinkCallback(uint8_t *rx_frame, uint8_t length)
{
int i;
int fixInterval;
DEBUG_PRINTF("Downlink...\r\n");
if (rx_frame == 0) {
// Finished receiving
//TD_SIGFOX_DOWNLINK_SetUserCallback(0);
DEBUG_PRINTF("RX END\r\n");
// Done
return 1;
} else {
if (length == 0) {
// Start receiving
DEBUG_PRINTF("RX BEGIN\r\n");
// Done
return 1;
}
// Received one good frame
tfp_dump("RX=", rx_frame, length);
DEBUG_PRINTF("rx_frame: %d - %x - %s\r\n", rx_frame, rx_frame, rx_frame);
for(i=0;i<8;i++){
DEBUG_PRINTF("rx_frame[%d]: %x - %d\r\n", i, rx_frame[i], rx_frame[i]);

}

//Here is the GPS timeout value meaning the maximum time you will try to get a GPS fix
timeout = rx_frame[0];
DEBUG_PRINTF("timeout: %d (in seconds)\r\n", timeout);

//The fixInterval (in hours) is the time interval to send a message
fixInterval = rx_frame[1];
if(fixInterval>3 && fixInterval<48){
DEBUG_PRINTF("fixInterval: %d (in hours)\r\n", fixInterval);
TD_SCHEDULER_SetInterval(fixIntervalSchedulerId, fixInterval * 3600,0,0);
gpsSleepMode = TD_GEOLOC_OFF;
}
if(fixInterval>0 && fixInterval<=3){
DEBUG_PRINTF("fixInterval: %d (in hours)\r\n", fixInterval);
TD_SCHEDULER_SetInterval(fixIntervalSchedulerId, fixInterval * 3600,0,0);
gpsSleepMode = TD_GEOLOC_HW_BCKP;
}

//you can add restriction for the max number of uplink to occur before requesting a downlink here
//When 255, it will always be true
//You can easily calculate the interval time for downlinks doing '(fixInterval * downlinkMaxCounter) + 1'
if(rx_frame[2]<48){
downlinkMaxCounter = rx_frame[2];
DEBUG_PRINTF("downlinkMaxCounter: %d (in hours)\r\n", downlinkMaxCounter);
}

// Done
return 1;

}
}

/***************************************************************************//**
* @brief
* Start fixing periodically.
*
* @param[in] arg
* Generic argument set by the user that is passed along to the callback
* function.
*
* @param[in] repeat_count
* Updated repeat count, decremented at each timer trigger, unless it is an
* infinite timer.
******************************************************************************/
static void StartFixing(uint32_t arg, uint8_t repeat_count)
{
DEBUG_PRINTF("Start fixing\r\n");
TD_GEOLOC_TryToFix(TD_GEOLOC_NAVIGATION, timeout, GPSFix);
}

/***************************************************************************//**
* @brief
* User Setup function.
******************************************************************************/
void TD_USER_Setup(void)
{
TD_UART_Options_t options = {LEUART_DEVICE, LEUART_LOCATION, 9600, 8, 'N',
1, false};

// Open an I/O stream using LEUART0
TD_UART_Open(&options, TD_STREAM_RDWR);

// Use a 64 s automatic watchdog
TD_WATCHDOG_Init(64);
TD_WATCHDOG_Enable(true, true);
TD_SENSOR_Init(SENSOR_TRANSMITTER, 0, 0);

// Geoloc and accelerometer initialization

tfp_printf("Initialization of GPS and Accelerometer\r\n");
TD_GEOLOC_Init();
TD_ACCELERO_Init();

//Fix timeout
timeout = 60;

//Init downlink counter
downlinkCounter = 0;
//Once every x uplink
downlinkMaxCounter = 23; //One downlink every day

#if BOOT_MONITORING

// Will only send a boot monitor frame on NEXT reboot
TD_SENSOR_MonitorBoot(true, 0);
#endif

#if KEEPALIVE_INTERVAL > 0

// Send a keep-alive frame immediately, then at given interval
TD_SENSOR_MonitorKeepAlive(true, KEEPALIVE_INTERVAL);
#endif

// Start fixing right now
StartFixing(0, 0);

// Start the fix infinite timer
fixIntervalSchedulerId = TD_SCHEDULER_Append(FIX_INTERVAL, 0, 0, TD_SCHEDULER_INFINITE, StartFixing, 0);

TD_SIGFOX_DOWNLINK_SetUserCallback(DownlinkCallback);
}

/***************************************************************************//**
* @brief
* User loop function.
******************************************************************************/
void TD_USER_Loop(void)
{

tfp_printf("I'm in void TD_USER_Loop\r\n");
// Process Sensor events

TD_SENSOR_Process();

// Process geoloc events
TD_GEOLOC_Process();

// Process downlink events
TD_SIGFOX_DOWNLINK_Process();
}


thanks

BR
nabil
 
Posts: 1
Joined: Wed Feb 21, 2018 2:47 pm

Re: program hanging if I move the TD1205P before it starts u

by nabil Wed Sep 05, 2018 1:29 pm

Hi @escalanterj

Could you paste the serial output you get when connecting to the module? And the trap you get (if there is any)?

Regards,
Nabil
Return to Firmware

Who is online

Users browsing this forum: No registered users and 2 guests