As promised in my last blog, here a first release of the Nextion Web Serial Framework! It allows to interact with all “classic” Nextion HMIs, be it the Basic, the Enhanced, the Intelligent, the Discovery, or the Edge series without having to install the Nextion Editor. A computer running Windows, macOS, or Linux and a web browser with Serial Api support. The current releases of Mozilla Firefox, Google Chrome, Microsoft Edge, and Opera will do the job. I understand that you can’t wait to try it out, but please continue reading, first, I’ll give you the URL of the live version and the GitHub repo below!

The current version v.0.2 does not yet implement all the planned features, but it allows already to send commands to the Nextion, and it decodes everything which the Nextion sends back and displays it in the Nextion Output pane. I’ve made an effort to decode and to display everything in an easily human readable form instead of displaying just the raw bytes or ASCII characters as the Nextion Debugger does. And it saves you a lot of time because there is no more need to look up the Nextion return codes, everything is translated to the corresponding text from the Nextion Instruction Set. Nevertheless, you may at each moment check the “Debug” checkbox below the output panel to have the raw bytes appended to the display as in the lower part of the picture above.

On top of that, I allowed to give a different color to the different types of messages: “Normal” returns like strings and numbers are blue, status messages are grey, events are green, commands are brown, and errors are bold and red. At the beginning of each line, you’ll also find a “>” for incoming messages or a “<” for outgoing messages (commands).

Light and shadow – your help is needed

The German poet Johann Wolfgang von Goethe said once “Where there is much light, there is also much shadow”. I met the shadow when I clicked the “Connect new” button for the first time. Among others, it makes a dialog pop up to select the COM port which you want to use with your Nextion. This dialog is provided by the browser and its web serial API and by default, it lists tons of (virtual) USB and Bluetooth ports which makes it difficult to identify the port with the USB-to Serial adapter where your Nextion HMI is actually connected to. Thus I decided to use the filters option of the API’s requestPort function. It’s a kind of whitelist where the developer can add USB VID and PID pairs. Having nothing else at hands, the only whitelisted adapter is actually the Nextion Foca Max Adapter which is not only a USB to Serial converter based on the CP2102 chip, but which cares also about a stable and clean power supply for your Nextion HMI. Thus, if you don’t yet have one, it’s perhaps time to order one by clicking here.

Or, you send me an email with the VID and PID pair of your preferred and known working adapter and I’ll be happy to add it to the list which is by the way in the nxconfig.js file. My email address can be found in the last paragraph. Or you create directly a pull request on GitHub.

Prepare your Nextion HMI for a first test

Create a new .hmi project, select the Nextion model which you have at hands and its orientation, set the leave the program.s file as is. Add a font with 16px height. On the default page, change its background color to something pleasing, add a Number component which will by default be named n0, and a Text component t0. Set the txt_maxl attribute to 20 and its txt to “Some text“. Add a timer tm0, set its en attribute to 0 and its tim attribute to 4000. Now to the event code panes: for the page itself, for the Text t0 and the Number n0, don’t put any code, but for each of these 3 items, check the “Send Component ID” in both places, the Touch Press Event and the Touch Release Event”. Finally, in the Timer Event code pane of timer tm0, add the following two lines:

n0.val++
get n0.val

At startup, this timer is disabled, but we will enable it later “by hand” over serial through the browser to produce a constant data flow for our test. Instead, you may download this .hmi file and adapt it in the Nextion Editor to your Nextion model: frameworktest.HMI. Compile this miniature project and upload it to your Nextion. Don’t forget to close the upload window to free the COM port!

A word about the Code

For a maximum of compatibility, I decided to create everything only using pure html/css and javascript. No third party libraries or tools, no jQuery. And to make it easily re-usable (in a later stage) for those among you who want to customise everything to deploy your specific variant to your customers, everything will be well encapsulated in javascript classes. Unfortunately, this is not yet fully accomplished in the currently published v.0.2 because I started with the nxComm class (to handle the serial stuff) and added the nxUI class (to handle everything visual) later. In the next version, the nxUI class will be in control of everything and the nxComm class its slave, but for the moment, it’s still partly the other way round which makes the code less undqerstable and customisable. Thus, please be patient, v.0.3 where everything will be cleaned up and more logical will come next Sunday. But if you are curious, you may already have a look onto the GitHub repository.

Finally, Action!

Your Nextion HMI with the miniature test project running as described above should be connected to the Foca Max Adapter and the latter to your computer. For the moment, switch the Foca Max’ power switch off. Now open this link and you’ll see the following in a new tab. Clicking the “Connect new” button brings the port selector up. Select the CP2102 USB to UART Bridge Controller (that’s the Foca Max Adapter) and click “Connect”. Then, the word “Disconnected” in the bottom left status bar section should show Connected to {“usbProductId”:”0xea60″,”usbVendorId”:”0x10c4″}.

Now, it’s time to action the power switch on the Foca Max Adapter and to observe the Nextion booting. Then, to get more verbose output, we enter bkcmd=3 in the command line and click “Send”

The result is visible in the output pane.

On our Nextion, we should see “Some Text” in the Text component on the screen. Let’s modify it by sending t0.txt=”It works!”. Then, let’s modify the 0 in the Number component by sending n0.val=-77.

Now, let’s read back the values to see how “normal” returns are displayed. Send get t0.txt and then get n0.val and look what happens. Afterwards touch the Number component and release it.

All Nextion events are decoded as javascript objects. This will allow us later to create additional callback functions and filters. Now, let’s check the “Debug” checkbox first, just for fun, to see also the raw bytes which represent the payload of the message. The preceding ident byte like 0x70 for strings or 0x71 for numbers are always suppressed. Then let’s enable the timer tm0 by sending tm0.en=1, wait a few seconds, and observe the output pane:

I think that this is already a nice playground and for today, we’ll leave it at that. There are a few more features already halfway implemented, but I think that it’s better to show these next Sunday with the upcoming version v.0.3.

Last, but not least

You have any questions, comments, critics, or suggestions? Just send me an email to thierry (at) itead (dot) cc! 🙂

And, by the way, if you like and you find useful what I write, and you are about to order Nextion stuff with Itead, please do so by clicking THIS REFERRAL LINK! To you, it won’t forcibly make a change for your order but on some products, you may even get a 10% discount using the coupon code THIERRYFRSONOFF. In ever case, it will pay me perhaps the one or the other beer or coffee. And that will motivate me to write still more interesting blogs 😉

Thank you for reading and happy Nextioning!

In the beginning, there was an email from a reader who asked if there was a stand-alone version of the Nextion upload tool, which is normally integrated in the Nextion Editor. The reader had created a commercial project around a Nextion HMI, and sold several hundreds worldwide. The problem now is updates. Many of his customers are not really ok with installing the whole Nextion Editor just for flashing a new tft file. Thus his request, which we couldn’t yet satisfy.

