sexta-feira, 22 de julho de 2016

Biblioteca para o módulo LCD 16 x 2


   Esta biblioteca foi obtida a partir do livro "MICROCONTROLADORES PIC18 - APRENDA E PROGRAME EM LINGUAGEM C" do autor ALBERTO NOBORU MIYADAIRA, indicado na área de bibliografia.

   O arquivo original estava preparado para um microcontrolador rodando a 20MHz e para ser compilado com o compilador C18 da Microchip (antecessor do XC8). 
   Foram feitas alterações para o clock de 48MHz que é o utilizado nas aplicações com bootloader em função da comunicação USB.
    Foram necessárias mais alterações para compilar com a biblioteca xc.h e dessa forma desvincular da biblioteca delays.h pertencente a PLIB

   Utilize um editor simples como bloco de notas e grave o conteúdo abaixo em uma arquivo com o nome "biblioteca_lcd_2x162_48M_XC.h" por exemplo.



Arquivo da biblioteca de LCD 16 x 2

  

/*********************************************************************************************************
******************************************BIBLIOTECA DISPLAY LCD******************************************
**                                                                                                       *
**                    Esta biblioteca contém as funções de controle do display LCD.                      *
**                                                                                                       *    
**  Livro: Microcontroladores PIC18 - Aprenda e Programe em Linguagem C.                                 *           
**  Autor: Alberto Noboru Miyadaira                                                                      *
**  Versão: v0.1 *
**  Data: 12/03/2011 *
**  Modificação: Junho/2016 - Ajuste para clock de 48MHz *
**  Modificação: Março/2017 - Ajuste para compilar com biblioteca xc.h (exclui plib/delays.h) *
**                            Exclusão das linhas antigas em comentário *     *
*********************************************************************************************************/

// Necessário incluir as seguintes linhas antes de carregar a biblioteca de LCD
// #define _XTAL_FREQ 48000000
// #include <xc.h>

// Os nome definidos são os próprios nomes dos pinos do display LCD.
#define B7 PORTDbits.RD2 //Define o nome B7 para a estrutra.
#define E_B7 TRISDbits.TRISD2=1;
#define S_B7 TRISDbits.TRISD2=0;
#define B6 PORTDbits.RD4 //Define o nome B6 para a estrutra.
#define E_B6 TRISDbits.TRISD4=1;
#define S_B6 TRISDbits.TRISD4=0;
#define B5 PORTDbits.RD5 //Define o nome B5 para a estrutra.
#define E_B5 TRISDbits.TRISD5=1;
#define S_B5 TRISDbits.TRISD5=0;
#define B4 PORTDbits.RD6 //Define o nome B4 para a estrutra.
#define E_B4 TRISDbits.TRISD6=1;
#define S_B4 TRISDbits.TRISD6=0;
#define E  PORTDbits.RD7  //Define o nome E para a estrutra.
#define E_E TRISDbits.TRISD7=1;
#define S_E TRISDbits.TRISD7=0;
#define RW PORTDbits.RD1//Define o nome RW para a estrutra.
#define E_RW TRISDbits.TRISD1=1;
#define S_RW TRISDbits.TRISD1=0;
#define RS PORTDbits.RD0 //Define o nome RS para a estrutra.
#define E_RS TRISDbits.TRISD0=1;
#define S_RS TRISDbits.TRISD0=0;

void gera_atraso_us(unsigned int atraso)//adaptado para Fosc de 48MHz
{
  do 
  {
      __delay_us(1); // Gera um atarso de 1us
    atraso--;
  }while (atraso>0);
}

