kumar singh
Dummy Lora Packet Sending
Fork of
Dealer_18feb17
by 
kumar singh
Diff: main.cpp
- Revision:
- 11:77e595130230
- Parent:
- 10:dc33cd3f4eb9
- Child:
- 12:6107b32b0729
diff -r dc33cd3f4eb9 -r 77e595130230 main.cpp
--- a/main.cpp Thu Jan 12 23:35:40 2017 +0000
+++ b/main.cpp Fri Jan 27 18:30:02 2017 +0000
@@ -1,21 +1,305 @@
#include "mbed.h"
-
+#include "rtos.h"
+#include "OBD.h"
+#include "Lora.h"
+#include "Accelerometer.h"
+#include "Beacon.h"
+#include "main.h"
+
+//Datatype typecasting
+typedef unsigned char uint8;
+typedef unsigned int uint16;
+
+//peripheral connection
DigitalOut led1(LED1);
DigitalOut led2(LED2);
-Thread thread;
+
+//Configure Serial port
+ RawSerial LORA_UART(PA_0, PA_1);//USART4_TX->PA_0,USART4_RX->PA_1 : Used for Lora module command sending and reception from gateway
+ RawSerial DEBUG_UART(PA_9, PA_10);//USART1_TX->PA_9,USART1_RX->PA_10 : Used for debugging purpose only
+ RawSerial Beacon_UART(PC_4, PC_5);//USART3_TX->PC4,USART3_RX->PC_5 : Used for sending command to beacon module
+
+ //InterruptIn OBD_PLUGIN_INTERRUPT_PIN(PC_13);
+ InterruptIn CheckIn_Interrupt(PC_13);
+
+ uint8 Ticker_Count = 0; //Variable to count for timer overflows
+
+
+ uint8 OBD_Plugin_Detected = FALSE;
-void led2_thread() {
- while (true) {
- led2 = !led2;
- wait(1);
+ //Create Object for structure of Lora Packet to be sent
+
+ static uint16 Calculate_Wheels_RPM(uint8* Buffer);
+ void flip_Packet_Sending_Flag();
+ void Lora_Periodic_Packet_Sending_thread(void const *args);
+
+ void Lora_Rcvd_Cmd_Processing_thread(void);// const *args);
+ void Enable_CheckIN_Packet_Sending();
+/*************************Accelerometer related definitions***********************************/
+//Accelerometer related definitions
+#define DOUBLE_TAP_INTERRUPT 0x20
+#define ACTIVITY_INTERRUPT 0x10
+#define INACTIVITY_INTERRUPT 0x08
+
+#define TAP_THRESHOLD 75
+#define ACTIVITY_THRESHOLD 64 // THRES_ACT register value 62.5mg/LSB , therfore value 32 indicates 2g activity
+#define INACTIVITY_THRESHOLD 50
+
+#define DUR_TIME 0x15 // DUR Register value providing maximum time to be held to generate an interrupt
+#define LATENT_TIME 0x15 // The interrupt latency
+#define WINDOW_TIME 0x45 // The time of the interrupt window in which the next tap will be detected
+#define INACTIVITY_VALIDATION_TIME 5 // The time until which the acceleration must be held below the inactivity threshold to generate an inactvity interrupt
+ // Here the value 5 indicates literally 5 secs
+#define X_AXIS_OFFSET 0x7F
+#define Y_AXIS_OFFSET 0x7F
+#define Z_AXIS_OFFSET 0x05
+
+
+I2C i2c(PB_9, PB_8);
+RawSerial DEBUG_UART1(PA_9, PA_10);//USART1_TX->PA_9,USART1_RX->PA_10
+
+InterruptIn activity(PB_0);
+InterruptIn inactivity(PA_4); // As for now only this is used
+DigitalOut led(LED1);
+
+const int slave_address_acc = 0xA6;
+char axis_data[6] = {0,0,0,0,0,0};
+
+char interrupt_source[2];
+char axis_data_start_address[2] = {0x32, 0};
+char intr_source_address[2] = {0x30, 0};
+char all_interrupt_clear_command[2] = {0x2E, 0x00};
+char all_interrupt_enable_command[2] = {0x2E, 0x38};
+char activity_interrupt_disable_command[2] = {0x2E, 0x08};
+char inactivity_interrupt_disable_command[2] = {0x2E, 0x30};
+char accelerometer_status_registered = 0;
+unsigned int interrupt_source_duplicate;
+
+char threshold_offset_command[5];
+char act_inact_time_config_command[8];
+char interrupt_enable_command[3];
+char tap_axis_enable_command[2];
+char baud_rate_command[2];
+char data_format_command[2];
+char measure_bit_on_command[2];
+
+
+char previous_state = 0;
+char current_state = 0;
+
+unsigned char vehicle_speed = 25; // Kmph
+unsigned char current_speed, previous_speed, speed_threshold = 10; // Kmph
+
+unsigned char x_axis, y_axis, z_axis;
+
+unsigned char Motion_Detect_Status = FALSE;
+uint8 OBD_PlugInOut_IOC_Status = FALSE;
+unsigned char Motion_Type_Detected = MOTION_TYPE_UNKNOWN; //By default set motion type as unknown
+void Accelerometer_Process_thread();//void const *args) ;
+
+//This function is Interrupt routine for detecting motion(acceleartion), i.e. either starts from rest/vehicle stops afeter running or if sudden jurk is detected
+void interrupt_activity_inactivity()
+{
+ i2c.write(slave_address_acc, all_interrupt_clear_command, 2);
+ Motion_Detect_Status = TRUE;
+}
+/************************************************************************/
+uint8 Command_Sent[100];
+uint8 Command_Length_Sent;
+void Extract_Received_Lora_Response(void);
+
+ //This function is Interrupt routine for detecting OBD Plugin and Out
+void Handle_CheckIn_Interrupt()
+{
+ OBD_PlugInOut_IOC_Status = TRUE;
+ DEBUG_UART.printf("Movement_Detected");
+}
+
+ //Declare Ticker for sending lora packet
+ Ticker Lora_Packet_Sending_Ticker;
+ void flip_Packet_Sending_Flag(void)
+ { //flip function
+ if(Ticker_Count < 5)
+ {
+ Ticker_Count++;
+ }
+ else
+ {
+ Ticker_Count = 0;
+ Send_Lora_Packet_Flag = TRUE;
+ }
+ }
+
+// called every time a byte is received from lora module.
+void Lora_onDataRx()
+{
+ while (LORA_UART.readable())
+ { // while there is data waiting
+ LORA_UART_RX_Buffer[Lora_RxBuffer_End_Pos++] = LORA_UART.getc(); // put it in the buffer
+ //DEBUG_UART.putc(LORA_UART_RX_Buffer[Lora_RxBuffer_End_Pos-1]);
+ if(Lora_RxBuffer_End_Pos >= LORA_UART_RX_Size)
+ {
+ // BUFFER OVERFLOW. What goes here depends on how you want to cope with that situation.
+ // For now just throw everything away.
+ Lora_RxBuffer_End_Pos = 0;
+ }
}
}
-
-int main() {
- thread.start(led2_thread);
-
- while (true) {
- led1 = !led1;
- wait(0.5);
+
+
+ /*
+// called every time a byte is received from Beacon Module.
+void Beacon_onDataRx()
+{
+ while (Beacon_UART.readable())
+ { // while there is data waiting
+ Beacon_RX_Buffer[Beacon_RxBuffer_End_Pos++] = Beacon_UART.getc(); // put it in the buffer
+ //DEBUG_UART.putc(LORA_UART_RX_Buffer[Beacon_RxBuffer_End_Pos-1]);
+ if(Beacon_RxBuffer_End_Pos >= 100)
+ {
+ // BUFFER OVERFLOW. What goes here depends on how you want to cope with that situation.
+ // For now just throw everything away.
+ Beacon_RxBuffer_End_Pos = 0;
+ }
}
}
+*/
+
+int main()
+{
+ DEBUG_UART.baud(115200);
+ DEBUG_UART.printf("%s","Debugging started");
+ LORA_UART.attach(&Lora_onDataRx, Serial::RxIrq);
+ //Beacon_UART.attach(&Beacon_onDataRx, Serial::RxIrq);
+
+ //Create a thread to read vehicle data
+ //Thread OBD_thread(OBD_Rcvd_Cmd_Processing_thread);
+
+ Lora_Packet_Sending_Ticker.attach(&flip_Packet_Sending_Flag, 3.0); // call flip_Packet_Sending_Flag function every 5 seconds
+
+ // OBD_PLUGIN_INTERRUPT_PIN.rise(&Enable_CheckIN_Packet_Sending); // call toggle function on the rising edge
+ //led2_thread is executing concurrently with main at this point
+ CheckIn_Interrupt.rise(&Handle_CheckIn_Interrupt);
+ inactivity.rise(interrupt_activity_inactivity); // Attach the address of interrupt_activity_inactivity function to rising edge
+ Initialize_Beacon_Module();
+ Lora_Periodic_Packet_Sending(); //Infinite loop for sending and receiving lora response, no return from here
+}
+
+ //Functiont to be called when Interrupt is genearted for motion sensing, checkin
+ void Initialize_Packets_Sent_Count(void)
+ {
+ Motion_Packet_Sent_Count = 0x00;
+ CheckIN_Packet_Sent_Count = 0x00;
+ }
+
+void Lora_Periodic_Packet_Sending()
+{
+ DEBUG_UART.printf("Periodic packet sending intiialized");
+ Set_Up_Lora_Network_Configuration();
+ Initialize_lora_Packets();
+ while (true)
+ {
+ if(Packet_Type_To_Send == HEARTBEAT_TYPE_PACKET) //check if packet to be sent is Heartbeat packet
+ {
+ if(Send_Lora_Packet_Flag) //Check if packet sending isd enabled, Packet should be sent only when enabled after timeout period
+ {
+
+ Send_HeartBeat_Packet(); //call function to send heartbeat packet
+ DEBUG_UART.printf("Sent HeartBeat Packet");
+ AT_Response_Receive_Status = FAILURE;
+ while(AT_Response_Receive_Status)
+ Get_Lora_Response();
+ Send_Lora_Packet_Flag = FALSE;
+ DEBUG_UART.printf("Heartbeat Packet Response Received");
+ }
+ }
+ else if(Packet_Type_To_Send == MOTION_TYPE_PACKET) //check if packet to be sent is motion packet
+ {
+ if(Send_Lora_Packet_Flag) //Check if packet sending isd enabled, Packet should be sent only when enabled after timeout period
+ {
+ Send_Motion_Packet();
+ DEBUG_UART.printf("Sent Motion Packet"); //call function to send periodic motion packet
+ AT_Response_Receive_Status = FAILURE;
+ while(AT_Response_Receive_Status)
+ Get_Lora_Response();
+ DEBUG_UART.printf("Motion Packet Response Received");
+ Send_Lora_Packet_Flag = FALSE;
+ if(Motion_Packet_Sent_Count >= 5) //Stop Sending Motion Packets if after sending for 2 minute
+ {
+ DEBUG_UART.printf("Packet Type Sending Changed to HeartBeat");
+ Motion_Packet_Sent_Count = 0;
+ Packet_Type_To_Send = HEARTBEAT_TYPE_PACKET; //Set Packet type to send as heartbeat packet
+ Lora_Packet_Sending_Ticker.detach(); //destroy ticker
+ Lora_Packet_Sending_Ticker.attach(&flip_Packet_Sending_Flag, 10.0); //create new ticker
+
+ }
+ }
+ }
+ else if(Packet_Type_To_Send == CHECKIN_TYPE_PACKET) //check if packet to be sent is Checkin packet
+ {
+ if(Send_Lora_Packet_Flag) //Check if packet sending isd enabled, Packet should be sent only when enabled after timeout period
+ {
+ Send_CheckIN_Packet(); //call function to send periodic checkIn packet
+ DEBUG_UART.printf("Sent Checkin Packet");
+ AT_Response_Receive_Status = FAILURE;
+ while(AT_Response_Receive_Status)
+ Get_Lora_Response();
+ Send_Lora_Packet_Flag = FALSE;
+ DEBUG_UART.printf("Checkin Packet Response Received");
+ if(CheckIN_Packet_Sent_Count >= 5) //Stop Sending Motion Packets if after sending for 2 minute
+ {
+ DEBUG_UART.printf("Packet Type Sending Changed to HeartBeat");
+ CheckIN_Packet_Sent_Count = 0;
+ Packet_Type_To_Send = HEARTBEAT_TYPE_PACKET; //Set Packet type to send as heartbeat packet
+ Initialize_Packets_Sent_Count();
+
+ }
+ }
+ }
+ if(OBD_PlugInOut_IOC_Status) //Check if Accelerometer Interrupt is generated
+ {
+ Enable_CheckIN_Packet_Sending();
+ //Get_Acceleration_Type();
+ OBD_PlugInOut_IOC_Status = FALSE;
+ }
+ if(Motion_Detect_Status) //Check if Accelerometer Interrupt is generated
+ {
+ Get_Acceleration_Type();
+ Motion_Detect_Status = FALSE;
+ }
+ }
+}
+
+void Get_Acceleration_Type(void)
+{
+ Packet_Type_To_Send = MOTION_TYPE_PACKET; //whenever acceleration is detected change the packet type to be sent to motion type
+ Lora_Packet_Sending_Ticker.detach(); //destroy ticker
+ Lora_Packet_Sending_Ticker.attach(&flip_Packet_Sending_Flag, 5.0); //create new ticker, time inetrval value to be changed
+ Send_Lora_Packet_Flag = 1; //set flag to send motion packet as soon as motion is detecetd
+ Motion_Lora_Packet.Acceleration_Type = Motion_Type_Detected; //Read Type of motion deteceted
+ //write code to read acceleration value for every 10sec after any of the acceleration is found
+}
+
+//This function is used to enable checkin packet sending once OBD device is plugged in
+void Enable_CheckIN_Packet_Sending()
+{
+ Packet_Type_To_Send = CHECKIN_TYPE_PACKET; //whenever acceleration is detected change the packet type to be sent to motion type
+ OBD_Plugin_Detected = TRUE;
+ Lora_Packet_Sending_Ticker.detach(); //destroy ticker
+ Lora_Packet_Sending_Ticker.attach(&flip_Packet_Sending_Flag, 5.0); //create new ticker
+ Send_Lora_Packet_Flag = 1; //Set Counter so that packet is sent instantly as soon as checkin interrupt is detected
+}
+
+static void Process_Lora_Command_Received(uint8* Command_Received,uint8 Command_Length)
+{
+ if(Command_Received[0] == 0xFE) //check start of frame of packet received. every packet must start with 0xFE
+ {
+ if(Calculate_Lora_Frame_FCS((Command_Received + 1),(Command_Length + 1)) == (Command_Received[Command_Length + 2])) //Check for packet inegrity by checking FCS
+ {
+ if((Command_Received[0] == SET_BEACON_CMD0) && (Command_Received[1] == SET_BEACON_CMD1)) //Check if command is received for setting beacon parameters
+ {
+ Process_Beacon_Command_Received((Command_Received + 2));
+ }
+ }
+ }
+}