Tipos de datos de Arduino: qué tan grande es cada caja
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
Every variable has a type that says what it can hold. On an Arduino Uno, int is 2 bytes and holds -32768 to 32767, long is 4 bytes and holds about plus or minus 2 billion, byte holds 0 to 255, bool holds true or false, char holds one character, and float holds decimals to about seven digits. Pick the type by the biggest number the variable will ever hold.
El circuito de arriba es el banco de código, un Uno con tres lámparas. Presiona Ejecutar y el monitor serie imprime cada variable que creó el sketch, luego "sizeof(int) = 2" y "sizeof(long) = 4", y al final "32000 + 1000 in an int = -32536": un int que se pasó del tope y regresó por abajo.
Abajo está el tamaño de cada tipo en un Uno y un ESP32, las cuatro formas en que los números salen mal sin ningún error, y cómo convertir un float en un int, cada una ejecutada en Mokxi con lo que imprimió.
¿Quieres la versión paso a paso? La lección "Las variables tienen un tamaño" recorre esto con puntos de control.
Abrir la lecciónLos tipos, y sus tamaños
Estas son las cinco variables del sketch que corre arriba, una de cada tipo común. Una variable se crea escribiendo su tipo, un nombre y, normalmente, un valor inicial. char grade = 'A'; usa comillas simples, porque un char es un solo carácter.
The sizes are not the same on every board. We printed sizeof for each type on an Uno and on an ESP32-C3. bool, char and byte were 1 byte on both, and long and float 4 on both. But int was 2 bytes on the Uno and 4 on the ESP32-C3, and double was 4 on the Uno and 8 on the ESP32-C3. A sketch that counts past 32767 in an int works on an ESP32 and goes wrong on an Uno. When the size matters, say it: int16_t, int32_t and uint8_t are the same size everywhere.
byte lampCount = 3;
int blinkMs = 400;
long totalMs = 0;
bool lampsOn = false;
char grade = 'A';Cuando un número no cabe
Nada detiene a un número en el tope de su tipo. Da la vuelta hacia abajo, como mostró el sketch de arriba con 32000 + 1000 imprimiendo -32536. int x = 40000; imprimió -25536, y la pestaña de compilación advirtió: implicit conversion from 'long' to 'int' changes value from 40000 to -25536.
Los tipos sin signo dan la vuelta al revés. unsigned int u = 0; menos uno imprimió 65535, y un byte en 255 más uno imprimió 0. Por eso un contador en un byte hace un ciclo que nunca termina, y por eso los tiempos de millis() van en un unsigned long, que dura 49.7 días antes de dar la vuelta.
La suma que se desborda antes de guardarse
Este atrapa a quienes sí eligieron el tipo correcto. long minute = 60 * 1000; imprimió -5536, aunque un long guarda 60000 sin problema. La suma se calcula primero, en int porque ambos números son ints, y ahí se desborda; solo el resultado equivocado se guarda en el long. Clang advirtió: overflow in expression; result is -5'536 with type 'int'.
Haz que uno de los números sea un long y toda la suma se hace en long. 60 * 1000L imprimió 60000, y 60UL * 60 * 1000 para una hora imprimió 3600000. Cada vez que una suma de tiempos o tamaños pueda pasar de 32767, pon L o UL en su primer número.
void setup() {
Serial.begin(9600);
long minute = 60 * 1000;
Serial.println(minute);
long fixed = 60 * 1000L;
Serial.println(fixed);
unsigned long hour = 60UL * 60 * 1000;
Serial.println(hour);
}
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 números enteros se dividen en números enteros
Divide un int entre otro y el resultado es un int, con el residuo descartado. 5 / 2 imprimió 2, y 5 / 2.0 imprimió 2.50, porque un decimal en la suma hace que toda la suma sea decimal. Poner el resultado en un float ya es tarde: float half = 5 / 2; imprimió 2.00, y el promedio de 3 y 4 dio 3.00 hasta que se dividió entre 2.0.
La versión de esto que todos escriben una vez es convertir una lectura a voltios. Con 3.3 V en A0, analogRead(A0) * (5 / 1023) imprimió 0.00, porque 5 / 1023 es 0 en números enteros. analogRead(A0) * (5.0 / 1023.0) imprimió 3.30.
void setup() {
Serial.begin(9600);
Serial.println(5 / 2);
Serial.println(5 / 2.0);
float half = 5 / 2;
Serial.println(half);
float avg = (3 + 4) / 2;
Serial.println(avg);
Serial.println((3 + 4) / 2.0);
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
float: unos siete dígitos, y nunca del todo exacto
Un float guarda unos siete dígitos significativos y redondea el resto. float big = 123456789; imprimió 123456792.00, con una advertencia de que el valor cambió. Los decimales se guardan en binario, así que la mayoría quedan un poco desviados: sumar 0.1 diez veces imprimió 1.0000001, y sum == 1.0 fue false. Compara floats con un margen, como en abs(sum - 1.0) < 0.001, nunca con ==.
En un Uno, double es el mismo float de 4 bytes, así que no compra más dígitos. Un tercio impreso a nueve lugares fue 0.333333349 como double en el Uno y 0.333333333 en el ESP32-C3, donde double es de 8 bytes.
float a int, y char contra byte
Poner un float en un int corta los decimales; no redondea. float f = 3.99; guardado en un int imprimió 3, y (int)-3.7 imprimió -3: hacia el cero, en ambos sentidos. Para redondear al entero más cercano, usa round(): round(3.5) imprimió 4 y round(2.5) imprimió 3, los medios van alejándose del cero. Para un número positivo, (int)(f + 0.5) hace lo mismo e imprimió 4.
char y byte son de un byte cada uno, pero se imprimen distinto. char c = 65; imprimió A, porque un char se imprime como la letra con ese código, y byte n = 65; imprimió 65. Un bool se imprime como 1 o 0.
void setup() {
Serial.begin(9600);
float f = 3.99;
int a = f;
Serial.println(a);
Serial.println((int)-3.7);
Serial.println(round(3.5));
Serial.println((int)round(2.5));
Serial.println((int)(f + 0.5));
}
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: cinco variables y un int que se desborda, cableado tal como se ejecuta arriba en esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Preguntas
¿Cuál es la diferencia entre int y long en Arduino?
En un Uno un int ocupa 2 bytes, de -32768 a 32767, y un long ocupa 4 bytes, más o menos entre más y menos 2.1 mil millones. En un ESP32 ambos ocupan 4 bytes. Usa long, o unsigned long para millis(), para cualquier valor que pueda pasar de 32767.
¿Cómo convierto un float a un int en Arduino?
Asígnalo, o escribe (int)f, y los decimales se cortan: 3.99 se convierte en 3. Usa round(f) para redondear al número entero más cercano.
¿Por qué mi operación en Arduino da un número negativo?
El resultado pasó del límite superior de su tipo y dio la vuelta. En un Uno, 32000 + 1000 en un int da -32536, y 60 * 1000 da -5536 aunque se guarde en un long, porque la suma se calcula en int. Usa long y escribe 60 * 1000L.
¿Es double más preciso que float en Arduino?
No en un Uno, Nano o Mega, donde double es el mismo float de 4 bytes. En un ESP32, una Raspberry Pi Pico o un Uno R4, double ocupa 8 bytes y conserva unas 15 cifras.
¿Cuál es la diferencia entre byte y char?
Ambos ocupan un byte. Un byte guarda de 0 a 255 y se imprime como número; un char es para un carácter y se imprime como letra, así que 65 se imprime como A.
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.