Basic elements of the C language

01Why C in an electronics technician program

There are more comfortable languages, but none combines these four things at once:

• Direct access to the hardware. It lets you write a value into a microcontroller register or read an input port exactly as described in the datasheet.
• Efficiency. The generated code is almost as compact and fast as code written in assembly, and that matters when you have 2 KB of memory.
• Portability. The same program, with minimal adjustments, compiles for a PIC, an AVR, an ARM or a PC.
• Universality. Every microcontroller manufacturer supplies its own C compiler. It is the common denominator of the industry.

02Structure of a program

#include <stdio.h>      // preprocessor directives
#define PI 3.14159    // symbolic constant

float area(float radio);   // function prototype

int main(void)             // EVERY program has a main
{
    float r = 2.5;         // declaration with initialization
    printf("Area = %.2f\n", area(r));
    return 0;                // 0 = finished without error
}

float area(float radio)    // function definition
{
    return PI * radio * radio;
}

03Variables, types and constants

Every variable must be declared before it is used, stating its type. That type determines how much memory it takes up and what values it can hold.

Overflow

unsigned char c = 250;
c = c + 10;     // NOT 260: it gives 4, because 260 does not fit in 8 bits

unsigned char i;
for (i = 0; i < 300; i++) { ... }   // INFINITE LOOP: i never reaches 300

Overflow does not generate any error: the value simply “wraps around.” It is one of the hardest causes to find in an embedded program, which is why the type must be chosen with the maximum possible value in mind, not the usual one.

Constants

#define LARGO 10            // preprocessor: textual replacement, no type
const float PI = 3.14159;   // read-only variable, WITH a type

int a = 255;      // decimal
int b = 0xFF;     // hexadecimal — the most widely used with registers
int c = 0b11111111; // binary (GCC extension, very handy for ports)
int d = 0377;     // OCTAL: the leading 0 changes the base. Classic trap

In electronics hexadecimal is the natural format: each hex digit represents exactly 4 bits, so 0xF0 reads at a glance as “the four high bits set to 1.”

04Operators

Bitwise operators: the essential ones

These are what make C suitable for electronics. They let you manipulate individual bits of a register without touching the others.

// The four operations used all the time with registers:

PORTB |=  (1 << 3);   // set bit 3 to 1, without touching the others
PORTB &= ~(1 << 3);   // set bit 3 to 0
PORTB ^=  (1 << 3);   // toggle bit 3

if (PINB & (1 << 3)) { // is bit 3 set to 1?
    // yes: the pushbutton is pressed
}

if (x = 5)   // ASSIGNS 5 to x, and since 5 is not 0, it is ALWAYS true
if (x == 5)  // COMPARES x with 5. This is what was intended

05Flow control

if (temp > 30) {
    encender_ventilador();
} else if (temp < 18) {
    encender_estufa();
} else {
    apagar_todo();
}

switch (tecla) {
    case 1: subir();  break;
    case 2: bajar();  break;
    default: parar();
}

for (i = 0; i < 8; i++) {
    encender_led(i);
}

while (!dato_listo()) {
    // wait
}

do {
    v = leer_adc();
} while (v < umbral);

while (1) { ... }  // main loop

int main(void)
{
    configurar_puertos();   // runs ONCE
    configurar_adc();
    configurar_timers();

    while (1) {              // repeats FOREVER
        leer_sensores();
        procesar();
        actualizar_salidas();
    }
    return 0;   // never reached
}

06Arrays and strings

An array is a set of elements of the same type, contiguous in memory, accessed by an index that starts at 0.

int muestras[10];              // valid indices: 0 to 9
int tabla[5] = {2, 4, 6, 8, 10};

muestras[0] = 512;             // first element
muestras[9] = 128;             // LAST element
muestras[10] = 0;              // OUT OF RANGE! Overwrites memory that is not yours

// Average 10 samples from the ADC
long suma = 0;
for (int i = 0; i < 10; i++) {
    muestras[i] = leer_adc();
    suma += muestras[i];
}
int promedio = suma / 10;

Character strings

In C a string is simply an array of char terminated by the null character '\0'. It is not a special type.

char nombre[20] = "Electronics";   // takes 11 letters + 1 for the '\0' = 12

#include <string.h>
strlen(nombre);            // 11 — does not count the '\0'
strcpy(destino, origen);   // copy
strcmp(a, b);              // compare: returns 0 if they are equal
strcat(destino, origen);   // concatenate

07Functions

Splitting the program into functions is not cosmetic: it is what lets you test each part separately, reuse code and understand a thousand-line program.

// return_type  name(type param1, type param2)
float celsius_a_fahrenheit(float c)
{
    return c * 9.0 / 5.0 + 32.0;
}

void parpadear(unsigned char veces)   // void: returns nothing
{
    for (unsigned char i = 0; i < veces; i++) {
        PORTB |= (1 << 0);
        retardo_ms(200);
        PORTB &= ~(1 << 0);
        retardo_ms(200);
    }
}

Scope of variables

08The preprocessor and the standard library

The preprocessor acts before the compiler and performs text replacements. It knows nothing about types or C syntax.

#include <stdio.h>       // paste the contents of that file here
#define LED_ON  PORTB |= 1
#define MAX(a,b) ((a) > (b) ? (a) : (b))   // macro with parameters

#ifdef DEBUG              // conditional compilation
    printf("value = %d\n", x);
#endif

#ifndef CONFIG_H          // include guard: avoids including
#define CONFIG_H          // the same file twice
    ...
#endif

The libraries in use

09In the lab

gcc -Wall -c hola.c -o hola.o    # compile to object
gcc hola.o -o hola               # link
./hola                           # run
gcc -E hola.c > hola.i           # see the PREPROCESSOR output

10Common mistakes