Ambiente de depuração integrado AVR Studio da Atmel. Do Arduino e fiação ao AVR Studio e descrição pura do SI Avr Studio em russo
Olá.
Este artigo irá agradar àqueles que acreditam que “cresceram” com o Arduino e estão prontos para entrar no mundo da programação “séria” de microcontroladores. Além de “aprimorar suas habilidades de programador”, você terá a oportunidade de escolher qualquer microcontrolador para seus projetos e, claro, apreciará a velocidade dos programas e o tamanho da memória que ocupam.
Tudo será descrito (para ), do início ao fim, - instalação e preparação do necessário programas, montagem do programador Gromov mais simples (não se assuste, existem apenas três diodos e sete resistores), Firmware MK e gravação de código em Estúdio AVR. Todo o processo será acompanhado de ilustrações e exemplos.
Deixe-me fazer uma reserva imediatamente: o computador deve estar equipado com uma porta COM ( Adaptador USB para COM não funciona bem). Se o seu computador não tiver esse conector na parte traseira, provavelmente ele está ligado placa-mãe(em forma de alfinetes), então tudo se resolve com essa “emissão”
Infelizmente, para proprietários de laptops sem COM, o artigo é de interesse apenas acadêmico.
Então vamos começar...
O que você vai precisar?
"Macio"
UniProf - programa universal para atualizar vários microcontroladores ATmega, simples e conveniente e, o mais importante, funciona perfeitamente com nosso programador. O autor é o desenvolvedor russo Mikhail Nikolaev.
Claro, você pode atualizar o MK do AVR Studio, mas para isso você precisa de um programador especial. Portanto, escreveremos o código no estúdio e atualizaremos os arquivos hexadecimais resultantes com UniProf usando nosso programador caseiro. Além disso, será descrito o método de atualização do firmware a partir da linha de comando.
Os usuários do Linux terão que usar uma máquina virtual ou Wine. Não funcionou para mim com o Wine, não consigo ver a porta e não tentei com uma máquina virtual.
Funciona perfeitamente no Wine (Debian 8.5, vinho 1.6).
Todos os softwares são gratuitos.
"Ferro"
Faremos experimentos em Arduino pro mini com chip ATmega328. Frequência de quartzo (8/16 MHz), bem como tensão (3,3/5v), não importa. (Veja abaixo)
No futuro você irá programar vários microcontroladores Atmel, mas pela primeira vez esta placa está perfeita. É bom porque é praticamente um controlador simples com fiação mínima e pinos soldados. Exatamente o que você precisa.
Sobre marcações em microcontroladores
Após o nome vêm os números, que geralmente indicam a quantidade de memória.
A letra após os números indica os parâmetros da tensão de alimentação.
Nenhuma carta- a tensão de alimentação do controlador está na faixa de 4,5-5,5 volts.
eu- versões de controladores operando com redução (Baixo) tensão de alimentação (2,7 - 5,5 volts).
V- versões de controladores operando em baixa tensão de alimentação (1,8-5,5 volts).
Você- versões de controladores operando com tensão de alimentação ultrabaixa (0,7-5,5 volts).
P- versões de baixo consumo (até 100 nA no modo desligado).
UM- consumo de corrente reduzido, cobrindo toda a faixa de frequência do clock de todas as versões, tensão de alimentação 1,8-5,5 volts (em alguns modelos, novos recursos e novos registros foram adicionados. Ao mesmo tempo, total compatibilidade com versões anteriores)
.
Microcontroladores « UM" e "não- UM"geralmente possuem a mesma assinatura, o que causa algumas dificuldades, já que os Fuse-bits são diferentes.
Exemplos:
ATmega8- a capacidade da memória do programa é de 8 kilobytes, a tensão de alimentação é de 4,5-5,5 volts.
ATmega8L- a capacidade da memória do programa é de 8 kilobytes, a tensão de alimentação é de 2,7-5,5 volts.
ATtiny43U- capacidade de memória 4 kilobytes, modificação - 3, tensão de alimentação - 0,7-5,5 volts.
ATtiny44A- capacidade de memória 4 kilobytes, modificação - 4, consumo de corrente reduzido, tensão de alimentação 1,8-5,5 volts.
Acontece que um controlador sem carta pode ter subtensão fonte de alimentação (1,7 ou 1,8 volts). Isso precisa ser esclarecido na ficha técnica.
ATtiny841- capacidade de memória 8 kilobytes, modificação - 41, tensão de alimentação - 1,7-5,5 volts.
Após o hífen, é indicada a versão do microcontrolador, composta por números que indicam a frequência máxima do controlador (na tensão de alimentação apropriada), e de letras que indicam a opção de alojamento, faixa de temperatura operacional e características de fabricação.
Uma ou duas letras após a frequência indicam o tipo de habitação:
UniProf
Escrever um programa é metade da batalha; você ainda precisa inseri-lo de alguma forma no controlador. Então vamos prestar mais atenção nisso.Seria bom se o seu Arduino fosse carregado com o Blink padrão (que vem de fábrica).
Vamos lançar UniProf... Talvez a seguinte janela apareça:
Isso está conectado à porta LPT, então basta clicar OK.
A janela do programa será então aberta:
Se a porta não for selecionada corretamente, aparecerá uma janela perguntando...
Clique em OK e selecione a porta desejada.
Caso o MK não seja detectado automaticamente, aparecerá uma janela com seleção manual:
Infelizmente não está na lista atmega328, então escolhemos mega32 (eles têm a mesma quantidade de memória flash) e pressione OK.
Depois disso, em vez da palavra desconhecido, aparecerá o controlador conectado...
32Ké a quantidade de memória Flash e 1024 - Volume EEPROM.
Agora, se tudo estiver como na imagem, abra a ajuda e leia atentamente o que está escrito lá. O autor foi muito conciso, então não levará muito tempo. Não pressione nenhum botão ainda.
Você já conheceu? Ótimo, agora podemos seguir em frente. Desmarque a caixa ao lado de EEPROM e você verá a interface alterada:
Após desmarcar a caixa de seleção EEPROM, a leitura e gravação nesta área da memória não são realizadas.
Como iremos operar com arquivos hexadecimais, removeremos as “marcas de seleção” Em geral E LIXO e também marque a caixa Freio!, isso aumentará o tempo de leitura/gravação, mas aumentará a estabilidade.
O processo não é rápido então você terá que esperar. Quadrados azuis irão rastejar abaixo e os números serão contados no canto inferior direito. A primeira passagem lerá a área PROGRAMA e a segunda lerá a EEPROM.
Eu tenho um novo Arduino com um Blink padrão integrado (quando o programador estiver conectado, o diodo irá parar de piscar). Se você tiver a mesma coisa, a seguinte imagem aparecerá:
À direita vemos que não há nada na EEPROM, e à esquerda, em PROGRAM, há um programa gravado (como eu disse, este é o Blink). Agora use a seta para baixo para rolar o controle deslizante até que os dados acabem...
...agora vá até o final. Você verá mais dados - este é o bootloader do Arduino.
Agora proponho fazer uma pausa no meu artigo e ler sobre a estrutura do MK, isso aumentará muito a sua compreensão do material. Tudo está escrito muito bem e claramente. Bem, depois de ler, volte e vamos continuar...
Desmarque o EEPROM. Na verdade não precisamos disso, mas ficará claro que existe um “tique” Freio!
Agora vamos salvar tudo que está firmware no controlador, para que após os experimentos possamos devolvê-lo estado inicial.
Pressione o botão e salve o firmware, chamando-o de algo como - origProMini328.hex. É isso, agora você tem um backup.
... e clique no já familiar botão Ler. Depois disso, você verá que todas as células do PROGRAM estão vazias. Não apenas o programa foi removido, mas também o bootloader do Arduino.
Ou seja, agora você não poderá fazer upload de esboços pelo método tradicional. Então, se quiser, com um leve aceno de mão, restaure tudo do backup.
Agora vamos piscar o controlador com o mesmo “Blink”, só que escrito no AVR Studio.
Esta é a aparência do código:
#define F_CPU 16000000UL #include
Se você usar um Arduino com quartzo de 8 MHz, não há nada de errado com isso, o diodo piscará com metade da frequência.
Veja quanto espaço ele ocupa:
AVRDude
Uniprof, como muitos outros programas similares, é apenas um complemento gráfico do programa AVRDude (AVR Downloader-Uploader), que então executa todas as ações descritas acima no microcontrolador.
Porque AVRDude não possui interface gráfica própria; você precisa trabalhar com ele na linha de comando. Isso pode parecer inconveniente para alguns, mas é exatamente o oposto: trabalhar no console é simplesmente ótimo. Prático, simples e não vinculado a nenhum sistema operacional, porque o avrdude provavelmente existe para tudo. Agora você verá isso.
Para usuários
Avrude está incluído no conjunto de ferramentas AVR, então instale-o (depois de instalar o AVR Studio) conforme escrito no início do artigo.
Cd\
... vá para a raiz do disco COM.
Digitando o comando:
Se for esse o caso, então avrdude pronto para ir e continuar.
Agora precisamos adicionar nosso programador ao arquivo de configuração avrdude (C:\Arquivos de Programas (x86)\Atmel\AVR Tools\AVR Toolchain\bin\ avrdude.conf) . Abra-o no programa Bloco de notas++ e após a inscrição “DEFINIÇÕES DO PROGRAMADOR” adicione estas linhas:
ID do programador = "gromov"; desc = "batendo na porta serial, reset=dtr sck=rts mosi=txd miso=cts"; tipo = serbb; redefinir = 4; scck = 7; mosi = 3; missô = 8; ;
Batendo um pouco.
Salve e feche o arquivo; ele não é mais necessário.
Volte ao terminal e dê o comando para verificar a comunicação entre o MK e o programador:
Avrdude -n -c gromov -P com1 -p m328p
Você pode ter uma porta de comunicação diferente.
Instalar avrdude
Sudo apt instalar avrdude
Digitando o comando:
Você deverá ver informações de ajuda.
Se for esse o caso, então avrdude pronto para ir.
Configure a porta:
Sudo stty 9600 ignbrk -brkint -icrnl -imaxbel -opost -isig -icanon -iexten -echo noflshIsso deve ser feito após cada reinicialização do computador ou adicioná-lo ao rc.local.
Onde /dev/ttyS0 está com1, /dev/ttyS1 - com2 etc.
No futuro, em equipes escreverei /dev/ttyS0, você pode ter /dev/ttyS1 etc.
Adicione o programador ao arquivo de configuração /etc/avrdude.conf
Sudo nano /etc/avrdude.conf
Após “DEFINIÇÕES DO PROGRAMADOR” adicione as seguintes linhas:
ID do programador = "gromov"; desc = "batendo na porta serial, reset=dtr sck=rts mosi=txd miso=cts"; type = "serbb"; redefinir = 4; scck = 7; mosi = 3; missô = 8; ;
O programador usa tecnologia Bit-banging.
Certifique-se de que, ao copiar, as aspas permaneçam apenas aspas, caso contrário elas podem mudar (devido à diferença nas codificações) e o avrdude xingará.
Salve e feche o arquivo.
Dê o comando para verificar a conexão entre o MK e o programador:
Sudo avrdude -n -c gromov -P /dev/ttyS0 -p m328p
Se houver uma conexão, a resposta será assim:
É aqui que terminam as diferenças entre os sistemas operacionais e os comandos são duplicados.
Adicione um argumento ao comando -v ou -v -v (pode ser adicionado a qualquer comando) para exibir informações completas:
Avrdude -n -v -c gromov -P com1 -p m328p ###WIN###
sudo avrdude -n -v -c gromov -P /dev/ttyS0 -p m328p ###Linux###
A conclusão de Avrdude é que tanto no Windows quanto no Linux são iguais, então de agora em diante farei capturas de tela apenas no Win.
Há mais informações aqui, por exemplo, você pode ver quais fusíveis estão instalados. Aqui eles são exibidos em hexadecimal (HEX) números. Por exemplo, hfuse 0xDA, em binário fica assim - . Ou seja, esses são os mesmos bits marcados nas interfaces gráficas.
Ao lidar com fusíveis, lembre-se que nos microcontroladores ATmega os fusíveis estão invertidos. Aquilo é 0 - Esse sobre Yucheno, e 1 - desligado Yucheno. Isto causa confusão nas calculadoras online (veja abaixo).
Vamos ler o firmware da área clarão (igual a PROGRAMA no uniprof) comando:
Avrdude -c gromov -P com1 -p m328p -U flash:r:readfl.txt:h ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U flash:r:readfl.txt:h ###Linux###
No uniprof o código foi mostrado no programa, mas aqui ele será gravado em um arquivo.
Firmware lido e gravado em arquivo readfl.txt. Carta h (hexágono) ao final indica que os dados devem ser escritos em formato hexadecimal. Se você escrever uma carta b (binário), será escrito no sistema binário, e se R (cru), então os dados estarão na forma “bruta” (kryakozyabra).
A partir daqui, assume-se que os usuários vencedores estão localizados na raiz do disco COM (C:\), e os usuários do Linux trabalham em sua pasta pessoal, então os arquivos serão salvos lá (a menos que especificado de outra forma). O firmware que será carregado no MK deverá estar localizado lá.
Para win, o arquivo estará localizado aqui C:\readfl.txt, e para linux, em /home/user/readfl.txt. Você pode abrir este arquivo e dar uma olhada.
Lendo EEPROM:
Avrdude -c gromov -P com1 -p m328p -U eeprom:r:reader.txt:h ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U eeprom:r:reader.txt:h ###Linux###
Lendo flash e eeprom juntos:
Avrdude -c gromov -P com1 -p m328p -U flash:r:readfl.txt:h -U eeprom:r:reader.txt:h ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U flash:r:readfl.txt:h -U eeprom:r:reader.txt:h ###Linux###
Apagando o controlador:
Avrdude -e -c gromov -P com1 -p m328p ###WIN###
sudo avrdude -e -c gromov -P /dev/ttyS0 -p m328p ###Linux###
Desconecte o pino “reset” - o diodo não piscará, o programa será apagado.
Vamos atualizar o MK com o arquivo baixado anteriormente 328teste.hex. Encontra-se na raiz do disco C(c:\328test.hex) no Windows ou na pasta inicial (/home/user/328test.hex) no Linux.
Avrdude -c gromov -P com1 -p m328p -U flash:w:328test.hex ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U flash:w:328test.hex ###Linux###
Agora se você desligar o “reset”, o controlador ganhará vida.
Observe. Ao atualizar MK via avrdude, não é necessário apagar o controlador, o programa faz isso sozinho. No entanto, se você especificar o parâmetro -D, então o MK não será limpo automaticamente.
Firmware EEPROM:
Avrdude -c gromov -P com1 -p m328p -U eeprom:w:eeprom.hex ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U eeprom:w:eeprom.hex ###Linux###
Lendo todos os fusíveis:
Avrdude -c gromov -P com1 -p m328p -U hfuse:r:hfuse.txt:h -U lfuse:r:lfuse.txt:h -U lock:r:lock.txt:h -U efuse:r:efuse .txt:h ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U hfuse:r:hfuse.txt:h -U lfuse:r:lfuse.txt:h -U lock:r:lock.txt:h -U efuse :r:efuse.txt:h ###Linux###
Alguns controladores podem não ter nenhum fusível.
Somente leitura Fusível baixo:
Avrdude -c gromov -P com1 -p m328p -U lfuse:r:lfuse.txt:h ###WIN###
sudo avrdude -c gromov -P com1 -p m328p -U lfuse:r:lfuse.txt:h ###Linux###
O fusível baixo é responsável por selecionar a fonte do sinal do clock (interno, externo), sua frequência e a pausa antes da partida do controlador após a alimentação ser aplicada a ele. Agora você tem o valor escrito lá - 0xff, que corresponde ao quartzo externo de 8 MHz e superior.
Agora vamos piscar outro lfuse, que irá transferir seu ATmeg para funcionar a partir de um gerador interno de 8 MHz.
Avrdude -c gromov -P com1 -p m328p -U lfuse:w:0xe2:m ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U lfuse:w:0xe2:m ###Linux###
Se você tiver um Arduino de 16 MHz, o diodo piscará duas vezes mais devagar.
Futuramente, ao codificar no AVR Studio, você poderá especificar uma frequência de 8 MHz e dessoldar o quartzo, obtendo assim mais dois pinos digitais livres à sua disposição.
Mas isso é mais tarde, e agora vamos devolver tudo como estava acendendo o fusível anterior:
Avrdude -c gromov -P com1 -p m328p -U lfuse:w:0xff:m ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U lfuse:w:0xff:m ###Linux###
O diodo piscará corretamente.
Os fusíveis podem piscar individualmente ou em conjunto:
Avrdude -c gromov -P com1 -p m328p -U hfuse:w:0xda:m -U lfuse:w:0xff:m -U efuse:w:0x05:m ###WIN###
sudo avrdude -c gromov -P /dev/ttyS0 -p m328p -U hfuse:w:0xda:m -U lfuse:w:0xff:m -U efuse:w:0x05:m ###Linux###
Esses comandos não precisam ser dados. Eu os apresento para maior clareza.
No futuro, quando precisar usar outros controladores, você marcará as caixas na calculadora online e obterá os valores (o link está no canto superior esquerdo) em formato hexadecimal e atualize-o.
Agora só falta descobrir os parâmetros avrdude e você pode passar para a parte final.
-c gromov- tipo de programador, ou melhor, o nome sob o qual está escrito na configuração (avrdude.conf).
-P com1- Bem, está tudo claro aqui.
-pm328p- designação tipo MK.
-Você- após esta opção a área de memória é indicada (flash, eeprom, xfuse), no qual quaisquer ações serão executadas (r - ler, w - escrever).
Os dois pontos servem como separadores.
Aqui, com os nomes dos microcontroladores e seus aliases, programadores e outras opções.
Apelidos MK
uc3a0512-AT32UC3A0512
c128-AT90CAN128
c32-AT90CAN32
c64-AT90CAN64
pwm2-AT90PWM2
pwm2b-AT90PWM2B
pwm3-AT90PWM3
pwm316-AT90PWM316
pwm3b-AT90PWM3B
1200
-AT90S1200 (****)
2313
-AT90S2313
2333
-AT90S2333
2343
-AT90S2343 (*)
4414
-AT90S4414
4433
-AT90S4433
4434
-AT90S4434
8515
-AT90S8515
8535
-AT90S8535
usb1286-AT90USB1286
usb1287-AT90USB1287
usb162-AT90USB162
usb646-AT90USB646
usb647-AT90USB647
usb82-AT90USB82
m103-ATmega103
m128- ATmega128
m1280-ATmega1280
m1281-ATmega1281
m1284p-ATmega1284P
m1284rfr2-ATmega1284RFR2
m128rfa1-ATmega128RFA1
m128rfr2-ATmega128RFR2
m16- ATmega16
m161-ATmega161
m162- ATmega162
m163-ATmega163
m164p-ATmega164P
m168- ATmega168
m168p-ATmega168P
m169- ATmega169
m16u2-ATmega16U2
m2560-ATmega2560 (**)
m2561-ATmega2561 (**)
m2564rfr2-ATmega2564RFR2
m256rfr2-ATmega256RFR2
m32- ATmega32
m324p-ATmega324P
m324pa-ATmega324PA
m325- ATmega325
m3250-ATmega3250
m328-ATmega328
m328p-ATmega328P
m329-ATmega329
m3290-ATmega3290
m3290p-ATmega3290P
m329p-ATmega329P
m32u2-ATmega32U2
m32u4-ATmega32U4
m406- ATMEGA406
m48- ATmega48
m48p-ATmega48P
m64- ATmega64
m640-ATmega640
m644-ATmega644
m644p-ATmega644P
m644rfr2-ATmega644RFR2
m645- ATmega645
m6450-ATmega6450
m649-ATmega649
m6490-ATmega6490
m64rfr2-ATmega64RFR2
m8- ATmega8
m8515-ATmega8515
m8535-ATmega8535
m88-ATmega88
m88p-ATmega88P
m8u2-ATmega8U2
t10-ATtiny10
t11-ATtiny11
t12- ATtiny12
t13- ATtiny13
t15-ATtiny15
t1634-ATtiny1634
t20-ATtiny20
t2313- ATtiny2313
t24- ATtiny24
t25- ATtiny25
t26-ATtiny26
t261-ATtiny261
t4- ATtiny4
t40-ATtiny40
t4313-ATtiny4313
t43u- ATtiny43u
t44-ATtiny44
t45-ATtiny45
t461-ATtiny461
t5-ATtiny5
t84- ATtiny84
t85- ATtiny85
t861-ATtiny861
t88- ATtiny88
t9-ATtiny9
x128a1-ATxmega128A1
x128a1d-ATxmega128A1revD
x128a1u-ATxmega128A1U
x128a3-ATxmega128A3
x128a3u-ATxmega128A3U
x128a4-ATxmega128A4
x128a4u-ATxmega128A4U
x128b1-ATxmega128B1
x128b3-ATxmega128B3
x128c3-ATxmega128C3
x128d3-ATxmega128D3
x128d4-ATxmega128D4
x16a4-ATxmega16A4
x16a4u-ATxmega16A4U
x16c4- ATxmega16C4
x16d4-ATxmega16D4
x16e5-ATxmega16E5
x192a1-ATxmega192A1
x192a3-ATxmega192A3
x192a3u-ATxmega192A3U
x192c3-ATxmega192C3
x192d3-ATxmega192D3
x256a1-ATxmega256A1
x256a3-ATxmega256A3
x256a3b-ATxmega256A3B
x256a3bu-ATxmega256A3BU
x256a3u-ATxmega256A3U
x256c3-ATxmega256C3
x256d3-ATxmega256D3
x32a4-ATxmega32A4
x32a4u-ATxmega32A4U
x32c4-ATxmega32C4
x32d4-ATxmega32D4
x32e5-ATxmega32E5
x384c3-ATxmega384C3
x384d3-ATxmega384D3
x64a1-ATxmega64A1
x64a1u-ATxmega64A1U
x64a3-ATxmega64A3
x64a3u-ATxmega64A3U
x64a4-ATxmega64A4
x64a4u-ATxmega64A4U
x64b1-ATxmega64B1
x64b3-ATxmega64B3
x64c3-ATxmega64C3
x64d3-ATxmega64D3
x64d4-ATxmega64D4
x8e5-ATxmega8E5
Usuários Linux podem usar vinho.
Espero que você já tenha tudo instalado, então vamos lançar o AVR Studio...
Aqui somos solicitados a criar um novo projeto ou abrir um antigo. Clique Novo Projeto…
Escolher AVR GCC, já que escreveremos em SI, e não em assembler.
Damos um nome ao projeto e marcamos as caixas.
Escolher Localização (Eu criei a pasta AVR na unidade C:\) Pastas com projetos serão criadas automaticamente lá.
Clique Próximo…
Escolher Simulador AVR, já que não temos um programador especial que permita a depuração, e nosso microcontrolador é ATmega328p.
Clique Terminar.
Após essas manipulações, o estúdio está pronto para funcionar.
À esquerda estão os caminhos para o projeto. No centro está um editor de texto no qual o código é escrito. À direita estão os registros do controlador. No canto inferior esquerdo estão as informações de depuração.
Dos botões que estamos atualmente interessados nestes -
Construa o projeto.
Crie o projeto e comece a depurar.
Compilando o arquivo.
Limpeza.
Configuração do projeto. Então clique nele...
Aqui você pode alterar o tipo de MK, definir a frequência do clock (vamos escrever diretamente no código), nível de otimização, bem como determinar quais arquivos serão criados.
Clique nos ícones à esquerda de interesse e clique Cancelar.
Não explicarei essas e outras opções, mas posteriormente fornecerei um link com uma descrição competente.
Agora copie o código escrito no início do artigo e cole no editor:
Especificamos a frequência do clock no código porque a biblioteca exige isso atraso.h.
A compilação foi bem-sucedida, não houve erros ou avisos.
Agora vamos seguir nosso caminho C:\AVR\my328\default\, encontramos lá o arquivo hexadecimal que criamos - meu328.hex e atualize-o no controlador. O que piscar (avrdude ou uniprof) escolha você mesmo.
No avrdude ficará assim:
Avrdude -c gromov -P com1 -p m328p -U flash:w:\AVR\my328\default\my328.hex ###WIN###
avrdude -c gromov -P /dev/ttyS0 -p m328p -U flash:w:my328.hex ###Linux###
Desative o “reset” e veja o diodo piscar uma vez por segundo. Espero ter convencido você da simplicidade e conveniência da linha de comando.
Para transformar o Arduino novamente em um Arduino, você tem um backup.
Como já escrito acima, não entrarei em explicações sobre como trabalhar com o AVR Studio, nem darei aulas sobre a linguagem SI. Em primeiro lugar, este não era o meu plano. (Eu só queria ajudar na transição do Arduino para o AVR Studio)
Atmel Studio é uma plataforma de desenvolvimento integrada que oferece a capacidade de projetar e depurar aplicativos desenvolvidos para microcontroladores Atmel baseados na arquitetura de processador da série ARM Cortex-M. Atmel Studio é um ambiente integrado e fácil de usar que oferece a capacidade de depurar e construir aplicativos criados em C/C++ ou linguagem assembly. Possui uma volumosa biblioteca integrada de código-fonte Atmel Software Framework totalmente gratuito, que inclui mais de 1.600 projetos para arquiteturas ARM e AVR. Ter essa biblioteca é um grande bônus para qualquer programador. Este IDE pode ser usado para programar uma ampla variedade de microcontroladores baseados em AVR, bem como microcontroladores flash baseados em Atmel SAM3 que usam núcleos Cortex-M3, Cortex-M4.
Atmel Studio também inclui ferramentas que facilitarão muito a vida de qualquer programador. A plataforma inclui soluções como Atmel Spaces e Atmel Gallery. Atmel Gallery é uma loja online de ferramentas de desenvolvimento e software integrado. Atmel Spaces é um espaço baseado em nuvem para desenvolvimento colaborativo e armazenamento de arquivos de projetos de hardware e software para microcontroladores Atmel.
Principais recursos e funções
- é um ambiente de desenvolvimento integrado totalmente gratuito;
- suporta linguagens C/C++ e Assembler;
- acompanhado de documentação detalhada;
- inclui uma extensa biblioteca com exemplos de código-fonte para diversas aplicações;
- projetado para programar microcontroladores Atmel.
Requisitos Especiais
- frequência de clock do processador de 1,6 GHz e superior;
- para sistemas de 32 bits a partir de 1 GB de RAM;
- para sistemas de 64 bits a partir de 2 GB de RAM;
- ao executar em uma máquina virtual, recomenda-se 512 MB adicionais de RAM;
- 6 GB de espaço livre no disco rígido.
O que há de novo nesta versão?
7.0.790 (25.02.2016)
- adicionado suporte para depurador estendido (EDBG);
- adicionado suporte para perfis de configurações de interface. Você pode alternar entre perfis usando as teclas do painel de configurações;
- adicionou a capacidade de importar bibliotecas para projetos importados anteriormente. Adicionado suporte para Arduino Zero e Zero Pro;
- a construção paralela agora está habilitada por padrão;
- firmware atualizado para Xplained Mini;
- A função "Mostrar todos os arquivos" no Solution Explorer foi corrigida.
Um IDE é um ambiente de desenvolvimento integrado que inclui vários modelos, bibliotecas e funções de depurador. Falando nisso, desde 2004 um poderoso pacote de software, AVR Studio, foi desenvolvido para eles.
Primeiras versões
As primeiras versões do estúdio incluíam um assembler para , você pode extraí-lo das primeiras montagens, mas depois esse projeto foi abandonado e o C AVR foi escolhido como linguagem principal. O compilador era um produto IAR pago e muito sério. Você pode baixar o WINAVR gratuitamente; para isso, após instalar o estúdio você precisa instalá-lo.
Prestar atenção! É melhor fazer isso somente após instalar o AVR Studio 4 e outras versões.
O AVR Studio 4 (foto acima) foi apresentado por muito tempo. Muitos desenvolvedores de microcontroladores encontraram esse problema. Posteriormente, o IDE foi atualizado para AVR Studio 5. Além da interface, não houve alterações especiais, e só então a empresa desenvolvedora renomeou o produto e mudou o nome para Atmel Studio 6.
O ambiente AVR Studio 5 suportava os seguintes microcontroladores:
- AVR32;
- XMEGA.
O Atmel Studio 6 diferia significativamente do AVR Studio 5; as inovações mais notáveis na versão foram:
- O Microsoft Visual Studio 2010 começou a trabalhar com a família AVR.
- Destaque de sintaxe aprimorado em comparação com AVR Studio 5.
- Adicionadas dicas e preenchimento automático de um conjunto de comandos, o que acelera o processo de desenvolvimento.
- De modo geral, todo o funcionamento do ambiente tornou-se mais confiável.
- Adicionado suporte para ARM Cortex-M.
- O WinAVR não precisa mais ser instalado separadamente. O GCC agora é instalado durante o processo de instalação, ao contrário das versões mais recentes;
No Atmel Studio 6 houve um salto para melhor para o usuário do programa, o que afetou a popularidade das famílias Atmel. No entanto, não foi possível obter suporte adequado para caracteres russos em caminhos de arquivos.
Versão atual – Atmel estúdio 7
O ambiente de desenvolvimento que utilizei foi o Visual Studio Isolated Shell 2015; por um lado, esta solução não é suportada no Windows XP, por outro lado, estas medidas foram tomadas para melhorar tanto a aparência do programa como a sua funcionalidade.
Talvez o mais significativo seja a adição do suporte Arduino no Atmel Studio 7. Isso significa que você pode ir de um conjunto de esboços simples até usar todas as funções C, depuração, simulador MCU e outras funções. A combinação do Arduino e do Atmel Studio 7 deu uma nova rodada no desenvolvimento desta plataforma de aprendizagem simples.
Estudar o estúdio Atmel com Arduino proporcionará uma oportunidade de avançar para um domínio completo e produtivo e um conhecimento mais profundo do coração do Arduino - o microcontrolador Atmega.
Além disso, no site da Atmel você pode baixar um pacote para operar e conectar o LCD. Como exemplo de masterização, você pode usar o LCD 1602; há muitas lições sobre ele na Internet, e o desenvolvedor tem 16 caracteres e 2 linhas disponíveis no display.
Por onde começar a aprender?
Você deve começar, é claro, comprando um programador; O mais econômico é o USBASP. O programador USBASP não é compatível com Atmel Studio 7.
Baixe os drivers do programador e do programa AVRdude, e para que tudo funcione junto, você pode usar o comando através da linha de comando:
"avrdude -c usbasp -p atmega32 -U flash:w: nome do arquivo de firmware. hexadecimal -U lfuse:w:0x6a:m -U hfuse:w:0xff:m"
e habilite seu suporte criando um perfil no atmel studio 7 (título – ferramentas externas), e no item Argumentos digite “-c usbasp -p atmega32 -U flash:w:$(TargetName).hex” e assim por diante para cada tipo você usa microcontroladores.
Só assim é possível conectar o estúdio e o programador USBASP. Tenha cuidado ao piscar - você pode danificar a assinatura do microcontrolador e só pode ser restaurada com um programador de 12 V (alta tensão).
Que literatura devo usar para treinamento?
Em primeiro lugar, baixe os manuais do site oficial de cada microcontrolador. É difícil recomendar um livro específico, mas existe “DI Halt – AVR. Curso de treinamento" você pode usá-lo - o criador deste material é um praticante, autor de muitos artigos sobre vários recursos da Internet e simplesmente uma pessoa respeitada nos círculos especializados.
Já disse mais de uma ou duas vezes que estudar MK deve começar com assembler. Um curso inteiro no site foi dedicado a isso (embora não seja muito consistente, mas aos poucos estou penteando até obter uma aparência adequada). Sim, é difícil, o resultado não será no primeiro dia, mas você aprenderá a entender o que está acontecendo no seu controlador. Você saberá como funciona, e não copiará as fontes de outras pessoas como um macaco e tentará entender por que de repente parou de funcionar. Além disso, é muito mais fácil para C criar código caipira que sairá com um forcado no momento mais inoportuno.
Infelizmente, todo mundo quer resultados imediatamente. Então resolvi ir por outro caminho - fazer um tutorial sobre C, mas mostrando a cueca dele. Um bom programador incorporador sempre segura seu hardware firmemente pelo parafuso, não permitindo que ele dê um único passo sem permissão. Então, primeiro haverá o código C, depois o que o compilador produziu e como tudo realmente funciona :)
Por outro lado, o ponto forte do C é a portabilidade do código. A menos, claro, que você escreva tudo corretamente. Separar os algoritmos de trabalho e suas implementações de hardware em diferentes partes do projeto. Então, para transferir o algoritmo para outro microcontrolador, bastará reescrever apenas a camada de interface, onde são gravadas todas as chamadas ao hardware, e deixar todo o código funcional como está. E, claro, legibilidade. O código-fonte C é mais fácil de entender à primeira vista (embora... por exemplo, eu não me importe com o que apontar - seja C ou ASM :)), mas, novamente, se tudo estiver escrito corretamente. Também prestarei atenção a esses pontos.
Minha placa de depuração servirá como hardware experimental no qual a maior parte de todos os exemplos será instalada.
O primeiro programa C para AVR
Escolhendo um compilador e configurando o ambiente
Existem muitos compiladores C diferentes para AVR:
Primeiro de tudo isso IAR AVR C- é quase definitivamente reconhecido como o melhor compilador para AVR, porque O controlador em si foi criado em estreita colaboração entre a Atmel e especialistas do IAR. Mas você tem que pagar por tudo. E esse compilador não é apenas um software comercial caro, mas também possui tantas configurações que é preciso muito esforço para simplesmente compilá-lo nele. Eu realmente não desenvolvi uma amizade com ele; o projeto estava apodrecendo devido a erros estranhos na fase de vinculação (depois descobri que era um crack torto).
Em segundo lugar vem WinAVR GCC- um poderoso compilador de otimização. Código totalmente aberto, multiplataforma, em geral, todas as alegrias da vida. Ele também se integra perfeitamente ao AVR Studio, permitindo depurar ali mesmo, o que é muito conveniente. Em geral, eu escolhi.
Há também CodeVision AVR Cé um compilador muito popular. Tornou-se popular devido à sua simplicidade. Você pode obter um programa funcional em apenas alguns minutos - o assistente de código inicial facilita muito isso, definindo padrões para a inicialização de todos os tipos de coisas. Para ser honesto, estou meio desconfiado disso - uma vez que tive que desmontar um programa escrito por este compilador, acabou sendo algum tipo de bagunça e não código. Uma quantidade terrível de movimentos e operações desnecessárias, que resultavam em uma quantidade considerável de código e desempenho lento. No entanto, talvez tenha havido um erro no DNA da pessoa que escreveu o firmware original. Além disso, ele quer dinheiro. Não tanto quanto o IAR, mas perceptível. E no modo de demonstração ele permite que você escreva no máximo 2 KB de código.
Claro que tem crack, mas se for roubar é um milhão, no sentido IAR :)
Ainda existem Imagem Craft AVR C E MicroC da microeletrônica. Não precisei usar nenhum dos dois, mas SWG. muito elogiando MicroPascal, dizem eles, um ambiente de programação e bibliotecas extremamente convenientes. Acho que o MicroC não será pior, mas também é pago.
Como eu disse, eu escolhi WinAVR por três razões: é gratuito, integra-se ao AVR Studio e há uma tonelada de código pronto escrito para todas as ocasiões.
Então baixe a instalação do WinAVR com AVR Studio. Em seguida, o estúdio é instalado primeiro, depois o WinAVR é colocado em cima e anexado ao estúdio na forma de um plugin. Eu recomendo fortemente instalar o WinAVR em um caminho curto, algo como C:\WinAVR, assim você evitará muitos problemas com caminhos.
Criando um projeto
Então, o estúdio está instalado, C está parafusado, é hora de tentar programar alguma coisa. Vamos começar pelo simples, pelo mais simples. Inicie o estúdio, selecione um novo projeto lá, como o compilador AVR GCC e digite o nome do projeto.
Um campo de trabalho é aberto com um arquivo *.c vazio.
Agora não vai doer configurar a exibição de caminhos nos favoritos do estúdio. Para fazer isso, vá para:
Menu Ferramentas - Opções - Geral - FileTabs e selecione “Somente nome de arquivo” na lista suspensa. Caso contrário, será impossível trabalhar - a aba conterá o caminho completo do arquivo e não haverá mais do que duas ou três abas na tela.
Configuração do projeto
Em geral, é considerado clássico criar um arquivo make no qual todas as dependências são descritas. E isso provavelmente está certo. Mas para mim, que cresci com IDEs totalmente integrados como uVisão ou Estúdio AVR esta abordagem é profundamente estranha. Portanto farei do meu jeito, tudo usando meios de estúdio.
Aperte o botão com a engrenagem.
 |
