For someone with no other tools in their toolbox, every problem appears like a nail. For maximum efficiency and effectiveness in any skilled occupation, it is essential to have access to the appropriate tools. In the same way, developing an embedded device is a process. However, embedded development tools have historically lagged behind the sophistication and cutting-edge feature sets of their desktop, web, and smartphone counterparts. Microcontroller and FPGA development has traditionally necessitated the use of costly hardware programmers/debuggers and proprietary software licenses. There has been a recent trend toward more open source ecosystems (such as the RISC-V microprocessor, the Arduino IDE, etc.), and this trend has likely improved the reliability and user-friendliness of many embedded programming tools. The following are examples of recent software advancements that have altered the typical practice of creating embedded systems:
1. Integrated Development Environment (IDE)
When working on Linux, many programmers find it appealing to use text tools like Vim or Nano. They are minimal in size and can be found in the standard installation of virtually all Linux distributions. However, contemporary code editors and integrated development environments (IDEs) offer much more features that are very appealing to embedded coders. In addition, numerous makers of embedded devices provide integrated development environments (IDEs) tailored to their particular families of microcontrollers. Access to support libraries for external components, templates for various microcontrollers, and examples to help developers get started with new hardware are just some of the benefits offered by manufacturer-centric IDEs.
2. Version Control Tools
The process of creating new software never stops. It is also unusual for a single developer to create a state-of-the-art embedded device. Because embedded systems are often just one part of a broader software ecosystem, embedded developers often need to collaborate with mobile and web programmers. Tools for version management, such as Git, allow developers to keep track of code changes over time. A couple of the most well-known places to store your project’s code and other design assets in the cloud are GitHub and GitLab. Tools for version control have many uses, including but not limited to versioning, release administration, and bug reporting. A few disadvantages do exist, though. The most common reason they are used in cyberattack chains is that coders forget to remove sensitive information before pushing changes to public repositories. Criminals then mine these databases for this data to use in their software campaigns.
3. Debugger
As a rule, high-priced gear was required for debugging microcontrollers in the past. Plug an In-Circuit Emulator (ICE) into the microcontroller port of your larger system to simulate its behavior. They provide debugging features like register and memory access, conditional breakpoints, and trace buffers while still allowing the software to execute in real time. In-Circuit Debuggers are more prevalent and less costly. (ICD). The In-Circuit Serial Programming (ICSP) interface requires a device to be placed between the developer’s desktop and the target microcontroller to facilitate debugging. Some newer microcontroller development boards come with in-circuit-stack-programming (ICSP) debugging hardware already installed, and all a developer needs is a USB cable to link the board in question to their local computer. The chosen IDE for a given development board is usually where debugging features are managed.
4. Linter
After finishing an essay or report, we always use a spell checker and grammar analyzer to make sure everything is perfect. In the context of programming, this is represented by a linter. Errors in style, configuration, project structure, and library dependencies can all be spotted by a linter because it analyzes the source code statically (before compilation) rather than dynamically (while the machine code is executing on the target device). The consequences of these mistakes range from a decrease in legibility to an inability to compile at all.
5. GitHub Copilot
Auto-completion is a staple of many code tools and has been for many years. As a coder types out source code, auto-complete provides intelligent suggestions for keywords and variable names, making them more productive. Code completion has been revolutionized by GitHub’s Copilot, an artificial intelligence (AI) plugin for Visual Studio Code. Copilot can analyze the name of a developer-created function and suggest the full set of instructions required to call that function. Take the following as an illustration of some writing:
float calculateVolume
Copilot will finish the function declaration as follows:
float calculateVolume(float radius) {
return (4.0/3.0) * PI * radius * radius * radius;
You can think of Copilot as an artificially intelligent coworker who can aid in the coding process by, at the very least, suggesting how certain functions might be defined. Copilot’s code can be automated, but it still requires human evaluation and correction.
6. HTTP and API Examination Tools
Embedded devices (i.e. IoT devices) rarely if ever function without some sort of network connection, if not direct Internet access. Unfortunately, web app writers may be working on software independently of the embedded development team. Embedded developers can examine and test HTTP request methods (like PUT, POST, and GET) and API requests separately and before committing them to the firmware with the help of tools like Postman. This decouples troubleshooting from the embedded hardware, making it more likely that API problems can be traced back to the API rather than the software or hardware.
7. Packet Inspection Tools
While development-focused HTTP and API inspection tools are great for high-level troubleshooting, inspecting at the packet level or looking into alternative protocols like Zigbee may be required on occasion. It is essential to use a packet inspection instrument like Wireshark in those scenarios. Many different packet-based communication methods are captured and analyzed by Wireshark.
8. Software-based Logic Analyzers
Instead of having a workstation piled high with bulky hardware like oscilloscopes and logic analyzers, developers now typically use software-based tools to debug their devices. The interface for these software-based tools is typically a desktop program that is connected to a computer via USB. The Saleae Logic Analyzer is a common low- to medium-tier logic analyzer. Among field technicians, these software-based instruments are among the most alluring. By taking analysis that was previously only possible in a laboratory, they improve the efficiency of field inspections and troubleshooting of distributed devices. One major benefit of a software-based analyzer is that you can create your own protocol analyzers for unique communications protocols in addition to the standard protocols supported (such as I2C, SPI, and USB).
9. Secure Shell (SSH) Terminal Client
In order to perform certain maintenance tasks on more complex embedded systems running an operating system and providing shell access for remote administration, it may be necessary to SSH into a device. Perhaps it’s time to make some adjustments to the backend services being provided by the server that a number of your IoT devices are talking to. In any case, SSH terminal clients like Termius are indispensable for remote access to networks. Modern clients also make it easy to write, save, and execute small chunks of bash code with a single click. You can use them to log in to numerous terminals simultaneously. Last but not least, some clients feature SFTP capability, which allows you to safely transfer files to and from remote devices.