Showing posts with label Attiny85. Show all posts
Showing posts with label Attiny85. Show all posts

Saturday, February 1, 2025

Not Really Tiny

 Until recently I used for  my hobby electronics projects two types of microchips:

  • Atmel Atmega328p (in case I needed at least ten in/out pins);
  • Atmel Attiny85 (if  five or less in/out pins are enough).
But recently I discovered some new for me members in  Atmel family of devices: Attiny261/461/861. These microchips are not actually that tiny:  20 pins providing  16 in/out signals. On the photo below you can compare  Attiny461 in the middle to Attiny85 on the left and  Atmega328 on the right.


 It  occupies less space on a breadboard than Atmega328, but  still big enough for many hobby projects. But what makes this chip outstanding is the fact how convenient it is  for breadboard prototyping. Look at  pinout of this chip in PDIP package:


As you can see all bits of the A register are on the right side, all bits of the B register  are on the left side. Bits are numerated from the top to the bottom. Very easy to remember and really convenient!  And all pins to connect  AVRISP MKii programming interface are located on the left side of the chip.  That allowed me to make flat vertical adapter  and use it during prototyping with the breadboard. On the picture below you can see circuit with Attiny461 chip, two multi-color LEDs and adapter.


I believe AttinyX61 will find some more usage  in my upcoming projects.

Sunday, July 4, 2021

Two against One

 







Clip above shows Attiny85 chip controlling two 10mm LEDs with the single pin. This post discusses schematic and programming of such a solution.

There are two ways to control LEDs with microcontrollers (like Attiny85).
One way would be to connect LED cathode to the chip pin and LED anode through the current limiting resistor to the power supply '+'.  To light up the LED you just need to program pin low. To turn it off  you need to program it high.

Another way would be to connect LED cathode to the ground and LED anode through the current limiting resistor to the  chip pin. To light up the LED you need to program pin high and low otherwise.
Which way to prefer? I can't tell. I myself often choose it based on how well it corresponds to controls of other devices in particular project.

But there are not that many pins on the chip like Attiny85. What if number of pin available is less than number of LEDs needed to be controlled.
On the circuit diagram above you see the method  of controlling two LEDs with single pin. It based on three important facts:
  1. Any LED has some forward voltage. For Green/White 10mm used here it exceeds 3 V.
  2. Microcontrollers pins may be programmed not only to provide output signal but to collect input as well, If pin is programmed for input it presents itself for external components as a circuit with very high resistance.
  3. Human eye can't see light blinking if its frequency exceeds 50 Hz. If circuit switches LED off/on fast enough (more than 50 times per seconds) you will see it as always lighted.
Rules to controller LEDs here are next:
  • If pin set high green LED is dark and white LED is lighted.
  • If pin set low green LED is lighted and white LED is dark.
  • If pin set into input mode both LEDs supposed to be dark, because sum of forward voltages on both LEDs exceeds power supply voltage,
I assembled the circuit and programmed it , but result was  disappointing. Setting pin into input mode did not turn both LEDs off, They were lighted up. The light was  less bright than normally but still visible.  Would resistors increase help? Alas not that much. LEDs dimmed a little but not fully. Obviously I need either decrease power voltage or look for LEDs with bigger forward voltage,
Then idea came to mine mind: what if I add to the circuit extra devices with some forward voltage.
Here you see each LED sequentially connected to  the silicon diode . Forward voltage of diode reaches 1 V,  which makes whole forward voltage of both (LED and silicone diode) ~ 4 V.  Obviously it is better to decrease value of resistor to keep current the same  (~20 mA). And this circuit solved the problem.  I believe it is not bad solution taking in to consideration that silicon diode cost pennies, Below you can see C program to run the test. 

#include <avr/io.h>
#define 	F_CPU   1000000UL
#include <util/delay.h>

typedef enum {OUT_LOW, OUT_HIGH} OutputLevel;