unsigned char lcd_envia_controle (unsigned char instrucao_dado, unsigned int escrita_leitura, unsigned char dado, unsigned int atraso_us)
{
/*
instrucao_dado = 0 //Instrução.
instrucao_dado = 1 //Dado.
escrita_leitura = 1 //Leitura.
escrita_leitura = 0 //Escrita.
*/
unsigned char dado_entrada=0;

//Configura os pinos de dados/controle, como saída.
S_B7;
S_B6;
S_B5;
S_B4;
S_E;
S_RW;
S_RS;

RS = instrucao_dado; //Informa se é um comando ou dado.
RW = escrita_leitura; //Informa se é escrita ou leitura.

        if(escrita_leitura == 0)
        {
                B7 = dado>>7;//B7 recebe o bit 7 da variável dado.
                B6 = dado>>6;//B6 recebe o bit 6 da variável dado.
                B5 = dado>>5;//B5 recebe o bit 5 da variável dado.
                B4 = dado>>4;//B4 recebe o bit 4 da variável dado.
                
                E = 1;//Habilita o Display LCD.
                gera_atraso_us(2); //Gera um delay de 2us.
                E = 0; //Desabilita o Display LCD.
                
                B7 = dado>>3;//B7 recebe o bit 3 da variável dado.
                B6 = dado>>2;//B6 recebe o bit 2 da variável dado.
                B5 = dado>>1;//B5 recebe o bit 1 da variável dado.
                B4 = dado;//B4 recebe o bit 0 da variável dado.
                        
                E = 1;//Habilita o Display LCD.
                gera_atraso_us(2); //Gera um delay de 2us.
                E = 0; //Desabilita o Display LCD.
                
                gera_atraso_us(atraso_us); //Gera um delay de xus. MAX 255 ciclos de máquina
                
                return 0;
        }
        else
        {
                //Configura os pinos de dados, como entrada.
                E_B7;
                E_B6;
                E_B5;
                E_B4;
                
                E = 1;//Habilita o Display LCD.
          gera_atraso_us(2); //Gera um delay de 2us.
        
                dado_entrada = B7;
                dado_entrada = dado_entrada<<1 | B6;
                dado_entrada = dado_entrada<<1 | B5;
                dado_entrada = dado_entrada<<1 | B4;    
                
                E = 0; //Desabilita o Display LCD.
                E = 1;//Habilita o Display LCD.
                gera_atraso_us(2); //Gera um delay de 2us.
                
                dado_entrada = dado_entrada<<1 | B7;
                dado_entrada = dado_entrada<<1 | B6;
                dado_entrada = dado_entrada<<1 | B5;
                dado_entrada = dado_entrada<<1 | B4;
                        
                E = 0; //Desabilita o Display LCD.
                
                gera_atraso_us(atraso_us); //Gera um delay de xus. MAX 255 ciclos de máquina
                
                return dado_entrada;
        }
}

//Limpa a tela e coloca o cursor na linha um e coluna um do display.
void lcd_limpa_tela ( )
{
        lcd_envia_controle (0,0,0x01,2000);
}

//Coloca o cursor na linha um e coluna um do display.
void lcd_cursor_home ( )
{
        lcd_envia_controle (0,0,0x02,2000);
}

//Desloca o cursor para a direita ou esquerda.
void lcd_desloca_cursor(unsigned char direita_esquerda)
{
/*
0 - Desloca o cursor para a direita.
1 - Desloca o cursor para a esquerda.
*/
unsigned char cursor[2] = {0x14, 0x10}; 
        lcd_envia_controle (0,0,cursor[direita_esquerda],40);
}

//Desloca a mensagem para a direita ou esquerda.
void lcd_desloca_mensagem(unsigned char direita_esquerda)
{
/*
0 - Desloca a mensagem para a direita.
1 - Desloca a mensagem para a esquerda.
*/
unsigned char cursor[2] = {0x1c, 0x18};
        lcd_envia_controle (0,0,cursor[direita_esquerda],40);
}

//Liga/Desliga o cursor/display.
void lcd_LD_cursor (unsigned char config)
{
/*
0 - Desliga o cursor.
1 - Desliga o display.
2 - Liga o cursor com alternância.
3 - Liga o display e o cursor.
4 - Liga o display e o cursor piscante.
*/
unsigned char cursor [5] = {0x0c, 0x08, 0x0f, 0x0e, 0x0d}; 
        lcd_envia_controle (0,0,cursor[config],40);
}

