Controle de GPIOs por registradores no ATmega328P

Um registrador de periférico é uma posição especial ligada ao hardware do microcontrolador. Ao acessá-la, o programa não está apenas manipulando um valor na memória: uma leitura pode consultar um estado do circuito, e uma escrita pode configurar ou acionar uma função do periférico.

Isso difere de uma variável comum em C/C++, cujo valor existe como dado do programa. Também difere dos registradores de armazenamento vistos em lógica digital: aqui, os bits têm significado definido pela documentação do periférico.

Por isso, antes de escrever em um registrador, confirme o efeito documentado daquele acesso.

Ao trabalhar com GPIO no Uno R3, consulte a folha de dados do ATmega328P — o microcontrolador da placa de referência. Siga este roteiro:

1. Confirme que o componente é o ATmega328P.
2. Localize a seção sobre portas de entrada e saída digital (I/O Ports).
3. Encontre o registrador de interesse na descrição da porta.
4. Leia o quadro do registrador e sua explicação detalhada.

Não use somente o nome parecido de um registrador como regra de programação. A descrição informa o que seus bits representam e quais consequências uma leitura ou escrita pode ter.

Associe cada pergunta à informação documental mais adequada.

No Uno R3 usado nesta prática, o nome do conector na placa não é o mesmo nome usado dentro do ATmega328P. A correspondência que vamos usar é:

• D13 → PB5
• D2 → PD2

Em PB5, a letra B identifica a porta e o número 5 identifica a posição do bit nessa porta. Analogamente, PD2 é o bit 2 da porta D. Esses nomes permitem selecionar o bit correto nos registradores da porta nas próximas etapas.

Quatro identificações podem aparecer ao consultar esquemas e documentação. Elas respondem a perguntas diferentes; não são sinônimos.

Em uma compilação para AVR, o cabeçalho avr/io.h disponibiliza os símbolos da arquitetura selecionada, incluindo registradores como PORTB e nomes de bits como PB5 e PD2.

Ele não converte automaticamente números Arduino: 13 não significa “bit 13”. Para esta placa, D13 é PB5; D2 é PD2. Em um Uno R4 ou em outra placa, o microcontrolador e o mapeamento podem ser diferentes. Consulte sempre a documentação e a definição da placa usada.

Complete a diretiva que torna disponíveis os símbolos AVR usados neste tutorial.

Em cada porta do ATmega328P, três famílias de registradores respondem a perguntas diferentes:

• DDRx: o pino será entrada ou saída?
• PORTx: qual comando aplicar conforme a direção escolhida?
• PINx: qual nível digital está presente no pino?

O x é a letra da porta. Assim, PB5 usa DDRB, PORTB e PINB; PD2 usa DDRD, PORTD e PIND.

Para um bit de DDRx, 0 configura entrada e 1 configura saída. Depois dessa escolha, o mesmo bit de PORTx ganha um significado dependente da direção.

Use PINx quando a tarefa for consultar o nível digital presente no pino. Por exemplo, para a porta D, PIND reúne os níveis dos bits PD0 a PD7.

Após um reset, os registradores DDRx e PORTx começam com bits em 0: os pinos começam como entradas e sem pull-up habilitado por esses bits. Isso descreve o estado de reset documentado, não uma promessa sobre o instante em que seu setup() começa: antes dele, o bootloader e a inicialização do ambiente podem ter executado.

D13 corresponde a PB5. Logo, o bit 5 é o ponto de interesse em DDRB e PORTB.

Uma atribuição como DDRB = 0b00100000; grava os oito bits do registrador: além de colocar PB5 em 1, força todos os outros bits para 0. Isso pode mudar a configuração de pinos que esta montagem não usa.

Use uma máscara de um bit para alterar somente PB5:

• |= ativa o bit selecionado e preserva os demais;
• &= ~ limpa o bit selecionado e preserva os demais.

Essa preservação vale para a operação realizada: os outros bits mantêm o valor que tinham imediatamente antes dela.

Partindo da condição de entrada usada nesta prática, defina primeiro o comando baixo em PORTB e depois habilite PB5 como saída em DDRB. Assim, quando o pino se tornar saída, já terá comando baixo.

O sketch abaixo é compilável: o cabeçalho fica no início do arquivo e as instruções executáveis ficam dentro de setup(). Ele não afirma qual era o estado da porta antes de setup() começar.

Exemplo completo de inicialização para o sketch.

Depois da inicialização, PB5 é saída; portanto, seu bit em PORTB comanda o LED integrado:

• PORTB |= LED_MASK; comanda nível alto e acende o LED;
• PORTB &= (uint8_t)~LED_MASK; comanda nível baixo e apaga o LED.

As duas instruções selecionam somente PB5. Os outros bits de PORTB não são intencionalmente substituídos.

Use estas instruções dentro de uma função, após a inicialização de PB5.

Complete as duas operações seletivas. A primeira deve configurar PB5 como saída; a segunda deve deixar o LED apagado. Em ambas, os bits não selecionados devem ser preservados.

