2011s on Mika Tuupola

Simple Serial Communications With AVR libc

Sat, 19 Nov 2011 00:00:00 +0000

I like to use various Arduino boards for AVR development. What I do not like are the Arduino libraries. They are often just wrappers around libc functions or rewrites of functions libc already provides. Serial communications is one good example. Arduino provides you with its own implementation of Serial.print(), Serial.println() and Serial.read() methods. At the same time AVR Libc has proven printf(), puts() and getchar() functions. This article explains easy implementation of libc functions used for serial communications.

If you do not have much experience in programming it is probably better to stick with Arduino libraries. They are good at hiding some of the confusing features of embedded programming. However changes are you grow out of them after few projects. Atmel datasheets are not as confusing as they first appear. You might also want to check the finished code of this article.

Configuring UART

AVR microcontrollers have three control and status registers. Register UCSR0A mostly contains status data. UCSR0B and UCSR0C contain all the configuration settings. See the tables in the end of article for all possible values.

AVR Libc provides helper macros for baud rate calculations. Header file requires F_CPU and BAUD to be defined. After including the header file UBRRL_VALUE, UBRRH_VALUE and USE_2X are defined. First two are used to set UART speed. Last one is used to determine if UART has to be configured to run in double speed mode with given baud rate.

UCSZ20 UCSZ01 and UCSZ00 control the data size. Possible sizes are 5-bit (000), 6-bit (001), 7-bit (010), 8-bit (011) and 9-bit (111). Most common used data size is 8-bit.

With above bits we can set most common configuration: no parity, 8 data bits, 1 stop bit.

#define F_CPU 16000000UL
#define BAUD 9600

#include <util/setbaud.h>

void uart_init(void) {
    UBRR0H = UBRRH_VALUE;
    UBRR0L = UBRRL_VALUE;

#if USE_2X
    UCSR0A |= _BV(U2X0);
#else
    UCSR0A &= ~(_BV(U2X0));
#endif

    UCSR0C = _BV(UCSZ01) | _BV(UCSZ00); /* 8-bit data */
    UCSR0B = _BV(RXEN0) | _BV(TXEN0);   /* Enable RX and TX */
}

Writing and Reading From UART

You can transmit data to UART by writing a byte to USART Data Register UDR0. First you have to make sure UART is ready to transmit new data. You can wait until USART Data Register Empty UDRE flag is set. Alternatively you can wait after each byte to transmission be ready. USART Transmit Complete TXC0 is set when transmission is ready.

void uart_putchar(char c) {
   loop_until_bit_is_set(UCSR0A, UDRE0); /* Wait until data register empty. */
   UDR0 = c;
}

void uart_putchar(char c) {
   UDR0 = c;
   loop_until_bit_is_set(UCSR0A, TXC0); /* Wait until transmission ready. */
}

You can receive data from UART by reading a byte from USART Data Register UDR0. USART Receive Complete RXC0 flag is set if to unread data exists in data register.

char uart_getchar(void) {
    loop_until_bit_is_set(UCSR0A, RXC0); /* Wait until data exists. */
    return UDR0;
}

Redirecting STDIN and STDOUT to UART

FDEV_SETUP_STREAM macro can be used to setup a buffer which is valid for stdio operations. Initialized buffer will be of type FILE. You can define separate buffers for input and output. Alternatively you can define only one buffer which works for both input and output. First and second parameters are names of the functions which will be called when data is either read from or written to the buffer.

FILE uart_output = FDEV_SETUP_STREAM(uart_putchar, NULL, _FDEV_SETUP_WRITE);
FILE uart_input = FDEV_SETUP_STREAM(NULL, uart_getchar, _FDEV_SETUP_READ);

FILE uart_io FDEV_SETUP_STREAM(uart_putchar, uart_getchar, _FDEV_SETUP_RW);

To prepare our uart_putchar and uart_getchar function to be used with streams we have to change the definition a bit. To properly format output we also force adding a carriage return after newline has been sent.

