Skip to content

Examples

Jump to bottom
cziter15 edited this page Feb 14, 2026 · 1 revision

Examples

Practical examples demonstrating ksIotFrameworkLib features and patterns.

📖 Overview

This section provides complete, working examples that you can use as starting points for your own projects.

Example Categories:

  • 📘 Basic — Simple getting-started examples
  • 🌐 IoT — Full WiFi + MQTT applications
  • 🎛️ Advanced — Complex real-world scenarios
  • 🔧 Utilities — Helper components and patterns

📘 Basic Examples

Example 1: LED Blink

Simple LED blink pattern using the framework.

Files:

  • examples/led-blink/src/main.cpp

Code:

#include <ksf/ksAppRotator.h>
#include <ksf/comp/ksLed.h>

class BlinkApp : public ksf::ksApplication
{
private:
    std::shared_ptr<ksf::comps::ksLed> led;
    std::shared_ptr<ksf::ksSimpleTimer> timer;
    
protected:
    bool init() override {
        // Add LED component
        addComponent<ksf::comps::ksLed>(LED_BUILTIN);
        
        // Add timer for 500ms
        addComponent<ksf::ksSimpleTimer>(500);
        
        return true;
    }
    
    bool postInit() override {
        // Get component references
        led = findComponent<ksf::comps::ksLed>();
        timer = findComponent<ksf::ksSimpleTimer>();
        
        return led && timer;
    }
    
    bool loop() override {
        if (timer->elapsed()) {
            led->toggle();
            timer->reset();
        }
        return true;
    }
};

KSF_IMPLEMENT_APP_ROTATOR(BlinkApp)

What It Shows:

  • Creating a custom application
  • Adding components
  • Getting component references
  • Using timers for non-blocking delays

🌐 IoT Examples

Example 2: MQTT-Controlled LED

Full IoT application with WiFi, MQTT, and web portal.

Files:

  • examples/mqtt-led/

Features:

  • WiFi connection management
  • MQTT connectivity
  • Device portal for configuration
  • LED control via MQTT
  • Status reporting

Application Structure:

#include <ksf/ksAppRotator.h>
#include <ksf/comp/ksWifiConnector.h>
#include <ksf/comp/ksMqttConnector.h>
#include <ksf/comp/ksDevicePortal.h>
#include <ksf/comp/ksLed.h>
#include <ksf/comp/ksDevStatMqttReporter.h>

class MqttLedApp : public ksf::ksApplication
{
protected:
    bool init() override {
        // Check if configured
        if (!hasWiFiConfig() || !hasMqttConfig()) {
            return false;  // Go to config app
        }
        
        // Network components
        addComponent<ksf::comps::ksWifiConnector>("MqttLed");
        addComponent<ksf::comps::ksMqttConnector>();
        
        // Device management
        addComponent<ksf::comps::ksDevicePortal>();
        addComponent<ksf::comps::ksDevStatMqttReporter>();
        
        // LED control
        addComponent<ksf::comps::ksLed>(LED_BUILTIN);
        
        return true;
    }
    
    bool postInit() override {
        auto mqtt = findComponent<ksf::comps::ksMqttConnector>();
        auto led = findComponent<ksf::comps::ksLed>();
        
        if (!mqtt || !led) return false;
        
        // Subscribe to LED control topic
        mqtt->onMessage([led](const char* topic, const char* payload) {
            if (strcmp(topic, "led/set") == 0) {
                if (strcmp(payload, "ON") == 0) {
                    led->on();
                }
                else if (strcmp(payload, "OFF") == 0) {
                    led->off();
                }
                else if (strcmp(payload, "BLINK") == 0) {
                    led->pattern(0b10101010);
                }
            }
        });
        
        return true;
    }
};

class ConfigApp : public ksf::ksApplication
{
protected:
    bool init() override {
        // Configuration mode components
        addComponent<ksf::comps::ksWifiConfigurator>();
        addComponent<ksf::comps::ksDevicePortal>();
        addComponent<ksf::comps::ksLed>(LED_BUILTIN);
        return true;
    }
    
    bool postInit() override {
        auto led = findComponent<ksf::comps::ksLed>();
        if (led) {
            led->pattern(0b10101010);  // Fast blink in config mode
        }
        return true;
    }
};

KSF_IMPLEMENT_APP_ROTATOR(
    MqttLedApp,
    ConfigApp
)

Usage:

