arduinousb.cpp

/*
  ____                                   _             _       
 / ___|  ___  _   _ _ __ ___ ___   _ __ | |_   _  __ _(_)_ __  
 \___ \ / _ \| | | | '__/ __/ _ \ | '_ \| | | | |/ _` | | '_ \ 
  ___) | (_) | |_| | | | (_|  __/ | |_) | | |_| | (_| | | | | |
 |____/ \___/ \__,_|_|  \___\___| | .__/|_|\__,_|\__, |_|_| |_|
                                  |_|            |___/         
# A Template for UsbsourcePlugin, a Source Plugin
# Generated by the command: plugin -t source -d ArduinoIO_plugin USBSource
# Hostname: Fram-IV
# Current working directory: /Users/p4010/Develop/MADS_plugins
# Creation date: 2026-09-02T21:59:15.981+0200
# NOTICE: MADS Version 2.4.3
*/
// Mandatory included headers
#include <source.hpp>
#include <sink.hpp>
#include <nlohmann/json.hpp>
#include <pugg/Kernel.h>
#include <map>
#include <vector>
#include <stdio.h>

// other includes as needed here
#include <arduino_driver/Device.h>
#include <arduino_driver/Enumerator.h>
#include <arduino_driver/Protocol.h>
#include "usb_driver.hpp"

// Load the namespaces
using namespace std;
using namespace ArduinoDriver;
using json = nlohmann::json;


// Plugin class. This shall be the only part that needs to be modified,
// implementing the actual functionality
class UsbsourcePlugin : public Source<json>, public USBDriver {

public:
  // Don't forget to inherit the constructors of the parent class
  // If you really need to implement your own constructor, make sure to call 
  // the parent constructor. Normally, use set_params() to set the parameters
  // instead of the constructor.
  using Source::Source; // inherit constructors

  // Typically, no need to change this.
  // On multi-driver plugins, the kind() is used to select the settings section 
  // in the agent's configuration file.
  string kind() override { return "usbsource"; }

  // Implement the actual functionality here
  // Return types:
  // return_type::success: the result is published
  // return_type::retry: go to next loop, nothing is published
  // return_type::warning: content of _error is added to result befor publishing
  // return_type::error: the result only has a copy of _error
  // return_type::critical: execution stops
  return_type get_output(json &out, vector<unsigned char> *blob = nullptr) override {
    if (_init_error) return return_type::critical;
    out.clear();

    try {
      for (const auto &[pin, mode] : _pin_modes) {
        if (mode == PinMode::Input || mode == PinMode::InputPullup || mode == PinMode::InputPulldown) {
          out["digital"][to_string(pin)] = _dev->digital_read(pin);
        } else if (mode == PinMode::AnalogIn) {
          out["analog"][to_string(pin)] = _dev->analog_read_volts(pin);
        }
      }
    } catch (const exception &e) {
      _error = e.what();
      return return_type::error;
    }

    if (!_agent_id.empty()) out["agent_id"] = _agent_id;
    return return_type::success;
  }

  void set_params(const json &params) override {
    Source::set_params(params);

    _params["serial"] = "";
    _params["pin_modes"] = json::object();
    _params["pin_modes"]["1"] = "PULLDOWN";

    _params.merge_patch(params);

    try {
      open(_params["serial"].get<string>());
      read_pin_modes(_params["pin_modes"], _allowed_pin_modes);
      apply_pin_modes();
    } catch (const exception &e) {
      _error = e.what();
      cerr << e.what() << endl;
      _init_error = true;
    }
  }

  // Implement this method if you want to provide additional information
  map<string, string> info() override { 
    // return a map of strings with additional information about the plugin
    // it is used to print the information about the plugin when it is loaded
    // by the agent
    
    return {
      {"pin modes", _params["pin_modes"].dump()}
    };
    
  };

private:
  // Define the fields that are used to store internal resources
  const vector<string> _allowed_pin_modes{"INPUT", "PULLUP", "PULLDOWN", "ANALOG"};
};

class UsbsinkPlugin : public Sink<json>, public USBDriver {

public:
  // Don't forget to inherit the constructors of the parent class
  // If you really need to implement your own constructor, make sure to call 
  // the parent constructor. Normally, use set_params() to set the parameters
  // instead of the constructor.
  using Sink::Sink; // inherit constructors

  // Typically, no need to change this.
  // On multi-driver plugins, the kind() is used to select the settings section 
  // in the agent's configuration file.
  string kind() override { return "usbsink"; }

