Maria Montero

What are functions in C programming?

This article will help you understand what features are, why they are used, and how they are implemented on embedded hardware.

support information

Every C program has a main () function. It is certainly possible to write a successful program in which the only function is main (). My guess is that this has been done many times, and it is true that in certain simple applications no other function is needed.

However, the extensive use of functions is an indication that the person writing the code is an experienced firmware developer. Why? Because functions allow us to write better code faster, with less work and fewer errors. For those who spend a significant portion of their professional life writing firmware, these are the advantages that cannot be ignored. Even if we initially resist using features because they seem to require more work, experience gradually teaches us that the benefits far outweigh the costs.

What is a function?

A C function is a group of instructions that work together to implement a specific type of processor activity. In many cases, a function will perform a specific task, such as retrieving data from an SPI buffer, setting a timer to generate a specific delay, or reading a value from memory and loading it into a DAC register.

However, there is no law that states that a function can perform only one task. You might find it convenient to have a function that updates three unrelated state machines, or you could write a function that transmits a byte through UART, then checks the status bit until a byte is received, and then incorporates the value of the received byte. in some mathematical calculations.

One thing I like about functions is that they allow for a fairly straightforward translation between a flowchart and code.

The “components” of a function

A function consists of a name, a list of input parameters, the code declarations that implement the required functionality, and a return type.

The following code snippet gives you an example.

                    char Convert_to_Lowercase (char UppercaseLetter)
{
¬†¬†¬†¬†¬†if (may√ļscula 90)
          devuelve 0x00;
     más
          return (UppercaseLetter + 32);
}
                  

I like to make my function names very descriptive. This makes the code more readable and helps you keep your thoughts organized.

Instructions are in square brackets; This part of the function definition is called the body of the function. The keyword “return” is used to exit the function and identify what data should be sent to the part of the code that runs before.

The return type, placed before the function name, identifies the data type of the information to be returned. It is perfectly acceptable to have a function that simply performs a task, without the need to return data. In this case, you would use the keyword “empty” instead of a data type.

Passing data to a function

Input parameters, also called arguments, are enclosed in parentheses and placed after the function name. A C function can have multiple arguments, in which case they are separated by commas. Each argument must be accompanied by a data type.

In embedded applications, it is often not necessary to use arguments. I can think of two reasons for this.

First, the embedded firmware frequently interacts directly with the device hardware, and thus a function can get the information it needs from the configuration registers, communication registers, or port pins.

Second, simple C programs written for microcontrollers can use global variables, that is, variables that are present throughout the program and can be accessed by any function. As I understand it, the use of global variables in application programming is discouraged, or maybe even “doomed” would be the right word. But in my opinion, many firmware projects, especially those written entirely by a programmer, can benefit from the simplicity of global variables.

When defining a function that has no arguments, you can leave the parentheses empty or insert the keyword “empty”. In theory, the “empty” approach is better than empty parentheses, but in the context of integrated development, especially considering how clever modern compilers are, I don’t know how much it really matters.