
Closed
Posted
Paid on delivery
I am building an embedded system that runs on both an Arduino-class MCU and an STM32, and I need firmware and a touch-enabled GUI developed in parallel. The core code will be written in C and must handle the usual peripherals—UART, SPI, I2C, ADC, PWM, timers, interrupts and DMA—while talking cleanly to a Nextion as well as a DWIN display over UART. On the visualization side the screen has to render real-time waveforms and scrolling graphs without noticeable lag, plus a touch menu that lets the user configure sensor calibration parameters stored in flash. I will supply the existing schematic, the sensor datasheets and a rough wireframe for the HMI; you will turn that into production-ready firmware, the display project files and documented drivers. The workflow is Git-based. You can work in STM32CubeIDE or Keil for the STM32 part, Arduino IDE or PlatformIO for the AVR/ARM Arduino board, whichever lets you keep the codebase clean and portable. I will test with ST-Link and a logic analyzer, so please leave clear hook points for debugging and provide a short README that maps pins, timers and DMA channels. Deliverables • Compilable source for both targets, committed to my Git repo • Nextion and DWIN project files with assets embedded • Build instructions and a brief test procedure that reproduces waveform and graph updates at the agreed sample rate • A changelog of any hardware-level tweaks you recommend after integration testing I am looking to kick this off immediately; if you have 1-3 years of hands-on experience and can demonstrate past work with live data on these displays, I would love to see it.
Project ID: 40778250
24 proposals
Remote project
Active 4 days ago
Set your budget and timeframe
Get paid for your work
Outline your proposal
It's free to sign up and bid on jobs
24 freelancers are bidding on average ₹9,644 INR for this job

Hi, I have experience in designing Circuits and can complete your project. I have expertise in the following: 1- Designing schematic and PCBA 2- Ordering the PCBA and getting boards manufactured. 3- Writing firmware for the PCBA to make sure everything works as expected. 4- I can also develop smartphone apps to communicate and control the hardware. If you wish we can discuss in chat. Thank you.
₹7,000 INR in 7 days
7.5
7.5

Our hands-on work with ESP32/STM32 firmware and custom IoT hardware directly matches your dual-target embedded system. I can develop clean C firmware around Arduino and STM32 microcontrollers, including the peripheral and low-level embedded systems work your design requires: UART, SPI, I2C, ADC, PWM, timers, interrupts and DMA. My background in electronics, firmware development and sensor-connected hardware is also relevant to the Nextion and DWIN integration, live sensor data, touch-driven configuration and flash-stored calibration values. I can provide portable, compilable source, documented drivers, display project assets, Git-ready organization, and clear pin/timer/DMA mapping with debugging hook points suited to ST-Link and logic-analyzer testing. I would be glad to apply this embedded and IoT experience to deliver the firmware, GUI files, build documentation, waveform test procedure and integration changelog your project needs. Choose me to build a clean, maintainable foundation for both targets.
₹7,000 INR in 7 days
5.2
5.2

Hi, Greetings! I am interested in working on your project. Could you please share the design details and technical requirements so we can discuss the project scope and key parameters in detail? I look forward to working with you. Thank you! Shivkant
₹20,000 INR in 7 days
4.7
4.7

I am an Embedded Systems Engineer with hands-on experience in ESP32, STM32, Arduino, IoT solutions, PCB design, and industrial automation. I specialize in developing complete hardware and firmware solutions from concept to production. My experience includes sensor integration, wireless communication, data logging systems, Ethernet and Wi-Fi connectivity, MQTT communication, cloud integration, and custom PCB development. My expertise includes: • ESP32 Firmware Development • STM32 Firmware Development • Arduino Projects • PCB Design using Altium Designer • IoT Solutions (Wi-Fi, BLE, Ethernet, MQTT) • AWS IoT Integration • Sensor Integration and Calibration • Data Logging Systems • Industrial Automation Projects • Embedded Linux Development • Serial Communication (UART, RS485, Modbus) • I2C, SPI, CAN Bus Development • Product Prototyping and Testing Recent project experience includes: • ESP32 Ethernet-based monitoring systems • BLE sensor networks with multiple wireless nodes • Engine dynamometer data acquisition systems • Industrial pressure, temperature, RPM, and level monitoring systems • MQTT-based cloud monitoring solutions • Custom PCB design and manufacturing support I focus on delivering reliable, well-documented, and production-ready solutions while maintaining clear communication throughout the project.
₹35,000 INR in 15 days
5.0
5.0

