page issue

AlphaNodesDev · AlphaNodesDev · commit 3d309d441083 · 2025-08-29T19:57:23.000+05:30
diff --git a/SciFyIoT.cpp b/SciFyIoT.cpp
@@ -0,0 +1,299 @@
+#include "SciFyIoT.h"
+
+// Static instance pointer for callback wrapper
+SciFyIoT* SciFyIoT::instance = nullptr;
+
+// Constructor
+SciFyIoT::SciFyIoT() {
+    authenticated = false;
+    lastHeartbeat = 0;
+    lastActivity = 0;
+    _commandCallback = nullptr;
+    _statusCallback = nullptr;
+    _serverUrl = "api.scify-tech.com";
+    _serverPort = 443;
+    _serverPath = "/ws";
+    
+    // Set static instance for callback wrapper
+    instance = this;
+}
+
+// Initialize with default server
+void SciFyIoT::begin(const char* ssid, const char* password, const char* apiKey, const char* secret) {
+    begin(ssid, password, apiKey, secret, "api.scify-tech.com", 443, "/ws");
+}
+
+// Initialize with custom server
+void SciFyIoT::begin(const char* ssid, const char* password, const char* apiKey, const char* secret, 
+                     const char* serverUrl, int serverPort, const char* serverPath) {
+    Serial.begin(115200);
+    delay(1000);
+    
+    Serial.println("[SciFyIoT] Starting...");
+    
+    _ssid = ssid;
+    _password = password;
+    _apiKey = apiKey;
+    _secret = secret;
+    _serverUrl = serverUrl;
+    _serverPort = serverPort;
+    _serverPath = serverPath;
+    
+    pinMode(LED_BUILTIN, OUTPUT);
+    digitalWrite(LED_BUILTIN, HIGH);
+    
+    // Connect to WiFi
+    connectWiFi();
+    
+    if (WiFi.status() == WL_CONNECTED) {
+        webSocket.beginSSL(_serverUrl.c_str(), _serverPort, _serverPath.c_str());
+        webSocket.onEvent(webSocketEventWrapper);
+        webSocket.setReconnectInterval(5000);
+        webSocket.enableHeartbeat(15000, 3000, 2);
+        lastActivity = millis();
+        Serial.println("[SciFyIoT] Initialized successfully!");
+    } else {
+        Serial.println("[SciFyIoT] WiFi connection failed");
+    }
+}
+
+// Main loop processing
+void SciFyIoT::loop() {
+    webSocket.loop();
+    
+    if (WiFi.status() != WL_CONNECTED) {
+        connectWiFi();
+    }
+    
+    if (authenticated && millis() - lastHeartbeat > heartbeatInterval) {
+        sendHeartbeat();
+        lastHeartbeat = millis();
+    }
+    
+    checkConnection();
+    delay(50);
+}
+
+// Status methods
+bool SciFyIoT::isConnected() {
+    return webSocket.isConnected();
+}
+
+bool SciFyIoT::isAuthenticated() {
+    return authenticated;
+}
+
+bool SciFyIoT::isWiFiConnected() {
+    return WiFi.status() == WL_CONNECTED;
+}
+
+// Connect to WiFi
+void SciFyIoT::connectWiFi() {
+    WiFi.begin(_ssid.c_str(), _password.c_str());
+    
+    int attempts = 0;
+    while (WiFi.status() != WL_CONNECTED && attempts < 30) {
+        delay(500);
+        attempts++;
+    }
+    
+    if (WiFi.status() == WL_CONNECTED) {
+        Serial.println("[WiFi] Connected");
+    } else {
+        Serial.println("[WiFi] Connection failed");
+    }
+}
+
+// Static callback wrapper
+void SciFyIoT::webSocketEventWrapper(WStype_t type, uint8_t * payload, size_t length) {
+    if (instance) {
+        instance->webSocketEvent(type, payload, length);
+    }
+}
+
+// WebSocket event handler
+void SciFyIoT::webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
+    lastActivity = millis();
+    
+    switch (type) {
+        case WStype_DISCONNECTED:
+            authenticated = false;
+            digitalWrite(LED_BUILTIN, HIGH);
+            if (_statusCallback) _statusCallback(false, false);
+            break;
+            
+        case WStype_CONNECTED:
+            authenticated = false;
+            authenticateDevice();
+            if (_statusCallback) _statusCallback(true, false);
+            break;
+            
+        case WStype_TEXT:
+            handleWebSocketMessage((char*)payload);
+            break;
+            
+        case WStype_ERROR:
+            Serial.printf("[WS] Error: %s\n", payload);
+            break;
+    }
+}
+
+// Authenticate with server
+void SciFyIoT::authenticateDevice() {
+    DynamicJsonDocument doc(256);
+    doc["type"] = "auth";
+    doc["apiKey"] = _apiKey;
+    doc["secret"] = _secret;
+    
+    String message;
+    serializeJson(doc, message);
+    webSocket.sendTXT(message);
+}
+
+// Handle incoming WebSocket messages
+void SciFyIoT::handleWebSocketMessage(const char* message) {
+    DynamicJsonDocument doc(512);
+    DeserializationError error = deserializeJson(doc, message);
+    
+    if (error) return;
+    
+    String type = doc["type"];
+    
+    if (type == "auth_success") {
+        authenticated = true;
+        digitalWrite(LED_BUILTIN, LOW);
+        lastHeartbeat = millis();
+        if (_statusCallback) _statusCallback(true, true);
+    }
+    else if (type == "auth_error") {
+        authenticated = false;
+        digitalWrite(LED_BUILTIN, HIGH);
+        if (_statusCallback) _statusCallback(true, false);
+    }
+    else if (type == "command" && authenticated) {
+        String commandId = doc["id"];
+        String payload = doc["payload"];
+        
+        bool handled = executeDefaultCommand(payload);
+        
+        if (!handled && _commandCallback) {
+            _commandCallback(payload, commandId);
+        } else if (handled) {
+            sendAck(commandId, "executed");
+        } else {
+            sendAck(commandId, "failed");
+        }
+    }
+}
+
+// Execute default commands
+bool SciFyIoT::executeDefaultCommand(const String& command) {
+    if (command == "LED_ON") {
+        digitalWrite(LED_BUILTIN, LOW);
+        return true;
+    }
+    else if (command == "LED_OFF") {
+        digitalWrite(LED_BUILTIN, HIGH);
+        return true;
+    }
+    else if (command == "STATUS") {
+        sendSensorData();
+        return true;
+    }
+    else if (command == "RESTART") {
+        ESP.restart();
+        return true;
+    }
+    
+    return false;
+}
+
+// Send acknowledgement
+void SciFyIoT::sendAck(const String& commandId, const String& status) {
+    DynamicJsonDocument doc(256);
+    doc["type"] = "ack";
+    doc["commandId"] = commandId;
+    doc["status"] = status;
+    doc["timestamp"] = millis();
+    
+    String message;
+    serializeJson(doc, message);
+    webSocket.sendTXT(message);
+}
+
+// Send heartbeat
+void SciFyIoT::sendHeartbeat() {
+    if (!authenticated) return;
+    
+    DynamicJsonDocument doc(128);
+    doc["type"] = "heartbeat";
+    doc["timestamp"] = millis();
+    
+    String message;
+    serializeJson(doc, message);
+    webSocket.sendTXT(message);
+}
+
+// Send sensor data
+void SciFyIoT::sendSensorData(float temperature, float humidity) {
+    DynamicJsonDocument doc(256);
+    doc["type"] = "sensor_data";
+    doc["payload"]["temperature"] = temperature;
+    doc["payload"]["humidity"] = humidity;
+    doc["payload"]["uptime"] = millis();
+    doc["payload"]["free_heap"] = ESP.getFreeHeap();
+    doc["payload"]["wifi_rssi"] = WiFi.RSSI();
+    doc["timestamp"] = millis();
+    
+    String message;
+    serializeJson(doc, message);
+    webSocket.sendTXT(message);
+}
+
+// Send custom data
+void SciFyIoT::sendCustomData(const String& dataType, JsonObject& data) {
+    DynamicJsonDocument doc(512);
+    doc["type"] = dataType;
+    doc["payload"] = data;
+    doc["timestamp"] = millis();
+    
+    String message;
+    serializeJson(doc, message);
+    webSocket.sendTXT(message);
+}
+
+// Send response
+void SciFyIoT::sendResponse(const String& commandId, const String& status, const String& data) {
+    sendAck(commandId, status);
+}
+
+// Check connection health
+void SciFyIoT::checkConnection() {
+    if (millis() - lastActivity > connectionTimeout) {
+        webSocket.disconnect();
+        authenticated = false;
+        lastActivity = millis();
+    }
+}
+
+// Set command callback
+void SciFyIoT::onCommandReceived(CommandCallback callback) {
+    _commandCallback = callback;
+}
+
+// Set status callback
+void SciFyIoT::onStatusChanged(StatusCallback callback) {
+    _statusCallback = callback;
+}
+
+// Restart device
+void SciFyIoT::restart() {
+    ESP.restart();
+}
+
+// Enable/disable built-in LED
+void SciFyIoT::enableBuiltinLED(bool enable) {
+    if (enable) {
+        pinMode(LED_BUILTIN, OUTPUT);
+    }
+}
diff --git a/SciFyIoT.h b/SciFyIoT.h
@@ -0,0 +1,88 @@
+#ifndef SCIFYIOT_H
+#define SCIFYIOT_H
+
+#if defined(ESP8266)
+  #include <ESP8266WiFi.h>
+#elif defined(ESP32)
+  #include <WiFi.h>
+#else
+  #error "Unsupported board. Use ESP8266 or ESP32."
+#endif
+
+#include <WebSocketsClient.h>
+#include <ArduinoJson.h>
+
+// Callback function types
+typedef void (*CommandCallback)(const String& command, const String& commandId);
+typedef void (*StatusCallback)(bool connected, bool authenticated);
+
+class SciFyIoT {
+private:
+    WebSocketsClient webSocket;
+    
+    // Configuration
+    String _ssid;
+    String _password;
+    String _apiKey;
+    String _secret;
+    String _serverUrl;
+    int _serverPort;
+    String _serverPath;
+    
+    // State variables
+    bool authenticated;
+    unsigned long lastHeartbeat;
+    unsigned long lastActivity;
+    static const unsigned long heartbeatInterval = 25000;
+    static const unsigned long connectionTimeout = 60000;
+    
+    // Callbacks
+    CommandCallback _commandCallback;
+    StatusCallback _statusCallback;
+    
+    // Private methods
+    void webSocketEvent(WStype_t type, uint8_t * payload, size_t length);
+    void authenticateDevice();
+    void handleWebSocketMessage(const char* message);
+    bool executeDefaultCommand(const String& command);
+    void sendAck(const String& commandId, const String& status);
+    void sendHeartbeat();
+    void checkConnection();
+    void connectWiFi();
+    
+    // Static callback wrapper for WebSocket events
+    static SciFyIoT* instance;
+    static void webSocketEventWrapper(WStype_t type, uint8_t * payload, size_t length);
+
+public:
+    // Constructor
+    SciFyIoT();
+    
+    // Initialization
+    void begin(const char* ssid, const char* password, const char* apiKey, const char* secret);
+    void begin(const char* ssid, const char* password, const char* apiKey, const char* secret, 
+               const char* serverUrl, int serverPort = 443, const char* serverPath = "/ws");
+    
+    // Main loop - call this in Arduino loop()
+    void loop();
+    
+    // Status methods
+    bool isConnected();
+    bool isAuthenticated();
+    bool isWiFiConnected();
+    
+    // Communication methods
+    void sendSensorData(float temperature = 25.5, float humidity = 60.0);
+    void sendCustomData(const String& dataType, JsonObject& data);
+    void sendResponse(const String& commandId, const String& status, const String& data = "");
+    
+    // Callback setters
+    void onCommandReceived(CommandCallback callback);
+    void onStatusChanged(StatusCallback callback);
+    
+    // Utility methods
+    void restart();
+    void enableBuiltinLED(bool enable = true);
+};
+
+#endif
diff --git a/src/SciFyIot.h b/src/SciFyIot.h
