To enable the Arduino IDE Serial Monitor on a Digispark ATtiny85 board, connect a USB-to-Serial converter. Then use the SoftwareSerial library in the Arduino IDE to create a UART port on the ATtiny85 chip.

For Digispark ATtiny85 pinout guide, kindly see Digispark ATtiny85 Pinout and Configuration.

Step by Step Guide For Serial Monitor

STEP 1 – Connect a USB-to-Serial Converter

First, connect a USB-to-serial converter to the Digispark ATtiny85 board as shown in Figure 1 and Figure 2.

There are many inexpensive USB-to-serial converters on the Internet. Examples of USB-to-serial converters are shown below in Figure 3. These converters are sometimes referred to as USB-to-serial TTL converters or USB-to-UART converters. Also, the converters use a variety of chips, hence, they may be referred to by their chip names. Some of the popular USB-to-serial chip names that you may encounter are FTDI, CP2104, CH304, and PL2303.

STEP 2 – Install the USB-to-Serial Converter Device Driver

Download and install the device driver for your USB-to-serial converter. Because USB-to-serial converters use different chips, you need to search the internet for the device driver for your particular USB-to-serial converter.

You can do a quick test if you have the right device driver installed. Open the Arduino IDE and go to the Tools/Port menu. You should see an additional port instead on only COM1 on the Serial Ports list when you plug in your USB-to-serial converter. Please see Figure 4.

STEP 3 – Install the Board Core ATTinycore by Spence Konde

Although we may use the original Digistump AVR board core, I prefer to use the ATTinyCore as it supports almost all of the ATtiny line of AVR chips. Additionally, the ATTinyCore gives us the option to program the ATtiny85 in several ways: no bootloader, Optiboot, and Micronucleus (Digispark) modes. If you need help in installing the ATTinyCore, please see How to Install ATTinyCore on Arduino IDE.

STEP 4 – Use Software Serial to Create UART Ports on ATtiny85

Open the Arduino IDE and upload the sketch shown below. If you need help in uploading the sketch using the board core ATtinyCore, you may visit How to Program Digispark ATtiny85 Board with Arduino IDE.

IMPORTANT NOTE
Before hitting the Upload button to install the sketch, unplug both USB cables for the Digispark board and the USB-to-serial converter. Plug in the USB cable for the Digispark board when prompted by the Arduino IDE. When the sketch upload is done, unplug the USB cable from the Digispark board. Connect the USB cable for the USB-to-serial converter and proceed to STEP 5 for testing the Serial Monitor.

/* cyberblogspot.com 15Jan2023 */

#include "SoftwareSerial.h"

SoftwareSerial mySerial(1, 0);  //RX, TX  PB1, PB0

void setup() { 
  mySerial.begin(19200);
  
  mySerial.println("Change baud rate to 19200");
  mySerial.println("Type something and press ENTER");
}

void loop() {
  if (mySerial.available()){
    mySerial.println(mySerial.readString());
  }
}

The sketch above needs no explanation. Simply include the library header file for the SoftwareSerial library. You do not have to download the SofwareSerial library as it should come with the ATtinyCore board core installation.

Regarding the code creating the SoftwareSerial object in line 5,

SoftwareSerial mySerial(1, 0); //RX, TX PB1, PB0

you may use any two (2) available ATtiny85 ports available. In this case, I used PB1 for RX (receiver) and PB0 for TX (transmitter).

STEP 5 – Test the Serial Monitor

After uploading the sketch to the Digispark ATtiny85 board, unplug the USB cable from the Digispark board. Plug in the USB cable for the USB-to-serial converter.

Then, select the correct COM port for your USB-to-serial converter in the Arduino IDE “Tools/Port” menu. Test the program and you should now be able to use the Serial Monitor on the Digispark ATtiny85 board.

References on How to Enable Serial Monitor on Digispark ATtiny85

USB-to-serial adapter – Wikipedia article on USB to Serial Converter
How to Install Arduino IDE on Windows 10
How to Install ATTinyCore on Arduino IDE
How to Use Arduino as ISP Programmer
How to Program ATtiny85 with Arduino IDE
Digispark ATtiny85 Pinout and Configuration
How to Program Digispark ATtiny85 Board with Arduino IDE
Digispark USB Device Not Recognized
How to Use AT-09 BLE with Arduino and Smartphone

The post How to Enable Serial Monitor on Digispark ATtiny85 appeared first on CyberBlogSpot.

To use an Arduino board as an ISP programmer, simply upload the Arduino IDE example sketch named “ArduinoISP”. Next, connect the SPI pins of the Arduino board to the MCU chip or MCU board to be programmed. Then, you can start using the Arduino board as an ISP programmer.

To illustrate the steps for the procedure, first, I will make an Arduino Nano board into an ISP programmer. Then, I will show how to upload sketches and burn bootloaders to a Digispark ATtiny85 development board.

Step by Step Guide on How to Use Arduino as ISP Programmer

STEP 1 – Connect your Arduino board to your computer’s USB port.

Connect the Arduino board of your choice to your programming computer hosting the Arduino IDE. In the next several steps, we will upload the ArduinoISP sketch to the board to make it an ISP programmer.

