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 any UART-capable development board to interface with the screen in this course, and learn simple UART communication by wiring the correct pins and sending data with a basic function.

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.

Learn how to use a ttl usb adapter in the course, using a similar device and wiring vcc and ground for touch screen projects.

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.

Discover how the Nextion IO adaptor connects the screen to gpios with an eight-pin cable (IO0 to IO7) to interface LEDs and breadboards.

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.

design and prototype a screen bezel using a 3d printed part to improve alignment, stability, and touch interaction, with optional accessories and downloadable resources.

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.

Learn the Nextion editor interface, navigate pages, toolbox, and components, and manage fonts, images, and font creation; save to virtual SD card and EEPROM settings.

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.

Explore dual state buttons and timers by resizing and positioning a button, mapping its on/off state to n0, and using a 1000 ms timer for automatic toggling.

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.

Explore the NExtion editor interface, mastering alignment, duplication, and lock controls to configure components efficiently. Learn to push projects via uart and understand sd card and simulation workflows.

Learn to use the 3.2 screen's eight gpios in input, output, pwm, and binding modes to drive an LED, change color and text of a box, and modulate an RGB LED.

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.

Connect an LED to a GPIO output with a 220 ohm resistor, use the NextGen IO adapter to link IO0 and ground, power the project, and observe LED on/off behavior.

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.

configure gpio pins as pulse width modulation outputs to drive a common cathode rgb led; vary duty cycle and optional frequency to mix red, green, and blue for color output.

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.

Test the project using pwm gpio to drive an rgb led, wiring three 30-ohm resistors, ground, and io pins to red, green, and blue.

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.

In the NextGen editor, create a new project named animated gauge, set vertical orientation, add 11 pictures on a black background, and animate by cycling picture IDs from 0 upward.

Create an animated gauge by cycling picture IDs on touch with a 1-second delay, showing progress from zero to one to two and 10%, then test and adjust timing.

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 2 in Nextion Editor by adding a black background, a battery indicator, and scrolling text with a serif 24 font, then enable touch navigation 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.

Plan and implement uart-based communication with the NextGen screen using cube ide, the uart transmit function, and the hardware abstraction layer, while configuring data strings and termination.

Develop a code plan to display battery status on a touch screen by using unsigned integers, sending percent values to n0, and updating p5 picture IDs accordingly.

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.

Open CubeIDE and configure a new STM32 project to connect a touch screen, enabling ADC with DMA in circular mode, and UART6 at 9600 baud, then generate the code.

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.

Solve unstable adc reading on stm32 nucleo by wiring a potentiometer to pa0 (adc in0) with ground, stabilizing the input and measuring battery voltage in 0–4096.

Explore ADC reading of the battery using PA0, calibrate 0–3.3V on a 12-bit scale, and build a table to map 10–80% battery ranges for code.

Develop an adc reading table for 0–1.5 volts battery input, acknowledging nonzero offsets and variability, and define ranges like 0–15 for 0%, 15–175 for 10%, 175–360 for 20% for coding.

Implement the battery ADC reading functions and associated display updates, ensure proper UART termination with 0xF3, and wire UART6 to the NextGen screen while validating with build and debug steps.

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.

Learn to display battery readings by mapping ADC values to percentages (0–15 → 0%, 16–175 → 10%, 176–360 → 20%), update the screen with send number and change picture, and debug.

Debug and test the final code by fixing errors, adjusting battery reading ranges, and ensuring the ADC data push from the board to the screen and to the outer world.

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.

Debug the Nextion Editor by navigating main, presets, and manual tuning, tune notes by tapping to set and reset, and explore info shortcuts to micro tune scales.

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.

Learn how to connect a screen to a project and send Midi instructions via uart interrupts, using a two-number code to play or stop notes with a Midi standard table.

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.