But recently, I stumbled over an amazing thing which is in the world for some time. It’s called the Web Serial API which allows to access local serial ports from a web page via Javascript. In the beginning, there was not much browser support, but now, there are Chrome, Edge, Opera, and Firefox which support it. And the initial security concerns (access local resources from the web???) are also solved: the user has to select and authorise the serial port access each time the page with the web serial application is loaded.

“Marvellous”, I thought and started diving into the documentation. One html file, some css styling and javascript code, and we are done. During the development phase, there is even no need for a web server. You can simply open the index.html file in the browser and everything will run file based in the local environment. So, I started and I discovered that there are some hurdles and a steep learning curve because the serial communication is based on stream objects, asynchronous calls, and (hopefully) resolved promises – things that were beyond my actual javascript knowledge. That looks like an interesting thing to explore and I’ll take you with me on this travel.

What we want to achieve

A compact javascript object with simple and easy to apply exported properties and methods to do about the same as the corresponding parts in the Nextion Editor:
– – Everything needed to easily connect to the serial port
– – Retrieving some system info from the connect string
– – Function to initialise and set the RTC
– – Command input and sendCommand() function
– – Function(s) to read and write the Nextion’s EEPROM
– – A firmware updater
– – File transfer from and to the SD card and/or the local storage memory area (if configured)
– – A listener, able to parse the return data from the Nextion HMI and to throw callback functions

That’s a long list, so we will advance step by step.

If you haven’t yet the famous Foca Max adapter which cares about the power supply for any Nextion HMI screen AND the USB-to-TTLserial conversion and which features an on-off switch and additional status LEDs, you may look at it and order by clicking here: Nextion Foca Max Adapter.

What we have today

The connection stuff is already working – phew! The code snippet below shows you that we check first if the browser supports the web serial API. Then we define a filter to prevent errors, so the the port selector list will only show any connected Nextion Foca Max boards. You may modify this if you use a different USB to TTL Serial adapter, but you should basically keep the filtering, so that you or your users will not get a long list of virtual com ports and bluetooth devices to select from. Finally, the requestPort() function is called which presents the user to select a port from the list (which shows ideally only the Foca Max adapter to prevent confusion, thanks to the filter) and to authorise the access to it.

static selectPort() {
    if ("serial" in navigator) {
        let portFilter = { "usbProductId": 60000, "usbVendorId": 4292 }; // Filter for Nextion Foca Max adapter, can be adjusted as needed
        navigator.serial.requestPort({ filters: [portFilter] }).then((port) => {
            this.#nxPort = port;
	    console.log("Port selected:", port.getInfo());
	    document.getElementById("selectStatus").textContent = "✅";
	}).catch((error) => {
	    console.error("Error selecting port:", error);
	    document.getElementById("selectStatus").textContent = "❌";
	});
    } else {
	console.error("Web Serial API not supported in this browser.");
    }
}

Once the port selected, we have the baud rate selector which on change calls a simple function so set the baud rate:

static set baudRate(baud) {
    this.#nxBaud = baud;
    console.log("Baud rate set to:", this.#nxBaud);
}

With a port and a baud rate, we can now logically connect to our Nextion screen:

static openPort() {
    if (this.#nxPort && this.#nxBaud > 0) {
	this.#nxPort.open({ baudRate: this.#nxBaud }).then(() => {
	    console.log("Port opened with baud rate:", this.#nxBaud);
	    document.getElementById("connectStatus").textContent = "✅";
	    this.#initHMI();
	}).catch((error) => {
	    console.error("Error opening port:", error);
	    document.getElementById("connectStatus").textContent = "❌";
	});
    } else {
	console.error("Port not selected or baud rate not set.");
    }
}

As you can see in the last code snippet, a private function #initHMI() is called after successfully connecting. It’s just a wrapper to set up the read and write stream objects which is not yet ready. On the other hand, the just opened port can naturally also be closed:

… and the redirection from the javascript console to the better visible “Log Output” pane works already, too!

Actually, I’m working on the elementary functions to send and receive data and I hope to get these working until next weekend. Then, when the actual web interface and the functionality will be in sync, I’ll put the whole stuff on GitHub and you can better follow the evolutions. For the listener, I have already a rudimentary function which receives data from the Nextion and logs it to the console without further parsing. Here the result when the Nextion executes get sys0, sys0++ every second with the help of a timer:

Last, but not least

You have any questions, comments, critics, or suggestions? Just send me an email to thierry (at) itead (dot) cc! 🙂

And, by the way, if you like and you find useful what I write, and you are about to order Nextion stuff with Itead, please do so by clicking THIS REFERRAL LINK! To you, it won’t forcibly make a change for your order but on some products, you may even get a 10% discount using the coupon code THIERRYFRSONOFF. In ever case, it will pay me perhaps the one or the other beer or coffee. And that will motivate me to write still more interesting blogs 😉

Thank you for reading and happy Nextioning!

Most Nextion enthusiasts are used to developing with a comfy IDE, that’s why I started blogging about the Genius series HMI and the underlying Open Nextion standard using the Arduino IDE and VS Code (part II here), using the corresponding plugins. The underlying framework, the ESP-IDF, provided by Espressif, the manufacturer of the ESP32s3, the heart of the Genius series HMI, is a huge collection of command line software, comprising libraries, compiler, linker and additional tools. Thus, the side behind the mirror for most of us. Nevertheless, I learned how to deal with it and wrote about my experience under Windows here. Afterwards, I found that it was less complicated as I had feared, and I decided to repeat the experience on one of my Macs.

Mac users know that macOS is built on a fork of BSD Unix. That makes that many command-line tools can run in a terminal window on a Mac, and so does the ESP-IDF. So, the installation procedure on a Mac is basically very Linux-like. It’s just that macOS does not come with a Linux-like package manager. Fortunately, there are two free tools Homebrew and MacPorts. You should have one of both installed on your system.  We’ll go with my favourite, Homebrew, here.

Step 1: Installing a package manager

Open a Terminal window. This can be found under /Applications/Utils. Enter the following line and press Return.

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Now, the magic will happen and when the installation routine has finished, you’ll be required to execute three additional commands separately to add Homebrew to the system path, so that you can call it from everywhere as indicated on the screen under ==> Next steps.

Step 2: Installing dependencies

The ESP-IDF requires some external tools which we install with the next command, using the just installed Homebrew:

brew install cmake ninja dfu-util

Step 3: Checking your Python version

Since the ESP-IDF is written in Python, you need to have Python 3 installed on your system. Up to macOS 10.15 (Catalina), Python 2.7 came with it. Newer versions of macOS don’t come with Python. Thus, lets check that out with

python3 --version

