Using the “ManRob” ATTiny Programmer / ATTiny Arduino Shield

I found this Arduino shield on eBay, recently, that will allow you to program the ATTiny 24, 44, 84, 13, 2313, 4313, 25, 45, and 85 from an arduino.

It looks like this:


and I purchased it here:

Although I don’t find any reference to “ManRob ATTiny Programmer” anywhere on the web, that’s what I’ve been calling it since that is what is etched on the PCB.

I will show how I got this shield running and used it to program an ATTiny84 and an ATTiny85.

Installing the Shield

The shield connects to the arduino pretty simply. I align the pins labeled 13 and RST. Once connected to my arduino uno, the 2 top left pins of the shield (first unlabeled, second labeled Ref) do not have a socket to connect into. That does not cause any problems.

Setting up Arduino to be an ISP Programmer

The next step is to load a sketch into the arduino to allow it to act as an ISP programmer.  Connect the arduino to your PC via USB as you normally would.

Start the Arduino IDE. Open the Arduino ISP sketch from the examples.

Take a look at the heartbeat function in this sketch. If there is a delay(20) in that function, change it to delay(40).

Select the appropriate board type and COM port for your arduino. Compile and upload the sketch to your arduino.

Here are some detailed instructions on doing this if you have trouble

Jump to the section titled Turning the Arduino into a Programmer.

Setup Arduino IDE to Allow Selection of ATTiny Boards

I did this for another project, so I’ll just point to that

(jump to the section titled Setup Arduino IDE)

The more official page for doing this is here:

When I did this this time, I placed the attiny directory in c:\users\documents\arduino\hardware and it worked fine.

Now when you start the arduino IDE and go to Tools | Boards, you will see a bunch of ATTiny boards.

Programming the ATTiny85 at 1MHZ

We are ready to write code to an ATTiny chip. I started with an ATTiny85, though the process is really the same for either the 84 or 85, but the test sketches are slightly different because the pins are different.

Load the blinky sketch from the arduino IDE examples. Change the LED pin from 13 to 0.

Now change the board to ATTiny85 (internal 1 MHz clock). Set the programmer to Arduino ISP. Compile and upload the sketch.

Note, when you upload the sketch you will get the message

please define PAGEL and BS2 signals in the configuration file for part ATtiny85

twice. This is OK.

Once the program starts executing on the ATTiny85 the test on the shield will start flashing at a 1 second interval.

Programming the ATTiny85 at 8MHz

It is possible to run the ATTiny85 at 8MHz using its internal clock. The primary reason for doing this seems to be to allow the ATTiny to make use of the SoftwareSerial Library. This library allows the ATTiny the ability to communicate serially without a UART chip. I may have to delve deeper into this in the future.

To use the 8MHz internal clock do the following (taken from

  • In the Arduino IDE, set the board to ATTiny85 (Internal 8Mhz).
  • Set programmer to Arduino as ISP.
  • Click on Burn BootLoader in the Tools menu

This will quickly come back with the same two warnings described above. That is normal.

Note that this does not actually burn a bootloader onto the chip. It is just setting the appropriate fuse bits on the ATTiny85 to let it know it should use the 8MHz clock speed.

Now to program the ATTiny85 for an 8MHZ clock, simply select the board ATTiny85 (Internal 8MHz).

If you compile/upload the blink sketch now, the test light should still blink at a 1 second interval.

Inconsistent Clock Settings

For fun, I configured the ATTiny to use the 8MHz clock (burning the bootloader to set the fuse bits). I then compiled and uploaded the blink sketch using the 1MHz board.

No errors are received doing this; however, delay no longer works properly since the real clock doesn’t match the clock selected during compile. In this case, the test light was flashing way faster than once a second (my guess would be closer to 8X a second).

Programming the ATTiny84

Everything I wrote about the ATTiny85 applies to the ATTiny84 EXCEPT one: the test LED on the ATTiny Programmer shield is tied to pin 6, not 0. So to make the blink sketch work on you must change the pin to 6. Otherwise, I was able to do everything to the 84 the same way I did it to the 85, including adjusting the clock.


This entry was posted in c-arduino and tagged . Bookmark the permalink.

1 Response to Using the “ManRob” ATTiny Programmer / ATTiny Arduino Shield

  1. Sean Straw says:

    If you’re serious about checking out the potential of software serial, you may want to check out the TinyISP-Tuner board by FriedCircuits. If you’re running a ‘tiny with a crystal, no biggie, but if you’re running from the internal oscillator, you could have slight variations in speed which can impact software serial. You need a FTDI (USB-Serial) interface to connect the programmer to your computer, and it has three sockets right on it much like the board you’re using has, but it also has an ATMega328 onboard, loaded with a sketch which can characterize the speed of the uC and store a timing profile in the uC’s EEPROM. I purchased the board off of Tindie as a assemble-it-yourself kit and it was a simple build.

    I use ICSP directly for programming my ATTiny projects – I add the 6-pin header to my board layouts so that I can reprogram the uC in-situ. This requires some planning/experimentation to ensure certain pins as used by the programming process itself don’t fire off some driven circuit, but it’s really handy being able to fab a board and solder in all the components and still be able to change the program (and not having to have the uC itself in a socket). Next progression is using pogo pins for ICSP and doing away with the header pins on the PCB entirely (six fewer holes to drill, no header to solder, more compact).

    Note that you can purchase SOIC-to-DIP adapters, that enable you to plug the adapter into the programmer board and then clip a surface-mount device into the adapter to program it (also useful for prototyping on a breadboard with an SMD). Once you start using SMD uCs, ICSP is a must, because you can’t really socket the uC and remove it to stuff it into a programmer. You could adapt your programmer to do ICSP by fabbing a DIP-8 socket adapter to grab the ICSP signals (Vcc, GND, SCLK, MOSI, MISO, RST) and run them to the appropriate 2×3 berg header. Or, if like me, you don’t really use the x13 series, perhaps fab it for the pinout of the x13 socket, which might permit the adapter to just live in the socket and never/rarely be in the way. The ICSP signals are the same, it’s just a matter of the uC pinout.

    My original ATTiny programmer (and which I still make periodic use of) was a shield I laid out on perfboard with a series of ICSP headers that ran the necessary signals to the appropriate pins on a single ZIF socket. Plugs into a host Arduino (loaded with the Arduino-as-ISP sketch, though required no hacking of it), and the programming pins from the host are exposed to an ICSP header (2×3 berg strip) on the shield. I have a suitable cable plugged into that, which I then either plug directly into my external PCB project, or plug into one of the other headers on the programmer board (x4 vs x5, vs x28 currently, though I have a spare header for future wiring). The ZIF makes it more pleasant to reprogram a device without jamming it into some overworked socket, which sometimes can result in a bent pin. I figure about the time I go to add another target (the x13, or even the model with the build-in voltage booster), I’ll lay it out in KiCAD and fab a new one as an etched PCB (which will be so much easier than the series of wires I ran from each of the ICSP headers). Honestly though when I use it these days, it’s as ICSP driver most of the time, though I use an inexpensive (circa US$3 from China) USPasp programmer for that on the system I do most of my work from, and that doesn’t suck up an UNO to drive, and if it were to become necessary to pre-program a batch of uCs, I can plug the ICSP cable from the USPasp into the appropriate ICSP header on my shield (sans host Arduino) and program a bare uC that way.

    It’s really a bit sad to see programmer devices that don’t expose an ICSP header on them. Even the TinyISP-Tuner has an ICSP header, though it’s there for the purpose of reprogramming the ATMega uC and isn’t tied to the ATTiny sockets…

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.