STEP 2 – Open your Arduino IDE and open the ArduinoISP sketch.

Open your Arduino IDE. If you are a beginner and you have not yet installed the Arduino IDE, please see How to Install Arduino IDE on Windows 10. On the Main menu, select File/Examples/11.ArduinoISP/ArduinoISP.

You should see the screen shown below after clicking on the ArduinoISP on the Built-in Examples menu.

STEP 3 – Choose the name of your Arduino board from the Board Manager’s list.

Go to Tools/Board/Arduino AVR Boards and select the type of Arduino board you are using. As shown in the screenshot below, I chose Arduino Nano for my Arduino board.

STEP 4 – Set the proper COM serial port for your board.

On the Tools menu, select Port. Then select from the serial ports list the appropriate port for your Arduino board.

STEP 5 – Click the Upload button.

As a final step for uploading the ArduinoISP sketch to the Arduino board, click on the Upload button.

When you see the message “Done uploading”, congratulations!!! You now have a full-pledged ISP programmer.

In the following steps, we are going to show how to use the Arduino board acting as an ISP programmer to:

• Program or upload a sketch to a Digispark ATtiny85 board
• Burn an Optiboot bootloader
• Burn a Micronucleus bootloader

STEP 6 – Connect the ISP programmer (the Arduino board) to the Digispark ATtiny85 development board.

Like in any other ISP programmers, including the popular USBtinyISP and USBasp programmers, we use six (6) terminals of the ISP programmer to connect to the device to be programmed. These terminals are:

• MOSI
• MISO
• SCLK
• RESET
• VCC
• GND

On the Arduino board acting as an ISP programmer, the corresponding terminals are as follow:

• D11 (MOSI) —> MOSI
• D12 (MISO) —> MISO
• D13 (SCLK) —> SCLK
• D10 (SS) —> RESET
• 5V —> VCC
• GND —> GND

Now, based on the foregoing discussion, we can connect the Arduino board to the Digispark ATtiny85 board using the following terminals:

Arduino Board —> Digispark ATtiny85 Board
D11 (MOSI) —> PB0(MOSI)
D12 (MISO) —> PB1(MISO)
D13 (SCLK) —> PB2(SCLK)
D10 (SS) —> PB5(RESET)
5V —> 5V
GND —> GND

For reference purposes, the Digispark ATtiny85 development board pinout is shown below. For more information on Digispark ATtiny85, you may consult the Digispark ATtiny85 Pinout and Configuration.

Shown below is the Fritzing breadboard diagram for connecting the Arduino Nano board to the Digispark ATtiny85 board.

How to connect the Arduino Nano board to the Digispark ATtiny85 board illustrated by an old-school schematic diagram.

After connecting the Arduino board to the Digispark ATtiny85 board, we are now ready to test drive the Arduino board as an ISP programmer.

Since we are going to work with the Digispark ATtiny85 board, you must have the board core ATTinyCore by Spence Konde installed on your Arduino IDE. If you do not have the ATTinyCore installed yet, see the article How to Install ATTinyCore on Arduino IDE.

STEP 7 – Copy and Paste the Blink Program.

Going back to the Arduino IDE, create a new sketch and then copy and paste the Blink program sketch shown below.

/*
www.cyberblogspot.com
07Jan2022  
*/

#define LED_BUILTIN 1  //PB1 for Model A
                       //PB0 for Model B

void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}

STEP 8 – Change the board from Arduino board to Digispark ATtiny85 board.

Go to Tools/Board/ATTinyCore and select ATtiny25/45/85 (No bootloader). Take note that we are using the “No bootloader” option and NOT the “Micronucleus/Digispark” option. This is because we are going to upload the Blink sketch via an ISP programmer (the Arduino board) and not thru the Digispark’s USB port.

STEP 9 – Select the proper COM port.

Go to Tools/Port and choose the correct COM port from the ports list.

STEP 10 – Select the programmer type.

On the Tools/Programmer menu, select Arduino as ISP as the programmer type.

STEP 11 – Upload the Blink program.

Upload the Blink program by clicking on the Upload button.

When you see the message saying that the upload is done, your Digispark ATtiny85 board should start blinking the built-in LED.

How to Burn Bootloader on Digispark ATtiny85 Using Arduino as ISP Programmer

Burn Optiboot Bootloader

STEP 1 – Select ATtiny45/85 (Optiboot) from the ATtinyCore list.

STEP 2 – Verify that the proper COM port is selected.

STEP 3 – Make sure that the programmer selected is “Arduino as ISP”.

STEP 4 – Click “Burn bootloader” to start the burning process.

Burn Micronucleus Bootloader

To burn the Micronucleus bootloader onto the Digispark ATtiny85 board using the Arduino as ISP programmer, follow the steps above for burning the Optiboot bootloader. However, instead of selecting ATtiny45/85 (Optiboot), select ATtiny85 (Micronucleus / Digispark) from the ATtinyCore list of supported devices.

References on How to Use Arduino as ISP Programmer

