LTE fonctionnel

ChaletLora.X/Source/InternalUart.c

@@ -373,7 +373,7 @@ int SendInternalUartData(char *p_pcDataBuf, int p_iDataSize, int p_iUartPort, ch
                     //					KickWatchdog();
 					U5TXREG = *p_stUartDataPtr->pcTxDataPtr++;
 					while(U5STAbits.TRMT == 0);
-					LTE_MODULE_TX_LED_PIN = ~ LTE_MODULE_TX_LED_PIN;
+//					LTE_MODULE_TX_LED_PIN = ~ LTE_MODULE_TX_LED_PIN;
 				}
 				p_stUartDataPtr->iIsBusy = 0;
 				DataSentNotification(p_stUartDataPtr->iUartHandle,iBufSize);
@@ -429,11 +429,11 @@ int SendInternalUartDataBlocking(char *p_pcDataBuf, int p_iDataSize, int p_iUart
             IEC2bits.U5TXIE = 0;
             for(i = 0; i < p_iDataSize; i++)
             {
-                LTE_MODULE_TX_LED_PIN = ~ LTE_MODULE_TX_LED_PIN;
+//                LTE_MODULE_TX_LED_PIN = ~ LTE_MODULE_TX_LED_PIN;
                 U2TXREG = *p_pcDataBuf++;
                 while(U5STAbits.TRMT == 0);
             }
-            LTE_MODULE_TX_LED_PIN = LED_OFF;
+//            LTE_MODULE_TX_LED_PIN = LED_OFF;
             IFS2bits.U5TXIF = 0;
             IEC2 = temp;
             break;
@@ -636,14 +636,17 @@ void __ISR(_UART_5_VECTOR, ipl7) InternalUart5Interrupt(void)
 		}
 		else
 		{
+//            LTE_MODULE_TX_LED_PIN = LED_ON;
 			do
 			{	
 				U5TXREG = *p_acUartDataPtr->pcTxDataPtr++;	//send data
 				p_acUartDataPtr->iNbFIFOPendingBytes--;
-				LTE_MODULE_TX_LED_PIN = ~ LTE_MODULE_TX_LED_PIN;
+				
 			}
 			while((U5STAbits.UTXBF == 0) && 	//while there is space in buffer
                     (p_acUartDataPtr->iNbFIFOPendingBytes != 0));	//and data to send
+            
+//            LTE_MODULE_TX_LED_PIN = LED_OFF;
 		}
 		
 	}

ChaletLora.X/Source/LTENetworkInterface.c

@@ -1,2 +1,344 @@
 #include "LTENetworkInterface.h"
+#include "NetworkProtocol.h"
+#include "SIM7080GInterface.h"
+#include "timer.h"
+#include "ChaletPowerRelay.h"
+#include "HarakiriRelay.h"
+#include "BatteryMonitor.h"
+#include "LedLightCtrl.h"
+#include "TemperatureSensor.h"
+#include "SPI_Flash.h"
+#include "FlashMapping.h"
+#include "LoraWatchdog.h"
+#include "versionbuild.h"
+#include "WiFiCtrl.h"
+#include "BoardCfg.h"
 
