Our 5 Winning Steps in Embedded Software Innovation

We are all well aware of the classic SDLC (Software Development Lifecycle) scheme, which includes planning, analysis, design, development, integration, and system maintenance. But how does it all work in practice? For example, the analysis step should come before planning. Otherwise, what can we plan if we need more information? So today, we will share our experience developing software for embedded systems.

Step 1: Technology Assessment and Brainstorming

This initial step involves the evaluation of the available hardware platforms, software tools, and communication protocols to ensure they align with the project’s specific requirements.

This includes assessing the capabilities of the main processing unit (microcontroller or an SBC), sensors, actuators, and other components to meet the feature requirements, performance, power consumption, and real-time processing needs. Additionally, evaluating development tools such as compilers, debuggers, and integrated development environments (IDEs) is essential to ensure compatibility and efficiency of the development process.

The assessment also considers the necessity to use a real-time operating system (RTOS), what power management techniques are required for the project, and security features to ensure the system’s robustness and efficiency.

Usually, brainstorming involves discussing the pros and cons of different hardware and software solutions, exploring various design approaches for critical system aspects like real-time processing and peripheral interfacing, and considering rapid prototyping methods to test and validate ideas quickly.

Step 2: Development Documentation

Each feature development cycle in embedded software begins with the thorough analysis of the feature requirements. This analysis draws from the product backlog, stakeholder input, and overarching project objectives to define what needs to be built and why. This stage ensures the development team understands the feature’s purpose, scope, and expected outcomes, providing a solid foundation for the subsequent stages. Remember, that correct, comprehensive and clear documentation is important at any stage of development. Meanwhile you can read more about our project development flow here. 

Anyway, we mention the most important documents for this step:

1. Requirements Documentation (PRD – Product Requirement Document)

• Functional requirements: Detailed descriptions of what the system should do, including specific features and functionalities.
• Non-Functional requirements: Requirements related to performance, reliability, scalability, and other quality attributes.
• Hardware requirements: Specifications of the hardware components, including microcontrollers, sensors, and communication interfaces.
• Mechanical requirements: Requirements related to the mechanical construction of the device or its installation.

2. Design Documentation

• System Architecture: High-level overview of the system, including principal components, their interactions, and data flow diagrams.
• High-Level Design (HLD): A more detailed design of the system’s significant components, including their interfaces and interactions between them.
• Interface Control Document (ICD): In-depth design details for interfaces and data protocols used for communication between system elements.

Step 3: Development Infrastructure Setup

This stage encompasses hardware, software tools, and processes that support the entire development lifecycle, from initial design through deployment and maintenance. We prepare everything we need for effective development. 

We start with task board creation, creating a folder structure in cloud and GitHub repository creation, and then we add the branch structure and set up the CI/DC routines necessary during the development cycle. For infrastructure development, we use the following tools:

• Tool chain consisting of a compiler and necessary build tools: Cross-compilers and build systems that generate executable code for the target hardware. For example, ARM GCC in combination with CMake.
• Version Control Systems (VCS): we use Git for software, cadlab.io for our PCB and Autodesk’s solution for version control in Fusion 360.
• Simulators and emulators: Software that simulates or emulates the target hardware environment for early testing and debugging. These tools may be useful when we need to run extensive testing that would benefit from not running on the actual hardware. For example, mesh network simulation using Renode.

When everything is ready, we start the development process. It comes together with testing. Such a flow lets us perform any code updates, and bug fixes on time, because development and testing go simultaneously.

Step 4: Feature Development & Testing Cycle

The feature development and testing cycle is designed to be flexible and adaptive, allowing teams to iterate on features based on feedback and changing requirements. This iterative approach enables continuous improvement and refinement, ensuring the final product meets user needs, and adapts to evolving project goals.