In-System Programming (ISP)
How to Install ATTinyCore on Arduino IDE
How to Program ATtiny85 with Arduino IDE
Digispark ATtiny85 Pinout and Configuration
How to Program Digispark ATtiny85 Board with Arduino IDE
Digispark USB Device Not Recognized
How to Use AT-09 BLE with Arduino and Smartphone

The post How to Use Arduino as ISP Programmer appeared first on CyberBlogSpot.

Types of Digispark Boards

Figure 1 shows the two (2) popular versions of the Digispark ATtiny85 development boards. The one on the left uses a type-A USB connector to connect directly to the USB port of a PC or a laptop. On the other hand, the board on the right has a micro-USB connector. As a result, we need a micro-USB cable to connect this to a computer for programming purposes.

It should be observed that both boards have the same pin layout. We can breadboard them as long as we do not connect a header pin to the VIN terminal.

Figure 2 is a picture of another type of Digispark ATtiny85 board. As shown in the picture, the board does not have an ATtiny85 chip but instead only an 8-pin DIP socket. We must provide a DIP-type ATtiny85 chip in order to use this board. Also, the pin layout of this board is different. This board is not breadboard friendly. However, the pin layout is ICSP-programmer ready. That is, the pins are arranged so as to accept the female connector of an AVR ICSP-programmer.

It must be mentioned here that technically, this board is not (yet) a Digispark ATtiny85 board. A Digispark ATtiny85 board has an ATtiny85 chip that was burned with a Micronucleus bootloader. In order to make this board a Digispark board, it needs an ATtiny85 chip that was pre-programmed with a Micronucleus bootloader. Otherwise, an ATtiny85 without a bootloader can be inserted into the DIP socket and an ICSP programmer is used to burn a new Micronucleus bootloader into it.

Digispark ATtiny85 Specifications

• Support for the Arduino IDE 1.0+ (OSX/Win/Linux)
• Power via USB or External Source – 5v or 7-35v (12v or less recommended, automatic selection)
• On-board 500ma 5V Regulator
• Built-in USB
• 6 I/O Pins (2 are used for USB only if your program actively communicates over USB, otherwise you can use all 6 even if you are programming via USB)
• 8k Flash Memory (about 6k after bootloader)
• I2C and SPI (vis USI)
• PWM on 3 pins (more possible with Software PWM)
• ADC on 4 pins
• Power LED and Test/Status LED

Digispark ATtiny85 Pinout

Digispark ATtiny85 Pinout Description

ATtiny85 Breakout

First of all, by referring to Figure 3, you will notice that the Digispark board serves as a breakout board for the ATtiny85 chip. All of the eight pins of the ATtiny85 chip are accessible. The physical pins of the ATtiny5 chip are designated by the gray-colored pinouts numbered 1 to 8.

Six (6) Digital I/O Pins

As per specification, the Digispark ATtiny85 board can be configured to use six (6) digital I/O ports. These ports are shown in Figure 3 as yellow pins, labeled PB0 to PB5. NOTE: Port B pin PB5 is by default configured as a RESET pin. In order to use PB5 as an I/O port, an ATtiny85 fuse (RSTDISBL) has to be reset (changed from 1 to 0). Please see How to Reset ATtiny85 Fuses.

Arduino IDE Programming Notes

In the Arduino IDE, pins PB0 to PB5, when used as digital I/O are referred to as 0 to 5. That is,

/*
cyberblogspot.com 09Jan2023
*/

bool a, b, c;

void setup() {
  // put your setup code here, to run once:
  pinMode(0, INPUT);   //set PB0 as input
  pinMode(1, INPUT);   //set PB1 as input
  pinMode(2, INPUT);   //set PB2 as input
  pinMode(3, OUTPUT);  //set PB3 as output
  pinMode(4, OUTPUT);  //set PB4 as output
  pinMode(5, OUTPUT);  //set PB5 as output
}

void loop() {
  // put your main code here, to run repeatedly:
  a = digitalRead(0);     //read PB0
  b = digitalRead(1);     //read PB1
  c = digitalRead(2);     //read PB2
  digitalWrite(3, LOW);   //set PB3 LOW
  digitalWrite(4, LOW);   //set PB4 LOW
  digitalWrite(5, HIGH);  //set PB5 HIGH
}

Four (4) Analog to Digital Converter (ADC) Ports

Port B ports PB2 to PB5 can be configured as analog inputs. These pins are shown in Figure 3 as orange pins. The pins are labeled ADC0 to ADC3. Be aware that the Port B numbers do not exactly match the ADC port numbers. In other words, PB2 does not correspond ADC2, PB3 does not correspond to ADC3, and so on. Instead,

• ADC0 is PB5
• ADC1 is PB2
• ADC2 is PB4
• ADC3 is PB3

Arduino IDE Programming Notes

When using the command analogRead(), Arduino IDE assumes you are using the ADC port numbers (0 for ADC0, 1 for ADC1, 2 for ADC2, and 3 for ADC3) and NOT the Port B numbers (0 for PB0, 1 for PB1, 2 for PB2, 3 for PB3, 4 for PB4, and 5 for PB5). However, the pinMode() command expects you to use the Port B numbers. This is one of ATtiny85’s peculiarities that is very confusing. The example code below should clear this up.

