Code kiểm tra phần cứng của  ZenoRTU0106

Code kiểm tra phần cứng của ZenoRTU0106
// =====================================================================
//  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);
    }
  }
}

Để lại một bình luận

Email của bạn sẽ không được hiển thị công khai. Các trường bắt buộc được đánh dấu *