Nextion has a nice series of touch displays that make a very good human machine interface (HMI) solution for embedded products. The interface combines an onboard processor and memory with a touch display. Nextion has developed a software editor to support HMI GUI development.
The Nextion HMI editor has drag and drop components to create your user interface. The display is connected via TTL serial (3V3) RX/TX and requires a 5V/GND power connection with enough current to run the display.
The device I used was part of the Basic Series, NX3224T024, which is a 2.4″, 320×240, resistive touch panel. The document is not clear on which wires are the TX and RX. I found the Nextion TX is the blue wire and the RX the yellow wire. Since the original post I have found documentation showing the interface is 3V3 compatible and will accept 5V on the RX.
For my application I needed a method for a user to configure the embedded system. Instead of using a serial port I selected the Nextion touchscreen. The application was hosted on an ESP32 and code was developed using the Arduino IDE. I found the itead library, which implemented all of the objects I needed in version v0.9.0. I had to modify some of the files in the library to work properly with the ESP32. In NexUpload.cpp I moved the include software serial #include to be within the define block USE_SOFTWARE_SERIAL (makes sense). I also had to modify the NexHardware.cpp NexInit function to assigned the hardware serial pins I used (had to move Serial1 pins due to conflict with flash control).
// NexUpload.cpp
//#define USE_SOFTWARE_SERIAL
#ifdef USE_SOFTWARE_SERIAL
#include <SoftwareSerial.h>
SoftwareSerial dbSerial(3, 2); /* RX:D3, TX:D2 */
#define DEBUG_SERIAL_ENABLE
#endif// NexHardware.cpp
bool nexInit(void)
{
bool ret1 = false;
bool ret2 = false;
dbSerialBegin(9600);
nexSerial.begin(9600,SERIAL_8N1, 32, 33); // modified for serial1 I/O
sendCommand("");
sendCommand("bkcmd=1");
ret1 = recvRetCommandFinished();
sendCommand("page 0");
ret2 = recvRetCommandFinished();
return ret1 && ret2;
}To build the ESP32 Nextion interface there are basically 5 steps after you create the HMI using the Nextion editor.
- Define objects
- Create an object listen list
- Create object callbacks (what to do on touch screen events)
- Attach callbacks to objects
- Use nexLoop to monitor the Nextion device
Defining the object requires information from the Nextion HMI editor. To define an object you need the object name, page, and id number. Watch out when editing Nextion pages, ids can change. The listen list is a NexTouch type array of pointers to the objects you created that have the events you are interested in. The callbacks are actions to take based on Nextion events (button push, release, etc.). Attaching callbacks associates the callback routine with an object and event. The object method attachPop() is used when attaching a callback for a button release.
So putting it all together. For a MIDI project I had multiple parameters that could be modified, e.g. MIDI channel number. The parameters were all numerical values so I create a change page that allowed a user to increase or decrease the value by pushing a plus or minus button. Once finished, the value was updated.
The parameter page had five objects, a title (text), value (numeric), and buttons for plus, minus, and done. The title was static and loaded with the page. The parameter value was also loaded showing the current parameter value. All objects except the title and value were setup for “Touch Release Event” to “Send Component ID”, which means when the button is pushed and then released, a serial string is transmitted with the Nextion object page, id, and name. The protocol is handled by the itead Nextion library.
Defining the objects for the parameter change page used the itead library definitions. These objects were on my Nextion page 6. The library parameters are <Object>(<page>,<id>,<name>).
// Define Nextion Objects
// page 6
NexButton minusChange = NexButton(6,4, "b1");
NexButton plusChange = NexButton(6,5, "b2");
NexNumber parameterValue = NexNumber(6,2, "n0");
NexButton setParameter = NexButton(6,3, "b0");
NexText parameterName = NexText(6,1, "t0");Next these objects were added to the listen list. The reduced version showing the page 6 objects is shown below. Remember to put a NULL at the end of the list. Note that I didn’t setup events for the parameter name or value. Only the plus and minus button that changed the parameter and a done button to set the new value were setup for events.
// Listen List
// object list for touch screen
NexTouch *nex_listen_list[] = {
// page 6
&minusChange,
&plusChange,
&setParameter,
NULL
};The call backs are the actions to perform when the event occurs for that object. For the plus and minus the parameter value is read from the Nextion object, checked against a max/min value, and updated accordingly. The Done button updates the parameter value to the current page value and returns to the calling page. Global variables were used for the min, max, and return information.
// Callbacks
// page 6
void minusPopCallback(void *ptr) {
uint32_t number;
parameterValue.getValue(&number);
if (number > minParameterValue)
parameterValue.setValue(number - 1);
}
void plusPopCallback(void *ptr) {
uint32_t number;
parameterValue.getValue(&number);
if (number < maxParameterValue)
parameterValue.setValue(number + 1);
}
void setParameterPopCallback(void *prt) {
uint32_t getValue;
// update variable that is changing
parameterValue.getValue(&getValue);
*modifyParameter = (int)getValue;
// go back to last page
returnPage->show();
// more stuff based on returning page
}Attaching the callbacks for the release event uses the attachPop() object method. The parameters are the callback function and object. If I had setup the touch event for a push, then the method is attachPush().
// Attach Callbacks
void setupNextion (void) {
// page 6
minusChange.attachPop(minusPopCallback, &minusChange);
plusChange.attachPop(plusPopCallback, &plusChange);
setParameter.attachPop(setParameterPopCallback, &setParameter);
}Finally, once everything is setup and initialized, use nexLoop with the listen list to handle the interface to the Nextion touch screen. The nexLoop polls the serial interface and is non-blocking, so my listener was setup as a task.
// Monitor Nextion Interface
// task
void getControl(void * parameter) {
for(;;) {
nexLoop(nex_listen_list);
vTaskDelay(50 / portTICK_PERIOD_MS);
}
}Overall the interface was very successful and I was happy with the results. The project had 7 different pages that required almost 900 lines of code. I’m sure there are more efficient ways of coding this interface, which I will discover as I continue to work with Nextion touchscreens.
