Embedded Linux Device Software Engineer

Architecture and system policies

• Design and evolve the device-side software architecture: process and thread model, concurrency and synchronization, inter-module communication, task priority and real-time requirements, memory and bandwidth allocation, and fault isolation and recovery.
• Keep the device’s concurrent workloads stable within limited compute — audio capture and processing, video capture and encoding, on-device inference, local storage, network upload, and motor motion.
• Define the device-level operating policies: power-up and power-down sequencing, operating states, sleep and wake, abnormal power-loss handling, recording triggers and retention, upload and bandwidth scheduling, motor motion sequencing, and degradation and self-recovery under abnormal conditions.
• Define how the main SoC and the secondary system (coprocessor) divide functions, synchronize state, communicate, and handle exceptions at the boundary.

ODM software requirements and acceptance

• Issue the software-side technical requirements before the ODM design is frozen: kernel version and configuration, device tree and pin definitions, power domains and sleep/wake paths, clock and scheduling configuration, SDK interfaces and error-code conventions, and access to logging and debug channels.
• Review the BSP, drivers, middleware, and SDK delivered by the ODM — state-machine completeness, exception paths, resource release, error-code traceability, concurrency safety — and drive the responsible party to fix root causes rather than working around low-level defects in the application layer.
• Define measurable acceptance criteria (long-run stability, memory growth, frame-drop rate, response and inference latency, power consumption per operating state, fault-recovery success rate) and apply them at development milestones.

System integration and fault attribution

• Integrate the capabilities delivered across camera, audio, motor motion, on-device models, networking, storage, and cloud; define the interface contracts and the device-level state machine.
• Isolate issues across application, SDK, middleware, BSP, driver, hardware, and cloud; produce reproduction conditions and evidence chains, and track each issue to closure.
• Implement device-cloud communication: MQTT / HTTP, persistent upload queues, resumable transfer, retry and backoff, weak-network handling, and adaptive bandwidth.
• Build lightweight automation (Shell / Python) for regression, fault injection, long-run stress testing, and log collection.

On-device AI integration

• Integrate the on-device inference runtime into the device software pipeline: runtime invocation, input and output handling, and the surrounding preprocessing and post-processing.
• Profile inference latency, memory footprint, and CPU / NPU utilization, and ensure that inference does not contend for resources with audio and video capture, encoding, storage, and upload.
• Localize deployment-stage issues — unsupported operators, excessive memory use, unexpected latency, output inconsistency — with reproduction conditions and evidence, and route them to the algorithm team or the chip vendor for resolution.

• 3–5 years of embedded Linux software development, with hands-on delivery on real products.
• Strong C / C++ on Linux, with practical experience in multi-threading, IPC, synchronization, resource management, and debugging complex concurrent software.
• Ability to design at the system level: task decomposition and priority, resource and timing budgets, module interfaces and state machines, and behavior under abnormal conditions.
• Experience integrating multiple device subsystems into one working product — camera and video, audio, storage, wireless networking, sensors, or motor-control modules — and defining the interfaces between them.
• Solid understanding of the Linux system stack — scheduling, memory management, file systems, device tree, power management and sleep/wake, and common kernel and driver concepts — sufficient to debug across application, SDK, middleware, BSP, and driver boundaries, and to technically review deliverables produced by others.
• Able to read schematics, work with dmesg, serial console, gdb, and strace, and collaborate with hardware engineers or the ODM to determine whether an issue originates in software or hardware.
• A record of concrete architecture or design decisions, with the ability to explain the trade-offs made, their costs, and how they were subsequently validated.
• Able to take a problem from reproduction and diagnosis through to resolution independently, and to communicate decisions, trade-offs, risks, and open issues clearly to software, hardware, algorithm, ODM, and product teams.

• Experience working with ODMs, design houses, SoC vendors, or module vendors.
• Embedded multimedia experience combining camera capture, video encoding, audio, networking, and local storage in a single system.
• Low-power design experience: power-state management, suspend and resume, abnormal power-loss handling.
• Experience with coprocessor, MCU, or dual-system architectures.
• Familiarity with on-device inference runtimes or embedded AI toolchains.
• Experience with platforms such as Rockchip, Ambarella, Qualcomm, MediaTek, Horizon Robotics, or NVIDIA Jetson.
• Experience through EVT / DVT / PVT and mass production.
• Experience building automated device validation or long-run stability testing.

• Compensation negotiable, set against your experience and fit.
• Full-time employment contract, with the statutory social insurance and housing fund.
• Three-month probation period.
• We evaluate on capability and project track record — neither your degree nor a big-company background is a threshold requirement.