Restore windows compatibility

Author: feer9

eeprom_programmer_PC/eeprom-programmer.pro

@@ -20,8 +20,9 @@ DEFINES += QT_DEPRECATED_WARNINGS
 
 # Disable debug messages for release builds
 # evaluate only when "release" is defined of the two options "debug" and "release"
-CONFIG(release, debug|release):DEFINES += QT_NO_DEBUG_OUTPUT
-DEFINES += QT_NO_DEBUG_OUTPUT
+CONFIG(release, debug|release): {
+    DEFINES += QT_NO_DEBUG_OUTPUT NDEBUG
+}
 
 # You can also make your code fail to compile if you use deprecated APIs.
 # In order to do so, uncomment the following line.
@@ -39,18 +40,27 @@ SOURCES += \
 	eeprom.cpp \
 	serialportreader.cpp \
 	serialportwriter.cpp \
-	memorycomm.cpp \
-	sigwatch.cpp
+        memorycomm.cpp
 
 HEADERS += \
 	app.h \
 	crc16.h \
 	eeprom.h \
 	serialportreader.h \
 	serialportwriter.h \
-	memorycomm.h \
-	sigwatch.h
+        memorycomm.h
 
+unix {
+    SOURCES += sigwatch.cpp
+    HEADERS += sigwatch.h
+    CONFIG(release, debug|release): \
+        CONFIG += staticlib
+}
+
+win32 {
+    SOURCES += signalhandler.cpp
+    HEADERS += signalhandler.h
+}
 
 # Default rules for deployment.
 qnx: target.path = /tmp/$${TARGET}/bin

eeprom_programmer_PC/eeprom-programmer.pro.user

@@ -151,6 +151,7 @@ App::~App() {
 
 }
 
+
 const QString &App::getOutputFilename() const
 {
 	return m_filename_out;

eeprom_programmer_PC/src/app.cpp

@@ -29,11 +29,12 @@ class App: public MemoryComm
 		ST_INIT,
 		ST_IDLE,
 		ST_MEMID,
-		ST_PING,
+		ST_WAIT_PING,
 		ST_WAIT_READMEM,
 		ST_WAIT_WRITEMEM
 	};
 
+
 private slots:
 	void handleTimeout(void);
 	void pingTimerLoop(void);
@@ -66,6 +67,7 @@ private slots:
 	void setSignals();
 	bool doSomething();
 	void retryConnection();
+	void retryOperation(operations_e);
 };
 
 // m_ = member

eeprom_programmer_PC/src/app.h

@@ -22,6 +22,7 @@
 
 void App::reconnect()
 {
+	qDebug() << "App::reconnect()";
 	m_xferState = ST_DISCONNECTED;
 	m_connected = false;
 	handleXfer(nullptr);
@@ -33,12 +34,9 @@ void App::handleTimeout(void) {
 }
 
 void App::pingTimerLoop(void) {
-/*	if(m_xferState == ST_IDLE && m_currentOperation == OP_NONE)
-	{
-		sendCommand_ping();
-		m_xferState = ST_PING;
-	}*/
-	setNextOperation(OP_PING);
+	if(m_currentOperation == OP_NONE && m_nextOperation == OP_NONE) {
+		setNextOperation(OP_PING);
+	}
 	handleXfer(nullptr);
 }
 
@@ -48,7 +46,7 @@ void App::printError(pkgdata_t *pkg)
 		m_standardOutput << "Unknown error from uC" << Qt::endl;
 	else {
 		char c_err = pkg->data[0];
-		errorcode_e err = errorcode_e(c_err);
+		errorcode_e err = static_cast<errorcode_e>(c_err);
 		m_standardOutput << "uC ERROR " << EEPROM::getErrorMsg(err) << Qt::endl;
 	}
 }