/*
cyberblogspot.com 09Jan2023
*/

int a, b, c, d;

void setup() {
// put your setup code here, to run once:
// the following four lines of code are actually not needed
// because by default the I/O pins are in Hi-Z INPUT mode
pinMode(2, INPUT); //set PB2 as input
pinMode(3, INPUT); //set PB3 as input
pinMode(4, INPUT); //set PB4 as input
pinMode(5, INPUT); //set PB5 as input
}

void loop() {
// put your main code here, to run repeatedly:
a = analogRead(0); //read ADC0 which is in PB5
b = analogRead(1); //read ADC1 which is in PB2
c = analogRead(2); //read ADC2 which is in PB4
d = analogRead(3); //read ADC3 which is in PB3
}

Three (3) Pulse Width Modulation (PWM) Outputs

Referring again to Figure 3, there are three (3) PWM outputs available on Digispark ATtiny85 boards. These are colored green in the pinout shown above and are labeled as PWM0, PWM1, and PWM4. There is no typo error here. The third PWM output is labeled as PWM4 because the PWM port numbers use the same Port B numbers. To clarify,

• PWM0 is PB0
• PWM1 is PB1
• PWM4 is PB4

Arduino IDE Programming Notes

The PWM output signal is generated by the command analogWrite(). Although we are going to use the ports as analog outputs, we DO NOT use the ADC port numbers. Rather, we use the PWM port numbers which are the same as the Port B numbers. In other words, we are also using the Port B numbers in programming PWM in the Arduino IDE. Please take a look at the following sketch.

/*
cyberblogspot.com 09Jan2023
*/

void setup() {
  // put your setup code here, to run once:
  pinMode(0, OUTPUT);  //set PB0 (PWM0) as output  
  pinMode(1, OUTPUT;  //set PB1 (PWM1) as output
  pinMode(4, OUTPUT);  //set PB4 (PWM4) as output
}

void loop() {
  // put your main code here, to run repeatedly:
  analogWrite(0, 255);  //100% duty cycle PWM on PB0
  analogWrite(1, 128);  //50% duty cycle PWM on PB1
  analogWrite(4, 0);    //0% duty cycle PWM on PB4
}

SPI (Serial Peripheral Interface) Communication

Ports PB0, PB1, and PB2 can be used for SPI communication:

• MOSI – PB0
• MISO – PB1
• SCLK – PB2

I²C (Inter-Integrated Circuit) Communication

Ports PB0 and PB2 can be used for I2C communication:

• SDA – PB0
• SCK – PB2

USB (Universal Serial Bus) Communication

Ports PB3 and PB4 can be used for USB communication:

• USB- is PB4
• USB+ is PB3

Pin Change Interrupt and External Interrupt

Finally, ports PB0 to PB5 can all be used for pin change interrupt and PB2 as external interrupt pin.

Final Notes on Port B Pins

PB5 has limited current sourcing capacity. Also, when it is at output HIGH, it generates 3V instead of 5V on its output.

PB3 and PB4 are both used during programming (sketch upload). Therefore, it may be necessary to temporarily disconnect the circuits connected to them to avoid interfering with the uploading of sketches. Additionally, PB3 has a 1.5K pull-up resistor that is used for USB communication.

PB0 or PB1 has the built-in LED attached to it. Version A boards use PB1 while version B boards use PB0.

Digispark ATtiny85 Schematic Diagram

References on Digispark ATtiny85 Pinout and Configuration

http://digistump.com/wiki/digispark
ATtiny85 External and Pin Change Interrupt
How to Install Arduino IDE on Windows 10
How to Install ATTinyCore on Arduino IDE
How to Program ATtiny85 with Arduino IDE
How to Program Digispark ATtiny85 Board with Arduino IDE
Digispark USB Device Not Recognized
How to Use AT-09 BLE with Arduino and Smartphone

The post Digispark ATtiny85 Pinout and Configuration appeared first on CyberBlogSpot.

A bare chip ATtiny85 needs to be connected to an ICSP (aka ISP) programmer in order to upload Arduino sketches. To facilitate programming, Digistump created the Digispark ATtiny85 USB Development Board. The Digispark ATtiny85 board does not need an ICSP programmer. Instead, it is directly connected to the USB port of the computer hosting the Arduino IDE. This is the normal way of how to program a Digispark ATtiny85 board.

Difference in Uploading the Sketch

Although a Digispark ATtiny85 board plugs directly into a USB port like any other Arduino development board, there is a slight difference in uploading a program or a sketch. While an Arduino board is connected first to the USB port prior to uploading a sketch, the Digispark board is connected to the USB port after initiating the upload sketch procedure. That is, to upload a sketch to the Digispark board, you have to first press the “Upload” button on the Arduino IDE. Afterwards, a message saying “Please plug in the device (will time out in 60 secs)” will appear on the Arduino IDE. Then, you plug in the Digispark board and the sketch starts uploading. Finally, when the sketch is successfully uploaded, Digispark will run the sketch automatically after five (5) seconds (not instantly as in other Arduino boards).

Configuring Arduino IDE for Digispark ATtiny85 Programming

To program the Digispark ATtiny85 board, first, install the latest version of Arduino IDE if you do not have the Arduino IDE yet on your computer. If you need help on installing the Arduino IDE, please see How to Install Arduino IDE on Windows 10 if you are using Microsoft Windows.

Next, you need to install the ATtinyCore on the Arduino IDE in order for Arduino IDE to recognize the Digispark ATtiny85 boards. You may want to read the article How to Install ATtinyCore on Arduino IDE.

Uploading the Blink Program on Arduino IDE

STEP 1 – Open the Arduino IDE and select the proper board.

STEP 2 – Create a new sketch. Then copy and paste the sketch below.

/*
www.cyberblogspot.com
07Jan2022  
*/

#define LED_BUILTIN 1  //PB1 for Model A
                       //PB0 for Model B

void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}

