ESP32 Telegram Motion Notifications

#include <Arduino.h>
// Keep Arduino IDE Core Debug Level set to None; redact credentials from all logs.
#include <WiFi.h>
#include <NetworkClientSecure.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <time.h>
#include <string.h>

const char* WIFI_SSID = "REPLACE_WIFI_SSID";
const char* WIFI_PASSWORD = "REPLACE_WIFI_PASSWORD";
const char* BOT_TOKEN = "REPLACE_BOT_TOKEN";
const char* CHAT_ID = "REPLACE_PRIVATE_CHAT_ID";
constexpr uint8_t PIR_PIN = 27;
constexpr uint32_t WARMUP_MS = 60000, LOW_REARM_MS = 2000;
constexpr uint32_t COOLDOWN_MS = 60000, EVENT_MAX_AGE_MS = 30000;
constexpr uint32_t WIFI_TRY_MS = 15000, WIFI_PAUSE_MS = 30000;

// Public Go Daddy Root Certificate Authority - G2, not a private key.
// Reviewed CA source: https://certs.godaddy.com/repository/gdroot-g2.crt
// Confirm the service trust chain when maintaining this example; never use setInsecure().
const char ROOT_CA[] PROGMEM = R"CERT(
-----BEGIN CERTIFICATE-----
MIIDxTCCAq2gAwIBAgIBADANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCVVMx
EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxGjAYBgNVBAoT
EUdvRGFkZHkuY29tLCBJbmMuMTEwLwYDVQQDEyhHbyBEYWRkeSBSb290IENlcnRp
ZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAwMFoXDTM3MTIzMTIz
NTk1OVowgYMxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQH
EwpTY290dHNkYWxlMRowGAYDVQQKExFHb0RhZGR5LmNvbSwgSW5jLjExMC8GA1UE
AxMoR28gRGFkZHkgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIw
DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL9xYgjx+lk09xvJGKP3gElY6SKD
E6bFIEMBO4Tx5oVJnyfq9oQbTqC023CYxzIBsQU+B07u9PpPL1kwIuerGVZr4oAH
/PMWdYA5UXvl+TW2dE6pjYIT5LY/qQOD+qK+ihVqf94Lw7YZFAXK6sOoBJQ7Rnwy
DfMAZiLIjWltNowRGLfTshxgtDj6AozO091GB94KPutdfMh8+7ArU6SSYmlRJQVh
GkSBjCypQ5Yj36w6gZoOKcUcqeldHraenjAKOc7xiID7S13MMuyFYkMlNAJWJwGR
tDtwKj9useiciAF9n9T521NtYJ2/LOdYq7hfRvzOxBsDPAnrSTFcaUaz4EcCAwEA
AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYE
FDqahQcQZyi27/a9BUFuIMGU2g/eMA0GCSqGSIb3DQEBCwUAA4IBAQCZ21151fmX
WWcDYfF+OwYxdS2hII5PZYe096acvNjpL9DbWu7PdIxztDhC2gV7+AJ1uP2lsdeu
9tfeE8tTEH6KRtGX+rcuKxGrkLAngPnon1rpN5+r5N9ss4UXnT3ZJE95kTXWXwTr
gIOrmgIttRD02JDHBHNA7XIloKmf7J6raBKZV8aPEjoJpL1E/QYVN8Gb5DKj7Tjo
2GTzLH4U/ALqn83/B2gX2yKQOC16jdFU8WnjXzPKej17CuPKf1855eJ1usV2GDPO
LPAvTK33sefOT6jEm0pUBsV/fdUID+Ic/n4XuKxe9tQWskMJDE32p2u0mYRlynqI
4uJEvlz36hz1
-----END CERTIFICATE-----
)CERT";

bool warmed = false;
bool configured = false, wifiTrying = false, wasConnected = false;
bool rawHigh = false, stableHigh = false, readyForEdge = false, pending = false;
bool attempted = false, rateLimited = false, lowTiming = false;
uint32_t wifiSince=0, wifiEnded=0, changedAt=0, lowSince=0, eventAt=0, lastAttempt=0;

