About this Post
This article about the TinyCore board package from MCUDude is now my third article about board packages for the classic ATtinys. So why another one? In 2019, I wrote about the attiny board package from David A. Mellis. It works wonderfully but only covers part of the classic ATtiny family. In 2022, I dedicated an article to the great ATtinyCore board package from Spence Konde. Unfortunately, there is a problem with the latest version of the package and the Arduino IDE 2.x. In addition, the package does not appear to be maintained, at least at present. Good reasons to discuss an alternative.
TinyCore is based on ATtinyCore and comes with some improvements. The disadvantage is that TinyCore does not (yet?) support Digispark/Micronucleus boards, but this is the only drawback I have found so far.
Here’s what you can expect in detail:
- The classic ATtinys
- Pinout / Pinmapping
- Installing TinyCore in the Arduino IDE
- Burning the bootloader
- Uploading sketches
- Further features of the TinyCore board package
This article repeats much of what I wrote about the MiniCore package in my last article. Regular readers may find this boring, but each post should be understandable on its own.
The classic ATtinys
TinyCore covers the following classic ATtinys and boards based on them:
Although the ATtinys may seem a bit outdated due to their sometimes very limited RAM and flash memory, they remain very popular. From a technical point of view, the newer models of the tinyAVR® 0 to 3 series are almost always the better choice (article here). However, the classic ATtinys are favored by their enormous popularity and the associated high number of articles, tutorials, and forum posts. In addition, they are available as PDIP and have a relatively simple and therefore easy-to-understand architecture. In my opinion, they are definitely still worth their own article.
Pinout / Pinmapping
In this article, the ATtiny85 is my standard example. Here is the corresponding pinout diagram of the PDIP variant, which is also valid for the ATtiny45 and the ATtiny25:
Some of the pin functions are defined on the hardware side, others are assigned via the board package. The pinout diagrams of the other ATtinys can be found here.
Installing TinyCore in the Arduino IDE
Installation is completed in two minutes:
- Go to File → Preferences and click on the green icon next to “Additional boards manager URLs”.
- Then enter the following as a separate line:
- https://mcudude.github.io/TinyCore/package_MCUdude_TinyCore_index.json
- Confirm twice by clicking on “OK”.
- Then go to the boards manager via the board icon on the left-hand side of the program window. Alternatively, you can navigate there via Tools → Board → Boards manager.
- Enter “TinyCore” in the search field and choose “TinyCore by MCUdude” among the hits.
- Click on “Install” – and that’s it.
Problems? Then you will find detailed instructions for installing board packages here.
Burning the bootloader
In my last post about the MiniCore board package, I covered the basics of bootloaders, fuses and programming methods in quite some detail. If you need or are interested, take a look here. In this article, I would just like to briefly summarize again:
- For uploading programs to a “naked” ATtiny you can use an ISP programmer or a USB-to-TTL adapter.
- To use the USB-to-TTL adapter, you must first burn a bootloader. This in turn requires an ISP programmer. In other words, there is no way around the programmer.
- Burning the bootloader in the Arduino IDE means more than just uploading the bootloader to the flash. You also set the so-called fuses, which determine the clock rate and the clock source, among other things.
- Therefore: When changing basic settings, it is also necessary to burn the bootloader if you want to upload programs via ISP.
- If you upload a program via ISP, any existing bootloader will be deleted.
So, no matter which board or microcontroller you want to use with MiniCore, and no matter whether with bootloader or not: First you have to burn the bootloader.
The good news is: you can turn an Arduino board into an ISP programmer. The bad news is that the whole thing is quite fiddly and you can make mistakes in many places. I therefore recommend investing in a programmer. There are some available for just a few euros. Here you can find a list of programmers that I successfully tried out in my last post.
Burning the bootloader with an “Arduino as ISP”
In the following, I will show you how to turn a classic Arduino Nano into an ISP programmer. This also works with an Arduino UNO R3 and many other Arduino boards. There are a few differences in the details of some boards. There’s an article on this topic on the Arduino website that I definitely recommend reading.
Step 1: You select the Arduino Nano (the programmer) as the board in the Arduino IDE and connect it to the PC. Also set the correct port. It’s best to do this without connecting the Arduino to anything else.
Step 2: Go to File → Examples → Built-in examples, open the ArduinoISP sketch, and upload it.
Step 3: Connect the Arduino Nano to the ATtiny85 as follows (you don’t need the LED here yet):
If you are using a different ATtiny, find the MISO, MOSI, SCK, RESET, VCC and GND pins in the respective pinout diagram and wire it accordingly.
Step 4: Now select the TinyCore package and apply the following settings for the ATtiny85 (your target):
If you want to upload your sketches later via USB-to-TTL adapter, select “Yes” as option for the bootloader.
Step 5: Click on “Burn Bootloader”.
Using external oscillators
If you want to use an external crystal, connect the ATtiny as shown below and select the corresponding option for “Clock” when burning the bootloader. With an additional LED, pin availability on ATtiny85 gets tight. You will have to share a pin with MISO, MOSI, or SCK.
Burning the bootloader with a dedicated programmer
As mentioned before, burning the bootloader and uploading sketches via ISP is much easier with a “real” programmer.
The programmers have a 6-pin and/or 10-pin connector:
Connect the pins to their counterparts on the ATtiny.
As you can easily get confused with the pins, I recommend using an adapter for breadboard circuits:
In the above instructions for burning the bootloader, start with step 4 and set the correct programmer. For some programmers you have to select the correct port, other programmers do not appear under “Port” in “Tools”. You will need to install a driver for most programmers. You can read more about this topic in my last post.
Uploading sketches
Uploading sketches via ISP
Sketch upload via ISP is simple. Leave both the connection of the ATtiny and the settings in the Arduino IDE as they were when burning the bootloader. You start the upload via the keyboard shortcut CTRL/Shift/U or via Sketch → “Upload with Programmer”. It also worked for me with the “normal” upload (i.e., arrow symbol or CTRL/U), but I cannot guarantee that this will work with every programmer.
A blink sketch is suitable for testing. This will also show you whether everything is OK with the clock settings.
void setup() {
// Serial.begin(9600);
pinMode(PB4, OUTPUT);
}
void loop() {
digitalWrite(PB4, HIGH); // PB4 or 4 or A2
delay(1000);
digitalWrite(PB4, LOW);
delay(1000);
// Serial.println("Hello World");
}
The advantage of the ISP method is that you save the space for the bootloader in the flash. The Urboot bootloader used by TinyCore is comparatively slim at 256 bytes, but that is still an eighth of the program memory of the ATtiny2xx. The disadvantage is that you usually have no connection to the serial monitor via the ISP connection (a trick for the “Arduino as ISP” is described below). If you uncomment lines 2 and 11, you will not see any output.
And don’t forget: Uploading a sketch via ISP overwrites any existing bootloader.
Uploading sketches with a USB-to-TTL adapter
First of all, you need a USB-to-TTL adapter for uploading, which is available for a few euros. I recommend variants that have a DTR pin. In principle, you can do without one, but it’s inconvenient. I wrote a bit more about the adapters in my last post.
A prerequisite for uploading via USB-to-TTL adapter is the presence of the bootloader on your ATtiny. You cannot burn the bootloader with the USB-to-TTL adapter, but only with a programmer and the procedure described above. Select the option “Bootloader: Yes”. Once this is done, connect the USB-to-TTL adapter to the ATtiny as follows:
100 nF is generally recommended for the capacitor on the reset pin. If you don’t have one, you can try a larger one. For me it also worked with 10 µF.
If you don’t have a DTR pin, leave out the capacitor and the pull-up resistor on Reset. When uploading, wait until the message “Warning: Attempt x of 10: not in sync” appears and then briefly pull the reset pin to GND.
The USB-to-TTL adapter allows you to output to the serial monitor. To test this, uncomment lines 2 and 11 in blink_serial_test.ino.
Uploading via ISP and using the serial monitor
Of course, you can also upload your sketches via ISP and use the serial monitor with an additional USB-to-TTL adapter. You only need to connect the GND, RX and TX pins of the USB-to-TTL adapter. You connect VCC if the ATtiny is not already supplied with power via the programmer. I was able to connect the programmer and adapter at the same time without any problems. When switching between uploading and serial output, you must select the correct ports.
Saving SRAM
If you only want to output to the serial monitor but not send anything from it, you can select the “TX only” option under Serial in the settings. This saves 36 bytes of SRAM, which would otherwise be reserved for the RX buffer. And if you have enough flash, use the F macro: Serial.print(F("......"));.
Changing the TX pin
You can assign TX to another pin using Serial.setTxBit(PBn);. Call this function before Serial.begin(). However, this is irrelevant for the program upload. For this step, TX is on the preset pin. After the upload, you can reconnect TX.
Using the serial monitor via “Arduino as ISP”
I am not a fan of “Arduino as ISP”, but I would still like to show you a variant of this method that also allows you to use the serial monitor. The programmer uses SoftwareSerial.
I found this variant here in the German Arduino forum. First you have to download the modified version of the ArduinoISP sketch from there (alternatively, here from GitHub). The SoftwareSerial communication requires an additional data line. The RX of the programmer (i.e. the Arduino board) is preset to pin D4. You can change this in the first lines of the modified ArduinoISP sketch. TX of the programmer is preset to the virtual pin 99. If you want to send messages from the serial monitor to the target (the ATtiny), you must change this to a real pin and set up a data line.
Please note that the serial baud rate of the programmer is preset to 19200 baud. You must set this baud rate in the serial monitor, or you can change the default setting in the ArduinoISP sketch to setup().
And this is what a test sketch for your ATtiny could look like:
#include<SoftwareSerial.h>
SoftwareSerial softSerial(99, 4); // RX, TX - we don't need RX
void setup() {
softSerial.begin(9600); // set Baud 19200 in Serial Monitor!!!
pinMode(PB3, OUTPUT);
}
void loop() {
digitalWrite(PB3, HIGH);
delay(1000);
digitalWrite(PB3, LOW);
delay(1000);
softSerial.println("Hello World");
}
Note that RX is preset to the virtual pin 99 here.
The disadvantage of this method is a slightly higher consumption of SRAM for the RX and TX buffers. There is also a small additional consumption of flash memory.
Further features of the TinyCore board package
Actually, this was only the beginning, because up to now the article was only about basic settings and the program upload. I have already gone into a little detail about Serial, but not about I2C and SPI. Other important topics are Timer/PWM, the ADC, the EEPROM and Servo or Tone. The members of the classic ATtiny family differ quite significantly in terms of these functions. However, it would go beyond the scope of this article to go into this in detail.
The good news: TinyCore abstracts many of the functions. For example, in most cases you will not even notice whether an ATtiny has a “real” UART or I2C interface or not. TinyCore is also excellently documented. On GitHub you will not only find general information on the functions mentioned, but also detailed descriptions of the individual members of the ATtiny family. The numerous example sketches provided are also particularly helpful.
Other special features of the TinyCore package that I would like to point out are:
- Support of
printf(). - Implementation of pin macros, e.g.
digitalWrite(PIN_PB0, HIGH). - Settings for Brown-Out Detection (BOD).
- Non-erase option of the EEPROM when uploading sketches via ISP or when burning the bootloader.
- Calibration of the oscillator (OSCCAL).
How you can support me
If you liked the article and would like to support me, please click here to find out how you can do so. This way you can help keep this site free of advertising.