  // Implement the actual functionality here
  // Return types:
  // return_type::success: processing is valid
  // return_type::retry: skip processing go to next loop
  // return_type::warning: content of _error is tracked with register_event
  // return_type::error: _error is traced, skip process
  // return_type::critical: execution stops
  return_type load_data(json const &input, string topic = "", vector<unsigned char> const *blob = nullptr) override {
    if (_init_error) return return_type::critical;
    if (!input.is_object()) {
      _error = "Input must be a JSON object";
      return return_type::error;
    }
    try {
      if (input.contains("digital")) {
        for (const auto &[pin_str, value] : input["digital"].items()) {
          if (!all_of(pin_str.begin(), pin_str.end(), ::isdigit)) {
            _error = "Pin must be a number: " + pin_str;
            return return_type::error;
          }
          uint8_t pin = stoi(pin_str);
          if (_pin_modes.find(pin) == _pin_modes.end() || _pin_modes[pin] != PinMode::Output) {
            _error = "Pin not configured as OUTPUT: " + pin_str;
            return return_type::error;
          }
          _dev->digital_write(pin, value.get<bool>());
        }
      }
      if (input.contains("pwm")) {
        for (const auto &[pin_str, value] : input["pwm"].items()) {
          if (!all_of(pin_str.begin(), pin_str.end(), ::isdigit)) {
            _error = "Pin must be a number: " + pin_str;
            return return_type::error;
          }
          uint8_t pin = stoi(pin_str);
          if (_pin_modes.find(pin) == _pin_modes.end() || _pin_modes[pin] != PinMode::Pwm) {
            _error = "Pin not configured as PWM: " + pin_str;
            return return_type::error;
          }
          _dev->pwm_write_fraction(pin, value.get<double>());
        }
      }
      if (input.contains("dac")) {
        for (const auto &[pin_str, value] : input["dac"].items()) {
          if (!all_of(pin_str.begin(), pin_str.end(), ::isdigit)) {
            _error = "Pin must be a number: " + pin_str;
            return return_type::error;
          }
          uint8_t pin = stoi(pin_str);
          if (_pin_modes.find(pin) == _pin_modes.end() || _pin_modes[pin] != PinMode::Dac) {
            _error = "Pin not configured as DAC: " + pin_str;
            return return_type::error;
          }
          _dev->dac_write_volts(pin, value.get<double>());
        }
      }
    } catch (const exception &e) {
      _error = e.what();
      return return_type::error;
    }
    return return_type::success;
  }

  void set_params(const json &params) override {
    // Call the parent class method to set the common parameters
    // (e.g. agent_id, etc.)
    Sink::set_params(params);

    // provide sensible defaults for the parameters
    _params["serial"] = "";
    _params["pin_modes"] = json::object();

    _params.merge_patch(params);

    try {
      open(_params["serial"].get<string>());
      read_pin_modes(_params["pin_modes"], _allowed_pin_modes);
      apply_pin_modes();
    } catch (const exception &e) {
      _error = e.what();
      cerr << e.what() << endl;
      _init_error = true;
    }
  }

  // Implement this method if you want to provide additional information
  map<string, string> info() override { 
    // return a map of strings with additional information about the plugin
    // it is used to print the information about the plugin when it is loaded
    // by the agent
    
    return {
      {"pin modes", _params["pin_modes"].dump()}
    };
    
  };

private:
  // Define the fields that are used to store internal resources
  const vector<string> _allowed_pin_modes{"OUTPUT", "PWM", "DAC"};
};


/*
  ____  _             _             _      _
 |  _ \| |_   _  __ _(_)_ __     __| |_ __(_)_   _____ _ __
 | |_) | | | | |/ _` | | '_ \   / _` | '__| \ \ / / _ \ '__|
 |  __/| | |_| | (_| | | | | | | (_| | |  | |\ V /  __/ |
 |_|   |_|\__,_|\__, |_|_| |_|  \__,_|_|  |_| \_/ \___|_|
                |___/
Enable the class as plugin
*/
MADS_REGISTER_PLUGINS(UsbsourcePlugin, UsbsinkPlugin)


/*
                  _
  _ __ ___   __ _(_)_ __
 | '_ ` _ \ / _` | | '_ \
 | | | | | | (_| | | | | |
 |_| |_| |_|\__,_|_|_| |_|

For testing purposes, when directly executing the plugin
*/
int main(int argc, char const *argv[]) {
  json output, params;
  
  try {
    cout << "Listing devices..." << endl;
    cout << USBDriver::list_devices() << endl;
  } catch (const Error &e) {
    cerr << "Error: " << e.what() << endl;
  } 
  
  UsbsourcePlugin plugin{};

  // Set example values to params
  params["pin_modes"]["1"] = "PULLDOWN";
  params["pin_modes"]["2"] = "PULLDOWN";
  params["pin_modes"]["3"] = "PULLUP";
  params["pin_modes"]["15"] = "ANALOG";
  

  // Set the parameters
  plugin.set_params(params);

  // Process data
  plugin.get_output(output);

  // Produce output
  cout << "Output: " << output << endl;
  return 0;
}