DIY PICMicro Low Pin Count DIP Prototype Board

Overview 

Using a prototype board for micro-controller firmware testing could save time and safer. Putting an on-board device programmer with prototype board could be more satisfy for electronic hobbyists.

I have some PIC18 and PIC16 series of micro-controllers left from previous projects. I don't know what to do with them anymore. So I put them on single board to PIC program testing next time I need them without checking their pin diagram, and wiring them on bread board. 

PCB Front View

PCB Back View

 

I designed a PCB with a 

1. PICKit2 device programmer (with AVR ISP header)
2. +5VDC and +3.3VDC low drop out power supply
3.  RS-232 to TTL logic converter
4. I2C DS1307 RTC and 24LC08 EEPROM 
5. 4-bit LCD (HD4478)
6. 3-digit 056'common cathode multiplexing display 
7. One passive buzzer with transistor driver (using CCP1 PWM output pin of PIC16F876A)
8. 8-LED that connects to PORTC of PIC16F876A
9. A 4x4 keypad matrix that connects to PORTB of PIC16F876A
10. Three analog inputs (one LM35 and two potentiometers) that connect to RA0...RA1 of PIC16F876A. 
11. A 28-pin IC socket for 28-pin PIC devices
12. A 20-pin IC socket for 20-pin PIC devices
13. A 18-pin IC socket for 18-pin PIC devices
14. A 14-pin IC socket for 14-pin PIC devices
15. And a 8-pin IC socket for 8-pin PIC devices

This board seem to be a large PCB with two copper layer near a size of an A4 paper that I'm not yet fabricate it. It need a PCB fabrication service.

Schematic

I use Protues VSM Release 8.16 SP3 to design draw its circuit diagram. Some components are not in its original libraries. So I find and download some devices symbol, footprints and 3D objects from snapeda website. I separate its schematic into A4 sheets. 

Sheet #1

Sheet #2

Sheet #3

Sheet #4

Sheet #5

This board could fit,

1. 28-pin PIC microcontrollers: PIC16F876A, PIC16F886, etc.
2. 20-pin PIC microcontrollers: PIC16F1459(USB), PIC16F690, etc.
3. 18-pin PIC microcontrollers: PIC16F1827, PIC16F84A, PIC16F818, etc.
4. 14-pin PIC microcontrollers: PIC16F630, PIC16F676, etc.
5. 8-pin PIC microcontrollers: PIC12F629, PIC12F675, PIC12F683, etc.

These are some mid-range PIC micro-controllers I have at my own workshop.

Printed Circuit Board (PCB)

This board size is 8.02x6.30 inches that could be a little bit expensive to order from any professional PCB fabrication service. But if we need to use it with classmate or friend the share cost is cheaper.

Top Copper non-mirror

Bottom Copper

Top Silk

I preview this PCB on an online Gerber viewer software.

Gerber View Top Copper

Gerber View Bottom Copper

 Click here to download its design file.

PCB Fabrication

I have been using PCBWay for many years now. PCBWay fabricate PCBs at low cost, fast processing time for only 24 hours, and fast delivery time using any carrier options. This double side 10cmx10cm can be fabricate at only 5USD for 5 to 10pcs by PCBWay. It's a standard PCB with silk screen and solder mask.

10 PCBs for only 5USD

 

For different size of PCB we can instantly quote on PCBWay website using a zip PCB Gerber file without account.

PCBWay Instant Quote

 

We can accurately see the preview of fabricated PCB generated by the company's online Gerber file viewer.

PCBWay also offer PCBA assembly service at reasonable price.

PCBWay PCB Assembly Service

PIC16F84A Simple Frequency Meter With LCD Using XC8

Frequency meter can be made using a conventional digital ICs with a big size, and complicated circuit connection. A small 8-bit micro-controller could do this job using a low level Assembly language or even a higher level C language.

In this example, I use an 8-bit PIC16F84A micro-controller to count external TTL input pulse. The total count will update for every seconds.

Simulating Program