If there is an error like in my screenshot, let’s install python3 with the following command

brew install python3

Step 4: Download the ESP-IDF

This is done with the git clone command as follows, we decide for the version 5.4.1 since it was used by my colleagues to develop the example projects for Open Nextion:

mkdir -p ~/esp
cd ~/esp
git clone -b v5.4.1 --recursive https://github.com/espressif/esp-idf.git

This will download the ESP-IDF into ~/esp/esp-idf. If you get an error instead, like zsh: command not found: git, you need to install the free developer tools from Apple with the following command:

xcode-select --install

Afterwards, run the two last of the three commands above, again.

Step 5: Set up the toolchain

This is needed to add the support files for the specific ESP hardware:

cd ~/esp/esp-idf
./install.sh esp32s3

Once this accomplished, we are almost done.

Step 6: The environment helper

The last thing is to set some environment variables, so that you can call the ESP-IDF from whatever source code directory which you want. There is explicitly NO permanent adding to the system path because you can theoretically have several different ESP-IDF versions installed on your system in parallel, and each one needs its own environment. Thus, let’s create a command alias and add it to our hidden .zprofile file:

nano ~/.zprofile

With that, you’ll see a text based text editor like in the screenshot below. Move to the last empty line with the cursor keys, the mouse won’t work here, and add the following:

alias get_idf='. $HOME/esp/esp-idf/export.sh'

Then, press Ctrl+o to save and confirm with the Return key, and then Ctrl+x to quit the editor. Then, activate the helper with

source ~/.zprofile

and we are done. With this, we may move to whatever directory with source code, activate the IDF with get_idf, and then start building, configuring, and uploading our Open Nextion Projects. And the setup is finished.

Step 7: Get the example project files

Depending on which Genius series HMI you have, download the example files for either the ONX2432G028 or the ONX3248G035. Then extract the .zip archive and move the whole folder with its 9 subdirectories into the esp folder in your user directory. This should then look like this:

The last step(s): Building and uploading a project

We’ll start with the 01_touch_test. Right-click the folder, select Services in the menu, and then New terminal in the folder. In the new terminal window, enter get_idf and Return to activate the environment.

Now, we are ready to build this project. The first step is to tell for which hardware we want to build. This is done with

idf.py set-target esp32s3

to check if all needed resources are present. This is not needed for the example programs which are already preconfigured. The next step is to configure the project with

idf.py menuconfig

but we do not use or modify it for the example programs. So, we start directly the build process with

idf.py build

This will take some time and issue probably a few warnings which you may ignore. If everything was done correctly, the build process will successfully come to an end. And finally, we may upload the compiled package with

idf.py flash

The IDF will normally detect the port automatically and a few seconds later, the project will run on your Genius!

Last, but not least

You have any questions, comments, critics, or suggestions? Just send me an email to thierry (at) itead (dot) cc! 🙂

And, by the way, if you like and you find useful what I write, and you are about to order Nextion stuff with Itead, please do so by clicking THIS REFERRAL LINK! To you, it won’t forcibly make a change for your order but on some products, you may even get a 10% discount using the coupon code THIERRYFRSONOFF. In ever case, it will pay me perhaps the one or the other beer or coffee. And that will motivate me to write still more interesting blogs 😉

Thank you for reading and happy Nextioning!

The new Open Nextion programming model and the new Genius series HMI have come to market a few weeks ago, and the user community doesn’t stop asking questions… Again, Open Nextion and the Genius series HMI will NOT replace the other series and their easy and convenient developing with the Nextion editor. These will remain in production as promised by the long term availability guarantee. Open Nextion and Genius are an extension of the product range. If you are unsure what to choose, depending of your project specifications, read my blog from last Sunday, especially the huge paragraph “Conclusions” towards the end!

Developing for the Genius series (or any other upcoming HMI for the Open Nextion standard) is totally different. You’ll have to code everything by hand, the program code, the graphical interface, the touch handler, Wifi, Bluetooth, etc., etc. For people who are familiar with the Arduino IDE, I showed here how to extend it for the ESP32-S3, the heart of the Genius series. Other, perhaps more advanced developers might already be familiar with the VS Code IDE which can also be extended with an ESP-IDF plugin, so that you have your usual editor for your code but additional menu functions which make VS Code a remote control for the ESP-IDF which will handle the build, compile, and upload processes. But the setup and configuration is somewhat tricky and I experienced many hurdles before I got everything working. That made even two blogs, here and here.

Thus, I thought – even if I feared it – I’d give the bare ESP-IDF a try and take you with me on this travel. Before starting, let’s make one thing clear: The ESP-IDF is fully written in Python. So, to work with it, it allows you to open a Terminal (cmd or powershell) Window which is backed by a python runtime. There is no graphical interface, no build, compile and monitor buttons. Every function has to be invoked from the command line in the form idf.py <function> <parameters>. If that does not frighten you, continue reading…

Installing the ESP-IDF

Let’s learn from the past experience and thus, let’s not use the new Espressif Installation Manager. Whatever IDF version one chooses to install with it, some paths will not be compatible with projects created with earlier IDF versions, like the 9 Open Nextion demo projects. Thus, let’s do the same as my Chinese colleagues did and download the IDF 5.4.2 offline installer from here. Once downloaded, launch it. The first question it will ask you  is your preferred language. I left it on the default setting, English.

Next, you have to accept the licence agreement – don’t worry, they won’t sell you a tumble dryer, everything is free.

Then, it checks your Windows environment. To me, it showed a warning as you can see. That’s why I clicked on “Apply Fixes”

And I confirmed.

On my system (remember, it’s a virtual Win11 machine, running on a Mac…), I went with the default installation path…

Here, too, I decided to go with the default settings…

And finally, we can click “Install”.

Now, you have time to get a coffee or two, the installation will take a little more than a few minutes, but you’ll (hopefully) end up with the following screen and click finish:

Building the first project

Although two terminal windows are now launched, the one presumably a powershell and the other a command prompt window, to me, both look very similar and I decided to do the following steps in the command prompt window which says itself that it is a powershell window, too… 🤨

Time to load the first example project. You should create a working directory for yourself. So, make sure to have created a directory named “esp” in the root of your user profile directory, besides Desktop, Documents, Downloads, and so on. Then, move to this directory by entering

cd %userprofile%\esp

and hitting return. Normally, the prompt of the command line will now change to C:\Users\YourName\esp>. From there, we import the hello world example which comes with the ESP-IDF by copying over to our local directory:

xcopy /e /i %IDF_PATH%\examples\get-started\hello_world hello_world

If this is achieved, we connect our Genius HMI and we check (for example in the Windows Device Manager) which virtual COM port has been attributed. In my case, it was COM4. Now, we may move to the local code directory with

cd %userprofile%\esp\hello_world