STEP 3 – Click on the Upload button.

STEP 4 – Insert the Digispark ATtiny85 board into the USB port when the message to do so appears.

If the message “USB device not recognized” appears when you insert the Digispark ATtiny85 board, the board may not have the Micronucleus bootloader installed. See the article Digispark USB Device Not Recognized to resolve the issue.

After the last step, you should see the messages as shown below and the LED on the Digispark ATtiny85 board should start blinking.

Important Notes on Digispark ATtiny85 I/O Ports

According to specifications, Digispark ATtiny85 boards support a total of six (6) digital I/O ports. However, there are several points to consider. Please refer to the Digispark ATtiny85 pinout in Figure 6.

• PB5 is by default being used as a Reset pin, hence, unavailable as a digital IO. ATtiny85 fuses have to be set to enable PB5 as an IO port. Moreover, PB5, when used as an output port, have some peculiarities. When it is at output HIGH, its output is 3V instead of 5V. Aside from that, it has limited current sourcing capability unlike the other ports that can source up to 20 milliamperes (20mA).
• Either PB0 or PB1 is used by the built-in LED depending on the Digispark model. Model A uses PB1 while Model B uses PB0. The explanation can be found here: Digispark Model A vs Model B.
• PB3 is used as USB+ for USB communication and has a 1.5K pull-up resistor.
• PB4 is used as USB- also for USB communication.

How to Address or Reference Digispark ATtiny85 Ports in Program

When programming the Digispark ATtiny85 in Arduino IDE, references to the IO ports differ between digital IO and analog input. When using the ports as digital input or digital output, PB0 to PB5 are referred to by their port numbers. That is, PB0 is 0, PB1 is 1, PB2 is 2, PB3 is 3, PB4 is 4, and PB5 is 5. For example:

pinMode(0, INPUT);  //PB0 is input
pinMode(1, INPUT);  //PB1 is input
pinMode(2, INPUT);  //PB2 is input
pinMode(3, OUTPUT);  //PB3 is output
pinMode(4, OUTPUT);  //PB4 is output
pinMode(5, OUTPUT);  //PB5 is output
bool x,y,z;
x = digitalRead(0);  //read PB0
y = digitalRead(1);  //read PB1
z = digitalRead(2);  //read PB2 
digitalWrite(3, HIGH);  //make PB3 HIGH  
digitalWrite(4, HIGH);  //make PB4 HIGH 
digitalWrite(5, LOW);  //make PB5 LOW

However, when the ports are used as analog input, the port references are different. Please refer to Digispark ATtiny85 pinout in Figure 6. There are only four (4) ports usable as ADC input. These are PB2, PB3, PB4, and PB5. Their corresponding ADC port numbers are ADC1, ADC3, ADC2, and ADC0. In other words,

• PB2 is ADC1
• PB3 is ADC3
• PB4 is ADC2
• PB5 is ADC0

As an example,

//pinMode() always refer to the Port B numbers
//applicable to both digital and analog I/O
pinMode(5, INPUT);  //Make PB5 as input (ADC0)
pinMode(2, INPUT);  //Make PB2 as input  (ADC1)
pinMode(4, INPUT);  //Make PB4 as input (ADC2)
pinMode(3, INPUT);  //Make PB3 as input (ADC3)
int a, b, c, d; 
//Uses analog port numbers instead of Port B numbers
a = analogRead(0);  //Read PB5
b = analogRead(1);  //Read PB2
c = analogRead(2);  //Read PB4
d = analogRead(3);  //Read PB3

Now, how about analogWrite()? Does it use the analog port numbers too? The answer is NO.

Again, referring to the Digispark ATtiny85 pinout above, there are three (3) ports capable of PWM outputs. These are PB0, PB1, and PB4. Let us look at an example of how to use them.

//all port references are Port B numbers like digitalRead() and digitalWrite()
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(4, OUTPUT); 
analogWrite(0, 255);  //100% duty cycle (fully on) PWM on PB0
analogWrite(1, 128);  //50% duty cycle PWM on PB1
analogWrite(4, 0);  //0% duty cycle (off) PWM on PB4

Summary on How to Address or Reference Digispark ATtiny85 Ports in Program

