rt.hpp

Go to the documentation of this file.

/*
 The Real-Time eXperiment Interface (RTXI)
 Copyright (C) 2011 Georgia Institute of Technology, University of Utah,
 Will Cornell Medical College

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef RT_H
#define RT_H

#include <unordered_map>
#include <variant>
#include <vector>

#include "event.hpp"
#include "fifo.hpp"
#include "io.hpp"
#include "rtos.hpp"

// forward declaration
namespace Widgets
{
class Component;
} // namespace Widgets

namespace RT
{

namespace State
{

enum state_t : int8_t
{
 INIT,
 EXEC,
 MODIFY,
 PERIOD,
 PAUSE,
 UNPAUSE,
 EXIT,
};
} // namespace State

namespace Telemitry
{
typedef int response_t;
constexpr response_t RT_PERIOD_UPDATE = 0;
constexpr response_t RT_THREAD_LIST_UPDATE = 1;
constexpr response_t RT_DEVICE_LIST_UPDATE = 2;
constexpr response_t RT_NOOP = 3;
constexpr response_t RT_SHUTDOWN =
 4;
constexpr response_t RT_WIDGET_PARAM_UPDATE =
 5;
constexpr response_t IO_LINK_UPDATED =
 6;
constexpr response_t RT_WIDGET_STATE_UPDATE =
 7;
constexpr response_t RT_ERROR =
 -1;
constexpr response_t NO_TELEMITRY = -2;
struct Response
{
 response_t type = NO_TELEMITRY;
 Event::Object* cmd = nullptr;
};
} // namespace Telemitry

class Device : public IO::Block
{
public:
 Device(std::string n, const std::vector<IO::channel_t>& c)
 : IO::Block(std::move(n), c, /*isdependent=*/false)
 {
 }
 Device(const Device&) = default; // copy constructor
 Device& operator=(const Device&) = default; // copy assignment operator
 Device(Device&&) = delete; // move constructor
 Device& operator=(Device&&) = delete; // move assignment operator
 ~Device() override = default;

 virtual void read() = 0;

 virtual void write() = 0;
}; // class Device

class Thread : public IO::Block
{
public:
 Thread(std::string n, const std::vector<IO::channel_t>& c)
 : IO::Block(std::move(n), c, /*isdependent=*/true)
 {
 }
 Thread(const Thread& connector) = default; // copy constructor
 Thread& operator=(const Thread& connector) =
 default; // copy assignment operator
 Thread(Thread&&) = delete; // move constructor
 Thread& operator=(Thread&&) = delete; // move assignment operator
 ~Thread() override = default;

 virtual void execute() = 0;
}; // class Thread

typedef struct block_connection_t
{
 IO::Block* src = nullptr;
 IO::flags_t src_port_type = IO::UNKNOWN;
 size_t src_port = 0;
 IO::Block* dest = nullptr;
 size_t dest_port = 0;
 bool operator==(const block_connection_t& rhs) const
 {
 return (this->src == rhs.src) && (this->src_port_type == rhs.src_port_type)
 && (this->src_port == rhs.src_port) && (this->dest == rhs.dest)
 && (this->dest_port == rhs.dest_port);
 }
 bool operator!=(const block_connection_t& rhs) const
 {
 return !operator==(rhs);
 }
} block_connection_t;

class Connector
{
public:
 Connector() = default; // default constructor
 Connector(const Connector& connector) = delete; // copy constructor
 Connector& operator=(const Connector& connector) =
 delete; // copy assignment operator
 Connector(Connector&&) = delete; // move constructor
 Connector& operator=(Connector&&) = delete; // move assignment operator
 ~Connector() = default;

 int connect(block_connection_t connection);

 void disconnect(block_connection_t connection);

 bool connected(block_connection_t connection);

 void insertBlock(IO::Block* block,
 std::vector<RT::block_connection_t>& block_connections);

 void removeBlock(IO::Block* block);

 bool isRegistered(IO::Block* block);

 std::vector<RT::Device*> getDevices();

 std::vector<RT::Thread*> getThreads();

 std::vector<RT::block_connection_t> getOutputs(IO::Block* src);

