Fundamentos · 11 min de leitura

Arduino String na prática: array de char, substring e toInt

Como usar String no Arduino? Concatenação, indexOf, substring, toInt, interpretação de comandos seriais, arrays de char, macro F() e fragmentação do heap no Uno.

A String do Arduino é uma classe pronta que permite guardar texto em uma única variável, juntar e separar suas partes. Quando você quer separar um comando como “LED,1” que chega pela porta serial, mostrar o valor de um sensor como “Temperatura: 24 C” ou reconhecer uma mensagem recebida por Bluetooth, ela é a primeira ferramenta a que você recorre. Existem duas formas de trabalhar com texto no Arduino: o objeto String, fácil de usar, e o array de char, de nível mais baixo, herdado da linguagem C. Os dois fazem o mesmo trabalho, mas usam a memória de maneiras bem diferentes.

Neste post você vai ver primeiro as operações mais comuns com String, como concatenação, indexOf, substring e toInt, com a saída real de cada uma. Depois vamos escrever um interpretador que recebe comandos pela porta serial, liga e desliga um LED e ajusta o brilho dele com PWM. Em seguida, vamos ver por que a String pode causar problemas com o tempo nos 2 KB de RAM do Arduino Uno, abordando a fragmentação do heap e a macro F(). Nas últimas seções, você vai aprender como o mesmo interpretador é escrito com array de char, no ESP32 e em MicroPython no Raspberry Pi Pico.

Placa Arduino Uno
Arduino Uno: o ATmega328P tem só 2 KB de RAM, e esse limite é decisivo quando você trabalha com texto.

O que é String no Arduino e qual a diferença para um array de char?

String (com S maiúsculo) é uma classe definida no core do Arduino. Ela guarda o texto em uma região de memória chamada heap e aumenta esse espaço sozinha à medida que o texto cresce. É isso que torna possível juntar textos com +, comparar com == e converter para número com uma única chamada. Já um array de char é um bloco fixo de bytes cujo tamanho você define de antemão. O fim do texto é sempre marcado por um caractere invisível '\0' (nulo), então a palavra “Hello”, de 5 letras, precisa de um array de pelo menos 6 bytes: char name[6] = "Hello";. Com array de char, você usa funções de C como strcat e strcmp para juntar e comparar; o operador == compara os endereços de memória dos dois arrays, não o conteúdo. Essa diferença é um dos pontos em que os iniciantes mais tropeçam.

CaracterísticaStringArray de char
Facilidade de usoMuito fácil: +, ==, substring()Mais difícil: strcat(), strcmp(), strtok()
Onde fica na memóriaHeap, dinâmicaFixa; área global ou pilha (stack)
TamanhoCresce sozinhaDefinido de antemão
Risco de estouroNenhum, mas se a memória acabar a operação falha em silêncioSim; você faz a verificação de limites
Risco de fragmentaçãoSim (principalmente no Uno)Não
Melhor usoESP32, Pico, textos curtos e pouco frequentesProjetos sempre ligados no Uno e no Nano

Memória por plataforma e ligações de teste

CaracterísticaArduino UnoESP32Raspberry Pi Pico
RAM2 KB SRAM520 KB SRAM264 KB SRAM
Memória de programa32 KB de flash4 MB de flash externa (na maioria das placas)2 MB de flash externa
Pino do LED de testeD9 (PWM) + 220 ΩGPIO 4 + 220 ΩGP15 + 220 Ω
Velocidade serial (nos exemplos)9600 baud115200 baudUSB (shell do Thonny)
Macro F()Economiza RAMSem efeito, existe por compatibilidadeNão disponível (MicroPython)
Tipo de textoString e char[]String e char[]str (Python)
Se a configuração de final de linha, no canto inferior direito do Monitor Serial, ficar em Sem final de linha, nenhum caractere '\n' é enviado quando você aperta Enter; o seu interpretador, que espera o fim da linha, ou fica esperando até o tempo limite ou nem chega a ser acionado. Para os exemplos deste post, escolha Nova linha ou Ambos, NL e CR. Com a segunda opção, o caractere '\r' fica grudado no fim do texto, e é por isso que o código usa trim() ou ignora o '\r'.

