void Controller::runTWI() {
	chrono::milliseconds sleepDuration(2000); //tmp
	this_thread::sleep_for(sleepDuration);

	TWI twi = TWI();
	LngLat currGoal = LngLat(0., 0.);
	Db db = Db::getInstance();
	while(!endThreads) {
		this->lngLatCurrent = db.getFakeTWI(); // todo: get current positon from ATmega
		if(sizeof(this->map)>0 && !this->mapLoading) // sprawdź czy pozycja jest granicach mapy
			this->positionInBounds = this->map->inBounds(this->lngLatCurrent);

		if(this->goalPath.size() > 0) { // ścieżka wyznaczona
			if(this->sentPoint == 0) { // nowa ścieżka
				this->twiStatus = twi.writeFirstGoal(this->goalPath[0].toLngLat(this->map));
				if(this->twiStatus < -1) { // twi ok
					currGoal = this->goalPath[1].toLngLat(this->map);
					this->twiStatus = twi.writeNextGoal(currGoal);
					if(this->twiStatus > -1) { // twi ok
						this->sentPoint=1;
					} else { // twi error
						// elog << "Problem z komunikacją TWI: " << this->twiStatus;
					}
				} else { // twi error
					// elog << "Problem z komunikacją TWI: " << this->twiStatus;
				}
			} else { // kontynuuj wysyłanie trajektorii
				LngLat tmp = twi.getCurrentGoal();
				// dlog << "current goal from robot: " << tmp;
				// dlog << "current set goal: " << currGoal;
				if(tmp == currGoal) { // robot podąża do 'następnego' celu
					// wyślij nowy 'następny' cel
					this->sentPoint++;
					if(this->sentPoint < this->goalPath.size()) { // pozostały punkty trajektorii do wysłania
						currGoal = this->goalPath[this->sentPoint].toLngLat(this->map);
						this->twiStatus = twi.writeNextGoal(currGoal);
						if(this->twiStatus <= -1) { // twi error
							// elog << "Problem z komunikacją TWI: " << this->twiStatus;
						}
					} else { // wysłano ostatni punkt
					}
				}
			}
		}

		// opóźnij wątek
		chrono::milliseconds sleepDuration(2000);
		this_thread::sleep_for(sleepDuration);
	}
	dlog << "koniec threadTWI";
}
예제 #2
0
void slave_thread(int id)
{
    printf("    +++ slave thread %d: starting\n", id);

    while (true)
    {
        boost::unique_lock<boost::mutex> lock(data_ready_mutex);
        while (!data_ready)
        {
            data_ready_cond.wait(lock);
        }
        data_ready = false;

        unsigned work_unit;
        {
            boost::lock_guard<boost::mutex> lock(work_queue_mutex);
            if (work_queue.size() == 0)
                abort();
            work_unit = work_queue.back();
            work_queue.pop_back();
        }
        printf("        slave thread %d: got work unit %u\n", id, work_unit);

        // Pretend to work
        boost::chrono::milliseconds sleepDuration(3);
        boost::this_thread::sleep_for(sleepDuration);
    }

    printf("    --- slave thread %d: finished\n", id);
}
예제 #3
0
void producer_thread()
{
    printf("+++ producer thread\n");

    for (unsigned work_unit_count = 0; work_unit_count < work_unit_limit; work_unit_count++)
    {
        // Pretend to work

        boost::chrono::milliseconds sleepDuration(5);
        boost::this_thread::sleep_for(sleepDuration);

        // Generate some work
        {
            boost::lock_guard<boost::mutex> lock(work_queue_mutex);
    
            printf("    producer: produced %u...\n", work_unit_count);
            work_queue.push_back(work_unit_count);
        }

        // Let one of the slaves know there's work to be done
        {
            boost::unique_lock<boost::mutex> lock(data_ready_mutex);
            data_ready = true;
        }
        data_ready_cond.notify_one();
    }

    printf("--- producer thread\n");
}
/**
 * metoda wątku 'worker'
 */
