Syntalos

Syntalos

Namespaces

Classes

Types

Functions

Attributes

Types Documentation

enum ModuleState

The ModuleState enum.

Describes the state a module can be in. The state is usually displayed to the user via a module indicator widget.

enum ControlCommandKind

The ControlCommandKind enum.

Basic operations to control a module from another module.

enum FirmataCommandKind

The FirmataCommandKind enum.

Set which type of change should be made on a Firmata interface.

enum SignalDataType

Type of a signal from a signal source.

This is usually set in the metadata of a data stream.

enum TimeSyncStrategy

The time synchronization strategy.

enum TSyncFileMode

Timepoint storage of a TSync file.

enum TSyncFileTimeUnit

Unit types for time representation in a TSync file.

enum TSyncFileDataType

Data types use for storing time values in the data file.

enum SysInfoCheckResult

enum ColorMode

enum PortAction

Action performed to modify a module port.

enum ModuleFeature

The ModuleFeature flags List of basic features this module may or may not support, or may request from the engine to be available.

enum ModuleDriverKind

The ModuleDriverKind enum.

enum UsbHotplugEventKind

The UsbHotplugEventKind enum.

enum ModuleCategory

Categorization for modules.

enum ModuleModifier

The ModuleModifier flags Flags set by Syntalos or the user to modify the behavior of the module in the wider context of the running experiment.

enum PortDirection

Enum specifying directionality of a port (in or out)

using symaster_timepoint

using Syntalos::symaster_timepoint = typedef std::chrono::time_point<symaster_clock>;

A timepoint on the master clock.

using seconds_t

using Syntalos::seconds_t = typedef std::chrono::seconds;

Shorthand for seconds.

using milliseconds_t

using Syntalos::milliseconds_t = typedef std::chrono::milliseconds;

Shorthand for milliseconds.

using microseconds_t

using Syntalos::microseconds_t = typedef std::chrono::duration<int64_t, std::micro>;

Shorthand for microseconds.

using nanoseconds_t

using Syntalos::nanoseconds_t = typedef std::chrono::duration<int64_t, std::nano>;

Shorthand for nanoseconds.

typedef VectorXsi

typedef Eigen::Matrix<int32_t, Eigen::Dynamic, 1> Syntalos::VectorXsi;

typedef VectorXul

typedef Eigen::Matrix<uint64_t, Eigen::Dynamic, 1> Syntalos::VectorXul;

typedef VectorXsl

typedef Eigen::Matrix<int64_t, Eigen::Dynamic, 1> Syntalos::VectorXsl;

typedef VectorXd

typedef Eigen::Matrix<double, Eigen::Dynamic, 1> Syntalos::VectorXd;

typedef MatrixXsi

typedef Eigen::Matrix<int32_t, Eigen::Dynamic, Eigen::Dynamic> Syntalos::MatrixXsi;

typedef MatrixXd

typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> Syntalos::MatrixXd;

using SyncDetailsChangeNotifyFn

using Syntalos::SyncDetailsChangeNotifyFn = typedef std::function<void(const QString &id, const TimeSyncStrategies &strategies, const microseconds_t &tolerance)>;

Function to call when synchronizer details have changed.

using OffsetChangeNotifyFn

using Syntalos::OffsetChangeNotifyFn = typedef std::function<void(const QString &id, const microseconds_t &currentOffset)>;

Function to call to notify about an offset change.

using intervalEventFunc_t

using Syntalos::intervalEventFunc_t = typedef void (AbstractModule::*)(int &);

Event function type for timed callbacks.

using recvDataEventFunc_t

using Syntalos::recvDataEventFunc_t = typedef void (AbstractModule::*)();

Event function type for subscription new data callbacks.

using ByteVector

using Syntalos::ByteVector = typedef std::vector<std::byte, mi_stl_allocator<std::byte> >;

ByteVector is a vector of bytes using mimalloc as allocator.

In Syntalos’ heavily threaded environment, where in the worst case a ton of these vectors may be created and destroyed in quick succession, the default glibc allocator is less than optimal. Mimalloc has shown to perform a lot better for this burst-like, threaded activity, therefore we prefer it. Please try to reuse buffers whenever possible still though - while mimalloc is a significant improvement, reusing memory segments is even better.

using LoadScriptFn

using Syntalos::LoadScriptFn = typedef std::function<void(const QString &script, const QString &wdir)>;

using PrepareStartFn

using Syntalos::PrepareStartFn = typedef std::function<void(const QByteArray &settings)>;

using StartFn

using Syntalos::StartFn = typedef std::function<void()>;

using StopFn

using Syntalos::StopFn = typedef std::function<void()>;

using ShutdownFn

using Syntalos::ShutdownFn = typedef std::function<void()>;