Hi, I can help develop your Arduino and STM32 firmware with real-time waveform visualization, touchscreen controls, sensor calibration, and Nextion/DWIN display integration. The best approach is to first review your schematics, MCU specifications, sensor datasheets, and HMI wireframes. I'll then structure the firmware into reusable C modules with platform-specific drivers for UART, SPI, I2C, ADC, PWM, timers, interrupts, and DMA. For the GUI, I'll focus on efficient UART communication, non-blocking updates, smooth waveform rendering, scrolling graphs, and touchscreen menus with flash-based calibration storage. Deliverables will include: - Modular embedded C firmware - Arduino and STM32 integration architecture - Peripheral drivers and interrupt handling - Nextion and DWIN display interfaces - Real-time waveform and graph updates - Touchscreen calibration menus - Flash-based parameter storage - Git commits and documented source code - Pin, timer, and DMA mapping - Build instructions and testing guide I'll prioritize responsive display updates, reliable sensor communication, and maintainable firmware. My proposed ₹12,500 covers the initial integration milestone, with full dual-target development scoped after reviewing your hardware. Could you share the exact MCU variants, display models, and required waveform sample rate? Best regards Ankit
₹12,500 INR in 7 days
4.2
4.2

We at HardFault are excited about the unique challenges your embedded system project presents, particularly the dual requirement for compiling within Arduino IDE and STM32CubeIDE while ensuring seamless GUI interaction with Nextion and DWIN displays. Our experience with custom PCB design and firmware development for STM32 and ESP32 makes us well-suited to tackle your need for efficient peripheral handling and robust GUI integration. With our team's combined expertise, you gain the advantage of faster turnaround and extensive skill coverage, particularly in IoT connectivity and advanced sensor interfacing. Our collaborative approach will ensure that we can adapt quickly to any hardware-level tweaks required during integration testing. We suggest kicking off by reviewing your existing schematic and sensor datasheets to streamline the development process. We're curious to know if you have any specific waveform sample rates in mind to ensure the touch menu configurations align perfectly with your expectations?
₹9,610 INR in 20 days
4.0
4.0

Hi, This project aligns directly with my work — I’ve shipped production firmware for STM32 and Arduino-class targets covering exactly the peripheral stack you listed: UART, SPI, I2C, ADC, PWM, timers, DMA-backed transfers, and interrupt-driven I/O. For displays, I’ve integrated both Nextion and DWIN over UART in live products, including real-time waveform rendering and scrolling trend graphs at sample rates up to 500 Hz with no visible lag. I handle the full loop — frame packing, ACK parsing, page/component state machines, and flash-backed config persistence. My toolchain is PlatformIO for AVR/ARM Arduino builds and STM32CubeIDE (HAL + LL) for the STM32 side, committed to Git with clean board-support abstraction so core logic compiles against both targets. I leave SWD hook points, ITM trace stubs, and logic-analyzer-friendly GPIO toggles baked in from the start — not added later. Given your schematic, datasheets, and HMI wireframe I can deliver: Compilable, documented source for both targets Nextion .HMI and DWIN DGUS project files with embedded assets Pin/timer/DMA mapping README + test procedure Hardware tweak changelog post-integration I can start immediately. Happy to walk through a relevant past waveform project on a quick call first if that helps. XinTian
₹7,000 INR in 7 days
3.4
3.4

Hi, I can build both firmware targets in C with clean drivers for UART, SPI, I2C, ADC, PWM, timers, interrupts and DMA. That covers the Nextion and DWIN HMI projects: real-time waveforms and scrolling graphs (DMA-driven ADC, so the screen never lags), and a touch menu for sensor calibration with values kept in flash. I'll work in STM32CubeIDE and PlatformIO, in your Git repo with small, reviewable commits, and documented drivers at the end. Send the schematic, datasheets and HMI wireframe and I'll share a milestone plan within a day. 5.0 rating and 100% completion here. Akshay
₹4,000 INR in 10 days
3.4
3.4

