Collin Kidder
a3cd14e495
This further abstracts the interface. Things are reasonably stable now for frame reception. Initial work has been done to support frame transmission as well. This is currently less stable but mostly working.
358 lines
11 KiB
C++
358 lines
11 KiB
C++
#include "connectionwindow.h"
|
|
#include "ui_connectionwindow.h"
|
|
#include <QtNetwork/QNetworkInterface>
|
|
|
|
ConnectionWindow::ConnectionWindow(CANFrameModel *cModel, QWidget *parent) :
|
|
QDialog(parent),
|
|
ui(new Ui::ConnectionWindow)
|
|
{
|
|
ui->setupUi(this);
|
|
|
|
settings = new QSettings();
|
|
|
|
qRegisterMetaType<CAN_Bus *>("CAN_Bus *");
|
|
qRegisterMetaType<const CANFrame *>("const CANFrame *");
|
|
qRegisterMetaType<const QList<CANFrame> *>("const QList<CANFrame> *");
|
|
|
|
connModel = new CANConnectionModel();
|
|
ui->tableConnections->setModel(connModel);
|
|
|
|
canModel = cModel;
|
|
|
|
ui->tableConnections->setColumnWidth(0, 50);
|
|
ui->tableConnections->setColumnWidth(1, 110);
|
|
ui->tableConnections->setColumnWidth(2, 110);
|
|
ui->tableConnections->setColumnWidth(3, 150);
|
|
ui->tableConnections->setColumnWidth(4, 75);
|
|
ui->tableConnections->setColumnWidth(5, 75);
|
|
ui->tableConnections->setColumnWidth(6, 75);
|
|
|
|
int temp = settings->value("Main/DefaultConnectionType", 0).toInt();
|
|
|
|
//currentPortName = settings->value("Main/DefaultConnectionPort", "").toString();
|
|
|
|
//currentSpeed1 = -1;
|
|
|
|
ui->ckSingleWire->setChecked(settings->value("Main/SingleWireMode", false).toBool());
|
|
|
|
ui->cbSpeed->addItem(tr("<Default>"));
|
|
ui->cbSpeed->addItem(tr("Disabled"));
|
|
ui->cbSpeed->addItem(tr("125000"));
|
|
ui->cbSpeed->addItem(tr("250000"));
|
|
ui->cbSpeed->addItem(tr("500000"));
|
|
ui->cbSpeed->addItem(tr("1000000"));
|
|
ui->cbSpeed->addItem(tr("33333"));
|
|
|
|
#ifdef Q_OS_LINUX
|
|
ui->rbSocketCAN->setEnabled(true);
|
|
#endif
|
|
|
|
#ifdef Q_OS_WIN
|
|
ui->rbKvaser->setEnabled(true);
|
|
#endif
|
|
|
|
connect(ui->btnOK, &QAbstractButton::clicked, this, &ConnectionWindow::handleOKButton);
|
|
connect(ui->rbGVRET, &QAbstractButton::toggled, this, &ConnectionWindow::handleConnTypeChanged);
|
|
connect(ui->rbKvaser, &QAbstractButton::toggled, this, &ConnectionWindow::handleConnTypeChanged);
|
|
connect(ui->rbSocketCAN, &QAbstractButton::toggled, this, &ConnectionWindow::handleConnTypeChanged);
|
|
connect(ui->btnRevert, &QPushButton::clicked, this, &ConnectionWindow::handleRevert);
|
|
connect(ui->tableConnections->selectionModel(), &QItemSelectionModel::selectionChanged, this, &ConnectionWindow::handleConnSelectionChanged);
|
|
connect(ui->btnNewConn, &QPushButton::clicked, this, &ConnectionWindow::handleNewConn);
|
|
}
|
|
|
|
ConnectionWindow::~ConnectionWindow()
|
|
{
|
|
delete settings;
|
|
delete ui;
|
|
}
|
|
|
|
void ConnectionWindow::showEvent(QShowEvent* event)
|
|
{
|
|
QDialog::showEvent(event);
|
|
qDebug() << "Show connectionwindow";
|
|
handleConnTypeChanged();
|
|
}
|
|
|
|
void ConnectionWindow::handleNewConn()
|
|
{
|
|
ui->tableConnections->selectionModel()->clearSelection();
|
|
ui->tableConnections->selectionModel()->clearCurrentIndex();
|
|
handleConnSelectionChanged();
|
|
}
|
|
|
|
void ConnectionWindow::handleConnTypeChanged()
|
|
{
|
|
if (ui->rbGVRET->isChecked()) getSerialPorts();
|
|
if (ui->rbKvaser->isChecked()) getKvaserPorts();
|
|
if (ui->rbSocketCAN->isChecked()) getSocketcanPorts();
|
|
}
|
|
|
|
void ConnectionWindow::handleOKButton()
|
|
{
|
|
QString conn;
|
|
int connType = 0;
|
|
int whichRow = ui->tableConnections->selectionModel()->currentIndex().row();
|
|
qDebug() << whichRow;
|
|
|
|
if (whichRow > -1)
|
|
{
|
|
//load settings from GUI into appropriate CAN_Bus entry and then send it off to the appropriate
|
|
//CANConnection object
|
|
CAN_Bus *bus = connModel->getBus(whichRow);
|
|
bus->setListenOnly(ui->ckListenOnly->isChecked());
|
|
bus->setSingleWire(ui->ckSingleWire->isChecked());
|
|
if (ui->cbSpeed->currentIndex() == 1)
|
|
{
|
|
bus->speed = 0;
|
|
bus->setEnabled(false);
|
|
}
|
|
else if (ui->cbSpeed->currentIndex() > 1)
|
|
{
|
|
bus->setSpeed(ui->cbSpeed->currentText().toInt());
|
|
}
|
|
//call through signal/slot interface without using connect
|
|
QMetaObject::invokeMethod(bus->connection, "updateBusSettings",
|
|
Qt::QueuedConnection,
|
|
Q_ARG(CAN_Bus *, bus));
|
|
}
|
|
else //new connection
|
|
{
|
|
if (ui->rbGVRET->isChecked())
|
|
{
|
|
SerialWorker *serial = new SerialWorker(canModel, connModel->rowCount());
|
|
connect(serial, SIGNAL(busStatus(int,int,int)), this, SLOT(receiveBusStatus(int,int,int)));
|
|
connModel->addConnection(serial);
|
|
|
|
qDebug() << "Setup initial connection object";
|
|
|
|
CAN_Bus bus;
|
|
bus.active = true;
|
|
bus.busNum = serial->getBusBase();
|
|
bus.connection = serial;
|
|
bus.listenOnly = ui->ckListenOnly->isChecked();
|
|
bus.singleWire = ui->ckSingleWire->isChecked();
|
|
|
|
if (ui->cbSpeed->currentIndex() < 1) bus.speed = 0; //default speed
|
|
else if (ui->cbSpeed->currentIndex() == 1)
|
|
{
|
|
bus.speed = 0;
|
|
bus.active = false;
|
|
}
|
|
else bus.speed = ui->cbSpeed->currentText().toInt();
|
|
connModel->addBus(bus);
|
|
|
|
int numBuses = serial->getNumBuses();
|
|
for (int i = 1; i < numBuses; i++)
|
|
{
|
|
bus.active = false;
|
|
bus.listenOnly = false;
|
|
bus.singleWire = false;
|
|
bus.speed = 250000;
|
|
bus.busNum = serial->getBusBase() + i;
|
|
bus.connection = serial;
|
|
connModel->addBus(bus);
|
|
qDebug() << "Added bus " << bus.busNum;
|
|
}
|
|
|
|
//call through signal/slot interface without using connect
|
|
QMetaObject::invokeMethod(serial, "updatePortName",
|
|
Qt::QueuedConnection,
|
|
Q_ARG(QString, ui->cbPort->currentText()));
|
|
}
|
|
else if (ui->rbKvaser->isChecked())
|
|
{
|
|
|
|
}
|
|
else if (ui->rbSocketCAN->isChecked())
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void ConnectionWindow::receiveBusStatus(int bus, int speed, int status)
|
|
{
|
|
qDebug() << "bus " << bus << " speed " << speed << " status " << status;
|
|
CAN_Bus *busRef = connModel->getBus(bus);
|
|
if (status & 40) busRef->setSpeed(speed);
|
|
if (status & 8) //update enabled status
|
|
{
|
|
busRef->setEnabled((status & 1)?true:false);
|
|
}
|
|
if (status & 0x10) //update single wire status
|
|
{
|
|
busRef->setSingleWire((status & 2)?true:false);
|
|
}
|
|
if (status & 0x20) //update listen only status
|
|
{
|
|
busRef->setListenOnly((status & 4)?true:false);
|
|
}
|
|
connModel->refreshView();
|
|
}
|
|
|
|
void ConnectionWindow::handleConnSelectionChanged()
|
|
{
|
|
int selIdx = ui->tableConnections->selectionModel()->currentIndex().row();
|
|
qDebug() << selIdx;
|
|
if (selIdx == -1)
|
|
{
|
|
ui->btnOK->setText(tr("Create New Connection"));
|
|
ui->cbPort->setEnabled(true);
|
|
ui->rbGVRET->setEnabled(true);
|
|
ui->rbKvaser->setEnabled(true);
|
|
ui->rbSocketCAN->setEnabled(true);
|
|
ui->cbPort->setCurrentIndex(0);
|
|
ui->ckListenOnly->setChecked(false);
|
|
ui->ckSingleWire->setChecked(false);
|
|
}
|
|
else
|
|
{
|
|
ui->btnOK->setText(tr("Update Connection Settings"));
|
|
ui->cbPort->setEnabled(false);
|
|
ui->rbGVRET->setEnabled(false);
|
|
ui->rbKvaser->setEnabled(false);
|
|
ui->rbSocketCAN->setEnabled(false);
|
|
CAN_Bus *bus = connModel->getBus(selIdx);
|
|
if (bus->connection->getConnTypeName() == "GVRET") ui->rbGVRET->setChecked(true);
|
|
if (bus->connection->getConnTypeName() == "KVASER") ui->rbKvaser->setChecked(true);
|
|
if (bus->connection->getConnTypeName() == "SOCKETCAN") ui->rbSocketCAN->setChecked(true);
|
|
ui->ckListenOnly->setChecked(bus->isListenOnly());
|
|
ui->ckSingleWire->setChecked(bus->isSingleWire());
|
|
int speed = bus->getSpeed();
|
|
setSpeed(speed);
|
|
connModel->refreshView();
|
|
}
|
|
}
|
|
|
|
void ConnectionWindow::getSerialPorts()
|
|
{
|
|
ui->cbPort->clear();
|
|
ports = QSerialPortInfo::availablePorts();
|
|
|
|
for (int i = 0; i < ports.count(); i++)
|
|
{
|
|
ui->cbPort->addItem(ports[i].portName());
|
|
//if (currentPortName == ports[i].portName()) ui->cbPort->setCurrentIndex(i);
|
|
}
|
|
}
|
|
|
|
void ConnectionWindow::getKvaserPorts()
|
|
{
|
|
|
|
}
|
|
|
|
void ConnectionWindow::getSocketcanPorts()
|
|
{
|
|
#ifdef Q_OS_LINUX
|
|
QList<QNetworkInterface> interfaces = QNetworkInterface::allInterfaces();
|
|
QString interfaceName;
|
|
|
|
ui->cbPort->clear();
|
|
|
|
foreach (QNetworkInterface interface, interfaces)
|
|
{
|
|
interfaceName = interface.name().toLower();
|
|
qDebug() << "Interface: " << interface.name();
|
|
if (interfaceName.contains("can"))
|
|
{
|
|
ui->cbPort->addItem(interfaceName);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void ConnectionWindow::setSpeed(int speed0)
|
|
{
|
|
bool found = false;
|
|
|
|
qDebug() << speed0;
|
|
|
|
for (int i = 0; i < ui->cbSpeed->count(); i++)
|
|
{
|
|
if (ui->cbSpeed->itemText(i).toInt() == speed0)
|
|
{
|
|
ui->cbSpeed->setCurrentIndex(i);
|
|
found = true;
|
|
}
|
|
}
|
|
if (!found)
|
|
{
|
|
ui->cbSpeed->addItem(QString::number(speed0));
|
|
ui->cbSpeed->setCurrentIndex(ui->cbSpeed->count() - 1);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//-1 means leave it at whatever it booted up to. 0 means disable. Otherwise the actual rate we want.
|
|
int ConnectionWindow::getSpeed()
|
|
{
|
|
switch (ui->cbSpeed->currentIndex())
|
|
{
|
|
case -1:
|
|
return -1;
|
|
break;
|
|
case 0:
|
|
return -1;
|
|
break;
|
|
case 1:
|
|
return 0;
|
|
break;
|
|
default:
|
|
return (ui->cbSpeed->currentText().toInt());
|
|
break;
|
|
}
|
|
}
|
|
|
|
QString ConnectionWindow::getPortName()
|
|
{
|
|
return (ui->cbPort->currentText());
|
|
}
|
|
|
|
ConnectionType::ConnectionType ConnectionWindow::getConnectionType()
|
|
{
|
|
if (ui->rbGVRET->isChecked()) return ConnectionType::GVRET_SERIAL;
|
|
if (ui->rbKvaser->isChecked()) return ConnectionType::KVASER;
|
|
if (ui->rbSocketCAN->isChecked()) return ConnectionType::SOCKETCAN;
|
|
}
|
|
|
|
void ConnectionWindow::setSWMode(bool mode)
|
|
{
|
|
ui->ckSingleWire->setChecked(mode);
|
|
}
|
|
|
|
bool ConnectionWindow::getSWMode()
|
|
{
|
|
if (ui->ckSingleWire->checkState() == Qt::Checked) return true;
|
|
return false;
|
|
}
|
|
|
|
void ConnectionWindow::handleRemoveConn()
|
|
{
|
|
|
|
}
|
|
|
|
void ConnectionWindow::handleRevert()
|
|
{
|
|
|
|
}
|
|
|
|
void ConnectionWindow::sendFrame(const CANFrame *frame)
|
|
{
|
|
CAN_Bus *bus = connModel->getBus(frame->bus);
|
|
if (bus == NULL) return;
|
|
QMetaObject::invokeMethod(bus->connection, "sendFrame",
|
|
Qt::QueuedConnection,
|
|
Q_ARG(const CANFrame *, frame));
|
|
}
|
|
|
|
void ConnectionWindow::sendFrameBatch(const QList<CANFrame> *frames)
|
|
{
|
|
if (frames->count() == 0) return;
|
|
CAN_Bus *bus = connModel->getBus(frames->at(0).bus);
|
|
if (bus == NULL) return;
|
|
QMetaObject::invokeMethod(bus->connection, "sendFrameBatch",
|
|
Qt::QueuedConnection,
|
|
Q_ARG(const QList<CANFrame> *, frames));
|
|
}
|