//Coloca o cursor em uma determinada posição do LCD.
void lcd_posicao(unsigned char linha, unsigned char coluna)
{
        switch (linha)
        {
                case 1:
                        lcd_envia_controle (0,0,0x80+coluna-1,40);
                        break;
                case 2:
                        lcd_envia_controle (0,0,0xc0+coluna-1,40);
                        break;
                case 3:
                        lcd_envia_controle (0,0,0x94+coluna-1,40);
                        break;
                case 4:
                        lcd_envia_controle (0,0,0xd4+coluna-1,40);
                        break;
        }       
}

//Escreve um caractere ou símbolo no display.
void lcd_escreve_dado(unsigned char dado)
{
        lcd_envia_controle (1,0,dado,45);
}

//Retorna o caractere presente na posição do cursor.
unsigned char lcd_le_dado( )
{
        return lcd_envia_controle (1,1,0,45);
}

//Retorna o valor do status + contador de endereço.
unsigned char lcd_status ( )
{
        return lcd_envia_controle (0,1,0,40);
}

//Envia String para o Display LCD.
void imprime_string_lcd(const char *s_caracteres)
{
        while (*s_caracteres!=0)
        {
                lcd_escreve_dado(*s_caracteres);
                s_caracteres++;
        }
}

//Envia uma matriz de dados para o Display LCD.
void imprime_buffer_lcd( char *s_caracteres, unsigned char tamanho_buffer)
{
        while (tamanho_buffer--)
        {
                lcd_escreve_dado(*s_caracteres);
                s_caracteres++;
        }
}

//Inicializa o display LCD alfanumérico.
void lcd_inicia( unsigned char conf1, unsigned char conf2, unsigned char conf3)
{
/*
Configuração do display LCD:

(0x28)
- Comunicação 4 vias
- Display com 2 linhas
- Matriz 8x5

(0x0f)
- Liga display
- Cursor piscante

(0x06)
- Desloca o cursor para a direita quando um caractere for inserido.
*/
unsigned char config_LCD[6] = {0x03, 0x02, 0x00, 0x00, 0x00};
unsigned char repeticao;

config_LCD[2] = conf1;
config_LCD[3] = conf2;
config_LCD[4] = conf3;

//Configura os pinos de dados/controle, como saída.
S_B7;
S_B6;
S_B5;
S_B4;
S_E;
S_RW;
S_RS;
        
RS = 0; //Instrução.
RW = 0; //Escrita.
E = 0; //Desabilita LCD.

        gera_atraso_us(20000); //Gera um atraso de 20ms. 

        for( repeticao = 0 ; repeticao < 3 ; repeticao++ )
        {
                B7 = config_LCD[0]>>3; //B7 recebe o bit 3 do elemento presente na posição 0 da matriz config_LCD.
                B6 = config_LCD[0]>>2; //B6 recebe o bit 2 do elemento presente na posição 0 da matriz config_LCD.
                B5 = config_LCD[0]>>1; //B5 recebe o bit 1 do elemento presente na posição 0 da matriz config_LCD.
                B4 = config_LCD[0];    //B4 recebe o bit 0 do elemento presente na posição 0 da matriz config_LCD.
                
                E = 1;//Habilita o Display LCD.
                gera_atraso_us(2); //Gera um delay de 2us.
                E = 0; //Desabilita o Display LCD.
                
                gera_atraso_us(5000); //Gera um delay de 5ms.
        }

B7 = config_LCD[1]>>3; //B7 recebe o bit 3 do elemento presente na posição 1 da matriz config_LCD.
B6 = config_LCD[1]>>2; //B6 recebe o bit 2 do elemento presente na posição 1 da matriz config_LCD.
B5 = config_LCD[1]>>1; //B5 recebe o bit 1 do elemento presente na posição 1 da matriz config_LCD.
B4 = config_LCD[1];    //B4 recebe o bit 0 do elemento presente na posição 1 da matriz config_LCD.
        
E = 1;//Habilita o Display LCD.
gera_atraso_us(2); //Gera um delay de 2us.
E = 0; //Desabilita o Display LCD.

gera_atraso_us(40); //Gera um delay de 40us.

lcd_envia_controle (0,0,config_LCD[2],40);
lcd_envia_controle (0,0,config_LCD[3],40);
lcd_envia_controle (0,0,config_LCD[4],40);

lcd_limpa_tela ( );

}