and tell the ESP-IDF that we want this project to be built for an ESP32-S3 with

idf.py set-target esp32s3

This corresponds to selecting a specific board in the Arduino IDE’s menu. But in opposite to the Arduino IDE, this will already compile and cache many internal ans system libraries for this CPU, when invoked for the first time. Then, if needed, we may set some options with

idf.py menuconfig

similar to the Tools menu in the Arduino IDE, but it’s text based… The demo project will run with the default settings, so, you may look at it and close it by pressing “Q”.

Now, after all these settings, we may start the compile an build process with

idf.py build

If done for the first time, this process is rather lengthy, get another coffee or two, the build process has 1038 steps…

… but it will eventually come to an end:

Finally, we can upload the compiled image to our Genius with

idf.py -p COM4 flash // replace COM4 with the COM port of your Genius HMI if different

It will then immediately run. Since the hello world example has no graphics output, we need to launch the serial monitor with

idf.py -p COM4 monitor // replace COM4 with the COM port of your Genius HMI if different

And here we are – It works! It wasn’t as complicated as I thought, before. So, we may be confident when trying to compile and upload the one or the other Open Nextion demo project, next time.

Last, but not least

You have any questions, comments, critics, or suggestions? Just send me an email to thierry (at) itead (dot) cc! 🙂

And, by the way, if you like and you find useful what I write, and you are about to order Nextion stuff with Itead, please do so by clicking THIS REFERRAL LINK! To you, it won’t forcibly make a change for your order but on some products, you may even get a 10% discount using the coupon code THIERRYFRSONOFF. In ever case, it will pay me perhaps the one or the other beer or coffee. And that will motivate me to write still more interesting blogs 😉

Thank you for reading and happy Nextioning!

Since I started writing about Open Nextion and the new Genius series HMI, I got many emails from readers of this Nextion Sunday blog, all asking more or less similar questions. So, I allow today to publish this compilation of your questions and my answers. If you are unsure if you should move over from the classic Nextion HMI to Open Nextion, please read the conclusion towards the end of this article, after the questions and answers.

Q1: Is the “Intelligent” series going to be canceled? If so, when?

The answer is NO. There is Nextion’s LTA, the Long Term Availability guarantee, which states clearly: 
ITEAD Studio guarantees the availability of Nextion Series products for a minimum of 5 years. Unless you are specifically notified at the time of purchase, all Nextion series products will be available for purchase for 5 years at least. We understand the investment you make by using our products and we ensure long-term product availability. There are no quantity restrictions on the guarantee for the below parts.

Then, the following series are listed with a LTA from 2023-2027, including: The Basic, Discovery, Enhanced, and Intelligent series. But long-term Nextion customers understand that this does NOT mean that everything will disappear after 2027, this document contains the Basic and Enhanced series which are much longer in the market, and for which this is already the second LTA 5 years period. On top of that, there isn’t actually any new product at the horizon which could replace the Intelligent series in terms of screen size and functionality. The Edge series could technically do so in many cases, but it’s missing the bigger screen sizes. Thus, the Intelligent series is very likely to persist.

Q2: In your blog, the screenshots of Open Nextion are very small, and I’ll admit I haven’t read everything, but VS Code intimidates me. I wouldn’t want to buy a screen only to have it sitting in a drawer in two weeks.

If you feel intimidated by VS Code, you should know that VS Code is well known and one of the preferred IDEs among professional developers who want a highly modular and configurable IDE to work not only in Arduino-C with one series of embedded MCUs, but who write at the same time web apps in PHP or Node.js, or desktop and mobile applications in Python, for example, in a unified structure. But it remains one option among many. The Genius series is built on top of a ESP32-S3 MCU and every tool which allows to compile and build firmware for the ESP32-S3, like the Arduino IDE as I showed here or even the bare ESP-IDF which requires the developer to use python commands on the command line in a PIP environment to build and upload a project, will do the job.

Q3: Is there a graphical user interface for Open Nextion like the one in the standard Nextion Editor?

Since in Open Nextion, you are basically free to code the way you prefer, there is no standardised GUI. Whatever IDE you use, you’ll have to code everything by hand. You might use the free LVGL graphics library (that’s what my Chinese colleagues used when creating the demo applications), but you’ll have still to write code in C to create and display a graphic element (widget) on the screen. There are third party tools which provide you with a GUI designer tool for LVGL to ease your work, but these are platform specific. The good old Ms Google might help you finding one which fits your needs.

Q4: Can one add images, sounds, and fonts just as easily as with Nextion Editor?

That depends on which libraries you use for your project. LVGL for example comes with a font converter and an image converter as helper tools, similar to the Nextion Editor. For audio, the integrated I2S module of the ESP32 requires a PCM format which can be generated from other audio formats like mp3 with the freeware command line tool ffmpeg. Overall, there remains some more work to do.

Q5: Can one write code in a language other than Python? (Bascom Basic, Visual Basic?)

The most common programming language for ESP32 MCUs is C/C++. The ESP-IDF expect you to code in C/C++, and so do the extension modules for the Arduino IDE and for VS Code. The ESP-IDF itself is written in Python and you’ll have to use python commands on the command line to compile, build, and upload your C/C++ code. The free and powerful LVGL graphics library comes also in C/C++. But you are naturally free to use whatever programming language you want, as long as you can find a compiler, a toolchain, and a building environment for the ESP32-S3 and libraries for its onboard peripherals, especially the ST7796S TFT display controller, and the the CST826 touch controller.

Q6: Is there a debugger as great as the one in the Nextion Editor? Is it possible to test the commands?

The Nextion Editor has no debugger in the technical sense, it has a simulator which can display error messages. On the other hand, the ESP-IDF (and thus the VS Code extension) come with a true debugger which means that you can execute your compiled assembly/machine code word by word, or from a predefined breakpoint to another, and inspect the binary content of the CPU registers at every moment. Thus, to test a function, you have to code it first in C/C++, compile, and upload before you can launch the debugger and check if the result corresponds to your expectations.

Conclusions

Don’t fall for a misconception! Nextion HMI and Open Nextion are completely different things. Open Nextion is NOT intended to replace the classic Nextion HMI. The Genius series HMI and the new Open Nextion programming model are, as I wrote already here, a completely separate product line for power users who need additional functionalities like (among others) extended I/O, Bluetooth, and Wifi. The price which you pay for this additional functionality and liberty is a much more complex programming model where much more development work has to be done.

If you are comfortable with the classic Nextion HMI, combined with the all-in-one, very convenient and easy to learn Nextion Editor and optionally an easy to program external MCU, and if this setup fits your needs, there is absolutely no reason to switch to Open Nextion – please keep doing your good work with the Discovery, Intelligent, and Edge series with confidence, using the Nextion Editor!

