👩🏻‍🔧 ⛳️ 🎁 Programação de baixo nível de microcontroladores tinyAVR série 0 🥉 📎 🕧

Você é um programador de 8 ou 32 bits? Na OMZLO, nos concentramos nos novos chips ARM Cortex de 32 bits (STM32 e SAMD), que normalmente oferecem mais RAM e melhor desempenho do que as unidades de micro controlador (MCUs) de 8 bits mais antigas. , suporte para mais periféricos. E tudo isso - pelo mesmo ou por um preço mais baixo. Mas os MCUs de 8 bits ainda não perderam sua relevância. Em particular, a Microchip lançou uma nova série de chips, "tinyAVR 0-series", que, em comparação com os chips AVR lançados anteriormente, torna possível trabalhar com periféricos mais modernos. Ao mesmo tempo, os novos chips se diferenciam por um preço muito atraente. Parece que esses chips são perfeitos para o desenvolvimento de dispositivos simples que não precisam dos recursoso que os MCUs mais novos de 32 bits oferecem. Além disso, os microcontroladores de 8 bits são muito mais fáceis de programar, o que leva a um aumento na velocidade de desenvolvimento da parte do software dos dispositivos criados a partir deles.

Graças ao sucesso do Arduino UNO, existem muitos tutoriais na Internet explicando os recursos de programação dos microcontroladores ATmega328 de 8 bits e seus equivalentes, como o ATtiny85. Estamos falando de acesso direto a registradores sem usar a linguagem de programação usada para Arduino e sem usar IDEs criados por fabricantes de chips como Atmel Studio. Para ver isso, basta pesquisar no Google por "atmega328 blinky". Para programar microcontroladores, você só precisa de um compilador C para AVR, um editor de texto, avrdude e um programador AVR. Em alguns recursosaté mesmo guias podem ser encontrados sobre como fazer o ATmega328 funcionar com placas de ensaio universais. É verdade que, se falarmos sobre os mais novos chips da série 0 tinyAVR, não é fácil encontrar informações desse tipo neles.

Claro, a Microchip oferece todas as ferramentas de que você precisa para programar o novo tinyAVR em um IDE projetado exclusivamente para Windows. Para alguns dos chips mais recentes, existem “núcleos Arduino”. Graças a isso, esses chips podem ser programados usando o IDE do Arduino. Mas, novamente, se alguém preferir escrever código de microcontrolador em um estilo de "baixo nível" usando seu editor de texto favorito Makefilee compilador C, então encontrará muito pouca informação sobre essa abordagem para trabalhar com tinyAVR.

Neste artigo, mostraremos como, do zero, usando as ferramentas mais simples, criar um firmware que piscapara ATtiny406. A maior parte do que será discutido também é verdade para outros MCUs tinyAVR. Este tutorial é direcionado para aqueles que usam macOS e Linux, mas nosso conselho, com pequenas modificações, será útil para aqueles que usam o ambiente Windows.

Parte de hardware do projeto

▍Research ATtiny406

Decidimos experimentar o ATtiny406 , esperando que no futuro este microcontrolador substitua o ATtiny45, que atualmente é usado no PiWatcher - em nosso desenvolvimento, que permite, quando tal necessidade surgir, desligar ou reiniciar completamente o Raspberry Pi. O ATtiny406 possui 4 KB de memória flash, 256 bytes de RAM e o microchip pode operar a 20 MHz sem uma fonte de relógio externa.

Uma das principais diferenças entre os novos MCUs tinyAVR e chips mais antigos e conhecidos como o ATtiny85 é que os chips mais novos usam o protocolo de programação UPDI. Ele só precisa de 3 pinos para funcionar, e 6 pinos são necessários para o protocolo ISP usado por chips antigos.

Após um breve estudo da questão, aprendemos que você pode programar o tinyAVR com UPDI usando um resistor e um cabo USB para serial simples. Descobrimos isso graças à ferramenta pyupdi Python , que sugeriu o seguinte diagrama de fiação para enviar firmware para um microcontrolador.

Diagrama de conexão do microcontrolador

▍Design de placa para ATtiny406

