Arrays no Arduino: declaração, laços for e exemplos práticos
Como usar arrays no Arduino passo a passo: declaração, índices, laços for, arrays bidimensionais, pinos de LED, média de sensores (média móvel) e exemplos de melodia.
Usar arrays no Arduino é uma habilidade básica de programação que permite agrupar muitos valores do mesmo tipo sob um único nome e acessar cada um pelo seu número (índice). Em vez de escrever os números dos pinos de seis LEDs, as últimas dez leituras de um sensor ou as notas de uma música em variáveis separadas como led1, led2, led3, você os guarda em um único array e processa todos em poucas linhas com um laço for. Seu código fica mais curto, você erra menos e, para adicionar um novo LED ao circuito, basta acrescentar um número à lista.
Neste guia você vai aprender como um array fica na memória, como declará-lo, por que o índice começa em zero e como contar os elementos com sizeof. Depois vamos montar três exemplos reais: um efeito de LEDs Super Máquina, uma média móvel que suaviza dados ruidosos de sensor e a reprodução de uma melodia com buzzer. Por fim, você vai montar uma tabela de estados de semáforo com arrays bidimensionais, ver as diferenças no ESP32 e no Raspberry Pi Pico e descobrir como pegar os erros de estouro que quebram seu programa em silêncio. Se você é totalmente novo no assunto, dê uma olhada antes em programação Arduino do zero.

