Adding Touch Screens to Projects and Prototypes

Explore the NextGen Enhanced Series 3.2 inch resistive touch screen with eight GPIOs and four PWM pins, a 400 by 200 display, USB TTL serial, and a required ribbon cable.

Choose the NextGen enhanced 3.2-inch resistive touchscreen (400 by 240) with eight GPIOs to practice UART communication and PWM, and review its data sheet for operating voltage and current limits.

Use a Nucleo f4 series development board or any compatible board to connect a screen, leveraging the hardware abstraction layer in CubeIDE and UART communications with C functions.

Explore using a USB to TTL serial connector to connect a laptop to a touch screen, wiring VCC, ground, TXD, and RXD, and compare SD card uploads with an editor.

Use the Nextion IO adaptor (8 IO pins, 5 volts, ground) to connect the screen; orient the cable toward the PCB, pull the plastic latch, and push until it locks.

Install the action editor to program the NextGen display, download from the NextGen website, and complete a straightforward Windows installation to access the main interface.

Explore the Nextion editor interface, including pages, attributes, and page events. Learn to use the toolbox, import assets, and define fonts within resource-limited embedded systems.

Open a new Nextion project, explore page attributes and events, use the toolbox to add pages and components, and understand local versus global scope and background color.

Learn to create and add fonts with the font generator, assign font IDs, apply Arial bold 24 and Microsoft Sans Serif 16 to text boxes, and test in the simulator.

Demonstrate touch-based text box styling by changing font color and background on press, using t0 attributes such as bco and pc, with the instruction set and gpio examples.

Explore the scrolling text box by adjusting attributes, text length, and font, then observe how touch press and touch release events affect color and behavior during debugging and hitting compile.

Learn to make a number box respond to touch by updating its n0 value from 0 to 20, adjusting the font id, and changing its background color to red.

Learn to configure a regular button and a dual-state button, handle press and release to increment a value, and customize styles, colors, and images for touch screen prototypes.

Learn to send and receive on-screen data via UART from an MCU, using strings like temperature=23°C to update text boxes, colors, and sensor readings such as temperature.

Learn to send data from the touch screen via uart, enabling send component IDs, composing messages with page number, component ID, and event, including length and termination, with debugging tips.

Configure gpio zero as a push-pull output to drive an LED with a resistor, controlled by on-screen high and low buttons. Explore gpio modes: input, output, and PWM.

Set up a Nextion editor project to drive a GPIO LED with on/off buttons, font setup, color feedback, and final compile, debug, and upload to the screen.

Configure gpio zero as an input and read 0 or 1 logic values from the gpio, using a 3.3V logic level, with a timer sampling every 400 milliseconds.

Implement the project in the Nextion editor with vertical layout, sliders, and controls; configure gpio pins for pulse width modulation to drive red, green, and blue rgb leds, then compile.

Link the red LED PWM duty cycle to the slider in Nextion Editor (0–100) using PWM 5, 6, and 7 on touch move, then compile and push to the board.

Create an animated battery gauge from 0 to 100% by displaying sequential images on a non-gif screen. Use the NextGen editor to prepare the image sequence, simulate, and display.

Create an animated gauge by tying a variable to the picture value, incrementing with a timer and an if statement, and resetting at ten to loop from 0% to 100%.

Upload and test the project on the touch screen, verify baud rate connections, and confirm the animated battery and graphics work as expected.

Demonstrate building a simple battery indicator on a nuclear board and NextGen screen, showing live battery levels from 0% to 100% as the system powers on.

Plan the project with NextGen editor, simulate, push to screen, and connect via uart to the development board. Read battery levels with adc and send data to the screen.

Open the NextGen editor, create a three-page battery indicator project, add picture elements, set a black background, and animate with timers and a variable to transition to the next page.

Create page 3 in Nextion Editor with a black background and a battery indicator. Use font ID 2 for a larger percent display, then compile to verify battery level.

Transfer the program to the screen by uploading and connecting, then verify the battery indicator updates from 0 to 100 while powered by five volts and observe the ten bars.

Map battery readings from the ADC to on-screen graphics by updating the image container P5 and the value container N0 to display the current percent on the development board.

Explain how to send full strings over uart to a Nextion screen, updating the picture with p5.pic and the battery value with n0.val, via two sending functions.

Explore a code plan for sending strings and numbers to a screen using a buffer, format specifiers, and pointers, with basic memory management and image switching.

Implement functions to update the n0 value and the picture ID on the screen via UART, manage memory buffers, determine lengths, and send termination signals.

Debug a CubeIDE project to ensure zero errors and warnings, initialize a 32-bit battery variable, start ADC in DMA mode, and read values with HAL_ADC get value.

Validate ADC readings in CubeIDE, ensure zero errors, and fix a floating ADC pin that skews battery readings; the coming lecture covers the fix and saving the project.

Connect uart 6 on the nucleo board by wiring rx to tx (pc7 to pc6), power with 5 volts, boot, and test before implementing 10%, 20%, and 30% battery ranges.

Send commands from the touch screen through a development board and Midi shield to a keyboard, using two uart channels at 9600 and 31.25k baud.

Explore the project hardware: power the screen from USB to TTL at five volts, wire RX/TX across UART channels at 9600 and 31.25 baud, and use a MIDI shield.

Explore Nextion Editor basics by building multi-page navigation with touch areas and buttons, including dual-state controls that emit UART commands to a development board for a musical keyboard.

Set up an STM32 project in CubeIDE, configure two UART channels for screen and midi, set 9600 and 31250 baud, clear unused pins, initialize peripherals, build with zero errors.

Explore how screen button presses generate hex messages read and translated into MIDI note on/off via UART to a MIDI instrument, with baud rate and code mapping.

Test the project in action as the touch screen sends MIDI messages through UART to a MIDI controller and shield, showcasing opto isolation and practical control from the screen.

Use a logic analyzer to test uart communication from nextion to stm32 at 9600 baud. Then verify transmission through the midi shield to the midi instrument at 31.25 kilo baud.