+int mLTENWISMState;
+static const char mFirmwareVersion[15] = VERSIONNUMBER;
+#define LORA_CHALET_STATUS_CUR_SENSOR_MASK 0x02
+#define LORA_CHALET_STATUS_POWER_RELAY_MASK 0x01
+
+unsigned int mLTETotalMasterNbRequests = 0;
+
+void LTENetworkInterfaceInit()
+{
+    ProtocolInit(NETWORK_PROTOCOL_USER_LTE);
+    
+    mLTENWISMState = LTE_NWI_INIT_STATE;
+}
+
+void ExecuteLTEMasterCommand(int SenderID, int Command, unsigned char *Data, int DataSize)
+{
+    KickLoraWatchdog();
+    ChaletPowerRelayKickTimer();
+    mLTETotalMasterNbRequests++;
+    LTE_MODULE_RX_LED_PIN = LED_OFF;
+    switch(SenderID)
+    {
+        case ID_MASTER:
+        {
+            switch(Command)
+            {
+                case CHALET_INTERFACE_ACK:
+                {
+                    break;
+                }
+                case CHALET_GENERAL_STATUS_REQUEST:
+                {
+                    float FloatVoltage = GetBatteryVoltage(1);
+                    float FloatTemperature = TempSensorGetTemp();
+                    unsigned int BattVoltage = *((int*)&FloatVoltage);
+                    unsigned int Temperature  = *((int*)&FloatTemperature);
+                    int SolarPanelCurrent = GetSolarPanelCurrent();
+                    int SOC = GetBatterySOC();
+                    
+                    char GeneralStatus = 0;
+                    char ChaletStatus[18];
+                    
+                    if(GetChaletPowerRelayState() == CHALET_POWER_RELAY_ON_STATE)
+                    {
+                        GeneralStatus |= LORA_CHALET_STATUS_POWER_RELAY_MASK;
+                    }
+                    if(GetCurrentModuleOK() == true)
+                    {
+                        GeneralStatus |= LORA_CHALET_STATUS_CUR_SENSOR_MASK;
+                    }
+                    
+                    ChaletStatus[0] = GeneralStatus;    //General Status
+                    ChaletStatus[1] = GetWiFiSate();    //Wifi Module state
+                    
+                    ChaletStatus[2] = (char)(BattVoltage & 0x000000FF);    //Battery Voltage 1
+                    BattVoltage >>= 8;
+                    ChaletStatus[3] = (char)(BattVoltage & 0x000000FF);    //Battery Voltage 2
+                    BattVoltage >>= 8;
+                    ChaletStatus[4] = (char)(BattVoltage & 0x000000FF);    //Battery Voltage 3
+                    BattVoltage >>= 8;
+                    ChaletStatus[5] = (char)(BattVoltage & 0x000000FF);    //Battery Voltage 4
+                    
+                    ChaletStatus[6] = (char)(SolarPanelCurrent & 0x000000FF);    //Solar panel Current 1
+                    SolarPanelCurrent >>= 8;
+                    ChaletStatus[7] = (char)(SolarPanelCurrent & 0x000000FF);    //Solar panel Current 2
+                    
+                    ChaletStatus[8] = (char)(SOC & 0x000000FF);    //Battery SOC 1
+                    SolarPanelCurrent >>= 8;    
+                    ChaletStatus[9] = (char)(SolarPanelCurrent & 0x000000FF);  //Battery SOC 2
+                    
+                    ChaletStatus[10] = (char)(Temperature & 0x000000FF);    //Temperature 1
+                    Temperature >>= 8;
+                    ChaletStatus[11] = (char)(Temperature & 0x000000FF);    //Temperature 2
+                    Temperature >>= 8;
+                    ChaletStatus[12] = (char)(Temperature & 0x000000FF);    //BTemperature 3
+                    Temperature >>= 8;
+                    ChaletStatus[13] = (char)(Temperature & 0x000000FF);    //Temperature 4
+                    
+                    int tmp = mLTETotalMasterNbRequests;
+                    ChaletStatus[14] = (char)(mLTETotalMasterNbRequests & 0x000000FF);    //Total Nb Requests 1
+                    mLTETotalMasterNbRequests >>= 8;
+                    ChaletStatus[15] = (char)(mLTETotalMasterNbRequests & 0x000000FF);    //Total Nb Requests 2
+                    mLTETotalMasterNbRequests >>= 8;
+                    ChaletStatus[16] = (char)(mLTETotalMasterNbRequests & 0x000000FF);    //Total Nb Requests 3
+                    mLTETotalMasterNbRequests >>= 8;
+                    ChaletStatus[17] = (char)(mLTETotalMasterNbRequests & 0x000000FF);    //Total Nb Requests 4
+                    mLTETotalMasterNbRequests = tmp;
+                    
+                    
+                    SendLTENetworkCommand(CHALET_GENERAL_STATUS_RESPONSE,ChaletStatus,18);
+                    
+                    HEARTBEAT_LED_1_PIN = ~HEARTBEAT_LED_1_PIN;
+                    
+                    break;
+                }
+                case CHALET_AC_POWER_STATE_STATUS_REQUEST:
+                {
+                    char PowerStatus = GetChaletPowerRelayState();
+                    SendLTENetworkCommand(CHALET_AC_POWER_STATE_STATUS_RESPONSE,&PowerStatus,1);
+                    break;
+                }
+                case CHALET_AC_POWER_SET_STATE_REQUEST:
+                {
+                    char response = CHALET_POWER_RELAY_UNKNOWN_STATE;
+                    if(Data[0] == CHALET_POWER_RELAY_OFF_STATE)
+                    {
+                        ChaletPowerRelayTurnOff();
+                        response = CHALET_POWER_RELAY_OFF_STATE;
+                    }
+                    else if(Data[0] == CHALET_POWER_RELAY_ON_STATE)
+                    {
+                        ChaletPowerRelayTurnOn();
+                        response = CHALET_POWER_RELAY_ON_STATE;
+                    }
+                    else
+                    {
+                        //invalid state requested.... don't do anything
+                        response = CHALET_POWER_RELAY_UNKNOWN_STATE;
+                    }
+                    
+                    SendLTENetworkCommand(CHALET_AC_POWER_SET_STATE_RESPONSE,&response,1);
+                    
+                    break;
+                }
+                case CHALET_BATTERY_VOLTAGE_REQUEST:
+                {
+                    
+                    break;
+                }
+                case CHALET_WIFI_STATUS_REQUEST:
+                {
+                    char response[5];
+                    uint32 IPAddress = GetCurIPAddress();
+                    
+                    response[0] = GetWiFiSate();    //Wifi Module state
+                    response[1] = IPV4_BYTE(IPAddress,0);
+                    response[2] = IPV4_BYTE(IPAddress,1);
+                    response[3] = IPV4_BYTE(IPAddress,2);
+                    response[4] = IPV4_BYTE(IPAddress,3);
+                    SendLTENetworkCommand(CHALET_WIFI_STATUS_RESPONSE,(unsigned char*)&response,5);
+                    break;
+                }        
+                case CHALET_WIFI_SET_STATE_REQUEST:
+                {
+                    char response = WIFI_UNKNOWN_STATE;
+                    if(Data[0] == 0)
+                    {
+                        TurnOFFWiFi();
+                        response = 0;
+                    }
+                    else if(Data[0] == 1)
+                    {
+                        if(GetWiFiSate() != WIFI_CONNECTED_STATE)
+                        {
+                            InitWiFi();
+                            response = GetWiFiSate();
+                        }
+                        else
+                        {
+                            response = 1;
+                        }
+                    }
+                    else
+                    {
+                        //invalid state requested.... don't do anything
+                        response = WIFI_UNKNOWN_STATE;
+                    }
+                    
+                    SendLTENetworkCommand(CHALET_WIFI_SET_STATE_RESPONSE,&response,1);
+                    break;
+                }
+                case CHALET_DO_HARAKIRI_REQUEST:
+                {
+                    char response;
+                    if(Data[0] == 0xBA &&
+                            Data[1] == 0xAD &&
+                            Data[2] == 0xBE &&
+                            Data[3] == 0xEF)
+                    {
+                        //Magic word is OK... let's suicide...
+                        response = 0x01;
+                        //First, send an ACK to master (this is blocking so it's OK)
+                        SendLTENetworkCommand(CHALET_DO_HARAKIRI_CONFIRMATION,&response,1);
+                        HarakiriRelayTurnOff();
+                    }
+                    else
+                    {
+                        response = 0x00;
+                        SendLTENetworkCommand(CHALET_DO_HARAKIRI_CONFIRMATION,&response,1);
+                    }
+                    break;
+                }
+                case CHALET_REBOOT_CPU_REQUEST:
+                {
+                    char response;
+                    if(Data[0] == 0xBA &&
+                            Data[1] == 0xAD &&
+                            Data[2] == 0xCA &&
+                            Data[3] == 0xFE)
+                    {
+                        //Magic word is OK... let's reboot...
+                        response = 0x01;
+                        //First, send an ACK to master (this is blocking so it's OK)
+                        SendLTENetworkCommand(CHALET_REBOOT_CPU_RESPONSE,&response,1);
+                        Sleep(100);
+                        TurnOFFWiFi();
+                        Sleep(100);
+                        SoftReset();
+                    }
+                    else
+                    {
+                        response = 0x00;
+                        SendLTENetworkCommand(CHALET_DO_HARAKIRI_CONFIRMATION,&response,1);
+                    }
+                    break;
+                }
+                case CHALET_GET_STORED_WIFI_SETTINGS_REQUEST:
+                {
+                    char response[140];
+                    char WifiDataSize;
+                    SPIFlashReadBuffer(response,11,FLASH_WIFI_IP_ADDRESS);
+                    WifiDataSize = 11 + response[9] + response[10];
+                    if(WifiDataSize > 140)
+                        break;
+                    SPIFlashReadBuffer(response,WifiDataSize,FLASH_WIFI_IP_ADDRESS);
+                    SendLTENetworkCommand(CHALET_GET_STORED_WIFI_SETTINGS_RESPONSE,response,WifiDataSize);
+                    break;
+                }
+                case CHALET_SET_STORED_WIFI_SETTINGS_REQUEST:
+                {
+                    char response = 0;
+                    if(SPIFlashWriteBuffer(Data,DataSize,FLASH_WIFI_IP_ADDRESS) == 1)
+                    {
+                        response = 1;
+                    }
+                    
+                    SendLTENetworkCommand(CHALET_SET_STORED_WIFI_SETTINGS_RESPONSE,&response,1);
+                    break;
+                }
+                case CHALET_GET_FIRMWARE_VERSION_REQUEST:
+                {
+                    SendLTENetworkCommand(CHALET_GET_FIRMWARE_VERSION_RESPONSE,(unsigned char*)mFirmwareVersion,15);
+                    break;
+                }
+                case CHALET_CLEAR_COMMS_STATISTICS_REQUEST:
+                {
+                    char response = 1;
+                    mLTETotalMasterNbRequests = 0;
+                    SendLTENetworkCommand(CHALET_CLEAR_COMMS_STATISTICS_RESPONSE,&response,1);
+                    break;
+                }
+                case ETH_NETWK_DEVICE_INFO_REQUEST:
+                {
+                    char data[2];
+                    data[0] = ID_CHALET_DEVICE;
+                    data[1] = MY_DEVICE_ADDRESS;
+                    int PayloadSize;
+                    unsigned char *response = ProtocolGetFrame(ID_MASTER,MASTER_ADDRESS,ID_ETHERNET_VIRTUAL,ETH_NETWK_DEVICE_INFO_RESPONSE, data,2,0, &PayloadSize);
+                    LTESendDataToMaster((char*)response,PayloadSize);
+                    
+                    break;
+                }
+                case ETH_NETWK_SET_DEVICE_INFO_ACK:
+                {
+                    LTENetworInterfaceExecSM(LTE_NWI_MASTER_CONNECTED_EVENT);
+                    break;
+                }
+                case ETH_NETWK_CONNECTION_REFUSED:
+                {
+                    //TODO: reset the TCP module to retry connection???
+                    break;
+                }
+            }
+            break;
+        }
+        default:
+        {
+            break;
+        }
+    }
+}
+
+void TickLTENetworkInterface()
+{
+    LTENetworInterfaceExecSM(LTE_NWI_TICK_EVENT);
+}
+
+void LTENetworInterfaceExecSM(int Event)
+{
+    switch(mLTENWISMState)
+    {
+        case LTE_NWI_INIT_STATE:
+        {
+            mLTENWISMState = LTE_NWI_CONNECT_TO_MASTER_STATE;
+            TimerStart(LTE_NWI_TIMER,LTE_NWI_MASTER_CONNECT_POLL_INTERVAL);
+            break;
+        }
+        case LTE_NWI_WAIT_FOR_LTE_STATE:
+        {
+            //Not necessary... master will init handshake on TCP connection....
+            break;
+        }
+        case LTE_NWI_CONNECT_TO_MASTER_STATE:   //Here we wait for the master to initiate the handshake after a TCP connection
+        {
+            if(Event == LTE_NWI_MASTER_CONNECTED_EVENT)
+            {
+                mLTENWISMState = LTE_NWI_OPERATE_STATE;
+            }
+            break;
+        }
+        case LTE_NWI_OPERATE_STATE:
+        {
+            if(Event == LTE_NWI_TICK_EVENT)
+            {
+                
+            }
+            break;
+        }
+    }
+}
+
+void SendLTENetworkCommand(int Command, unsigned char *Data, unsigned int DataSize)
+{
+    unsigned char *Payload;
+    unsigned int PayloadSize;
+    Payload = ProtocolGetFrame(ID_MASTER,MASTER_ADDRESS,ID_CHALET_DEVICE,Command,Data,DataSize,0,&PayloadSize);
+    LTESendDataToMaster(Payload,PayloadSize);
+}

