Programando microcontroladores AVR em C. Programando microcontroladores AVR em C. Então, o que é um microcontrolador

Decidi escrever um pequeno artigo introdutório para aqueles que começaram a programar microcontroladores pela primeira vez e nunca estavam familiarizados com a linguagem C antes. Não entraremos em detalhes, falaremos um pouco de tudo para se ter uma ideia geral de como trabalhar com CodeVisionAVR.

Mais informação detalhada pode ser visualizado em inglês no Manual do Usuário CodeVision, e também recomendo o site http://somecode.ru com videoaulas sobre C para microcontroladores e o livro “Como Programar em C” da Deitel, este é o único livro bom com o qual eu mesmo comecei.

Vamos começar com o fato de que não importa quais ações façamos, em última análise, tudo se resume ao firmware do microcontrolador. O próprio processo de firmware ocorre da seguinte forma: usando um determinado programa, um arquivo de firmware é selecionado, os parâmetros são selecionados, um botão é pressionado e o firmware é atualizado diretamente, o que, em essência, é uma cópia. Assim como você copia músicas ou documentos de um computador para uma unidade flash, a física do processo é a mesma.

O próprio firmware possui extensão .hex e é um conjunto de instruções, na forma de uns e zeros, que são compreensíveis para o microcontrolador. Onde posso obter o firmware? Você pode baixá-lo de sites de eletrônicos ou escrevê-lo você mesmo. Você pode escrevê-lo em programas especiais chamados ambiente de desenvolvimento. Os mais conhecidos para mim são AVR Studio, IAR, CodeVision, WinAVR... É impossível dizer qual desses ambientes é melhor ou pior, cada um no seu. Podemos dizer que esses programas se diferenciam principalmente pela praticidade, linguagem de programação e preço. Dentro deste site, apenas CodeVision é considerado.

Resolvemos o ambiente, agora vamos dar uma olhada no processo de gravação do firmware. No CodeVision, primeiro você precisa criar um projeto. Ele pode ser criado usando o assistente de código ou vazio. Em qualquer caso, é necessário selecionar o tipo de microcontrolador utilizado e indicar sua frequência. Ao usar o assistente, você será solicitado a selecionar as configurações iniciais e gerar o código-fonte com as configurações. A seguir, aparecerá uma janela na qual você poderá editar este código. Embora você possa escrever seu código-fonte no Bloco de Notas e anexá-lo ao projeto nas configurações.

Um arquivo de código-fonte é um conjunto de comandos em uma linguagem de programação, a tarefa do CodeVision é traduzir esses comandos em código binário, sua tarefa é escrever esse código-fonte. CodeVision entende a linguagem C, os arquivos de código-fonte possuem a extensão “.c”. Mas CodeVision tem algumas construções que não são usadas em C, e é por isso que muitos programadores não gostam dele, e a linguagem usada é chamada de C-like. No entanto, isso não o impede de escrever projetos sérios. Muitos exemplos, um gerador de código e um grande conjunto de bibliotecas dão ao CodeVision uma grande vantagem. O único aspecto negativo é que é pago, embora haja versões gratuitas com restrição de código.

O código fonte deve conter um cabeçalho com o tipo de microcontrolador utilizado e a função principal. Por exemplo, ATtiny13 é usado

#incluir vazio principal(vazio) ( ) ;

#incluir vazio principal(vazio) ( );

Antes da função principal, você pode conectar as bibliotecas necessárias, declarar variáveis ​​globais, constantes e configurações. Uma biblioteca é um arquivo separado, geralmente com extensão “.h”, que já contém código pré-escrito. Em alguns projetos podemos precisar deste código, mas em outros não. Por exemplo, em um projeto usamos monitores LCD, mas em outro não. Você pode conectar a biblioteca para trabalhar com o display LCD “alcd.h” assim:

#incluir #incluir vazio principal(vazio) ( ) ;

#incluir #incluir vazio principal(vazio) ( );