void Controller::runWorker() {
	while(!endThreads) {
		if(!this->workerTask.empty()) {
			switch(this->workerTask.front()) {
				case 0:
					break;
				case TASK_FINDPATH: // wyznacz trajektorię
					this->astar();
					break;
				case TASK_LOADMAP: { // wczytaj mapę
					string mapName = this->workerTaskParams.front();
					this->workerTaskParams.pop();
					dlog << "wczytywanie mapy: " << mapName;
					this->map = new Map(mapName);
					this->mapLoading = false;
					break;
				} default:
					elog << "nieznana komenda dla wątku threadWorker";
					break;
			}
			this->workerTask.pop();
		}
		chrono::milliseconds sleepDuration(1000);
		this_thread::sleep_for(sleepDuration);
	}
	dlog << "koniec threadWorker";
}
void Controller::runUart() {
	int fd = serialOpen(UART_DEVICE, 9600);
	int bSize = 0; // ilość znaków w buforze
	while(!endThreads) {
		bSize = serialDataAvail(fd);
		if(bSize==8) { // dwa inty czekają na odczyt
			union IntOrByte {
				char b[4];
				int i;
			} u;
			
			// odczyt kierunku wiatru
			for (int i =0; i < 4; i++) { //odczytaj 4 bajty
				u.b[i] = serialGetchar(fd);
			}
			this->windDirection = u.i;

			// odczyt prędkości wiatru
			u.i = 0; // resetujemy union
			for (int i =0; i < 4; i++) { //odczytaj 4 bajty
				u.b[i] = serialGetchar(fd);
			}
			this->windSpeed = u.i;
		} else if(bSize>8) { // zbyt dużo informacji w buforze
			serialFlush(fd);
		}

		chrono::milliseconds sleepDuration(500);
		this_thread::sleep_for(sleepDuration);
	}
	serialClose(fd);
	dlog << "koniec threadWorker";
}
예제 #6
0
void ProgressReporter::PrintBar() {
    int barLength = TerminalWidth() - 28;
    int totalPlusses = std::max(2, barLength - (int)title.size());
    int plussesPrinted = 0;

    // Initialize progress string
    const int bufLen = title.size() + totalPlusses + 64;
    std::unique_ptr<char[]> buf(new char[bufLen]);
    snprintf(buf.get(), bufLen, "\r%s: [", title.c_str());
    char *curSpace = buf.get() + strlen(buf.get());
    char *s = curSpace;
    for (int i = 0; i < totalPlusses; ++i) *s++ = ' ';
    *s++ = ']';
    *s++ = ' ';
    *s++ = '\0';
    fputs(buf.get(), stdout);
    fflush(stdout);

    std::chrono::milliseconds sleepDuration(250);
    int iterCount = 0;
    while (!exitThread) {
        std::this_thread::sleep_for(sleepDuration);

        // Periodically increase sleepDuration to reduce overhead of
        // updates.
        ++iterCount;
        if (iterCount == 10)
            // Up to 0.5s after ~2.5s elapsed
            sleepDuration *= 2;
        else if (iterCount == 70)
            // Up to 1s after an additional ~30s have elapsed.
            sleepDuration *= 2;

        Float percentDone = Float(workDone) / Float(totalWork);
        int plussesNeeded = std::round(totalPlusses * percentDone);
        while (plussesPrinted < plussesNeeded) {
            *curSpace++ = '+';
            ++plussesPrinted;
        }
        fputs(buf.get(), stdout);

        // Update elapsed time and estimated time to completion
        Float seconds = ElapsedMS() / 1000.f;
        Float estRemaining = seconds / percentDone - seconds;
        if (percentDone == 1.f)
            printf(" (%.1fs)       ", seconds);
        else if (!std::isinf(estRemaining))
            printf(" (%.1fs|%.1fs)  ", seconds,
                   std::max((Float)0., estRemaining));
        else
            printf(" (%.1fs|?s)  ", seconds);
        fflush(stdout);
    }
}
예제 #7
0
void work(){
    std::chrono::milliseconds timeout(100);

    while(true){
        if(mutex.try_lock_for(timeout)){
            std::cout << std::this_thread::get_id() << ": do work with the mutex" << std::endl;

            std::chrono::milliseconds sleepDuration(250);
            std::this_thread::sleep_for(sleepDuration);

            mutex.unlock();

            std::this_thread::sleep_for(sleepDuration);
        } else {
            std::cout << std::this_thread::get_id() << ": do work without mutex" << std::endl;

            std::chrono::milliseconds sleepDuration(100);
            std::this_thread::sleep_for(sleepDuration);
        }
    }
}
예제 #8
0
파일: Main.cpp 프로젝트: riverfor/luce
int lua_sleep(lua_State *L) {
    int ms = luaL_checknumber(L,-1);
    lua_pop(L,1);
// FIXME: posix-thread for mingw
#ifdef __MINGW32__
    Sleep(ms);
#else
    std::chrono::milliseconds sleepDuration(ms);
    std::this_thread::sleep_for(sleepDuration);
#endif
    return 0;
}
예제 #9
0
void primary_thread()
{
    printf("primary starting\n");

    // Pretend to do some work
    boost::chrono::milliseconds sleepDuration(500);
    boost::this_thread::sleep_for(sleepDuration);

    {
        boost::unique_lock<boost::mutex> lock(cond_mutex);
        finished = true;
    }

    printf("notify\n");
    cond.notify_one();

    printf("primary done\n");
}
예제 #10
0
int main()
{
	std::chrono::milliseconds sleepDuration(20);

	std::this_thread::sleep_for(sleepDuration);
}
예제 #11
0
 void waitDelay () {
   std::chrono::milliseconds sleepDuration(1000);
   std::this_thread::sleep_for(sleepDuration);
 }
