// =====================================================================
// TEST BOARD ESP32 + SIM7600 + W5500 + RS485 Modbus + RTC + SD
// - Khi khởi động 3 LED nhấp nháy rồi tắt
// - Có RTC -> khởi động xong LED1 (bên trái) sáng
// - Có thẻ SD khi khởi động -> LED2 sáng
// - Bấm nút IO-0 -> đảo trạng thái LED1
// - Giữ IO-0 3s -> LED3 sáng, reset module SIM qua PWRKEY rồi gọi điện / gửi SMS (TEST-SIM)
// =====================================================================
#include <SPI.h>
#include <SD.h>
#include <Ethernet.h>
#include <WiFi.h>
#include <ModbusMaster.h>
#include "RTClib.h"
#include "Wire.h"
#include <HardwareSerial.h>
#define BUTTON 0
// LED (tích cực mức LOW)
#define LED1 12
#define LED2 13
#define LED3 5
// UART2 cho Modbus RTU
#define RXD2 17
#define TXD2 16
// I2C cho RTC
#define SDA 22
#define SCL 21
// CS thẻ SD
#define SD_CS 33
// CS Ethernet W5500
#define ETH_CS_PIN 32
RTC_DS1307 rtc;
#define PHONE_NUMBER "+8497111xxxx"
// ============================ MODULE SIM7600 ============================
// SIM dùng UART1 riêng. Bản cũ dùng chung Serial2 với Modbus nên sau lần test
// SIM đầu tiên, Serial2 bị chuyển sang chân 26/27 và Modbus gửi nhầm vào module SIM.
HardwareSerial simSerial(1);
#define MCU_SIM_BAUDRATE 115200
#define MCU_SIM_TX_PIN 26
#define MCU_SIM_RX_PIN 27
#define SIM_PWRKEY_PIN 25
// Cách đấu GPIO25 -> PWRKEY của module:
// 1 = qua transistor NPN/MOSFET: GPIO HIGH kéo PWRKEY xuống GND (mặc định)
// 0 = nối thẳng GPIO vào PWRKEY: chạy open-drain, LOW kéo PWRKEY xuống,
// thả ra để pull-up nội của module giữ mức cao (không đẩy 3.3V vào PWRKEY)
#define PWRKEY_VIA_TRANSISTOR 1
#if PWRKEY_VIA_TRANSISTOR
#define PWRKEY_PINMODE OUTPUT
#define PWRKEY_ACTIVE HIGH
#define PWRKEY_IDLE LOW
#else
#define PWRKEY_PINMODE OUTPUT_OPEN_DRAIN
#define PWRKEY_ACTIVE LOW
#define PWRKEY_IDLE HIGH // open-drain: HIGH = thả nổi
#endif
// Thời gian tham khảo theo Hardware Design SIM7600 - kiểm tra lại với đúng model đang dùng
#define PWRKEY_ON_PULSE_MS 500 // bật: kéo PWRKEY xuống >= 100 ms (điển hình 500 ms)
#define PWRKEY_OFF_PULSE_MS 3000 // tắt: kéo PWRKEY xuống >= 2.5 s
#define SIM_BOOT_TIMEOUT_MS 25000 // chờ module phản hồi AT sau khi bật
#define SIM_SHUTDOWN_TIMEOUT_MS 30000 // chờ module ngừng phản hồi sau xung tắt
#define SIM_OFF_SETTLE_MS 5000 // nghỉ sau khi tắt, trước khi bật lại
#define SIM_FORCED_OFF_WAIT_MS 15000 // chờ sau khi ép tắt module bị treo (không đo được trạng thái)
#define SIM_CPIN_TIMEOUT_MS 15000 // chờ thẻ SIM sẵn sàng
#define SIM_NET_TIMEOUT_MS 60000 // chờ đăng ký mạng
#define SIM_CALL_DURATION_MS 20000 // thời gian giữ cuộc gọi test
// ============================ MẠNG ============================
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
const char *ssid = "iMaker Viet Nam";
const char *password = "imaker12345";
// ============================ MODBUS ============================
ModbusMaster node;
uint16_t startAddress = 0;
uint8_t quantity = 1;
// ============================ TRẠNG THÁI ============================
bool led1State = HIGH;
bool wifiConnected = false;
bool ethConnected = false;
unsigned long lastWifiBlink = 0, lastEthBlink = 0;
bool wifiLedState = HIGH, ethLedState = HIGH;
// Nút nhấn: chống dội + nhấn giữ
#define DEBOUNCE_MS 30
#define LONG_PRESS_MS 3000
bool buttonStable = HIGH;
bool buttonReading = HIGH;
unsigned long buttonChangeTime = 0;
unsigned long buttonPressTime = 0;
bool buttonLongPressed = false;
// =====================================================================
// LED
// =====================================================================
void blinkAllLEDs()
{
for (int i = 0; i < 3; i++)
{
digitalWrite(LED1, LOW);
digitalWrite(LED2, LOW);
digitalWrite(LED3, LOW);
delay(250);
digitalWrite(LED1, HIGH);
digitalWrite(LED2, HIGH);
digitalWrite(LED3, HIGH);
delay(250);
}
}
// =====================================================================
// ĐIỀU KHIỂN PWRKEY
// =====================================================================
void pwrkeyInit()
{
pinMode(SIM_PWRKEY_PIN, PWRKEY_PINMODE);
digitalWrite(SIM_PWRKEY_PIN, PWRKEY_IDLE);
}
// Tạo một xung "nhấn phím nguồn" dài ms mili-giây
void pwrkeyPulse(uint32_t ms)
{
digitalWrite(SIM_PWRKEY_PIN, PWRKEY_ACTIVE);
delay(ms);
digitalWrite(SIM_PWRKEY_PIN, PWRKEY_IDLE);
}
// =====================================================================
// LỚP LỆNH AT
// =====================================================================
// Đọc bỏ dữ liệu cũ (URC, rác) và in ra để debug
void simFlushInput()
{
while (simSerial.available())
{
Serial.write(simSerial.read());
}
}
// Chờ chuỗi 'expect' xuất hiện trên UART SIM. Dừng sớm nếu gặp "ERROR".
bool simWaitFor(const char *expect, uint32_t timeoutMs, String *resp = nullptr)
{
String buf;
bool found = false;
unsigned long t0 = millis();
while (millis() - t0 < timeoutMs)
{
while (simSerial.available())
{
char c = simSerial.read();
buf += c;
Serial.write(c);
}
if (buf.indexOf(expect) >= 0)
{
found = true;
break;
}
if (buf.indexOf("ERROR") >= 0)
break;
delay(5);
}
if (resp)
*resp = buf;
return found;
}
// Gửi lệnh AT và chờ phản hồi mong đợi (mặc định "OK")
bool simAT(const String &cmd, const char *expect = "OK", uint32_t timeoutMs = 1000, String *resp = nullptr)
{
simFlushInput();
simSerial.println(cmd);
return simWaitFor(expect, timeoutMs, resp);
}
// Module có phản hồi lệnh AT không (thử vài lần)
bool simIsAlive(uint8_t tries = 3)
{
for (uint8_t i = 0; i < tries; i++)
{
if (simAT("AT", "OK", 300))
return true;
delay(100);
}
return false;
}
// Chờ module bắt đầu phản hồi AT (sau khi bật)
bool simWaitAlive(uint32_t timeoutMs)
{
unsigned long t0 = millis();
while (millis() - t0 < timeoutMs)
{
if (simAT("AT", "OK", 500))
return true;
delay(500);
}
return false;
}
// Chờ module ngừng phản hồi AT (sau khi tắt). 3 lần liên tiếp im lặng = đã tắt
bool simWaitDead(uint32_t timeoutMs)
{
uint8_t miss = 0;
unsigned long t0 = millis();
while (millis() - t0 < timeoutMs)
{
if (simAT("AT", "OK", 500))
miss = 0;
else if (++miss >= 3)
return true;
delay(500);
}
return false;
}
// =====================================================================
// BẬT / TẮT / RESET MODULE SIM
// =====================================================================
bool simPowerOn()
{
if (simIsAlive())
{
Serial.println("ℹ️ SIM đang bật sẵn");
return true;
}
Serial.println("🔌 Bật SIM: xung PWRKEY 500 ms");
pwrkeyPulse(PWRKEY_ON_PULSE_MS);
if (simWaitAlive(SIM_BOOT_TIMEOUT_MS))
{
Serial.println("\n✅ SIM đã khởi động");
return true;
}
Serial.println("❌ SIM không phản hồi sau khi bật");
return false;
}
bool simPowerOff()
{
if (!simIsAlive())
{
Serial.println("ℹ️ SIM không phản hồi, coi như đã tắt (nếu nghi treo thì dùng simRestart)");
return true;
}
Serial.println("⏻ Tắt SIM: giữ PWRKEY 3 s");
pwrkeyPulse(PWRKEY_OFF_PULSE_MS);
if (simWaitDead(SIM_SHUTDOWN_TIMEOUT_MS))
{
Serial.println("\n✅ SIM đã tắt");
return true;
}
// PWRKEY không có tác dụng -> thường do đặt sai PWRKEY_VIA_TRANSISTOR
Serial.println("⚠️ SIM chưa tắt sau xung PWRKEY (kiểm tra PWRKEY_VIA_TRANSISTOR), thử AT+CPOF");
simAT("AT+CPOF", "OK", 3000);
if (simWaitDead(SIM_SHUTDOWN_TIMEOUT_MS))
{
Serial.println("\n✅ SIM đã tắt bằng AT+CPOF");
return true;
}
Serial.println("❌ Không tắt được SIM");
return false;
}
// Reset module chỉ bằng PWRKEY:
// - Module đang chạy -> tắt hẳn (giữ 3 s), chờ, rồi bật lại
// - Module không phản hồi -> không biết đang tắt hay đang treo:
// thử bật (500 ms); nếu vẫn im -> coi như treo, ép tắt (3 s), chờ, bật lại
bool simRestart()
{
Serial.println("\n🔄 Reset module SIM qua PWRKEY");
if (simIsAlive())
{
if (!simPowerOff())
return false;
delay(SIM_OFF_SETTLE_MS);
}
else
{
Serial.println("SIM không phản hồi, thử bật");
pwrkeyPulse(PWRKEY_ON_PULSE_MS);
if (simWaitAlive(SIM_BOOT_TIMEOUT_MS))
{
Serial.println("\n✅ SIM đã khởi động");
return true;
}
Serial.println("⚠️ SIM vẫn im, có thể đang treo -> ép tắt bằng PWRKEY 3 s");
pwrkeyPulse(PWRKEY_OFF_PULSE_MS);
delay(SIM_FORCED_OFF_WAIT_MS);
}
// Thử bật 2 lần. Xung 500 ms không làm tắt module đang chạy nên lặp lại là an toàn.
for (uint8_t attempt = 1; attempt <= 2; attempt++)
{
Serial.printf("🔌 Bật lại SIM (lần %u): xung PWRKEY 500 ms\n", attempt);
pwrkeyPulse(PWRKEY_ON_PULSE_MS);
if (simWaitAlive(SIM_BOOT_TIMEOUT_MS))
{
Serial.println("\n✅ Reset SIM thành công");
return true;
}
}
Serial.println("❌ Reset SIM thất bại: kiểm tra nguồn VBAT, cách đấu PWRKEY, UART TX/RX");
return false;
}
// =====================================================================
// CẤU HÌNH, ĐĂNG KÝ MẠNG, GỌI, SMS
// =====================================================================
// Đọc trạng thái đăng ký mạng từ +CREG / +CEREG. Trả về -1 nếu lỗi
int simRegStat(const char *cmd, const char *tag)
{
String r;
if (!simAT(cmd, "OK", 1000, &r))
return -1;
int p = r.indexOf(tag);
if (p < 0)
return -1;
p = r.indexOf(',', p);
if (p < 0)
return -1;
return r.substring(p + 1).toInt();
}
// Cấu hình cơ bản + chờ thẻ SIM và đăng ký mạng
bool simSetup()
{
simAT("ATE0"); // tắt echo
simAT("AT+CMEE=2"); // báo lỗi dạng chữ
simAT("ATI");
// Chờ thẻ SIM sẵn sàng
bool cardReady = false;
unsigned long t0 = millis();
while (millis() - t0 < SIM_CPIN_TIMEOUT_MS)
{
String r;
if (simAT("AT+CPIN?", "OK", 1000, &r) && r.indexOf("READY") >= 0)
{
cardReady = true;
break;
}
delay(1000);
}
if (!cardReady)
{
Serial.println("❌ Thẻ SIM chưa sẵn sàng (kiểm tra thẻ, khay SIM, mã PIN)");
return false;
}
simAT("AT+CIMI");
// Chờ đăng ký mạng: stat 1 = mạng nhà, 5 = roaming
t0 = millis();
while (millis() - t0 < SIM_NET_TIMEOUT_MS)
{
simAT("AT+CSQ");
int cs = simRegStat("AT+CREG?", "+CREG:"); // 2G/3G
int eps = simRegStat("AT+CEREG?", "+CEREG:"); // 4G
if (cs == 1 || cs == 5 || eps == 1 || eps == 5)
{
Serial.printf("✅ Đã đăng ký mạng (CREG=%d, CEREG=%d)\n", cs, eps);
return true;
}
delay(2000);
}
Serial.println("❌ Không đăng ký được mạng");
return false;
}
bool simSendSMS(const char *phone, const char *text)
{
if (!simAT("AT+CMGF=1"))
return false;
if (!simAT(String("AT+CMGS=\"") + phone + "\"", ">", 5000))
{
Serial.println("❌ Không nhận được dấu nhắc '>'");
simSerial.write(0x1B); // ESC: hủy soạn tin
return false;
}
simSerial.print(text);
simSerial.write(0x1A); // Ctrl+Z: gửi
if (simWaitFor("+CMGS:", 60000))
{
Serial.println("\n✅ Đã gửi SMS");
return true;
}
Serial.println("\n❌ Gửi SMS thất bại");
return false;
}
bool simCall(const char *phone, uint32_t durationMs)
{
if (!simAT(String("ATD") + phone + ";", "OK", 10000))
{
Serial.println("❌ Không thực hiện được cuộc gọi");
return false;
}
Serial.println("📞 Đang gọi...");
// Giữ cuộc gọi, kết thúc sớm nếu bên kia từ chối / bận / không nghe
String buf;
unsigned long t0 = millis();
while (millis() - t0 < durationMs)
{
while (simSerial.available())
{
char c = simSerial.read();
buf += c;
Serial.write(c);
}
if (buf.indexOf("NO CARRIER") >= 0 || buf.indexOf("BUSY") >= 0 || buf.indexOf("NO ANSWER") >= 0)
break;
delay(10);
}
simAT("ATH", "OK", 5000);
Serial.println("📴 Kết thúc cuộc gọi");
return true;
}
void runSimTest()
{
digitalWrite(LED3, LOW); // sáng LED3 trong lúc test
Serial.println("\n========== TEST SIM ==========");
if (simRestart() && simSetup())
{
simCall(PHONE_NUMBER, SIM_CALL_DURATION_MS);
// simSendSMS(PHONE_NUMBER, "ESP32-SIM7600X");
}
else
{
Serial.println("❌ TEST SIM thất bại");
}
Serial.println("========== HẾT TEST SIM ==========\n");
digitalWrite(LED3, HIGH);
}
// =====================================================================
// SD CARD / RTC
// =====================================================================
bool checkSDCard()
{
if (SD.begin(SD_CS))
{
Serial.println("✅ SD Card detected");
digitalWrite(LED2, LOW);
return true;
}
Serial.println("❌ No SD Card");
digitalWrite(LED2, HIGH);
return false;
}
bool checkRTC()
{
if (!rtc.begin())
{
Serial.println("❌ RTC not found");
led1State = HIGH;
digitalWrite(LED1, led1State);
return false;
}
Serial.println("✅ RTC detected");
led1State = LOW;
digitalWrite(LED1, led1State);
return true;
}
// =====================================================================
// NÚT NHẤN
// =====================================================================
void handleButton()
{
bool reading = digitalRead(BUTTON);
if (reading != buttonReading)
{
buttonReading = reading;
buttonChangeTime = millis();
}
if (millis() - buttonChangeTime >= DEBOUNCE_MS && buttonStable != buttonReading)
{
buttonStable = buttonReading;
if (buttonStable == LOW) // vừa nhấn
{
led1State = !led1State;
digitalWrite(LED1, led1State);
buttonPressTime = millis();
}
else // vừa thả -> cho phép nhấn giữ lần sau
{
buttonLongPressed = false;
}
}
if (buttonStable == LOW && !buttonLongPressed && millis() - buttonPressTime >= LONG_PRESS_MS)
{
buttonLongPressed = true;
runSimTest();
}
}
// =====================================================================
// SETUP
// =====================================================================
void setup()
{
// Đưa PWRKEY về trạng thái nghỉ ngay đầu tiên để không "nhấn" nhầm phím nguồn SIM
pwrkeyInit();
Serial.begin(115200);
simSerial.begin(MCU_SIM_BAUDRATE, SERIAL_8N1, MCU_SIM_RX_PIN, MCU_SIM_TX_PIN);
pinMode(LED1, OUTPUT);
digitalWrite(LED1, HIGH);
pinMode(LED2, OUTPUT);
digitalWrite(LED2, HIGH);
pinMode(LED3, OUTPUT);
digitalWrite(LED3, HIGH);
pinMode(BUTTON, INPUT_PULLUP);
blinkAllLEDs();
// Ethernet
Ethernet.init(ETH_CS_PIN);
if (Ethernet.begin(mac) == 0)
{
Serial.println("❌ Ethernet DHCP failed");
ethConnected = false;
}
else
{
Serial.print("✅ Ethernet IP: ");
Serial.println(Ethernet.localIP());
ethConnected = true;
}
// WiFi
WiFi.begin(ssid, password);
Serial.println("🔄 Connecting WiFi...");
// Modbus RTU trên UART2
Serial2.begin(9600, SERIAL_8N1, RXD2, TXD2);
node.begin(1, Serial2);
Wire.begin(SDA, SCL);
checkSDCard();
checkRTC();
delay(20);
Serial.println("\n\n\n\n-----------------------\nSystem started!!!!");
}
// =====================================================================
// LOOP
// =====================================================================
void loop()
{
handleButton();
// WiFi
if (!wifiConnected && WiFi.status() == WL_CONNECTED)
{
Serial.print("✅ WiFi Connected, IP: ");
Serial.println(WiFi.localIP());
wifiConnected = true;
}
// LED2 nhấp nháy khi có WiFi
if (wifiConnected && millis() - lastWifiBlink > 500)
{
wifiLedState = !wifiLedState;
digitalWrite(LED2, wifiLedState);
lastWifiBlink = millis();
}
// LED3 nhấp nháy khi có Ethernet
if (ethConnected && millis() - lastEthBlink > 500)
{
ethLedState = !ethLedState;
digitalWrite(LED3, ethLedState);
lastEthBlink = millis();
}
// Đọc Modbus mỗi 500 ms
static unsigned long lastModbusRead = 0;
if (millis() - lastModbusRead >= 500)
{
lastModbusRead = millis();
uint8_t result = node.readHoldingRegisters(startAddress, quantity);
if (result == node.ku8MBSuccess)
{
Serial.print("Register 0: ");
Serial.println(node.getResponseBuffer(0));
}
else
{
Serial.print("Modbus read failed, error code: ");
Serial.println(result);
}
}
}