Subversion Repositories Code-Repo

Compare Revisions

Ignore whitespace Rev 353 → Rev 354

/Misc Projects/PcMarlinInterface/MacroController.cpp
File deleted
/Misc Projects/PcMarlinInterface/SerialController.cpp
File deleted
/Misc Projects/PcMarlinInterface/SerialController.h
File deleted
/Misc Projects/PcMarlinInterface/MacroController.h
File deleted
/Misc Projects/PcMarlinInterface/MacroWidget.cpp
0,0 → 1,401
#include "MacroWidget.h"
 
MacroWidget::MacroWidget(QWidget *parent) : QWidget(parent)
{
sigmapTransmit = new QSignalMapper();
sigmapKeybind = new QSignalMapper();
 
btnExport = new QPushButton("&Export");
btnImport = new QPushButton("&Import");
btnAddMacro = new QPushButton("&Add");
btnRemoveMacro = new QPushButton("&Remove");
btnClear = new QPushButton("&Clear");
currKeyBindInfo = QPair<QPushButton*,int>(NULL, 0);
 
mainLayout = new QGridLayout();
 
macroCount = 0;
connected = false;
lastKnownFilePath = ".";
 
ioLayout = new QHBoxLayout();
ioLayout->addWidget(btnAddMacro);
ioLayout->addWidget(btnRemoveMacro);
ioLayout->addWidget(btnClear);
ioLayout->addWidget(btnExport);
ioLayout->addWidget(btnImport);
ioLayout->addStretch();
mainLayout->addLayout(ioLayout, 0, 0, 1, 2);
 
for (int i = 0; i < MACRO_DEFAULT_COUNT; i++) {
Macro_AddEntry();
}
 
setLayout(mainLayout);
 
connect(btnAddMacro, SIGNAL(clicked()), this, SLOT(Macro_AddEntry()));
connect(btnRemoveMacro, SIGNAL(clicked()), this, SLOT(Macro_RemoveEntry()));
connect(btnClear, SIGNAL(clicked()), this, SLOT(Macro_Clear()));
connect(btnExport, SIGNAL(clicked()), this, SLOT(Macro_WriteToFile()));
connect(btnImport, SIGNAL(clicked()), this, SLOT(Macro_ReadFromFile()));
connect(sigmapTransmit, SIGNAL(mapped(QWidget*)), this, SLOT(Macro_InitTransmit(QWidget*)));
connect(sigmapKeybind, SIGNAL(mapped(int)), this, SLOT(Macro_KeybindPrompt(int)));
 
// Register global event process for keyboard shortcut handling
qApp->installEventFilter(this);
}
 
MacroWidget::~MacroWidget()
{
 
}
 
QSize MacroWidget::sizeHint() const
{
return this->minimumSizeHint();
}
 
void MacroWidget::Macro_EnableTransmit()
{
connected = true;
for (int i = 0; i < macroBtnSendList.size(); i++) {
macroBtnSendList[i]->setEnabled(true);
}
}
 
void MacroWidget::Macro_DisableTransmit()
{
connected = false;
for (int i = 0; i < macroBtnSendList.size(); i++) {
macroBtnSendList[i]->setEnabled(false);
}
}
 
void MacroWidget::Macro_InitTransmit(QWidget *t)
{
if (connected) {
QTextEdit *text = qobject_cast<QTextEdit*>(t);
emit Macro_TransmitText(text->toPlainText().toUtf8());
}
}
 
void MacroWidget::Macro_KeybindPrompt(int id)
{
QPushButton *btn = qobject_cast<QPushButton*>(sigmapKeybind->mapping(id));
 
// Check to make sure we arn't processing another key first
if (currKeyBindInfo.first != NULL) {
currKeyBindInfo.first->setText("Hotkey: None");
currKeyBindInfo.first->setDown(false);
currKeyBindInfo.first->removeEventFilter(this);
}
 
// Mark and save button as waiting for key sequence
btn->setDown(true);
btn->setText("Waiting for Key..");
currKeyBindInfo = QPair<QPushButton*,int>(btn, id);
 
// Remove current keybinding for this macro
int index = registeredKeyMacroIDs.indexOf(id);
if (index >= 0) {
registeredKeySequences.removeAt(index);
registeredKeyMacroIDs.removeAt(index);
}
 
// Inspect all following keyboard events
btn->installEventFilter(this);
}
 
void MacroWidget::Macro_AddEntry()
{
macroCount++;
 
// Create new layout/widgets
QLineEdit *lineEdit = new QLineEdit(QString("Macro %1").arg(macroCount));
lineEdit->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
lineEdit->setMinimumWidth(100);
lineEdit->setAlignment(Qt::AlignCenter);
macroNameList.append(lineEdit);
 
QTextEdit *textEdit = new QTextEdit();
textEdit->setMinimumHeight(50);
textEdit->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
textEdit->setWordWrapMode(QTextOption::NoWrap);
textEdit->setFont(QFont("Consolas", 8));
textEdit->setAcceptRichText(false);
textEdit->setTabChangesFocus(true);
macroValueList.append(textEdit);
 
QPushButton *keyButton = new QPushButton("Hotkey: None");
keyButton->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
macroBtnKeyList.append(keyButton);
 
QPushButton *pushButton = new QPushButton("Send Macro");
pushButton->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
pushButton->setEnabled(connected);
macroBtnSendList.append(pushButton);
 
QVBoxLayout *tmpLayout = new QVBoxLayout();
tmpLayout->addWidget(lineEdit);
tmpLayout->addWidget(keyButton);
tmpLayout->addWidget(pushButton);
 
// Add layout/widgets to main layout
mainLayout->addLayout(tmpLayout, macroCount, 0);
mainLayout->addWidget(textEdit, macroCount, 1);
mainLayout->setColumnStretch(1, 1);
 
// Associate KeyButton with its corresponding ID
sigmapKeybind->setMapping(keyButton, macroCount-1);
connect(keyButton, SIGNAL(clicked()), sigmapKeybind, SLOT(map()));
 
// Associate PushButton with its corresponding TextEdit
sigmapTransmit->setMapping(pushButton, textEdit);
connect(pushButton, SIGNAL(clicked()), sigmapTransmit, SLOT(map()));
 
QLayoutItem *item = mainLayout->itemAtPosition(1, 1);
int height = item->widget()->height() + mainLayout->verticalSpacing();
 
QDockWidget *parent = qobject_cast<QDockWidget*>(this->parent());
if (parent->isFloating())
parent->resize(parent->width(), parent->height() + height);
 
btnRemoveMacro->setEnabled(true);
}
 
