928 lines
31 KiB
C++
928 lines
31 KiB
C++
// Clean, full sketch for ESP8266 (NodeMCU)
|
|
// - RCSwitch receiver on D5
|
|
// - RTC DS3231 on I2C (SDA=D2, SCL=D1)
|
|
// - Optional SD on CS = D8 (GPIO15)
|
|
// - Always prints received RF data to Serial
|
|
// - Saves to SD every N minutes if SD present
|
|
// - Cleans files older than M days every 12 hours
|
|
// - getPageID(...) returns numeric page id; switch-case used
|
|
// - STA + periodic sending to server
|
|
// - API to set STA & send interval
|
|
|
|
#include <ESP8266WiFi.h>
|
|
#include <Wire.h>
|
|
#include "RTClib.h"
|
|
#include <RCSwitch.h>
|
|
#include <SD.h>
|
|
#include <SPI.h>
|
|
#include <ESP8266HTTPClient.h>
|
|
#include <WiFiClientSecureBearSSL.h>
|
|
#include <Adafruit_NeoPixel.h>
|
|
#include <TimeLib.h>
|
|
|
|
|
|
// ---------------- CONFIG ----------------
|
|
String apSSID = "ESP8266_AP";
|
|
String apPassword = "12345678";
|
|
WiFiServer server(80);
|
|
|
|
// ---------------- HW ----------------
|
|
RTC_DS3231 rtc;
|
|
bool rtcReady = false;
|
|
|
|
RCSwitch rx;
|
|
const uint8_t RX_PIN = D1;
|
|
|
|
//-------------------------------------led----------------------------------
|
|
#define LED_PIN 2
|
|
#define NUM_LEDS 8
|
|
uint32_t lastLedState[NUM_LEDS] = {0};
|
|
// uint8_t currentLedIndex = 0; // LED فعلی برای ارسال
|
|
// bool ledUpdateNeeded = false;
|
|
uint32_t targetColors[NUM_LEDS]; // رنگهای هدف
|
|
Adafruit_NeoPixel strip(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
|
|
uint32_t On_color = strip.Color(0,255,127);
|
|
uint32_t off_color = strip.Color(0, 0, 0);
|
|
//uint32_t off_color = strip.Color(210, 105, 30);
|
|
uint32_t false_color = strip.Color(255, 255, 0);
|
|
uint32_t Ok_color = strip.Color(0,255,127);
|
|
uint32_t Red_color = strip.Color(255,0,0);
|
|
//-----------------------------------------------------------------------
|
|
|
|
|
|
#define SD_CS_PIN D8
|
|
bool sdReady = false;
|
|
const char* CONFIG_FILE = "config.txt";
|
|
|
|
const int buttonPin = 16; // D0
|
|
bool wifiEnabled = true;
|
|
bool StartConnectToModem = false;
|
|
bool buttonPressed = false;
|
|
int lastButtonState = HIGH;
|
|
unsigned long lastDebounceTime = 0;
|
|
const unsigned long debounceDelay = 50;
|
|
|
|
// ---------------- Protocol & storage ----------------
|
|
const String PRIVATE_KEY = "as23f";
|
|
const String device_1 = "dr142";
|
|
const String device_2 = "dv154";
|
|
|
|
uint8_t device1_recived=0;
|
|
uint8_t device2_recived=0;
|
|
//bool device2_recived=false;
|
|
|
|
const String ALLOWED_DEVICES[] = {device_1,device_2};
|
|
const int NUM_ALLOWED = 2;
|
|
|
|
#define MAX_DEVICES 16
|
|
struct DeviceData {
|
|
String deviceId;
|
|
int soil;
|
|
int gas;
|
|
float temp;
|
|
float hum;
|
|
String timestamp;
|
|
};
|
|
DeviceData lastRemoteData[MAX_DEVICES];
|
|
int deviceCount = 0;
|
|
|
|
// RX frame parsing
|
|
String receivedKey = "";
|
|
String receivedHex = "";
|
|
bool receivingPublicKey = true;
|
|
int receivedChars = 0;
|
|
unsigned long lastReceiveTime = 0;
|
|
const unsigned long FRAME_TIMEOUT_MS = 500;
|
|
const int EXPECTED_PLAIN_LEN = 25;
|
|
|
|
// ---------------- Settings (default) ----------------
|
|
unsigned long saveIntervalMinutes = 5;
|
|
int retentionDays = 90;
|
|
unsigned long lastSaveMillis = 0;
|
|
unsigned long lastCleanupMillis = 0;
|
|
unsigned long lastCheckDevice = 0;
|
|
|
|
|
|
// ---------------- WiFi client (STA) ----------------
|
|
String staSSID = "";
|
|
String staPassword = "";
|
|
unsigned long lastSendMillis = 0;
|
|
unsigned long sendIntervalMinutes = 1; // پیش فرض
|
|
|
|
// ---------------- Helpers ----------------
|
|
bool isHexChar(char c) {
|
|
return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
|
|
}
|
|
|
|
bool isDeviceAllowed(const String &id) {
|
|
for (int i=0;i<NUM_ALLOWED;i++) if (id == ALLOWED_DEVICES[i]) return true;
|
|
return false;
|
|
}
|
|
|
|
void resetFrame() {
|
|
receivedKey = "";
|
|
receivedHex = "";
|
|
receivingPublicKey = true;
|
|
receivedChars = 0;
|
|
}
|
|
|
|
String dateTimeToISO(const DateTime &dt) {
|
|
char buf[25];
|
|
sprintf(buf, "%04d-%02d-%02dT%02d:%02d:%02d",
|
|
dt.year(), dt.month(), dt.day(),
|
|
dt.hour(), dt.minute(), dt.second());
|
|
return String(buf);
|
|
}
|
|
|
|
String safeFileNameForNow() {
|
|
if (rtcReady) {
|
|
DateTime now = rtc.now();
|
|
char fn[20];
|
|
sprintf(fn, "%04d%02d%02d.txt", now.year(), now.month(), now.day());
|
|
return String(fn);
|
|
} else {
|
|
unsigned long s = millis() / 1000UL;
|
|
return String("t") + String(s) + ".txt";
|
|
}
|
|
}
|
|
|
|
String decryptData(const String &data, const String &key) {
|
|
String out;
|
|
out.reserve(data.length());
|
|
for (int i=0;i<data.length();++i) out += (char)(data[i] ^ key[i % key.length()]);
|
|
return out;
|
|
}
|
|
|
|
// ---------------- SD / config helpers ----------------
|
|
// -------------------- loadConfigFromSD --------------------
|
|
// -------------------- loadConfigFromSD --------------------
|
|
void loadConfigFromSD() {
|
|
if (!sdReady) {
|
|
Serial.println("[CONFIG] SD not ready, skipping load");
|
|
return;
|
|
}
|
|
|
|
Serial.println("[CONFIG] Loading configuration from SD...");
|
|
File f = SD.open(CONFIG_FILE, "r");
|
|
if (!f) {
|
|
Serial.println("[CONFIG] Config file not found, using defaults");
|
|
return;
|
|
}
|
|
|
|
while (f.available()) {
|
|
String line = f.readStringUntil('\n');
|
|
line.trim();
|
|
if (line.length() == 0) continue;
|
|
|
|
Serial.print("[CONFIG] Line: ");
|
|
Serial.println(line);
|
|
|
|
if (line.startsWith("save_interval_minutes=")) {
|
|
saveIntervalMinutes = line.substring(strlen("save_interval_minutes=")).toInt();
|
|
Serial.print("[CONFIG] Loaded save_interval_minutes = ");
|
|
Serial.println(saveIntervalMinutes);
|
|
}
|
|
else if (line.startsWith("retention_days=")) {
|
|
retentionDays = line.substring(strlen("retention_days=")).toInt();
|
|
Serial.print("[CONFIG] Loaded retention_days = ");
|
|
Serial.println(retentionDays);
|
|
}
|
|
else if (line.startsWith("wifi_ssid=")) {
|
|
apSSID = line.substring(strlen("wifi_ssid="));
|
|
Serial.print("[CONFIG] Loaded wifi_ssid = ");
|
|
Serial.println(apSSID);
|
|
}
|
|
else if (line.startsWith("wifi_password=")) {
|
|
apPassword = line.substring(strlen("wifi_password="));
|
|
Serial.print("[CONFIG] Loaded wifi_password = ");
|
|
Serial.println(apPassword);
|
|
}
|
|
else if (line.startsWith("sta_ssid=")) {
|
|
staSSID = line.substring(strlen("sta_ssid="));
|
|
Serial.print("[CONFIG] Loaded sta_ssid = ");
|
|
Serial.println(staSSID);
|
|
}
|
|
else if (line.startsWith("sta_password=")) {
|
|
staPassword = line.substring(strlen("sta_password="));
|
|
Serial.print("[CONFIG] Loaded sta_password = ");
|
|
Serial.println(staPassword);
|
|
}
|
|
else if (line.startsWith("sendIntervalMinutes=")) {
|
|
sendIntervalMinutes = line.substring(strlen("sendIntervalMinutes=")).toInt();
|
|
Serial.print("[CONFIG] Loaded sendIntervalMinutes = ");
|
|
Serial.println(sendIntervalMinutes);
|
|
}
|
|
else {
|
|
Serial.print("[CONFIG] Unknown line ignored: ");
|
|
Serial.println(line);
|
|
}
|
|
}
|
|
|
|
f.close();
|
|
Serial.println("[CONFIG] Finished loading configuration");
|
|
}
|
|
|
|
// -------------------- saveConfigToSD --------------------
|
|
void saveConfigToSD() {
|
|
if (!sdReady) {
|
|
Serial.println("[CONFIG] SD not ready, cannot save config");
|
|
return;
|
|
}
|
|
|
|
Serial.println("[CONFIG] Saving configuration to SD...");
|
|
|
|
// اول فایل قبلی رو پاک کن
|
|
if (SD.exists(CONFIG_FILE)) {
|
|
SD.remove(CONFIG_FILE);
|
|
Serial.println("[CONFIG] Old config file removed");
|
|
}
|
|
|
|
File f = SD.open(CONFIG_FILE, FILE_WRITE);
|
|
if (!f) {
|
|
Serial.println("[CONFIG] Failed to open config file for writing");
|
|
return;
|
|
}
|
|
|
|
// همه مقادیر رو یکجا مینویسیم
|
|
f.print("save_interval_minutes=");
|
|
f.println(saveIntervalMinutes);
|
|
|
|
f.print("retention_days=");
|
|
f.println(retentionDays);
|
|
|
|
f.print("sendIntervalMinutes=");
|
|
f.println(sendIntervalMinutes);
|
|
|
|
f.print("wifi_ssid=");
|
|
f.println(apSSID);
|
|
|
|
f.print("wifi_password=");
|
|
f.println(apPassword);
|
|
|
|
f.print("sta_ssid=");
|
|
f.println(staSSID);
|
|
|
|
f.print("sta_password=");
|
|
f.println(staPassword);
|
|
|
|
f.close();
|
|
Serial.println("[CONFIG] Configuration saved successfully (file rewritten)");
|
|
}
|
|
|
|
|
|
void appendDataToSD(const String &line) {
|
|
if (!sdReady) return;
|
|
String fname = safeFileNameForNow();
|
|
File f = SD.open(fname, FILE_WRITE);
|
|
if (!f) f = SD.open(fname, "a");
|
|
if (!f) return;
|
|
f.println(line);
|
|
f.close();
|
|
}
|
|
|
|
uint64_t computeSDUsedBytes() {
|
|
if (!sdReady) return 0;
|
|
uint64_t used = 0;
|
|
File root = SD.open("/");
|
|
if (!root) return 0;
|
|
File entry = root.openNextFile();
|
|
while (entry) { if (!entry.isDirectory()) used += (uint64_t)entry.size(); entry.close(); entry = root.openNextFile(); }
|
|
root.close();
|
|
return used;
|
|
}
|
|
|
|
void cleanupOldFilesOnSD() {
|
|
if (!sdReady || !rtcReady) return;
|
|
File root = SD.open("/");
|
|
if (!root) return;
|
|
File entry = root.openNextFile();
|
|
DateTime now = rtc.now();
|
|
while (entry) {
|
|
String name = entry.name();
|
|
if (name.length() && name[0] == '/') name = name.substring(1);
|
|
if (name != String(CONFIG_FILE) && !entry.isDirectory()) {
|
|
if (name.length() >= 8 && isDigit(name[0])) {
|
|
int y = name.substring(0,4).toInt();
|
|
int m = name.substring(4,6).toInt();
|
|
int d = name.substring(6,8).toInt();
|
|
if (y > 2000 && m>=1 && m<=12 && d>=1 && d<=31) {
|
|
DateTime fileDate(y,m,d,0,0,0);
|
|
TimeSpan diff = now - fileDate;
|
|
if (diff.days() > retentionDays) SD.remove(name);
|
|
}
|
|
}
|
|
}
|
|
entry.close();
|
|
entry = root.openNextFile();
|
|
}
|
|
root.close();
|
|
}
|
|
|
|
// ---------------- Remote receiver ----------------
|
|
void processRemote() {
|
|
if (rx.available()) {
|
|
unsigned long value = rx.getReceivedValue();
|
|
unsigned int bitlen = rx.getReceivedBitlength();
|
|
if (bitlen == 8) {
|
|
char c = (char)value;
|
|
if (receivingPublicKey) {
|
|
if (receivedKey.length() < 5) receivedKey += c;
|
|
if (receivedKey.length() == 5) receivingPublicKey = false;
|
|
} else {
|
|
if (isHexChar(c)) receivedHex += c;
|
|
}
|
|
receivedChars++;
|
|
lastReceiveTime = millis();
|
|
}
|
|
rx.resetAvailable();
|
|
}
|
|
|
|
if (receivedChars >= 5 && (millis() - lastReceiveTime) > FRAME_TIMEOUT_MS) {
|
|
if (receivedKey != PRIVATE_KEY || (receivedHex.length() % 2) != 0) { resetFrame(); return; }
|
|
|
|
String decoded; decoded.reserve(receivedHex.length()/2);
|
|
for (int i=0; i+1<receivedHex.length(); i+=2) {
|
|
char hex2[3] = { receivedHex[i], receivedHex[i+1], '\0' };
|
|
decoded += (char)strtol(hex2,NULL,16);
|
|
}
|
|
|
|
if (decoded.length() != EXPECTED_PLAIN_LEN) { resetFrame(); return; }
|
|
String plain = decryptData(decoded, PRIVATE_KEY);
|
|
if (plain[5]!='S'||plain[10]!='G'||plain[15]!='T'||plain[20]!='H') { resetFrame(); return; }
|
|
|
|
String deviceId = plain.substring(0,5);
|
|
if (!isDeviceAllowed(deviceId)) { resetFrame(); return; }
|
|
|
|
int soil = plain.substring(6,10).toInt();
|
|
int gas = plain.substring(11,15).toInt();
|
|
float temp = plain.substring(16,20).toInt()/10.0;
|
|
float hum = plain.substring(21,25).toInt()/10.0;
|
|
|
|
String ts = rtcReady?dateTimeToISO(rtc.now()):String(millis());
|
|
|
|
Serial.printf("[RX] %s soil=%d gas=%d temp=%.1f hum=%.1f time=%s\n", deviceId.c_str(),soil,gas,temp,hum,ts.c_str());
|
|
|
|
bool updated=false;
|
|
for (int i=0;i<deviceCount;i++) {
|
|
if (lastRemoteData[i].deviceId==deviceId) {
|
|
lastRemoteData[i]={deviceId,soil,gas,temp,hum,ts};
|
|
updated=true; break;
|
|
}
|
|
}
|
|
if (!updated && deviceCount<MAX_DEVICES) lastRemoteData[deviceCount++]={deviceId,soil,gas,temp,hum,ts};
|
|
checkDeviceData();
|
|
if ((millis()-lastSaveMillis) >= saveIntervalMinutes*60000UL) {
|
|
if (sdReady) {
|
|
String j="{\"device\":\""+deviceId+"\",\"soil\":"+String(soil)+",\"gas\":"+String(gas)+
|
|
",\"temp\":"+String(temp)+",\"hum\":"+String(hum)+",\"time\":\""+ts+"\"}";
|
|
appendDataToSD(j);
|
|
Serial.println("[INFO] appended to SD");
|
|
}
|
|
lastSaveMillis=millis();
|
|
}
|
|
|
|
resetFrame();
|
|
}
|
|
}
|
|
|
|
// ---------------- Page mapping ----------------
|
|
int getPageID(const String &page) {
|
|
if (page == "info") return 1;
|
|
if (page == "sensor") return 2;
|
|
if (page == "time") return 3;
|
|
if (page == "settime") return 4;
|
|
if (page == "lastremote") return 5;
|
|
if (page == "readfile") return 6;
|
|
if (page == "files") return 7;
|
|
if (page == "format") return 8;
|
|
if (page == "set_save_interval") return 9;
|
|
if (page == "set_retention_days") return 10;
|
|
if (page == "sd_status") return 11;
|
|
return 0;
|
|
}
|
|
|
|
String urlDecode(const String &input) {
|
|
String s = input;
|
|
s.replace("+", " ");
|
|
for (int i = 0; i + 2 < s.length(); ++i) {
|
|
if (s[i] == '%') {
|
|
String hx = s.substring(i+1, i+3);
|
|
char c = (char) strtol(hx.c_str(), NULL, 16);
|
|
s = s.substring(0,i) + String(c) + s.substring(i+3);
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
|
|
String getParamFromPath(const String &path, const String &key) {
|
|
int q = path.indexOf('?');
|
|
if (q == -1) return "";
|
|
String qstr = path.substring(q+1);
|
|
int start = 0;
|
|
while (start < qstr.length()) {
|
|
int amp = qstr.indexOf('&', start);
|
|
if (amp == -1) amp = qstr.length();
|
|
int eq = qstr.indexOf('=', start);
|
|
if (eq != -1 && eq < amp) {
|
|
String k = qstr.substring(start, eq);
|
|
String v = qstr.substring(eq+1, amp);
|
|
if (k == key) return urlDecode(v);
|
|
}
|
|
start = amp + 1;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
// ---------------- HTTP handler ----------------
|
|
void handleClient() {
|
|
if (!wifiEnabled)
|
|
return;
|
|
WiFiClient client = server.available();
|
|
if (!client)
|
|
return;
|
|
String req = "";
|
|
unsigned long start = millis();
|
|
while (client.connected() && millis() - start < 1500) {
|
|
while (client.available()) {
|
|
char c = client.read();
|
|
req += c;
|
|
if (req.endsWith("\r\n\r\n")) break;
|
|
}
|
|
if (req.endsWith("\r\n\r\n")) break;
|
|
}
|
|
if (req.length() == 0) return;
|
|
|
|
int lineEnd = req.indexOf("\r\n");
|
|
String firstLine = (lineEnd == -1) ? req : req.substring(0, lineEnd);
|
|
Serial.print("[HTTP] "); Serial.println(firstLine);
|
|
|
|
String path = "";
|
|
int sp1 = firstLine.indexOf(' ');
|
|
int sp2 = firstLine.indexOf(" HTTP/");
|
|
if (sp1 != -1 && sp2 != -1) path = firstLine.substring(sp1+1, sp2);
|
|
|
|
String page = getParamFromPath(path,"page");
|
|
String response="";
|
|
|
|
// --- API: set STA ---
|
|
if(page=="set_sta") {
|
|
String ssid = getParamFromPath(path,"ssid");
|
|
String pass = getParamFromPath(path,"pass");
|
|
if(ssid.length()>0) {
|
|
staSSID=ssid; staPassword=pass;
|
|
StartConnectToModem=WiFi.begin(staSSID.c_str(),staPassword.c_str());
|
|
if(sdReady) saveConfigToSD();
|
|
response="{\"status\":\"ok\",\"message\":\"STA updated, connecting...\"}";
|
|
} else response="{\"status\":\"error\",\"message\":\"SSID missing\"}";
|
|
client.println(F("HTTP/1.1 200 OK"));
|
|
client.println(F("Content-Type: application/json"));
|
|
client.print(F("Content-Length: ")); client.println(response.length());
|
|
client.println(F("Connection: close")); client.println();
|
|
client.println(response);
|
|
client.stop();
|
|
return;
|
|
}
|
|
|
|
// --- API: set send interval ---
|
|
if(page=="set_send_interval") {
|
|
String v = getParamFromPath(path,"minutes");
|
|
int m=v.toInt();
|
|
if(m>0) {
|
|
sendIntervalMinutes=m;
|
|
if(sdReady) saveConfigToSD();
|
|
response="{\"status\":\"ok\",\"send_interval_minutes\":"+String(m)+"}";
|
|
} else response="{\"status\":\"error\",\"message\":\"invalid minutes\"}";
|
|
client.println(F("HTTP/1.1 200 OK"));
|
|
client.println(F("Content-Type: application/json"));
|
|
client.print(F("Content-Length: ")); client.println(response.length());
|
|
client.println(F("Connection: close")); client.println();
|
|
client.println(response);
|
|
client.stop();
|
|
return;
|
|
}
|
|
|
|
// --- old page switch ---
|
|
int pid = getPageID(page);
|
|
switch(pid) {
|
|
case 1:
|
|
response="{\"status\":\"ok\",\"data\":\"ESP ready,StartConnectToModem:"+String(StartConnectToModem)+",wifiEnabled:"+String(wifiEnabled)+"\"}"; break;
|
|
case 2: response="{\"status\":\"ok\",\"sensor\":"+String(analogRead(A0))+"}"; break;
|
|
case 3: response=rtcReady?"{\"status\":\"ok\",\"data\":\""+dateTimeToISO(rtc.now())+"\"}":"{\"status\":\"error\",\"message\":\"RTC not ready\"}"; break;
|
|
case 4: {
|
|
String iso=getParamFromPath(path,"iso");
|
|
if(!rtcReady){ response="{\"status\":\"error\",\"message\":\"RTC not ready\"}"; break; }
|
|
if(iso.length()>=19){
|
|
int y=iso.substring(0,4).toInt(), m=iso.substring(5,7).toInt(), d=iso.substring(8,10).toInt();
|
|
int hh=iso.substring(11,13).toInt(), mm=iso.substring(14,16).toInt(), ss=iso.substring(17,19).toInt();
|
|
rtc.adjust(DateTime(y,m,d,hh,mm,ss));
|
|
response="{\"status\":\"ok\",\"data\":\""+dateTimeToISO(rtc.now())+"\"}";
|
|
} else response="{\"status\":\"error\",\"message\":\"invalid iso\"}";
|
|
break;
|
|
}
|
|
case 5: {
|
|
String arr="[";
|
|
for(int i=0;i<deviceCount;i++){ if(i) arr+=","; DeviceData &d=lastRemoteData[i]; arr+="{\"device\":\""+d.deviceId+"\",\"soil\":"+String(d.soil)+",\"gas\":"+String(d.gas)+",\"temp\":"+String(d.temp)+",\"hum\":"+String(d.hum)+",\"time\":\""+d.timestamp+"\"}"; }
|
|
arr+="]";
|
|
response="{\"status\":\"ok\",\"data\":"+arr+"}"; break;
|
|
}
|
|
case 6: {
|
|
if (!sdReady) { response = "{\"status\":\"error\",\"message\":\"SD not ready\"}"; break; }
|
|
String name = getParamFromPath(path, "name");
|
|
if (name.length() == 0) { response = "{\"status\":\"error\",\"message\":\"missing name\"}"; break; }
|
|
File f = SD.open(name, "r");
|
|
if (!f) { response = "{\"status\":\"error\",\"message\":\"file not found\"}"; break; }
|
|
String content = "";
|
|
while (f.available()) {
|
|
char c = f.read();
|
|
if (c == '"') content += "\""; else content += c;
|
|
if (c == '}')
|
|
{
|
|
//content += c;
|
|
content += ",";
|
|
}
|
|
}
|
|
if (content.length() > 0) {
|
|
content.remove(content.length() - 3);
|
|
}
|
|
f.close();
|
|
response = "{\"status\":\"ok\",\"content\":[" + content + "]}";
|
|
|
|
break;
|
|
}
|
|
case 7: { // files
|
|
if (!sdReady) { response = "{\"status\":\"error\",\"message\":\"SD not ready\"}"; break; }
|
|
File root = SD.open("/");
|
|
String arr = "[";
|
|
bool first = true;
|
|
File entry = root.openNextFile();
|
|
while (entry) {
|
|
String name = entry.name();
|
|
if (name.length() && name[0] == '/') name = name.substring(1);
|
|
if (!first) arr += ",";
|
|
arr += "\"" + name + "\"";
|
|
first = false;
|
|
entry.close();
|
|
entry = root.openNextFile();
|
|
}
|
|
root.close();
|
|
arr += "]";
|
|
response = "{\"status\":\"ok\",\"files\":" + arr + "}";
|
|
break;
|
|
}
|
|
case 8: { // format (remove all files except config)
|
|
if (!sdReady) { response = "{\"status\":\"error\",\"message\":\"SD not ready\"}"; break; }
|
|
File root = SD.open("/");
|
|
File entry = root.openNextFile();
|
|
while (entry) {
|
|
String name = entry.name();
|
|
if (name.length() && name[0] == '/') name = name.substring(1);
|
|
if (name != String(CONFIG_FILE) && !entry.isDirectory()) SD.remove(name);
|
|
entry.close();
|
|
entry = root.openNextFile();
|
|
}
|
|
root.close();
|
|
response = "{\"status\":\"ok\",\"message\":\"formatted (config preserved)\"}";
|
|
break;
|
|
}
|
|
case 9: { // set_save_interval?min=NUM
|
|
String v = getParamFromPath(path, "min");
|
|
int m = v.toInt();
|
|
if (m <= 0) response = "{\"status\":\"error\",\"message\":\"invalid min\"}";
|
|
else {
|
|
saveIntervalMinutes = (unsigned long)m;
|
|
if (sdReady) saveConfigToSD();
|
|
response = "{\"status\":\"ok\",\"save_interval_minutes\":" + String(m) + "}";
|
|
}
|
|
break;
|
|
}
|
|
case 10: { // set_retention_days?days=NUM
|
|
String v = getParamFromPath(path, "days");
|
|
int d = v.toInt();
|
|
if (d <= 0) response = "{\"status\":\"error\",\"message\":\"invalid days\"}";
|
|
else {
|
|
retentionDays = d;
|
|
if (sdReady) saveConfigToSD();
|
|
response = "{\"status\":\"ok\",\"retention_days\":" + String(d) + "}";
|
|
}
|
|
break;
|
|
}
|
|
case 11: { // sd_status
|
|
if (!sdReady) response = "{\"status\":\"error\",\"message\":\"SD not ready\"}";
|
|
else
|
|
{
|
|
uint64_t used = computeSDUsedBytes();
|
|
//total/free not reliably available via SD.h on ESP8266
|
|
response = "{\"status\":\"ok\",\"used_bytes\":" + String((unsigned long)used) + "}";
|
|
}
|
|
break;
|
|
}
|
|
default: response = page.length()==0?"{\"status\":\"error\",\"message\":\"missing page\"}":"{\"status\":\"error\",\"message\":\"unknown page\"}"; break;
|
|
}
|
|
|
|
client.println(F("HTTP/1.1 200 OK"));
|
|
client.println(F("Content-Type: application/json"));
|
|
client.print(F("Content-Length: ")); client.println(response.length());
|
|
client.println(F("Connection: close"));
|
|
client.println();
|
|
client.println(response);
|
|
delay(5);
|
|
client.stop();
|
|
Serial.println("[HTTP] client disconnected");
|
|
}
|
|
|
|
time_t parseTimestamp(String ts) {
|
|
int year = ts.substring(0, 4).toInt();
|
|
int month = ts.substring(5, 7).toInt();
|
|
int day = ts.substring(8, 10).toInt();
|
|
int hour = ts.substring(11, 13).toInt();
|
|
int min = ts.substring(14, 16).toInt();
|
|
int sec = ts.substring(17, 19).toInt();
|
|
|
|
tmElements_t tm;
|
|
tm.Year = year - 1970;
|
|
tm.Month = month;
|
|
tm.Day = day;
|
|
tm.Hour = hour;
|
|
tm.Minute = min;
|
|
tm.Second = sec;
|
|
|
|
return makeTime(tm);
|
|
}
|
|
void checkDeviceData() {
|
|
time_t now = rtc.now().unixtime();
|
|
int device1Index=-1;
|
|
int device2Index=-1;
|
|
for (int i = 0; i < MAX_DEVICES; i++)
|
|
{
|
|
if(i<deviceCount)
|
|
{
|
|
if(lastRemoteData[i].deviceId==device_1)
|
|
device1Index=i;
|
|
if(lastRemoteData[i].deviceId==device_2)
|
|
device2Index=i;
|
|
}
|
|
}
|
|
if(device1Index==-1)
|
|
{
|
|
device1_recived=0;//دریافتی از دستگاه 1 نداشتیم
|
|
Serial.println(device_1 + " not exist");
|
|
}
|
|
else
|
|
{
|
|
int i=device1Index;
|
|
if (lastRemoteData[i].timestamp.length() > 0) {
|
|
time_t t = parseTimestamp(lastRemoteData[i].timestamp);
|
|
long diff = now - t; // اختلاف زمان به ثانیه
|
|
|
|
if (diff < 60) {
|
|
device1_recived=2;
|
|
Serial.println(lastRemoteData[i].deviceId + " updated less than 60 seconds ago");
|
|
} else {
|
|
device1_recived=1;
|
|
Serial.println(lastRemoteData[i].deviceId + "--- updated more than 60 seconds ago");
|
|
}
|
|
}
|
|
else{
|
|
device1_recived=1;
|
|
Serial.println(lastRemoteData[i].deviceId + "--- noDataRecive updated more than 60 seconds ago");
|
|
}
|
|
}
|
|
if(device2Index==-1)
|
|
{
|
|
device2_recived=0;//دریافتی از دستگاه 2 نداشتیم
|
|
Serial.println(device_2 + " not exist");
|
|
}
|
|
else
|
|
{
|
|
int i=device2Index;
|
|
if (lastRemoteData[i].timestamp.length() > 0) {
|
|
time_t t = parseTimestamp(lastRemoteData[i].timestamp);
|
|
long diff = now - t; // اختلاف زمان به ثانیه
|
|
|
|
if (diff < 60) {
|
|
device2_recived=2;
|
|
Serial.println(lastRemoteData[i].deviceId + " updated less than 60 seconds ago");
|
|
} else {
|
|
device2_recived=1;
|
|
Serial.println(lastRemoteData[i].deviceId + "--- updated more than 60 seconds ago");
|
|
}
|
|
}
|
|
else{
|
|
device1_recived=1;
|
|
Serial.println(lastRemoteData[i].deviceId + "--- noDataRecive updated more than 60 seconds ago");
|
|
}
|
|
}
|
|
}
|
|
void setLed(uint8_t idx, bool condition, uint32_t colorTrue, uint32_t colorFalse) {
|
|
if (condition) {
|
|
strip.setPixelColor(idx, colorTrue);
|
|
} else {
|
|
strip.setPixelColor(idx, colorFalse);
|
|
}
|
|
}
|
|
// ---------------- Setup & Loop ----------------
|
|
void startEsp()
|
|
{
|
|
|
|
}
|
|
void setup() {
|
|
|
|
Serial.begin(115200); delay(100);
|
|
|
|
//--------------------------------Start Led---------------------------------------------------------
|
|
strip.begin();
|
|
strip.show();
|
|
|
|
//چراغ اول روشن شود. یعنی دستگاه روشن است
|
|
//setLed(0, true, On_color, On_color);
|
|
//strip.show();
|
|
//-----------------------------------------------------------------------------------------
|
|
//-------------------------------------Button Config----------------------------------------------------
|
|
pinMode(buttonPin, INPUT_PULLUP);
|
|
//-----------------------------------------------------------------------------------------
|
|
//------------------------------------Start Clock-----------------------------------------------------
|
|
Wire.begin(D2,D3);
|
|
rtcReady=rtc.begin();
|
|
if(rtcReady && rtc.lostPower()) rtc.adjust(DateTime(F(__DATE__),F(__TIME__)));
|
|
//-----------------------------------------------------------------------------------------
|
|
|
|
//--------------------------------------Start Sdk---------------------------------------------------
|
|
rx.enableReceive(digitalPinToInterrupt(RX_PIN));
|
|
rx.setProtocol(1);
|
|
rx.setPulseLength(300);
|
|
Serial.println("[INFO] RCSwitch enabled on D1");
|
|
//-----------------------------------------------------------------------------------------
|
|
//-----------------------------------------Start SD Card------------------------------------------------
|
|
sdReady=SD.begin(SD_CS_PIN);
|
|
if(sdReady){ Serial.println("[INFO] SD ready"); loadConfigFromSD(); }
|
|
else Serial.println("[WARN] SD init failed");
|
|
//-----------------------------------------------------------------------------------------
|
|
//-----------------------------------Start ESP------------------------------------------------------
|
|
if(wifiEnabled){ WiFi.softAP(apSSID,apPassword,6); server.begin(); Serial.print("AP IP: "); Serial.println(WiFi.softAPIP()); }
|
|
|
|
if(staSSID.length()>0){ StartConnectToModem=WiFi.begin(staSSID.c_str(),staPassword.c_str()); }
|
|
//-----------------------------------------------------------------------------------------
|
|
|
|
lastSaveMillis=millis(); lastCleanupMillis=millis(); lastSendMillis=millis();lastCheckDevice=millis();
|
|
}
|
|
void CheckWifiBtn()
|
|
{
|
|
// ---------------- Button handling (toggle AP) ----------------
|
|
int reading = digitalRead(buttonPin);
|
|
if (reading != lastButtonState) lastDebounceTime = millis();
|
|
|
|
if ((millis() - lastDebounceTime) > debounceDelay) {
|
|
if (reading == LOW && !buttonPressed) {
|
|
buttonPressed = true;
|
|
wifiEnabled = !wifiEnabled;
|
|
|
|
if (wifiEnabled) {
|
|
WiFi.mode(WIFI_AP_STA);
|
|
WiFi.softAP(apSSID, apPassword,6);
|
|
server.begin();
|
|
Serial.println("✅ AP enabled");
|
|
Serial.print("IP: "); Serial.println(WiFi.softAPIP());
|
|
} else {
|
|
WiFi.softAPdisconnect(true);
|
|
WiFi.mode(WIFI_STA);
|
|
Serial.println("❌ AP disabled");
|
|
}
|
|
}
|
|
|
|
if (reading == HIGH) buttonPressed = false;
|
|
}
|
|
lastButtonState = reading;
|
|
}
|
|
void SendDataToServer()
|
|
{
|
|
if (deviceCount > 0 && sendIntervalMinutes > 0) {
|
|
if (lastSendMillis == 0) lastSendMillis = millis();
|
|
|
|
if ((millis() - lastSendMillis) >= sendIntervalMinutes * 60000UL) {
|
|
Serial.println("[DEBUG] Entering send block");
|
|
Serial.print("[DEBUG] WiFi.status: "); Serial.println(WiFi.status());
|
|
if (WiFi.status() == WL_CONNECTED) {
|
|
// Prepare JSON payload
|
|
String payload = "[";
|
|
for (int i = 0; i < deviceCount; i++) {
|
|
if (i) payload += ",";
|
|
DeviceData &d = lastRemoteData[i];
|
|
payload += "{\"device\":\"" + d.deviceId + "\",\"soil\":" + String(d.soil) +
|
|
",\"gas\":" + String(d.gas) + ",\"temp\":" + String(d.temp) +
|
|
",\"hum\":" + String(d.hum) + ",\"time\":\"" + d.timestamp + "\"}";
|
|
}
|
|
payload += "]";
|
|
|
|
// Use WiFiClientSecure for HTTPS
|
|
WiFiClientSecure client;
|
|
client.setInsecure(); // SSL certificate not verified
|
|
HTTPClient http;
|
|
|
|
// Use URL with www if nabaksoft.ir ریدایرکت میکند
|
|
String url = "https://www.nabaksoft.ir/greenhome/mygreenhome.php?aid="+PRIVATE_KEY+"&data=" + payload;
|
|
|
|
http.begin(client, url);
|
|
http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS); // Follow redirects automatically
|
|
|
|
Serial.println("[HTTP] Sending data to server...");
|
|
int httpCode = http.GET();
|
|
|
|
if (httpCode > 0) {
|
|
Serial.printf("[HTTP] Response code: %d\n", httpCode);
|
|
String resp = http.getString();
|
|
Serial.printf("[HTTP] Server response: %s\n", resp.c_str());
|
|
} else {
|
|
Serial.printf("[HTTP] Send failed, error: %s\n", http.errorToString(httpCode).c_str());
|
|
}
|
|
|
|
http.end();
|
|
} else {
|
|
Serial.println("[HTTP] WiFi not connected, skipping send");
|
|
}
|
|
lastSendMillis = millis();
|
|
}
|
|
}
|
|
}
|
|
void SetLedStates()
|
|
{
|
|
//دریافت کننده فعال است؟
|
|
/*setLed(1, rtcReady, Ok_color, off_color);
|
|
//کارتخوان فعال است؟
|
|
setLed(2, sdReady, Ok_color, off_color);
|
|
//wifi فعال است؟
|
|
setLed(3, wifiEnabled, Ok_color, off_color);
|
|
//مودم فعال است یا خیر و اگر فعال است متصل است؟
|
|
if(staSSID.length()>0)
|
|
{
|
|
//اگر رمز دارد پس باید متصل بشه.اگر شده که سبز. اگر نشده قرمز
|
|
setLed(4, WiFi.status()==WL_CONNECTED, Ok_color, false_color);
|
|
}
|
|
else
|
|
setLed(4, true, off_color, off_color);
|
|
|
|
setLed(5, true, off_color, off_color);
|
|
setLed(6, true, off_color, off_color);
|
|
setLed(7, true, off_color, off_color);
|
|
//شدت روشنایی
|
|
strip.setBrightness(20);
|
|
strip.show();*/
|
|
int32_t colors[NUM_LEDS];
|
|
colors[0] = On_color; // دستگاه روشن
|
|
colors[1] = rtcReady ? Ok_color : off_color; // وضعیت RTC
|
|
colors[2] = sdReady ? Ok_color : off_color; // وضعیت SD
|
|
colors[3] = wifiEnabled ? Ok_color : off_color; // وضعیت AP
|
|
colors[4] = (staSSID.length() > 0 && WiFi.status() == WL_CONNECTED) ? Ok_color : false_color; // STA
|
|
|
|
colors[5] = (device1_recived==2)?Ok_color:(device1_recived==1?false_color:Red_color);
|
|
colors[6] = (device2_recived == 2)?Ok_color:(device2_recived==1?false_color:Red_color);
|
|
colors[7] = off_color;
|
|
|
|
// بررسی اینکه آیا تغییری نسبت به وضعیت قبلی وجود دارد
|
|
bool changed = false;
|
|
for (int i = 0; i < NUM_LEDS; i++) {
|
|
if (colors[i] != lastLedState[i]) {
|
|
lastLedState[i] = colors[i];
|
|
strip.setPixelColor(i, colors[i]);
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
// فقط وقتی تغییر بوده، strip.show() اجرا شود
|
|
if (changed) {
|
|
strip.setBrightness(20);
|
|
strip.show(); // این تابع اکنون به حداقل فراخوانی کاهش یافته
|
|
}
|
|
}
|
|
void loop() {
|
|
|
|
CheckWifiBtn();
|
|
|
|
// ---------------- HTTP server handling ----------------
|
|
handleClient();
|
|
|
|
// ---------------- Process RF data ----------------
|
|
processRemote();
|
|
|
|
//---------------- Periodic cleanup every 12 hours ----------------
|
|
if ((millis() - lastCleanupMillis) >= (12UL * 60UL * 60UL * 1000UL)) {
|
|
cleanupOldFilesOnSD();
|
|
lastCleanupMillis = millis();
|
|
}
|
|
//هر یک دقیقه چک کنه وضعیت دو فرستنده چطور هست
|
|
if ((millis() - lastCheckDevice) >= (60UL * 1000UL)) {
|
|
checkDeviceData();
|
|
lastCheckDevice = millis();
|
|
}
|
|
|
|
|
|
// ---------------- Periodic send to server ----------------
|
|
SendDataToServer();
|
|
|
|
SetLedStates();
|
|
}
|
|
|
|
|
|
// if (wifiEnabled) {
|
|
// WiFiClient client = server.available();
|
|
// if (client) handleClient(client);
|
|
// }
|