- windows build restored

- some tweaks to build system

Author: yurii-litvinov

global.pri

@@ -15,10 +15,6 @@
 # Build settings common to all projects in TrikRuntime.
 # Provides:
 # CONFIGURATION_SUFFIX variable that shall be consistently used in TARGET and LIBS variables in all projects.
-#
-# Depends on:
-# FILES_TO_COPY variable for a list of additional files and directories which needed to be copied after build to
-#		target directory.
 
 CROSS_COMPILE = $$(CROSS_COMPILE)
 
@@ -59,10 +55,24 @@ unix {
 	INSTALLS += target
 }
 
-!isEmpty(FILES_TO_COPY) {
-	win32 {
-		QMAKE_POST_LINK = "xcopy $$replace(FILES_TO_COPY, /, \\) $$replace(DESTDIR, /, \\) /s /e /q /y /i"
-	} else {
-		QMAKE_POST_LINK = "cp -rf $$FILES_TO_COPY $$DESTDIR"
+# Useful function to copy additional files to destination,
+# from http://stackoverflow.com/questions/3984104/qmake-how-to-copy-a-file-to-the-output
+defineTest(copyToDestdir) {
+	FILES = $$1
+
+	for (FILE, FILES) {
+		# This ugly code is needed because xcopy requires to add source directory name to target directory name when copying directories
+		win32:AFTER_SLASH = $$section(FILE, "/", -1, -1)
+		win32:BASE_NAME = $$section(FILE, "/", -2, -2)
+		win32:equals(AFTER_SLASH, ""):DESTDIR_SUFFIX = /$$BASE_NAME
+
+		win32:FILE ~= s,/$,,g
+
+		FILE = $$shell_path($$FILE)
+		DDIR = $$shell_path($$DESTDIR$$DESTDIR_SUFFIX/)
+        
+		QMAKE_POST_LINK += $(COPY_DIR) $$quote($$FILE) $$quote($$DDIR) $$escape_expand(\\n\\t)
 	}
+
+	export(QMAKE_POST_LINK)
 }

…l/src/linux/cameraLineDetectorSensor.cpp …Control/src/cameraLineDetectorSensor.cpptrikControl/src/linux/cameraLineDetectorSensor.cpp renamed to trikControl/src/cameraLineDetectorSensor.cpp trikControl/src/linux/cameraLineDetectorSensor.cpp renamed to trikControl/src/cameraLineDetectorSensor.cpp

@@ -0,0 +1,274 @@
+/* Copyright 2014 CyberTech Labs Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License. */
+
+#include "src/cameraLineDetectorSensorWorker.h"
+
+#include <QtCore/QDebug>
+#include <QtCore/QFileInfo>
+#include <QtCore/QWaitCondition>
+#include <QtCore/QMutex>
+
+using namespace trikControl;
+
+CameraLineDetectorSensorWorker::CameraLineDetectorSensorWorker(QString const &roverCvBinary
+		, QString const &inputFile
+		, QString const &outputFile
+		, double toleranceFactor
+		, QString const &params
+		)
+	: mReading(0)
+	, mRoverCvBinary(roverCvBinary)
+	, mOutputFileDescriptor(-1)
+	, mRoverCvProcess(this)
+	, mInputFile(inputFile)
+	, mOutputFile(outputFile)
+	, mReady(false)
+	, mToleranceFactor(toleranceFactor)
+	, mParams(params)
+{
+	qRegisterMetaType<QProcess::ProcessError>("QProcess::ProcessError");
+
+	connect(&mRoverCvProcess, SIGNAL(error(QProcess::ProcessError))
+			, this, SLOT(onRoverCvError(QProcess::ProcessError)), Qt::QueuedConnection);
+
+	connect(&mRoverCvProcess, SIGNAL(readyReadStandardError())
+			, this, SLOT(onRoverCvReadyReadStandardError()), Qt::QueuedConnection);
+
+	connect(&mRoverCvProcess, SIGNAL(readyReadStandardOutput())
+			, this, SLOT(onRoverCvReadyReadStandardOutput()), Qt::QueuedConnection);
+}
+
+CameraLineDetectorSensorWorker::~CameraLineDetectorSensorWorker()
+{
+	deinitialize();
+}
+
+void CameraLineDetectorSensorWorker::init()
+{
+	// Since rover-cv can die silently, we need to check not only mReady flag, but also input and output fifos.
+	if (!mReady || !mInputFile.exists() || !mOutputFile.exists()) {
+		initDetector();
+	}
+}
+
+void CameraLineDetectorSensorWorker::detect()
+{
+	if (!mReady || !mInputFile.exists() || !mOutputFile.exists()) {
+		init();
+	}
+
+	mCommandQueue << "detect";
+	tryToExecute();
+}
+
+int CameraLineDetectorSensorWorker::read()
+{
+	return mReading;
+}
+
+void CameraLineDetectorSensorWorker::initDetector()
+{
+	if (!mInputFile.exists() || !mOutputFile.exists()) {
+		startRoverCv();
+	} else {
+		openFifos();
+	}
+}
+
+void CameraLineDetectorSensorWorker::onRoverCvError(QProcess::ProcessError error)
+{
+	qDebug() << "rover-cv error: " << error;
+
+	mReady = false;
+	deinitialize();
+}
+
+void CameraLineDetectorSensorWorker::onRoverCvReadyReadStandardOutput()
+{
+	QString const data = mRoverCvProcess.readAllStandardOutput();
+	QStringList const lines = data.split("\n");
+	foreach (QString const line, lines) {
+		qDebug() << "From rover-cv:" << line;
+		if (line == "Entering video thread loop") {
+			openFifos();
+		}
+
+		if (line == "Terminating") {
+			mReady = false;
+			deinitialize();
+		}
+	}
+}
+
+void CameraLineDetectorSensorWorker::onRoverCvReadyReadStandardError()
+{
+	QString const data = mRoverCvProcess.readAllStandardError();
+	QStringList const lines = data.split("\n");
+	foreach (QString const line, lines) {
+		qDebug() << "From rover-cv standard error:" << line;
+	}
+}
+
+void CameraLineDetectorSensorWorker::readFile()
+{
+	char data[4000] = {0};
+	int size = 0;
+
+	mSocketNotifier->setEnabled(false);
+
+	if ((size = mOutputFile.read(data, 4000)) < 0) {
+		qDebug() << mOutputFile.fileName() << ": fifo read failed: " << errno;
+		return;
+	}
+
+	QString const linesRead(data);
+	QStringList const lines = linesRead.split('\n', QString::SkipEmptyParts);
+
+	foreach (QString const line, lines) {
+		QStringList const parsedLine = line.split(" ", QString::SkipEmptyParts);
+
+		qDebug() << "parsed: " << parsedLine;
+
+		if (parsedLine[0] == "loc:") {
+			int const x = parsedLine[1].toInt();
+			int const angle = parsedLine[2].toInt();
+			int const mass = parsedLine[3].toInt();
+
+			mReading = x;
+
+			// These values are not needed in current implementation, but are left here for reference.
+			Q_UNUSED(angle)
+			Q_UNUSED(mass)
+		}
+
+		if (parsedLine[0] == "hsv:") {
+			int const hue = parsedLine[1].toInt();
+			int const hueTolerance = parsedLine[2].toInt();
+			int const saturation = parsedLine[3].toInt();
+			int const saturationTolerance = parsedLine[4].toInt();
+			int const value = parsedLine[5].toInt();
+			int const valueTolerance = parsedLine[6].toInt();
+
+			mInputStream
+					<< QString("hsv %0 %1 %2 %3 %4 %5 %6")
+							.arg(hue)
+							.arg(hueTolerance * mToleranceFactor)
+							.arg(saturation)
+							.arg(saturationTolerance * mToleranceFactor)
+							.arg(value)
+							.arg(valueTolerance * mToleranceFactor)
+					<< "\n";
+
+			mInputStream.flush();
+		}
+	}
+
+	mSocketNotifier->setEnabled(true);
+}
+
+void CameraLineDetectorSensorWorker::startRoverCv()
+{
+	QFileInfo roverCvBinaryFileInfo(mRoverCvBinary);
+
+	qDebug() << "Starting rover-cv";
+
+	if (mRoverCvProcess.state() == QProcess::Running) {
+		mRoverCvProcess.close();
+	}
+
+	QStringList const params = mParams.split(" ", QString::SkipEmptyParts);
+
+	mRoverCvProcess.setWorkingDirectory(roverCvBinaryFileInfo.absolutePath());
+	mRoverCvProcess.start(roverCvBinaryFileInfo.filePath(), params, QIODevice::ReadOnly | QIODevice::Unbuffered);
+
+	mRoverCvProcess.waitForStarted();
+
+	if (mRoverCvProcess.state() != QProcess::Running)
+	{
+		qDebug() << "Cannot launch detector application " << roverCvBinaryFileInfo.filePath() << " in "
+				<< roverCvBinaryFileInfo.absolutePath();
+		return;
+	}
+
+	qDebug() << "rover-cv started, waiting for it to initialize...";
+
+	/// @todo Remove this hack! QProcess does not deliver messages from rover-cv during startup.
+	QMutex mutex;
+	QWaitCondition wait;
+	wait.wait(&mutex, 1000);
+
+	openFifos();
+}
+
+void CameraLineDetectorSensorWorker::openFifos()
+{
+	qDebug() << "opening" << mOutputFile.fileName();
+
+	if (mInputFile.isOpen()) {
+		mInputFile.close();
+	}
+
+	mOutputFile.open(QIODevice::ReadOnly);
+	mOutputFileDescriptor = mOutputFile.handle();
+
+	if (mOutputFileDescriptor == -1) {
+		qDebug() << "Cannot open sensor output file " << mOutputFile.fileName();
+		return;
+	}
+
+	mSocketNotifier.reset(new QSocketNotifier(mOutputFileDescriptor, QSocketNotifier::Read));
+
+	connect(mSocketNotifier.data(), SIGNAL(activated(int)), this, SLOT(readFile()));
+	mSocketNotifier->setEnabled(true);
+
+	qDebug() << "opening" << mInputFile.fileName();
+
+	if (!mInputFile.open(QIODevice::WriteOnly | QIODevice::Text)) {
+		qDebug() << "Sensor input file" << mInputFile.fileName() << " failed to open";
+		return;
+	}
+
+	mInputStream.setDevice(&mInputFile);
+
+	mReady = true;
+
+	qDebug() << "initialization completed";
+
+	tryToExecute();
+}
+
+void CameraLineDetectorSensorWorker::tryToExecute()
+{
+	if (mReady) {
+		foreach (QString const &command, mCommandQueue) {
+			mInputStream << command + "\n";
+			mInputStream.flush();
+		}
+
+		mCommandQueue.clear();
+	}
+}
+
+void CameraLineDetectorSensorWorker::deinitialize()
+{
+	if (mSocketNotifier) {
+		disconnect(mSocketNotifier.data(), SIGNAL(activated(int)), this, SLOT(readFile()));
+		mSocketNotifier->setEnabled(false);
+	}
+
+	mOutputFile.close();
+
+	mOutputFileDescriptor = -1;
+	mInputFile.close();
+}

trikControl/src/linux/keys.cpp trikControl/src/keys.cpptrikControl/src/linux/keys.cpp renamed to trikControl/src/keys.cpp

@@ -1,4 +1,4 @@
-/* Copyright 2013 Matvey Bryksin, Yurii Litvinov
+/* Copyright 2014 CyberTech Labs Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,15 +12,28 @@
  * See the License for the specific language governing permissions and
  * limitations under the License. */
 
-#include "keys.h"
+#include "src/keysWorker.h"
+
+#include <QtCore/QDebug>
 
 using namespace trikControl;
 
-Keys::Keys(const QString &keysPath)
+KeysWorker::KeysWorker(QString const &keysPath)
+{
+	Q_UNUSED(keysPath)
+}
+
+void KeysWorker::reset()
 {
-	Q_UNUSED(keysPath);
 }
 
-void Keys::readKeysEvent()
+bool KeysWorker::wasPressed(int code)
+{
+	Q_UNUSED(code)
+
+	return false;
+}
+
+void KeysWorker::readKeysEvent()
 {
 }