void MacroWidget::Macro_RemoveEntry()
{
 
// Remove and delete layout/widgets at last macro slot
QLayoutItem *item = mainLayout->itemAtPosition(macroCount, 0);
while(!item->isEmpty())
delete item->layout()->takeAt(0)->widget();
delete item;
 
item = mainLayout->itemAtPosition(macroCount, 1);
delete item->widget();
 
item = mainLayout->itemAtPosition(1, 1);
int height = item->widget()->height() + mainLayout->verticalSpacing();
 
// Unmap and remove widgets from lists
QPushButton *pushButton = macroBtnSendList.back();
sigmapTransmit->removeMappings(pushButton);
 
QPushButton *keyButton = macroBtnKeyList.back();
sigmapKeybind->removeMappings(keyButton);
 
macroNameList.pop_back();
macroValueList.pop_back();
macroBtnSendList.pop_back();
macroBtnKeyList.pop_back();
 
int index = registeredKeyMacroIDs.indexOf(macroCount-1);
if (index >= 0) {
registeredKeySequences.removeAt(index);
registeredKeyMacroIDs.removeAt(index);
}
 
macroCount--;
 
QDockWidget *parent = qobject_cast<QDockWidget*>(this->parent());
if (parent->isFloating())
parent->resize(parent->width(), parent->height() - height);
 
if (macroCount == 1)
btnRemoveMacro->setEnabled(false);
}
 
void MacroWidget::Macro_Clear()
{
for (int i = 0; i < macroCount; i++) {
macroNameList[i]->setText(QString("Macro %1").arg(i+1));
macroValueList[i]->clear();
macroBtnKeyList[i]->setText("Hotkey: None");
}
registeredKeyMacroIDs.clear();
registeredKeySequences.clear();
}
 
void MacroWidget::Macro_WriteToFile()
{
QString file = QFileDialog::getSaveFileName(this, "Settings XML File", lastKnownFilePath, "XML File (*.xml)");
QCoreApplication::processEvents(); // Wait for dialog to close
 
if (file.size() == 0) return;
 
// If file was selected, save directory for next time
QFileInfo fileInfo = QFileInfo(file);
lastKnownFilePath = fileInfo.absolutePath();
 
if (file.size() != 0)
QFile::remove(file);
 
QFile inputFile(file);
if (!inputFile.open(QIODevice::ReadWrite | QIODevice::Text)) return;
 
QXmlStreamWriter stream(&inputFile);
stream.setAutoFormatting(true);
 
stream.writeStartDocument();
stream.writeStartElement("Settings");
stream.writeStartElement("Macro");
 
for (int i = 0; i < macroCount; i++) {
stream.writeStartElement("Macro_Entry");
 
stream.writeAttribute("Name", macroNameList[i]->text());
stream.writeTextElement("Value", macroValueList[i]->toPlainText());
 
int index = registeredKeyMacroIDs.indexOf(i);
if (index >= 0) {
stream.writeTextElement("Keybinding", registeredKeySequences[index].toString());
} else {
stream.writeTextElement("Keybinding", "");
}
 
stream.writeEndElement(); // Macro Entry
}
 
stream.writeEndElement(); // Macro
stream.writeEndElement(); // Settings
stream.writeEndDocument();
 
inputFile.close();
}
 
void MacroWidget::Macro_ReadFromFile()
{
int counter = 0;
 
QString file = QFileDialog::getOpenFileName(this, "Settings XML File", lastKnownFilePath, "XML File (*.xml)");
QCoreApplication::processEvents(); // Wait for dialog to close
 
if (file.size() == 0) return;
 
Macro_Clear();
 
// If file was selected, save directory for next time
QFileInfo fileInfo = QFileInfo(file);
lastKnownFilePath = fileInfo.absolutePath();
 
QFile inputFile(file);
if (!inputFile.open(QIODevice::ReadWrite | QIODevice::Text)) return;
 
QXmlStreamReader stream(&inputFile);
 
// Parse the XML file till we reach the end (or errors)
while (!stream.atEnd() && !stream.hasError()) {
QXmlStreamReader::TokenType token = stream.readNext();
 
// Ignore StartDocument
if (token == QXmlStreamReader::StartDocument) continue;
 
// Parse StartElements
if (token == QXmlStreamReader::StartElement) {
 
// Ignore elements <Settings> and <Macro>
if (stream.name() == "Settings") continue;
if (stream.name() == "Macro") continue;
 
// Parse element <Macro_Entry>
if (stream.name() == "Macro_Entry") {
QString name, value, keybinding;
 
// Read and save attribute value
QXmlStreamAttributes attr = stream.attributes();
if (attr.hasAttribute("Name"))
name = attr.value("Name").toString();
 
stream.readNext();
 
// Loop in this element to find all sub-elements
while (!(stream.tokenType() == QXmlStreamReader::EndElement && stream.name() == "Macro_Entry")) {
 
// Parse and save element value
if (stream.tokenType() == QXmlStreamReader::StartElement) {
if (stream.name() == "Value") {
stream.readNext();
value = stream.text().toString();
}
if (stream.name() == "Keybinding") {
stream.readNext();
keybinding = stream.text().toString();
}
}
stream.readNext();
}
 
// Write values to GUI
if (counter == macroCount)
Macro_AddEntry();
 
macroNameList[counter]->setText(name);
macroValueList[counter]->setText(value);
if (keybinding != "") {
registeredKeySequences.append(QKeySequence(keybinding));
registeredKeyMacroIDs.append(counter);
macroBtnKeyList[counter]->setText("Hotkey: " + keybinding);
}
counter++;
}
}
}
}
 
