How to write header file for microcontroller

With CPU clock speeds going as high as MHz and having an enormous variety of chips to choose from, they open up a whole new world of possibilities. You may have heard of projects like STM32duino , which aim to make some popular STM32 development boards compatible with the Arduino platform. While this may be an attractive middle ground for some, it is outside the scope of this article, and can still suffer from the optimization issues I just mentioned.

The most significant shift from Arduino to STM32 is by far the programming experience. Additionally, the code comes pre-structured with setup and loop functions, with the contents of the setup function being run once on startup, and the loop function running again and again indefinitely when the setup function has finished executing.

Even with the inclusion of third-party libraries, the majority of user-provided code will still end up in this single sketch file, with the user writing definitions for these setup and loop functions as well as potentially other helper functions. These qualities are specific to the Arduino platform, which is why Arduino sketches also have a proprietary. Variables are defined there, as well as functions. A header file will instead provide things like function declarations for external libraries, or more generally, declarations for some interface that is also defined by a corresponding source file.

This is a trivial difference, however structuring your main function as follows will set up a program to execute in the same way an Arduino sketch does:. Generally there will also be a variety of other source and header files making up the project, some which will be created by the programmer and some that will be provided by the IDE. This actually brings us to the next major element of the programming experience.

What software is being used to create and upload code, if not the Arduino IDE? This is actually a very open-ended question, as even Arduino-compatible chips may be used outside of the Arduino environment. Programming like this is the best way for a more experienced developer to truly maximize performance, but it is an especially large leap coming from Arduino, which combines the editing, compiling, and flashing sequence seamlessly and does all the heavy lifting under the hood.

It is an Eclipse-based IDE, which means that it is a modified version of the ubiquitous general-purpose Eclipse code editor. This means that code will have features like auto completion, and the ability to search for definitions or declarations of variables and functions, which makes the actual process of programming for larger applications much easier. Perhaps its most powerful feature, however, is its integration with STM32 firmware generation software, which provides a graphical interface for enabling and configuring the various hardware components within an STM32 and automatically generating firmware and setup functions that match the selected options.

The following image is a screengrab of the pinout tool, which is available for practically every available STM32 microcontroller. You can see that the I2C1 bus has been enabled, and two pins in the image to the right have been highlighted green and labeled to indicate which I2C pins they are.

The window to the left shows the various configuration options that are available to that I2C bus, such as the ability to change its speed. This feature makes taking full advantage of the powerful peripherals available to the STM32 chips incredibly straightforward, and makes it much less necessary to spend time poring over a datasheet figuring out how to increase the resolution of your analog-to-digital converter or set your SPI bus to slave mode.

These options have been neatly laid out for you in this graphical interface! The resulting generated code files provide commented blocks within which to write your own user code, which can be seen in the main. Live debugging allows you to step through your code line-by-line while it is running. You can place breakpoints to pause your program at certain lines for inspection, and even view live, constantly updating variables without needing to write a single print statement or any other code.

Simply press the debugging button when ready to test a program, and the code will automatically compile, upload, and pause at the start of execution. Live debugging drastically increases productivity when writing and testing code, particularly for embedded systems. Another necessary step in the transition from Arduino to STM32 is understanding and addressing the key hardware differences between the two families.

Perhaps most critically, especially if your embedded device is built into a custom PCB, is that STM32 chips use a logic level of 3. While 3. This means that in any supporting circuits, PCBs, etc. Additionally, make sure that any inputs, such as GPIO pins reading the status of a switch, or analog pins reading a variable resistor, are limited between 0 and 3.

If you are mounting your microcontroller on a custom PCB , then it is also necessary to adjust the surrounding circuitry compared to what may have been done for an Arduino chip. Exact values and practice can vary slightly from chip to chip, but it is generally advised to place a ceramic bypass capacitor at each power supply input on the microcontroller.

To take full advantage of the more capable hardware, you may also wish to provide the STM32 chip with an external clock oscillator and a dedicated voltage reference IC for the analog reference pin this makes the ADC reference point extremely stable compared to just connecting it to the same supply used for power. You may have done one or all of these things before with Arduino chips, but they should be considered doubly important now.

Finally, the interface for uploading code to the microcontroller is different. If you are used to just Arduino development boards, then most likely you have only uploaded code directly over the USB port on those boards. For those who have created their own PCBs with Arduino-compatible microcontrollers onboard, it is likely that you are also familiar with the AVR-ISP programmer, which connects to an SPI interface as well as the reset pin on the microcontroller.

Also, you can open existing projects, close projects and import from this menu. After that, this window will pop up. After that click on the Next button. Now we will select a target microcontroller that we want to use. You must select a microcontroller that you want to use.

Type the name of the pic microcontroller in the device window. Now form select tool option, we can select the hardware tools such as programmers, debugger or other tools. Otherwise, you can select from other available options. Moreover, if you are not using any hardware and just want to use a simulator, you can select a simulator option. From compiler toolchains, select the compiler you want to use.

Right now, it is showing only XC8 compiler and mpasm. But if you have installed multiple compilers all will show here. Now select the XC8 compiler and click on the next button. In this last step, we will select the location where we want to store a PIC16FA project in our system. Type a name for the project in the Project Name field. Click Browse to set the location of the project files. Now click on the finish button, it will create a new project and you will see a project window in MPLAB as shown below:.

The easiest way to add source will is through a project window option. After you click on the main. Similarly, we can add header files also. It will create a new source file. The file contains this minimum code. This header file microcontroller specific features. After you finish writing your first program, you will need to compile the code to generate hex file and to see if there is an error in the code.

To compile code, click on a building project button. If there is no error in the code, it will display a message of successfully built and generate a hex file. You can upload this hex file to your microcontroller. You can read this tutorial on how to upload code to pic microcontroller using PICKit3 programmer:.

If you are using proteus, you can get a hex file from your project folder and upload it to the proteus. In this section, we will take an example code and compile this code. After that, we will upload hex file into proteus file and see how it works. Configuration bits file defines main features of pic microcontroller such as oscillator setting, watchdog timer, Power-on Reset, Brownout detect settings, etc.

To know more about configuration bits, read this post:.