@@ -65,14 +63,14 @@ bool App::doSomething()
 	switch(m_nextOperation)
 	{
 	case OP_RX:
-		m_currentOperation = m_nextOperation;
 		m_xferState = ST_WAIT_READMEM;
+		m_currentOperation = OP_RX;
 		readMem();
 		break;
 
 	case OP_TX:
-		m_currentOperation = m_nextOperation;
 		m_xferState = ST_WAIT_WRITEMEM;
+		m_currentOperation = OP_TX;
 		if(!App::writeMem()) {
 			m_currentOperation = OP_NONE;
 			m_xferState = ST_IDLE;
@@ -81,22 +79,22 @@ bool App::doSomething()
 		break;
 
 	case OP_PING:
-		m_xferState = ST_PING;
-		sendCommand_ping();
-		break;
-
 	case OP_NONE:
+		m_xferState = ST_WAIT_PING;
+		m_currentOperation = OP_PING;
+		sendCommand_ping();
+	//	m_pingTimer.start();
 		break;
 
 	default:
 		m_standardOutput << "Invalid operation." << Qt::endl;
+		m_currentOperation = OP_NONE;
 		break;
 	}
 
 	// clean "Next" flag
 	m_nextOperation = OP_NONE;
 
-
 	// return true if we're gonna do something
 	return m_currentOperation != OP_NONE;
 }
@@ -106,11 +104,23 @@ void App::retryConnection()
 	clearBuffers();
 	m_xferState = ST_DISCONNECTED;
 	m_connected = false;
