robot_plugin.cpp

Author: CodelikeC

plugins/external/robotic_adapter_plugin/robot_plugin.cpp

@@ -0,0 +1,103 @@
+// ibcs/plugins/external/robotic_adapter_plugin/robotic_adapter_plugin.cpp
+#include "robot_plugin.h"
+#include <iostream>
+#include <algorithm>
+
+namespace ibcs::plugin::external::robot {
+
+RoboticAdapterPlugin::RoboticAdapterPlugin()
+    : proto_(make_default_robot_protocol())
+{
+}
+
+RoboticAdapterPlugin::~RoboticAdapterPlugin() {
+}
+
+ibcs::plugin::PluginInfo RoboticAdapterPlugin::info() const {
+    return {
+        "external.robotic_adapter",
+        "1.0.0",
+        "IBCS External Robotics"
+    };
+}
+
+bool RoboticAdapterPlugin::on_load() {
+    std::cout << "[robotic_adapter] plugin loaded\n";
+    return true;
+}
+
+bool RoboticAdapterPlugin::on_unload() {
+    std::cout << "[robotic_adapter] plugin unloaded\n";
+    if (proto_) proto_->disconnect();
+    return true;
+}
+
+std::vector<std::string> RoboticAdapterPlugin::capabilities() const {
+    return {
+        "robot.send",
+        "robot.read",
+        "robot.motion_adapt",
+        "safety.guard"
+    };
+}
+
+bool RoboticAdapterPlugin::configure(const std::string &endpoint) {
+    endpoint_ = endpoint;
+    if (!proto_->connect(endpoint_)) {
+        std::cerr << "[robotic_adapter] could not connect to " << endpoint << "\n";
+        return false;
+    }
+    if (!proto_->ping()) {
+        std::cerr << "[robotic_adapter] ping failed\n";
+        return false;
+    }
+    std::cout << "[robotic_adapter] configured successfully\n";
+    return true;
+}
+
+// safety: clamp ranges & duration
+bool RoboticAdapterPlugin::safety_filter(MotionCommand &cmd) const {
+    if (cmd.duration_seconds <= 0.0 || cmd.duration_seconds > 5.0) {
+        std::cerr << "[robotic_adapter] duration out of bounds\n";
+        return false;
+    }
+
+    if (!cmd.joint_positions.empty())
+        clamp_vec(cmd.joint_positions, -2.0, 2.0); // rad or m
+    if (!cmd.joint_velocities.empty())
+        clamp_vec(cmd.joint_velocities, -1.0, 1.0);
+
+    return true;
+}
+
+void RoboticAdapterPlugin::clamp_vec(std::vector<double> &v, double lo, double hi) const {
+    for (auto &x : v) {
+        if (x < lo) x = lo;
+        if (x > hi) x = hi;
+    }
+}
+
+bool RoboticAdapterPlugin::send_motion_command(MotionCommand cmd) {
+    if (!proto_) return false;
+
+    if (!safety_filter(cmd)) {
+        std::cerr << "[robotic_adapter] safety_filter blocked motion\n";
+        return false;
+    }
+    return proto_->send_motion(cmd);
+}
+
+optional<RobotState> RoboticAdapterPlugin::get_state() {
+    if (!proto_) return nullopt;
+    return proto_->read_state();
+}
+
+extern "C" ibcs::plugin::IPlugin* create_plugin() {
+    return new RoboticAdapterPlugin();
+}
+
+extern "C" void destroy_plugin(ibcs::plugin::IPlugin* p) {
+    delete p;
+}
+
+} // namespace ibcs::plugin::external::robot

plugins/external/robotic_adapter_plugin/robot_plugin.h