using NewDataRawFn

using Syntalos::NewDataRawFn = typedef std::function<void(const void *data, size_t size)>;

using ShowSettingsFn

using Syntalos::ShowSettingsFn = typedef std::function<void(const QByteArray &settings)>;

using ShowDisplayFn

using Syntalos::ShowDisplayFn = typedef std::function<void(void)>;

Functions Documentation

function syDataTypeId

template <typename T >
constexpr int syDataTypeId()

Helper function to get the type ID of a data type.

function deserializeFromMemory

template <typename T >
T deserializeFromMemory(
    const void * memory,
    size_t size
)

Convenience function to deserialize a data type from memory.

function registerStreamMetaTypes

void registerStreamMetaTypes()

Helper function to register all meta types for stream data.

This function registers all types with the meta object system and also creates a global map of all available stream types.

function streamTypeIdIndex

std::vector< std::pair< std::string, int > > streamTypeIdIndex()

Get a mapping of type names to their IDs.

function numToString

template <typename T >
inline std::string numToString(
    T x
)

Convert a numeric value to a string using Syntalos’ default notation.

This function converts arithmetic types to strings in a locale-independent way. For floating-point types, it uses the “general” format (shortest representation). Special values (NaN, infinity) are handled consistently across all types.

function qstr

inline const QString & qstr(
    const QString & s
)

function qstr

inline QString qstr(
    QStringView s
)

function qstr

inline QString qstr(
    const char * s
)

function qstr

inline QString qstr(
    std::string_view s
)

function qstr

inline QString qstr(
    const std::string & s
)

function usecToMsec

inline auto usecToMsec(
    const microseconds_t & usec
)

Convert microseconds to milliseconds.

Shorthand for duration-case to increase code readability.

function msecToUsec

inline auto msecToUsec(
    const milliseconds_t & msec
)

Convert milliseconds microseconds.

Shorthand for duration-case to increase code readability.

function nsecToUsec

inline auto nsecToUsec(
    const nanoseconds_t & msec
)

Convert nanoseconds microseconds.

Shorthand for duration-case to increase code readability.

function timeDiffSec

inline auto timeDiffSec(
    const symaster_timepoint & timePoint1,
    const symaster_timepoint & timePoint2
)

function timeDiffMsec

inline auto timeDiffMsec(
    const symaster_timepoint & timePoint1,
    const symaster_timepoint & timePoint2
)

function timeDiffUsec

inline auto timeDiffUsec(
    const symaster_timepoint & timePoint1,
    const symaster_timepoint & timePoint2
)

function timeDiffToNowMsec

inline auto timeDiffToNowMsec(
    const std::chrono::time_point< symaster_clock > & timePoint
)

function currentTimePoint

inline symaster_timepoint currentTimePoint()

function vectorMedian

template <typename T >
double vectorMedian(
    const Eigen::Matrix< T, Eigen::Dynamic, 1 > & vec
)

function vectorMedianInplace

template <typename T >
double vectorMedianInplace(
    Eigen::Matrix< T, Eigen::Dynamic, 1 > & vec
)

function vectorVariance

template <typename T >
double vectorVariance(
    const Eigen::Matrix< T, Eigen::Dynamic, 1 > & vec,
    const double & mean,
    bool unbiased =true
)

function vectorVariance

template <typename T >
double vectorVariance(
    const Eigen::Matrix< T, Eigen::Dynamic, 1 > & vec,
    bool unbiased =true
)

function serializeEigen

template <typename EigenType >
void serializeEigen(
    BinaryStreamWriter & stream,
    const EigenType & matrix
)

function deserializeEigen

template <typename EigenType >
EigenType deserializeEigen(
    BinaryStreamReader & stream
)

function configureGlibcAllocator

void configureGlibcAllocator()

Change settings of the default Glibc allocator to reduce fragmentation and match Syntalos’ allocation patterns better. Not needed if mimalloc is used.

function setCvMiMatAllocator

void setCvMiMatAllocator()

Install the mimalloc-backed allocator as OpenCV’s default matrix allocator.

Call this once early in main(), before any cv::Mat is created.

function timeSyncStrategyToHString

const QString timeSyncStrategyToHString(
    const TimeSyncStrategy & strategy
)

function timeSyncStrategiesToHString

const QString timeSyncStrategiesToHString(
    const TimeSyncStrategies & strategies
)

function safeStopSynchronizer

template <typename T >
void safeStopSynchronizer(
    const T & synchronizerSmartPtr
)

function safeStopSynchronizer

template <typename T >
void safeStopSynchronizer(
    const T & synchronizer,
    const microseconds_t & lastValidMasterTimestamp
)

function tsyncFileTimeUnitToString

