Elementos básicos del lenguaje C

01Por qué C en una tecnicatura en electrónica

Existen lenguajes más cómodos, pero ninguno reúne estas cuatro cosas a la vez:

• Acceso directo al hardware. Permite escribir un valor en un registro del microcontrolador o leer un puerto de entrada tal como está en la hoja de datos.
• Eficiencia. El código generado es casi tan compacto y rápido como el escrito en assembler, y eso importa cuando hay 2 KB de memoria.
• Portabilidad. El mismo programa, con ajustes mínimos, compila para un PIC, un AVR, un ARM o una PC.
• Universalidad. Todo fabricante de microcontroladores entrega su compilador de C. Es el denominador común de la industria.

02Estructura de un programa

#include <stdio.h>      // directivas al preprocesador
#define PI 3.14159    // constante simbólica

float area(float radio);   // prototipo de función

int main(void)             // TODO programa tiene un main
{
    float r = 2.5;         // declaración con inicialización
    printf("Area = %.2f\n", area(r));
    return 0;                // 0 = terminó sin error
}

float area(float radio)    // definición de la función
{
    return PI * radio * radio;
}

03Variables, tipos y constantes

Toda variable debe declararse antes de usarse, indicando su tipo. Ese tipo determina cuánta memoria ocupa y qué valores puede guardar.

Desbordamiento

unsigned char c = 250;
c = c + 10;     // NO da 260: da 4, porque 260 no entra en 8 bits

unsigned char i;
for (i = 0; i < 300; i++) { ... }   // BUCLE INFINITO: i nunca llega a 300

El desbordamiento no genera ningún error: el valor simplemente «da la vuelta». Es una de las causas más difíciles de encontrar en un programa embebido, y por eso hay que elegir el tipo pensando en el máximo valor posible, no en el habitual.

Constantes

#define LARGO 10            // preprocesador: reemplazo textual, sin tipo
const float PI = 3.14159;   // variable de sólo lectura, CON tipo

int a = 255;      // decimal
int b = 0xFF;     // hexadecimal — el más usado con registros
int c = 0b11111111; // binario (extensión de GCC, muy cómoda para puertos)
int d = 0377;     // OCTAL: el 0 inicial cambia la base. Trampa clásica

En electrónica el hexadecimal es el formato natural: cada dígito hex representa exactamente 4 bits, así que 0xF0 se lee de un vistazo como «los cuatro bits altos en 1».

04Operadores

Operadores a nivel de bit: los imprescindibles

Son los que hacen a C apto para electrónica. Permiten manipular bits individuales de un registro sin tocar los demás.

// Las cuatro operaciones que se usan todo el tiempo con registros:

PORTB |=  (1 << 3);   // poner en 1 el bit 3, sin tocar los otros
PORTB &= ~(1 << 3);   // poner en 0 el bit 3
PORTB ^=  (1 << 3);   // invertir el bit 3

if (PINB & (1 << 3)) { // ¿el bit 3 está en 1?
    // sí: el pulsador está apretado
}

if (x = 5)   // ASIGNA 5 a x, y como 5 es distinto de 0, SIEMPRE es verdadero
if (x == 5)  // COMPARA x con 5. Esto es lo que se quería

05Control de flujo

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()) {
    // espera
}

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

while (1) { ... }  // bucle principal

int main(void)
{
    configurar_puertos();   // se ejecuta UNA vez
    configurar_adc();
    configurar_timers();

    while (1) {              // se repite PARA SIEMPRE
        leer_sensores();
        procesar();
        actualizar_salidas();
    }
    return 0;   // nunca se llega acá
}

06Arreglos y cadenas

Un arreglo es un conjunto de elementos del mismo tipo, contiguos en memoria, accesibles por un índice que empieza en 0.

int muestras[10];              // índices válidos: 0 a 9
int tabla[5] = {2, 4, 6, 8, 10};

muestras[0] = 512;             // primer elemento
muestras[9] = 128;             // ÚLTIMO elemento
muestras[10] = 0;              // ¡FUERA DE RANGO! Pisa memoria ajena

// Promediar 10 muestras del conversor A/D
long suma = 0;
for (int i = 0; i < 10; i++) {
    muestras[i] = leer_adc();
    suma += muestras[i];
}
int promedio = suma / 10;

Cadenas de caracteres

En C una cadena es simplemente un arreglo de char terminado por el carácter nulo '\0'. No es un tipo especial.

char nombre[20] = "Electronica";   // ocupa 11 letras + 1 del '\0' = 12

#include <string.h>
strlen(nombre);            // 11 — no cuenta el '\0'
strcpy(destino, origen);   // copiar
strcmp(a, b);              // comparar: devuelve 0 si son iguales
strcat(destino, origen);   // concatenar

07Funciones

Dividir el programa en funciones no es cosmética: es lo que permite probar cada parte por separado, reutilizar código y entender un programa de mil líneas.

// tipo_devuelto  nombre(tipo parám1, tipo parám2)
float celsius_a_fahrenheit(float c)
{
    return c * 9.0 / 5.0 + 32.0;
}

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

Ámbito de las variables

08El preprocesador y la biblioteca estándar

El preprocesador actúa antes del compilador y hace reemplazos de texto. No entiende de tipos ni de sintaxis de C.

#include <stdio.h>       // pegar el contenido de ese archivo acá
#define LED_ON  PORTB |= 1
#define MAX(a,b) ((a) > (b) ? (a) : (b))   // macro con parámetros

#ifdef DEBUG              // compilación condicional
    printf("valor = %d\n", x);
#endif

#ifndef CONFIG_H          // guarda de inclusión: evita incluir
#define CONFIG_H          // dos veces el mismo archivo
    ...
#endif

Las bibliotecas que se usan

09En el laboratorio

gcc -Wall -c hola.c -o hola.o    # compilar a objeto
gcc hola.o -o hola               # enlazar
./hola                           # ejecutar
gcc -E hola.c > hola.i           # ver la salida del PREPROCESADOR

10Errores frecuentes