Loja física na cidade do Montijo na Rua Cidade de Faro 111
Horário loja física segunda a sexta das 09:30 às 13:00 e das 15:00 às 19:00, exepto feríados e comunicação prévia
A loja não tem serviço de reparação de equipamentos
Trustpilot

Qual a Frequência Máxima do Sinal PWM no Arduino? É Possível Alterar? Guia Completo

Escrito em 4 de Abril de 2025

Qual a Frequência Máxima do Sinal PWM no Arduino? É Possível Alterar? Guia Completo

Qual a Frequência Máxima do Sinal PWM no Arduino? É Possível Alterar? Guia Completo

O Arduino tornou-se uma ferramenta indispensável para entusiastas da eletrónica, makers, estudantes e até profissionais. A sua simplicidade, flexibilidade e vasta comunidade de suporte fazem dele a porta de entrada ideal para o mundo dos microcontroladores. Uma das funcionalidades mais utilizadas e poderosas do Arduino é a capacidade de gerar sinais PWM (Pulse Width Modulation), essenciais para tarefas como controlar a intensidade de LEDs, a velocidade de motores DC, a posição de servomotores e até simular saídas analógicas.

No entanto, ao aprofundar os projetos, surgem questões mais técnicas. Uma dúvida comum é: Qual é a frequência padrão do PWM no Arduino? E, mais importante, é possível alterá-la? Qual a frequência máxima que podemos alcançar?

Este artigo abrangente foi criado para responder a estas perguntas em detalhe. Vamos explorar os fundamentos do PWM, como o Arduino o implementa por defeito, as frequências padrão e porquê dessas escolhas. Mais crucialmente, vamos mergulhar nas técnicas para modificar essa frequência, discutir os limites máximos alcançáveis e analisar as implicações e aplicações práticas dessas alterações. Se procura um controlo mais fino sobre os seus projetos Arduino, este guia é para si.

1. O Que é PWM (Pulse Width Modulation)? Desmistificando o Conceito


Antes de falarmos sobre frequências no Arduino, é fundamental entender o que é PWM.

No mundo digital, os microcontroladores como os que equipam as placas Arduino trabalham fundamentalmente com sinais binários: LIGADO (HIGH, geralmente 5V ou 3.3V) ou DESLIGADO (LOW, 0V). Isto é ótimo para tarefas simples como acender/apagar um LED ou ler o estado de um botão. Contudo, muitas aplicações do mundo real exigem um controlo mais "analógico" ou gradual – pense em variar a luminosidade de uma lâmpada, ajustar a velocidade de uma ventoinha ou controlar o volume de um som.

Os microcontroladores, sendo digitais, não conseguem gerar diretamente tensões variáveis como um potenciómetro. É aqui que entra o PWM.

PWM é uma técnica inteligente para simular uma saída analógica usando um sinal digital. Em vez de variar a tensão, o PWM varia o tempo durante o qual o sinal permanece LIGADO (HIGH) em relação ao tempo total de um ciclo.

Imagine ligar e desligar um LED muito rapidamente. Se o LED passar metade do tempo ligado e metade desligado, o nosso olho perceberá uma luminosidade média, aproximadamente metade do brilho máximo. Se passar 90% do tempo ligado e 10% desligado, parecerá quase totalmente aceso. Se passar apenas 10% do tempo ligado, parecerá muito ténue.

Componentes Chave do PWM:

Período (Period): O tempo total para completar um ciclo LIGADO-DESLIGADO. É o inverso da frequência. (Período = 1 / Frequência).
Frequência (Frequency): O número de ciclos PWM que ocorrem por segundo. Medida em Hertz (Hz). Uma frequência de 500 Hz significa que o ciclo LIGA-DESLIGA repete-se 500 vezes a cada segundo.
Duty Cycle (Ciclo de Trabalho): A percentagem de tempo, dentro de um período, em que o sinal está no estado HIGH (LIGADO). Um duty cycle de 0% significa que o sinal está sempre DESLIGADO. Um duty cycle de 100% significa que está sempre LIGADO. Um duty cycle de 50% significa que está LIGADO durante metade do período e DESLIGADO na outra metade.
Analogia: Pense numa torneira de água. Abrir a torneira completamente corresponde a 100% duty cycle (fluxo máximo). Fechá-la corresponde a 0% (sem fluxo). Agora, imagine que só pode abrir ou fechar a torneira completamente, mas pode fazê-lo muito depressa. Se abrir e fechar rapidamente, alternando entre os dois estados, o fluxo médio de água ao longo do tempo será algo intermédio. Variando a proporção de tempo "aberta" vs "fechada", controla o fluxo médio. O PWM faz o mesmo com a tensão elétrica.

2. PWM no Arduino: A Implementação Padrão com analogWrite()


O Arduino simplifica enormemente a utilização do PWM através da função analogWrite(pin, value).

pin: Refere-se ao pino do Arduino onde queremos gerar o sinal PWM. É importante notar que nem todos os pinos digitais do Arduino suportam PWM. Nas placas mais comuns como o Arduino UNO, Nano e Mega, os pinos com capacidade PWM são marcados com um til (~) junto ao número (por exemplo, ~3, ~5, ~6, ~9, ~10, ~11 no UNO/Nano).
value: É um número inteiro que define o duty cycle. No Arduino (baseado em microcontroladores AVR de 8 bits como o ATmega328P), este valor varia de 0 (corresponde a 0% duty cycle - sempre desligado) a 255 (corresponde a 100% duty cycle - sempre ligado). Um valor de analogWrite(pino, 127) resulta num duty cycle de aproximadamente 50%.
Exemplo Simples: Variar o Brilho de um LED

C++ 
const int ledPin = 9; // Pino PWM (marcado com ~)

void setup() {
pinMode(ledPin, OUTPUT); // Configura o pino como saída
}

void loop() {
// Aumenta gradualmente o brilho
for (int dutyCycle = 0; dutyCycle <= 255; dutyCycle++) {
analogWrite(ledPin, dutyCycle); // Define o duty cycle
delay(10); // Pequena pausa para ver o efeito
}

// Diminui gradualmente o brilho
for (int dutyCycle = 255; dutyCycle >= 0; dutyCycle--) {
analogWrite(ledPin, dutyCycle); // Define o duty cycle
delay(10); // Pequena pausa para ver o efeito
}
}

Este código faz um LED ligado ao pino 9 aumentar e diminuir o brilho continuamente. A função analogWrite() trata de gerar o sinal PWM correspondente ao valor fornecido.

3. As Frequências PWM Padrão do Arduino (UNO/Nano/Mega)


Agora, a questão central: Qual é a frequência destes sinais PWM gerados por analogWrite()?

A resposta não é única e depende dos pinos específicos e da placa Arduino utilizada. Nos Arduinos mais comuns baseados no ATmega328P (UNO, Nano) e ATmega2560 (Mega), as frequências PWM padrão são:

Para os pinos ~5 e ~6 (controlados pelo Timer0): Aproximadamente 976.56 Hz (~980 Hz).
Para os pinos ~3, ~9, ~10, ~11 (controlados pelo Timer1 e Timer2): Aproximadamente 490.20 Hz (~490 Hz).
No Arduino Mega 2560: A distribuição é um pouco diferente devido a mais timers:

Pinos ~4 e ~13 (Timer0): ~980 Hz
Pinos ~11 e ~12 (Timer1): ~490 Hz
Pinos ~2, ~3, ~5 (Timer3): ~490 Hz
Pinos ~6, ~7, ~8 (Timer4): ~490 Hz
Pinos 44, 45, 46 (Timer5): ~490 Hz
Porquê estas frequências específicas?