ChaletLora.X/Source/LTENetworkInterface.h

@@ -8,7 +8,33 @@
 #ifndef LTENETWORKINTERFACE_H
 #define	LTENETWORKINTERFACE_H
 
+#define LTE_NWI_MASTER_CONNECT_POLL_INTERVAL 5000
 
+enum  eLTENWISMStates
+{
+    LTE_NWI_INIT_STATE,
+    LTE_NWI_WAIT_FOR_LTE_STATE,
+    LTE_NWI_CONNECT_TO_MASTER_STATE,
+    LTE_NWI_OPERATE_STATE,
+    
+    LTE_NWI_MAX_STATE
+};
+
+enum eLTENWISMEvents
+{
+    LTE_NWI_TICK_EVENT,
+    LTE_NWI_MASTER_CONNECTED_EVENT,
+    
+    LTE_NWI_MAX_EVENT
+};
+
+
+void LTENetworkInterfaceInit();
+void ExecuteLTEMasterCommand(int SenderID, int Command, unsigned char *Data, int DataSize);
+
+void TickLTENetworkInterface();
+void LTENetworInterfaceExecSM(int Event);
+void SendLTENetworkCommand(int Command, unsigned char *Data, unsigned int DataSize);
 
 #endif	/* LTENETWORKINTERFACE_H */
 

ChaletLora.X/Source/LoraNetworkInterface.c

@@ -15,6 +15,7 @@
 #include "LoraWatchdog.h"
 #include "versionbuild.h"
 #include "WiFiCtrl.h"
+
 //#include "WiFiCtrl.h"
 //
 
@@ -31,7 +32,13 @@ unsigned char mLoraPreamble[3]={0x00,LORA_MASTER_ADDRESS,LORA_CHANNEL};
 static const char mFirmwareVersion[15] = VERSIONNUMBER;
 unsigned int mTotalMasterNbRequests = 0;
 
-void ExecuteMasterCommand(int Command, unsigned char *Data, int DataSize)
+
+void LoraNetworkInterfaceInit()
+{
+    ProtocolInit(NETWORK_PROTOCOL_USER_LORA);
+}
+
+void ExecuteLoraMasterCommand(int Command, unsigned char *Data, int DataSize)
 {
     //Whatever was the command, we are online...
 	LORA_MODULE_RX_LED_PIN = LED_OFF;

ChaletLora.X/Source/LoraNetworkInterface.h

@@ -10,7 +10,8 @@
 #define LORA_CHALET_STATUS_POWER_RELAY_MASK 0x01
 #define LORA_CHALET_STATUS_CUR_SENSOR_MASK 0x02
 
-void ExecuteMasterCommand(int Command, unsigned char *Data, int DataSize);
+void LoraNetworkInterfaceInit();
+void ExecuteLoraMasterCommand(int Command, unsigned char *Data, int DataSize);
 void SendLoraNetworkCommand(int Command, unsigned char *Data, unsigned int DataSize);
 void SendLoraNetworkCommandBlocking(int Command, unsigned char *Data, unsigned int DataSize);    //USE WITH CARE
 

ChaletLora.X/Source/LoraWatchdog.c

@@ -4,6 +4,7 @@
 #include "BoardCfg.h"
 #include "timer.h"
 #include "LoraWatchdog.h"
+#include "SIM7080GInterface.h"
 
 int mLoraSMState;
 
@@ -61,6 +62,7 @@ void LoraWatchdogStateMachine(int Event)
 						LORA_MODULE_RELAY_PIN = 0;	//Turn ON the LoRa module
 						TimerStart(LORA_WATCHDOG_TIMER,LORA_WATCHDOG_REBOOT_TIMEOUT);	//If we don't get Comm. back after this delay... reboot the PIC
 						mLoraSMState = LORA_WATCHDOG_WAIT_FOR_RECONNECT_STATE;
+                        LTEModuleReset();
 					}
 					break;
 				}

ChaletLora.X/Source/NetworkProtocol.c

@@ -15,79 +15,89 @@ jean-francois.martel@polymtl.ca
 #include "NetworkProtocol.h"
 #include "Uart.h"
 #include <string.h>
-#include "ProtocolDefs.h"
+
 #include "MasterCtrlInterface.h"
 #include "LoraNetworkInterface.h"
+#include "LTENetworkInterface.h"
 
 
 
 
-unsigned char mRxData[MAX_MESSAGE_SIZE+10], mTxData[MAX_MESSAGE_SIZE+10];
-unsigned int DataSize = 0;
-unsigned int DataCtr = 0;
-unsigned int BufPtr = 0;
-unsigned char RxPtr = 0;
-unsigned char Command = 0;
-unsigned char State = RxHeader;
-unsigned char CRC = 0;
-unsigned char SenderID = 0;
-unsigned char SenderAddress = 0;
-unsigned char Flags = 0;
-unsigned char IsUpdating = 0;
-unsigned char *BmpDataPtr = 0;
-
 static char MyDeviceID = ID_SPRINKLER_DEVICE;
 
-void ProtocolInit(void)
+char mFrameData[MAX_MESSAGE_SIZE+10];
+
+ProtocolData_t mLoraProtocolData;
+ProtocolData_t mLTEProtocolData;
+
+
+void ProtocolInit(int User)
 {
-	ResetStateMachine();
+    ProtocolData_t *DataStruct;
+    switch(User)
+    {
+        case NETWORK_PROTOCOL_USER_LORA:
+        {
+            DataStruct = &mLoraProtocolData;
+            break;
+        }
+        case NETWORK_PROTOCOL_USER_LTE:
+        {
+            DataStruct = &mLTEProtocolData;
+            break;
+        }
+        default:
+            return;
+            break;
+    }
+	ResetStateMachine(DataStruct);
 
 }
 
