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() << "OK pressed. Row " << 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() << "Selection: " << 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() << "Set Speed " << 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));
|
|
}
|