Estas frequências não são aleatórias. Resultam da forma como o hardware interno do microcontrolador Arduino (os Timers/Counters) é configurado por defeito pelo código do core Arduino para implementar a função analogWrite().

Os microcontroladores ATmega têm temporizadores internos (Timer0, Timer1, Timer2 no ATmega328P) que são essencialmente contadores que incrementam a uma taxa determinada pelo clock do sistema (16 MHz no UNO/Nano/Mega) e por um fator de divisão chamado prescaler. O PWM é gerado comparando o valor do contador com um valor de referência (relacionado com o value do analogWrite()). Quando o contador atinge o valor de referência ou reinicia, o estado do pino de saída PWM é alterado.

As configurações padrão do Arduino para estes timers, que equilibram resolução (os 256 passos do analogWrite) e frequência, resultam nestes valores de ~490 Hz e ~980 Hz.

Frequência de ~490 Hz: 16,000,000 Hz (Clock) / 64 (Prescaler) / 510 (Ciclos do modo PWM*) = 490.20 Hz
Frequência de ~980 Hz: 16,000,000 Hz (Clock) / 64 (Prescaler) / 256 (Ciclos do modo PWM*) = 976.56 Hz
(Nota: O número de ciclos depende do modo PWM específico usado pelo timer (e.g., Fast PWM vs Phase Correct PWM) e da resolução.)

Estas frequências são geralmente adequadas para muitas aplicações comuns:

Controlo de LEDs: A frequência é suficientemente alta para que o olho humano não perceba a cintilação (efeito de persistência da visão).
Controlo Básico de Motores DC: Para muitos motores simples, estas frequências funcionam, embora possam gerar um ruído audível (um zumbido agudo).
Servomotores: Os servos padrão esperam um sinal de controlo numa frequência muito mais baixa (tipicamente 50 Hz), pelo que analogWrite() não é usado diretamente para os controlar. Utiliza-se a biblioteca Servo.h, que reconfigura um dos timers para gerar os pulsos corretos de 50 Hz.


4. É Possível Alterar a Frequência PWM no Arduino?


Sim, é absolutamente possível alterar a frequência PWM no Arduino.

A função analogWrite() fornece uma interface simples, mas não expõe opções para mudar a frequência. Para o fazer, precisamos de ir um nível mais fundo e interagir diretamente com os registradores de configuração dos timers do microcontrolador.

Porquê alterar a frequência PWM?

Existem várias razões pelas quais pode querer ou precisar de uma frequência PWM diferente da padrão:

Controlo de Motores DC:Redução de Ruído Audível: As frequências padrão (~490/980 Hz) estão dentro da faixa audível humana. Motores controlados por PWM nesta gama podem emitir um zumbido irritante. Aumentar a frequência para valores ultrassónicos (acima de 20 kHz) pode eliminar este ruído.
Melhor Eficiência e Suavidade: Alguns tipos de motores e controladores (drivers H-bridge) podem operar de forma mais eficiente ou suave com frequências PWM mais elevadas. Frequências muito baixas podem causar vibração ou operação "aos solavancos".
Compatibilidade com Drivers: Certos drivers de motor especificam uma gama de frequências PWM de entrada ideal para o seu funcionamento.
Controlo de Componentes Específicos:ESCs (Electronic Speed Controllers): Usados em drones e RC, os ESCs modernos muitas vezes funcionam melhor ou requerem sinais PWM de alta frequência (vários kHz ou mais) para uma resposta rápida.
Fontes de Alimentação Comutadas (SMPS): Se estiver a construir um conversor DC-DC (buck/boost), a frequência PWM é um parâmetro de design crítico que afeta o tamanho dos indutores e condensadores, a eficiência e o ripple. Frequências mais altas (dezenas ou centenas de kHz) são comuns.
Geração de Áudio: Embora não seja de alta fidelidade, é possível gerar tons sonoros básicos usando PWM. A frequência do sinal PWM determinará diretamente a frequência (tom) do som produzido (por exemplo, com um pequeno altifalante ou buzzer ligado ao pino PWM através de um filtro passa-baixo simples).
Aplicações de Iluminação Avançada: Embora 490/980 Hz seja suficiente para evitar cintilação visível na maioria dos casos, algumas aplicações de vídeo ou científicas podem ser sensíveis a essa cintilação, beneficiando de frequências mais altas.
Comunicação por Infravermelhos: A modulação de sinais IR, como os usados em comandos remotos, muitas vezes utiliza uma portadora PWM de alta frequência (e.g., 38 kHz).