Agora organize a inicialização completa a partir da condição de entrada adotada neste exemplo. A direção só deve ser habilitada depois que o comando baixo estiver definido em PORTB.

No Uno R3 com ATmega328P, D2 corresponde a PD2, o bit 2 da porta D. Para usar o botão ligado entre D2 e GND, PD2 deve permanecer como entrada e ter seu pull-up interno habilitado.

Use máscaras para modificar somente esse bit:

• Em DDRD, limpe PD2 para selecionar entrada.
• Em PORTD, ative PD2 para habilitar o pull-up dessa entrada.

As operações preservam os demais bits de DDRD e PORTD: elas não pretendem substituir a configuração dos outros pinos da porta.

Este sketch completo mostra o escopo correto das instruções: a constante fica fora das funções, mas a configuração dos registradores ocorre dentro de setup().

PORTD e PIND respondem a perguntas diferentes:

• Ler PORTD consulta o comando armazenado. Quando PD2 é entrada, o bit em 1 mantém seu pull-up habilitado.
• Ler PIND consulta o nível digital presente no terminal.

Portanto, nesta prática o bit 2 de PORTD continua em 1 tanto com o botão solto quanto pressionado. Ao pressionar, o botão conecta D2 ao GND; então o bit 2 lido em PIND passa a 0.

A máscara seleciona apenas PD2. Como a ligação é ativa em nível baixo, resultado mascarado igual a zero significa botão pressionado.

No ATmega328P, PINx é o registrador usado para ler o nível presente nos pinos. Porém, a documentação define um efeito especial para a escrita: escrever 1 em uma posição de PINx alterna o bit correspondente em PORTx; escrever 0 não altera esse bit.

Assim, PINB não recebe um novo “valor de entrada”. A escrita aciona uma operação sobre o comando armazenado em PORTB.

Para PB5, ligado ao D13 no Uno R3, a máscara é (1U << PB5).

Para alternar somente PB5, escreva diretamente a máscara desejada em PINB:

PINB = (1U << PB5);

Essa atribuição coloca 1 apenas no bit 5 da escrita. Os demais bits recebem 0 e, pela regra especial, não são alterados. Não é necessário ler PINB antes.

Depois de configurar PB5 como saída, uma função curta pode alternar o LED integrado assim:

Um pino, um único hardware

pinMode(), digitalWrite() e digitalRead() são funções da API Arduino. Já DDRx, PORTx e PINx são acessos diretos aos registradores do ATmega328P. Eles não controlam hardwares separados: ambos chegam aos mesmos circuitos dos pinos.

Assim, uma chamada da API pode alterar uma configuração feita por registradores — e uma escrita em registrador pode mudar o estado que uma chamada posterior da API encontrará.

Nesta prática, defina uma responsabilidade simples: o código de registradores controla D13/PB5 e D2/PD2. Não use chamadas da API Arduino para configurar ou comandar esses dois pinos no mesmo programa.

As máscaras continuam importantes: uma operação como DDRB |= _BV(DDB5); pretende mudar apenas PB5 e preservar os demais bits de DDRB.

Mas isso não impede outro trecho de código de escrever depois em DDRB, PORTB, DDRD ou PORTD. A máscara protege os bits não selecionados naquela operação; ela não reserva a porta nem coordena autores diferentes.

Por isso, durante a prática, bibliotecas e outros trechos não devem alterar as portas B e D usadas por D13 e D2.

Nesta aplicação, o LED integrado de D13 acompanha o nível mantido do botão em D2: solto, LED apagado; pressionado, LED aceso. Não há contagem de cliques, temporização nem tratamento de rebote.

Use um Arduino Uno R3 com ATmega328P, cabo USB de dados, um botão e fios. O programa acessa PB5 (D13) e PD2 (D2) diretamente pelos registradores AVR.

Complete as lacunas que levam PB5 explicitamente à condição de saída inicialmente baixa, configuram PD2 como entrada com pull-up e leem o nível presente em D2. As máscaras já selecionam somente os bits da prática.

A primeira operação de DDRB não presume qual direção PB5 tinha antes de setup(): ela o coloca como entrada antes de definir o comando baixo.

Crie um sketch novo, substitua seu conteúdo por este programa, compile e grave no Uno R3 com o botão ainda desconectado.

Depois de gravar, desligue a placa pelo cabo USB, faça a ligação D2–botão–GND mostrada anteriormente e reconecte o USB.

Observe o LED integrado:

• botão solto: apagado;
• botão mantido pressionado: aceso.

Se o resultado divergir, desligue pelo USB e confira a posição dos contatos do botão e a ligação ao GND. Não force níveis externos em D2.

Você aplicou o acesso direto aos GPIOs do ATmega328P: configurou D13/PB5 e D2/PD2, leu o nível por PIND e comandou o LED por PORTB, preservando os demais bits nas operações seletivas.

Lembre a distinção final: PORTB |= LED_MASK comanda PB5 em nível alto; PORTB &= ~LED_MASK comanda nível baixo; PINB = LED_MASK aciona a alternância especial de PB5. Evite PINB |= LED_MASK, pois uma leitura prévia pode provocar alternâncias indesejadas em outros bits.