Tipos de dados do Arduino: o tamanho de cada caixa
- 526componentes na bancada
- 46placas rodando agora
- 1.00xtempo real, em todas as 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.
O circuito acima é a bancada de código, um Uno com três lâmpadas. Aperte Rodar e o monitor serial imprime cada variável que o sketch criou, depois "sizeof(int) = 2" e "sizeof(long) = 4", e por último "32000 + 1000 in an int = -32536": um int que passou do topo e voltou por baixo.
Abaixo estão o tamanho de cada tipo em um Uno e em um ESP32, os quatro jeitos de números darem errado sem erro nenhum, e como transformar um float em um int, cada um rodado no Mokxi com o que imprimiu.
Quer a versão passo a passo? A aula "Variáveis têm um tamanho" percorre tudo isso com checkpoints.
Abrir a aulaOs tipos, e seus tamanhos
Aqui estão as cinco variáveis do sketch rodando acima, uma de cada tipo comum. Uma variável é criada escrevendo seu tipo, um nome e, geralmente, um valor inicial. char grade = 'A'; usa aspas simples, porque um char é um caractere só.
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';Quando um número não cabe
Nada segura um número no topo do seu tipo. Ele dá a volta para o fundo, como o sketch acima mostrou com 32000 + 1000 imprimindo -32536. int x = 40000; imprimiu -25536, e a aba de compilação avisou: implicit conversion from 'long' to 'int' changes value from 40000 to -25536.
Tipos unsigned dão a volta para o outro lado. unsigned int u = 0; menos um imprimiu 65535, e um byte em 255 mais um imprimiu 0. É por isso que um contador em um byte faz um laço que nunca termina, e por isso que tempos de millis() pertencem a um unsigned long, que dura 49,7 dias antes de dar a volta.
A soma que estoura antes de ser guardada
Essa pega quem escolheu o tipo certo. long minute = 60 * 1000; imprimiu -5536, mesmo um long guardando 60000 com facilidade. A soma é calculada primeiro, em int porque os dois números são ints, e estoura ali; só o resultado errado é colocado no long. O Clang avisou: overflow in expression; result is -5'536 with type 'int'.
Faça um dos números ser um long e a soma inteira é feita em long. 60 * 1000L imprimiu 60000, e 60UL * 60 * 1000 para uma hora imprimiu 3600000. Sempre que uma soma de tempos ou tamanhos puder passar de 32767, coloque L ou UL no primeiro 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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
Números inteiros dividem em números inteiros
Divida um int por outro e a resposta é um int, com o resto jogado fora. 5 / 2 imprimiu 2, e 5 / 2.0 imprimiu 2.50, porque um decimal na conta torna a conta toda decimal. Colocar a resposta em um float é tarde demais: float half = 5 / 2; imprimiu 2.00, e a média de 3 e 4 deu 3.00 até ser dividida por 2.0.
A versão disso que todo mundo escreve uma vez é transformar uma leitura em volts. Com 3.3 V em A0, analogRead(A0) * (5 / 1023) imprimiu 0.00, porque 5 / 1023 é 0 em números inteiros. analogRead(A0) * (5.0 / 1023.0) imprimiu 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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
float: cerca de sete dígitos, e nunca exato por completo
Um float guarda cerca de sete dígitos significativos e arredonda o resto. float big = 123456789; imprimiu 123456792.00, com um aviso de que o valor mudou. Decimais são guardados em binário, então a maioria fica levemente errada: somar 0.1 dez vezes imprimiu 1.0000001, e sum == 1.0 foi false. Compare floats com uma margem, como em abs(sum - 1.0) < 0.001, nunca com ==.
No Uno, double é o mesmo float de 4 bytes, então não ganha nenhum dígito a mais. Um terço impresso com nove casas foi 0.333333349 como double no Uno e 0.333333333 no ESP32-C3, onde double tem 8 bytes.
float para int, e char contra byte
Colocar um float em um int corta os decimais; não arredonda. float f = 3.99; guardado em um int imprimiu 3, e (int)-3.7 imprimiu -3: em direção ao zero, nos dois sentidos. Para arredondar ao inteiro mais próximo, use round(): round(3.5) imprimiu 4 e round(2.5) imprimiu 3, com as metades indo para longe do zero. Para um número positivo, (int)(f + 0.5) faz o mesmo e imprimiu 4.
char e byte têm um byte cada, mas imprimem diferente. char c = 65; imprimiu A, porque um char é impresso como a letra com aquele código, e byte n = 65; imprimiu 65. Um bool imprime como 1 ou 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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
Abra este circuito no editor. Arduino Uno: cinco variáveis e um int que estoura, ligado como roda no topo desta página. Troque um componente ou um valor e rode de novo.
Perguntas
Qual é a diferença entre int e long no Arduino?
Em uma Uno, um int tem 2 bytes, de -32768 a 32767, e um long tem 4 bytes, cerca de mais ou menos 2,1 bilhões. Em uma ESP32, ambos têm 4 bytes. Use long, ou unsigned long para millis(), para qualquer coisa que possa passar de 32767.
Como converto um float em int no Arduino?
Atribua o valor, ou escreva (int)f, e as casas decimais são cortadas: 3.99 vira 3. Use round(f) para arredondar para o número inteiro mais próximo.
Por que minha conta no Arduino dá um número negativo?
A resposta passou do limite máximo do tipo e deu a volta. Em uma Uno, 32000 + 1000 em um int dá -32536, e 60 * 1000 dá -5536 mesmo armazenado em um long, porque a conta é calculada em int. Use long e escreva 60 * 1000L.
double é mais preciso que float no Arduino?
Não em uma Uno, Nano ou Mega, onde double é o mesmo float de 4 bytes. Em uma ESP32, uma Raspberry Pi Pico ou uma Uno R4, double tem 8 bytes e mantém cerca de 15 dígitos.
Qual é a diferença entre byte e char?
Ambos têm um byte. Um byte guarda de 0 a 255 e é impresso como número; um char serve para um caractere e é impresso como letra, então 65 é impresso como A.
Continuar
De onde vêm as informações desta página
Monte isto de verdade
Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.