-void StateMachine(unsigned char Data)
+void StateMachine(unsigned char Data,ProtocolData_t *ProtocolData )
 {
-	switch(State)
+	switch(ProtocolData->State)
 	{
 		case Initialization:	//Reset all pointers and data...
 		{
-			DataSize = 0;
+			ProtocolData->DataSize = 0;
-			BufPtr = 0;
+			ProtocolData->BufPtr = 0;
-			RxPtr = 0;
+			ProtocolData->RxPtr = 0;
-			Command = 0;
+			ProtocolData->Command = 0;
-			CRC = 0;
+			ProtocolData->CRC = 0;
-			State = RxHeader;
+			ProtocolData->State = RxHeader;
 			break;
 		}
 		case RxHeader:	//Wait for data header...
 		{
 			if(Data == FRAME_HEADER)
 			{
-				mRxData[BufPtr++] = Data;
+				ProtocolData->mRxData[ProtocolData->BufPtr++] = Data;
-				State = RxAdd;
+				ProtocolData->State = RxAdd;
-				CRC ^= Data;
+				ProtocolData->CRC ^= Data;
 			}
 			else
 			{
-				DataSize = 0;
+				ProtocolData->DataSize = 0;
-				ResetStateMachine();
+				ResetStateMachine(ProtocolData);
 			}
 			
 			break;	
 		}
 		case RxAdd:	//Sender Address.
 		{
-			SenderAddress = Data;
+			ProtocolData->SenderAddress = Data;
-			mRxData[BufPtr++] = Data;
+			ProtocolData->mRxData[ProtocolData->BufPtr++] = Data;
-		 	State = RxID;
+		 	ProtocolData->State = RxID;
-		 	CRC ^= Data;
+		 	ProtocolData->CRC ^= Data;
 			break;
 		}
 		case RxID:			//Sender ID
 		{
-			mRxData[BufPtr++] = Data;
+			ProtocolData->mRxData[ProtocolData->BufPtr++] = Data;
-			State = RxMyID;
+			ProtocolData->State = RxMyID;
-			SenderID = Data;
+			ProtocolData->SenderID = Data;
-			CRC ^= Data;
+			ProtocolData->CRC ^= Data;
 			break;
 		}
 		case RxMyID:
@@ -97,158 +107,182 @@ void StateMachine(unsigned char Data)
 //				ResetStateMachine();
 //				break;
 //			}
-			mRxData[BufPtr++] = Data;
+			ProtocolData->mRxData[ProtocolData->BufPtr++] = Data;
-			State = RxMyAddress;
+			ProtocolData->State = RxMyAddress;
-			CRC ^= Data;
+			ProtocolData->CRC ^= Data;
 			break;
 		}
 		case RxMyAddress:
 		{
 			if(Data != MY_DEVICE_ADDRESS && Data != BROADCAST_VALUE)	//Message is not for this device address and it's not a broadcast
 			{
-				ResetStateMachine();
+				ResetStateMachine(ProtocolData);
 				break;
 			}
-			mRxData[BufPtr++] = Data;
+			ProtocolData->mRxData[ProtocolData->BufPtr++] = Data;
-			State = RxFlags;
+			ProtocolData->State = RxFlags;
-			CRC ^= Data;
+			ProtocolData->CRC ^= Data;
 			break;	
 		}
 		case RxFlags:
 		{
-			Flags = Data;
+			ProtocolData->Flags = Data;
-			mRxData[BufPtr++] = Data;
+			ProtocolData->mRxData[ProtocolData->BufPtr++] = Data;
-			State = RxCMD;
+			ProtocolData->State = RxCMD;
-			CRC ^= Data;
+			ProtocolData->CRC ^= Data;
 			break;
 		}
 		case RxCMD:
 		{
-			Command = Data;
+			ProtocolData->Command = Data;
-			mRxData[BufPtr++] = Data;
+			ProtocolData->mRxData[ProtocolData->BufPtr++] = Data;
-			State = RxSize1;
+			ProtocolData->State = RxSize1;
-			CRC ^= Data;
+			ProtocolData->CRC ^= Data;
 			break;	
 		}
 		case RxSize1:	//Data size MSB
 		{
-			DataSize = 0;
+			ProtocolData->DataSize = 0;
-			DataSize = (unsigned int)Data;
+			ProtocolData->DataSize = (unsigned int)Data;
-			DataSize <<= 8;
+			ProtocolData->DataSize <<= 8;
-			mRxData[BufPtr++] = Data;
+			ProtocolData->mRxData[ProtocolData->BufPtr++] = Data;
 			
 					
-			State = RxSize2;
+			ProtocolData->State = RxSize2;
-			CRC ^= Data;
+			ProtocolData->CRC ^= Data;
 			break;	
 		}
         case RxSize2:	//Data size
 		{
-			DataSize |= (unsigned int)Data;
+			ProtocolData->DataSize |= (unsigned int)Data;
-			DataSize <<= 8;
+			ProtocolData->DataSize <<= 8;
-			mRxData[BufPtr++] = Data;
+			ProtocolData->mRxData[ProtocolData->BufPtr++] = Data;
 			
 					
-			State = RxSize3;
+			ProtocolData->State = RxSize3;
-			CRC ^= Data;
+			ProtocolData->CRC ^= Data;
 			break;	
 		}
         case RxSize3:	//Data size
 		{
-			DataSize |= (unsigned int)Data;
+			ProtocolData->DataSize |= (unsigned int)Data;
-			DataSize <<= 8;
+			ProtocolData->DataSize <<= 8;
-			mRxData[BufPtr++] = Data;
+			ProtocolData->mRxData[ProtocolData->BufPtr++] = Data;
 			
 					
-			State = RxSize4;
+			ProtocolData->State = RxSize4;
-			CRC ^= Data;
+			ProtocolData->CRC ^= Data;
 			break;	
 		}
 		
 		case RxSize4:	//Data size LSB
 		{
-			DataSize |= (unsigned int)Data;
+			ProtocolData->DataSize |= (unsigned int)Data;
-			mRxData[BufPtr++] = Data;
+			ProtocolData->mRxData[ProtocolData->BufPtr++] = Data;
 
-			if(DataSize > MAX_MESSAGE_SIZE)
+			if(ProtocolData->DataSize > MAX_MESSAGE_SIZE)
-				ResetStateMachine();
+				ResetStateMachine(ProtocolData);
 			
-			if(DataSize == 0)
+			if(ProtocolData->DataSize == 0)
-				State = RxCRC;
+				ProtocolData->State = RxCRC;
 			else
-				State = RxData;
+				ProtocolData->State = RxData;
 			
-			CRC ^= Data;
+			ProtocolData->CRC ^= Data;
 			break;	
 		}
 		case RxData:
 		{
-			CRC ^= Data;
+			ProtocolData->CRC ^= Data;
 
-			mRxData[BufPtr++] = Data;
+			ProtocolData->mRxData[ProtocolData->BufPtr++] = Data;
-			DataCtr++;
+			ProtocolData->DataCtr++;
 
-			if(DataCtr == DataSize)
+			if(ProtocolData->DataCtr == ProtocolData->DataSize)
 			{
-				State = RxCRC;
+				ProtocolData->State = RxCRC;
 			}
 			
 			break;
 		}
 		case RxCRC:
 		{
-			if(Data != CRC)
+			if(Data != ProtocolData->CRC)
 			{
-				ResetStateMachine();
+				ResetStateMachine(ProtocolData);
 //				ProtocolAcknowledge(0,Command,0);
 				break;
 			}
 //			NewMasterMessageReceived(mRxData);
-            ExecuteMasterCommand(Command,ProtocolMsgDataPtr(),DataSize);
+            if(ProtocolData == &mLoraProtocolData)
-			ResetStateMachine();
+            {
+                ExecuteLoraMasterCommand(ProtocolData->Command,ProtocolMsgDataPtr(ProtocolData),ProtocolData->DataSize);
+            }
+            else if(ProtocolData == &mLTEProtocolData)
+            {
+                ExecuteLTEMasterCommand(ProtocolData->SenderID, ProtocolData->Command,ProtocolMsgDataPtr(ProtocolData),ProtocolData->DataSize);
+            }
+			ResetStateMachine(ProtocolData);
 			break;
 		}
 		default:
 		{
-			ResetStateMachine();
+			ResetStateMachine(ProtocolData);
 			break;
 		}		
 	}	
 }
 
