bmy/esp8266_study
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
编码猿
2024-09-27 01:22:07 +08:00
commit 1360daaab0
931 changed files with 131068 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

912
blinker-library/src/Adapters/BlinkerSerialGPRS.h Normal file
View File

@@ -0,0 +1,912 @@
#ifndef BLINKER_SERIAL_GPRS_H
#define BLINKER_SERIAL_GPRS_H
#if ARDUINO >= 100
#include <Arduino.h>
#else
#include <WProgram.h>
#endif
#include "../Blinker/BlinkerConfig.h"
#include "../Blinker/BlinkerDebug.h"
#include "../Blinker/BlinkerStream.h"
#include "../Blinker/BlinkerUtility.h"
#include "../Functions/BlinkerHTTPAIR202.h"
#ifndef ARDUINOJSON_VERSION_MAJOR
#include "../modules/ArduinoJson/ArduinoJson.h"
#endif
#include "../Functions/BlinkerMQTTAIR202.h"
// #if defined(ESP32)
// #include <HardwareSerial.h>
// HardwareSerial *HSerial;
// #else
// #include <SoftwareSerial.h>
// SoftwareSerial *SSerial;
// #endif
char* MQTT_HOST_GPRS;
char* MQTT_ID_GPRS;
char* MQTT_NAME_GPRS;
char* MQTT_KEY_GPRS;
char* MQTT_PRODUCTINFO_GPRS;
char* UUID_GPRS;
char* AUTHKEY_GPRS;
char* MQTT_DEVICEID_GPRS;
char* DEVICE_NAME_GPRS;
char* BLINKER_PUB_TOPIC_GPRS;
char* BLINKER_SUB_TOPIC_GPRS;
uint16_t MQTT_PORT_GPRS;
BlinkerMQTTAIR202* mqtt_GPRS;
class BlinkerSerialGPRS : public BlinkerStream
{
public :
BlinkerSerialGPRS()
: stream(NULL), isConnect(false)
{}
int connect();
int connected();
int mConnected();
void disconnect();
void ping();
int available();
void subscribe();
int timedRead();
char * lastRead() { if (isFresh_GPRS) return msgBuf_GPRS; return ""; }
void flush();
// int print(const String & s, bool needCheck = true);
int print(char * data, bool needCheck = true);
int toServer(char * data);
// int bPrint(char * name, const String & data);
// int aliPrint(const String & s);
// int duerPrint(const String & s);
// int aliPrint(const String & data);
// int duerPrint(const String & data, bool report = false);
void begin(const char* _deviceType, String _imei);
void initStream(Stream& s, bool state, blinker_callback_t func);
char * deviceName();
char * authKey() { return AUTHKEY_GPRS; }
char * token() { if (!isMQTTinit) return ""; else return MQTT_KEY_GPRS; }
int init() { return isMQTTinit; }
int reRegister() { return connectServer(); }
int deviceRegister() { return connectServer(); }
// int authCheck();
void freshAlive() { kaTime = millis(); isAlive = true; }
// int needFreshShare();
private :
bool isMQTTinit = false;
int connectServer();
void checkKA();
int checkCanPrint();
int checkPrintSpan();
protected :
Stream* stream;
// char* streamData;
char* msgBuf_GPRS;
// bool isFresh = false;
bool isFresh_GPRS = false;
bool isConnect;
bool isHWS = false;
char* imei;
uint8_t respTimes = 0;
uint32_t respTime = 0;
bool isAvail_GPRS = false;
uint8_t dataFrom_GPRS = BLINKER_MSG_FROM_MQTT;
// uint8_t _sharerFrom = BLINKER_MQTT_FROM_AUTHER;
const char* _deviceType;
bool isAlive = false;
uint32_t kaTime = 0;
uint32_t latestTime;
uint32_t printTime = 0;
int isJson(const String & data);
uint8_t reconnect_time = 0;
blinker_callback_t listenFunc = NULL;
};
int BlinkerSerialGPRS::connect()
{
if (!isMQTTinit) return false;
if (mqtt_GPRS->connected()) return true;
disconnect();
if ((millis() - latestTime) < BLINKER_MQTT_CONNECT_TIMESLOT && latestTime > 0)
{
yield();
return false;
}
BLINKER_LOG(BLINKER_F("Connecting to MQTT... "));
BLINKER_LOG_FreeHeap_ALL();
if (!mqtt_GPRS->connect())
{
BLINKER_LOG(BLINKER_F("Retrying MQTT connection in "), \
BLINKER_MQTT_CONNECT_TIMESLOT/1000, \
BLINKER_F(" seconds..."));
this->latestTime = millis();
reconnect_time += 1;
if (reconnect_time >= 12)
{
reRegister();
reconnect_time = 0;
}
return false;
}
reconnect_time = 0;
BLINKER_LOG(BLINKER_F("MQTT Connected!"));
BLINKER_LOG_FreeHeap();
this->latestTime = millis();
return true;
}
int BlinkerSerialGPRS::connected()
{
if (!isMQTTinit) return false;
return mqtt_GPRS->connected();
}
int BlinkerSerialGPRS::mConnected()
{
if (!isMQTTinit) return false;
else return mqtt_GPRS->connected();
}
void BlinkerSerialGPRS::disconnect()
{
if (isMQTTinit) mqtt_GPRS->disconnect();
}
void BlinkerSerialGPRS::ping()
{
BLINKER_LOG_ALL(BLINKER_F("MQTT Ping!"));
BLINKER_LOG_FreeHeap_ALL();
if (!isMQTTinit) return;
if (!mqtt_GPRS->connected())
{
disconnect();
// delay(100);
// connect();
}
else
{
this->latestTime = millis();
}
}
int BlinkerSerialGPRS::available()
{
if (isMQTTinit) {
checkKA();
// if (!mqtt_PRO->connected() || \
// (millis() - this->latestTime) > BLINKER_MQTT_PING_TIMEOUT)
if ((millis() - this->latestTime) > 30000)
{
ping();
}
else
{
subscribe();
}
}
if (isAvail_GPRS)
{
isAvail_GPRS = false;
return true;
}
else {
return false;
}
}
void BlinkerSerialGPRS::subscribe()
{
if (!isMQTTinit) return;
if (mqtt_GPRS->readSubscription())
{
BLINKER_LOG_ALL(BLINKER_F("Got: "), mqtt_GPRS->lastRead);
// DynamicJsonBuffer jsonBuffer;
// JsonObject& root = jsonBuffer.parseObject(String(mqtt_GPRS->lastRead));
DynamicJsonDocument jsonBuffer(1024);
DeserializationError error = deserializeJson(jsonBuffer, String(mqtt_GPRS->lastRead));
JsonObject root = jsonBuffer.as<JsonObject>();
String _uuid = root["fromDevice"];
String dataGet = root["data"];
BLINKER_LOG_ALL(BLINKER_F("data: "), dataGet);
BLINKER_LOG_ALL(BLINKER_F("fromDevice: "), _uuid);
if (strcmp(_uuid.c_str(), UUID_GPRS) == 0)
{
BLINKER_LOG_ALL(BLINKER_F("Authority uuid"));
kaTime = millis();
isAvail_GPRS = true;
isAlive = true;
// _sharerFrom = BLINKER_MQTT_FROM_AUTHER;
}
if (isFresh_GPRS) free(msgBuf_GPRS);
msgBuf_GPRS = (char*)malloc((dataGet.length()+1)*sizeof(char));
strcpy(msgBuf_GPRS, dataGet.c_str());
isFresh_GPRS = true;
this->latestTime = millis();
dataFrom_GPRS = BLINKER_MSG_FROM_MQTT;
}
}
void BlinkerSerialGPRS::flush()
{
if (isFresh_GPRS)
{
free(msgBuf_GPRS); isFresh_GPRS = false; isAvail_GPRS = false;
// isAliAvail = false; //isBavail = false;
}
}
int BlinkerSerialGPRS::timedRead()
{
int c;
uint32_t _startMillis = millis();
do {
c = stream->read();
if (c >= 0) return c;
} while(millis() - _startMillis < 1000);
return -1;
}
// void BlinkerSerialGPRS::flush()
// {
// if (isFresh)
// {
// free(streamData); isFresh_GPRS = false;
// }
// }
int BlinkerSerialGPRS::print(char * data, bool needCheck)
{
BLINKER_LOG_ALL(BLINKER_F("data: "), data);
uint16_t num = strlen(data);
data[num+8] = '\0';
for(uint16_t c_num = num; c_num > 0; c_num--)
{
data[c_num+7] = data[c_num-1];
}
// String data_add = BLINKER_F("{\"data\":");
char data_add[20] = "{\"data\":";
for(uint16_t c_num = 0; c_num < 8; c_num++)
{
data[c_num] = data_add[c_num];
}
// data_add = BLINKER_F(",\"fromDevice\":\"");
// strcat(data, data_add.c_str());
strcat(data, ",\"fromDevice\":\"");
strcat(data, MQTT_ID_GPRS);
// strcat(data, MQTT_DEVICEID_GPRS); //PRO
// data_add = BLINKER_F("\",\"toDevice\":\"");
// strcat(data, data_add.c_str());
strcat(data, "\",\"toDevice\":\"");
// if (_sharerFrom < BLINKER_MQTT_MAX_SHARERS_NUM)
// {
// strcat(data, _sharers[_sharerFrom]->uuid());
// }
// else
// {
strcat(data, UUID_GPRS);
// }
// data_add = BLINKER_F("\",\"deviceType\":\"OwnApp\"}");
// _sharerFrom = BLINKER_MQTT_FROM_AUTHER;
// strcat(data, data_add.c_str());
strcat(data, "\",\"deviceType\":\"OwnApp\"}");
// data_add = STRING_format(data);
if (!isJson(STRING_format(data))) return false;
// data_add.replace("\"", "\\22");
// strcpy(data, data_add.c_str());
uint16_t d_data_len;
for (uint16_t d_num = 0; d_num < 1024; d_num++)
{
if (data[d_num] == '\"')
{
data[d_num] = '\\';
d_data_len = strlen(data);
// BLINKER_LOG_ALL(BLINKER_F("d_num: "), d_num,
// BLINKER_F(", d_data_len: "), d_data_len);
for(uint16_t c_num = d_data_len; c_num > d_num; c_num--)
{
data[c_num + 2] = data[c_num];
}
data[d_num + 1] = '2';
data[d_num + 2] = '2';
}
}
// #if defined(ESP8266)
// data_add = "";
// #endif
// if (!isJson(STRING_format(data)) return false;
// strcpy(data, STRING_format(data).replace("\"", "\\22").c_str());
// String msg_data = STRING_format(data);
// msg_data.replace("\"", "\\22");
BLINKER_LOG_ALL(BLINKER_F("MQTT Publish..."));
BLINKER_LOG_FreeHeap_ALL();
bool _alive = isAlive;
if (needCheck)
{
if (!checkPrintSpan())
{
return false;
}
respTime = millis();
}
if (mqtt_GPRS->connected())
{
if (needCheck)
{
if (!checkCanPrint())
{
if (!_alive)
{
isAlive = false;
}
return false;
}
}
// if (! mqtt_GPRS->publish(BLINKER_PUB_TOPIC_GPRS, msg_data.c_str()))
if (! mqtt_GPRS->publish(BLINKER_PUB_TOPIC_GPRS, data))
{
BLINKER_LOG_ALL(data);
BLINKER_LOG_ALL(BLINKER_F("...Failed"));
BLINKER_LOG_FreeHeap_ALL();
if (!_alive)
{
isAlive = false;
}
return false;
}
else
{
BLINKER_LOG_ALL(data);
BLINKER_LOG_ALL(BLINKER_F("...OK!"));
BLINKER_LOG_FreeHeap_ALL();
if (needCheck) printTime = millis();
if (!_alive)
{
isAlive = false;
}
this->latestTime = millis();
return true;
}
}
else
{
BLINKER_ERR_LOG(BLINKER_F("MQTT Disconnected"));
isAlive = false;
return false;
}
}
int BlinkerSerialGPRS::toServer(char * data)
{
// if (!checkInit()) return false;
if (!isJson(STRING_format(data))) return false;
BLINKER_LOG_ALL(BLINKER_F("MQTT Publish to server..."));
BLINKER_LOG_FreeHeap_ALL();
bool _alive = isAlive;
if (mqtt_GPRS->connected())
{
if (! mqtt_GPRS->publish(BLINKER_PUB_TOPIC_GPRS, data))
{
BLINKER_LOG_ALL(data);
BLINKER_LOG_ALL(BLINKER_F("...Failed"));
BLINKER_LOG_FreeHeap_ALL();
return false;
}
else
{
BLINKER_LOG_ALL(data);
BLINKER_LOG_ALL(BLINKER_F("...OK!"));
BLINKER_LOG_FreeHeap_ALL();
return true;
}
}
else
{
BLINKER_ERR_LOG(BLINKER_F("MQTT Disconnected"));
isAlive = false;
return false;
}
}
// int BlinkerSerialGPRS::aliPrint(const String & s)
// {
// if (!checkPrintSpan()) {
// respTime = millis();
// return false;
// }
// String _s = s.substring(0, s.length() - 1);
// _s += BLINKER_F(",\"toDeviceAT\":\"AliGenie\"}");
// respTime = millis();
// BLINKER_LOG_ALL(BLINKER_F("AliGenie Response: "), _s);
// if(connected()) {
// BLINKER_LOG_ALL(BLINKER_F("Success..."));
// stream->println(_s);
// return true;
// }
// else {
// BLINKER_LOG_ALL(BLINKER_F("Faile... Disconnected"));
// return false;
// }
// }
// int BlinkerSerialGPRS::duerPrint(const String & s)
// {
// if (!checkPrintSpan()) {
// respTime = millis();
// return false;
// }
// String _s = s.substring(0, s.length() - 1);
// _s += BLINKER_F(",\"toDeviceAT\":\"DuerOS\"}");
// respTime = millis();
// BLINKER_LOG_ALL(BLINKER_F("DuerOS Response: "), _s);
// if(connected()) {
// BLINKER_LOG_ALL(BLINKER_F("Success..."));
// stream->println(_s);
// return true;
// }
// else {
// BLINKER_LOG_ALL(BLINKER_F("Faile... Disconnected"));
// return false;
// }
// }
// int BlinkerSerialGPRS::print(const String & s, bool needCheck)
void BlinkerSerialGPRS::begin(const char* _type, String _imei)
{
_deviceType = _type;
BLINKER_LOG_ALL(BLINKER_F("PRO deviceType: "), _type);
// stream = &s;
// stream->setTimeout(BLINKER_STREAM_TIMEOUT);
// isHWS = state;
imei = (char*)malloc((_imei.length() + 1)*sizeof(char));
strcpy(imei, _imei.c_str());
}
void BlinkerSerialGPRS::initStream(Stream& s, bool state, blinker_callback_t func)
{
// _deviceType = _type;
// BLINKER_LOG_ALL(BLINKER_F("PRO deviceType: "), _type);
stream = &s;
stream->setTimeout(BLINKER_STREAM_TIMEOUT);
isHWS = state;
listenFunc = func;
// streamPrint(BLINKER_CMD_CRESET_RESQ);
// _imei = (char*)malloc(imei.length()*sizeof(char));
// strcpy(_imei, imei.c_str());
}
char * BlinkerSerialGPRS::deviceName() { return MQTT_DEVICEID_GPRS;/*MQTT_ID_PRO;*/ }
void BlinkerSerialGPRS::checkKA()
{
if (millis() - kaTime >= BLINKER_MQTT_KEEPALIVE)
isAlive = false;
}
int BlinkerSerialGPRS::checkCanPrint() {
if ((millis() - printTime >= BLINKER_PRO_MSG_LIMIT && isAlive) || printTime == 0) {
return true;
}
else {
BLINKER_ERR_LOG(BLINKER_F("MQTT NOT ALIVE OR MSG LIMIT"));
checkKA();
return false;
}
}
int BlinkerSerialGPRS::checkPrintSpan()
{
if (millis() - respTime < BLINKER_PRINT_MSG_LIMIT)
{
if (respTimes > BLINKER_PRINT_MSG_LIMIT)
{
BLINKER_ERR_LOG(BLINKER_F("DEVICE NOT CONNECT OR MSG LIMIT"));
return false;
}
else
{
respTimes++;
return true;
}
}
else
{
respTimes = 0;
return true;
}
}
int BlinkerSerialGPRS::connectServer()
{
String host = BLINKER_F(BLINKER_SERVER_HTTPS);
String uri = "";
// uri += BLINKER_F("/api/v1/user/device/register?deviceType=");
// uri += _deviceType;
// uri += BLINKER_F("&deviceName=");
// uri += imei;
uri += BLINKER_F("/api/v1/user/device/diy/auth?authKey=");
uri += _deviceType;
BLINKER_LOG_ALL(BLINKER_F("HTTPS begin: "), host + uri);
BlinkerHTTPAIR202 http(*stream, isHWS, listenFunc);
http.begin(host, uri);
String payload;
if (http.GET())
{
BLINKER_LOG(BLINKER_F("[HTTP] GET... success"));
payload = http.getString();
// return true;
}
else
{
BLINKER_LOG(BLINKER_F("[HTTP] GET... failed"));
return false;
}
BLINKER_LOG_ALL(BLINKER_F("reply was:"));
BLINKER_LOG_ALL(BLINKER_F("=============================="));
BLINKER_LOG_ALL(payload);
BLINKER_LOG_ALL(BLINKER_F("=============================="));
// DynamicJsonBuffer jsonBuffer;
// JsonObject& root = jsonBuffer.parseObject(payload);
DynamicJsonDocument jsonBuffer(1024);
DeserializationError error = deserializeJson(jsonBuffer, payload);
JsonObject root = jsonBuffer.as<JsonObject>();
if (STRING_contains_string(payload, BLINKER_CMD_NOTFOUND) || error ||
!STRING_contains_string(payload, BLINKER_CMD_IOTID)) {
// while(1) {
BLINKER_ERR_LOG(("Please make sure you have register this device!"));
// ::delay(60000);
return false;
// }
}
String _userID = root[BLINKER_CMD_DETAIL][BLINKER_CMD_DEVICENAME];
String _userName = root[BLINKER_CMD_DETAIL][BLINKER_CMD_IOTID];
String _key = root[BLINKER_CMD_DETAIL][BLINKER_CMD_IOTTOKEN];
String _productInfo = root[BLINKER_CMD_DETAIL][BLINKER_CMD_PRODUCTKEY];
String _broker = root[BLINKER_CMD_DETAIL][BLINKER_CMD_BROKER];
String _uuid = root[BLINKER_CMD_DETAIL][BLINKER_CMD_UUID];
if (isMQTTinit)
{
free(MQTT_HOST_GPRS);
free(MQTT_ID_GPRS);
free(MQTT_NAME_GPRS);
free(MQTT_KEY_GPRS);
free(MQTT_PRODUCTINFO_GPRS);
free(UUID_GPRS);
free(DEVICE_NAME_GPRS);
free(BLINKER_PUB_TOPIC_GPRS);
free(BLINKER_SUB_TOPIC_GPRS);
free(mqtt_GPRS);
// free(iotSub_GPRS);
isMQTTinit = false;
}
if (_broker == BLINKER_MQTT_BORKER_ALIYUN) {
// memcpy(DEVICE_NAME_MQTT, _userID.c_str(), 12);
DEVICE_NAME_GPRS = (char*)malloc((_userID.length()+1)*sizeof(char));
strcpy(DEVICE_NAME_GPRS, _userID.c_str());
MQTT_ID_GPRS = (char*)malloc((_userID.length()+1)*sizeof(char));
strcpy(MQTT_ID_GPRS, _userID.c_str());
MQTT_NAME_GPRS = (char*)malloc((_userName.length()+1)*sizeof(char));
strcpy(MQTT_NAME_GPRS, _userName.c_str());
MQTT_KEY_GPRS = (char*)malloc((_key.length()+1)*sizeof(char));
strcpy(MQTT_KEY_GPRS, _key.c_str());
MQTT_PRODUCTINFO_GPRS = (char*)malloc((_productInfo.length()+1)*sizeof(char));
strcpy(MQTT_PRODUCTINFO_GPRS, _productInfo.c_str());
MQTT_HOST_GPRS = (char*)malloc((strlen(BLINKER_MQTT_ALIYUN_HOST)+1)*sizeof(char));
strcpy(MQTT_HOST_GPRS, BLINKER_MQTT_ALIYUN_HOST);
MQTT_PORT_GPRS = BLINKER_MQTT_ALIYUN_PORT;
}
UUID_GPRS = (char*)malloc((_uuid.length()+1)*sizeof(char));
strcpy(UUID_GPRS, _uuid.c_str());
BLINKER_LOG_ALL(BLINKER_F("===================="));
BLINKER_LOG_ALL(BLINKER_F("DEVICE_NAME_GPRS: "), DEVICE_NAME_GPRS);
BLINKER_LOG_ALL(BLINKER_F("MQTT_PRODUCTINFO_GPRS: "), MQTT_PRODUCTINFO_GPRS);
BLINKER_LOG_ALL(BLINKER_F("MQTT_ID_GPRS: "), MQTT_ID_GPRS);
BLINKER_LOG_ALL(BLINKER_F("MQTT_NAME_GPRS: "), MQTT_NAME_GPRS);
BLINKER_LOG_ALL(BLINKER_F("MQTT_KEY_GPRS: "), MQTT_KEY_GPRS);
BLINKER_LOG_ALL(BLINKER_F("MQTT_BROKER: "), _broker);
BLINKER_LOG_ALL(BLINKER_F("HOST: "), MQTT_HOST_GPRS);
BLINKER_LOG_ALL(BLINKER_F("PORT: "), MQTT_PORT_GPRS);
BLINKER_LOG_ALL(BLINKER_F("UUID_GPRS: "), UUID_GPRS);
BLINKER_LOG_ALL(BLINKER_F("===================="));
if (_broker == BLINKER_MQTT_BORKER_ALIYUN) {
String PUB_TOPIC_STR = BLINKER_F("/");
PUB_TOPIC_STR += MQTT_PRODUCTINFO_GPRS;
PUB_TOPIC_STR += BLINKER_F("/");
PUB_TOPIC_STR += MQTT_ID_GPRS;
PUB_TOPIC_STR += BLINKER_F("/s");
BLINKER_PUB_TOPIC_GPRS = (char*)malloc((PUB_TOPIC_STR.length() + 1)*sizeof(char));
// memcpy(BLINKER_PUB_TOPIC_GPRS, PUB_TOPIC_STR.c_str(), str_len);
strcpy(BLINKER_PUB_TOPIC_GPRS, PUB_TOPIC_STR.c_str());
BLINKER_LOG_ALL(BLINKER_F("BLINKER_PUB_TOPIC_GPRS: "), BLINKER_PUB_TOPIC_GPRS);
String SUB_TOPIC_STR = BLINKER_F("/");
SUB_TOPIC_STR += MQTT_PRODUCTINFO_GPRS;
SUB_TOPIC_STR += BLINKER_F("/");
SUB_TOPIC_STR += MQTT_ID_GPRS;
SUB_TOPIC_STR += BLINKER_F("/r");
BLINKER_SUB_TOPIC_GPRS = (char*)malloc((SUB_TOPIC_STR.length() + 1)*sizeof(char));
// memcpy(BLINKER_SUB_TOPIC_GPRS, SUB_TOPIC_STR.c_str(), str_len);
strcpy(BLINKER_SUB_TOPIC_GPRS, SUB_TOPIC_STR.c_str());
BLINKER_LOG_ALL(BLINKER_F("BLINKER_SUB_TOPIC_GPRS: "), BLINKER_SUB_TOPIC_GPRS);
}
// String _userID = root[BLINKER_CMD_DETAIL][BLINKER_CMD_DEVICENAME];
// String _userName = root[BLINKER_CMD_DETAIL][BLINKER_CMD_IOTID];
// String _key = root[BLINKER_CMD_DETAIL][BLINKER_CMD_IOTTOKEN];
// String _productInfo = root[BLINKER_CMD_DETAIL][BLINKER_CMD_PRODUCTKEY];
// String _broker = root[BLINKER_CMD_DETAIL][BLINKER_CMD_BROKER];
// String _uuid = root[BLINKER_CMD_DETAIL][BLINKER_CMD_UUID];
// String _authKey = root[BLINKER_CMD_DETAIL][BLINKER_CMD_KEY];
// if (isMQTTinit)
// {
// free(MQTT_HOST_GPRS);
// free(MQTT_ID_GPRS);
// free(MQTT_NAME_GPRS);
// free(MQTT_KEY_GPRS);
// free(MQTT_PRODUCTINFO_GPRS);
// free(UUID_GPRS);
// free(AUTHKEY_GPRS);
// free(MQTT_DEVICEID_GPRS);
// free(BLINKER_PUB_TOPIC_GPRS);
// free(BLINKER_SUB_TOPIC_GPRS);
// free(mqtt_GPRS);
// isMQTTinit = false;
// }
// BLINKER_LOG_ALL(("===================="));
// // if (_broker == "BLINKER_MQTT_BORKER_ALIYUN") {
// // memcpy(DEVICE_NAME, _userID.c_str(), 12);
// String _deviceName = _userID.substring(12, 36);
// MQTT_DEVICEID_GPRS = (char*)malloc((_deviceName.length()+1)*sizeof(char));
// strcpy(MQTT_DEVICEID_GPRS, _deviceName.c_str());
// MQTT_ID_GPRS = (char*)malloc((_userID.length()+1)*sizeof(char));
// strcpy(MQTT_ID_GPRS, _userID.c_str());
// MQTT_NAME_GPRS = (char*)malloc((_userName.length()+1)*sizeof(char));
// strcpy(MQTT_NAME_GPRS, _userName.c_str());
// MQTT_KEY_GPRS = (char*)malloc((_key.length()+1)*sizeof(char));
// strcpy(MQTT_KEY_GPRS, _key.c_str());
// MQTT_PRODUCTINFO_GPRS = (char*)malloc((_productInfo.length()+1)*sizeof(char));
// strcpy(MQTT_PRODUCTINFO_GPRS, _productInfo.c_str());
// MQTT_HOST_GPRS = (char*)malloc((strlen(BLINKER_MQTT_ALIYUN_HOST)+1)*sizeof(char));
// strcpy(MQTT_HOST_GPRS, BLINKER_MQTT_ALIYUN_HOST);
// AUTHKEY_GPRS = (char*)malloc((_authKey.length()+1)*sizeof(char));
// strcpy(AUTHKEY_GPRS, _authKey.c_str());
// MQTT_PORT_GPRS = BLINKER_MQTT_ALIYUN_PORT;
// BLINKER_LOG_ALL(("===================="));
// // }
// UUID_GPRS = (char*)malloc((_uuid.length()+1)*sizeof(char));
// strcpy(UUID_GPRS, _uuid.c_str());
// char uuid_eeprom[BLINKER_AUUID_SIZE];
// BLINKER_LOG_ALL(("==========AUTH CHECK=========="));
// // if (!isFirst)
// // {
// // char _authCheck;
// // EEPROM.begin(BLINKER_EEP_SIZE);
// // EEPROM.get(BLINKER_EEP_ADDR_AUUID, uuid_eeprom);
// // if (strcmp(uuid_eeprom, _uuid.c_str()) != 0) {
// // // strcpy(UUID_PRO, _uuid.c_str());
// // strcpy(uuid_eeprom, _uuid.c_str());
// // EEPROM.put(BLINKER_EEP_ADDR_AUUID, uuid_eeprom);
// // EEPROM.get(BLINKER_EEP_ADDR_AUUID, uuid_eeprom);
// // BLINKER_LOG_ALL(BLINKER_F("===================="));
// // BLINKER_LOG_ALL(BLINKER_F("uuid_eeprom: "), uuid_eeprom);
// // BLINKER_LOG_ALL(BLINKER_F("_uuid: "), _uuid);
// // isNew = true;
// // }
// // EEPROM.get(BLINKER_EEP_ADDR_AUTH_CHECK, _authCheck);
// // if (_authCheck != BLINKER_AUTH_CHECK_DATA) {
// // EEPROM.put(BLINKER_EEP_ADDR_AUTH_CHECK, BLINKER_AUTH_CHECK_DATA);
// // isAuth = true;
// // }
// // EEPROM.commit();
// // EEPROM.end();
// // isFirst = true;
// // }
// BLINKER_LOG_ALL(BLINKER_F("===================="));
// BLINKER_LOG_ALL(BLINKER_F("DEVICE_NAME: "), imei);
// BLINKER_LOG_ALL(BLINKER_F("MQTT_PRODUCTINFO_GPRS: "), MQTT_PRODUCTINFO_GPRS);
// BLINKER_LOG_ALL(BLINKER_F("MQTT_DEVICEID_GPRS: "), MQTT_DEVICEID_GPRS);
// BLINKER_LOG_ALL(BLINKER_F("MQTT_ID_GPRS: "), MQTT_ID_GPRS);
// BLINKER_LOG_ALL(BLINKER_F("MQTT_NAME_GPRS: "), MQTT_NAME_GPRS);
// BLINKER_LOG_ALL(BLINKER_F("MQTT_KEY_GPRS: "), MQTT_KEY_GPRS);
// BLINKER_LOG_ALL(BLINKER_F("MQTT_BROKER: "), _broker);
// BLINKER_LOG_ALL(BLINKER_F("HOST: "), MQTT_HOST_GPRS);
// BLINKER_LOG_ALL(BLINKER_F("PORT: "), MQTT_PORT_GPRS);
// BLINKER_LOG_ALL(BLINKER_F("UUID_GPRS: "), UUID_GPRS);
// BLINKER_LOG_ALL(BLINKER_F("AUTHKEY_GPRS: "), AUTHKEY_GPRS);
// BLINKER_LOG_ALL(BLINKER_F("===================="));
// // if (_broker == BLINKER_MQTT_BORKER_ALIYUN) {
// String PUB_TOPIC_STR = BLINKER_F("/");
// PUB_TOPIC_STR += MQTT_PRODUCTINFO_GPRS;
// PUB_TOPIC_STR += BLINKER_F("/");
// PUB_TOPIC_STR += MQTT_DEVICEID_GPRS;
// PUB_TOPIC_STR += BLINKER_F("/s");
// BLINKER_PUB_TOPIC_GPRS = (char*)malloc((PUB_TOPIC_STR.length() + 1)*sizeof(char));
// strcpy(BLINKER_PUB_TOPIC_GPRS, PUB_TOPIC_STR.c_str());
// BLINKER_LOG_ALL(BLINKER_F("BLINKER_PUB_TOPIC_GPRS: "), BLINKER_PUB_TOPIC_GPRS);
// String SUB_TOPIC_STR = BLINKER_F("/");
// SUB_TOPIC_STR += MQTT_PRODUCTINFO_GPRS;
// SUB_TOPIC_STR += BLINKER_F("/");
// SUB_TOPIC_STR += MQTT_DEVICEID_GPRS;
// SUB_TOPIC_STR += BLINKER_F("/r");
// BLINKER_SUB_TOPIC_GPRS = (char*)malloc((SUB_TOPIC_STR.length() + 1)*sizeof(char));
// strcpy(BLINKER_SUB_TOPIC_GPRS, SUB_TOPIC_STR.c_str());
// BLINKER_LOG_ALL(BLINKER_F("BLINKER_SUB_TOPIC_GPRS: "), BLINKER_SUB_TOPIC_GPRS);
// // }
// if (_broker == BLINKER_MQTT_BORKER_ALIYUN) {
mqtt_GPRS = new BlinkerMQTTAIR202(*stream, isHWS, MQTT_HOST_GPRS, MQTT_PORT_GPRS,
MQTT_ID_GPRS, MQTT_NAME_GPRS, MQTT_KEY_GPRS, listenFunc);
// }
this->latestTime = millis();
isMQTTinit = true;
mqtt_GPRS->subscribe(BLINKER_SUB_TOPIC_GPRS);
return true;
}
// int BlinkerSerialGPRS::connect()
// {
// stream->println(STRING_format(BLINKER_CMD_MCONFIG_RESQ) +
// "=\"" + MQTT_ID_GPRS +
// "\",\"" + MQTT_NAME_GPRS +
// "\",\"" + MQTT_KEY_GPRS + "\"");
// }
int BlinkerSerialGPRS::isJson(const String & data)
{
BLINKER_LOG_ALL(BLINKER_F("isJson: "), data);
// DynamicJsonBuffer jsonBuffer;
// JsonObject& root = jsonBuffer.parseObject(data);
DynamicJsonDocument jsonBuffer(1024);
DeserializationError error = deserializeJson(jsonBuffer, data);
JsonObject root = jsonBuffer.as<JsonObject>();
// if (!root.success())
if (error)
{
BLINKER_ERR_LOG("Print data is not Json! ", data);
return false;
}
return true;
}
#endif