Tag: I2C

I2C-Dimmer

10.12.2011 by Ronald·0 Comments

I took this article from my old CMS in 2015, it wasn’t in the blog until then.

Breadboard in action

I haven’t done many microcontroller-projects till now, but more than one of the few projects I did involved controlling LEDs by pulse width modulation (PWM). Doing this for one or more LEDs is a stressful task for a little microcontroller, but if you want to do some other more or less complicated things while keeping LEDs at certain brightnesses is likely to ruin the timings that are used in the PWM. Not to talk about the program code, which gets more and more unreadable if you try to do several different things ‘at the same time’.

For my next project I need to fade some LEDs again, so I was looking for an easier way to do it. The plans include reading from memory cards, talking to real time clocks and displaying text on an LCD, so I’m almost sure that I won’t be able to reliably control the five channels I’m going to use.

The first plan was to use a ready-made chip. I looked around and the best thing I could find was one made by Philips (PCA something, I forgot the number) that can be controlled via I2C-bus. That part is able to control eight LEDs, but apart from ‘on’ and ‘off’ you can set the LEDs only to two different brightnesses. Those are variable, nevertheless, but it would be impossible to light one LED at 20%, one at 50% and one at 80%. Another drawback is that it is SMD-only, and my soldering-skills don’t including working with stuff that small.

So the Idea was to set up a separate controller for LED-fading, that can be externally controlled, ideally via I2C-bus since I intend to use several other devices in my next project that can make use of the bus. So I set up an ATtiny2313 on my breadboard, clocked it with an external 20MHz-crystal and we tried to control as many LEDs as possible…

Pulse width modulation

Controlling the brightness of LEDs by PWM is a common technique, I used it myself in several projects.

The old way

Till now I used to switch on all LEDs that should light up at a level greater than zero, waited till the first of the LEDs has to be switched off, switched it off, waited for the next one and so on. After a certain time all LEDs are switched off, and I start again.

I try to visualize that with a little picture:

          .         .         .         .         .|         .         .
1 *************************************************|************************
2 ***************************************          |************************
3 *********                                        |**********
4                                                  |
5 *****************************                    |************************

. . . . .| . .

1 *************************************************|************************

2 *************************************** |************************

3 ********* |**********

4 |

5 ***************************** |************************

In this example, a full cycle of the PWM would need 50 units of time. The first LED is switched on the full time (100%), the second for 40 of the 50 units (80%), the third one for ten (20%) and the fifth one for 30 units (60%). The fourth LED is off (0%). We see that after 50 units of time the modulation starts again.

The drawback of this technique is, that it’s slow. And for each additional channel you try to control, it gets even slower. We tried, but we weren’t able to control more than five LEDs in this way without them to start flickering to a visible amount.

We tried to create an array with all states of the process, so the PWM only would have to loop through the array and set the outputs accordingly. But that didn’t work either, because the used microcontroller doesn’t have enough RAM to store the array.

Thomas’ idea

After some tests that didn’t work out too well, Thomas had a great idea how to implement the PWM. It also works with an array for all states, but the states of the modulation are not displayed for the same time. The first state is displayed for one time-unit, the second one for two time-units, the third one for four and so on. In this way the LEDs are turned on and off more than once per cycle of the PWM, but that doesn’t hurt.

Let’s try to paint a picture again:

          .         .         .         .         .         .   |      .
  .. .   .       .               .                              |.. .   .
1 *                                                             |*
2  **                                                           | **
3 ***                                                           |***
4    ****                                                       |   ****
5 *  ****                                                       |*  ****
6  ******                                                       | ******
7 *******                                                       |*******
8        ********                                               |       ****

. . . . . . | .

.. . . . . |.. . .

1 * |*

2 ** | **

3 *** |***

4 **** | ****

5 * **** |* ****

6 ****** | ******

7 ******* |*******

8 ******** | ****