void uart_putchar(char c, FILE *stream) {
    if (c == '\n') {
        uart_putchar('\r', stream);
    }
    loop_until_bit_is_set(UCSR0A, UDRE0);
    UDR0 = c;
}

char uart_getchar(FILE *stream) {
    loop_until_bit_is_set(UCSR0A, RXC0); /* Wait until data exists. */
    return UDR0;
}

Now we can redirect both STDIN and STDOUT to UART. This enables us to use AVR Libc provided functions to read and write to serial port.

int main(void) {

    uart_init();
    stdout = &uart_output;
    stdin  = &uart_input;

    char input;

    while(1) {
        puts("Hello world!");
        input = getchar();
        printf("You wrote %c\n", input);
    }

    return 0;
}

Control and Status Registers

UCSR0A Bit #	Name	Description
bit 7	`RXC0`	USART Receive Complete. Set when data is available and the data register has not be read yet.
bit 6	`TXC0`	USART Transmit Complete. Set when all data has transmitted.
bit 5	`UDRE0`	USART Data Register Empty. Set when the `UDR0` register is empty and new data can be transmitted.
bit 4	`FE0`	Frame Error. Set when next byte in the `UDR0` register has a framing error.
bit 3	`DOR0`	Data OverRun. Set when the `UDR0` was not read before the next frame arrived.
bit 2	`UPE0`	USART Parity Error. Set when next frame in the `UDR0` has a parity error.
bit 1	`U2X0`	USART Double Transmission Speed. When set decreases the bit time by half doubling the speed.
bit 0	`MPCM0`	Multi-processor Communication Mode. When set incoming data is ignored if no addressing information is provided.

UCSR0B Bit #	Name	Description
bit 7	`RXCIE0`	RX Complete Interrupt Enable. Set to allow receive complete interrupts.
bit 6	`TXCIE0`	TX Complete Interrupt Enable. Set to allow transmission complete interrupts.
bit 5	`UDRIE0`	USART Data Register Empty Interrupt Enable. Set to allow data register empty interrupts.
bit 4	`RXEN0`	Receiver Enable. Set to enable receiver.
bit 3	`TXEN0`	Transmitter enable. Set to enable transmitter.
bit 2	`UCSZ20`	USART Character Size 0. Used together with `UCSZ01` and `UCSZ00` to set data frame size. Available sizes are 5-bit (000), 6-bit (001), 7-bit (010), 8-bit (011) and 9-bit (111).
bit 1	`RXB80`	Receive Data Bit 8. When using 8 bit transmission the 8th bit received.
bit 0	`TXB80`	Transmit Data Bit 8. When using 8 bit transmission the 8th bit to be submitted.

UCSR0C Bit #	Name	Description
bit 7 bit 6		USART Mode Select 1 and 0. `UMSEL01` and `UMSEL00` combined select the operating mode. Available modes are asynchronous (00), synchronous (01) and master SPI (11).
bit 5 bit 4	`UPM01` `UPM00`	USART Parity Mode 1 and 0. `UPM01` and `UPM00` select the parity. Available modes are none (00), even (10) and odd (11).
bit 3	`USBS0`	USART Stop Bit Select. Set to select 1 stop bit. Unset to select 2 stop bits.
bit 2 bit 1	`UCSZ01` `UCSZ00`	USART Character Size 1 and 0. Used together with with `UCSZ20` to set data frame size. Available sizes are 5-bit (000), 6-bit (001), 7-bit (010), 8-bit (011) and 9-bit (111).
bit 0	`UCPOL0`	USART Clock Polarity. Set to transmit on falling edge and sample on rising edge. Unset to transmit on rising edge and sample on falling edge.

How Does Led Matrix Work?

Fri, 04 Nov 2011 00:00:00 +0000