-void ProtocolAnalyzeNewData(unsigned char Data)
+void ProtocolAnalyzeNewData(unsigned char Data, int User)
 {
+    ProtocolData_t *DataStruct;
+    switch(User)
+    {
+        case NETWORK_PROTOCOL_USER_LORA:
+        {
+            DataStruct = &mLoraProtocolData;
+            break;
+        }
+        case NETWORK_PROTOCOL_USER_LTE:
+        {
+            DataStruct = &mLTEProtocolData;
+            break;
+        }
+        default:
+            return;
+            break;
+    }
 //	mRxData[RxPtr] = Data;
 //	printf("%X",Data);
-	StateMachine(Data);	
+	StateMachine(Data, DataStruct);	
 }
 	
-void ResetStateMachine(void)
+void ResetStateMachine(ProtocolData_t *ProtocolData)
 {
-	DataSize = 0;
+    ProtocolData->DataSize = 0;
-	BufPtr = 0;
+	ProtocolData->BufPtr = 0;
-	RxPtr = 0;
+	ProtocolData->RxPtr = 0;
-	Command = 0;
+	ProtocolData->Command = 0;
-	CRC = 0;
+	ProtocolData->CRC = 0;
-	State = RxHeader;
+	ProtocolData->State = RxHeader;
-	DataCtr = 0;
+	ProtocolData->DataCtr = 0;
-	Flags = 0;
+	ProtocolData->Flags = 0;
-	SenderAddress = 0;
+	ProtocolData->SenderAddress = 0;
 }
 
 void ProtocolExecCmd(void)
 {
-	switch(Command)
+//	switch(Command)
-	{
+//	{
-		case RX_GET_STATUS:
+//		case RX_GET_STATUS:
-		{
+//		{
-			unsigned char StatusByte =0;
+//			unsigned char StatusByte =0;
-//			memcpy(&StatusByte, &IRRemoteStatus, sizeof(IRRemoteStatus));
+////			memcpy(&StatusByte, &IRRemoteStatus, sizeof(IRRemoteStatus));
-//			ProtocolSendCmd(TX_DEADBOLT_STATUS,&StatusByte,sizeof(StatusByte),1,0);
+////			ProtocolSendCmd(TX_DEADBOLT_STATUS,&StatusByte,sizeof(StatusByte),1,0);
-
+//
-			break;
+//			break;
-		}
+//		}
-	}
+//	}
 }
 
 void ProtocolAcknowledge(unsigned char Answer,unsigned char Cmd, unsigned char Data)
@@ -281,10 +315,10 @@ unsigned char ProtocolCalcCrc(unsigned char* Buffer,unsigned char size)
 
 unsigned char ProtocolIsReceiving(void)
 {
-	if(State == RxHeader)
+//	if(State == RxHeader)
-		return 0;	// Idle...
+//		return 0;	// Idle...
-	else
+//	else
-		return 1;	//receiving from serial port
+//		return 1;	//receiving from serial port
 
 }
 
@@ -295,30 +329,32 @@ unsigned char* ProtocolGetFrame(unsigned char DestDevice,unsigned char DestAddre
     if(Size > MAX_MESSAGE_SIZE)
     {
         *FrameSize = 0;
-        return &mTxData[FRAME_HEADER_INDEX];
+        return &mFrameData[FRAME_HEADER_INDEX];
     }
     
-  	mTxData[FRAME_HEADER_INDEX] = FRAME_HEADER;	//header
+    
-	mTxData[FRAME_SENDER_ADDRESS_INDEX] = MY_DEVICE_ADDRESS;		//My Address
+    
-    mTxData[FRAME_SENDER_DEVICE_ID_INDEX] = SenderDevice;	//My ID
+  	mFrameData[FRAME_HEADER_INDEX] = FRAME_HEADER;	//header
-	mTxData[FRAME_DEST_DEVICE_ID_INDEX] = DestDevice;			//Destination ID
+	mFrameData[FRAME_SENDER_ADDRESS_INDEX] = MY_DEVICE_ADDRESS;		//My Address
-	mTxData[FRAME_DEST_ADDRESS_INDEX] = DestAddress ;//Address;				//Destination Address
+    mFrameData[FRAME_SENDER_DEVICE_ID_INDEX] = SenderDevice;	//My ID
-	mTxData[FRAME_FLAGS_INDEX] = Flags;				//Flags
+	mFrameData[FRAME_DEST_DEVICE_ID_INDEX] = DestDevice;			//Destination ID
-	mTxData[FRAME_COMMAND_INDEX] = Cmd;			//Command to send
+	mFrameData[FRAME_DEST_ADDRESS_INDEX] = DestAddress ;//Address;				//Destination Address
-    mTxData[FRAME_SIZE1_INDEX] = (unsigned char)((Size >> 24) & 0xFF);
+	mFrameData[FRAME_FLAGS_INDEX] = Flags;				//Flags
-    mTxData[FRAME_SIZE2_INDEX] = (unsigned char)((Size >> 16) & 0xFF);
+	mFrameData[FRAME_COMMAND_INDEX] = Cmd;			//Command to send
-    mTxData[FRAME_SIZE3_INDEX] = (unsigned char)((Size >> 8) & 0xFF);
+    mFrameData[FRAME_SIZE1_INDEX] = (unsigned char)((Size >> 24) & 0xFF);
-    mTxData[FRAME_SIZE4_INDEX] = (unsigned char)(Size & 0xFF);
+    mFrameData[FRAME_SIZE2_INDEX] = (unsigned char)((Size >> 16) & 0xFF);
-	memcpy((void*)&mTxData[FRAME_DATA_INDEX],(void*)Data,Size);			//Cmd data
+    mFrameData[FRAME_SIZE3_INDEX] = (unsigned char)((Size >> 8) & 0xFF);
-	mTxData[Size+FRAME_DATA_INDEX] = ProtocolCalcCrc(mTxData,Size + FRAME_DATA_INDEX);		// CRC
+    mFrameData[FRAME_SIZE4_INDEX] = (unsigned char)(Size & 0xFF);
+	memcpy((void*)&mFrameData[FRAME_DATA_INDEX],(void*)Data,Size);			//Cmd data
+	mFrameData[Size+FRAME_DATA_INDEX] = ProtocolCalcCrc(mFrameData,Size + FRAME_DATA_INDEX);		// CRC
     
     *FrameSize = Size + FRAME_INDEX_NBR;
 
-    return &mTxData[FRAME_HEADER_INDEX];
+    return &mFrameData[FRAME_HEADER_INDEX];
 	
 }
 
-unsigned char *ProtocolMsgDataPtr()
+unsigned char *ProtocolMsgDataPtr(ProtocolData_t *ProtocolData)
 {
-    return &mRxData[FRAME_DATA_INDEX];
+    return &ProtocolData->mRxData[FRAME_DATA_INDEX];
 }

ChaletLora.X/Source/NetworkProtocol.h

@@ -17,12 +17,19 @@ jean-francois.martel@polymtl.ca
 #define	BOOTLOADERINTERFACE_H
 
 //Protocol buffer specific definitions
+#include "ProtocolDefs.h"
 
 #define MASTER_ADDRESS 0x01
 #define MY_DEVICE_ADDRESS 0x01
 
 #define ADDRESS 0x01
 