So here we see a PWM with eight channels that are able to display up to 64 different brightnesses. Channel one is switched on for one unit of time, channel two for two units and so on. The most interesting thing is on channel five: the LED is switched on for one unit of time, switched off, and switched on again for four units of time.

Lets try a more complicated example — with brighter LEDs, too:

          .         .         .         .         .         .   |      .
  .. .   .       .               .                              |.. .   .
1 *                              *******************************|*
2  **            ****************                               | **
3 *******        ****************                               |*******
4                                *******************************|
5 *  ****        ****************                               |*  ****
6  *************************************************************| **********
7 **************************************************************|***********
8        ************************                               |       ****

. . . . . . | .

.. . . . . |.. . .

1 * *******************************|*

2 ** **************** | **

3 ******* **************** |*******

4 *******************************|

5 * **** **************** |* ****

6 *************************************************************| **********

7 **************************************************************|***********

8 ************************ | ****

The channels 1 to 8 have the brightnesses 33, 18, 23, 32, 21, 63, 64 and 24.

Brightness 75 on the oscilloscope

The advantage of this technique is that on the one hand you have to save a limited number of states (six states in the example), and the looping through the states is very simple: state n is sent to the output pins, then we wait for 2^(n-1) time units, then the next state is sent.

Each state represents the bit-pattern that has to be sent during one step. In other words: one column out of the above picture at the start of a new time period. So in this example, we have six states: 01010101, 01100110, 01110100, 11100000, 11110110 and 01101001. The first one is displayed for one unit of time, the second one for two units, the third one for four units and so on…

Using this technique has the advantage that adding more channels does almost nothing in terms of system load. The only time that the algorithm has to do actual calculations is when a new value has been delivered and has to be converted into the states. So using this algorithm, it is possible to show different brightnesses on all free pins of the controller. With an ATtiny2313 that means that you can fade 13 different LEDs while still talking I2C to communicate with other devices!

I2C communication

Speaking I2C is no rocket science, but since one has to do a lot of bit-shifting when implementing it, I took a ready-made library.

The one I used is written by Donald R. Blake, he was so kind to put it under GPL and post it to avrfreaks.net. You can find the original post in a thread called ‘8 bit communication between AVR using TWI‘, and some additions in the thread ‘I2C Slave on an ATtiny45‘.

Thanks for the great work, Donald! And for putting it under a free license.

Since his package seems to be only available as a forum-attachment, and I’m not sure for how long that will be, I included it into the tarball of this project.

Usage

You should be able to use this device in the same way you would use any other I2C-slave:

Connecting it

The controller needs to have the following pins connected in the circuit:

Pin 1 – Reset – should be connected to VCC with a 10k-resistor
Pin 4 and 5 – XTAL1 and XTAL2 – connected to a 20MHz-crystal, using 22p-capacitors against GND
Pin 10 – GND – Ground
Pin 17 – SDA – I2C-data
Pin 19 – SCL – I2C-clock
Pin 20 – VCC – 5V

Your I2C-data and -clock lines should be terminated by 4,7k-resistors to pull up the lines. All the other pins can be used to connect LEDs. They are arranged in this way:

Pin 2 – PD0 – Channel 0
Pin 3 – PD1 – Channel 1
Pin 6 – PD2 – Channel 2
Pin 7 – PD3 – Channel 3
Pin 8 – PD4 – Channel 4
Pin 9 – PD5 – Channel 5
Pin 11 – PD6 – Channel 6
Pin 12 – PB0 – Channel 7
Pin 13 – PB1 – Channel 8
Pin 14 – PB2 – Channel 9
Pin 15 – PB3 – Channel 10
Pin 16 – PB4 – Channel 11
Pin 18 – PB6 – Channel 12

Talking to it

For my tests I used an ATmega8 as I2C-master with the library written by Peter Fleury. You can find it on http://jump.to/fleury. Thanks to him for putting it online!

The typical send function looks like this:

#define I2C_FADER 0x10
 
void sendi2cBytes(uint8_t address, uint8_t brightness) {
    // address: number of the LED to set (0..12)
    // brightness: value between 0 and 127
    // start the communication...
    i2c_start_wait((I2C_FADER < < 1) + I2C_WRITE);
    // write a byte with the address. we want the highest bit of the
    // address to be 1, so the slave can be sure that this is an address.
    i2c_write(address | 0x80);
    // calculate the actual duration the LED should light up. we could do
    // this on the slave's side, but we assume that the device is more
    // flexible when it is done on the master side.
    uint16_t duration = (brightness + 1) * (brightness + 1) - 1;
    // calculate the low- and the high-byte and send it. note that we split
    // the duration into 7-bit-values, not 8 bit! in this way the highest
    // bit of the transferred bytes is always low, allowing the slave to
    // recognize the transmitted bytes as values, not as addresses.
    i2c_write(duration & 0x7f);        // low byte
    i2c_write((duration >> 7) & 0x7f); // high byte
    // stop the communication...
    i2c_stop();
}

#define I2C_FADER 0x10

void sendi2cBytes(uint8_t address, uint8_t brightness) {

// address: number of the LED to set (0..12)

// brightness: value between 0 and 127

// start the communication...

i2c_start_wait((I2C_FADER < < 1) + I2C_WRITE);

// write a byte with the address. we want the highest bit of the

// address to be 1, so the slave can be sure that this is an address.

i2c_write(address | 0x80);

// calculate the actual duration the LED should light up. we could do

// this on the slave's side, but we assume that the device is more

// flexible when it is done on the master side.

uint16_t duration = (brightness + 1) * (brightness + 1) - 1;

// calculate the low- and the high-byte and send it. note that we split

// the duration into 7-bit-values, not 8 bit! in this way the highest

// bit of the transferred bytes is always low, allowing the slave to

// recognize the transmitted bytes as values, not as addresses.

i2c_write(duration & 0x7f); // low byte

i2c_write((duration >> 7) & 0x7f); // high byte

// stop the communication...

i2c_stop();

}

Examples

I2C-Fader on testboard

Here, you see all LEDs fading at different speeds.

The code running on the I2C-master to generate this pattern looked like this:

void sendi2cBytes(uint8_t address, uint8_t brightness) {
    i2c_start_wait((I2C_FADER << 1) + I2C_WRITE);
    i2c_write(address | 0x80);
    uint16_t duration = (brightness + 1) * (brightness + 1) - 1;
    i2c_write(duration & 0x7f);        // low byte
    i2c_write((duration >> 7) & 0x7f); // high byte
    i2c_stop();
}

void fadeall(void) {
    uint8_t i = 0;
    int16_t brightness[13];
    int16_t  speed[13];
    for (i = 0; i < 13; i++) {
        brightness[i] = 64<<8;
        speed[i] = random() & 0xff + 0x40;
    }
    while (1) {
        for(i= 0; i < 13; i++){
            sendi2cBytes(i, brightness[i]>>8);
            brightness[i]+= speed[i];
            if(brightness[i]>>8 > 127 || brightness[i]>>8 < 0){
                brightness[i]-= speed[i];
                speed[i] = -speed[i];
            }
        }
        timerPause(1);
    }
}

void sendi2cBytes(uint8_t address, uint8_t brightness) {

i2c_start_wait((I2C_FADER << 1) + I2C_WRITE);

i2c_write(address | 0x80);

uint16_t duration = (brightness + 1) * (brightness + 1) - 1;

i2c_write(duration & 0x7f); // low byte

i2c_write((duration >> 7) & 0x7f); // high byte

i2c_stop();

}