Fim do arquivo da biblioteca de LCD 16 x 2

  

Bibliografia

Alguns livros:

Datasheet:







   


sábado, 14 de junho de 2014

GRAVANDO PROGRAMAS NO MICROCONTROLADOR COM BOOTLOADER



Com a placa desligada, coloque os jumpers J1, J2, J3, J4 e J5 (chaves H) na posição 1-2 (Boot).
Conecte o cabo USB do circuito no PC. Pressione o botão BOOTLOADER, que esta ligado ao PORTB<4> (pino37) do PIC e, em seguida, pressione e solte o botão RESET. Quando os dois LEDs começarem a piscar alternadamente, solte o botão BOOTLOADER e o bootloader estará pronto para receber programas pela porta USB. Para gravar o programa, use a aplicação PDFSUSB.exe seguindo os passos abaixo:




1) Execute o programa PDFSUSB.exe e na janela dessa aplicação, clique o botão Load HEX File para abrir a janela de seleção de arquivos.


2) Escolha o programa que deseja gravar no microcontrolador. O programa deve ter a extenção .hex.


3) Na janela de configuração que aparecer, escolha a opção "Não". Essa opção deve ser sempre selecionada pois ela não permitirá que os bits de configuração sejam regravados pelo seu programa. Se a opção Sim for escolhida, o bootloader vai deixar de funcionar e não será possível, da próxima vez, gravar o programa via bootloader. Nesse caso, o bootloader deverá ser regravado com um programador de porta serial ou outro qualquer.


4) O programa em formato hexa decimal será carregado e mostrado na parte inferior da janela.
Se o endereço inicial do programa não for "000800" você cometeu algum erro nas modificações do projeto. Reveja suas configurações.



5) Abra a lista Select PICDEM FS USB Board e selecione o dispositivo ativo na porta USB, relativo ao circuito que iremos gravar, indicado pela seta 1.



6)  Após selecionar o dispositivo USB, clique no botão Program Device, indicado pela seta 2 para iniciar a gravação do programa. Quem esta acostumado a usar programadores de porta serial vai notar que, com o bootloader, o programa é transferido para o microcontrolador a uma velocidade muito alta.


7) Quando a gravação terminar, confira as mensagens que aparecem na janela de mensagens. Se tudo correu bem, então pode iniciar a execução do programa no microcontrolador. 

  • Para isso desligue a energia da placa C
  • Coloque os jumpers J1, J2, J3, J4 e J5 (chaves H) na posição 2-3 (troque as chaves).
  • Alimente a placa que o programa carregado deve começar a ser executado.
  • Em algumas situações se o programa carrgeado não iniciar, pressionone o botão RESET do circuito.


Observação importante: O arquivo HEX deve ser compilado para iniciar em 0x800.
Veja o post "Compilando arquivos para uso com bootloader"




   

INSTALAÇÃO DO PROGRAMA DE COMUNICAÇÃO

INSTALAÇÃO DO PROGRAMA DE COMUNICAÇÃO: 

 PIC-DEM(TM) FS Demo Tool Version 1.00

Você pode baixar o programa aqui:

Acesse o arquivo do programa de instalação.



Inicie a instalação do programa


   


  


O programa pode ser acessado pelo link criado pelo programa de instalação. Para facilitar crie um atalho dele na sua área de trabalho.


O programa é instalado na pasta C:\MCHPFSUSB\Pc\Pdfusb\




Estabelecendo a comunicação

  • Conecte o cabo USB no PC. A princípio nada vai acontecer.
  • Pressione o botão BOOT, que esta ligado ao PORTB<4> (chave pull-up no pino37) do PIC e, em seguida, pressione e solte o botão RESET (chave pull-up no pino1).
  • Quando os dois LEDs começarem a piscar alternadamente, solte o botão BOOT e o bootloader estará pronto para receber programas pela porta USB.
  • Na primeira vez que esse procedimento for realizado no computador , o sistema operacional vai dizer que um novo hardware foi detectado e é necessário instalar um driver para o dispositivo USB.


Instalando o driver do para o dispositivo


