diff --git a/AudioGame.ico b/AudioGame.ico
new file mode 100644
index 0000000..f451afd
Binary files /dev/null and b/AudioGame.ico differ
diff --git a/AudioGameGUI.pro b/AudioGameGUI.pro
index d465701..8a1e6bd 100644
--- a/AudioGameGUI.pro
+++ b/AudioGameGUI.pro
@@ -10,6 +10,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 CONFIG += c++11
 
 win32 {
+    RC_FILE = app.rc
     QT += axcontainer
     TYPELIBS = $$system(dumpcpp -getfile {D323A622-1D13-11D4-8858-444553540000})
 
@@ -31,7 +32,8 @@ SOURCES += main.cpp\
     Mainwindow.cpp \
     TimerDialog.cpp \
     TDTInterface.cpp \
-    trialseq.cpp
+    trialseq.cpp \
+    LogFileWriter.cpp
 
 
 HEADERS  += \
@@ -41,7 +43,8 @@ HEADERS  += \
     Mainwindow.h \
     SettingStructures.h \
     TDTInterface.h \
-    trialseq.h
+    trialseq.h \
+    LogFileWriter.h
 
 #LIBS += -L"C:\\TDT\\lib64" \
 #    -lRPco
diff --git a/LogFileWriter.cpp b/LogFileWriter.cpp
new file mode 100644
index 0000000..8fa7070
--- /dev/null
+++ b/LogFileWriter.cpp
@@ -0,0 +1,29 @@
+#include "LogFileWriter.h"
+
+LogFileWriter::LogFileWriter(QObject* parent)
+    : QObject(parent)
+{
+}
+
+void LogFileWriter::onOpen(QString fileName)
+{
+    logFile.setFileName(fileName);
+    logFile.open(QIODevice::WriteOnly | QIODevice::Text);
+    QTextStream out(&logFile);
+    /*Write header*/
+    out<<QString("#event\tbit_mask\tstate\ttime\n");
+}
+
+void LogFileWriter::onClose()
+{
+    logFile.close();
+}
+
+void LogFileWriter::onWrite(QString text, uint id, uint counter, QString timeString)
+{
+//    QString timeString = QTime::currentTime().toString("hh:mm:ss.zzz");
+    if(logFile.isOpen()){
+        QTextStream out(&logFile);
+        out << text << "\t" << id << "\t" << counter << "\t" << timeString << "\n";
+    }
+}
diff --git a/LogFileWriter.h b/LogFileWriter.h
new file mode 100644
index 0000000..fc5e019
--- /dev/null
+++ b/LogFileWriter.h
@@ -0,0 +1,26 @@
+#ifndef LOGFILEWRITER_H
+#define LOGFILEWRITER_H
+
+#include <QObject>
+#include <QFile>
+#include <QThread>
+#include <QDataStream>
+#include <QDebug>
+#include <QTime>
+
+class LogFileWriter : public QObject
+{
+    Q_OBJECT
+public:
+    LogFileWriter(QObject *parent = 0);
+private:
+    QFile logFile;
+    QIODevice* device;
+    QTime qTime;
+private slots:
+    void onOpen(QString fileName);
+    void onClose();
+    void onWrite(QString text, uint id, uint counter, QString timeString);
+};
+
+#endif // LOGFILEWRITER_H
diff --git a/Mainwindow.cpp b/Mainwindow.cpp
index 723c19d..b921173 100644
--- a/Mainwindow.cpp
+++ b/Mainwindow.cpp
@@ -40,8 +40,8 @@ MainWindow::MainWindow(QWidget *parent) :
     ui->lineEdit_licksToReward->setValidator(intValidator);
     ui->lineEdit_iti->setValidator(doubleValidator);
 
-    ui->lineEdit_fileNegative->setText("C:/Users/superuser.D-01477/Desktop/attentionGame/20160812_AttentionGame/20160812_AttentionGame/Audio/negative_state.rcx");
-    ui->lineEdit_filePositive->setText("C:/Users/superuser.D-01477/Desktop/attentionGame/20160812_AttentionGame/20160812_AttentionGame/Audio/positive_state.rcx");
+    //ui->lineEdit_fileNegative->setText("C:/Users/superuser.D-01477/Desktop/attentionGame/20160812_AttentionGame/20160812_AttentionGame/Audio/negative_state.rcx");
+    //ui->lineEdit_filePositive->setText("C:/Users/superuser.D-01477/Desktop/attentionGame/20160812_AttentionGame/20160812_AttentionGame/Audio/positive_state.rcx");
 
     connect(&smc, SIGNAL(statusMessage(QString)), this, SLOT(onStatusMessage(QString)));
     connect(&smc, SIGNAL(terminated()), this, SLOT(onStateMachineTerminated()));
@@ -83,6 +83,7 @@ void MainWindow::on_pushButton_Run_clicked()
     settings.trialSequence = TrialSeq::generateTrialSequence(sorting, ui->lineEdit_repeatPositive->text().toInt(), ui->lineEdit_repeatNegative->text().toInt());
     settings.fileNameNegative = ui->lineEdit_filePositive->text();
     settings.fileNamePositive = ui->lineEdit_filePositive->text();
+    settings.logFileName = ui->lineEdit_outputFolder->text() + "/" + ui->lineEdit_outputFilename->text() + ".csv";
 
     if(ui->checkBox_itiExternal->isChecked()){
         qDebug()<<"Using iti from file";
@@ -220,6 +221,7 @@ void MainWindow::on_lineEdit_preImaq_editingFinished()
 void MainWindow::onStateMachineTerminated()
 {
     ui->pushButton_Run->setText("Run");
+    ui->pushButton_Run->setDisabled(false);
 }
 
 void MainWindow::onStatusMessage(QString statusMessage)
diff --git a/Mainwindow.h b/Mainwindow.h
index 8d28230..e42e693 100644
--- a/Mainwindow.h
+++ b/Mainwindow.h
@@ -44,6 +44,7 @@ private slots:
     void onStatusMessage(QString statusMessage);
 
 
+
 private:
     Ui::MainWindow *ui;
 
diff --git a/NIDAQmxInterface.cpp b/NIDAQmxInterface.cpp
index 0454b6b..13e8045 100644
--- a/NIDAQmxInterface.cpp
+++ b/NIDAQmxInterface.cpp
@@ -4,16 +4,16 @@
 /*Indirection for C function pointer to method pointer */
 int32 CVICALLBACK ChangeDetectionCallbackWrapper(TaskHandle taskHandle, int32 signalID, void *callbackData) {
     NIDAQmxInterface * this_ = reinterpret_cast<NIDAQmxInterface*>(callbackData);
-    return this_->FcnCbckDetectDI(taskHandle, signalID, callbackData);
+    return this_->FcnCbckDetectDI(taskHandle, signalID);
 }
 /*Indirection for C function pointer to method pointer */
 int32 CVICALLBACK ChangeTriggerStopCallbackWrapper(TaskHandle taskHandle, int32 signalID, void *callbackData) {
     NIDAQmxInterface * this_ = reinterpret_cast<NIDAQmxInterface*>(callbackData);
-    return this_->FcnCbckTriggerStopDO(taskHandle, signalID, callbackData);
+    return this_->FcnCbckTriggerStopDO(taskHandle, signalID);
 }
 
 
-NIDAQmxInterface::NIDAQmxInterface()
+NIDAQmxInterface::NIDAQmxInterface(QObject* parent) : QObject(parent)
 {
     daq = new DAQmxEngine();
 }
@@ -32,7 +32,8 @@ void NIDAQmxInterface::DAQmxInitializeInterface()
     DAQmxErrChk(DAQmxCreateTask("DigIn", &daq->di_port));
     DAQmxErrChk(DAQmxCreateDIChan(daq->di_port, "Dev1/port0", "", DAQmx_Val_ChanForAllLines));
     DAQmxErrChk(DAQmxCfgChangeDetectionTiming(daq->di_port, "Dev1/port0/line2,Dev1/port0/line6", "Dev1/port0/line2,Dev1/port0/line6", DAQmx_Val_ContSamps, 1));
-    DAQmxErrChk(DAQmxRegisterSignalEvent(daq->di_port, DAQmx_Val_ChangeDetectionEvent, 0, ChangeDetectionCallbackWrapper, daq));
+    //DAQmxErrChk(DAQmxRegisterSignalEvent(daq->di_port, DAQmx_Val_ChangeDetectionEvent, 0, ChangeDetectionCallbackWrapper, daq));
+    DAQmxErrChk(DAQmxRegisterSignalEvent(daq->di_port, DAQmx_Val_ChangeDetectionEvent, 0, ChangeDetectionCallbackWrapper, this));
 
 
     /* configure digital write task */
@@ -45,7 +46,8 @@ void NIDAQmxInterface::DAQmxInitializeInterface()
     DAQmxErrChk(DAQmxCreateCOPulseChanTime(daq->do_clk, "Dev1/ctr0", "", DAQmx_Val_Seconds, DAQmx_Val_Low, 0, 0.05, 0.08));
     DAQmxErrChk(DAQmxCfgImplicitTiming(daq->do_clk, DAQmx_Val_FiniteSamps, 1));
 
-    DAQmxErrChk(DAQmxRegisterDoneEvent(daq->do_clk, 0, ChangeTriggerStopCallbackWrapper, daq));
+    //DAQmxErrChk(DAQmxRegisterDoneEvent(daq->do_clk, 0, ChangeTriggerStopCallbackWrapper, daq));
+    DAQmxErrChk(DAQmxRegisterDoneEvent(daq->do_clk, 0, ChangeTriggerStopCallbackWrapper, this));
 
     /* initialize query performance timer QPC */
     //QPCInitialize();
@@ -59,14 +61,6 @@ void NIDAQmxInterface::DAQmxInitializeInterface()
 /* allocate engine pointer */
 void NIDAQmxInterface::DAQmxSetDefaultEngine()
 {
-    char file_out[256];
-    char date_str[32];
-    time_t now = time(NULL);
-    struct tm *t = localtime(&now);
-    strftime(date_str, sizeof(date_str), "%Y%m%d_%H%M", t);
-    sprintf(file_out, "..\\Logs\\%s_TriggerTasks_logFile.txt", date_str);
-
-
     /* ports TaskHandle */
     daq->di_port = 0;
     daq->di_error = 0;
@@ -84,15 +78,6 @@ void NIDAQmxInterface::DAQmxSetDefaultEngine()
     daq->di_cntr_frame = 0;
     daq->di_cntr_imaq = 0;
 
-    /* log file pointer */
-//    daq->fp_log = fopen(file_out, "w");
-//    if (daq->fp_log == NULL)
-//    {
-//        fprintf(stderr, "DAQmxError:NIDAQmxInterface/DAQmxSetDefaultEngine:\n\tfailed to open %s to write!\n", file_out);
-//        exit(EXIT_FAILURE);
-//    }
-//    fprintf(daq->fp_log, "#event\tbit_mask\tstate\ttick[usec]\n");
-
 	return;
 }
 
@@ -157,10 +142,6 @@ void NIDAQmxInterface::DAQmxDestroyInterface()
     DAQmxErrChk(DAQmxClearTask(daq->do_clk));
     daq->do_clk = 0;
 
-    /* close file */
-    if (daq->fp_log)
-        fclose(daq->fp_log);
-
     return;
 }
 
@@ -230,23 +211,16 @@ void NIDAQmxInterface::DAQmxTriggerDO(uInt8 qry_port_bit, bool arm_timer)
         DAQmxErrChk(DAQmxStartTask(daq->do_clk));
     }
     /* log trigger */