I use RA4/T0CKI (Timer0 External Clock Input) pin to count external TTL pulse. Since Timer0 is only 8-bit wide the maximum counting is only 255 counts. So I add Timer0 Interrupt to increase the maximum counts. I use XC8 built-in delay function to create a precise 1000 ms (1 second) delay before the summation of external pulse is evaluated. A 16x2 character LCD is suitable for this example.

#include <stdio.h>
#include <xc.h>
 
#define _XTAL_FREQ 4000000UL
 
#include "LCD4Bits.h"
 
void tmr0Init(void){
    PORTA=0;
    TRISA4=1;
    T0CS=1;
    T0SE=0;
    PSA=1;
    OPTION_REGbits.PS=0;
    T0IE=1;
    GIE=1;
    T0IF=0;
}
 
long TMR0H=0;
 
void interrupt T0_ISR(void){
    if(T0IF){
        TMR0H+=1;
        T0IF=0;
    }
}
 
int main(void){
    unsigned char freq[10];
    uint32_t temp=0;
    PORTB=0;
    TRISB=0;
    lcdInit();
    tmr0Init();
    lcdXY(4,1);
    lcdString("PIC16F84A");
    lcdXY(1,2);
    lcdString("Frequency Meter");
    __delay_ms(1000);
    lcdCommand(CLEAR_SCREEN);
    __delay_ms(5);
    lcdXY(4,1);
    lcdString("Frequency:");
    TMR0H=0;
    TMR0=0;
    while(1){
        __delay_ms(1000);
        temp=(TMR0H<<8)+TMR0;
        lcdXY(6,2);
        sprintf(freq,"%uHz ",temp);
        lcdString(freq);
        TMR0H=0;
        TMR0=0;
    }
    return 0;
} 

I can not test it on bread-board because this chip was burn out. And I only have some newer PIC chips. So this program can only be tested using a simulator like Proteus. We can use another PIC chip like the PIC16F628A, and CCS PICC compiler. 

Resource Usage

 

This program require 69.5% of program memory, and 89.7% of data memory. Click here to download this example.

 

PIC16F84A EEPROM Reading And Writing Example Using XC8

PIC16F84A contains 68 bytes of EEPROM non-volatile memory. It's useful for storing some setting parameters when the MCU is powered off. EEPROM has a slower access time than SRAM and Flash memory. But it has a higher endurance compares to Flash memory. We can erase or write EEPROM up to 10 million times.

Running Program

Using a low level Assembly language or C programming language without EEPROM library, we can access to this memory via these four SRFs,

1. EEDATA - EEPROM Data Register
2. EEADR   - EEPROM Address Register
3. EECON1
4. and EECON2.

EEPROM Control Regsiter 1 (EECON1) has some control bits to read, write, and status checking of EEPROM operations. 

EECON1 Register

 

Using XC8 we can use all of these registers to read or write to EEPROM. However XC8 compiler has a built-in EEPROM library that's very easy to use. To read or write EEPROM, we only need these functions,

1. EEPROM_READ(address)
2. EEPROM_WRITE(address, data) .
   

We just include the "xc.h" header file to call these functions.

Example #1 : EEPROM Writing And Reading

In this example, the program write a set of ASCII characters to EEPROM starting from address 0. Then the controller read them back, and they will be shown on virtual terminal. I use software UART (bit banging) to process serial data.

 
/*
 for 9600 baud rate
 * 1/9600 = 104uS per bit
 * we can use 102.5uS per bit or above
 */
 
#include <xc.h>
 
// PIC16F84A Configuration Bit Settings
 
// CONFIG
#pragma config FOSC = XT        // Oscillator Selection bits (XT oscillator)
#pragma config WDTE = OFF       // Watchdog Timer (WDT disabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable bit (Power-up Timer is disabled)
#pragma config CP = OFF         // Code Protection bit (Code protection disabled)
 
#define _XTAL_FREQ  4000000
#define TX  RA0
#define RX  RA1
 
