togo-lab.io – 塔郷研究所

Controlling my Siglent SDG2042X from Linux

As part of rebuilding my electronics test bench for future projects at ToGo-Lab, I wanted a simple way to control my Siglent SDG2042X remotely from my Ubuntu box. So I wrote a small PyQt5 GUI script.

In its current state, the script lets you:

Select waveform, amplitude, frequency, and DC offset
Run sweeps, bursts, or arbitrary waveforms
Save and recall up to 10 presets (you can also recall directly from the generator)
Use the ARB Manager to download waveforms from the generator or upload new ones (not fully tested yet!) — it also shows the waveforms currently stored
Send direct SCPI commands through a built-in CLI
Grab screenshots from the generator display (saved in the same directory as the script)

Use it as-is or tweak it for your own setup. Programming in Python and PyQt5 isn’t my main profession — I’m more of a hardware guy — so if you try it and find bugs (there will be some), I’d love to hear from you.

Script source and details: ToGo-Lab Git Repository

The program talks to the SDG2042X over a simple socket connection on port 5025 using SCPI commands. You can call the script with the -ip parameter (try also --help). This is handy if you launch it via a .desktop file.

The functions are straightforward, so there’s no detailed documentation yet. I hope most of the features are self-explanatory. Each GUI tab covers one main function. See more details in the Gitea repo:

Basic – waveform, frequency, amplitude, offset, phase, and output control
Burst – configure burst mode, trigger source, cycles, and delay
Sweep – set up linear or logarithmic sweeps, start/stop frequency
ARB Manager – list, upload, and download arbitrary waveforms (still experimental)
SCPI CLI – the command-line interface for direct SCPI communication
Presets – store and recall up to 10 custom setups; presets are saved in a text-based .dat file. This tab is especially useful — you can adjust settings directly on the generator, then read them back and save them as presets. The file is easy to edit manually if needed.

You can take screenshots at any time. They’re stored as .bmp files in the working directory, with the date and time included in the filename.

Old meter (MXD-4660A), new tricks.

I pulled my veteran DMM, a Voltcraft MXD-4660A, from the drawer to set up my workbench (adding a serial-to-USB converter) and gave it a second tour of duty with QtDMM on Ubuntu. After a bit of searching online what to use under I found the QtDMM project at http://www.mtoussaint.de/qtdmm.htmlm , but appears abandoned. The active fork, I think, is at https://github.com/tuxmaster/QtDMM.

Here’s the final install and setup for my lab computer running Ubuntu 22.04 (Jammy):

Build & Install QtDMM on Ubuntu 22.04 (Jammy)

1) Prerequisites

Enable Universe and base tools:

sudo apt update
sudo apt install -y software-properties-common
sudo add-apt-repository -y universe
sudo apt update

Compilers, build tools, VCS:

sudo apt install -y git build-essential cmake ninja-build pkg-config

Qt6 SDK

sudo apt install -y qt6-base-dev qt6-tools-dev qt6-tools-dev-tools qt6-l10n-tools libqt6serialport6-dev

HID API

sudo apt install -y libhidapi-dev libhidapi-hidraw0

OpenGL headers for Qt6Gui/Widgets

sudo apt install -y libopengl-dev libgl1-mesa-dev libglu1-mesa-dev mesa-common-dev

Serial access without sudo:
```
sudo usermod -aG dialout "$USER"
```
Log out and back in to apply group membership

2) Get the source and make the script executable

git clone https://github.com/tuxmaster/QtDMM.git
cd QtDMM
chmod +x compile.sh

3) Build

Clean build (optional). Also verifies prerequisites are present.

./compile.sh clean || true
rm -rf build CMakeCache.txt CMakeFiles
./compile.sh

Artifacts land in ./bin/:
```
./bin/qtdmm --version
```
Verify it runs. If not, see Troubleshooting below

4) Install for all users (see §5 for a .deb`option)`

Preferred:

sudo ./compile.sh install
# now on PATH:
qtdmm --version

5) Alternative: make a .deb

Keeps your system clean and is easy to remove later.

./compile.sh pack
sudo apt install ./QtDMM_*amd64.deb

6) Uninstall

If installed via .deb:

sudo apt remove qtdmm

If installed via compile.sh install:

# run from the same build dir used for the install
sudo xargs rm &lt; build/install_manifest.txt

Troubleshooting:

If you hit errors, try a clean build reset instead of first searching forums. I learned the hard way to make a clean install as a belt-and-suspenders reset, that deletes built objects but keeps the CMake cache.

“|| true” lets the sequence continue even if the clean step fails due to a broken config.
“rm -rf build CMakeCache.txt CMakeFiles” force-removes any stale out-of-source build dir and any accidental in-source CMake cache:
“Final ./compile.sh” does a fresh configure and build:

cd ~/QtDMM
./compile.sh clean || true
rm -rf build CMakeCache.txt CMakeFiles
./compile.sh