Estas são as configurações do seu projeto, ou melhor, as configurações para geração automática de um arquivo make. Na primeira página você só precisa inserir a frequência em que seu MK irá operar. Isso depende dos bits do fusível, então assumimos que nossa frequência é 8000000Hz.
Preste atenção também à linha de otimização. Agora existe -Os - isso é otimização de tamanho. Deixe como está por enquanto, então você pode tentar brincar com este parâmetro. -O0 não é nenhuma otimização.
A próxima etapa é configurar os caminhos. Em primeiro lugar, adicione o diretório do seu projeto lá - você adicionará bibliotecas de terceiros lá. O caminho “.\” aparecerá na lista.
O arquivo Make foi gerado, você pode olhar ele na pasta padrão do seu projeto, basta correr os olhos e ver o que tem lá.
 |
Isso é tudo por enquanto. Clique em OK em todos os lugares e vá para a fonte.
Declaração do problema
Uma folha de papel em branco é tentadora para implementar alguma ideia astuta, já que o piscar banal de um diodo não funciona mais. Vamos imediatamente pegar o touro pelos chifres e implementar a conexão com o computador - esta é a primeira coisa que faço.
Funcionará assim:
Quando chegar um um (código 0x31) na porta COM acenderemos o diodo, e quando chegar um zero (código 0x30) ele desliga. Além disso, tudo será feito em interrupções, e a tarefa em segundo plano será piscar outro diodo. Simples e significativo.
Montando o circuito
Precisamos conectar o módulo conversor USB-USART aos pinos USART do microcontrolador. Para fazer isso, pegue um jumper de dois fios e coloque-o transversalmente sobre os pinos. Ou seja, conectamos o Rx do controlador ao Tx do conversor, e o Tx do conversor ao Rx do controlador.
No final, este é o diagrama:
 |