Criamos uma placa de fuga minimalista para o ATtiny406. Esta placa pode ser alimentada por 5 V de USB. Como alternativa, você pode aplicar uma tensão inferior de 3,3 V a ele usando os pinos VCC / GND dedicados. Há um lugar para um botão e um LED na placa. Para realizar experimentos, decidimos construir um resistor de 4,7 kOhm na placa, que é necessário para usar o protocolo UPDI (este é o resistor R2). Como resultado, obtivemos o seguinte layout de placa.

Layout da placa

▍ Quadro acabado

A placa de breakout acabada acabou sendo bastante compacta, ela se encaixa bem em uma pequena placa de ensaio. Os esquemas do tabuleiro podem ser encontrados aqui .

Backplane montado na placa de protótipo

Para programar o ATtiny406, um cabo USB-para-serial é conectado à placa usando os pinos nele.

Diagrama de conexão de cabo

A parte do software do projeto

▍pyupdi

Instalamos o pyupdi seguindo as instruções do repositório do projeto .

O cabo USB para serial foi conectado à placa usando quatro pinos UPDI. Nosso conversor de USB para serial era visto no macOS como um /dev/tty.usbserial-FTF5HUAV.

Para se certificar de que o programador reconhece o ATtiny406, você pode executar um comando semelhante ao seguinte editando o caminho do arquivo:

pyupdi -d tiny406 -c /dev/tty.usbserial-FTF5HUAV -i

Se tudo estiver configurado corretamente, a execução de um comando como este deve resultar na saída de algo como este:

Device info: {'family': 'tinyAVR', 'nvm': 'P:0', 'ocd': 'D:0', 'osc': '3', 'device_id': '1E9225', 'device_rev': '0.1'}

▍C compilador

Descobriu-se que o compilador avr-gcc regular que pode ser instalado no macOS usando o Homebrew não permite definir o ATtiny406 como um destino de compilação. Portanto, decidimos instalar o avr-gcc fornecido pela Microchip. Para baixar o compilador, você precisa criar uma conta no site da Microchip, o que é um pouco chato.

Baixando o compilador

Depois de baixar os materiais necessários apresentados na forma de um arquivo, descompactamos esse arquivo em uma pasta separada. O caminho para o diretóriobinque estará nesta pasta deve ser adicionadoPATH. Isso, no futuro, facilitará o trabalho. Supondo que o compilador esteja armazenado em uma pasta$HOME/Src/avr8-gnu-toolchain-darwin_x86_64, vocêPATHpodeeditá-lo adicionando o seguinte comando ao arquivo.bash_profile:

export PATH=$PATH:$HOME/Src/avr8-gnu-toolchain-darwin_x86_64/bin/

Os MCUs ATtiny mais novos não são suportados pelo compilador avr-gcc da Microchip sem configuração adicional. Para suportá-los, você precisa baixar o ATtiny Device Pack .

Baixando o ATtiny Device Pack

Como resultado, baixamos o pacoteAtmel.ATtiny_DFP.1.6.326.atpack(este arquivo pode ter um nome diferente, seu nome pode incluir um número de versão diferente). Embora a extensão do arquivo seja. atpack, este é realmente um.ziparquivoregular. Mudamos sua extensão para.zipe extraímos o conteúdo do pacote para uma pasta$HOME/Src/Atmel.ATtiny_DFP.1.6.326, ou seja, para o mesmo local onde já estavam os arquivos do compilador.

▍ Escrevendo um programa C

Escrevemos o seguinte programa, que, a uma frequência de 1 Hz, pisca o LED conectado ao pino B5 de nossa placa ATtiny.

#include <avr/io.h>
#include <util/delay.h>

int main() {
    _PROTECTED_WRITE(CLKCTRL.MCLKCTRLB, 0); //   20 (,   0x02   2)

    PORTB.DIRSET = (1<<5);
    for (;;) {
        PORTB.OUTSET = (1<<5);
        _delay_ms(500);
        PORTB.OUTCLR = (1<<5);
        _delay_ms(500);
    }
}