Variáveis ​​são áreas da memória nas quais determinados valores podem ser colocados. Por exemplo, se você adicionar dois números, precisará salvar o resultado em algum lugar para usá-lo no futuro. Primeiro você precisa declarar a variável, ou seja, alocar memória para ele, por exemplo:
int i=0;
aqueles. declaramos a variável i e colocamos nela o valor 0, int é o tipo da variável, ou mais simplesmente, significa o tamanho da memória alocada. Cada tipo de variável só pode armazenar um determinado intervalo de valores. Por exemplo, int pode ser escrito como números de -32768 a 32767. Se você precisar usar números com parte fracionária, a variável deverá ser declarada como float, para caracteres, use o tipo char.

bit, _Bit 0 ou 1 char de -128 a 127 unsigned char de 0 a 255 int de -32768 a 32767 unsigned int de 0 a 65535 long int de -2147483648 a 2147483647 unsigned long int de 0 a 4294967295 float de ±1,17 5e- 38 a ±3.402e38

Dentro da função principal, o programa principal já está em execução. Após executar a função, o programa irá parar, então eles fazem um loop while infinito, que repete o mesmo programa constantemente.

void main(void) ( while (1) ( ) ; ) ;

void main(void) ( while (1) ( ); );

Você pode escrever um comentário em qualquer parte do código-fonte; isso não afetará de forma alguma o funcionamento do programa, mas ajudará a fazer anotações no código escrito. Você pode comentar uma linha com duas barras //após as quais o compilador irá ignorar a linha inteira ou várias linhas /**/, por exemplo:

/*Operações matemáticas básicas:*/ int eu= 0; //declara a variável i e atribui a ela o valor 0//Adição: i = 2 + 2 ; //Subtração: i = 2 - 2 ; //após executar esta expressão, a variável i será igual a 0//Multiplicação: i = 2 * 2 ; //após executar esta expressão, a variável i será igual a 4//Divisão: i = 2/2; //após executar esta expressão, a variável i será igual a 1

/*Operações matemáticas básicas:*/ int i=0; //declara a variável i e atribui a ela o valor 0 //Adição: i = 2+2; //após executar esta expressão, a variável i será igual a 4 //Subtração: i = 2-2; //após executar esta expressão, a variável i será igual a 0 //Multiplicação: i = 2*2; //após executar esta expressão, a variável i será igual a 4 //Divisão: i = 2/2; //após executar esta expressão, a variável i será igual a 1

Muitas vezes, um programa precisa fazer a transição de um trecho de código para outro, dependendo das condições; para isso, existem operações if() condicionais, por exemplo:

if(i>3) //se i for maior que 3, então atribua a i o valor 0 ( i=0; ) /*se i for menor que 3, então vá para o código seguindo o corpo da condição, ou seja. depois dos colchetes ()*/

Além disso, if pode ser usado em conjunto com else - caso contrário

se eu<3) //если i меньше 3, то присвоить i значение 0 { i=0; } else { i=5; //иначе, т.е. если i больше 3, присвоить значение 5 }

Existe também um operador de comparação “==”, que não deve ser confundido com “=” atribuir. A operação inversa não é igual a "!=", digamos

if(i==3)//se i for 3, atribua a i o valor 0 ( i=0; ) if(i!=5) //se i não seja 5, atribua a i o valor 0 ( i=0; ) )

Vamos passar para coisas mais complexas - funções. Digamos que você tenha um determinado trecho de código que é repetido várias vezes. Além disso, este código é bastante grande. É inconveniente escrever sempre. Por exemplo, em um programa que de alguma forma altera a variável i, ao pressionar os botões 0 e 3 da porta D, é executado o mesmo código, que, dependendo do valor da variável i, liga as pernas da porta B.