Operações básicas com String: concatenação, indexOf, substring, toInt

Para acrescentar texto a uma String, você usa += ou concat(). indexOf() informa em que posição está o caractere ou a palavra que você procura; a contagem começa em 0 e o retorno é -1 se nada for encontrado. substring(início, fim) copia um pedaço do texto: a posição inicial entra e a posição final fica de fora, então substring(8, 12) pega os caracteres das posições 8, 9, 10 e 11. toInt() converte os dígitos do início do texto em um número long. Se você carregar o código abaixo e abrir o Monitor Serial em 9600 baud, pode comparar a saída de cada linha com o valor do comentário.

C++ (Arduino IDE)
1void setup() {
2  Serial.begin(9600);
3
4  String ad = "Blue";
5  ad += "Grays";                                  // birleştirme / concatenation
6  String mesaj = "Merhaba " + ad;                 // "Merhaba BlueGrays"
7  int sicaklik = 24;
8  String satir = String("Sicaklik: ") + sicaklik + " C";  // sayı eklemek / appending a number
9
10  Serial.println(mesaj);                          // Merhaba BlueGrays
11  Serial.println(satir);                          // Sicaklik: 24 C
12  Serial.println(mesaj.length());                 // 17
13  Serial.println(mesaj.indexOf(' '));             // 7
14  Serial.println(mesaj.indexOf("Grays"));         // 12
15  Serial.println(mesaj.substring(8));             // BlueGrays
16  Serial.println(mesaj.substring(8, 12));         // Blue
17  mesaj.toUpperCase();                            // yerinde değiştirir / modifies in place
18  Serial.println(mesaj);                          // MERHABA BLUEGRAYS
19
20  String sayiMetni = "1250";
21  long n = sayiMetni.toInt() + 1;                 // 1251
22  Serial.println(n);
23  float f = String("3.75").toFloat();             // 3.75
24  Serial.println(f, 2);
25  Serial.println(String(255, HEX));               // ff
26}
27
28void loop() {
29}
FunçãoO que fazExemplo (s = "LED,128")
s.length() (comprimento)Retorna o número de caracteres7
s.indexOf(',') (busca)Posição da primeira ocorrência, -1 se não houver3
s.substring(0, 3) (trecho)Da posição 0 até a 3 (a 3 fica de fora)"LED"
s.substring(4) (até o fim)Da posição 4 até o fim"128"
s.substring(4).toInt() (para número)Converte para número (long); 0 se for inválido128
s.startsWith("LED") (começa com)Começa com este texto?true (verdadeiro)
s.equalsIgnoreCase("led,128") (comparação)Compara ignorando maiúsculas e minúsculastrue (verdadeiro)
s.charAt(0) (caractere)Retorna um único caractere'L'
s.trim() (limpeza)Remove espaços, \r e \n do início e do fim (na própria String)Sem alteração (não há espaços)
s.c_str() (ponteiro)Retorna um ponteiro que pode ser lido como um array de charstrcmp(s.c_str(), "LED,128") == 0 (comparação)
String(3.14159, 2) (conversão)Converte um número decimal em texto com as casas indicadas"3.14"
s.replace(",", ";") (substituição)Substitui um trecho na própria Strings agora é "LED;128"
Cuidado ao somar um número a um texto: a linha String s = "Value: " + 5; compila, mas não funciona como você espera. Não existe nenhum objeto String aqui; o compilador soma 5 ao endereço do texto “Value: ” e s recebe um pedaço sem sentido como “: ”. O item mais à esquerda da cadeia precisa ser uma String: escreva String s = String("Value: ") + 5; ou primeiro escreva String s = "Value: "; e depois acrescente s += 5;.