void Controller::runMysql() {
	Db db = Db::getInstance();
	
	//wczytanie konfiguracji
	this->debug = (db.getConfig("debug")=="1"?true:false);
	this->maxSailDeviantion = stoi(db.getConfig("maxSailDeviation"));
	this->rotationPenalty = stof(db.getConfig("rotationPenalty"));

	//reset data
	db.updateLngLat(LngLat(0., 0.));
	db.setPathStatus(PATH_SEARCHING);
	db.setMapStatus(MAP_NOTLOADED); //mapa niewczytana

	// dodaj zadanie wczytania mapy do kolejki wątku 'worker'
	this->workerTaskParams.push(db.getMapName());
	this->workerTask.push(TASK_LOADMAP);

	bool positionInBounds = this->positionInBounds; // czy pozycja znajduje się w obrębie mapy?
	string mapName; // nazwa wczytanej mapy pobierana z db
	LngLat newGoal; // cel pobierany z db
	while(!endThreads) {
		db.updateLngLat(this->lngLatCurrent);
		
		// zmiana celu
		newGoal = db.getLngLatGoal(); // pobierz cel z bazy danych
		if(newGoal != this->lngLatGoal && abs(newGoal.lat)>0. && abs(newGoal.lng)>0.) { // zmieniono cel
			this->lngLatGoal = newGoal;
			dlog << "nowy cel: " << newGoal.toString();
			db.setPathStatus(PATH_SEARCHING);
			this->workerTask.push(TASK_FINDPATH);
		}

		// uaktualnij pole positionInBounds w bazie danych
		if(positionInBounds != this->positionInBounds) { //zapisz zmianę do db
			positionInBounds = this->positionInBounds;
			db.updateDataParam("positionInBounds", to_string(positionInBounds));
		}

		// zmiana mapy
		if(this->map && !this->mapLoading) {
			mapName = db.getMapName();
			if(mapName != this->map->getMapName()) {
				// dodaj zadanie wczytania mapy do kolejki wątku 'worker'
				this->workerTaskParams.push(mapName);
				this->workerTask.push(TASK_LOADMAP);
				this->mapLoading = true;
				// dodaj zadanie wyznaczenia trajektori do kolejki wątku 'worker'
				db.setPathStatus(PATH_SEARCHING);
				this->workerTask.push(TASK_FINDPATH);
			}
		}

		db.setTwiStatus(this->twiStatus); // uaktualnij status TWI

		// todo: usunąć po podpięciu czujnika wiatru do uart
		this->windDirection = stoi(db.getDataParam("windDirection")); // pobierz informację o kierunku wiatru z bazy danych

		// opóźnienie pętli
		std::chrono::milliseconds sleepDuration(5000);
		std::this_thread::sleep_for(sleepDuration);
	}
	dlog << "koniec threadMysql";
}