QString tsyncFileTimeUnitToString(
    const TSyncFileTimeUnit & tsftunit
)

function tsyncFileDataTypeToString

QString tsyncFileDataTypeToString(
    const TSyncFileDataType & dtype
)

function tsyncFileModeToString

QString tsyncFileModeToString(
    const TSyncFileMode & mode
)

function cvMatToQImage

std::optional< QImage > cvMatToQImage(
    const cv::Mat & mat
)

Converts an OpenCV Mat to a QImage.

Parameters:

• mat The OpenCV Mat to convert.

Return: An optional containing the converted QImage, or std::nullopt if conversion fails.

This function attempts to convert the given OpenCV Mat to a QImage. It supports grayscale (1 channel), RGB (3 channels), and RGBA (4 channels) images. If the conversion is successful, it returns a QImage wrapped in std::optional. If the conversion fails (e.g., unsupported number of channels), it returns std::nullopt.

function cvMatToQPixmap

std::optional< QPixmap > cvMatToQPixmap(
    const cv::Mat & mat
)

function shellQuote

QString shellQuote(
    const QString & str
)

Shell-escape a string.

function findHostExecutable

QString findHostExecutable(
    const QString & exe
)

Find executable on the host system (if running in a sandbox)

Parameters:

• exe Name of the executable to look for

Return: Executable name, or empty string if not found

function runHostExecutable

int runHostExecutable(
    const QString & exe,
    const QStringList & args,
    bool waitForFinished
)

Run command on the host.

Parameters:

• exe The program to run
• args Program arguments
• waitForFinished Wait for the command to finish

Return: Exit status of the program (if waiting for finished)

function runInTerminal

int runInTerminal(
    const QString & cmd,
    const QStringList & args,
    const QString & wdir,
    const QString & title
)

function launchProgramNC3Fallback

static bool launchProgramNC3Fallback(
    const QString & exePath,
    int * pidfd_out
)

Fallback for launchProgram() if the clone3() syscall was not available or is blocked by seccomp filters.

function launchProgramPidFd

bool launchProgramPidFd(
    const QString & exePath,
    int * pidfd_out
)

Launch a program in a new process, and return the PID of the new process as pidfd.

Parameters:

• exePath The path to the executable to launch.
• pidfd_out A pointer to an integer, which will be set to the PID of the new process.

Return: true if the program was successfully launched, false otherwise.

This function is used to launch a new program in a new process, and return the PID as pidfd.

function isProcessRunning

bool isProcessRunning(
    int pidfd
)

Check if a process is still running using a pidfd.

Parameters:

• pidfd The PIDFD of the process to check.

Return: true if the process is still running, false otherwise.

This function checks if a process is still running, by checking if the process has exited or not.

function colorModeToString

QString colorModeToString(
    ColorMode mode
)

function colorModeFromString

ColorMode colorModeFromString(
    const QString & str
)

function findSyntalosPyWorkerBinary

QString findSyntalosPyWorkerBinary()

function findSyntalosLibraryPaths

void findSyntalosLibraryPaths(
    QString & pkgConfigPath,
    QString & ldLibraryPath,
    QString & includePath
)

function toString

QString toString(
    ModuleCategory category
)

function moduleCategoryFromString

ModuleCategory moduleCategoryFromString(
    const QString & categoryStr
)

function moduleCategoriesFromString

ModuleCategories moduleCategoriesFromString(
    const QString & categoriesStr
)

function qHash

inline uint qHash(
    ModuleModifier key,
    uint seed
)

function newStreamForType

VariantDataStream * newStreamForType(
    int typeId
)

Create a new DataStream for the type identified by the given ID.

function newInputPortForType

VarStreamInputPort * newInputPortForType(
    int typeId,
    AbstractModule * mod,
    const QString & id,
    const QString & title
)

Create a new Input Port for the type identified by the given ID.

function streamDataFromRawMemory

template <typename T >
T streamDataFromRawMemory(
    const void * data,
    size_t size
)

Convert raw received bytes into their data type.

function initSyntalosModuleLink

std::unique_ptr< SyntalosLink > initSyntalosModuleLink()

Attributes Documentation

variable US_PER_MS

constexpr int64_t US_PER_MS = 1'000;

variable US_PER_S

constexpr int64_t US_PER_S = 1'000 * US_PER_MS;

variable US_PER_MIN

constexpr int64_t US_PER_MIN = 60 * US_PER_S;

variable US_PER_H

constexpr int64_t US_PER_H = 60 * US_PER_MIN;

variable NS_PER_US

constexpr int64_t NS_PER_US = 1'000;

variable MS_PER_S

constexpr int64_t MS_PER_S = 1'000;

variable MS_PER_MIN

constexpr int64_t MS_PER_MIN = 60 * MS_PER_S;