Interpretando comandos seriais passo a passo

  1. Ligue a perna longa do LED (ânodo) ao pino D9 do Uno por meio de um resistor de 220 Ω e a perna curta ao GND. O D9 tem PWM, então o brilho também pode ser ajustado.
  2. Defina o formato do comando: COMANDO,VALOR. Por exemplo, LED,1 acende o LED, LED,0 apaga e PWM,128 dá mais ou menos metade do brilho.
  3. Leia uma linha da porta serial até o caractere de Enter ('\n') e limpe os caracteres invisíveis com trim().
  4. Encontre a vírgula com indexOf(','); use substring() para separar o que vem antes dela como comando e o que vem depois como valor.
  5. Converta o valor em número com toInt(), passe o comando para maiúsculas com toUpperCase(), compare e execute a ação correspondente.
  6. Mostre uma resposta curta no Monitor Serial depois de cada comando, assim você vê na hora se o comando foi entendido.
C++ (Arduino IDE)
1const int LED_PIN = 9;          // PWM destekli pin / PWM capable pin
2
3void setup() {
4  Serial.begin(9600);
5  Serial.setTimeout(50);        // satır bekleme süresi (ms) / line wait timeout (ms)
6  pinMode(LED_PIN, OUTPUT);
7  Serial.println(F("Komutlar / Commands: LED,1  LED,0  PWM,0-255"));
8}
9
10void loop() {
11  if (Serial.available() > 0) {
12    String satir = Serial.readStringUntil('\n');  // Enter'a kadar oku / read until Enter
13    satir.trim();                                // CR ve boşlukları sil / remove CR and spaces
14    if (satir.length() == 0) return;
15
16    String komut = satir;
17    String deger = "";
18    int virgul = satir.indexOf(',');
19    if (virgul >= 0) {
20      komut = satir.substring(0, virgul);        // virgülden önce / before the comma
21      deger = satir.substring(virgul + 1);       // virgülden sonra / after the comma
22    }
23    komut.toUpperCase();
24    long sayi = deger.toInt();                   // geçersizse 0 / 0 if invalid
25
26    if (komut == "LED") {
27      digitalWrite(LED_PIN, sayi ? HIGH : LOW);
28      Serial.print(F("LED -> "));
29      Serial.println(sayi ? "ACIK / ON" : "KAPALI / OFF");
30    } else if (komut == "PWM") {
31      sayi = constrain(sayi, 0, 255);            // 0-255 arasında tut / keep in 0-255
32      analogWrite(LED_PIN, (int)sayi);
33      Serial.print(F("PWM -> "));
34      Serial.println(sayi);
35    } else {
36      Serial.print(F("Bilinmeyen komut / Unknown command: "));
37      Serial.println(komut);
38    }
39  }
40}

A linha Serial.setTimeout(50) é importante: por padrão, readStringUntil() espera 1000 ms pelo próximo caractere, então, se o final de linha não chegar, o programa trava por um segundo. A 9600 baud, um caractere chega em cerca de 1 ms, então 50 ms é mais que suficiente. Se o comando não tiver vírgula, indexOf() retorna -1; nesse caso, tratamos a linha inteira como comando e o valor fica vazio. Aplicar toInt() a uma String vazia dá 0. Aqui tem uma armadilha: toInt() também retorna 0 para texto inválido, então “PWM,abc” e “PWM,0” parecem iguais para o código. Em um projeto real, é um bom hábito verificar com isDigit() se o primeiro caractere do valor é um dígito. Já constrain() impede que o valor de PWM saia da faixa de 0–255.

Fragmentação de memória: por que a String pode travar um Uno?

