diff --git a/CPP/HriBoardLib/hriboard.cpp b/CPP/HriBoardLib/hriboard.cpp
index 4720143..84eb8a2 100644
--- a/CPP/HriBoardLib/hriboard.cpp
+++ b/CPP/HriBoardLib/hriboard.cpp
@@ -1,414 +1,415 @@
 /*
  * Copyright (C) 2017 EPFL-LSRO (Laboratoire de Systèmes Robotiques).
  *
  * 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 "hriboard.h"
 
 #include <QDebug>
 #include <QSerialPortInfo>
 #include <QDateTime>
 #include <QMessageBox>
 #include <QApplication>
 #include <QDir>
 
 const int SYNCVAR_LIST_ITEM_SIZE = SYNCVAR_NAME_SIZE + 3;
 
 /**
  * @brief Constructor.
  */
 HriBoard::HriBoard()
 {
 
 }
 
 /**
  * @brief Establish the link with the board.
  * Establish the link with the board, then stops the streaming and requests the
  * variables list.
  * @param comPortName serial port name, in the format "COM1" on Windows, or
  * "/dev/ttyO1" on UNIX.
  * @throws A runtime_error is thrown if the serial port could not be opened.
  */
 void HriBoard::openLink(QString comPortName)
 {
     streamID = 0;
 
     // Setup the serial port.
     serial.setPortName(comPortName);
     serial.setBaudRate(UART_BAUDRATE);
     serial.setDataBits(QSerialPort::Data8);
     serial.setFlowControl(QSerialPort::NoFlowControl);
     serial.setParity(QSerialPort::NoParity);
 
     connect(&serial, SIGNAL(readyRead()), this, SLOT(onReceivedData()));
 
     qDebug() << "Opening the serial COM port...";
 
     if(serial.open(QIODevice::ReadWrite))
         qDebug() << "COM port opened successfully.";
     else
         throw std::runtime_error("Can't open the COM port.");
 
     // Stop the streaming, in case it was enabled.
     QByteArray ba;
     ba.append((char)0);
     sendPacket(PC_MESSAGE_SET_STREAMED_VAR, ba);
 
     // Request the variables list.
     sendPacket(PC_MESSAGE_GET_VARS_LIST);
 }
 
 /**
  * @brief Sets the SyncVars to stream.
  * @param varsToStream list of the SyncVars to stream.
  * @param streamedVarsValues pointer to array where the streaming values will be
  * appended. This parameter can be nullptr to not use this feature.
  */
 void HriBoard::setStreamedVars(QList<SyncVarBase *> varsToStream,
                                QLinkedList<QList<double> > *streamedVarsValues)
 {
     this->streamedVarsValues = streamedVarsValues;
     streamedVarsValues->clear();
 
     // Copy the list of variables to stream, and compute the size of a streaming
     // packet.
     streamedVars.clear();
     streamPacketSize = sizeof(quint8) + sizeof(quint32); // Stream ID + timestamp.
 
     for(SyncVarBase* sv : varsToStream)
     {
         streamedVars.append(syncVars[sv->getIndex()]);
         streamPacketSize += sv->getSize();
     }
 
     //
     streamID++;
 
     QByteArray ba;
     ba.append((quint8)varsToStream.size());
     ba.append(streamID);
 
     for(SyncVarBase* sv : varsToStream)
     {
         int varIndex = sv->getIndex();
         ba.append((quint8)varIndex);
     }
 
     sendPacket(PC_MESSAGE_SET_STREAMED_VAR, ba);
 }
 
 /**
  * @brief Updates a SyncVar on the board with the value of the local one.
  * @param var the SyncVar to synchronize.
  */
 void HriBoard::writeRemoteVar(SyncVarBase *var)
 {
     QByteArray ba;
     ba.append(var->getIndex());
     ba.append(var->getData());
 
     sendPacket(PC_MESSAGE_SET_VAR, ba);
 }
 
 /**
  * @brief Updates a local SyncVar with the value of the SyncVar on the board.
  * @param var the SyncVar to synchronize.
  */
 void HriBoard::readRemoteVar(SyncVarBase *var)
 {
     QByteArray ba;
     ba.append(var->getIndex());
 
     sendPacket(PC_MESSAGE_GET_VAR, ba);
 
     var->setOutOfDate();
 }
 
 /**
  * @brief Makes a list of all the candidate serial ports.
  * @return a list of all the serial port that use the right USB-to-UART chip.
  */
 QStringList HriBoard::getComPorts()
 {
     QList<QSerialPortInfo> ports = QSerialPortInfo::availablePorts();
 
     for(int i=ports.size()-1; i >= 0; i--)
     {
         // Remove from the list all the serial COM ports that are not the CP210x
         // USB-to-serial chip.
         if(!ports[i].description().contains("CP210"))
             ports.removeAt(i);
     }
 
     // Make a list of the COM ports names.
     QStringList portsNames;
     for(QSerialPortInfo comInfo : ports)
         portsNames << comInfo.portName();
 
     return portsNames;
 }
 
 /**
  * @brief Start logging the streamed variables to a CSV file.
  * @return true if the logfile could be created, false otherwise.
  */
 bool HriBoard::startLoggingToFile()
 {
     stopLoggingToFile();
 
     QDateTime now = QDateTime::currentDateTime();
     logFile.setFileName("logs/log_" + now.toString("yyyy-MM-dd_hh-mm-ss")
                         + ".csv");
 
     if(QDir().mkpath("logs/") &&
        !logFile.open(QFile::WriteOnly | QFile::Truncate))
     {
         QMessageBox::warning(nullptr, qApp->applicationName(),
                              "Could not create the logfile.");
         return false;
     }
 
     logStream.setDevice(&logFile);
 
     // Write the file header.
-    logStream << "Timestamp [s];";
+    logStream << "timestamp [s];";
+    logStream.setRealNumberPrecision(10);
 
     for(int i=0; i<syncVars.size(); i++)
     {
         logStream << syncVars[i]->getName();
 
         if(i < syncVars.size()-1)
             logStream << ";";
     }
 
     logStream << endl;
 
     return true;
 }
 
 /**
  * @brief Stop logging the streamed variables to a file.
  * @remark This function does nothing if the logging was not enabled.
  */
 void HriBoard::stopLoggingToFile()
 {
     if(logFile.isOpen())
     {
         logFile.close();
 
         QFileInfo fileInfo(logFile.fileName());
         QMessageBox::information(nullptr, qApp->applicationName(),
                                  "Logfile saved as " +
                                  fileInfo.absoluteFilePath());
     }
 }
 
 /**
  * @brief Return the list of the streamed variables.
  * @return A const reference to the list of the streamed variables.
  */
 const QList<SyncVarBase *> &HriBoard::getStreamedVars()
 {
     return streamedVars;
 }
 
 /**
  * @brief Interprets the received bytes, and reacts accordingly.
  */
 void HriBoard::onReceivedData()
 {
     QByteArray rxData = serial.readAll();
     //qDebug() << "RX:" << rxData;
 
     for(int i=0; i<rxData.size(); i++)
     {
         quint8 rxByte = rxData[i];
 
         if(rxByte & (1<<7)) // The start byte has the most significant bit high.
         {
             rxCurrentMessageType = (rxByte & ~(1<<7)); // Remove the start bit.
             rxBytesCount = 0;
         }
         else // The data bytes have the most significant byte low.
             rxBytesCount++;
 
         if(rxBytesCount % 2 == 1) // First half of the data byte has been received.
             firstHalfByte = rxByte; // Store it until the second half arrives.
         else // Second half of the data byte has been received.
         {
             int dataBytesReady = rxBytesCount/2;
 
             if(dataBytesReady > 0)
                 rxDataBytesBuffer[dataBytesReady-1] = (firstHalfByte<<4) + (rxByte & 0xf);
 
             switch(rxCurrentMessageType)
             {
             case STM_MESSAGE_START_INFO:
                 if(dataBytesReady == 0)
                 {
                     // Request variables list.
                     sendPacket(PC_MESSAGE_GET_VARS_LIST);
                 }
                 break;
 
             case STM_MESSAGE_VAR:
                 if(dataBytesReady >= 1)
                 {
                     quint8 varIndex = rxDataBytesBuffer[0];
 
                     if(dataBytesReady == 1 + syncVars[varIndex]->getSize())
                     {
                         QByteArray ba((char*)&rxDataBytesBuffer[1],
                                        syncVars[varIndex]->getSize());
                         syncVars[varIndex]->setData(ba);
 
                         emit syncVarUpdated(syncVars[varIndex]);
                     }
                 }
                 break;
 
             case STM_MESSAGE_VARS_LIST:
                 if(dataBytesReady >= 1)
                 {
                     quint8 nVars = rxDataBytesBuffer[0];
 
                     if(dataBytesReady == 1 + nVars * SYNCVAR_LIST_ITEM_SIZE)
                     {
                         // Clear the SyncVar array.
                         for(SyncVarBase *sv : syncVars)
                             delete sv;
                         syncVars.clear();
 
                         //
                         quint8* p = &rxDataBytesBuffer[1];
 
                         for(int i=0; i<nVars; i++)
                         {
                             QString varName((char*)p);
                             p += SYNCVAR_NAME_SIZE;
 
                             VarType varType = (VarType)*p;
                             p++;
 
                             VarAccess varAccess = (VarAccess)*p;
                             p++;
 
                             //int varSize = (int)*p; // Size is ignored.
                             p++;
 
                             syncVars.append(makeSyncVar(varType, i, varName,
                                                         varAccess));
                         }
 
                         //
                         emit syncVarsListReceived(syncVars);
 
                         // Stop logging, if in progress.
                         stopLoggingToFile();
                     }
                 }
                 break;
 
             case STM_MESSAGE_STREAMING_PACKET:
                 if(dataBytesReady == streamPacketSize)
                 {
                     if(rxDataBytesBuffer[0] == (quint8)streamID)
                     {
                         QList<double> values;
 
                         // Decode the timestamp.
                         quint32 timestamp;
                         memcpy(&timestamp, &rxDataBytesBuffer[1],
                                sizeof(timestamp));
                         double time = ((double)timestamp) / 1000000.0;
                         values.append(time);
 
                         // Decode the variables values.
                         quint8 const* p = &rxDataBytesBuffer[5];
 
                         for(int i=0; i<streamedVars.size(); i++)
                         {
                             QByteArray value((char*)p,
                                              streamedVars[i]->getSize());
                             streamedVars[i]->setData(value);
                             p += streamedVars[i]->getSize();
 
                             values.append(streamedVars[i]->toDouble());
                         }
 
                         if(streamedVarsValues != nullptr)
                             streamedVarsValues->append(values);
 
                         emit streamedSyncVarsUpdated(time, streamedVars);
 
                         // Log to file, if enabled.
                         if(logFile.isOpen())
                         {
                             logStream << time << ";";
 
                             for(int i=0; i<syncVars.size(); i++)
                             {
                                 if(syncVars[i]->isUpToDate())
                                     logStream << syncVars[i]->toDouble();
                                 else
                                     logStream << 0;
 
                                 if(i < syncVars.size()-1)
                                     logStream << ";";
                             }
 
                             logStream << endl;
                         }
                     }
                 }
                 break;
 
             case STM_MESSAGE_DEBUG_TEXT:
                 if(dataBytesReady > 0 &&
                    rxDataBytesBuffer[dataBytesReady-1] == '\0')
                 {
                     qDebug() << QString((const char*)rxDataBytesBuffer);
                     rxCurrentMessageType = 0;
                 }
                 break;
 
             default: // Ignore.
                 break;
             }
         }
     }
 }
 
 /**
  * @brief Sends a communication packet to the board.
  * @param messageType the type of the message.
  * @param dataBytes the data that will be part of the packet, which is
  * type-specific. If omitted, there will be no data in the message, so it will
  * contain only the type.
  */
 void HriBoard::sendPacket(comm_PcMessage messageType, QByteArray dataBytes)
 {
     QByteArray txBuffer;
     txBuffer.append((1<<7) + (uint8_t)messageType);
 
     for(int i=0; i<dataBytes.size(); i++)
     {
         txBuffer.append(((quint8)dataBytes[i]) >> 4); // MSB.
         txBuffer.append(((quint8)dataBytes[i]) & 0xf); // LSB.
     }
 
     serial.write(txBuffer);
     serial.waitForBytesWritten(-1);
 }
