From b8896d76b696b4652c9d8f19fb5094fbf76453b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fabi=C3=A1n=20Inostroza?= <fabianinostroza@udec.cl>
Date: Sun, 29 Apr 2018 18:52:31 -0300
Subject: [PATCH 1/2] Make SavvyCAN aware of remote frames.

---
 blfhandler.cpp                      |   9 +-
 bus_protocols/isotp_handler.cpp     |   1 +
 can_structs.h                       |   1 +
 canframemodel.cpp                   |  54 ++++++----
 connections/gvretserial.cpp         |   6 ++
 connections/serialbusconnection.cpp |  13 ++-
 framefileio.cpp                     | 154 ++++++++++++++++++++--------
 framesenderwindow.cpp               | 129 ++++++++++++++++++-----
 mainwindow.cpp                      |  22 ++--
 re/fuzzingwindow.cpp                |   1 +
 10 files changed, 285 insertions(+), 105 deletions(-)

diff --git a/blfhandler.cpp b/blfhandler.cpp
index b00c662..41ada14 100644
--- a/blfhandler.cpp
+++ b/blfhandler.cpp
@@ -4,6 +4,8 @@
 #include <QString>
 #include <QtEndian>
 
+#define BLF_REMOTE_FLAG 0x80
+
 BLFHandler::BLFHandler()
 {
 
@@ -70,8 +72,13 @@ bool BLFHandler::loadBLF(QString filename, QVector<CANFrame>* frames)
                             frame.ID = canObject.id & 0x1FFFFFFFull;
                             frame.isReceived = true;
                             frame.len = canObject.dlc;
+                            if (canObject.flags & BLF_REMOTE_FLAG) {
+                                frame.remote = true;
+                            } else {
+                                frame.remote = false;
+                                for (int i = 0; i < 8; i++) frame.data[i] = canObject.data[i];
+                            }
                             frame.timestamp = obj.header.uncompSize / 1000000.0; //uncompsize field also used for timestamp oddly enough
-                            for (int i = 0; i < 8; i++) frame.data[i] = canObject.data[i];
                             frames->append(frame);
                         }
                         pos += obj.header.objSize + (obj.header.objSize % 4);
diff --git a/bus_protocols/isotp_handler.cpp b/bus_protocols/isotp_handler.cpp
index 67d3f83..1ba547c 100644
--- a/bus_protocols/isotp_handler.cpp
+++ b/bus_protocols/isotp_handler.cpp
@@ -51,6 +51,7 @@ void ISOTP_HANDLER::setReception(bool mode)
 void ISOTP_HANDLER::sendISOTPFrame(int bus, int ID, QVector<unsigned char> data)
 {
     CANFrame frame;
+    frame.remote = false;
     int currByte = 0;
     int index = 0;
     if (bus < 0) return;
diff --git a/can_structs.h b/can_structs.h
index b19e901..da60766 100644
--- a/can_structs.h
+++ b/can_structs.h
@@ -11,6 +11,7 @@ public:
     uint32_t ID;
     uint32_t bus;
     bool extended;
+    bool remote;
     bool isReceived; //did we receive this or send it?
     uint32_t len;
     unsigned char data[8];
diff --git a/canframemodel.cpp b/canframemodel.cpp
index 021f681..94f0e0a 100644
--- a/canframemodel.cpp
+++ b/canframemodel.cpp
@@ -6,6 +6,18 @@
 #include <QDateTime>
 #include "utility.h"
 
+enum class Column {
+    TimeStamp = 0, ///< The timestamp when the frame was transmitted or received
+    FrameId   = 1, ///< The frames CAN identifier (Standard: 11 or Extended: 29 bit)
+    Extended  = 2, ///< True if the frames CAN identifier is 29 bit
+    Remote    = 3, ///< True if the frames is a remote frame
+    Direction = 4, ///< Whether the frame was transmitted or received
+    Bus       = 5, ///< The bus where the frame was transmitted or received
+    Length    = 6, ///< The frames payload data length
+    ASCII     = 7, ///< The payload interpreted as ASCII characters
+    Data      = 8, ///< The frames payload data
+    NUM_COLUMN
+};
 
 CANFrameModel::~CANFrameModel()
 {
@@ -40,7 +52,7 @@ int CANFrameModel::totalFrameCount()
 int CANFrameModel::columnCount(const QModelIndex &index) const
 {
     Q_UNUSED(index);
-    return 8;
+    return (int)Column::NUM_COLUMN;
 }
 
 CANFrameModel::CANFrameModel(QObject *parent)
@@ -215,17 +227,6 @@ void CANFrameModel::recalcOverwrite()
     mutex.unlock();
 }
 
-enum class Column {
-    TimeStamp = 0, ///< The timestamp when the frame was transmitted or received
-    FrameId   = 1, ///< The frames CAN identifier (Standard: 11 or Extended: 29 bit)
-    Extended  = 2, ///< True if the frames CAN identifier is 29 bit
-    Direction = 3, ///< Whether the frame was transmitted or received
-    Bus       = 4, ///< The bus where the frame was transmitted or received
-    Length    = 5, ///< The frames payload data length
-    ASCII     = 6, ///< The payload interpreted as ASCII characters
-    Data      = 7 ///< The frames payload data
-};
-
 QVariant CANFrameModel::data(const QModelIndex &index, int role) const
 {
     int dLen;
@@ -276,6 +277,8 @@ QVariant CANFrameModel::data(const QModelIndex &index, int role) const
             return Utility::formatCANID(thisFrame.ID, thisFrame.extended);
         case Column::Extended:
             return QString::number(thisFrame.extended);
+        case Column::Remote:
+            return QString::number(thisFrame.remote);
         case Column::Direction:
             if (thisFrame.isReceived) return QString(tr("Rx"));
             return QString(tr("Tx"));
@@ -291,14 +294,16 @@ QVariant CANFrameModel::data(const QModelIndex &index, int role) const
                 return tempString;
             }
             dLen = thisFrame.len;
-            if (dLen < 0) dLen = 0;
-            if (dLen > 8) dLen = 8;
-            for (int i = 0; i < dLen; i++)
-            {
-                quint8 byt = thisFrame.data[i];
-                if (byt < 0x20) byt = 0x2E; //A dot
-                if (byt > 0x7E) byt = 0x2E;
-                tempString.append(QString::fromUtf8((char *)&byt, 1));
+            if (!thisFrame.remote) {
+                if (dLen < 0) dLen = 0;
+                if (dLen > 8) dLen = 8;
+                for (int i = 0; i < dLen; i++)
+                {
+                    quint8 byt = thisFrame.data[i];
+                    if (byt < 0x20) byt = 0x2E; //A dot
+                    if (byt > 0x7E) byt = 0x2E;
+                    tempString.append(QString::fromUtf8((char *)&byt, 1));
+                }
             }
             return tempString;
         case Column::Data:
@@ -306,6 +311,9 @@ QVariant CANFrameModel::data(const QModelIndex &index, int role) const
             if (dLen < 0) dLen = 0;
             if (dLen > 8) dLen = 8;
             //if (useHexMode) tempString.append("0x ");
+            if (thisFrame.remote) {
+                return tempString;
+            }
             for (int i = 0; i < dLen; i++)
             {
                 if (useHexMode) tempString.append( QString::number(thisFrame.data[i], 16).toUpper().rightJustified(2, '0'));
@@ -332,6 +340,8 @@ QVariant CANFrameModel::data(const QModelIndex &index, int role) const
                 }
             }
             return tempString;
+        default:
+            return tempString;
         }
     }
 
