Fundamentos · 12 min de leitura

Função map() do Arduino: uso, exemplos e constrain()

Como usar a função map() do Arduino? Sintaxe, a armadilha da divisão inteira, limitação com constrain(), exemplos de potenciômetro para servo e PWM, ESP32 e Pico.

A função map() do Arduino é um comando integrado que converte proporcionalmente um valor de uma faixa numérica para outra. Quando você quer transformar a leitura de 0–1023 de um potenciômetro em 0–180 graus para um servo, em um valor PWM de 0–255 para o brilho de um LED ou em 0–100 por cento para um display, ela resolve em uma linha. Em resumo, a map() é um conversor de régua que encaixa a escala que você tem na escala que você quer.

Mas a map() não é tão inofensiva quanto parece: ela trabalha só com números inteiros, descarta a parte decimal e não limita o resultado à faixa de destino. Neste post você vai ver, passo a passo, a fórmula da função, as surpresas causadas pela divisão inteira, o uso seguro com constrain(), exemplos reais do potenciômetro ao servo e do sensor ao PWM, e como o mesmo trabalho é feito no ADC de 12 bits do ESP32 e no Raspberry Pi Pico com MicroPython.

Potenciômetro usado com a função map() do Arduino
O potenciômetro é o dispositivo de entrada mais usado com a map(): a leitura de 0–1023 é convertida em ângulo do servo ou em valor PWM.

O que é a map() do Arduino e como ela funciona?