diff --git a/CPP/HriPcController/mainwindow.cpp b/CPP/HriPcController/mainwindow.cpp
index 3f58d04..c63d415 100644
--- a/CPP/HriPcController/mainwindow.cpp
+++ b/CPP/HriPcController/mainwindow.cpp
@@ -1,389 +1,402 @@
 /*
  * Copyright (C) 2017 EPFL-LSRO (Laboratoire de Systèmes Robotiques).
  *
  * 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 "mainwindow.h"
 #include "ui_mainwindow.h"
 
 #include <QMessageBox>
 #include <QDebug>
 #include <QInputDialog>
 #include <QList>
 #include <QDateTime>
 #include <limits>
 
 #define GRAPH_UPDATE_PERIOD 50 ///< Plot window refresh period [ms].
 
 #define SETTING_WINDOW_SIZE "window_size"
 
 /**
  * @brief Constructor
  * Setups the GUI, and try to connect to the HRI board.
  * @param parent parent of this widget.
  */
 MainWindow::MainWindow(QWidget *parent) :
     QMainWindow(parent),
     ui(new Ui::MainWindow)
 {
     //
     ui->setupUi(this);
 
     variablesListLayout = new QGridLayout();
     variablesListLayout->setAlignment(Qt::AlignTop);
     delete ui->scrollWidget->layout();
     ui->scrollWidget->setLayout(variablesListLayout);
 
     chart = new QtCharts::QChart();
     ui->graphicsView->setChart(chart);
     ui->graphicsView->setRenderHint(QPainter::Antialiasing);
 
     graphUpdateTimer.setInterval(GRAPH_UPDATE_PERIOD);
     graphUpdateTimer.setSingleShot(false);
     connect(&graphUpdateTimer, SIGNAL(timeout()), this, SLOT(updateGraph()));
 
     //
     syncVars = nullptr;
 
     // Resize the window to the previous size.
     if(settings.contains(SETTING_WINDOW_SIZE))
         resize(settings.value(SETTING_WINDOW_SIZE).toSize());
 
     // Ask for the COM port.
     QString comPortName;
     QStringList ports = HriBoard::getComPorts();
 
     if(ports.size() == 0)
     {
         QMessageBox::critical(this, qApp->applicationName(), "No COM port.");
         exit(0);
     }
     else if(ports.size() == 1)
         comPortName = ports.first();
     else
     {
         bool ok;
 
         QString portChoice = QInputDialog::getItem(this,
                                                    qApp->applicationName(),
                                                    "Serial port:", ports, 0,
                                                    false, &ok);
 
         int portIndex = ports.indexOf(portChoice);
 
         if(portIndex == -1 || !ok)
             exit(0);
 
         comPortName = ports[portIndex];
     }
 
     //
+    connect(ui->clearButton, SIGNAL(clicked(bool)), this, SLOT(clearPlot()));
     connect(ui->logToFileCheckbox, SIGNAL(toggled(bool)),
             this, SLOT(onLogToFileCheckboxToggled()));
 
     // Establish the link with the HRI board.
     hriBoard.openLink(comPortName);
     connect(&hriBoard, SIGNAL(syncVarsListReceived(const QList<SyncVarBase*>&)),
             this, SLOT(onVarsListReceived(const QList<SyncVarBase*>&)));
     connect(&hriBoard, SIGNAL(syncVarUpdated(SyncVarBase*)),
             this, SLOT(onVarUpdated(SyncVarBase*)));
 }
 
 /**
  * @brief Destructor.
  */
 MainWindow::~MainWindow()
 {
     // Store the window size.
     settings.setValue(SETTING_WINDOW_SIZE, size());
 
     //
     delete ui;
 }
 
 /**
  * @brief Displays the SyncVars list, and starts the streaming.
  * @param syncVars SyncVars list.
  * @remark This slot function is called automatically by the HriBoard object, as
  * soon as the list is received from the board.
  */
 void MainWindow::onVarsListReceived(const QList<SyncVarBase *> &syncVars)
 {
     this->syncVars = &syncVars;
 
     QLayoutItem *li;
     while((li = variablesListLayout->takeAt(0)) != nullptr)
         li->widget()->deleteLater();
 
     syncVarsWidgets.clear();
 
     for(int i=0; i<syncVars.size(); i++)
     {
         SyncVarWidgetsLine varsWidgets;
 
         // Name label.
         varsWidgets.name = new QLabel(syncVars[i]->getName());
         variablesListLayout->addWidget(varsWidgets.name, i, 0);
 
         // Get button.
         if(syncVars[i]->getAccess() != WRITEONLY)
         {
             varsWidgets.getButton = new QPushButton("Get");
             variablesListLayout->addWidget(varsWidgets.getButton, i, 1);
             connect(varsWidgets.getButton, SIGNAL(clicked(bool)),
                     this, SLOT(onGetButtonPressed()));
         }
 
         // Value field.
         varsWidgets.valueSpinBox = new QDoubleSpinBox();
         varsWidgets.valueSpinBox->setDecimals(4);
         varsWidgets.valueSpinBox->setMinimum(std::numeric_limits<double>::lowest());
         varsWidgets.valueSpinBox->setMaximum(std::numeric_limits<double>::max());
         variablesListLayout->addWidget(varsWidgets.valueSpinBox, i, 2);
 
         if(syncVars[i]->getAccess() == READONLY)
         {
             varsWidgets.valueSpinBox->setReadOnly(true);
             varsWidgets.valueSpinBox->setButtonSymbols(QAbstractSpinBox::NoButtons);
         }
         else
         {
             connect(varsWidgets.valueSpinBox, SIGNAL(editingFinished()),
                     this, SLOT(onSetButtonPressed()));
         }
 
         // Set button.
         if(syncVars[i]->getAccess() != READONLY)
         {
             varsWidgets.setButton = new QPushButton("Set");
             variablesListLayout->addWidget(varsWidgets.setButton, i, 3);
             connect(varsWidgets.setButton, SIGNAL(clicked(bool)),
                     this, SLOT(onSetButtonPressed()));
         }
 
         // Stream checkbox.
         if(syncVars[i]->getAccess() != WRITEONLY)
         {
             varsWidgets.streamCheckbox = new QCheckBox("Stream");
             variablesListLayout->addWidget(varsWidgets.streamCheckbox, i, 4);
             connect(varsWidgets.streamCheckbox, SIGNAL(toggled(bool)),
                     this, SLOT(onStreamCheckboxToggled()));
         }
 
         if(syncVars[i]->getAccess() != WRITEONLY)
         {
             varsWidgets.scaleSpinbox = new QDoubleSpinBox();
             variablesListLayout->addWidget(varsWidgets.scaleSpinbox, i, 5);
             varsWidgets.scaleSpinbox->setPrefix("x");
             varsWidgets.scaleSpinbox->setValue(1.0);
             varsWidgets.scaleSpinbox->setRange(-1000000.0, 1000000.0);
         }
 
         syncVarsWidgets.append(varsWidgets);
     }
+
+    //
+    clearPlot();
 }
 
 /**
  * @brief Updates the "value" field of a SyncVar.
  * @param var the SyncVar corresponding to the "value" field to update.
  */
 void MainWindow::onVarUpdated(SyncVarBase *var)
 {
     int varIndex = syncVars->indexOf(var);
 
     if(varIndex >= 0 && varIndex < syncVarsWidgets.size())
         syncVarsWidgets[varIndex].valueSpinBox->setValue(var->toDouble());
 }
 
 /**
  * @brief Gets the value of a SyncVar whose the "Get" button was pressed.
  * @warning This function should only be called by the "Get" button signal.
  */
 void MainWindow::onGetButtonPressed()
 {
     int varIndex = getVarIndexFromWidget((QWidget*)sender());
 
     hriBoard.readRemoteVar(syncVars->at(varIndex));
 }
 
 /**
  * @brief Sets the value of a SyncVar whose the "Set" button was pressed.
  * @warning This function should only be called by the "Set" button signal.
  */
 void MainWindow::onSetButtonPressed()
 {
     int varIndex = getVarIndexFromWidget((QWidget*)sender());
 
     SyncVarBase *sv = syncVars->at(varIndex);
     sv->fromDouble(syncVarsWidgets[varIndex].valueSpinBox->value());
     hriBoard.writeRemoteVar(sv);
 }
 
 /**
  * @brief Updates the list of SyncVars to stream from the checkboxes' states.
  */
 void MainWindow::onStreamCheckboxToggled()
 {
     // Setup the streaming.
     QList<SyncVarBase*> varsToStream;
 
     for(int i=0; i<syncVarsWidgets.size(); i++)
     {
         if(syncVarsWidgets[i].streamCheckbox->isChecked())
             varsToStream.append(syncVars->at(i));
     }
 
     hriBoard.setStreamedVars(varsToStream, &streamedVarsValuesBuffer);
 
     // Setup the graph.
     streamedVarsValuesBuffer.clear();
 
     chart->removeAllSeries();
     linesSeries.clear();
 
     for(SyncVarBase *sv : varsToStream)
     {
         QtCharts::QLineSeries *series = new QtCharts::QLineSeries();
         series->setName(sv->getName());
         chart->addSeries(series);
         linesSeries.append(series);
     }
 
     chart->createDefaultAxes();
     chart->axisX()->setTitleText("Time [s]");
 
     // Setup the update timer.
     if(varsToStream.isEmpty())
         graphUpdateTimer.stop();
     else
         graphUpdateTimer.start();
 }
 