bool MacroWidget::eventFilter(QObject *obj, QEvent *event)
{
// Only process keyboard events
if (event->type() == QEvent::KeyPress) {
QKeyEvent *keyevent = static_cast<QKeyEvent*>(event);
QKeySequence seq = keyevent->modifiers() + keyevent->key();
if ((keyevent->key() >= 0x21 && keyevent->key() <= 0x2F) ||
(keyevent->key() >= 0x3A && keyevent->key() <= 0x40) ||
(keyevent->key() >= 0x5E && keyevent->key() <= 0x7E) ) {
seq = keyevent->key();
}
 
if (connected) {
// First check if key sequence matches any saved ones
if (!registeredKeySequences.isEmpty()) {
int index = registeredKeySequences.indexOf(seq);
if (index >= 0) {
Macro_InitTransmit(macroValueList[registeredKeyMacroIDs[index]]);
return true;
}
}
}
 
// Then save key sequence if needed
if (currKeyBindInfo.first != NULL) {
// Ignore modifier keys and locks
if (keyevent->key() == Qt::Key_Shift || keyevent->key() == Qt::Key_Control ||
keyevent->key() == Qt::Key_Meta || keyevent->key() == Qt::Key_Alt ||
keyevent->key() == Qt::Key_AltGr || keyevent->key() == Qt::Key_CapsLock ||
keyevent->key() == Qt::Key_NumLock || keyevent->key() == Qt::Key_ScrollLock)
return true;
 
// Reset on ESC key
if (keyevent->key() == Qt::Key_Escape) {
currKeyBindInfo.first->setText("Hotkey: None");
currKeyBindInfo.first->setDown(false);
currKeyBindInfo.first->removeEventFilter(this);
currKeyBindInfo = QPair<QPushButton*, int>(NULL, 0);
return true;
}
 
// Otherwise save key sequence if it doesnt already exist
if (!registeredKeySequences.contains(seq)) {
registeredKeySequences.append(seq);
registeredKeyMacroIDs.append(currKeyBindInfo.second);
currKeyBindInfo.first->setText("Hotkey: " + seq.toString());
currKeyBindInfo.first->setDown(false);
currKeyBindInfo.first->removeEventFilter(this);
currKeyBindInfo = QPair<QPushButton*, int>(NULL, 0);
return true;
}
}
}
 
return QWidget::eventFilter(obj, event);
}
/Misc Projects/PcMarlinInterface/MacroWidget.h
0,0 → 1,61
#ifndef MACROWIDGET_H
#define MACROWIDGET_H
 
#include "GlobalDefines.h"
 
#define MACRO_DEFAULT_COUNT 4
 
class MacroWidget : public QWidget
{
Q_OBJECT
public:
MacroWidget(QWidget *parent = 0);
~MacroWidget();
 
QSize sizeHint() const;
 
public slots:
void Macro_EnableTransmit(void);
void Macro_DisableTransmit(void);
void Macro_InitTransmit(QWidget* t);
void Macro_KeybindPrompt(int id);
void Macro_AddEntry(void);
void Macro_RemoveEntry(void);
void Macro_Clear(void);
void Macro_WriteToFile(void);
void Macro_ReadFromFile(void);
 
signals:
void Macro_TransmitText(QByteArray data);
 
protected:
bool eventFilter(QObject *, QEvent *);
 
private:
int macroCount;
bool connected;
QString lastKnownFilePath;
 
QPushButton *btnExport;
QPushButton *btnImport;
QPushButton *btnAddMacro;
QPushButton *btnRemoveMacro;
QPushButton *btnClear;
 
QList<QLineEdit*> macroNameList;
QList<QTextEdit*> macroValueList;
QList<QPushButton*> macroBtnSendList;
QList<QPushButton*> macroBtnKeyList;
 
QList<QKeySequence> registeredKeySequences;
QList<int> registeredKeyMacroIDs;
 
QGridLayout *mainLayout;
QHBoxLayout *ioLayout;
QSignalMapper *sigmapTransmit;
QSignalMapper *sigmapKeybind;
 
QPair<QPushButton*,int> currKeyBindInfo;
};
 
#endif // MACROWIDGET
/Misc Projects/PcMarlinInterface/MainWindow.cpp
7,28 → 7,7
centralWidget = new QWidget();
setCentralWidget(centralWidget);
 
// Serial data UI
groupSerialData = new QGroupBox("Data");
textSerialData = new QTextEdit();
textSerialData->setCurrentFont(QFont("Consolas", 8));
textSerialData->append("Waiting for serial connection...");
textSerialData->setMinimumHeight(100);
textSerialData->setReadOnly(true);
textSerialTransmit = new QLineEdit();
textSerialTransmit->setFont(QFont("Consolas", 8));
btnSerialTransmit = new QPushButton("&Send");
btnSerialClear = new QPushButton("Clear");
 
