PLACA DE ESTUDOS E TESTES
PE-PIC16F628A

Já há algum tempo eu tenho o projeto dessa placa. Ela foi desenvolvida para servir de base e estudos de projetos da minha turma de Microcontroladores de 2010/2011, quando ministrei aulas em um colégio técnico na zona sul de São Paulo. Essa placa é ideal para o iniciante que deseja aprender sobre os microcontroladores PIC. E também pode ser utilizada por professores da área da mesma maneira que usei um dia.

Para muitos o popular PIC16F628A está "obsoleto", "desatualizado". Isso porque temos nos dias atuais microcontroladores de 32bits com suporte a periféricos fantásticos (WiFi, rede LAN, Bluetooth, etc). E sendo assim, porque então aprender a lidar com um microcontrolador de 8 bits considerado por muitos “especialistas” no assunto como “obsoleto”? A resposta para essa pergunta é muito simples: se você quer realmente aprender sobre microcontroladores, iniciar com um pequeno microcontrolador de 8 bits sem muitos recursos ainda é a melhor opção.

O CIRCUITO

Na figura acima mostro o esquema elétrico da placa. CI1 é o conhecido microcontrolador PIC16F628A. Seus pinos de I/O estão ligados a barra de pinos PORTA e PORTB_1 e PORTB_2, o que facilita muito o uso destes. Na placa existem também 4 LEDs para testes, LED2 a LED5 ligados ao PORTB_2. O jumper JP3 liga os cátodos dos LEDs ao GND. Dessa forma, caso o usuário queira utilizar essa parte do PORTB (MSB) sem a interferência dos LEDs basta deixar esse jumper "aberto". As chaves S1 a S4 estão ligadas ao PORTA e o jumper JP2 permite ligar ou não os 5VDC aos resistores de pull-up das mesmas (R2 a R5). Dessa forma o usuário também poderá utilizar o PORTA para outros testes, sem que estes resistores interfiram.

A placa também tem um relé para testes, RL1. Esse relé é controlado pelo pino RB3 através do transistor Q1 (NPN BC338). E caso o usuário deseje utilizar esse pino para outro fim, poderá abrir o jumper RB3. CI3 serve para adaptar os níveis de tensão de entrada/saída dos pinos RB1/RB2 (RX/TX) TTL 5VDC para os níveis de tensão RS-232 (+/-12VDC).

A placa possui ainda um regulador de tensão CI2 (7805) para 5VDC/1A que é mais que suficiente para os dispositivos de testes presentes na placa (LEDs, chaves, relé e porta RS-232), além de periféricos externos como: LCDs, CIs conversores AD, memórias I2C, dispositivos SPI+.++++
 e muitos outros. Na entrada da fonte (9VDC) foi inserido o diodo D1 para prevenir contra inversões. Os capacitores C5, C6, C7 e C4 são os filtros da fonte. O LED1, juntamente com seu resistor limitador de corrente R1, formam o indicador visual de "fonte ligada, 5VDC presentes".

A entrada para gravação é feita através do conector ICSP, padrão Microchip presente nos gravadores PICKit2 e PICKit3.

Note que a placa conta com um circuito oscilador externo formado pelo cristal oscilador X1 de 4MHz e os capacitores C1 e C2. Porém caso o você deseje utilizar os pinos RA6 e RA7 como pinos de I/O poderá optar por não montar estes componentes e utilizar o oscilador interno presente no PIC16F628A. O circuito de reset é formado pela chave S5, o resistor R10 e o diodo D2. O mesmo caso se aplica aqui caso estes componentes não sejam montados. O pino RA5 poderá ser utilizado como I/O e ao programar o PIC bastará configurar o reset interno.

MONTAGEM

O  para a confecção do circuito impresso pode ser visto acima. O mesmo pode ser confeccionado utilizando uma placa dupla face ou ainda face simples e nesse caso as trilhas do lado superior podem ser feitas utilizando fios pelo lado de baixo da placa ou ainda pelo lado superior mesmo.

Comece soldando os resistores, tomando cuidado apenas para não trocá-los de lugar. Atenção ao código de cores de cada um. Em seguida monte os capacitores cerâmicos e de poliéster. Monte também as chaves, o cristal (se este for o caso) e as barra de pinos. Até aqui os componentes não possuem polarização e você não precisa de um cuidado relacionado a isso.

Em seguida monte os diodos, LEDs, capacitores eletrolíticos, o regulador e o transistor. Cuidado agora, pois são componentes polarizados. Monte o relé e os conectores para entrada de alimentação, saída para os contatos do relé e o DB09 fêmea para comunicação RS-232. É recomendado usar um pequeno dissipador de calor no regulador de tensão.

É altamente recomendado o uso de um suporte/soquete de CIs para CI1. Isso permitirá que você possa trocar ou ainda remover o microcontrolador para ser utilizado em outro projeto qualquer. O uso de um microcontrolador PIC16F648 também é permitido nessa montagem, com a vantagem de se garantir o dobro de memória de programa para seus projetos/testes. A montagem do CI3 pode ou não ser feita utilizando um suporte. Lembrando apenas que ambos os CIs precisam ser montados da forma correta, indicada na placa. Qualquer inversão na montagem de qualquer um deles poderá causar a sua perda irremediavelmente.