-    //DAQmxLogToFile(daq->fp_log, "TRIGGER", qry_port_bit, (qry_port_bit & daq->do_bit_wrt) == qry_port_bit);
+    QString timeString = QTime::currentTime().toString("hh:mm:ss.zzz");
+    emit(writeToLogFile("TRIGGER", qry_port_bit, (qry_port_bit & daq->do_bit_wrt) == qry_port_bit, timeString));
 
     return;
 }
 
-/* log NIDAQmx events to file */
-void NIDAQmxInterface::DAQmxLogToFile(FILE *fp, const char *msg, uInt32 id, uInt32 counter)
-{
-    if (fp)
-        //fprintf(fp, "%s\t%d\t%d\t%ld\n", msg, id, counter, QPCReadTick());
-	return;
-}
-
 /* Detect Input Callback */
-int32 CVICALLBACK NIDAQmxInterface::FcnCbckDetectDI(TaskHandle taskHandle, int32 signalID, void* callbackData)
+int32 CVICALLBACK NIDAQmxInterface::FcnCbckDetectDI(TaskHandle taskHandle, int32 signalID)
 {
-    DAQmxEngine *daq = (DAQmxEngine *)callbackData;
+    //DAQmxEngine *daq = (DAQmxEngine *)callbackData;
 
     int32 read = 0;
     if (taskHandle != 0)
@@ -264,7 +238,7 @@ int32 CVICALLBACK NIDAQmxInterface::FcnCbckDetectDI(TaskHandle taskHandle, int32
             daq->di_cntr_frame = 0;
 
             /* switch OFF box internal resonance generator */
-            //DAQmxTriggerDO(DAQ_PORT_DO_FREQGEN, FALSE);
+            DAQmxTriggerDO(DAQ_PORT_DO_FREQGEN, FALSE);
         }
 
         /* SHUTTER OFF condition, SHUTTER line changes from 1 to 0 */
@@ -275,26 +249,29 @@ int32 CVICALLBACK NIDAQmxInterface::FcnCbckDetectDI(TaskHandle taskHandle, int32
             daq->flag_scanner = DAQ_PORT_NULL;
 
             /* switch ON box internal resonance generator */
-            //DAQmxTriggerDO(DAQ_PORT_DO_FREQGEN, FALSE);
+            DAQmxTriggerDO(DAQ_PORT_DO_FREQGEN, FALSE);
         }
 
         /* FRAME condition, line 2 changes from 1 to 0 */
         if (((daq->di_bit_prev & DAQ_PORT_DI_FRAME) == DAQ_PORT_DI_FRAME) & ((daq->di_bit_now & DAQ_PORT_DI_FRAME) == DAQ_PORT_NULL))
         {
             daq->di_cntr_frame++;
-            DAQmxLogToFile(daq->fp_log, "FRAME", daq->di_cntr_imaq, daq->di_cntr_frame);
+            QString timeString = QTime::currentTime().toString("hh:mm:ss.zzz");
+            emit(writeToLogFile("FRAME", daq->di_cntr_imaq, daq->di_cntr_frame, timeString));
         }
 
         /* LICK condition, line 6 changes from 0 to 1 */
         if (((daq->di_bit_prev & DAQ_PORT_DI_LICK) == DAQ_PORT_NULL) & ((daq->di_bit_now & DAQ_PORT_DI_LICK) == DAQ_PORT_DI_LICK))
         {
             daq->di_cntr_lick++;
-            DAQmxLogToFile(daq->fp_log, "LICK", DAQ_PORT_DI_LICK, daq->di_cntr_lick);
+            QString timeString = QTime::currentTime().toString("hh:mm:ss.zzz");
+            emit(writeToLogFile("LICK", DAQ_PORT_DI_LICK, daq->di_cntr_lick, timeString));
 
             /* every N licks give a reward */
-            if ((daq->di_cntr_lick % 16) == 0){
+            if ((daq->di_cntr_lick % licksToReward) == 0){
+                DAQmxTriggerDO(DAQ_PORT_DO_WATER, TRUE);
+                qDebug()<<"Water reward!";
             }
-                //DAQmxTriggerDO(DAQ_PORT_DO_WATER, TRUE);
 
         }
 
@@ -306,9 +283,9 @@ int32 CVICALLBACK NIDAQmxInterface::FcnCbckDetectDI(TaskHandle taskHandle, int32
 }
 
 /* Timer Digital Out is Done */
-int32 CVICALLBACK NIDAQmxInterface::FcnCbckTriggerStopDO(TaskHandle taskHandle, int32 signalID, void* callbackData)
+int32 CVICALLBACK NIDAQmxInterface::FcnCbckTriggerStopDO(TaskHandle taskHandle, int32 signalID)
 {
-    DAQmxEngine *daq = (DAQmxEngine *)callbackData;
+    //DAQmxEngine *daq = (DAQmxEngine *)callbackData;
 
     int32 written = 0;
     /* flip query bit, to switch off pulse */
@@ -326,7 +303,8 @@ int32 CVICALLBACK NIDAQmxInterface::FcnCbckTriggerStopDO(TaskHandle taskHandle,
     }
 
     /* log trigger */
-    //DAQmxLogToFile(daq->fp_log, "TRIGGER", daq->do_bit_qry, (daq->do_bit_qry & daq->do_bit_wrt) == daq->do_bit_qry);
+    QString timeString = QTime::currentTime().toString("hh:mm:ss.zzz");
+    emit(writeToLogFile("TRIGGER", daq->do_bit_qry, (daq->do_bit_qry & daq->do_bit_wrt) == daq->do_bit_qry, timeString));
 
     return 0;
 }
diff --git a/NIDAQmxInterface.h b/NIDAQmxInterface.h
index f0d41e9..c2c0d88 100644
--- a/NIDAQmxInterface.h
+++ b/NIDAQmxInterface.h
@@ -1,11 +1,13 @@
 #ifndef NIDAQmxInterface_h
 #define NIDAQmxInterface_h
 
+#include <QObject>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <ctype.h> 
 #include <time.h>
+#include <QTime>
 #include <QDebug>
 #include "C:\Program Files (x86)\National Instruments\Shared\ExternalCompilerSupport\C\include\NIDAQmx.h"
 
@@ -13,9 +15,9 @@
 int32 CVICALLBACK ChangeDetectionCallbackWrapper(TaskHandle taskHandle, int32 signalID, void *callbackData);
 int32 CVICALLBACK ChangeTriggerStopCallbackWrapper(TaskHandle taskHandle, int32 signalID, void *callbackData);
 
-class NIDAQmxInterface
+class NIDAQmxInterface: public QObject
 {
-
+    Q_OBJECT
 
     /* define DAQmxErrChk macro */
     #define DAQmxErrChk(functionCall)\
@@ -42,7 +44,6 @@ class NIDAQmxInterface
         uInt32	di_cntr_lick;
         uInt32	di_cntr_frame;
         uInt32	di_cntr_imaq;
-        FILE	*fp_log;
     } DAQmxEngine;
 
 
@@ -72,8 +73,9 @@ class NIDAQmxInterface
     static const int DAQ_PORT_DE_WATER = 0x04;
 
     const double DO_PULSE_WIDTH = 0.08;// in seconds
+    int licksToReward = 16;
 
-    explicit NIDAQmxInterface();
+    explicit NIDAQmxInterface(QObject *parent = 0);
     /* function prototypes */
     void DAQmxInitializeInterface();
     void DAQmxDestroyInterface();
@@ -83,17 +85,17 @@ class NIDAQmxInterface
     void DAQmxStopCustomTask(TaskHandle);
     void DAQmxTriggerDO(uInt8, bool);
     void DAQmxWriteDO(uInt8);
-    void DAQmxLogToFile(FILE *, const char *, uInt32, uInt32);
-
     DAQmxEngine* daq; /*MAKE PRIVATE*/
 
+signals:
+    void writeToLogFile(QString text, uint id, uint counter, QString stringTime);
+
 private:
     /* events callback functions */
-    int32 CVICALLBACK FcnCbckDetectDI(TaskHandle, int32, void *callback_data);
-    int32 CVICALLBACK FcnCbckTriggerStopDO(TaskHandle, int32, void *callback_data);
-    friend int32 CVICALLBACK ChangeDetectionCallbackWrapper(TaskHandle taskHandle, int32 signalID, void *callbackData);
-    friend int32 CVICALLBACK ChangeTriggerStopCallbackWrapper(TaskHandle taskHandle, int32 signalID, void *callbackData);
-
+    int32 CVICALLBACK FcnCbckDetectDI(TaskHandle, int32);
+    int32 CVICALLBACK FcnCbckTriggerStopDO(TaskHandle, int32);
+    friend int32 CVICALLBACK ChangeDetectionCallbackWrapper(TaskHandle taskHandle, int32 signalID, void *callback_dat);
+    friend int32 CVICALLBACK ChangeTriggerStopCallbackWrapper(TaskHandle taskHandle, int32 signalID, void *callback_dat);
 
     #endif /* define (NIDAQmxInterface_h) */
 };
diff --git a/SettingStructures.h b/SettingStructures.h
index e758bbf..93f869c 100644
--- a/SettingStructures.h
+++ b/SettingStructures.h
@@ -5,6 +5,9 @@
 
 
 struct audioGameSettings{
+
+    QString logFileName;
+
     /*Sequences*/
     QVector<int> trialSequence;
     QVector<double> itiSequence;
@@ -12,7 +15,7 @@ struct audioGameSettings{
     /*Timing*/
     double preDelay = -1;
     double iti = -1;
-    double userReaction = 30; //sec
+    double userReaction = -1; //sec
     double preImaq = -1;
 
     /*Stimulus properties*/
diff --git a/StateMachineController.cpp b/StateMachineController.cpp
index 0c90998..26232eb 100644
--- a/StateMachineController.cpp
+++ b/StateMachineController.cpp
@@ -5,8 +5,6 @@ StateMachineController::StateMachineController(QObject *parent)
     // seed randomizer
     srand(time(0));
     timerDialog = new TimerDialog();
-    //TDTInitializeInterface();
-
     mainTimer = new QTimer(this);
     mainTimer->setSingleShot(true);
 
@@ -52,20 +50,34 @@ StateMachineController::StateMachineController(QObject *parent)
     connect(state_iti, SIGNAL(entered()), this, SLOT(onStateItiEntered()));
     // state user reaction
     connect(state_userReaction, SIGNAL(entered()), this, SLOT(onStateUserReactionEntered()));
+    connect(state_userReaction, SIGNAL(exited()), this, SLOT(onStateUserReactionExited()));
     connect(state_userReaction, SIGNAL(exited()), timerDialog, SLOT(removeTimer()));
     // state baseline
     connect(state_acquisitionBaseline, SIGNAL(entered()), this, SLOT(onStateAcquisitionBaselineEntered()));
     // state sound
     connect(state_sound, SIGNAL(entered()), this, SLOT(onStateSoundEntered()));
-    connect(state_sound, SIGNAL(exited()), this, SLOT(onStateSoundExited()));
     connect(pausedState, SIGNAL(entered()), this, SLOT(onStatePauseEntered()));
 
+
     nidaq = new NIDAQmxInterface();
     nidaq->DAQmxSetDefaultEngine();
     nidaq->DAQmxInitializeInterface();
 
     tdt = new TDTInterface();
     tdt->initializeInterface();
+
+    logFileThread = new QThread(this);
+    logFileWriter = new LogFileWriter();
+
+    /*Thread-safe event communication*/
+    connect(this, SIGNAL(openLogFile(QString)), logFileWriter, SLOT(onOpen(QString)));
+    connect(this, SIGNAL(closeLogFile()), logFileWriter, SLOT(onClose()));
+    connect(this, SIGNAL(writeToLogFile(QString, uint, uint, QString)), logFileWriter, SLOT(onWrite(QString, uint, uint, QString)));
+    connect(nidaq, SIGNAL(writeToLogFile(QString, uint, uint, QString)), logFileWriter, SLOT(onWrite(QString, uint, uint, QString)));
+    logFileWriter->moveToThread(logFileThread);
+    logFileThread->start();
+
+
 }
 
 StateMachineController::~StateMachineController()
@@ -82,6 +94,11 @@ void StateMachineController::startStateMachine(audioGameSettings settings)
     this->settings = settings;
     trialsCurrent = 1; // set index for first trial (1-based)
     trialsTotal = settings.trialSequence.length();
+    nidaq->licksToReward = settings.licksToReward;
+
+    emit(openLogFile(settings.logFileName));
+    QString timeString = QTime::currentTime().toString("hh:mm:ss.zzz");
+    emit(writeToLogFile("INIT",0,0,timeString));
 
     // start state machine
     stateMachine->start();
@@ -97,6 +114,9 @@ void StateMachineController::stopStateMachine()
     timerDialog->removeTimer();
     mainTimer->stop();
     stateMachine->stop();
+    QString timeString = QTime::currentTime().toString("hh:mm:ss.zzz");
+    emit(writeToLogFile("EXIT",0,0,timeString));
+    emit(closeLogFile());
 }
 
 
@@ -104,7 +124,8 @@ void StateMachineController::onStatePreDelayEntered()
 {
     qDebug() << "Pre delay";
     emit(statusMessage("Pre delay running"));
-
+    QString timeString = QTime::currentTime().toString("hh:mm:ss.zzz");
+    emit(writeToLogFile("IDLE", 0, trialsCurrent,timeString));
     mainTimer->setInterval(settings.preDelay * 1000);
     mainTimer->start();
 }
@@ -133,6 +154,12 @@ void StateMachineController::onStateUserReactionEntered()
     mainTimer->start();
 }
 