But if you are a power developer who felt always limited by the Nextion Editor and its proprietary programming language, AND if your project requires a small and compact setup with for example Wifi, or Bluetooth without an external MCU, and if you don’t fear using professional development tools because you are already used to work with these, Open Nextion opens you a whole new world.

One more thing: Besides the email feedback by some of my readers, I (as a Nextion consultant and technical writer) have not much visibility on what my readers do and want. That’s why I suggest that you use always THIS LINK when ordering Nextion HMI or Open Nextion and accessories. Not because of the few referral cents I’d earn with that, but to see what devices my readers do order, so that I can better adapt the content of my blog to your needs.

Last, but not least

You have any questions, comments, critics, or suggestions? Just send me an email to thierry (at) itead (dot) cc! 🙂

And, by the way, if you like and you find useful what I write, and you are about to order Nextion stuff with Itead, please do so by clicking THIS REFERRAL LINK! To you, it won’t forcibly make a change for your order but on some products, you may even get a 10% discount using the coupon code THIERRYFRSONOFF. In ever case, it will pay me perhaps the one or the other beer or coffee. And that will motivate me to write still more interesting blogs 😉

Thank you for reading and happy Nextioning!

In last week’s blog, we started installing the free VS Code IDE and to add the ESP IDF extensions. It’s a long process at the beginning, but almost everybody who moved from the Arduino IDE to VS Code feels that the latter is more mature, flexible, and powerful. So, we too, we want to benefit from it to get the maximum out of the new Open Nextion Genius series and we complete everything, today!

The first startup of VS Code after installing the ESP IDF extension

After we installed the ESP IDF extension, we are invited to select the current ESP IDF version.

… but clicking on the corresponding button gives us an error message:

This helps us understanding an important thing: The ESP IDF extension in VS Code allows us to adjust the needed or required ESP IDF version project-wise or folder-wise, which will allow us in the future to handle multiple projects with different ESP IDF version to maintain a maximum of compatibility. That’s amazing! We could now create and open an empty project folder, just to see how to configure the ESP IDF version but that’s slightly out of scope of this blog. Let’s rather download the Open Nextion example projects for the ONX4832G035 (that’s the one I have actually at hands) from here. The example programs for the ONX2432G028 can be downloaded here.

Order the Open Nextion Genius series at an incredible introductory price

Before I’ll forget it at the end, let me mention that actually, there is a 35% introductory discount: The ONX2432G028 is only $19.44 instead of $29.90 and the ONX4832G035 only $22.69 instead of $34.90. Once you have started your order by using one of the product links provided in this blog, you may afterwards add the coupon code THIERRYFRSONOFF to get an additional 10% discount! Don’t thank me, just click to order… 😉

Now that we have downloaded the example code .zip file…

… let’s extract it in an appropriate place. For example, in your “Documents” folder, create a sub-folder named “Open Nextion” and move the downloaded .zip file there. Extract it as in the following picture.

When done, you should see the 9 demo projects as follows:

Now, let’s switch back to VS Code and let’s open the 01_touch_test folder with “File” -> “Open folder” and navigate there and confirm with the “Select folder” button. We’ll be greeted with a security warning about trusting the actors of the files in the folder. Check the “Trust the authors of all files in the parent folder ‘ONX3248G035′” and confirm by clicking the “Yes, I trust the authors” button.

Now that the folder is open, we see that there is already a sdkconfig file, thus, there should be no need to do additional configuration steps and we will try to build the project directly by clicking the wrench icon in the (bottom) status bar.

Now, we take a break while the compiler and linker do their work:

Since it’s the first time we compile a ESP IDF project, a huge number of dependencies have to be processed and many firmware modules have to be precompiled – time to get a coffee… Meanwhile, I saw a few warnings to fly through the Terminal tab but I decided to ignore them for the moment… ok… finally, the build failed with 6 “problems”. Two of them are warnings which we might ignore for the moment but there remain 4. Two of them, the missing i2c_master.h and the first error in the esp_lcd_st7796u library seem to be true problems, the other two only following. Perhaps, we should have read the readme file before… 🤔

And, in fact, the README file tells us the following:

# ESP32S3-NEXTION-EXAMPLE

This directory contains example projects for the ESP32-S3 development board (ONX3248G035), 
covering peripherals such as LCD touch, camera, audio, SD card, Wi-Fi, and battery. For details of each example, 
see the README in the corresponding example folder.

> Note: This project was developed with ESP-IDF 5.4.1. It is recommended to use ESP-IDF version >= 5.4.0

What we did install by default was ESP-IDF 6.0.0. Sure it’s >= 5.4.0, but it’s a major version jump where system libraries might have been modified (which would explain the library errors). Thus, let’s go back to the installation manager and let’s add ESP-IDF 5.4.4…

Once done, we may switch the ESP IDF version to 5.4.4 in VS Code…

… and launch the build process again:

Well, this time, the build did work!

Thus, we check (also in the bottom status bar) if the correct com port and the upload method (UART) is set. You may also click on the ESP IDF icon in the left sidebar and then on the corresponding function in the menu. Then, let’s flash, and -suspense – it works!

Phew, that was long… but it was worth it! Now, we are already familiar with most struggles which can happen. And the next project will already go easy-peasy. Next week, we’ll look at some of the other demo programs – stay tuned!

Last, but not least

You have any questions, comments, critics, or suggestions? Just send me an email to thierry (at) itead (dot) cc! 🙂

And, by the way, if you like and you find useful what I write, and you are about to order Nextion stuff with Itead, please do so by clicking THIS REFERRAL LINK! To you, it won’t forcibly make a change for your order but on some products, you may even get a 10% discount using the coupon code THIERRYFRSONOFF. In ever case, it will pay me perhaps the one or the other beer or coffee. And that will motivate me to write still more interesting blogs 😉

Thank you for reading and happy Nextioning!

In last week’s blog, I walked you through all the necessary steps to develop simple projects with Open Nextion for the new Genius Series HMIs with the Arduino IDE. While the Arduino IDE is a great tool for beginners, has well improved over the last years, and is very easy to start with, it’s far from being “grown up”, having weaknesses when it comes to handle large projects and re-using your own custom code and libraries. And using it with Espressif’s ESP32 sets another hurdle, here: When you add the ESP32 support via Arduino’s Board manager, it conveniently installs and maintains (in the background) the required toolchain and hardware support, but, although provided by Espressif, it remains a subset and might sometimes be behind Espressif’s own tool, the ESP IDF. So, why wouldn’t we simply use the latter directly? We could, but most of us are not the hardcore “bare metal” style embedded developers, writing code and header files in a simple text editor and moving them into the (hopefully) right directories, able to interpret cryptic compiler errors correctly and fixing our stuff accordingly, but we like a cosy IDE, and preferably one which covers all our needs, be it embedded development for different MCUs, or, for example web development. And we want nevertheless access to the full power of Espressif’s framework! That’s where the free VS Code, an abbreviation for Visual Studio Code, IDE comes in. Its modular structure allowing plugins for tens of different programming languages and for hundreds of different CPU technologies and toolchains makes it the preferred tool for many advanced hobbyists and a huge part of professional developers (at least those who don’t use Eclipse…). Even developing projects for the good old Arduino AVR 8bit MCUs is raised to a new level by installing the PlatformIO plugin. But today, we’ll see how to install and setup VS Code as a convenience layer and remote control for the ESP IDF.

