manipulando registradores esp32

Manipulando os registradores - ESP32

Registradores - ESP32

Com o sucesso gigantesco do ESP32 que veio para bater de frente dos PIC32 e STM32, ganhando em alguns aspectos como velocidade, não podemos deixar de lado a manipulação de registradores que não estavam presentes, de maneira fácil, no ESP8266. Neste tutorial, vamos aprender a manipular os registradores de porta (GPIO) do ESP32 de forma simples para efetuar um Blink extremamente compacto e o mais rápido possível.

[toc]

O que são registradores em um microcontrolador?

São pequenos endereços de memória que nos permitem, via software, controlar pinos, processos, interrupções e coisas do tipo de forma extremamente eficiente. Podemos dizer que isso se assemelha ao assembly, visto que é um dos itens de mais baixo nível que conseguimos controlar diretamente pelo código e com isso temos uma eficiente forma de programação em questão de velocidade e confiança.

O ESP32 conta com centenas de registradores de 32bits para que possamos manipular com eficiência todo o hardware disponível, todas as informações estão disponíveis no Datasheet que estará ao fim deste tutorial.

Observação importante: em alguns casos de registradores como o correspondente ao famoso "pinMode()" que declara um pino como saída por exemplo, há mais de um registrador que faz essa mesma tarefa e também mais formas de escrever ou ler registradores, entretanto, sobre os registradores, usaremos os registradores atômicos, que nos garantem a escrita ordenada em um ambiente Triple-Core.

 

Mãos a obra - Piscando um LED através da manipulação de registradores

Componentes necessários

Código do projeto

void setup()
{
	REG_WRITE(GPIO_ENABLE_REG, BIT2);//Define o GPIO2 como saída
}

void loop()
{
	REG_WRITE(GPIO_OUT_W1TS_REG, BIT2);//GPIO2 HIGH (set)
        delay(250);
	REG_WRITE(GPIO_OUT_W1TC_REG, BIT2);//GPIO2 LOW (clear)
        delay(250);
}

Colocando para funcionar

Entendendo a fundo

Software

Quem esta acostumado com registradores pode estranhar esse jeito de manipula-los, parecendo muito mais fácil do que em outros microcontroladores. A verdade é que "REG_WRITE" é uma macro para facilitar a manipulação dos registradores que é definida no arquivo "soc.h", lá você também encontra macros como REG_READ que é usada para leitura de registradores, REG_SET_FIELD e etc.

Os três registradores usados são:

  • GPIO_ENABLE_REG (Figura 1): Registrador que habilita o GPIO(0-31) como saída.
  • GPIO_OUT_W1TS_REG (Figura 2): Registrador que define o GPIO(0-31) em HIGH (Vcc). (SET)
  • GPIO_OUT_W1TC_REG (Figura 3): Registrador que define o GPIO(0-31) em LOW (GND). (CLEAR)

 

Figura 1 - GPIO_ENABLE_REG

 

Figura 2 - GPIO_OUT_W1TS_REG

 

Figura 3 - GPIO_OUT_W1TC_REG

 

Uma forma bem comum de se utilizar registradores para pinos, é a manipulação direta (nesse caso há a 32 bits, logo, 32 pinos) de uma única vez em uma linha! Com isso é possível economizar varias linhas e também deixar o código mais rápido. Se você pretende definir dois pinos como saída, a sentença ficará dessa forma (serve para os outros registradores também):

REG_WRITE(GPIO_ENABLE_REG, BIT2 + BIT4);//Define o GPIO2 e GPIO4 como saída

Esses são os registradores básicos para manipular um pino de saída, se você pretende ler pinos de entrada, terá que usar outros registradores que estão detalhados no Datasheet.

 

Observação: alguns registradores não estão com os nomes definidos nos arquivos do ESP32, logo, você não conseguirá manipular o registrador pelo nome (igual feito acima com GPIO_ENABLE_OUT e etc). Para manipular os registradores que não estão definidos, é necessário pegar o endereço do registrador na memória que se encontra no Datasheet. Veja como ficaria a manipulação sem o nome definido:

 

Figura 4 - Endereço dos registradores.
REG_WRITE(0x3ff44020, BIT2);//Define o GPIO2 como saída

while (1)
{
	REG_WRITE(0x3ff44008, BIT2);//GPIO2  = HIGH
	delay(250);
	REG_WRITE(0x3ff4400C, BIT2);//GPIO2 = LOW
	delay(250);
}

 