+void StateMachineController::onStateUserReactionExited()
+{
+    qDebug()<<"Triggering microscope";
+    nidaq->DAQmxTriggerDO(NIDAQmxInterface::DAQ_PORT_DO_IMGAQ, true);
+}
+
 void StateMachineController::onStateAcquisitionBaselineEntered()
 {
     qDebug()<< "Starting baseline";
@@ -161,16 +188,10 @@ void StateMachineController::onStateSoundEntered()
             break;
     }
 
-    mainTimer->start();
-    nidaq->DAQmxTriggerDO(NIDAQmxInterface::DAQ_PORT_DO_SOUND, true);
-
     qDebug()<< "Starting sound";
     emit(statusMessage("Starting sound"));
-
-}
-
-void StateMachineController::onStateSoundExited()
-{
+    mainTimer->start();
+    nidaq->DAQmxTriggerDO(NIDAQmxInterface::DAQ_PORT_DO_SOUND, true);
     qDebug()<< "Finished sound";
     emit(statusMessage("Finished sound"));
     // go to next trial
@@ -184,11 +205,15 @@ void StateMachineController::onStateSoundExited()
         qDebug() << "Terminated";
         emit(statusMessage("Terminated"));
         emit(terminated());
+        QString timeString = QTime::currentTime().toString("hh:mm:ss.zzz");
+        emit(writeToLogFile("EXIT",0,0,timeString));
+        emit(closeLogFile());
     }