+enum eProtocolUser
+{
+    NETWORK_PROTOCOL_USER_LORA,
+    NETWORK_PROTOCOL_USER_LTE
+};
+
 //State Machine states
 enum States
 {
@@ -63,15 +70,33 @@ enum States
 
 //State machine states definition
 
-void ProtocolInit(void);
+typedef struct stProtocolData
-void StateMachine(unsigned char STATE);
+{
-void ProtocolAnalyzeNewData(unsigned char RxByte);
+unsigned char mRxData[MAX_MESSAGE_SIZE+10];
-void ResetStateMachine(void);
+unsigned char mTxData[MAX_MESSAGE_SIZE+10];
+unsigned int DataSize;
+unsigned int DataCtr;
+unsigned int BufPtr;
+unsigned char RxPtr;
+unsigned char Command;
+unsigned char State;
+unsigned char CRC;
+unsigned char SenderID;
+unsigned char SenderAddress;
+unsigned char Flags;
+unsigned char IsUpdating;
+unsigned char *BmpDataPtr;
+}ProtocolData_t;
+
+void ProtocolInit(int User);
+void StateMachine(unsigned char STATE, ProtocolData_t *ProtocolData);
+void ProtocolAnalyzeNewData(unsigned char RxByte, int User);
+void ResetStateMachine(ProtocolData_t *ProtocolData);
 void ProtocolExecCmd(void);
 void ProtocolAcknowledge(unsigned char Answer,unsigned char Cmd, unsigned char Data);
 unsigned char* ProtocolGetFrame(unsigned char DestDevice,unsigned char DestAddress, unsigned char SenderDevice, unsigned char Cmd, unsigned char *Data,unsigned int Size,unsigned char Flags, int *FrameSize);
 unsigned char ProtocolCalcCrc(unsigned char* Buffer,unsigned char size);
 unsigned char ProtocolIsReceiving(void);
-unsigned char *ProtocolMsgDataPtr();
+unsigned char *ProtocolMsgDataPtr(ProtocolData_t *ProtocolData);
 
 #endif

ChaletLora.X/Source/SIM7080GInterface.c

@@ -6,11 +6,12 @@
 #include "WiFiCtrl.h"
 #include "ATCmdInterpreter.h"
 #include "ProtocolDefs.h"
+#include "NetworkProtocol.h"
 
 static BYTE mActivateNetworkCmd[] = "AT+CNACT=0,1\r";
 static BYTE mDisconnectNetworkCmd[] = "AT+CNACT=0,0\r";
 static BYTE mCheckAPNConnectionCmd[] = "AT+CNACT?\r";
-static BYTE mConnectToMasterCmd[] = "AT+CAOPEN=0,0,\"TCP\",\"grosgin.myftp.org\",6463\r";
+static BYTE mConnectToMasterCmd[] = "AT+CAOPEN=0,0,\"TCP\",\"grosgin.myftp.org\",2182\r";
 static BYTE mDisconnectFromMasterCmd[] = "AT+CACLOSE=0\r";
 static BYTE mReceiveDataCmd[] = "AT+CARECV=0,100\r";
 
@@ -85,6 +86,7 @@ void LTEModuleSM(int SMEvent)
                 LTE_MODULE_PWR_PIN = 1;
                 TimerStart(LTE_MODULE_TIMER,LTE_MODULE_WAIT_INIT_TIMEOUT);
                 mLTEModuleSMState = LTE_MODULE_SM_WAIT_RDY_STATE;
+                TimerStart(LTE_COMM_TIMER, LTE_MODULE_MAX_COMM_TIMEOUT);
             }
             break;
         }
@@ -96,11 +98,10 @@ void LTEModuleSM(int SMEvent)
             }
             else if(SMEvent == LTE_MODULE_SM_TICK_EVENT)
             {
-                //TODO: it module takes too much time... reset..
+                if(IsTimerExpired(LTE_COMM_TIMER) == true)
-                //            if(IsTimerExpired(LTE_MODULE_TIMER) == true)
+                {
-                //            {
+                    LTEModuleReset();
-                //                mLTEModuleSMState = LTE_MODULE_SM_SETAPN_STATE;
+                }
-                //            }
             }
             break;
         }
@@ -278,6 +279,7 @@ int LTEEnableSerialDebug(bool EnModule, bool EnPic)
 
 void SendDataToLteModule(char *Data, int Size)
 {
+    
     if(mPICSerialDebugEnabled)
     {
         char *ptr = Data;
@@ -410,12 +412,12 @@ void LTEModuleAPNConnectionStatus(int Status)
     if(Status == LTE_MODULE_APN_CONNECTED)
     {
         mAPNConnected = true;
-      //  SyslogNewString("APN connected\n");
+        //  SyslogNewString("APN connected\n");
     }
     else
     {
         mAPNConnected = false;
-       // SyslogNewString("APN disconnected\n");
+        // SyslogNewString("APN disconnected\n");
     }
 }
 void LTEModuleMasterConnectionStatus(int Status)
@@ -423,18 +425,18 @@ void LTEModuleMasterConnectionStatus(int Status)
     if(Status == LTE_MODULE_MASTER_CONNECTED)
     {
         mMasterConnected = true;
-      //  SyslogNewString("Master connected\n");
+        //  SyslogNewString("Master connected\n");
     }
     else if(Status == LTE_MODULE_MASTER_SOCKET_ERROR)
     {
         mMasterConnected = false;
         mMasterSocketError = true;
-    //    SyslogNewString("Master socket error\n");
+        //    SyslogNewString("Master socket error\n");
     }
     else
     {
         mMasterConnected = false;
-     //   SyslogNewString("Master disconnected\n");
+        //   SyslogNewString("Master disconnected\n");
     }
 }
 
@@ -461,14 +463,17 @@ void LTEModuleOperationSM(int OperationEvent)
                 LTESendCommandToModule(LTE_MODULE_CHECK_APN_CONNECTION_CMD);
                 mLTEModuleOperationSMState = LTE_MODULE_OPERATION_CHECK_APN_STATE;
             }
-            if(OperationEvent == LTE_MODULE_OP_APN_CONN_FAILED_EVENT)
+            else if(OperationEvent == LTE_MODULE_OP_APN_CONN_FAILED_EVENT)
             {
                 //TODO: What do we do??
                 LTEModuleReset();   //Something's wrong... reset the module.
             }
             else if(OperationEvent == LTE_MODULE_OP_TICK_EVENT)
             {
-                //TODO: manage timeouts
+                if(IsTimerExpired(LTE_COMM_TIMER) == true)
+                {
+                    LTEModuleReset();
+                }
             }
             
             break;
@@ -490,18 +495,18 @@ void LTEModuleOperationSM(int OperationEvent)
                     mLTEModuleOperationSMState = LTE_MODULE_OPERATION_STANDBY_STATE;
                 }
             }
-            if(OperationEvent == LTE_MODULE_OP_APN_DISCONNECTED_EVENT)
+            else if(OperationEvent == LTE_MODULE_OP_APN_DISCONNECTED_EVENT)
             {
-                //TODO:  What do we do??
+                //Let the main loop retry later...
-                
+                mCurrentCmd = LTE_MODULE_NO_CMD;
-                //Send the request to connect to Mastercontroller
+                mLTEModuleOperationSMState = LTE_MODULE_OPERATION_STANDBY_STATE;
-                //                mCurrentCmd = LTE_MODULE_CONNECT_TO_MASTER_CMD;
-                //                SendDataToLteModule(mConnectToMasterCmd,strlen(mConnectToMasterCmd));
-                //                mLTEModuleOperationSMState = LTE_MODULE_OPERATION_WAIT_CONNECT_SERVER_STATE;
             }
             else if(OperationEvent == LTE_MODULE_OP_TICK_EVENT)
             {
-                //TODO: manage timeouts
+                if(IsTimerExpired(LTE_COMM_TIMER) == true)
+                {
+                    LTEModuleReset();
+                }
             }
             break;
         }
@@ -513,22 +518,26 @@ void LTEModuleOperationSM(int OperationEvent)
                 mLTEModuleOperationSMState = LTE_MODULE_OPERATION_STANDBY_STATE;
                 TimerStart(LTE_MODULE_TIMER,LTE_MODULE_CONNECTION_CHECK_TIMEOUT);
             }
