Category: Qt

building a qt 6.2 application — the power of encapsulation

whbeebe

I’ve reached a point where the central part of the USB Device Monitor, which contains the device table at top and the console at the bottom, has evolved into its own class. It started out as a class function of the primary class, MainWindow. But it quickly became evident I needed to better organize specific functionality into its own compilation unit. The best way to do that was with a unique class that encapsulated the data and structures unique to both the table and console. That’s the reason I like C++ and other object-oriented languages; encapsulation. Not inheritance, encapsulation.

Here is the unique header for CentralWidget:

#pragma once#include <QSplitter>#include <QWidget>#include <QString>#include <QStringList>#include <QHeaderView>#include <QTableWidget>#include <QTableWidgetItem>#include <QTextEdit>#include <QPlainTextEdit>#include <QSettings>#include <QPalette>#include <QSerialPort>#include <QByteArray>#include <QScrollBar>#include <QFont>class CentralWidget : public QSplitter {public:const QString CWIDGET_STATE{"cwidget/state"};explicit CentralWidget(QWidget *parent);void saveCWState(QSettings &settings);void restoreCWState(QSettings &settings);private:QTextEdit *console;QSerialPort *serialPort;QTableWidget *table;void readSerialData();void openUSBPort(QTableWidgetItem *);void closeUSBPort();};

And the implementation, with some beginning comments:

#include "CentralWidget.hpp"#include "devices.hpp"CentralWidget::CentralWidget(QWidget *parent) :QSplitter(parent),console(new QTextEdit),serialPort(new QSerialPort),table(new QTableWidget) {setOrientation(Qt::Vertical);// Configure the console onto which we will communicate with a given// USB device.//QPalette colors = palette();colors.setColor(QPalette::Base, Qt::black);colors.setColor(QPalette::Text, Qt::white);QFont font("Monospace", 12);font.setStyleStrategy(QFont::PreferAntialias);console->setPalette(colors);console->setFont(font);console->setCursorWidth(8);// Connect the console with the serial port so that any data that is// recieved by the serial port will be displayed on the console.//connect(serialPort, &QSerialPort::readyRead, this,&CentralWidget::readSerialData);// Find all the USB devices connected to our system. Put their data in a// spreadsheet-like table.//auto devices = getDevices();table->setRowCount(devices.size());QStringList headers = {"Device", "Adapter Name", "Hex Identification"};table->setColumnCount(headers.size());table->setHorizontalHeaderLabels(headers);table->horizontalHeader()->setStretchLastSection(true);int row{0};// Populate the table with eacj USB device, one row/devices.//for (auto [device, values] : devices) {QString dev(device.c_str());QString v1(values[0].c_str());QString v2(values[1].c_str());table->setItem(row, 0, new QTableWidgetItem(dev));table->setItem(row, 1, new QTableWidgetItem(v1));table->setItem(row, 2, new QTableWidgetItem(v2));++row;}table->resizeColumnsToContents();// Connect the table with the class function so that when a user// clicks on a port in the table, that port will be opened and// communicating with the console.//connect(table, &QTableWidget::itemClicked, this,&CentralWidget::openUSBPort);// Finish construction by putting the table at the top and the// console beneath it.//addWidget(table);addWidget(console);}void CentralWidget::readSerialData() {QByteArray data = serialPort->readAll();console->insertPlainText(data);QScrollBar *scrollBar = console->verticalScrollBar();scrollBar->setValue(scrollBar->maximum());}void CentralWidget::openUSBPort(QTableWidgetItem *cell) {if (cell->column() == 0) {closeUSBPort();QString portName = "/dev/" + cell->text();console->insertPlainText(QString("\nPort open: %1\n").arg(portName));QScrollBar *scrollBar = console->verticalScrollBar();scrollBar->setValue(scrollBar->maximum());serialPort->setPortName(portName);serialPort->setBaudRate(QSerialPort::Baud115200);serialPort->setDataBits(QSerialPort::Data8);serialPort->setParity(QSerialPort::NoParity);serialPort->open(QIODevice::ReadOnly);serialPort->clear(QSerialPort::AllDirections);}}void CentralWidget::closeUSBPort() {if (serialPort->isOpen()) {serialPort->clear();serialPort->close();}}void CentralWidget::saveCWState(QSettings &settings) {settings.setValue(CWIDGET_STATE, saveState());}void CentralWidget::restoreCWState(QSettings &settings) {if(settings.contains(CWIDGET_STATE)) {restoreState(settings.value(CWIDGET_STATE).toByteArray());}}

