UPDATE 2022: The MAX7219LED8x8 library, now renamed to MAX7219tiny has now a new home at tinusaur.com/libraries/max7219tiny/. Check also this MAX7219 & ATtiny85 tutorial to learn how the library works.

The MAX7219LED8x8 library combined with a simple scheduler to automate the task of outputting the buffer to the LED 8×8 matrix comes very handy if you want to write certain type programs, like games for instance. Given the small number of pixels on the LED matrix – only 64, and other limitations set by the Tinusaur platform, it looks like a game as simple as Conway’s Game of Life would be a perfect example of how to write such a program.

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 the user is required to play the game’s turns – it goes by itself until it concludes or goes in a cycle forever.

Its simple rules (outlined below) allow being implemented on very simple microprocessor systems and Tinusaur (and ATtiny microcontroller systems in general) could be the 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:

1. Any live cell with fewer than two live neighbours dies, as if caused by under-population.
2. Any live cell with two or three live neighbours lives on to the next generation.
3. Any live cell with more than three live neighbours dies, as if by overcrowding.
4. 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.

(ref: Wikipedia/Conway’s_Game_of_Life)

The Program

The board is defined as a short byte array:

typedef uint8_t life_board[8];

An initial board is specified by the bits in that array:

life_board life_oscillators_blinkers = {
0b00000000,
0b00000000,
0b01110000,
0b00000000,
0b00000100,
0b00000100,
0b00000100,
0b00000000
};

Here are the most important functions that are implemented:

void life_board_init(life_board buffer);
void life_board_out(void);
uint8_t life_cell_count(uint8_t cx, uint8_t cy);
void life_board_turn(void);
void life_board2_copy(void);

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.

The source code is part of the MAX7219LED8x8 library and it is available at https://bitbucket.org/tinusaur/max7219led8x8.