#define pinOut(bit, outLevel) \
(DDRB |= (1 << ( DDB##bit)));\
switch(outLevel) \
{\
	case OUT_LOW: (PORTB &= ~(1 << (DDB##bit))); break;\
	case OUT_HIGH: (PORTB |= (1 << (DDB##bit))); break;\
}

#define pinIn(bit) \
((DDRB &= ~(1 << (DDB##bit))),\
(PORTB &= ~(1 << (PORTB##bit))),\
(PINB & (1 << (PORTB##bit))))

int main(void)
{
    while (1) 
    {
		for (int i=0; i < 100; i++) { // White & Green
			pinOut(2,OUT_HIGH);
			_delay_ms(5.0);
			pinOut(2,OUT_LOW);
			_delay_ms(5.0);
		}
		for (int i=0; i < 100; i++) { // White
			pinOut(2,OUT_HIGH);
			_delay_ms(5.0);
			pinIn(2);
			_delay_ms(5.0);
		}
		for (int i=0; i < 100; i++) { // Green
			pinOut(2,OUT_LOW);
			_delay_ms(5.0);
			pinIn(2);
			_delay_ms(5.0);
		}
		for (int i=0; i < 100; i++) { // No light
			pinIn(2);
			_delay_ms(10.0);
		}
    }
}

But one may ask why this? Why not charlieplexing?  Indeed charlieplexing is well known technique which utilizes facts of of pin high resistance while  in input mode, and non-ability of human eye to see  high frequency light oscillation. It can provide LEDs/pin ratio not only 2 but much bigger. To compare  let us look at charlieplexing example with the same LED/pin  ratio: 2. There is need to have three pins to control six LEDs.  But how to control just four LEDs, or two? Not possible. And in addition you need to connect/solder five components to the single dot which for DYI project presents some challenge. 


So in a conclusion: even if charlieplexing is great there could be  cases when method described in this post is a valuable solution.

Update 07/05/2021. I put link to this post on the AVR subreddit . And I got some comments that there actually different schematic exists which allows to control two LEDs with the single pin without need of silicon diodes.

Indeed such circuit works perfectly. But again nothing is free. It consumes ~ 20 mA even if both LEDs are off. Meanwhile for circuit  with silicon diodes consumption during dark time is much smaller. So which circuit to choose is really question of use case and preferences.

Thursday, April 1, 2021

1/4 Sized Breadboard

 


In the photo above there is Adafruit small breadboard. I found it to be a perfect match for projects utilizing Attiny85 microcontroller. 


While it is single side board, top side has copper circles around holes so components can be soldered on any side of the board. Board is not very thin and feels sturdy. Occasional soldering overheating will not damage conductor strips. Conveniently it has four strips for power and it is well suited for projects needed two voltage levels (like 5V and 12V).

So far I used such a board for two projects  made for last year Halloween  (published here). 


First project is to control two three colors LEDs. It is minimalistic: apart of controller board accommodates just three resistors. To make controller programmable in-board there is  6 pins ISP male header. I soldered pins, cut strips between two pin rows with the knife (cut is on the bottom side of the board) and wired them to corresponding pins of the the microchip.


Second project required two voltage levels (12V and 5V).  See 12V-5V stepdown power supply on the right side of the board soldered to it. There is no 6-pins ISP header on the board, Does that mean there is no way for in-board programming? Absolutely not. To make microchip in-board programable I mounted on each side of the chip female headers. Because of that board becomes suitable for AVR ISP to Attiny85 adapter  and  can  be   programmed the same as projects mounted on non-soldering breadboard.


Saturday, March 6, 2021

Capabilities of Supercapacitor

 



Several years ago I built the project utilizing supercapacitor (useless machine). Now I returned to this component again to make a set of small projects, which  will use super capacitor as backup power supply. Clip above shows initial test. Several seconds of charge is enough to power Attiny85 chip controlling blinking be-color LED for five minutes. At the end of this time LED blinks are barely visible but anyway I found result impressive. In case you need details, here is circuit diagram:


 And here is list of components:

  • Supercapacitor 0.1 F, 5.5 V (NEC)
  • Attiny85 microchip
  • Red-Green bi-color LED (5mm)
  • Resistor 180 Ohm, 0.125 W
  • Diode Schottky ( 1N5817) (for this test it is not really needed but later I will utilize it to detect the moment  when external power is down).
Circuit initially powered up by 5V USB 0.5 A power supply.
 Code is short, so I put it here as well.

#include <avr/io.h>
#define 	F_CPU   1000000UL
#include <util/delay.h>

typedef enum {OUT_LOW, OUT_HIGH} OutputLevel;

#define pinOut(bit, outLevel) \
(DDRB |= (1 << ( DDB##bit)));\
switch(outLevel) \
{\
	case OUT_LOW: (PORTB &= ~(1 << (DDB##bit))); break;\
	case OUT_HIGH: (PORTB |= (1 << (DDB##bit))); break;\
}

int main(void)
{
    while (1) 
    {
		pinOut(0,OUT_LOW);
		pinOut(2,OUT_HIGH);
		_delay_ms(200.0);
		pinOut(0,OUT_HIGH);
		pinOut(2,OUT_HIGH);
		_delay_ms(800.0);
		pinOut(0,OUT_HIGH);
		pinOut(2,OUT_LOW);
		_delay_ms(200.0);
		pinOut(0,OUT_HIGH);
		pinOut(2,OUT_HIGH);
		_delay_ms(800.0);
    }
}

Sunday, February 28, 2021

AVRISP II adapter to Attiny85

 



For my hobby projects  I often use Attiny85 chip . Usually first stage of the project is breadboard prototyping. But there is the problem: connecting AVRISP programmer to the chip on the breadboard is not that easy. So I made dedicated  adapter  which allows effortless connection between  AVRISP programmer and Attinny85 chip. 

\


Adapter is passive: it contains nothing but headers to connect programmer and headers to connect to the chip. Apart of that added LED with resistor to indicate if power is supplied.


Adapter has two set of headers:

  •  one set to connect AVRISP (on the photo on the left)
  • another set to insert into breadboard on top of Attiny85 chip.
LED with resistor added for convince to be sure that power provided to the circuit. Marking on the circuit diagram below corresponds to the photo above.
Here you can see the breadboard with the microchip attached to the power.




I need just put adapter with connected AVRISP II programmer on top of microchip, connect AVRISP programmer to a computer through USB in interface, and start Atmel Studio.  Now I am ready to program.



One may ask why not to buy some breadboard ready ISP header? Indeed for less than one dollar you can get adapter kit at  Adafruit site. It is nicely made and can be used with any AVR device. But to make it work there is need to connect that adapter to a controller with six jumper wires. With my adapter I just need to snap it in place. Obviously, if I want to work with different controller (like  Atmega328), I have to make another dedicated adapter. Still I assume that benefits worth the effort.





Monday, October 19, 2020

It Is a Halloween Time

Recently I upgraded our windows Halloween decoration with two items. Both are LED installations. Each is controlled by Attiny85 chip.

This one is the pumpkin with multi-colored eyes:


You can find place with source code, circuit diagram and some details here: https://github.com/jumbleview/pumpkin


This one is lighted ghost image.


Source code and circuit diagram is here: https://github.com/jumbleview/casper

Some additional description published on "Instructables".

Below is the video of three projects (two mentioned above plus my old project: "Moon with the Bat silhouette") installed in our home window.