Esempio n. 1
0
void ResetHandler::handleRequest(HttpRequest *request, const std::vector<std::string>& tokens)
{
	map<Dashel::Stream *, HttpDashelTarget *>& targets = getInterface()->getTargets();

	map<Dashel::Stream *, HttpDashelTarget *>::iterator end = targets.begin();
	for(std::map<Dashel::Stream *, HttpDashelTarget *>::iterator iter = targets.begin(); iter != end; ++iter) {
		Dashel::Stream *stream = iter->first;
		HttpDashelTarget *target = iter->second;
		const map<unsigned, HttpDashelTarget::Node>& nodes = target->getNodes();

		map<unsigned, HttpDashelTarget::Node>::const_iterator nodesEnd = nodes.end();
		for(map<unsigned, HttpDashelTarget::Node>::const_iterator nodesIter = nodes.begin(); nodesIter != nodesEnd; ++nodesIter) {
			const HttpDashelTarget::Node& node = nodesIter->second;

			try {
				Reset(node.localId).serialize(stream); // reset node
				stream->flush();
				Run(node.localId).serialize(stream); // re-run node
				stream->flush();
			} catch(Dashel::DashelException e) {
				if(getInterface()->isVerbose()) {
					cerr << request << " Failed to reset and re-run node: " << e.what() << endl;
				}
				return;
			}

			if(node.name.find("thymio-II") == 0) { // Special case for Thymio-II. Should we instead just check whether motor.*.target exists?
				vector<string> tokens;
				tokens.push_back("motor.left.target");
				tokens.push_back("0");
				if(!target->sendSetVariable(node.globalId, tokens)) {
					request->respond().setStatus(HttpResponse::HTTP_STATUS_INTERNAL_SERVER_ERROR);
					request->respond().setContent("Failed to set Thymio left motor target");
					return;
				}

				tokens[0] = "motor.right.target";
				if(!target->sendSetVariable(node.globalId, tokens)) {
					request->respond().setStatus(HttpResponse::HTTP_STATUS_INTERNAL_SERVER_ERROR);
					request->respond().setContent("Failed to set Thymio left motor target");
					return;
				}
			}

			size_t eventPos;
			if(getInterface()->getProgram().getCommonDefinitions().events.contains(UTF8ToWString("reset"), &eventPos)) {
				vector<string> data;
				data.push_back("reset");

				if(!getInterface()->sendEvent(data)) {
					request->respond().setStatus(HttpResponse::HTTP_STATUS_INTERNAL_SERVER_ERROR);
					request->respond().setContent("Failed to send reset event");
					return;
				}
			}
		}
	}

	request->respond();
}
Esempio n. 2
0
extern "C" void AsebaSendBuffer(AsebaVMState *vm, const uint8* data, uint16 length)
{
	Enki::AsebaMarxbot& marxBot = *asebaSocketMaps[vm];
	Dashel::Stream* stream = marxBot.stream;
	if (!stream)
		return;
	
	// send to stream
	try
	{
		uint16 temp;
		temp = bswap16(length - 2);
		stream->write(&temp, 2);
		temp = bswap16(vm->nodeId);
		stream->write(&temp, 2);
		stream->write(data, length);
		stream->flush();

		// push to other nodes
		for (size_t i = 0; i < marxBot.modules.size(); ++i)
		{
			Enki::AsebaMarxbot::Module& module = *(marxBot.modules[i]);
			if (&(module.vm) != vm) 
			{
				module.events.push_back(Enki::AsebaMarxbot::Event(vm->nodeId, data, length));
				AsebaProcessIncomingEvents(&(module.vm));
			}
		}
	}
	catch (Dashel::DashelException e)
	{
		std::cerr << "Cannot write to socket: " << stream->getFailReason() << std::endl;
	}
}
Esempio n. 3
0
File: cmd.cpp Progetto: Juxi/aseba
int main(int argc, char *argv[])
{
	Dashel::initPlugins();
	
	const char *target = ASEBA_DEFAULT_TARGET;
	int argCounter = 1;
	
	if (argc == 1)
	{
		Aseba::dumpHelp(std::cout, argv[0]);
		return 0;
	}
	
	while (argCounter < argc)
	{
		const char *arg = argv[argCounter];
		if (strcmp(arg, "-t") == 0)
		{
			if (++argCounter < argc)
				target = argv[argCounter];
			else
				Aseba::errorMissingArgument(argv[0]);
		}
		else if ((strcmp(arg, "-h") == 0) || (strcmp(arg, "--help") == 0))
		{
			Aseba::dumpHelp(std::cout, argv[0]);
			return 0;
		}
		else if ((strcmp(arg, "-V") == 0) || (strcmp(arg, "--version") == 0))
		{
			Aseba::dumpVersion(std::cout);
			return 0;
		}
		else
		{
			Dashel::Hub client;
			Dashel::Stream* stream = client.connect(target);
			assert(stream);
			
			// process command
			try
			{
				 argCounter += Aseba::processCommand(stream, argc - argCounter, &argv[argCounter]);
				 stream->flush();
			}
			catch (Dashel::DashelException e)
			{
				Aseba::errorServerDisconnected();
			}
			catch (Aseba::BootloaderInterface::Error e)
			{
				Aseba::errorBootloader(e.what());
			}
		}
		argCounter++;
	}
	return 0;
}
Esempio n. 4
0
extern "C" void AsebaSendBuffer(AsebaVMState *vm, const uint8* data, uint16 length)
{
	Dashel::Stream* stream = node.stream;
	if (stream)
	{
		try
		{
			uint16 temp;
			temp = bswap16(length - 2);
			stream->write(&temp, 2);
			temp = bswap16(vm->nodeId);
			stream->write(&temp, 2);
			stream->write(data, length);
			stream->flush();
		}
		catch (Dashel::DashelException e)
		{
			std::cerr << "Cannot write to socket: " << stream->getFailReason() << std::endl;
		}
	}
}