Group Actions
Engagement
  • Author Author: colporteur
  • Date Created: Date Created
  • Views 30 views
  • Likes 2 likes
  • Comments 4 comments
Related
Recommended

Looking for an LED driver recommendation

colporteur

image

I'm looking for some suggestions on a replacement LED driver circuit for the one above..

I have 10 common cathode tri-colour LEDs I need to drive. I banged out this transistor circuit to isolate the LED's from the Arduino. A HIGH output from the Arduino should light the LED. I've used the transistor circuit on a small scale for driving LEDs. My formal training was in electronics but 20 years ago my career forked to computer networks as a system administrator and the electronics became a thing for hobbies.

I then thought there has to be an easier way. I started newark searching for possible drivers but my lack of practical experience in this area makes it tough. I'm looking for something simple that takes the load of the microcontroller. I found this SN74HCT245N bus driver and thought that might work. Four twenty pin IC's would give me 32 drivers. I need 30 in total. Simple IC's verses all the individual components would make PCB assembly definitely easier.

This is not high speed switching. It is simple on and off control for LED's. I'm hoping the folks that hang out here and do this sort of stuff all the time would have a recommendation for there go to circuits for this sort of thing. 

  • Have a look at the Lumissil IS31FL3218. Get 18 channels, so that drives 6 x RGB's.

  • in reply to colporteur

    I wrote a minimal one myself, it was really simple and barebones. The LP5030 will almost certainly have a different register layout and addressing scheme(I used the LP5860T which has 4 addresses), but that should only further simplify things.

    #pragma once
#include "i2c.hpp"

enum RefreshMode
{
    NO_VSYNC = 0,
    VSYNC_8BIT = 1,
    VSYNC_16BIT = 2,
};

enum PWMFreq
{
    FREQ_125kHZ = 0,
    FREQ_62_5kHZ = 1,
};

enum CurrentLimit
{
    LIMIT_7_5mA = 0,
    LIMIT_12_5mA = 1,
    LIMIT_25mA = 2,
    LIMIT_37_5mA = 3,
    LIMIT_50mA = 4,
    LIMIT_75mA = 5,
    LIMIT_100mA = 6,
};

class LP5860T
{
    I2C *i2c;
    uint8_t baseAddress; // LP5860T has too many registers for a single address, so it has 4. This is the common part of the 4 addresses a single LP5860T has. The last 2 bits(2LSB) change depending on which register needs to be accessed.
public:
    void write_reg(uint16_t reg, uint8_t data)
    {
        //Figure out which one out of the 4 addresses to use based on the register
        uint8_t address = baseAddress;
        if ((reg >> 9) & 1)
            address |= 0b0000010;
        if ((reg >> 8) & 1)
            address |= 0b0000001;
        i2c->writeu8(address, (uint8_t)reg, data);
    }

    LP5860T(I2C *i2c, bool a1, bool a0)
    {
        this->i2c = i2c;
        baseAddress = 0b1000000;
        if (a1)
            baseAddress |= 0b0001000;
        if (a0)
            baseAddress |= 0b0000100;
    }

    void enable(bool en)
    {
        write_reg(0x0, en);
    }

    void init(RefreshMode ref, uint8_t lineCount, PWMFreq freq)
    {
        uint8_t reg = (lineCount << 3) | (ref << 1) | freq;
        write_reg(0x1, reg);
    }

    void setCurrentLimit(CurrentLimit limit)
    {
        uint8_t defaultReg = 0x47;
        defaultReg &= 0b11110001;
        defaultReg |= (limit << 1);
        write_reg(0x4, defaultReg);
    }

    // Set max current limit per color, as a ratio to the current limit set by setCurrent(). 0 is 0%, 127 is 100%
    void setColorCompensation(uint8_t red, uint8_t green, uint8_t blue)
    {
        write_reg(0x9, red & 0b01111111);
        write_reg(0xA, green & 0b01111111);
        write_reg(0xB, blue & 0b01111111);
    }

    void setLED(uint8_t index, uint8_t brightness)
    {
        if(index >= 198) return;
        uint16_t reg = (uint16_t)0x200 + (uint16_t)index;
        write_reg(reg, brightness);
    }

    //Write all pixel colors as a single 198 byte array
    void writeFrameBuffer(uint8_t *data)
    {
        i2c->writeu8(baseAddress | 0b10, 0x0, data, 198);
    }

    void setBrightness(uint8_t brightness)
    {
        write_reg(0x5, brightness);
    }

    uint8_t getBrightness()
    {
        return i2c->readu8(baseAddress, 0x5);
    }
};


    If this is too complex and you're looking for something simpler, I'd look into high(er) current shift registers. MIC5891 is the only one I'm familiar with that would be a decent fit(watch out for the minimum voltage specs), it's a bit overkill too and not the cheapest, and you'd need four of them, but it's a simple and robust solution.

  • in reply to vmate

    I took a look. What library are you calling to support the device?

  • I've used TI's LP58xx series LED drivers in the past, and was very happy with them. They are a bit more complex than you're looking for, not sure if that's an issue. LEDs are controlled through I2C/SPI, not through individual control lines per LED.

    Is the common cathode LED a hard requirement, any chance you can swap them for common anode? With LP5030, you'd need a single IC and half a dozen passives to drive all of your LEDs. (or if you don't want to bother with soldering a QFN, then use two LP5018, which is available in a VSSOP package).