 void propagateBlockConnections(IO::Block* block);

 void clearAllConnections(IO::Block* block);

 std::vector<IO::Block*> getRegisteredBlocks();

 std::vector<RT::block_connection_t> getAllConnections();

private:
 int find_cycle(RT::block_connection_t conn, IO::Block* ref_block);
 std::vector<RT::Thread*> topological_sort();
 std::vector<IO::Block*> block_registry;
 std::vector<std::vector<RT::block_connection_t>> connections;
}; // class Connector

using command_param_t = std::variant<std::monostate,
 int64_t,
 int64_t*,
 uint64_t,
 double,
 RT::Thread*,
 std::vector<RT::Thread*>*,
 RT::Device*,
 std::vector<RT::Device*>*,
 IO::Block*,
 RT::block_connection_t,
 Widgets::Component*,
 State::state_t,
 std::string>;
class System : public Event::Handler
{
public:
 explicit System(Event::Manager* em, RT::Connector* rtc);
 System(const System& system) = delete; // copy constructor
 System& operator=(const System& system) = delete; // copy assignment operator
 System(System&&) = delete; // move constructor
 System& operator=(System&&) = delete; // move assignment operator
 ~System() override;

 int64_t getPeriod();

 std::vector<RT::Telemitry::Response> getTelemitry();

 void createTelemitryProcessor();

 void receiveEvent(Event::Object* event) override;

private:
 // We want our cmd class to be private. the only way to access
 // RT::System functions is through its event handler.
 class CMD : public Event::Object
 {
 public:
 explicit CMD(Event::Type et);
 command_param_t getRTParam(const std::string_view& param_name);
 void setRTParam(const std::string_view& param_name,
 const command_param_t& value);

 private:
 struct rt_param
 {
 std::string_view name;
 RT::command_param_t value;
 };
 std::vector<rt_param> rt_params;
 };

 void insertDevice(Event::Object* event);
 void removeDevice(Event::Object* event);
 void insertThread(Event::Object* event);
 void removeThread(Event::Object* event);
 // void blockActivityChange(Event::Object* event);
 void threadActivityChange(Event::Object* event);
 void deviceActivityChange(Event::Object* event);
 void ioLinkChange(Event::Object* event);
 void connectionsInfoRequest(Event::Object* event);
 void allConnectionsInfoRequest(Event::Object* event);
 void blockInfoRequest(Event::Object* event);
 void setPeriod(Event::Object* event);
 void shutdown(Event::Object* event);
 void NOOP(Event::Object* event);
 void getPeriodValues(Event::Object* event);
 void provideTimetickPointers(Event::Object* event);
 void changeWidgetParameters(Event::Object* event);
 void changeWidgetState(Event::Object* event);

 void executeCMD(CMD* cmd);
 void updateDeviceList(CMD* cmd);
 void updateThreadList(CMD* cmd);
 void ioLinkUpdateCMD(CMD* cmd);
 void updateBlockActivity(CMD* cmd);
 void setPeriod(CMD* cmd);
 void shutdown(CMD* cmd);
 void getPeriodTicksCMD(CMD* cmd);
 void changeWidgetParametersCMD(CMD* cmd);
 void changeWidgetStateCMD(CMD* cmd);

 void postTelemitry(RT::Telemitry::Response telemitry);

 static void execute(void* sys);

 int64_t periodStartTime = 1;
 int64_t periodEndTime = 1;
 int64_t lastperiodStartTime = 1;

 // System owns the task object and the pipe used to communicate with it
 std::unique_ptr<RT::OS::Task> task;
 std::unique_ptr<RT::OS::Fifo> eventFifo;
 std::thread telemitry_processing_thread;
 std::atomic<bool> telemitry_processing_thread_running = true;

 // system doesn't own any of the below variables. That's why they are
 // only pointers.
 Event::Manager* event_manager;
 RT::Connector* rt_connector;

 // System's real-time loop maintains copy of device and thread pointers
 std::vector<RT::Device*> devices;
 std::vector<RT::Thread*> threads;
}; // class System
} // namespace RT
#endif // RT_H