Assembled board shown for reference only - this is the listing for the BARE BOARD

Assembled boards with 1626, ATtiny3216 or the new ATtiny3226 are available in my other listing

This is a breakout board for the ATtiny 0/1/2-series with 20 pins. These feature the latest and greatest peripherals in a low cost tinyAVR package (in fact, they are in most cases cheaper than classic tinyAVRs), including the 3226, 1626, 826, 426, 3216, 1616, 816, 416, 1606, 806 - all the 20-pin tinyAVR 2-series, 1-series and 0-series ATtiny parts. These are highly capable and affordable ATtiny parts - prices are lower than most classic AVR ATtinys with the powerful megaAVR peripherals. These parts are fully compatible with Arduino using my megaTinyCore, too.

Available Versions

• Rev. B - yellow solder mask, designed for the 0-series and 1-series. Autoreset can only pulse PA0 low. As always, buy out our stock of Rev. B boards, and get our steel stencil ($25 value) absolutely free!
• Rev. C - blue solder mask, improved markings including both Port/bit, not just Arduino pin numbers. Gerbers for the stencil layer are available to customers.

The biggest change between Rev B and C is - they're narrower than the old ones: Now the rows of pins on the edges are 0.6" apart, the same width as a Nano - and you know what that means: You can also put machined pin header on them, facing down, and plug them into a Wide DIP socket, This works great with my prototyping boards, especially the new 1.5" x 4" DIP-48 ones. The machined pins are also far better for use with breadboards, since they don't deform te contacts in the holes like normal pin header. We switched to dark blue solder mask to improve readability of solder mask, pins are now marked with both the pin name in Pxn notation (eg, PB2 is the pin corresponding to bit 2 of PORTB, and can be referred to if using my Arduino core as PIN_PB2 - since the functions are based on this, using this notation makes it easy to port your design between tinyAVR parts with different numbers of pins.For example, you want to output some PWM on 2 pins, so you choose PB0 and PB1. You then want to move to a 1626 because you didn't have quite enough pins. If you referred to those pins by their numbers, you'd have to change that. But if you call them PIN_PB0 and PIN_PB1, those would be correctly identified and you could likely move between the 14, 20, and 24 pin parts without any code changes (and that is why I promote that system!). We also mark some of the common alternate functions next to the pins.

We have also improved markings around the groups of jumpers on the back for making use of the DTR and CTS linesBy default, CTS (which is an input to the serial adapter) will be tied to UPDI (also an input) but it allows a modified cable to connect to both UPDI and Serial (through two separate serial adapters), allowing you to use a modified 6-pin serial cable to conveniently connect both at once. It can also be left floating , tied to ground (some software expects the CTS line to be driven low and uses that as a way of detecting that it's connected to something. Finally it can be connected to PB0, the XDIR pin for USART0, which will be mighty convenient if you happen to be doing anything with RS485, now that the Serial class supports Serial.begin(57600,SERIAL_8N1 | SERIAL_RS485 | SERIAL_HALF_DUPLEX.

The reset enable jumper is now a pair which can route either the pulse to the UPFI/Reset pin (for autoreset) or to PB1, where you could detect it with a LOW level interrupt and trigger a reset based on it (Ersatz reset), or route a pulse to PB4 for the 2-series alternate reset feature.

This is a breakout board for all of the "modern" ATtiny parts in SOIC-20 pin packages. They are numbered like: ATtinymmd6 where mm is flash size is kb, d is the series, 0, 1 or 2, and the 6 indicates that it's the 20-pin version. The 8-pin parts end in 2, 14-pin ons end in 4, and 24-pin ones in 7 (my understanding is that the 14, 20, and 24 pin versions use the same die; a complication resulting from this may be the reason that we saw so few 8-pin tinyAVR parts released; within each series, parts of the same flash size and 14-24 pins have identical pinouts, provided that the pin exists on a given pincount (ie, PC0 has the same function on any part that has it).

All of the modern tinyAVR devices are highly capable and affordable - prices are lower than most classic AVR ATtiny devices (as with EVERYTHING since the 2016 AVR revolution) - while the peripherals use the latest and greatest technology (let's face it - the classic AVR peripherals had been getting a little stale. Actually, they'd been stale for a while). As far as I can tell, Microchip tests out their new technology on a tinyAVR before bringing it to a full sized chip most of the time. The tinyAVR 1-series brought us the Type D high speed async timer which then showed up in 2020 on the DA-series - and while the headline features of the DB-series were entirely novel, the only other changes that showed up in the DA/DB series were evolutionary. Now, in 2021, the amazing new fully differential ADC wth Programable Gain Amplifier (PGA) is featured on the 2-series tinyAVRs; this has been announced for the AVR EA-series line of full size parts for future release. These parts are fully compatible with Arduino using my megaTinyCore, and you can access the full functionality of the new ADC through a handful of new functions, or use analogRead() for backwards compatible ADC functionality.

Board Features (dependent on customer-installed parts)

• 1 LED connected to PA7 (Arduino pin 3)
• 1117-series or compatible voltage regulator
• series resistor for UPDI programming (recommended value 470 ohm)
• 3-pin header for UPDI programming
• 6-pin header for Serial (FTDI pinout)
• 3 Gnd and Vcc pins - easily power multiple devices from the breakout board without having to make Y-cables!
• All pins broken out to headers at 0.1 pitch
• Rev. C only: Autoreset can be routed to PB4 for alternate reset support.
• Rev. C only: New narrower form factor - same width as a nano!
• Rev. C only: Pads for a 3225 oscillator (not crystal) if you happen to need one.

ATtiny Features

• 17 usable I/O pins
• 1.8v~5.5v operation
• up to 32kb of flash
• up to 3k of RAM on 2-series, 2k on 1- series.
• Unified address space - no need to use PROGMEM or pgm_read_byte - anything declared const doesn't need to be copied to RAM!
• DAC (1-series parts only)
• Hardware SPI, TWI, and Serial. 2-series has 2 serial ports.
• 8 PWM pins exposed via Arduino core (6 pins on 2-series or 0-series, as they lack Timer D)
• Unique and powerful ADC:
• The 1-series has two 10-bitidentical ADCs, ADC0 (used by megaTinyCore for analogRead) and ADC1. I think they were meant to be triggered simultaneously to provide a standin for a differential ADC, but you can do other things, like use one normally while leaving the other in free running mode (maybe even with the window comparator enabled)
• The 2-series parts are the first modern AVRs with a true differential ADC with programmable gain. It's a 12-bit ADC, supporting single ended or differential input. The amplifier can be used in both single ended and differential mode, 1x, 2x, 4x, 8x, and 16x gain (1x appears to be meant as a buffer for high impedance signals). The ADC is lightning fast.
• All modern AVRs feature accumulation of multiple samples, but while the 0-series and 1-series only support 64 samples (and the DA/DB 128), the 2-series can accumulate 1024 samples. With the usual technique of oversampling and decimation, would permit 17-bit readings (realistically, not all of those bits are signal - some are just noise)
• Configurable Custom Logic (2 CCL logic blocks on 0/1-series, 4 on 2-series) and event system allow you to set up actions that happen without CPU intervention. It's almost like a very very small FPGA that's simple enough to program directly:
• Implement the PWM modulation like larger megaAVR parts could in the past
• Divide a clock by a power of two
• Configure the SPI port as slave, and use external jumpers to tie it to a CCL output pin, and use it to blast out timing dependent data with far less CPU interaction - not only can you clock out bits, use the CCL to listen to that pin, and choose between one of two timer channels, which would output a long or short pulsse (in other words, it should be possible to build interrupt driven neopixel output).
• Re-route serial ports onto other pins.
• On chip analog comparator or comparators (3 on 1-series, 1 on 0/2-series).
• Overclocks very well - 50% overclock at 5v is easy, and can be done even with the internal oscillator.
• Arduino wrappers for Event, Logic, Comparator, plua includes compatible Servo, SD card, WS2812 (Neopixel), and other libraries optimized for these parts.

BOM

* 4.7uF or as directed by regulator datasheet

** if Y1 is installed, cut the bridge between PA3 and the through hole normally connected to it for best results. 32 MHz is very possible with solid power supply and external clock.

If you plan to run directly off a battery (ex, a protected LiPo battery), but still want the PTC fuse protecting the power from battery, a 2512 0-ohm resistor can be soldered between the pads for the regulator tab and pin furthest from the fuse to jumper around the regulator; this will connect the fuse (and hence Vin header) directly to Vcc.

Additionally, you will almost certainly want some pin header. 1x3 for UPDI header, 1x6 for FTDI serial header. 2 1x15 headers for the I/O pins - recommend normal square header for use with DuPont jumpers, or machined pin header for use with breadboard. All 0.1" pitch. Beautiful, colorful pin header (looks great on social media posts) is available for an added fee.

Programming the modern tinyAVR parts

Unlike older ("classic") AVR microcontrollers, these new parts are programmed via "UPDI" single-wire interface based closely on half-duplex UART serial with autobaud (indeed, it would appear that the UPDI interface is simply a modified UART that always operates in half-duplex single wire mode with autobaud.

In the past the standard in Arduino circles was to use an Arduino Nano as the programmer, running "JTAG2UPDI" - unfortunately that firmware was always rather buggy, and unlike the analogous firmware for programming classic AVRs (Arduino as ISP), the source code is actively hostile to someone wishing to modify it. I worked for months and was never satisfied with the results. We now recommend using the SerialUPDI tool included with megaTinyCore (or pyupdi as a standalone tool - it works much the same way), with an ordinary TTL serial adapter, with the addition of a resistor and/or diode. We provide a number of configuration options that can be get the highest performance your hardware is capable of (it depends on the OS, the serial adapter and the hardware; 57600 baud works everywhere without any compatibility options, while 921600 baud almost always does. See the SerialUPDI guide

Optiboot and Autoreset

megaTinyCore supports the Optiboot bootloader for serial uploads (though you still need a UPDI programmer to bootload the board - our assembled boards are now available with optiboot preinstalled). Unfortunately, on all tinyAVR parts except the 20 and 24-pin 2-series, there is either a UPDI pin or a reset pin. If you make the pin reset, you need to use an HV programmer if you ever want to reprogram it with UPDI. The 20 and 24-pin 2-series parts have the option to use PB4 as the alternate reset pin (configured via fuses). We do not recommend the use of Optiboot on 14-pin boards or any 0/1-series boards. The experience is substantially better on the parts with alternate reset option. Note that support for routing the autoreset pulse to PB4 was added in Rev. C of this board.

More information on Optiboot and the tinyAVR 0, 1, and 2-series ATtiny parts is available in the megaTinyCore documentation.