Considerações finais

Manipulando diretamente os registradores, conseguimos fazer tarefas com uma extrema velocidade e confiança, sendo necessária para vários projetos. Leia bem o Datasheet se você pretende dominar este incrível microcontrolador e boa sorte com os registradores.

Referências

Todos os registradores, informações e detalhes sobre o ESP32 se encontram nesse Datasheet:

http://espressif.com/sites/default/files/documentation/esp32_technical_reference_manual_en.pdf

by José Morais

ATtiny85 - Primeiros passos

ATtiny85 - Primeiros Passos

Precisa criar projetos pequenos e com baixo consumo energético? Neste tutorial vamos apresentar o ATtiny85, um pequeno Microcontrolador (MCU) de 8 pinos, que pode ser programado pela Arduino IDE!

ATtiny85
ATtiny85

[toc]

O ATtiny85

Este pequeno MCU, apesar de ser inferior em relação ao desempenho quando comparado diretamente ao existente em uma placa Arduino UNO (ATmega328P). O ATtiny85 é útil em diversos projetos, entre eles, os portáteis, os de baixo consumo energético, os que utilizam poucos pinos, robôs e até em pequenos módulos separados de uma central, que por sua vez, se comunicaria com o ATtiny85 através de I2C, SPI ou UART (Serial), para controlar itens específicos, como por exemplo, uma placa de reles.

Comparando o tamanho de placas famosas e do ATtiny85

Características

  • Tensão: 1,8V a 5,5V.
  • Clock interno: 1MHz - 8MHz.
  • Flash: 8KB.
  • RAM: 512B.
  • EEPROM: 512B.
  • Digital Pins: 6.
  • Analog Input (ADC): 4 canais de 10bit.
  • PWM: 3 canais de 8bit.
  • UART: 0.
  • I2C: 1.
  • SPI: 1.

Mapa de pinos

Pinagem do ATtiny85
Pinagem do ATtiny85

Em muitos projetos simples que fazemos, não usamos nem metade dos pinos do Arduino UNO por exemplo. Assim desperdiçando um imenso hardware. Quando pensamos em algo portátil, qualquer consumo desnecessário é ruim ao projeto, porém, o ATtiny85 pode nos ajudar com isso.

Para efeitos de comparação, o Arduino UNO funcionando normalmente, consome aproximadamente ~50mA. Já o ATtiny85, consome aproximadamente ~1mA! Em relação ao Arduino UNO podemos melhorar isso usando Sleeps, no entanto, devido a existência de um LED indicando que a placa esta ligada e a diversos outros itens, portanto, mesmo com Deep Sleep, o Arduino UNO consome aproximadamente ~15mA. Já o ATtiny85, por não conter nada além do MCU, no modo Deep-Sleep consome ~0,0001mA ou ~100nA! Seus projetos portáteis irão melhorar muito na questão de autonomia, pois, é possível liga-lo com uma simples bateria CR2032 que encontramos em placa-mãe de CPUs.

Um dos problemas mais comuns é a falta dos pinos físicos de UART ,logo, se você for usar o Serial Monitor para algum debug ou até a comunicação com outros MCUs via UART (Serial), será necessário o uso da Software Serial. Esta biblioteca emula a comunicação Serial (UART) em qualquer pino do MCU e visto que o ATtiny85 não há pinos físicos para UART, devemos usa-la. Entretanto, a biblioteca ocupa uma imensa quantidade de Flash e RAM.

Podemos trabalhar, satisfatoriamente, com o Clock interno, que vai de 1MHz até 8MH. No entanto, Se for preciso mais velocidade, é necessário adicionar um cristal externo de até 20MHz.

Instalando na Arduino IDE

A Arduino IDE não suporta o ATtiny85 nativamente, portanto,  precisamos adicionar o Core do ATtiny85  a ela para conseguir usar o ATtiny85.

1-) Entre em https://github.com/SpenceKonde/ATTinyCore e copie o link .JSON que esta descrito dentro do arquivo "Installation" . Com este link iremos baixar os arquivos na Arduino IDE.

2-) Vá em "Preferências", adicione o link copiado em "URLs adicionais" e clique em "OK".

3-) Vá em "Ferramentas" -> "Placa" -> "Gerenciador de Placas...". Procure pelo ATtinyCore na lista e instale.

4-) Volte em "Ferramentas" -> "Placa" e veja que apareceu o ATtiny!

