LED piscando com microcontrolador PIC

Em nossos dois tutoriais anteriores, discutimos Como começar a usar o PIC usando o compilador MPLABX e XC8, também fizemos nosso primeiro programa de piscar de LED com PIC e o verificamos por simulação. Agora é hora de colocarmos nossas mãos no hardware. Neste tutorial iremos construir um pequeno circuito em uma placa PCB Universal para piscar o LED usando o PIC. Vamos descarregar o programa em nosso microcontrolador PIC e verificar o LED piscando. Para programar o PIC MCU, usaremos MPLAB IPE.

Materiais requisitados:

Conforme discutido em nosso tutorial anterior, precisaremos dos seguintes materiais:

• PicKit 3
• PIC16F877A IC
• 40 – Suporte para IC
• Placa PCB Universal
• 20 MHz Crystal OSC
• Fios para ligação
• Capacitor 33pf – 2x, 100uf e 10uf cap.
• Resistor de 680 ohm, 10K e 560 ohm
• LED de qualquer cor
• 1 Kit de soldagem
• IC 7805
• Adaptador de 12V

O que acontece quando “BURN” um microcontrolador !!

É uma prática comum carregar o código em um MCU e fazê-lo funcionar dentro do MCU.

Mas o que realmente acontece dentro do MCU, como algumas linhas do Programa C entram em um chip de silício e são executadas?

Em, para entender isso, vamos dar uma olhada em nosso programa

Como podemos ver, este código é escrito em linguagem C e não fará sentido para o nosso MCU. É aqui que entra a parte do nosso compilador; um compilador é aquele que converte este código em um formato legível por máquina. Esta forma legível por máquina é chamada de código HEX, cada projeto que criarmos terá um código HEX que estará no seguinte diretório

**Sua localização**\Blink\Blink.X\dist\default\production\Blink.X.production.hex

Se você está tão interessado em saber como é este código HEX, basta abri-lo usando o bloco de notas. Para nosso programa Blink, o código HEX será semelhante ao seguinte:

:060000000A128A11FC2F18
:100FAA008316031386018312031386018312031324
:100FBA0086150D30F200AF30F100C130F000F00BB1
:100FCA00E42FF10BE42FF20BE42F0000831203133A
:100FDA0086110D30F200AF30F100C130F000F00B95
:100FEA00F42FF10BF42FF20BF42F0000DB2F830107
:060FFA000A128A11D52F36
:02400E007A3FF7
:00000001FF

Existem maneiras de ler isso e como entendê-lo e revertê-lo para a linguagem Assembly, mas está completamente fora do escopo deste tutorial. Então, simplesmente resumindo; o HEX é o resultado final do software de nossa codificação e é isso que será enviado pelo MPLAB IPE para queimar o MCU.

Memória flash:

O código HEX é armazenado no MCU em um local chamado memória Flash. A memória flash é o local onde nosso programa será armazenado dentro do MCU e executado a partir daí. Depois de compilar o programa em nosso MPLABX, teríamos as seguintes informações sobre o tipo de memória no console de saída

Como acabamos de compilar um pequeno programa de LED piscando, o resumo da memória mostra que consumimos apenas 0,5% do espaço disponível para o programa e 1,4% do espaço para dados.

A memória do microcontrolador PIC16F877 é basicamente dividida em 3 tipos:

Memória de programa: Esta memória contém o programa (que escrevemos), depois de o termos queimado. Como um lembrete, Program Counter executa comandos armazenados na memória do programa, um após o outro. Como escrevemos um programa muito pequeno, consumimos apenas 0,5% do espaço total. Esta é uma memória não volátil, significa que os dados armazenados não serão perdidos após o desligamento.

Memória de dados: Este é o tipo de memória RAM, que contém registros especiais como SFR (Registro de função especial) que inclui o temporizador Watchdog, Brown out Reset etc. e GPR (Registro de propósito geral) que inclui TRIS e PORT etc. As variáveis ​​que são armazenadas na memória de dados durante o programa são excluídos após desligarmos o MCU. Qualquer variável declarada no programa ficará dentro da memória de dados. Esta também é uma memória volátil.

EEPROM de dados (memória somente leitura programável apagável eletricamente): Uma memória que permite armazenar as variáveis ​​como resultado da gravação do programa escrito. Por exemplo, se atribuirmos uma variável “a” para salvar um valor de 5 nela e armazená-lo na EEPROM, esses dados não serão perdidos mesmo se a energia for desligada. Esta é uma memória não volátil.

