TL866CS, universal programmer

I can’t say I use a programmer very often, but sometimes I have to. So when I moved to a new computer, I ran into a problem: my old programmers wouldn’t work with it.
That’s why I bought a more modern one that doesn’t need a COM or LPT port.
There are already reviews of this device here, so mine will be more of a short photo dump addendum, along with a little history of programmers.

I bought this programmer last summer, but only got around to it now, mainly because I’m no longer using the familiar XP, but Windows 7 x64. On top of that, I’m now much more limited in terms of port options.

Programmers can be divided into several groups, although in many cases the distinction is rather arbitrary, since some can operate in different modes.

First, by how they’re controlled: “software,” “hardware,” and standalone.

Software programmers are the simplest kind. They don’t contain any microcontrollers; the entire process is controlled by the computer. Their drawbacks include being heavily dependent on the “hardware,” and being almost impossible to use through USB-COM and USB-LPT converters.
Their advantages are simplicity: sometimes all you need is a few wires, and sometimes one or more logic chips.

Hardware programmers have a microcontroller on board that acts as an intermediary between the computer and the chip being programmed. In this case, the software uses a standard data transfer protocol, so converters can be used. These programmers also usually deliver more consistent programming results, approaching 100%.

Standalone programmers let you program without a computer at all.

There’s also a division into serial and parallel programmers.

Serial: data is written one bit at a time. It’s slow, but requires fewer wires.
The same principle is also used for in-circuit programming.

Parallel: data is written one byte at a time, so it’s faster, but more complex and requires more wires. These programmers are often “hardware” types, although there were also versions that connected to an LPT port. In some situations, a parallel programmer can also help unlock chips that a serial programmer can’t.

There are also programmers with high-voltage programming (for example, they can unlock microcontrollers with the reset pin disabled), as well as ones with in-circuit debugging.
If you’re determined enough, you can even program a chip manually using ordinary switches. It takes a very long time and is tedious, but it can be done.

While preparing this review and testing the programmer, I tried to remember what I’d used in the past.
If anyone’s interested, I’ll show you, but the faint-hearted might want to look away :)
Maybe someone will show us their own versions.

The programmer arrived in a small cardboard box. It’s shown in exactly the same packaging on the manufacturer’s website.


The programmer comes with the bare minimum, including:
1. Programmer
2. USB cable
3. Software disc
4. Warranty card.


The warranty card isn't particularly useful, and I didn't even look at what was on the disc, since I simply downloaded the software I needed. I'll include a link to it at the end.
The only useful thing is probably the cable, which is quite good quality.


I'd seen the programmer in other reviews before, so I already knew what to expect. It's a small gray box with a socket on top.


There's a USB port on one side, and it's the proper type—the kind that should be used on devices, not Mini or Micro.
The other side just has a spot for a connector.


On top is what's called a zero-insertion-force socket. Most DIY devices use ordinary sockets. I do that myself; they're cheap and convenient in their own way. But a proper socket is much more convenient, especially in universal devices. Open it, put in the chip, close it, done :)
The bottom has only a sticker with the serial number and the manufacturer's address.


I took it apart before the first power-up, mostly out of curiosity. It's extremely easy to disassemble: just four self-tapping screws. I didn't like two things, though: it has no feet, and the screws are quite short.


The circuit board—or, more precisely, a sandwich of two boards. Everything looks excellent at first glance.


The sheer number of components stands out; in places, the board is literally covered with them.


The soldering is good and everything is clean, but for some reason the microcontroller's markings have been erased. As far as I know, it's something from Microchip, though it doesn't really matter.


The power-converter ICs are visible on the left, and there's a whole crowd of diodes in the middle. All these components are there because every socket pin can be controlled individually—or, more precisely, completely independently—so the programming capabilities are limited only by the software.


Besides the connectors joining the boards, there are also a couple of wire leads soldering them together. You can also see a spot nearby for another connector.


There's also a spot for a connector on the other side. I may be wrong, but as I understand it, this is the programming connector for the microcontroller installed in the programmer.


That's the end of the first part of the inspection. Let's see if it starts.
I install the software, replace the original program file with the Russian-localized version, and launch it. Before the program itself starts, this window pops up.
If you close it, the software works, but seeing this notification every time you start it gets annoying.