-	QTimer::singleShot(1000, this, &App::reconnect);
+//	QTimer::singleShot(1000, this, &App::reconnect);
+}
+
+void App::retryOperation(operations_e op)
+{
+	m_currentOperation = OP_NONE;
+	setNextOperation(op);
+	doSomething();
 }
 
 void App::handleXfer(pkgdata_t *pkg) {
-	// TODO: handle error packages
+	// TODO: improve handle of error packages?
+
+	static bool busy = false;
+	if(busy) // make sure no stupid shit happen
+		return;
+	busy = true;
 
 	switch(m_xferState)
 	{
@@ -143,6 +153,7 @@ void App::handleXfer(pkgdata_t *pkg) {
 
 		if(pkg->cmd == CMD_OK) {
 			m_xferState = ST_IDLE;
+			m_currentOperation = OP_NONE;
 			doSomething();
 		}
 		else {
@@ -155,13 +166,14 @@ void App::handleXfer(pkgdata_t *pkg) {
 		doSomething();
 		break;
 
-	case ST_PING: // waiting for ping answer
+	case ST_WAIT_PING: // waiting for ping answer
 
 		if(!pkg)
 			break;
 
 		if(pkg->cmd == CMD_TXRX_ACK) {
 			m_standardOutput << "Ping." << Qt::endl;
+			m_currentOperation = OP_NONE;
 			m_xferState = ST_IDLE;
 		}
 		else {
@@ -175,45 +187,42 @@ void App::handleXfer(pkgdata_t *pkg) {
 		if(!pkg)
 			break;
 
-		m_currentOperation = OP_NONE;
 		if(pkg->cmd == CMD_MEMDATA) {
 			// finished receiving memory data
 			m_memBuffer = pkg->data;
 			printData();
 			saveData();
 			m_xferState = ST_IDLE;
+			m_currentOperation = OP_NONE;
 			QTimer::singleShot(50, qApp, SLOT(quit()));
 		}
 		else {
 			printError(pkg);
-			setNextOperation(OP_RX);
-			doSomething();
+			retryOperation(OP_RX);
 		}
-//		clearBuffers();
 		break;
 
 	case ST_WAIT_WRITEMEM: // requested eeprom full write - waiting confirmation
 
 		if(!pkg)
 			break;
 
-		m_currentOperation = OP_NONE;
 		if(pkg->cmd == CMD_TXRX_DONE) {
 			m_standardOutput << "Memory write SUCCESSFULLY" << Qt::endl;
 			m_xferState = ST_IDLE;
+			m_currentOperation = OP_NONE;
 			QTimer::singleShot(50, qApp, SLOT(quit()));
 		}
 		else {
 			printError(pkg);
-			setNextOperation(OP_TX);
-			doSomething();
+			retryOperation(OP_TX);
 		}
-//		clearBuffers();
 		break;
 
 	default:
 		while(1); // catch the bug :-)
 	}
+	busy = false;
 }
 // TODO: split into simple methods
 

eeprom_programmer_PC/src/app_.cpp

@@ -1,5 +1,8 @@
 #include "app.h"
+#ifdef __unix
 #include "sigwatch.h"
+#endif
+
 
 void myMessageOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg)
 {
@@ -27,7 +30,9 @@ void myMessageOutput(QtMsgType type, const QMessageLogContext &context, const QS
 
 int main(int argc, char *argv[])
 {
-	qInstallMessageHandler(myMessageOutput);
+#ifndef NDEBUG
+//	qInstallMessageHandler(myMessageOutput);
+#endif
 
 	App app(argc, argv);
 
@@ -36,9 +41,8 @@ int main(int argc, char *argv[])
 	UnixSignalWatcher sigwatch;
 	sigwatch.watchForSignal(SIGINT);
 	sigwatch.watchForSignal(SIGTERM);
-	QObject::connect(&sigwatch, SIGNAL(unixSignal(int)), &app, SLOT(quit()));
+	QObject::connect(&sigwatch, SIGNAL(unixSignal(int)), &app, SLOT(quit()));	
 #endif
-
 	return app.exec();
 }
 

eeprom_programmer_PC/src/main.cpp

@@ -44,6 +44,9 @@ void MemoryComm::setSignals()
 
 	connect(&m_serialPortWriter, &SerialPortWriter::packageSent,
 						   this, &MemoryComm::handlePackageSent);
+
+	connect(               qApp, &QCoreApplication::aboutToQuit,
+						   this, &MemoryComm::handleAppQuit);
 }
 
 
@@ -59,23 +62,53 @@ void MemoryComm::setSerialPortOptions(SerialPortOptions& op)
 
 MemoryComm::~MemoryComm()
 {
+	qDebug() << "MemoryComm destructor.";
+
+	if(m_serialPort.isOpen()) {
+		qDebug() << "SerialPort is still open.";
+		m_serialPort.close();
+	}
+}
+
+void MemoryComm::handleAppQuit()
+{
+	qDebug() << "MemoryComm::HandleAppQuit()";
 	if(m_serialPort.isOpen()) {
-		qDebug() <<  "SerialPort connected. Sending CMD_DISCONNECT...";
+		qDebug() << "SerialPort connected. Sending CMD_DISCONNECT...";
 		sendCommand(CMD_DISCONNECT);
-		m_serialPort.waitForBytesWritten(500);
+		while( m_serialPortWriter.busy() == true
+			&& m_serialPort.waitForBytesWritten(5000) != false);
+		// TODO: this doesn't seems to return on time on linux.
+		// Nor does the signal bytesWritten get emmited.
 		m_serialPort.close();
 	}
 	else {
 		qDebug() << "SerialPort not connected.";
 	}
+//	MemoryComm::quit();
 }
 
+#ifdef _WIN32
+bool MemoryComm::handleSignal(int signal)
+{
+	qDebug() << "Handling signal " << signal;
+	if(signal & DEFAULT_SIGNALS) {
+		QTimer::singleShot(0, qApp, SLOT(quit()));
+		// The thread is going to stop soon, so don't propagate this signal further
+		return true;
+	}
+	else {
+		// Let the signal propagate as though we had not been there
+		return false;
+	}
+}
+#endif
+
 void MemoryComm::clearBuffers() {
 	m_serialPortReader.clearBuffer();
 	m_buffer.clear();
 }
 
-
 bool MemoryComm::sendCommand(commands_e cmd, uint8_t data) {
 	return sendCommand(cmd, QByteArray(1, char(data)));
 }
@@ -221,7 +254,7 @@ void MemoryComm::handlePackageReceived(package_t *pkg)
 			if(pkg->cmd == CMD_MEMDATA)
 			{
 				m_buffer.append((char*)(pkg->data), pkg->datalen);
-				qDebug("Received %d bytes out of %d", m_buffer.size(), m_memsize);
+				qDebug("Received %lld bytes out of %d", m_buffer.size(), m_memsize);
 				if(m_buffer.size() < m_memsize) {
 					sendCommand(CMD_TXRX_ACK);
 					m_pending.append(CMD_READNEXT);
@@ -291,7 +324,6 @@ void MemoryComm::setPackageError(package_t *pkg, errorcode_e err)
 
 void MemoryComm::packageReady(package_t *pkg)
 {
-	// hasta acá el paquete llega bien.
 	m_pkg.cmd = pkg->cmd;
 	QByteArray data((char*)(pkg->data), pkg->datalen);
 	m_pkg.data = data;