Contact person: Title: Embedded Software Engineer — ESP32 (blocks-based IDE + code generator + compiler + uploader)

Phone:Show

Email:Show

Location: sonipat, India

Budget: Recommended by industry experts

Time to start: As soon as possible

Project description:
"Overview:
We need an experienced embedded software developer (or small team) to build a cross-platform desktop application that provides a blocks workspace (drag-and-drop) and converts blocks into runnable Python and C/C++ for an ESP32 DevModule (with CH340C USB-serial). The app must be able to compile and upload code over USB serial and include a terminal for device output.

Key responsibilities

Build a blocks-based visual editor and workspace (Blockly/Scratch-like) with custom blocks for sensors/actuators and code export to Python and C/C++.

Produce libraries and code generation templates that include all necessary includes/initialization for ESP32 (ESP-IDF/Arduino/PlatformIO compatible).

Implement compile & upload pipeline (local toolchain or PlatformIO/esp-idf) and a serial terminal (logs, REPL).

Implement pin mapping and drivers per the exact mapping (see “Pin mapping” below).

Provide automated unit/integration tests and documentation for use and for extending blocks.

Deliver source code, build instructions, and a release installer for Windows/macOS (Linux optional).

Pin mapping (must be implemented exactly)

LDR: IO34

IR: IO35

Temp data: IO32

Ultrasonic trig: IO33

Ultrasonic echo: IO32 (note: same pin as temp data — candidate must propose/read/write-safe option)

Touch: IO12

OLED SCL: IO15

OLED SDA: IO13

Motor M1: IO19, IO18

Motor M2: IO5, IO17

Motor M3: IO23, IO22

Motor M4: IO21, IO16

Joystick 1: V axis IO4, H axis IO2

Joystick 2: V axis IO26, H axis IO25

Deliverables

Desktop app with blocks workspace and code export (Python & C/C++) + examples.

Code generator templates & runtime libraries for ESP32 (either Arduino core or ESP-IDF + PlatformIO support).

Compiler integration and reliable upload over CH340C (via serial/esptool or PlatformIO).

Built installers (Windows, macOS) / or portable executables.

Terminal/console showing device output and upload logs.

Unit tests, integration tests on hardware (test report), and user documentation.

Experience required

3+ years embedded firmware experience (ESP32 strongly preferred).

Proficiency with Blockly/Scratch-like editor creation or experience customizing Blockly/ScratchBlocks.

Experience integrating toolchains: PlatformIO, ESP-IDF, esptool, and serial/USB programming.

Experience with Electron (or similar cross-platform frameworks) and Node.js backend for invoking toolchains is highly desirable.

Experience writing code generators (AST → code templates) and embedding Python/C++ targets.

Good testing discipline and documentation.

How to apply — send portfolio + 1–2 links to previous block editors/ESP32 projects + estimated timeline and cost.

2) Technical spec & acceptance criteria (concise)
A. Features (required)

Blocks workspace

Drag-and-drop blocks for: digitalRead/digitalWrite, analogRead, PWM motor control, servo, I2C OLED, ultrasonic distance, joystick read, touch sensor read, IR read, color sensor (if available), delays, control flow, variables, functions.

Blocks should export to readable Python and C/C++ code, including required includes and initialization lines.

Code generation

Two backends: Python (MicroPython/ESP32 port) and C/C++ (Arduino or ESP-IDF). Candidate should propose one primary C/C++ target (PlatformIO/Arduino or ESP-IDF) and justify choice.

Generated code compiles out-of-the-box with minimal edits.

Block definitions and code templates must be editable for future expansion.

Compiler & uploader

Option A: Integrate PlatformIO for build & upload (recommended for multi-board support and cross-platform).

Option B: Support direct invocation of esp-idf/xtensa toolchain if chosen.

Upload via CH340C USB-serial using esptool or PlatformIO; must detect COM port and show progress + errors.

Serial terminal

Show device boot logs, application prints, and allow raw input to device (REPL if using MicroPython).

Support configurable baud rate.

Pin mapping enforcement

The UI should show the pin mapping and prevent conflicting assignments; when a block uses a pin reserved by another block it should warn or refuse.

Project & export

Save/load project files. Export generated code and compiled binary.

Testing

Provide a test harness and sample hardware tests proving code generation, compile, and upload. A test report demonstrating all sensors/motors work on actual hardware.

B. Acceptance criteria

