Embedded Software Engineer - CAN / SPI / Linux

We are seeking a highly experienced Senior Embedded Software Engineer to lead the development of our Linux-based ARM industrial gateways. You will be responsible for designing, implementing, and optimizing complex embedded software, focusing on performance, reliability, and security. This role requires a deep understanding of embedded Linux, C++ development, industrial protocols, and hardware-software integration. You will also be instrumental in driving our CI/CD initiatives and ensuring the quality and efficiency of our software development lifecycle.

Key Responsibilities

Embedded Software Development:
Design and develop robust embedded C++ software for ARM-based industrial gateways.
Develop and maintain Linux-based systems using Yocto Project.
Implement multithreaded applications and utilize design patterns for maintainability and scalability.
Develop CLI/SSH-based diagnostic commands for system health monitoring and troubleshooting.
Industrial Protocol Integration:
Implement and integrate industrial communication protocols such as CAN, Modbus RTU, Modbus TCP/IP, and SNMP.
Peripheral Driver Development:
Develop and implement drivers for embedded peripherals such as I2C, SPI, and UART.
System Architecture and Integration:
Design and implement embedded systems architecture, ensuring seamless hardware-software interaction and low-level system integration.
CI/CD and Agile Development:
Implement and maintain CI/CD pipelines using tools like Jenkins, GitLab CI, and GitHub Actions.
Participate in agile development processes, including sprint planning, code reviews, and testing.
Linux Application Development:
Develop applications for ported SBCs (e.g., Raspberry Pi, BeagleBone, NXP i.MX).
Integrate web servers and RESTful APIs for remote management.
Debugging and Testing:
Utilize debugging tools (GDB, JTAG, serial debugging) and command-line services for testing and troubleshooting.
Develop and implement testing strategies for embedded systems.
HMI Development (Desired):
Design and implement HMIs (graphical user interfaces, touchscreens) using frameworks like TouchGFX, Qt, or LVGL for Embedded.

Required Skills and Experience

9-11 years of experience in embedded software development.
Strong proficiency in Embedded C++ programming.
Extensive experience with ARM-based microcontrollers and Linux-based systems (Yocto preferred).
Proven experience with multithreading, IPC, and design patterns.
Hands-on experience with industrial protocols (CAN, Modbus RTU, Modbus TCP/IP, SNMP).
Strong understanding of embedded systems architecture and low-level system integration.
Experience with CI/CD pipelines and agile development methodologies.
Proficient in using debugging tools (GDB, JTAG, serial debugging).
Experience with baremetal programming.
Experience with webserver and RESTful API integration.

Qualifications

Education: Bachelor's or Master's degree in Electrical Engineering, Computer Engineering, or a related field.

General Requirements

Employment Type: Full Time, Permanent
Working Mode: Regular
Notice Period: Immediate - 15 Days

Candidate Self-Assessment Checklist:

To help us better understand your qualifications, please provide details for the following:

Total Years of Experience (excluding testing, documentation, and management):

Embedded C: [Years]
Embedded C++ Development: [Years]
Microcontrollers, RTOS, and Linux-based Platforms: [Years]
Specific controller families you've worked with (e.g., STM32, PIC, Infineon): [List specific families]

Experience in Specific Areas:

Embedded C/C++ programming with RTOS (e.g., FreeRTOS, Zephyr): [Years]
Linux-based systems (e.g., Yocto, Ubuntu for embedded): [Years]

Bare Metal Programming:

Have you worked with low-level BareMetal programming (e.g., memory management, I/O configuration, setting up interrupts, timers) [Yes/No]
Describe your experience in bare metal development or working with peripherals directly: [Your response]

Multithreading and IPC:

Do you have experience with multithreading (e.g., thread synchronization, mutexes, condition variables) and IPC (e.g., message queues, semaphores, shared memory) [Yes/No]
Provide examples of projects where you've used these techniques, especially in RTOS or Linux: [Your response]

Peripherals Experience:

Please list the peripherals you have worked with (e.g., UART, SPI, I2C, ADC, RS485, CAN): [List peripherals]

Industrial Protocol Experience (Modbus RTU, MODBUS TCP/IP):

Do you have hands-on implementation knowledge of Modbus RTU and Modbus TCP/IP [Yes/No]
If yes, specify the years of experience: [Years]

Web Server / RESTful API Integration in Embedded Systems:

Have you developed or integrated a web server or worked with RESTful APIs for remote management or data exchange in embedded systems [Yes/No]
Please mention any cloud services (e.g., AWS, Azure) or communication protocols (e.g., HTTP/HTTPS) you've worked with: [Your response]

Linux Application Development on Ported SBCs:

Do you have experience with Linux application development on ported SBCs (e.g., Raspberry Pi, BeagleBone, NXP i.MX) [Yes/No]
Please describe your experience in developing applications for Linux-based embedded systems: [Your response]

HMI Development:

Have you designed or worked with HMIs (graphical user interfaces, touchscreens) in embedded systems [Yes/No]
Describe the frameworks or libraries you've used (e.g., TouchGFX, Qt, LVGL for Embedded), and how you integrated them into your embedded projects: [Your response]

Debugging, Testing, and Continuous Integration:

Do you have experience with debugging tools (e.g., GDB, JTAG, serial debugging) and command-line services for testing and troubleshooting embedded systems [Yes/No]
How do you approach debugging, testing, and continuous integration in embedded environments [Your response]

Embedded Software Engineer - Can / SPI / Linux