Toda vez que uma String cresce e o espaço atual não basta, ela pede ao heap um bloco novo e maior, move o texto para lá e libera o bloco antigo. Os blocos liberados nem sempre podem ser reaproveitados; com o tempo, o heap vira uma fatia de queijo suíço cheia de buraquinhos. Mesmo que haja 300 bytes livres no total, não dá para criar uma String de 50 bytes se o maior pedaço contínuo tiver 40 bytes. Isso se chama fragmentação do heap. Nos 2 KB de RAM do Arduino Uno, o heap cresce para cima enquanto a pilha (stack) usada pelas chamadas de função cresce para baixo; quando os dois se encontram, variáveis são corrompidas, aparecem caracteres estranhos no Monitor Serial ou a placa reinicia sozinha. O mais traiçoeiro é que, quando não há espaço, a operação com String falha sem dar erro: depois de uma concatenação, o texto fica pela metade ou vazio. Como esses problemas costumam aparecer depois de o programa rodar por horas, você não os percebe em testes curtos na bancada.

  • Reserve espaço com reserve(): Para uma String cujo tamanho você consegue estimar, escreva line.reserve(64); no setup(); enquanto o texto ficar dentro desse limite, ela não pede espaço novo.
  • Use global ou static: Strings recriadas a cada ciclo do loop() ficam revirando o heap o tempo todo; reutilizar uma única String global é mais seguro.
  • Passe por referência: Declare os parâmetros de função como void print(const String &text); passar uma String por valor cria uma cópia nova a cada chamada.
  • Quebre cadeias longas: Expressões como a + b + c + d criam objetos temporários; acrescentar passo a passo com += usa menos memória temporária.
  • Imprima direto: Se você só quer mostrar o texto, use chamadas seguidas de Serial.print() em vez de juntar tudo; assim nenhuma String é criada.
  • Não use em interrupções: Não crie Strings em funções chamadas por attachInterrupt(); alocar memória dentro de uma interrupção não é seguro.

Economizando RAM no Uno com a macro F()

Nas placas AVR (Uno, Nano, Mega), todo texto constante que você escreve no código é copiado da flash para a RAM quando o programa começa. Só dez textos de menu de 40 caracteres já ocupam 400 bytes, um quinto da RAM do Uno. A macro F("...") deixa o texto na flash, e Serial.print() ou lcd.print() o leem de lá. A regra é simples: coloque dentro de F() todo texto constante que você imprime no Monitor Serial ou em um display. F() só funciona com a família print e com lugares que aceitam esse recurso, como acrescentar a uma String; não dá para passá-la diretamente para funções de C como strcmp(). O código abaixo também mostra a forma clássica de medir a RAM livre em placas AVR; você pode comparar esse valor antes e depois de usar F().

C++ (Arduino IDE)
1// Yalnız AVR kartlar (Uno, Nano, Mega) / AVR boards only (Uno, Nano, Mega)
2extern int __heap_start, *__brkval;
3
4int bosRam() {
5  int v;
6  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
7}
8
9void setup() {
10  Serial.begin(9600);
11  Serial.println("Bu metin RAM'e kopyalanir / This text is copied to RAM");
12  Serial.println(F("Bu metin flash'ta kalir / This text stays in flash"));
13
14  String s;
15  s.reserve(40);                 // tek seferde 40 bayt / 40 bytes at once
16  s += F("Sicaklik: ");          // F() String'e de eklenebilir / F() works with String too
17  s += 24;
18  Serial.println(s);
19
20  Serial.print(F("Bos RAM / Free RAM: "));
21  Serial.println(bosRam());
22}
23
24void loop() {
25}

Interpretação segura de comandos com array de char

Em projetos em que a placa vai rodar por dias sem parar, principalmente no Uno e no Nano, juntar os comandos em um array de char de tamanho fixo é o caminho mais robusto. O código abaixo grava os caracteres recebidos um a um em um buffer de 32 bytes, termina a linha com '\0' quando chega o '\n' e a divide na vírgula com strtok(). Quando o buffer enche, os caracteres a mais são descartados em silêncio, então não há estouro. Como o código nunca espera com delay() nem com tempo limite, outras tarefas do loop(), como ler sensores ou acionar motores, continuam rodando sem interrupção. A única diferença é que a comparação diferencia maiúsculas de minúsculas: você precisa digitar os comandos em maiúsculas.

