Last Chance Sale: Prices on "Last Chance" variants cut

While supplies last, get a free Rev. D bare PCB with the purchase of any "Last Chance" board.

Convenient, basic development/breakout board for new ATtiny1624, ATiny3224 (yes, 32k of flash!), 1614 (any modern tinyAVR with part number of the form (expressed here as a regex) ATtiny\d\d?[012]4 can be mounted on the bare board (available here, as those are all pin compatible 14-pin parts made in SOIC. These are not usable with the new EB14 or DD14 parts - we'll be introducing new boards based on those soon.

Over the past half decade Atmel/Microchip has been releasing AVR microcontrollers based on an all new set of peripherals, the megaAVR 0-series and tinyAVR 0/1/2-series, as well as the newer Dx-series. These use the familiar AVR instruction set and open source avr-gcc compiler used with the classic AVR microcontrollers, but with redesigned and more capable on-chip peripherals and highly competitive prices. The AVR instruction set has been given a significant performance tuneup, with a handful of the most important instructions executing in a single clock (push, pop, std, call, rcall) plus sbi and cbi are now single clock instructions. It se happens that the memory access instructions are the most used instructions so code runs slightly faster. The best known of this new line of chips (among hobbyists, at least) is the ATmega4809, used on the Arduino Uno WiFi Rev.2 and Nano Every. However, there is also an extensive line of tinyAVR parts based on this new architecture, ranging from 8-pin to 24 pin packages, with up to 32k of flash and 3k of RAM (yes, an ATmega328p would back away slowly if it met one in a dark alley).

With my megaTinyCore, there is full Arduino IDE support for these, and almost all libraries are either compatible, or have a compatible bundled version included with the core.

Even more exciting, the 2-series (with a 2 in the tens place) introduces the first true differential ADC with programable gain on an avr since the tiny841 - resolution was improved to to 12 bits from 10, accepted voltages range can go a fraction of a volt outside of the power rails for high side current sensing and similar applications, and features 1024-sample automatic accumulation, allowing oversampling and decimation to reach 17 bit accuracy (though the lower bits in that case depend on careful power supply and reference decoupling). With the release of the 3224, we've dropped the 1604, which was a strictly worse version of the 1614 with about the same price tag. So we now carry assembled boards with the 3224, 1624, and 1614 (the parts are available down to 4k with the 2-series and 2k on 0/1-series - but for piddling discounts that only matter if you're making thousands of them. )

All of these breakout boards come equipped with your choice of 3.3v or 5v regulator (LDL1117) so that it can be supplied with an external supply higher than it's operating voltage (minimum dropout as low as 0.35v - maximum power dissipation can be around 1 watt in the regulator); the input to the regulator is the two pins in the lower left corner. an LED (on pin PA3), and a UPDI programming header (with the 470 ohm resistor on the board to allow safe programming using programmers like many self-made JTAG2UPDI units that did not include any such resistor (this can be bypassed with the RBP solder bridge jumper on the back). There is a 1x6 pin "FTDI"-style serial header on the bottom edge of the board. Autoreset circuits are included, but except on the older boards, these components (10k resistor, 0.1uF Cap, and a diode in SOT23 package) are not installed because of the awkwardness of their use - there is a single pin that can be ether reset or UPDI, but not both: To program a board set to enable reset with UPDI (for example, to turn the reset pin back into UPDI, an exotic HV UPDI programmer is needed.

All pins are broken out, and there are 3 Vcc and 3 Gnd pins available, plus the ones on the UPDI and Serial headers so even if you're not using breadboard, you can still easily connect power and ground for multiple external devices.

Board dimensions are 1.4" x 0.75" with the rows of pins 0.7" center to center for the Rev. B. Rev. D boards (with the darker solder mask for more readability) are slightly narrower, with the rows of pins 0.6" center to center, so you can use them with wide SOIC sockets or should you wish to.

These boards have pads for a 3225 external clock if desired. We previously planned to offer to install these, but since the boards came back and passed tests with external clocks we tested with, we have not been able to source suitable external clocks in 3225 packages which are rated to work over more than a very narrow range of voltages. Knowing what voltage it will be run on (which I don't know) in some cases you can find a suitable clock, other times not really - but it is incredibly rare to need a better timebase than the internal oscillator, which is often within half a percent out of the box. So yeah, not as useful as i'd hoped. They were available when I designed the board, I swear!

[This is available as a bare board (supporting all the x24, x14 and x04 parts) here.]

ATtiny1614 features and Arduino support

• 16Kb flash, 2k SRAM, 16/20 MHz
• 11 available I/O pins
• 6 PWM pins with 8-bit resolution.
• Servo, Tone, Serial, SPI and Wire (I2C) support "just works".
• 2 Type B timers - so Servo and Tone can both be used simultaneously, or one or both can be taken over for input capture, periodic interrupt, or other functionality.
• DAC output (just do analogWrite() on the DAC pin - voltage is between 0V and the DAC reference voltage; that can be set to any of the internal ADC references with the DACReference() function; no, you can't use the supply voltage as the DAC reference).
• 1 type D timer that could generate verty sophisticated PWM waveforms, but all the pins it could output on are also used by TCA0 and it is fiendishly difficult to program (longest chapter of the datasheet, and it's still terse in critical areas). Since few people will take on reprogramming it, megaTinyCore defaults to using it for millis.
• 10 analog inputs (Counting A0, the UPDI pin, which can be used to measure analog voltages as long as they don't look like the start of a updi programming sequence, referenced to Vcc, external reference, or one of the 5 built-in analog references, through analogRead() as normal
• A SECOND ADC, ADC1. megaTinyCore doesn't configure or interact with it in any way... (though functions are provided so you could enable it with the same settings) so you could put ADC1 into freerun or WCOMP made, while continuing to use analogRead elsewhere (which uses ADC0)
• Configurable custom logic: you get a pair of 3-input "Configurable Custom Logic" blocks which can be be entirely asynchronous (faster than the system clock). The inputs can be taken from pins, the event system, or from a number of internally generated signals from most peripherals (you can, for example, output the logical AND of two PWM signals like the output compare modulation feature on some classic AVRs - these timer inputs are probably the most useful). The core includes the Logic library, which provides a consistent interface across all modern AVR parts, including a number of examples, including squeezing an extra PWM channel out of TCD0, moving PWM pins around, and so on.
• Event system - 6 channels that can route certain events between peripherals (this, for example, is how you do input capture now - instead of there being a single pin that's also the only pin for other important things, you use the event system to route any pin to a timer. megaTinyCore includes the Event library which provides a consistent interface across all of the modern AVRs (the behavior of logic changed significantly between the 0/1-series and... basically every other modern AVR).

Differences between 1624/3224 and 1614

• A single MUCH fancier ADC - a lot more useful than two copies of a more basic one. 12 bit resolution, capable of true differential measurements, faster conversions, and with a programmable gain amplifier, the first release since Microchip bought out Atmel to feature any of those. It has hardware accumulation so you can do oversampling and decimation from a single "start conversion" command to sum up 1024 readings, which can then be "decimated" to get a 17 bit result. And unlike most Arduino cores, megaTinyCore exposes that functionality through a few simple new functions, while still maintaining backwards compatibility so analogRead() works normally - taking that aforementioned 17-bit accumulated reading is as simple as analogReadEnh(pin,17); ("enhanced analog read of 'pin' to 17 bits of resolution") - or if you wanted that to be a differential reading? analogReadDiff(positive_pin,negative_pin,17); You wanted to amplify that by 16x using the PGA too? `analogReadDiff(positive_pin,negative_pin,17,16); - there is a detailed reference for the exposed functions surrounding the ADC included with the megaTinyCore readme Of course, analogRead(pin) will still by default give you a 10-bit reading, though you can, as usual, switching between the resolutions supported in hardware for a single conversion (8 or 12 - the 10 is a compatibility shim that takes a 12 bit reading and drops the two LSB). Note that I make no claims as to how many of those extra bits you get from oversampling and decimation are noise vs signal - it doesn't take much to throw off a 17-bit ADC measurement.
• 16k flash, 2k SRAM for them 1624, while the 3224 has 32k flash and 3k SRAM)
• A second hardware serial port (Hurrah!)
• Same PWM, Servo, Tone, Wire, SPI libraries work
• 2 type B timers (on all sizes of flash now - 1-series parts only had them on 16k parts)
• Twice as many CCL logic blocks or "LUTs" (Microchip likes that abbreviation, which refers to the truth look-up tables for the logical operation). I've used these to make a "splitter" to allow centralized control of non-daisychainable fairy-light style WS2812 strings (ie, send first 100 pixels down string 1 second 100 down string 2, and allow daisy chaining of the rest. )
• Slightly better overclocking (1-series could reach 25-30 MHz with the internal oscillator typically, while most extended temperature range 2-series parts will hit 32 MHz no problem.)
• These aren't a strict upgrade, as they dropped a couple of features, which I suspect were there to field test ones going into the Dx-series:
• No DAC, No Type D timer
• Only 1 analog comparator - but with more pin options

Arduino support

In addition to the usual amenities to be expected for Arduino cores, we've included support for tuning the oscillator. See our tuning doc for the full details, but this permits significant overclocking with the internal oscillator, as well as wacky speeds like 14 MHz if you like making life harder on your self, and we support dividing the speed down as low at 1 MHz

We also sell a board in the same spirit for the 24-pin (ATtiny parts with part numbers ending in 07, 17, or 27) and 20-pin (ATtiny parts with part numbers ending in 06, 16, or 26) 0/1/2-series tinyAVR parts, and for the 8-pin (part no. ending in 02 or 12) 0/1-series ones. Bare boards are also available in those sizes as well.

Recommended Pins

In some of the pictures shown above, the boards are shown with pin header (not included) attached. We recommend:

• For prototyping w/out breadboard: Two 1x9 pin male pin header for the rows of pins on the sides (in picture, 1x6 in black, for the I/O pins, 1x3 green and red for ground and vcc pins - colored pin header can be had cheaply on ebay)
• For use with breadboard 2 1x9 "machined" pin headers are recommended. The full-size 0.1" header deforms the clips in the breadboard, making the holes it is plugged into unreliable when using things with smaller pins.
• A 1x6 pin header for the serial port (standard FTDI pinout) - I recommend 90-degree angled male pin header.
• A 1x3 pin header for UPDI programming - I find straight pin header more convenient on breadboard (so the cable doesn't get in the way as much), and angled header more convenient if not using breadboard (for the same reason).

We offer an optional colored pin header kit containing:

• 1x3 red and green - for the Vcc and Gnd pins
• 2 pcs 1x6 - for the I/O pins
• 1x6 yellow, 90 degree angle - for the serial adapter
• 1x3 white, 90 degree angle - for connecting a UPDI programmer

Programming the tinyAVR 0/1/2-series parts

There are two approaches to programming these parts:

UPDI

Unlike "classic" AVR microcontrollers, these new parts are programmed via a "UPDI" single wire interface instead of the SPI-based ICSP protocol. You can easily make a UPDI programmer from (almost) any serial adapter with a schottky diode or 4.7k resistor, (I found that the diode worked far better - some people disagree and the matter has not yet been fully explained). As of the most recent releases of my megaTinyCore which improved performance using this method (it now leaves jtag2updi and Microchip's official programmers in the dust), this is what we recommend; see the instructions here;

The 2.4.0 release has further improved compatibility with a wide range of serial adapters by ensuring that the non-TURBO mode (turbo mode being "go faster at all costs, including buying inexpensive serial adapters (Blue DeekRobot FT232RL and black CH340G with voltage switch are both great adapters for this); the DeekRobot RT232RL boards even have an A that don't suffer from implicit latency) does not implicitly use the USB latency to give the chip a chance to perform the page write, making it work with (almost) all adapters. The performance will fixed back up in a future version to get rid of most of the performance penalty (up to 1 second per upload).

Make UPDI programmer from either a serial adapter and a diode, or a Nano/ProMini/Uno

The order of the pins on the UPDI header is UPDI-Gnd-Vcc - this means that if the programmer is connected backwards, the board will not be damaged. The 470 ohm resistor is compatible with all three of the most plausible options: SerialUPDI ( resistor is on the breakout board; you do not need to (and should not) use another one.

A typical development configuration might have the board connected to a serial port via the 6-pin serial header for serial debug, and to the UPDI programmer via the 3-pin header for uploading new code (as shown in the pictures). This is generally how we use it, and is what we recommend.

Serial (Optiboot bootloader)

The Optiboot bootloader is supported for all parts; this works with an external serial adapter (like the 6-pin ones used for the Arduino Pro Mini). Optiboot takes up 512b of flash for the bootloader. In addition to obliviating the need for a UPDI programmer to upload sketches (though note that the same serial adapter could also be used as a UPDI programmer, Optiboot allows you to use the same port for upload and serial monitor like a normal Arduino board.

There are two general approaches to using Optiboot on these parts:

1. Without auto-reset, UPDI enabled. On all boards that do not support auto-reset, and on boards that do if this option is selected, the UPDI/Reset pin will be left as UPDI, and the board can be freely reprogrammed via UPDI. The version of the bootloader installed will be active for 8 seconds after power on, or after a WDT or software reset. So for example, to upload, you would verify sketch, unplug, plug back in, and then upload - or alternatively, you could adapt your sketch to trigger a software reset. UPDI programming will still be possible. Note that for these boards, you must use UPDI to "burn bootloader" with the non-optiboot board definition selected if you want to switch back to uploading sketches via UPDI

2. With auto-reset, no UPDI. On boards which do support auto-reset (if using optiboot), you may elect to order the board with or without that enabled. If it is, the bootloader will not run on power on; it will only run after a "hardware reset" - it will not run after a normal power on reset. Only after external (reset pin) or software reset; this mimics the behavior of a classic bootloader on (for example) an ATmega328p, and coupled with autoreset provides a very smooth user experience. Warning: This comes with a very large downside: if this option is chosen, you cannot reprogram the board via UPDI unless you use an "HV UPDI" programmer. The RST_EN solder bridge must also be disconnected prior to that.

A third approach is to upload sketches which all have a means of triggering a "software reset" from within the sketch, either from a pin interrupt (the existing autoreset parts could be wired to this pin). With other trigger mechanisms, this could be used in more advanced deployments, such as a device at the far end of a serial line, which resets in response to a specific command0). These schemes allow one to use the bootloader without power cycling the board while also permitting use of UPDI programming - however because they depend on the sketch, they are inherently more "brittle", and that UPDI programming option may become necessary to revive boards during development - in the event of bugs in the application. This method is beyond the scope of this product listing.

If purchased without the bootloader installed, if you later decide that you want it, you may install it using a UPDI by doing burn bootloader (if using autoreset and UPDI pin set as reset, the jumper on the back must be closed after bootloading); this pre-bootloading service is intended only as a convenience.

Boards with optiboot preinstalled are bootloaded at the time the order is received. All boards are set to 20-MHz speeds

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

Regulators and power supply - do I want a regulator?

The linear regulators offered can provide a regulated operating voltage provided Vin in at least 1.3v (ZLDO1117) higher than the operating voltage. These regulators are appropriate when your current requirements are relatively low, and you have access to a power supply with a voltage higher than the operating voltage (max 18v input) - maximum power dissipation, however, is only ~ 1.2W without adding heatsinks, (that is to say (Vin - Vout)*(current) < 1.2W) so the practical maximum current is much lower.

Example calculations of maximum current when using the regulator:

Vin=12v, Vout=5v. Vin-Vout=7V. 7V*I < 1.2W -> I < 1.2W/7V -> I < 170mA

Vin=7v, Vout=5v. Vin-Vout=2V. 2V*I < 1.2W -> I < 1.2W/2V -> I < 600mA

Only the Vin pin goes through the regulator - all other Vcc pins (including the UPDI and FTDI headers) are connected directly to the Vcc rail - so if you have a 3.3v regulator, but connect a 5v serial adapter's 5v line to the board, the board will be running at 5v (this will not harm the board itself, as long as the voltage does not exceed 5.5v - but if you have 3.3V devices connected to it, those may be harmed, so if you have any of those connected, you must use a 3.3v serial adapter, or disconnect the 3.3v parts during programming. and not connect the 5v pin of the serial adapter (the data lines are fine, as serial adapters almost universally have a 1k - 2.2k resistor in series with the TX line, while the RX line is only weakly pulled up and can be handled by the protection diodes which will limit the current to a non-dangerous level, or disconnect the 3.3v devices from the board before connecting the 5v to the board's Vcc), whereas if you supply 5v to the Vin pin of a 3.3V board, the board will be running at 3.3v. The regulators we use have astonishingly low dropout voltages; you will lose little if any voltage, even with just 3.7v powering a 3.3v board! (typ full load dropout spec'ed as 350 mV.

However - a regulator has a quiescent current that it draws to power itself The LDL1117 we use now burns around 0.25-0.4 mA. This is an order of magnitude better than most 1117's, but its still multiple orders of magnitude more than these chips will consume in sleep. Hence, if you are running on batteries and using power saving techniques, you want to avoid having a regulator on the board if possible. For example, if running off a LiPo/LiIon battery at 3.7~4.2v, you could set it to run at 10MHz, and use no regulator - approximate power use with a regulator (whether or not you power through the regulator or connect power direct to Vcc), the sleep mode power down current will be ~0.25mA (almost all from the regulator), whereas without the regulator, current in sleep mode power down will be ~0.1uA (0.0001mA) at room temperature - that is, for a project where the chip will spend most of it's time in sleep mode power down, the battery life may be 2,500 times longer without the regulator.

If powering from batteries w/out a regulator, you need to be careful not to connect external power directly to Vcc (including from a serial adapter or UPDI programmer) while the battery is connected.

On boards where there is no regulator, the PTC fuse is still present (in series with Vin), and the regulator is bypassed by a 0-ohm resistor, so you can still use the Vin pin power the board to get the benefit of overcurrent protection. See picture 3 for an example of what the "no regulator" looks like.

Note on resistor values

Early versions of this board used a 4.7k resistor. This is an inappropriate value, this was pointed out to me before SerialUPDI existed, and since then (spring 2020) I've been shipping boards with the correct 470 ohm resistor.