Step 1: Install VS Code (if you haven’t yet)

You may download VS Code for free from https://code.visualstudio.com/Download, just select your operating system (Windows, Linux, or Mac). After downloading, start the installer and go through the usual installation steps with “OK”, “Next”, etc. installing it with the default configuration options.

And now, it’s the big moment to launch it for the first time! Since in a first step, we won’t use AI (still relying on our natural intelligence 😉), we select “Continue without signing in”, then we select a theme (to taste, but “Dark 2026” looks very nice). In the next window, we won’t install any Extensions for the moment, so, it’s simply “Continue”. And “Get started” in the last window.

Finally – tadaa – we have VS Code up and running, the first step is accomplished:

Step 2: Add the ESP IDF support

Now, we’ll have to install the ESP IDF extension for VS Code. For Mac and Linux, there are additional prerequisites like installing libgcrypt, glib, pixman, sdl2, libslirp, dfu-util, cmake, and python in MacOS using homebrew, and a much longer list of system libraries, depending on the Linux bistro. Please find all the details by clicking here. We’ll move on for now with Windows, which does not require any prerequisites. It’s time to open the extension manager in VS Code which is in the left sidebar by clicking the icon with the 4 boxes. In the search field on top of the just opened extension sidebar, enter “ESP-IDF” and wait a few seconds. The first search result should be “ESP-IDF by Espressif Systems” and clicking on it should reveal all details as shown here:

Now click on “Install” and confirm in the next dialog that you trust the publisher. Once the extension active, it’s time to follow the two simple steps to install the ESP-IDF itself and to configure it as shown on the screen:

First, we launch the ESP-IDF Installation Manager with the corresponding button. If you get an error message telling you that the executable could not be found, select “GitHub” in the top menu which just popped up. Afterwards, the installation of the installation manager will be almost automatic and it will open in a new window:

And, in opposite to what they said in the doc, there is a prerequisite missing, even in Windows: Git… But that’s not a problem, we simply click on “Install Prerequisites automatically”:

This accomplished, we click “Start Easy Installation” and then “Start Installation”:

This will take some (much long) time and we’ll leave it at it for today. Next week, when everything will be installed, we move on and load our first demo project!

Last, but not least

You have any questions, comments, critics, or suggestions? Just send me an email to thierry (at) itead (dot) cc! 🙂

And, by the way, if you like and you find useful what I write, and you are about to order Nextion stuff with Itead, please do so by clicking THIS REFERRAL LINK! To you, it won’t forcibly make a change for your order but on some products, you may even get a 10% discount using the coupon code THIERRYFRSONOFF. In ever case, it will pay me perhaps the one or the other beer or coffee. And that will motivate me to write still more interesting blogs 😉

Thank you for reading and happy Nextioning!

Welcome to the new world of Open Nextion – a new and powerful generation of HMI screens by Nextion with more features on one side and a new programming model on the other side. In this blog, I have already shown the most important new features, but your feedback showed me that there are two specific points to address. First, no, Open Nextion will NOT replace the classic Nextion HMI screens! It’s an extension of the product range. While the classic Nextion HMI with the WYSIWYG Nextion Editor and the simple and hardware independent ASCII-based wired serial protocol will continue to cover a multitude of industrial, automotive,  and automatisation applications, the Open Nextion environment with the Genius series HMI adds new application fields, especially thanks to its wireless connectivity. The price which we have to pay for that is a new more hardware-oriented programming model since the new faculties exceed the convenience of the Nextion Editor. Second point to retain from your valued feedback is that despite the creation of an excellent Wiki by my colleagues, some of you reported struggling with setting up the new Open Nextion development environment. That’s why I decided to walk through that Wiki, especially the Arduino variant, and to take you with me on this travel.

Step 1 – Downloading and installing the Arduino IDE

This should be pretty straightforward, since installing the Arduino IDE on whatever platform (Windows, Mac, Linux) has become a common task among developers for more than 10 years, thus, let’s make it short: Go to the Arduino download page and download the most recent version for your operating system.

After downloading the installer file, open it to launch the installation of the Arduino IDE.

At the end of the installation process, launch the Arduino IDE and you have already accomplished the first step. It might ask you for some patience, since the Arduino IDE will auto-update some of its libraries, modules and additional tools and drivers at the first launch. When dialog boxes pop up, asking you for network access and consent for the installation of add-ons, just click “yes”.

Step 2 – Making the Arduino IDE ready for ESP32

The ESP32 MCU, used in the Genius Series, is not a genuine Arduino. Thus, we’ll have to add an extension to the Arduino IDE to make it compatible with this processor. For this, we do to the File menu and select “Preferences”. Under “Additional board manager URLs”, add https://espressif.github.io/arduino-esp32/package_esp32_index.json and click “OK”.

Next, go to “Tools” -> “Boards” -> “Boards manager”, enter “esp32” in the search field, locate “esp32 by Espressif Systems” in the results and click “install”. Be prepared to taking this some time, it’s a huge package.

After accomplishing this step, we are almost up and running.

Step 3 – Establish the communication

The Genius series use a CH340K USB to serial adapter chip. Thus, the Arduino IDE might not see your Genius when you connect it via USB. In that case, simply install the driver from here, restart Windows and launch the Arduino IDE again.

Step4 – Write and upload your first ESP32 program

For the moment, and for the first test, we’ll leave the LCD and touch part aside. We’ll just write a simple “hello world” style sketch like this one:

uint32_t i=0;

void setup() {
  Serial.begin(57600);
}

void loop() {
  Serial.print(i++);
  Serial.println(": Hello, Open Nextion world!");
  delay(1000);
}

Now, select “ESP32S3 Dev Module” as your board and the corresponding COM port as you would for each other Arduino, compile and upload the sketch, leaving all other settings in the “Tools” menu at their default values (only for the moment!).

Finally, you should open the serial monitor to check if every second, a new line with an increasing number and the text “Hello, Open Nextion world” appears. If this is accomplished, your hardware and system setup is done successfully.

// ToDo…