C++ (Arduino IDE)
1const int LED_PIN = 9;
2const byte MAX_UZUNLUK = 32;          // en fazla 31 karakter + '\0' / max 31 chars + '\0'
3char tampon[MAX_UZUNLUK];
4byte konum = 0;
5
6void komutIsle(char *satir) {
7  char *komut = strtok(satir, ",");   // ilk parça / first token
8  char *deger = strtok(NULL, ",");    // ikinci parça / second token
9  if (komut == NULL) return;
10  int sayi = (deger != NULL) ? atoi(deger) : 0;
11
12  if (strcmp(komut, "LED") == 0) {
13    digitalWrite(LED_PIN, sayi ? HIGH : LOW);
14  } else if (strcmp(komut, "PWM") == 0) {
15    sayi = constrain(sayi, 0, 255);
16    analogWrite(LED_PIN, sayi);
17  } else {
18    Serial.print(F("Bilinmeyen / Unknown: "));
19    Serial.println(komut);
20    return;
21  }
22  char cevap[40];
23  snprintf(cevap, sizeof(cevap), "OK %s=%d", komut, sayi);   // taşma korumalı / overflow safe
24  Serial.println(cevap);
25}
26
27void setup() {
28  Serial.begin(9600);
29  pinMode(LED_PIN, OUTPUT);
30}
31
32void loop() {
33  while (Serial.available() > 0) {
34    char c = Serial.read();
35    if (c == '\r') continue;              // CR karakterini atla / skip CR
36    if (c == '\n') {                      // satır bitti / line complete
37      tampon[konum] = '\0';
38      if (konum > 0) komutIsle(tampon);
39      konum = 0;
40    } else if (konum < MAX_UZUNLUK - 1) {
41      tampon[konum++] = c;                // yer varsa ekle / append if there is room
42    }
43  }
44}
FunçãoO que fazExemplo
strlen(s) (comprimento)Retorna o número de caracteres, sem contar o '\0'strlen("LED") → 3
strncpy(destino, origem, n)Copia no máximo n caracteresstrncpy(buf, "PWM", sizeof(buf) - 1) (cópia)
strcat(destino, origem)Acrescenta ao final (o destino precisa ter espaço)strcat(buf, ",128") (acréscimo)
strcmp(a, b) (comparação)Retorna 0 se os textos forem iguaisstrcmp(comando, "LED") == 0
strchr(s, c) (busca)Retorna o endereço do caractere, NULL se não houverstrchr(s, ',') (busca da vírgula)
strtok(s, ",") (divisão)Divide o texto em um delimitador (altera o original)strtok(NULL, ",") para o próximo pedaço
atoi / atol / atof (conversão)Converte texto em número int, long ou doubleatoi("128") → 128
snprintf(buf, tamanho, ...)Monta texto formatado, com proteção contra estourosnprintf(buf, sizeof(buf), "%d", 42) (formatação)
dtostrf(numero, largura, casas, buf)Converte um float em texto (%f não funciona no AVR)dtostrf(3.14159, 4, 2, buf) → "3.14"

String no ESP32: por que é mais fácil e onde tomar cuidado?

O ESP32 tem 520 KB de SRAM, cerca de 260 vezes a do Uno. Isso deixa a String muito mais confortável em tarefas cheias de texto, como servidores web, mensagens JSON ou MQTT, e o interpretador com String mostrado acima roda sem mudanças no ESP32 se você definir LED_PIN como 4 e o baud rate como 115200. A String do core do ESP32 guarda textos curtos dentro do próprio objeto, sem ir ao heap, o que reduz a fragmentação em rótulos pequenos. Os textos constantes já são lidos da flash, então F() não muda nada aqui e só mantém o código compatível com AVR. Mesmo assim, criar Strings grandes a cada requisição em um servidor web que fica ligado por meses pode levar à fragmentação. Para acompanhar isso, ESP.getFreeHeap() dá a memória livre total e ESP.getMaxAllocHeap() dá o maior bloco contínuo que pode ser alocado; se a diferença entre os dois só aumenta com o tempo, a fragmentação começou.

