void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
rtsys = getrtsys() ; // Get pointer to rtsys
if (rtsys==NULL) {
return;
}
// Check number and type of arguments.
if (nrhs != 2) {
MEX_ERROR("ttCreateMonitor: Wrong number of input arguments!\nUsage: ttCreateMonitor(monitorname, display)");
return;
}
if (mxIsChar(prhs[0]) != 1) {
MEX_ERROR("ttCreateMonitor: monitorname must be a string");
return;
}
if (!mxIsDoubleScalar(prhs[1])) {
MEX_ERROR("ttCreateMonitor: display must be an integer scalar");
return;
}
char monitorname[100];
mxGetString(prhs[0], monitorname, 100);
int display = (int) *mxGetPr(prhs[1]);
if (display == 0) {
ttCreateMonitor(monitorname, false);
} else {
ttCreateMonitor(monitorname, true);
}
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
rtsys = getrtsys() ; // Get pointer to rtsys
if (rtsys==NULL) {
return;
}
// Check number and type of arguments.
if (nrhs != 1) {
MEX_ERROR("ttGive: Wrong number of input arguments!\nUsage: ttGive(sempahorename)");
return;
}
if (mxIsChar(prhs[0]) != 1 || mxGetM(prhs[0]) != 1) {
MEX_ERROR("ttGive: sempahorename must be a non-empty string");
return;
}
char sempahorename[100];
mxGetString(prhs[0], sempahorename, 100);
ttGive(sempahorename);
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
rtsys = getrtsys() ; // Get pointer to rtsys
if (rtsys==NULL) {
return;
}
// Check number and type of arguments.
if (nrhs != 1) {
MEX_ERROR("ttLogStop: Wrong number of input arguments!\nUsage: ttLogStop(logID)");
return;
}
int ID = 0;
if (mxIsDoubleScalar(prhs[0])) {
ID = (int)*mxGetPr(prhs[0]);
}
if (ID <= 0) {
MEX_ERROR("ttLogStop: logID must be a positive number");
return;
}
ttLogStop(ID);
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
rtsys = getrtsys() ; // Get pointer to rtsys
if (rtsys==NULL) {
return;
}
// Check number and type of arguments.
if (nrhs != 1) {
MEX_ERROR("ttNotify: Wrong number of input arguments!\nUsage: ttNotify(eventname)");
return;
}
if (mxIsChar(prhs[0]) != 1) {
MEX_ERROR("ttNotify: eventname must be a string");
return;
}
char eventname[100];
mxGetString(prhs[0], eventname, 100);
ttNotify(eventname);
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
rtsys = getrtsys() ; // Get pointer to rtsys
if (rtsys==NULL) {
return;
}
// Check number and type of arguments.
if (nrhs != 2) {
MEX_ERROR("ttAttachDLHandler: Wrong number of input arguments!\nUsage: ttAttachDLHandler(taskname, handlername)");
return;
}
if (mxIsChar(prhs[0]) != 1 || mxGetM(prhs[0]) != 1) {
MEX_ERROR("ttAttachDLHandler: taskname must be a non-empty string");
return;
}
if (mxIsChar(prhs[1]) != 1 || mxGetM(prhs[1]) != 1) {
MEX_ERROR("ttAttachDLHandler: handlername must be a non-empty string");
return;
}
char taskname[100];
char handlername[100];
mxGetString(prhs[0], taskname, 100);
mxGetString(prhs[1], handlername, 100);
ttAttachDLHandler(taskname, handlername);
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
double value;
char parametername[100];
rtsys = getrtsys(); // Get pointer to rtsys
if (rtsys==NULL) {
return;
}
// Check number and type of arguments.
if (nrhs < 2 || nrhs > 2) {
MEX_ERROR("ttSetKernelParameter: Wrong number of input arguments!\nUsage: ttSetKernelParameter(parameter, value)");
return;
}
if (mxIsChar(prhs[0]) != 1) {
MEX_ERROR("ttSetKernelParameter: parameter name must be a string");
return;
}
mxGetString(prhs[0], parametername, 100);
if (!mxIsDouble(prhs[1])) {
MEX_ERROR("ttSetKernelParameter: value must be a double");
return;
}
value = (double)*mxGetPr(prhs[1]);
//printf("%s, %f\n", parametername, value);
ttSetKernelParameter(parametername, value);
//printf("%s:%d\n", __FILE__,__LINE__);
}
void ttNoSchedule(char* name) {
DataNode* dn1, *dn2;
UserTask* task;
InterruptHandler* handler;
// can only be called during initialization phase
if (!rtsys->init_phase) {
MEX_ERROR("ttNoSchedule: Can only be called from the init-function!");
return;
}
dn1 = getNode(name, rtsys->taskList);
dn2 = getNode(name, rtsys->handlerList);
if (dn1 == NULL && dn2 == NULL) {
char buf[200];
sprintf(buf, "ttNoSchedule: Non-existent task or handler '%s'\n", name);
MEX_ERROR(buf);
}
if (dn1 != NULL) {
task = (UserTask*) dn1->data;
task->display = false;
rtsys->nbrOfSchedTasks--;
}
if (dn2 != NULL) {
handler = (InterruptHandler*) dn2->data;
handler->display = false;
rtsys->nbrOfSchedHandlers--;
}
}
// Matlab gateway function
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
//mexPrintf("I'm Running!\n");
// Get the command string
char cmd[64];
if (nrhs < 1 || mxGetString(prhs[0], cmd, sizeof(cmd)))
{
MEX_ERROR("First input should be a command string less than 64 characters long.");
}
//--- Standard Functions ---//
// Command: New
if (!strcmp("new", cmd))
{
return CommandNew(nlhs, plhs, nrhs, prhs);
}
// All Other Comamnds:
// 2nd input must be class instance handle
if (nrhs < 2)
{
MEX_ERROR("ERROR: Second input should be a class instance handle.");
}
// Command: Delete
if (!strcmp("delete", cmd))
{
return CommandDelete(nlhs, plhs, nrhs, prhs);
}
//--- ICP Methods ---//
// Command: Initialize
if (!strcmp("Initialize", cmd))
{
return CommandInitialize(nlhs, plhs, nrhs, prhs);
}
// Command: Match
if (!strcmp("ComputeMatches", cmd))
{
return CommandComputeMatches(nlhs, plhs, nrhs, prhs);
}
MEX_ERROR("ERROR: Command not recognized.");
//// Command: Template
//if (!strcmp("template", cmd))
//{
// return CommandInitialize( nlhs, plhs, nrhs, prhs );
//}
}
bool ttCreateTask(char *name, double deadline, double priority, double (*codeFcn)(int, void*)) {
UserTask* task;
if (strcmp(name,"") == 0) {
MEX_ERROR("ttCreate(Periodic)Task: Name should be a non-empty string!");
return false;
}
if (rtsys->prioFcn == NULL) {
MEX_ERROR("ttCreate(Periodic)Task: Kernel must be initialized before creation of tasks!");
return false;
}
DataNode* dn = getNode(name, rtsys->taskList);
if (dn != NULL) {
MEX_ERROR("ttCreate(Periodic)Task: Name of task not unique! Task not created!");
return false;
}
if (priority < EPS) {
MEX_ERROR("ttCreate(Periodic)Task: Priorities are supposed to be positive real numbers!");
return false;
}
task = new UserTask(name);
task->codeFcn = codeFcn;
task->priority = priority;
task->wcExecTime = deadline;
task->deadline = deadline;
task->state = IDLE;
task->taskID = rtsys->nbrOfTasks + 1;
task->isPreemptable = true;
task->display = true;
task->lastStart = 0.0;
task->absDeadline = deadline;
task->release = 0.0;
task->budget = deadline;
task->arrival_hook = rtsys->default_arrival;
task->release_hook = rtsys->default_release;
task->start_hook = rtsys->default_start;
task->suspend_hook = rtsys->default_suspend;
task->resume_hook = rtsys->default_resume;
task->finish_hook = rtsys->default_finish;
rtsys->taskList->appendNode(new DataNode(task, task->name));
rtsys->nbrOfSchedTasks++;
rtsys->nbrOfTasks++;
return true;
}
void ttTake(char *nameOfSemaphore) {
Semaphore* sem;
UserTask* task;
DataNode* dn = getNode(nameOfSemaphore, rtsys->semaphoreList);
if (dn == NULL) {
// Semaphore does not exist
char buf[200];
sprintf(buf, "ttTake: Non-existent semaphore '%s'!", nameOfSemaphore);
MEX_ERROR(buf);
return;
}
task = (UserTask*) rtsys->running;
sem = (Semaphore*) dn->data;
sem->value--;
if (sem->value < 0) { // Not free
task->moveToList(sem->waitingQ);
task->state = WAITING;
// Execute suspend hook
task->suspend_hook(task);
}
}
static void
mex_telepathy_channel_on_contact_fetched (TpConnection *connection,
guint n_contacts,
TpContact *const *contacts,
guint n_failed,
const TpHandle *failed,
const GError *fetched_error,
gpointer user_data,
GObject *weak_object)
{
MexTelepathyChannel *self = MEX_TELEPATHY_CHANNEL (user_data);
int i = 0;
if (self->priv->channel)
{
for (i = 0; i < n_contacts; ++i)
{
gchar *text;
const gchar *alias;
TpContact *current;
GFile *file;
// Get the contacts.
current = contacts[i];
// Connect to alias change signal.
// Add the alias to the label.
alias = tp_contact_get_alias (current);
mx_label_set_text (MX_LABEL (self->priv->title_label),
alias);
if (tp_channel_get_requested(self->priv->channel))
text = g_strdup_printf ("Calling %s", alias);
else
text = g_strdup_printf ("Setting up call with %s", alias);
mx_label_set_text (MX_LABEL (self->priv->busy_label), text);
g_free (text);
file = tp_contact_get_avatar_file (current);
if (file)
{
gchar *filename = g_file_get_path (file);
GError *error = NULL;
MEX_DEBUG ("setting new avatar filename to %s", filename);
mx_image_set_from_file (MX_IMAGE(self->priv->avatar_image),
filename,
&error);
if (error)
{
MEX_ERROR ("ERROR %s loading avatar from file %s\n",
error->message, filename);
g_clear_error (&error);
}
if (filename)
g_free (filename);
}
}
}
}
void ttAnalogOut(int outputChan, double value) {
if (outputChan < 1 || outputChan > rtsys->nbrOfOutputs) {
MEX_ERROR("ttAnalogOut: outpChan out of bounds");
return;
}
rtsys->outputs[outputChan-1] = value;
}
double ttAnalogIn(int inputNbr) {
if (inputNbr < 1 || inputNbr > rtsys->nbrOfInputs) {
MEX_ERROR("ttAnalogIn: inpChan out of bounds");
return 0.0;
}
return rtsys->inputs[inputNbr-1];
}
void ttExitMonitor(char *nameOfMonitor) {
Monitor* mon;
UserTask* task;
DataNode* dn = getNode(nameOfMonitor, rtsys->monitorList);
if (dn == NULL) {
// Monitor does not exist
char buf[200];
sprintf(buf, "ttExitMonitor: Non-existent monitor '%s'!", nameOfMonitor);
MEX_ERROR(buf);
return;
}
task = (UserTask*) rtsys->running;
mon = (Monitor*) dn->data;
if (mon->heldBy != task) {
char buf[200];
sprintf(buf, "ttExitMonitor: Task '%s' not holding monitor '%s'!", task->name, nameOfMonitor);
MEX_ERROR(buf);
return;
}
// Priority Inheritance, reset
task->tempPrio = 0.0;
task->prioRaised = false;
// Reshuffle readyQ
if (task->myList == rtsys->readyQ) {
task->moveToList(rtsys->readyQ);
}
mon->heldBy = NULL;
// Move first waiting task to readyQ
task = (UserTask*) mon->waitingQ->getFirst();
if (task != NULL) {
task->moveToList(rtsys->readyQ);
task->state = READY;
mon->heldBy = task;
}
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
int network;
double value;
char parametername[100];
rtsys = getrtsys(); // Get pointer to rtsys
if (rtsys==NULL) {
return;
}
// Check number and type of arguments.
if (nrhs < 2 || nrhs > 3) {
MEX_ERROR("ttSetNetworkParameter: Wrong number of input arguments!\nUsage: ttSetNetworkParameter(parameter, value) or\n ttSetNetworkParameter(network, parameter, value)");
return;
}
if (mxIsChar(prhs[nrhs-2]) != 1) {
MEX_ERROR("ttSetNetworkParameter: parameter name must be a string");
return;
}
mxGetString(prhs[nrhs-2], parametername, 100);
if (nrhs == 2){ // no network specified
if (!mxIsDouble(prhs[1])){
MEX_ERROR("ttSetNetworkParameter: value must be a double");
return;
}
network = 1;
value = (double)*mxGetPr(prhs[1]);
} else { // the network is specified
if (!mxIsDouble(prhs[0]) || !mxIsDouble(prhs[2])){
MEX_ERROR("ttSetNetworkParameter: network must be a double\n value must be a double");
return;
}
network = (int)*mxGetPr(prhs[0]);
value = (double)*mxGetPr(prhs[2]);
}
//printf("%d, %s, %f\n", network, parametername, value);
ttSetNetworkParameter(network, parametername, value);
//printf("%s:%d\n", __FILE__,__LINE__);
}
// get priority of calling task
double ttGetPriority() {
if (!rtsys->running->isUserTask()) {
MEX_ERROR("ttGetPriority: Can not be called by interrupt handler!");
return 0.0;
}
UserTask* task = (UserTask*) (rtsys->running);
return task->priority;
}
// get absolute deadline of specific task
double ttGetAbsDeadline(char *nameOfTask) {
DataNode* dn = getNode(nameOfTask, rtsys->taskList);
if (dn == NULL) {
char buf[200];
sprintf(buf, "ttGetAbsDeadline: Non-existent task '%s'!", nameOfTask);
MEX_ERROR(buf);
return 0.0;
}
UserTask* task = (UserTask*) dn->data;
if (task->nbrJobs == 0) {
char buf[200];
sprintf(buf, "ttGetAbsDeadline: No running job of task '%s'!", nameOfTask);
MEX_ERROR(buf);
return 0.0;
}
return task->absDeadline;
}
// get absolute deadline of calling task
double ttGetAbsDeadline() {
if (!rtsys->running->isUserTask()) {
MEX_ERROR("ttGetAbsDeadline: Can not be called by interrupt handler!");
return 0.0;
}
UserTask* task = (UserTask*) (rtsys->running);
return task->absDeadline;
}
void ttSetNetworkParameter(int networkNbr, char* parameter, double value)
{
Network* net = getNetwork(networkNbr);
if (net == NULL) {
char buf[200];
sprintf(buf, "ttSendMsg: Network #%d not present!", networkNbr);
MEX_ERROR(buf);
return;
}
//printf("%d\n",(int)net);
nwSetNetworkParameter(net, parameter, value);
}
void ttCreateLog(char* taskname, int logtype, char* variable, int size) {
DataNode* dn;
UserTask* task;
char buf[100];
// can only be called during initialization phase
if (!rtsys->init_phase) {
MEX_ERROR("ttCreateLog: Can only be called from the init-function!");
return;
}
if (logtype > USERLOG || logtype < RESPONSETIMELOG) {
sprintf(buf,"ttCreateLog: unknown log type %d", logtype);
MEX_ERROR(buf);
return;
}
dn = getNode(taskname, rtsys->taskList);
if (dn == NULL) {
sprintf(buf, "ttCreateLog: Non-existent task '%s'", taskname);
MEX_ERROR(buf);
return;
}
task = (UserTask*) dn->data;
if (logtype != USERLOG) {
if (task->logs[logtype-1] != NULL) {
MEX_ERROR("ttCreateLog: log already assigned");
return;
}
task->logs[logtype-1] = new Log(variable, size);
} else {
if (task->nbrOfUserLogs == NBRUSERLOGS) {
sprintf(buf, "ttCreateLog: Maximum number of user logs exceeded! Can not create log variable %s for task %s", variable, taskname);
MEX_ERROR(buf);
return;
}
task->logs[task->nbrOfUserLogs+5] = new Log(variable, size);
task->nbrOfUserLogs++;
}
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
rtsys = getrtsys() ; // Get pointer to rtsys
if (rtsys==NULL) {
return;
}
// Check number and type of arguments.
if (nrhs < 2 || nrhs > 3 ) {
MEX_ERROR("ttCreateSemaphore: Wrong number of input arguments!\nUsage: ttCreateSemaphore(semaphorename, initval [, maxval])");
return;
}
if (mxIsChar(prhs[0]) != 1) {
MEX_ERROR("ttCreateSemaphore: semaphorename must be a string");
return;
}
if (!mxIsDoubleScalar(prhs[1])) {
MEX_ERROR("ttCreateSemaphore: initval must be an integer scalar");
return;
}
if (nrhs == 3) {
if (!mxIsDoubleScalar(prhs[2])) {
MEX_ERROR("ttCreateSemaphore: maxval must be an integer scalar");
return;
}
}
char semaphorename[100];
mxGetString(prhs[0], semaphorename, 100);
int initval = (int) *mxGetPr(prhs[1]);
if (nrhs == 2) {
ttCreateSemaphore(semaphorename, initval);
} else {
int maxval = (int) *mxGetPr(prhs[2]);
ttCreateSemaphore(semaphorename, initval, maxval);
}
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
mxArray* data;
int network;
rtsys = getrtsys(); // Get pointer to rtsys
if (rtsys==NULL) {
return;
}
// Check number and type of arguments.
if (nrhs > 1) {
MEX_ERROR("ttGetMsg: Wrong number of input arguments!\nUsage: ttGetMsg or\n ttGetMsg(network)");
return;
}
if (nrhs == 1) {
if (!mxIsDoubleScalar(prhs[0])) {
MEX_ERROR("ttGetMsg: network must be an integer scalar");
return;
}
network = (int) *mxGetPr(prhs[0]);
} else {
network = 1;
}
double signalPower;
data = ttGetMsgMATLAB(network, &signalPower);
if ( data==NULL ) {
data = mxCreateDoubleMatrix(0,0,mxREAL); // Return empty matrix
}
plhs[0] = data;
if ( nlhs>=2 ) {
plhs[1] = mxCreateDoubleScalar(signalPower);
}
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
double value;
rtsys = getrtsys() ; // Get pointer to rtsys
if (rtsys==NULL) {
return;
}
// Check number and type of arguments.
if (nrhs == 0 || nrhs > 2) {
MEX_ERROR("ttSetDeadline: Wrong number of input arguments!\nUsage: ttSetDeadline(value) or ttSetDeadline(value, taskname)");
return;
}
if (!mxIsDoubleScalar(prhs[0])) {
MEX_ERROR("ttSetDeadline: value must be a number");
return;
}
if (nrhs == 1) {
value = *mxGetPr(prhs[0]);
ttSetDeadline(value);
} else {
if (mxIsChar(prhs[1]) != 1 || mxGetM(prhs[1]) != 1) {
MEX_ERROR("ttSetDeadline: taskname must be a string");
return;
}
value = *mxGetPr(prhs[0]);
char taskname[100];
mxGetString(prhs[1], taskname, 100);
ttSetDeadline(value, taskname);
}
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
rtsys = getrtsys() ; // Get pointer to rtsys
if (rtsys==NULL) {
return;
}
// Check number and type of arguments.
if (nrhs < 1 || nrhs > 2) {
MEX_ERROR("ttCreateEvent: Wrong number of input arguments!\nUsage: ttCreateEvent(eventname) or ttCreateEvent(eventname, monitorname)");
return;
}
if (mxIsChar(prhs[0]) != 1) {
MEX_ERROR("ttCreateEvent: eventname must be a string");
return;
}
if (nrhs == 2) {
if (mxIsChar(prhs[1]) != 1) {
MEX_ERROR("ttCreateEvent: monitorname must be a string");
return;
}
}
char eventname[100];
mxGetString(prhs[0], eventname, 100);
if (nrhs == 1) {
ttCreateEvent(eventname);
} else {
char monitorname[100];
mxGetString(prhs[1], monitorname, 100);
ttCreateEvent(eventname, monitorname);
}
}
// get priority of specific task
double ttGetPriority(char *nameOfTask) {
DataNode* dn = getNode(nameOfTask, rtsys->taskList);
if (dn == NULL) {
char buf[200];
sprintf(buf, "ttGetPriority: Non-existent task '%s'!", nameOfTask);
MEX_ERROR(buf);
return 0.0;
}
UserTask* task = (UserTask*) dn->data;
return task->priority;
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
double retval;
rtsys = getrtsys() ; // Get pointer to rtsys
if (rtsys==NULL) {
return;
}
// Check number and type of arguments.
if (nrhs > 1) {
MEX_ERROR("ttGetWCET: Wrong number of input arguments!\nUsage: ttGetWCET or ttGetWCET(taskname)");
return;
}
if (nrhs == 0) {
retval = ttGetWCET();
plhs[0] = mxCreateDoubleScalar(retval);
} else {
if (mxIsChar(prhs[0]) != 1 || mxGetM(prhs[0]) != 1) {
MEX_ERROR("ttGetWCET: taskname must be a string");
return;
}
char taskname[100];
mxGetString(prhs[0], taskname, 100);
retval = ttGetWCET(taskname);
plhs[0] = mxCreateDoubleScalar(retval);
}
}
void CommandNew(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{ // create new class instance
// Expected Input:
// cmd
// Check parameters
if (nlhs != 1 || nrhs != 1)
{
MEX_ERROR("New: requires 1 outputs, 1 inputs.");
}
// Return a handle to a new C++ instance
plhs[0] = convertPtr2Mat < mexInterface_AlgPDTree_MLP_Mesh >
(new mexInterface_AlgPDTree_MLP_Mesh);
}
static gboolean
mex_telepathy_channel_on_bus_watch (GstBus *bus,
GstMessage *message,
gpointer user_data)
{
MexTelepathyChannel *self = MEX_TELEPATHY_CHANNEL (user_data);
MexTelepathyChannelPrivate *priv = self->priv;
if (priv->tf_channel != NULL)
tf_channel_bus_message (priv->tf_channel, message);
if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ERROR)
{
GError *error = NULL;
gchar *debug = NULL;
gst_message_parse_error (message, &error, &debug);
MEX_ERROR ("ERROR from element %s: %s\n",
GST_OBJECT_NAME (message->src), error->message);
MEX_ERROR ("Debugging info: %s\n", (debug) ? debug : "none");
g_error_free (error);
g_free (debug);
}
return TRUE;
}
void ttLogStart(int logID) {
UserTask* usertask;
if (logID < 1 || logID > NBRUSERLOGS) {
MEX_ERROR("ttLogStart: Log ID out of bounds!");
return;
}
if (rtsys->running->isUserTask()) {
usertask = (UserTask*) rtsys->running;
logstart(usertask, logID+5); // 5 pre-defined log types
} else {
printf("ttLogStart: Call from interrupt handler ignored!\n");
return;
}
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
rtsys = getrtsys() ; // Get pointer to rtsys
if (rtsys==NULL) {
return;
}
// Check number and type of arguments.
if (nrhs != 1) {
MEX_ERROR("ttSleepUntil: Wrong number of input arguments!\nUsage: ttSleepUntil(time)");
return;
}
if (!mxIsDoubleScalar(prhs[0])) {
MEX_ERROR("ttSleepUntil: time must be a number");
return;
}
double time = *mxGetPr(prhs[0]);
ttSleepUntil(time);
}