O driver encontra-se na pasta C:\MCHPFSUSB\Pc\MCHPUSB Driver\Release




Abra o Gerenciador de dispositivos, você encontrará um "Dispositivo desconhecido"



Clique com o botão direito do mouse sobre o "Dispositivo desconhecido" e escolha "Atualizar Driver..."



Siga as telas abaixo


 


 



Se, se tudo correr bem, no Windows nunca se sabe, o driver será instalado.
Após o Driver instalado os Leds ligados em RD0 e RD1 (pinos 19 e 20 respectivamente) começam a piscar alternadamente.




   

Bootloader

Obs.: O desenvolvimento deste post praticamente igual (com alguns ajustes) ao do site http://www.hpspin.com.br/site1/bootloader/

Agradecimentos ao ex-aluno Mirayr Raul que ajudou no desmitificar o funcionamento do bootloader.

USB E BOOTLOADER

   Alguns microcontroladores da família 18F como o PIC18F4550 possuem porta de comunicação USB para facilitar a comunincação entre o PC e o microcontrolador. Uma das opções é usar a porta USB para gravar o programa no microcontrolador usando um bootloader, programa que fica residente no próprio microcontrolador e permite que o programa de aplicação seja gravado sem a necessidade de um programador.
   A Microchip fornece um framework com vários exemplos que permitem desenvolver aplicações em seus microcontroladores usando a porta USB. Nesta experiência, usaremos somente alguns arquivos mas, quem quiser, poderá baixar todo o diretório contendo o framework. Infelizmente não posso fornecer o link para o framework porque a estrutura de páginas da Microchip muda constantemente.