C++ (Arduino IDE)
1String satir;                     // global, tekrar kullanılır / global, reused
2
3void setup() {
4  Serial.begin(115200);
5  satir.reserve(96);              // önceden yer ayır / pre-allocate
6  Serial.printf("Bos heap: %u bayt\n", (unsigned int)ESP.getFreeHeap());
7}
8
9void loop() {
10  static unsigned long son = 0;
11  if (millis() - son >= 2000) {
12    son = millis();
13    int ham = analogRead(34);     // GPIO 34: yalnız giriş, ADC1 / input only, ADC1
14    satir = "t=";
15    satir += millis() / 1000;
16    satir += " s, adc=";
17    satir += ham;
18    satir += ", heap=";
19    satir += (unsigned long)ESP.getFreeHeap();       // toplam boş / total free
20    satir += ", blok=";
21    satir += (unsigned long)ESP.getMaxAllocHeap();   // en büyük blok / largest block
22    Serial.println(satir);
23  }
24}

Trabalhando com texto no Raspberry Pi Pico com MicroPython

Em MicroPython, texto é do tipo str e, como no Python, é imutável; cada operação gera um novo texto, e o coletor de lixo limpa os que não são mais usados. Como o Pico tem 264 KB de RAM, tarefas como interpretar comandos não pesam nada para a placa. O equivalente ao indexOf da String é find(), ao substring é o fatiamento (line[0:3]), ao toInt é int() e ao trim é strip(). O mais útil é split(","), que quebra o texto em pedaços em uma única linha. Com texto inválido, int() gera um ValueError em vez de retornar 0; isso é mais seguro do que a ambiguidade do toInt() do Arduino, mas você precisa capturar o erro com try/except. Ligue o LED ao GP15 por meio de um resistor de 220 Ω, rode o código no Thonny e digite os comandos na janela Shell. Se você programar o Pico pela Arduino IDE, String e array de char funcionam do mesmo jeito; a única diferença é que sobra RAM.

MicroPython
1import sys
2from machine import Pin, PWM
3
4led = PWM(Pin(15))                          # GP15 + 220 ohm direnç / resistor
5led.freq(1000)
6
7print("Komutlar / Commands: LED,1  LED,0  PWM,0-255")
8
9while True:
10    satir = sys.stdin.readline().strip()    # Enter'a kadar bekler / waits for Enter
11    if not satir:
12        continue
13    parcalar = satir.split(",")             # "PWM,128" -> ["PWM", "128"]
14    komut = parcalar[0].upper()
15    try:
16        deger = int(parcalar[1]) if len(parcalar) > 1 else 0
17    except ValueError:                      # sayı değil / not a number
18        print("Gecersiz sayi / Invalid number:", parcalar[1])
19        continue
20    if komut == "LED":
21        led.duty_u16(65535 if deger else 0)
22        print("LED ->", "ACIK / ON" if deger else "KAPALI / OFF")
23    elif komut == "PWM":
24        deger = max(0, min(255, deger))     # 0-255 arasında tut / keep in 0-255
25        led.duty_u16(deger * 257)           # 0-255 -> 0-65535
26        print("PWM ->", deger)
27    else:
28        print("Bilinmeyen komut / Unknown command:", komut)