Este código é muito semelhante ao programa de LED piscando escrito para microcontroladores AVR familiares. A primeira mudança notável é o uso de estruturas para acessar os registros MCU. Por exemplo, em vez de se referir a PORTB, uma referência a PORTB.DIRSET.

Outra mudança é representada pelo código de configuração de frequência (_PROTECTED_WRITE(CLKCTRL.MCLKCTRLB, 0)). O novo ATtiny406 roda a 3,33 MHz após uma reinicialização, o que corresponde a um clock base de 20 MHz, que é dividido por 6. Para que o chip funcione na velocidade máxima de 20 MHz, limpamos o registro CLKCTRL.MCLKCTRLB. Uma vez que este registro deve ser protegido de alterações acidentais, no ATtiny406, uma construção de software especial deve ser usada para modificá-lo. Felizmente, as macros tornam isso mais fácil _PROTECTED_WRITE. Você pode ler mais sobre isso.aqui .

Se você comparar este código com aquele que foi escrito para STM32 ou SAMD21, ele se tornará muito mais simples.

▍ Makefile

Aqui, estamos usando a seguinte estrutura de diretório:

src/Atmel.ATtiny_DFP.1.6.326/ - caminho para o Microchip Device Pack.
src/attiny406-test/- a pasta na qual, no arquivo main.c, o código acima está armazenado.

A compilação do código do diretório attiny406-test/pode ser realizada com o seguinte comando:

avr-gcc -mmcu=attiny406 -B ../Atmel.ATtiny_DFP.1.6.326/gcc/dev/attiny406/ -O3 -I ../Atmel.ATtiny_DFP.1.6.326/include/ -DF_CPU=20000000L -o attiny406-test.elf main.c

O sinalizador -Opermite que você execute as otimizações necessárias para que as chamadas de função funcionem com êxito _delay_ms(). O mesmo é verdadeiro para a variável -DF_CPU, cujo conteúdo reflete a frequência esperada do chip. O restante dos parâmetros contém informações sobre a localização dos arquivos do ATtiny406, que baixamos anteriormente e extraímos do arquivo do Device Pack.

Para baixar o firmware para o MCU, você precisa converter o que obteve para o formato Intel HEX. Depois disso, você precisa usar o pyupdi. Criamos uma Makefilesolução simples e automatizada para estas tarefas:

OBJS=main.o
ELF=$(notdir $(CURDIR)).elf  
HEX=$(notdir $(CURDIR)).hex
F_CPU=20000000L

CFLAGS=-mmcu=attiny406 -B ../Atmel.ATtiny_DFP.1.6.326/gcc/dev/attiny406/ -O3
CFLAGS+=-I ../Atmel.ATtiny_DFP.1.6.326/include/ -DF_CPU=$(F_CPU)
LDFLAGS=-mmcu=attiny406 -B ../Atmel.ATtiny_DFP.1.6.326/gcc/dev/attiny406/
CC=avr-gcc
LD=avr-gcc

all:    $(HEX)  

$(ELF): $(OBJS)
                $(LD) $(LDFLAGS) -o $@ $(OBJS) $(LDLIBS)

$(HEX): $(ELF)
                avr-objcopy -O ihex -R .eeprom $< $@

flash:  $(HEX)
                pyupdi -d tiny406 -c /dev/tty.usbserial-FTF5HUAV -f attiny406-test.hex

read-fuses:
                pyupdi -d tiny406 -c /dev/tty.usbserial-FTF5HUAV -fr

clean:
                rm -rf $(OBJS) $(ELF) $(HEX)

Para compilar o código, basta executar o comando make. O download do código para o microcontrolador é realizado pelo comando make flash. Enviados por nós Makefilepodem ser, se necessário, revisados.

Resultado

Os novos TinyAVRs são tão fáceis de programar quanto as gerações anteriores de MCUs. A chave é encontrar as ferramentas certas. Se você tiver alguma dica para programar o AVRTiny, por favor, compartilhe conosco no Twitter ou nos comentários abaixo.

Você está planejando usar o novo TinyAVR em seus projetos?

Programação de baixo nível de microcontroladores tinyAVR série 0