bool credentialsReady() {
  if (strstr(WIFI_SSID,"REPLACE_") || strstr(WIFI_PASSWORD,"REPLACE_") ||
      strstr(BOT_TOKEN,"REPLACE_") || !strchr(BOT_TOKEN,':')) return false;
  size_t n = strlen(CHAT_ID);
  if (!n || n > 20) return false;
  for (size_t i=0;i<n;++i) if (CHAT_ID[i]<'0' || CHAT_ID[i]>'9') return false;
  return true; // Private-chat numeric ID only; no group/channel support in this example.
}
void startWiFi(uint32_t now) {
  WiFi.begin(WIFI_SSID,WIFI_PASSWORD);wifiTrying=true;wifiSince=now;
  Serial.println("Starting bounded Wi-Fi attempt (credentials hidden)");
}
void serviceWiFi(uint32_t now) {
  if (!configured) return;
  if (WiFi.status()==WL_CONNECTED) {
    if (!wasConnected) {
      wasConnected=true;wifiTrying=false;
      configTime(0,0,"pool.ntp.org","time.nist.gov");
      Serial.println("Wi-Fi connected; TLS waits for plausible network time");
    }
    return;
  }
  if (wasConnected) { wasConnected=false;wifiTrying=false;wifiEnded=now; }
  if (wifiTrying && now-wifiSince>=WIFI_TRY_MS) {
    WiFi.disconnect();wifiTrying=false;wifiEnded=now;
    Serial.println("Wi-Fi attempt ended; wait 30 s before next attempt");
  } else if (!wifiTrying && now-wifiEnded>=WIFI_PAUSE_MS) startWiFi(now);
}
void servicePIR(uint32_t now) {
  bool high = digitalRead(PIR_PIN)==HIGH;
  if (high!=rawHigh) { rawHigh=high;changedAt=now; }
  if (now-changedAt>=30) stableHigh=rawHigh;
  if (!warmed) {
    if (now>=WARMUP_MS) warmed=true;
    else { readyForEdge=false;lowTiming=false;return; }
  }
  if (!stableHigh) {
    if (!lowTiming) { lowTiming=true;lowSince=now; }
    if (now-lowSince>=LOW_REARM_MS) readyForEdge=true;
  } else {
    lowTiming=false;
    if (readyForEdge) {
      readyForEdge=false;
      if (pending) Serial.println("Additional edge coalesced; one event already pending");
      else { pending=true;eventAt=now;Serial.println("Motion-input event queued (not proof of a person)"); }
    }
  }
}
bool sendAlert(uint32_t eventUptime) {
  NetworkClientSecure tls; tls.setCACert(ROOT_CA);
  tls.setHandshakeTimeout(8);tls.setTimeout(5000);
  HTTPClient http;http.useHTTP10(true);http.setReuse(false);
  http.setConnectTimeout(5000);http.setTimeout(5000);
  String url=String("https://api.telegram.org/bot")+BOT_TOKEN+"/sendMessage";
  if (!http.begin(tls,url)) return false; // Never print URL/token/response body.
  StaticJsonDocument<384> outgoing;
  outgoing["chat_id"]=CHAT_ID;
  outgoing["text"]=String("Educational PIR input event. Board uptime at detection: ")+String(eventUptime/1000)+" s. Not a verified security alarm.";
  String body;serializeJson(outgoing,body);
  http.addHeader("Content-Type","application/json");
  int code=http.POST(body);
  StaticJsonDocument<128> filter;filter["ok"]=true;
  StaticJsonDocument<128> answer;
  bool accepted=false;
  if (code==200) {
    auto error=deserializeJson(answer,http.getStream(),DeserializationOption::Filter(filter),DeserializationOption::NestingLimit(12));
    accepted=!error && answer["ok"].is<bool>() && answer["ok"].as<bool>();
  }
  if (code==429) { rateLimited=true;Serial.println("HTTP 429: sending paused until reset; inspect Telegram rate limits before restarting"); }
  Serial.printf("Telegram HTTP status: %d; API accepted: %s\n",code,accepted?"yes":"no/unknown");
  http.end();tls.stop();return accepted;
}
void setup() {
  Serial.begin(115200);pinMode(PIR_PIN,INPUT_PULLDOWN);
  configured=credentialsReady();
  WiFi.mode(WIFI_STA);WiFi.setAutoReconnect(false);
  Serial.println("PIR warm-up: 60 s, then require LOW for 2 s. Network calls can miss short input pulses.");
  if (configured) startWiFi(millis());
  else Serial.println("Replace credentials and positive private chat ID; no cloud requests while placeholders remain");
}
void loop() {
  uint32_t now=millis();servicePIR(now);serviceWiFi(now);
  if (pending && now-eventAt>EVENT_MAX_AGE_MS) { pending=false;Serial.println("Queued event expired after 30 s; no replay"); }
  bool cooldownOver=!attempted || now-lastAttempt>=COOLDOWN_MS;
  bool timeReady=time(nullptr)>1700000000; // Plausibility gate, not proof of clock accuracy.
  if (pending && configured && !rateLimited && WiFi.status()==WL_CONNECTED && timeReady && cooldownOver) {
    uint32_t captured=eventAt;pending=false;attempted=true;lastAttempt=now;
    bool accepted=sendAlert(captured); // Synchronous, bounded per-operation timeouts; not a hard total deadline.
    Serial.println(accepted?"API acceptance is not proof of delivery/read":"Outcome failed/unknown; no automatic resend of this event");
  }
  delay(5);
}