Finished switching over everything to the new can format (I hope). It
seems to function now but much more testing is needed.
This commit is contained in:
+15
-14
@@ -100,19 +100,20 @@ bool BLFHandler::loadBLF(QString filename, QVector<CANFrame>* frames)
|
||||
memcpy(&canObject, fileData.constData(), sizeof(BLF_CAN_OBJ));
|
||||
CANFrame frame;
|
||||
frame.bus = canObject.channel;
|
||||
frame.extended = (canObject.id & 0x80000000ull)?true:false;
|
||||
frame.ID = canObject.id & 0x1FFFFFFFull;
|
||||
frame.setExtendedFrameFormat((canObject.id & 0x80000000ull)?true:false);
|
||||
frame.setFrameId(canObject.id & 0x1FFFFFFFull);
|
||||
frame.isReceived = true;
|
||||
frame.len = canObject.dlc;
|
||||
QByteArray bytes(canObject.dlc, 0);
|
||||
|
||||
if (canObject.flags & BLF_REMOTE_FLAG) {
|
||||
frame.remote = true;
|
||||
frame.setFrameType(QCanBusFrame::RemoteRequestFrame);
|
||||
} else {
|
||||
frame.remote = false;
|
||||
for (int i = 0; i < 8; i++) frame.data[i] = canObject.data[i];
|
||||
frame.setFrameType(QCanBusFrame::DataFrame);
|
||||
for (int i = 0; i < 8; i++) bytes[i] = canObject.data[i];
|
||||
}
|
||||
frame.setPayload(bytes);
|
||||
//Should we divide by a thousand or a million? Unsure here. It appears some logs are stamped in microseconds and some in milliseconds?
|
||||
frame.timestamp = obj.header.v1Obj.uncompSize / 1000.0; //uncompsize field also used for timestamp oddly enough
|
||||
frame.setTimeStamp(QCanBusFrame::TimeStamp(0, obj.header.v1Obj.uncompSize / 1000.0)); //uncompsize field also used for timestamp oddly enough
|
||||
frames->append(frame);
|
||||
}
|
||||
else if (obj.header.base.objType == BLF_CAN_MSG2)
|
||||
@@ -120,19 +121,19 @@ bool BLFHandler::loadBLF(QString filename, QVector<CANFrame>* frames)
|
||||
memcpy(&canObject2, fileData.constData(), sizeof(BLF_CAN_OBJ2));
|
||||
CANFrame frame;
|
||||
frame.bus = canObject2.channel;
|
||||
frame.extended = (canObject2.id & 0x80000000ull)?true:false;
|
||||
frame.ID = canObject2.id & 0x1FFFFFFFull;
|
||||
frame.setExtendedFrameFormat((canObject2.id & 0x80000000ull)?true:false);
|
||||
frame.setFrameId(canObject2.id & 0x1FFFFFFFull);
|
||||
frame.isReceived = true;
|
||||
frame.len = canObject2.dlc;
|
||||
QByteArray bytes(canObject2.dlc, 0);
|
||||
|
||||
if (canObject2.flags & BLF_REMOTE_FLAG) {
|
||||
frame.remote = true;
|
||||
frame.setFrameType(QCanBusFrame::RemoteRequestFrame);
|
||||
} else {
|
||||
frame.remote = false;
|
||||
for (int i = 0; i < 8; i++) frame.data[i] = canObject2.data[i];
|
||||
frame.setFrameType(QCanBusFrame::DataFrame);
|
||||
for (int i = 0; i < 8; i++) bytes[i] = canObject2.data[i];
|
||||
}
|
||||
//Should we divide by a thousand or a million? Unsure here. It appears some logs are stamped in microseconds and some in milliseconds?
|
||||
frame.timestamp = obj.header.v1Obj.uncompSize / 1000.0; //uncompsize field also used for timestamp oddly enough
|
||||
frame.setTimeStamp(QCanBusFrame::TimeStamp(0, obj.header.v1Obj.uncompSize / 1000.0)); //uncompsize field also used for timestamp oddly enough
|
||||
frames->append(frame);
|
||||
}
|
||||
else
|
||||
|
||||
+43
-43
@@ -133,23 +133,23 @@ void CANFrameModel::normalizeTiming()
|
||||
{
|
||||
mutex.lock();
|
||||
if (frames.count() == 0) return;
|
||||
timeOffset = frames[0].timestamp;
|
||||
timeOffset = frames[0].timeStamp().microSeconds();
|
||||
|
||||
//find the absolute lowest timestamp in the whole time. Needed because maybe timestamp was reset in the middle.
|
||||
for (int j = 0; j < frames.count(); j++)
|
||||
{
|
||||
if (frames[j].timestamp < timeOffset) timeOffset = frames[j].timestamp;
|
||||
if (frames[j].timeStamp().microSeconds() < timeOffset) timeOffset = frames[j].timeStamp().microSeconds();
|
||||
}
|
||||
|
||||
for (int i = 0; i < frames.count(); i++)
|
||||
{
|
||||
frames[i].timestamp -= timeOffset;
|
||||
frames[i].setTimeStamp(QCanBusFrame::TimeStamp(0, frames[i].timeStamp().microSeconds() - timeOffset));
|
||||
}
|
||||
|
||||
this->beginResetModel();
|
||||
for (int i = 0; i < filteredFrames.count(); i++)
|
||||
{
|
||||
filteredFrames[i].timestamp -= timeOffset;
|
||||
filteredFrames[i].setTimeStamp(QCanBusFrame::TimeStamp(0, filteredFrames[i].timeStamp().microSeconds() - timeOffset));
|
||||
}
|
||||
this->endResetModel();
|
||||
|
||||
@@ -195,15 +195,15 @@ uint64_t CANFrameModel::getCANFrameVal(int row, Column col)
|
||||
{
|
||||
case Column::TimeStamp:
|
||||
if (overwriteDups) return frame.timedelta;
|
||||
return frame.timestamp;
|
||||
return frame.timeStamp().microSeconds();
|
||||
case Column::FrameId:
|
||||
return frame.ID;
|
||||
return frame.frameId();
|
||||
case Column::Extended:
|
||||
if (frame.extended) return 1;
|
||||
if (frame.hasExtendedFrameFormat()) return 1;
|
||||
return 0;
|
||||
case Column::Remote:
|
||||
if (overwriteDups) return frame.frameCount;
|
||||
if (frame.remote) return 1;
|
||||
if (frame.frameType() == QCanBusFrame::RemoteRequestFrame) return 1;
|
||||
return 0;
|
||||
case Column::Direction:
|
||||
if (frame.isReceived) return 1;
|
||||
@@ -211,10 +211,10 @@ uint64_t CANFrameModel::getCANFrameVal(int row, Column col)
|
||||
case Column::Bus:
|
||||
return static_cast<uint64_t>(frame.bus);
|
||||
case Column::Length:
|
||||
return static_cast<uint64_t>(frame.len);
|
||||
return static_cast<uint64_t>(frame.payload().length());
|
||||
case Column::ASCII: //sort both the same for now
|
||||
case Column::Data:
|
||||
for (int i = 0; i < frame.len; i++) temp += (static_cast<uint64_t>(frame.data[i]) << (56 - (8 * i)));
|
||||
for (int i = 0; i < frame.payload().length(); i++) temp += (static_cast<uint64_t>(frame.payload()[i]) << (56 - (8 * i)));
|
||||
//qDebug() << temp;
|
||||
return temp;
|
||||
case Column::NUM_COLUMN:
|
||||
@@ -311,7 +311,7 @@ void CANFrameModel::recalcOverwrite()
|
||||
uint64_t idAugmented; //id in lower 29 bits, bus number shifted up 29 bits
|
||||
foreach(CANFrame frame, frames)
|
||||
{
|
||||
idAugmented = frame.ID;
|
||||
idAugmented = frame.frameId();
|
||||
idAugmented = idAugmented + (frame.bus << 29ull);
|
||||
if (!overWriteFrames.contains(idAugmented))
|
||||
{
|
||||
@@ -321,7 +321,7 @@ void CANFrameModel::recalcOverwrite()
|
||||
}
|
||||
else
|
||||
{
|
||||
frame.timedelta = frame.timestamp - overWriteFrames[idAugmented].timestamp;
|
||||
frame.timedelta = frame.timeStamp().microSeconds() - overWriteFrames[idAugmented].timeStamp().microSeconds();
|
||||
frame.frameCount = overWriteFrames[idAugmented].frameCount + 1;
|
||||
overWriteFrames[idAugmented] = frame;
|
||||
}
|
||||
@@ -335,7 +335,7 @@ void CANFrameModel::recalcOverwrite()
|
||||
|
||||
for (int i = 0; i < frames.count(); i++)
|
||||
{
|
||||
if (filters[frames[i].ID])
|
||||
if (filters[frames[i].frameId()])
|
||||
{
|
||||
filteredFrames.append(frames[i]);
|
||||
}
|
||||
@@ -404,17 +404,17 @@ QVariant CANFrameModel::data(const QModelIndex &index, int role) const
|
||||
if (timeSeconds) return QString::number(thisFrame.timedelta / 1000000.0, 'f', 5);
|
||||
return QString::number(thisFrame.timedelta);
|
||||
}
|
||||
else ts = Utility::formatTimestamp(thisFrame.timestamp);
|
||||
else ts = Utility::formatTimestamp(thisFrame.timeStamp().microSeconds());
|
||||
if (ts.type() == QVariant::Double) return QString::number(ts.toDouble(), 'f', 5); //never scientific notation, 5 decimal places
|
||||
if (ts.type() == QVariant::LongLong) return QString::number(ts.toLongLong()); //never scientific notion, all digits shown
|
||||
if (ts.type() == QVariant::DateTime) return ts.toDateTime().toString(timeFormat); //custom set format for dates and times
|
||||
return Utility::formatTimestamp(thisFrame.timestamp);
|
||||
return Utility::formatTimestamp(thisFrame.timeStamp().microSeconds());
|
||||
case Column::FrameId:
|
||||
return Utility::formatCANID(thisFrame.ID, thisFrame.extended);
|
||||
return Utility::formatCANID(thisFrame.frameId(), thisFrame.hasExtendedFrameFormat());
|
||||
case Column::Extended:
|
||||
return QString::number(thisFrame.extended);
|
||||
return QString::number(thisFrame.hasExtendedFrameFormat());
|
||||
case Column::Remote:
|
||||
if (!overwriteDups) return QString::number(thisFrame.remote);
|
||||
if (!overwriteDups) return QString::number(thisFrame.frameType() == QCanBusFrame::RemoteRequestFrame);
|
||||
return QString::number(thisFrame.frameCount);
|
||||
case Column::Direction:
|
||||
if (thisFrame.isReceived) return QString(tr("Rx"));
|
||||
@@ -422,21 +422,21 @@ QVariant CANFrameModel::data(const QModelIndex &index, int role) const
|
||||
case Column::Bus:
|
||||
return QString::number(thisFrame.bus);
|
||||
case Column::Length:
|
||||
return QString::number(thisFrame.len);
|
||||
return QString::number(thisFrame.payload().length());
|
||||
case Column::ASCII:
|
||||
if (thisFrame.ID >= 0x7FFFFFF0ull)
|
||||
if (thisFrame.frameId() >= 0x7FFFFFF0ull)
|
||||
{
|
||||
tempString.append("MARK ");
|
||||
tempString.append(QString::number(thisFrame.ID & 0x7));
|
||||
tempString.append(QString::number(thisFrame.frameId() & 0x7));
|
||||
return tempString;
|
||||
}
|
||||
dLen = thisFrame.len;
|
||||
if (!thisFrame.remote) {
|
||||
dLen = thisFrame.payload().length();
|
||||
if (!thisFrame.frameType() != QCanBusFrame::RemoteRequestFrame) {
|
||||
if (dLen < 0) dLen = 0;
|
||||
if (dLen > 8) dLen = 8;
|
||||
for (int i = 0; i < dLen; i++)
|
||||
{
|
||||
quint8 byt = thisFrame.data[i];
|
||||
quint8 byt = thisFrame.payload()[i];
|
||||
//0x20 through 0x7E are printable characters. Outside of that range they aren't. So use dots instead
|
||||
if (byt < 0x20) byt = 0x2E; //dot character
|
||||
if (byt > 0x7E) byt = 0x2E;
|
||||
@@ -445,17 +445,17 @@ QVariant CANFrameModel::data(const QModelIndex &index, int role) const
|
||||
}
|
||||
return tempString;
|
||||
case Column::Data:
|
||||
dLen = thisFrame.len;
|
||||
dLen = thisFrame.payload().length();
|
||||
if (dLen < 0) dLen = 0;
|
||||
if (dLen > 8) dLen = 8;
|
||||
//if (useHexMode) tempString.append("0x ");
|
||||
if (thisFrame.remote) {
|
||||
if (thisFrame.frameType() == QCanBusFrame::RemoteRequestFrame) {
|
||||
return tempString;
|
||||
}
|
||||
for (int i = 0; i < dLen; i++)
|
||||
{
|
||||
if (useHexMode) tempString.append( QString::number(thisFrame.data[i], 16).toUpper().rightJustified(2, '0'));
|
||||
else tempString.append(QString::number(thisFrame.data[i], 10));
|
||||
if (useHexMode) tempString.append( QString::number((unsigned char)thisFrame.payload()[i], 16).toUpper().rightJustified(2, '0'));
|
||||
else tempString.append(QString::number(thisFrame.payload()[i], 10));
|
||||
tempString.append(" ");
|
||||
}
|
||||
//now, if we're supposed to interpret the data and the DBC handler is loaded then use it
|
||||
@@ -552,25 +552,25 @@ void CANFrameModel::addFrame(const CANFrame& frame, bool autoRefresh = false)
|
||||
mutex.lock();
|
||||
CANFrame tempFrame;
|
||||
tempFrame = frame;
|
||||
tempFrame.timestamp -= timeOffset;
|
||||
tempFrame.setTimeStamp(QCanBusFrame::TimeStamp(0, tempFrame.timeStamp().microSeconds() - timeOffset));
|
||||
|
||||
lastUpdateNumFrames++;
|
||||
|
||||
//if this ID isn't found in the filters list then add it and show it by default
|
||||
if (!filters.contains(tempFrame.ID))
|
||||
if (!filters.contains(tempFrame.frameId()))
|
||||
{
|
||||
// if there are any filters already configured, leave the new filter disabled
|
||||
if (any_filters_are_configured())
|
||||
filters.insert(tempFrame.ID, false);
|
||||
filters.insert(tempFrame.frameId(), false);
|
||||
else
|
||||
filters.insert(tempFrame.ID, true);
|
||||
filters.insert(tempFrame.frameId(), true);
|
||||
needFilterRefresh = true;
|
||||
}
|
||||
|
||||
if (!overwriteDups)
|
||||
{
|
||||
frames.append(tempFrame);
|
||||
if (filters[tempFrame.ID])
|
||||
if (filters[tempFrame.frameId()])
|
||||
{
|
||||
if (autoRefresh) beginInsertRows(QModelIndex(), filteredFrames.count(), filteredFrames.count());
|
||||
tempFrame.frameCount = 1;
|
||||
@@ -583,10 +583,10 @@ void CANFrameModel::addFrame(const CANFrame& frame, bool autoRefresh = false)
|
||||
bool found = false;
|
||||
for (int i = 0; i < frames.count(); i++)
|
||||
{
|
||||
if ( (frames[i].ID == tempFrame.ID) && (frames[i].bus == tempFrame.bus) )
|
||||
if ( (frames[i].frameId() == tempFrame.frameId()) && (frames[i].bus == tempFrame.bus) )
|
||||
{
|
||||
tempFrame.frameCount = frames[i].frameCount + 1;
|
||||
tempFrame.timedelta = tempFrame.timestamp - frames[i].timestamp;
|
||||
tempFrame.timedelta = tempFrame.timeStamp().microSeconds() - frames[i].timeStamp().microSeconds();
|
||||
frames.replace(i, tempFrame);
|
||||
found = true;
|
||||
break;
|
||||
@@ -595,7 +595,7 @@ void CANFrameModel::addFrame(const CANFrame& frame, bool autoRefresh = false)
|
||||
if (!found)
|
||||
{
|
||||
frames.append(tempFrame);
|
||||
if (filters[tempFrame.ID])
|
||||
if (filters[tempFrame.frameId()])
|
||||
{
|
||||
if (autoRefresh) beginInsertRows(QModelIndex(), filteredFrames.count(), filteredFrames.count());
|
||||
tempFrame.frameCount = 1;
|
||||
@@ -608,7 +608,7 @@ void CANFrameModel::addFrame(const CANFrame& frame, bool autoRefresh = false)
|
||||
{
|
||||
for (int j = 0; j < filteredFrames.count(); j++)
|
||||
{
|
||||
if ( (filteredFrames[j].ID == tempFrame.ID) && (filteredFrames[j].bus == tempFrame.bus) )
|
||||
if ( (filteredFrames[j].frameId() == tempFrame.frameId()) && (filteredFrames[j].bus == tempFrame.bus) )
|
||||
{
|
||||
if (autoRefresh) beginResetModel();
|
||||
filteredFrames.replace(j, tempFrame);
|
||||
@@ -642,7 +642,7 @@ void CANFrameModel::sendRefresh()
|
||||
int count = frames.count();
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
if (filters[frames[i].ID])
|
||||
if (filters[frames[i].frameId()])
|
||||
{
|
||||
tempContainer.append(frames[i]);
|
||||
}
|
||||
@@ -718,12 +718,12 @@ void CANFrameModel::insertFrames(const QVector<CANFrame> &newFrames)
|
||||
for (int i = 0; i < newFrames.count(); i++)
|
||||
{
|
||||
frames.append(newFrames[i]);
|
||||
if (!filters.contains(newFrames[i].ID))
|
||||
if (!filters.contains(newFrames[i].frameId()))
|
||||
{
|
||||
filters.insert(newFrames[i].ID, true);
|
||||
filters.insert(newFrames[i].frameId(), true);
|
||||
needFilterRefresh = true;
|
||||
}
|
||||
if (filters[newFrames[i].ID])
|
||||
if (filters[newFrames[i].frameId()])
|
||||
{
|
||||
insertedFiltered++;
|
||||
filteredFrames.append(newFrames[i]);
|
||||
@@ -743,9 +743,9 @@ int CANFrameModel::getIndexFromTimeID(unsigned int ID, double timestamp)
|
||||
uint64_t intTimeStamp = timestamp * 1000000l;
|
||||
for (int i = 0; i < frames.count(); i++)
|
||||
{
|
||||
if ((frames[i].ID == ID))
|
||||
if ((frames[i].frameId() == ID))
|
||||
{
|
||||
if (frames[i].timestamp <= intTimeStamp) bestIndex = i;
|
||||
if (frames[i].timeStamp().microSeconds() <= intTimeStamp) bestIndex = i;
|
||||
else break; //drop out of loop as soon as we pass the proper timestamp
|
||||
}
|
||||
}
|
||||
|
||||
@@ -343,7 +343,7 @@ void CANConnection::checkTargettedFrame(CANFrame &frame)
|
||||
foreach (const CANFltObserver filt, mBusData[frame.bus].mTargettedFrames)
|
||||
{
|
||||
//qDebug() << "Checking filter with id " << filt.id << " mask " << filt.mask;
|
||||
maskedID = frame.ID & filt.mask;
|
||||
maskedID = frame.frameId() & filt.mask;
|
||||
if (maskedID == filt.id) {
|
||||
qDebug() << "In connection object I got a targetted frame. Forwarding it.";
|
||||
QMetaObject::invokeMethod(filt.observer, "gotTargettedFrame",Qt::QueuedConnection, Q_ARG(CANFrame, frame));
|
||||
|
||||
+1
-1
@@ -1531,7 +1531,7 @@ DBC_MESSAGE* DBCHandler::findMessage(const CANFrame &frame)
|
||||
{
|
||||
if (loadedFiles[i].getAssocBus() == -1 || frame.bus == (unsigned int)loadedFiles[i].getAssocBus())
|
||||
{
|
||||
DBC_MESSAGE* msg = loadedFiles[i].messageHandler->findMsgByID(frame.ID);
|
||||
DBC_MESSAGE* msg = loadedFiles[i].messageHandler->findMsgByID(frame.frameId());
|
||||
if (msg != nullptr) return msg;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -585,7 +585,7 @@ void DBCSignalEditor::fillValueTable(DBC_SIGNAL *sig)
|
||||
|
||||
for (int i = 0; i < sig->valList.count(); i++)
|
||||
{
|
||||
QTableWidgetItem *val = new QTableWidgetItem(Utility::formatNumber(sig->valList[i].value));
|
||||
QTableWidgetItem *val = new QTableWidgetItem(Utility::formatNumber((uint64_t)sig->valList[i].value));
|
||||
QTableWidgetItem *desc = new QTableWidgetItem(sig->valList[i].descript);
|
||||
rowIdx = ui->valuesTable->rowCount();
|
||||
ui->valuesTable->insertRow(rowIdx);
|
||||
|
||||
+47
-38
@@ -4,6 +4,13 @@
|
||||
|
||||
#include <QFile>
|
||||
|
||||
//You might wonder: Collin, what in the hell is this for? Firmware uploader? For what? I'm interested! Well, it's a custom
|
||||
//firmware uploader for a motor controller I built. Why would that be in this project. Cuz. It's not really relevant
|
||||
//to anyone else but might serve as a decent reference for a few things: How to make an uploader interface that runs over CAN,
|
||||
//how to lay out a screen like this, how to make a comm protocol for firmware updating over CAN. But, most things use UDS
|
||||
//for firmware updates and wouldn't need this specific code. But, it might be able to be turned into a UDS firmware uploader or downloader.
|
||||
//Note that this screen is specifically hidden by default because of it's oddball status. You have to re-enable it in mainwindow.cpp to see it.
|
||||
|
||||
FirmwareUploaderWindow::FirmwareUploaderWindow(const QVector<CANFrame> *frames, QWidget *parent) :
|
||||
QDialog(parent),
|
||||
ui(new Ui::FirmwareUploaderWindow)
|
||||
@@ -70,17 +77,17 @@ void FirmwareUploaderWindow::updatedFrames(int numFrames)
|
||||
|
||||
void FirmwareUploaderWindow::gotTargettedFrame(CANFrame frame)
|
||||
{
|
||||
qDebug() << "FUW: Got targetted frame with id " << frame.ID;
|
||||
if (frame.ID == (uint32_t)(baseAddress + 0x10)) {
|
||||
qDebug() << "FUW: Got targetted frame with id " << frame.frameId();
|
||||
if (frame.frameId() == (uint32_t)(baseAddress + 0x10)) {
|
||||
qDebug() << "Start firmware reply";
|
||||
if ((frame.data[0] == 0xAD) && (frame.data[1] == 0xDE))
|
||||
if (((char)frame.payload()[0] == (char)0xAD) && ((char)frame.payload()[1] == (char)0xDE))
|
||||
{
|
||||
if ((frame.data[2] == 0xAF) && (frame.data[3] == 0xDE))
|
||||
if (((char)frame.payload()[2] == (char)0xAF) && ((char)frame.payload()[3] == (char)0xDE))
|
||||
{
|
||||
qDebug() << "THere's dead beef here";
|
||||
if ((frame.data[4] == (token & 0xFF)) && (frame.data[5] == ((token >> 8) & 0xFF)))
|
||||
qDebug() << "There's dead beef here";
|
||||
if (((char)frame.payload()[4] == (char)(token & 0xFF)) && ((char)frame.payload()[5] == (char)((token >> 8) & 0xFF)))
|
||||
{
|
||||
if ((frame.data[6] == ((token >> 16) & 0xFF)) && (frame.data[7] == ((token >> 24) & 0xFF)))
|
||||
if (((char)frame.payload()[6] == (char)((token >> 16) & 0xFF)) && ((char)frame.payload()[7] == (char)((token >> 24) & 0xFF)))
|
||||
{
|
||||
qDebug() << "starting firmware process";
|
||||
//MainWindow::getReference()->setTargettedID(baseAddress + 0x20);
|
||||
@@ -92,9 +99,9 @@ void FirmwareUploaderWindow::gotTargettedFrame(CANFrame frame)
|
||||
}
|
||||
}
|
||||
|
||||
if (frame.ID == (uint32_t)(baseAddress + 0x20)) {
|
||||
if (frame.frameId() == (uint32_t)(baseAddress + 0x20)) {
|
||||
qDebug() << "Firmware reception success reply";
|
||||
int seq = frame.data[0] + (256 * frame.data[1]);
|
||||
int seq = frame.payload()[0] + (256 * frame.payload()[1]);
|
||||
if (seq == currentSendingPosition)
|
||||
{
|
||||
currentSendingPosition++;
|
||||
@@ -126,18 +133,19 @@ void FirmwareUploaderWindow::sendFirmwareChunk()
|
||||
CANFrame *output = new CANFrame;
|
||||
int firmwareLocation = currentSendingPosition * 4;
|
||||
int xorByte = 0;
|
||||
output->extended = false;
|
||||
output->len = 7;
|
||||
output->setExtendedFrameFormat(false);
|
||||
QByteArray bytes(7,0);
|
||||
output->bus = bus;
|
||||
output->ID = baseAddress + 0x16;
|
||||
output->data[0] = currentSendingPosition & 0xFF;
|
||||
output->data[1] = (currentSendingPosition >> 8) & 0xFF;
|
||||
output->data[2] = firmwareData[firmwareLocation++];
|
||||
output->data[3] = firmwareData[firmwareLocation++];
|
||||
output->data[4] = firmwareData[firmwareLocation++];
|
||||
output->data[5] = firmwareData[firmwareLocation++];
|
||||
for (int i = 0; i < 6; i++) xorByte = xorByte ^ output->data[i];
|
||||
output->data[6] = xorByte;
|
||||
output->setFrameId(baseAddress + 0x16);
|
||||
output->payload()[0] = currentSendingPosition & 0xFF;
|
||||
output->payload()[1] = (currentSendingPosition >> 8) & 0xFF;
|
||||
output->payload()[2] = firmwareData[firmwareLocation++];
|
||||
output->payload()[3] = firmwareData[firmwareLocation++];
|
||||
output->payload()[4] = firmwareData[firmwareLocation++];
|
||||
output->payload()[5] = firmwareData[firmwareLocation++];
|
||||
for (int i = 0; i < 6; i++) xorByte = xorByte ^ output->payload()[i];
|
||||
output->payload()[6] = xorByte;
|
||||
output->setPayload(bytes);
|
||||
sendCANFrame(output);
|
||||
timer->start();
|
||||
}
|
||||
@@ -145,14 +153,15 @@ void FirmwareUploaderWindow::sendFirmwareChunk()
|
||||
void FirmwareUploaderWindow::sendFirmwareEnding()
|
||||
{
|
||||
CANFrame *output = new CANFrame;
|
||||
output->extended = false;
|
||||
output->setExtendedFrameFormat(false);
|
||||
output->bus = bus;
|
||||
output->len = 4;
|
||||
output->ID = baseAddress + 0x30;
|
||||
output->data[3] = 0xC0;
|
||||
output->data[2] = 0xDE;
|
||||
output->data[1] = 0xFA;
|
||||
output->data[0] = 0xDE;
|
||||
QByteArray bytes(4,0);
|
||||
output->setFrameId(baseAddress + 0x30);
|
||||
output->payload()[3] = 0xC0;
|
||||
output->payload()[2] = 0xDE;
|
||||
output->payload()[1] = 0xFA;
|
||||
output->payload()[0] = 0xDE;
|
||||
output->setPayload(bytes);
|
||||
//sendCANFrame(output, bus);
|
||||
}
|
||||
|
||||
@@ -171,19 +180,19 @@ void FirmwareUploaderWindow::handleStartStopTransfer()
|
||||
CANConManager::getInstance()->addTargettedFrame(bus, baseAddress + 0x10, 0x7FF, this);
|
||||
CANConManager::getInstance()->addTargettedFrame(bus, baseAddress + 0x20, 0x7FF, this);
|
||||
CANFrame *output = new CANFrame;
|
||||
output->extended = false;
|
||||
output->len = 8;
|
||||
output->setExtendedFrameFormat(false);
|
||||
QByteArray bytes(8,0);
|
||||
output->bus = bus;
|
||||
output->ID = baseAddress;
|
||||
output->setFrameId(baseAddress);
|
||||
|
||||
output->data[0] = 0xEF;
|
||||
output->data[1] = 0xBE;
|
||||
output->data[2] = 0xAD;
|
||||
output->data[3] = 0xDE;
|
||||
output->data[4] = token & 0xFF;
|
||||
output->data[5] = (token >> 8) & 0xFF;
|
||||
output->data[6] = (token >> 16) & 0xFF;
|
||||
output->data[7] = (token >> 24) & 0xFF;
|
||||
output->payload()[0] = 0xEF;
|
||||
output->payload()[1] = 0xBE;
|
||||
output->payload()[2] = 0xAD;
|
||||
output->payload()[3] = 0xDE;
|
||||
output->payload()[4] = token & 0xFF;
|
||||
output->payload()[5] = (token >> 8) & 0xFF;
|
||||
output->payload()[6] = (token >> 16) & 0xFF;
|
||||
output->payload()[7] = (token >> 24) & 0xFF;
|
||||
sendCANFrame(output);
|
||||
}
|
||||
else //stop anything in process
|
||||
|
||||
+311
-294
File diff suppressed because it is too large
Load Diff
@@ -68,7 +68,7 @@ quint64 FramePlaybackObject::updatePosition(bool forward)
|
||||
//only send frame out if its ID is checked in the list. Otherwise discard it.
|
||||
CANFrame *thisFrame = ¤tSeqItem->data[currentPosition];
|
||||
uint32_t originalBus = thisFrame->bus;
|
||||
if (currentSeqItem->idFilters.find(thisFrame->ID).value())
|
||||
if (currentSeqItem->idFilters.find(thisFrame->frameId()).value())
|
||||
{
|
||||
if (whichBusSend > -1)
|
||||
{
|
||||
@@ -90,7 +90,7 @@ quint64 FramePlaybackObject::updatePosition(bool forward)
|
||||
|
||||
thisFrame->bus = originalBus;
|
||||
}
|
||||
return thisFrame->timestamp;
|
||||
return thisFrame->timeStamp().microSeconds();
|
||||
}
|
||||
|
||||
quint64 FramePlaybackObject::peekPosition(bool forward)
|
||||
@@ -113,7 +113,7 @@ quint64 FramePlaybackObject::peekPosition(bool forward)
|
||||
}
|
||||
}
|
||||
CANFrame *thisFrame = ¤tSeqItem->data[peekCurrentPosition];
|
||||
return thisFrame->timestamp;
|
||||
return thisFrame->timeStamp().microSeconds();
|
||||
}
|
||||
|
||||
void FramePlaybackObject::piStart()
|
||||
@@ -197,8 +197,8 @@ void FramePlaybackObject::startPlaybackForward()
|
||||
{
|
||||
playbackTimer->setInterval(1);
|
||||
playbackElapsed.start();
|
||||
if (currentSeqItem->data[currentPosition].timestamp > 2000)
|
||||
playbackLastTimeStamp = currentSeqItem->data[currentPosition].timestamp - 2000;
|
||||
if (currentSeqItem->data[currentPosition].timeStamp().microSeconds() > 2000)
|
||||
playbackLastTimeStamp = currentSeqItem->data[currentPosition].timeStamp().microSeconds() - 2000;
|
||||
else playbackLastTimeStamp = 0;
|
||||
}
|
||||
playbackTimer->start();
|
||||
@@ -219,7 +219,7 @@ void FramePlaybackObject::startPlaybackBackward()
|
||||
{
|
||||
playbackElapsed.start();
|
||||
playbackTimer->setInterval(1);
|
||||
playbackLastTimeStamp = currentSeqItem->data[currentPosition].timestamp + 2000;
|
||||
playbackLastTimeStamp = currentSeqItem->data[currentPosition].timeStamp().microSeconds() + 2000;
|
||||
}
|
||||
playbackTimer->start();
|
||||
}
|
||||
@@ -350,8 +350,8 @@ void FramePlaybackObject::timerTriggered()
|
||||
if (peekPosition(true) == 0xFFFFFFFFFFFFFFFFull)
|
||||
{
|
||||
updatePosition(true); //this'll go to the next log (if there is one)
|
||||
if (currentSeqItem->data[currentPosition].timestamp > 1000)
|
||||
playbackLastTimeStamp = currentSeqItem->data[currentPosition].timestamp - 1000;
|
||||
if (currentSeqItem->data[currentPosition].timeStamp().microSeconds() > 1000)
|
||||
playbackLastTimeStamp = currentSeqItem->data[currentPosition].timeStamp().microSeconds() - 1000;
|
||||
else playbackLastTimeStamp = 0;
|
||||
}
|
||||
}
|
||||
@@ -367,7 +367,7 @@ void FramePlaybackObject::timerTriggered()
|
||||
if (peekPosition(false) == 0xFFFFFFFFFFFFFFFFull)
|
||||
{
|
||||
updatePosition(false); //this'll go to the next log (if there is one)
|
||||
playbackLastTimeStamp = currentSeqItem->data[currentPosition].timestamp + 1000;
|
||||
playbackLastTimeStamp = currentSeqItem->data[currentPosition].timeStamp().microSeconds() + 1000;
|
||||
}
|
||||
}
|
||||
statusCounter++;
|
||||
|
||||
@@ -426,7 +426,7 @@ void FramePlaybackWindow::fillIDHash(SequenceItem &item)
|
||||
|
||||
for (int i = 0; i < item.data.count(); i++)
|
||||
{
|
||||
id = item.data[i].ID;
|
||||
id = item.data[i].frameId();
|
||||
if (!item.idFilters.contains(id))
|
||||
{
|
||||
item.idFilters.insert(id, true);
|
||||
|
||||
+29
-29
@@ -130,13 +130,13 @@ void FrameSenderWindow::buildFrameCache()
|
||||
for (int i = 0; i < modelFrames->count(); i++)
|
||||
{
|
||||
thisFrame = modelFrames->at(i);
|
||||
if (!frameCache.contains(thisFrame.ID))
|
||||
if (!frameCache.contains(thisFrame.frameId()))
|
||||
{
|
||||
frameCache.insert(thisFrame.ID, thisFrame);
|
||||
frameCache.insert(thisFrame.frameId(), thisFrame);
|
||||
}
|
||||
else
|
||||
{
|
||||
frameCache[thisFrame.ID] = thisFrame;
|
||||
frameCache[thisFrame.frameId()] = thisFrame;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -160,13 +160,13 @@ void FrameSenderWindow::updatedFrames(int numFrames)
|
||||
for (int i = modelFrames->count() - numFrames; i < modelFrames->count(); i++)
|
||||
{
|
||||
thisFrame = modelFrames->at(i);
|
||||
if (!frameCache.contains(thisFrame.ID))
|
||||
if (!frameCache.contains(thisFrame.frameId()))
|
||||
{
|
||||
frameCache.insert(thisFrame.ID, thisFrame);
|
||||
frameCache.insert(thisFrame.frameId(), thisFrame);
|
||||
}
|
||||
else
|
||||
{
|
||||
frameCache[thisFrame.ID] = thisFrame;
|
||||
frameCache[thisFrame.frameId()] = thisFrame;
|
||||
}
|
||||
processIncomingFrame(&thisFrame);
|
||||
}
|
||||
@@ -182,8 +182,8 @@ void FrameSenderWindow::processIncomingFrame(CANFrame *frame)
|
||||
{
|
||||
Trigger *thisTrigger = &sendingData[sd].triggers[trig];
|
||||
qDebug() << "Trigger ID: " << thisTrigger->ID;
|
||||
qDebug() << "Frame ID: " << frame->ID;
|
||||
if (thisTrigger->ID > 0 && (uint32_t)thisTrigger->ID == frame->ID)
|
||||
qDebug() << "Frame ID: " << frame->frameId();
|
||||
if (thisTrigger->ID > 0 && (uint32_t)thisTrigger->ID == frame->frameId())
|
||||
{
|
||||
if ((uint32_t)thisTrigger->bus == frame->bus || thisTrigger->bus == -1)
|
||||
{
|
||||
@@ -511,7 +511,7 @@ void FrameSenderWindow::doModifiers(int idx)
|
||||
}
|
||||
}
|
||||
//Finally, drop the result into the proper data byte
|
||||
sendData->data[mod->destByte] = (unsigned char) shadowReg;
|
||||
sendData->payload().data()[mod->destByte] = (char) shadowReg;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -525,16 +525,16 @@ int FrameSenderWindow::fetchOperand(int idx, ModifierOperand op)
|
||||
}
|
||||
else if (op.ID == -2) //fetch data from a data byte within the output frame
|
||||
{
|
||||
if (op.notOper) return ~sendingData.at(idx).data[op.databyte];
|
||||
else return sendingData.at(idx).data[op.databyte];
|
||||
if (op.notOper) return ~sendingData.at(idx).payload()[op.databyte];
|
||||
else return sendingData.at(idx).payload()[op.databyte];
|
||||
}
|
||||
else //look up external data byte
|
||||
{
|
||||
tempFrame = lookupFrame(op.ID, op.bus);
|
||||
if (tempFrame != nullptr)
|
||||
{
|
||||
if (op.notOper) return ~tempFrame->data[op.databyte];
|
||||
else return tempFrame->data[op.databyte];
|
||||
if (op.notOper) return ~tempFrame->payload()[op.databyte];
|
||||
else return tempFrame->payload()[op.databyte];
|
||||
}
|
||||
else return 0;
|
||||
}
|
||||
@@ -643,7 +643,7 @@ void FrameSenderWindow::processModifierText(int line)
|
||||
}
|
||||
else thisOp.second.notOper = false;
|
||||
thisOp.second.bus = sendingData[line].bus;
|
||||
thisOp.second.ID = sendingData[line].ID;
|
||||
thisOp.second.ID = sendingData[line].frameId();
|
||||
parseOperandString(secondOp.split(":"), thisOp.second);
|
||||
thisMod.operations.append(thisOp);
|
||||
}
|
||||
@@ -793,10 +793,10 @@ void FrameSenderWindow::updateGridRow(int idx)
|
||||
QTableWidgetItem *item = ui->tableSender->item(gridLine, 9);
|
||||
if (item == nullptr) item = new QTableWidgetItem();
|
||||
item->setText(QString::number(temp->count));
|
||||
if (!temp->remote) {
|
||||
for (unsigned int i = 0; i < temp->len; i++)
|
||||
if (temp->frameType() != QCanBusFrame::RemoteRequestFrame) {
|
||||
for (unsigned int i = 0; i < temp->payload().length(); i++)
|
||||
{
|
||||
dataString.append(Utility::formatNumber(temp->data[i]));
|
||||
dataString.append(Utility::formatNumber(temp->payload()[i]));
|
||||
dataString.append(" ");
|
||||
}
|
||||
ui->tableSender->item(gridLine, 6)->setText(dataString);
|
||||
@@ -818,8 +818,8 @@ void FrameSenderWindow::processCellChange(int line, int col)
|
||||
{
|
||||
FrameSendData tempData;
|
||||
tempData.enabled = false;
|
||||
tempData.remote = false;
|
||||
tempData.extended = false;
|
||||
tempData.setFrameType(QCanBusFrame::DataFrame);
|
||||
tempData.setExtendedFrameFormat(false);
|
||||
sendingData.append(tempData);
|
||||
}
|
||||
|
||||
@@ -848,9 +848,9 @@ void FrameSenderWindow::processCellChange(int line, int col)
|
||||
tempVal = Utility::ParseStringToNum(ui->tableSender->item(line, 2)->text());
|
||||
if (tempVal < 0) tempVal = 0;
|
||||
if (tempVal > 0x7FFFFFFF) tempVal = 0x7FFFFFFF;
|
||||
sendingData[line].ID = tempVal;
|
||||
if (sendingData[line].ID > 0x7FF) {
|
||||
sendingData[line].extended = true;
|
||||
sendingData[line].setFrameId(tempVal);
|
||||
if (sendingData[line].frameId() > 0x7FF) {
|
||||
sendingData[line].setExtendedFrameFormat(true);
|
||||
ui->tableSender->blockSignals(true);
|
||||
ui->tableSender->item(line, 4)->setCheckState(Qt::Checked);
|
||||
ui->tableSender->blockSignals(false);
|
||||
@@ -861,29 +861,29 @@ void FrameSenderWindow::processCellChange(int line, int col)
|
||||
tempVal = Utility::ParseStringToNum(ui->tableSender->item(line, 3)->text());
|
||||
if (tempVal < 0) tempVal = 0;
|
||||
if (tempVal > 8) tempVal = 8;
|
||||
sendingData[line].len = tempVal;
|
||||
sendingData[line].payload().resize(tempVal);
|
||||
break;
|
||||
case 4: // Ext
|
||||
if (ui->tableSender->item(line, 4)->checkState() == Qt::Checked) {
|
||||
sendingData[line].extended = true;
|
||||
sendingData[line].setExtendedFrameFormat(true);
|
||||
} else {
|
||||
sendingData[line].extended = false;
|
||||
sendingData[line].setExtendedFrameFormat(false);
|
||||
}
|
||||
break;
|
||||
case 5: // Rem
|
||||
if (ui->tableSender->item(line, 5)->checkState() == Qt::Checked) {
|
||||
sendingData[line].remote = true;
|
||||
sendingData[line].setFrameType(QCanBusFrame::RemoteRequestFrame);
|
||||
} else {
|
||||
sendingData[line].remote = false;
|
||||
sendingData[line].setFrameType(QCanBusFrame::DataFrame);
|
||||
}
|
||||
break;
|
||||
case 6: //Data bytes
|
||||
for (int i = 0; i < 8; i++) sendingData[line].data[i] = 0;
|
||||
for (int i = 0; i < 8; i++) sendingData[line].payload().data()[i] = 0;
|
||||
|
||||
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]);
|
||||
sendingData[line].payload().data()[j] = (uint8_t)Utility::ParseStringToNum(tokens[j]);
|
||||
}
|
||||
break;
|
||||
case 7: //triggers
|
||||
|
||||
+9
-12
@@ -168,12 +168,9 @@ MainWindow::MainWindow(QWidget *parent) :
|
||||
//of scaling or font differences between different computers.
|
||||
CANFrame temp;
|
||||
temp.bus = 0;
|
||||
temp.ID = 0x100;
|
||||
temp.len = 0;
|
||||
temp.extended = false;
|
||||
temp.setFrameId(0x100);
|
||||
temp.isReceived = true;
|
||||
temp.remote = false;
|
||||
temp.timestamp = 100000000;
|
||||
temp.setTimeStamp(QCanBusFrame::TimeStamp(0, 100000000));
|
||||
model->addFrame(temp, true);
|
||||
qApp->processEvents();
|
||||
tickGUIUpdate(); //force a GUI refresh so that the row exists to measure
|
||||
@@ -402,7 +399,7 @@ void MainWindow::gridDoubleClicked(QModelIndex idx)
|
||||
//qDebug() << "Grid double clicked";
|
||||
//grab ID and timestamp and send them away
|
||||
CANFrame frame = model->getListReference()->at(idx.row());
|
||||
emit sendCenterTimeID(frame.ID, frame.timestamp / 1000000.0);
|
||||
emit sendCenterTimeID(frame.frameId(), frame.timeStamp().microSeconds() / 1000000.0);
|
||||
}
|
||||
|
||||
void MainWindow::interpretToggled(bool state)
|
||||
@@ -743,18 +740,18 @@ Data Bytes: 88 10 00 13 BB 00 06 00
|
||||
{
|
||||
CANFrame thisFrame = frames->at(c);
|
||||
QString builderString;
|
||||
builderString += tr("Time: ") + QString::number((thisFrame.timestamp / 1000000.0), 'f', 6);
|
||||
builderString += tr(" ID: ") + Utility::formatCANID(thisFrame.ID, thisFrame.extended);
|
||||
if (thisFrame.extended) builderString += tr(" Ext ");
|
||||
builderString += tr("Time: ") + QString::number((thisFrame.timeStamp().microSeconds() / 1000000.0), 'f', 6);
|
||||
builderString += tr(" ID: ") + Utility::formatCANID(thisFrame.frameId(), thisFrame.hasExtendedFrameFormat());
|
||||
if (thisFrame.hasExtendedFrameFormat()) builderString += tr(" Ext ");
|
||||
else builderString += tr(" Std ");
|
||||
builderString += tr("Bus: ") + QString::number(thisFrame.bus);
|
||||
builderString += " Len: " + QString::number(thisFrame.len) + "\n";
|
||||
builderString += " Len: " + QString::number(thisFrame.payload().length()) + "\n";
|
||||
outFile->write(builderString.toUtf8());
|
||||
|
||||
builderString = tr("Data Bytes: ");
|
||||
for (unsigned int temp = 0; temp < thisFrame.len; temp++)
|
||||
for (unsigned int temp = 0; temp < thisFrame.payload().length(); temp++)
|
||||
{
|
||||
builderString += Utility::formatNumber(thisFrame.data[temp]) + " ";
|
||||
builderString += Utility::formatNumber(thisFrame.payload()[temp]) + " ";
|
||||
}
|
||||
builderString += "\n";
|
||||
outFile->write(builderString.toUtf8());
|
||||
|
||||
@@ -4,6 +4,17 @@
|
||||
#include "mainwindow.h"
|
||||
#include <QDebug>
|
||||
|
||||
/*
|
||||
* Nothing to see here, these are not the droids you're looking for. Go away
|
||||
*
|
||||
*
|
||||
*
|
||||
* You didn't go away, did you... This is a screen that allows for setting EEPROM configuration for a
|
||||
* custom motor controller project I was working on. It's hidden by default. You could re-enable it and play around
|
||||
* with it if you're bored. It might be a good basis for how to set a list of parameters on a device. But, it could be broken
|
||||
* these days too. It is not maintained any longer as the project it was meant for is abandoned. YMMV.
|
||||
*/
|
||||
|
||||
MotorControllerConfigWindow::MotorControllerConfigWindow(const QVector<CANFrame> *frames, QWidget *parent) :
|
||||
QDialog(parent),
|
||||
ui(new Ui::MotorControllerConfigWindow)
|
||||
@@ -57,18 +68,18 @@ void MotorControllerConfigWindow::updatedFrames(int numFrames)
|
||||
for (int i = modelFrames->count() - numFrames; i < modelFrames->count(); i++)
|
||||
{
|
||||
thisFrame = modelFrames->at(i);
|
||||
id = thisFrame.ID;
|
||||
id = thisFrame.frameId();
|
||||
|
||||
if (id == 0xC2) //response to a query we made
|
||||
{
|
||||
if (thisFrame.data[2] == 0)
|
||||
if ((char)thisFrame.payload()[2] == 0)
|
||||
{
|
||||
int paramID = thisFrame.data[0] + (thisFrame.data[1] * 256);
|
||||
int paramID = thisFrame.payload()[0] + (thisFrame.payload()[1] * 256);
|
||||
for (int i = 0; i < params.length(); i++)
|
||||
{
|
||||
if (params[i].paramID == paramID)
|
||||
{
|
||||
params[i].value = thisFrame.data[4] + (thisFrame.data[5] * 256);
|
||||
params[i].value = thisFrame.payload()[4] + (thisFrame.payload()[5] * 256);
|
||||
if (params[i].paramType == ASCII) item = new QTableWidgetItem(); //QString::fromUtf8((char *)params[i].value, 2));
|
||||
if (params[i].paramType == HEX) item = new QTableWidgetItem(Utility::formatHexNum(params[i].value));
|
||||
if (params[i].paramType == DEC)
|
||||
@@ -177,18 +188,19 @@ void MotorControllerConfigWindow::timerTick()
|
||||
{
|
||||
qDebug() << "Request: " << QString::number(transmitStep);
|
||||
|
||||
outFrame.ID = 0xC1;
|
||||
outFrame.len = 8;
|
||||
outFrame.setFrameId(0xC1);
|
||||
QByteArray bytes(8, 0);
|
||||
outFrame.bus = 0;
|
||||
outFrame.extended = false;
|
||||
outFrame.data[0] = params[transmitStep].paramID & 0xFF;
|
||||
outFrame.data[1] = (params[transmitStep].paramID >> 8) & 0xFF;
|
||||
outFrame.data[2] = 0; //0 = read, 1 = write
|
||||
outFrame.data[3] = 0; //reserved
|
||||
outFrame.data[4] = 0; //value goes in bytes 4,5 when writing
|
||||
outFrame.data[5] = 0;
|
||||
outFrame.data[6] = 0; //reserved
|
||||
outFrame.data[7] = 0; //reserved
|
||||
outFrame.setExtendedFrameFormat(false);
|
||||
bytes[0] = params[transmitStep].paramID & 0xFF;
|
||||
bytes[1] = (params[transmitStep].paramID >> 8) & 0xFF;
|
||||
bytes[2] = 0; //0 = read, 1 = write
|
||||
bytes[3] = 0; //reserved
|
||||
bytes[4] = 0; //value goes in bytes 4,5 when writing
|
||||
bytes[5] = 0;
|
||||
bytes[6] = 0; //reserved
|
||||
bytes[7] = 0; //reserved
|
||||
outFrame.setPayload(bytes);
|
||||
|
||||
CANConManager::getInstance()->sendFrame(outFrame);
|
||||
|
||||
@@ -213,18 +225,18 @@ void MotorControllerConfigWindow::timerTick()
|
||||
|
||||
if (thisValue != params[transmitStep].value)
|
||||
{
|
||||
outFrame.ID = 0xC1;
|
||||
outFrame.len = 8;
|
||||
outFrame.setFrameId(0xC1);
|
||||
QByteArray bytes(8, 0);
|
||||
outFrame.bus = 0;
|
||||
outFrame.extended = false;
|
||||
outFrame.data[0] = params[transmitStep].paramID & 0xFF;
|
||||
outFrame.data[1] = (params[transmitStep].paramID >> 8) & 0xFF;
|
||||
outFrame.data[2] = 1; //0 = read, 1 = write
|
||||
outFrame.data[3] = 0; //reserved
|
||||
outFrame.data[4] = params[transmitStep].value & 0xFF;
|
||||
outFrame.data[5] = (params[transmitStep].value >> 8) & 0xFF;
|
||||
outFrame.data[6] = 0; //reserved
|
||||
outFrame.data[7] = 0; //reserved
|
||||
outFrame.setExtendedFrameFormat(false);
|
||||
bytes[0] = params[transmitStep].paramID & 0xFF;
|
||||
bytes[1] = (params[transmitStep].paramID >> 8) & 0xFF;
|
||||
bytes[2] = 1; //0 = read, 1 = write
|
||||
bytes[3] = 0; //reserved
|
||||
bytes[4] = params[transmitStep].value & 0xFF;
|
||||
bytes[5] = (params[transmitStep].value >> 8) & 0xFF;
|
||||
bytes[6] = 0; //reserved
|
||||
bytes[7] = 0; //reserved
|
||||
|
||||
CANConManager::getInstance()->sendFrame(outFrame);
|
||||
}
|
||||
|
||||
+17
-17
@@ -293,7 +293,7 @@ void FlowViewWindow::gotCenterTimeID(int32_t ID, double timestamp)
|
||||
memcpy(refBytes, currBytes, 8);
|
||||
}
|
||||
|
||||
memcpy(currBytes, frameCache.at(currentPosition).data, 8);
|
||||
memcpy(currBytes, frameCache.at(currentPosition).payload().data(), 8);
|
||||
|
||||
updateDataView();
|
||||
}
|
||||
@@ -696,23 +696,23 @@ void FlowViewWindow::timerTriggered()
|
||||
void FlowViewWindow::updateDataView()
|
||||
{
|
||||
|
||||
ui->txtCurr1->setText(Utility::formatNumber(currBytes[0]));
|
||||
ui->txtCurr2->setText(Utility::formatNumber(currBytes[1]));
|
||||
ui->txtCurr3->setText(Utility::formatNumber(currBytes[2]));
|
||||
ui->txtCurr4->setText(Utility::formatNumber(currBytes[3]));
|
||||
ui->txtCurr5->setText(Utility::formatNumber(currBytes[4]));
|
||||
ui->txtCurr6->setText(Utility::formatNumber(currBytes[5]));
|
||||
ui->txtCurr7->setText(Utility::formatNumber(currBytes[6]));
|
||||
ui->txtCurr8->setText(Utility::formatNumber(currBytes[7]));
|
||||
ui->txtCurr1->setText(Utility::formatNumber((char)currBytes[0]));
|
||||
ui->txtCurr2->setText(Utility::formatNumber((char)currBytes[1]));
|
||||
ui->txtCurr3->setText(Utility::formatNumber((char)currBytes[2]));
|
||||
ui->txtCurr4->setText(Utility::formatNumber((char)currBytes[3]));
|
||||
ui->txtCurr5->setText(Utility::formatNumber((char)currBytes[4]));
|
||||
ui->txtCurr6->setText(Utility::formatNumber((char)currBytes[5]));
|
||||
ui->txtCurr7->setText(Utility::formatNumber((char)currBytes[6]));
|
||||
ui->txtCurr8->setText(Utility::formatNumber((char)currBytes[7]));
|
||||
|
||||
ui->txtRef1->setText(Utility::formatNumber(refBytes[0]));
|
||||
ui->txtRef2->setText(Utility::formatNumber(refBytes[1]));
|
||||
ui->txtRef3->setText(Utility::formatNumber(refBytes[2]));
|
||||
ui->txtRef4->setText(Utility::formatNumber(refBytes[3]));
|
||||
ui->txtRef5->setText(Utility::formatNumber(refBytes[4]));
|
||||
ui->txtRef6->setText(Utility::formatNumber(refBytes[5]));
|
||||
ui->txtRef7->setText(Utility::formatNumber(refBytes[6]));
|
||||
ui->txtRef8->setText(Utility::formatNumber(refBytes[7]));
|
||||
ui->txtRef1->setText(Utility::formatNumber((char)refBytes[0]));
|
||||
ui->txtRef2->setText(Utility::formatNumber((char)refBytes[1]));
|
||||
ui->txtRef3->setText(Utility::formatNumber((char)refBytes[2]));
|
||||
ui->txtRef4->setText(Utility::formatNumber((char)refBytes[3]));
|
||||
ui->txtRef5->setText(Utility::formatNumber((char)refBytes[4]));
|
||||
ui->txtRef6->setText(Utility::formatNumber((char)refBytes[5]));
|
||||
ui->txtRef7->setText(Utility::formatNumber((char)refBytes[6]));
|
||||
ui->txtRef8->setText(Utility::formatNumber((char)refBytes[7]));
|
||||
|
||||
ui->flowView->setReference(refBytes, false);
|
||||
ui->flowView->updateData(currBytes, true);
|
||||
|
||||
@@ -336,13 +336,13 @@ void FrameInfoWindow::updateDetailsWindow(QString newID)
|
||||
baseNode->addChild(tempItem);
|
||||
|
||||
tempItem = new QTreeWidgetItem();
|
||||
tempItem->setText(0, tr(" Priority bits: ") + Utility::formatNumber( FilterUtility::getGMLanPriorityBits(targettedID)));
|
||||
tempItem->setText(0, tr(" Priority bits: ") + Utility::formatNumber( (uint64_t)FilterUtility::getGMLanPriorityBits(targettedID)));
|
||||
baseNode->addChild(tempItem);
|
||||
tempItem = new QTreeWidgetItem();
|
||||
tempItem->setText(0, tr(" Arbitration Id: ") + Utility::formatNumber( FilterUtility::getGMLanArbitrationId(targettedID)));
|
||||
tempItem->setText(0, tr(" Arbitration Id: ") + Utility::formatNumber( (uint64_t)FilterUtility::getGMLanArbitrationId(targettedID)));
|
||||
baseNode->addChild(tempItem);
|
||||
tempItem = new QTreeWidgetItem();
|
||||
tempItem->setText(0, tr(" Sender Id: ") + Utility::formatNumber( FilterUtility::getGMLanSenderId(targettedID)));
|
||||
tempItem->setText(0, tr(" Sender Id: ") + Utility::formatNumber( (uint64_t)FilterUtility::getGMLanSenderId(targettedID)));
|
||||
baseNode->addChild(tempItem);
|
||||
|
||||
}
|
||||
@@ -506,7 +506,7 @@ void FrameInfoWindow::updateDetailsWindow(QString newID)
|
||||
dataBase->addChild(tempItem);
|
||||
|
||||
tempItem = new QTreeWidgetItem();
|
||||
tempItem->setText(0, tr("Range: ") + Utility::formatNumber(minData[c]) + tr(" to ") + Utility::formatNumber(maxData[c]));
|
||||
tempItem->setText(0, tr("Range: ") + Utility::formatNumber((char)minData[c]) + tr(" to ") + Utility::formatNumber((char)maxData[c]));
|
||||
dataBase->addChild(tempItem);
|
||||
histBase->setText(0, tr("Histogram"));
|
||||
dataBase->addChild(histBase);
|
||||
|
||||
@@ -1153,7 +1153,7 @@ void GraphingWindow::createGraph(GraphParams ¶ms, bool createGraphParam)
|
||||
}
|
||||
else
|
||||
{
|
||||
params.x[j] = frameCache[k].timeStamp.microSeconds();
|
||||
params.x[j] = frameCache[k].timeStamp().microSeconds();
|
||||
}
|
||||
params.y[j] = (tempVal * params.scale) + params.bias;
|
||||
if (params.y[j] < yminval) yminval = params.y[j];
|
||||
|
||||
@@ -218,7 +218,7 @@ void ISOTP_InterpreterWindow::showDetailView()
|
||||
buildString.append(tr("Raw Payload: "));
|
||||
for (int i = 0; i < messages[rowNum].data.count(); i++)
|
||||
{
|
||||
buildString.append(Utility::formatNumber(messages[rowNum].data[i]));
|
||||
buildString.append(Utility::formatNumber((char)messages[rowNum].data[i]));
|
||||
buildString.append(" ");
|
||||
}
|
||||
buildString.append("\r\r");
|
||||
@@ -291,7 +291,7 @@ void ISOTP_InterpreterWindow::newISOMessage(ISOTP_MESSAGE msg)
|
||||
|
||||
for (int i = 0; i < msg.data.count(); i++)
|
||||
{
|
||||
tempString.append(Utility::formatNumber(msg.data[i]));
|
||||
tempString.append(Utility::formatNumber((char)msg.data[i]));
|
||||
tempString.append(" ");
|
||||
}
|
||||
ui->tableIsoFrames->setItem(rowNum, 5, new QTableWidgetItem(tempString));
|
||||
|
||||
@@ -116,7 +116,7 @@ void SnifferDelegate::paint(QPainter *painter, const QStyleOptionViewItem &optio
|
||||
painter->setOpacity(1.0);
|
||||
painter->setPen(QApplication::palette().color(QPalette::Text));
|
||||
painter->setFont(mainFont);
|
||||
painter->drawText(QRect(viewport.left(), viewport.top() + xSector + yOffset, xSpan, mainFontInfo->pixelSize()), Qt::AlignCenter, Utility::formatNumber(val));
|
||||
painter->drawText(QRect(viewport.left(), viewport.top() + xSector + yOffset, xSpan, mainFontInfo->pixelSize()), Qt::AlignCenter, Utility::formatNumber((char)val));
|
||||
}
|
||||
|
||||
QSize SnifferDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
|
||||
SnifferItem::SnifferItem(const CANFrame& pFrame, quint32 seq):
|
||||
mID(pFrame.ID)
|
||||
mID(pFrame.frameId())
|
||||
{
|
||||
for (int i = 0; i < 8; i++) {
|
||||
mNotch[i] =0;
|
||||
|
||||
+11
-13
@@ -230,23 +230,21 @@ void CANScriptHelper::clearFilters()
|
||||
void CANScriptHelper::sendFrame(QJSValue bus, QJSValue id, QJSValue length, QJSValue data)
|
||||
{
|
||||
CANFrame frame;
|
||||
frame.extended = false;
|
||||
frame.remote = false;
|
||||
frame.ID = static_cast<uint32_t>(id.toInt());
|
||||
frame.len = length.toUInt();
|
||||
if (frame.len > 8) frame.len = 8;
|
||||
frame.setExtendedFrameFormat(false);
|
||||
frame.setFrameId(static_cast<uint32_t>(id.toInt()));
|
||||
QByteArray bytes(length.toUInt(), 0);
|
||||
|
||||
if (!data.isArray()) qDebug() << "data isn't an array";
|
||||
|
||||
for (unsigned int i = 0; i < frame.len; i++)
|
||||
for (unsigned int i = 0; i < bytes.length(); i++)
|
||||
{
|
||||
frame.data[i] = (uint8_t)data.property(i).toInt();
|
||||
bytes[i] = (uint8_t)data.property(i).toInt();
|
||||
}
|
||||
|
||||
frame.setPayload(bytes);
|
||||
frame.bus = (uint32_t)bus.toInt();
|
||||
//if (frame.bus > 1) frame.bus = 1;
|
||||
|
||||
if (frame.ID > 0x7FF) frame.extended = true;
|
||||
if (frame.frameId() > 0x7FF) frame.setExtendedFrameFormat(true);
|
||||
|
||||
qDebug() << "sending frame from script";
|
||||
CANConManager::getInstance()->sendFrame(frame);
|
||||
@@ -258,13 +256,13 @@ void CANScriptHelper::gotTargettedFrame(const CANFrame &frame)
|
||||
//qDebug() << "Got frame in script interface";
|
||||
for (int i = 0; i < filters.length(); i++)
|
||||
{
|
||||
if (filters[i].checkFilter(frame.ID, frame.bus))
|
||||
if (filters[i].checkFilter(frame.frameId(), frame.bus))
|
||||
{
|
||||
QJSValueList args;
|
||||
args << frame.bus << frame.ID << frame.len;
|
||||
QJSValue dataBytes = scriptEngine->newArray(frame.len);
|
||||
args << frame.bus << frame.frameId() << frame.payload().length();
|
||||
QJSValue dataBytes = scriptEngine->newArray(frame.payload().length());
|
||||
|
||||
for (unsigned int j = 0; j < frame.len; j++) dataBytes.setProperty(j, QJSValue(frame.data[j]));
|
||||
for (unsigned int j = 0; j < frame.payload().length(); j++) dataBytes.setProperty(j, QJSValue((unsigned char)frame.payload()[j]));
|
||||
args.append(dataBytes);
|
||||
gotFrameFunction.call(args);
|
||||
return; //as soon as one filter matches we jump out
|
||||
|
||||
@@ -71,7 +71,7 @@ void SignalViewerWindow::processFrame(CANFrame &frame)
|
||||
{
|
||||
sig = signalList.at(i);
|
||||
if (!sig) return;
|
||||
if (sig->parentMessage->ID == frame.ID)
|
||||
if (sig->parentMessage->ID == frame.frameId())
|
||||
{
|
||||
if (sig->processAsText(frame, sigString, false)) //if true we could interpret the signal so update it in the list
|
||||
{
|
||||
|
||||
@@ -97,6 +97,15 @@ public:
|
||||
else return formatHexNum(value);
|
||||
}
|
||||
|
||||
static QString formatNumber(char value)
|
||||
{
|
||||
if (decimalMode)
|
||||
{
|
||||
return QString::number((unsigned char)value, 10);
|
||||
}
|
||||
else return formatHexNum((unsigned char)value);
|
||||
}
|
||||
|
||||
static QString formatCANID(uint64_t id, bool extended)
|
||||
{
|
||||
if (decimalMode) return QString::number(id, 10);
|
||||
|
||||
Reference in New Issue
Block a user