• We start coding the feature based on the detailed specifications. This process involves writing new code, modifying existing code, and integrating third-party drivers or libraries as necessary. The goal is to implement the feature while ensuring compatibility and performance within the embedded system’s constraints. At the Git repository, we create a new branch for the feature and start working on it. 
• Functional testing then verifies that the feature meets business requirements and user expectations. This stage involves testing the feature’s functionality from the user’s perspective, ensuring it works as intended, and delivers the desired outcomes. Functional testing is critical for validating that the feature fulfills its intended purpose. Before this process, we prepare a detailed test plan. After we test each feature one by one and we put all the results in the test report. 
• Any bugs or issues identified during testing are promptly addressed. This may involve code fixes and performance optimizations. Resolving these issues ensures the feature is robust, efficient, and user-friendly. To track all the issues, we use bug reports, which are constantly updated.

Step 5: Release & Support

A well-executed release and robust support infrastructure are critical for the long-term success and sustainability of any embedded device. They make sure the device stays reliable, secure, and effective for users. Why is all this essential? Let’s check on some reasons:

• User Satisfaction: We need to make sure the transition to the new features or updates goes smoothly and doesn’t mess with the user experience.
• System Reliability: We maintain the reliability and stability of the system through proactive monitoring and prompt issue resolution.
• Security: We try to avoid the introduction of any vulnerabilities to the system in the early stages and mitigate them through timely patches and updates in the support stages.
• Continuous Improvement: This strategy uses user feedback and performance data to improve the system continuously, ensuring it meets evolving needs and expectations.

Release Phase

Now, let’s talk a bit more about the release stage.

1. Release Planning
   • Training and Documentation: We prepare user manuals, technical documentation, and training materials to support the end customer and their maintenance teams during and after the release.
2. Pre-Release Testing
   • System Testing: To identify any last-minute issues, we perform extensive system testing in a controlled environment that will mirror the production environment as closely as possible. When the code passes the review, we merge it into the development branch. At this stage, if it is enough for release, we prepare \ update the release docs (source code, release notes, test report, user instructions), merge it with the main branch, and add a version tag. 
   • We use semantic versioning (v 2.0.0) for the code version:
     – 0.0.1 – patch (minor changes);
     – 0.1.0 – release (new feature presented);
     – 1.0.0 – demo version (several breaking complete features).

3. Deployment
   • Production Environment Preparation: We ensure that the production environment, including hardware, software, and network configurations, is ready for the new release.
   • Software Deployment: We deploy the software update in the production environment, following our planned strategy to minimize any disruptions for users. For example, we implement an over the air (OTA) updating feature
   • Post-Deployment Validation: Finally, we conduct post-deployment validation to ensure the system operates as expected in the live environment.
4. Presentation
   • Introduction and Context: We set the stage by providing a brief overview of the project, its objectives, and the problem it aims to solve. 
   • Feature Demonstration: We conduct a live demo of the software, showcasing its key features, functionalities, and user interface.
   • Technical Insights: Provide an overview of the technical architecture, including the technology stack, integrations, and any innovative solutions implemented. 
   • Q&A Session: Next, we open the floor for questions from stakeholders, providing clarifications and additional details as needed. 
   • Next Steps: Finally, we define the immediate next steps, including any last checks, the official release date, and post-release monitoring. Highlight future development plans, updates, or potential enhancements to keep the product growing.

Support Phase

However, the project does not end up with a release presentation. We provide comprehensive support for our clients. 

1. Monitoring and Maintenance
   • Continuous Monitoring: We implement monitoring tools to track the deployed system’s performance, stability, and security continuously.
   • Issue Tracking: We set up real-time mechanisms for detecting, logging, and addressing issues. 
2. Bug Fixing and Updates
   • Rapid Response: We quickly address critical issues and bugs that raise post-release.
   • Patch Management: We develop and deploy patches to fix bugs, security vulnerabilities, and performance issues in short periods of time.
   • Minor Updates: We regularly release minor updates to improve functionality, user experience, and system performance.
3. User Support
   • Technical Support: Our technical team assists users with issues, provides guidance, and answers queries.
   • Feedback Collection: We collect feedback from users to identify common issues, areas for improvement, and potential new features.
4. Continuous Improvement
   • Performance Analysis: We regularly analyze system performance and customer feedback to identify trends and areas for improvement.

Unlocking innovation through seamless code: Our software development process turns visionary ideas into robust, scalable solutions. From concept to deployment, we ensure excellence every step of the way.