# Control LED via MQTT
mosquitto_pub -h broker -t "led/set" -m "ON"
mosquitto_pub -h broker -t "led/set" -m "OFF"
mosquitto_pub -h broker -t "led/set" -m "BLINK"

What It Shows:

  • Two-application rotation pattern
  • WiFi and MQTT setup
  • MQTT message handling
  • Configuration application
  • Device portal integration

Example 3: Temperature Sensor

IoT sensor with WiFi, MQTT, and DHT temperature sensor.

Files:

  • examples/temp-sensor/

Hardware Required:

  • ESP32/ESP8266
  • DHT22 temperature sensor

Application:

#include <ksf/ksAppRotator.h>
#include <ksf/comp/ksWifiConnector.h>
#include <ksf/comp/ksMqttConnector.h>
#include <DHT.h>

class TempSensorApp : public ksf::ksApplication
{
private:
    DHT dht;
    
protected:
    bool init() override {
        // Initialize sensor
        dht = DHT(DHT_PIN, DHT22);
        dht.begin();
        
        // Add network components
        addComponent<ksf::comps::ksWifiConnector>("TempSensor");
        addComponent<ksf::comps::ksMqttConnector>();
        addComponent<ksf::comps::ksDevStatMqttReporter>();
        
        return true;
    }
    
    bool loop() override {
        // Read every 5 seconds
        static unsigned long lastRead = 0;
        const unsigned long interval = 5000;
        
        if (millis() - lastRead >= interval) {
            float temp = dht.readTemperature();
            float humidity = dht.readHumidity();
            
            // Publish via MQTT
            auto mqtt = findComponent<ksf::comps::ksMqttConnector>();
            if (mqtt && mqtt->isConnected()) {
                mqtt->publish("sensor/temperature", String(temp));
                mqtt->publish("sensor/humidity", String(humidity));
            }
            
            lastRead = millis();
        }
        
        return true;
    }
    
public:
    TempSensorApp() : dht(DHT_PIN, DHT22) {}
};

KSF_IMPLEMENT_APP_ROTATOR(TempSensorApp)

What It Shows:

  • Reading sensors periodically
  • Publishing telemetry via MQTT
  • Non-blocking sensor reads

🎛️ Advanced Examples

Example 4: Smart Relay Controller

Smart relay with MQTT control, status feedback, and web interface.

Files:

  • examples/smart-relay/

Features:

  • MQTT control with acknowledgment
  • Realay state feedback
  • Web control via device portal
  • LED status indication
  • Watchdog timer
  • Configuration app

Key Components:

class SmartRelayApp : public ksf::ksApplication
{
protected:
    bool init() override {
        // Network
        addComponent<ksf::comps::ksWifiConnector>("SmartRelay");
        addComponent<ksf::comps::ksMqttConnector>();
        addComponent<ksf::comps::ksDevicePortal>();
        
        // UI
        addComponent<ksf::comps::ksLed>(LED_BUILTIN);
        addComponent<ksf::comps::ksResetButton>(RESET_PIN, LOW, 5000);
        
        // Custom components
        addComponent<RelayController>(RELAY_PIN);
        addComponent<WatchdogComponent>(30000);
        
        return true;
    }
    
    bool postInit() override {
        auto mqtt = findComponent<ksf::comps::ksMqttConnector>();
        if (!mqtt) return false;
        
        // Subscribe to control topic
        mqtt->subscribe("relay/set");
        
        // Handle commands
        mqtt->onMessage([this](const char* topic, const char* payload) {
            if (strcmp(topic, "relay/set") == 0) {
                auto relay = findComponent<RelayController>();
                if (relay) {
                    relay->setCommand(payload);
                }
            }
        });
        
        return true;
    }
};

What It Shows:

  • Complex multi-component application
  • Custom hardware control
  • MQTT bidirectional communication
  • Watchdog integration
  • Reset button for config mode

Example 5: Multi-Sensor Gateway

Comprehensive IoT gateway with multiple sensors and aggregation.

Files:

  • examples/sensor-gateway/

Features:

  • Multiple sensor types (temp, humidity, light)
  • Data aggregation and buffering
  • Periodic batch publishing
  • Error handling and recovery
  • Configurable sampling intervals

Architecture:

Multi-Sensor Gateway
├─ Temperature Sensor
├─ Humidity Sensor
├─ Light Sensor
├─ Data Aggregator
├─ Batch Publisher (MQTT)
└─ Status Reporter

