Aprender

Arduino const y #define: dos formas de darle nombre a un número

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: un pin con nombre, parpadeandoen vivo0.000 s 0.00x
Presiona Ejecutar y luego cambia LAMP a 12
const int LAMP = 13; names the pin once. Change it to 12 and the yellow lamp blinks instead.

Ambos le dan un nombre a un número, para que puedas escribir LAMP en lugar de 13 y cambiarlo en un solo sitio. const int LAMP = 13; crea una variable con un tipo que nunca puede cambiar. #define LAMP 13 le dice al compilador que busque cada LAMP del sketch y pegue 13 en su lugar antes de compilar nada. Para números de pin y configuraciones, usa const: la referencia de Arduino lo recomienda, y evita todos los errores de abajo.

El circuito de arriba es el banco de código, un Uno con tres lámparas. Presiona Ejecutar. La lámpara roja del pin 13 parpadea, y el monitor serie imprime "hello from the board", "setup() has run once" y luego "loop() pass 1", "loop() pass 2" y así. El pin se nombra una sola vez, arriba, como const int LAMP = 13;. Cambia el 13 por 12, presiona Ejecutar, y parpadea el pin 12, la lámpara amarilla.

Abajo verás qué hace #define, por qué LED_BUILTIN es uno, y las cinco formas en que un #define falla donde un const no, cada una hecha en Mokxi con lo que imprimió o el error que dio.

¿Quieres la versión paso a paso? La lección "Un programa es una lista" recorre esto con puntos de control.

Abrir la lección

Un nombre para un pin

Aquí está el sketch completo que corre arriba. LAMP se usa tres veces y se define una sola vez. Sin el nombre, cambiar el pin significaría buscar cada 13 del sketch y esperar que ninguno significara otra cosa.

const means the value is fixed. Try to change it, LAMP = 12; inside setup(), and the build stops: clang says cannot assign to variable 'LAMP' with const-qualified type 'const int', and the Arduino IDE’s GCC says assignment of read-only variable 'LAMP'. That is the point: a pin number that changes while the sketch runs is a bug.

firmware/uno/examples/cpphello (el sketch que corre arriba)
const int LAMP = 13;

int passes = 0;

void setup() {
  pinMode(LAMP, OUTPUT);
  Serial.begin(115200);
  Serial.println("hello from the board");
  Serial.println("setup() has run once");
}

