setup()

void setup

(

)

Definition at line 100 of file RpcBidirectional.ino.

             {
    Serial.begin(115200);
    while (!Serial && millis() < 3000) {
        // Wait for serial or timeout
    }
 
    Serial.println("\n=== HTTP RPC Bidirectional Example ===\n");
    Serial.println("This example demonstrates server + client in one process:");
    Serial.println("  - Server listens on port 8080");
    Serial.println("  - Client connects to localhost:8080");
    Serial.println("  - All three RPC modes demonstrated");
    Serial.println();
 
    // Initialize LEDs
    FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
    FastLED.setBrightness(50);
    fill_solid(leds, NUM_LEDS, CRGB::Black);
    FastLED.show();
 
    // ========== SERVER SETUP ==========
    Serial.println("Starting HTTP server on port 8080...");
 
    serverTransport = fl::make_unique<fl::net::http::HttpStreamServer>(SERVER_PORT);
    serverTransport->setHeartbeatInterval(30000);
    serverTransport->setTimeout(60000);
 
    // Connection callbacks
    serverTransport->setOnConnect([]() {
        Serial.println("[SERVER] Client connected!");
        leds[0] = CRGB::Green;
        FastLED.show();
    });
 
    serverTransport->setOnDisconnect([]() {
        Serial.println("[SERVER] Client disconnected!");
        leds[0] = CRGB::Red;
        FastLED.show();
    });
 
    // Create server Remote
    serverRemote = fl::make_unique<fl::Remote>(
        []() { return serverTransport->readRequest(); },
        [](const fl::json& response) { serverTransport->writeResponse(response); }
    );
 
    // ========== BIND SERVER METHODS ==========
 
    // SYNC mode: add(a, b)
    serverRemote->bind("add", [](const fl::json& params) -> fl::json {
        int a = 0, b = 0;
        if (params.is_array() && params.size() >= 2) {
            auto aOpt = params[0].as_int();
            auto bOpt = params[1].as_int();
            if (aOpt && bOpt) {
                a = *aOpt;
                b = *bOpt;
            }
        }
        int result = a + b;
        fl::printf("[SERVER] add(%d, %d) = %d\n", a, b, result);
        return fl::json(result);
    });
 
    // ASYNC mode: longTask(duration)
    serverRemote->bindAsync("longTask", [](fl::ResponseSend& send, const fl::json& params) {
        // Send ACK
        fl::json ack = fl::json::object();
        ack.set("ack", true);
        send.send(ack);
 
        // Extract duration
        int duration = 1000;
        if (params.is_array() && params.size() > 0) {
            auto durationOpt = params[0].as_int();
            if (durationOpt) {
                duration = *durationOpt;
            }
        }
 
        fl::printf("[SERVER] longTask(%d) - ACK sent\n", duration);
 
        // Simulate work
        uint32_t startTime = millis();
        while (millis() - startTime < static_cast<uint32_t>(duration)) {
            delay(100);
        }
 
        // Send result
        fl::json result = fl::json::object();
        result.set("value", 42);
        result.set("duration", duration);
        send.send(result);
 
        fl::printf("[SERVER] longTask(%d) - DONE\n", duration);
    }, fl::RpcMode::ASYNC);
 
    // ASYNC_STREAM mode: streamData(count)
    serverRemote->bindAsync("streamData", [](fl::ResponseSend& send, const fl::json& params) {
        // Send ACK
        fl::json ack = fl::json::object();
        ack.set("ack", true);
        send.send(ack);
 
        // Extract count
        int count = 5;
        if (params.is_array() && params.size() > 0) {
            auto countOpt = params[0].as_int();
            if (countOpt) {
                count = *countOpt;
            }
        }
 
        fl::printf("[SERVER] streamData(%d) - ACK sent\n", count);
 
        // Send updates
        for (int i = 0; i < count; i++) {
            fl::json update = fl::json::object();
            update.set("update", i);
            send.sendUpdate(update);
            fl::printf("[SERVER] streamData - update %d/%d\n", i + 1, count);
            delay(200);
        }
 
        // Send final
        fl::json final = fl::json::object();
        final.set("value", count);
        send.sendFinal(final);
 
        fl::printf("[SERVER] streamData(%d) - DONE\n", count);
    }, fl::RpcMode::ASYNC_STREAM);
 
    // Start server
    if (!serverTransport->connect()) {
        Serial.println("ERROR: Failed to start server!");
        return;
    }
    Serial.println("✓ Server started successfully");
    fl::u16 actualPort = serverTransport->port();
    Serial.print("  Listening on port: ");
    Serial.println(actualPort);
    Serial.println();
 
    // Start server in background thread so client can connect without deadlock
    serverRunning.store(true);
    serverThread = std::thread(serverThreadFunc);
 
    // Register cleanup listener now — must happen after thread starts so the
    // thread is always joined during onExit(), even if setup() returns early.
    // Without this, std::thread destructor calls std::terminate() on a joinable thread.
    fl::EngineEvents::addListener(&serverCleanup);
 
    // ========== CLIENT SETUP ==========
    delay(500); // Give server time to start and begin accepting connections
 
    Serial.println("Connecting client to server...");
 
    clientTransport = fl::make_unique<fl::net::http::HttpStreamClient>("localhost", actualPort);
    clientTransport->setHeartbeatInterval(30000);
    clientTransport->setTimeout(60000);
 
    // Connection callbacks
    clientTransport->setOnConnect([]() {
        Serial.println("[CLIENT] Connected to server!");
        leds[9] = CRGB::Blue;
        FastLED.show();
    });
 
    clientTransport->setOnDisconnect([]() {
        Serial.println("[CLIENT] Disconnected from server!");
        leds[9] = CRGB::Red;
        FastLED.show();
        waitingForResponse = false;
    });
 
    // Create client Remote
    clientRemote = fl::make_unique<fl::Remote>(
        []() { return clientTransport->readRequest(); },
        [](const fl::json& response) { clientTransport->writeResponse(response); }
    );
 
    // Connect to server
    if (!clientTransport->connect()) {
        Serial.println("ERROR: Failed to connect to server!");
        return;
    }
 
    Serial.println("✓ Client connected successfully\n");
    Serial.println("Starting test sequence...\n");
}

References fl::EngineEvents::addListener(), fl::json::as_int(), fl::ASYNC, fl::ASYNC_STREAM, fl::CRGB::Black, fl::CRGB::Blue, clientRemote, clientTransport, DATA_PIN, FastLED, fill_solid(), GRB, fl::CRGB::Green, fl::json::is_array(), leds, fl::make_unique(), NUM_LEDS, fl::json::object(), fl::printf(), fl::CRGB::Red, fl::ResponseSend::send(), fl::ResponseSend::sendFinal(), fl::ResponseSend::sendUpdate(), Serial, SERVER_PORT, serverCleanup, serverRemote, serverRunning(), serverThread, serverThreadFunc(), serverTransport, fl::json::set(), fl::json::size(), and waitingForResponse.

Here is the call graph for this function: