Prefácio
Como você sabe, o ambiente do Arduino (AVR) não contém funções de depuração no circuito, o que cria um grande inconveniente na localização de erros complexos e na manutenção de projetos. Quero mostrar duas maneiras pelas quais você pode depurar seus esboços de diferentes níveis de dificuldade. Para o primeiro método, você só precisa de programas e, para o segundo, um adaptador barato (comparado ao depurador original), que pode ser montado ou comprado pronto.Em geral, nada de novo para quem usa depuradores constantemente, mas pode ser útil para usuários do Arduino (AVR).Construir com Makefile
Antes de chegarmos à descrição da depuração no hardware (na segunda parte), precisamos fazer algum treinamento. Provavelmente muitas pessoas sabem que o ambiente do Arduino chama o compilador avr-gcc com todo o ambiente, configura automaticamente os parâmetros para chamá-lo e inicia o processo de compilação. Portanto, precisamos repetir esse processo explicitamente. Não faremos isso manualmente, embora alguns gestos ainda sejam necessários. Isso é necessário para obter o arquivo do objeto de depuração no formato ELF. O ambiente do Arduino se limpa e não temos acesso às opções do compilador nem aos resultados da compilação.Isso nos leva à questão do uso de utilitários para criar automaticamente um projeto avr-gcc, ou melhor, um esboço com as bibliotecas do Arduino. Aqui seria triste, porque isso não é uma questão simples, mas como eles dizem, tudo já foi feito diante de nós. Acontece que o github já tem tudo o que você precisa para montar esboços com as bibliotecas do Arduino. O projeto é chamado Arduino-Makefile . Como não é difícil adivinhar pela descrição, este projeto contém um Makefile para criar automaticamente projetos no Arduino. Dos recursos listados na descrição, prestaremos atenção apenas em alguns.O pacote Arduino-Makefile é uma coleção de arquivos de configuração, exemplos e descrições. Não há utilitários que devam usar tudo isso. Também não há ambiente de desenvolvimento, ou seja, A montagem é feita através da linha de comando. Isso significa que você pode fixar qualquer IDE que seja conveniente para você, que suporte a montagem através do Makefile. Eu costumo usar o Visual Studio.Se você examinar cuidadosamente o conteúdo, notará que existe um Makefile universal universal (Arduino.mk), incluído em arquivos de montagem local específicos. Você precisa especificar apenas configurações privadas (mínimas) para uma finalidade específica da montagem, e o restante será feito no modo automático (configuração de variáveis, pesquisa de dependências etc.). Isso é muito conveniente, como será mostrado abaixo.É importante observar que os arquivos com várias extensões (* .ino, * .pde, * .c e * .cpp) são suportados. O fato é que um dos depuradores será o AVR Studio 4. Quando você carrega um arquivo de depuração nele, as fontes na árvore do projeto ficam localizadas em diferentes pastas: arquivos-cpp nas fontes e o restante nos cabeçalhos. Se deixarmos a extensão para o esboço (ino), o arquivo não entrará nas fontes e o destaque da sintaxe não atuará nele. É impossível olhar para isso. Portanto, observamos que a extensão dos esboços durante a montagem para depuração no AVR Studio precisa ser alterada para padrão (.c ou .cpp).Toolkit
Descobrimos que podemos coletar esboços. Agora vamos ver como o processo de montagem e depuração será organizado. Prometi mostrar duas maneiras. Cada um deles tem seus prós e contras. Vamos analisá-los brevemente.Método 1 . Crie um arquivo de depuração, faça o upload para o Proteus, depure lá. Vantagens: - relativa facilidade de depuração (com a conexão de um monitor de porta serial, você só precisa se atormentar); - acesso ao mundo exterior através de uma porta serial; - construção de gráficos (instrumentos virtuais de medição estão disponíveis); - a capacidade de simular o circuito em tempo real;
- Em janelas separadas, registradores mk, áreas de memória, variáveis globais e código fonte estão disponíveis, é claro, incluindo sua versão do assembler.Desvantagens:- Proteus pago;- um conjunto limitado de periféricos;- modelos complexos não podem levar em consideração todos os recursos dos componentes originais.Método 2 . Criamos um arquivo de depuração, carregamos no AVR Studio 4, depuramos usando o plug-in Proteus VSM Viewer especial para o AVR Studio 4.
Suas vantagens e desvantagens são quase as mesmas do método 1. Você pode adicionar que o AVR Studio mostra uma árvore detalhada de todos os registros dos mícrons simulados, até os bits, o que é muito conveniente. Das desvantagens, vale a pena notar que o código otimizado para depuração tem suas próprias características e não é tão fácil entender como fazer o depurador parar nos lugares certos.Método 3 . Criamos um arquivo de depuração, carregamos no AVR Studio 4, depuramos usando o emulador de software JTAG ICE mkII e um adaptador especial (HappyJTAG2). Vantagens: - trata-se de uma depuração real em hardware real usando o depurador JTAG ICE mkII (suporte de microfone até ATmega2560); - HappyJTAG 2.45 é executado no Windows 7 x64, você só precisa pular uma janela na qual é solicitado a comprar drivers de qualquer maneira.
Desvantagens:- foi constatada uma operação instável do HappyJTAG2 com pequenos códigos-fonte;- trabalho instável do AVR Studio ao executar operações de depuração;- O autor de HappyJTAG2 há muito tempo abandonou sua ideia (aparentemente com o advento do AVR Studio 5 e Atmel Studio);- alguns recursos da conexão (COM4 ou uma das 4 primeiras portas seriais devem estar livres ou ausentes, porque o AVR Studio itera através do COM1-COM4 em busca de um depurador). É gratuito ou ausente , porque O HappyJTAG2 funciona, por assim dizer, por dentro.Como você pode ver, mostrei três maneiras, mas, atualmente, apenas duas delas praticamente me conquistaram. O primeiro método será descrito neste artigo. Infelizmente, não consegui repetir o segundo método. Você precisa encontrar uma combinação "compatível" de Proteus e AVR Studio. Os mais recentes AVR Studio 4.19.730 e Proteus 7.7 SP2 são usados na imagem. Era uma vez eu usei esse método, mas na presença de um depurador de ferro, usá-lo não faz muito sentido. O terceiro método que eu deixei para a segunda parte. Lá, você precisará de um adaptador e uma descrição de sua conexão com as placas do Arduino que suportam a depuração JTAG.E o que precisamos para toda essa cozinha? Primeiro você precisa esquecer o IDE do Arduino, que só pode ser usado para verificações de controle ao montar esboços. Em seguida, precisaremos de:-Arduino-Makefile - um conjunto de arquivos de configuração para montagem manual de projetos no Arduino;- Um editor com destaque para a sintaxe C ++ e a capacidade de executar comandos externos ( Notepad ++ , VS20xx, Far, ...);- Proteus 7.x - um conhecido simulador de circuitos mistos (analógicos-digitais);- programa terminal ( PuTTY , ZOC Pro), que será um análogo do monitor;- Um programa que cria portas seriais virtuais com modem nulo (VSPD, ...);- Arduino IDE 1.6.x (precisamos de bibliotecas e do compilador avr-gcc);- WinAVR (precisamos de binutils do seu conjunto, este é um conjunto de comandos unix para Windows);- avr gcc 4.9.2(o compilador é mais atualizado se você não quiser usar o que acompanha o IDE do Arduino);- AVR Studio 4.19.730 - a versão mais recente do ambiente de desenvolvimento do Atmel antes de mudar para o Visual Studio (necessário apenas para a segunda parte);- HappyJTAG 2.45 (necessário apenas para a segunda parte).Vamos supor que você saiba como perguntar ao Google onde conseguir toda essa família. Apenas no caso, fornecerei links úteis no final do artigo. Alguns comentários sobre o kit de ferramentas.Como você sabe, Proteus é pago, mas isso não é a coisa mais triste. Infelizmente, suas bibliotecas não estão tão próximas do mundo real quanto gostaríamos. Por exemplo, você não pode modelar a blindagem Ethernet W5100 nela (pelo menos na versão 7.x). Portanto, queridos seguidores do Arduino, sigam o caminho verdadeiro. Somente a depuração e apenas o hardware salvarão suas almas de perguntas incorretas. Usaremos o Proteus como uma ferramenta de treinamento, e em campo - apenas o JTAG.Depurando esboços do Arduino (AVR) no Proteus 7.x
O suficiente para palavras comuns, agora específicas. Existem muitas opções para iniciar o processo de montagem. Você não pode anotá-las, portanto, vou me concentrar em apenas uma e tentar descrevê-la claramente. Vendo o esquema geral, você pode aplicá-lo ao seu conjunto de ferramentas de desenvolvimento. Por conveniência, detalharei a descrição de todo o processo em etapas, algumas podem ser ignoradas. Espero que até os usuários mais inexperientes do Arduino entendam do que se trata.Passo 1 . Baixare instale o ambiente de desenvolvimento do Arduino. Por definição, vamos supor que será da série 1.6.x. Aqui vou fazer alguns comentários imediatamente. Em geral, precisamos apenas de bibliotecas do Arduino. Além de todo o resto, a própria idéia de uma forma simplificada do programa é muito boa (se você comparar C # e C ++ ou, se Deus permitir, C ++ / CLI, então isso é o céu e a terra). A falta de ferramentas de depuração normais levou, francamente, a analfabetos de programação. Em vez de transformar conscientemente o algoritmo concebido em código de programa, os usuários do Arduino são forçados a fazer combinações de feitiços mágicos, filtrar informações através do Serial.print () e apenas alguns tentam ler estaticamente as fontes da biblioteca. É difícil olhar para tudo.Fiquei distraído e você provavelmente conseguiu colocar o ambiente da maneira padrão. É recomendável que a pasta Arduino esteja na raiz da partição (C: \ Arduino). Isso ocorre devido a caminhos de makefile que não gostam de espaços nos arquivos de programas. Mais tarde, configuraremos os caminhos para aqueles que já possuem uma pasta nos “Arquivos de Programas” e terão que fazer uma coisa difícil para os usuários do Windows - um ponto de junção na pasta. Talvez o espaço possa escapar, mas eu não tentei isso.Por definição, digamos que o caminho para o ambiente seja: C: \ Arquivos de Programas \ Arduino.Passo 2 . Baixare descompacte o Arduino-Makefile. Descompacte o conteúdo da pasta Arduino-Makefile-master em C: \ Arduino-Makefile. Quero notar imediatamente que, dentro, existe um arquivo README.md, que é melhor olhar para o github, onde muitas coisas são descritas. Você também deve tomar nota do arquivo arduino-mk-vars.md, que contém uma descrição das variáveis usadas no Makefile do usuário (projeto).Para usar o utilitário make, você precisa do kit gnu bin utils, que fazia parte do WinAVRno devido tempo. Não sei se existe um site oficial para montar esses mesmos utilitários para Windows, mas você pode fazer o seguinte. Você precisará fazer o download do bom e velho WinAVR da versão mais recente e retirar a pasta utils, onde estão os utilitários de comando. Você pode instalar, copiar a pasta e desinstalar o WinAVR (porque inclui o antigo compilador avr-gcc, do qual não precisamos).Em seguida, por exemplo, crie uma pasta c: \ avr-gcc e copie utils para ela. Depois disso, adicione o caminho C: \ avr-gcc \ utils \ bin à variável PATH (por meio das propriedades do computador): O caminho deve ser um dos primeiros na pesquisa. Não se esqueça dessa mudança, pois isso pode afetar outros programas se você usar outros ambientes de desenvolvimento semelhantes . Etapa 3set PATH=C:\avr-gcc\utils\bin;%PATH%
. Você mesmo sabe onde compra / compra o Proteus [7.2 - 7.8]. Por que exatamente essa série e esse intervalo de versões? Porque eu tentei e aparentemente em projetos simples, eles são muito bons. As versões acima de 7.8 não podiam carregar o arquivo de objeto de um dos meus projetos no IAR e, abaixo, não tentei. Os oito são apenas buggy por enquanto, talvez alguém escreva algo sobre ela. Aqui vamos abordar especificamente o Proteus 7.8 SP2.Passo 4 . Usando o artigo , crie um ponto de junção na pasta com o ambiente do Arduino instalado, ou seja, C: \ Arduino deve fazer referência a C: \ Arquivos de Programas \ Arduino. Isso é necessário para não ser mais sábio com o suporte de espaços em makefiles. Assim, sem copiar a pasta com o Arduino, conseguimos uma cópia no local certo. Quem usa o Far pode usar a combinação Alt + F6 na pasta.Alteramos as configurações do ambiente do Arduino. O caminho para a pasta com os esboços: C: \ Arduino-Makefile \ examples. Se você usar um editor externo (Notepd ++, ...), poderá verificar as configurações. Ao mesmo tempo, quando a janela é ativada, o Arduino atualiza o conteúdo de seu editor automaticamente. Selecionamos a placa Arduino Mega 2560 e o processador ATmega2560 (na verdade, não é tão importante o que escolher aqui, o principal é decidir sobre o controlador usado).Escrevemos um programa de exemplo para testar a montagem no ambiente do Arduino, nomeie-o Exemplo1 e salve-o na pasta de esboço: Compile e verifique se a montagem está passando. No Arduino 1.6.7, o vinculador de arquivo de objeto (ld.exe) travou com um erro, substituí-o por outro (por exemplo, desta montagem). Etapa 5void setup()
{
DDRD |= ( 1 << DDD2 );
}
void loop()
{
PIND |= ( 1 << PIND2 );
}
. Copie o arquivo C: \ Arduino-Makefile \ examples \ WebServer \ Makefile para a pasta com nosso esboço: C: \ Arduino-Makefile \ examples \ Example1. Fixamos seu conteúdo da seguinte forma:Makefile# Arduino Make file. Refer to https://github.com/sudar/Arduino-Makefile
# Suppress printing of Arduino-Makefile configuration.
#ARDUINO_QUIET = 1
# Directory where the Arduino IDE and/or core files are stored. Usually can be auto-detected as `AUTO_ARDUINO_DIR`.
ARDUINO_DIR = ../../../Arduino
# Directory where tools such as `avrdude`, `avr-g++`, `avr-gcc`, etc. are stored in the `bin/` subdirectory.
AVR_TOOLS_DIR = ../../../Arduino/hardware/tools/avr
# Directory where the `*.mk` files are stored.
# Usually can be auto-detected as parent of `Arduino.mk`.
ARDMK_DIR = ../../../Arduino-Makefile
# Device type as listed in `boards.txt` or `make show_boards`.
BOARD_TAG = mega
# Microcontroller model.
# Usually can be auto-detected as `build.mcu` from `boards.txt`
MCU = atmega2560
#CPU speed in Hz
#Usually can be auto-detected as `build.f_cpu` from `boards.txt`, except in
#some 1.5+ cores like attiny where there is a clock submenu.
#F_CPU = 16000000L
# What name you would like for generated target files.
# Defaults to the name of your current working directory, but with underscores (_) instead of spaces.
#TARGET = project
# Baudrate of the serial monitor.
# Defaults to `9600` if it can't find it in the sketch `Serial.begin()`
MONITOR_BAUDRATE = 9600
DEBUG = 1
DEBUG_FLAGS = -O1 -gdwarf-2 -gstrict-dwarf
include ../../Arduino.mk
Nós inserimos no início de nossa fonte uma linha que conecta explicitamente o Arduino.h (isso não é necessário se houver dependências de biblioteca indicadas na variável ARDUINO_LIBS): Não esqueça de salvar a fonte e o Makefile. Em seguida, estando na pasta Example1, inserimos o comando make (usando o console ou Far, ou de outra maneira conveniente), um calçado grande deve aparecer, semelhante ao exibido no IDE do Arduino quando você ativa a saída de informações completas sobre o processo de compilação. Isto é, se tudo foi feito corretamente, se algo não funcionou, primeiro tente entender independentemente o que está errado e, em seguida, escreva comentários no artigo.#include "Arduino.h"
void setup()
{
DDRD |= ( 1 << DDD2 );
}
void loop()
{
PIND |= ( 1 << PIND2 );
}
Como comentamos a linha ARDUINO_QUIET = 1 no Makefile, antes das informações sobre a montagem existe um cabeçalho com os valores das variáveis do próprio Makefile. Alguns deles são especificados, enquanto outros são calculados à medida que progridem. Isso ajuda a encontrar erros ao editar o Makefile do projeto.O início do calçado-------------------------
Arduino.mk Configuration:
- [AUTODETECTED] CURRENT_OS = WINDOWS
- [USER] ARDUINO_DIR = ../../../Arduino
Usage: egrep [OPTION]... PATTERN [FILE]...
Try `egrep --help' for more information.
- [USER] ARDMK_DIR = ../../../Arduino-Makefile
- [AUTODETECTED] ARDUINO_VERSION = 167
- [DEFAULT] ARCHITECTURE = avr
- [DEFAULT] ARDMK_VENDOR = arduino
- [DEFAULT] ARDUINO_SKETCHBOOK =
- [USER] AVR_TOOLS_DIR = ../../../Arduino/hardware/tools/avr
- [COMPUTED] ARDUINO_LIB_PATH = ../../../Arduino/libraries (from ARDUINO_DIR)
- [COMPUTED] ARDUINO_PLATFORM_LIB_PATH = ../../../Arduino/hardware/arduino/avr/libraries (from ARDUINO_DIR)
- [COMPUTED] ARDUINO_VAR_PATH = ../../../Arduino/hardware/arduino/avr/variants (from ARDUINO_DIR)
- [COMPUTED] BOARDS_TXT = ../../../Arduino/hardware/arduino/avr/boards.txt (from ARDUINO_DIR)
- [DEFAULT] USER_LIB_PATH = /libraries (in user sketchbook)
- [DEFAULT] PRE_BUILD_HOOK = pre-build-hook.sh
- [USER] BOARD_TAG = mega
- [COMPUTED] CORE = arduino (from build.core)
- [COMPUTED] VARIANT = mega (from build.variant)
- [COMPUTED] OBJDIR = build-mega (from BOARD_TAG)
- [COMPUTED] ARDUINO_CORE_PATH = ../../../Arduino/hardware/arduino/avr/cores/arduino (from ARDUINO_DIR, BOARD_TAG and boards.txt)
- [USER] MONITOR_BAUDRATE = 9600
- [DEFAULT] OPTIMIZATION_LEVEL = s
- [DEFAULT] MCU_FLAG_NAME = mmcu
- [DEFAULT] CFLAGS_STD =
- [DEFAULT] CXXFLAGS_STD =
- [AUTODETECTED] DEVICE_PATH =
- [DEFAULT] FORCE_MONITOR_PORT =
- [AUTODETECTED] Size utility: AVR-aware for enhanced output
- [COMPUTED] BOOTLOADER_PARENT = ../../../Arduino/hardware/arduino/avr/bootloaders (from ARDUINO_DIR)
- [COMPUTED] ARDMK_VERSION = 1.5
- [COMPUTED] CC_VERSION = 4.8.1 (avr-gcc)
-------------------------
mkdir -p build-mega
Assumimos que tudo correu bem, então você deve ter um mega pai de construção, no qual o nosso tão esperado Example1.elf é o próprio arquivo para o qual toda a ação foi iniciada. Com este arquivo, faremos uma lavagem cerebral no microfone virtual do Proteus e curaremos ... com outro grau de liberdade.Passo 6 . Voltar para Proteus. Crie um novo projeto (arquivo dsn) na pasta de origem . Retiramos o componente - o microcontrolador ATmega2560 das entranhas da biblioteca e o inserimos onde se encaixa, é realmente doloroso. Preencha as propriedades do componente na imagem. A instalação do COMPIM ainda não é necessária, será necessário trabalhar com o monitor. Então entramos no modo de depuração Debug \ Start / Restart Debugging. Tire uma foto assim.
Bem, e então, tudo depende do vôo da sua imaginação. Não apenas o Example1.ino, mas também outras fontes dependentes estarão disponíveis na janela de origem. Você pode abrir o código do assembler, os registros do processador, a memória e algo mais. Leia a doca no Proteus.Passo 7 . Você precisa configurar um monitor. Para escrever preguiça, espero fazer você mesmo. O significado, em suma, é este. Você cria duas portas seriais virtuais conectadas por um modem nulo (de preferência com números maiores que COM4). Você prescreve um no componente COMPIM Proteus e o segundo no programa do terminal (PuTTY). Não se esqueça de corrigir a velocidade e a codificação da saída no programa do terminal; em teoria, ela deve coincidir com a codificação dos arquivos de origem, se você quiser fazer uma saída para o monitor em russo.Passo 8 . Se você quiser usaravr gcc 4.9.2 , você precisa colocar o conteúdo do arquivo morto na raiz do disco e corrigir o caminho na variável AVR_TOOLS_DIR. Só lá, avr-size não funcionou para mim, ao que parece. Você pode alterá-lo para o que acompanha o WinAVR (ou Arduino).By the way, que o tamanho da saída na necessidade forma normal para adicionar a opção de chamada AVR-size (arquivo Arduino.mk): Links úteis : 1. o Arduino o 1.6.x IDE . 2. Arduino-Makefile . 3. WinAVR . 4. avr o gcc 4.9.2 . 5. Links físicos, etc. no Windows . 6. PuTTY . 7. Notepad ++ .avr_size = $(SIZE) $(SIZEFLAGS) --format=avr $(1)