variable SECONDARY_CLOCK_TOLERANCE

static constexpr auto SECONDARY_CLOCK_TOLERANCE = microseconds_t(1000);

The amount of time a secondary clock is allowed to deviate from the master.

Since Syntalos uses millisecond time resolution, permitting (slightly more than) half a millisecond deviation for secondary clocks from the master clock is sensible.

IMPORTANT: Modules may override this value for their synchronizers to one that fits their device better. This is just a default for modules which do not change the default setting.

variable DEFAULT_CLOCKSYNC_CHECK_INTERVAL

static constexpr auto DEFAULT_CLOCKSYNC_CHECK_INTERVAL = milliseconds_t(4000);

Interval at which we check for external clock synchronization.

IMPORTANT: This is just a default value for modules which do not explicitly define a check interval. Individual modules may choose a different value that fits the device they are communicating with best.

variable SY_IOX_QUEUE_CAPACITY

static constexpr uint64_t SY_IOX_QUEUE_CAPACITY = 12U;

variable SY_IOX_HISTORY_SIZE

static constexpr uint64_t SY_IOX_HISTORY_SIZE = 2U;

variable SY_IOX_INITIAL_SLICE_LEN

static constexpr uint64_t SY_IOX_INITIAL_SLICE_LEN = 4096;

variable SY_IOX_ID_MAX_LEN

static constexpr size_t SY_IOX_ID_MAX_LEN = IOX2_SERVICE_NAME_LENGTH;

variable IN_PORT_CHANGE_CHANNEL_ID

static const std::string IN_PORT_CHANGE_CHANNEL_ID = "InPortChange";

variable OUT_PORT_CHANGE_CHANNEL_ID

static const std::string OUT_PORT_CHANGE_CHANNEL_ID = "OutPortChange";

variable IN_PORT_UPDATE_METADATA_ID

static const std::string IN_PORT_UPDATE_METADATA_ID = "UpdateInputPortMetadata";

variable WORKER_CTL_EVENT_ID

static const std::string WORKER_CTL_EVENT_ID = "worker-event";

Shared wakeup event service names for the control channel.

WORKER_CTL_EVENT_ID - the worker notifies the master whenever it publishes on a control channel (error, state, port-changes …). The master attaches one listener for this to its WaitSet.

MASTER_CTL_EVENT_ID - the master notifies the worker whenever it sends a request (request-response commands).

variable MASTER_CTL_EVENT_ID

static const std::string MASTER_CTL_EVENT_ID = "master-event";

variable ERROR_CHANNEL_ID

static const std::string ERROR_CHANNEL_ID = "Error";

variable STATE_CHANNEL_ID

static const std::string STATE_CHANNEL_ID = "State";

variable STATUS_MESSAGE_CHANNEL_ID

static const std::string STATUS_MESSAGE_CHANNEL_ID = "StatusMessage";

variable SET_NICENESS_CALL_ID

static const std::string SET_NICENESS_CALL_ID = "SetNiceness";

variable SET_MAX_RT_PRIORITY_CALL_ID

static const std::string SET_MAX_RT_PRIORITY_CALL_ID = "SetMaxRealtimePriority";

variable SET_CPU_AFFINITY_CALL_ID

static const std::string SET_CPU_AFFINITY_CALL_ID = "SetCPUAffinity";

variable DELETE_PORT_CALL_ID

static const std::string DELETE_PORT_CALL_ID = "DeletePort";

variable CONNECT_INPUT_CALL_ID

static const std::string CONNECT_INPUT_CALL_ID = "ConnectInputPort";

variable LOAD_SCRIPT_CALL_ID

static const std::string LOAD_SCRIPT_CALL_ID = "LoadScript";

variable SET_PORTS_PRESET_CALL_ID

static const std::string SET_PORTS_PRESET_CALL_ID = "SetPortsPresetRequest";

variable PREPARE_START_CALL_ID

static const std::string PREPARE_START_CALL_ID = "PrepareStart";

variable START_CALL_ID

static const std::string START_CALL_ID = "Start";

variable STOP_CALL_ID

static const std::string STOP_CALL_ID = "Stop";

variable SHUTDOWN_CALL_ID

static const std::string SHUTDOWN_CALL_ID = "Shutdown";

variable SETTINGS_CHANGE_CHANNEL_ID

static const std::string SETTINGS_CHANGE_CHANNEL_ID = "SettingsChange";

variable SHOW_SETTINGS_CALL_ID

static const std::string SHOW_SETTINGS_CALL_ID = "ShowSettings";

variable SHOW_DISPLAY_CALL_ID

static const std::string SHOW_DISPLAY_CALL_ID = "ShowDisplay";

Updated on 2026-03-16 at 19:16:01 +0000