@@ -354,6 +364,8 @@ QVariant CANFrameModel::headerData(int section, Qt::Orientation orientation,
             return QString(tr("ID"));
         case Column::Extended:
             return QString(tr("Ext"));
+        case Column::Remote:
+            return QString(tr("Rem"));
         case Column::Direction:
             return QString(tr("Dir"));
         case Column::Bus:
@@ -364,6 +376,8 @@ QVariant CANFrameModel::headerData(int section, Qt::Orientation orientation,
             return QString(tr("ASCII"));
         case Column::Data:
             return QString(tr("Data"));
+        default:
+            return QString("");
         }
     }
 
diff --git a/connections/gvretserial.cpp b/connections/gvretserial.cpp
index 83a53ec..8c96d38 100644
--- a/connections/gvretserial.cpp
+++ b/connections/gvretserial.cpp
@@ -236,6 +236,11 @@ bool GVRetSerial::piSendFrame(const CANFrame& frame)
     if (!serial->isOpen()) return false;
     //if (!isConnected) return false;
 
+    // Doesn't make sense to send an error frame
+    // to an adapter
+    if (frame.ID & 0x20000000) {
+        return true;
+    }
     ID = frame.ID;
     if (frame.extended) ID |= 1 << 31;
 
@@ -639,6 +644,7 @@ void GVRetSerial::procRXChar(unsigned char c)
                         //qDebug() << "GVRET got frame on bus " << frame_p->bus;
                         /* copy frame */
                         *frame_p = buildFrame;
+                        frame_p->remote = false;
                         checkTargettedFrame(buildFrame);
                         /* enqueue frame */
                         getQueue().queue();
diff --git a/connections/serialbusconnection.cpp b/connections/serialbusconnection.cpp
index f2f4cd2..a054a4e 100644
--- a/connections/serialbusconnection.cpp
+++ b/connections/serialbusconnection.cpp
@@ -117,9 +117,13 @@ bool SerialBusConnection::piSendFrame(const CANFrame& pFrame)
     QCanBusFrame frame;
     frame.setFrameId(pFrame.ID);
     frame.setExtendedFrameFormat(pFrame.extended);
+    if (pFrame.remote) {
+        frame.setFrameType(QCanBusFrame::FrameType::RemoteRequestFrame);
+    } else {
+        frame.setFrameType(QCanBusFrame::FrameType::DataFrame);
+    }
     frame.setPayload(QByteArray(reinterpret_cast<const char *>(pFrame.data),
                                 static_cast<int>(pFrame.len)));
-
     return mDev_p->writeFrame(frame);
 }
 