Com tudo montado, faça uma verificação minuciosa. Não tenha pressa nesse momento. Verifique sua montagem com calma e bastante atenção.

Obs.: Dependendo da data em que você estiver lendo esse artigo, pode ser que eu ainda tenha comigo algumas placas confeccionadas. Caso tenha interesse em adquirir uma (apenas a placa para montagem, sem componentes), por favor entre em contato através de um dos meus e-mail's: arne_robotics@hotmail.com ou contato@arnerobotics.com.br.

PROGRAMA DE TESTES

Abaixo segue um pequeno programa de testes que fará os LEDs funcionarem como um sequencial vai e vem e pressionando as chaves é possível alterar a velocidade do sequencial. Para isso, feche os jumper's JP2 e JP3 e mantenha aberto JP1.

O programa foi desenvolvido utilizando a IDE MPLABx juntamente com o compilador XC8 ambos da Microchip, mas você poderá utilizar o compilador que estiver acostumado ou ainda outro a sua escolha. Lembrando apenas que a portabilidade não é garantida em 100% de uma IDE/compilador para outro e algumas adaptações poderão ser necessárias. Isso fica por conta de cada um.

//******************************************************************************
// Projeto Teclas para placa PE-PIC16F628A
// Desenvolvido por: Eng. Márcio José Soares
// 
// V1.0 - 06/09/2022
//
// Compilador: XC8 v2.45
// IDE       : MPLABX 6.0 Linux
// Plataforma: placa PE-PIC16F628A com PIC16F648A
// Gravador  : PICKIT3
//
// Pinos utilizados:
// RA0 : S4
// RA1 : S3
// RA2 : S2
// RA3 : S1
// RB4 : LED5 
// RB5 : LED3 
// RB6 : LED2 
// RB7 : LED1 
//
//******************************************************************************

//******************************************************************************
// Bits de configuração
#pragma config FOSC = HS        // Seleção do oscilador (Oscilador externo: cristal)
#pragma config WDTE = OFF       // WDT desabilitado
#pragma config PWRTE = ON       // Power-up Timer desabilitado
#pragma config MCLRE = ON       // MCLR = reset
#pragma config BOREN = OFF      // Brown-out Detect BOD disabilitado
#pragma config LVP = OFF        // Low-Voltage Programming desabilitado - I/O RB4
#pragma config CPD = OFF        // EEPROM desprotegida pode ser apagada/lida/escrita
#pragma config CP = OFF         // Flash desprotegida pode ser lida/escrita

//******************************************************************************
// Se nenhuma freqüência foi definida, assume 4MHz
// Esta definição é exigida para calibrar as funções __delay_us() e __delay_ms()
#define _XTAL_FREQ 4000000

//******************************************************************************
// Inclui arquivos
#include 

//******************************************************************************
// Definições importantes do módulo
#define TRUE    1
#define LEDS    PORTB
#define TECLAS  PORTA
#define TEMPO   500

//******************************************************************************
// Função para temporizar x ms
//
// Entradas - tempo em ms
// Saídas   - nenhuma
//******************************************************************************
void mdelay_ms(unsigned long tempo){
    
    while(tempo--)
        __delay_ms(1);
}

//******************************************************************************
// Função para ler as teclas
//
// Entradas - nenhuma
// Saídas   - valor da tecla ou 0 se sem tecla
//******************************************************************************
uint8_t get_teclas(void){
    
    uint8_t ret = 0;
    
    switch(TECLAS & 0x0F){      //lê port A e limpa MSB
        case 0x0E:              //se tecla S4 pressionada
            ret = 0x02;         //divisor
            break;
        case 0x0D:              //se tecla S3 pressionada
            ret = 0x03;
            break;
        case 0x0B:              //se tecla S2 pressionada
            ret = 0x04;
            break;
        case 0x07:              //se tecla S1 pressionada
            ret = 0x05;
            break;
    }
    
    return ret;
}

//******************************************************************************
// Função principal
//
// Entradas - nenhuma
// Saídas   - nenhuma
//******************************************************************************
void main(void) {
    
    uint8_t i, j;
        
    PORTA = 0;              // zera ports
    PORTB = 0;
        
    INTCON = 0x00;          // Todas as ints desligadas
    CMCON = 0x07;           // desliga comparadores 
        
    TRISA = 0xFF;           // Configura PORT A - entrada
    TRISB = 0x00;           // Configura PORT B - saída
    
    LEDS = 0;               // limpa port
        
    while(TRUE){
        
        for(i=0;i<4;i++){
            LEDS = ((0x10 << i) & 0xF0);    // faz shift left e limpa LSB
            j = get_teclas();               // lê teclas
            if(j)                           // se tem teclas, tem divisor
               mdelay_ms(TEMPO/j);          // temporiza com divisor
            else
                __delay_ms(TEMPO);          // senão usa tempo default
        }
        
        for(i=0;i<4;i++){
            LEDS = ((0x80 >> i) & 0xF0);    // faz shift rigth e limpa LSB
            j = get_teclas();               // lê teclas ...
            if(j)                           //
                mdelay_ms(TEMPO/j);         // 
            else
                __delay_ms(TEMPO);          // ...senão ...
        }
        
    }
    
 }

CONCLUSÃO