Blocks convert to Python and C/C++ such that the generated code compiles (no user edits) and runs on the referenced board.

Upload works reliably to a board with CH340C on Windows and macOS (at minimum Windows).

Terminal displays serial output and logging.

All listed sensors and motors operate according to example projects delivered.

Documentation and developer notes for adding new blocks/libraries.

3) Recommended tech stack & components

Editor: Electron for desktop + Blockly or Scratch Blocks for GUI. (Electron lets you ship Windows/macOS builds quickly.)

Code gen: Custom Blockly generator modules (JavaScript) that emit MicroPython and C/C++ source. Use template engines for consistency.

Build & upload: PlatformIO CLI integration (recommended) for C/C++ builds + [login to view URL] for direct flashing fallback; pySerial for serial terminal.

Runtime libs: Provide two runtime options:

MicroPython firmware + helper libs for sensors (for Python target).

Arduino/ESP32 runtime libraries (for C/C++) — packaged as PlatformIO library dependencies.

Languages: App UI in JS/TS; backend Node child_process to call PlatformIO/esptool; codegen in JS.

Testing & CI: GitHub Actions to run linting and codegen tests (simulate compile where possible), automated artifact builds.

Installer: electron-builder or similar to make Windows/Mac installers.

4) Screening test (small paid task)

Task: Create a mini-block (in Blockly) for reading the LDR (IO34) and producing code for both:

MicroPython: a function read_ldr() that returns analog value.

C++ (PlatformIO/Arduino): a function int read_ldr() that returns analogRead(IO34).

Deliverable: A zip with (1) Blockly block definition + generator for Python and C++, (2) generated code for both targets, and (3) instructions to run. Time: 8–12 hours paid. This proves block→code skill & ESP32 pin handling.

5) Interview checklist + technical questions

Architecture & skill checks

Explain how you’d implement a blocks → code pipeline for two languages. (Look for knowledge of Blockly generators & templating.)

Have you integrated PlatformIO or esp-idf in a desktop app? Explain steps to reliably flash devices with CH340C.

Ask for examples of hardware tests they wrote.

Ask about handling pin conflicts and same-pin usage (e.g., user assigned echo and temp to IO32) — look for practical mitigation (sharing ADC vs digital, using multiplexing, changing mapping).

Sample technical questions

How would you detect and handle a device connected via CH340C on Windows vs macOS? (expect COM/TTY detection + driver handling)

How do you design a Blockly generator to ensure that generated C++ has proper includes and setup() / loop()? (expect AST or generator templates)

How would you create an I2C OLED block that works for both Python (MicroPython ssd1306) and Arduino (Adafruit_SSD1306)? (expect library abstraction)

Explain pros/cons of MicroPython vs Arduino for beginner users in a blocks editor.

6) Milestones & payment schedule (recommended)

Spec & prototype — interactive mockups + one working block + demo: 15%

Core editor + codegen (Python & C++) — 35%

Compiler/upload integration + terminal — 25%

Full hardware integration & tests (all sensors/actuators) — 15%

Docs, installers & handover — 10%

Include acceptance tests for each milestone. Use escrow or milestone payments (Upwork/Arc) when possible.

7) Rough cost & rate guidance

Freelance embedded rates vary by experience and region. Typical ranges you can expect (USD):

Junior (India/local) freelance: $15–40/hr.
Your Team In India
Upwork

Mid-level / experienced embedded devs: $35–95/hr (specialized ESP32, blocks experience toward the higher end).
Upwork
Arc

Senior product firms / agencies: $100–250+/hr — higher but offer full team + QA.
[login to view URL]

If you hire in India as an employee (FTE) yearly: expect ~₹4 lakh – ₹20 lakh depending on level & company — but for freelance fixed-price with milestones is typical.
upGrad
Salary Expert

(Use the screening task above to calibrate a candidate’s price.)

8) Contract/IP and risk checklist

IP: All code produced under “work-for-hire” transferred to you on final payment. Specify license (exclusive) in contract.

Confidentiality: NDA prior to detailed design sharing.

Acceptance tests: Define exact test hardware and test scripts; milestone acceptance is based on passing tests.

Warranty/bug-fix period: 30–90 days after delivery included.

Source & build artifacts: Must hand over source repo + build scripts + installer + all PlatformIO manifests, plus credentials for build pipeline if used.

Driver/distribution note: CH340C drivers are sometimes needed on Windows; include user-friendly driver instructions in docs." (client-provided description)