🔧 Utility Examples

Example 6: Custom LED Patterns

Creating custom LED patterns for status indication.

class StatusIndicator : public ksComponent
{
private:
    std::shared_ptr<ksf::comps::ksLed> led;
    
protected:
    bool postInit() override {
        led = findComponent<ksf::comps::ksLed>();
        return led != nullptr;
    }
    
    bool loop() override {
        // Update LED based on system state
        if (isError()) {
            led->pattern(0b100100100);  // Triple flash
        }
        else if (isConnecting()) {
            led->pattern(0b110);  // Fast blink
        }
        else if (isConnected()) {
            led->pattern(0b11001100);  // Slow blink
        }
        else {
            led->off();
        }
        return true;
    }
};

Example 7: WiFi Monitor

Monitor WiFi connection quality and signal strength.

class WiFiMonitor : public ksComponent
{
private:
    std::shared_ptr<ksf::comps::ksWifiConnector> wifi;
    std::shared_ptr<ksf::comps::ksMqttConnector> mqtt;
    
protected:
    bool postInit() override {
        wifi = findComponent<ksf::comps::ksWifiConnector>();
        mqtt = findComponent<ksf::comps::ksMqttConnector>();
        return true;
    }
    
    bool loop() override {
        // Report signal strength every minute
        static unsigned long lastReport = 0;
        
        if (millis() - lastReport > 60000 && mqtt && mqtt->isConnected()) {
            if (wifi && wifi->isConnected()) {
                int rssi = wifi->getRssi();
                mqtt->publish("wifi/rssi", String(rssi));
            }
            lastReport = millis();
        }
        return true;
    }
};

🚀 Running Examples

Using PlatformIO

# Clone repository
git clone https://github.com/cziter15/ksIotFrameworkLib.git
cd ksIotFrameworkLib/examples/mqtt-led

# Build
pio run

# Upload
pio run --target upload

# Monitor
pio device monitor

Using Arduino IDE

  1. Install Library:

    • Sketch → Include Library → Manage Libraries
    • Search for "ksIotFrameworkLib"
    • Click Install

  2. Open Example:

    • File → Examples → ksIotFrameworkLib → mqtt-led

  3. Configure:

    • Set board type (Tools → Board)
    • Select correct port

  4. Upload:

    • Click Upload button

💡 Example Patterns

Pattern 1: Always Include Config App

KSF_IMPLEMENT_APP_ROTATOR(
    MainApp,     // Normal operation
    ConfigApp     // Setup mode
)

Pattern 2: Check Config Before Init

bool init() override {
    if (!hasWiFiConfig() || !hasMqttConfig()) {
        return false;  // Trigger config app
    }
    // ... rest of init
}

Pattern 3: LED Indicates Mode

// Main app
bool postInit() override {
    auto led = findComponent<ksLed>();
    led->pattern(0b11001100);  // Running
    return true;
}

// Config app
bool postInit() override {
    auto led = findComponent<ksLed>();
    led->pattern(0b10101010);  // Config mode
    return true;
}

📖 Building from Examples

Customize MQTT Topics

// Change topic names
mqtt->publish("mysensor/temp", String(temp));
mqtt->subscribe("mydevice/command");

Add More Sensors

bool init() override {
    addComponent<ksWifiConnector>("Device");
    addComponent<ksMqttConnector>();
    
    // Add multiple sensors
    addComponent<TempSensor>(TEMP_PIN);
    addComponent<HumiditySensor>(HUM_PIN);
    addComponent<LightSensor>(LIGHT_PIN);
    
    return true;
}

Add Web Control

bool init() override {
    addComponent<ksWifiConnector>("Device");
    addComponent<ksMqttConnector>();
    addComponent<ksDevicePortal>();  // Add web interface
    return true;
}

🎓 Learning Path

  1. Start with LED Blink — Understand basics
  2. Try MQTT LED — Learn IoT patterns
  3. Add Temperature Sensor — Real-world hardware
  4. Build Smart Relay — Production-ready device
  5. Create Custom — Your unique application

📖 Related Resources


🤖 This wiki is automatically generated and may contain errors.

Please report any issues here:
👉 https://github.com/cziter15/ksIotFrameworkLib/issues

📘 Getting Started

🏗️ Core Concepts

📦 Components Reference

⚙️ Configuration & Management

🔬 Advanced Topics

💡 Examples

🔗 External Resources

Clone this wiki locally