+/**
+ * @brief Clears the plot window.
+ */
+void MainWindow::clearPlot()
+{
+    for(QtCharts::QLineSeries *ls : linesSeries)
+        ls->clear();
+}
+
 /**
  * @brief Starts or stops the streamed variables logging to file.
  */
 void MainWindow::onLogToFileCheckboxToggled()
 {
     if(ui->logToFileCheckbox->isChecked())
     {
         if(!hriBoard.startLoggingToFile())
         {
             QSignalBlocker signalBlocker(ui->logToFileCheckbox);
             ui->logToFileCheckbox->setChecked(false);
         }
     }
     else
         hriBoard.stopLoggingToFile();
 }
 
 /**
  * @brief Refreshes the plot frame.
  */
 void MainWindow::updateGraph()
 {
     // Get the variables scales.
     const QList<SyncVarBase*> &streamedVars = hriBoard.getStreamedVars();
     QList<double> plotScales;
 
     for(SyncVarBase* sv : streamedVars)
     {
         int varIndex = syncVars->indexOf(sv);
 
         if(varIndex != -1)
             plotScales.append(syncVarsWidgets[varIndex].scaleSpinbox->value());
     }
 
     // Add the new points to the graph series.
     int decimationCounter = 0;
 
     while(!streamedVarsValuesBuffer.isEmpty())
     {
         if(decimationCounter <= 0)
         {
             decimationCounter = ui->plotDecimSpinbox->value();
 
             QList<double> &values = streamedVarsValuesBuffer.first();
 
             for(int i=0; i<linesSeries.size(); i++)
                 linesSeries[i]->append(values[0], values[i+1] * plotScales[i]);
         }
         else
             decimationCounter--;
 
         streamedVarsValuesBuffer.removeFirst();
     }
 
     // Remove the oldest points, to limit the number of points displayed.
     for(QtCharts::QLineSeries *ls : linesSeries)
     {
         if(ls->count() > ui->nPointsSpinbox->value())
             ls->removePoints(0, ls->count() - ui->nPointsSpinbox->value());
     }
 
     // Compute the display range.
     if(linesSeries.size() > 0 && linesSeries.first()->count() > 0)
     {
         // Compute the horizontal (time) range.
         double firstTime = linesSeries.first()->points().first().x();
         double lastTime = linesSeries.first()->points().last().x();
 
         chart->axisX()->setRange(firstTime, lastTime);
 
         // Compute the vertical range.
         double min = std::numeric_limits<double>::max();
         double max = std::numeric_limits<double>::lowest();
 
         for(QtCharts::QLineSeries *ls : linesSeries)
         {
             QVector<QPointF> points = ls->pointsVector();
 
             for(QPointF p : points)
             {
                 if(p.y() < min)
                     min = p.y();
 
                 if(p.y() > max)
                     max = p.y();
             }
         }
 
         if(min == max)
         {
             min -= 1.0;
             max += 1.0;
         }
         else
         {
             min -= (max-min) * 0.05; // Add a 5% margin at the top and the
             max += (max-min) * 0.05; // bottom.
         }
 
         chart->axisY()->setRange(min, max);
     }
 }
 
 /**
  * @brief Gets the variable index from a widget of the SyncVars list.
  * @param widget the widget belonging to the variables list.
  * @return The index of the SyncVar corresponding to the given widget.
  */
 int MainWindow::getVarIndexFromWidget(QWidget *widget)
 {
     int index = variablesListLayout->indexOf(widget);
     int row, column, rowSpan, columnSpan;
     variablesListLayout->getItemPosition(index, &row, &column,
                                          &rowSpan, &columnSpan);
 
     return row;
 }