Não considero conectar os pinos restantes, power, reset, é padrão
Escrevendo código
Deixe-me fazer uma reserva imediatamente: não irei me aprofundar especificamente na descrição da linguagem C em si. Existe simplesmente uma quantidade colossal de material para isso, começando com a clássica “Linguagem de programação C” da K&R e terminando com vários manuais.
Encontrei um desses métodos em meu estoque; uma vez usei-o para estudar esse idioma. Tudo ali é curto, claro e direto ao ponto. Aos poucos estou montando tudo e arrastando para o meu site.
É verdade que nem todos os capítulos foram transferidos ainda, mas acho que não será por muito tempo.
É improvável que eu consiga descrevê-lo melhor, portanto, no curso de treinamento, em vez de uma explicação detalhada das sutilezas, simplesmente fornecerei links diretos para páginas individuais deste manual.
Adicionando bibliotecas.
Em primeiro lugar, adicionamos as bibliotecas e cabeçalhos necessários com definições. Afinal C é uma linguagem universal e precisamos explicar para ele que estamos trabalhando especificamente com AVR, então escreva a linha no código fonte:
| 1 | #incluir |
#incluir
Este arquivo está localizado na pasta WinAVR e contém uma descrição de todos os registros e portas do controlador. Além disso, tudo aí é astuto, com ligação a um controlador específico, que é transmitido pelo compilador via fazer arquivo no parâmetro UCM e com base nesta variável, um arquivo de cabeçalho é conectado ao seu projeto com uma descrição dos endereços de todas as portas e registros deste controlador específico. Uau! Sem ele também é possível, mas você não poderá usar nomes de registro simbólicos como SREG ou UDR e terá que lembrar o endereço de cada um, como “0xC1”, o que será uma dor de cabeça.
A própria equipe #incluir<имя файла> permite adicionar o conteúdo de qualquer arquivo de texto ao seu projeto, por exemplo, um arquivo com uma descrição de funções ou um trecho de outro código. E para que a diretiva pudesse encontrar este arquivo, especificamos o caminho para o nosso projeto (o diretório WinAVR já está registrado lá por padrão).
Função principal.
Um programa C consiste inteiramente em funções. Eles podem ser aninhados e chamados uns dos outros em qualquer ordem e de maneiras diferentes. Cada função possui três parâmetros obrigatórios:
- O valor de retorno é, por exemplo. pecado (x) retorna o valor do seno de x. Como na matemática, em suma.
- Os parâmetros transmitidos são os mesmos X.
- Corpo funcional.
Todos os valores transmitidos e retornados devem ser de algum tipo, dependendo dos dados.
Qualquer programa C deve conter uma função principal como ponto de entrada no programa principal, caso contrário não é C :). Pela presença de main no código-fonte de outra pessoa a partir de um milhão de arquivos, você pode entender que esta é a parte principal do programa, onde tudo começa. Então vamos perguntar:
| 1 2 3 4 5 | int principal(void) ( return 0 ; ) |
int principal(void) ( return 0; )
É isso, o primeiro programa mais simples foi escrito, não importa que não faça nada, apenas começamos.
Vamos descobrir o que fizemos.
interno Este é o tipo de dados que a função principal retorna.
Claro, em um microcontrolador principal em princípio, nada pode ser devolvido e, em teoria, deveria haver vazio principal(vazio), mas o GCC foi originalmente projetado para PC e aí o programa pode retornar o valor ao sistema operacional após a conclusão. Portanto, o CCG em vazio principal(vazio) jura por Aviso.
Isso não é um erro, vai funcionar, mas não gosto de avisos.
vazio este é o tipo de dado que passamos para a função, neste caso principal também não pode aceitar nada de fora, portanto vazio- um manequim. Um stub é usado quando não há necessidade de transmitir ou retornar nada.
Aqui estão eles { } chaves são um bloco de programa, neste caso o corpo de uma função principal, o código estará localizado lá.
retornar- este é o valor de retorno que a função principal retornará ao ser concluída, já que temos um int, ou seja, um número, então devemos retornar um número. Embora isso ainda não faça sentido, porque... no microcontrolador, não podemos ir a lugar nenhum do principal. Eu retorno nulo. Porque isso não importa. Mas o compilador costuma ser inteligente e não gera código para esse caso.
Embora, se pervertido, então de principal Você pode ir para o MK - por exemplo, entrar na seção do bootloader e executá-lo, mas isso exigirá ajustes de baixo nível no firmware para corrigir os endereços de transição. Abaixo você verá por si mesmo e entenderá como fazer. Para que? Essa é outra questão, em 99,999% dos casos isso não é necessário :)
Fizemos isso e seguimos em frente. Vamos adicionar uma variável, realmente não precisamos dela e não adianta introduzir variáveis sem ela, mas estamos aprendendo. Se variáveis forem adicionadas dentro do corpo de uma função, elas serão locais e existirão apenas nesta função. Ao sair da função, essas variáveis são excluídas e a memória RAM é alocada para necessidades mais importantes. .
| 1 2 3 4 5 6 | int main(void) (unsigned char i; return 0;) |
int main(void) (unsigned char i; return 0; )
não assinado significa não assinado. O fato é que na representação binária o bit mais significativo é alocado ao sinal, o que significa que o número +127/-128 cabe em um byte (char), mas se o sinal for descartado caberá de 0 a 255. Normalmente o sinal não é necessário. Então não assinado.
eué apenas um nome de variável. Nada mais.
Agora precisamos inicializar as portas e UART. Claro, você pode pegar e conectar a biblioteca e chamar algum tipo de UartInit(9600); mas então você não saberá o que realmente aconteceu.
Nós fazemos isso:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | int main(void) (unsigned char i; #define XTAL 8000000L #define taxa de transmissão 9600L #define bauddivider (XTAL/(16*taxa de transmissão)-1)#define HI(x) ((x)>>8) #define LO(x) ((x)& 0xFF) UBRRL = LO(divisor de baud) ;<< RXEN| 1 << TXEN| 1 << RXCIE| 0 << TXCIE; UCSRC = 1 << URSEL| 1 << UCSZ0| 1 << UCSZ1; } |
UBRRH = HI(divisor de transmissão) ;< UCSAR = 0; UCSRB = 1 int main(void) ( unsigned char i; #define XTAL 8000000L #define baudrate 9600L #define bauddivider (XTAL/(16*baudrate)-1) #define HI(x) ((x)>>8) #define LO( x) ((x)& 0xFF) UBRRL = LO(divisor de baud); Apavorante? Na verdade, existem apenas cinco últimas linhas de código real. Tudo isso #definir você pode substituir 8.000.000 com segurança, e eu- indicação do tipo, dizendo que long é a frequência do clock do processador. O mesmo taxa de transmissão— frequência de transmissão de dados via UART. divisor de transmissão já mais complicado, em vez dela será substituída a expressão calculada pela fórmula das duas anteriores. Então, tudo o que é feito é como UCSRB = 1 você pode jogá-lo fora com segurança e calcular os números necessários em uma calculadora e inseri-los imediatamente nas linhas UBBRL =…. e UBBRH =….. Pode. Mas! Faça isso ABSOLUTAMENTE IMPOSSÍVEL! Funcionará desta ou daquela maneira, mas você terá os chamados números mágicos- valores retirados do nada e por razões desconhecidas, e se você abrir tal projeto em alguns anos, será muito difícil entender quais são esses valores. Mesmo agora, se você quiser alterar a velocidade, ou se alterar a frequência do quartzo, tudo terá que ser recalculado novamente, mas você alterou alguns números no código e pronto. Em geral, se você não deseja ser rotulado como um codificador, faça seu código de forma que seja fácil de ler, compreensível e fácil de modificar. Então tudo é simples: Tipo de gravação 1< Pronto, é hora de ver o que aconteceu. Clique em compilação e inicie a emulação (Ctrl+F7). Depuração O fato é que inicialmente, na verdade, estava na linha UBRRL = LO(bauddivider); Afinal, o que temos em definição não é código, mas simplesmente cálculos preliminares, por isso o simulador é um pouco chato. Mas agora ele percebeu, a primeira instrução foi concluída e se você subir na árvore Visualização de E/S, para a seção USART e olhe o byte UBBRL ali, você verá que o valor já está lá! 0x33. Dê um passo adiante. Veja como o conteúdo do outro registro muda. Então analise todos eles, preste atenção ao fato de que todos os bits indicados estão configurados como eu disse, e estão configurados simultaneamente para todo o byte. Não irá além do Return - o programa acabou. Abertura Primeiro teremos os tops da série: 00000000: 940C002A JMP 0x00002A Salto +00000002: 940C0034 JMP 0x00000034 Salto +00000004: 940C0034 JMP 0x000034 SALTO +00000006: 940C0034 JMP 0x00 0034 Salto +000008: 940C0034 JMP 0x00000034 Salto +0000000a: 940c0034 JMP 0x00000034 Salto +0000000C: 940c0034 JMP 0x00000034 Salto +0000000EE : 940C0034 JMP 0x00000034 Salto +00000010: 940C0034 JMP 0x00000034 Salto +00000012: 940C0034 JMP 0x00000034 Salto +00000014: 940C0034 JMP 0x00000 4 Salto +00000016: 940C0034 JMP 0x00000034 Salto +00000018: 940C0034 JMP 0x00000034 Salto +0000001A: 940C0034 JMP 0x00000034 Salto +0000001C : 940C0034 JMP 0x00000034 Salto +0000001E: 940C0034 JMP 0x00000034 Salto +00000020: 940C0034 JMP 0x00000034 Salto +00000022: 940C0034 JMP 0x0000003 4 Salto +00000024: 940C0034 JMP 0x00000034 Salto +00000026: 940C0034 JMP 0x00000034 Salto +00000028: 940C0034 JMP 0x00000034 Salto Esta é a tabela de vetores de interrupção. Voltaremos a ele mais tarde, mas por enquanto basta olhar e lembrar que ele existe. A primeira coluna é o endereço da célula flash onde está o comando, a segunda é o código do comando, a terceira é o mnemônico do comando, a mesma instrução assembly, a terceira são os operandos do comando. Bem, comentário automático. 0000002B: BE1F OUT 0x3F,R1 Out para local de E/S Registrando esse zero no endereço 0x3F Se você olhar a coluna de visualização de E/S, verá que o endereço 0x3F é o endereço do registrador SREG – o registrador de flag do controlador. Aqueles. redefinimos o SREG para executar o programa em condições zero. 0000002C: E5CF LDI R28,0x5F Carga imediata +0000002D: E0D4 LDI R29,0x04 Carga imediata +0000002E: BFDE OUT 0x3E,R29 Saída para local de E/S +0000002F: BFCD OUT 0x3D,R28 Saída para local de E/S Isso está carregando o ponteiro da pilha. Você não pode carregar diretamente nos registradores de E/S, apenas através de um registrador intermediário. Portanto, primeiro LDI para intermediário e depois OUT para I/O. Também contarei mais sobre a pilha mais tarde. Por enquanto, saiba que esta é uma área de memória dinâmica que fica pendurada no final da RAM e armazena endereços e variáveis intermediárias. Agora indicamos de onde nossa pilha começará. 00000032: 940C0041 JMP 0x00000041 Salto Vá para o final do programa e lá teremos uma proibição de interrupções e loops rígidos sobre si mesmo: 00000041: 94F8 CLI Global Interrupt Disable +00000042: CFFF RJMP PC-0x0000 Salto relativo Isso ocorre em caso de imprevistos, como saída da função principal. O controlador pode ser retirado desse loop por uma reinicialização de hardware ou, mais provavelmente, por uma reinicialização de um watchdog. Bem, ou, como eu disse acima, corrija isso no editor hexadecimal e galope para onde seu coração desejar. Observe também que existem dois tipos de transições: JMP e RJMP, a primeira é uma transição direta para um endereço; Ocupa quatro bytes e pode saltar diretamente por toda a área da memória. O segundo tipo de transição é RJMP - relativa. Seu comando leva dois bytes, mas ele se move da posição atual (endereço) 1.024 passos para frente ou para trás. E seus parâmetros indicam o deslocamento do ponto atual. É usado com mais frequência porque ocupa metade do espaço de forma nivelada e raramente são necessárias transições longas. 00000034: 940C0000 JMP 0x00000000 Salto E isso é um salto para o início do código. Uma espécie de reinicialização. Você pode verificar se todos os vetores saltam aqui. A conclusão disso é que se você agora habilitar interrupções (elas estão desabilitadas por padrão) e sua interrupção ocorrer, mas não houver manipulador, então haverá uma reinicialização do software - o programa será retornado ao início. Função principal. Tudo é parecido, nem precisa descrever. Basta olhar para o número já calculado que está sendo inserido nos registros. O pré-processador do compilador é demais!!! Portanto, nada de números “mágicos”! 00000036: E383 LDI R24,0x33 Carga imediata +00000037: B989 OUT 0x09,R24 Saída para local de E/S 15: UBRRH = HI(bauddivider); +00000038: BC10 OUT 0x20,R1 Saída para local de E/S 16: UCSRA = 0; +00000039: B81B OUT 0x0B, R1 Saída para local de E/S 17: UCSRB = 1< E aqui está o bug: 0000003E: E080 LDI R24.0x00 Carga imediata +0000003F: E090 LDI R25.0x00 Carga imediata +00000040: 9508 RET Retorno de sub-rotina A questão é: por que o compilador adiciona esses topos? E isso nada mais é do que Return 0, definimos a função como int main(void), então desperdiçamos mais quatro bytes sem motivo :) E se você fizer void main(void) então apenas RET permanecerá, mas um aviso irá parece que nossa função principal não retorna nada. Em geral, faça o que quiser :) Difícil? Aparentemente não. Clique na execução passo a passo no modo desmontador e veja como o processador executa instruções individuais, o que acontece com os registradores. Como ocorre o movimento através dos comandos e do loop final? Continuará em alguns dias... Fora de cima: AVR Studio 4 é um novo ambiente de desenvolvimento integrado (IDE) profissional, projetado para escrever e depurar programas aplicativos para microprocessadores AVR no Windows 9x/NT/2000. AVR Studio 4 contém um montador e um simulador. O IDE também suporta ferramentas de desenvolvimento para AVR como: ICE50, ICE40, JTAGICE, ICE200, STK500/501/502 e AVRISP. Nos próximos meses, a lista de microcontroladores e ferramentas de desenvolvimento suportadas pelo AVR Studio 4 será ampliada. Todas as atualizações podem ser encontradas no site. AVR Studio suporta COFF como formato de saída para depuração simbólica. Outros softwares de terceiros também podem ser configurados para funcionar com o AVR Studio. Janela de origem do programa A janela principal do AVR Studio é a janela de origem do programa. Quando um arquivo objeto é aberto, uma janela de origem do programa é criada automaticamente. A janela exibe o código que é executado em um ambiente de depuração (emulador ou simulador de software) e o marcador de texto está sempre localizado na linha que será executada no próximo loop. Execução de programas e modo passo a passo O usuário pode executar todo o programa passo a passo, traçando blocos de funções ou executando o programa até o local onde o cursor está localizado. Além disso, você pode definir um número ilimitado de pontos de interrupção, cada um dos quais pode ser ativado ou desativado. Os pontos de interrupção são salvos entre sessões de trabalho. Ver registros A janela de origem do programa exibe informações sobre o processo de execução do programa. Além disso, o AVR Studio possui muitas outras janelas que permitem controlar e exibir informações sobre qualquer elemento do microcontrolador. Lista de janelas disponíveis: As configurações do ambiente de trabalho são salvas quando você sai. Ao iniciá-lo pela primeira vez, você precisa configurar o Windows para controlar e exibir as informações necessárias. As configurações são restauradas automaticamente durante a próxima inicialização. AVR Studio inclui suporte para ferramentas de depuração Atmel: Quaisquer programadores e ferramentas de depuração que suportem microcontroladores Atmel também são compatíveis com AVR Studio. Programas:
Bem, bem L.O. E OI os bytes baixos e altos serão retirados deste resultado, porque Obviamente, pode não caber em um byte. EM OI X (o parâmetro de entrada da macro) é deslocado oito vezes para a direita, resultando apenas no byte mais significativo restante. E em L.O. fazemos um AND bit a bit com o número 00FF, como resultado apenas o byte baixo permanecerá.
Todos esses “UBRRL and Co” são registros de configuração do transmissor UART com a ajuda dos quais nos comunicaremos com o mundo. E agora atribuímos a eles os valores necessários, configurando-os para a velocidade e modo desejados.
Todos os tipos de barras de progresso passaram, o estúdio mudou e uma seta amarela apareceu perto da entrada da função principal. É aqui que o processador está em execução e a simulação está pausada.
Agora redefina a simulação para zero. Clique aqui Redefinir (Shift+F5). Abra a listagem desmontada, agora você verá o que realmente está acontecendo no controlador. Ver -> Desmontador. E não YYAAAAA!!! Montador!!! HORROR!!! E É NECESSÁRIO. Para que mais tarde, quando algo der errado, você não seja estúpido no código e não faça perguntas idiotas nos fóruns, mas imediatamente entre no estômago e veja onde está preso. Não há nada assustador aí. 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
+00000000: 940C002A JMP 0x0000002A Salto +00000002: 940C0034 JMP 0x00000034 Salto +00000004: 940C0034 JMP 0x00000034 Salto +00000006: 940C0034 JMP 0x 00000034 Salto +00000008: 940C0034 JMP 0x00000034 Salto +0000000A: 940C0034 JMP 0x00000034 Salto +0000000C: 940C0034 JMP 0x00000034 Salto + 0000000E: 940C0034 JMP 0x000034 Salto +00000010: 940c0034 JMP 0x00000034 Salto +000012: 940c0034 JMP 0x00000034 Salto +00000014: 940c0034 JMP 0x0000 0034 Salto +00000016: 940C003 4 JMP 0x00000034 Salto +00000018: 940c0034 JMP 0x00000034 Salto +0000001a: 940c0034 JMP 0x00000034 Salto + 0000001c: 940C0034 JMP 0x00000034 Salto +0000001E: 940C0034 JMP 0x00000034 Salto +00000020: 940C0034 JMP 0x00000034 Salto +00000022: 940C0034 JMP 0 x00000 034 Salto +00000024: 940C0034 JMP 0x00000034 Salto +00000026: 940C0034 JMP 0x00000034 Salto +00000028: 940C0034 JMP 0x00000034 Salto
Então, se você observar, há transições contínuas. E o código de comando JMP tem quatro bytes, contém o endereço de salto escrito ao contrário - o byte baixo no endereço baixo e o código de comando de salto 940C 1
2
3
4
+0000002C: E5CF LDI R28,0x5F Carga imediata +0000002D: E0D4 LDI R29,0x04 Carga imediata +0000002E: BFDE OUT 0x3E,R29 Saída para local de E/S +0000002F: BFCD OUT 0x3D,R28 Saída para local de E/S
1
2
+00000041: 94F8 CLI Global Interrupt Disable +00000042: CFFF RJMP PC-0x0000 Salto relativo
1
+00000034: 940C0000 JMP 0x00000000 Salto
1
2
3
4
5
6
7
8
9
10
11
12
< 1
2
3
+0000003E: E080 LDI R24.0x00 Carga imediata +0000003F: E090 LDI R25.0x00 Carga imediata +00000040: 9508 RET Retorno de sub-rotina
Alexei78 Criei um plugin para Firefox que facilita a navegação em meu site e fórum.
Discussão e download,
AVR Studio 4.12 Service Pack 4 (setembro de 2006)
Outra atualização do popular ambiente de design integrado com montador e simulador integrados. O quarto service pack, SP4, herdou todos os novos recursos das atualizações anteriores SP1, SP2 e SP3.
O programa, firmware, manual do usuário e lista de microcontroladores suportados para AVR Dragon foram atualizados. O pacote também inclui novo firmware para ferramentas de depuração JTAGICE MKII e STK500. Está incluído suporte para novos tipos de microcontroladores, incluindo: ATmega644P, ATmega329P, ATmega3290P, ATmega325P, ATmega3250P. Foram corrigidos erros no funcionamento do simulador, assembler e JTAGICEmkII. Observe que o AVR Studio 4 SP3 e SP4 não pode ser executado no sistema operacional Windows 95.
AVR Studio 4.11 Service Pack 3 (27 MB, atualizado em maio de 2005)
Ambiente de design integrado AVR Studio 4.11 (41Mb janeiro de 2005)
Ambiente de design integrado AVR Studio 4.10 (30Mb de setembro de 2004)
Nova! AVR Studio 4.10 com montador atualizado (versão 2 beta-5 (AVRASM2)), a versão antiga do montador AVRASM1 está conectada por padrão. O simulador AVR Studio foi atualizado, que agora também suporta os novos microcontroladores AVR ATmega165, ATmega649, ATmega325, ATmega3250, ATmega3290. Suporte de software atualizado para JTAGICE2, ICE50, STK500, AVRISP, JTAGICE2. USB WinDriver foi atualizado da versão 6.03 para a versão 6.22.
Ambiente de design integrado AVR Studio 4.09 (28Mb de abril de 2004)
AVR Studio 4.09 adiciona suporte para JTAGICE mkII. Combinado com a nova versão do AVR Studio, o JTAGICE mkII é uma ferramenta completa para realizar depuração on-chip de todos os 8 bits. Microcontroladores AVR RISC contendo uma interface JTAG ou uma interface debugWIRE de fio único para esta finalidade. Esta versão também adiciona suporte para novos microcontroladores e traz diversas melhorias.
AVR Studio 4.08 SP1 (8 MB, atualizado em 2/04)
Esta é uma versão de manutenção do AVR Studio 4 e requer instalação prévia do AVR Studio versão 4.08. Ele adiciona suporte de simulação e emulação (ICE50) à nova família ATMega48 de microcontroladores AVR. Para obter informações completas sobre os recursos desta versão, consulte a documentação incluída, que pode ser acessada no menu Ajuda do AVR Studio.
AVR Studio 4.08 (26 MB, atualizado em 03/12)
AVR Studio 4.08 é um ambiente de desenvolvimento integrado (IDE) projetado para escrever e depurar programas aplicativos para microprocessadores AVR no Windows 9x/NT/2000. Rastreador atualizado, monitor de pilha e suporte USB aprimorado para ICE40/50. Além disso, há uma série de adições adicionais.
Estúdio AVR V4.0 de 12756 Kb
Estúdio AVR V3.56 de 7.163 Kb
1,31 Mb AVR LCD Visualizer versão 1.0 (atualizado em 02/2004), versão beta pública.
Criação e modificação de LCDs utilizando o editor, depuração e visualização utilizando add-ons ao programa AVR Studio. Atualizações em tempo real ao trabalhar com ICE50 e simulador. Suporta ATmega169. A instalação requer AVR Studio IDE versão 4.07 ou mais recente. Antes da instalação, você deve remover complementos de LCD antigos do programa.