Memória de programa e EEPROM são memórias não voláteis e são chamadas de memória flash ou EEPROM.

ICSP (Programação serial em circuito):

Estaremos programando nosso PIC16F877A usando a opção ICSP que está disponível em nosso MCU.

Agora, o que é ICSP?

ICSP é uma maneira simples que nos ajuda a programar uma MCU, mesmo depois de colocada dentro de nosso painel de projeto. Não há necessidade de ter uma placa de programador separada para programar o MCU, tudo o que precisamos é de 6 conexões do programador PicKit3 para nossa placa da seguinte forma:

ICSP é adequado para todos os pacotes PIC; tudo o que precisamos é retirar esses cinco pinos (6º pino PGM é opcional) do MCU para o Pickit3 como mostrado na imagem abaixo.

Circuito e Hardware:

Agora, temos nosso código HEX pronto e também sabemos como conectar nosso PicKit 3 ao nosso PIC MCU usando ICSP. Então, vamos soldar o circuito com a ajuda dos esquemas abaixo:

No circuito acima, usei um 7805 para regular a saída de 5 V para meu PIC MCU. Este regulador será alimentado por um adaptador de 12V. O Led VERMELHO é usado para indicar se o PIC está energizado. O conector J1 é usado para programação ICSP. Os pinos são conectados conforme discutido na tabela acima.

O primeiro pino MCLR deve ser mantido alto com a ajuda de um 10k por padrão. Isso evitará que o MCU seja reiniciado. Para reinicializar o MCU, o pino MCLR deve ser aterrado, o que pode ser feito com a ajuda da chave SW1.

O LED é conectado ao pino RB3 através de um resistor de valor 560 ohms. Se tudo estiver correto assim que nosso programa for carregado, este LED deve piscar com base no programa. Todo o circuito é construído na Placa PCB Universal soldando todos os componentes nele, como você pode ver na imagem no topo.

Queimando o código usando MPLAB IPE:

Para gravar o código, siga as etapas abaixo:

1. Inicie o MPLAB IPE.
2. Conecte uma extremidade do PicKit 3 ao PC e a outra extremidade aos pinos ICSP na placa de desempenho.
3. Conecte-se ao seu dispositivo PIC clicando no botão conectar.
4. Procure o arquivo Blink HEX e clique em Programa.

Se tudo correr conforme o planejado, a mensagem de sucesso deverá aparecer na tela. Verifique o código e o vídeo abaixo para uma demonstração completa e use a seção de comentários se tiver alguma dúvida.

Obrigado!!!

Vamos nos encontrar no próximo tutorial, onde brincaremos com mais LEDs e um switch.

Código

// 'C' declarações de configuração da linha de origem

// CONFIG
#pragma config FOSC = HS    // Bits de seleção do oscilador (oscilador HS)
#pragma config WDTE = OFF   // Bit de ativação do temporizador de watchdog (WDT desativado)
#pragma config PWRTE = OFF  // Bit de ativação do temporizador de inicialização (PWRT desativado)
#pragma config BOREN = ON   // Bit de habilitação de redefinição de Brown-out (BOR habilitado)
#pragma config LVP = OFF    // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 é digital I / O, HV em MCLR deve ser usado para programação)
#pragma config CPD = OFF    // Bit de proteção de código de memória EEPROM de dados (proteção de código EEPROM de dados desativada)
#pragma config WRT = OFF    // Bits de habilitação de gravação da memória do programa Flash (proteção contra gravação desligada; toda a memória do programa pode ser gravada pelo controle EECON)
#pragma config CP = OFF     // Bit de proteção de código de memória de programa Flash (proteção de código desativada)

// #pragma config declarações devem preceder inclusões de arquivo de projeto.
// Use enums do projeto em vez de #define para ON e OFF.

#include <xc.h>
#define _XTAL_FREQ 20000000 // Especifique o FREQ de cristal XTAL

void main() // A função principal
{
   TRISB=0X00; //Instrua o MCU que os pinos PORTB são usados como saída.
   PORTB=0X00; //Faça todas as saídas de RB3 LOW

   while(1) //Entre no loop infinito While
   {
      RB3=1; //LED ON
      __delay_ms(100); //Espere
      RB3=0; //LED OFF
      __delay_ms(100); //Espere
     
      //Repete
    }
}