@@ -0,0 +1,51 @@
+#pragma once 
+#include "../../base/plugin_interface.h"
+#include "robot_protocol.h"
+
+#include <memory> 
+#include <string> 
+
+#include <vector> 
+#include <optional>
+
+namespace ibcs :: plugin :: external :: robot 
+{
+    class RoboticAdapterPlugin : public ibcs :: plugin :: IPlugin
+    {
+        public: 
+        RoboticAdapterPlugin();
+        ~RoboticAdapterPlugin(); 
+
+        // IPlugin 
+        ibcs :: plugin :: PluginInfo info() const override; 
+        bool on_load() override; 
+        bool on_unload() override;
+        
+        vector<string> capabilities() const override; 
+
+        // setup protocol and (endpoint = Ip/serial...)
+        bool configure(const string &endpoint); 
+
+        // control operations.. 
+        bool send_motion_command(const MotionCommand cmd); 
+        optional<RobotState> get_state();
+        
+        // health check..
+        bool ping(); 
+
+        private: 
+        unique_ptr<IRobotProtocol> proto_;
+        string endpoint_; 
+
+        // small safety guard..
+        bool safety_filter(MotionCommand &cmd) const ;
+        
+        // Saturation helpers.. 
+        void clamp_vec(vector<double> &v, double lo, double hi) const; 
+    }; 
+    extern "C"
+    {
+    ibcs :: plugin :: IPlugin *create_plugin(); 
+    void destroy_plugin(ibcs :: plugin :: IPlugin *p); 
+    } 
+} // namespace ibcs :: plugin :: external :: robot

plugins/external/robotic_adapter_plugin/robot_protocol.cpp

@@ -0,0 +1,62 @@
+#include "robot_protocol.h"
+
+#include <iostream> 
+using namespace std; 
+
+namespace ibcs :: plugin :: external :: robot
+{
+    class DummyRobotProtocol : public IRobotProtocol
+    {
+        public: 
+        bool connect(const string &endpoint) override 
+        {
+            cout <<"Robot proto" << "connect to " << endpoint << endl;
+            connected = true;  
+            return true; 
+        }
+
+        void disconnect() override 
+        {
+            cout <<"Robot proto" << "disconnect" << endl; 
+            connected = false; 
+        }
+
+        bool send_motion(const MotionCommand &cmd) override 
+        {
+            if (!connected)
+            return false; 
+
+            cout <<"Robot proto - send motion: joints ="
+            << cmd.joint_positions.size() << "duration = "
+            << cmd.duration_seconds << "seconds" << endl; 
+            return true; 
+        }
+
+        optional<RobotState> read_state() override 
+        {
+            if (!connected)
+            return nullopt; 
+
+            RobotState state; 
+            state.battery = 95.0; 
+            state.joint_positions = {0.0, 1.0, 0.5};
+            state.joint_velocities = {0.0, 0.0, 0.0};
+            state.estop_triggered = false; 
+            state.raw_status = "OK";
+
+            return state; 
+        }
+
+        bool ping() override 
+        {
+            return connected;
+        }
+
+        private: 
+        bool connected = false ; 
+    }; 
+
+    IRobotProtocol *make_default_robot_protocol(){
+        return new DummyRobotProtocol(); 
+    }
+} // namespace ibcs :: plugin :: external :: robot

plugins/external/robotic_adapter_plugin/robot_protocol.h

@@ -0,0 +1,53 @@
+#pragma once 
+#include <string> 
+
+#include <vector> 
+#include <optional>
+
+using namespace std; 
+
+namespace ibcs :: plugin :: external :: robot
+{
+    // High level state from robot... 
+    struct RobotState
+    {
+        double battery  = 100.0 ; 
+        vector<double> joint_positions; 
+        vector<double> joint_velocities; 
+        bool estop_triggered = false; 
+        string raw_status; 
+    };
+    
+    // A generic motion command.. 
+    struct MotionCommand
+    {
+        vector<double> joint_positions; 
+        vector<double> joint_velocities; 
+
+        double duration_seconds = 0.0; 
+    }; 
+
+    class IRobotProtocol
+    {
+        public: 
+        virtual ~IRobotProtocol() = default; 
+
+        // establish connection to robot endpoint.. 
+        virtual bool connect(const string &endpoint) = 0; 
+
+        // disconnect cleanly..
+        virtual void disconnect() = 0; 
+
+        // send a single motion command..
+        virtual bool send_motion(const MotionCommand &cmd) = 0 ;
+        
+        // query low level state.. 
+        virtual optional<RobotState> read_state() = 0; 
+
+        // small health check. . 
+        virtual bool ping() = 0; 
+    };
+
+    // factory for default protocol (dummy stab)
+    IRobotProtocol *make_default_robot_protocol();
+} // namespace ibcs :: plugin :: external :: robot