To make full HMI projects and to use not only the LCD and the Touch controller, but also Wifi, Bluetooth, etc., we’ll need to install and to include more libraries. The next steps for users of the Arduino IDE are thus defined and I will continue to blog about these topics, step by step. On the other side, we won’t neglect users who prefer the ESP-IDF or VS Code as their development environment and there will be similar blogs for these. So, everybody, stay tuned, please !

Last, but not least

You have any questions, comments, critics, or suggestions? Just send me an email to thierry (at) itead (dot) cc! 🙂

And, by the way, if you like and you find useful what I write, and you are about to order Nextion stuff with Itead, please do so by clicking THIS REFERRAL LINK! To you, it won’t forcibly make a change for your order but on some products, you may even get a 10% discount using the coupon code THIERRYFRSONOFF. In ever case, it will pay me perhaps the one or the other beer or coffee. And that will motivate me to write still more interesting blogs 😉

Thank you for reading and happy Nextioning!

As we saw in last week’s blog that the new Open Nextion GENIUS series HMI had a different programming model, not longer relying on the Nextion Editor but on your favourite development environment on Windows, Linux, or Mac, I promised, too, to not to drop my support for the vast majority of users, working happily with the Nextion Editor. Long-term readers (yes, this is my 200th Nextion Sunday Blog 🎂 🥳 ) have seen some of my screenshots over the years, clearly indicating that I’ve been always working on a Mac. Moreover, as I do not only and exclusively work for Itead/Nextion, I’m not always on my lab desk when I need to access my Nextion Editor, for example if a reader sends me an email and I need to check quickly their code for bugs. Thus, today is the moment to share my years long experience with running the Nextion Editor on a Mac and even on accessing it remote.

First, a few basics

All modern operating systems have one thing in common: They make partly abstraction of the hardware, so that a user program does most times not longer interact directly with the peripherals of the CPU, like the hard drive, the graphics and sound card, or the USB ports, but addresses them through APIs and drivers provided by the respective OS. Moreover, the operating system provides many resources which are common to most programs like resizeable windows, dialogs, menus, and much more, so that the developers of a program do not to have to reinvent the wheel each time, but they pick these from the integrated libraries and frameworks. Sometimes, to realise more complex functionalities, additional libraries and frameworks may be user for a program, that’s the moment where it cannot longer be distributed as a single executable file, but it needs a complex setup routine to install and register these additional tools in the right place.

So, a program written and compiled for Windows (.exe file) depends strongly on the presence of a Windows OS to be able to interact with your CPU, your screen, your mouse, your keyboard, etc. For other functionalities, additional libraries (.dll files) have to accompany it. I the same way, programs for Linux or MacOS (which is based on BSD Unix) come as executable .bin (binary) files and are are accompanied by static library files (.lib) and dynamic libraries (.dylib), the equivalent of a .dll in Windows. You can imagine a modern computer system built from Hardware, peripherals and software as a gear box or a clock movement where all gears have to have the correct size and place to make the thing turn round without blocking. And that’s the reason why you can’t simply launch an .exe file on a Mac or a Linux computer, and why a Windows machine can’t start a .bin file. It’s all about form and dependencies.

Why the simplest and totally free way which does not longer work

With older and simpler versions of the Nextion Editor, before the Intelligent series HMI and the accompanying multimedia functions were introduced, things were still relatively simple: You could install the free and open source WineHQ on your MacOS or Linux machine with an Intel CPU. WineHQ is a compatibility layer, basically consisting of hundreds of .dll files which translate all elementary Windows system calls by a Windows executable into the corresponding system calls of the underlying POSIX based OS (Linux, macOS and BSD). But that alone was already not sufficient since the Nextion Editor uses also the .NET framework 3.5 which goes far beyond elementary Windows functionality. So, you had also to install the Mono framework to emulate these functions. Add a registry hack to re-route the serial port and you were done.

Naturally, this just-in-time emulation ran a bit slower than on a native Windows system, because every command had to be translated but one could work well with it. This only came to an end when the Nextion editor was extended with all the multimedia functions, and the additional video tools. All these rely on Windows’ integrated DirectX 9 library/framework which could not be added as a complementary module because parts of it were buried deeply in the Internet Explorer. Neither DirectX nor the Internet Explorer were open source, that’s why up to today, there is no fully working emulator for these available. So, this path is cut for some years, already.

You might ask, why does the Nextion editor still rely on older technologies like .NET 3.5 and DirectX 9 ? The answer is simple: Nextion wants its editor to be useable in the whole world, even in regions where many users are still using Windows XP or 7. And since, on the other side, all the required components come still with Windows 11 although the Internet Explorer has been replaced by Edge, everything is kept for the moment to provide a maximum of backwards and forwards compatibility.

From Windows emulation to virtualisation

Instead of adding an additional emulation layer between Linux/MacOS and a Windows application like WineHQ does, virtualisation uses functionalities of modern CPUs to push the currently running Linux or MacOS a bit aside to allow the hypervisor partly direct access to the hardware. This allows to share the graphics card, the mouse, the keyboard between multiple operating systems at the same time, and to re-distribute dynamically the overall number of CPU cores and the available RAM. There are just a few hurdles:

1.) The price. Professional virtualisation solutions like Parallels ® , or VMware ® are incredibly powerful and allow to do many things cross-platform and cross-OS. But they are expensive, far beyond the budget of a hobbyist (or a freelance blogger). The free and open source VirtualBox is complicated to install and to set up and still too complex for occasional use. Then, there is the free and also open source qemu. Although its name seems to point towards an emulator, it has grown up to a virtualisation solution with optional hardware emulation. But it’s almost impossible to set up without much hassle, there are more than 60 command line options… But continue reading, please, things will get very easy.

2.) It’s still about money, because whatever virtualisation solution you take, you’ll need a Windows licence. But these are easy and cheap to get. I bought an official and legal OEM licence code for Windows 10 professional for 4$ and in the meantime, I was able to do a free upgrade to Windows 11 v25H2 without licence problems. The only thing is that when you buy a licence code only, you’ll have to download the full Windows installer ISO which is around 5GB. Hint: Start always with Win10 since even if you have a Mac with an Intel Core i3, i5, or i7 CPU and 16GB of RAM, it’s not always guaranteed that your Mac hardware meets the hardware requirements by Microsoft for installing Win11. There are naturally ways around this, as there are ways to run the recent macOS Sequoia on my iMac from 2015, but this goes beyond the scope of this blog…

3.) For the moment, this is known to be working if you have a Mac with an Intel CPU. Newer Macs with Apple Silicon (M1 to M5) CPUs require an additional emulation layer, although Windows 10 and Windows 11 versions for ARM CPUs do exist. But these, since they were not created to be so backwards compatible, they lack the required DirectX support for the Nextion Editor, so, you’ll have to stay with a Windows version for the x64 Intel/AMD CPUs.

The free and open source UTM app solves most problems