Mãos a obra - Piscando o primeiro LED no ATtiny85

Componentes necessários

Montando o projeto

O ATtiny85 não conta com conversor Serial e muito menos uma porta USB, portanto, devemos dar upload a ele através de um gravador que neste caso será o Arduino UNO. A explicação estará logo abaixo em "Entendendo a fundo: Hardware".

Para gravar o "Bootloader" (definição dos Fuses) e o código em si, devemos utilizar um gravador externo. Iremos usar o Arduino UNO como ISP.

1-) Abra o exemplo "ArduinoISP" no menu de exemplos , e faça o upload deste código no seu Arduino UNO. Não esqueça de selecionar a porta COM e a placa "Arduino UNO" no menu de ferramentas, caso não esteja selecionado.

2-) Após efetuar o upload do "ArduinoISP" no Arduino UNO, ele está apto a gravar códigos em Microcontroladores ISP sem Bootloader. Podemos agora concluir as ligações necessárias para upload do código e gravação dos Fuses ("Bootloader") no ATtiny85.

Muita atenção na posição do ATtiny85! Deixamos a "bolinha indicadora" para a esquerda, se você inverter, consequentemente irá inverter os pinos de alimentação e queimar seu tiny85! Sempre confira as ligações com o Mapa de pinos.

Os pinos utilizados são os mesmos de uma comunicação SPI e alimentação.

  • 5V.
  • GND.
  • CLOCK (13).
  • MISO (12).
  • MOSI (11).
  • CS (10).

3-) Plugue o Arduino UNO no computador e abra um novo Sketch (projeto). Precisamos selecionar as configurações de "Bootloader" (Fuses) para depois gravar o código no tiny85. Entre no menu de ferramentas e indicamos que deixe igual o da imagem, apenas altere se souber o que esta fazendo!

Obs: Altere a porta COM para a porta que seu Arduino UNO estiver conectado.

Após arrumar todos itens, clique em "Gravar Bootloader". Isso irá apenas configurar os Fuses do ATtiny85, ainda não é o upload do nosso código. Você só precisa fazer isso para o primeiro upload ou se for alterar alguma dessas configurações futuramente.

Agora que gravamos o "Bootloader", podemos finalmente dar upload de nossos códigos. Basta manter as configurações selecionadas anteriormente, escrever o código e dar upload.

Veja como ficou nossa montagem:

ATtiny85 montado no protoboard junto ao Arduino Uno
ATtiny85 montado no protoboard junto ao Arduino Uno

Código do projeto

void setup()
{
    pinMode(4, OUTPUT);//Define o pino 4 (PB4) como saida.
}

void loop()
{
    digitalWrite(4, !digitalRead(4));//Inverte o estado do pino.
    delay(200);//Espera 200mS.
}

Colando para funcionar

Após a gravação do "Bootloader" e do código, podemos ver essa mini-maravilha funcionando! Removemos os fios de upload e deixamos apenas a alimentação (5V e GND) juntamente com o LED no pino PB4.

ATtiny85 com led

Entendendo a fundo

Software

-Função pinMode

 pinMode(4, OUTPUT);//Define o pino 4 (PB4) como saida.

Como podemos ver no Mapa de pinos, as opções em verde são os pinos que podemos usar normalmente. Estes estão descritos como PB0 ao PB5 e podemos usar o número para programar. Usamos o pino 4, que é referente ao PB4 (localizado ao lado do GND).

-Blink

digitalWrite(4, !digitalRead(4));//Inverte o estado do pino.
delay(200);//Espera 200mS.

Efetuamos um Blink (inversão de estado) no pino 4, para que vejamos o LED piscando.

Desafio

Como citado anteriormente, podemos utilizar esse pequeno MCU para fazer sub-módulos de controle, que estará conectado em uma central (um Arduino MEGA por exemplo). Tente fazer a comunicação Serial (UART) entre o Arduino UNO com o ATtiny85 para fazer o LED piscar a partir de comandos recebidos pela Serial (UART). Também citamos que não há pinos físicos para UART no tiny85, então você precisa usar a biblioteca Software Serial.

Fechamento

Com esse  minúsculo Microcontrolador, podemos fazer diversos projetos onde tamanho e consumo energético são essenciais e importantes. Entretanto, a pouca RAM e Flash comparada ao UNO, pode ser fatal se seus modos de programação não forem os melhores. Não se esqueça de "boas práticas" para programa-lo e bons estudos.

 

by José Morais