O QUE É O BOOTLOADER

   O bootloader é um programa que será gravado no microcontrolador, uma única vez, por um programador comum, como um McFlash, um JDM ou através do ICSP. A partir daí, o programador não será mais necessário, pois bastará conectar o microcontrolador na porta USB e transferir o programa de aplicação para o microcontrolador quantas vezes forem necessárias, sem que seja necessário remover o chip do circuito e numa velocidade muito mais alta do que a velocidade alcançada pelos programadores comuns.






   O programa de bootloader permite a comunicação entre o computador e a flash do PIC sem a necessidade de um gravador, com ele é possível ler, apagar e gravar novos dados na memória flash do microcontrolador.
   É importante salientar que desta forma teremos sempre o programa bootloader em "background" ao programa desenvolvido, e com isso algumas configurações não são possíveis de alterar.
   Esta é uma solução econômica, destinada ao estudo e desenvolvimento.
   Para aplicações profissionais é indicado a aquisição de um gravador, ou a construção de um (existem na WEB alguns tutoriais orientando a contrução de gravadores free.

PROGRAMA NECESSÁRIO PARA COMUNICAÇÃO USB



   

sexta-feira, 13 de junho de 2014

Biblioteca de incialização - config_PIC18F4550.h

   Existem alguns parâmetros que é necessário setar em cada projeto.
   A fim de simplificar, e não ter que digitar ou copiar a cada projeto novo, podemos incluir esses parâmetros em um aquivo de biblioteca ".h"

Para criar o arquivo de configuração

  1. Abra um editor de textos qualquer (bloco de notas, por exemplo), 
  2. Copie o conteúdo mostrado abaixo entre as barras horizontais e cole no arquivo
  3. Salve o arquivo com o nome "Config_PIC18F4550.H", lembre-se que a extensão do arquivo deve ser ".H" 



Arquivo de configuração para as praticas com o PIC18F4550
  
// PIC18F4550 Configuration Bit Settings
// 'C' source line config statements
// Cristal 20MHz / 5 = 4MHz
// PLL interno com entrada de 4MHz => 96MHz
// PLL interno /2 => 48MHz
// Fosc = 48MHz
// Tciclo = 4/Fosc = 1/12MHz = 83,333ns

// CONFIG1L
#pragma config PLLDIV = 5       // PLL Prescaler Selection bits (Divide by 5 (20 MHz oscillator input))
#pragma config CPUDIV = OSC1_PLL2// System Clock Postscaler Selection bits ([Primary Oscillator Src: /1][96 MHz PLL Src: /2])
#pragma config USBDIV = 2       // USB Clock Selection bit (used in Full-Speed USB mode only; UCFG:FSEN = 1) (USB clock source comes from the 96 MHz PLL divided by 2)

// CONFIG1H
#pragma config FOSC = HS        // Oscillator Selection bits (HS oscillator (HS))
#pragma config FCMEN = OFF      // Fail-Safe Clock Monitor Enable bit (Fail-Safe Clock Monitor disabled)
#pragma config IESO = OFF       // Internal/External Oscillator Switchover bit (Oscillator Switchover mode disabled)

// CONFIG2L
#pragma config PWRT = ON        // Power-up Timer Enable bit (PWRT enabled)
#pragma config BOR = ON         // Brown-out Reset Enable bits (Brown-out Reset enabled in hardware only (SBOREN is disabled))
#pragma config BORV = 2         // Brown-out Reset Voltage bits (Setting 1 2.79V)
#pragma config VREGEN = ON      // USB Voltage Regulator Enable bit (USB voltage regulator enabled)

// CONFIG2H
#pragma config WDT = OFF        // Watchdog Timer Enable bit (WDT disabled (control is placed on the SWDTEN bit))
#pragma config WDTPS = 32768    // Watchdog Timer Postscale Select bits (1:32768)

// CONFIG3H
#pragma config CCP2MX = ON      // CCP2 MUX bit (CCP2 input/output is multiplexed with RC1)
#pragma config PBADEN = OFF     // PORTB A/D Enable bit (PORTB<4:0> pins are configured as digital I/O on Reset)
#pragma config LPT1OSC = OFF    // Low-Power Timer 1 Oscillator Enable bit (Timer1 configured for higher power operation)
#pragma config MCLRE = ON       // MCLR Pin Enable bit (MCLR pin enabled; RE3 input pin disabled)

// CONFIG4L
#pragma config STVREN = ON      // Stack Full/Underflow Reset Enable bit (Stack full/underflow will cause Reset)
#pragma config LVP = OFF        // Single-Supply ICSP Enable bit (Single-Supply ICSP disabled)
#pragma config ICPRT = OFF      // Dedicated In-Circuit Debug/Programming Port (ICPORT) Enable bit (ICPORT disabled)
#pragma config XINST = OFF      // Extended Instruction Set Enable bit (Instruction set extension and Indexed Addressing mode disabled (Legacy mode))

// CONFIG5L
#pragma config CP0 = OFF        // Code Protection bit (Block 0 (000800-001FFFh) is not code-protected)
#pragma config CP1 = OFF        // Code Protection bit (Block 1 (002000-003FFFh) is not code-protected)
#pragma config CP2 = OFF        // Code Protection bit (Block 2 (004000-005FFFh) is not code-protected)
#pragma config CP3 = OFF        // Code Protection bit (Block 3 (006000-007FFFh) is not code-protected)

// CONFIG5H
#pragma config CPB = OFF        // Boot Block Code Protection bit (Boot block (000000-0007FFh) is not code-protected)
#pragma config CPD = OFF        // Data EEPROM Code Protection bit (Data EEPROM is not code-protected)

// CONFIG6L
#pragma config WRT0 = OFF       // Write Protection bit (Block 0 (000800-001FFFh) is not write-protected)
#pragma config WRT1 = OFF       // Write Protection bit (Block 1 (002000-003FFFh) is not write-protected)
#pragma config WRT2 = OFF       // Write Protection bit (Block 2 (004000-005FFFh) is not write-protected)
#pragma config WRT3 = OFF       // Write Protection bit (Block 3 (006000-007FFFh) is not write-protected)

// CONFIG6H
#pragma config WRTC = OFF       // Configuration Register Write Protection bit (Configuration registers (300000-3000FFh) are not write-protected)
#pragma config WRTB = OFF       // Boot Block Write Protection bit (Boot block (000000-0007FFh) is not write-protected)
#pragma config WRTD = OFF       // Data EEPROM Write Protection bit (Data EEPROM is not write-protected)

// CONFIG7L
#pragma config EBTR0 = OFF      // Table Read Protection bit (Block 0 (000800-001FFFh) is not protected from table reads executed in other blocks)
#pragma config EBTR1 = OFF      // Table Read Protection bit (Block 1 (002000-003FFFh) is not protected from table reads executed in other blocks)
#pragma config EBTR2 = OFF      // Table Read Protection bit (Block 2 (004000-005FFFh) is not protected from table reads executed in other blocks)
#pragma config EBTR3 = OFF      // Table Read Protection bit (Block 3 (006000-007FFFh) is not protected from table reads executed in other blocks)

// CONFIG7H
#pragma config EBTRB = OFF      // Boot Block Table Read Protection bit (Boot block (000000-0007FFh) is not protected from table reads executed in other blocks)

// #pragma config statements should precede project file includes.
// Use project enums instead of #define for ON and OFF.

//#include <xc.h>



Fim do arquivo de configuração  para as praticas com o PIC18F4550

  

Esta configuração pode ser obtida dentro do MPLABX
   Menu: "Windows\Pic Memory Views\Configuration Bits"



  O arquivo gerado abaixo aparentemente é o que se aproxima do que existe dentro do bootloader, sendo necessário para a simulação, uma vez que na execução o software criado roda "sob o bootloader"





   

MPLAB X IDE – Criando um projeto


Este tutorial tem por objetivo criar um projeto novo no MPLAB X IDE para um microcontrolador PIC18F4550


================================================

Abrindo a interface do MPLAB X IDE temos:


Nela temos a página inicial que nos disponibiliza links para várias fontes de consulta sejam elas por arquivos instalados junto ao ambiente ou informações on-line na web.

Criando um projeto



Inicie o assistente (wizard), que pode ser acessado pelo botão “New Projetc”, ou pelo menu File/New project.

  

1)      Escolhendo o Projeto

  •         Em “Categories” selecione “Microchip Embedded”
  •         Em “Projets” selecione “Standalone Project”
  •         Clique no botão “Next” para a próxima etapa