diff --git a/CPP/HriPcController/mainwindow.h b/CPP/HriPcController/mainwindow.h
index c740eb1..5d2329a 100644
--- a/CPP/HriPcController/mainwindow.h
+++ b/CPP/HriPcController/mainwindow.h
@@ -1,97 +1,98 @@
 /*
  * Copyright (C) 2017 EPFL-LSRO (Laboratoire de Systèmes Robotiques).
  *
  * 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.
  */
 
 #ifndef MAINWINDOW_H
 #define MAINWINDOW_H
 
 #include <QMainWindow>
 #include <QTimer>
 #include <QGridLayout>
 #include <QDoubleSpinBox>
 #include <QPushButton>
 #include <QCheckBox>
 #include <QLabel>
 #include <QChart>
 #include <QLineSeries>
 #include <QTimer>
 #include <QLinkedList>
 #include <QSettings>
 
 #include "../HriBoardLib/hriboard.h"
 #include "../HriBoardLib/syncvar.h"
 
 namespace Ui {
 class MainWindow;
 }
 
 /**
  * @addtogroup HriPcController
  * @{
  */
 
 struct SyncVarWidgetsLine
 {
     QLabel *name;
     QPushButton *getButton, *setButton;
     QDoubleSpinBox *valueSpinBox;
     QCheckBox *streamCheckbox;
     QDoubleSpinBox *scaleSpinbox;
 };
 
 /**
  * @brief Qt MainWindow with widgets to interact with SyncVars.
  */
 class MainWindow : public QMainWindow
 {
     Q_OBJECT
 
 public:
     explicit MainWindow(QWidget *parent = 0);
     ~MainWindow();
 
 public slots:
     void onVarsListReceived(const QList<SyncVarBase *> &syncVars);
     void onVarUpdated(SyncVarBase *var);
 
     void onGetButtonPressed();
     void onSetButtonPressed();
     void onStreamCheckboxToggled();
+    void clearPlot();
 
     void onLogToFileCheckboxToggled();
 
     void updateGraph();
 
 private:
     int getVarIndexFromWidget(QWidget* widget);
 
     Ui::MainWindow *ui; ///< Graphical user interface from the ui file.
     HriBoard hriBoard; ///< HRI board interface.
     const QList<SyncVarBase*> *syncVars;
     QList<SyncVarWidgetsLine> syncVarsWidgets;
 
     QSettings settings;
     QGridLayout *variablesListLayout;
     QtCharts::QChart *chart;
     QList<QtCharts::QLineSeries*> linesSeries;
     QTimer graphUpdateTimer;
     QLinkedList<QList<double>> streamedVarsValuesBuffer;
 };
 
 /**
  * @}
  */
 
 #endif