QHBoxLayout *serialTransmitLayout = new QHBoxLayout();
serialTransmitLayout->addWidget(textSerialTransmit);
serialTransmitLayout->addWidget(btnSerialTransmit);
serialTransmitLayout->addWidget(btnSerialClear);
QVBoxLayout *serialDataLayout = new QVBoxLayout();
serialDataLayout->addWidget(textSerialData);
serialDataLayout->addLayout(serialTransmitLayout);
groupSerialData->setLayout(serialDataLayout);
 
// Macro controller
// Misc button group
groupMacro = new QGroupBox("Other");
btnMacro = new QPushButton("&Macros");
QHBoxLayout *macroLayout = new QHBoxLayout();
35,30 → 14,39
macroLayout->addWidget(btnMacro);
groupMacro->setLayout(macroLayout);
 
// Initialize serial controller
serialController = new SerialController();
// Initialize serial widget
serialInitWidget = new SerialWidget();
groupSerialInit = new QGroupBox("Serial Connection");
QGridLayout *serialInitLayout = new QGridLayout();
serialInitLayout->setContentsMargins(0, 0, 0, 0);
serialInitLayout->addWidget(serialController);
serialInitLayout->addWidget(serialInitWidget);
groupSerialInit->setLayout(serialInitLayout);
connect(serialController, SIGNAL(UpdateStatus(QString)), this, SLOT(UpdateSerialStatus(QString)));
connect(serialInitWidget, SIGNAL(UpdateStatus(QString)), this, SLOT(UpdateSerialStatus(QString)));
 
// Initialize macro controller
// Initialize data widget
textIOWidget = new TextIOWidget();
groupSerialData = new QGroupBox("Data");
QGridLayout *serialDataLayout = new QGridLayout();
serialDataLayout->setContentsMargins(0, 0, 0, 0);
serialDataLayout->addWidget(textIOWidget);
groupSerialData->setLayout(serialDataLayout);
connect(serialInitWidget, SIGNAL(Serial_ReceivedByte(char)), textIOWidget, SLOT(Serial_ReceivedByte(char)));
connect(serialInitWidget, SIGNAL(Serial_Connected()), textIOWidget, SLOT(Serial_EnableTransmit()));
connect(serialInitWidget, SIGNAL(Serial_Disconnected()), textIOWidget, SLOT(Serial_DisableTransmit()));
connect(textIOWidget, SIGNAL(Serial_TransmitByteArray(QByteArray)), serialInitWidget, SIGNAL(Serial_TransmitByteArray(QByteArray)));
 
// Initialize macro widget
macroDockWidget = new QDockWidget("Macro Controller", this);
macroController = new MacroController(macroDockWidget);
macroDockWidget->setWidget(macroController);
macroWidget = new MacroWidget(macroDockWidget);
macroDockWidget->setWidget(macroWidget);
macroDockWidget->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
macroDockWidget->hide();
addDockWidget(Qt::RightDockWidgetArea, macroDockWidget);
connect(macroController, SIGNAL(Macro_TransmitText(QString)), this, SLOT(Serial_PrepareTransmit(QString)));
connect(serialController, SIGNAL(Serial_Connected()), macroController, SLOT(Macro_EnableTransmit()));
connect(serialController, SIGNAL(Serial_Disconnected()), macroController, SLOT(Macro_DisableTransmit()));
connect(macroWidget, SIGNAL(Macro_TransmitText(QByteArray)), textIOWidget, SLOT(Serial_PrepareTransmit(QByteArray)));
connect(serialInitWidget, SIGNAL(Serial_Connected()), macroWidget, SLOT(Macro_EnableTransmit()));
connect(serialInitWidget, SIGNAL(Serial_Disconnected()), macroWidget, SLOT(Macro_DisableTransmit()));
 
// Connect local widgets
connect(btnSerialTransmit, SIGNAL(clicked()), this, SLOT(Serial_PrepareTransmit()));
connect(textSerialTransmit, SIGNAL(returnPressed()), btnSerialTransmit, SIGNAL(clicked()));
connect(btnSerialClear, SIGNAL(clicked()), this, SLOT(Serial_ClearBtn()));
connect(btnMacro, SIGNAL(clicked()), macroDockWidget->toggleViewAction(), SLOT(trigger()));
 
// Main layout
73,7 → 61,7
setWindowTitle("Marlin Controller");
setWindowIcon(QIcon(":/External/Resources/Icon_16.bmp"));
 
labelSerialStatus = new QLabel("Serial: Disconnected");
labelSerialStatus = new QLabel("Disconnected");
statusBar()->addPermanentWidget(labelSerialStatus);
}
 
82,32 → 70,6
 
}
 
void MainWindow::Serial_PrepareTransmit(QString string)
{
if (string == "") {
string = textSerialTransmit->text();
textSerialTransmit->setText("");
}
emit Serial_TransmitString(string);
textSerialData->setTextColor(Qt::darkBlue);
 
QStringList cmds = string.split('\n');
for (int i = 0; i < cmds.size(); i++) {
textSerialData->append("TX: " + cmds[i]);
}
}
 
void MainWindow::Serial_ClearBtn()
{
textSerialData->clear();
}
 
void MainWindow::Serial_ReceivedString(QString string)
{
textSerialData->setTextColor(Qt::darkRed);
textSerialData->append("RX: " + string);
}
 