A map() estabelece uma proporção linear entre duas faixas. Ela descobre em que porcentagem da sua própria faixa o valor de entrada está e depois calcula o número na mesma posição da faixa de destino. A definição no core do Arduino tem uma única linha: (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min. Todos os parâmetros e o valor de retorno são do tipo long, que no Uno é um inteiro de 32 bits com sinal. A sintaxe é map(valor, deMin, deMax, paraMin, paraMax), e você não precisa adicionar nenhuma biblioteca para usá-la.

ParâmetroSignificadoExemplo pot → servo
value (x)O valor a converterResultado de analogRead(A0)
fromLow (in_min)Limite inferior da faixa de entrada0
fromHigh (in_max)Limite superior da faixa de entrada1023
toLow (out_min)Limite inferior da faixa de saída0
toHigh (out_max)Limite superior da faixa de saída180
Valor de retornoO equivalente na faixa de destino (long)Um ângulo entre 0 e 180

Vamos calcular um exemplo: com o potenciômetro exatamente no meio, analogRead() retorna cerca de 512. Para map(512, 0, 1023, 0, 180), primeiro se obtém 512 - 0 = 512, que é multiplicado por 180 - 0 = 180, dando 92160. Depois isso é dividido por 1023: 92160 / 1023 = 90,09. Como a divisão inteira descarta a parte decimal, o resultado é 90 graus; por fim, soma-se o limite inferior da saída, 0. Se você inverter os limites de saída, o sentido também se inverte: map(x, 0, 1023, 255, 0) produz um valor que diminui conforme o potenciômetro aumenta. Faixas negativas também funcionam sem problema; você pode transformar o eixo de um joystick em velocidade de motor para frente e para trás com map(x, 0, 1023, -255, 255). A tabela abaixo resume as conversões mais comuns.

ObjetivoCódigoObservação
Potenciômetro → ângulo do servomap(x, 0, 1023, 0, 180) (ângulo)Para Servo.write()
Potenciômetro → PWMmap(x, 0, 1023, 0, 255) (PWM)Para analogWrite(); x / 4 dá uma distribuição mais uniforme
Leitura analógica → porcentagemmap(x, 0, 1023, 0, 100) (porcentagem)Para mostrar uma porcentagem em um display
Joystick → velocidade e sentido do motormap(x, 0, 1023, -255, 255) (velocidade com sinal)O sinal dá o sentido, o módulo dá a velocidade
Sentido invertido (escuro → claro)map(x, 0, 1023, 255, 0) (invertido)Troque os limites de saída de lugar
ADC de 12 bits do ESP32 → PWMmap(x, 0, 4095, 0, 255) (ESP32)No ESP32, analogRead() retorna 0–4095

O limite da divisão inteira: por que a map() não dá decimais?

Como a divisão dentro da map() é feita com inteiros, o resultado é sempre truncado em direção a zero; a parte decimal não é arredondada, é simplesmente descartada. Em uma faixa de destino estreita isso fica muito evidente. Por exemplo, se você escrever map(x, 0, 1023, 0, 10) para transformar um potenciômetro em um indicador de nível de 0–10, obtém esta tabela:

Entrada (x)Proporção realResultado da map()
00,0000
1020,9970
1031,0071
5125,0055
10229,9909
102310,00010

O verdadeiro problema da tabela é este: 103 valores de entrada diferentes (0–102) produzem o resultado 0, enquanto o valor máximo, 10, é produzido por uma única entrada, 1023. Se você não girar o potenciômetro até o fim, seu indicador nunca chega a 10. Se quiser uma distribuição uniforme, aumente os dois limites superiores em um e escreva map(x, 0, 1024, 0, 11); assim cada valor de saída corresponde a cerca de 93 valores de entrada, e o resultado continua entre 0 e 10. O segundo limite é o estouro: se o produto intermediário (x - in_min) * (out_max - out_min) ultrapassar o limite do long de 32 bits, de cerca de 2,1 bilhões, o resultado se corrompe. Faixas grandes como map(50000, 0, 100000, 0, 100000) geram no Uno um produto intermediário de 5 bilhões e dão um resultado errado. O terceiro limite é a necessidade de decimais: se você escrever map(x, 0, 1023, 0, 5) para transformar uma leitura analógica em uma tensão de 0–5 V, só obtém os resultados 0, 1, 2, 3, 4 e 5. Nesse caso, escreva sua própria função map com ponto flutuante usando a mesma fórmula:

C++ (Arduino IDE)
1// Ondalikli map fonksiyonu / Floating-point map function
2float mapFloat(float x, float inMin, float inMax, float outMin, float outMax) {
3  return (x - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
4}
5
6void setup() {
7  Serial.begin(9600);
8}
9
10void loop() {
11  int raw = analogRead(A0);                          // 0-1023 ham deger / raw value
12  float volt = mapFloat(raw, 0, 1023, 0.0, 5.0);     // 0.00-5.00 V
13  long milliVolt = map(raw, 0, 1023, 0, 5000);       // tamsayi mV / integer mV
14  int percent = map(raw, 0, 1023, 0, 100);           // tamsayi yuzde / integer percent
15
16  Serial.print(F("Ham / Raw: "));
17  Serial.print(raw);
18  Serial.print(F("  V: "));
19  Serial.print(volt, 2);
20  Serial.print(F("  mV: "));
21  Serial.print(milliVolt);
22  Serial.print(F("  %: "));
23  Serial.println(percent);
24  delay(500);
25}
No Uno, operações com float são várias vezes mais lentas que as com inteiros e ocupam mais memória de programa. Se os decimais não forem essenciais, use a map() inteira; se quiser precisão, diminua a unidade de destino. Por exemplo, calcule a tensão em milivolts em vez de volts: map(raw, 0, 1023, 0, 5000) dá 0–5000 mV, e o maior produto intermediário (5.115.000) fica muito abaixo do limite do long.

Usando junto com constrain

A map() não trata a faixa de destino como limite; ela só calcula uma proporção. Se a entrada sair da faixa que você espera, a saída também sai. Digamos que você mediu que um LDR dá na prática valores entre 200 e 900 e escreveu map(x, 200, 900, 0, 255). Quando uma lanterna forte leva o valor a 980, o resultado é (980 - 200) * 255 / 700 = 284; se o valor cair para 150 com o ambiente muito escuro, você obtém -18. No Uno, analogWrite() interpreta um valor acima de 255 de forma diferente conforme o pino; no pino 6, por exemplo, 284 é cortado para 8 bits e vira 28, ou seja, um LED quase apagado. A solução é a função constrain(valor, minimo, maximo): ela comprime o valor dentro dos limites informados. Há duas ordens corretas: limitar a entrada antes da map(), ou seja, map(constrain(x, 200, 900), 200, 900, 0, 255), ou limitar o resultado depois da map(), ou seja, constrain(map(x, 200, 900, 0, 255), 0, 255). As duas impedem que você saia de 0–255; se estiver calibrando um sensor, limitar a entrada fica mais legível.

No core do Arduino Uno (AVR), constrain() é uma macro, não uma função, e avalia seus parâmetros mais de uma vez. Se você escrever constrain(analogRead(A0), 200, 900), analogRead() pode rodar várias vezes e o valor comparado pode ser diferente do valor retornado. Guarde a leitura primeiro em uma variável e depois coloque essa variável dentro da constrain().

Tabela de ligações: Arduino Uno, ESP32 e Pico

LigaçãoArduino UnoESP32Raspberry Pi Pico
Terminais externos do potenciômetro5V e GND3V3 e GND3V3 e GND
Terminal central do potenciômetroA0GPIO 34GP26 (ADC0)
Ponto central do divisor LDR + 10 kΩA1GPIO 35GP27 (ADC1)
LED (com resistor de 220 Ω)D6 (PWM)GPIO 25GP15
Sinal do servo (fio laranja)D9GPIO 13GP16
Faixa de leitura do ADC10 bits (0–1023)12 bits (0–4095)read_u16(): 0–65535
As entradas analógicas do ESP32 e do Pico aceitam no máximo 3,3 V. Se você ligar as pontas do potenciômetro ao pino 5V por costume, o terminal central pode chegar a 5 V e a entrada do ADC pode ser danificada permanentemente. Nessas placas, sempre alimente o potenciômetro pelo pino 3V3; se usar um sensor com saída de 5 V, primeiro reduza o nível com um divisor de tensão.

Passo a passo: ajustando o ângulo de um servo com potenciômetro

  1. Ligue os dois terminais externos do potenciômetro de 10 kΩ aos pinos 5V e GND do Arduino e o terminal central ao A0.
  2. Ligue o fio marrom do servo SG90 ao GND, o vermelho ao 5V e o fio laranja de sinal ao D9.
  3. Confira se a biblioteca Servo está instalada; ela vem com a Arduino IDE, então você não precisa baixar nada.
  4. Carregue o código abaixo e abra o Monitor Serial a 9600 baud.
  5. Ao girar o potenciômetro, observe o valor bruto e o ângulo mudarem juntos na tela e o servo girar entre 0 e 180 graus.
  6. Se o servo forçar e zumbir nas extremidades, reduza a saída da map() para uma faixa mais estreita, como 10–170.
C++ (Arduino IDE)
1#include <Servo.h>
2
3const int POT_PIN = A0;     // potansiyometre orta ucu / potentiometer wiper
4const int SERVO_PIN = 9;    // servo sinyal pini / servo signal pin
5
6Servo servo;
7
8void setup() {
9  servo.attach(SERVO_PIN);
10  Serial.begin(9600);
11}
12
13void loop() {
14  int raw = analogRead(POT_PIN);           // 0-1023 ham deger / raw value
15  int angle = map(raw, 0, 1023, 0, 180);   // dereceye cevir / convert to degrees
16  angle = constrain(angle, 0, 180);        // guvenlik siniri / safety limit
17  servo.write(angle);
18
19  Serial.print(F("Ham / Raw: "));
20  Serial.print(raw);
21  Serial.print(F("  Aci / Angle: "));
22  Serial.println(angle);
23  delay(20);                               // servoya zaman tani / give the servo time
24}

No código, analogRead() retorna um valor de 10 bits, a map() o converte em graus e a constrain() garante que, mesmo que você mude a faixa depois, nenhum ângulo fora de 0–180 vá para o servo. Como o ADC do Uno tem um pouco de ruído, o valor pode oscilar entre 511, 512 e 513 mesmo sem você tocar no potenciômetro, o que faz o servo tremer. Tirar a média de algumas leituras, ou chamar servo.write() só quando o ângulo mudar mais de 2 graus, resolve boa parte do problema. Para detalhes, veja os posts sobre tremedeira do servo e filtragem de dados de sensores. Se tem curiosidade sobre como um servo funciona, O que é um servo motor? é um bom ponto de partida.

Do sensor ao PWM: brilho automático de LED com LDR

A map() não serve só para potenciômetros; ela funciona com qualquer sensor analógico. Neste exemplo, uma ponta do LDR está ligada ao 5V e a outra ao A1; um resistor de 10 kΩ também está ligado entre o A1 e o GND. Com essa ligação, conforme a luz aumenta, a resistência do LDR cai e a tensão no A1 sobe. Primeiro anote no Monitor Serial os valores lidos em um cômodo escuro e com luz forte; por exemplo, 150 e 850. Esses dois números são seus limites de calibração. O código deixa o LED mais forte conforme o ambiente escurece, por isso a faixa de saída é escrita ao contrário: de 255 a 0. Para entender como um LDR funciona, veja Sensor de luz LDR, e para a base do PWM, veja O que é PWM?.

C++ (Arduino IDE)
1const int LDR_PIN = A1;     // LDR + 10k bolucu / LDR + 10k divider
2const int LED_PIN = 6;      // PWM pini / PWM pin
3const int DARK = 150;       // karanlikta olculen / measured in the dark
4const int BRIGHT = 850;     // aydinlikta olculen / measured in bright light
5
6void setup() {
7  pinMode(LED_PIN, OUTPUT);
8  Serial.begin(9600);
9}
10
11void loop() {
12  int raw = analogRead(LDR_PIN);
13  int limited = constrain(raw, DARK, BRIGHT);       // once sinirla / limit first
14  int pwm = map(limited, DARK, BRIGHT, 255, 0);     // karanlik = parlak / dark = bright
15  analogWrite(LED_PIN, pwm);
16
17  Serial.print(raw);
18  Serial.print(F(" -> "));
19  Serial.println(pwm);
20  delay(100);
21}

map() no ESP32: ADC de 12 bits e PWM LEDC

No ESP32, a map() funciona do mesmo jeito; o que muda é a faixa de entrada. O ADC do ESP32 tem resolução padrão de 12 bits, então analogRead() retorna 0–4095 em vez de 0–1023. Se você deixar map(x, 0, 1023, ...) em um código trazido do Uno, consome toda a faixa de saída no primeiro quarto do curso do potenciômetro, e no restante os valores ultrapassam a faixa de destino em até quatro vezes. Por isso, no ESP32 escreva a entrada como 0–4095, ou reduza para 10 bits com analogReadResolution(10). No lado do PWM, o ESP32 usa a unidade LEDC; o core do Arduino 3.x trouxe ledcAttach(pino, frequência, resolução), enquanto o 2.x usa ledcSetup() e ledcAttachPin(), baseados em canais. O código abaixo compila nas duas versões. Como os pinos do ADC2 não podem ser lidos com o Wi-Fi ligado, ligamos o potenciômetro ao GPIO 34, que fica no ADC1. Se quiser controlar um servo no ESP32, use a mesma lógica com a biblioteca ESP32Servo e a linha map(x, 0, 4095, 0, 180).

C++ (Arduino IDE)
1const int POT_PIN = 34;      // ADC1 pini, yalniz giris / ADC1 pin, input only
2const int LED_PIN = 25;      // PWM cikisi / PWM output
3const int PWM_FREQ = 5000;   // 5 kHz
4const int PWM_RES = 8;       // 8 bit: 0-255
5
6#if ESP_ARDUINO_VERSION_MAJOR < 3
7const int PWM_CH = 0;        // 2.x icin LEDC kanali / LEDC channel for 2.x
8#endif
9
10void setup() {
11  Serial.begin(115200);
12  analogReadResolution(12);  // 0-4095
13#if ESP_ARDUINO_VERSION_MAJOR >= 3
14  ledcAttach(LED_PIN, PWM_FREQ, PWM_RES);
15#else
16  ledcSetup(PWM_CH, PWM_FREQ, PWM_RES);
17  ledcAttachPin(LED_PIN, PWM_CH);
18#endif
19}
20
21void loop() {
22  int raw = analogRead(POT_PIN);                // 0-4095
23  int duty = map(raw, 0, 4095, 0, 255);         // 12 bit -> 8 bit
24  duty = constrain(duty, 0, 255);
25#if ESP_ARDUINO_VERSION_MAJOR >= 3
26  ledcWrite(LED_PIN, duty);                     // 3.x: pin numarasi / pin number
27#else
28  ledcWrite(PWM_CH, duty);                      // 2.x: kanal numarasi / channel number
29#endif
30  Serial.printf("%d -> %d\n", raw, duty);
31  delay(20);
32}

O ADC do ESP32 tem uma peculiaridade que você precisa conhecer: ele não é linear nas extremidades. Com a atenuação padrão, tensões abaixo de cerca de 0,1 V são lidas como 0, e acima de cerca de 3,1 V o valor satura em 4095; no meio, a medição é levemente curva. Por isso você pode chegar a 4095 antes de girar o potenciômetro até o fim, ou sentir uma zona morta no início. A solução prática é medir as leituras mínima e máxima reais e usar esses limites na map() e na constrain(). Se precisar de tensão, a função analogReadMilliVolts(), que usa a calibração de fábrica, dá resultados mais precisos que a map. Para as características gerais da placa, veja O que é o ESP32?.

O equivalente da map() no Raspberry Pi Pico e no MicroPython

O MicroPython não tem uma map() pronta como a do Arduino; a map() do Python faz algo completamente diferente e aplica uma função a uma lista. Por isso você mesmo escreve a mesma fórmula. No Pico, ADC.read_u16() retorna a medição física de 12 bits escalada para 16 bits, na faixa de 0–65535; PWM.duty_u16() também espera um ciclo de trabalho entre 0 e 65535. Como os inteiros do Python não têm limite de tamanho, você não sofre com o estouro do Uno. A diferença a observar é que o operador // sempre arredonda em direção a menos infinito, enquanto a map() do C++ trunca em direção a zero; assim, com faixas negativas, você pode ver uma diferença de 1 unidade entre as duas linguagens. Se quiser um resultado decimal, basta usar / em vez de //. No código, o potenciômetro é lido no GP26, o LED no GP15 acompanha o brilho e o servo no GP16 acompanha o ângulo. Para o LED limitamos a entrada a 500–65000, porque o ADC do Pico raramente chega exatamente a 0 e 65535 nas extremidades. No lado do servo, 0–180 graus com PWM de 50 Hz correspondem a um pulso de aproximadamente 500–2500 microssegundos na maioria dos SG90. Se você é novo no Pico, comece por O que é o Raspberry Pi Pico? e noções básicas de MicroPython.

MicroPython
1from machine import ADC, Pin, PWM
2import time
3
4pot = ADC(26)                    # GP26 = ADC0
5led = PWM(Pin(15))               # LED GP15
6led.freq(1000)
7servo = PWM(Pin(16))             # servo sinyal GP16 / servo signal GP16
8servo.freq(50)                   # 50 Hz = 20 ms periyot / period
9
10def map_range(x, in_min, in_max, out_min, out_max):
11    # Arduino map() karsiligi (tamsayi) / Arduino map() equivalent (integer)
12    return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
13
14def constrain(x, low, high):
15    # degeri sinirla / clamp the value
16    return max(low, min(x, high))
17
18while True:
19    raw = pot.read_u16()                                           # 0-65535
20    percent = map_range(raw, 0, 65535, 0, 100)                     # yuzde / percent
21    duty = map_range(constrain(raw, 500, 65000), 500, 65000, 0, 65535)
22    led.duty_u16(duty)                                             # LED parlakligi / LED brightness
23    angle = map_range(raw, 0, 65535, 0, 180)                       # derece / degrees
24    pulse_us = map_range(angle, 0, 180, 500, 2500)                 # darbe suresi / pulse width
25    servo.duty_ns(pulse_us * 1000)                                 # mikrosaniye -> nanosaniye / us -> ns
26    print(raw, percent, angle, pulse_us)
27    time.sleep_ms(50)

Ideias de projetos com map()

  • Indicador de nível: converta o valor de um potenciômetro ou de um sensor de som para 0–8 com map(x, 0, 1024, 0, 9) e mostre em uma barra de 8 LEDs.
  • Carrinho controlado por joystick: converta um eixo do joystick para entre -255 e 255 e ajuste o sentido e a velocidade dos motores com um L298N.
  • Voltímetro digital: converta a leitura analógica em milivolts e mostre em um LCD; os detalhes estão em Como fazer um voltímetro com Arduino.
  • Porcentagem de umidade da planta: converta os valores de calibração seco e molhado de um sensor de umidade do solo em uma porcentagem de 0–100 com constrain() e map().
  • Instrumento controlado pela luz: converta o valor de um LDR ou de distância para a faixa de 200–2000 Hz com map() e passe-o para tone() como frequência.
  • Sequencial de LEDs com velocidade ajustável: converta um potenciômetro em um tempo de espera em milissegundos com map(x, 0, 1023, 50, 500).

Erros comuns e como corrigi-los

SintomaCausaSolução
O resultado sai da faixa de destinoA map() não limitaLimite a entrada ou a saída com constrain()
Resultados decimais sempre saem como números inteirosA divisão inteira descarta a parte decimalEscreva uma mapFloat() ou use uma unidade menor (mV em vez de V)
O valor máximo nunca é alcançadoO valor máximo ocorre para uma única entradaDistribua de forma uniforme com map(x, 0, 1024, 0, max + 1)
Resultados absurdos com números grandesO produto intermediário ultrapassa o limite do long de 32 bitsReduza as faixas ou calcule com float ou int64_t
No ESP32 o valor chega ao teto cedo demaisO código foi escrito para 0–1023, mas o ADC dá 0–4095Use 0–4095 como faixa de entrada
O sentido funciona ao contrárioOs limites de saída ou a ligação do sensor estão invertidosTroque de lugar os limites inferior e superior da saída
O resultado é constante e sem sentidoin_min é igual a in_max, ou seja, divisão por zeroConfira se os limites de calibração são diferentes
Em vez de escrever a calibração com números fixos, meça durante a execução: no setup(), leia o sensor por alguns segundos, registre o menor e o maior valor e depois use essas variáveis na map() e na constrain(). Se os dois valores continuarem iguais, volte para os limites padrão para não dividir por zero. Assim o mesmo código se ajusta sozinho a LDRs, potenciômetros e ambientes diferentes. Você encontra a base da leitura analógica em O que é ADC?.

A função map() é a tradutora entre o mundo dos sensores e o mundo das saídas: leve em conta a divisão inteira, proteja os limites com constrain() e, se você escrever corretamente a resolução do ADC da sua placa, ela funciona com a mesma lógica no Uno, no ESP32 e no Pico. Você pode rever o básico do potenciômetro em O que é um potenciômetro?. No app BlueGrays você pode explorar, passo a passo, com esquema do circuito e código, projetos que usam map(), como sequencial de LEDs com velocidade ajustável, medição da intensidade da luz com LDR, controle de servo com potenciômetro e ajuste de brilho PWM com o ESP32.

Perguntas frequentes

Para que serve a função map() do Arduino?

A map() converte proporcionalmente um número de uma faixa para outra. O uso mais comum é transformar um valor de 0–1023 lido com analogRead() em 0–180 graus para um servo ou em um valor PWM de 0–255 para analogWrite(). Ela não precisa de biblioteca e já vem integrada no core do Arduino.

A map() retorna números decimais?

Não. A map() trabalha com o tipo long e descarta a parte decimal na divisão; por exemplo, map(512, 0, 1023, 0, 5) dá 2, não 2,5. Se precisar de decimais, escreva uma função mapFloat() com parâmetros float usando a mesma fórmula, ou calcule o resultado em uma unidade menor, como milivolts.

Qual é a diferença entre map() e constrain()?

A map() converte um valor de uma escala para outra, mas não o limita; se a entrada estiver fora da faixa, a saída também fica fora. A constrain() não muda a escala, só comprime o valor entre os limites inferior e superior que você define. Para um uso seguro, as duas são escritas juntas: map(constrain(x, 200, 900), 200, 900, 0, 255).

Como ajustar o ângulo de um servo com potenciômetro?

Ligue o terminal central do potenciômetro ao A0 e o fio de sinal do servo ao D9. No loop(), calcule o ângulo com int angulo = map(analogRead(A0), 0, 1023, 0, 180); e envie ao servo com servo.write(angulo). Se o servo tremer, tire a média de algumas leituras ou ignore mudanças pequenas.

A map() funciona de forma diferente no ESP32?

A fórmula é a mesma, mas como o ADC do ESP32 é de 12 bits, analogRead() retorna 0–4095. Por isso você deve escrever a faixa de entrada como map(x, 0, 4095, 0, 255). Como o ADC do ESP32 não é linear nas extremidades, medir e usar as leituras mínima e máxima reais dá resultados melhores.

Existe um equivalente da função map() do Arduino no MicroPython?

Não existe um equivalente pronto; a map() do Python é outra construção, que aplica uma função a listas. Você escreve uma função curta com a fórmula (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min. Como read_u16() retorna 0–65535 no Pico, a faixa de entrada geralmente é essa.

Ver todos os projetos
Sequencial de LEDs com velocidade ajustável
AR-7Intermediário

Sequencial de LEDs com velocidade ajustável

Seis LEDs acendem um após o outro, fazendo a luz parecer correr de uma ponta à outra.

4.6(72)
148
Efeito Knight Rider com LEDs e velocidade ajustável
AR-8Intermediário

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…

4.5(60)
124
Medição da intensidade da luz com LDR
AR-11Iniciante

Medição da intensidade da luz com LDR

Quer ver a luminosidade do seu quarto em números? O LDR, um pequeno componente sensível à luz, mede a luz ambiente, e o Arduino exibe o valor na tela do computador a cada meio segundo.

4.6(83)
143
Uso de servo motor com potenciômetro
AR-36Iniciante
Premium

Uso de servo motor com potenciômetro

Conforme você gira o botão do potenciômetro, o braço do servo motor gira junto: uma extremidade do botão corresponde a zero grau, e a outra, a meia volta.

4.6(37)
53
Brilho do LED com potenciômetro no ESP32 (analógico → PWM)
ES-13Intermediário
Premium

Brilho do LED com potenciômetro no ESP32 (analógico → PWM)

Neste projeto, controlamos o brilho de um LED de forma analógica com um potenciômetro. O pino ADC do ESP32 lê a tensão de 0-3,3V do potenciômetro e converte esse valor em um sinal PWM (modulação por largura de pulso), enviado ao LED. Assim, ao girar o potenciômetro, o brilho do LED aumenta e diminui gradualmente. Com Arduino Core 3.0+, você pode usar analogWrite() diretamente; no ESP32-S2/S3, a resolução do ADC é fixada em 12 bits.

4.5(19)
32
Servo motor com ESP32 (controle por potenciômetro)
ES-16Intermediário
Premium

Servo motor com ESP32 (controle por potenciômetro)

Neste projeto, controlamos um servo motor SG90 com um potenciômetro. Ajustamos o ângulo do servo mapeando o valor analógico lido do potenciômetro para a faixa de 0 a 180 graus. A biblioteca ESP32Servo gera sinais para o servo nos GPIOs do ESP32 adequados e capazes de operar como saída; este projeto usa o GPIO 18. Esse é um método básico de controle para braços robóticos, estabilizadores de câmera e mecanismos de portas automáticas.

4.3(29)
42
Controle de servos com joystick
AR-60Intermediário
Premium

Controle de servos com joystick

Controle dois motores com um joystick, como ao girar uma câmera de segurança. Empurre a alavanca para os lados e o servo motor inferior gira lentamente; mova para cima ou para baixo e o servo…

4.7(42)
58