Shift Register

[greenaum]

Hi,

I'm planning to build a scrolling LED display with my Arduino. One
thing I think I'll need, is shift registers.

It'll be a grid 7 high x however wide. Arduino will be driving the 7
row pins therefore, and the shift register providing ground for each
column. Unless the other way's better for some reason.

The idea would be to keep the shift registers full of '1's, right?
With one '0' that I circulate round with each tick, to selectively
provide ground for a column at a time. Clocked by an Arduino pin.

My main worrry, I think, is current capacity. How much should I be
feeding the LEDs? Do I need resistors to limit current or does the low
duty cycle make that unimportant? More importantly, and this is my
question, what shift register do I use? It'll have to sink up to 7
LEDs at a time. It's actually a bugger looking up current ratings on
component suppliers, it's always in the PDF, never available on the
page. So what technology do I use? CMOS, TTL, HCT etc?

If you're naming suppliers, UK would be best since it's where I am,
but just part numbers will be fine.

Any hints on this, I'd be grateful! I'll probably start off with just
a couple of the 7x5 modules for the display, then build up once I get
it working. AFAIK you can drive a good few dozen columns in this way
while keeping decent brightness. Ta!


--

--------------------------------------------------------------------------------
"There's nothing like eating hay when you're faint," the White King remarked to Alice, as he munched away.
"I should think throwing cold water over you would be better," Alice suggested: "--or some sal-volatile."
"I didn't say there was nothing better," the King replied. "I said there was nothing like it."
Which Alice did not venture to deny.

 

[Computer Nerd Kev]

greenaum <greenaum@gmail.com> wrote:

It'll be a grid 7 high x however wide. Arduino will be driving the 7
row pins therefore, and the shift register providing ground for each
column. Unless the other way's better for some reason.

TTL chips can sink much more current than they can source, so that is
the best arrangement (though it doesn't matter when you consider what
I say below).

The idea would be to keep the shift registers full of '1's, right?
With one '0' that I circulate round with each tick, to selectively
provide ground for a column at a time. Clocked by an Arduino pin.

Yeah, you could use a capacitor to give you the starting zero, but you
might prefer just to hook it up to an Anduino output.

My main worrry, I think, is current capacity. How much should I be
feeding the LEDs? Do I need resistors to limit current or does the low
duty cycle make that unimportant?