O que é um array e como ele funciona?
Um array é um bloco de elementos do mesmo tipo de dado que ficam lado a lado na memória. Pense nele como um armário de gavetas numeradas: o armário tem um único nome e cada gaveta tem um número. Na linguagem do Arduino, baseada em C e C++, essa numeração começa em 0; um array de 5 elementos tem os índices 0, 1, 2, 3 e 4, então o último índice é sempre um a menos que a quantidade de elementos. O compilador conhece o endereço inicial do array; quando você escreve array[3], ele soma 3 × tamanho do elemento ao endereço inicial e vai direto para aquela célula. Por isso acessar um array é muito rápido, mas, pelo mesmo motivo, o compilador não verifica se você saiu dos limites. A memória que um array ocupa é a quantidade de elementos multiplicada pelo tamanho de um elemento:
| Tipo de dado | Tamanho do elemento (Uno) | Tamanho do elemento (ESP32 / Pico, C++) | Array de 100 elementos (Uno) |
|---|---|---|---|
| byte / uint8_t | 1 byte | 1 byte | 100 bytes |
| char | 1 byte | 1 byte | 100 bytes |
| int | 2 bytes | 4 bytes | 200 bytes |
| unsigned int | 2 bytes | 4 bytes | 200 bytes |
| long | 4 bytes | 4 bytes | 400 bytes |
| float | 4 bytes | 4 bytes | 400 bytes |
Considerando que o Arduino Uno tem só 2 KB (2048 bytes) de RAM, um array int de 1000 elementos sozinho comeria quase toda a memória. Por isso é um bom hábito usar byte para valores entre 0 e 255 (números de pino, brilho PWM, dia ou hora), int para resultados do analogRead e long para somas grandes. Escolher o tipo certo significa caber o dobro de dados na mesma memória.
Como declarar um array no Arduino?
Ao declarar um array, você escreve primeiro o tipo de dado, depois o nome do array e, entre colchetes, a quantidade de elementos. Você pode dar os valores logo em seguida entre chaves ou deixar o tamanho vazio e deixar o compilador contar. O programa abaixo mostra as formas mais comuns juntas e exibe os resultados no Monitor Serial:
1int notlar[5] = {90, 75, 60, 85, 100}; // boyut ve değerler / size and values
2int pinler[] = {2, 3, 4, 5, 6, 7}; // boyutu derleyici sayar / compiler counts the size
3float olcumler[10] = {1.5, 2.0}; // kalan 8 eleman 0.0 / remaining 8 are 0.0
4int bos[5]; // global dizi: hepsi 0 / global array: all zeros
5char isim[] = "Arduino"; // 7 harf + '\0' = 8 bayt / 7 letters + '\0' = 8 bytes
6
7void setup() {
8 Serial.begin(9600);
9 Serial.println(notlar[0]); // ilk eleman: 90 / first element: 90
10 Serial.println(notlar[4]); // son eleman: 100 / last element: 100
11 notlar[2] = 65; // üçüncü elemanı değiştir / change the third element
12 Serial.println(notlar[2]); // 65
13 Serial.println(olcumler[5]); // 0.00
14 Serial.println(bos[3]); // 0
15 Serial.println(sizeof(isim)); // 8
16 Serial.println(sizeof(pinler) / sizeof(pinler[0])); // eleman sayısı: 6 / element count: 6
17}
18
19void loop() {
20}| Declaração | Significado |
|---|---|
| int a[5]; | Array de 5 elementos; se for global, todos valem 0; se estiver dentro de uma função, os valores iniciais são aleatórios |
| int a[5] = {1, 2, 3, 4, 5}; | Tamanho e todos os valores informados juntos |
| int a[] = {2, 3, 4}; | O compilador conta o tamanho (aqui, 3) |
| float a[10] = {1.5, 2.0}; | Os elementos sem valor informado ficam com 0 |
| int a[5] = {0}; | O jeito curto de zerar todos os elementos |
| char s[] = "Arduino"; | Um array de texto; há um caractere invisível '\0' no final (8 bytes no total) |
| const byte a[] = {2, 3, 4}; | Um array constante que não pode ser alterado no programa |
Percorrendo um array com um laço for
O verdadeiro poder dos arrays aparece quando você os combina com um laço for. A variável do laço i começa em 0 e aumenta até um a menos que a quantidade de elementos, e a cada repetição você acessa o próximo elemento com array[i]. Em vez de digitar a quantidade de elementos à mão, o jeito mais seguro é calculá-la com sizeof(array) / sizeof(array[0]): sizeof(array) dá o total de bytes do array e sizeof(array[0]) dá o tamanho de um elemento. Por exemplo, no Uno um array int de 7 elementos tem 14 bytes, e 14 / 2 = 7. Quando você adiciona um elemento ao array, essa fórmula atualiza a contagem automaticamente. O código abaixo encontra a média, o mínimo e o máximo das temperaturas de uma semana. As leituras somam 161, a média é 23,0 graus, o mínimo é 19 e o máximo é 27. Repare que a condição do laço é i < ADET (a quantidade): se você usar menor ou igual, o laço roda uma vez a mais e lê memória fora do array.
1int sicakliklar[] = {22, 24, 19, 27, 25, 21, 23}; // bir haftalık ölçüm / one week of readings
2const int ADET = sizeof(sicakliklar) / sizeof(sicakliklar[0]); // 7
3
4void setup() {
5 Serial.begin(9600);
6 long toplam = 0; // taşmasın diye long / long to avoid overflow
7 int enKucuk = sicakliklar[0];
8 int enBuyuk = sicakliklar[0];
9
10 for (int i = 0; i < ADET; i++) { // 0'dan 6'ya / from 0 to 6
11 toplam += sicakliklar[i];
12 if (sicakliklar[i] < enKucuk) enKucuk = sicakliklar[i];
13 if (sicakliklar[i] > enBuyuk) enBuyuk = sicakliklar[i];
14 }
15
16 Serial.print("Ortalama / Average: ");
17 Serial.println((float)toplam / ADET); // 23.00
18 Serial.print("En dusuk / Min: ");
19 Serial.println(enKucuk); // 19
20 Serial.print("En yuksek / Max: ");
21 Serial.println(enBuyuk); // 27
22}
23
24void loop() {
25}Exemplo 1: gerenciando pinos de LED com um array
O uso clássico dos arrays no Arduino é gerenciar vários LEDs. Controlar seis LEDs sem array significa escrever seis linhas pinMode separadas e linhas digitalWrite separadas para cada passo; com um array, um único laço basta. Ligue a perna longa (ânodo) de cada LED a um pino digital e a perna curta ao GND através de um resistor de 220 Ω. Se quiser calcular o valor do resistor você mesmo, use a ferramenta Resistor para LED.
| LED (índice do array) | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| LED 1 (ledPins[0]) | D2 | GPIO 13 | GP14 |
| LED 2 (ledPins[1]) | D3 | GPIO 14 | GP13 |
| LED 3 (ledPins[2]) | D4 | GPIO 27 | GP12 |
| LED 4 (ledPins[3]) | D5 | GPIO 26 | GP11 |
| LED 5 (ledPins[4]) | D6 | GPIO 25 | GP10 |
| LED 6 (ledPins[5]) | D7 | GPIO 33 | GP9 |
| Cátodo (perna curta) | GND via 220 Ω | GND via 220 Ω | GND via 220 Ω |
- Coloque os LEDs na protoboard em ordem; ligue as pernas curtas (cátodos) à linha de GND através de resistores de 220 Ω.
- Ligue as pernas longas aos pinos 2–7 do Arduino na ordem mostrada na tabela.
- Escreva os números dos pinos no array ledPins na ordem física dos LEDs; a ordem no array define a direção em que a luz corre.
- Em setup(), configure todos os pinos como OUTPUT com um único laço for.
- Em loop(), crie o efeito Super Máquina com dois laços, um indo para a frente e outro voltando, e carregue o código.
1const byte ledPinleri[] = {2, 3, 4, 5, 6, 7}; // LED'lerin fiziksel sırası / physical order of LEDs
2const byte LED_SAYISI = sizeof(ledPinleri) / sizeof(ledPinleri[0]); // 6
3const int BEKLEME = 100; // adım süresi ms / step time in ms
4
5void setup() {
6 for (byte i = 0; i < LED_SAYISI; i++) {
7 pinMode(ledPinleri[i], OUTPUT); // tüm pinler çıkış / all pins as output
8 }
9}
10
11void loop() {
12 // ileri: 0'dan 5'e / forward: 0 to 5
13 for (byte i = 0; i < LED_SAYISI; i++) {
14 digitalWrite(ledPinleri[i], HIGH);
15 delay(BEKLEME);
16 digitalWrite(ledPinleri[i], LOW);
17 }
18 // geri: 4'ten 1'e, uçlar tekrar yanmaz / backward: 4 to 1, ends are not repeated
19 for (int i = LED_SAYISI - 2; i > 0; i--) {
20 digitalWrite(ledPinleri[i], HIGH);
21 delay(BEKLEME);
22 digitalWrite(ledPinleri[i], LOW);
23 }
24}O laço para a frente acende e apaga cada LED de 0 a 5 por 100 ms. O laço de volta começa em 4 e para em 1; como ele não acende os LEDs das pontas uma segunda vez, a luz volta de forma suave, sem pausar nas extremidades. Usamos int como contador no laço de volta porque byte não tem sinal e não pode ficar abaixo de 0; se você usar um byte em um laço que espera o contador cair abaixo de 0, ele volta para 255 depois do 0 e o laço nunca termina. Para mudar a ordem do efeito, basta trocar os números no array sem mexer no resto do código. Para outros efeitos escritos com a mesma lógica, veja sequencial de LEDs com efeito Super Máquina.
Exemplo 2: média de sensor com um array (média móvel)
As leituras de sensores analógicos como um potenciômetro, um LDR ou um sensor de umidade do solo ficam oscilando alguns pontos o tempo todo. O jeito mais fácil de reduzir esse ruído é tirar a média das últimas N leituras. Você guarda as últimas 10 leituras em um array e, a cada nova medição, subtrai o valor mais antigo do total e soma o novo. Como voltamos o índice para 0 ao chegar ao fim do array, essa estrutura se chama buffer circular (ring buffer). Atualizar o total pelo método de subtrair e somar, em vez de recalcular tudo a cada vez, mantém o processamento rápido mesmo que a janela cresça para 100 elementos. Durante as primeiras 10 leituras o array ainda não está cheio, então a média sobe a partir de zero e se estabiliza no valor real depois de cerca de meio segundo. Ligue o pino de sinal do sensor ao A0 (por exemplo, a perna do meio de um potenciômetro) e acompanhe o resultado como duas linhas no Plotter Serial:
1const byte PENCERE = 10; // ortalama alınacak okuma sayısı / number of readings to average
2int okumalar[PENCERE]; // global dizi sıfırla başlar / global array starts at zero
3byte indeks = 0; // sıradaki hücre / next slot
4long toplam = 0; // taşmasın diye long / long to avoid overflow
5
6void setup() {
7 Serial.begin(9600);
8}
9
10void loop() {
11 int yeni = analogRead(A0);
12 toplam -= okumalar[indeks]; // en eski okumayı çıkar / remove the oldest reading
13 okumalar[indeks] = yeni; // yerine yenisini yaz / store the new one
14 toplam += yeni; // toplama ekle / add to the total
15 indeks++;
16 if (indeks >= PENCERE) { // sona gelince başa dön / wrap around at the end
17 indeks = 0;
18 }
19 int ortalama = toplam / PENCERE;
20 Serial.print(yeni); // ham değer / raw value
21 Serial.print(" ");
22 Serial.println(ortalama); // yumuşatılmış değer / smoothed value
23 delay(50);
24}Exemplo 3: guardando as notas de uma melodia em um array
Uma melodia, na verdade, é formada por duas listas: qual nota tocar (frequência) e quanto tempo ela dura. Você guarda essas duas informações em dois arrays paralelos do mesmo tamanho: melody[i] e durations[i] sempre pertencem à mesma nota. Ligue a perna positiva do buzzer passivo ao pino 8 e a negativa ao GND. O código abaixo toca os dois primeiros versos de “Twinkle Twinkle Little Star” (a melodia de “Brilha, brilha, estrelinha”) e separa os sons deixando entre as notas uma pausa de um terço da duração de cada nota. Para adicionar uma música nova, basta preencher os dois arrays; o laço de reprodução nunca muda. Se os dois arrays tiverem quantidades de elementos diferentes, o laço passa do fim do mais curto, então escrever a mesma quantidade de elementos em cada linha evita o erro. Se melodias longas começarem a encher a RAM do Uno, você pode mover os arrays para a memória flash com PROGMEM. Se não conhece a diferença entre buzzer ativo e passivo, leia o que é buzzer.
1#define NOTA_DO 262 // Hz
2#define NOTA_RE 294
3#define NOTA_MI 330
4#define NOTA_FA 349
5#define NOTA_SOL 392
6#define NOTA_LA 440
7
8const byte BUZZER_PIN = 8; // pasif buzzer / passive buzzer
9
10// notalar ve süreler aynı sırada / notes and durations in the same order
11const int melodi[] = {NOTA_DO, NOTA_DO, NOTA_SOL, NOTA_SOL, NOTA_LA, NOTA_LA, NOTA_SOL,
12 NOTA_FA, NOTA_FA, NOTA_MI, NOTA_MI, NOTA_RE, NOTA_RE, NOTA_DO};
13const int sureler[] = {400, 400, 400, 400, 400, 400, 800,
14 400, 400, 400, 400, 400, 400, 800};
15const int NOTA_SAYISI = sizeof(melodi) / sizeof(melodi[0]); // 14
16
17void setup() {
18 for (int i = 0; i < NOTA_SAYISI; i++) {
19 tone(BUZZER_PIN, melodi[i], sureler[i]); // notayı çal / play the note
20 delay(sureler[i] + sureler[i] / 3); // nota + kısa boşluk / note + short gap
21 }
22 noTone(BUZZER_PIN);
23}
24
25void loop() {
26}Arrays multidimensionais: guardando dados em forma de tabela
Um array bidimensional é uma tabela formada por linhas e colunas. int tabela[4][3] é um array de 12 elementos com 4 linhas e 3 colunas; você acessa um elemento com tabela[linha][coluna], e os dois índices começam em 0. Na memória as linhas ficam uma depois da outra, então essa tabela ocupa 4 × 3 × 2 = 24 bytes no Uno. Padrões de matriz de LED 8x8, mapas de teclas de teclado matricial e tabelas de estados são usos típicos de arrays bidimensionais. No exemplo abaixo escrevemos cada estado de um semáforo em uma linha: as três primeiras colunas indicam se os LEDs vermelho, amarelo e verde ficam acesos, e a quarta coluna indica quantos milissegundos aquele estado dura. Você pode ligar os LEDs aos três primeiros pinos da tabela de pinos (D2 vermelho, D3 amarelo, D4 verde). Calculamos a quantidade de linhas com sizeof(states) / sizeof(states[0]); aqui sizeof(states[0]) dá o tamanho de uma linha inteira. Para adicionar um novo estado ao semáforo, basta escrever uma nova linha na tabela; o código dentro de loop() continua igual. Essa abordagem de separar a lógica do programa dos seus dados também vai ajudar mais tarde, quando você montar uma máquina de estados.
1const byte trafikPinleri[3] = {2, 3, 4}; // kırmızı, sarı, yeşil / red, yellow, green
2
3// her satır bir durum: {kırmızı, sarı, yeşil, süre ms} / each row: {red, yellow, green, time ms}
4const unsigned int durumlar[4][4] = {
5 {1, 0, 0, 5000}, // kırmızı / red
6 {1, 1, 0, 1500}, // kırmızı + sarı / red + yellow
7 {0, 0, 1, 5000}, // yeşil / green
8 {0, 1, 0, 1500} // sarı / yellow
9};
10const byte DURUM_SAYISI = sizeof(durumlar) / sizeof(durumlar[0]); // 4 satır / 4 rows
11
12void setup() {
13 for (byte i = 0; i < 3; i++) {
14 pinMode(trafikPinleri[i], OUTPUT);
15 }
16}
17
18void loop() {
19 for (byte d = 0; d < DURUM_SAYISI; d++) { // satırları gez / walk the rows
20 for (byte led = 0; led < 3; led++) { // sütunları gez / walk the columns
21 digitalWrite(trafikPinleri[led], durumlar[d][led] ? HIGH : LOW);
22 }
23 delay(durumlar[d][3]); // durumun süresi / duration of the state
24 }
25}Arrays no ESP32 e no Raspberry Pi Pico
No ESP32, os arrays são escritos com a mesma sintaxe C++ do Arduino Uno, e os exemplos acima compilam sem mudanças; você só precisa adaptar os números dos pinos. No exemplo dos LEDs, basta trocar a linha do array por {13, 14, 27, 26, 25, 33}; os pinos 6–11 são reservados para a memória flash interna, então não os coloque no array. No ESP32 um int tem 4 bytes e há mais de 300 KB de RAM disponíveis para seus programas; um array de medições de 10.000 elementos que não caberia no Uno cabe tranquilamente aqui. Como as leituras analógicas do ESP32 vão de 0 a 4095, os números do exemplo de média móvel saem maiores, mas a lógica é a mesma. Se você usa o Raspberry Pi Pico com MicroPython, usa uma lista em vez de um array: o tamanho não é fixo, você pode adicionar elementos com append() e saber o comprimento com len(). Índices negativos também valem em uma lista; leds[-1] dá o último elemento. Colocar objetos Pin diretamente na lista simplifica bastante o código:
1from machine import Pin
2import time
3
4led_pinleri = [14, 13, 12, 11, 10, 9] # GP14 -> GP9 sırası / order
5ledler = [Pin(p, Pin.OUT) for p in led_pinleri] # Pin nesnelerinden liste / list of Pin objects
6print("LED sayisi / LED count:", len(ledler))
7
8while True:
9 for led in ledler: # ileri / forward
10 led.on()
11 time.sleep_ms(100)
12 led.off()
13 for i in range(len(ledler) - 2, 0, -1): # geri, uçlar hariç / backward, ends skipped
14 ledler[i].on()
15 time.sleep_ms(100)
16 ledler[i].off()Erros de estouro e erros comuns com arrays
| Erro | Sintoma | Solução |
|---|---|---|
| Usar menor ou igual na condição do laço | A última repetição lê ou escreve fora do array; valores sem sentido, reinicializações | Use a condição i < COUNT |
| Começar o índice em 1 | O primeiro elemento é pulado e a última repetição estoura | Os índices vão de 0 a N-1 |
| Confundir o resultado de sizeof(array) com a quantidade de elementos | Em um array int, o laço roda duas vezes mais no Uno e quatro vezes mais no ESP32 | Utilize sizeof(array) / sizeof(array[0]) |
| Usar sizeof dentro de uma função | O array é passado à função como endereço; sizeof retorna 2 ou 4 | Passe a quantidade de elementos como um parâmetro separado |
| Guardar o total em uma variável int | Média negativa quando passa de 32.767 no Uno | Use long para o total |
| Não inicializar um array dentro de uma função | Valores iniciais aleatórios em um array local | Zere com int a[10] = {0}; |
| Atribuir um array a outro com = | Erro de compilação: invalid array assignment | Copie com um laço for ou com memcpy |
| Declarar um array muito grande no Uno | Aviso de pouca memória, travamentos e reinicializações | Use byte e mova as tabelas constantes para PROGMEM |
Ideias de projetos com arrays
- Pacote de efeitos de LED: Guarde os padrões em um array bidimensional e toque cada linha como um quadro de animação; gerencie efeitos de sequencial de LEDs e Super Máquina com um único laço.
- Jogo da memória Simon (no Brasil, conhecido como Genius): Guarde a sequência de cores gerada aleatoriamente em um array e compare-a com os botões que o jogador aperta; para ideias parecidas, veja jogos com Arduino.
- Fechadura com senha: Guarde a senha correta em um array char, escreva as teclas digitadas em um teclado matricial em um segundo array e compare-os elemento por elemento.
- Animações em matriz de LED: Guarde padrões 8x8 em arrays byte e mostre-os em uma matriz de LED MAX7219.
- Registrador de dados diário: Guarde as temperaturas de cada hora em um array de 24 elementos e calcule o mínimo, o máximo e a média do dia; você pode usar um DHT11 como sensor.
- Caixinha de música: Guarde várias músicas em arrays separados e alterne entre elas com um botão.
Arrays são um bloco básico que entra em cena no momento em que você lida com mais do que algumas variáveis na programação do Arduino: listas de pinos, histórico de medições, melodias e padrões são todos gerenciados com arrays. Quando for trabalhar com texto, você pode continuar com como usar String no Arduino para aprender a diferença entre arrays char e a classe String. No app BlueGrays você pode seguir passo a passo os projetos de sequencial de LEDs, efeito Knight Rider, semáforo e hino nacional com buzzer, com códigos prontos baseados em arrays e esquemas do circuito.
Perguntas frequentes
Como descobrir a quantidade de elementos de um array no Arduino?
O Arduino não tem uma função length() pronta para arrays. Você encontra a quantidade de elementos com a fórmula sizeof(array) / sizeof(array[0]): a primeira parte dá o total de bytes do array, a segunda o tamanho de um elemento. Essa fórmula só funciona corretamente onde o array é declarado; para um array passado a uma função, ela dá o tamanho de um ponteiro.
O índice de um array no Arduino começa em 0 ou em 1?
Na linguagem do Arduino, baseada em C e C++, o índice de um array sempre começa em 0. Em um array de 10 elementos, o primeiro é array[0] e o último é array[9]. Acessar array[10] não causa erro de compilação, mas corrompe a memória fora do array.
Dá para mudar o tamanho de um array no Arduino depois?
Não, o tamanho de um array normal é definido na compilação e não pode ser aumentado enquanto o programa roda. A solução prática é declarar um array do maior tamanho de que você possa precisar e controlar quantos elementos estão preenchidos em uma variável contadora separada. Alocar memória dinâmica com malloc ou new é possível, mas não é recomendado no Uno, com 2 KB de RAM, porque fragmenta a memória.
Como declarar um array de textos (strings) no Arduino?
Para guardar vários textos, você usa um array de ponteiros como const char* cores[] = {"Vermelho", "Amarelo", "Verde"}; e acessa "Amarelo" com cores[1]. Um único texto é um array de caracteres como char nome[] = "Arduino"; e carrega um caractere invisível '\0' no final. Também dá para escrever arrays de objetos String, mas eles consomem a RAM do Uno mais rápido.
Quantos elementos um array pode ter no Arduino Uno?
Quem define o limite é a RAM: o Uno tem 2048 bytes de RAM no total, e parte deles é usada pelo Serial e por outras variáveis. Na prática, um array de cerca de 1500 bytes, ou seja, 1500 byte ou 750 int, está perto do limite. Se você mover tabelas constantes para a flash com PROGMEM, pode guardar muito mais dados; o ESP32 e o Pico têm centenas de KB de RAM.
Como copiar um array para outro no Arduino?
Em C++ não dá para copiar um array escrevendo destino = origem; o compilador dá erro. Você pode copiar os elementos um por um com um laço for ou usar memcpy(destino, origem, sizeof(origem));. Confira se os dois arrays têm o mesmo tipo e tamanho; se o destino for menor, o memcpy também causa estouro.
Projetos para montar depois desta leitura
Ver todos os projetos
Semáforo
Uma pequena versão do semáforo que você vê na rua todos os dias. O vermelho fica aceso por dois segundos, o amarelo acende por um instante, o verde fica aceso por dois segundos e depois volta ao…