Led matrices are fun toys. Who would not love blinkenlights? Electronics is hard. Electronics is much harder than programming. I had hard time trying to understand how do the led matrices work. What is best way to learn something? Build one yourself.

Structure of Led Matrix

In a matrix format LEDs are arranged in rows and columns. You can also think of them as y and x coordinates. Lets assume we have 4x4 matrix. Rows would be marked from A to D and columns from 1 to 4. Now we can address each LED by row and column. Top left led would be (A,1). Bottom down led would be (D,4).

Led matrices come in two flavors. Common-row anode (left) and common-row cathode (right).

Figure above shows the different configurations. The difference between these two configurations is how you lit a led. With common-row anode current sources (positive voltage) are attached to rows A..D and currents sinks (negative voltage, ground) to columns 1..4. With common-row cathode current sinks are attached to rows A..D and currents sources to columns 1..4.

For example. To light bottom down led (D,4) of common cathode matrix you would feed positive voltage to column 4 and connect row D to ground. For sake of clarity I will using common-row cathode in examples for the rest of this article.

Building a LED Matrix

To build a 4x4 common-row cathode matrix you will need 16 LEDs, four resistors, some headers and prototyping board. I started by gluing the leds to prototyping board with epoxy glue. This way it is easier to have LEDs beautifully aligned. When gluing the leds make sure long and short legs are aligned the same way.

When glue is dry it is time to bend and solder. First bend all cathodes to left as close to prototyping board as possible. Solder all cathodes in each row together. When cathodes are ready, bend all anodes. Anodes must not touch cathodes. I used piece of plastic tubing to help bending the anodes to form a bridge above cathodes.

Now solder together all anodes in each row. Solder the headers and connect cathode rows directly to the header.

Anode rows are connected to header with current limiting resistors. Value of the resistor depends on the LED used. Check the LED datasheet for forward voltage and current. LED calculator will help you finding out correct resistor. Matrix is now ready for testing.

Addressing Single LED

Connecting ground to row A and positive voltage to column 1 will light the top right LED (A,1).

Connecting ground to row D and positive voltage to column 4 will light the bottom down LED (D,4).

Intuition would say lighting the both (A,1) and (D,4) at the same time is just connecting all the four wires. This is not the case. There are four LEDs which are lit. This is because current is also flowing through (A,4) and (D,1).

Multiplexing and Persistence of Vision

Multiplexing can be used to display arbitrary patterns with led matrices. Multiplexing is sometimes also called scanning. It scans rows (usually from up to down) and lights needed leds only in one row at time. Something like following:

Start by having everything disconnected.
Connect positive voltage all the needed columns.
Connect row to ground. This lights the needed leds in the row.
Disconnect the row and all columns.
Do the same steps one by one to all rows and then start from the beginning.

Do this slowly and you would see blinking LED rows. Do it really fast and human eye can see the whole pattern. Phenomenon is called persistence of vision.

Draw a Pattern

Lets write some simple code for drawing a pattern on the matrix. Note! Even though I am using Arduino board I do not use Arduino libraries nor IDE for developing. I do however like the Arduino pin numbering scheme. Functions pin_mode() and digital_write() work exactly the same way as their Arduino equivalents.

We start by setting up the pins and default state for them.

uint8_t column_pins[4] = { 2, 3, 4, 5 };
uint8_t row_pins[4]    = { 11, 10, 9, 8 };

static void init(void) {

    /* Turn all columns off by setting then low. */
    for (uint8_t x=0; x<4; x++) {
        pin_mode(column_pins[x], OUTPUT);
        digital_write(column_pins[x], LOW);
    }

    /* Turn all rows off by setting then high. */
    for (uint8_t y=0; y<4; y++) {
        pin_mode(row_pins[y], OUTPUT);
        digital_write(row_pins[y], HIGH);
    }
}

To display a pattern on matrix we use draw() function. Bitmap is passed as two dimensional array. Delay is used only to demonstrate persistence of vision.