-            if(OperationEvent == LTE_MODULE_OP_SERVER_DISCONNECTED_EVENT)
+            else if(OperationEvent == LTE_MODULE_OP_SERVER_DISCONNECTED_EVENT)
             {
                 //TODO: What do we do?
                 
                 mCurrentCmd = LTE_MODULE_NO_CMD;
                 mLTEModuleOperationSMState = LTE_MODULE_OPERATION_STANDBY_STATE;
                 TimerStart(LTE_MODULE_TIMER,LTE_MODULE_CONNECTION_CHECK_TIMEOUT);
+                
             }
-            if(OperationEvent == LTE_MODULE_OP_SERVER_CONN_FAILED_EVENT)
+            else if(OperationEvent == LTE_MODULE_OP_SERVER_CONN_FAILED_EVENT)
             {
                 mCurrentCmd = LTE_MODULE_NO_CMD;
                 //TODO: What do we do?
             }
             else if(OperationEvent == LTE_MODULE_OP_TICK_EVENT)
             {
-                //TODO: manage timeouts
+                if(IsTimerExpired(LTE_COMM_TIMER) == true)
+                {
+                    LTEModuleReset();
+                }
             }
             break;
         }
@@ -540,12 +549,23 @@ void LTEModuleOperationSM(int OperationEvent)
                 mLTEModuleOperationSMState = LTE_MODULE_OPERATION_WAIT_CONNECT_SERVER_STATE;
                 LTESendCommandToModule(LTE_MODULE_CONNECT_TO_MASTER_CMD);
             }
+            else if(OperationEvent == LTE_MODULE_OP_TICK_EVENT)
+            {
+                if(IsTimerExpired(LTE_COMM_TIMER) == true)
+                {
+                    LTEModuleReset();
+                }
+            }
             break;
         }
         case LTE_MODULE_OPERATION_STANDBY_STATE:
         {
             if(OperationEvent == LTE_MODULE_OP_TICK_EVENT)
             {
+                if(IsTimerRunning(LTE_COMM_TIMER) == true)
+                {
+                    TimerStop(LTE_COMM_TIMER);
+                }
                 switch(mLTEModuleOperationSMSubState)
                 {
                     case LTE_MODULE_OPERATION_NOMINAL_SUBSTATE:
@@ -557,7 +577,6 @@ void LTEModuleOperationSM(int OperationEvent)
                                 char tmp[] = "Ca marche\n\r";
                                 mNbMasterReconnectCount = 0;
                                 TimerStart(LTE_MODULE_TIMER,LTE_MODULE_CONNECTION_CHECK_TIMEOUT);
-                                LTESendDataToMaster(tmp,strlen(tmp));
                             }
                             else
                             {
@@ -568,7 +587,7 @@ void LTEModuleOperationSM(int OperationEvent)
                                     mLTEModuleOperationSMSubState = LTE_MODULE_OPERATION_RECONNECT_MASTER_SUBSTATE;
                                     mLTEModuleOperationSMState = LTE_MODULE_OPERATION_WAIT_DISCONNECT_SERVER_STATE;
                                     LTESendCommandToModule(LTE_MODULE_DISCONNECT_FROM_MASTER_CMD); //Always disconnect before reconnecting...
-                                //    SyslogNewString("Master reconnection attempt\n");
+                                    //    SyslogNewString("Master reconnection attempt\n");
                                 }
                                 else    //We tried 10 times, check the APN
                                 {
@@ -576,7 +595,7 @@ void LTEModuleOperationSM(int OperationEvent)
                                     mLTEModuleOperationSMSubState = LTE_MODULE_OPERATION_CHECK_APN_SUBSTATE;
                                     LTESendCommandToModule(LTE_MODULE_CHECK_APN_CONNECTION_CMD);
                                     mNbMasterReconnectCount = 0;
-                                   // SyslogNewString("Master reconnection attempt count reached.. checking APN\n");
+                                    // SyslogNewString("Master reconnection attempt count reached.. checking APN\n");
                                 }
                             }
                         }
@@ -586,14 +605,14 @@ void LTEModuleOperationSM(int OperationEvent)
                     {
                         mLTEModuleOperationSMSubState = LTE_MODULE_OPERATION_NOMINAL_SUBSTATE;
                         //TODO: check for SOCKET ERROR result code and reset APN directly here?
-//                        if(mMasterSocketError == true)
+                        //                        if(mMasterSocketError == true)
-//                        {
+                        //                        {
-//                            mMasterSocketError = false;
+                        //                            mMasterSocketError = false;
-//                            mLTEModuleOperationSMState = LTE_MODULE_OPERATION_CHECK_APN_STATE;
+                        //                            mLTEModuleOperationSMState = LTE_MODULE_OPERATION_CHECK_APN_STATE;
-//                            mLTEModuleOperationSMSubState = LTE_MODULE_OPERATION_CHECK_APN_SUBSTATE;
+                        //                            mLTEModuleOperationSMSubState = LTE_MODULE_OPERATION_CHECK_APN_SUBSTATE;
-//                            LTESendCommandToModule(LTE_MODULE_CHECK_APN_CONNECTION_CMD);
+                        //                            LTESendCommandToModule(LTE_MODULE_CHECK_APN_CONNECTION_CMD);
-//                            mNbMasterReconnectCount = 0;                            
+                        //                            mNbMasterReconnectCount = 0;                            
-//                        }
+                        //                        }
                         break;
                     }
                     case LTE_MODULE_OPERATION_CHECK_APN_SUBSTATE:
@@ -638,15 +657,18 @@ void LTEModuleOperationSM(int OperationEvent)
         }
         case LTE_MODULE_OPERATION_WAIT_FOR_DATA_STATE:
         {
-            if(OperationEvent == LTE_MODULE_OP_TICK_EVENT)
-            {
-                //TODO: manage timeouts
-            }
             if(OperationEvent == LTE_MODULE_OP_MASTER_DATA_RECEIVED_EVENT)
             {
                 mCurrentCmd = LTE_MODULE_NO_CMD;
                 mLTEModuleOperationSMState = LTE_MODULE_OPERATION_STANDBY_STATE;
             }
+            else if(OperationEvent == LTE_MODULE_OP_TICK_EVENT)
+            {
+                if(IsTimerExpired(LTE_COMM_TIMER) == true)
+                {
+                    LTEModuleReset();
+                }
+            }
             
             break;
         }
