Пример #1
0
CCmd::CCmd()
{
	resetCmd(_cmd);
	registerCmd(HELP_CMDID,"HELP",&helpCmd);
	//registerCmd(NOLOG_CMDID,"NOLOG",&noLogCmd);
	registerCmd(EXIT_CMDID,"EXIT",&exitCmd);
#if CMD_DEBUG
	printf("(C)Copyright ASUSTEK Hunter_Chen 2009.\n");
#endif
}
Пример #2
0
static int cmdDestructor(MprCmd *cmd)
{
    MprCmdService   *cs;

    resetCmd(cmd);
#if VXWORKS
    vxCmdDestructor(cmd);
#endif
    cs = mprGetMpr(cmd)->cmdService;
    mprLock(cs->mutex);
    mprRemoveItem(cs->cmds, cmd);
    mprUnlock(cs->mutex);
    return 0;
}
Пример #3
0
void Graphical_UI::createProcessingMenu() {
    QMenu* pm = menuBar()->addMenu(tr("&Processing"));
    newMenuItem(pm, "&Reset",
                SLOT(resetCmd()),
                "Reset the graph, clear all data collected",
                "Ctrl+R",
                QIcon::fromTheme("edit-delete"));

    newMenuItem(pm, "&Process",
                this,
                SLOT(pause(bool)),
                "Start/stop processing of frames",
                !ParameterServer::instance()->get<bool>("start_paused"),
                " ",
                QIcon::fromTheme("media-playback-start"));

    newMenuItem(pm, "Capture One& Frame",
                SLOT(getOneFrameCmd()),
                "Process one frame only",
                QKeySequence::InsertParagraphSeparator);
                
                              
    /* Crashes
    newMenuItem(pm, "&Delete Last Node",
                SLOT(deleteLastFrameCmd()),
                "Remove last node from graph",
                "Backspace",
                QIcon::fromTheme("edit-undo"));
                */
    pm->addSeparator();
                              
    newMenuItem(pm, "Clear Cloud Storage",
                SIGNAL(clearClouds()),
                "Remove Point Clouds from Memory",
                "",
                QIcon::fromTheme("edit-delete"));

    newMenuItem(pm, "Optimize Trajectory &Estimate",
                SLOT(optimizeGraphTrig()),
                "Compute optimized pose graph with g2o",
                "O");
                
    pm->addSeparator();

    newMenuItem(pm, "E&xit",
                SLOT(close()),
                "Exit the application",
                "Ctrl+Q",
                QIcon::fromTheme("application-exit"));//doesn't work for gnome
}
Пример #4
0
void GetCmd(){
	char input;
	resetCmd();
	while ((input != '\n') && (buffSize < INPUT_MAX_LENGTH)) {
		buffer[buffSize++] = input;
		input = getc();
	}
	buffer[buffSize] = '\0';     
	char* bufferTemp; //
	bufferTemp = strtok(buffer, " ");
	while (bufferTemp != NULL) {  
		cmdArgv[cmdArgc] = bufferTemp; //On stock les arguments
		bufferTemp = strtok(NULL, " ");
		cmdArgc++;
	}
}
Пример #5
0
static void manageCmd(MprCmd *cmd, int flags)
{
    int             i;

    if (flags & MPR_MANAGE_MARK) {
        mprMark(cmd->program);
        mprMark(cmd->makeArgv);
        mprMark(cmd->defaultEnv);
        mprMark(cmd->dir);
        mprMark(cmd->env);
        for (i = 0; i < MPR_CMD_MAX_PIPE; i++) {
            mprMark(cmd->files[i].name);
        }
        for (i = 0; i < MPR_CMD_MAX_PIPE; i++) {
            mprMark(cmd->handlers[i]);
        }
        mprMark(cmd->dispatcher);
        mprMark(cmd->callbackData);
        mprMark(cmd->signal);
        mprMark(cmd->forkData);
        mprMark(cmd->stdoutBuf);
        mprMark(cmd->stderrBuf);
        mprMark(cmd->userData);
        mprMark(cmd->mutex);
        mprMark(cmd->searchPath);
#if ME_WIN_LIKE
        mprMark(cmd->command);
#endif
        mprMark(cmd->argv);
        for (i = 0; cmd->argv && i < cmd->argc; i++) {
            mprMark(cmd->argv[i]);
        }

    } else if (flags & MPR_MANAGE_FREE) {
        resetCmd(cmd, 1);
#if VXWORKS
        if (cmd->startCond) {
            semDelete(cmd->startCond);
        }
        if (cmd->exitCond) {
            semDelete(cmd->exitCond);
        }
#endif
    }
}
Пример #6
0
/*
    Start the command to run (stdIn and stdOut are named from the client's perspective). This is the lower-level way to
    run a command. The caller needs to do code like mprRunCmd() themselves to wait for completion and to send/receive data.
    The routine does not wait. Callers must call mprWaitForCmd to wait for the command to complete.
 */
