As you may already know last week we announced the Tinusaur Shield LEDx2 – this is very simple add-on board that you put on top of the Tinusaur Board. It has just 4 components: 2 LEDs and 2 resistors for each LED – there is no much to solder.
So far we’ve used a LED as output to produce light of different colors and intensity (Tutorial 001 and Tutorial 002) but we haven’t generated any sound yet.
In fact, that isn’t very difficult to do.
We will use a buzzer for output.
According to Wikipedia … the buzzer or beeper is an audio signaling device, which may be mechanical, electromechanical, or piezoelectric. Typical uses of buzzers and beepers include alarm devices, timers, and confirmation of user input such as a mouse click or keystroke.
We will use an electromechanical buzzer. When voltage is applied to it its membrane moves up (or down, depending on the particular device), and respectively when there is no voltage the membrane goes back to its normal position. Applying constantly changing voltage will generate audio waves perceived by us as a sound.
Let’s connect the buzzer to the PB2 of the ATtiny85 on the Tinusaur board.
The program should look very much like the one for blinking LED except that the delay between switching the port should be very short.
In the example below we have a delay 500 and since we’re using the _delay_us() function that means the delay is 500 uS (microseconds). That means the period of the signal will be 2 x 500 uS = 1000 uS (or 0.0001 sec.) and then the frequency is 1 / 0.0001 S = 10000. That means the sound will have a frequency of 10 KHz.
Here is the source code:
#include <stdint.h>
#include <avr/io.h>
#include <util/delay.h>
#define BUZZER_PORT PB2 // Buzzer I/O Port
#define BUZZER_DELAY 500 // Delay for each tick
int main(void)
{
DDRB |= (1 << BUZZER_PORT); // Set port as output
while (1) {
PORTB |= (1 << BUZZER_PORT);
_delay_us(BUZZER_DELAY);
PORTB &= ~(1 << BUZZER_PORT);
_delay_us(BUZZER_DELAY);
}
return (0);
}
The buzzer should start making sounds immediately.
Let’s do some more experiments.
Let’s make the delay between the buzzer ticks change over time and see what sound it will produce.
This time instead of _delay_us() we will use the _delay_loop_2() function. According to the _delay_loop_2(int) documentation it produces 4 empty CPU cycles per iteration – in other words with parameter 100 it will produce a delay of 400 CPU cycles. That tells us that the maximum is 65536 x 4 = 262252 cycles. That, at 1MHz CPU clock, is approximately 262 mS (milliseconds) maximum delay, … or about 3.8 Hz minimum frequency – perfect for our experiments.
Below is the source code:
#include <stdint.h>
#include <avr/io.h>
#include <util/delay.h>
#define BUZZER_PORT PB2 // Buzzer I/O Port
#define BUZZER_DELAY 200 // Delay for each tick
int main(void)
{
DDRB |= (1 << BUZZER_PORT); // Set port as output
int delay = 0;
while (1) {
if (delay < 1) delay = BUZZER_DELAY;
PORTB |= (1 << BUZZER_PORT);
_delay_loop_2(delay);
PORTB &= ~(1 << BUZZER_PORT);
_delay_loop_2(delay);
delay--;
}
return (0);
}
After building and uploading this should start making sounds like a car alarm.
With similar techniques, a lot more complex sounds could be generated.
I was playing with the MAX7219LED8x8 library and writing some code for how to use a simple scheduler to automate the task of outputting the buffer to the LED 8×8 matrix. So I was thinking … may be writing a simple game will illustrate the use of those libraries very well. Because just few days earlier I was looking at some Arduino projects implementing the Conway’s Game of Life I decided to write it for ATtiny85 and MAX7219/LED 8×8.
The Game of Life is a classical computer game and a cellular automaton created by the British mathematician John Horton Conway in 1970. This is a zero-player game which means that once it starts no input from user is required to play the game’s turns – it goes by itself.
Its simple rules (outlined below) allow to be implemented on very simple microprocessor systems and Tinusaur (and ATtiny systems in general) could be perfect platform for that.
Hardware
One Tinusaur Board connected to LED matrix 8×8 controlled by MAX7219.
Drivers
The MAX7219Led8x8 library is used to output the pixels to the LED 8×8 matrix.
The Rules
The universe of the Game of Life is an infinite two-dimensional orthogonal grid of square cells, each of which is in one of two possible states, alive or dead. Every cell interacts with its eight neighbours, which are the cells that are horizontally, vertically, or diagonally adjacent. At each step in time, the following transitions occur:
Any live cell with fewer than two live neighbours dies, as if caused by under-population.
Any live cell with two or three live neighbours lives on to the next generation.
Any live cell with more than three live neighbours dies, as if by overcrowding.
Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.
The initial pattern constitutes the seed of the system. The first generation is created by applying the above rules simultaneously to every cell in the seed—births and deaths occur simultaneously, and the discrete moment at which this happens is sometimes called atick (in other words, each generation is a pure function of the preceding one). The rules continue to be applied repeatedly to create further generations.
The life_board_init function initializes the board with preset values and life_board_out outputs the content of the boards to the LED 8×8 matrix.
The life_cell_count function counts how many neighbors the specified cell has.
The life_board_turn performs one turn of the game based on the rules described above. It reads the data from the main buffer life_board_buffer array and stores the result in the life_board_buffer2 array. After that life_board2_copy copies the new data to the main buffer which then is outputted to the LED 8×8 matrix.
Here is the source code of the most important function – life_board_turn:
void life_board_turn(void) {
for (uint8_t y = 0; y = 7; y++) {
for (uint8_t x = 0; x <= 7; x++) {
uint8_t count = life_cell_count(x, y);
if (LIFE_CELL_ISSET(x, y)) {
if (count < 2)
LIFE_CELL_CLR(x, y);
else if (count == 2 || count == 3)
LIFE_CELL_SET(x, y);
else if (count > 3)
LIFE_CELL_CLR(x, y);
} else {
if (count == 3)
LIFE_CELL_SET(x, y);
else
LIFE_CELL_CLR(x, y);
}
}
}
}
This function implements the rules of the Game of Life.
That’s it.
In the program, there is some more code that shows about 10 well know and interesting shapes such as blinker, toad, beacon, glider, etc.
MAX7219LED8x8 is a C library for working with the MAX7219 display driver to control 8×8 LED matrix. It is intended to be used with the Tinusaur board but should also work with any other board based on Atmel ATtiny85 or similar microcontroller.
The MAX7219 is manufactured by Maxim Integrated is compact, serial input display driver that could interface microcontrollers to 64 individual LEDs such as 8×8 LED matrix. Only one external resistor is required to set the segment current for all LEDs.
To put that in simpler words – with the MAX7219 driver it is possible to control 8×8 LED matrix using just 2 wires serial interface – one for the sync clock and one for the data. There is another wire that could be used to enable/disable the communication with the chip. The maximum frequency for the serial interface is 10MHz.
The LED matrix 8×8 is connected almost diretcly to the MAX7219 driver – only few external components are required.
Working with MAX7219 is very simple – turning on and off individual LEDs is done by sending 2-bytes command to the driver containing the row and the byte which bits define which LED value to set.
There are also few other command that are needed during the initialization process.
The library supports short buffer – only 8 bytes in size – to keep the values before sending them to the driver.
MAX7219LED8x8 is written in plain C and does not require any additional libraries to function except those that come with the WinAVR SDK. Check our WinAVR Setup Guide.
Using it is very simple …
MAX7219_init();
MAX7219_buffer_set(2, 3); // Set pixel
MAX7219_buffer_clr(4, 5); // Clear pixel
MAX7219_buffer_out(); // Output the buffer
Please continue to MAX7219LED8x8 page to see full source code the rest of the article.
Note: The code in this tutorial does not use the built-in PWM capabilities of the ATtiny microcontrollers, instead it uses direct bit manipulation since this an easier way to understand how it works. Another tutorial should cover the PWM functionality that is built into the microcontroller.
The Tinusaur board is a standard ATtiny breakout board so this could be applied to almost any other board that has ATtiny microcontroller on it. The code was tested to work with ATtiny13, ATtiny25, ATtiny45 and ATtiny85 but will probably work on any other ATtiny microcontrollers as well.
This is very simple tutorial that shows how to connect a LED to the Tinusaur board and write the “Hello World” of the microcontrollers – very simple program that makes a LED to blink.
Since the Tinusaur board is a very standard ATtiny breakout board this could be applied to almost any other board that has ATtiny microcontroller.
The code was tested to work with ATtiny13, ATtiny25, ATtiny45 and ATtiny85 but will probably work with other microcontrollers too.
This is a very simple tutorial on how to make a LED blinking.
Since the Tinusaur board is a very standard ATtiny breakout board this could be applied to almost any such other board.
The code was tested to work with ATtiny13, ATtiny25, ATtiny45, and ATtiny85 but will probably work with other chips too.
We assume that the Tinusaur board is already assembled, successfully; connected through the ISP programmer to the computer; and development environment. It is not the subject of this tutorial how to assemble the board or how to setup a development environment.
The LED should be connected on pin 2 of the ATtiny – this is PB3 – through a resistor, and to the GND.
The LED, marked as D1, is just a standard light-emitting diode.
Set the LED wire signal to “1” – that will make it to light.
Wait a little – 200 milliseconds.
Clear the LED wire signal to “0” – that will turn it off.
Wait a little -400 milliseconds.
Do it again.
Here is the entire source code:
/**
* The Tinusaur Project
*
* Tutorial 001: Blinking LED
*
* file: main.c
* created: 2014-01-04
*
**/
#include <avr/io.h>
#include <util/delay.h>
// ====================================
// ATtiny
// 25/45/85
// +--------+
// --+ o Vcc +------------
// LED - PB3 --+ +--
// --+ +--
// ------------+ GND +--
// +--------+
// ====================================
// Define the I/O port to be used for the LED.
// This a number between 0 and 7 that tells which bit to use.
#define LED_PORT PB3
int main(void) {
// Set the LED port number as output.
// The DDRB is the data direction for port B.
// This ...
// - shifts the "1" on left to the desired position and ...
// - does bitwise "OR" with the value in the port register.
DDRB |= (1 << LED_PORT);
// Start infinite loop.
// (this is how most programs work)
while (1) {
// Set the LED bit to "1" - LED will be "on".
PORTB |= (1 << LED_PORT);
// Wait a little.
// The delay function simply does N-number of "empty" loops.
_delay_ms(200);
// Set the LED bit to "0" - LED will be "off".
PORTB &= ~(1 << LED_PORT);
// Wait a little.
_delay_ms(400);
// Do it again ...
}
// Return the mandatory for the "main" function value.
return (0);
}
The Rules
We have put together a short guide how to setup and use 