void fadeall(void) {

uint8_t i = 0;

int16_t brightness[13];

int16_t speed[13];

for (i = 0; i < 13; i++) {

brightness[i] = 64<<8;

speed[i] = random() & 0xff + 0x40;

}

while (1) {

for(i= 0; i < 13; i++){

sendi2cBytes(i, brightness[i]>>8);

brightness[i]+= speed[i];

if(brightness[i]>>8 > 127 || brightness[i]>>8 < 0){

brightness[i]-= speed[i];

speed[i] = -speed[i];

}

timerPause(1);

}

Visible PWM

Here you see the signal of one LED fading from 0 to 127. Unfortunately, my oldtimer-oscilloscope doesn’t trigger correctly in the middle part.

This is the code that ran on the I2C-master:

void sendi2cBytes(uint8_t address, uint8_t brightness) {
    i2c_start_wait((I2C_FADER < < 1) + I2C_WRITE);
    i2c_write(address | 0x80);
    uint16_t duration = (brightness + 1) * (brightness + 1) - 1;
    i2c_write(duration & 0x7f);        // low byte
    i2c_write((duration >> 7) & 0x7f); // high byte
    i2c_stop();
}
               
void fade(void) {                                                                   
    uint8_t i;                                                                      
    for(i= 0; i < = 127; i++){
        sendi2cBytes(0, i);
        timerPause(100);
    }
}

void sendi2cBytes(uint8_t address, uint8_t brightness) {

i2c_start_wait((I2C_FADER < < 1) + I2C_WRITE);

i2c_write(address | 0x80);

uint16_t duration = (brightness + 1) * (brightness + 1) - 1;

i2c_write(duration & 0x7f); // low byte

i2c_write((duration >> 7) & 0x7f); // high byte

i2c_stop();

}

void fade(void) {

uint8_t i;

for(i= 0; i < = 127; i++){

sendi2cBytes(0, i);

timerPause(100);

}

Drawbacks

Till now, the device worked in all situations I tested it in. So far everything is fine.

I guess that, compared to the ready-made off-the-hook-parts that controls LEDs via I2C, this module is a bit slow. I can’t see any flickering in the LEDs since they are still switched very fast (about every 6ms, which would result in a 166Hz flickering — too fast for me).

Thanks!

Once again, special credits go to Thomas Stegemann. He had the great idea for the PWM-algorithm, and I am always astonished by the patience he has to show me how to do anything complicated in a sick language like C…

About the license

My work is licensed under the GNU General Public License (GPL). A copy of the GPL is included in License.txt.

Download

i2c-dimmer_111210.tar.gz – Sourcecode and documentation, 232kB

I2C-LED-Matrix

06.05.2009 by Ronald·0 Comments

I didn’t have this article on my blog in 2009, it came over from my old CMS in 2015.

Test circuit on breadboard

This project turns an AVR ATmega8 microcontroller into a LED controller for a matrix of 8×8 LEDs. The controller is acting as I2C-slave, so you can control the patterns to display via this bus (also known as TWI, Two Wire Interface).

Purpose

For my next project, I need to display number values on seven-segment-displays. I bought a bunch of 4-digit-displays a while ago, now I’m going to put them to a use. They are built with four digits in one case, and 12 pins on the underside. Eight of them are the cathodes of the segments (seven segments plus dot), four are the anodes. One for each digit.

You can imagine these modules as a matrix of four times eight LEDs, as can be seen in the included circuit. I use two of these, so I have a matrix of eight times eight LEDs.

The rows and columns of this matrix are connected to the microcontroller, so it can power them row by row. This has two advantages: at first a maximum of eight LEDs is powered at a time, so power consumption is lowered. And at second you need only 16 pins of the controller to address a total of 64 LEDs.

Driving the LEDs in this way makes them flicker a bit, but the controller is fast enough to keep the flickering way above the level you would be able to recognize.

I could have connected my display modules directly to the main controller of my next project, but I don’t have enough free pins on that. As a further benefit, multiplexing the LEDs on a second controller makes the main program easier to write, since I don’t have to mind the timing. So the solution is to use a cheap ATmega8 as LED driver and use the I2C-bus to tell it what to display.

I2C communication

The ATmega8 has a built-in hardware I2C-interface, so it doesn’t take very much code to use it. Nevertheless, I used a little library that Uwe Grosse-Wortmann (uwegw) published on roboternetz.de. I only reformatted it a bit to make the code resemble my style. It is well commented, but the comments are in german. Since only one global array, one init-function and an interrupt service routine are used, it shouldn’t be too hard for english-speaking people to figure out how it is used.

Usage

On the other end of the communication, I used the excellent Procyon AVRlib written by Pascal Stang. You can find it here.

 #define I2C_LEDMATRIX 0x10   // address of the device
 timerInit();                 // initialize timers
 timerPause(100);             // give everything a little time to settle
 i2cInit();                   // initialize i2c function library
 timerPause(100);             // wait a bit more
 while (1) {                  // endless loop
     uint8_t buffer[9];       // prepare buffer
                              // loop until 255
     for (uint8_t i = 0; i <= 255; i++) {
                              // set all bytes of the buffer to value i
         memset(buffer, i, sizeof(buffer));
                              // send the buffer via I2C-bus
         i2cMasterSend(I2C_LEDMATRIX, sizeof(buffer), buffer);
         timerPause(500);     // wait, so you have the time to watch
     }
 }

#define I2C_LEDMATRIX 0x10 // address of the device

timerInit(); // initialize timers

timerPause(100); // give everything a little time to settle

i2cInit(); // initialize i2c function library

timerPause(100); // wait a bit more

while (1) { // endless loop

uint8_t buffer[9]; // prepare buffer

// loop until 255

for (uint8_t i = 0; i <= 255; i++) {

// set all bytes of the buffer to value i

memset(buffer, i, sizeof(buffer));

// send the buffer via I2C-bus

i2cMasterSend(I2C_LEDMATRIX, sizeof(buffer), buffer);

timerPause(500); // wait, so you have the time to watch

}

The Circuit

Note: the buffer doesn’t contain any numbers that should be displayed on 7segment-displays. At least not in this example. It only holds bit-patterns.

Displaying numbers

If you solder 7segment displays to the unit and intend to display numbers or characters on it, you need to define them on the master-side of the bus. I didn’t include the definitions in this library because I want the master to have the full flexibility of displaying whatever it wants to, even if it are no numbers.

However, if you are going to use 7segment displays, definition of the numbers still depends on how you soldered them to the controller. I don’t know if the pin-outs are commonly standardized.

To give an example of how you would implement this, here is a fragment of code that defines hexadecimal numbers for usage on my displays:

 // Names of the segments:
 //      aaaaa
 //     f     b
 //     f     b
 //      ggggg
 //     e     c
 //     e     c
 //      ddddd  h
 uint8_t characters[16];
 //               c          e          g          a          h          f          b          d
 characters[ 0] = (1 << 0) | (1 << 1) | (0 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (1 << 6) | (1 << 7); // 0
 characters[ 1] = (1 << 0) | (0 << 1) | (0 << 2) | (0 << 3) | (0 << 4) | (0 << 5) | (1 << 6) | (0 << 7); // 1
 characters[ 2] = (0 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (0 << 5) | (1 << 6) | (1 << 7); // 2
 characters[ 3] = (1 << 0) | (0 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (0 << 5) | (1 << 6) | (1 << 7); // 3
 characters[ 4] = (1 << 0) | (0 << 1) | (1 << 2) | (0 << 3) | (0 << 4) | (1 << 5) | (1 << 6) | (0 << 7); // 4
 characters[ 5] = (1 << 0) | (0 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (0 << 6) | (1 << 7); // 5
 characters[ 6] = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (0 << 6) | (1 << 7); // 6
 characters[ 7] = (1 << 0) | (0 << 1) | (0 << 2) | (1 << 3) | (0 << 4) | (0 << 5) | (1 << 6) | (0 << 7); // 7
 characters[ 8] = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (1 << 6) | (1 << 7); // 8
 characters[ 9] = (1 << 0) | (0 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (1 << 6) | (1 << 7); // 9
 characters[10] = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (1 << 6) | (0 << 7); // a
 characters[11] = (1 << 0) | (1 << 1) | (1 << 2) | (0 << 3) | (0 << 4) | (1 << 5) | (0 << 6) | (1 << 7); // b
 characters[12] = (0 << 0) | (1 << 1) | (0 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (0 << 6) | (1 << 7); // c
 characters[13] = (1 << 0) | (1 << 1) | (1 << 2) | (0 << 3) | (0 << 4) | (0 << 5) | (1 << 6) | (1 << 7); // d
 characters[14] = (0 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (0 << 6) | (1 << 7); // e
 characters[15] = (0 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (0 << 6) | (0 << 7); // f

// Names of the segments:

// aaaaa

// f b

// ggggg

// e c

// ddddd h

uint8_t characters[16];

// c e g a h f b d

characters[ 0] = (1 << 0) | (1 << 1) | (0 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (1 << 6) | (1 << 7); // 0

characters[ 1] = (1 << 0) | (0 << 1) | (0 << 2) | (0 << 3) | (0 << 4) | (0 << 5) | (1 << 6) | (0 << 7); // 1

characters[ 2] = (0 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (0 << 5) | (1 << 6) | (1 << 7); // 2

characters[ 3] = (1 << 0) | (0 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (0 << 5) | (1 << 6) | (1 << 7); // 3

characters[ 4] = (1 << 0) | (0 << 1) | (1 << 2) | (0 << 3) | (0 << 4) | (1 << 5) | (1 << 6) | (0 << 7); // 4

characters[ 5] = (1 << 0) | (0 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (0 << 6) | (1 << 7); // 5

characters[ 6] = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (0 << 6) | (1 << 7); // 6

characters[ 7] = (1 << 0) | (0 << 1) | (0 << 2) | (1 << 3) | (0 << 4) | (0 << 5) | (1 << 6) | (0 << 7); // 7

characters[ 8] = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (1 << 6) | (1 << 7); // 8

characters[ 9] = (1 << 0) | (0 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (1 << 6) | (1 << 7); // 9

characters[10] = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (1 << 6) | (0 << 7); // a

characters[11] = (1 << 0) | (1 << 1) | (1 << 2) | (0 << 3) | (0 << 4) | (1 << 5) | (0 << 6) | (1 << 7); // b

characters[12] = (0 << 0) | (1 << 1) | (0 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (0 << 6) | (1 << 7); // c

characters[13] = (1 << 0) | (1 << 1) | (1 << 2) | (0 << 3) | (0 << 4) | (0 << 5) | (1 << 6) | (1 << 7); // d

characters[14] = (0 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (0 << 6) | (1 << 7); // e

characters[15] = (0 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (0 << 4) | (1 << 5) | (0 << 6) | (0 << 7); // f

Drawbacks

Till now, the device worked in all situations I tested it in. So far everything is fine.

Thanks!

I’d like to thank the authors of the libraries I used: Uwe Grosse-Wortmann (uwegw) for the I2C-slave and Pascal Stang for the Procyon AVRlib.

About the license

My work is licensed under the GNU General Public License (GPL). A copy of the GPL is included in License.txt.

Download

i2c-ledmatrix_090506.tar.gz – Source code and documentation, 212kB

Schatenseite

Ronald Online

Tag: I2C

I2C-Dimmer

Pulse width modulation

The old way

Thomas’ idea

I2C communication

Usage

Connecting it

Talking to it

Examples

I2C-Fader on testboard

Visible PWM

Drawbacks

Thanks!

About the license

Download

I2C-LED-Matrix

Purpose

I2C communication

Usage

Displaying numbers

Drawbacks

Thanks!

About the license

Download