PUBLIC int mprStartCmd(MprCmd *cmd, int argc, cchar **argv, cchar **envp, int flags)
{
    MprPath     info;
    cchar       *pair;
    int         rc, next, i;

    assert(cmd);
    assert(argv);

    if (argc <= 0 || argv == NULL || argv[0] == NULL) {
        return MPR_ERR_BAD_ARGS;
    }
    resetCmd(cmd, 0);

    cmd->flags = flags;
    cmd->argc = argc;
    cmd->argv = mprAlloc((argc + 1) * sizeof(char*));
    for (i = 0; i < argc; i++) {
        cmd->argv[i] = sclone(argv[i]);
    }
    cmd->argv[i] = 0;

    prepWinProgram(cmd);

    if ((cmd->program = mprSearchPath(cmd->argv[0], MPR_SEARCH_EXE, cmd->searchPath, NULL)) == 0) {
        mprLog("error mpr cmd", 0, "Cannot access %s, errno %d", cmd->argv[0], mprGetOsError());
        return MPR_ERR_CANT_ACCESS;
    }
    if (mprGetPathInfo(cmd->program, &info) == 0 && info.isDir) {
        mprLog("error mpr cmd", 0, "Program \"%s\", is a directory", cmd->program);
        return MPR_ERR_CANT_ACCESS;
    }
    mprLog("info mpr cmd", 6, "Program: %s", cmd->program);
    cmd->argv[0] = cmd->program;

    prepWinCommand(cmd);

    if (envp == 0) {
        envp = cmd->defaultEnv;
    }
    if (blendEnv(cmd, envp, flags) < 0) {
        return MPR_ERR_MEMORY;
    }
    for (i = 0; i < cmd->argc; i++) {
        mprLog("info mpr cmd", 6, "    arg[%d]: %s", i, cmd->argv[i]);
    }
    for (ITERATE_ITEMS(cmd->env, pair, next)) {
        mprLog("info mpr cmd", 6, "    env[%d]: %s", next, pair);
    }
    slock(cmd);
    if (makeCmdIO(cmd) < 0) {
        sunlock(cmd);
        return MPR_ERR_CANT_OPEN;
    }
    /*
        Determine how many end-of-files will be seen when the child dies
     */
    cmd->requiredEof = 0;
    if (cmd->flags & MPR_CMD_OUT) {
        cmd->requiredEof++;
    }
    if (cmd->flags & MPR_CMD_ERR) {
        cmd->requiredEof++;
    }
    if (addCmdHandlers(cmd) < 0) {
        mprLog("error mpr cmd", 0, "Cannot open command handlers - insufficient I/O handles");
        return MPR_ERR_CANT_OPEN;
    }
    rc = startProcess(cmd);

    cmd->originalPid = cmd->pid;
    mprAddItem(MPR->cmdService->cmds, cmd);
    sunlock(cmd);
#if ME_WIN_LIKE
    if (!rc) {
        mprCreateTimerEvent(cmd->dispatcher, "pollWinTimer", 10, pollWinTimer, cmd, 0);
    }
#endif
    return rc;
}
Пример #7
0
PUBLIC void mprDestroyCmd(MprCmd *cmd)
{
    assert(cmd);
    resetCmd(cmd, 0);
    mprRemoveItem(MPR->cmdService->cmds, cmd);
}
Пример #8
0
  static int syncOVS(EVMod *mod)
  {
    HSP_mod_OVS *mdata = (HSP_mod_OVS *)mod->data;
    resetCmd(mod);
    resetExtras(mod);
    char line[SFVS_MAX_LINELEN];

    myDebug(1, "==== ovs-vsctl version ====");
    char *version_cmd[] = { SFVS_OVS_CMD, "--version", NULL};
    // don't abort if this fails: readVersion returns NO as an easy way
    // to only see the first line. (Line number should really be supplied to
    // callback from myExec)
    mdata->ovs10 = NO; // assume newer version
    mdata->usingAtVar = NO;
    myExec((void *)mod, version_cmd, readVersion, line, SFVS_MAX_LINELEN, NULL);
    // adapt if OVS is upgraded under our feet
    if(mdata->ovs10 == NO) mdata->useAtVar = YES;
    if(mdata->config.error
       || mdata->config.num_collectors == 0
       || (mdata->config.sampling_n == 0 && mdata->config.polling_secs == 0)) {
      // no config or no targets or no sampling/polling - clear everything
      myDebug(1, "no config found: clearing all OVS sFlow config");
      setStr(&mdata->sflowUUID, "[]");
      setState(mod, SFVSSTATE_SYNC_DESTROY);
    }
    else {
      // got config - assume here that we're going to create a new
      // sflow object, but if we find one we'll adopt it
      setStr(&mdata->sflowUUID, SFVS_NEW_SFLOW_ID);
      setState(mod, SFVSSTATE_SYNC_SEARCH);
    }
    myDebug(1, "==== list sflow ====");
    char *list_sflow_cmd[] = { SFVS_OVS_CMD, "list", "sflow", NULL };
    if(myExec((void *)mod, list_sflow_cmd, sFlowList, line, SFVS_MAX_LINELEN, NULL) == NO) return NO;

    if(mdata->useAtVar) {
      // we can add the create at the end
    }
    else {
      // create new sFlow object if there were none found (i.e. if
      // the sflowUUID has not changed from the initial setting we
      // gave it.
      if(strcmp(SFVS_NEW_SFLOW_ID, mdata->sflowUUID) == 0) {
	addCreateSFlow(mod);
	logCmd(mod);
	strArrayAdd(mdata->cmd, NULL); // for execve(2)
	if(myExec((void *)mod, strArray(mdata->cmd), submitCreate, line, SFVS_MAX_LINELEN, NULL) == NO) return NO;
	resetCmd(mod);
      }
    }

    // make sure every bridge is using this sFlow entry
    myDebug(1, "==== list bridge ====");
    char *list_bridge_cmd[] = { SFVS_OVS_CMD, "list", "bridge", NULL};
    if(myExec((void *)mod, list_bridge_cmd, bridgeList, line, SFVS_MAX_LINELEN, NULL) == NO) return NO;

    // now it's safe to delete any extras that we found
    for(int ex = strArrayN(mdata->extras); --ex >= 0; ) {
      addDestroySFlow(mod, strArrayAt(mdata->extras, ex));
    }

    if(mdata->useAtVar) {
      // create new sFlow object if there were none found (i.e. if
      // the sflowUUID has not changed from the initial setting we
      // gave it.
      if(strcmp(SFVS_NEW_SFLOW_ID, mdata->sflowUUID) == 0) {
	addCreateSFlow(mod);
      }
    }

    // if we decided to make any changes, submit them now
    mdata->cmdFailed = NO;
    if(strArrayN(mdata->cmd) > 1) {
      logCmd(mod);
      strArrayAdd(mdata->cmd, NULL); // for execve(2)
      if(myExec((void *)mod, strArray(mdata->cmd), submitChanges, line, SFVS_MAX_LINELEN, NULL) == NO) return NO;
      if(mdata->usingAtVar && mdata->cmdFailed == NO) {
        // remember that it worked at least once
        mdata->usedAtVarOK = YES;
      }
    }
    return mdata->cmdFailed ? NO : YES;
  }