@@ -654,9 +676,12 @@ void LTEModuleOperationSM(int OperationEvent)
         {
             if(OperationEvent == LTE_MODULE_OP_TICK_EVENT)
             {
-                //TODO: manage timeouts
+                if(IsTimerExpired(LTE_COMM_TIMER) == true)
+                {
+                    LTEModuleReset();
+                }
             }
-            if(OperationEvent == LTE_MODULE_OP_MASTER_DATA_SENT_EVENT)
+            else if(OperationEvent == LTE_MODULE_OP_MASTER_DATA_SENT_EVENT)
             {
                 mCurrentCmd = LTE_MODULE_NO_CMD;
                 mLTEModuleOperationSMState = LTE_MODULE_OPERATION_STANDBY_STATE;
@@ -674,7 +699,11 @@ void LTEModuleNewDataReady()
 void LTEModuleDataReceived(char *Data, int Size)
 {
     LTEModuleOperationSM(LTE_MODULE_OP_MASTER_DATA_RECEIVED_EVENT);
-    //Execute command..
+    int i;
+    for(i = 0; i < Size; i++)
+    {
+        ProtocolAnalyzeNewData(Data[i], NETWORK_PROTOCOL_USER_LTE);
+    }
 }
 
 int LTESendCommandToModule(int Cmd)
@@ -682,6 +711,7 @@ int LTESendCommandToModule(int Cmd)
     switch(Cmd)
     {
         
+        TimerStart(LTE_COMM_TIMER,LTE_MODULE_MAX_COMM_TIMEOUT);
         case LTE_MODULE_CONNECT_APN_CMD:
         {
             mCurrentCmd = LTE_MODULE_CONNECT_APN_CMD;
@@ -733,6 +763,7 @@ int LTESendCommandToModule(int Cmd)
         case LTE_MODULE_NO_CMD:
         default:
         {
+            TimerStop(LTE_COMM_TIMER);
             mCurrentCmd = LTE_MODULE_NO_CMD;
             return RET_ERROR;
             break;
@@ -748,13 +779,14 @@ void LTEModuleMasterCtrlCommStatus(bool Offline)
     {
         mMasterConnected = false;
     }
-//    else
+    //    else
-//        mMasterConnected = true;
+    //        mMasterConnected = true;
 }
 
 //This is the function to call from outside to send data to the server
 int LTESendDataToMaster(char *Buffer, int Size)
 {
+    LTE_MODULE_TX_LED_PIN = LED_ON;
     if(Size > MAX_MESSAGE_SIZE)
     {
         return RET_ERROR;
@@ -774,5 +806,11 @@ int LTESendDataToMaster(char *Buffer, int Size)
 int LTESendMasterBufferToModule()
 {
     SendDataToLteModule(mMasterTxBuffer,mMasterTxSize);
+    LTE_MODULE_TX_LED_PIN = LED_OFF;
     return RET_OK;
+}
+
+bool LTEModuleIsMasterConnected()
+{
+    return mMasterConnected;
 }

ChaletLora.X/Source/SIM7080GInterface.h

@@ -15,6 +15,7 @@
 #define LTE_MODULE_CONNECTION_CHECK_TIMEOUT 5000
 #define LTE_MODULE_MAX_CMD_LENGTH 128
 #define LTE_MODULE_MAX_MASTER_CONNECT_RETRY 5
+#define LTE_MODULE_MAX_COMM_TIMEOUT 10000
 
 enum eLTEModuleCommands
 {
@@ -146,5 +147,7 @@ void LTEModuleNewDataReady();
 void LTEModuleDataReceived(char *Data, int Size);
 void LTEModuleMasterCtrlCommStatus(bool Offline);
 
+bool LTEModuleIsMasterConnected();
+
 #endif	/* SIM7080GINTERFACE_H */
 

ChaletLora.X/Source/main.c

@@ -43,6 +43,7 @@
 #include "LoraWatchdog.h"
 #include "LCDCtrl.h"
 #include "SIM7080GInterface.h"
+#include "LTENetworkInterface.h"
 
 #include "BootloaderInterface.h"
 
@@ -60,6 +61,7 @@
 void _mon_putc(char c);	//override from stdio to redirect stdout on uart 3B
 #elif defined USE_SYSLOG
 #include "Syslog.h"
+#include "LoraNetworkInterface.h"
 void _mon_putc(char c);	//override from stdio to redirect stdout on uart 3B
 #endif
 
@@ -102,13 +104,16 @@ int main(void)
 	
     
     InitUart();
-    ProtocolInit();
+    LoraNetworkInterfaceInit();
 	InitLoraWatchdog();
     
+    
+    
     InitSPIFlash();
 	InitLCDCtrl();
+    
     InitLTEModule();
-	
+	LTENetworkInterfaceInit();
 	
 
 #ifdef USE_SYSLOG
@@ -207,9 +212,10 @@ int main(void)
 		SyslogTick();
 		TickTempSensor();
 		BootloaderInterfaceTick();
-	//	TickLoraWatchdog();
+		TickLoraWatchdog();
 		TickLCDCtrl();
         TickLTEModule();
+        TickLTENetworkInterface();
 		
         if(IsTimerExpired(HEARTBEAT_LED_TMR))
         {

ChaletLora.X/Source/timer.h

@@ -52,6 +52,8 @@ typedef enum
     LORA_WATCHDOG_TIMER,
     LCD_CTRL_TIMER,
     LTE_MODULE_TIMER,
+    LTE_COMM_TIMER,
+    LTE_NWI_TIMER,
 	TIMER_MAX_ID
 }eTimerID;
 

ChaletLora.X/nbproject/Makefile-genesis.properties

@@ -1,5 +1,5 @@
 #
-#Mon Dec 30 11:51:17 EST 2024
+#Mon Dec 30 20:57:03 EST 2024
 ChaletDuinoV2_795F512H_.languagetoolchain.dir=C\:\\Program Files\\Microchip\\xc32\\v1.33\\bin
 default.languagetoolchain.dir=C\:\\Program Files\\Microchip\\xc32\\v1.33\\bin
 proj.dir=D\:\\Main\\PicDev\\Projets\\ChaletLora\\ChaletLora.X
@@ -13,7 +13,7 @@ host.platform=windows
 ChaletDuinoV2_795F512H_.com-microchip-mplab-nbide-toolchain-xc32-XC32LanguageToolchain.md5=de2d3bc95a22a3f432c2e39f49efafbc
 ChaletDuinoV2_795F512H_.Pack.dfplocation=C\:\\Users\\JF\\.mchp_packs\\Microchip\\PIC32MX_DFP\\1.3.231
 ChaletDuino_775F512H_.languagetoolchain.dir=C\:\\Program Files\\Microchip\\xc32\\v1.33\\bin
-host.id=2r0w-c3lh-oj
+host.id=1ig4-46sv-sm
 conf.ids=default,ChaletDuino_775F512H_,ChaletDuinoV2_795F512H_
 default.languagetoolchain.version=1.33
 ChaletDuinoV2_795F512H_.languagetoolchain.version=1.33

ChaletLora.X/nbproject/private/private.xml

@@ -1,6 +1,37 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project-private xmlns="http://www.netbeans.org/ns/project-private/1">
-    <editor-bookmarks xmlns="http://www.netbeans.org/ns/editor-bookmarks/2" lastBookmarkId="9">
+    <editor-bookmarks xmlns="http://www.netbeans.org/ns/editor-bookmarks/2" lastBookmarkId="11">
+        <file>
+            <url>Source/hd44780.c</url>
+            <bookmark id="7">
+                <name/>
+                <line>340</line>
+                <key/>
+            </bookmark>
+        </file>
+        <file>
+            <url>Source/SIM7080GInterface.c</url>
+            <bookmark id="11">
+                <name/>
+                <line>119</line>
+                <key/>
+            </bookmark>
+            <bookmark id="10">
+                <name/>
+                <line>201</line>
+                <key/>
+            </bookmark>
+            <bookmark id="8">
+                <name/>
+                <line>443</line>
+                <key/>
+            </bookmark>
+            <bookmark id="9">
+                <name/>
+                <line>560</line>
+                <key/>
+            </bookmark>
+        </file>
         <file>
             <url>Source/BootloaderInterface.c</url>
             <bookmark id="5">
@@ -14,32 +45,8 @@
                 <key/>
             </bookmark>
         </file>
-        <file>
-            <url>Source/hd44780.c</url>
-            <bookmark id="7">
-                <name/>
-                <line>340</line>
-                <key/>
-            </bookmark>
-        </file>
-        <file>
-            <url>Source/SIM7080GInterface.c</url>
-            <bookmark id="8">
-                <name/>
-                <line>426</line>
-                <key/>
-            </bookmark>
-            <bookmark id="9">
-                <name/>
-                <line>527</line>
-                <key/>
-            </bookmark>
-        </file>
     </editor-bookmarks>
     <open-files xmlns="http://www.netbeans.org/ns/projectui-open-files/2">
-        <group>
+        <group/>
-            <file>file:/D:/Main/PicDev/Projets/ChaletLora/ChaletLora.X/Source/SIM7080GInterface.c</file>
-            <file>file:/D:/Main/PicDev/Projets/ChaletLora/ChaletLora.X/Source/SIM7080GInterface.h</file>
-        </group>
     </open-files>
 </project-private>