By the way, the software installed surprisingly smoothly. I ran the installer, it installed the drivers by itself, and everything worked once it finished. I was even surprised, since I'd already braced myself for problems. A reminder: I ran this test on Windows 7 x64.


After launching it, we see a familiar-looking programmer control window.
It may look slightly different for different programmers, but the general idea is the same: the various operating modes (write, read, verify, erase, etc.) and chip selection are at the top.
Below is a window showing the data being written or read. As with the rest of the software, you can edit the data here.


Since the pop-up window that kept appearing was getting on my nerves, the first thing I decided to do was update the programmer's firmware.
Go to the “Tools” menu and select “New firmware.”
There is also a “Self-test” option, which is quite useful.


Next, a scary warning pops up, basically telling us to watch what we're doing, because if anything goes wrong, they won't be able to help us :)
This is serious business, though: a failed firmware update really can cause major problems.
Click “Program” and hope the computer doesn't freeze and the power doesn't go out. In my case, everything went smoothly and the software updated without any problems.


But that was only half the job. Next, I wanted to turn my TL866CS programmer into the more convenient TL866A version.
There are two ways to do this:
1. Reprogram the programmer's microcontroller using another programmer—or, more precisely, a few wires, an LPT port, and special software.
2. Reflash the bootloader, essentially a “software” modification.

The first method is considered the proper one, but it's also more complicated. The second is much easier, though I've read that you'll have to repeat the procedure whenever you update the software. Since I don't plan to update the software often, I decided to use the second method. I got the information and file here.
To do this, run TL866.exe from the Reflash folder.


Then locate the update.dat file. It's in the folder where we installed the programmer software.


Click “Reflash.” One last time, we're given the chance to change our minds, but we don't take it.
I hope everyone understands that you do all of this at your own risk?


At the end, we should get a window like this. If you don't, you'll most likely have to use wires and an LPT port after all.


That's it—we now have a TL866A.
This upgrade lets us program microcontrollers not only in the programmer's socket, but also in-circuit. Of course, you can desolder the controller from the board and program it in the programmer, but if you need to do this more than once, it's much easier to connect six wires and program it without desoldering.


But updating the software isn't enough; you also have to solder in the connector itself. I left that until last because I wasn't 100% sure the reflash had worked.

After rummaging through my stash at home, I found some connectors and a wire.


The manufacturer originally intended this type of connector to be used.
It's called NS25-W6K.


You can even install it without taking apart the board sandwich. For example, I managed to fit it in place without using tweezers or any other tools. I only had a three-pin connector, but that doesn't change anything.


But I didn't have the right connector on hand, so I used a different one, also with six pins and a similar pitch (mine is 2.5 mm, but it should be 2.54 mm).


Though I think an IDC-type connector would have been much more convenient.
The big advantage of this type of connector is that it has no latch, and the cable is held firmly in place, so it can't be pulled out.
But there's a problem: to install one neatly, it needs to have 12 pins, but they only come with 10 or 14. So you either have to use a 10-pin connector and connect one of the pins with a wire, or use a 14-pin connector and leave the extra pins unused (if you only use one row of pins).

I used these connectors in my old programmer, and they proved that there's no need to look for anything better. The photo shows a 10-pin BH-10R connector.


The connector that was originally supposed to go here sticks out a little beyond the edge of the board, but I think it should stick out even farther. That's another reason to use a different type of connector.


In my case, there's no getting around using a soldering iron.
First, desolder the LEDs, making sure to remember how they were installed. The positive pad is marked with a square on the board, though.


Then, gradually heat the two pins holding the halves together while pulling the boards apart, and separate them.


Now we can take a look inside.
Inside, you can see a bunch of small transistors, connectors, and inductors in the power supply.


Step-up power converters. Overall, I think the power supply section is quite well done. The design itself is also well thought out.


I happened to notice a resettable fuse on the USB power line. That's a nice touch too—it lowers the chance of frying the computer's port if something goes wrong.


The second board also has a bunch of small transistors, probably the ones that wouldn't fit on the first board.


That's the inspection done; let's move on.
Before the next step, I'd already got my tools ready to break out the plug for the connector, but it turned out to simply pull out. Nice :)


I solder a tinned wire to the connector. At first I thought I'd just use leads from some components, but then I figured that if I used stiff, tinned wires, I wouldn't need to glue the connector in place. The original connector's pins are stiff enough to hold it on the board.