Let’s check if it’s running

As your regular user, start QtDMM from the command line or via the Ubuntu Dock (search for “QtDMM”):
Hint: How to create a Desktop shortcut launcher for ubuntu 22.04
Configure settings for MXD-4660A:

Final test setup (send a known signal) and the result:

Question to readers: Is there Linux software for the old Hameg HM1507-3? I’m currently using a Windows XP VM with very old software.

“Hello World” Project for Tōgō Lab: FireFly Morse Blinker

This is my first hardware project on the new ToGo-Lab.io server.

Some years ago, when I started with AVR/ATTiny programming, I built a tiny Morse “throwie”: one ATtiny, one LED, one resistor, and power-friendly firmware. The goal was to use as few parts as possible to keep it cheap, while still adding a couple of useful functions.

Two main functions: Detect daylight. If it’s bright, sleep; if it’s dark, send a Morse message. The LED doubles as a light sensor.

This is a good restart for my new project home, https://togo-lab.io/, the HW version of a “Hello World” program. So I don’t plan heavy hardware work here, though I may add a small solar cell to stretch battery life. This version adds a supercapacitor and small solar cells and uses the LED as a light detector, so it only blinks in the dark. It’s no longer a throwie, more of a pendant. Hang it where it gets daylight and stays dry. It charges by day and blinks by night.

Yes – I want also a PCB and maybe you will the final result as a little DIY Project on e.g. – Tindie.

But real goal is to define the specs and a simple, repeatable workflow from Idea to real DIY Kit especially for bigger future projects.

This post will evolve as the project advances. I’ll append notes, design decisions, and lessons learned rather than writing a single post-mortem at the end. But don’t expect too much progress too quickly; this is a side hustle. Perhaps in a few years, after I retire, it will become one of my main activities.

What it is

DIY-Kit goal: beginner-friendly soldering kit with clear docs and hackable programm (using Arduino IDE).
MCU: ATtiny45/85, through-hole.
Power: 3–5 V, with solar + supercap option.
Behavior: Morse message presets, LED as light sensor for night-only blink.

Process and tooling

Repos:
- ToGo-Lab Gitea holds sources and releases.
- ToGo-Lab Nextcloud holds docs and larger assets, but actual only for internal use.
- Default license: CC-BY-NC-4.0 for docs and design files.

Roadmap

v0.1: Proto: breadboard + first PCB, single message, speed presets.
v1.0: Pilot: build guide, BOM with alternates, pilot of 10 units.
v1.1: docs polish, optional brightness setting, minor PCB tweaks.
v2.0: Zero Series
…

How this post will evolve
I’ll update this page with:

Schematics, Circuit description,
PCB Design, CAD. All you need to build one,
Build photos and assembly hints.,
BOM changes and sourcing notes,
Additional Blog post about the program itself and how to do with Arduino IDE.

Want to get involved?
Suggestions welcome. Open an issue on the repo or email tgohle@togo-lab.io. If you build one, share photos and your timing results—those will feed back into the docs and the next revision.

Schematics, Circuit description,
tbd

First Light at Tōgō Lab : Lab-Log Zero

I’m Thomas Gohle, and Tōgō Lab / 塔郷研究所 is my home base for future electronics projects.

About me: I studied RF communications in my youth, then spent the last few decades in semiconductor maintenance (details on LinkedIn).

I currently live in Dresden, Germany. With retirement on the horizon in some years, I’m rebooting my hobby. To my boss, if you’re reading this: it will take a while (you know how slow I can be). As you know I’m still working on current and upcoming equipment projects, and I still like to play with my wet-chemistry semicon beasts.

What can you expect? RF experiments, analog circuits, sensor builds and some digital electronics projects to some extend. I enjoy small AVR work, especially ATtiny. I document designs so they can be reproduced and improved by others. The midterm plan is to turn stable builds into small-batch kits and offer them to you. But making money is definitely not the goal of Tōgō Lab. The main goal is community, having fun, learning something new and doing things with my hands.

Collaboration lives on this server. Source code and issues are in Gitea at https://gitea.togo-lab.io. Shared docs and files that don’t fit into Gitea run through Nextcloud at https://nextcloud.togo-lab.io, which also supports basic project planning and control. This blog ties it together with build notes, measurements, and hard-won lessons. Some areas may be invite-only while the workspace settles.

Under the hood it’s a simple stack: Debian on a VPS and Apache with HTTPS via Let’s Encrypt, with a reverse proxy to services. I also keep a separate, older weblog you can find at my primary landing page https://tgonet.de. That older blog is shifting to private and travel notes (I like to travel, especially in the Far East), while Tōgō Lab here stays focused on electronics.

If RF, analog, and ATtiny projects are your thing, feel free to follow along, e.g., via my Mastodon account connected to Tōgō Lab. Ideas and pull requests welcome.