To summarize, the commands pinMode(), digitalRead(), digitalWrite(), and analogWrite() all use the Port B number references. Specifically, 0 for PB0, 1 for PB1, 2 for PB2, 3 for PB3, 4 for PB4, and 5 for PB5. However, as an exception, analogRead() uses its own ADC port numbers. Namely, 0 for PB5, 1 for PB2, 2 for PB4, and 3 for PB3.

References on How to Program Digispark ATtiny85 Board with Arduino IDE

How to Program ATtiny85 with Arduino IDE
Digispark USB Device Not Recognized
How to Enable Serial Monitor on Digispark ATtiny85
Digispark ATtiny85 Pinout and Configuration
How to Use AT-09 BLE with Arduino and Smartphone
Arduino IDE Download Page
ATtinyCore by SpenceKonde on Github
Digispark Model A Versus Model B

The post How to Program Digispark ATtiny85 Board with Arduino IDE appeared first on CyberBlogSpot.

When inserting an ATtiny85 Digispark board on a USB port of a PC running Windows 10, the error “USB device not recognized” pops up. There are only two reasons for this error, assuming your ATtiny85 Digispark board is still good. One, the Windows device driver for Digispark is not installed. And two, the Digispark board does not have the required Micronucleus bootloader installed on it.

Solution 1 – Install the Device Driver for the Digispark Board

Download and install the Windows device driver for Digispark. You can find the latest version here: Digistump Arduino Release 1.6.7. Also, an alternative is to download and install Zadig. It is an application software for installing generic USB device drivers which include libusb, the device driver for Digispark boards.

After successfully installing the device driver, you should see the libusb device driver when you open the Windows Device Manager. See Figure 2 above.

If the error “USB device not recognized” still appears when you plug in the Digispark board, proceed to solution 2.

Solution 2 – Install the Micronucleus Bootloader

In order to install the Micronucleus bootloader, you will need an ICSP (In-Circuit Serial Programmer) programmer. Examples of ICSP programmers are USBtinyISP, USBasp, and Arduino as ISP. Additionally, you will need to install ATtinyCore on the Arduino IDE. The following instructions assumes you have wired your Digispark board with an ICSP programmer and have already installed the ATtinyCore on the Arduino IDE.

For help on how to install ATtinyCore, please see How to Install ATTinyCore on Arduino IDE.

STEP 1 – SELECT THE BOARD – ATtiny85(Micronucleus/Digispark)

Open the Arduino IDE and select the proper board: ATtiny85(Micronucleus/Digispark), see Figure 3 below.

STEP 2 – SELECT THE PROGRAMMER

On the Arduino IDE main menu, go Tools -> Programmer and then select the ICSP programmer you are using. In my case, I am using a USBasp programmer, so I select USBasp(ATtinyCore).

STEP 3 – SELECT THE BURN BOOTLOADER METHOD

The next step is to select the Burn Bootloader method. We must select “Fresh Install (Via ISP)” because we are installing a new bootloader via the ICSP (ISP) programmer and not thru the USB interface. Please see illustration in Figure 5.

STEP 4 – SELECT BURN BOOTLOADER

Finally, we start the bootloader installation by clicking on “Burn Bootloader”, see Figure 6. However, you may want to change other options prior to burning the bootloader. You may change the Clock, Timer1 Clock, LTO, millis()/micros(), and BOD as indicated on the menu. But do not change the “Reset Pin” which is currently set to “Reset”, unless you know what you are doing. Changing the “Reset Pin” to “GPIO” will disable ICSP programming. As a consequence, you will not be able to access the Digispark board again using an ICSP programmer. You will need a High-Voltage programmer to reprogram the ATtiny85’s fuses in order re-enable ICSP programming.

Final Notes on Digispark USB Device Not Recognized

It is very easy to fix the Windows error “USB device not recognized” that appears every time an ATtiny85 Digispark board is inserted on a USB port. The error is caused by either a missing Windows device driver or a missing Micronucleus bootloader. The solution is to install the Digispark Windows device driver and/or burn a new Micronucleus bootloader onto the ATtiny85.

References on Digispark USB Device Not Recognized

How to Install ATTinyCore on Arduino IDE
Digispark USB Development Board

The post Digispark USB Device Not Recognized appeared first on CyberBlogSpot.

• ATtiny1634
• ATtiny2313/4313
• ATtiny24/44/84
• ATtiny441/841
• ATtiny25/45/85
• ATtiny261/461/861
• ATtiny87/167
• ATtiny48/88
• ATTiny43
• ATtiny828

Additionally, the ATTinyCore supports programming via ICSP AVR programmers, Serial (Optiboot), and VUSB (Micronucleus).

1. Install the Arduino IDE

If you don’t have the Arduino IDE (Integrated Development Environment) yet, you can download it here. As of this writing, the latest stable version is 1.8.19.

2. Add the ATTinyCore URL to the Board Manager

Open the Arduino IDE and on the main menu, select Files -> Preferences. In the Additional Boards Manager URLs textbox, type the URL “http://drazzy.com/package_drazzy.com_index.json“, and then press the OK button.