5. Como Alterar a Frequência PWM: Manipulando os Registradores dos Timers


A forma mais direta e flexível de alterar a frequência PWM no Arduino (AVR) é manipulando os registradores de controlo dos timers (Timer/Counter Control Registers - TCCRxA e TCCRxB).

Cada timer (Timer0, Timer1, Timer2 no ATmega328P) tem os seus próprios registradores que controlam o seu modo de operação, a fonte de clock (prescaler) e os modos de comparação para gerar o PWM.

O Fator Chave: O Prescaler

A maneira mais comum e relativamente simples de alterar a frequência PWM é mudar o prescaler do timer. O prescaler é um divisor de clock: ele divide a frequência principal do sistema (16 MHz) antes que ela chegue ao contador do timer. Ao escolher um prescaler menor, o timer conta mais rápido, resultando numa frequência PWM mais alta. Ao escolher um prescaler maior, o timer conta mais devagar, resultando numa frequência PWM mais baixa.

Registradores Importantes (Exemplo ATmega328P - Arduino UNO/Nano):

Timer0 (8 bits): Controla os pinos ~5 e ~6.Registradores: TCCR0A, TCCR0B.
Bits do Prescaler (em TCCR0B): CS02, CS01, CS00.
AVISO EXTREMO: Alterar a configuração do Timer0 vai afetar o funcionamento das funções delay(), millis() e micros(), pois elas dependem da interrupção de overflow do Timer0 com a configuração padrão. A biblioteca Servo.h também pode ser afetada se usar o Timer0. Evite modificar o Timer0 se precisar destas funções ou da biblioteca Servo!
Timer1 (16 bits): Controla os pinos ~9 e ~10.Registradores: TCCR1A, TCCR1B.
Bits do Prescaler (em TCCR1B): CS12, CS11, CS10.
Sendo de 16 bits, oferece mais flexibilidade em termos de modos e resolução.
Timer2 (8 bits): Controla os pinos ~3 e ~11.Registradores: TCCR2A, TCCR2B.
Bits do Prescaler (em TCCR2B): CS22, CS21, CS20.
Timer2 tem opções de prescaler ligeiramente diferentes do Timer0 e Timer1.
Valores dos Prescalers e Frequências Resultantes (Modo Fast PWM, 8 bits de Resolução):

A fórmula geral para a frequência em modo Fast PWM de 8 bits (0-255) é: Frequência PWM = F_CPU / (Prescaler * 256) Onde F_CPU é a frequência do clock (16,000,000 Hz para UNO/Nano/Mega).

Para Timer0 (Pinos 5, 6) - NÃO RECOMENDADO ALTERAR: (Prescaler padrão: 64, Freq: ~977 Hz)


Como Alterar o Prescaler (Exemplo para Timer 1 - Pinos 9, 10):

Para definir a frequência PWM nos pinos 9 e 10 para a mais alta possível (62.5 kHz), usando o modo Fast PWM de 8 bits e um prescaler de 1, pode adicionar o seguinte código à sua função setup():

