Overview
So hello guys, welcome to series of Microcontroller tutorials. As Microcontrollers are big thing happening across the globe, but to learn about microcontrollers becomes quite challenging as most of the content on web is theoretical based and quite unorganized. Or the content is only roaming around 2-3 microcontrollers (Arduino, ESP or PIC), even though there are number of Microcontrollers of different vendors. Also, framework of Arduino and Arduino IDE hides most of the things that are going inside the microcontrollers.
Would recommend viewers to read these 3 blogs in order, so as to get understanding on how to get started with any Microcontroller and in what order.
- How to start with Microcontrollers? – gettobyte
- Hardware Development Kit In Mcrocontrollers – gettobyte
- Software Development Kit In Microcontrollers – gettobyte
Here at Gettobyte, you will get content on microcontroller tutorials for different vendors in chronological way and covering the topics, in a much more interesting and story kind of way to make people understood easily.
- NXP Semiconductors – gettobyte
- Nordic SoC – gettobyte
- STM32 MCU’s – gettobyte
- Texas Instruments – gettobyte
- Silicon Labs – gettobyte
- AVR MCU – gettobyte
- ESP SoC – gettobyte
Which will help you to learn important skills to build you Carrer on Semiconductor Industry and also help you in product development/DIY projects for different Industries, so as to make embedded devices with Industry standard Microcontroller.
In return what Gettobyte platform seeks is that if you find these blogs insightful, then share it with people so make the reach more. And provide with constructive feedback and reviews in blogs comment section .
If you guys want to start with microcontroller coding and looking for chronological order, then you have come to right place.
In the last 2 blog:
- we get to know a lot about microcontrollers and how to start with them.
- And Hardware Development KIT in microcontrollers.
One of the essential and important things to know before starting with microcontrollers is Software Development Kit. So, let’s start with it.
In this blog we are going to start with another essential and important things to know before starting with microcontrollers that is Software Development Kit (SDK).
Objective of this blog
Objective of this blog, will be to understand:
- What is Software Development Kit in Embedded (SDK).
- Different components in Software Development Kit in Embedded.
- Why there is need of Software Development Kit in Embedded.
What is Software Development Kit?
Software Development Kit in embedded is collection of Software tools and applications, Software libraries, documentations to program the microcontrollers via host computer.
Software Development Kit(SDK) majorly include:
- Software Stack for Microcontrollers
- Code Configuration Tools
- Software Debugging Tools
- Software drivers for debuggers and programmers.
- Integrated Development Environment (IDE)
Software Stack for Microcontrollers
Microcontrollers are not only hardware devices, but there is also very good amount of software used in microcontroller to run them, which are termed as software stack for microcontrollers. Software stack for microcontrollers can be divided into following components:
- Peripherals Drivers/Real Time Drivers: for using the peripherals of microcontrollers. This software controls the registers of microcontrollers to configure, enable, disable and use the different peripherals of microcontroller. Every MCU vendor design and develop these Drivers for their corresponding microcontroller. so that application developers can directly start with application development instead of creating these drivers on own. These drivers are kind of bare metal programming, as it is register level programming. which are written using C/CPP language using the concepts like Functions, loops, variables, static, user defined data types (typedef, Enums, structures), arrays and etc. For e.g. NXP semiconductors has S32K Standard software stack for its S32K1 Microcontrollers. Texas Instruments has
- Miscellaneous Stack: Peripheral Drivers is stack to drive the microcontroller peripherals, but with these peripheral drivers their is use of other embedded software technologies to build complex and real time applications like RTOSes(FreeRTOS, ChibiOS, Mbed and etc), IoT protocols Stacks( WiFi, BLE, Lora, LwIP, MbedTLS,and etc), Bootrom(openBLT), Sensor & Module drivers, crytography stack for providing security and safety in embedded applications, mathematics or signal processing algorithms stack for doing complex calculations. These all are also written using C/CPP language and it requires knowledge of programming along with hardware knowledge too.
- Peripheral Abstraction Layer/Hardware Abstraction Layer: This software stack is for code portablity and modularity in microcontrollers. Their are so many microcontrollers out their and for every MCU their is different peripheral driver. So if we change the microcontroller in our application, we need to rewrite the code of our application. This can be very cumbersome, there is need of some form of abstraction layer, through which our application end APIs remain same and just low-level driver files has to be changed if hardware is changed. This is done through the concept of C/CPP programming with use of programming concepts like, Classes, Structures, function pointers, templates, MACRO definition, linked lists and etc. In the large code bases like Autosaur and Ardupilot, Code portability is very essential, and use of Abstraction layers are heavy implemented through advance programming concepts like that of OOPS.
For the starting we would just be needing peripheral drivers and abstraction layer stack of microcontrollers. These are provided by corresponding microcontroller vendors.
// Examples of different peripheral drivers of MCU’s
Code Configuration Tools
As told in above sections there are many software stacks used in microcontrollers, so to design and develop the code using these software stack from scratch would be very cumbersome. As we need to include files for every stack and necessary configuration has to be done for building and compiling the code.
So Code Configuration Tools are the software tools, which provide GUI based interface and environment to configure the software stack. We just need to select the hardware(microcontroller), what features we need and what all software components and peripheral to be enabled and then click on a button to generate the code. These tools then generate all the base software automatically from startup code to make files for the configured project.
The features of CCT includes Graphical User Interface (GUI), tools for configuring peripherals, code generation and project building.
In Arduino environment, their is no feature like this we need to manually add all files and software components.
//Examples of different code configuration tools
Every microcontroller vendor has such tool for their corresponding microcontrollers. Like STMicroelectronics has STM32CubeMXProgrammer for STM32 microcontrollers, Atmel Start their for ATSAMD microcontrollers by microchip and one can explore these tools in the website of corresponding microcontroller vendor website.
Software Debugging Tools/Miscellaneous Software Tools
Like in hardware we were need of Hardware tools to debug the program in microcontrollers. Same way from software end we need certain software files to do that. GDB and OpenOCD are the software debugging tools that are required to make the connection with hardware debuggers so that debugging can be done. These are usually part of the compiler package (like GNU GCC) and has code optimization features so that elf has extra debugging information. More on this would be told in this blog.
Also, there are other software tools to monitor and analyze the power consumption that would be by the code which we have written, for IoT applications RF analysis and etc. To explore Different software tools, navigate to Webpage of Software development kit of corresponding microcontroller.
Integrated Development Environment(IDE)
An Integrated Development Environment (IDE) is a software application that provides a comprehensive set of tools and features for software development. It is designed to streamline the development process by combining various tools into a single interface, making it easier for programmers to write, edit, compile, debug, and test their code.
Typically, an IDE includes a source code editor with features like syntax highlighting, code completion, and code navigation, which assist developers in writing code efficiently. It also provides built-in build automation tools that help compile and run the code, along with debugging capabilities to identify and fix errors in the code.
An IDE for embedded systems provides tools and features that are tailored to the unique requirements of embedded programming. It typically includes:
Code Editor: An embedded IDE includes a code editor with syntax highlighting and code completion capabilities, specific to the programming language used for embedded development, such as C or C++.
Compiler and Toolchain: The IDE integrates a compiler and toolchain specific to the target hardware platform and microcontroller used in the embedded system. These tools are responsible for translating the high-level code into machine code that can run on the embedded system.
Debugger: An essential component of an embedded IDE is the debugger, which allows developers to analyze and debug their code while it is running on the target hardware. It helps identify and fix issues, such as memory leaks, incorrect behavior, or timing problems.
Simulator/Emulator: Some embedded IDEs provide simulators or emulators that allow developers to test and debug their code without the need for physical hardware. This enables faster development and testing cycles.
Hardware Integration: Embedded IDEs often offer integration with specific hardware platforms, providing libraries, APIs, and tools to interact with the hardware components of the embedded system. This integration may include features like GPIO (General Purpose Input/Output) configuration, device drivers, and real-time operating system (RTOS) support.
Flashing and Deployment: The IDE includes tools for programming and deploying the compiled code onto the embedded system, such as flashing the firmware onto microcontrollers or programming memory devices.
//Examples of different IDE’s
These IDEs provide an integrated and efficient development environment, specific to embedded systems, to facilitate the coding, debugging, and deployment processes involved in embedded software development.
What is need of Software Development Kit(SDK)
As told in Previous blog that microcontrollers need some software/program to run. It is the program that is inside the microcontroller that tells it what to do and when to do for corresponding embedded application.
Now microcontrollers only understand digital language of 0 & 1’s, that is they are binary in nature. But we humans can’t understand 0 & 1 language. Thus, there is need of some kind of environment which can act as an interface between humans and microcontrollers. Thus, programming languages are originated. Programming languages are logical in nature and written using English alphabets and math’s digits. Which humans can easily learn/understand. Programming language used in embedded is assembly, embedded C, C, CPP language. The program written using these languages is often called as high-level language (as that is understandable by humans). We write the program in header files(.h) and source files(.c) using these languages. Now we need a place where we can write the program using this language, that are called as Text editors. There are many text editors that are used in embedded like VS-Code, Eclipse IDE and etc.
Program written using these languages is compiled into binary format using the compiler. The type of compiler used in embedded is cross-compiler. There is a process of converting the high-level code into the low-level format (another name of binary format code), that is called as compilation process. Cross compilers have the software files like linker, assembler, compiler and some standard software libraries. Examples of cross compilers for microcontrollers are GNU GCC, GHS, IAR, DIAB compiler. Their are different compiler files and packages for different microocntrollers and CPU present in them. Like for ARM processor-based microcontroller and Power processor-based microcontrollers there would be different cross compilers.
Now for building all the files (.c & .h) that are written in text editor and then compiling the program to low-level format that is understandable by microcontrollers there is need of some tool that can do all these stuffs automatically. These Automation tools are called Build Automation Tools. Examples of Build AUtomation tools in embedded are Make files, Waf scripts, Zebra Tools Hub. Make Files are the most widely used build automation tool used.
Apart from these there are many other software tools to needed to ease the development of programming the microcontrollers, like:
- Peripheral Drivers also called as Real Time Drivers of the corresponding MCU.
- Code Configuration Tools to generate the base code for microcontrollers like: S32CubeProgrammer for STMicroelectronics, S32 Design Studio code configuration tools for NXP Semiconductor S32 Automotive MCU’s and etc.
- Software Packages of RTOSes, IoT Stacks and miscellaneous packages to build different applications over the microcontrollers.
- Software Debugging files to debug the program.
So, you can see for writing the code for programming the microcontrollers, we have to create an environment on host desktop/computer. This environment includes components like Text Editors, Build Automation tools, Cross compilers and software debugging files. This can be bit cumbersome to integrate all these components separately. Thus, there is environment called as Integrated Development Environment (IDE), which is solution to this. IDE are the software applications that integrates all these components into one place and makes easy for us to develop programs for microcontrollers. There are different IDEs for different microcontroller families. Like For STM32 MCU’s there is STM32CubeIDE, Segger Studio, For NXP semiconductors S32 Automotive MCU’s there is S32 Design Studio IDE, Code Compiler Studio.
To Conclude
Well to program the microcontrollers, there is need of Software Development Kit.
- First thing that to look for is Integrated development Environment for the corresponding MCU. Semiconductor company that is designing and developing the microcontrollers, also provides its IDE for users to easily program the MCU’s.
- Next thing is Software Stack for microcontrollers. This includes, peripheral drivers (also called as real time drivers), Hardware Abstraction Layers (HAL) for code portability. Other software stacks like: RTOSes, IoT protocols, Sensor & Module drivers for developing complex and real time applications in microcontrollers. All these are also usually provided by semiconductor company of corresponding MCU.
Now to get started viewers can start with NXP Semiconductors S32K144 MCU. You can find tutorial blog on how to set-up the SDK for S32K144 MCU and then move to tutorial blogs on how to use/program different peripherals of S32K144 MCU .
Buy the S32K144 General Purpose development board: ElecronicsV1. Its breadboard and easy to use development board is best way to start having hands on this MCU. It is designed and developed by Gettobyte. But you have bought the external debugger/programmer for dumping code on it (I am trying to make its external debugger too just like STLINKV2 using OpenSDA interface).
To get started with NXP Semiconductors S32K144 MCU, refer these blogs:
- S32K144 Eval Board & S32K144 breadboard board
- Gettings started with S32 Design Studio
- Peripheral Drivers
- Sensor/Module Interfacing
There are many other MCU’s tutorial blogs too on all of their peripherals. Explore from here.
More Blogs to Read
Kunal Gupta
Author: Kunal Gupta
