enum de Arduino, en un temporizador Pomodoro que sabe en qué sesión está
Principiante
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
enum Phase { FOCUS, SHORT_BREAK, LONG_BREAK }; da nombres a los números enteros 0, 1 y 2, y hace de Phase un tipo que guarda uno de ellos. Una variable de ese tipo dice en qué estado está un programa, con palabras en lugar de números, y un switch sobre él le da a cada estado su propio bloque.
El circuito de arriba es un temporizador Pomodoro en un Uno: un display TM1637, una lámpara roja de concentración, una lámpara verde de descanso y dos botones. Su sketch guarda la sesión en Phase phase. Presiona Ejecutar y luego el segundo botón, saltar. El monitor serie imprime "Skipped" y "Short break (1 session done)", y la lámpara verde reemplaza a la roja. Presiona saltar otra vez e imprime "Focus (1 session done)".
Abajo se ve cómo corresponden los nombres a los números, imprimir un enum por su nombre, enum con switch, enum class, y los errores que da un enum, cada uno ejecutado en un Uno con lo que imprimió.
El enum del temporizador
Here are the two lines from the sketch running above. : uint8_t stores a Phase in one byte; without it an enum on the Uno takes 2, the size of an int. The sketch then reads like the method it follows: if (phase == FOCUS), phase = LONG_BREAK. Nothing at run time knows the names. They are for you and for the compiler, which now refuses a phase that is not one of the three.
enum Phase : uint8_t { FOCUS, SHORT_BREAK, LONG_BREAK };
Phase phase = FOCUS;Los números detrás de los nombres
El primer nombre es 0 y cada nombre siguiente es uno más, salvo que le des un valor. Abajo, Serial.println(c) con c puesto en BLUE imprimió 2, y FAST imprimió 50 porque se le dio 50. sizeof(Color) imprimió 2. Los valores son útiles cuando los números significan algo fuera del sketch, como una velocidad o un byte de comando.
Dos nombres pueden compartir un valor, y a un nombre se le puede dar el valor de otro más uno, MEDIUM = SLOW + 15. Los nombres que quedan sin valor siguen contando desde el último que tiene uno, así que tras SLOW = 10, un FASTER suelto sería 11. Mantén la lista en un solo lugar al inicio del sketch, donde todos los estados en que puede estar el programa se leen de un vistazo.
enum Color { RED, GREEN, BLUE };
enum Speed { SLOW = 10, MEDIUM = 25, FAST = 50 };
void setup() {
Serial.begin(9600);
Color c = BLUE;
Serial.println(c);
Serial.println(FAST);
Serial.println(sizeof(Color));
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Imprimir un enum por su nombre
Serial.println() imprime el número, nunca el nombre. Para imprimir el nombre, guarda los nombres en un arreglo en el mismo orden y usa el enum como índice: el sketch de abajo imprimió "green". El sketch del Pomodoro lo hace con una función que devuelve "Focus", "Short break" o "Long break", lo cual es más seguro cuando los valores se asignan a mano, porque entonces los nombres ya no coinciden con las posiciones de un arreglo.
enum Color { RED, GREEN, BLUE };
const char *colorNames[] = {"red", "green", "blue"};
void setup() {
Serial.begin(9600);
Color c = GREEN;
Serial.println(colorNames[c]);
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
enum y switch
Un switch sobre un enum es la forma habitual de una máquina de estados: un case por estado, cada uno haciendo su trabajo y eligiendo el siguiente estado. Si omites un estado, el compilador se da cuenta. El sketch de abajo tiene tres luces y solo dos cases; clang advirtió enumeration value 'YELLOW' not handled in switch, y el sketch imprimió "red" y "green" y luego nada, porque llegó a YELLOW y no tenía case para él. Agrega el case, o un default: a propósito.
enum Light { RED, GREEN, YELLOW };
Light light = RED;
void setup() {
Serial.begin(9600);
}
void loop() {
switch (light) {
case RED:
Serial.println("red");
light = GREEN;
break;
case GREEN:
Serial.println("green");
light = YELLOW;
break;
}
delay(100);
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
enum class: nombres que se quedan en su propia caja
Los nombres de un enum simple pertenecen a todo el sketch, y en silencio se convierten en ints. enum class evita ambas cosas: escribe el tipo antes de cada nombre, Mode::Blink, y compara solo con otros Modes. El sketch de abajo imprimió "blinking", y (int)m imprimió 1.
El precio es que no pasa por un número. Serial.println(m) se detuvo con no matching member function for call to 'println', y if (m == 1) con invalid operands to binary expression ('Mode' and 'int'), clang sin conversión implícita para scoped enum. GCC dice no match for 'operator=='. Haz un cast, como (int)m, cuando de verdad quieras el número.
enum class Mode { Off, Blink, On };
void setup() {
Serial.begin(9600);
Mode m = Mode::Blink;
if (m == Mode::Blink) {
Serial.println("blinking");
}
Serial.println((int)m);
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Los errores que da un enum
Un nombre que Arduino ya usa: enum Level { LOW, MEDIUM, HIGH }; se detuvo con expected identifier, dos veces, porque LOW y HIGH ya están definidos como 0 y 1 antes de que tu sketch empiece. Elige otros nombres, como LEVEL_LOW, o usa enum class.
El mismo nombre en dos enums: OFF en un enum Light y en un enum Fan dio redefinition of enumerator 'OFF'; GCC dice 'OFF' conflicts with a previous declaration. Los nombres de enums simples comparten un solo espacio, así que dales un prefijo o usa enum class.
Recorrerlo: c++ sobre un Color se detuvo con cannot increment expression of enum type 'Color', y Color c = 2; con cannot initialize a variable of type 'Color' with an rvalue of type 'int'; GCC dice invalid conversion from 'int' to 'Color'. Avánzalo con un cast, c = (Color)((c + 1) % 3);, que fue 0, 1, 2 y volvió a 0.
Abre este circuito en el editor. Arduino Uno: un temporizador Pomodoro con su sesión en un enum, cableado tal como corre en la parte superior de esta página. Cambia un componente o un valor y ejecútalo otra vez.
Abrir el circuitoPreguntas
¿Qué es un enum en Arduino?
Una lista de nombres para números enteros que además crea un tipo nuevo. Es la forma en que un sketch nombra sus estados, modos o elementos de menú para que el código diga FOCUS en lugar de 0.
¿Cómo imprimo el nombre de un enum?
Guarda los nombres en un arreglo const char * en el mismo orden e imprime colorNames[c], o escribe una función con un switch que devuelva el nombre. Serial.println() por sí solo imprime el número.
¿Es enum mejor que #define para estados?
Sí. Un enum da un tipo real, así que el compilador puede rechazar un valor que no sea un estado y avisar cuando a un switch le falta uno. Los nombres hechos con #define son solo texto que se sustituye antes de compilar.
¿Cuál es la diferencia entre enum y enum class?
Los nombres de un enum simple son visibles en todas partes y se convierten en int por sí solos. Un enum class guarda sus nombres detrás de su tipo, Mode::On, y necesita una conversión para volverse un número, así que dos enums pueden tener ambos un OFF.
Sigue así
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.