Sequencial de LEDs
Luzes que acendem uma após a outra, como se estivessem correndo. O Arduino acende seis LEDs, um de cada vez; cada um brilha por um instante e apaga, fazendo a luz percorrer a sequência do início ao…

Efeito Knight Rider com LEDs
O clássico efeito Knight Rider: um ponto de luz percorre seis LEDs de uma ponta à outra e depois volta.

Sequencial de LEDs com velocidade ajustável
Seis LEDs acendem um após o outro, fazendo a luz parecer correr de uma ponta à outra.

Efeito Knight Rider com LEDs e velocidade ajustável
Uma luz percorre seis LEDs de uma ponta à outra, muda de direção e volta. Ao girar o botão do potenciômetro, você ajusta a velocidade na hora: em uma extremidade, a luz quase voa; na outra, avança…

Hino nacional da Turquia com buzzer
Pressione o botão e um pequeno buzzer começa a tocar o hino nacional da Turquia, nota por nota.

LEDs sequenciais com ESP32
6 LEDs se acendem em sequência da esquerda para a direita e da direita para a esquerda, no estilo Knight Rider. Um exemplo básico de uso de laços for e arrays. Ensina a lógica de mudança de direção.

Raspberry Pi Pico: LEDs sequenciais (6 LEDs)
A clássica animação de LEDs sequenciais com o Pico — versão com 6 LEDs! Os 6 LEDs acendem em sequência da esquerda para a direita, como se a luz percorresse a fileira. Aprenda listas em Python, compreensão de listas ([Pin(p, Pin.OUT) for p in LED_PINS]), controle de pinos com laço for e enumerate(). São 6 LEDs nos pinos GP9-GP14, cada um com um resistor limitador de corrente de 220Ω.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

