YShuvakin/CuboBmsFirmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
190522943f85b06736801aa55d45f7c62c7810fd
CuboBmsFirmware/Core/Src/GSM.c
Yury Shuvakin 190522943f Initial commit
2023-03-29 20:05:40 +03:00

1647 lines
50 KiB
C
Raw Blame History

/*
*/
#include "GSM.h"
#include "string.h"
#include "stdlib.h"
#include "stdio.h"
#include "DPC_Timeout.h"
#ifndef NORMAL_DUMP
#define NORMAL_DUMP 0
#endif
UART_HandleTypeDef huart2;
uint8_t Buffer[8]={0,};
uint8_t Buffer_T[1000]={0,};
uint8_t calibration_status=1; // 0 - не проведена настройка, 1 - проведена
void SIM800_Var_Init(SIM800_Global_Struct* Sim_Struct){
AT_Commands_Struct* CMD_Struct;
CMD_Struct=&Sim_Struct->Sim_At_Commands;
CMD_Struct->AT = "AT\r\n";
CMD_Struct->ATV = "ATV1\r\n"; //echo turn off
CMD_Struct->ATE = "ATE1\r\n"; //answer with echo
CMD_Struct->ATW = "AT&W\r\n"; //save presets to mem
CMD_Struct->ATCFUN0="AT+CFUN=0\r\n"; //reboot
CMD_Struct->ATCFUN1="AT+CFUN=1\r\n"; //reboot
CMD_Struct->ATCMEE2="AT+CMEE=2\r\n"; //return error code
CMD_Struct->ATCGREG="AT+CGREG?\r\n"; //gprs availability
CMD_Struct->ATCOPS="AT+COPS=?\r\n";
CMD_Struct->ATCOPS_Manual="AT+COPS=0,2\r\n";
CMD_Struct->ATCPAS="AT+CPAS\r\n";
CMD_Struct->ATCSQ="AT+CSQ\r\n";
CMD_Struct->ATCDNSCFG_REQ="AT+CDNSCFG?\r\n";
CMD_Struct->ATCDNSCFG="AT+CDNSCFG=\"8.8.8.8\",\"8.8.4.4\"\r\n";
//sms
CMD_Struct->ATCMGF1="AT+CMGF=1\r\n";
CMD_Struct->ATCSMP="AT+CSMP=17,167,0,0\r\n";
CMD_Struct->ATCMGFnum="AT+CMGS=\"+79253801217\"\r\n";
CMD_Struct->ATCMGFtext="Hello\32\r\n";
CMD_Struct->ATD="ATD+79253801217\r\n";
CMD_Struct->ATCSCSUCS2="AT+CSCS=\"UCS2\"\r\n";
//TIME
CMD_Struct->ATCLTS = "AT+CLTS=1\r\n";
CMD_Struct->ATCCLK = "AT+CCLK?\r\n";
//GPRS
CMD_Struct->ATCGATT_check="AT+CGATT?\r\n";
CMD_Struct->ATCGATT_disconnect="AT+CGATT=0\r\n";
CMD_Struct->ATCGATT_connect="AT+CGATT=1\r\n";
CMD_Struct->ATSAPBR0="AT+SAPBR=0,1\r\n"; //close
CMD_Struct->ATSAPBR1="AT+SAPBR=1,1\r\n"; //Set connection
CMD_Struct->ATSAPBR2="AT+SAPBR=2,1\r\n"; //get info and IP
CMD_Struct->ATSAPBR3_1_CONTYPE="AT+SAPBR=3,1,\"CONTYPE\",\"GPRS\"\r\n"; //CONTYPE gprs connection types
//CMD_Struct->ATSAPBR3_1_APN="AT+SAPBR=3,1,\"APN\",\"internet.beeline.ru\"\r\n"; //APN connection¤
//CMD_Struct->ATSAPBR3_1_USER="AT+SAPBR=3,1,\"USER\",\"Beeline\"\r\n"; //
//CMD_Struct->ATSAPBR3_1_PWD="AT+SAPBR=3,1,\"PWD\",\"Beeline\"\r\n"; //
CMD_Struct->ATSAPBR4_1="AT+SAPBR=4,1\r\n"; //current settings
CMD_Struct->ATCIFSR="AT+CIFSR\r\n"; //current settings
CMD_Struct->ATCIPSTATUS="AT+CIPSTATUS\r\n"; //current settings
CMD_Struct->ATCSTT="AT+CSTT=\"internet.beeline.ru\",\"Beeline\",\"Beeline\" \r\n";
CMD_Struct->ATCIICR="AT+CIICR\r\n";
CMD_Struct->ATCIPSHUT="AT+CIPSHUT\r\n";
CMD_Struct->ATCIPMUX="AT+CIPMUX=0\r\n";
//Getting location +CIPGSMLOC: 0,0.000000,0.000000,2021/11/02,14:48:00
CMD_Struct->ATCIPGSMLOC="AT+ATCIPGSMLOC=1,1\r\n"; //Get time not location
CMD_Struct->ATCLBS="AT+CLBS=1,1\r\n"; //get location +CLBS: 0, 37.596079, 55.711303,400
//CMD_Struct->ATCLBSCFG="AT+CLBSCFG=0,3\r\n";
CMD_Struct->ATCLBSCFG="AT+CLBSCFG=1,3,\"lbs-simcom.com:3002\"\r\n";
//Latitude moscow 55.711303 Longitude 37.596079
//HTTP
CMD_Struct->ATHTTP="AT+HTTPINIT\r\n"; //init http
CMD_Struct->ATHTTPPARA_CID="AT+HTTPPARA=\"CID\",1\r\n"; //set CID for http session
CMD_Struct->ATHTTPSTATUS="AT+HTTPSTATUS?\r\n"; //check state
CMD_Struct->ATHTTPPARA_PARAM="AT+HTTPPARA?\r\n";//parameter list
#if NORMAL_DUMP
CMD_Struct->ATHTTPPARA_URL="AT+HTTPPARA=\"URL\",\"http://battery.cscw.ru/api/v1/battery\"\r\n"; //page address
CMD_Struct->ATHTTPPARA_URL_EVENT="AT+HTTPPARA=\"URL\",\"http://battery.cscw.ru/api/v1/events\"\r\n"; //Event page address
#else
CMD_Struct->ATHTTPPARA_URL_EVENT="AT+HTTPPARA=\"URL\",\"http://ptsv2.com/t/zwu8a-1639397340/post\"\r\n"; //page address
// CMD_Struct->ATHTTPPARA_URL="AT+HTTPPARA=\"URL\",\"http://ptsv2.com/t/dmxkc-1639397041/post\"\r\n"; //page address
#endif
// TEST SERVER
//
// CMD_Struct->ATHTTPPARA_URL_EVENT_TEST="AT+HTTPPARA=\"URL\",\"http://ptsv2.com/t/da1w9-1638273723/post\"\r\n"; //page address
// //https://ptsv2.com/t/dmxkc-1639397041
// CMD_Struct->ATHTTPPARA_URL_TEST="AT+HTTPPARA=\"URL\",\"http://ptsv2.com/t/da1w9-1638273723/post\"\r\n"; //page address
CMD_Struct->ATHTTPP_ACTION_POST="AT+HTTPACTION=1\r\n";//POST METHOD
CMD_Struct->ATHTTPP_ACTION_GET="AT+HTTPACTION=0\r\n";//POST METHOD
CMD_Struct->ATHTTPPARA_CONTENT="AT+HTTPPARA=\"CONTENT\",\"application/json\"\r\n"; //set the Content-Type field in HTTP header
CMD_Struct->ATHTTPPARA_USERDATA="AT+HTTPPARA=\"USERDATA\",\"x-api-key: 10028535-af51-45ad-8521-12973f7f6f1d\\r\\nAccept: application/json\"\r\n";
CMD_Struct->ATHTTPHEAD="AT+HTTPHEAD\r\n";//CHECK Receive response
//CMD_Struct->ATHTTPDATA="AT+HTTPDATA=473,5000\r\n"; //number of bytes, timeout
//after this should return DOWNLOAD - we ready to transmit
CMD_Struct->DATA0="{\"serial_number\": 20000054, \"started_at\": \"2021-05-04T17:59:12+0000\", \"ended_at\": "
"\"2021-05-04T18:31:12+0000\", \"status_indication\" :13, \"energy_sum\": 250, \"battery_level_at_start\": 20, "
"\"battery_level_at_end\": 70, \"battery_voltage_at_start\": 23.5, \"battery_voltage_at_end\": 23.9, "
"\"battery_temperature_at_end\": 22, \"latitude\": 56.24587, \"longitude\": 43.25611, \"maximum_load_current\": 645, "
"\"maximum_charge_current\": 150, \"internal_resistance\": 8.2111011, \"is_moderated\": false}\r\n";
CMD_Struct->DATA2="param=20000054\r\n";
CMD_Struct->ATHTTPACTION="AT+HTTPACTION=0\r\n"; //0-GET 1-POST 2-HEAD
CMD_Struct->ATHTTPREAD="AT+HTTPREAD=442\r\n"; //should return 200
CMD_Struct->ATHTTPREAD_REQ="AT+HTTPREAD?\r\n";
CMD_Struct->ATHTTPTERM="AT+HTTPTERM\r\n"; //close
CMD_Struct->ATSAPBR0="AT+SAPBR=0,1\r\n"; //close
CMD_Struct->AT_CSCS_GSM="AT+CSCS=\"GSM\"\r\n";
CMD_Struct->ATCUSD102="AT+CUSD=1,\"*102#\"\r\n";
CMD_Struct->ATCNMI="AT+CNMI=1,2,2,1,0\r\n";
CMD_Struct->ATCMGL="AT+CMGL=\"ALL\"\r\n";
CMD_Struct->ATCCID="AT+CCID\r\n";
CMD_Struct->ATCREG="AT+CREG?\r\n";
CMD_Struct->ATCGMR="AT+CGMR=?\r\n"; //Firmware version request
CMD_Struct->ATHTTPSSLREQUEST="AT+HTTPSSL=?\r\n";
CMD_Struct->ATHTTPSSL="AT+HTTPSSL=0\r\n";
// CMD_Struct->ATHTTPDATA0=malloc(100 * sizeof(char));
// CMD_Struct->ATHTTPDATA1=malloc(100 * sizeof(char));
//
// CMD_Struct->SE_Length1=malloc(100 * sizeof(char));
// CMD_Struct->SE_Length2=malloc(100 * sizeof(char));
//
// CMD_Struct->DATA1=malloc(300 * sizeof(char));
// CMD_Struct->DATA0=malloc(500 * sizeof(char));
CMD_Struct->ATHTTPDATA0=&CMD_Struct->ATHTTPDATA0_ch[0];
CMD_Struct->ATHTTPDATA1=&CMD_Struct->ATHTTPDATA1_ch[0];
CMD_Struct->SE_Length1=&CMD_Struct->SE_Length1_ch[0];
CMD_Struct->SE_Length2=&CMD_Struct->SE_Length2_ch[0];
CMD_Struct->DATA1=&CMD_Struct->DATA1_ch[0];
CMD_Struct->DATA0=&CMD_Struct->DATA0_ch[0];
CMD_Struct->ATHTTPPARA_URL=&CMD_Struct->Domain_URL[0];
CMD_Struct->ATHTTPPARA_URL_EVENT=&CMD_Struct->Domain_URL_Event[0];
CMD_Struct->ATSAPBR3_1_APN=&CMD_Struct->GSM_APN[0];
CMD_Struct->ATSAPBR3_1_PWD=&CMD_Struct->GSM_PWD[0];
CMD_Struct->ATSAPBR3_1_USER=&CMD_Struct->GSM_USER[0];
}
void SetParametersFromConfig(SIM800_Global_Struct* Sim_Struct, modConfigGeneralConfigStructTypedef *Config){
char* qstr = "/0";
char* istr = "/0";
char* urlpart1="AT+HTTPPARA=\"URL\",\"";
char* urlpart2="\"\r\n";
char* apn_part1="AT+SAPBR=3,1,\"APN\",\"";
char* usr_part1="AT+SAPBR=3,1,\"USER\",\"";
char* pwd_part1="AT+SAPBR=3,1,\"PWD\",\"";
AT_Commands_Struct* CMD_Struct;
CMD_Struct=&Sim_Struct->Sim_At_Commands;
qstr=strstr(&Config->Domain_URL,"\0");
strcpy(CMD_Struct->ATHTTPPARA_URL,urlpart1);
strcat(CMD_Struct->ATHTTPPARA_URL,qstr);
strcat(CMD_Struct->ATHTTPPARA_URL,urlpart2);
qstr=strstr(&Config->Domain_URL_Event,"\0");
strcpy(CMD_Struct->ATHTTPPARA_URL_EVENT,urlpart1);
strcat(CMD_Struct->ATHTTPPARA_URL_EVENT,qstr);
strcat(CMD_Struct->ATHTTPPARA_URL_EVENT,urlpart2);
qstr=strstr(&Config->GSM_APN,"\0");
strcpy(CMD_Struct->ATSAPBR3_1_APN,apn_part1);
strcat(CMD_Struct->ATSAPBR3_1_APN,qstr);
strcat(CMD_Struct->ATSAPBR3_1_APN,urlpart2);
qstr=strstr(&Config->GSM_PWD,"\0");
strcpy(CMD_Struct->ATSAPBR3_1_PWD,pwd_part1);
strcat(CMD_Struct->ATSAPBR3_1_PWD,qstr);
strcat(CMD_Struct->ATSAPBR3_1_PWD,urlpart2);
qstr=strstr(&Config->GSM_USER,"\0");
strcpy(CMD_Struct->ATSAPBR3_1_USER,usr_part1);
strcat(CMD_Struct->ATSAPBR3_1_USER,qstr);
strcat(CMD_Struct->ATSAPBR3_1_USER,urlpart2);
}
void Battery_Data_Length_Calculating(/*AT_Commands_Struct* CMD_Struct*/SIM800_Global_Struct* Sim_Struct){
AT_Commands_Struct* CMD_Struct;
CMD_Struct = &Sim_Struct->Sim_At_Commands;
uint16_t Data_Length1;
uint16_t Data_Length2;
CMD_Struct->SE_HTTPDATA="AT+HTTPDATA=";
CMD_Struct->SE_DATATO=",1000";
CMD_Struct->SE_ENDOFSTRING="\r\n";
Data_Length1 = strlen(CMD_Struct->DATA0);
Data_Length1 = Data_Length1 - 2;
Data_Length2 = strlen(CMD_Struct->DATA1);
Data_Length2 = Data_Length2 - 2;
//CMD_Struct->ATHTTPDATA="AT+HTTPDATA="; //number of bytes, timeout
itoa(Data_Length1,CMD_Struct->SE_Length1, 10);
strcpy(CMD_Struct->ATHTTPDATA0,CMD_Struct->SE_HTTPDATA);
//strcat(CMD_Struct->ATHTTPDATA,CMD_Struct->SE_HTTPDATA);
strcat(CMD_Struct->ATHTTPDATA0,CMD_Struct->SE_Length1);
strcat(CMD_Struct->ATHTTPDATA0,CMD_Struct->SE_DATATO);
strcat(CMD_Struct->ATHTTPDATA0,CMD_Struct->SE_ENDOFSTRING);
itoa(Data_Length2,CMD_Struct->SE_Length2, 10);
strcpy(CMD_Struct->ATHTTPDATA1,CMD_Struct->SE_HTTPDATA);
//strcat(CMD_Struct->ATHTTPDATA,CMD_Struct->SE_HTTPDATA);
strcat(CMD_Struct->ATHTTPDATA1,CMD_Struct->SE_Length2);
strcat(CMD_Struct->ATHTTPDATA1,CMD_Struct->SE_DATATO);
strcat(CMD_Struct->ATHTTPDATA1,CMD_Struct->SE_ENDOFSTRING);
}
void HTTP_Data_Init(SIM800_Global_Struct* Sim_Struct){
HTTP_DATA_Struct* HTTP_DATA;
HTTP_DATA=&Sim_Struct->Sim_HTTP_Data;
// HTTP_DATA->Serial_Number = malloc(10 * sizeof(char));
// HTTP_DATA->Battery_Condition_ID = malloc(10 * sizeof(char));
// HTTP_DATA->Event_time = malloc(30 * sizeof(char));
// HTTP_DATA->Started_At_Time = malloc(30 * sizeof(char));
// HTTP_DATA->Ended_At_Time = malloc(30 * sizeof(char));
// HTTP_DATA->Status_Indication = malloc(10 * sizeof(char));
// HTTP_DATA->Energy_Sum = malloc(10 * sizeof(char));
// HTTP_DATA->Battery_Level_At_Start = malloc(10 * sizeof(char));
// HTTP_DATA->Battery_Level_At_End = malloc(10 * sizeof(char));
// HTTP_DATA->Battery_Voltage_At_Start = malloc(10 * sizeof(char));
// HTTP_DATA->Battery_Voltage_At_End = malloc(10 * sizeof(char));
// HTTP_DATA->Battery_Temperature_At_End = malloc(10 * sizeof(char));
// HTTP_DATA->Latitude = malloc(10 * sizeof(char));
// HTTP_DATA->Longitude = malloc(10 * sizeof(char));
// HTTP_DATA->Maximum_Load_Current = malloc(10 * sizeof(char));
// HTTP_DATA->Maximum_Charge_Current= malloc(10 * sizeof(char));
// HTTP_DATA->Internal_Resistance = malloc(15 * sizeof(char));
// HTTP_DATA->Moderated = malloc(15 * sizeof(char));
// HTTP_DATA->Current_time = malloc(30 * sizeof(char));
HTTP_DATA->Serial_Number = &HTTP_DATA->Serial_Number_var[0];
HTTP_DATA->Battery_Condition_ID = &HTTP_DATA->Battery_Condition_ID_var[0];
HTTP_DATA->Event_time = &HTTP_DATA->Event_time_var[0];
HTTP_DATA->Started_At_Time = &HTTP_DATA->Started_At_Time_var[0];
HTTP_DATA->Ended_At_Time = &HTTP_DATA->Ended_At_Time_var[0];
HTTP_DATA->Status_Indication = &HTTP_DATA->Status_Indication_var[0];
HTTP_DATA->Energy_Sum = &HTTP_DATA->Energy_Sum_var[0];
HTTP_DATA->Battery_Level_At_Start = &HTTP_DATA->Battery_Level_At_Start_var[0];
HTTP_DATA->Battery_Level_At_End = &HTTP_DATA->Battery_Level_At_End_var[0];
HTTP_DATA->Battery_Voltage_At_Start = &HTTP_DATA->Battery_Voltage_At_Start_var[0];
HTTP_DATA->Battery_Voltage_At_End = &HTTP_DATA->Battery_Voltage_At_End_var[0];
HTTP_DATA->Battery_Temperature_At_End = &HTTP_DATA->Battery_Temperature_At_End_var[0];
HTTP_DATA->Latitude = &HTTP_DATA->Latitude_var[0];
HTTP_DATA->Longitude = &HTTP_DATA->Longitude_var[0];
HTTP_DATA->Maximum_Load_Current = &HTTP_DATA->Maximum_Load_Current_var[0];
HTTP_DATA->Maximum_Charge_Current = &HTTP_DATA->Maximum_Charge_Current_var[0];
HTTP_DATA->Internal_Resistance = &HTTP_DATA->Internal_Resistance_var[0];
HTTP_DATA->Moderated = &HTTP_DATA->Moderated_var[0];
HTTP_DATA->Current_time = &HTTP_DATA->Current_time_var[0];
}
void Battery_Data_Event_Processing(/*AT_Commands_Struct* CMD_Struct, HTTP_DATA_Struct* HTTP_DATA,*/SIM800_Global_Struct* Sim_Struct){
AT_Commands_Struct* AT_CMD;
HTTP_DATA_Struct* HTTP_DATA;
char* Serial = "{\"serial_number\": ";
char* BatCond = ", \"battery_condition_id\": ";
char* EventTime = ", \"event_time\": \"";
char* JSONEND="\"}\r\n";
AT_CMD = &Sim_Struct->Sim_At_Commands;
HTTP_DATA = &Sim_Struct->Sim_HTTP_Data;
strcpy(AT_CMD->DATA1, Serial);
strcat(AT_CMD->DATA1,HTTP_DATA->Serial_Number);
strcat(AT_CMD->DATA1,BatCond);
strcat(AT_CMD->DATA1,HTTP_DATA->Battery_Condition_ID);
strcat(AT_CMD->DATA1,EventTime);
strcat(AT_CMD->DATA1,HTTP_DATA->Event_time);
strcat(AT_CMD->DATA1,JSONEND);
}
void Battery_Data_to_String_Converter(SIM800_Global_Struct* Sim_Struct){
Battery_Data_Struct* Bat_data;
//char* Raw = malloc(100 * sizeof(char));
char* Raw = &Sim_Struct->Raw_var[0];
int Size;
Bat_data = &Sim_Struct->BATTERY_DATA;
itoa(Bat_data->Serial,Raw,sizeof(Bat_data->Serial)+2);
strcpy(Sim_Struct->Sim_HTTP_Data.Serial_Number, Raw);
itoa(Bat_data->Battery_cond_ID,Raw,10);
strcpy(Sim_Struct->Sim_HTTP_Data.Battery_Condition_ID, Raw);
// SIM800_Struct.Sim_HTTP_Data.Event_time
SIM800_Time_To_String(&Bat_data->Event_time,Sim_Struct->Sim_HTTP_Data.Event_time);
SIM800_Time_To_String(&Bat_data->Started_At_Time,Sim_Struct->Sim_HTTP_Data.Started_At_Time);
SIM800_Time_To_String(&Bat_data->Ended_At_Time,Sim_Struct->Sim_HTTP_Data.Ended_At_Time);
//memcpy(Sim_Struct->Sim_HTTP_Data.Event_time,Raw,sizeof(*Raw));
//Sim_Struct->Sim_HTTP_Data.Event_time = SIM800_Time_To_String(&Bat_data->Event_time);
//Sim_Struct->Sim_HTTP_Data.Started_At_Time = SIM800_Time_To_String(&Bat_data->Started_At_Time);
//Sim_Struct->Sim_HTTP_Data.Ended_At_Time = SIM800_Time_To_String(&Bat_data->Ended_At_Time);
itoa(Bat_data->Status_Indication,Raw,10);
strcpy(Sim_Struct->Sim_HTTP_Data.Status_Indication, Raw);
itoa(Bat_data->Energy_Sum,Raw,10);
strcpy(Sim_Struct->Sim_HTTP_Data.Energy_Sum, Raw);
itoa(Bat_data->Battery_Level_At_Start,Raw,10);
strcpy(Sim_Struct->Sim_HTTP_Data.Battery_Level_At_Start, Raw);
itoa(Bat_data->Battery_Level_At_End,Raw,10);
strcpy(Sim_Struct->Sim_HTTP_Data.Battery_Level_At_End, Raw);
sprintf(Raw, "%f", Bat_data->Battery_Voltage_At_Start);
//ftoa(Bat_data->Battery_Voltage_At_Start,Raw,sizeof(Bat_data->Battery_Voltage_At_Start));
strcpy(Sim_Struct->Sim_HTTP_Data.Battery_Voltage_At_Start, Raw);
sprintf(Raw, "%f", Bat_data->Battery_Voltage_At_End);
//ftoa(Bat_data->Battery_Voltage_At_End,Raw,sizeof(Bat_data->Battery_Voltage_At_End));
strcpy(Sim_Struct->Sim_HTTP_Data.Battery_Voltage_At_End, Raw);
itoa(Bat_data->Battery_Temperature_At_End,Raw,10);
strcpy(Sim_Struct->Sim_HTTP_Data.Battery_Temperature_At_End, Raw);
itoa(Bat_data->Maximum_Load_Current,Raw,10);
strcpy(Sim_Struct->Sim_HTTP_Data.Maximum_Load_Current, Raw);
itoa(Bat_data->Maximum_Charge_Current,Raw,10);
strcpy(Sim_Struct->Sim_HTTP_Data.Maximum_Charge_Current, Raw);
sprintf(Raw, "%f", Bat_data->Internal_Resistance);
//ftoa(Bat_data->Internal_Resistance,Raw,sizeof(Bat_data->Internal_Resistance));
strcpy(Sim_Struct->Sim_HTTP_Data.Internal_Resistance, Raw);
if (Bat_data->Moderated){
strcpy(Sim_Struct->Sim_HTTP_Data.Moderated,"true");
}
else strcpy(Sim_Struct->Sim_HTTP_Data.Moderated,"false");
//free(Raw);
memset(Raw,0,100);
}
void Battery_Data_Time_Processing(SIM800_Global_Struct* Sim_Struct/*HTTP_DATA_Struct* HTTP_DATA,Time_Struct* time*/){
HTTP_DATA_Struct* HTTP_DATA;
Time_Struct* Time;
char* Year_def= "{\"serial_number\": ";
//char* Raw = malloc(100 * sizeof(char));
char* Raw = &Sim_Struct->Raw_var[0];
char* delimeter1 = "-";
char* delimeter2 = ":";
char* delimeter3 = "T";
char* delimeter4 = "+";
char* delimeter5 = "/0";
uint16_t Year;
HTTP_DATA = &Sim_Struct->Sim_HTTP_Data;
Time = &Sim_Struct->Sim_Time;
//2021-05-04T17:59:12+0000
Year = Time->year +2000;
itoa(Year,Raw,10);
strcpy(HTTP_DATA->Current_time, Raw);
strcat(HTTP_DATA->Current_time,delimeter1);
itoa(Time->month,Raw,10);
strcat(HTTP_DATA->Current_time, Raw);
strcat(HTTP_DATA->Current_time,delimeter1);
itoa(Time->day,Raw,10);
strcat(HTTP_DATA->Current_time, Raw);
strcat(HTTP_DATA->Current_time,delimeter3);
itoa(Time->hour,Raw,10);
strcat(HTTP_DATA->Current_time, Raw);
strcat(HTTP_DATA->Current_time,delimeter2);
itoa(Time->minute,Raw,10);
strcat(HTTP_DATA->Current_time, Raw);
strcat(HTTP_DATA->Current_time,delimeter2);
itoa(Time->second,Raw,10);
strcat(HTTP_DATA->Current_time, Raw);
strcat(HTTP_DATA->Current_time,delimeter4);
itoa(Time->timezone,Raw,10);
strcat(HTTP_DATA->Current_time, Raw);
//free(Raw);
memset(Raw,0,100);
}
char Raw_Buffer[800];
char ReturnValue_Buffer[800];
void SIM800_Time_To_String(Time_Struct* Time, char* DST){
char* Year_def= "{\"serial_number\": ";
char* Raw = &Raw_Buffer;
char* ReturnValue = &ReturnValue_Buffer;
char* delimeter1 = "-";
char* delimeter2 = ":";
char* delimeter3 = "T";
char* delimeter4 = "+";
char* delimeter5 = "/0";
uint16_t Year;
Year = Time->year + 2000;
itoa(Year,Raw,10);
strcpy(DST, Raw);
strcat(DST, delimeter1);
itoa(Time->month,Raw,10);
strcat(DST, Raw);
strcat(DST,delimeter1);
itoa(Time->day,Raw,10);
strcat(DST, Raw);
strcat(DST,delimeter3);
itoa(Time->hour,Raw,10);
strcat(DST, Raw);
strcat(DST,delimeter2);
itoa(Time->minute,Raw,10);
strcat(DST, Raw);
strcat(DST,delimeter2);
itoa(Time->second,Raw,10);
strcat(DST, Raw);
strcat(DST,delimeter4);
itoa(Time->timezone,Raw,10);
strcat(DST, Raw);
//free(Raw);
//free(ReturnValue);
// return &ReturnValue_Buffer;
}
void Battery_Data_Parameters_Processing(/*AT_Commands_Struct* CMD_Struct, HTTP_DATA_Struct* HTTP_DATA,*/SIM800_Global_Struct* Sim_Struct){
AT_Commands_Struct* CMD_Struct;
HTTP_DATA_Struct* HTTP_DATA;
char* Serial = "{\"serial_number\": ";
char* Started_At = ", \"started_at\": \"";
char* Ended_At = "\", \"ended_at\": \"";
char* Status_ind = "\", \"status_indication\": ";
char* Energy= ", \"energy_sum\": ";
char* Bat_lev_St = ", \"battery_level_at_start\": ";
char* Bat_lev_End = ", \"battery_level_at_end\": ";
char* Bat_V_St = ", \"battery_voltage_at_start\": ";
char* Bat_V_End=", \"battery_voltage_at_end\": ";
char* Bat_T_End=", \"battery_temperature_at_end\": ";
char* Lat=", \"latitude\": ";
char* Long=", \"longitude\": ";
char* Max_Load_Cur=", \"maximum_load_current\": ";
char* Max_Ch_Cur=", \"maximum_charge_current\": ";
char* Int_Res=", \"internal_resistance\": ";
char* Mod = ", \"is_moderated\": ";
char* JSONEND = "}\r\n";
CMD_Struct = &Sim_Struct->Sim_At_Commands;
HTTP_DATA = &Sim_Struct->Sim_HTTP_Data;
strcpy(CMD_Struct->DATA0, Serial);
strcat(CMD_Struct->DATA0,HTTP_DATA->Serial_Number);
strcat(CMD_Struct->DATA0,Started_At);
strcat(CMD_Struct->DATA0,HTTP_DATA->Started_At_Time);
strcat(CMD_Struct->DATA0,Ended_At);
strcat(CMD_Struct->DATA0,HTTP_DATA->Ended_At_Time);
strcat(CMD_Struct->DATA0,Status_ind);
strcat(CMD_Struct->DATA0,HTTP_DATA->Status_Indication);
strcat(CMD_Struct->DATA0,Energy);
strcat(CMD_Struct->DATA0,HTTP_DATA->Energy_Sum);
strcat(CMD_Struct->DATA0,Bat_lev_St);
strcat(CMD_Struct->DATA0,HTTP_DATA->Battery_Level_At_Start);
strcat(CMD_Struct->DATA0,Bat_lev_End);
strcat(CMD_Struct->DATA0,HTTP_DATA->Battery_Level_At_End);
strcat(CMD_Struct->DATA0,Bat_V_St);
strcat(CMD_Struct->DATA0,HTTP_DATA->Battery_Voltage_At_Start);
strcat(CMD_Struct->DATA0,Bat_V_End);
strcat(CMD_Struct->DATA0,HTTP_DATA->Battery_Voltage_At_End);
strcat(CMD_Struct->DATA0,Bat_T_End);
strcat(CMD_Struct->DATA0,HTTP_DATA->Battery_Temperature_At_End);
strcat(CMD_Struct->DATA0,Lat);
strcat(CMD_Struct->DATA0,HTTP_DATA->Latitude);
strcat(CMD_Struct->DATA0,Long);
strcat(CMD_Struct->DATA0,HTTP_DATA->Longitude);
strcat(CMD_Struct->DATA0,Max_Load_Cur);
strcat(CMD_Struct->DATA0,HTTP_DATA->Maximum_Load_Current);
strcat(CMD_Struct->DATA0,Max_Ch_Cur);
strcat(CMD_Struct->DATA0,HTTP_DATA->Maximum_Charge_Current);
strcat(CMD_Struct->DATA0,Int_Res);
strcat(CMD_Struct->DATA0,HTTP_DATA->Internal_Resistance);
strcat(CMD_Struct->DATA0,Mod);
strcat(CMD_Struct->DATA0,HTTP_DATA->Moderated);
strcat(CMD_Struct->DATA0,JSONEND);
}
void SIM800_RESET(SIM800_Global_Struct* Sim_Struct){
Sim_Struct->SIM_RESET_Switch = 1;
}
void SIM800_Send_Command(char* command){
HAL_UART_Transmit(&huart2, (uint8_t*)command, strlen(command), 20);
}
void SIM800_Send_Command_Long(char* command){
HAL_UART_Transmit(&huart2, (uint8_t*)command, strlen(command), 50);
}
uint8_t SIM800_Received_LOOKFOR(SIM_Answer_Struct* answ, char* LOOKFOR ){
uint8_t result=0;
char *istr='\0';
istr=strstr((char*)answ->SIM_answer, LOOKFOR);
if (istr=='\0')
{
result=0; //nothing found
}
else
{
result=1; //found
}
return result;
}
void SIM800_get_time(SIM_Answer_Struct* answ, Time_Struct* time)
{
char *istr='\0'; //answer start
char *qstr='\0';
istr=strstr((answ->SIM_answer),"CCLK:");
qstr=strtok(istr+7,"/");
time->year=atoi(qstr);
qstr=strtok(istr+10,"/");
time->month=atoi(qstr);
qstr=strtok(istr+13,",");
time->day=atoi(qstr);
qstr=strtok(istr+16,":");
time->hour=atoi(qstr);
qstr=strtok(istr+19,":");
time->minute=atoi(qstr);
qstr=strtok(istr+22,"+");
time->second=atoi(qstr);
qstr=strtok(istr+25,"\"");
time->timezone=atoi(qstr);
}
void SIM800_import_time_to_struct(SIM800_Global_Struct* Sim_Struct, Time_Struct* DST){
*DST = Sim_Struct->Sim_Time;
}
void SIM800_Get_Coordinates(SIM800_Global_Struct* Sim_Struct/*SIM_Answer_Struct* answ, HTTP_DATA_Struct* HTTP_DATA*/){
SIM_Answer_Struct* Answer_Struct;
HTTP_DATA_Struct* HTTP_DATA;
Answer_Struct = &Sim_Struct->Sim_Answer;
HTTP_DATA = &Sim_Struct->Sim_HTTP_Data;
char *istr='\0'; //answer start
char *qstr='\0';
istr=strstr((Answer_Struct->SIM_answer),"CLBS:");
qstr=strtok(istr+8,",");
strcpy(HTTP_DATA->Longitude,qstr);
qstr=strtok(istr+18,",");
strcpy(HTTP_DATA->Latitude,qstr);
}
void SIM800_Interrupt_Handler(SIM800_Global_Struct* Sim_Struct, uint8_t* UART_Buffer, uint16_t Size){
SIM_Answer_Struct* Answer_Struct;
Answer_Struct=&Sim_Struct->Sim_Answer;
memset(Answer_Struct->SIM_answer, 0, 1023);
memcpy(Answer_Struct->SIM_answer, UART_Buffer, Size);
Answer_Struct->SIM_RX_Flag=1;
memset(UART_Buffer, 0, 1023);
}
void SIM800_Processing(SIM800_Global_Struct* Sim_Struct, uint8_t* UART_Buf){
if (Sim_Struct->INIT_Timeout_Active==0 && Sim_Struct->Sim_Main_States.GPRS_Established==0){
Sim_Struct->INIT_Timeout_Active=1;
DPC_TO_Set(TO_SIM_TIMEOUT, SIM_RESET_TIMEOUT);
}
if (DPC_TO_Check(TO_UART)==TO_OUT_TOOK){
Sim_Struct->Sim_Main_States.Permission_to_Send=1;
HAL_UARTEx_ReceiveToIdle_IT(&huart2, UART_Buf, 1023);
}
if (Sim_Struct->SIM_RESET_Switch){
if (Sim_Struct->SIM_RESET_Set){
if (DPC_TO_Check(TO_COM)==TO_OUT_TOOK){
HAL_GPIO_WritePin(GSM_RST_GPIO_Port, GSM_RST_Pin, GPIO_PIN_SET);
//HAL_GPIO_WritePin(HL3_GPIO_Port, HL3_Pin, GPIO_PIN_RESET);
Sim_Struct->SIM_RESET_Set = 0;
Sim_Struct->SIM_RESET_Switch = 0;
Sim_Struct->Sim_Main_States.Init_Complete=0;
Sim_Struct->Sim_Main_States.GPRS_Established=0;
Sim_Struct->Sim_Stages_List=AT;
}
}
else
{
HAL_GPIO_WritePin(GSM_RST_GPIO_Port, GSM_RST_Pin, GPIO_PIN_RESET);
//HAL_GPIO_WritePin(HL3_GPIO_Port, HL3_Pin, GPIO_PIN_SET);
Sim_Struct->SIM_RESET_Set = 1;
DPC_TO_Set(TO_COM, 1000);
}
}
if (DPC_TO_Check(TO_SIM_TIMEOUT)==TO_OUT_TOOK){
if (!Sim_Struct->Sim_Main_States.GPRS_Established){
Sim_Struct->SIM_RESET_Switch = 1;
Sim_Struct->Sim_Stages_List = AT;
DPC_TO_Set(TO_SIM_TIMEOUT, SIM_RESET_TIMEOUT);
}
else if (Sim_Struct->Sim_Main_States.GPRS_Established){
Sim_Struct->Network_Check_Flag=1;
}
}
if (Sim_Struct->Network_Check_Flag){
if(SIM800_Set_Command(Sim_Struct, CHECK_NETWORK_AWAILABILITY, 20000) == COMMAND_SET) {
DPC_TO_Set(TO_SIM_TIMEOUT, SIM_NETWORK_CHECK_TIMEOUT);
Sim_Struct->Network_Check_Flag=0;
}
}
//each command have timeout
if (DPC_TO_Check(TO_AT_TIMEOUT)==TO_OUT_TOOK ){
if (!Sim_Struct->Sim_Main_States.Init_Complete || !Sim_Struct->Sim_Main_States.GPRS_Established){
Sim_Struct->Sim_Stages_List = AT;
Sim_Struct->SIM_RESET_Switch = 1;
}
else {
Sim_Struct->Sim_Stages_List=READY_TO_OPERATE;
Sim_Struct->REQUEST_Timeout_Active=0;
}
}
if (SIM800_Init(Sim_Struct/*&Sim_States, &Sim_Commands, &SIM_CMD_Struct, &Sim_prev_answer, &Sim_time*/)==READY){
Sim_Struct->Sim_States_to_return = SIM800_Active_Mode(Sim_Struct);
if (Sim_Struct->INIT_Timeout_Active==1){
Sim_Struct->INIT_Timeout_Active=0;
}
}
}
SIM800_Op_States SIM800_Init(SIM800_Global_Struct* Sim_Struct/*SIM800_States* State, Sim_Stages* CMD_Type, AT_Commands_Struct* AT_CMD ,SIM_Answer_Struct* Answer_Struct, Time_Struct* Time*/){
SIM800_States* State;
Sim_Stages* CMD_Type;
AT_Commands_Struct* AT_CMD;
SIM_Answer_Struct* Answer_Struct;
Time_Struct* Time;
State = &Sim_Struct->Sim_Main_States;
CMD_Type = &Sim_Struct->Sim_Stages_List;
AT_CMD = &Sim_Struct->Sim_At_Commands;
Answer_Struct = &Sim_Struct->Sim_Answer;
Time = &Sim_Struct->Sim_Time;
if (!State->Init_Complete){
switch(*CMD_Type){
case AT:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->AT);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATE;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
else {
}
}
break;
case ATE:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATE);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATV;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
case ATV:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATV);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATCMEE2;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
case ATCMEE2:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCMEE2);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATCLTS;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
case ATCLTS:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCLTS);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,1000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "CLTS") && SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATW;
DPC_TO_Set(TO_AT_TIMEOUT,30000);
}
}
break;
case ATW:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATW);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATCREG;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
case ATCCLK:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCCLK);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "CCLK:") && SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
SIM800_get_time(Answer_Struct, Time);
State->Init_Complete = 1;
*CMD_Type = ATCGATT_check;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
case ATCREG:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCREG);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,1000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "CREG: 0,1")){
*CMD_Type = ATCCLK;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
else if (SIM800_Received_LOOKFOR(Answer_Struct, "CREG: 0,2")){
*CMD_Type = ATCREG;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
DPC_TO_Set(TO_UART,5000);
}
else if (SIM800_Received_LOOKFOR(Answer_Struct, "CREG: 0,3")){
*CMD_Type = ATCREG;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
DPC_TO_Set(TO_UART,5000);
}
else if (SIM800_Received_LOOKFOR(Answer_Struct, "CREG: 0,4")){
*CMD_Type = ATCREG;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
else if (SIM800_Received_LOOKFOR(Answer_Struct, "CREG: 0,0")){
*CMD_Type = ATCREG;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
case ATCSQ:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCSQ);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,200);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATCREG;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
case ATCOPS:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCOPS);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,15000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "Beeline")){
*CMD_Type = ATCOPS_Manual;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
case ATCOPS_Manual:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCOPS_Manual);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,5000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
*CMD_Type = ATCREG;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
break;
case ATHTTPSSLREQUEST:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATHTTPSSLREQUEST);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATHTTPSTATUS;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
case ATHTTPSTATUS:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATHTTPSTATUS);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATCGMR;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
case ATCGMR:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCGMR);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
State->Init_Complete = 1;
*CMD_Type = ATCGATT_check;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
}
}
else if (State->Init_Complete && !State->GPRS_Established){
switch(*CMD_Type){
case ATCGATT_check:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCGATT_check);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "CGATT: 0")){
*CMD_Type = ATCGATT_connect;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
else if (SIM800_Received_LOOKFOR(Answer_Struct, "CGATT: 1")){
*CMD_Type = ATCIPSHUT;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
else if (SIM800_Received_LOOKFOR(Answer_Struct, "ERROR")){
*CMD_Type = ATCGATT_disconnect;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
case ATCGATT_disconnect:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCGATT_disconnect);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATCGATT_check;
DPC_TO_Set(TO_AT_TIMEOUT,20000);
}
}
break;
case ATCGATT_connect:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCGATT_connect);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,1000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATCGATT_check;
DPC_TO_Set(TO_AT_TIMEOUT,20000);
}
}
break;
case ATSAPBR0:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATSAPBR0);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATSAPBR1;
DPC_TO_Set(TO_AT_TIMEOUT,5000);
}
}
break;
//case IPPP
case ATCIPSHUT:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCIPSHUT);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATCIPSTATUS;
DPC_TO_Set(TO_AT_TIMEOUT,5000);
}
}
break;
case ATCIPSTATUS:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCIPSTATUS);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "IP INITIAL")){
*CMD_Type = ATCIPMUX;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
else if (SIM800_Received_LOOKFOR(Answer_Struct, "IP GPRSACT")){
*CMD_Type = ATCIPSTATUS;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
else if (SIM800_Received_LOOKFOR(Answer_Struct, "IP STATUS")){
*CMD_Type = ATSAPBR2;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
case ATCIPMUX:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCIPMUX);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,500);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATCSTT;
DPC_TO_Set(TO_AT_TIMEOUT,5000);
}
}
break;
case ATCDNSCFG:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCDNSCFG);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,500);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATSAPBR2;
DPC_TO_Set(TO_AT_TIMEOUT,5000);
}
}
break;
case ATCSTT:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCSTT);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,1000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATCIICR;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
case ATCIICR:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCIICR);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,1000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATCIFSR;
DPC_TO_Set(TO_AT_TIMEOUT,10000);
}
}
break;
case ATCIFSR:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCIFSR);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
//if (SIM800_Check_Received(Answer_Struct, &AT_CMD)){
*CMD_Type = ATCIPSTATUS;
DPC_TO_Set(TO_AT_TIMEOUT,5000);
//}
}
break;
case ATSAPBR2:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATSAPBR2);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,1000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "0.0.0.0")){
*CMD_Type = ATSAPBR3_1_CONTYPE;
DPC_TO_Set(TO_AT_TIMEOUT,20000);
}
else if (SIM800_Received_LOOKFOR(Answer_Struct, "SAPBR: 1,1")){
*CMD_Type = ATHTTP;
}
}
break;
case ATHTTP:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATHTTP);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,200);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
State->GPRS_Established = 1;
*CMD_Type = READY_TO_OPERATE;
DPC_TO_Set(TO_AT_TIMEOUT,5000);
}
}
break;
case ATSAPBR3_1_CONTYPE:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATSAPBR3_1_CONTYPE);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATSAPBR3_1_APN;
DPC_TO_Set(TO_AT_TIMEOUT,20000);
}
}
break;
case ATSAPBR3_1_APN:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATSAPBR3_1_APN);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATSAPBR3_1_USER;
DPC_TO_Set(TO_AT_TIMEOUT,20000);
}
}
break;
case ATSAPBR3_1_USER:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATSAPBR3_1_USER);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATSAPBR3_1_PWD;
DPC_TO_Set(TO_AT_TIMEOUT,20000);
}
}
break;
case ATSAPBR3_1_PWD:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATSAPBR3_1_PWD);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,1000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATSAPBR4_1;
DPC_TO_Set(TO_AT_TIMEOUT,20000);
}
}
break;
case ATSAPBR4_1:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATSAPBR4_1);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,1000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
*CMD_Type = ATSAPBR1;
DPC_TO_Set(TO_AT_TIMEOUT,30000);
}
break;
case ATSAPBR1:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATSAPBR1);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,3000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*CMD_Type = ATSAPBR2;
DPC_TO_Set(TO_AT_TIMEOUT,20000);
}
}
break;
}
}
if (State->GPRS_Established) return READY;
else return BUSY;
}
SIM800_Op_States SIM800_Set_Command(SIM800_Global_Struct* Sim_Struct, SIM800_Op_Commands CMD, uint32_t Timeout){
if (Sim_Struct->Sim_States_to_return == READY){
Battery_Data_to_String_Converter(Sim_Struct);
Sim_Struct->Sim_Active_Command = CMD;
Sim_Struct->Sim_States_to_return = BUSY;
Sim_Struct->REQUEST_Timeout = Timeout;
Sim_Struct->REQUEST_Timeout_Active = 1;
DPC_TO_Set(TO_AT_TIMEOUT,Timeout);
return COMMAND_SET;
}
else return COMMAND_NOT_SET;
}
SIM800_Op_States SIM800_Active_Mode(SIM800_Global_Struct* Sim_Struct){
SIM800_Op_Commands* CMD;
Sim_Stages* Current_Stage;
SIM800_States* State;
AT_Commands_Struct* AT_CMD;
SIM_Answer_Struct* Answer_Struct;
Time_Struct* Time;
State = &Sim_Struct->Sim_Main_States;
AT_CMD = &Sim_Struct->Sim_At_Commands;
Answer_Struct = &Sim_Struct->Sim_Answer;
Time = &Sim_Struct->Sim_Time;
CMD = &Sim_Struct->Sim_Active_Command;
Current_Stage = &Sim_Struct->Sim_Stages_List;
switch (*Current_Stage){
case READY_TO_OPERATE:
if (*CMD==GET_GPS_COORDINATES){
*Current_Stage = GPS_Req;
}
else if (*CMD==HTTP_EVENT_POST){
Battery_Data_Event_Processing(Sim_Struct);
Battery_Data_Length_Calculating(Sim_Struct);
*Current_Stage = ATHTTPPARA_CID;
}
else if (*CMD==HTTP_PARAMETERS_POST){
Battery_Data_Parameters_Processing(Sim_Struct);
Battery_Data_Length_Calculating(Sim_Struct);
*Current_Stage = ATHTTPPARA_CID;
}
else if (*CMD==GET_TIME){
*Current_Stage = GET_ACTUAL_TIME;
}
else if (*CMD==CHECK_NETWORK_AWAILABILITY){
*Current_Stage = NETWORK_CHECK;
}
break;
case GPS_Req:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCLBS);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,2000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "+CLBS: 0")){
SIM800_Get_Coordinates(Sim_Struct);
*CMD=DONOTHING;
*Current_Stage = READY_TO_OPERATE;
}
else if (SIM800_Received_LOOKFOR(Answer_Struct, "+CLBS:")){
strcpy(Sim_Struct->Sim_HTTP_Data.Latitude,Sim_Struct->Default_Latitude);
strcpy(Sim_Struct->Sim_HTTP_Data.Longitude,Sim_Struct->Default_Longitude);
*Current_Stage = GPS_LBS_Change;
*CMD=DONOTHING;
}
}
break;
case NETWORK_CHECK:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCREG);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,1000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "CREG:")){
if (SIM800_Received_LOOKFOR(Answer_Struct, "CREG: 0,1")){
*Current_Stage = READY_TO_OPERATE;
*CMD=DONOTHING;
}
else {
Sim_Struct->SIM_RESET_Switch = 1;
}
}
}
break;
case GPS_LBS_Change:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCLBSCFG);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,2000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*Current_Stage = READY_TO_OPERATE;
}
}
break;
case GET_ACTUAL_TIME:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATCCLK);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,100);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "CCLK:") && SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
SIM800_get_time(Answer_Struct, Time);
*Current_Stage = READY_TO_OPERATE;
*CMD=DONOTHING;
}
}
break;
case ATHTTPPARA_CID:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATHTTPPARA_CID);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,200);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "CID")){
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*Current_Stage = ATHTTPPARA_URL;
}
}
}
break;
case ATHTTPPARA_URL:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
if (*CMD==HTTP_EVENT_POST) SIM800_Send_Command(AT_CMD->ATHTTPPARA_URL_EVENT);
else if (*CMD==HTTP_PARAMETERS_POST) SIM800_Send_Command(AT_CMD->ATHTTPPARA_URL);
else if (*CMD==HTTP_EVENT_POST_TEST) SIM800_Send_Command(AT_CMD->ATHTTPPARA_URL_EVENT_TEST);
else if (*CMD==HTTP_PARAMETERS_POST_TEST) SIM800_Send_Command(AT_CMD->ATHTTPPARA_URL_TEST);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,200);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*Current_Stage = ATHTTPPARA_CONTENT;
}
}
break;
case ATHTTPPARA_CONTENT:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATHTTPPARA_CONTENT);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,200);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*Current_Stage = ATHTTPPARA_USERDATA;
}
}
break;
case ATHTTPPARA_USERDATA:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATHTTPPARA_USERDATA);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,200);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*Current_Stage = ATHTTPPARA_PARAM;
}
}
break;
case ATHTTPPARA_PARAM:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATHTTPPARA_PARAM);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,1000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "http://battery.cscw.ru/api/v1/battery")||
SIM800_Received_LOOKFOR(Answer_Struct, "http://battery.cscw.ru/api/v1/events") ||
SIM800_Received_LOOKFOR(Answer_Struct, "http://ptsv2.com/")){
*Current_Stage = ATHTTPDATA;
}
else {
*Current_Stage = ATHTTPPARA_CID;
}
}
break;
case ATHTTPDATA:
if (State->Permission_to_Send){
if (*CMD==HTTP_EVENT_POST) SIM800_Send_Command(AT_CMD->ATHTTPDATA1);
else if (*CMD==HTTP_PARAMETERS_POST) SIM800_Send_Command(AT_CMD->ATHTTPDATA0);
else if (*CMD==HTTP_EVENT_POST_TEST) SIM800_Send_Command(AT_CMD->ATHTTPDATA1);
else if (*CMD==HTTP_PARAMETERS_POST_TEST) SIM800_Send_Command(AT_CMD->ATHTTPDATA0);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,500);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "DOWNLOAD")){
if (*CMD==HTTP_EVENT_POST) *Current_Stage = DATA1;
else if (*CMD==HTTP_PARAMETERS_POST) *Current_Stage = DATA0;
else if (*CMD==HTTP_EVENT_POST_TEST) *Current_Stage = DATA1;
else if (*CMD==HTTP_PARAMETERS_POST_TEST) *Current_Stage = DATA0;
}
if (SIM800_Received_LOOKFOR(Answer_Struct, "ERROR")){
*Current_Stage = ATHTTPPARA_CID;
}
}
break;
case DATA0:
if (State->Permission_to_Send){
SIM800_Send_Command_Long(AT_CMD->DATA0);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,2000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*Current_Stage = ATHTTPSSL;
}
if (SIM800_Received_LOOKFOR(Answer_Struct, "ERROR")){
*Current_Stage = ATHTTPDATA;
}
}
break;
case DATA1:
if (State->Permission_to_Send){
SIM800_Send_Command_Long(AT_CMD->DATA1);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,2000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*Current_Stage = ATHTTPSSL;
}
if (SIM800_Received_LOOKFOR(Answer_Struct, "ERROR")){
*Current_Stage = ATHTTPDATA;
}
}
break;
case ATHTTPSSL:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATHTTPSSL);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,1000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*Current_Stage = ATHTTPP_ACTION_POST;
}
}
break;
case ATHTTPP_ACTION_POST:
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATHTTPP_ACTION_POST);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,5000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "HTTPACTION:")){
if (SIM800_Received_LOOKFOR(Answer_Struct, "HTTPACTION: 0,200")){
*Current_Stage = READY_TO_OPERATE;
*CMD=DONOTHING;
}
else if (SIM800_Received_LOOKFOR(Answer_Struct, "HTTPACTION: 1,200")){
*Current_Stage = READY_TO_OPERATE;
*CMD=DONOTHING;
}
else {
*Current_Stage = ATHTTPHEAD;
}
}
}
break;
case ATHTTPHEAD:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATHTTPHEAD);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,1000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
if (*CMD==HTTP_EVENT_POST){
*CMD=HTTP_EVENT_POST_TEST;
Battery_Data_Event_Processing(Sim_Struct);
Battery_Data_Length_Calculating(Sim_Struct);
DPC_TO_Set(TO_AT_TIMEOUT,60000);
}
else if(*CMD==HTTP_PARAMETERS_POST){
*CMD=HTTP_PARAMETERS_POST_TEST;
Battery_Data_Parameters_Processing(Sim_Struct);
Battery_Data_Length_Calculating(Sim_Struct);
DPC_TO_Set(TO_AT_TIMEOUT,60000);
}
*Current_Stage = ATHTTPPARA_CID;
// *Current_Stage = READY_TO_OPERATE;
// *CMD=DONOTHING;
}
}
break;
case ATHTTPREAD:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATHTTPREAD);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,1000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*Current_Stage = READY_TO_OPERATE;
*CMD=DONOTHING;
}
}
break;
case ATHTTPTERM:
//SIM800_Command(CMD_Struct.AT, answ, CMD_Struct);
if (State->Permission_to_Send){
SIM800_Send_Command(AT_CMD->ATHTTPTERM);
State->Permission_to_Send = 0;
DPC_TO_Set(TO_UART,1000);
}
if (Answer_Struct->SIM_RX_Flag){
Answer_Struct->SIM_RX_Flag=0;
if (SIM800_Received_LOOKFOR(Answer_Struct, "OK")){
*Current_Stage = ATHTTP;
}
}
break;
}
if (*Current_Stage==READY_TO_OPERATE) return READY;
else return BUSY;
}
Reference in New Issue View Git Blame Copy Permalink