Put everything back together, solder the LEDs in, and install it in the case.


Before the next step, we need to decide which connector pinout to use.
For Microchip, everything is simple and straightforward, but Atmel is a different story. It has two standard ICSP connector options: six-pin and ten-pin.
I usually try to use the six-pin version because it's more compact, but the ten-pin version is considered more correct and was originally proposed by Atmel itself. Of course, there's nothing stopping you from making an adapter or simply using two cables, but either way, it's best to stick to these two standards—it may come in handy later.


This may make it easier for someone to understand how to wire the connector.


I ended up choosing the six-pin option, even though my connector has ten pins, so I only wired the middle six.


I keep all the wire crossings on the programmer-connector side. I don't have a crimping tool, so I had to solder them.


Of course, I check that it works. I take the board from this review and try to read its contents.


To use the external programming connector, select the corresponding option in the program settings. You can also choose whether or not to power the device.
The current is limited, and for some reason I kept getting a programmer port overload error. I had to hold down the programmed device's power button and disable power output in the programmer settings.


Read speed in this mode isn't very high: the Atmega644 took 13 seconds to read.


After trying a few other microcontrollers and confirming that everything worked, I moved on to some less common tests, though by this point it was mostly curiosity.
I take a 27C256 EPROM from an old computer and read it.
By the way, for UV-erasable chips there's a handy option to check whether the chip is blank. In this mode, the programmer checks that the chip has been completely erased.


The chip is about 30 years old, but it reads :) Though I'm almost certain there are read errors, since EPROMs like these tend to lose their charge over time.


All right, for the sake of the experiment, I'll try another similar chip, from some ancient 80286 computer.


Here, the errors seem to start right at the beginning of the read and are more obvious—you can see them in the text that was read.


One handy feature is the list of recently used chips.


During testing, I also checked some older Atmel chips, such as the 89C2051, and found no problems.
The list of supported microcontrollers is quite extensive.


Next I wanted to find my old Sinclair so I could read its ROM, but it wasn't to hand, so I moved on to something that really pleasantly surprised me about this programmer. What's odd is that nobody seems to have paid much attention to it.
The device can test logic ICs, as well as static and dynamic RAM chips.
This was a revelation to me, since I'd always thought of this device purely as a programmer.


Next I tested everything I could get my hands on. First, some basic logic.


Since most of our ICs (though by no means all) are equivalents of imported parts, you can test those too.
Then I tried a K537RU10 static RAM chip. It's an equivalent of the imported 6216, but I couldn't find that part in the list, so I tested it as a 6116.


Next was a 555IR27 shift register. But after testing two chips, the device reported an error both times. The errors were different for each chip, and the results were inconsistent. The chips had been soldered in and pulled out of some device, so they may have been faulty.


Let's try our KR1533IR9. We find the corresponding equivalent, and everything works perfectly.


I also came across a 155IE9V, and that worked fine too.


I also wanted to test our K565RU7 chips, but couldn't find an imported equivalent in the programmer's IC list :(
I also wanted to see whether the programmer could unlock ATtiny15L microcontrollers (and similar ones) with the reset pin disabled. But the chips I found weren't locked (or were unlocked), and the only ATtiny15L I found that couldn't be read or erased had been soldered in. Of course, I could try locking one first and then erasing it, but I don't have many of these controllers, and they're no longer available for sale, so I kept them as possible replacements.

That about covers it. I won't list pros and cons, since I really liked the programmer. Converting it to version A turned out to be extremely simple, while adding useful functionality. The fact that the programmer can test logic ICs came as a complete surprise. It may seem like a minor feature, but it's a very useful one for me. I probably won't test RAM chips, since I rarely come across them, but it could come in handy for troubleshooting.
The build quality is excellent too. The design is a little awkward to take apart, since the boards are soldered together in two places, but I doubt I'll ever need to disassemble it in normal use.

As promised, here's the software and driver, along with the firmware update utility, schematic, and list of supported ICs. The list is constantly growing, so it may already be longer. Download link.

With the TL866CSS coupon, the programmer costs $37. Mine ended up costing a little more, though, since there was no coupon at the time and I used points.

That's all for now. As always, I'm looking forward to your questions. And as a bonus, here's a little riddle: the first person to answer correctly gets a +1 to their karma (if I haven't already given them one).