Ideias de projetos com String e comunicação serial

  • Controle por Bluetooth: Trate com o mesmo interpretador comandos como “LED,1” ou “SERVO,90” enviados pelo celular através de um módulo Bluetooth HC-05.
  • Painel de controle em Python: Envie comandos de um script Python no computador e receba as medições do Arduino; detalhes em comunicação serial entre Arduino e Python.
  • Mensagens entre dois Arduinos: Com comunicação serial UART, uma placa envia uma medição e a outra interpreta a linha “T,24” e a mostra em um display.
  • Mensagem rolante no LCD: Faça rolar com substring() um texto digitado na porta serial e mostre-o em um display LCD I2C.
  • Deixe as configurações permanentes: Salve na EEPROM um limite recebido com um comando como “THRESH,500”, para que a configuração não se perca quando a placa reiniciar.
  • Registre dados no Excel: Envie os valores dos sensores como linhas separadas por vírgula e exporte para o Excel.

Erros comuns e como resolver

SintomaCausaSolução
O comando nunca é detectadoFinal de linha em Sem final de linha, ou '\r' sobrando no fim do textoSelecione Nova linha, use trim()
Atraso de 1 segundo em cada comandoreadStringUntil() está esperando o tempo limite padrão de 1000 msSerial.setTimeout(50) ou leitura caractere por caractere
“PWM,abc” apaga o LEDtoInt() retorna 0 para texto inválidoVerifique o primeiro caractere com isDigit()
== sempre dá false com arrays de char== compara endereços, não conteúdoUse strcmp(a, b) == 0
Caracteres sem sentido no fim do textoFalta o '\0' no array de char ou o array é pequeno demaisCrie o array com o tamanho do texto + 1 e termine com '\0'
Trava ou reinicia depois de horasFragmentação do heap ou falta de RAM no UnoUse reserve(), F() e arrays de char
snprintf mostra “?” em vez de um floatO suporte a %f é desativado no AVRConverta com dtostrf()
length() grande demais em texto com letras acentuadasLetras como ş, ğ, ı ocupam 2 bytes em UTF-8Calcule pela contagem de bytes ou use ASCII
Se você não consegue decidir qual caminho seguir, aplique uma regra simples: arrays de char e F() em código que roda sem parar no Uno e no Nano, e String em código de teste e no ESP32 e no Pico. Fique de olho também na linha “Variáveis globais usam ... bytes” que a Arduino IDE mostra no fim da compilação; no Uno, se isso passar de 75%, a IDE avisa que há pouca memória. Para saber mais sobre problemas de memória, veja Arduino sem memória.

Depois de entender a diferença entre String e array de char, você consegue processar com segurança qualquer comando da porta serial, qualquer mensagem Bluetooth ou qualquer linha de sensor. Para conhecer melhor o Monitor Serial, veja Monitor Serial do Arduino, e para a lógica geral dos arrays, veja arrays no Arduino. No app BlueGrays, você pode colocar em prática na hora o que aprendeu aqui com projetos como acender um LED pelo celular via Bluetooth, comunicação serial entre dois Arduinos e mensagens em um LCD, com esquemas do circuito e códigos passo a passo.

Perguntas frequentes

Devo usar String ou array de char no Arduino?

Em sketches curtos de teste, no ESP32 e no Pico, a String é rápida e fácil de ler. Em um projeto que precisa rodar por dias em uma placa com 2 KB de RAM, como o Arduino Uno ou o Nano, um array de char de tamanho fixo é mais seguro, porque evita totalmente a fragmentação do heap. Você também pode misturar os dois: a função c_str() da String permite lê-la como um array de char.

Como converter String em int no Arduino?

Em um objeto String, você usa texto.toInt(); o resultado é um long e são lidos os dígitos do início do texto. Se o texto não tiver número, o retorno é 0, então, para diferenciar um 0 de verdade de uma entrada inválida, verifique o primeiro caractere com isDigit(). Com array de char, atoi(), atol() ou strtol(), que oferece verificação de erro, fazem o mesmo trabalho.

Como converter um número em String no Arduino?

O jeito mais fácil é escrever String(numero); String(255, HEX) gera texto em hexadecimal e String(3.14159, 2) gera texto com duas casas decimais. Você também pode acrescentar direto a uma String existente com s += numero. Para array de char, use snprintf() ou itoa(); nas placas AVR, você precisa de dtostrf() para números float.

