Entornos de desarrollo C y C++

01La cadena de herramientas

Programar un microcontrolador tiene una diferencia central respecto de programar una PC: el programa se escribe y compila en una máquina y se ejecuta en otra. Eso se llama compilación cruzada.

02Punteros

Un puntero es una variable que guarda una dirección de memoria. Es el concepto que más cuesta y el que más rinde: sin punteros no hay acceso a hardware, ni paso por referencia, ni estructuras de datos.

int  x = 42;
int *p;          // p es un puntero a int

p = &x;         // p toma la DIRECCIÓN de x
printf("%d", *p);  // imprime 42 — * accede al CONTENIDO
*p = 7;          // ahora x vale 7, sin nombrar a x

Para qué sirven realmente

// NO funciona: recibe copias
void mal(int a, int b) {
    int t = a; a = b; b = t;
}

// SÍ funciona: recibe direcciones
void bien(int *a, int *b) {
    int t = *a; *a = *b; *b = t;
}
bien(&x, &y);

void leer_sensor(int *temp,
                 int *hum)
{
    *temp = medir_t();
    *hum  = medir_h();
}

int t, h;
leer_sensor(&t, &h);

Aritmética de punteros

Sumarle 1 a un puntero no le suma 1 a la dirección: le suma el tamaño del tipo apuntado. Esa es la razón por la que el puntero tiene tipo.

int v[5] = {10, 20, 30, 40, 50};
int *p = v;        // el nombre del arreglo YA es la dirección del primer elemento

*p        // 10  — equivale a v[0]
*(p + 2)  // 30  — equivale a v[2]; avanzó 2 * sizeof(int) bytes
p[2]      // 30  — la notación de corchetes ES aritmética de punteros

// Recorrer un arreglo con punteros
for (int *q = v; q < v + 5; q++) {
    printf("%d ", *q);
}

03Estructuras, uniones y typedef

Una estructura agrupa datos de tipos distintos bajo un mismo nombre. Es lo que permite tratar «un sensor» o «una medición» como una sola cosa.

typedef struct {
    uint8_t  id;
    int16_t  temperatura;   // en décimas de grado
    uint16_t humedad;
    uint8_t  valido;
} Sensor;

Sensor s1;
s1.id = 3;
s1.temperatura = 235;      // 23,5 °C

Sensor red[8];             // un arreglo de estructuras
red[0].humedad = 640;

Sensor *ps = &s1;
ps->id = 4;                // con puntero se usa -> en vez de .

union {
    uint16_t palabra;
    uint8_t  byte[2];
} conv;

conv.palabra = 0xABCD;
// conv.byte[0] y [1] son
// 0xCD y 0xAB (o al revés,
// según endianness)

struct {
    uint8_t habilitado : 1;
    uint8_t modo       : 2;
    uint8_t prescaler  : 3;
    uint8_t reservado  : 2;
} ctrl;

ctrl.modo = 2;   // legible

04Acceso al hardware y device drivers

Acá se junta todo lo anterior. En un microcontrolador, los periféricos se manejan escribiendo y leyendo registros ubicados en direcciones fijas de memoria. Un puntero a una dirección concreta es el mecanismo que lo hace posible.

// Un registro es un puntero a una dirección fija, marcado volatile
#define PORTB  (*(volatile uint8_t *) 0x25)
#define DDRB   (*(volatile uint8_t *) 0x24)
#define PINB   (*(volatile uint8_t *) 0x23)

DDRB  |= (1 << 0);   // PB0 como salida
PORTB |= (1 << 0);   // PB0 en alto

Los tres elementos de esa línea son los que hay que entender:

• (volatile uint8_t *) 0x25 — convierte el número 0x25 en un puntero a un byte en esa dirección.
• volatile — le prohíbe al compilador optimizar los accesos, porque el valor puede cambiar por hardware.
• *(...) — desreferencia, de modo que PORTB se comporta como una variable común.

Qué es un device driver

Es la capa de software que traduce entre «lo que el programa quiere hacer» y «los registros que hay que tocar». Aísla al resto del programa de los detalles del chip.

// ---- led.h : la INTERFAZ, lo único que ve el resto del programa ----
void led_init(void);
void led_on(uint8_t n);
void led_off(uint8_t n);
void led_toggle(uint8_t n);

// ---- led.c : la IMPLEMENTACIÓN, específica de este micro ----
#include "led.h"
#include "registros.h"

void led_init(void)          { DDRB = 0xFF; PORTB = 0x00; }
void led_on(uint8_t n)     { PORTB |=  (1 << n); }
void led_off(uint8_t n)    { PORTB &= ~(1 << n); }
void led_toggle(uint8_t n) { PORTB ^=  (1 << n); }

05Bootloaders

Un bootloader es un programa pequeño que vive en una zona reservada de la flash y se ejecuta primero al encender. Su función es poder grabar el resto de la flash sin necesidad de un programador externo.

06Tiempo real e interrupciones

Un sistema es de tiempo real cuando responder tarde equivale a responder mal. No significa «rápido»: significa previsible. Un airbag que se dispara 200 ms tarde falló, aunque el procesador sea velocísimo.

while (1) {
  if (boton_apretado())
      accion();
  otras_tareas();
}

ISR(INT0_vect) {
    bandera = 1;   // corta
}

while (1) {
  if (bandera) { ... }
}

07Concurrencia

Apenas hay interrupciones, hay dos flujos de ejecución compartiendo variables. Y ahí aparecen errores que no existen en un programa secuencial.

volatile uint16_t contador;   // 16 bits en un micro de 8 bits

ISR(TIMER0_OVF_vect) { contador++; }

int main(void) {
    while (1) {
        uint16_t c = contador;   // ← PELIGRO
        ...
    }
}

uint8_t sreg = SREG;   // guardar el estado previo
cli();                  // deshabilitar interrupciones
uint16_t c = contador; // lectura atómica
SREG = sreg;            // restaurar (NO hacer sei() a ciegas)

08En el laboratorio

09Errores frecuentes