diff --git a/CPP/HriPcController/mainwindow.ui b/CPP/HriPcController/mainwindow.ui
index 804c338..9358dba 100644
--- a/CPP/HriPcController/mainwindow.ui
+++ b/CPP/HriPcController/mainwindow.ui
@@ -1,134 +1,141 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>MainWindow</class>
  <widget class="QMainWindow" name="MainWindow">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>648</width>
     <height>649</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>HRI PC Controller</string>
   </property>
   <widget class="QWidget" name="centralWidget">
    <layout class="QGridLayout" name="gridLayout">
     <item row="4" column="0">
      <widget class="QCheckBox" name="logToFileCheckbox">
       <property name="text">
        <string>Log to CSV file</string>
       </property>
      </widget>
     </item>
     <item row="1" column="0" colspan="2">
      <widget class="QGroupBox" name="groupBox">
       <property name="title">
        <string>Live graph</string>
       </property>
       <layout class="QGridLayout" name="gridLayout_2">
+       <item row="1" column="1">
+        <widget class="QSpinBox" name="nPointsSpinbox">
+         <property name="minimum">
+          <number>10</number>
+         </property>
+         <property name="maximum">
+          <number>1000000</number>
+         </property>
+         <property name="value">
+          <number>1000</number>
+         </property>
+        </widget>
+       </item>
        <item row="1" column="0">
         <widget class="QLabel" name="label">
          <property name="text">
           <string>Number of points to show:</string>
          </property>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QLabel" name="label_2">
          <property name="text">
           <string>Decimation:</string>
          </property>
         </widget>
        </item>
