AutoResearchRemote.h

Go to the documentation of this file.

// examples/AutoResearch/AutoResearchRemote.h
//
// Remote RPC control system for AutoResearch sketch.
// Provides JSON-RPC interface for dynamic test control via serial commands.
//
// ARCHITECTURE:
// - All test output is communicated EXCLUSIVELY via JSON-RPC
// - ScopedLogDisable suppresses FL_DBG/FL_PRINT during test execution
// - RPC responses use printJsonRaw() which bypasses fl::println (direct Serial output)
// - This allows clean, parseable JSON output without debug noise
 
#pragma once
 
#include "fl/stl/stdint.h"  // for uint32_t, uint8_t
#include "fl/remote/remote.h"  // for fl::Remote (no longer provided by FastLED.h)
#include "fl/channels/manager.h"  // for DriverInfo
#include "fl/stl/shared_ptr.h"
#include "fl/stl/span.h"
#include "fl/stl/unique_ptr.h"
#include "fl/stl/vector.h"
 
// Forward declarations
namespace fl {
class json;
class Remote;
class RxChannel;
namespace net { namespace ble { struct TransportState; } }
}

using RxDeviceFactory = fl::shared_ptr<fl::RxChannel>(*)(int pin);

struct AutoResearchState {
    fl::vector<fl::DriverInfo> drivers_available;
    fl::shared_ptr<fl::RxChannel> rx_channel;
    fl::span<uint8_t> rx_buffer;
    int pin_tx;
    int pin_rx;
    int default_pin_tx;
    int default_pin_rx;
    RxDeviceFactory rx_factory;
    bool gpio_baseline_test_done = false;  // Track whether GPIO baseline test has run in loop()
    bool led_rx_available = false;  // True only after the configured RX path validates
    bool debug_enabled = false;  // Runtime debug logging toggle (default: off)
    bool net_server_active = false;  // Network server autoresearch active
    bool net_client_active = false;  // Network client autoresearch active
    bool ble_server_active = false;  // BLE GATT server autoresearch active
    bool deliberate_hang_requested = false;  // Watchdog autoresearch hang trigger (#2731)
 
    void invalidateLedRxValidation() {
        led_rx_available = false;
        gpio_baseline_test_done = false;
    }
};

void printJsonRaw(const fl::json& json, const char* prefix = "REMOTE: ");

void printStreamRaw(const char* messageType, const fl::json& data);

class AutoResearchRemoteControl {
public:
    AutoResearchRemoteControl();

    ~AutoResearchRemoteControl();

    void registerFunctions(fl::shared_ptr<AutoResearchState> state);

    void tick(uint32_t current_millis);

    fl::Remote* getRemote() { return mRemote.get(); }

    fl::json startBleRemote();

    fl::json stopBleRemote();
 
private:
    fl::unique_ptr<fl::Remote> mRemote;      // Serial Remote RPC system instance
    fl::unique_ptr<fl::Remote> mBleRemote;   // BLE Remote RPC system instance (created by startBle)
    fl::net::ble::TransportState* mBleState = nullptr; // Opaque BLE state (heap-allocated by ble::createTransport, nullptr on stub platforms)
    fl::shared_ptr<AutoResearchState> mState;  // Shared autoresearch state
    bool mPendingBleStop = false;            // Deferred BLE teardown flag (set by stopBle RPC)

    void registerAllMethods(fl::Remote* remote);
 
    // Private helper functions for RPC implementation
    fl::json runSingleTestImpl(const fl::json& args);
    fl::json runParallelTestImpl(const fl::json& args);
    fl::json findConnectedPinsImpl(const fl::json& args);
 
    // RPC binding helpers — each implemented in its own .cpp file to keep
    // file sizes below 1 K LOC (#3132 / meta #3127). The Remote target is
    // passed explicitly so the same partitioning can be used for the BLE
    // Remote (mBleRemote) or any future transport.
    void bindSystemMethods(fl::Remote& remote);
    void bindDriverMethods(fl::Remote& remote);
    void bindPinMethods(fl::Remote& remote);
    void bindMathMethods(fl::Remote& remote);
    void bindNetworkMethods(fl::Remote& remote);
    void bindAsyncMethods(fl::Remote& remote);
    void bindBenchmarkMethods(fl::Remote& remote);
    void bindRpSpiMethods(fl::Remote& remote);
};