@@ -187,7 +191,12 @@ void SerialBusConnection::framesReceived()
             if(frame_p) {
                 frame_p->len           = static_cast<uint32_t>(recFrame.payload().length());
                 frame_p->bus           = 0;
-                memcpy(frame_p->data, recFrame.payload().data(), frame_p->len);
+                if (recFrame.frameType() == QCanBusFrame::FrameType::RemoteRequestFrame) {
+                    frame_p->remote = true;
+                } else {
+                    frame_p->remote = false;
+                    memcpy(frame_p->data, recFrame.payload().data(), frame_p->len);
+                }
                 frame_p->extended      = recFrame.hasExtendedFrameFormat();
                 frame_p->ID            = recFrame.frameId();
                 frame_p->isReceived    = true;
diff --git a/framefileio.cpp b/framefileio.cpp
index 53fd2e2..966ae6a 100644
--- a/framefileio.cpp
+++ b/framefileio.cpp
@@ -551,15 +551,25 @@ bool FrameFileIO::loadPCANFile(QString filename, QVector<CANFrame>* frames)
                     thisFrame.len = line.mid(38,1).toInt();
                     thisFrame.isReceived = true;
                     thisFrame.bus = 0;
-                    thisFrame.extended = false;
-                    QList<QByteArray> tokens = line.mid(41, thisFrame.len * 3).split(' ');
-                    for (unsigned int d = 0; d < thisFrame.len; d++)
-                    {
-                        if (tokens[d] != "")
+                    if (line.at(28) == ' ') {
+                        thisFrame.extended = true;
+                    } else {
+                        thisFrame.extended = false;
+                    }
+
+                    if (line.at(41) == 'R') {
+                        thisFrame.remote = true;
+                    } else {
+                        QList<QByteArray> tokens = line.mid(41, thisFrame.len * 3).split(' ');
+                        thisFrame.remote = false;
+                        for (unsigned int d = 0; d < thisFrame.len; d++)
                         {
-                            thisFrame.data[d] = tokens[d].toInt(NULL, 16);
+                            if (tokens[d] != "")
+                            {
+                                thisFrame.data[d] = tokens[d].toInt(NULL, 16);
+                            }
+                            else thisFrame.data[d] = 0;
                         }
-                        else thisFrame.data[d] = 0;
                     }
                     frames->append(thisFrame);
                 }
@@ -574,15 +584,24 @@ bool FrameFileIO::loadPCANFile(QString filename, QVector<CANFrame>* frames)
                     qDebug() << thisFrame.len;
                     thisFrame.isReceived = true;
                     thisFrame.bus = 0;
-                    thisFrame.extended = false;
-                    QList<QByteArray> tokens = line.mid(40, thisFrame.len * 3).split(' ');
-                    for (unsigned int d = 0; d < thisFrame.len; d++)
-                    {
-                        if (tokens[d] != "")
+                    if (line.at(25) == ' ') {
+                        thisFrame.extended = false;
+                    } else {
+                        thisFrame.extended = true;
+                    }
+                    if (line.at(40) == 'R') {
+                        thisFrame.remote = true;
+                    } else {
+                        QList<QByteArray> tokens = line.mid(40, thisFrame.len * 3).split(' ');
+                        thisFrame.remote = false;
+                        for (unsigned int d = 0; d < thisFrame.len; d++)
                         {
-                            thisFrame.data[d] = tokens[d].toInt(NULL, 16);
+                            if (tokens[d] != "")
+                            {
+                                thisFrame.data[d] = tokens[d].toInt(NULL, 16);
+                            }
+                            else thisFrame.data[d] = 0;
                         }
-                        else thisFrame.data[d] = 0;
                     }
                     frames->append(thisFrame);
                 }
@@ -610,6 +629,7 @@ bool FrameFileIO::loadCanalyzerASC(QString filename, QVector<CANFrame>* frames)
     int lineCounter = 0;
     bool foundErrors = false;
     bool inHeader = true;
+    thisFrame.remote = false;
 
     if (!inFile->open(QIODevice::ReadOnly | QIODevice::Text))
     {
@@ -640,6 +660,7 @@ bool FrameFileIO::loadCanalyzerASC(QString filename, QVector<CANFrame>* frames)
             thisFrame.isReceived = tokens[3].toUpper().contains("RX");
             thisFrame.bus = tokens[1].toUInt();
             thisFrame.extended = (thisFrame.ID > 0x7FF);
+            thisFrame.remote = false;
             for (unsigned int d = 6; d < (6 + thisFrame.len); d++)
             {
                 if (tokens.count() > d)
@@ -677,6 +698,7 @@ bool FrameFileIO::loadNativeCSVFile(QString filename, QVector<CANFrame>* frames)
     long long timeStamp = Utility::GetTimeMS();
     int lineCounter = 0;
     bool foundErrors = false;
+    thisFrame.remote = false;
 
     if (!inFile->open(QIODevice::ReadOnly | QIODevice::Text))
     {
@@ -899,6 +921,7 @@ bool FrameFileIO::loadGenericCSVFile(QString filename, QVector<CANFrame>* frames
     long long timeStamp = Utility::GetTimeMS();
     int lineCounter = 0;
     bool foundErrors = false;
+    thisFrame.remote = false;
 
     if (!inFile->open(QIODevice::ReadOnly | QIODevice::Text))
     {
@@ -989,7 +1012,7 @@ tokens:
 1 = Transmission direction
 2 = Channel
 3 = ID
-4 = Type (s = standard, I believe x = extended)
+4 = Type (s = standard, x = extended, sr = standard remote, xr = extended remote)
 5 = Data byte length
 6-x = The data bytes
 
@@ -1053,12 +1076,26 @@ bool FrameFileIO::loadLogFile(QString filename, QVector<CANFrame>* frames)
                 if (tokens[1].at(0) == 'R') thisFrame.isReceived = true;
                     else thisFrame.isReceived = false;
                 thisFrame.ID = tokens[3].right(tokens[3].length() - 2).toInt(NULL, 16);
-                if (tokens[4] == "s") thisFrame.extended = false;
-                    else thisFrame.extended = true;
+                if (tokens[4] == "S") {
+                    thisFrame.extended = false;
+                    thisFrame.remote = false;
+                } else if (tokens[4] == "X") {
+                    thisFrame.extended = true;
+                    thisFrame.remote = false;
+                } else if (tokens[4] == "SR") {
+                    thisFrame.extended = false;
+                    thisFrame.remote = true;
+                } else { // XR
+                    thisFrame.extended = true;
+                    thisFrame.remote = true;
+                }
                 thisFrame.bus = tokens[2].toInt() - 1;
                 thisFrame.len = tokens[5].toUInt();
                 if (thisFrame.len > 8) thisFrame.len = 8;
-                for (unsigned int d = 0; d < thisFrame.len; d++) thisFrame.data[d] = tokens[d + 6].toInt(NULL, 16);
+                if (!thisFrame.remote) {
+                    for (unsigned int d = 0; d < thisFrame.len; d++)
+                        thisFrame.data[d] = tokens[d + 6].toInt(NULL, 16);
+                }
                 frames->append(thisFrame);
             }
             else foundErrors = true;
@@ -1083,7 +1120,7 @@ bool FrameFileIO::saveLogFile(QString filename, const QVector<CANFrame>* frames)
         return false;
     }
 
-    outFile->write("***BUSMASTER Ver 2.4.0***\n");
+    outFile->write("***BUSMASTER Ver 3.2.0***\n");
     outFile->write("***PROTOCOL CAN***\n");
     outFile->write("***NOTE: PLEASE DO NOT EDIT THIS DOCUMENT***\n");
     outFile->write("***[START LOGGING SESSION]***\n");
@@ -1095,8 +1132,8 @@ bool FrameFileIO::saveLogFile(QString filename, const QVector<CANFrame>* frames)
     outFile->write("***START CHANNEL BAUD RATE***\n");
     outFile->write("***CHANNEL 1 - Kvaser - Kvaser Leaf Light HS #0 (Channel 0), Serial Number- 0, Firmware- 0x00000037 0x00020000 - 500000 bps***\n");
     outFile->write("***END CHANNEL BAUD RATE***\n");
-    outFile->write("***START DATABASE FILES (DBF/DBC)***\n");
-    outFile->write("***END OF DATABASE FILES (DBF/DBC)***\n");
+    outFile->write("***START DATABASE FILES***\n");
+    outFile->write("***END OF DATABASE FILES***\n");
     outFile->write("***<Time><Tx/Rx><Channel><CAN ID><Type><DLC><DataBytes>***\n");
 
     for (int c = 0; c < frames->count(); c++)
@@ -1109,19 +1146,29 @@ bool FrameFileIO::saveLogFile(QString filename, const QVector<CANFrame>* frames)
         }
 
         tempStamp = QDateTime::fromMSecsSinceEpoch(frames->at(c).timestamp / 1000);
-        outFile->write(tempStamp.toString("h:m:s:z").toUtf8());
+        outFile->write(tempStamp.toString("hh:mm:ss:zzz").toUtf8());
         if (frames->at(c).isReceived) outFile->write(" Rx ");
         else outFile->write(" Tx ");
-        outFile->write(QString::number(frames->at(c).bus).toUtf8() + " ");
-        outFile->write(QString::number(frames->at(c).ID, 16).toUpper().rightJustified(8, '0').toUtf8());
-        if (frames->at(c).extended) outFile->write(" x ");
-            else outFile->write(" s ");
+        // busmaster channel start at 1
+        outFile->write(QString::number(frames->at(c).bus+1).toUtf8() + " ");
+        outFile->write("0x");
+        if (frames->at(c).extended && frames->at(c).ID > 0x7FF) {
+            outFile->write(QString::number(frames->at(c).ID, 16).toUpper().rightJustified(8, '0').toUtf8());
+        } else {
+            outFile->write(QString::number(frames->at(c).ID, 16).toUpper().rightJustified(3, '0').toUtf8());
+        }
+        if (frames->at(c).extended) outFile->write(" x");
+            else outFile->write(" s");
+        if (frames->at(c).remote) outFile->write("r ");
+            else outFile->write(" ");
         outFile->write(QString::number(frames->at(c).len).toUtf8() + " ");
 
-        for (unsigned int temp = 0; temp < frames->at(c).len; temp++)
-        {
-            outFile->write(QString::number(frames->at(c).data[temp], 16).toUpper().rightJustified(2, '0').toUtf8());
-            outFile->putChar(' ');
+        if (!frames->at(c).remote) {
+            for (unsigned int temp = 0; temp < frames->at(c).len; temp++)
+            {
+                outFile->write(QString::number(frames->at(c).data[temp], 16).toUpper().rightJustified(2, '0').toUtf8());
+                outFile->putChar(' ');
+            }
         }
 
         outFile->write("\n");
@@ -1141,6 +1188,7 @@ bool FrameFileIO::loadIXXATFile(QString filename, QVector<CANFrame>* frames)
     uint64_t timeStamp = Utility::GetTimeMS();
     int lineCounter = 0;
     bool foundErrors = false;
+    thisFrame.remote = false;
 
     if (!inFile->open(QIODevice::ReadOnly | QIODevice::Text))
     {
@@ -1268,6 +1316,7 @@ bool FrameFileIO::loadCANDOFile(QString filename, QVector<CANFrame>* frames)
     int timeOffset = 0;
     uint64_t lastTimeStamp = 0;
     bool foundErrors = false;
+    thisFrame.remote = false;
 
     if (!inFile->open(QIODevice::ReadOnly))
     {
@@ -1391,6 +1440,7 @@ bool FrameFileIO::loadMicrochipFile(QString filename, QVector<CANFrame>* frames)
     long long timeStamp;
     int lineCounter = 0;
     bool foundErrors = false;
+    thisFrame.remote = false;
 
     if (!inFile->open(QIODevice::ReadOnly | QIODevice::Text))
     {
@@ -1547,6 +1597,7 @@ bool FrameFileIO::loadTraceFile(QString filename, QVector<CANFrame>* frames)
     long long timeStamp = 0;
     int lineCounter = 0;
     bool foundErrors = false;
+    thisFrame.remote = false;
 
     if (!inFile->open(QIODevice::ReadOnly | QIODevice::Text))
     {
@@ -1718,17 +1769,26 @@ bool FrameFileIO::saveCanDumpFile(QString filename, const QVector<CANFrame> * fr
 
         outFile->write("(");
 
-	tempTime = frames->at(c).timestamp / 1000000.0;
-        outFile->write(QString::number(tempTime,'f').toUtf8());
+        tempTime = frames->at(c).timestamp / 1000000.0;
+        outFile->write(QString::number(tempTime,'f', 6).rightJustified(17, '0').toUtf8());
         outFile->write(") vcan0 ");
 
-        outFile->write(QString::number(frames->at(c).ID, 16).rightJustified(3,'0').toUpper().toUtf8());
+        if (frames->at(c).extended) {
+            outFile->write(QString::number(frames->at(c).ID, 16).rightJustified(8,'0').toUpper().toUtf8());
+        } else {
+            outFile->write(QString::number(frames->at(c).ID, 16).rightJustified(3,'0').toUpper().toUtf8());
+        }
 
         outFile->write("#");
 
-        for (unsigned int temp = 0; temp < frames->at(c).len; temp++)
-        {
-            outFile->write(QString::number(frames->at(c).data[temp], 16).rightJustified(2,'0').toUpper().toUtf8());
+        if (frames->at(c).remote) {
+            outFile->write("R");
+            outFile->write(QString::number(frames->at(c).len).toUtf8());
+        } else {
+            for (unsigned int temp = 0; temp < frames->at(c).len; temp++)
+            {
+                outFile->write(QString::number(frames->at(c).data[temp], 16).rightJustified(2,'0').toUpper().toUtf8());
+            }
         }
 
         outFile->write("\n");
@@ -1784,7 +1844,6 @@ bool FrameFileIO::loadCanDumpFile(QString filename, QVector<CANFrame>* frames)
             if(!ret) continue;
 
             /* ID */
-            qDebug() << IdValExp.cap(1);
             thisFrame.ID = IdValExp.cap(1).toInt(&ret, 16);
             if (IdValExp.cap(1).length() > 3) {
                 thisFrame.extended = true;
@@ -1796,16 +1855,22 @@ bool FrameFileIO::loadCanDumpFile(QString filename, QVector<CANFrame>* frames)
             QString val= IdValExp.cap(2);
             QRegExp valExp("(\\S{2})");
 
-            /* val byte per byte */
             pos = 0;
             thisFrame.len = 0;
-            while ((pos = valExp.indexIn(val, pos)) != -1)
-            {
-                thisFrame.data[thisFrame.len] = valExp.cap(1).toInt(&ret, 16);
-                if(!ret) continue;
+            if (val.startsWith("R") && val.at(1).isDigit()) {
+                thisFrame.len = val.at(1).toLatin1() - '0';
+                thisFrame.remote = true;
+            } else {
+                thisFrame.remote = false;
+                /* val byte per byte */
+                while ((pos = valExp.indexIn(val, pos)) != -1)
+                {
+                    thisFrame.data[thisFrame.len] = valExp.cap(1).toInt(&ret, 16);
+                    if(!ret) continue;
 
-                thisFrame.len++;
-                pos += valExp.matchedLength();
+                    thisFrame.len++;
+                    pos += valExp.matchedLength();
+                }
             }
 
             /*NB: should we make sure len <= 8? */
@@ -1829,6 +1894,7 @@ bool FrameFileIO::loadKvaserFile(QString filename, QVector<CANFrame> *frames, bo
     int lineCounter = 0;
     int base = 10;
     bool foundErrors = false;
+    thisFrame.remote = false;
 
     if (useHex) base = 16;
 
diff --git a/framesenderwindow.cpp b/framesenderwindow.cpp
index e3bed0d..d74cddb 100644
--- a/framesenderwindow.cpp
+++ b/framesenderwindow.cpp
@@ -47,16 +47,19 @@ FrameSenderWindow::FrameSenderWindow(const QVector<CANFrame> *frames, QWidget *p
 void FrameSenderWindow::setupGrid()
 {
     QStringList headers;
-    headers << "En" << "Bus" << "ID" << "Len" << "Data" << "Trigger" << "Modifications" << "Count";
-    ui->tableSender->setColumnCount(8);
+    headers << "En" << "Bus" << "ID" << "Len" << "Ext" << "Rem" << "Data"
+            << "Trigger" << "Modifications" << "Count";
+    ui->tableSender->setColumnCount(10);
     ui->tableSender->setColumnWidth(0, 50);
     ui->tableSender->setColumnWidth(1, 50);
     ui->tableSender->setColumnWidth(2, 50);
     ui->tableSender->setColumnWidth(3, 50);
-    ui->tableSender->setColumnWidth(4, 220);
-    ui->tableSender->setColumnWidth(5, 220);
+    ui->tableSender->setColumnWidth(4, 50);
+    ui->tableSender->setColumnWidth(5, 50);
     ui->tableSender->setColumnWidth(6, 220);
-    ui->tableSender->setColumnWidth(7, 80);
+    ui->tableSender->setColumnWidth(7, 220);
+    ui->tableSender->setColumnWidth(8, 220);
+    ui->tableSender->setColumnWidth(9, 80);
     ui->tableSender->setHorizontalHeaderLabels(headers);
 }
 
@@ -98,10 +101,22 @@ void FrameSenderWindow::createBlankRow()
     inhibitChanged = true;
     ui->tableSender->setItem(row, 0, item);
 
-    for (int i = 1; i < 8; i++)
+    item = new QTableWidgetItem();
+    item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
+    item->setCheckState(Qt::Unchecked);
+    ui->tableSender->setItem(row, 4, item);
+
+    item = new QTableWidgetItem();
+    item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
+    item->setCheckState(Qt::Unchecked);
+    ui->tableSender->setItem(row, 5, item);
+
+    for (int i = 1; i < 10; i++)
     {
-        item = new QTableWidgetItem("");
-        ui->tableSender->setItem(row, i, item);
+        if (i != 4 && i != 5) {
+            item = new QTableWidgetItem("");
+            ui->tableSender->setItem(row, i, item);
+         }
     }
 
     inhibitChanged = false;
@@ -290,9 +305,17 @@ void FrameSenderWindow::saveSenderFile(QString filename)
             outString = "T#";
         }
         else outString = "F#";
-        for (int i = 1; i < 7; i++)
+        for (int i = 1; i < 9; i++)
         {
-            outString.append(ui->tableSender->item(c, i)->text());
+            if (i == 4 || i == 5) {
+                if (ui->tableSender->item(c, i)->checkState() == Qt::Checked) {
+                    outString.append("T");
+                } else {
+                    outString.append("F");
+                }
+            } else {
+                outString.append(ui->tableSender->item(c, i)->text());
+            }
             outString.append("#");
         }
         outString.append("\n");
@@ -330,17 +353,43 @@ void FrameSenderWindow::loadSenderFile(QString filename)
             QTableWidgetItem *item = new QTableWidgetItem();
             ui->tableSender->setItem(row, 0, item);
             ui->tableSender->item(row, 0)->setFlags(item->flags() | Qt::ItemIsUserCheckable);
+
+            item = new QTableWidgetItem();
+            ui->tableSender->setItem(row, 4, item);
+            ui->tableSender->item(row, 4)->setFlags(item->flags() | Qt::ItemIsUserCheckable);
+            item->setCheckState(Qt::Unchecked);
+
+            item = new QTableWidgetItem();
+            ui->tableSender->setItem(row, 5, item);
+            ui->tableSender->item(row, 5)->setFlags(item->flags() | Qt::ItemIsUserCheckable);
+            item->setCheckState(Qt::Unchecked);
+
             if (tokens[0] == "T")
             {
                 ui->tableSender->item(row, 0)->setCheckState(Qt::Checked);
             }
             else ui->tableSender->item(row, 0)->setCheckState(Qt::Unchecked);
-            for (int i = 1; i < 7; i++)
-            {
-                ui->tableSender->setItem(row, i, new QTableWidgetItem(QString(tokens[i])));
+            if (tokens.length() >= 9) {
+                for (int i = 1; i < 9; i++)
+                {
+                    if (i != 4 && i != 5) {
+                        ui->tableSender->setItem(row, i, new QTableWidgetItem(QString(tokens[i])));
+                    } else {
+                        if (tokens[i] == "T") {
+                            ui->tableSender->item(row, i)->setCheckState(Qt::Checked);
+                        }
+                    }
+                }
+            } else {
+                ui->tableSender->setItem(row, 1, new QTableWidgetItem(QString(tokens[1])));
+                ui->tableSender->setItem(row, 2, new QTableWidgetItem(QString(tokens[2])));
+                ui->tableSender->setItem(row, 3, new QTableWidgetItem(QString(tokens[3])));
+                ui->tableSender->setItem(row, 6, new QTableWidgetItem(QString(tokens[4])));
+                ui->tableSender->setItem(row, 7, new QTableWidgetItem(QString(tokens[5])));
+                ui->tableSender->setItem(row, 8, new QTableWidgetItem(QString(tokens[6])));
             }
             inhibitChanged = false;
-            for (int k = 0; k < 7; k++) processCellChange(row, k);
+            for (int k = 0; k < 9; k++) processCellChange(row, k);
 
         }
     }
@@ -523,7 +572,7 @@ void FrameSenderWindow::processModifierText(int line)
 
     //yeah, lots of operations on this one line but it's for a good cause. Removes the convenience English versions of the
     //logical operators and replaces them with the math equivs. Also uppercases and removes all superfluous whitespace
-    modString = ui->tableSender->item(line, 6)->text().toUpper().trimmed().replace("AND", "&").replace("XOR", "^").replace("OR", "|").replace(" ", "");
+    modString = ui->tableSender->item(line, 8)->text().toUpper().trimmed().replace("AND", "&").replace("XOR", "^").replace("OR", "|").replace(" ", "");
     if (modString != "")
     {
         QStringList mods = modString.split(',');
@@ -613,7 +662,7 @@ void FrameSenderWindow::processTriggerText(int line)
     //trigger has two levels of syntactic parsing. First you split by comma to get each
     //actual trigger. Then you split by spaces to get the tokens within each trigger
     //trigger = ui->tableSender->item(line, 5)->text().toUpper().trimmed().replace(" ", "");
-    trigger = ui->tableSender->item(line, 5)->text().toUpper();
+    trigger = ui->tableSender->item(line, 7)->text().toUpper();
     if (trigger != "")
     {
         QStringList triggers = trigger.split(',');
@@ -735,15 +784,19 @@ void FrameSenderWindow::updateGridRow(int idx)
     FrameSendData *temp = &sendingData[idx];
     int gridLine = idx;
     QString dataString;
-    QTableWidgetItem *item = ui->tableSender->item(gridLine, 7);
+    QTableWidgetItem *item = ui->tableSender->item(gridLine, 9);
     if (item == NULL) item = new QTableWidgetItem();
     item->setText(QString::number(temp->count));
-    for (unsigned int i = 0; i < temp->len; i++)
-    {
-        dataString.append(Utility::formatNumber(temp->data[i]));
-        dataString.append(" ");
+    if (!temp->remote) {
+        for (unsigned int i = 0; i < temp->len; i++)
+        {
+            dataString.append(Utility::formatNumber(temp->data[i]));
+            dataString.append(" ");
+        }
+        ui->tableSender->item(gridLine, 6)->setText(dataString);
+    } else {
+        ui->tableSender->item(gridLine, 6)->setText("");
     }
-    ui->tableSender->item(gridLine, 4)->setText(dataString);
     inhibitChanged = false;
 }
 
@@ -759,6 +812,8 @@ void FrameSenderWindow::processCellChange(int line, int col)
     {
         FrameSendData tempData;
         tempData.enabled = false;
+        tempData.remote = false;
+        tempData.extended = false;
         sendingData.append(tempData);
     }
 
@@ -786,8 +841,12 @@ void FrameSenderWindow::processCellChange(int line, int col)
             if (tempVal < 1) tempVal = 1;
             if (tempVal > 0x7FFFFFFF) tempVal = 0x7FFFFFFF;
             sendingData[line].ID = tempVal;
-            if (sendingData[line].ID <= 0x7FF) sendingData[line].extended = false;
-            else sendingData[line].extended = true;
+            if (sendingData[line].ID > 0x7FF) {
+                sendingData[line].extended = true;
+                ui->tableSender->blockSignals(true);
+                ui->tableSender->item(line, 4)->setCheckState(Qt::Checked);
+                ui->tableSender->blockSignals(false);
+            }
             qDebug() << "setting ID to " << tempVal;
             break;
         case 3: //length field
@@ -796,19 +855,33 @@ void FrameSenderWindow::processCellChange(int line, int col)
             if (tempVal > 8) tempVal = 8;
             sendingData[line].len = tempVal;
             break;
-        case 4: //Data bytes
+        case 4: // Ext
+            if (ui->tableSender->item(line, 4)->checkState() == Qt::Checked) {
+                sendingData[line].extended = true;
+            } else {
+                sendingData[line].extended = false;
+            }
+            break;
+        case 5: // Rem
+            if (ui->tableSender->item(line, 5)->checkState() == Qt::Checked) {
+                sendingData[line].remote = true;
+            } else {
+                sendingData[line].remote = false;
+            }
+            break;
+        case 6: //Data bytes
             for (int i = 0; i < 8; i++) sendingData[line].data[i] = 0;
 
-            tokens = ui->tableSender->item(line, 4)->text().split(" ");
+            tokens = ui->tableSender->item(line, 6)->text().split(" ");
             for (int j = 0; j < tokens.count(); j++)
             {
                 sendingData[line].data[j] = (uint8_t)Utility::ParseStringToNum(tokens[j]);
             }
             break;
-        case 5: //triggers
+        case 7: //triggers
             processTriggerText(line);
             break;
-        case 6: //modifiers
+        case 8: //modifiers
             processModifierText(line);
             break;
     }
diff --git a/mainwindow.cpp b/mainwindow.cpp
index 40df9e7..d274955 100644
--- a/mainwindow.cpp
+++ b/mainwindow.cpp
@@ -281,11 +281,12 @@ void MainWindow::readSettings()
         ui->canFramesView->setColumnWidth(0, settings.value("Main/TimeColumn", 150).toUInt()); //time stamp
         ui->canFramesView->setColumnWidth(1, settings.value("Main/IDColumn", 70).toUInt()); //frame ID
         ui->canFramesView->setColumnWidth(2, settings.value("Main/ExtColumn", 40).toUInt()); //extended
-        ui->canFramesView->setColumnWidth(3, settings.value("Main/DirColumn", 40).toUInt()); //direction
-        ui->canFramesView->setColumnWidth(4, settings.value("Main/BusColumn", 40).toUInt()); //bus
-        ui->canFramesView->setColumnWidth(5, settings.value("Main/LengthColumn", 40).toUInt()); //length
-        ui->canFramesView->setColumnWidth(6, settings.value("Main/AsciiColumn", 50).toUInt()); //ascii
-        ui->canFramesView->setColumnWidth(7, settings.value("Main/DataColumn", 225).toUInt()); //data
+        ui->canFramesView->setColumnWidth(3, settings.value("Main/RemColumn", 40).toUInt()); //remote
+        ui->canFramesView->setColumnWidth(4, settings.value("Main/DirColumn", 40).toUInt()); //direction
+        ui->canFramesView->setColumnWidth(5, settings.value("Main/BusColumn", 40).toUInt()); //bus
+        ui->canFramesView->setColumnWidth(6, settings.value("Main/LengthColumn", 40).toUInt()); //length
+        ui->canFramesView->setColumnWidth(7, settings.value("Main/AsciiColumn", 50).toUInt()); //ascii
+        ui->canFramesView->setColumnWidth(8, settings.value("Main/DataColumn", 225).toUInt()); //data
     }
     if (settings.value("Main/AutoScroll", false).toBool())
     {
@@ -325,11 +326,12 @@ void MainWindow::writeSettings()
         settings.setValue("Main/TimeColumn", ui->canFramesView->columnWidth(0));
         settings.setValue("Main/IDColumn", ui->canFramesView->columnWidth(1));
         settings.setValue("Main/ExtColumn", ui->canFramesView->columnWidth(2));
-        settings.setValue("Main/DirColumn", ui->canFramesView->columnWidth(3));
-        settings.setValue("Main/BusColumn", ui->canFramesView->columnWidth(4));
-        settings.setValue("Main/LengthColumn", ui->canFramesView->columnWidth(5));
-        settings.setValue("Main/AsciiColumn", ui->canFramesView->columnWidth(6));
-        settings.setValue("Main/DataColumn", ui->canFramesView->columnWidth(7));
+        settings.setValue("Main/RemColumn", ui->canFramesView->columnWidth(3));
+        settings.setValue("Main/DirColumn", ui->canFramesView->columnWidth(4));
+        settings.setValue("Main/BusColumn", ui->canFramesView->columnWidth(5));
+        settings.setValue("Main/LengthColumn", ui->canFramesView->columnWidth(6));
+        settings.setValue("Main/AsciiColumn", ui->canFramesView->columnWidth(7));
+        settings.setValue("Main/DataColumn", ui->canFramesView->columnWidth(8));
     }
 }
 
diff --git a/re/fuzzingwindow.cpp b/re/fuzzingwindow.cpp
index 58e6ec0..33be476 100644
--- a/re/fuzzingwindow.cpp
+++ b/re/fuzzingwindow.cpp
@@ -132,6 +132,7 @@ void FuzzingWindow::changedNumDataBytes(int newVal)
 void FuzzingWindow::timerTriggered()
 {
     CANFrame thisFrame;
+    thisFrame.remote = false;
     sendingBuffer.clear();
     int buses = ui->cbBuses->currentIndex();
     for (int count = 0; count < ui->spinBurst->value(); count++)

From 6109fa5f9ae818e2b352e3dfac91c0cb3c716889 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fabi=C3=A1n=20Inostroza?= <fabianinostroza@udec.cl>
Date: Sun, 29 Apr 2018 20:54:03 -0300
Subject: [PATCH 2/2] send non remote frames in scripts.

---
 scriptcontainer.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/scriptcontainer.cpp b/scriptcontainer.cpp
index 6d004c0..01b83f6 100644
--- a/scriptcontainer.cpp
+++ b/scriptcontainer.cpp
@@ -231,6 +231,7 @@ void CANScriptHelper::sendFrame(QJSValue bus, QJSValue id, QJSValue length, QJSV
 {
     CANFrame frame;
     frame.extended = false;
+    frame.remote = false;
     frame.ID = id.toInt();
     frame.len = length.toUInt();
     if (frame.len > 8) frame.len = 8;