-       <item row="1" column="1">
-        <widget class="QSpinBox" name="nPointsSpinbox">
-         <property name="minimum">
-          <number>10</number>
-         </property>
-         <property name="maximum">
-          <number>1000000</number>
-         </property>
-         <property name="value">
-          <number>1000</number>
-         </property>
-        </widget>
+       <item row="0" column="0" colspan="2">
+        <widget class="QtCharts::QChartView" name="graphicsView"/>
        </item>
        <item row="2" column="1">
         <widget class="QSpinBox" name="plotDecimSpinbox">
          <property name="minimum">
           <number>1</number>
          </property>
          <property name="maximum">
           <number>100</number>
          </property>
          <property name="value">
           <number>10</number>
          </property>
         </widget>
        </item>
-       <item row="0" column="0" colspan="2">
-        <widget class="QtCharts::QChartView" name="graphicsView"/>
+       <item row="3" column="0" colspan="2">
+        <widget class="QPushButton" name="clearButton">
+         <property name="text">
+          <string>Clear plot</string>
+         </property>
+        </widget>
        </item>
       </layout>
      </widget>
     </item>
     <item row="0" column="0">
      <widget class="QGroupBox" name="groupBox_2">
       <property name="title">
        <string>Variables list</string>
       </property>
       <layout class="QVBoxLayout" name="verticalLayout">
        <item>
         <widget class="QScrollArea" name="variablesListArea">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="horizontalScrollBarPolicy">
           <enum>Qt::ScrollBarAlwaysOff</enum>
          </property>
          <property name="sizeAdjustPolicy">
           <enum>QAbstractScrollArea::AdjustIgnored</enum>
          </property>
          <property name="widgetResizable">
           <bool>true</bool>
          </property>
          <widget class="QWidget" name="scrollWidget">
           <property name="geometry">
            <rect>
             <x>0</x>
             <y>0</y>
             <width>612</width>
             <height>274</height>
            </rect>
           </property>
          </widget>
         </widget>
        </item>
       </layout>
      </widget>
     </item>
    </layout>
   </widget>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
    <class>QtCharts::QChartView</class>
    <extends>QGraphicsView</extends>
    <header location="global">QtCharts/QChartView</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>