C++ 
void setup() {
pinMode(9, OUTPUT); // Configura pino 9 como saída
pinMode(10, OUTPUT); // Configura pino 10 como saída

// Configurar Timer1 para Fast PWM, 8-bit (Modo 5)
TCCR1A = 0; // Limpar registrador A
TCCR1B = 0; // Limpar registrador B
TCNT1 = 0; // Limpar contador

// Modo Fast PWM 8-bit (WGM10 e WGM12 = 1)
// COM1A1=1, COM1B1=1 -> Saída não-invertida nos pinos OC1A (Pino 9) e OC1B (Pino 10)
TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(WGM10);

// CS10=1 -> Prescaler = 1
// WGM12=1 -> Parte da configuração do modo Fast PWM 8-bit
TCCR1B = _BV(WGM12) | _BV(CS10);

// Agora, em vez de analogWrite(9, valor), use:
// OCR1A = valor; // Para o pino 9 (0-255)
// OCR1B = valor; // Para o pino 10 (0-255)

// Exemplo: Definir pino 9 para 50% duty cycle (aprox)
OCR1A = 127;
}

void loop() {
// O PWM já está a ser gerado pelo hardware nos pinos 9 e 10
// Pode alterar OCR1A ou OCR1B aqui se necessário
}

Explicação do Código:

pinMode(): Ainda é necessário configurar os pinos como saídas.
TCCR1A = 0; TCCR1B = 0;: Boa prática para limpar as configurações anteriores.
TCNT1 = 0;: Reinicia o contador do timer.
TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(WGM10);:_BV(bit) é uma macro que cria uma máscara com o bit especificado a 1 (e.g., _BV(CS10) é o mesmo que (1 << CS10)).
COM1A1=1, COM1B1=1: Configura os pinos OC1A (9) e OC1B (10) para modo PWM não-invertido (vão a LOW quando o contador TCNT1 faz match com OCR1A/OCR1B, e a HIGH no overflow/reset).
WGM10=1: Parte da seleção do modo de operação (Waveform Generation Mode).
TCCR1B = _BV(WGM12) | _BV(CS10);:WGM12=1: Juntamente com WGM10=1 em TCCR1A (e WGM11=0, WGM13=0 por defeito), seleciona o Modo 5: Fast PWM, 8-bit. Neste modo, o contador vai de 0 a 255 (0xFF).
CS10=1: Define o prescaler para 1 (sem divisão de clock). Os bits CS11 e CS12 estão a 0.
OCR1A = valor; / OCR1B = valor;: Estes são os registradores de Output Compare. É aqui que define o duty cycle (de 0 a 255) para os pinos 9 e 10, respetivamente. Isto substitui a necessidade de usar analogWrite() para estes pinos.
Para outras frequências: Simplesmente altere os bits CS12, CS11, CS10 em TCCR1B de acordo com a tabela de prescalers. Por exemplo, para obter ~7.8 kHz (prescaler 8), usaria TCCR1B = _BV(WGM12) | _BV(CS11); (apenas CS11=1).

Modos PWM (Fast PWM vs Phase Correct PWM):

Fast PWM: O contador conta apenas para cima (0 -> TOP) e reinicia. A frequência é mais alta para a mesma resolução. Pode gerar ligeiras assimetrias no sinal se o duty cycle for alterado dinamicamente. O analogWrite nos pinos do Timer0 usa este modo por defeito.Freq (8-bit) = F_CPU / (Prescaler * 256)
Phase Correct PWM: O contador conta para cima (0 -> TOP) e depois para baixo (TOP -> 0). Isto resulta num sinal mais simétrico, o que é melhor para controlo de motores. No entanto, para a mesma resolução, a frequência PWM é metade da do Fast PWM. O analogWrite nos pinos dos Timers 1 e 2 usa este modo por defeito.Freq (8-bit) = F_CPU / (Prescaler * 510)
Ao manipular os registradores, pode escolher explicitamente qual modo usar através dos bits WGM (Waveform Generation Mode).

6. Qual a Frequência Máxima de PWM Possível no Arduino?


Como vimos nas tabelas, ao usar um prescaler de 1 e o modo Fast PWM de 8 bits (resolução 0-255), a frequência máxima teórica para os timers do ATmega328P é:

Frequência Máxima (8-bit) = 16,000,000 Hz / (1 * 256) = 62,500 Hz = 62.5 kHz

Esta é a frequência PWM mais alta que pode obter mantendo a resolução de 8 bits (256 níveis de duty cycle) que analogWrite utiliza.

É possível ir além de 62.5 kHz?

Sim, mas com um compromisso na resolução do duty cycle. A frequência PWM depende do valor MÁXIMO que o contador atinge (TOP). Nos modos de 8 bits, TOP é 255. No entanto, os timers têm modos onde TOP pode ser um valor fixo menor ou definido por outro registrador (como ICR1 ou OCR1A no Timer1).

Por exemplo, se configurar o Timer1 no modo Fast PWM onde TOP é definido por OCR1A (Modo 15), e definir OCR1A para um valor baixo, a frequência aumentará.

Frequência PWM = F_CPU / (Prescaler * (1 + TOP))

Se usar Prescaler = 1 e definir TOP = 15 (ou seja, OCR1A = 15), teria apenas 16 níveis de duty cycle (0 a 15), mas a frequência seria:

Freq = 16,000,000 / (1 * (1 + 15)) = 16,000,000 / 16 = 1,000,000 Hz = 1 MHz

Se definir TOP = 7 (8 níveis de duty cycle):

Freq = 16,000,000 / (1 * (1 + 7)) = 16,000,000 / 8 = 2,000,000 Hz = 2 MHz

Se definir TOP = 1 (apenas 2 níveis de duty cycle: 0% ou 50% se usar OCR1B=0 ou OCR1B=1 com TOP=1):

Freq = 16,000,000 / (1 * (1 + 1)) = 16,000,000 / 2 = 8,000,000 Hz = 8 MHz

O Limite Absoluto: A frequência PWM mais alta possível é obtida com TOP = 0 (o que não é útil para PWM, pois só teria 0% duty cycle), mas o limite conceptual seria com TOP = 1, que dá F_CPU / 2 = 8 MHz. Contudo, isto oferece apenas controlo LIGADO/DESLIGADO, o que derrota o propósito do PWM.

Portanto, a resposta prática para a frequência máxima é:

Com resolução de 8 bits (0-255): 62.5 kHz
Com resolução reduzida: Pode ir até vários MHz, mas com muito poucos passos de controlo do duty cycle.
A escolha depende da aplicação: precisa de alta frequência ou de alta resolução no controlo?

7. Implicações e Considerações ao Alterar a Frequência PWM


Modificar a frequência PWM não é isento de consequências. É crucial estar ciente dos trade-offs:

Impacto nas Funções de Temporização (Timer0): Como mencionado várias vezes, alterar o prescaler ou modo do Timer0 (pinos 5, 6) QUEBRA as funções millis(), micros() e delay(). O tempo deixará de ser contado corretamente. Evite modificar o Timer0 a menos que não precise destas funções ou tenha uma alternativa para manter o tempo.
Impacto na Biblioteca Servo: A biblioteca Servo.h geralmente usa o Timer1 no Arduino UNO/Nano. Se reconfigurar o Timer1 para PWM de alta frequência, não poderá usar a biblioteca Servo nos pinos padrão (9, 10) ao mesmo tempo. No Mega, há mais timers, oferecendo mais flexibilidade.
Resolução do Duty Cycle: Se aumentar a frequência reduzindo o valor TOP (como no exemplo de 1 MHz), perde resolução. Em vez de 256 passos de controlo, pode ter apenas 16, 8 ou menos. Isto pode não ser aceitável para aplicações que exigem controlo fino, como dimming suave de LEDs.
Complexidade: Manipular registradores diretamente é mais complexo e menos intuitivo do que usar analogWrite(). Requer consulta da datasheet do microcontrolador e compreensão dos modos de operação dos timers.
Portabilidade: O código que manipula registradores diretamente é específico para a família de microcontroladores (AVR neste caso). Não funcionará diretamente noutras arquiteturas como ESP32 ou ARM (Arduino Due, etc.) sem modificações significativas.
Necessidade de Teste: É fundamental testar o comportamento do sistema após alterar a frequência PWM. Um osciloscópio é a ferramenta ideal para verificar a frequência real, o duty cycle e a forma de onda do sinal PWM gerado.