Hi, I have 16 years of experience in embedded systems, electronics R&D, STM32, Arduino, and real-time firmware development. I can develop modular C firmware for both MCU platforms, integrating UART, SPI, I2C, ADC, PWM, timers, interrupts, DMA, and Nextion/DWIN UART displays. My approach includes: - Portable drivers and hardware abstraction for both targets. - Responsive touch menus with calibration parameters stored in flash. - Real-time waveforms and scrolling graphs optimized for low latency. - Nextion and DWIN HMI project files and assets. - Debug hooks, documented pin/timer/DMA mappings, and Git integration. - Build instructions, README, and repeatable testing procedures. My relevant experience includes STM32/ESP32 development, sensor acquisition, calibration workflows, biomedical electronics, and hardware–firmware integration. I can review your schematic, sensor datasheets, display models, and wireframe to define the architecture and confirm achievable sampling and refresh rates before implementation. Best regards, Subhash Suman Embedded Systems | STM32 | Arduino | HMI | Firmware Development
₹20,000 INR in 7 days
3.0
3.0

Hi, Embedded C developer with 9 years of experience, 7 on automotive ECU firmware at Bosch. Fit: • UART, SPI, I2C, ADC, PWM, timers, interrupts and DMA in production C • Flash storage for calibration data (I've written flash drivers for bootloaders) • Git workflow, a README mapping pins/timers/DMA, and debug hooks for ST-Link Approach: • Shared C core with a thin port per board (STM32CubeIDE + PlatformIO) • One display interface with Nextion and DWIN backends over UART • DMA-driven ADC sampling feeding the graphs, to keep the UI smooth Honest note: I haven't used Nextion/DWIN specifically. Their UART protocols are simple, and I'll prove the waveform rate in the first milestone. Questions: • Target sample rate and number of channels? • Which STM32 and Arduino boards? Hau
₹10,000 INR in 10 days
2.9
2.9

Hi, there I recently delivered a dual‑MCU firmware for an industrial controller that ran on an ATmega328P and an STM32F103, integrating UART, SPI, I2C, ADC, PWM, and DMA, while driving a Nextion and a DWIN display. I implemented a real‑time waveform renderer using a double‑buffered circular FIFO, achieved 120 Hz scrolling without UI stutter, and built a touch‑menu that writes calibration data to flash via a lightweight EEPROM abstraction. Challenges included synchronizing DMA transfers between two cores and minimizing ISR latency; I solved this by using a priority‑based scheduler and a dedicated DMA completion interrupt that signals the GUI thread. I am planning to structure the project with a common C library for peripheral drivers, abstracted through weak symbols so that each MCU can provide its own hardware layer. Peripherals will be initialized via a configuration table parsed from flash, allowing the same build to target either the Arduino‑class AVR or the STM32. For the GUI, I will create a modular widget library that renders onto a framebuffer mapped to the display’s RAM, using an interrupt‑driven DMA to push frames at the required sample rate. A touch handler will debounce and translate coordinates into calibration commands, persisting them with a custom flash API.
₹7,000 INR in 7 days
2.6
2.6

Embedded Systems Development with Arduino and C/C++ is a core part of my engineering work, making me well suited to build portable firmware for your Arduino-class MCU and STM32-based system. My background in electronics, microcontrollers and complete system integration supports the peripheral drivers, sensor interfacing and production-focused embedded code your project requires. I can develop clean C firmware around UART, SPI, I2C, ADC, PWM, timers, interrupts and DMA, while applying my Arduino and embedded-systems experience to the Nextion and DWIN UART display integration. My electronics expertise also helps connect the firmware to your schematic and sensor hardware, including calibration storage, real-time signal visualization and debugging-oriented integration. I will provide organized source code, display project assets, documented drivers, build instructions, testing notes and the requested pin/timer/DMA mapping. Choose me to turn your embedded design into a reliable, maintainable firmware and GUI implementation.
₹5,500 INR in 7 days
2.5
2.5

Hi, PURE CODE here, from Saudi Arabia. Building your Arduino STM32 GUI firmware comes down to one thing: a device that behaves the same in the field as on the bench. I'm a senior embedded and electronics engineer with 10+ years of experience working with Arduino, STM32, Embedded Systems and C Programming. For your Arduino STM32 GUI firmware, the real challenge is timing, power and real conditions. A common issue: testing only on the bench, so problems appear once the device runs in real conditions. My plan: first, review the schematic, pin map and timing requirements. Then, write the firmware in small modules, each tested on the board. Finally, test on the real hardware under load, power loss and bad signal. I'd start with the core firmware features as phase one. I've done firmware work in Arduino, so I check early for timing issues and power drops. A few questions to better understand the scope: 1. Does the device run on battery? Battery power shapes the whole firmware design. 2. Use the vendor HAL except where timing is tight? I'd recommend it, it's easier to change later. 3. Who uses the device, engineers or everyday users? Everyday users need clear status lights and defaults. I can start right away. Happy to go over the details here in chat and suggest the best approach. Looking forward to hearing from you, PURE CODE
₹12,500 INR in 3 days
2.2
2.2

Hi, this is the kind of project I enjoy. I write C firmware for STM32 and Arduino-class boards, covering UART, SPI, I2C, ADC, PWM, timers, interrupts and DMA, and I keep the hardware layer separate from the application code so the same logic runs cleanly on both targets. For the displays, I’d drive Nextion and DWIN over UART with DMA-based transfers, so live waveforms and scrolling graphs update smoothly without blocking the main loop. The touch menu for sensor calibration would save to flash with validation and a safe fallback to defaults. You’d get compilable code in your Git repo (STM32CubeIDE and PlatformIO), the display project files with assets, a README mapping pins, timers and DMA channels, debug hooks for your ST-Link and logic analyzer, and a short test procedure that reproduces the waveform updates at your sample rate. I only hand over tested, finished work, and I’ll log any hardware tweaks I’d recommend after integration testing. I can start right away. Could you share the schematic, the target sample rate and the wireframe so I can confirm scope and timeline?
₹1,500 INR in 1 day
0.0
0.0

Hi! I’m Thanos. I'm new to this platform but bring solid experience from my previous projects in embedded systems development. I understand you're looking for firmware and a touch-enabled GUI for both an Arduino-class MCU and an STM32. I can help you create the production-ready firmware that handles peripherals like UART, SPI, and DMA while seamlessly interfacing with the Nextion and DWIN displays. The real-time waveforms and scrolling graphs will be rendered smoothly, ensuring a responsive user experience. With over three years of hands-on experience in C programming for embedded systems, I have successfully developed similar projects, ensuring clean and portable code across various platforms. I would love to discuss how I can bring your vision to life. Could you share more details about the specific sensor calibration parameters you want to configure through the touch menu?
₹4,400 INR in 7 days
0.0
0.0

Hi there, I can help you develop the firmware and touch-enabled GUI for your Arduino-class MCU and STM32 embedded system. How I will approach this project: 1. Core C Programming: Clean, structured C code handling all necessary peripherals (UART, SPI, I2C, ADC, PWM, timers, and interrupts) cleanly. 2. Touch-Enabled GUI Integration: Seamless communication and smooth interface handling with Nextion and DWIN displays. 3. Parallel Architecture: Well-managed execution flow ensuring both the Arduino-class MCU and STM32 communicate reliably. As an embedded systems and mechatronics engineering student with hands-on microcontroller programming experience, I am ready to start immediately and deliver high-quality code within 3 days. Let's discuss your specific display models and architecture in chat! Best regards, Kavindu
₹4,000 INR in 3 days
0.0
0.0

My hands-on background in Arduino, electronics, and embedded systems aligns directly with your dual-target firmware project. As an Automation Engineer, I work with industrial control, HMIs, PLCs, SCADA, and real-time monitoring systems, giving me a practical understanding of reliable device communication and operator-facing interfaces. I can contribute to clean, documented embedded code for the Arduino-class and STM32 targets, with attention to peripheral integration, sensor data handling, UART-based display communication, and responsive visualization. My experience with HMIs and industrial protocols such as Modbus TCP/RTU, OPC UA, Ethernet/IP, and MQTT supports the structured communication and debugging discipline your system requires. I also understand the importance of clear integration documentation, troubleshooting hooks, and maintainable code in automation environments. My focus is on delivering a dependable, well-organized firmware and GUI solution that is practical to test and maintain. Choose me to develop this embedded system with the reliability and documentation expected for production integration.
₹8,000 INR in 7 days
0.0
0.0

Hello, I can develop the portable firmware and Nextion/DWIN HMI projects for ₹8,750, targeting 21 days from an agreed kickoff with both target boards, display models and requirements confirmed. My background includes STM32, embedded C, FreeRTOS and peripheral/DMA integration. On Upwork I completed “C++ code to stream video from OV5640 to TFT display on RT1062” ($1,030, 5/5), including bare-metal firmware, live image/log streaming and clear examples. That is relevant display/data work, not a claim of an identical Nextion/DWIN project. I would separate board-specific HAL/drivers from the acquisition and application layer, implement buffered UART display protocols, and decouple sampling from graph refresh so UI traffic cannot stall acquisition. Calibration values will use validated flash records with safe defaults and controlled write frequency. Deliverables: compilable source for both targets in your Git workflow, both editable display projects/assets, pin/timer/DMA map, build README, reproducible waveform/graph test at the agreed sample rate, and a hardware-tweak changelog. I will use your ST-Link/logic-analyzer feedback for integration checks. Please share MCU/display part numbers, channel/sample rates and screen count so I can confirm the scope and scheduled start.
₹8,750 INR in 21 days
0.0
0.0

Hi, I write embedded C for STM32 and Arduino-class MCUs and can deliver the firmware and the HMI together. How I'd structure it: - A shared, hardware-independent core (sensor processing, calibration, data model) with a thin HAL layer per target: STM32 HAL/LL in STM32CubeIDE, and Arduino/PlatformIO for the AVR/ARM board. - Drivers for UART, SPI, I2C, ADC with DMA, PWM, timers and interrupts, written non-blocking so sampling never stalls while the screen updates. - Display layer behind one interface with two backends: Nextion (instruction set) and DWIN (DGUS variable/curve protocol). Real-time waveforms are pushed in batched packets (Nextion addt for waveforms, DWIN curve buffers) to keep scrolling smooth at the UART baud you choose. - Touch menu for calibration parameters stored in flash with a CRC and default fallback, so a bad write never bricks the settings. - Git workflow with small commits, a README per driver, and the Nextion/DWIN project files. I'll start by bringing up one sensor and a live graph on each display, so you can see real progress early. I'm an embedded and PCB engineer (ESP32, STM32, FreeRTOS, KiCad); my portfolio shows recent work. Which STM32 part and Arduino board are you using, and what sample rate do the waveforms need?
₹11,500 INR in 10 days
0.0
0.0

I build C firmware for AVR/Arduino-class and STM32 targets and have shipped Nextion and DWIN HMIs with live waveforms and scrolling graphs. I’ll deliver a portable C core with a thin HAL (UART, SPI, I2C, ADC, PWM, timers, interrupts, DMA), DMA-driven display updates for lag-free graphs at your agreed sample rate, and a touch calibration menu with CRC-protected flash storage. Everything goes into one clean Git repo (PlatformIO for Arduino, STM32CubeIDE for STM32), with debug GPIO pins for your logic analyzer, ST-Link support, and a README mapping pins, timers and DMA channels. You’ll also get both display projects with assets embedded, build and test instructions, and a changelog of any hardware tweaks after integration testing. I estimate about 3 weeks, committing working code at each milestone so you can test as we go. Portfolio: [add links or demo videos]. Could you share the sample rate, display models and MCU part numbers so I can start right away? My 3 years in autonomous and robotic systems include hands-on firmware development for STM32 and Arduino boards, with strong C++ and UART experience. This directly supports your portable embedded codebase, sensor communication and display integration. I also work with CAN bus, ROS and Python, giving me useful experience in real-time control and debugging. I can deliver clean, documented source, display project files and Git-ready build documentation. I would be glad to contribute to this project.
₹7,000 INR in 7 days
0.0
0.0

Noida, India
Member since Oct 20, 2026
₹1500-12500 INR
₹1500-12500 INR
₹12500-37500 INR
$30-250 USD
₹12500-37500 INR
$100-250 USD
₹1500-12500 INR
₹1500-12500 INR
$10-30 USD
$30-250 USD
$30-250 USD
₹600-1500 INR
$30-250 USD
$250-750 USD
£20-250 GBP
$1500-3000 USD
₹600-1500 INR
₹1500-12500 INR
€30-250 EUR
₹1500-12500 INR