Firmware Engineer

7RD; Delhi; Sur place; INR 900 000 - 1 500 000; Plein temps

Résumé du poste

7RD is building a Counter Drone Swarm Stack with an EdgeAI Module that runs autonomous mission planning on-device. We are seeking a Firmware Engineer to convert product and system requirements into reliable firmware that interfaces with sensors, actuators, and higher-level software.

The role covers bare-metal or RTOS-based firmware development, Python tooling, and robotics integration with ROS/ROS 2 interfaces. Cross-compile, Yocto, and ArduPilot customization are part of the scope.

Qualifications

• Strong embedded C development for microcontrollers.
• Experience with C++ in constrained or real-time systems.
• Python for automation, tooling, and data analysis.
• Experience with ROS or ROS 2 interfaces is a plus.
• Experience with Yocto-based software images is preferred.

Responsabilités

• Develop and maintain firmware for AVR, STM32, and ESP32 devices using C/C++.
• Create Python tools for test automation, build support, telemetry, and log analysis.
• Integrate embedded firmware with sensors, actuators, and higher-level robotics software including ROS/ROS 2.
• Configure cross-compilation toolchains and embedded Linux builds (Yocto).
• Develop and maintain firmware for ArduPilot-like autopilot workflows and peripherals.
• Implement and debug communications protocols (UART, SPI, I2C, CAN, USB, Ethernet).
• Ensure firmware reliability with watchdogs, safe-state behavior, and update mechanisms.
• Perform verification tests and contribute to release documentation.

Connaissances

Embedded C

C++

Python

RTOS

ROS2

Formation

Bachelor's degree

Outils

Yocto

Git

Linux

Description du poste

7RD is building the Counter Drone Swarm Stack, powered by our core product: an EdgeAI Module for drones, a neural chip based "brain" that runs autonomous mission planning, target tracking, and navigation entirely on the edge, with no cloud or GPS dependency.

Job Description

OB DESCRIPTION

Firmware Engineer

Embedded Systems and Linux

Location:

Employment Type:

Full-time

Experience Level:

2-4 Years

Department:

Role Purpose

The engineer will convert product and system requirements into reliable firmware that interfaces correctly with electronic hardware, sensors, communication modules, actuators, and higher-level applications. The position requires practical ownership from architecture and driver development through integration, debugging, verification, release, and field support.

Key Responsibilities

Microcontroller firmware: Develop and maintain bare-metal or RTOS-based firmware for AVR, STM32, and ESP32 devices using C and C++.

Python development: Develop Python tools and utilities for test automation, build support, telemetry and log analysis, calibration, simulation, manufacturing, and system integration.

Robotics integration: Integrate embedded firmware with sensors, encoders, actuators, motor controllers, safety interlocks, and higher-level robotic software, including ROS or ROS 2 interfaces where applicable.

Embedded Linux: Configure cross-compilation toolchains, build applications and system components, integrate board support packages, and troubleshoot software on embedded Linux computers.

Yocto development: Create and maintain Yocto layers, recipes, image configurations, machine settings, package selections, and reproducible builds for target hardware.

ArduPilot customization: Understand the ArduPilot codebase, modify firmware for product-specific behavior, integrate sensors or peripherals, configure boards, and validate changes through bench and flight-oriented testing.

ESP32 development: Build connected firmware using ESP-IDF or an equivalent framework, including peripheral control, communication, networking, logging, update, and fault-recovery functions.

Drivers and board support: Develop and integrate low-level drivers, hardware abstraction layers, startup code, interrupt handling, timers, DMA, memory interfaces, and board configuration.

System communication: Implement and debug UART, SPI, I2C, CAN, USB, Ethernet, Wi-Fi, Bluetooth, MAVLink, and other product-specific protocols.

Firmware reliability: Design watchdog handling, error detection, safe-state behavior, configuration storage, bootloaders, firmware update mechanisms, and recovery paths appropriate to the product.

Verification and debugging: Create unit, integration, bench, and hardware-in-the-loop tests; diagnose timing, memory, concurrency, communication, and hardware-interface faults using suitable tools.

Release management: Maintain source control, build instructions, configuration records, change history, release notes, traceable binaries, and technical documentation.

Cross-functional support: Work with hardware, systems, controls, testing, manufacturing, and field teams to define interfaces, review risks, reproduce issues, and deliver corrective updates.

Core Technical Areas

Area

Expected Knowledge and Application

Languages

Strong embedded C and practical C++ knowledge, plus Python for automation, test tools, build support, simulation, telemetry processing, and log analysis.

Microcontrollers

AVR, STM32, and ESP32 architecture, clocks, GPIO, interrupts, timers, ADC, PWM, DMA, nonvolatile memory, low-power modes, and vendor SDKs.

Real time software

Task design, scheduling, synchronization, queues, timing, interrupt interaction, resource sharing, and debugging in an RTOS such as FreeRTOS.

Embedded Linux

Cross-compilation, Linux processes and services, permissions, filesystems, networking, shell tools, system logs, device access, and deployment to target systems.

BitBake, recipes, layers, images, packages, machine configuration, SDK generation, build reproducibility, and integration of custom applications.

Autopilot and robotics

ArduPilot architecture, MAVLink, sensors, actuators, simulation and logging, together with robotic interfaces, motor controllers, safety interlocks, and ROS or ROS 2 integration awareness.

Hardware interfaces

Schematic and datasheet interpretation, peripheral bring-up, protocol timing, electrical constraints, driver behavior, and cooperation with hardware engineers.

Debug and test

GDB, JTAG or SWD, serial logs, oscilloscopes, logic analyzers, static analysis, unit tests, integration tests, and repeatable fault reproduction.

Requirements

Required Qualifications

Bachelor's degree or diploma in Electronics, Computer Engineering, Computer Science, Embedded Systems, or a closely related discipline.

Demonstrated experience developing production firmware for microcontrollers, including at least one STM32 or ESP32 platform and practical familiarity with AVR devices.

Strong programming ability in embedded C, working knowledge of C++ for constrained or real-time systems, and practical Python experience for automation, testing, build tooling, simulation, or data and log analysis.

Experience with embedded Linux cross-compilation and with configuring or maintaining Yocto-based software images.

Ability to read schematics and component datasheets, debug firmware at the boundary between software and hardware, and integrate robotic sensors, encoders, actuators, or motor controllers.

Experience using Git, structured code review, reproducible build procedures, issue tracking, and documented firmware releases.

Ability to investigate complex faults systematically and communicate findings through clear code, test evidence, and technical documentation.

Preferred Experience

Direct modification of ArduPilot firmware, including custom board support, sensor or actuator integration, MAVLink changes, parameter handling, or vehicle-specific behavior.

Use of ArduPilot simulation, software-in-the-loop testing, hardware-in-the-loop testing, flight logs, and controlled field-validation procedures.

Linux board support work involving U-Boot, device trees, kernel configuration, kernel modules, systemd services, or custom root filesystems.

Bootloader design, secure boot, signed firmware, over-the-air or field updates, rollback, and recovery mechanisms.

Experience with DroneCAN, CANopen, Ethernet-based protocols, GNSS receivers, inertial sensors, radio modules, motor controllers, or payload interfaces.

Familiarity with ROS 2 or micro-ROS, PX4 or another autopilot stack, robotic simulation tools, shell scripting, continuous integration, static analysis, and automated test equipment.

Firmware development for defence, aerospace, robotics, industrial control, automotive, or other reliability-sensitive systems.