Para que serve a macro F() do Arduino?

F() impede que o texto constante passado para comandos como Serial.print() seja copiado para a RAM e faz com que ele seja lido da flash. Como o Arduino Uno tem só 2 KB de RAM, ela economiza centenas de bytes em textos longos de menu e de aviso. No ESP32 e no Pico, os textos constantes já ficam na flash, então F() não faz diferença e existe só por compatibilidade.

Como o Arduino lê texto da porta serial?

O jeito mais curto é ler até o caractere de Enter com Serial.readStringUntil('\n'); depois, limpe o '\r' e os espaços com trim(). Como essa função espera 1 segundo por padrão, é uma boa ideia encurtar o tempo com Serial.setTimeout(). Se o programa nunca puder esperar, leia os caracteres um a um com Serial.read(), junte-os em um array de char e processe a linha quando chegar o '\n'.

Como comparar duas Strings no Arduino?

Em objetos String, o operador == ou equals() compara o conteúdo; se você não quer diferenciar maiúsculas de minúsculas, use equalsIgnoreCase(). Com arrays de char, == compara só os endereços de memória e dá resultado errado, então você precisa escrever strcmp(a, b) == 0. Não se esqueça de remover o '\r' do fim do texto com trim() antes de comparar.

Ver todos os projetos
Medição de distância com HC-SR04 (Monitor Serial)
AR-27Iniciante

Medição de distância com HC-SR04 (Monitor Serial)

O sensor HC-SR04 funciona como um morcego que se orienta no escuro: emite um som que você não consegue ouvir, escuta o eco e mede a distância até o objeto à sua frente.

4.6(50)
82
Controle de LED pelo celular via Bluetooth
AR-34Iniciante
Premium

Controle de LED pelo celular via Bluetooth

Um pequeno ensaio para acender e apagar as luzes do seu quarto pelo celular. O módulo Bluetooth repassa ao Arduino as letras enviadas pelo celular; uma letra acende o LED vermelho, outra acende o…

4.8(69)
91
Comunicação unidirecional entre 2 Arduinos
AR-57Intermediário
Premium

Comunicação unidirecional entre 2 Arduinos

Faça dois Arduinos conversarem por um único fio: ao pressionar o botão de um, o LED do outro acende; ao pressionar de novo, ele apaga.

4.4(37)
50
Comunicação bidirecional entre 2 Arduinos
AR-58Intermediário
Premium

Comunicação bidirecional entre 2 Arduinos

Dois Arduinos se conectam por fios e conversam entre si: ao pressionar o botão de um, a luz do outro acende; ao pressionar novamente, ela apaga.

4.5(20)
26
Exibição de mensagens no display LCD 2x16
AR-29Avançado
Premium

Exibição de mensagens no display LCD 2x16

Seu primeiro passo para escrever textos em um display. O display LCD de duas linhas mostra primeiro uma mensagem de espera, depois escreve uma saudação na linha de cima e uma palavra letra por letra…

4.6(37)
51
Uso do display LCD com I2C
AR-32Iniciante
Premium

Uso do display LCD com I2C

Dê ao seu Arduino um display próprio e faça-o escrever sua primeira mensagem. O display LCD de duas linhas é conectado com poucos fios; primeiro aparece uma saudação na linha de cima, depois uma…

4.8(53)
70
Teclado para programar em Python
AR-66Intermediário
Premium

Teclado para programar em Python

Se você se cansou de digitar os mesmos padrões várias vezes ao programar, este pequeno teclado é para você.

4.6(35)
45
Carrinho controlado por Bluetooth com L298N
AR-80Avançado
Premium

Carrinho controlado por Bluetooth com L298N

Transforme seu celular em um controle remoto e dirija seu próprio carrinho robô.

5.0(39)
66