EasyTerm - The Story of an Idea

First of all, welcome!

I would like to start this first post on a more personal note—so allow me, as the creator of EasyTerm, to introduce myself. My name is Miroslav Šíma. I am primarily a firmware developer with experience in both hardware and software, and I have been working on a device called EasyTerm for quite a few years now.

EasyTerm has an interesting history. Initially, it was supposed to be a device centered around a touchscreen and UART—a sort of "HMI" (Human-Machine Interface) for operating and monitoring various devices with serial ports, whether for development, validation, or regular use. Many people are familiar with terminal applications like Putty or my personal favorite, ScriptCommunicator. However, monitoring logs from various devices can often be unintuitive, and controlling them via a text-based API is no different—messages are displayed in chronological order without any sorting or filtering, and managing parameters by manually rewriting commands is inconvenient and prone to errors. Sometimes the device isn't even within reach of the computer, the UART<->USB adapter is misplaced, or the device’s API has been forgotten... (I’m getting carried away, but this is personal experience at play).

EasyTerm as an HMI

The first version included a set of graphical widgets for monitoring messages, with parsing based on masks (forms, graphs, sequential logging windows), and a set of widgets for creating (or rather, parameterizing) messages—buttons, keyboards, sliders, checkboxes. I used the device to control other devices—essentially anything with UART. Thanks to the ability to save layouts of these widgets, each controlled device could have its own layout (or "control panel," if you will). Even a small, low-power microcontroller with only a few pins could be easily operated and monitored as long as it had UART. There was no need to complicate things, allowing focus on developing and improving the primary function for which the device was being created. Since it used an ASCII protocol, no integration of libraries or firmware modifications were necessary for the device being controlled (because, let's face it, in many cases, someone would just give up and stick to a regular software terminal).

A lot of time was spent designing the ASCII protocol (I didn’t want to keep changing it). The priority was intuitiveness. Commands could be entered in a compact or self-documenting format (or a combination of both).

For example, I believe that even a complete beginner to EasyTerm could understand a command like displayButton x=10 y=10 text="Save layout" action="SaveLayout bankId=0". The same could be written more concisely as db x=10 y=10 t="Save layout" a="sl bid=0" or as a combination of both formats.

Operating anything finally became fun, and there was no longer a need to add interfaces to a display or many buttons. But over time, I became more frustrated by situations where I needed to perform a seemingly simple task during development—like generating a specific voltage, a PWM signal with a specific frequency and duty cycle, reading a register from an integrated circuit, or setting a logical level somewhere. It may sound simple, but it was often a nightmare. One either had to cobble something together or make space on the desk for a bulky and expensive device that was absolute overkill for the task. Reading an integrated circuit required obtaining specialized equipment and installing software. Heaven forbid automation was needed, such as generating a time sequence of various PWM signals—this led to scouring manuals and often wondering why the SCPI command wasn’t working.

EasyTerm as a multitool

That’s when the second version came into play. The circuitry became more complex, adding well-known buses (UART/SPI/I2C), digital inputs/outputs (GPIOs, PWM), and analog pins (ADC/DAC). Generating voltage or PWM became a matter of seconds (usually just one command—e.g., commands like DAC v=1000, ADC v=? or PWM initialized=1 frequency=10kHz dutyCycle=80 ). Scripting any sequence in Python using the pyserial library took just a minute without any hurdles.

The best part was how easily the original "HMI" functionality could be connected to these interfaces. All it took was displaying a slider that, instead of sending a generic message, had a defined action like PWM frequency=%d , allowing you to set the frequency by moving the slider! Add another slider for setting the duty cycle, a few checkboxes and buttons for finer PWM parameterization, and suddenly, EasyTerm transforms into a PWM generator controlled via a touchscreen! The same could be applied to other interfaces. One moment you need a signal generator, and the next, an I2C circuit reader that graphs a register’s value. Thanks to support for "paging" between layout screens, you could have a signal generator on the first screen and an "HMI" control panel for any device on the next.

EasyTerm Goes Global

The final phase came when I realized what a powerful tool I had created (no modesty here). The following steps focused on making EasyTerm accessible to others. The firmware was improved as far as imagination could go, and the hardware was iterated to perfection. A manual was created. To make EasyTerm as user-friendly as possible (because, let’s face it, browsing through a manual isn’t fun!), the CmdBuilder application was developed, allowing commands to be easily assembled through forms. For those interested in using EasyTerm as a multitool, a set of layouts was created (essentially a collection of pre-prepared "commands"). So, for example, a touch-controlled PWM generator or many other functions could be obtained right after sending a "pre-prepared" set of commands. To top it all off, the hardware was certified for EMI/ESD in a certified testing lab. So, if you’re interested, you can have one too. Initially, it’s available only in the Czech Republic, but in time, throughout Europe—and hopefully soon, the whole world!

I’m happy to personally answer any questions at support@7-tech.net

Happy developing!

Ing. Miroslav Šíma - the father of EasyTerm