10/01/22, 15:05 Mudando de Arduino para AVR - Mikrocontroller.

net

Bem-vindo à coleção de artigos Mikrocontroller.net. Todos os artigos aqui podem ser editados
por qualquer pessoa de acordo com o princípio wiki. Para a página principal da coleção de
artigos

Mudando de Arduino para AVR

Da coleção de artigos Mikrocontroller.net, com contribuições de vários autores (consulte o histórico da
versão)

por nova geração

Este artigo deve ser uma pequena ajuda para todos que estão trabalhando atualmente com uma
placa Arduino, mas estão mais interessados ​no assunto e desejam mudar para a programação de
microcontroladores reais.

Algumas etapas pequenas, mas úteis, são mostradas aqui para tornar a mudança mais fácil.
Estas instruções são destinadas apenas para os Arduinos com um AVR de 8 bits como
processador (Uno, Mega, Leonardo, ...) e não para microcontroladores de 32 bits (Due, ...).

O microcontrolador é programado em C nestas instruções. A razão para isso é a distribuição das

linguagens de programação e sua dificuldade de aprendizagem. Em microcontroladores, há
principalmente assembler e C, embora outras linguagens também estejam em ascensão, como C
++ (a estrutura do Arduino é escrita em C ++).

No entanto, deve ser limitado a C aqui porque

1. C ++ é mais difícil de dominar do que C

2. A maioria dos esboços do Arduino tendem a ser escritos em C, com exceção das bibliotecas
do Arduino e seus objetos
3. Assembler é uma linguagem completamente diferente

https://www.mikrocontroller.net/articles/Umstieg_von_Arduino_auf_AVR 1/13
10/01/22, 15:05 Mudando de Arduino para AVR - Mikrocontroller.net

Índice

1 requisitos
Conhecimento 1.1 C
1.2 Outros conhecimentos prévios
1.3 software
2 Modificando o esboço do Arduino
2.1 Adaptação de tipos int
2.2 Removendo as bibliotecas do Arduino
2.3 função principal () em vez de configuração () e loop ()
3 vias do IDE Arduino
3.1 Selecionando o novo IDE
3.2 Familiarização com o novo ambiente
3.3 Transferir o programa
4 substituições da biblioteca Arduino
4.1 Criação de suas próprias bibliotecas

requisitos

Conhecimento C

Qualquer pessoa que já pode programar C - o que significa mais do que if-else e copiar e colar a
programação - pode, é claro, pular este ponto. Só posso recomendar calorosamente a todos os
outros que trabalhem com um livro C ou pelo menos um (bom) tutorial C.

No artigo C, há alguns links para tutoriais e introduções à linguagem C. Deve ser mais fácil
adquirir conhecimento de C em um PC, pois aí você tem muito mais possibilidades de analisar
seu programa e reagir a erros.

Atenção: tutoriais, principalmente aqueles em alemão, devem ser questionados em alguns casos.
Freqüentemente, o autor apenas escreve sua visão (às vezes limitada) das coisas. Não custa
nada ler mais de um tutorial e consultar o padrão C em caso de discrepâncias.

Outro conhecimento prévio

Manipulação de bits
Arquitetura Harvard
Saber sobre AVR e microcontroladores em geral não faz mal

Programas

Compilador: você deve adicionar os caminhos para os executáveis ​do avr-gccs no ambiente
Arduino à variável de ambiente PATH ou, especialmente se quiser desinstalar o IDE do
Arduino posteriormente, fazer uma instalação separada do compilador. Veja também AVR-
GCC .

https://www.mikrocontroller.net/articles/Umstieg_von_Arduino_auf_AVR 2/13
10/01/22, 15:05 Mudando de Arduino para AVR - Mikrocontroller.net

Um programa de terminal como Putty ou HTerm nunca faz mal.

Modificando o esboço do Arduino

A primeira coisa a fazer é desistir de falar de sketches , só vai te fazer sorrir. Existem programas ,
aplicativos , aplicativos , ...

Adaptação de tipos int

Quase todos os exemplos do Arduino de alguma forma se parecem com isto (aqui um pouco de
luz em movimento):

int ledPin = 13 ; // LED conectado ao pino digital 13

void setup ()
{
pinMode ( ledPin , OUTPUT ); // define o pino digital como saída para ( int
i = 0 ; i < 8 ; i ++ ) {

pinMode ( i , OUTPUT ); // define o pino digital como saída }

digitalWrite ( ledPin , HIGH ); // liga o LED da placa }

void loop ()
{
para ( int i = 0 ; i < 8 ; i ++ ) {
digitalWrite ( i , HIGH ); // define o LED no pino <i> on delay ( 100
); // espera 100 milissegundos digitalWrite ( i , LOW ); // define o LED no
pino <i> desligado }

atraso ( 1000 ); // espera um segundo }

/ *
O esboço usa 1006 bytes (3%) da memória do programa.
O máximo é 32256 bytes.
Variáveis ​
globais usam 9 bytes (0%) de memória dinâmica,
2039 bytes permanecem para variáveis ​
locais. O máximo é 2.048 bytes.
* /

Você percebe algo? Não? Qual é o tamanho de um int ? Exatamente pelo menos 16 bits. E é um
cara assinado.

Uma variável do tipo int pode assumir valores de -2 ^ 15 a 2 ^ 15-1 em um AVR. São números
entre -32768 e 32767. E o que é armazenado neste tipo?

Uma variável cujo valor nunca muda: int ledPin = 13;

E duas variáveis ​de execução de 0 a 7.
https://www.mikrocontroller.net/articles/Umstieg_von_Arduino_auf_AVR 3/13
10/01/22, 15:05 Mudando de Arduino para AVR - Mikrocontroller.net

Portanto, nenhum deles é realmente o que você precisa para as variáveis ​de 16 bits.

Ok, então você acabou de definir variáveis ​com um tipo que é muito grande, o que isso faz? Algo,
porque o AVR é ​um microcontrolador de 8 bits, o que significa que ele só pode manipular números
de 8 bits por vez, tudo maior requer vários comandos e, portanto, é mais lento. Os
microcontroladores também preferem números sem sinal aos assinados.

Portanto, para cada variável, você deve pensar na faixa de valores de que precisa e sempre usar
o tipo o menor possível, mas o maior necessário.

O padrão C oferece tipos com uma largura de bit exata, para os quais apenas um arquivo de
cabeçalho deve ser integrado:

#include <stdint.h>

Os seguintes tipos, entre outros, são então definidos neste:

Tamanho Sem sinal Assinado

8 bits uint8_t int8_t

16 bits uint16_t int16_t

32 bits uint32_t int32_t

64 bits uint64_t int64_t

A nomenclatura é na verdade bastante simples: [u] int [bits] _t, onde [u] significa sem sinal, ou
seja, sem sinal, e [bits] especifica o número de bits para a variável.

O código-fonte alterado tem a seguinte aparência:

#include <stdint.h>

#define LED_PIN 13 // uma definição não gera nenhum código adicional,

// apenas uma substituição de texto ocorre depois de tudo. //
Define sempre em MAIÚSCULAS

void setup ()
{
pinMode ( LED_PIN , OUTPUT ); // define o pino digital como saída para (
uint8_t i = 0 ; i < 8 ; i ++ ) {

pinMode ( i , OUTPUT ); // define o pino digital como saída }

digitalWrite ( LED_PIN , HIGH ); // liga o LED da placa }

void loop ()
{
para ( uint8_t i = 0 ; i < 8 ; i ++ ) {
https://www.mikrocontroller.net/articles/Umstieg_von_Arduino_auf_AVR 4/13
10/01/22, 15:05 Mudando de Arduino para AVR - Mikrocontroller.net

digitalWrite ( i , HIGH ); // define o LED no pino <i> on delay ( 100

); // espera 100 milissegundos digitalWrite ( i , LOW ); // define o LED no
pino <i> desligado }

atraso ( 1000 ); // espera um segundo }

/ * O esboço usa 1006 bytes (3%) da memória do programa.

O máximo é 32256 bytes.
Variáveis ​
globais usam 9 bytes (0%) de memória dinâmica,
2039 bytes permanecem para variáveis ​
locais.
O máximo é 2.048 bytes.
* /

Como você pode ver, essa mudança não ajudou com esse programa mínimo, mas não mostra
que essa adaptação é inútil, mas que o compilador a otimizou muito bem e eliminou essas
variáveis ​desnecessariamente grandes.

Outro exemplo é este programa. Não importa, exceto contar uma variável volátil. (Volátil para
proibir as otimizações).

#include <stdint.h>
// 64 bits
voláteis int64_t a ;

void setup ()
{
a = 0 ;
}

void loop ()
{
a ++ ;
}
/ *
O esboço usa 570 bytes (1%) da memória do programa.
O máximo é 32256 bytes.
Variáveis ​globais usam 17 bytes (0%) de memória dinâmica,
2031 bytes permanecem para variáveis ​locais. O máximo é 2.048 bytes.
* /

Se você agora reduzir o tamanho da variável e alterá-la para sem sinal:

#include <stdint.h>
// 8 bits
voláteis uint8_t a ;

void setup ()
{
a = 0 ;
}

https://www.mikrocontroller.net/articles/Umstieg_von_Arduino_auf_AVR 5/13
10/01/22, 15:05 Mudando de Arduino para AVR - Mikrocontroller.net

void loop ()
{
a ++ ;
}
/ *
O esboço usa 458 bytes (1%) da memória do programa.
O máximo é 32256 bytes.
Variáveis ​globais usam 10 bytes (0%) de memória dinâmica,
2038 bytes permanecem para variáveis ​locais. O máximo é 2.048 bytes.
* /

Mesmo com este programa mínimo, você pode ver uma pequena diferença

No caso de programas maiores com vários módulos, no entanto, o compilador não pode mais ver
tudo, então essa mudança vale a pena lá, o mais tardar.

Remover as bibliotecas do Arduino [ editar ]

Se você quiser entender seu microcontrolador corretamente, também deve tentar programar
todos os controles de hardware sozinho.

Remover o atraso () chama [ editar ]

Em primeiro lugar: os atrasos são quase sempre graves! Enquanto o controlador está esperando
em delay (), ele não pode fazer mais nada!

A implementação de delay () na biblioteca Arduino usa interrupções e, portanto, não pode

funcionar em interrupções (embora isso seja uma ideia muito ruim, de qualquer maneira). Mas,
para fugir do Arduino e de sua biblioteca, usamos outra implementação, a saber, a do avr-libc.
Isso oferece _delay_ms () e _delay_us () para atrasos precisos em milissegundos ou
microssegundos. Tudo o que é necessário é incluir <util / delay.h>.

#include <stdint.h>
#include <util / delay.h>

#define LED_PIN 13 // uma definição não gera nenhum código adicional,

// apenas uma substituição de texto ocorre depois de tudo. //
Define sempre em MAIÚSCULAS

void setup ()
{
pinMode ( LED_PIN , OUTPUT ); // define o pino digital como saída para (
uint8_t i = 0 ; i < 8 ; i ++ ) {

pinMode ( i , OUTPUT ); // define o pino digital como saída }

digitalWrite ( LED_PIN , HIGH ); // liga o LED da placa }

https://www.mikrocontroller.net/articles/Umstieg_von_Arduino_auf_AVR 6/13
10/01/22, 15:05 Mudando de Arduino para AVR - Mikrocontroller.net

void loop ()
{
para ( uint8_t i = 0 ; i < 8 ; i ++ ) {
digitalWrite ( i , HIGH ); // define o LED no pino <i> em _delay_ms (
100 ); // espera 100 milissegundos digitalWrite ( i , LOW ); // define o LED no
pino <i> desligado }

_delay_ms ( 1000 ); // espera um segundo }

/ *
O esboço usa 828 bytes (2%) da memória do programa.
O máximo é 32256 bytes.
Variáveis ​
globais usam 9 bytes (0%) de memória dinâmica,
2039 bytes permanecem para variáveis ​
locais. O máximo é 2.048 bytes.
* /

Remover as chamadas de E / S [ editar ]

Isso inclui pinMode, digitalWrite e ditigalRead. Todos eles têm uma coisa em comum: a
numeração idiossincrática dos pinos.

Embora estejam organizados de forma lógica na placa Arduino, eles não estão necessariamente
conectados de forma lógica ao processador! É por isso que você tem que pesquisar sua placa
arduino + pinagem no Google e obter belas imagens que mostram claramente o que está
conectado com o quê. Com o Arduino Uno a coisa toda continua bem legal, com o Arduino Mega
lembra mais o caos ...

Um site que tem muitas pinagens é o libraries.io . Aí basta procurar a sua prancha e é melhor
guardar a fotografia, porque é necessário com ainda mais frequência.

Para realmente começar agora, falta apenas uma coisa: a ficha técnica do processador. A página
do Arduino informa que tipo de processador está instalado lá, você deve então pesquisar esta
folha de dados no Google ou diretamente do fabricante Atmel. Com o Arduino Uno é o
ATmega328p .

Há um capítulo "Portas de E / S" na folha de dados, que explica em detalhes como os pinos
funcionam e como devem ser controlados. Existem três registros que são particularmente
importantes :

PORT x - O registro de dados da porta x

DDR x - O registro de direção de dados da porta x
PIN x - O registro do pino de entrada da porta x

Onde ox representa a porta. As portas existentes dependem do respectivo AVR. Por exemplo, o
Atmega328p possui quatro peças: PORTA, PORTB, PORTC, PORTD. Já um ATmega2560 tem
onze: PORTA - PORTH e PORTJ - PORTL. O que todos eles têm em comum é que uma porta
contém no máximo 8 pinos (P XN , X = letra da porta, N = bit da porta).

https://www.mikrocontroller.net/articles/Umstieg_von_Arduino_auf_AVR 7/13
10/01/22, 15:05 Mudando de Arduino para AVR - Mikrocontroller.net

Mais detalhes podem ser encontrados aqui:

Cadastre o acesso
Portas I / O

Uma versão curta agora segue:

Para poder acessar os registradores de I / O (ou registradores em geral), você precisa de um

arquivo de cabeçalho adicional:

#include <avr / io.h>

Cada pino individual pode então ser controlado usando esses registros. A tabela a seguir mostra
as opções de configuração:

DDRxPORTx Status do pino IO

0 0 Entrada sem pull-up (status de reset)
0 1 Entrada com pull-up
1 0 Saída push-pull para BAIXO
1 1 Saída push-pull para HIGH

O restante do registro PINx agora pode ser usado novamente de duas maneiras. Se o pino for um
pino de entrada (DDxn = 0), este registro gera o estado do pino, 1 para alto e 0 para baixo. No
entanto, se o pino for configurado como uma saída, os AVRs mais novos (praticamente todos em
Arduinos) podem "alternar" o pino diretamente, ou seja, alterná-lo: se estiver alto no momento, ele
será alterado para baixo e vice-versa.

Com esse conhecimento, podemos lidar com nosso código novamente:

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

// Arduino pino 13 é pino PB5 no Arduino Uno

# define LED_DDR DDRB
# define LED_PORT PORTB
# define LED_BIT PB5

void setup ()
{
LED_DDR | = ( 1 << LED_BIT ); // define o pino digital como saída // os 8
LEDs estão todos em PORTD, então está completamente na saída DDRD = 0xFF ;

LED_PORT | = ( 1 << LED_BIT ); // liga o LED da placa }

void loop ()

https://www.mikrocontroller.net/articles/Umstieg_von_Arduino_auf_AVR 8/13
10/01/22, 15:05 Mudando de Arduino para AVR - Mikrocontroller.net

{
para ( uint8_t i = 0 ; i < 8 ; i ++ ) {

PORTD | = ( 1 << i ); // define o LED no pino <i> em _delay_ms ( 100 );

// espera 100 milissegundos PORTD & = ~ ( 1 << i ); // define o LED no pino <i>
desligado }

_delay_ms ( 1000 ); // espera um segundo }

/ *
O esboço usa 534 bytes (1%) da memória do programa.
O máximo é 32256 bytes.
Variáveis ​
globais usam 9 bytes (0%) de memória dinâmica,
2039 bytes permanecem para variáveis ​
locais. O máximo é 2.048 bytes.
* /

Você pode ver: o consumo de memória foi pressionado novamente, e o programa também ficou
mais rápido.

Mas ainda há dúvidas: por que este miniprograma ainda usa tanto Flash? Por que a RAM está
sendo consumida, embora nenhuma variável seja usada?

TODO : Meça a velocidade usando um oscilador (também pode ser feito por outra pessoa) .

main () função em vez de setup () & loop () [ editar ]

Comparado com outros IDEs, o Arduino IDE foi construído em uma "coisa desagradável". Para
tornar as coisas mais fáceis para o usuário, ele muda silenciosamente o código (por exemplo,
adiciona uma função main () e o include <Arduino.h>) e puxa o código mesmo se ele não for
usado.

Por exemplo, a rotina de interrupção que forma o cronômetro de milissegundos para a função
delay (): Tanto a rotina em si quanto a configuração da interrupção e a permissão geral de todos
os ISRs acontecem automaticamente, sem que o usuário tenha que fazer nada pode mudar.

Isso geralmente é bom, uma vez que o usuário Arduino de 15/08 não está interessado nele.

Mas conosco é algo diferente! Portanto, o programa é adaptado a um programa C real, ou seja,
com uma função main () em vez de setup () e loop ().

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

// Arduino pino 13 é pino PB5 no Arduino Uno

# define LED_DDR DDRB
# define LED_PORT PORTB
# define LED_BIT PB5

https://www.mikrocontroller.net/articles/Umstieg_von_Arduino_auf_AVR 9/13
10/01/22, 15:05 Mudando de Arduino para AVR - Mikrocontroller.net

int main ( vazio )

{
LED_DDR | = ( 1 << LED_BIT ); // define o pino digital como saída // os 8
LEDs estão todos em PORTD, então está completamente na saída DDRD = 0xFF ;

LED_PORT | = ( 1 << LED_BIT ); // acende o LED da placa enquanto ( 1 )

{
para ( uint8_t i = 0 ; i < 8 ; i ++ ) {

PORTD | = ( 1 << i ); // define o LED no pino <i> em _delay_ms (

100 ); // espera 100 milissegundos PORTD & = ~ ( 1 << i ); // define o LED no
pino <i> desligado }

_delay_ms ( 1000 ); // espera um segundo }

}
/ *
O esboço usa 222 bytes (0%) da memória do programa.
O máximo é 32256 bytes.
Variáveis ​
globais usam 0 bytes (0%) de memória dinâmica,
2048 bytes permanecem para variáveis ​
locais. O máximo é 2.048 bytes.
* /

Et voilà! Aí está: O consumo de código caiu drasticamente novamente e acima de tudo: sem
variáveis, sem consumo de RAM!

Isso apaga qualquer código do Arduino que foi adicionado em segundo plano.

Nota: O compilador não gosta de alternar entre variáveis, ou seja (1 << i). É muito melhor se você
escrever algo assim:

máscara uint8_t = ( 1 << 0 );

para ( uint8_t i = 0 ; i < 8 ; i ++ ) {

PORTD | = máscara ; // define o LED no pino <i> em _delay_ms ( 100 ); //

espera 100 milissegundos PORTD & = ~ mask ; // define o LED no pino <i> off
mask = ( máscara << 1 ); // desloca a parte para a esquerda }

Em primeiro lugar, é mais rápido e, em segundo lugar, usa menos memória (apenas 204 bytes no
exemplo).

https://www.mikrocontroller.net/articles/Umstieg_von_Arduino_auf_AVR 10/13
10/01/22, 15:05 Mudando de Arduino para AVR - Mikrocontroller.net

Longe do Arduino IDE [ editar ]

Seleção do novo IDE [ editar ]

Então, agora você chegou ao ponto em que pode (e na minha opinião deve) decidir dizer adeus
ao IDE do Arduino. Isso não é ideal em muitos aspectos, seja por exemplo ao destacar o código
ou a falta de opções de configuração.

Existem várias maneiras pelas quais você pode proceder agora:

fique com o IDE do Arduino

mude para o Atmel Studio (seja a versão 7 com vários novos recursos ou a versão 4, se for
rápida e confiável)
mudar para outro IDE (por exemplo, eclipse )
Por Makefile e um editor / IDE seu trabalho eleitoral

Pessoalmente, depois de trabalhar por muito tempo com cada uma dessas opções (além do IDE
do Arduino, que descartei mais ou menos diretamente), decidi trabalhar com Makefiles para a
última. Lá você tem controle total sobre tudo: o que é compilado, com qual opção e o que está
vinculado?

Mas todos devem descobrir por si próprios. A lista acima é classificada por dificuldade, o que
significa que os Makefiles são os mais exigentes.

Familiarização com o novo ambiente [ editar ]

Assim que tiver decidido por um IDE, você deve primeiro se familiarizar com ele. Este ponto não
pode ser tratado neste manual, uma vez que dicas possíveis ou semelhantes podem diferir
dependendo do IDE.

É melhor primeiro tentar encontrar as funções que são importantes para você e lidar com o novo
ambiente em geral.

Em qualquer caso, o objetivo é fazer com que o programa acima seja compilado.

Transferir o programa [ editar ]

Até agora tudo bem.

O novo editor / IDE está rodando, o código está compilando.

Mas como você coloca o código no AVR? Existem duas possibilidades, entre outras, que gostaria
de examinar aqui:

com programador / depurador extra

usando o bootloader embutido

O que é isso não é explicado aqui, mas os artigos estão vinculados.

https://www.mikrocontroller.net/articles/Umstieg_von_Arduino_auf_AVR 11/13
10/01/22, 15:05 Mudando de Arduino para AVR - Mikrocontroller.net

Programador / Debugger [ editar ]

Se você já tem um programador ou mesmo um depurador para AVRs, você deve usá-lo, pois ele
libera espaço de memória para o bootloader novamente (isso significa que o programa pode ser
aumentado em ~ 2kB) e não há tempo de espera após cada redefinir.

Se você ainda não tem um programador, não precisa necessariamente comprar um, desde que
possa conviver com as desvantagens que acabamos de mencionar.

Mas se você quiser cavar seu bolso agora, pode considerar a compra de um depurador completo
imediatamente. Tal como acontece com um PC, isso pode ser usado para interromper um
programa em execução, exibir valores de registradores, etc. Isso pode ser muito útil quando
ocorrem fenômenos "inexplicáveis".

Como programar o AVR com o programador depende novamente do IDE. Com o Atmel Studio
você certamente usará a caixa de diálogo de programação, com outros IDEs um programa de
terceiros como o avrdude provavelmente é usado.

Bootloader [ editar ]

A maioria dos Arduinos vem com um bootloader pré-instalado. Freqüentemente, os clones

também são vendidos sem. Com o bootloader, o processador também pode ser atualizado
diretamente via USB sem um programador.

Portanto, avrdude oferece um programa de PC para esse fim . Este é um programa de gravação
mais ou menos "universal" para quase todos os tipos de AVR. Ele também domina a comunicação
com o bootloader Arduino. Você pode então transferir facilmente seu programa com ele. A linha
de comando infelizmente é diferente dependendo do Arduino e da versão do bootloader

# é mega com o Arduino

$ avrdude -cwiring -patmega2560 -P <porta serial> -b115200 -U flash: w:
<arquivo> -D
# outras configurações podem ser (não testadas por mim, prazer em ser
completadas)
$ avrdude -carduino -patmega328p -P <porta serial> -b115200 -U flash: w:
<arquivo> -D
$ avrdude -carduino -patmega328p -P <porta serial> -b57600 -U flash: w:
<arquivo> -D
$ avrdude -cstk500v2 -patmega328p -P <porta serial> -b115200 -U flash: w:
<arquivo> -D

Arduino Library sobressalente [ Editar ]

Agora que o programa mínimo foi testado na placa AVR de cima, ele continua.

Dissemos adeus ao Arduino, mas também a todas as bibliotecas do Arduino! Isso significa que
mesmo coisas tão mundanas como Serial.println () não existem mais. Agora temos que escrevê-
los nós mesmos.

https://www.mikrocontroller.net/articles/Umstieg_von_Arduino_auf_AVR 12/13
10/01/22, 15:05 Mudando de Arduino para AVR - Mikrocontroller.net

Criar suas próprias bibliotecas [ editar ]

Aqui está um exemplo com instruções passo a passo. Eu escolhi o módulo UART para isso.

Comunicação serial usando UART hardware [ editar ]

Esta será a biblioteca Xth UART, mas o módulo UART é ideal para demonstração.

TODO : Links para outros artigos, por exemplo, para UART e biblioteca LCD escritos por mim, ...

Categorias :

C.
Tutorial do Avr-gcc
AVR
Placas AVR
Avr-gcc
local de construção

https://www.mikrocontroller.net/articles/Umstieg_von_Arduino_auf_AVR 13/13