The key features of the new class are:

  • The table is built based on the number of entries found by getDevices(), and the data now fits into the table accordingly. The code was reorganized so that the devices are found before the table is filled with the resultant data.
  • The table cell click event is now connected to openUSBPort(), so that clicking on a cell that contains a port will close any port that may be open, then open the new port clicked on.
  • The class handles saving and restoring its own internal state, instead of having MainWindow do it, via saveCWState() and restoreCWState().

Now when you start the application, it just sits there not displaying any information. When you click on a port, such as ttyACM0, then that port is opened and any data being sent from the device connected to that port is displayed on the console. The screen capture leading this post shows how this works now. The ttyACM0 was clicked, and then the port was opened.

The biggest problem right now is that if an text is displayed on the console that contains ANSI escape sequences, they are not interpreted and instead are just printed as raw data. I’m going to have to either find a Qt class that can interpret those sequences and display the text accordingly (usually colors), or else write my own. What I may wind up doing is stripping that ANSI data before writing to a log file.

Another chunk of future work is to put functional controls on the dock panel. I have some ideas what I want.

Once I get those tasks out of the way, I will probably release this as an open tool for others to use. As I’ve written before, more to come…

Links

building a qt 6.2 application — beginning usb comms

building a qt 6.2 application — beginning usb comms

whbeebe1 Comment

My Qt 6 application isn’t simple any more. It’s grown more complicated as I continue to add features and evolve it towards what I finally want. In this post I’m adding very basic serial communications via USB to my attached development boards. For this post I’m only communicating with the Raspberry Pi Pico W. I’ll be using QSerialPort to develop that functionality. I’ll show what additional source and libraries I had to install, the core modified code, and the application I had running on the Pico W to produce test output.

First things first. I had to install the headers and library files to support developing with Qt’s QSerialPort. Those extra packages are libqt6serialport6 and libqt6serialport6-dev. This will put the necessary header files down /usr/include/x86_64-linux-gnu/qt6/QtSerialPort/. You’ll also need to link against Qt6SerialPort.

Here’s the modified code module. I’ll highlight the pertinent sections after the code block.

#include <QStringList>#include <QHeaderView>#include <QTableWidgetItem>#include <QSplitter>#include <QPalette>#include <QSerialPort>#include <QByteArray>#include <QScrollBar>#include <QFont>#include "MainWindow.hpp"#include "devices.hpp"void MainWindow::addCentralWidget() {console = new QPlainTextEdit(this);QPalette colors = palette();colors.setColor(QPalette::Base, Qt::black);colors.setColor(QPalette::Text, Qt::white);QFont font("Monospace", 12);font.setStyleStrategy(QFont::PreferAntialias);console->setPalette(colors);console->setFont(font);serialPort = new QSerialPort(this);connect(serialPort, &QSerialPort::readyRead, this, &MainWindow::readSerialData);serialPort->setPortName("/dev/ttyACM0");serialPort->setBaudRate(QSerialPort::Baud115200);serialPort->setDataBits(QSerialPort::Data8);serialPort->setParity(QSerialPort::NoParity);serialPort->open(QIODevice::ReadOnly);table = new QTableWidget(this);table->setColumnCount(3);table->setRowCount(6);QStringList headers = {"Device", "Adapter Name", "Hex Identification"};table->setHorizontalHeaderLabels(headers);table->horizontalHeader()->setStretchLastSection(true);int row{0};for (auto [device, values] : getDevices()) {QString dev(device.c_str());QString v1(values[0].c_str());QString v2(values[1].c_str());table->setItem(row, 0, new QTableWidgetItem(dev));table->setItem(row, 1, new QTableWidgetItem(v1));table->setItem(row, 2, new QTableWidgetItem(v2));++row;}table->resizeColumnsToContents();QSplitter *splitter = new QSplitter(Qt::Vertical, this);splitter->addWidget(table);splitter->addWidget(console);setCentralWidget(splitter);}void MainWindow::readSerialData() {QByteArray data = serialPort->readAll();console->insertPlainText(data);QScrollBar *scrollBar = console->verticalScrollBar();scrollBar->setValue(scrollBar->maximum());}