+
 }
 
 void StateMachineController::onStatePauseEntered()
 {
     qDebug()<<"Pause state entered";
-     timerDialog->removeTimer();
+    timerDialog->removeTimer();
 }
diff --git a/StateMachineController.h b/StateMachineController.h
index 9b70496..5bc3fef 100644
--- a/StateMachineController.h
+++ b/StateMachineController.h
@@ -9,6 +9,7 @@
 #include <QHistoryState>
 #include <QDebug>
 #include <QAxObject>
+#include <QTime>
 
 #include <ctime>
 #include <algorithm> //std::random_shuffle
@@ -17,6 +18,7 @@
 #include "TimerDialog.h"
 #include "NIDAQmxInterface.h"
 #include "TDTInterface.h"
+#include "LogFileWriter.h"
 
 //#include "TDTInterface.h"
 #include "rpcoxlib.h"
@@ -49,24 +51,31 @@ class StateMachineController : public QObject
     //RPCOXLib::RPcoX* rp;
     NIDAQmxInterface* nidaq;
     TDTInterface* tdt;
+    QThread* logFileThread;
+    LogFileWriter* logFileWriter;
 
     int trialsTotal = -1;
     int trialsCurrent = -1; // is gonna be 1-based, so first trial has index 1
 
-public slots:
+private slots:
     void onStatePreDelayEntered();
     void onStateItiEntered();
     void onStateUserReactionEntered();