void MainWindow::UpdateStatus(QString string)
{
statusBar()->showMessage(string, STATUS_TIMEOUT_MS);
/Misc Projects/PcMarlinInterface/MainWindow.h
2,27 → 2,23
#define MAINWINDOW_H
 
#include "GlobalDefines.h"
#include "SerialController.h"
#include "MacroController.h"
#include "SerialWidget.h"
#include "MacroWidget.h"
#include "TextIOWidget.h"
 
class MainWindow : public QMainWindow
{
Q_OBJECT
 
public:
explicit MainWindow(QWidget *parent = 0);
MainWindow(QWidget *parent = 0);
~MainWindow();
 
public slots:
void Serial_PrepareTransmit(QString string = "");
void Serial_ReceivedString(QString string);
void Serial_ClearBtn(void);
 
void UpdateStatus(QString string);
void UpdateSerialStatus(QString string);
 
signals:
void Serial_TransmitString(QString string);
void Serial_TransmitByteArray(QByteArray data);
 
protected:
 
30,19 → 26,16
QWidget *centralWidget;
 
// Serial controller + UI
SerialController *serialController;
SerialWidget *serialInitWidget;
QGroupBox *groupSerialInit;
QPushButton *btnSerialConnect;
 
// Serial data
TextIOWidget *textIOWidget;
QGroupBox *groupSerialData;
QTextEdit *textSerialData;
QLineEdit *textSerialTransmit;
QPushButton *btnSerialTransmit;
QPushButton *btnSerialClear;
 
// Macro controller + UI
MacroController *macroController;
MacroWidget *macroWidget;
QDockWidget *macroDockWidget;
QGroupBox *groupMacro;
QPushButton *btnMacro;
/Misc Projects/PcMarlinInterface/PcMarlinInterface.pro
14,15 → 14,17
 
SOURCES += main.cpp \
MainWindow.cpp \
SerialController.cpp \
MacroController.cpp \
SerialHelper.cpp
SerialHelper.cpp \
TextIOWidget.cpp \
MacroWidget.cpp \
SerialWidget.cpp
 
HEADERS += GlobalDefines.h \
MainWindow.h \
SerialController.h \
MacroController.h \
SerialHelper.h
SerialHelper.h \
TextIOWidget.h \
MacroWidget.h \
SerialWidget.h
 
RESOURCES += Resources.qrc
 
/Misc Projects/PcMarlinInterface/PcMarlinInterface.pro.user
1,6 → 1,6
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject>
<!-- Written by QtCreator 3.3.0, 2015-01-08T06:54:51. -->
<!-- Written by QtCreator 3.3.0, 2015-01-08T10:53:44. -->
<qtcreator>
<data>
<variable>EnvironmentId</variable>
/Misc Projects/PcMarlinInterface/SerialHelper.cpp
30,7 → 30,7
QString stopBits, QString parity, QString flowControl)
{
if (!connected) {
emit UpdateStatus("Serial: Connecting to " + port);
emit UpdateStatus("Connecting to " + port);
serialPort = new QSerialPort();
connect(serialPort, SIGNAL(readyRead()), this, SLOT(Serial_ProcessIncomingData()));
connect(serialPort, SIGNAL(error(QSerialPort::SerialPortError)), this, SLOT(Serial_ProcessError(QSerialPort::SerialPortError)));
80,7 → 80,7
serialPort->setDataTerminalReady(1);
 
if (ok) {
QString status = "Serial: Connected (%1 @ %2 D: %3 S: %4 P: %5 FC: %6)";
QString status = "Connected (%1 @ %2 D: %3 S: %4 P: %5 FC: %6)";
emit UpdateStatus(status.arg(port).arg(speed).arg(dataBits).arg(stopBits).arg(parity).arg(flowControl));
emit Serial_Connected();
} else
96,7 → 96,7
delete serialPort;
connected = false;
if (!errored)
emit UpdateStatus("Serial: Disconnected");
emit UpdateStatus("Disconnected");
emit Serial_Disconnected();
}
 
106,9 → 106,9
serialPort->write(SERIAL_NEWLINE_CHAR);
}
 
void SerialHelper::Serial_TransmitByteArray(QByteArray buffer)
void SerialHelper::Serial_TransmitByteArray(QByteArray data)
{
serialPort->write(buffer);
serialPort->write(data);
}
 
void SerialHelper::Serial_ProcessIncomingData()
130,43 → 130,43
 
switch(error) {
case QSerialPort::DeviceNotFoundError:
emit UpdateStatus("Serial: (Error) Device not found");
emit UpdateStatus("(Error) Device not found");
return;
case QSerialPort::PermissionError:
emit UpdateStatus("Serial: (Error) Device already opened or lacking permission");
emit UpdateStatus("(Error) Device already opened or lacking permission");
return;
case QSerialPort::OpenError:
emit UpdateStatus("Serial: (Error) Device already opened");
emit UpdateStatus("(Error) Device already opened");
return;
case QSerialPort::NotOpenError:
emit UpdateStatus("Serial: (Error) Device not opened");
emit UpdateStatus("(Error) Device not opened");
return;
case QSerialPort::ParityError:
emit UpdateStatus("Serial: (Error) Parity error detected");
emit UpdateStatus("(Error) Parity error detected");
break;
case QSerialPort::FramingError:
emit UpdateStatus("Serial: (Error) Framing error detected");
emit UpdateStatus("(Error) Framing error detected");
break;
case QSerialPort::BreakConditionError:
emit UpdateStatus("Serial: (Error) Break condition detected");
emit UpdateStatus("(Error) Break condition detected");
break;
case QSerialPort::WriteError:
emit UpdateStatus("Serial: (Error) Unable to write to device");
emit UpdateStatus("(Error) Unable to write to device");
break;
case QSerialPort::ReadError:
emit UpdateStatus("Serial: (Error) Unable to read from device");
emit UpdateStatus("(Error) Unable to read from device");
break;
case QSerialPort::ResourceError:
emit UpdateStatus("Serial: (Error) Device missing or disconnected");
emit UpdateStatus("(Error) Device missing or disconnected");
break;
case QSerialPort::UnsupportedOperationError:
emit UpdateStatus("Serial: (Error) Operation not supported or prohibited");
emit UpdateStatus("(Error) Operation not supported or prohibited");
break;
case QSerialPort::TimeoutError:
emit UpdateStatus("Serial: (Error) Connection timeout");
emit UpdateStatus("(Error) Connection timeout");
break;
case QSerialPort::UnknownError:
emit UpdateStatus("Serial: (Error) Unknown error");
emit UpdateStatus("(Error) Unknown error");
break;
default:
break;
/Misc Projects/PcMarlinInterface/SerialHelper.h
23,7 → 23,7
QString stopBits, QString parity, QString flowControl);
void Serial_Disconnect(bool errored = false);
void Serial_TransmitString(QString string);
void Serial_TransmitByteArray(QByteArray buffer);
void Serial_TransmitByteArray(QByteArray data);
 
// Local processing of received data
void Serial_ProcessIncomingData(void);
/Misc Projects/PcMarlinInterface/SerialWidget.cpp
0,0 → 1,217
#include "SerialWidget.h"
 
SerialWidget::SerialWidget(QWidget *parent) : QWidget(parent)
{
// Serial connection UI
btnSerialConnect = new QPushButton("&Connect");
btnSerialRefresh = new QPushButton("&Refresh");
labelSerialPort = new QLabel("Serial Port:");
labelSerialSpeed = new QLabel("Baud Rate:");
labelSerialDataBits = new QLabel("Data:");
labelSerialStopBits = new QLabel("Stop:");
labelSerialParity = new QLabel("Parity Bit:");
labelSerialFlowControl = new QLabel("Flow Control:");
cboxSerialPort = new QComboBox();
cboxSerialPort->setMinimumWidth(80);
cboxSerialSpeed = new QComboBox();
cboxSerialSpeed->setEditable(true);
cboxSerialSpeed->setValidator(new QIntValidator(0, 100000000, this));
cboxSerialDataBits = new QComboBox();
cboxSerialDataBits->setMaximumWidth(60);
cboxSerialStopBits = new QComboBox();
cboxSerialStopBits->setMaximumWidth(60);
cboxSerialParity = new QComboBox();
cboxSerialFlowControl = new QComboBox();
cboxSerialFlowControl->setMinimumWidth(70);
 
QGridLayout *serialSettingsLayout = new QGridLayout();
serialSettingsLayout->addWidget(btnSerialConnect, 0, 0);
serialSettingsLayout->addWidget(labelSerialPort, 0, 1);
serialSettingsLayout->addWidget(cboxSerialPort, 0, 2);
serialSettingsLayout->addWidget(labelSerialDataBits, 0, 3);
serialSettingsLayout->addWidget(cboxSerialDataBits, 0, 4);
serialSettingsLayout->addWidget(labelSerialParity, 0, 5);
serialSettingsLayout->addWidget(cboxSerialParity, 0, 6);
 
serialSettingsLayout->addWidget(btnSerialRefresh, 1, 0);
serialSettingsLayout->addWidget(labelSerialSpeed, 1, 1);
serialSettingsLayout->addWidget(cboxSerialSpeed, 1, 2);
serialSettingsLayout->addWidget(labelSerialStopBits, 1, 3);
serialSettingsLayout->addWidget(cboxSerialStopBits, 1, 4);
serialSettingsLayout->addWidget(labelSerialFlowControl, 1, 5);
serialSettingsLayout->addWidget(cboxSerialFlowControl, 1, 6);
 
setLayout(serialSettingsLayout);
 
serialHelper = new SerialHelper();
serialThread = new QThread();
serialHelper->moveToThread(serialThread);
 
connect(serialHelper, SIGNAL(UpdateStatus(QString)), this, SIGNAL(UpdateStatus(QString)));
 
connect(this, SIGNAL(Serial_QueryParameters()), serialHelper, SLOT(Serial_QueryParameters()));
connect(serialHelper, SIGNAL(Serial_UpdateParameters(QStringList,QStringList,QStringList,QStringList,QStringList,QStringList)),
this, SLOT(Serial_UpdateParameters(QStringList,QStringList,QStringList,QStringList,QStringList,QStringList)));
 
connect(this, SIGNAL(Serial_Connect(QString,QString,QString,QString,QString,QString)),
serialHelper, SLOT(Serial_Connect(QString,QString,QString,QString,QString,QString)));
connect(serialHelper, SIGNAL(Serial_Connected()), this, SIGNAL(Serial_Connected()));
connect(serialHelper, SIGNAL(Serial_Connected()), this, SLOT(Serial_LocalConnected()));
 
connect(this, SIGNAL(Serial_Disconnect()), serialHelper, SLOT(Serial_Disconnect()));
connect(serialHelper, SIGNAL(Serial_Disconnected()), this, SIGNAL(Serial_Disconnected()));
connect(serialHelper, SIGNAL(Serial_Disconnected()), this, SLOT(Serial_LocalDisconnected()));
 
connect(this, SIGNAL(Serial_TransmitByteArray(QByteArray)), serialHelper, SLOT(Serial_TransmitByteArray(QByteArray)));
 
connect(serialHelper, SIGNAL(Serial_ReceivedByte(char)), this, SIGNAL(Serial_ReceivedByte(char)));
 
connect(serialThread, SIGNAL(finished()), serialHelper, SLOT(deleteLater()));
serialThread->start();
 
connect(btnSerialConnect, SIGNAL(clicked()), this, SLOT(Serial_ConnectToggleBtn()));
connect(btnSerialRefresh, SIGNAL(clicked()), this, SIGNAL(Serial_QueryParameters()));
 
emit Serial_QueryParameters();
Serial_LocalDisconnected();
}
 
SerialWidget::~SerialWidget()
{
serialThread->quit();
}
 
void SerialWidget::Serial_UpdateParameters(QStringList ports, QStringList speeds, QStringList dataBits,
QStringList stopBits, QStringList parity, QStringList flowControl)
{
QString currPort = cboxSerialPort->currentText();
cboxSerialPort->clear();
cboxSerialPort->addItems(ports);
if (currPort != "" && ports.contains(currPort))
cboxSerialPort->setCurrentText(currPort);
 
QString currSpeed = cboxSerialSpeed->currentText();
cboxSerialSpeed->clear();
cboxSerialSpeed->addItems(speeds);
if (currSpeed != "") cboxSerialSpeed->setCurrentText(currSpeed);
 
int currData = cboxSerialDataBits->currentIndex();
cboxSerialDataBits->clear();
cboxSerialDataBits->addItems(dataBits);
if (currData >= 0) cboxSerialDataBits->setCurrentIndex(currData);
 
int currStop = cboxSerialStopBits->currentIndex();
cboxSerialStopBits->clear();
cboxSerialStopBits->addItems(stopBits);
if (currStop >= 0) cboxSerialStopBits->setCurrentIndex(currStop);
 
int currParity = cboxSerialParity->currentIndex();
cboxSerialParity->clear();
cboxSerialParity->addItems(parity);
if (currParity >= 0) cboxSerialParity->setCurrentIndex(currParity);
 
int currFlow = cboxSerialFlowControl->currentIndex();
cboxSerialFlowControl->clear();
cboxSerialFlowControl->addItems(flowControl);
if (currFlow >= 0) cboxSerialFlowControl->setCurrentIndex(currFlow);
}
 
void SerialWidget::Serial_LocalConnected()
{
btnSerialConnect->setText("&Disconnect");
// cboxSerialPort->setEnabled(false);
// cboxSerialSpeed->setEnabled(false);
// cboxSerialDataBits->setEnabled(false);
// cboxSerialStopBits->setEnabled(false);
// cboxSerialParity->setEnabled(false);
// cboxSerialFlowControl->setEnabled(false);
// btnSerialRefresh->setEnabled(false);
btnSerialRefresh->hide();
labelSerialPort->hide();
labelSerialSpeed->hide();
labelSerialDataBits->hide();
labelSerialStopBits->hide();
labelSerialParity->hide();
labelSerialFlowControl->hide();
cboxSerialPort->hide();
cboxSerialSpeed->hide();
cboxSerialDataBits->hide();
cboxSerialStopBits->hide();
cboxSerialParity->hide();
cboxSerialFlowControl->hide();
}
 
void SerialWidget::Serial_LocalDisconnected()
{
btnSerialConnect->setText("&Connect");
// cboxSerialPort->setEnabled(true);
// cboxSerialSpeed->setEnabled(true);
// cboxSerialDataBits->setEnabled(true);
// cboxSerialStopBits->setEnabled(true);
// cboxSerialParity->setEnabled(true);
// cboxSerialFlowControl->setEnabled(true);
// btnSerialRefresh->setEnabled(true);
btnSerialRefresh->show();
labelSerialPort->show();
labelSerialSpeed->show();
labelSerialDataBits->show();
labelSerialStopBits->show();
labelSerialParity->show();
labelSerialFlowControl->show();
cboxSerialPort->show();
cboxSerialSpeed->show();
cboxSerialDataBits->show();
cboxSerialStopBits->show();
cboxSerialParity->show();
cboxSerialFlowControl->show();
}
 
void SerialWidget::Serial_ConnectToggleBtn()
{
if (serialHelper->connected) {
emit Serial_Disconnect();
} else {
if (cboxSerialPort->currentText() != "" && cboxSerialSpeed->currentText() != "") {
emit Serial_Connect(cboxSerialPort->currentText(), cboxSerialSpeed->currentText(), cboxSerialDataBits->currentText(),
cboxSerialStopBits->currentText(), cboxSerialParity->currentText(), cboxSerialFlowControl->currentText());
}
}
}
 
//void SerialController::Serial_ProcessIncomingData()
//{
// char tmpBuffer[SERIAL_BUFFER_SIZE];
// int len = serialPort->read(tmpBuffer, sizeof(tmpBuffer));
// while (len > 0) {
// for (int i = 0; i < len; i++) {
// // Save received data into local buffer
// bufferIn[bufferInIndex] = tmpBuffer[i];
 
// // If newline char is received, end current string
// if (tmpBuffer[i] == '\n') {
// if (bufferInOverflow)
// currString.append(QString::fromLocal8Bit(bufferIn, bufferInIndex));
// else
// currString = QString::fromLocal8Bit(bufferIn, bufferInIndex);
// bufferInOverflow = false;
// bufferInIndex = 0;
// emit Serial_ReceivedString(currString);
// } else {
// bufferInIndex++;
// }
 
// // If received string is larger than our serial buffer, append to previous data
// if (bufferInIndex == SERIAL_BUFFER_SIZE-1) {
// bufferIn[SERIAL_BUFFER_SIZE-1] = 0x0;
// if (bufferInOverflow)
// currString.append(QString::fromLocal8Bit(bufferIn, bufferInIndex));
// else
// currString = QString::fromLocal8Bit(bufferIn, bufferInIndex);
// bufferInOverflow = true;
// bufferInIndex = 0;
// }
// }
// // Check if there is more data to be read from the serial port
// len = serialPort->read(tmpBuffer, sizeof(tmpBuffer));
// }
//}
/Misc Projects/PcMarlinInterface/SerialWidget.h
0,0 → 1,58
#ifndef SERIALWIDGET_H
#define SERIALWIDGET_H
 
#include "GlobalDefines.h"
#include "SerialHelper.h"
 
class SerialWidget : public QWidget
{
Q_OBJECT
public:
SerialWidget(QWidget *parent = 0);
~SerialWidget();
 
public slots:
// Inbound from SerialHelper
void Serial_UpdateParameters(QStringList ports, QStringList speeds, QStringList dataBits,
QStringList stopBits, QStringList parity, QStringList flowControl);
 
// Local GUI processing
void Serial_ConnectToggleBtn(void);
void Serial_LocalConnected(void);
void Serial_LocalDisconnected(void);
 
signals:
// Outbound to SerialHelper
void Serial_QueryParameters(void);
void Serial_Connect(QString port, QString speed, QString dataBits,
QString stopBits, QString parity, QString flowControl);
void Serial_Disconnect(void);
void Serial_TransmitByteArray(QByteArray data);
 
// Outbound to MainWindow
void Serial_ReceivedByte(char byte);
void Serial_Connected(void);
void Serial_Disconnected(void);
void UpdateStatus(QString string);
 
private:
SerialHelper *serialHelper;
QThread *serialThread;
 
QPushButton *btnSerialConnect;
QPushButton *btnSerialRefresh;
QLabel *labelSerialPort;
QLabel *labelSerialSpeed;
QLabel *labelSerialDataBits;
QLabel *labelSerialStopBits;
QLabel *labelSerialParity;
QLabel *labelSerialFlowControl;
QComboBox *cboxSerialPort;
QComboBox *cboxSerialSpeed;
QComboBox *cboxSerialDataBits;
QComboBox *cboxSerialStopBits;
QComboBox *cboxSerialParity;
QComboBox *cboxSerialFlowControl;
};
 
#endif // SERIALWIDGET_H
/Misc Projects/PcMarlinInterface/TextIOWidget.cpp
0,0 → 1,79
#include "TextIOWidget.h"
 
TextIOWidget::TextIOWidget(QWidget *parent) : QWidget(parent)
{
// Serial data UI
textSerialData = new QTextEdit();
textSerialData->setCurrentFont(QFont("Consolas", 8));
textSerialData->append("Waiting for serial connection...");
textSerialData->setMinimumSize(400, 100);
textSerialData->setReadOnly(true);
textSerialTransmit = new QLineEdit();
textSerialTransmit->setEnabled(false);
textSerialTransmit->setFont(QFont("Consolas", 8));
btnSerialTransmit = new QPushButton("&Send");
btnSerialTransmit->setEnabled(false);
btnSerialClear = new QPushButton("Clear");
 
QHBoxLayout *serialTransmitLayout = new QHBoxLayout();
serialTransmitLayout->addWidget(textSerialTransmit);
serialTransmitLayout->addWidget(btnSerialTransmit);
serialTransmitLayout->addWidget(btnSerialClear);
QVBoxLayout *serialDataLayout = new QVBoxLayout();
serialDataLayout->addWidget(textSerialData);
serialDataLayout->addLayout(serialTransmitLayout);
setLayout(serialDataLayout);
 
connect(btnSerialTransmit, SIGNAL(clicked()), this, SLOT(Serial_PrepareTransmit()));
connect(textSerialTransmit, SIGNAL(returnPressed()), btnSerialTransmit, SIGNAL(clicked()));
connect(btnSerialClear, SIGNAL(clicked()), this, SLOT(Serial_ClearBtn()));
 
Serial_DisableTransmit();
}
 
TextIOWidget::~TextIOWidget()
{
 
}
 
void TextIOWidget::Serial_PrepareTransmit(QByteArray data)
{
QString str;
if (data.isEmpty()) {
str = textSerialTransmit->text();
textSerialTransmit->setText("");
} else {
str = QString(data);
}
 
emit Serial_TransmitByteArray(str.toUtf8());
textSerialData->setTextColor(Qt::darkBlue);
 
QStringList cmds = str.split('\n');
for (int i = 0; i < cmds.size(); i++) {
textSerialData->append("TX: " + cmds[i]);
}
}
 
void TextIOWidget::Serial_ReceivedByte(char byte)
{
textSerialData->setTextColor(Qt::darkRed);
textSerialData->append("RX: " + QString(byte));
}
 
void TextIOWidget::Serial_ClearBtn()
{
textSerialData->clear();
}
 
void TextIOWidget::Serial_EnableTransmit()
{
textSerialTransmit->setEnabled(true);
btnSerialTransmit->setEnabled(true);
}
 
void TextIOWidget::Serial_DisableTransmit()
{
textSerialTransmit->setEnabled(false);
btnSerialTransmit->setEnabled(false);
}
/Misc Projects/PcMarlinInterface/TextIOWidget.h
0,0 → 1,30
#ifndef TEXTIOWIDGET_H
#define TEXTIOWIDGET_H
 
#include "GlobalDefines.h"
 
class TextIOWidget : public QWidget
{
Q_OBJECT
public:
TextIOWidget(QWidget *parent = 0);
~TextIOWidget();
 
public slots:
void Serial_PrepareTransmit(QByteArray data = QByteArray());
void Serial_ReceivedByte(char byte);
void Serial_ClearBtn(void);
void Serial_EnableTransmit(void);
void Serial_DisableTransmit(void);
 
signals:
void Serial_TransmitByteArray(QByteArray data);
 
private:
QTextEdit *textSerialData;
QLineEdit *textSerialTransmit;
QPushButton *btnSerialTransmit;
QPushButton *btnSerialClear;
};
 
#endif // TEXTIOWIDGET_H