Mac users do not want to fiddle around with command line parameters. In Mac OS the command line interface is even almost hidden in the seldom used Applications>Utilities folder. Mac users want a graphical user interface where they can handle everything with a few mouse clicks. And they get it with the UTM app which can be installed in 2 ways. The first is the free download of the .dmg installer when you go on https://mac.getutm.app/ and click on “Download”. It’s free but you have to check periodically for updates. The other version (which is exactly the same) redirects you towards the App Store where you can get it for $10 (to support the project) and which will automatically update, thanks to the App Store, as soon as a new version is released.

Whatever option you choose, installation of UTM is as usual. Then launch it, click on “virtualize” since you are on an Intel Mac and want to install the Intel version of Win 10. Then, select “Windows”, set the virtual machine up for at least 4GB RAM (it’s more fluid with 6) and 2 cores which is perfectly fine for the Nextion Editor, and finally, click on “Browse…” and select the previously downloaded Win10 .iso file, let all the other settings by default as in the screenshot below, followed by “Continue” and let the magic happen!

After a few minutes and some reboots of the new virtual machine (not the Mac!), you are done and have a working Win10 (or 11) subsystem, either fullscreen or windowed on your Mac:

Next, inside the new Windows machine, download and install the Nextion Editor and you are ready to work:

And now, working remote

To access the virtual Windows machine on your Mac “from outside”, the Mac has naturally to be always on and is not allowed to enter sleep mode. The virtual Windows machine has to be started but might be minimised. Please, for security reasons, don’t rely on tools like TeamViewer or AnyDesk. Create rather a free and open source software VPN using Tailscale and install it in your virtual Windows machine and on all devices from which you want to access it. In Windows, enable the Remote Desktop access, and on the other devices install the free RDP app from Microsoft which is called “Windows App” and exists for iPadOS and macOS. Now, you can work with the Nextion Editor even from your iPad (fullscreen or windowed) when you are spending your holidays abroad…

Last, but not least

You have any questions, comments, critics, or suggestions? Just send me an email to thierry (at) itead (dot) cc! 🙂

And, by the way, if you like and you find useful what I write, and you are about to order Nextion stuff with Itead, please do so by clicking THIS REFERRAL LINK! To you, it won’t forcibly make a change for your order but on some products, you may even get a 10% discount using the coupon code THIERRYFRSONOFF. In ever case, it will pay me perhaps the one or the other beer or coffee. And that will motivate me to write still more interesting blogs 😉

Thank you for reading and happy Nextioning!

As a moderator in the Nextion user forums for more than 8 years and as your preferred author of the Nextion Sunday Blog for almost 6 years, I’ve heard many user voices: The ones who love Nextion HMI for its simplicity and robustness with the industry-standard ASCII based serial protocol, the easy to learn and event-driven programming language, and the really all-in-one Nextion Editor/Simulator/Debugger. The others who were not always satisfied because they felt limited by almost the same aspects.

Over the years, with 199 Nextion Sunday Blogs (including today), I’ve often shown how one can push the limits, building for example extended mathematical functions, bringing swipe gestures to the “smaller and simpler” series, showing optimised drawing routines, and much more, all with the “onboard tools” and the Nextion programming language, most times without the need for an external MCU. Not only in theory, but with sharing demo projects and code to learn from and to integrate all these jewels into your own projects. Don’t worry, all this will naturally continue beyond the 200th blog article!

So, my dear colleagues, the Nextion engineers in Shenzhen/China have also heard the voices of the “power users” who want an all-in-one hardware solution, which means a highly versatile graphic touch screen with a more powerful internal MCU and, the most important, more access to the functionalities of the latter. Thus, the new Nextion GENIUS series was created and brings you things like builtin Wifi, Bluetooth, USB-C, 2 UARTs, 14 GPIOs, I2C, digital microphone, speaker and camera interfaces, and much more. Please continue reading!

No worries!

Although the new GENIUS series has a different programming model (see below), all the other things which you like with Nextion remain unchanged:

Price tag: With all the new features, the abundance of RAM, PSRAM, ROM, and Flash memory, 4 times more colors, and the extended connectivity, paired with a dual core ESP32-S3 MCU, the retail price of the GENIUS series is actually below the entry-level Discovery series.

Availability: As for Nextion’s “classics”, there is a 5 Year availability guarantee – we won’t stop production or support in the near future. Reminder: The LTA for the BASIC, ENHANCED, DISCOVERY, and INTELLIGENT series runs still until 2027, for the EDGE series until 2029, and for the GENIUS series at least until 2030.

Support: The support remains equally active in parallel for the existing Nextion and the new Open Nextion series. Why “open”? – continue reading! BTW: This blog will from now on deal with one more product family without dropping the others.

A new programming model

You’ve probably already guessed it: All this new complexity can not longer be handled by the good old Nextion Editor. That means that the GENIUS series will have to be programmed in a different way. The advantage and the new freedom is that you do not longer depend on whatever proprietary firmware and protected intellectual property. Because the GENIUS series is completely open!

While still relying on the excellent Nextion hardware, you are free to use the development environment (IDE) of your choice, be it the ESP-IDF, the Arduino IDE, Eclipse, or VS-Code (with the required plugins), to taste. For the graphic side, you may rely on the mighty and open-source LVGL library for which nice WYSIWYG editors like LVGL Pro or SquareLine Studio exist. And, you are not longer limited to Windows. From now on, you can also do your Open Nextion development on MacOS and Linux!

Comprehensive Wikis for the new ONX2432G028 and the ONX 3248G035 help you through every step and come with links to demo applications.

Nevertheless, there will be a learning curve. And, more features requiring more complexity, users who are happy with the Nextion Editor and the BASIC, ENHANCED, DISCOVERY, INTELLIGENT, and EDGE series, may stay with these without problems. The GENIUS series has not come to replace things, it’s an extension to the existing product portfolio!

The Feature overview

As mentionned above, the features and the connectivity of the GENIUS series are outstanding! Here is an overview:

Isn’t that impressive ?

During the next weeks, we’ll look deeper in the one or the other detail, especially into the available range of accessories and perhaps still discover the one or the other feature.

No need to wait

You may start immediately! Click here to order the smaller ONX2432G028 and here to order the bigger ONX3248G035!

Last, but not least

You have any questions, comments, critics, or suggestions? Just send me an email to thierry (at) itead (dot) cc! 🙂

And, by the way, if you like and you find useful what I write, and you are about to order Nextion stuff with Itead, please do so by clicking THIS REFERRAL LINK! To you, it won’t forcibly make a change for your order but on some products, you may even get a 10% discount using the coupon code THIERRYFRSONOFF. In ever case, it will pay me perhaps the one or the other beer or coffee. And that will motivate me to write still more interesting blogs 😉

Thank you for reading and happy Nextioning!