+    void onStateUserReactionExited();
     void onStateAcquisitionBaselineEntered();
     void onStateSoundEntered();
-    void onStateSoundExited();
     void onStatePauseEntered();
 
+
 signals:
     void statusMessage(QString);
     void terminated();
     void pauseRequested();
 
+    void openLogFile(QString fileName);
+    void closeLogFile();
+    void writeToLogFile(QString text, uint id, uint counter, QString stringTime);
+
 
 };
 
diff --git a/app.rc b/app.rc
new file mode 100644
index 0000000..d207ed4
--- /dev/null
+++ b/app.rc
@@ -0,0 +1 @@
+IDI_ICON1               ICON    DISCARDABLE     "AudioGame.ico"
diff --git a/mainwindow.ui b/mainwindow.ui
index 6993f49..ff86386 100644
--- a/mainwindow.ui
+++ b/mainwindow.ui
@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>472</width>
-    <height>833</height>
+    <height>614</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -218,7 +218,7 @@
            <item>
             <widget class="QLabel" name="label_10">
              <property name="text">
-              <string>pre-imaq [sec]</string>
+              <string>pre-stimulus [sec]</string>
              </property>
             </widget>
            </item>
@@ -270,7 +270,7 @@
             <widget class="QComboBox" name="comboBox_trialSequence">
              <item>
               <property name="text">