If the textbox already contains additional URLs, press the button on the right side of the textbox. A window will appear where you can type the URL on a new line.

3. Install the Board

On the main menu, select Tools -> Board -> Board Manager.

When the Board Manager window appears, change the board Type from All to Contributed (1). Next, find and select the ATTinyCore board (2). Then, click the Install button (3). And finally, close the Board Manager window by clicking the Close button (4).

Select the Board

From the main menu, open Tools –> Board –> ATTinyCore and then select the appropriate ATtiny board for your microcontroller.

Note that in selecting a board, you will have to choose among No bootloader, Optiboot, and Micronucleus. First, choose No bootloader if you are programming with an AVR programmer. Second, select Optiboot if your ATtiny MCU has been previously burned with an Optiboot bootloader and it is wired as an Optiboot serial device. Finally, select Micronucleus if the MCU has been flushed with a Micronucleus bootloader and connected as a USB device. For more information about these three (3) programming modes, please see How to Program ATtiny85 in Arduino IDE.

The next and final step depends on your chosen programming mode. If you select No bootloader, then you will need to choose a programmer. Open Tools –> Programmer and select the AVR programmer you are going to use. You may also have to specify the Port if your AVR programmer uses the serial port. Although most AVR programmers like the USBasp and USBtinyISP are USB devices and you won’t have to specify the port.

If you choose Optiboot, you need to specify the serial port. Open Tools –> Port and select the port for your ATtiny microcontroller.

Finally, if you choose Micronucleus, you also don’t have to specify the port because Micronucleus uses a virtual USB device.

Now, you’re ready to start programming your ATtiny microcontroller!

References on How to Install ATTinyCore on Arduino IDE

How to Install Arduino IDE on Windows 10
How to Program ATtiny85 with Arduino IDE
Digispark USB Device Not Recognized
ATTinyCore – ATtiny Arduino core by Spence Konde

The post How to Install ATTinyCore on Arduino IDE appeared first on CyberBlogSpot.

In order to use all these programming modes, we need to install the ATTinyCore. It is an Arduino core designed for the ATtiny family of MCUs. Please see How to Install ATTinyCore on Arduino IDE.

If we install the ATTinyCore in the Arduino IDE, we would get the ATTinyCore board menu shown below. Based on the menu, to program an ATtiny85 in Arduino IDE, three (3) options exists. These are the No bootloader, Optiboot, and Micronucleus/DigiSpark.

Program ATtiny85 in Arduino IDE Using an AVR Programmer (No Bootloader)

What is a Bootloader

Actually, the Arduino IDE recognizes an MCU board because of a bootloader. A bootloader is a small software that resides in the flash memory of a microcontroller. Its main function is to detect an incoming program upload. If it sees one, it takes the program and stores it in the flash memory. Otherwise, it runs a previously loaded program, if any exist.

Without a bootloader, the Arduino IDE cannot directly program or upload sketches to an ATtiny85 chip. Or for that matter, any microcontroller at all.

AVR Programmers

Now, in the absence of a bootloader, how do we program or upload sketches to ATtiny85 using the Arduino IDE? We need an AVR programmer. There are many kinds of AVR programmers. We can see the list of AVR programmers supported by ATtinyCore in the Tools -> Programmer menu.

Shown below is a picture of a USBasp ICSP AVR programmer. USBasp is an open-source AVR programmer that you can build by yourself. Or you can buy it cheap on the Internet. It sells for around two dollars ($2) only.

If you don’t have an AVR programmer but you have an Arduino board lying around, you’re good to go. You can use an Arduino board as an AVR programmer. It is one of the options in the ATtinyCore list of programmers – Arduino as ISP. See How to Program ATtiny85 with Arduino.

Wiring the ATtiny85 to an AVR Programmer

Connecting the ATtiny85 to an AVR programmer is straightforward. We connect the six (6) pins of the AVR programmer to the corresponding six (6) pins of the ATtiny85 chip. That is, we connect the following pins:

PROGRAMMER ATTINY85
MOSI (Pin 1) –> MOSI (Pin 5)
MISO (Pin 9) –> MISO (Pin 6)
SCK (Pin 7) –> SCK (Pin 7)
RST (Pin 5) –> RESET (Pin 1)
VCC (Pin 2) –> VCC (Pin 8)
GND (Pin10) –> GND (Pin4)

Uploading Sketch using AVR Programmer

1. Connect the ATtiny85 chip to the AVR programmer as shown in the diagram above.
2. Connect the AVR programmer to the USB port of a computer running the Arduino IDE. You may have to install a device driver for your AVR programmer. If you are using a USBasp programmer like the one shown above, you need to download and run Zadig. This will install the device driver needed by the USBasp programmer.
3. Open the Arduino IDE. On the main menu, open Tools –> Board –> ATtinyCore and select the board ATtiny25/45/85(No bootloader).
4. Next, open Tools –> Programmer and select your AVR programmer. In my case, I would select USBasp(ATTinyCore).
5. Create your sketch or open an existing sketch you want to upload to the ATtiny85 chip. To start uploading, press the Upload button (right arrow icon). Or you may open Sketch on the main menu and select either Upload or Upload Using Programmer.