Пример #9
0
/*
 *  Start the command to run (stdIn and stdOut are named from the client's perspective). This is the lower-level way to 
 *  run a command. The caller needs to do code like mprRunCmd() themselves to wait for completion and to send/receive data.
 *  The routine does not wait. Callers must call mprWaitForCmd to wait for the command to complete.
 */
int mprStartCmd(MprCmd *cmd, int argc, char **argv, char **envp, int flags)
{
    MprPath     info;
    char        *program;
    int         rc;

    mprAssert(argv);
    mprAssert(argc > 0);

    if (argc <= 0 || argv == NULL || argv[0] == NULL) {
        return MPR_ERR_BAD_STATE;
    }
    resetCmd(cmd);
    program = argv[0];
    cmd->program = program;
    cmd->flags = flags;

    if (sanitizeArgs(cmd, argc, argv, envp) < 0) {
        return MPR_ERR_NO_MEMORY;
    }
    if (access(program, X_OK) < 0) {
        program = mprJoinPathExt(cmd, program, BLD_EXE);
        if (access(program, X_OK) < 0) {
            mprLog(cmd, 1, "cmd: can't access %s, errno %d", program, mprGetOsError());
            return MPR_ERR_CANT_ACCESS;
        }
    }
    if (mprGetPathInfo(cmd, program, &info) == 0 && info.isDir) {
        mprLog(cmd, 1, "cmd: program \"%s\", is a directory", program);
        return MPR_ERR_CANT_ACCESS;
    }

#if CYGWIN
    mprGlobalLock(cmd);
#endif
    if (mprMakeCmdIO(cmd) < 0) {
#if CYGWIN
        mprGlobalUnlock(cmd);
#endif
        return MPR_ERR_CANT_OPEN;
    }

    /*
     *  Determine how many end-of-files will be seen when the child dies
     */
    cmd->requiredEof = 0;
    if (cmd->flags & MPR_CMD_OUT) {
        cmd->requiredEof++;
    }
    if (cmd->flags & MPR_CMD_ERR) {
        cmd->requiredEof++;
    }

#if UNUSED && KEEP && NON_BLOCKING
#if BLD_UNIX_LIKE || VXWORKS
    {
        int     stdinFd, stdoutFd, stderrFd, nonBlock;
      
        stdinFd = cmd->files[MPR_CMD_STDIN].fd; 
        stdoutFd = cmd->files[MPR_CMD_STDOUT].fd; 
        stderrFd = cmd->files[MPR_CMD_STDERR].fd; 
        nonBlock = 1;

        /*
         *  Put the stdout and stderr into non-blocking mode. Windows can't do this because both ends of the pipe
         *  share the same blocking mode (Ugh!).
         */
#if VXWORKS
        if (stdoutFd >= 0) {
            ioctl(stdoutFd, FIONBIO, (int) &nonBlock);
        }
        if (stderrFd >= 0) {
            ioctl(stderrFd, FIONBIO, (int) &nonBlock);
        }
#else
        if (stdoutFd >= 0) {
            fcntl(stdoutFd, F_SETFL, fcntl(stdoutFd, F_GETFL) | O_NONBLOCK);
        }
        if (stderrFd >= 0) {
            fcntl(stderrFd, F_SETFL, fcntl(stderrFd, F_GETFL) | O_NONBLOCK);
        }
#endif
        if (stdoutFd >= 0) {
            cmd->handlers[MPR_CMD_STDOUT] = mprCreateWaitHandler(cmd, stdoutFd, MPR_READABLE,
                (MprWaitProc) stdoutCallback, cmd, MPR_NORMAL_PRIORITY, MPR_WAIT_THREAD);
        }
        if (stderrFd >= 0) {
            cmd->handlers[MPR_CMD_STDERR] = mprCreateWaitHandler(cmd, stderrFd, MPR_READABLE,
                (MprWaitProc) stderrCallback, cmd, MPR_NORMAL_PRIORITY, MPR_WAIT_THREAD);
            if (stdoutFd >= 0) {
                /*
                 *  Delay enabling stderr events until stdout is complete
                 */
                mprDisableWaitEvents(cmd->handlers[MPR_CMD_STDERR]);
            }
        }
    }
#endif
#endif
    rc = startProcess(cmd);
#if CYGWIN
    mprGlobalUnlock(cmd);
#endif
    return rc;
}
void SerialThreadObject::serialCommand(const ThreadCmd& incomingCommand)
{
	// check for avaiable data:
		
		if(incomingCommand != noCmd)
		{
			boost::mutex::scoped_lock looplock(threadMutex);
			// act on the command.
			switch (incomingCommand)
			{
			case resetArduino:
			{
				// reset the arduino.
				//flush out the commands.
				commandsToArd.clear();
				commandsToArd.push_back(resetCmd());
				//add the reset command:
				;
			}
			break;
			case resetSerial:
			{
				if(textStatusData != NULL)
				{
					textStatusData->appendText(std::string("Attempting to reset Arduino Serial Connection"));
				}
				//reset the serial bus.
				std::vector<std::string> ports;
				ss->getAvailablePorts(ports);

				if (!ports.size())
				{
					if(textStatusData != NULL)
					{
						textStatusData->appendText(std::string("No Serial Ports found."));
					}
				} 
				else
				{
					if (ports.size() == 1)
					{
						ss->setPort(ports[0]);
						if(textStatusData != NULL)
						{
							textStatusData->appendText(std::string("Connecting to Port: ")+ports[0]);
						}
					}
					else
					{
					// have user select the correct port
					for (int i = 0; i < ports.size(); i++) {
						wxMessageBox(wxString::Format("Found Serial Port: %s (%d/%d)", wxString(ports[i]), i + 1, ports.size()));
					}
						int which_port(wxGetNumberFromUser(wxEmptyString, wxT("Select Serial Port Number"), wxEmptyString, 0, 1, ports.size()) - 1);
						wxMessageBox(wxString::Format("Selected Serial Port: %s", wxString(ports[which_port])));
						ss->setPort(ports[which_port]);
						if(textStatusData != NULL)
						{
							textStatusData->appendText(std::string("Connecting to Port: ")+ports[which_port]);
						}
					}
					connected = ss->start();
					if(textStatusData != NULL)
					{
						textStatusData->appendText(std::string("Connected!!"));
					}
				}

			}	
			break;
			case connect:
				//connect to the arduino
			break;
			case disconnect:
				//disconnect from the arduino
			break;
			case poll:
				commandsToArd.clear();
				commandsToArd.push_back(pollCmd());
			break;
			default:
				if(textStatusData != NULL)
				{
					textStatusData->appendText(std::string("Command not recognized"));
				}
			}
			looplock.unlock();
		}
		// return currentStatus;

}