16 Nov
|
Vayavya Labs
|
Bengaluru
16 Nov
Vayavya Labs
Bengaluru
Position Name: Middleware Developer (C&C;++) — ADAS
Years of Experience: 3- 7 years
Location: Bengaluru, Karnataka
About Vayavya Labs
Vayavya Labs builds embedded software and firmware for the semiconductor and automotive industries, with deep expertise in low-level device software, driver automation, and safety-critical systems. Our engineers work close to the metal — bringing up silicon, writing production firmware, and validating it to the standards demanded by modern and autonomous vehicles. We are expanding our middleware and platform-software capability to support the next generation of software-defined vehicles, where robust, well-architected middleware is what connects hardware to the applications that run on it.
About the Role
We are looking for a C/C++ Middleware Developer to design, implement, and maintain the middleware layer of a vehicle compute platform built for ADAS and autonomous driving. This is the layer where inter-process communication frameworks, service daemons, hardware abstraction interfaces, and system services come together to carry sensor data and control signals between low-level drivers and the autonomy software that depends on them. You will work within and contribute to the team’s in-house C++ middleware frameworks — not building from scratch in isolation, but extending, hardening, and optimizing a shared codebase that other engineers build on. The role combines strong C++ systems programming with an understanding of how embedded software stacks are organized — from device drivers through middleware services to application interfaces. You will collaborate closely with firmware engineers, driver developers, perception and planning teams, and will be expected to write production-quality, testable, well-documented code that runs in resource-constrained, safety-adjacent environments. You should be comfortable working in a large, shared C++ codebase with established patterns, contributing clean code that other engineers review, extend, and rely on.
What You’ll Do
- Design and implement middleware components in C++ (C++14/17) that provide well-defined interfaces between platform services, device drivers, and application software.
- Develop and maintain inter-process communication (IPC) frameworks — D-Bus like services, shared-memory interfaces, zero-copy transports (e.g. Eclipse iceoryx), POSIX message queues, and Unix domain sockets — for reliable, low-latency communication between system daemons, sensor pipelines, and application software.
- Implement system services and background daemons on embedded Linux — managing lifecycle, configuration, logging, health monitoring, and error recovery.
- Write and integrate hardware abstraction layers (HALs) that expose sensor data, actuator controls, and peripheral status to higher-level software through clean, versioned APIs.
- Develop middleware for vehicle communication stacks — receiving and routing CAN, Ethernet, or serial data from the platform’s networking layer and exposing it to application consumers as structured service interfaces.
- Build and maintain configuration management, parameter storage, and runtime-tunable settings frameworks for embedded platforms.
- Work within and contribute to the team’s in-house C++ middleware frameworks — understanding the existing architecture,
following established coding patterns and API conventions, and extending the framework with new modules as the platform evolves.
- Integrate third-party and silicon-vendor SDKs into the middleware stack — wrapping vendor libraries behind clean, testable C++ interfaces that isolate the rest of the platform from vendor-specific APIs and versioning.
- Develop middleware components for sensor data routing — receiving high-bandwidth data from camera, lidar, and radar interfaces and delivering it to perception and fusion consumers through well-defined, latency-aware service interfaces.
- Implement platform health monitoring and diagnostics services — collecting hardware status, software health metrics, and error conditions from across the middleware stack and exposing them for logging, alerting, and fleet-level telemetry.
- Profile and optimize middleware for CPU usage, memory footprint, latency, and thread safety using tools such as perf, Valgrind, strace, and GDB.
- Write unit tests (Google Test / Google Mock), integration tests, and system-level tests for middleware components, and integrate them into CI/CD pipelines.
- Collaborate with firmware engineers on bring-up and integration — understanding how middleware depends on driver and BSP behavior, and debugging issues that span the middleware-driver boundary.
- Participate in architecture and design reviews, contribute to coding standards, and maintain clear technical documentation for middleware APIs and service interfaces.
What You’ll Bring
- 3–7 years of hands-on C/C++ software development experience, with at least 2 years focused on middleware, platform services, or system-level software.
- Strong modern C++ skills (C++14 or later) — comfortable with RAII, smart pointers, move semantics, STL containers and algorithms, templates, and lambda expressions in production code.
- Solid understanding of Linux system programming — processes, threads (pthreads / std::thread), synchronization primitives (mutexes, condition variables, semaphores), signals, file descriptors, epoll/select, and the POSIX API.
- Experience designing and implementing IPC mechanisms — at least one of: D-Bus (sd-bus or GDBus), shared memory, POSIX message queues, Unix domain sockets, or named pipes — in a multi-process embedded or systems-software context.
- Working knowledge of the Linux build and packaging ecosystem — CMake (and ideally colcon for ROS 2 workspaces) for build, pkg-config for dependency management, and familiarity with cross-compilation toolchains for ARM targets.
- Comfortable with debugging and profiling tools — GDB, Valgrind (memcheck, helgrind), strace, ltrace, and perf — for diagnosing memory leaks, race conditions, deadlocks, and performance bottlenecks.
- A structured approach to software quality — unit testing with Google Test / Google Mock, static analysis (cppcheck, clang-tidy), and code review discipline.
- Valuable understanding of version control workflows with Git, and experience with CI/CD pipelines (Jenkins, GitLab CI, or similar).
- Comfort working in a large, shared C++ codebase — reading and understanding existing code, following established patterns and API conventions, writing code that fits the team’s style and passes review.
- Awareness of Linux real-time concepts — PREEMPT_RT, CPU affinity, scheduling policies, and cgroups — at least enough to reason about latency-sensitive middleware behavior and work with engineers who tune these.
Nice to Have
- Experience with embedded Linux distribution building — Yocto / OpenEmbedded, Buildroot, or custom rootfs generation — including writing recipes, configuring layers, and integrating middleware packages into a BSP.
- Exposure to Linux device driver development — character drivers, platform drivers, or interfacing with kernel subsystems (sysfs, procfs, ioctl, DMA) — even at the level of reading and debugging existing drivers.
- Experience with embedded firmware development on microcontrollers (ARM Cortex-M, RISC-V) and an RTOS (FreeRTOS, Zephyr, or QNX) — helpful for understanding the firmware layer that middleware sits on top of.
- Familiarity with D-Bus system architecture — writing D-Bus services and clients, understanding the session bus vs. system bus, introspection, signal emission, and method calls using sd-bus (systemd) or GDBus (GLib).
- Exposure to automotive middleware and communication protocols — CAN, SOME/IP, AUTOSAR Adaptive, UDS — at any level (application, middleware, or driver).
- Experience with serialization frameworks — Protocol Buffers, FlatBuffers, or Cap’n Proto — for structured, versioned data exchange between middleware services.
- Familiarity with systemd service management — writing unit files, managing dependencies, socket activation, watchdog integration, and journal-based logging.
- Exposure to functional safety concepts (ISO 26262) or safety-critical software development practices (MISRA-C/C++, static analysis, ASPICE).
- Exposure to ROS 2 and DDS-based middleware — node architecture, executors, QoS policies, launch files, and lifecycle management — even at a user level rather than contributor level.
- Familiarity with zero-copy IPC frameworks such as Eclipse iceoryx, or shared-memory DDS transports, for high-bandwidth sensor data paths.
- Working knowledge of ADAS or autonomous driving concepts — perception, sensor fusion, localization, planning — at least enough to understand what the middleware serves and why latency and reliability matter.
- Experience integrating third-party or silicon-vendor SDKs into a larger platform — wrapping vendor APIs, managing ABI/API compatibility, and isolating vendor dependencies.
Why Join Us
You’ll work on the middleware that carries sensor data and control signals through an ADAS vehicle compute platform — the layer between the hardware and the autonomy software that depends on it. It’s an environment for engineers who care about clean interfaces, low-latency data paths, and code that runs reliably on real hardware in the field. You’ll contribute to a shared C++ codebase alongside firmware, driver, and perception engineers, solving problems that span the full stack.
Apply Here
📌 Middleware Developer (C&C++) — ADAS (Bengaluru)
🏢 Vayavya Labs
📍 Bengaluru