Burning Bootloaders

Besides uploading sketches, we use the AVR programmer to burn bootloaders. That is, we can upload bootloaders like Optiboot and Micronucleus into an ATtiny85 chip.

How to Burn ATtiny85 Chip with Optiboot Bootloader

1. On the main menu, open Tools –> Board –> ATtinyCore and select the board ATtiny45/85(Optiboot).
2. Next, open Tools –> Programmer and select your AVR programmer.
3. Finally, open Tools and click on the Burn Bootloader.

How to Burn ATtiny85 Chip with Micronucleus Bootloader

1. On the main menu, open Tools –> Board –> ATtinyCore and select the board ATtiny85(Micronucleus/Digispark).
2. Next, open Tools –> Programmer and select your AVR programmer.
3. Finally, open Tools and click on the Burn Bootloader.

Program ATtiny85 in Arduino IDE using Optiboot Bootloader

If you have been programming an Arduino board (Uno, Nano, etc.) using the Arduino IDE, then you have been using the Optiboot bootloader. The Arduino IDE uploads sketches to an Arduino board by communicating with the Optiboot bootloader. The communication is done thru a serial port. That is why before you upload a sketch, you need to select the proper serial port (COM port).

The ATtiny85 chip does not have a serial device. Therefore, to connect it to the PC running the Arduino IDE, we must provide a USB to serial converter. Shown below is an example of a USB serial converter.

Connecting USB Serial Converter to ATtiny85

We need to connect the following terminals:

Serial Converter ATtiny85
DTR –> RESET (Pin 1)
RXD –> MOSI (Pin 5)
TXD –> MISO (Pin 6)
5V –> Vcc (Pin 8)
GND –> GND (Pin 4)

Note that the DTR terminal from the serial converter does not connect directly to the RESET pin of the ATtiny85. It is connected via a 0.1uF ceramic capacitor. Moreover, a 10K-ohm pull-up resistor is connected to the RESET pin of the ATtiny85.

Uploading Sketch Using Optiboot Bootloader

1. Burn or flash the ATtiny85 with Optiboot bootloader. See above topic – How to Burn ATtiny85 Chip with Optiboot Bootloader.
2. Connect the ATtiny85 chip to a USB serial converter as shown in the diagram above.
3. Connect the USB serial converter to a computer running the Arduino IDE. You may have to install a device driver for your USB serial converter.
4. Open the Arduino IDE. On the main menu, open Tools –> Board –> ATtinyCore and select the board ATtiny45/85(Optiboot).
5. Next, open Tools –> Port and select the serial port (COM port) of the serial converter.
6. Create your sketch or open an existing sketch you want to upload to the ATtiny85 chip. To start uploading, press the Upload button (right arrow icon). Or you may open Sketch on the main menu and select Upload.

Program ATtiny85 in Arduino IDE using Micronucleus/Digispark

Micronucleus is a bootloader like the Optiboot bootloader discussed above. However, Micronucleus does not use a serial port (COM port) to communicate with the Arduino IDE. Instead, it uses a virtual USB device. This virtual device is installed on the computer hosting the Arduino IDE. The virtual USB serves as a go-between for Micronucleus and the Arduino IDE.

On the hardware side, an ATtiny85 with a Micronucleus bootloader needs a USB connector. The USB connector allows it connect to the USB port of the computer running the Arduino IDE.

Digispark Development Board

Now comes the Digispark board. It is a small board fitted with an ATtiny85 chip pre-programmed with the Micronucleus bootloader. Also, the board has the required USB connector. And as a bonus, the board includes a 5V voltage regulator, a power indicator LED, and an extra built-in LED on PB2.

For more information on Digispark ATtiny85, please see:
Digispark ATtiny85 Pinout and Configuration
How to Program Digispark ATtiny85 Board with Arduino IDE
Digispark USB Device Not Recognized

Uploading Sketch Using Digispark Boards

1. We need to install the Digispark device driver before the Arduino IDE can recognize it. We can download the Digispark device driver and run the installer. However, we can also use the Zadig software to install the Digispark driver.
2. Open the Arduino IDE. On the main menu, open Tools –> Board –> ATtinyCore and select the board ATtiny85(Micronucleus / DigiSpark). There is no need to select the Port because Digispark does not use the serial COM port.
3. Create a sketch or open an existing sketch to be uploaded
4. Press the Upload button.
5. Wait for a message to plug in the Digispark board. After inserting the board’s USB, the uploading of the sketch will continue.

References on How to Program ATtiny85 with Arduino IDE

How to Install Arduino IDE on Windows 10
How to Install ATTinyCore on Arduino IDE
Digispark USB Device Not Recognized
Digispark ATtiny85 Pinout and Configuration
How to Program Digispark ATtiny85 Board with Arduino IDE
Types of AVR Programmers – by Nick Gammon
USBasp Project – USB Programmer for Atmel AVR Microcontrollers

The post How to Program ATtiny85 with Arduino IDE appeared first on CyberBlogSpot.