2)      Seleção do dispositivo

  •         No campo “Family”, selecione “Advanced 8-bit MCUs (PIC18)
  •         No campo “Device”, selecione “PIC18F4550”
  •         Clique no botão “Next” para a próxima etapa


3)      Seleção da ferramenta
Como a transferência do programa usaremos o Bootloader não importa a ferramenta a ser selecionada. Se desejar utilizar os recursos de simulação, escolha “Simulator”. Clique no botão “Next” para a próxima etapa.


4)      Seleção do compilador

  •          Selecione o XC8 para indicar que o programa é escrito em linguagem C.
  •         Clique no botão “Next” para a próxima etapa


5)      Nome do projeto e local de armazenamento

  •          Em “Project Name”, digite um nome relacionado com o objetivo do projeto (o que ele faz). Não utilize espaços, pontos, caracteres acentuados.
  •         Em “Project Location” indique a pasta onde estarão armazenados os seus projetos. No exemplo abaixo note que foi criada uma pasta “PIC18” no “Drive C” e nesta pasta foi criada uma pasta “Projetos”. Procure simplificar para você facilmente encontrar o projeto e seus arquivos.
  •         Clique no botão “Finish” para encerrar o assistente.


   Se você seguiu os passos terá janela abaixo.


    Agora é hora de você criar um arquivo para você digitar o seu código em linguagem C.

  • ·        Clique em “Source Files” com o botão direito do mouse e selecione “C Main File...”


  • Nome e local de armazenamento
  • Na janela que se abre digite um nome para o projeto que tenha relação com o objetivo do projeto. Aqui valem as mesmas regras mencionadas anteriormente quanto ao nome do projeto evitando espaços, pontos ou caracteres acentuados.
  • Clique no botão “Finish” para criar o arquivo.



Ao finalizar você terá um arquivo para digitar o código em linguagem C com:
  •         Um cabeçalho de comentário indicando o nome do projeto, o Autor (nome do usuário da máquina) e a data de criação do arquivo.
  •         Duas linhas de include com bibliotecas padrão de linguagem C
  •         A função Main criada