void principal(void) ( if (PIND.0== 0 ) //verifica se o botão do PD0 está pressionado(se (eu== 0) //se i==0 habilita PB0( PORTB.0= 1 ; ) se (i== 5 ) // se i==5 habilita PB1( PORTB.1= 1 ; ) ) … se (PIND.3== 0 ) //faça a mesma coisa ao verificar o botão PD3(se (i== 0) (PORTB.0= 1;) se (i== 5) (PORTB.1= 1;)))

void main(void) ( if(PIND.0==0) //verifica se o botão no PD0 está pressionado ( if(i==0) //se i==0 liga PB0 ( PORTB.0=1; ) if( i==5) // se i==5 ativa PB1 ( PORTB.1=1; ) ) ... if(PIND.3==0) // faça a mesma coisa ao verificar o botão PD3 ( if(i==0 ) ( PORTB.0=1; ) if(i==5) ( PORTB.1=1; ) ) )

Em geral, o código não é muito grande, mas poderia ser muitas vezes maior, por isso seria muito mais conveniente criar sua própria função.
Por exemplo:

void i_check() ( if (i== 0 ) ( PORTB.0= 1 ; ) if (i== 5 ) ( PORTB.1= 1 ; ) )

void i_check() ( if(i==0) ( PORTB.0=1; ) if(i==5) ( PORTB.1=1; ) )

void significa que a função não retorna nada, mais sobre isso abaixo i_check() - esse é o nome da nossa função, você pode chamá-la como quiser, eu chamei exatamente assim - verifique i. Agora podemos reescrever nosso código:

void i_check() ( if(i==0) ( PORTB.0=1; ) if(i==5) ( PORTB.1=1; ) ) void main(void) ( if(PIND.0==0 ) //verifica se o botão no PD0 está pressionado ( i_check(); ) ... if(PIND.3==0) ( i_check(); ) )

Quando o código atinge a linha i_check(); então ele irá pular para dentro da função e executar o código dentro dela. Concordo, o código é mais compacto e claro, ou seja, funções ajudam a substituir o mesmo código, apenas uma linha. Observe que a função é declarada fora do código principal, ou seja, antes da função principal. Você pode dizer por que preciso disso, mas ao estudar as lições você frequentemente encontrará funções, por exemplo, limpar a tela LCD lcd_clear() - a função não aceita nenhum parâmetro e não retorna nada, mas limpa o tela. Às vezes, essa função é usada em quase todas as linhas, portanto a economia de código é óbvia.

Parece muito mais interessante usar uma função quando ela assume valores, por exemplo, existe uma variável c e existe uma função soma que assume dois valores do tipo int. Quando o programa principal executar esta função, os argumentos já estarão entre parênteses, então "a" será igual a dois e "b" será igual a 1. A função será executada e "c" será igual a 3 .

interno c= 0; void soma(int a, int b) ( c= a+ b; ) void main(void ) ( sum(2 , 1 ) ; )

interno c=0; void soma(int a, int b) ( c=a+b; ) void main(void) ( soma(2,1); )

Uma das funções semelhantes mais comuns é mover o cursor no display LCD lcd_gotoxy(0,0); que, aliás, também aceita argumentos - coordenadas x e y.

Outra opção de utilização de uma função, quando ela retorna um valor, agora não será mais nula, vamos melhorar o exemplo anterior de função para soma de dois números:

interno c= 0; int soma(int a, int b) ( return a+ b; ) void main(void) ( с= soma(2, 1) ; )

interno c=0; int soma(int a, int b) ( return a+b; ) void main(void) ( с=soma(2,1); )

O resultado será o mesmo da última vez c=3, mas observe que atribuímos à variável “c” o valor de uma função que não é mais nula, mas retorna a soma de dois números do tipo int. Dessa forma não ficamos presos a uma variável específica “c”, o que agrega flexibilidade no uso de funções. Um exemplo simples de tal função é a leitura de dados ADC, a função retorna o valor medido result=read_adc();. Vamos terminar com as funções.

Agora vamos passar para matrizes. Uma matriz são variáveis ​​relacionadas. Por exemplo, você tem uma tabela de senos com vários pontos, você não irá criar variáveis ​​int sinus1=0; int seno2=1; etc. Uma matriz é usada para isso. Por exemplo, você pode criar um array de três elementos como este:
int seio=(0,1,5);
O número total de elementos da matriz é indicado entre colchetes. Você pode atribuir o valor do terceiro elemento à variável “c” assim:
с=sinus;
Observe que a numeração dos elementos da matriz começa em zero, ou seja, "c" se tornará igual a cinco. Este array não possui um elemento sinusal!!!
Você pode atribuir um valor a um elemento individual como este:
seio=10;

Você já deve ter notado que o CodeVision não possui variáveis ​​de string. Aqueles. você não pode criar uma string variável hello=”hello”; Para fazer isso, você terá que criar uma matriz de caracteres individuais.

lcd_putchar(olá); lcd_putchar(olá); lcd_putchar(olá);

etc.
Acontece bastante complicado, é aqui que os ciclos vêm em socorro.
Por exemplo, loop while

enquanto(PINB.0!=0) ( )

Até que o botão seja pressionado, não faça nada - execute um loop vazio.

Outra opção é o loop for

int eu; para (eu= 0; eu< 6 ; i++ ) { lcd_putchar(hello[ i] ) ; }

int eu; para (eu=0;eu<6;i++) { lcd_putchar(hello[i]); }

O significado é exatamente o mesmo de while, apenas a condição inicial i=0 e a condição que é executada a cada ciclo i++ são adicionadas. O código dentro do loop é o mais simplificado possível.

Depois de escrever seu programa, o código-fonte é compilado e, se não houver erros, você receberá o cobiçado firmware na pasta do projeto. Agora você pode atualizar o microcontrolador e aproveitar o funcionamento do dispositivo.

Você não deve tentar usar loops, arrays e funções imediatamente em seu firmware. Sua principal tarefa é fazer o firmware funcionar, então faça como for mais fácil para você e não preste atenção no tamanho do código. Chegará o momento em que você desejará não apenas escrever um código funcional, mas também escrevê-lo de maneira bonita e compacta. Então será possível mergulhar nos confins da linguagem C. Para quem quer dominar tudo, recomendo mais uma vez o livro “Como Programar em C”, são muitos exemplos e tarefas. Instale o Visual Studio, crie um aplicativo de console win32 e pratique o quanto quiser.

Lição 0.

Então, hoje abrimos uma série de aulas sobre programação de microcontroladores da família AVR.

Hoje serão consideradas as seguintes questões:

1. O que é um microcontrolador?
2. Onde os microcontroladores são usados?

Introdução.

Os microcontroladores estão por toda parte. Em telefones, máquinas de lavar, “casas inteligentes”, máquinas-ferramentas em fábricas e também em inúmeros outros dispositivos técnicos. Seu uso generalizado permite substituir circuitos analógicos complexos por circuitos digitais mais compactados.

Então, o que é um microcontrolador?

Microcontrolador (Unidade de microcontrolador, MCU) - um microcircuito projetado para controlar dispositivos eletrônicos. Você pode imaginá-lo como um computador simples capaz de interagir com dispositivos externos. Por exemplo, abrindo e fechando transistores, recebendo dados de sensores de temperatura, exibindo dados em telas LCD, etc. Além disso, o microcontrolador pode realizar diversos processamentos de dados de entrada, assim como o seu computador pessoal.

Ou seja, os microcontroladores oferecem-nos possibilidades quase ilimitadas de controlo de quaisquer dispositivos, graças à presença de portas I/0 (portas de entrada/saída), bem como à possibilidade de os programar.

Onde os microcontroladores são usados?

1. Eletrodomésticos (Máquinas de lavar roupa, fornos microondas, etc.).
2. Tecnologia móvel (robôs, sistemas robóticos, equipamentos de comunicação, etc.).
3. Equipamentos industriais (sistemas de controle de máquinas).
4. Tecnologia informática (placas-mãe, sistemas de controle de dispositivos periféricos).
5. Equipamentos de entretenimento (brinquedos infantis, decorações).
6. Transporte (sistemas de controle de motores de automóveis, sistemas de segurança)

Esta não é uma lista completa de aplicações para microcontroladores. Freqüentemente, é muito lucrativo substituir um conjunto de chips de controle por um microcontrolador, devido à produção simplificada e ao consumo reduzido de energia.

Introdução ao AVR

AVR- uma família de microcontroladores da Atmel, com desempenho suficiente para a maioria dos dispositivos amadores. Eles também são amplamente utilizados na indústria.

O diagrama esquemático do programador de porta LPT é mostrado na figura. Como driver de barramento, use o microcircuito 74AC 244 ou 74HC244 (K1564AP5), 74LS244 (K555AP5) ou 74ALS244 (K1533AP5).

LED VD1 indica o modo de gravação do microcontrolador,

LED VD2 - leitura,

LED VD3 - presença de alimentação ao circuito.

O circuito obtém a tensão necessária para alimentação do conector ISP, ou seja, do dispositivo programável. Este circuito é um circuito programador STK200/300 redesenhado (LEDs adicionados para facilitar a operação), portanto é compatível com todos os programas programadores de PC que funcionam com o circuito STK200/300. Para trabalhar com este programador, use o programa CVAVR

O programador pode ser feito em placa de circuito impresso e colocado no invólucro do conector LPT, conforme mostram as figuras:

Para trabalhar com o programador é conveniente utilizar uma extensão de porta LPT, fácil de fazer você mesmo (por exemplo, de um cabo Centronix para impressora), o principal é não poupar os condutores de aterramento (18- 25 pernas de conector) ou compre. O cabo entre o programador e o chip programável não deve exceder 20-30 cm.

As operações bit a bit são baseadas nas operações lógicas que abordamos anteriormente. Eles desempenham um papel fundamental na programação de AVR e outros tipos de microcontroladores. Quase nenhum programa pode prescindir do uso de operações bit a bit. Antes disso, nós os evitamos deliberadamente para facilitar o processo de aprendizagem da programação MK.

Em todos os artigos anteriores, programamos apenas portas de E/S e não utilizamos componentes adicionais integrados, por exemplo, temporizadores, conversores analógico-digitais, interrupções e outros dispositivos internos sem os quais o MK perde toda a sua potência.

Antes de prosseguir para o domínio dos dispositivos integrados do MK, você precisa aprender como controlar ou verificar bits individuais dos registros do AVR MK. Anteriormente, realizávamos uma verificação ou definimos os dígitos de todo o registro de uma só vez. Vamos descobrir qual é a diferença e depois seguir em frente.

Operações bit a bit

Na maioria das vezes, ao programar microcontroladores AVR, nós o usamos, pois é mais visual em comparação e é bem compreendido por programadores MK novatos. Por exemplo, precisamos definir apenas o 3º bit da porta D. Para fazer isso, como já sabemos, podemos usar o seguinte código binário:

PORTD = 0b00001000;

Porém, com este comando definimos o 3º dígito para um e zeramos todos os outros (0, 1, 2, 4, 5, 6 e 7º). Agora vamos imaginar uma situação onde os 6º e 7º bits são usados ​​como entradas ADC e neste momento um sinal de algum dispositivo é recebido nos pinos MK correspondentes, e usamos o comando acima para resetar esses sinais. Como resultado, o microcontrolador não os vê e acredita que os sinais não chegaram. Portanto, em vez de tal comando, deveríamos usar outro que definiria apenas o 3º bit como um, sem afetar os bits restantes. Para fazer isso, geralmente é usada a seguinte operação bit a bit:

PORTD |= (1<<3);

Discutiremos sua sintaxe em detalhes abaixo. E agora outro exemplo. Digamos que precisamos verificar o estado do terceiro dígito do registro PIND, verificando assim o estado do botão. Se este bit for zerado, sabemos que o botão está pressionado e então o código de comando é executado, que corresponde ao estado do botão pressionado. Anteriormente teríamos usado a seguinte notação:

se (PIND == 0b00000000)

(qualquer código)

Porém, com sua ajuda verificamos não apenas o terceiro bit, mas todos os bits do registro PIND de uma só vez. Portanto, mesmo que o botão seja pressionado e o bit desejado seja zerado, mas neste momento um sinal for recebido em algum outro pino da porta D, o valor correspondente será definido como um e a condição entre parênteses será falsa. Como resultado, o código entre chaves não será executado mesmo quando o botão for pressionado. Portanto, para verificar o estado de um terceiro bit individual do registrador PIND, uma operação bit a bit deve ser usada:

if (~PIND & (1<<3))

(qualquer código)

Para trabalhar com bits individuais do microcontrolador, a linguagem de programação C possui ferramentas que podem ser usadas para alterar ou verificar o estado de um ou mais bits individuais de uma só vez.

Configurando um único bit

Para definir um único bit, como a porta D, uma operação OR bit a bit é usada. Isso é o que usamos no início do artigo.

PORTD = 0b00011100; // valor inicial

PORTD = PORTD | (1<<0); применяем побитовую ИЛИ

PORTD |= (1<<0); // сокращенная форма записи

PORTD == 0b00011101; //resultado

Este comando define o bit zero e deixa o restante inalterado.

Por exemplo, vamos instalar outro 6º bit da porta D.

PORTD = 0b00011100; // estado inicial da porta

PORTD |= (1<<6); //

PORTD == 0b01011100; //resultado

Para escrever um em vários bits separados de uma só vez, por exemplo, as portas zero, sexta e sétima B A seguinte notação se aplica.

PORTB = 0b00011100; // valor inicial

PORTAB |= (1<<0) | (1<<6) | (1<<7); //

PORTB == 0b1011101; //resultado

Redefinindo (zerando) bits individuais

Para redefinir um único bit, três comandos discutidos anteriormente são usados ​​de uma só vez: .

Vamos zerar o 3º bit do registrador PORTC e deixar o restante inalterado.

PORTC = 0b00011100;

PORTC &= ~(1<<3);

PORTC == 0b00010100;

Vamos realizar ações semelhantes para o 2º e 4º dígitos:

PORTC = 0b00111110;

PORTC &= ~((1<<2) | (1<<4));

PORTC == 0b00101010;

Troca de bits

Além de definir e redefinir, também é usado um comando útil que muda um único bit para o estado oposto: um para zero e vice-versa. Esta operação lógica é amplamente utilizada na criação de vários efeitos de iluminação, por exemplo, uma guirlanda de Ano Novo. Vejamos o exemplo do PORTA

PORTA = 0b00011111;

PORTA ^= (1<<2);

PORTA == 0b00011011;

Vamos mudar o estado dos bits zero, segundo e sexto:

PORTA = 0b00011111;

PORTA ^= (1<<0) | (1<<2) | (1<<6);

PORTA == 0b01011010;

Verificando o estado de um bit individual. Deixe-me lembrá-lo de que a verificação (em vez de escrita) de uma porta de E/S é realizada através da leitura de dados do registro PIN.

Na maioria das vezes, o teste é realizado por uma das duas instruções de loop: if e while. Já estamos familiarizados com esses operadores anteriormente.

Verificando o bit quanto à presença de um zero lógico (reset) com se

se (0==(PIND & (1<<3)))

Se o terceiro bit da porta D for limpo, o Code1 será executado. Caso contrário, Code2 será executado.

Ações semelhantes são realizadas com esta forma de gravação:

if (~PIND & (1<<3))

Verificando o bit quanto à presença de uma unidade lógica (configuração) com se

se (0! = (PIND & (1<<3)))

se (PIND & (1<<3))

Os dois loops acima funcionam de forma semelhante, mas podem, devido à flexibilidade da linguagem de programação C, ter uma forma de notação diferente. O operador != significa diferente. Se o terceiro bit da porta PD I/O estiver definido (um), então o Code1 será executado; caso contrário, o Code2 será executado.

Aguardando a reinicialização do bit enquanto

enquanto (PIND & (1<<5))

Code1 será executado enquanto o 5º bit do registro PIND estiver definido. Ao redefini-lo, o Code2 começará a ser executado.

Esperando que o bit seja definido enquanto

Aqui, a sintaxe C permite escrever código de duas das maneiras mais comuns. Na prática, ambos os tipos de gravação são utilizados.

Os microcontroladores (doravante denominados MK) entraram firmemente em nossas vidas, na Internet você pode encontrar muitos circuitos interessantes que são executados no MK. O que você não pode montar em um MK: vários indicadores, voltímetros, eletrodomésticos (dispositivos de proteção, dispositivos de comutação, termômetros...), detectores de metais, brinquedos diversos, robôs, etc. A lista pode demorar muito. Vi o primeiro circuito de um microcontrolador há 5 a 6 anos em uma revista de rádio e quase imediatamente virei a página, pensando comigo mesmo: “Ainda não conseguirei montá-lo”. Na verdade, naquela época os MKs eram um dispositivo muito complexo e incompreendido para mim; eu não tinha ideia de como funcionavam, como atualizá-los e o que fazer com eles em caso de firmware incorreto. Mas há cerca de um ano, montei meu primeiro circuito em um MK; era um circuito de voltímetro digital baseado em indicadores de 7 segmentos e um microcontrolador ATmega8. Acontece que comprei um microcontrolador por acidente, quando estava no departamento de componentes de rádio, o cara na minha frente estava comprando um MK, e também resolvi comprar e tentar montar alguma coisa. Em meus artigos vou falar sobre Microcontroladores AVR, vou te ensinar como trabalhar com eles, veremos programas para firmware, faremos um programador simples e confiável, veremos o processo de firmware e, o mais importante, os problemas que podem surgir não apenas para iniciantes.

Parâmetros básicos de alguns microcontroladores da família AVR:

Microcontrolador	Memória flash	memoria RAM	Memória EEPROM	Portas de E/S	Você poder

Parâmetros adicionais do AVR mega MK:

Temperatura operacional: -55…+125*С
Temperatura de armazenamento: -65…+150*С
Tensão no pino RESET em relação ao GND: máx. 13V
Tensão máxima de alimentação: 6,0V
Corrente máxima da linha de E/S: 40mA
Corrente máxima de alimentação VCC e GND: 200mA

Pinagens do modelo ATmega 8X

Pinagens para modelos ATmega48x, 88x, 168x

Layout de pinos para modelos ATmega8515x

Layout de pinos para modelos ATmega8535x

Layout de pinos para modelos ATmega16, 32x

Layout de pinos para modelos ATtiny2313

Um arquivo com fichas técnicas de alguns microcontroladores está anexado no final do artigo.

Instalação de MK AVR FUSE bits

Lembre-se, um fusível programado é 0, um não programado é 1. Você deve ter cuidado ao configurar os fusíveis, um fusível programado incorretamente pode bloquear o microcontrolador. Se você não tiver certeza de qual fusível precisa programar, é melhor atualizar o MK sem fusíveis pela primeira vez.

Os microcontroladores mais populares entre os rádios amadores são o ATmega8, seguido pelo ATmega48, 16, 32, ATtiny2313 e outros. Os microcontroladores são vendidos em pacotes TQFP e DIP, para iniciantes recomendo comprar em DIP. Se você comprar TQFP, será mais problemático atualizá-los; você terá que comprar ou soldar a placa porque suas pernas estão localizadas muito próximas uma da outra. Aconselho você a instalar microcontroladores em pacotes DIP em soquetes especiais, é conveniente e prático, você não precisa dessoldar o MK se quiser reflashá-lo, ou utilizá-lo para outro projeto.

Quase todos os MKs modernos têm a capacidade de programação ISP no circuito, ou seja, Se o seu microcontrolador estiver soldado à placa, para alterar o firmware não precisaremos dessoldá-lo da placa.

6 pinos são usados ​​para programação:
REINICIAR- Entrar MK
CCV- Mais fonte de alimentação, 3-5V, depende do MK
GND- Fio comum, menos potência.
MOSI- Entrada MK (sinal de informação em MK)
MISSÔ- Saída MK (sinal de informação do MK)
SCK- Entrada MK (sinal de clock em MK)

Às vezes eles também usam os pinos XTAL 1 e XTAL2; o quartzo é anexado a esses pinos se o MK for alimentado por um oscilador externo; no ATmega 64 e 128, os pinos MOSI e MISO não são usados ​​para programação ISP; em vez disso, os pinos MOSI são conectado ao pino PE0 e MISO ao pino PE1. Ao conectar o microcontrolador ao programador, os fios de conexão devem ser tão curtos quanto possível, e o cabo que vai do programador à porta LPT também não deve ser muito longo.

A marcação do microcontrolador pode conter letras estranhas com números, por exemplo Atmega 8L 16PU, 8 16AU, 8A PU, etc. A letra L significa que o MK opera em uma tensão menor que o MK sem a letra L, geralmente 2,7V. Os números após o hífen ou espaço 16PU ou 8AU indicam a frequência interna do gerador que está no MK. Se os fusíveis forem configurados para operar a partir de um quartzo externo, o quartzo deverá ser ajustado para uma frequência que não exceda o máximo de acordo com a folha de dados, que é 20 MHz para ATmega48/88/168 e 16 MHz para outros atmegas.