Woah, yes definately use resistors. the equation for the resistor is
(<supply voltage>-<LED Voltage&gt/<LED current>. Most LEDs can take 20mA
current, but you might be able to use less and still get enough brightness.

More importantly, and this is my
question, what shift register do I use? It'll have to sink up to 7
LEDs at a time. It's actually a bugger looking up current ratings on
component suppliers, it's always in the PDF, never available on the
page. So what technology do I use? CMOS, TTL, HCT etc?

You will have trouble driving seven LEDS from one chip.

The standard chip for the job would be a 74LS164, while 74LS299 and 74LS323
should also do. Problem is that these can only sink 8mA; one LED is bright
enough at this current, but I doubt you will get good results running seven
at 1mA each.

The CMOS world offers the 4015, but it can't do any better. You could also
go for 74AS or 74ALS to get about twice the current capability, but they
are harder to find.

The conclusion is to use a 74LS164 or whatever with a buffer transistor
on each output.

Any hints on this, I'd be grateful! I'll probably start off with just
a couple of the 7x5 modules for the display, then build up once I get
it working. AFAIK you can drive a good few dozen columns in this way
while keeping decent brightness. Ta!

In theory I'd say you should be able to drive as many columns as you want.

It might help to read up a bit more on electronics theory before you get
started with this though.

--
__ __
#_ < |\| |< _#

 

[petrus bitbyter]

"greenaum" schreef in bericht
news:53998036.9422656@news.eternal-september.org...

Hi,

I'm planning to build a scrolling LED display with my Arduino. One
thing I think I'll need, is shift registers.

It'll be a grid 7 high x however wide. Arduino will be driving the 7
row pins therefore, and the shift register providing ground for each
column. Unless the other way's better for some reason.

The idea would be to keep the shift registers full of '1's, right?
With one '0' that I circulate round with each tick, to selectively
provide ground for a column at a time. Clocked by an Arduino pin.

My main worrry, I think, is current capacity. How much should I be
feeding the LEDs? Do I need resistors to limit current or does the low
duty cycle make that unimportant? More importantly, and this is my
question, what shift register do I use? It'll have to sink up to 7
LEDs at a time. It's actually a bugger looking up current ratings on
component suppliers, it's always in the PDF, never available on the
page. So what technology do I use? CMOS, TTL, HCT etc?

If you're naming suppliers, UK would be best since it's where I am,
but just part numbers will be fine.

Any hints on this, I'd be grateful! I'll probably start off with just
a couple of the 7x5 modules for the display, then build up once I get
it working. AFAIK you can drive a good few dozen columns in this way
while keeping decent brightness. Ta!


--

--------------------------------------------------------------------------------
"There's nothing like eating hay when you're faint," the White King remarked
to Alice, as he munched away.
"I should think throwing cold water over you would be better," Alice
suggested: "--or some sal-volatile."
"I didn't say there was nothing better," the King replied. "I said there was
nothing like it."
Which Alice did not venture to deny.

***

As you are multiplexing x columns, a LED will light only 1/x of the time.
Depending on x and on the properties of your LEDs you may need to source
20mA or even more. Don't know what current your Arduino pins can source.

So your column drivers may need to sink 140mA or more. I'm don't know any
logic family able to sink that amount of current. Even the old 7406 did 30mA
max. if memory serves. You will have to add a buffer transistor for every
column. Be aware that your output will be inverted by it.

petrus bitbyter

 

[David Platt]

In article <5397a3f1$0$4912$e4fe514c@dreader35.news.xs4all.nl>,
petrus bitbyter <petrus.bitbyter@hotmail.com> wrote:

So your column drivers may need to sink 140mA or more. I'm don't know any
logic family able to sink that amount of current. Even the old 7406 did 30mA
max. if memory serves. You will have to add a buffer transistor for every
column. Be aware that your output will be inverted by it.

As others have suggested: use a buffer transistor for each column.

Urgent recommendation: run separate power and ground-return wires for
the LEDs (e.g. a good-sized wire from Vcc to the PNP row-drivers, and
a good-sized ground wire from the NPN column drivers back to system
ground). Power your logic chips (shift registers) via separate power
and ground.

A guy I know built a system like this some years ago, and neglected to
use separate wires for the high-current LED loads... he ran the shift
registers and latches on the same power bus. The Vcc and ground
bounced around enough, due to I^2*R voltage drop in the wiring, that
the system was completely unreliable.

 

[Cydrome Leader]

greenaum <greenaum@gmail.com> wrote:

Hi,

I'm planning to build a scrolling LED display with my Arduino. One
thing I think I'll need, is shift registers.

It'll be a grid 7 high x however wide. Arduino will be driving the 7
row pins therefore, and the shift register providing ground for each
column. Unless the other way's better for some reason.

The idea would be to keep the shift registers full of '1's, right?
With one '0' that I circulate round with each tick, to selectively
provide ground for a column at a time. Clocked by an Arduino pin.

My main worrry, I think, is current capacity. How much should I be
feeding the LEDs? Do I need resistors to limit current or does the low
duty cycle make that unimportant? More importantly, and this is my
question, what shift register do I use? It'll have to sink up to 7
LEDs at a time. It's actually a bugger looking up current ratings on
component suppliers, it's always in the PDF, never available on the
page. So what technology do I use? CMOS, TTL, HCT etc?

If you're naming suppliers, UK would be best since it's where I am,
but just part numbers will be fine.

Any hints on this, I'd be grateful! I'll probably start off with just
a couple of the 7x5 modules for the display, then build up once I get
it working. AFAIK you can drive a good few dozen columns in this way
while keeping decent brightness. Ta!

check out the Allegro UCN5841 or UCN5842.