M
Author:
AN589
After entering programming mode, RB7 is used to
serially enter programming modes and data into the
part. A high to low transition on RB6, the clock input,
qualifies each bit of the data applied on RB7. Please
refer to the PIC16C84 Programming Specification
(DS30189) for details on the figures. The serial com-
mand-data format is specified in Figure 1.2.1.3 of the
Microchip PIC16C84 Programming Specification
(DS30189). The first 6 bits form the command field, and
the last 16 bits form the data field. Notice that the data
field is composed of one zero starting bit, 14 actual
data bits, and one zero stop bit. The increment address
command, shown in Figure 1.2.1.5 (PIC16C84 Pro-
gramming Specification, DS30189), is comprised of
only the command field. Table 1.2.1.1 (see DS30189)
summarizes the available commands and command
codes for serial programming mode.
Read mode is similar to programming mode with the
exception that the data direction of RB7 is reversed
after receiving the 6-bit command to allow the
requested data to be returned to the programmer.
Figure 1.2.1.4 (see DS30189) shows this sequence
which starts by shifting the 6-bit command into the part.
After the read command is issued, the programmer
tri-states its buffer to allow the part to serially shift its
internal data back to the programmer. The rising edge
of RB6, (the clock input), controls the data flow by
sequentially shifting previously programmed or data
bits from the part. The programmer qualifies this data
on the falling edge of RB6. Notice that 16 clock cycles
are necessary to shift out 14 data bits.
Accidental in-circuit reprogramming is prevented during
normal operation by the MCLR voltage which should
never exceed the maximum circuit supply voltage of
6 VDC and the logic levels of port bits RB7 and RB6.
After program/verification the MCLR pin is brought low
to reset the target microcontroller and then electrically
released. The target circuit is then free to activate the
MCLR signal. In the event MCLR is not forced by the
target circuit, R4 (a 2 k
Ω
pull-up resistor in the
programmer) provides a high logic level on the target
microcontroller which enables execution of its program
independent of the programmer connection. Provisions
should be made to prevent the target circuit from
resetting the target microcontroller with MCLR or
affecting the RB7 and RB6 pins during the
programming process. In most cases this can be done
without jumpers.
A PC-Based Development Programmer for the PIC16C84
Robert Spur
Analog Design Specialist, Inc.
INTRODUCTION
This application note describes the construction of a
low cost serial programmer which uses a PC with a par-
allel (Centronix printer) port to control a PIC16C84.
This programmer has the capability of programming a
PIC16C84 microcontroller, and reading back internal
data without removing the device from the target circuit.
This feature is very useful in applications where
changes in program code or program constants are
necessary to compensate for other system features.
For example, an embedded control system may have to
compensate for variances in a mechanical actuator’s
performance or loading. The basic program can be pro-
grammed and tested during design phase. The final
program and control constants can be easily added
later in the production phase without removing the
microcontroller from the circuit.
Automatic software and performance upgrades can
also be implemented in-system. Upon receiving new
system software via disk or modem, a control
processor with the included programming code could
perform
in-circuit
reprogramming
of
other
microcontrollers in the system.
This programmer can load program code, part
configuration, and EEPROM data into the PIC16C84.
In read back mode, it can verify all data entries.
PROGRAMMING DESCRIPTION
The PIC16C84 microcontroller is placed into program-
ming mode by forcing a low logic level on RB7 (pin 13)
and RB6 (pin 12) while MCLR (pin 4) is first brought low
to reset the part, and then brought to the program/verify
voltage of 12 to 14V. The MCLR pin remains at the pro-
gram/verify voltage for the remainder of the program-
ming or verification.
©
1997 Microchip Technology Inc.
DS00589A-page 1
AN589
DETAILED CIRCUIT DESCRIPTION
A logic high on PC parallel interface latch bit D4 turns
on Q3 causing the MCLR pin to go low which places
the target part in reset mode. The reset condition is
then removed and the program/verify voltage is applied
by placing a logic high on D3 and a logic low on D4
which turns off Q3 and turns on Q2 and Q1. Circuit
protection of Q1 and Q3 is obtained from connecting
the emitter of Q2 to latch bit D4 which prevents a
simultaneous reset and program/verify voltage mode.
Q2, a 2N3904, has a reverse emitter base breakdown
voltage of 6V which will not be exceeded when 5V logic
is used on the parallel interface.
Resistors R1, R2, R3, and diode D1 provide a logic
level interface to the analog circuitry. R4 provides a
MCLR (master clear) pull-up function during target cir-
cuit run mode. The programming voltage is supplied
and adjusted by an external lab supply. This supply
should have a current limit in the 100 mA range. 5V for
U2 (LS244) is locally regulated from programming
supply voltage by U1. R5 (750
Ω
resistor) is connected
to the regulator output to insure proper 5V regulation
when the 13.5V programming voltage is applied
through the pull-up resistor R4.
Data and clock are connected to the part via tri-state
buffer, U2. PC parallel port interface bit D0 is used for
data and port bit D1 is used for clock. During
programming mode both clock and data buffers are
enabled by port bits D2 and D5. During read mode, the
data buffer is tri-stated via D2 and the printer data
acknowledge signal line is used to receive verification
data from the part.
After program/verification mode both the data and
clock lines are tri-stated via D2 and D5, allowing these
lines to be used by the target circuit. This allows the
programmer to remain physically, but not electrically
connected to the target system.
An optional 5V line was included in the 3-foot
programming interconnect cable for convenience.
Short interconnection leads and good grounding are
always good construction practice.
To meet the programming/verification specification, the
target part’s supply voltage should first be set to the
maximum specified supply voltage and a program/data
read back should then be performed. This process is
then repeated at the lowest specified supply voltage.
FIGURE 1:
PROGRAMER SCHEMATIC
U1
V
PP
(13.5V)
C1
22
µF
35V
LM340-5
R1
2k
Q1
2N3906
Q2
2N3904
R2
2k
R3
2k
D1
1N4148
LS244 (pin 10)
Q3
2N3904
GND (pin 5)
PIC16C84
INTERFACE
R4
2k
R5
750
LS244 (pin 20)
+5 VDC
C2
68
µF
10V
MCLR (pin 4)
D3
5
PC PARALLEL D4
INTERFACE
GND
6
18, 25
D2
4
1
U2
74LS244
18
10
DATA (RB7, pin 13)
D0
2
2
ACK
D5
7
19
U2
74LS244
3
11
12
Resistors: 1/4 watt, 5%
CLOCK (RB6, pin 12)
D1
3
17
BUSY
PE
DS00589A-page 2
©
1997 Microchip Technology Inc.
AN589
SOFTWARE DESCRIPTION
The listed code provides a hardware-software interface
to a standard PC parallel (Centronix) interface port. The
code can be adapted to a microprocessor parallel inter-
face port by substituting an output command for the
“
biosprint
” command.
Control software can transfer the PIC16C84 program,
configuration bits, and EEPROM data from a standard
PROM interface file into the target system by reading
the file and calling the function in Example 1 using the
appropriate command name in the definition table, and
the data to be programmed. The command names are
repeated here for reference.
LOAD_CONFIG
LOAD_DATA
READ_DATA
INC_ADDR
Sets PIC16C84 data pointer to
configuration.
Loads, but does not program,
data.
Reads data at current pointer
location.
Increments
pointer.
PIC16C84
data
BEGIN_PROG
PARALLEL_MODE
LOAD_DATA_DM
READ_DATA_DM
Programs data at current data
pointer location.
Puts PIC16C84 into parallel
mode (not used).
Loads EEPROM data.
Reads EEPROM data.
Function “
int ser_pic16c84
(<command>,<data [or
0]>) is called to perform command. Function returns
internal data after read commands.
Do not forget to initiate the programming mode before
programming, increment the addresses after each byte
is programmed, and put the programmer in run mode
after programming.
Designed by:
Analog Design Specialist, Inc.
P.O. Box 26-0846
Littleton, CO 80126
EXAMPLE 1:
PUT TARGET SYSTEM INTO PROGRAM MODE
.. program code..
ser_pic16c84(PROGRAM_MODE,0);
.. program code..
EXAMPLE 2:
READ DATA FROM THE TARGET SYSTEM
.. program code..
data = ser_pic16c84(READ_DATA,0); // read data
// transfers data from target part to variable “data”
.. more program code..
EXAMPLE 3:
PROGRAM DATA INTO THE TARGET SYSTEM
.. program code..
ser_pic16c84(LOAD_DATA,data);// load data into target
ser_pic16c84(BEGIN_PROG,0);// program loaded data
ser_pic16c84(INC_ADDR,0);// increment to next address
// transfers data from program variable “data” to target part
.. more program code..
EXAMPLE 4:
PUT TARGET SYSTEM INTO RUN MODE
.. program code..
ser_pic16c84(RUN,0);
.. program code..
©
1997 Microchip Technology Inc.
DS00589A-page 3
AN589
//************************** FIGURE #2 ********************************
//**
**
//**
SERIAL PROGRAMMING ROUTINE FOR THE PIC16C84 MICROCONTROLLER
**
//**
**
//**
Analog Design Specialists
**
//**
**
//*********************************************************************
//FUNCTION PROTOTYPE: int ser_pic16c84(int cmd, int data)
// cmd: LOAD_CONFIG
-> part configuration bits
//
LOAD_DATA
-> program data, write
//
READ_DATA
-> program data, read
//
INC_ADDR
-> increment to the next address (routine does not auto increment)
//
BEGIN_PROG
-> program a previously loaded program code or data
//
LOAD_DATA_DM -> load EEPROM data regesters (BEGIN_PROG must follow)
//
READ_DATA_DM -> read EEPROM data
//
// data: 1) 14 bits of program data or
//
2) 8 bits of EEPROM data (least significant 8 bits of int)
// Additional programmer commands (not part of PIC16C84 programming codes)
//
// cmd: RESET
-> provides 1 ms reset pulse to target system
//
PROGRAM_MODE -> initializes PIC16C84 for programming
//
RUN
-> disconnects programmer from target system
//
// function returns:1) 14 or 8 bits read back data for read commands
//
2) zero
for write data commands
//
3) PIC_PROG_EROR = -1 for programming function errors
//
4) PROGMR_ERROR = -2 for programmer function errors
#include <bios.h>
#define
#define
#define
#define
#define
#define
#define
#define
#define
LOAD_CONFIG
0
LOAD_DATA
2
READ_DATA
4
INC_ADDR
6
BEGIN_PROG
8
PARALLEL_MODE 10
LOAD_DATA_DM
3
READ_DATA_DM
5
MAX_PIC_CMD
63
64
65
66
// not used
// division between pic16c84 and programmer commands
// external reset command, not needed for programming
// initialize program mode
// electrically disconnect programmer
#define RESET
#define PROGRAM_MODE
#define RUN
#define PIC_PROG_EROR -1
#define PROGMR_ERROR -2
#define PTR
0
// use device #0
// parallel port bits
//
d0: data output to part to be programmed
//
d1: programming clock
//
d2: data dirrection, 0= enable tri state buf -> send data to part
//
d3: Vpp control 1= turn on Vpp
//
d4: ~MCLR =0, 1 = reset device with MCLR line
//
d5: clock line tri state control, 0 = enable clock line
int ser_pic16c84(int cmd, int data)
{
int i, s_cmd;
// custom interface for pic16c84
DS00589A-page 4
©
1997 Microchip Technology Inc.
AN589
if(cmd <=MAX_PIC_CMD)
{
biosprint(0,8,PTR);
s_cmd = cmd;
for (i=0;i<6;i++)
{
biosprint(0,(s_cmd&0x1) +2+8,PTR);
biosprint(0,(s_cmd&0x1)
+8,PTR);
s_cmd >>=1;
}
if((cmd ==INC_ADDR)||(cmd ==PARALLEL_MODE)
return 0;
else if(cmd ==BEGIN_PROG)
{
delay(10);
return 0;
}
// all programming modes
// set bits 001000, output mode, clock & data low
// retain command “cmd”
// output 6 bits of command
// set bits 001010, clock hi
// set bits 001000, clock low
// command only, no data cycle
// program command only, no data cycle
// 10 ms PIC programming time
else if((cmd ==LOAD_DATA)||(cmd ==LOAD_DATA_DM)||(cmd ==LOAD_CONFIG)) // output 14 bits
for (i=200;i;i—) ;
// delay between command & data
biosprint(0,2+8,PTR);
// set bits 001010, clock hi; leading bit
biosprint(0, 8,PTR);
// set bits 001000, clock low
for (i=0;i<14;i++)
{
biosprint(0,(data&0x1) +2+8,PTR);
biosprint(0,(data&0x1)
+8,PTR);
data >>=1;
}
biosprint(0,2+8,PTR);
// *****************
biosprint(0,
return 0;
}
else if((cmd ==READ_DATA)||(cmd ==READ_DATA_DM)) //read 14 bits from part, lsb first
{
biosprint(0, 4+8,PTR);
// set bits 001100, clock low, tri state data buffer
for (i=200;i;i—) ;
// delay between command & data
biosprint(0,2+4+8,PTR);
// set bits 001110, clock hi, leading bit
biosprint(0, 4+8,PTR);
// set bits 001100, clock low
data =0;
for (i=0;i<14;i++)
Analog Design Specialists
// 14 data bits, lsb first
// set bits 001010,
// set bits 001000,
clock hi
clock low
// set bits 001010, clock hi; trailing bit
******************
// set bits 001000, clock low
8,PTR);
// input 14 bits of data, lsb first
{
data >>=1;
// shift data for next input bit
biosprint(0,2+4+8,PTR);
// set bits 001110, clock hi
biosprint(0, 4+8,PTR);
// set bits 001100, clock low
if(!(biosprint(2,0,0)&0x40)) data += 0x2000; //use printer acknowledge line for input,
//data lsb first
}
biosprint(0,2+4+8,PTR);
// set bits 001110, clock hi, trailing bit
biosprint(0, 4+8,PTR);
// set bits 001100, clock low
return data;
}
else return PIC_PROG_EROR;
}
else if(cmd == RESET)
// programmer error
// reset device
©
1997 Microchip Technology Inc.
DS00589A-page 5
京公网安备 11010802033920号
EEWORLD