-               <string>ordered</string>
+               <string>alternating</string>
               </property>
              </item>
              <item>
@@ -394,45 +394,8 @@
       </layout>
      </widget>
     </item>
-    <item row="3" column="0">
-     <spacer name="verticalSpacer">
-      <property name="orientation">
-       <enum>Qt::Vertical</enum>
-      </property>
-      <property name="sizeHint" stdset="0">
-       <size>
-        <width>20</width>
-        <height>40</height>
-       </size>
-      </property>
-     </spacer>
-    </item>
    </layout>
   </widget>
-  <widget class="QMenuBar" name="menuBar">
-   <property name="geometry">
-    <rect>
-     <x>0</x>
-     <y>0</y>
-     <width>472</width>
-     <height>21</height>
-    </rect>
-   </property>
-   <property name="defaultUp">
-    <bool>false</bool>
-   </property>
-  </widget>
-  <widget class="QToolBar" name="mainToolBar">
-   <property name="movable">
-    <bool>false</bool>
-   </property>
-   <attribute name="toolBarArea">
-    <enum>TopToolBarArea</enum>
-   </attribute>
-   <attribute name="toolBarBreak">
-    <bool>false</bool>
-   </attribute>
-  </widget>
   <widget class="QStatusBar" name="statusBar"/>
  </widget>
  <layoutdefault spacing="6" margin="11"/>