Making A Pickit 3 Clone

What a “PICkit 3 clone” is, and is not

There are two different things people mean by this phrase, and confusing them wastes a lot of time.

• A PICkit 2 clone. The PICkit 2 design was published: schematic and firmware are available, and the firmware runs on a PIC18F2550 with a 20 MHz crystal, talking USB HID. That is why cloned PICkit 2 boards exist at all — someone can build one from the released files. It supports the older PIC10/12/16/18 families, and the host software is the PICkit 2 standalone programmer.
• A “PICkit 3” clone. Microchip never published the PICkit 3 firmware. The cheap boards sold under that name are reverse-engineered or copied hardware running extracted firmware, they identify themselves as a PICkit 3 over USB, and they work with MPLAB X and MPLAB IPE — until a toolchain update or a newer device breaks them.

So “making a clone” in the useful sense means one of: building a PICkit 2 from the published design, buying a clone and making it behave, or accepting that a genuine programmer is cheaper than the hours you will spend. All three are covered below.

The chicken-and-egg problem

Every programmer needs a programmer. A blank PIC18F2550 cannot program itself, and the PICkit 2 clone design assumes you already have something that can flash a 28-pin PIC once. If you have no programmer at all, the practical order is:

1. Buy the cheapest working programmer you can find — a genuine PICkit 3, a SNAP, or a known-good clone — and use it once.
2. Use that to flash the PICkit 2 firmware into your clone build.
3. Keep the first programmer as the recovery tool, because a clone that loses its firmware cannot revive itself.

Without a first programmer, a clone project stalls at step zero no matter how good the board is.

Building the PICkit 2 route properly

• Part: PIC18F2550 in the 28-pin package the published schematic expects, with a 20 MHz crystal and two loading capacitors sized for it.
• USB: HID class, so no driver install on Windows, Linux or macOS. The 12 Mbit/s USB lines need short, matched traces and the correct series resistors — a sloppy USB layout is the most common reason a hand-built clone is not detected.
• Firmware: flash the published hex, then confirm the device enumerates and the host software reports the firmware version.
• ICSP header: the programming pins must reach the target with short leads. Over 20 cm of ribbon, signals degrade and the target answers intermittently.
• VPP: the programming voltage has to reach the target’s MCLR pin, and the target must be able to supply the current. A weak VPP shows up as “target not found” on some parts and works on others.

Living with a PICkit 3 clone

If you already own one, these are the behaviours that matter:

• Device support is the moving target. Newer PIC16/18 revisions and most PIC24/dsPIC/PIC32 parts need a device file the clone’s firmware may not carry. If MPLAB X says the device is not supported while a genuine tool lists it, that is the clone’s firmware, not your wiring.
• Toolchain versions drift. A clone that works with one MPLAB X release can stop working after an update. Pinning the IDE version, or keeping an older MPLAB IPE install for the clone, is a legitimate workaround.
• Voltage and current limits. Clones often cut corners on the VPP generator and on target power. Programming a board that also draws current from the programmer is where they fail.
• Programmer-To-Go (standalone programming without a PC) is a genuine PICkit 3 feature that clones implement inconsistently or not at all.

Wiring the ICSP header

Five signals, and the names differ between datasheets: VPP/MCLR, VDD, VSS, ICSPDAT (data), ICSPCLK (clock). For 3.3 V parts, check that the programmer’s VDD sense pin is connected — many “target not found” errors are simply the tool not seeing target power. Keep the cable short, keep VSS solid, and do not leave a large capacitor on MCLR: the programmer has to be able to pull that pin to VPP quickly.

When it refuses to program

• Target device ID not found — wiring, target power, or VPP. Check VDD at the target’s own pins, not at the header.
• Device ID mismatch — the selected part does not match the silicon. Verify the exact suffix; a PIC16F877A is not a PIC16F877.
• Programming failed at address 0x0 — code-protect bits from a previous session, or a target that browns out while writing.
• Works on one board, fails on another — almost always cable length, missing VDD sense, or a target circuit loading the ICSP lines.

The honest recommendation

Build a PICkit 2 clone if you want the exercise and you already own a programmer to bootstrap it: the design is documented, it is cheap, and it teaches you what ICSP actually does. Do not build a “PICkit 3 clone” expecting a documented design — there is none. If your work depends on PIC24, dsPIC or PIC32, buy a genuine tool; the time saved pays for it within a couple of projects.

References

• Microchip, PICkit 2 programmer user’s guide and the published PICkit 2 schematic/firmware — the documented clone route.
• Microchip, PICkit 3 in-circuit debugger/programmer user’s guide — ICSP signal definitions, VPP and VDD sense requirements, Programmer-To-Go.
• Target device datasheets, “ICSP” chapter — pinout, VPP limits, and the capacitor-on-MCLR caution.

Firmware and schematic availability above reflects what Microchip published. No specific clone board is claimed to have been tested here.