Microchip PICkit™ 3 In-Circuit Debugger Programmer - Review

Table of contents

RoadTest: Microchip PICkit™ 3 In-Circuit Debugger Programmer

Author: hlipka

Creation date:

Evaluation Type: Development Boards & Tools

Did you receive all parts the manufacturer stated would be included in the package?: True

What other parts do you consider comparable to this product?: Maybe the PicKit2 and the ICD3/4

What were the biggest problems encountered?: The construction of the connection header is not really suitable for using it on a PCB or breadboard.

Detailed Review:

A note at the beginning: in the scoring above I'm using 5 as "meets what I expect from such a tool / product", and better scores are only when it exceeds expectations. So a 30 means "this is what as good as expected", below that means its lacking and more than that indicates its better.

Intro

This is not really a traditional road test. This is because I do already own a PicKit3 for several years, albeit a DIY one. So it does not really make sense to write a test about it - I'm already familiar with it. Instead I proposed to look at the differences between the two, to find out why you might (or should?) buy a PK3 instead of building your own.

So this road test will be in a somewhat unusual format. First I will explain why and how I build my own PicKit3, so you know what I was starting with. Then we will get a look at the real PicKit3 I got from Microchip (many thanks to them, and to Farnell, for sponsoring this road test!). The last part will then show how both differ.

Building a DIY PicKit3

The reason I did build my own PicKit instead of buying one was mostly a reason of price. While these tools are not very expensive, when you add shipping they get quite pricey in comparison. And when I started into working with Microchips PIC series, I did not have that much money available for my hobby.

I actually started with a DIY PicKit2, not with the PK3. It is much simpler, and there are quite a lot of tutorials and blog posts available of how to do this. For initial programming you could use a simple parallel-port programmer (back then PCs still had these...). So I ended up with this:

{gallery} DIY PicKit2

Inside of the DIY PicKit2

Enclosure for the DIY PicKit2

DIY PicKit2 PCB

DIY PicKit2 PCB backside

Back then the idea was to use the PicKit2 to then build an ICD2, which was its faster and more versatile bigger brother (and there are also tons of instructions how to build one). But with the introduction of MPLAB X support for the newer PICs from Microchip (e.g. the Pic32 line) was never added to the PK2 and the ICD2. So the goal shifted to the PicKit3.

Fortunately Microchip was so kind to still publish the schematics for it in the user guide. so I went ahead with building one. See my blog post about the DIY PicKit3 for the changes I made, for schematics and anything you need to know should you want to go the same route. The result looks quite similar to the PK2, since I also used a Sparkfun box:

 

{gallery} DIY PicKit3

DIY PicKit3 Enclosure

Inside of the DIY PicKit3

DIY PicKit3 - PCB top side

DIY PicKit3 PCB bottom side

Yes, it looks quite messy since I just used a protoboard. But at least it inspired someone else for come up with a proper PCB.

What you get for buying a PK3

First, you get a nice package. Second thing you notice is how small it actually is:

 

{gallery} Microchip PicKit3

PicKit3 packaging

PicKit3 size comparison

PK3 poster

(especially when compared to my DIY versions).

The added poster with all the required information of how to connect and use the PK3 was a nice surprise. I really like it, unfortunately I don't have a place where to put it near my bench. Suggestion to Microchip: add a sticker on the PK3 showing the pin names (just as I did on my DIY PK3) - this something you always need to know.

The red USB cable also has a nice touch, it fits the company color scheme quite well.

Comparison

Since I wanted to have a deeper look, we need also to look at whats inside. So its time for a teardown. Fortunately the two plastic halves of the enclosure come apart without using too much force, so I had a look at the PCB:

{gallery} PicKit3 PCB

PCB top side

PCB bottom side

The PCB itself seems to be a four layer one, and most of the components go only to the top side. The quality of soldering was very good. There is some flux residue on the USB connector, so it seems it was soldered manually at the sides (so its sits stronger on the PCB and doesn't come lose).

There are quite some number of test points, so should it fails you actually should have a chance to find out whats wrong (using the schematic). But I guess thats not their purpose, they are most likely to do after-production testing.

When compared with my DIY version, the original PicKit3 is build with less ICs and more discrete parts. This is because it does quite some functionality with transistors (especially around voltage switching) which I replaced with ICs because thats what I had available. This also allows for a denser PCB. All in all I like the build quality. Also the layout looks neat and tidy, thats what you expect from a big company.

From the schematic I know that the PicKit3 comes with some protection on the input and output ports, so it should withstand some mishandling such as mixed-up wiring (thats actually something my DIY version skipped - I had no SMD PTC available at that time). I know that the PK3 has some bad reputation for being unreliable, but from my experiences I cannot confirm this. And I think the original version should be even more robust than mine.

Another difference is that, on my DIY version, I skipped the flash memory chip for the on-the-go functional, since I had no use for it. But I can see its value when you need to program in a place where you cannot bring your computer with you, or when you need to program multiple devices with the same code.

The biggest difference, construction-wise, is the choice of the programming connector. As you can see from the images above, the PicKit3 comes with a female header directly at the front. This means for programming you need a male header on you board. If you want to use a 90° header, it needs to be right at one of the sides of the board, otherwise you can only use straight headers. And then the PK3 needs to stand upright on your board, which I think is not really optimal (and can stress your board and the connector). In addition, I don't like to add male headers on a PCB since there is always the chance that some contacts get shorted by accident (Vcc and GND are next to each other on the connector). From a development tool I expect that it is safe against such mishandling (the PK3 has PTCs in all lines, so its protected against over-current), but normally on a PCB you don't add something like that.

{gallery} Connecting the PicKit3 to a breadboard

Pic12F1822 sample circuit on a breadboard

PicKit3 with straight pin headers

PicKit3 with 90° headers

using a short cable with two male headers

None of these is optimal, so in the end I just build a short cable with two male headers which you can use. For my DIY variant I directly used a male connector, so I don't need an adapter. Additional note here: normally pin 1 is on the left side of a connector, for the PicKit3 its on the right side. Watch out for this.

So much for the differences. Testing the real PicKit3 was unremarkable - it does just what it should, without any fuss. And just doing its job is what you expect from a debugging tool - it should just work. Its not the fastest, but for small and medium-sized PICs its surely fast enough. In that regards there was no difference to my DIY one, except that the real thing uses much less bench space.

Conclusion

So, is it worth to build your own PicKit3? I don't think so anymore. Probably it was not even worth it back then when I built mine - but I had nearly all parts available (and a PicKit2 to program it initially) so it seemed like a good idea. But now the availability of the PK3 is good enough (and shipping to Germany is not so expensive anymore) that its just easier to buy one. When you limit yourself to older PIC chips (which means you miss out on all the new and nice functionality of the newer ones) it still might be OK to build your own PicKit2, as its of simpler construction. This can save you some bucks, but limits you to the older MPLab (the MPLabX will not work with the PK2).

But when you think about doing more work with PICs, or want to use the new functionality, just get a PK3 directly from Microchips. Its small, looks nice, and does its job. And building a small adapter cable so you can use it easily on a breadboard is not such a big deal. I for myself might start saving some money to get an ICD4...

Anonymous