Beispiel #1
0
byte Radioino::receiveCommand()
{
	// Check the setup mode command
	if (digitalRead(_setupButtonPin)==HIGH && !_setupMode)
	{	
		_setupMode = true;
		_previousTime = 0;
		_setupModeCount = 0;
	}
	if (_setupMode)
	{
		// check to see if it's time to blink the LED; that is, if the 
		// difference between the current time and last time you blinked 
		// the LED is bigger than the interval at which you want to 
		// blink the LED.
		unsigned long currentTime = millis();
		if(currentTime - _previousTime > RADIOINO_SETUP_LED_BLINK_MS) {
			// save the last time you blinked the LED 
			_previousTime = currentTime;   
			setActivityLedState(!_activityLedState);
			_setupModeCount++;
		}
		
		// Exit the setup mode
		if (_setupModeCount > RADIOINO_SETUP_ATTEMPTS)
		{
			_setupMode = false;
			setActivityLedState(LOW);
		}
	}
	
	//Wait for a new command
	_commandResult = RADIOINO_NO_COMMAND;
	if (Serial.available() > 0) {
		if (receive()) {
			if (execute())
			{
				// Build the response message
				beginResponse(true);
				// Add the sensors status
				sendSensorsStatus();   
				_commandResult = RADIOINO_COMMAND_OK;
			}
			else {
				// Build the error response message
				beginResponse(false);
				_commandResult = RADIOINO_COMMAND_ERROR;
			}
			// wait for another command
			resetCommand();
		}
	}
	// end activity
	setActivityLedState(LOW);  
	
	return _commandResult;
}
Beispiel #2
0
void runCmd(struct Node* node, const char *fPath) {
	//Run the commands for each node in parallel
	pthread_t pt;

	if (node->child != NULL)
		runCmd(node->child, fPath);

	if (node->command != NULL) {
		char buf[2048];
		memset(buf, 0, sizeof(buf));
		if (node->statusFlag == 0) {
			if (treeSearchDups(node, node->nodeName, node->statusFlag,
					node->command))
				return 0;
		}
		if (node->statusFlag == 0) {

			char *sourceExt = strchr(node->nodeName, '.');
			if (sourceExt != NULL) {

				if ((strcmp(sourceExt, ".cpp") == 0)
						|| (strcmp(sourceExt, ".o") == 0))
					resetCommand(node, fPath);
			} else {

				//Need to fix other string and remove ""
				const char *src = strrchr(node->command, 'g');
				int endl = 0;
				if (src != NULL) {
					//src--;
					const char *dsc = strrchr(src, '"');
					endl = dsc - src;
					char* iptr = (char*) malloc(endl + 1);
					memset(iptr, 0, endl);
					memcpy(iptr, src, endl);
					iptr[endl] = 0;
					node->command = iptr;
				}
			}

			sprintf(buf, "%s", node->command);

			if (createThread(buf, &pt))
				return NULL;
			node->statusFlag = 1;

			if (node->next != NULL)
				runCmd(node->next, fPath);
		}
	}

}
bool ONScripter::executeSystemReset()
{
    if ( executeSystemYesNo( SYSTEM_RESET ) ){
        resetCommand();
        leaveSystemCall( false );
        
        return true;
    }

    leaveSystemCall();

    return false;
}
Beispiel #4
0
// Build the incoming command in a ascii-string
boolean Radioino::receive()
{
	while (Serial.available() > 0)
	{    
		int value = Serial.read();
		// show activity
		setActivityLedState(!_activityLedState);
		switch (value)
		{
			case RADIOINO_COMMAND_END	:
				// Command arrived. Check if we can accept this command command address
				if (_command.startsWith(_startHeader) || _command.startsWith(RADIOINO_SETUP_HEADER) && _setupMode)
				{			
					// Check if is not message to send the latest result again
					if (_command == _startHeader+"C")
					{
						// Send the latest response again
						Serial.println(_response);
						resetCommand();
						return false;
					}
					// It's a regular command. execute-it
					return true;
				}
				else {
					resetCommand();
					return false;
				}
			case 'R'  :
				resetCommand();
				_command = _command + char(value);
				return false;
			default:
				_command = _command + char(value);
				return false;
		}
	}
	return false;
}
Beispiel #5
0
byte IOToaster::receiveCommand()
{
	if (_setupMode)
	{
		// check to see if it's time to blink the LED; that is, if the 
		// difference between the current time and last time you blinked 
		// the LED is bigger than the interval at which you want to 
		// blink the LED.
		unsigned long currentTime = millis();
		if (currentTime - _previousTime > IOTOASTER_SETUP_LED_BLINK_MS) {
			// save the last time you blinked the LED 
			_previousTime = currentTime;

			// if the LED is off turn it on and vice-versa:
			if (_activityLedState == LOW)
				setActivityLedState(HIGH);
			else setActivityLedState(LOW);
		}
	}

	//Wait for a new command
	_commandResult = IOTOASTER_NO_COMMAND;
	if (Serial.available() > 0) {
		if (receive()) {
			if (_command.startsWith("+IPD")) // Check for data sent from the server
			{
				_command = _command.substring(_command.lastIndexOf(':') + 1);
				_customResponse = "";
				if (execute())
				{
					// Build the response message
					beginResponse(true);
					// Add the sensors status
					send(getInputSensorsStatus());
					_commandResult = IOTOASTER_COMMAND_OK;
				}
				else {
					// Build the error response message
					beginResponse(false);
					_commandResult = IOTOASTER_COMMAND_ERROR;
				}
			}
			// wait for another command
			resetCommand();
		}
	}

	return _commandResult;
}
MainApplication::MainApplication(int argc, char *argv[])
    : QApplication(argc, argv), simulator(12345), engine(), history(), communication(),
      robot(history, communication), handler(robot, *engine.rootContext(), history)
{
    // Szimulátor indítása
    simulator.start(0.3F);

    // Csatlakozás a szimulátorhoz.
    communication.connect(QStringLiteral("localhost"),12345);

    // Szimulálunk egy history változást, mert attól kezdve léteznek a QML oldalon
    //  a C++ oldalról származó változók. (Különben referencia hibákat kapnánk a QML oldalon
    //  egészen addig, amíg az első üzenet meg nem jönne a szimulátortól.
    //handler.historyChanged();

    engine.load(QUrl(QStringLiteral("qrc:/main.qml")));

    // A QML gyökérelemre szükségünk van ahhoz, hogy tudjunk hivatkozni a QML-es elemekre.
    auto rootObjects = engine.rootObjects();
    if (rootObjects.size() == 0)
    {
        qDebug() << "HIBA: Nem sikerült létrehozni a QML környezetet.";
        return;
    }
    // A QML környezet is felállt, bekötjük a signalokat a QML és C++ oldal között.
    QObject *rootObject = rootObjects[0];
    // A handler beköti a saját signaljait.
    handler.ConnectQmlSignals(rootObject);

    // Bekötjük a nyomógombok signaljait.
    QObject::connect(rootObject, SIGNAL(resetCommandCpp()),
                     &handler, SLOT(resetCommand()));
    QObject::connect(rootObject, SIGNAL(accelerateXCommandCpp()),
                     &handler, SLOT(accelerateXCommand()));
    QObject::connect(rootObject, SIGNAL(accelerateYCommandCpp()),
                     &handler, SLOT(accelerateYCommand()));
    QObject::connect(rootObject, SIGNAL(slowDownXCommandCpp()),
                     &handler, SLOT(slowDownXCommand()));
    QObject::connect(rootObject, SIGNAL(slowDownYCommandCpp()),
                     &handler, SLOT(slowDownYCommand()));
    QObject::connect(rootObject, SIGNAL(stopCommandCpp()),
                     &handler, SLOT(stopCommand()));
    QObject::connect(rootObject, SIGNAL(testCommandCpp()),
                     &handler, SLOT(testCommand()));
    QObject::connect(rootObject, SIGNAL(defaultCommandCpp()),
                     &handler, SLOT(defaultCommand()));
}
void PonscripterLabel::executeSystemYesNo()
{
    current_font = &menu_font;
    if (event_mode & WAIT_BUTTON_MODE) {
        if (current_button_state.button == 0) return;

        event_mode = IDLE_EVENT_MODE;

        deleteButtons();

        if (current_button_state.button == 1) { // yes is selected
	    playSound(menuselectvoice_file_name[MENUSELECTVOICE_YES],
		      SOUND_WAVE | SOUND_OGG, false, MIX_WAVE_CHANNEL);

            if (yesno_caller == SYSTEM_SAVE) {
                saveSaveFile(yesno_selected_file_no);
                leaveSystemCall();
            }
            else if (yesno_caller == SYSTEM_LOAD) {
                current_font = &sentence_font;
                if (loadSaveFile(yesno_selected_file_no)) {
                    system_menu_mode = yesno_caller;
                    advancePhase();
                    return;
                }

                leaveSystemCall(false);
                saveon_flag = true;
                internal_saveon_flag = true;
                text_on_flag  = false;
                indent_offset = 0;
                line_enter_status    = 0;
                string_buffer_offset = 0;
                string_buffer_restore = -1;
		break_flag = false;

                if (loadgosub_label)
                    gosubReal(loadgosub_label, script_h.getCurrent());

                readToken();
            }
            else if (yesno_caller == SYSTEM_RESET) {
                resetCommand("reset");
                readToken();
                event_mode = IDLE_EVENT_MODE;
                leaveSystemCall(false);
            }
            else if (yesno_caller == SYSTEM_END) {
                endCommand("end");
            }
        }
        else {
	    playSound(menuselectvoice_file_name[MENUSELECTVOICE_NO],
		      SOUND_WAVE | SOUND_OGG, false, MIX_WAVE_CHANNEL);

            system_menu_mode = yesno_caller & 0xf;
            if (yesno_caller == SYSTEM_RESET)
                leaveSystemCall();

            advancePhase();
        }
    }
    else {
        text_info.fill(0, 0, 0, 0);
	pstring name;

        if (yesno_caller == SYSTEM_SAVE) {
            SaveFileInfo save_file_info;
            searchSaveFile(save_file_info, yesno_selected_file_no);
            processMessage(name, locale.message_save_confirm, save_file_info);
        }
        else if (yesno_caller == SYSTEM_LOAD) {
            SaveFileInfo save_file_info;
            searchSaveFile(save_file_info, yesno_selected_file_no);
            processMessage(name, locale.message_load_confirm, save_file_info);
        }
        else if (yesno_caller == SYSTEM_RESET)
            name = locale.message_reset_confirm;
        else if (yesno_caller == SYSTEM_END)
            name = locale.message_end_confirm;

        current_font->area_x = int (ceil(current_font->StringAdvance(name)));
        current_font->area_y = current_font->line_top(4);
        current_font->top_x  = (screen_width * screen_ratio2 / screen_ratio1 - current_font->area_x) / 2;
        current_font->top_y  = (screen_height * screen_ratio2 / screen_ratio1 - current_font->area_y) / 2;
        current_font->SetXY(0, 0);

	buttons[0] = getSelectableSentence(name, current_font, false);

        flush(refreshMode());

        float yes_len = current_font->StringAdvance(locale.message_yes),
              no_len  = current_font->StringAdvance(locale.message_no);

        name = locale.message_yes;
        current_font->SetXY(float (current_font->area_x) / 4 - yes_len / 2,
			current_font->line_top(2));
	buttons[1] = getSelectableSentence(name, current_font, false);

        name = locale.message_no;
        current_font->SetXY(float (current_font->area_x) * 3 / 4 - no_len / 2,
			current_font->line_top(2));
        buttons[2] = getSelectableSentence(name, current_font, false);

        flush(refreshMode());

        event_mode = WAIT_BUTTON_MODE;
        refreshMouseOverButton();
    }
}
Beispiel #8
0
void Keyboard::releaseAll()
{
    // set pressure to zero for every key
    memset(m_keyState, 0, sizeof(m_keyState));
    resetCommand();
}
Beispiel #9
0
/* Enter the main loop.  Read and parse input from the serial port
   and run any valid commands. Run a PID calculation at the target
   interval and check for auto-stop conditions.
*/
void loop() {
  while (Serial.available() > 0) {

    // Read the next character
    chr = Serial.read();

    // Terminate a command with a CR
    if (chr == 13) {
      if (arg == 1) argv1[index] = NULL;
      else if (arg == 2) argv2[index] = NULL;
      runCommand();
      resetCommand();
    }
    // Use spaces to delimit parts of the command
    else if (chr == ' ') {
      // Step through the arguments
      if (arg == 0) arg = 1;
      else if (arg == 1)  {
        argv1[index] = NULL;
        arg = 2;
        index = 0;
      }
      continue;
    }
    else {
      if (arg == 0) {
        // The first arg is the single-letter command
        cmd = chr;
      }
      else if (arg == 1) {
        // Subsequent arguments can be more than one character
        argv1[index] = chr;
        index++;
      }
      else if (arg == 2) {
        argv2[index] = chr;
        index++;
      }
    }
  }

// If we are using base control, run a PID calculation at the appropriate intervals
#ifdef USE_BASE
  if (millis() > nextPID) {
    updatePID();
    nextPID += PID_INTERVAL;
  }

  // Check to see if we have exceeded the auto-stop interval
  if ((millis() - lastMotorCommand) > AUTO_STOP_INTERVAL) {;
    setMotorSpeeds(0, 0);
    moving = 0;
    resetPID();
  }

#endif
  if (millis() > nextTick) {
	 ticks += 1;
	 nextTick += TICK_INTERVAL;
  }
}