void sendChar(char data){
    TX=0;
    __delay_us(100);
    for(int i=0;i<8;i++){
        TX=data&(1<<0);
        data>>=1;
        __delay_us(75);
    }
    TX=1;
    __delay_us(100);
}
 
char myChar=0,temp=0;
void receiveChar(void){
    if(RX==0){
        __delay_us(100);
 
        for(char i=0;i<8;i++){
            __delay_us(60);
            if(RX==1) myChar|=(1<<i);
            else myChar&=~(1<<i);
        }
        __delay_us(100);
    }
}
 
void sendText(char *text){
    while(*text) sendChar(*text++);
}
 
void softUARTInit(void){
    PORTA=0x00;
    TRISA=0x02;
    PORTB=0;
    TRISB=0;
    TX=1;
}
 
void main(){
 
    softUARTInit();
    sendText("PIC16F84A Software UART Read EEPROM Write And Read\r\n");
    for(uint8_t i=0;i<43;i++) {EEPROM_WRITE(i,i+48);while(WR==1);}
    for(uint8_t i=0;i<43;i++) {sendChar(EEPROM_READ(i)); while(RD==1);}
    sendText("\r\n");
    while(1){
 
    }
}
 

Click here to download this example.

 

Example #2: Initializing EEPROM Data

Without using the EEPROM_WRITE function, we can initialize the EEPROM space. We use the __EEPROM_DATA() macro. The input is an 8 parameters. Each parameters are the 1 byte EEPROM data. For example,

__EEPROM_DATA('H','E','L','L','O','S','I','R'); .

In this example, I initialize some ASCII characters on EEPROM space. Then the program read them back before they are sent over the software UART terminal.

/*
 for 9600 baud rate
 * 1/9600 = 104uS per bit
 * we can use 102.5uS per bit or above
 */
 
#include <xc.h>
 
// PIC16F84A Configuration Bit Settings
 
// CONFIG
#pragma config FOSC = XT        // Oscillator Selection bits (XT oscillator)
#pragma config WDTE = OFF       // Watchdog Timer (WDT disabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable bit (Power-up Timer is disabled)
#pragma config CP = OFF         // Code Protection bit (Code protection disabled)
 
#define _XTAL_FREQ  4000000
#define TX  RA0
#define RX  RA1
 
__EEPROM_DATA('H','E','L','L','O','S','I','R');
__EEPROM_DATA('P','I','C','1','6','F','8','4');
__EEPROM_DATA(' ','S','i','m','p','l','e',' ');
__EEPROM_DATA('U','A','R','T',' ','P','r','o');
__EEPROM_DATA('g','r','a','m','m','i','n','g');
__EEPROM_DATA(' ','W','i','t','h',' ','M','P');
__EEPROM_DATA('L','A','B','X',' ','I','D','E');
__EEPROM_DATA(' ','X','C','8',' ','C',' ','.');
 
void sendChar(char data){
    TX=0;
    __delay_us(100);
    for(int i=0;i<8;i++){
        TX=data&(1<<0);
        data>>=1;
        __delay_us(75);
    }
    TX=1;
    __delay_us(100);
}
 
char myChar=0,temp=0;
void receiveChar(void){
    if(RX==0){
        __delay_us(100);
 
        for(char i=0;i<8;i++){
            __delay_us(60);
            if(RX==1) myChar|=(1<<i);
            else myChar&=~(1<<i);
        }
        __delay_us(100);
    }
}
void sendText(char *text){
    while(*text) sendChar(*text++);
}
 
void softUARTInit(void){
    PORTA=0x00;
    TRISA=0x02;
    PORTB=0;
    TRISB=0;
    TX=1;
}
 
void main(){
 
    softUARTInit();
    sendText("PIC16F84A Software UART Read EEPROM Example 1\r\n");
    for(uint8_t i=0;i<8;i++) sendChar(EEPROM_READ(i));
    sendText("\r\n");
    for(uint8_t i=8;i<64;i++) sendChar(EEPROM_READ(i));
    while(1){
 
    }
}
 

Click here to download its source file.