8. Alternativas e Placas Diferentes


Se as limitações dos timers AVR no Arduino UNO/Nano/Mega forem um problema:

Bibliotecas: Existem bibliotecas que tentam abstrair a manipulação de timers (como TimerOne, TimerThree, PWM.h), mas podem não estar sempre atualizadas ou cobrir todos os casos de uso. Verifique sempre a compatibilidade e documentação.
Arduino Due (ARM Cortex-M3): Possui capacidades PWM muito mais avançadas e flexíveis, com mais canais, maior resolução e controlo de frequência mais direto através das suas APIs.
ESP32: Uma placa popular com Wi-Fi e Bluetooth integrados. O ESP32 tem um periférico LEDC (LED Control) dedicado que oferece múltiplos canais PWM de alta resolução (até 16 bits) com frequência e duty cycle facilmente configuráveis por software, sem afetar timers de sistema. Pode gerar PWMs de alta frequência (MHz) com boa resolução.
ICs Dedicados de PWM: Para requisitos muito específicos ou de alta potência/precisão, pode usar circuitos integrados externos (PWM controllers) controlados pelo Arduino via I2C ou SPI.


9. Conclusão


A capacidade de gerar sinais PWM é uma das funcionalidades mais versáteis do Arduino, mas a implementação padrão através de analogWrite() opera a frequências fixas (~490 Hz ou ~980 Hz no UNO/Nano/Mega).

Respondendo às perguntas iniciais:

Qual a frequência padrão? Cerca de 490 Hz e 980 Hz, dependendo do pino.
É possível alterar? Sim, através da manipulação direta dos registradores dos timers do microcontrolador, principalmente alterando o prescaler ou o modo de operação do timer.
Qual a frequência máxima?Com resolução de 8 bits (semelhante a analogWrite), o máximo é 62.5 kHz.
Sacrificando a resolução do duty cycle, podem ser alcançadas frequências na ordem dos MHz, mas com controlo muito limitado.
Alterar a frequência PWM abre portas para otimizar o controlo de motores (reduzindo ruído audível, melhorando a resposta), interagir com componentes específicos (ESCs, drivers), gerar áudio ou até implementar fontes comutadas simples. No entanto, esta flexibilidade vem com a necessidade de um entendimento mais profundo do hardware do microcontrolador, o risco de afetar outras funcionalidades (como millis() e delay() se modificar o Timer0) e a perda de resolução em frequências muito altas.

Ao embarcar na modificação da frequência PWM, lembre-se sempre de:

Escolher o Timer Certo: Evite o Timer0 se precisar das funções de tempo padrão. Timer1 (16 bits) e Timer2 (8 bits) são geralmente escolhas mais seguras no UNO/Nano.
Consultar a Datasheet: A datasheet do microcontrolador (e.g., ATmega328P) é a fonte definitiva de informação sobre os registradores dos timers.
Comentar o Código: Documente bem as alterações feitas nos registradores para referência futura.
Testar Exaustivamente: Use um osciloscópio se possível, ou pelo menos observe cuidadosamente o comportamento do seu circuito.
Dominar o controlo da frequência PWM no Arduino é um passo significativo para desbloquear todo o potencial desta plataforma fantástica nos seus projetos de eletrónica. Experimente, explore e continue a aprender!


Calculadora de Resistência (4 Faixas)

Valor: --

Tolerância: --

Gama: --

Calculadora Watts Lâmpada LED vs Lâmpada Incandescente

Nota: Estimativa baseada em brilho (lumens) médio. Verifique sempre a embalagem da lâmpada LED.