The text box is being used again as a console. Starting at line 15, we set up the foreground and background colors and the font we want to see any text in. This gives us a console with white text on a black background, with a 12pt Monospaced font using anti-aliasing. The default font is horrible.

Lines 24 through 27 are critical to this working. While Qt calls the ability to handle callbacks as signals (the call) and slots (the callback), this is their nomenclature for a feature as old as C, which is the ability to call pointers to functions. This was a feature in the Unix widget toolkit, Motif, in which controls had the ability to be programatically configured with pointers to functions that were called when a given control was activated. Line 26 sets up the callback (MainWindow::readSerialData) to be called by the serialPort when any data is present. The callback reads that data and places it to be displayed on the console. This is all done asynchronously such that the GUI event queue isn’t blocked. This is very similar to what Java tries to do with its GUI toolkits. The callback is in lines 61-66. When the application is running, it will open the port to the Pico W and then begin to read the data that the Pico W sends out.

These are early days for this. I only wrote enough to get the callback going and to read from the port. You’ll note that the port is hard coded for the Pico W. In the future I’ll be able to pick any port just by clicking on the entry in the upper table and the console will be fully bi-directional. I’m also going to add the ability to log everything in the console. As a stretch goal I’d like to be able to edit Micropython source in the attached microcontroller as well. But that’s a stretch goal which is going to require almost as much work as all the work leading up to finishing the first three goals.

Now for the interesting part. The Pico W is running Circuit Python 8 beta 6.

# SPDX-FileCopyrightText: 2022 Liz Clark for Adafruit Industries## SPDX-License-Identifier: MITimport osimport timeimport sslimport wifiimport socketpoolimport microcontrollerimport adafruit_requestsimport jsonimport gc# Adafruit quotes URL#quotes_url = "https://www.adafruit.com/api/quotes.php"# Connect to your local hostspot.# WIFI_SSID and WIFI_PASSWORD should be defined in your settings.toml# file.#wifi.radio.connect(os.getenv('WIFI_SSID'), os.getenv('WIFI_PASSWORD'))pool = socketpool.SocketPool(wifi.radio)session = adafruit_requests.Session(pool, ssl.create_default_context())print("Fetching quotes from ", quotes_url)print()while True:try:time.sleep(5)gc.collect()# Get a quote.#response = session.get(quotes_url)dic = dict(json.loads(response.text)[0])qstr = dic['text'] + "."print("   " + qstr)print(".. " + dic['author'])print("")response.close()gc.collect()# pylint: disable=broad-exceptexcept ValueError as e:print("Error: bad JSON")response.close()except Exception as e:print("Error:\n", str(e))print("Resetting microcontroller in 10 seconds")time.sleep(10)microcontroller.reset()

The original code came from Adafruit. I cleaned up the while loop to make the output more readable. The original code just spat out the JSON strings that came back from the URL. I’ve done some formatting and cleanup instead.

That’s it for the time being. I’ll continue to clean up the C++ code. Hopefully I’ll have more progress to post by the weekend.