void loop() {
  passes = passes + 1;
  Serial.print("loop() pass ");
  Serial.println(passes);

  digitalWrite(LAMP, HIGH);
  delay(200);
  digitalWrite(LAMP, LOW);
  delay(800);
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Qué hace #define en realidad

Un #define no es una variable. Es un buscar y reemplazar, aplicado al texto del sketch antes de que el compilador lo lea. #define LAMP 13 no tiene tipo y no ocupa memoria; cada LAMP después de él simplemente se convierte en 13.

Ya los usas. LED_BUILTIN es #define LED_BUILTIN 13 en el núcleo del Uno, e imprimirlo imprimió 13. HIGH es un #define para 1 e imprimió 1. Por costumbre se escriben en mayúsculas, así que un nombre en mayúsculas le dice al lector que podría ser un #define, y un const también suele escribirse en mayúsculas, porque hace el mismo trabajo.

El punto y coma y el signo igual

Una línea de #define no es una instrucción, así que no lleva punto y coma ni signo igual. Con #define LED 13;, el punto y coma se pega junto con el 13, así que pinMode(LED, OUTPUT); se convierte en pinMode(13;, OUTPUT);. Clang dice expected ')', con una nota que apunta de vuelta al #define, expanded from macro 'LED'; GCC dice expected ')' before ';' token. El error aparece en la línea que usa el nombre, no en la línea equivocada, y por eso cuesta tanto encontrarlo.

#define LED = 13 falla igual, como pinMode(= 13, OUTPUT), y clang dice expected expression. Un const no puede cometer ninguno de esos errores: const int LED = 13; es una instrucción normal, con su signo igual y su punto y coma donde corresponden.

Un punto y coma pegado
#define LED 13;

void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Paréntesis faltantes

Como un #define pega texto, la suma que pega se mezcla con lo que la rodea. Con #define WIDTH 10 + 5, WIDTH * 2 se convierte en 10 + 5 * 2 e imprimió 20, mientras que const int WIDTH_C = 10 + 5; al duplicarse imprimió 30. Un #define con parámetros es peor: #define SQUARE(x) x * x convirtió SQUARE(1 + 2) en 1 + 2 * 1 + 2 e imprimió 5. Con paréntesis en cada uso y alrededor de todo, ((x) * (x)), imprimió 9.

Un #define tampoco tiene tipo, así que su suma se hace en int. #define SECONDS 60 * 60 * 24 imprimió 20864 para un día, con una advertencia de desbordamiento, mientras que const long SECONDS_C = 60L * 60 * 24; imprimió 86400. La página de tipos de datos explica por qué.

Sumas pegadas
#define WIDTH 10 + 5
#define SQUARE(x) x * x
#define SQUARE_OK(x) ((x) * (x))
const int WIDTH_C = 10 + 5;

void setup() {
  Serial.begin(9600);
  Serial.println(WIDTH * 2);
  Serial.println(WIDTH_C * 2);
  Serial.println(SQUARE(1 + 2));
  Serial.println(SQUARE_OK(1 + 2));
  Serial.println(LED_BUILTIN);
  Serial.println(HIGH);
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Nombres que chocan

Un #define reemplaza su nombre en todas partes después de él, en cada función, sin excepciones. Tras #define LED 13, una línea dentro de setup() que dice int LED = 5; se convierte en int 13 = 5;, y clang dice expected unqualified-id. Lo mismo pasa con los nombres que el núcleo de Arduino ya definió. const float PI = 3.14; parece inofensivo y detuvo la compilación con el mismo error, porque PI ya es un #define en el núcleo y la línea se convirtió en const float 3.14159... = 3.14;.

Si defines el mismo nombre dos veces, gana el segundo, con solo una advertencia. #define LED 13 seguido de #define LED 12 imprimió 12, y la pestaña de compilación dijo 'LED' macro redefined. Dos const con el mismo nombre en el mismo lugar detienen la compilación, que es la respuesta más segura.

Para qué sirve aún #define

Usa const para números, pines y configuraciones, y constexpr para un valor calculado a partir de otros, como en constexpr int LIMIT = COUNT * 2;, que imprimió 6. Un const int también puede dar el tamaño de un arreglo: int pins[COUNT] con COUNT en 3 midió 6 bytes, tres int de 2 bytes.

Un #define es la herramienta correcta para activar y desactivar código antes de compilarlo. Con #define DEBUG arriba, las líneas entre #ifdef DEBUG y #endif se compilan, y nuestro sketch imprimió "start" y "debug: setup done". Borra el #define y el mismo sketch imprimió solo "start", y las líneas de depuración nunca se compilaron.

Líneas de depuración que van y vienen
#define DEBUG

void setup() {
  Serial.begin(9600);
  Serial.println("start");
#ifdef DEBUG
  Serial.println("debug: setup done");
#endif
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Abre este circuito en el editor. Arduino Uno: un pin con nombre, parpadeando, cableado como se ejecuta arriba en esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Preguntas

¿Debo usar const o #define en Arduino?

Usa const para números de pin y configuraciones. Tiene un tipo, sigue las reglas normales de los nombres y no permite pegar un punto y coma o una suma de más. Deja #define para activar y desactivar código con #ifdef.

¿Un #define usa memoria en un Arduino?

No. Se reemplaza antes de compilar, así que en el código solo queda el número.

¿Por qué un #define con punto y coma da un error?

Porque el punto y coma se pega junto con el valor. #define LED 13; convierte pinMode(LED, OUTPUT) en pinMode(13;, OUTPUT), y el error aparece en esa línea, no en el #define.

¿Qué significa "expected unqualified-id" con un #define?

Un nombre que usaste ya es un #define, así que fue reemplazado por un número donde el compilador esperaba un nombre. Arduino define PI, HIGH, LOW, INPUT y otros; elige un nombre diferente.

¿Cuál es la diferencia entre const y constexpr?

Ambos crean un valor que no puede cambiar. constexpr además le promete al compilador que puede calcularlo durante la compilación, así que puede usarse en cualquier lugar donde se necesite un número fijo, como el tamaño de un arreglo.

¿Cuál es la diferencia entre const int e int?

Un int puede cambiar mientras el sketch corre y un const int no. Escribe `LAMP = 12;` después de `const int LAMP = 13;` y la compilación se detiene con cannot assign to variable 'LAMP' with const-qualified type 'const int'; el GCC del IDE de Arduino dice assignment of read-only variable 'LAMP'. Ese error es el objetivo: un número de pin no puede cambiarse por accidente.

Fuentes

De dónde vienen los datos de esta página

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.