Creating projects that use microcontrollers inevitably requires the use of software packages to code them. But not all integrated development environments (IDE) are created equal. Picking the right one can be a tough choice!
Before choosing the IDE that you will use for your project, you will need to carefully decide what tools and features that the IDE needs to have. Since not all IDE packages are made equal, some may have useful debugging software, while others may be trivial to use. While the list of features and properties below is not complete (there are many more determining points an IDE might have), it should give you an indication as to which IDE is right for you.
Most IDEs on the market are free of charge, but addons may not be. IDEs such as Arduino IDE and Python IDLE are completely free and open-source, but packages such as IAR Embedded Workbench are proprietary and come with a price tag. Open-source packages have the cost benefit, as well as community support, but paid-for packages are often full of features, are often well supported, and also come with customer support that could be beneficial when things go wrong. However, closed-source software also relies on the company fixing bugs and rolling out updates on a regular basis. Otherwise, an IDE could be left unusable for some time.
Personally, speed is one of the biggest deal-breakers in which IDE I choose, and MPLAB X is a classic example. MPLAB 8.92 was a fantastic IDE (that is still available), as it provided debugging tools, a good C compiler for PICs, was very responsive, and rarely crashed. To try and modernize the IDE, Microchip released MPLAB X, which is written in Java and provides many different addons. However, MPLAB X has some serious performance issues and can take a long time to load, save, open projects, write code, wait for autocompletion, and compile projects. These performance issues are somewhat avoidable when MPLAB X is run on a modern operating system and used on a computer with relatively decent specs (quad core, plenty of RAM, etc.), but this was not an option for some time. IDEs that tend to include fewer features are often the fastest, and the Python IDLE is a classic example of a very fast, low-feature IDE that gets the job done.
Most people who have dealt with microcontrollers will know the importance of debugging. When programs don’t work, they often provide very little information as to why they failed. Most IDEs provide an error output window that, when used with Google, can provide insight as to why an error occurred, but these errors often have to do with compilation as opposed to code execution. This is why debugging is so vital; it allows the programmer to run the program step by step, as well as set breakpoints that halt the program in key areas. Debuggers also allow the user to view variable values, which can be very useful when trying to decide why a program crashes or produces an unexpected result.
Many well-established IDEs come with some form of debugging, but, believe it or not, there are some popular ones that do not. Examples of IDEs that do not provide debugging support include the Python IDLE and the Arduino IDE. While there are other Python IDEs that provide debugging, the fact that the Arduino IDE does not provide debugging can be genuinely problematic. When creating programs for microcontrollers, it is essential that debugging can be done, as microcontrollers do not have output windows, displays, or even a keyboard input. While the Arduino does have a serial port that can be used to dump variable values to a serial terminal, the Arduino cannot be single-stepped, nor can register values be watched.
These three properties of IDEs are interlinked, as IDEs that contain plenty of packages and libraries can become harder to use (due to the increase in options and GUI elements). However, this also depends on how those libraries and packages are implemented because IDEs such as the Arduino IDE are incredibly simple. Yet, they contain a vast amount of library support, as well as library managers, that makes including new libraries trivial. But why use an easy-to-use IDE? Remember the previous example with MPLAB 8.92 and MPLAB X? MPLAB 8.92 supports fewer devices than the more recent MPLAB X, and it has far fewer addons and packages. It is incredibly simple and easy to use, whereas MPLAB X can be a tad difficult to navigate around. This is one of the reasons why I often go back to MPLAB 8.92 whenever possible!
IDEs such as the Arduino IDE and Eclipse contain package managers that are one of the best tools available for an IDE. When installing libraries and different language types to an IDE, it often requires complex linking and configuration, which makes no sense to most. Package managers instead allow you to search for a specific library, language, board, or tool that you want to integrate into your project, and they will automatically install everything needed (in addition to automatic linking).
When deciding what IDE you want to use in your next project, you should take the considerations in this article seriously. Some individuals out there will recommend that you only use up-to-date, modern IDEs with plenty of complex functions, but remember that this could cause unnecessary hassle and stress. Always choose the IDE that gets the job done and has the features that you need!