uint8_t pattern[4][4]  = {{1,0,0,1}, {0,1,0,0}, {0,0,1,0}, {1,0,0,1}};

void draw(uint8_t buffer[4][4], uint8_t delay) {

    for (uint8_t row=0; row<4; ++row) {
        /* Connect or disconnect columns as needed. */
        for (uint8_t column=0; column<4; ++column) {
            digital_write(column_pins[column], buffer[row][column]);
        }

        /* Turn on whole row. */
        digital_write(row_pins[row], LOW);

        _delay_ms(delay);

        /* Turn off whole row. */
        digital_write(row_pins[row], HIGH);
    }
}

To examine persistence of vision effect we draw the pattern with different delays.

uint8_t main(void) {

    init();

    /* With 100ms delay eye can see updating row by row. */
    for (uint8_t i=0; i<10; i++) {
        draw(pattern, 100);
    }

    /* With 10ms delay pattern appears but flickers. */
    for (uint16_t i=0; i<100; i++) {
        draw(pattern, 10);
    }

    /* Withoud delay solid pattern appears. */
    while (1) {
        draw(pattern, 1);
    }

    return 0;
}

Full code can be found from GitHub. Check the output from video below.

iPhone Controlled HTML5 Logo and Color Cube

Wed, 02 Feb 2011 00:00:00 +0000

Heads up! This article was written in 2011 and it exists mostly for historical purposes.

When Apple released iOS 4.2 end of last year I was on a boat trip to Finland. For me the most interesting features were added to Safari browser. I wanted to learn about WebSockets. New DeviceOrientation API just begged to be abused. I had an idea to control the content of laptop browser by tilting and rotating the phone. I had working but ugly code before ship arrived to Helsinki.

If you have short attention span go straight to the HTML5 logo demo.

Code has been sitting on my hard drive since. I cleaned it up during last couple of days. Also added additional eye candy by using the oh-so-hot-at-the-moment HTML5 logo.

How Does It Look?

How Does It Work?

First open demo page with your browser. Browser must support WebSockets. If you are using Safari which also support CSS 3D transforms check HTML5 Logo page. If you are using Chrome try Colour Cube page. When you open a demo page it generates a random PIN number and connects to a WebSocket server. PIN number is used as part of channel name.

var socket = new WebSocket("ws://ws.appelsiini.net:8080/iphone/" + pin);

Next open the mobile page with you iPhone or iPod. Enter PIN number from previous page and press connect. Your mobile browser now connects to same WebSocket server.

var socket = new WebSocket("ws://ws.appelsiini.net:8080/iphone/" + pin);

If the PIN numbers match your browsers are effectively paired. Mobile browser then uses DeviceOrientation API do determine iPhone orientation. When user tilts or turn the device new orientation is sent via WebSocket to server. Server in turn sends the same data to computer browser which is listening on same channel.

Every time HTML5 Logo page receives WebSocket message it animates the logo using CSS 3D transforms.

socket.onmessage = function(event) {
    var payload = JSON.parse(event.data);
    $("#elevator").css("-webkit-transform", "rotateX(" + payload.data.x * -1 + "deg)");
    $("#aileron").css("-webkit-transform", "rotateZ(" + payload.data.y * 1 + "deg)");
    $("#pitch").css("-webkit-transform", "rotateY(" + payload.data.z * 1 + "deg)");
}

Colour Cube is almost the same. Only difference is It uses Pre3d JavaScript 3d rendering engine to draw and animate the cube.

Note! Spinning HTML5 logo is taken from HTML5 demo by Boaz Sender. Color cube is taken from Pre3d demo gallery by Dean McNamee. I did not originally create them. I just adapted them to connect and animate with iPhones.

WebSocket Server

WebSocket server itself is simple Ruby script based on Event Machine and em-websocket. I could have used Pusher which provides a hosted service. However I wanted to use this as learning experience. Also if this demo goes popular I might hit some message limits of Pusher.