74HC595 & 74HC165 Shift Registers with Arduino
Vložit
- čas přidán 8. 07. 2024
- Expand your Arduino with shift registers! Today I will show you how to use the 74HC595 and 74HC165 to increase your Arduino's inputs and outputs so we can flash a bunch of LEDs.
Article with all the code: dronebotworkshop.com/shift-re...
More articles and tutorials: dronebotworkshop.com
Suggest new content and meet new people - join the forum: forum.dronebotworkshop.com
Get the newsletter and stay in touch: dronebotworkshop.com/subscribe/
Shift registers are sequential logic circuits that can be used to convert between serial and parallel data. Really exciting stuff, right?
Well although these fundamental building blocks may not seem that thrilling, they can be really useful in expanding the number of digital outputs and inputs on Arduino and other microcontrollers.
Today we will work with two common 8-bit shift registers, the 74HC595 and 74HC165.
We will use the 74HC595 to drive eight LEDs with just a few connections. By cascading these chips we can drive a lot more LEDs. We will also use the 74HC595 to drive a 7-segment LED display.
After that we will hook up eight push buttons to a 74HC165, reading them all using just a few I/O lines on our Arduino.
And finally, we’ll put both chips together and build a really fun LED light sequencer with eight different flashing patterns.
Here is a breakdown of this extensive coverage of shift registers with the Arduino:
00:00 - Introduction
03:03- How Shift Registers Work
07:32 - More outputs with the 74HC595
15:22 - Driving a 7-Segment Display
21:49- Extra inputs with the 74HC165
29:46 - 74HC595 & 74HC165 Together
34:30 - Custom Light Sequencer
If you’d like to get the code I used to make all this magic happen just visit the DroneBot Workshop website where you'll find a full article to accompany this video.
BTW, this video was suggested to me by some great folks on the DroneBot Workshop Forums. That’s the place to go if you want to suggest new content or just interact with some amazing people who love electronics just like you do. Join us today at forum.dronebotworkshop.com. - Jak na to + styl
![The Shift Register: Explained [74HC595]](/img/n.gif)
this gentleman is so generous in giving knowledge, I wish him the best in all (health, long life, fortune, good wife, and more important to stay progressed) >>>> big hug to you from Iraq 🌹
yup, agree with you :D
Can you be more specific regarding the "good" wife please?
@@muesli4597
I was expressing best wishes for him basing on my country best wishes to good people.
In Iraq, one of good wishes to a friend is to wish him have a good wife to support and live with her happily 😉
Did you consider peoples sexual preferences before jumping to a conclusion?
@@muesli4597 Dude can you stop talking please
I just want to say that I began my electrical career as a electrical technician by starting out with tinkering with microcontrollers, namely Arduinos. I learned the basics from Drone Bot Workshop and carried the knowledge I learned from it to other fields and through these events impressed my current employer to land a job straight out of community college. Thank you so much for all you do. I will be donating to show my gratitude and appreciation :) I encourage anyone else who understands how valuable and rare it is to find material like the one DBW provides.
I have found the Bob Ross of Electronics. Subscribed.
Great video! Simple and straight forward. I feel I have a better grasp on these than I have ever had.
Another incredible tutorial video. The level of detail and explanation you provide in these tutorials is amazing. Thanks so much
Bill *ALWAYS* has a way of presenting video's in a very logical way. And he presents a wide range of projects!
your videos are becoming top notch and quickly my favorite on youtube, keep it coming!
A video that illustrates in a great way some articles on the Net I had to read when I had to deal with shift registers for my project. I wish you had published this before : clear, informative and now, 74H* are not magic to me anymore! Great examples too!!
Thank you! I've seen multiple videos saying "this is what a shift register does" but never showed how to actually use it
This is one of the best explanation and tutorials on logic gates I have come across. The examples you’ve created showcase their use very well. Great work and worth the wait! Thank-you! Now I’m off to order some logic chips to play with.
Thank you Bill!
Just what I was looking for. I was lurking around on your forum site and found this in a topic discussion.
Your forum website is great!
Keep up with the good work.
Another amazing video. Thank you kindly for putting this together, it will simplify a very important and useful process in digital electronics for the amateur/enthusiast.
Hey Bill! I needed a good tutorial for my daughter (she's learning digital electronics) and this was my go-to for shift registers. Great video and thank you for presenting this subject in such a way that it is easy to understand for complete beginners!
This video really helped me. Now my 5x5 led display project can be upgraded to have everything on one board. Thank you!
Thank you for the time you give people like myself who are looking to improve their skills with Arduino projects. Your an amazing teacher and I wish you the best in all aspects of life. I love how you explain everything in a normal calm voice unlike others who speak so fast or don't explain in the detail you do. Thanks again
Hi, I have used this Sketch to make my own 8 by 8 LED Matrix with 1 74hc595 and I am also just 14 years old, thank you a Lot!
Thanks for all the great support for my hobby! Very good tutorials! Thanks very much for all your work!
Superb!! Your image / write up on your website was even better. Very grateful to you :)
Thank you so much for taking the time to do these videos!
Very useful tutorial, thank you for the work you put in on this. I did get confused when the clock enable pin was used as the clock and the clock pin was used as the enable. I got the data sheet and sure enough it said those pins are interchangeable. I like the way you taught how the byte was complemented to get it back to what it really represented.
Excellent tutorial! Good job man!
Hi, have used this Sketch to make my own 8 by 8 LED Matrix with 1 74hc595 and I am also just 14 years old!
i just cant get enough of watching your videos , you among a few who i take as my reference to learn a new skill , so thank you very much
Great tutorial. I used these for controlling a board of 8 active low opto-isolated relays, in conjunction with a library I made specifically for this setup.
Basically, shift registers act like gateways.
Such detailed and easy content is rare
Ultra helpful. Thanks for the vid!!
Very much appreciated! You are making a difference in this world!
Another great video as usual. I haven't seen or heard anything about DB1 in a very long time. I never expected you to do one a week plus one a week of the component level videos as you had once proposed. That's just to much work! I was however hoping you were going to do a DB1 video every other time.
I was not planning on building one right now, but was so intrigued by your concept I needed more. I take it that you were not getting enough interest from other viewers to keep it going? That's really ashame. That looked like it was going to be something really special. I would love to see you bring it back to life.
You are amazing!
For me, you are the Andrew Huberman of electronics.
There is nobody out there that conveys the information needed to create your own schematics more concisely than you.
Fabulous video and detailed explanation. Not only explaining what shift registers are and their benefits, but also a practical example of how they can be used in the real world (or workshop). Thank you very much.
When you talk about SIPO and PISO, you may use branched and directional arrows to illstrate their jobs in a visual manner.
Excellent! I needed to read the states of several pir and magnetic switch sensors while also controlling lights. Shift registers fit this problem like a glove.
Really good video, you take the time to explain, and you speak at just the right pace for me to process what is going on. Great to see practical use rather than all just flop flop theory!
heck ya, anytime im lookin for a refresher on something i find your videos.
Thanks for your in-depth explanation.
Like always very well done, thanks
Very good explanation.Soothing voice,nice to listen,.Very calm.You got an arduino-fan subscribed!!
I'm from Iraq .. your videos are very excellent. And very useful. Thank you very very much.. I wish for you the best 🌹❤
Cheers, makes sense finally!
Crystal clear explanation, thanks!
This was great education and demonstration. Thank you!!!!
Great video. Thank you!
Amazing, thanks for the tutorial.
Excellent video!
Awesome professor! Love it.
Super bon boulot! As usual 😉
You really are a wealth of knowledge.
perfect explanation ... Thanks from Vienna/Austria
coolest thing ever. great explanation.
You do beautiful work.
I studied a lot.
Thank you for teaching me properly.^^
It was very helpful and useful.
Very helpful information
Thanks so much for another excellent video. I'm one of the people who asked for this subject and thrilled to see you listen to us - thanks!
Thank you, it helped me a lot : )
Great tutorial!
Purchased on Amazon and tested (Worked Great) these Jameco Valuepro 4116R-1-331LF. Bussed Resistor Network, 16 Pin, 125 mWatt, 330 Ohm, 2% Tolerance ... Great Video!!
Great video and very very helpful.
Thank u so much for this clear explaination!
Amazing ! Thank you !
i really like his tutorials
Thank you for your excellent presentation. Well done keep it up.
Thank you
It's very beautiful and practical
Getting a few resistor array dips. Fiddling with individual resistors is for the birds.
Great video! After some initial problems due to my own stupidity (forgot that the same rows on the breadboard are connected ^^..) I got my example to work. Finally I understood how to work with SIPO shift registers and I can't wait to use multiple ones in order to drive more LEDs.
I am an amateur electronics enthusiast, i'm a Noob, i will have to re-watch this a few times, great video by the way.
You are just amazing dude! Thank you very much
Great video. Thank you
love it ..thank you man
Best ever explanation ... Love from INDIA
Geee... a great coffee shop video... Aaah, with some Irish-coffee i can watch most anything...:] and this shift is register wonderful stuff... makes me think of the heath-kit days. thaanks a lot...:)
You deserve more than you get!
Super !, Thank you very much and wish you all the best! 👍👍👍
Great video !!
I'm a complete novice when it comes to basic electronics. I was searching for PISO without knowing it. Thinking it must be named differently because I associated shift registers solely with SIPO functionality. Thanks so much for enlightening me!
Hi Bill,
It's great as all of your videos.
GOD explanation. trashes those of difficult web explanations by words.
Thanks a lot for educate us. Sir
Very good subject
Very interresting video
I didn't think shift register are so useful
Thanks for sharing!
Nice video. Thank you.
Hi, I have used this Sketch to make my own 8 by 8 LED Matrix with 1 74hc595 and I am also just 14 years old, thank you a Lot!
Excuse me, but how did you manage to drive 64 Leds with just the eight outputs of one 74hc595?
I really don't get why this guy hasn't more subs. Your one of the best content creators on CZcams!
Probably because he's too specific and slow in his way of explaining his projects, this requires a mind-set that accept this type of videos. People these days are stressed and can't put themselves to listen to him for 30-40min about how you get some LED to blink, they just want the fancy product, not the "boring" side of it.
I get calm when listen too teachers and or people like this man or Ben Eater (probably butchered him surname...)
Thank you for sharing your knowledge. This is very helpful to me. I'm making a 28 standard LED police light bar for my RC using a Teensy. It seems using SIPO shift register is the way to go.
Great tutorial.
Parabéns por falar um Inglês pausado e fácil de entender. Isso facilita muito para quem não tem o inglês como língua nativa.
You, Sir, have opened the doors to my better understanding of Arduino and bitwise logic, and I thank you sincerely. I'm 62-years-old and discovered the Arduino playground in early January of 2020, and I'm hooked (it's my new hobby). After using the 74HC595 in an early LED display project, I began to study the nuts-and-bolts of the unit, and I find this all fascinating. For those interested in the logic-level workings of the 74HC595 (or any other chips, for that matter), here are a few references that I've discovered along the way that can be used by both beginners and advanced coders alike.
For those who aren't familiar with bitwise operations and boolean algebra, don't let the big words fool you; it's as simple as yes or no, on or off, zero or one...just forget about the world of 0s and 9s, and shift into the world of 0x0 through 0xf (hex numbers), and 0b0 through 0b1 (binary numbers (all two of them)). Once I started coding with hex and binary numbers back in 1990, I never looked back. Mentally converting hex numbers into binary numbers and vice versa is simple, once you learn the trick.
I've C & Ped a copy of comments I wrote for a 74HC595 bit-shifting LED project I wrote. I'll share the code on the DroneBot Workshop as soon as I can. When I code, I comment a lot; I comment on the comments if need be.
// Forward: The 74HC595 is a SIPO (Serial In, Parallel Out) shift register used to store eight bits of serial data,
// and to produce eight bits of parallel outputs. There are two data registers inside the 74HC595:
//
// 1) the SHIFT register, used to store the serial data inputs ([shift: 1] shifted-in by the shift clock, via the data pin)
// 2) the STORAGE register, which stores the parallel output data shifted-in from the SHIFT register ([shift: 2] by the latch clock, internal).
//
// In review: the "shift clock" shifts data into the SHIFT register, and after eight bits are shifted into the
// SHIFT register, the "latch clock" shifts the data stored FROM the SHIFT register INTO the STORAGE register,
// which produces the eight bits of outputs. (lol I'm not screaming; just making a point.)
//
// The 74HC595 is mainly utilized to reduce the amount of output pins needed to use from the microcontroller board
// (the Arduino UNO board, in this case). Using three pins from the microcontroller board, the 74HC595 provides
// eight output pins in a state of either on or off at 5vDC or 0vDC (and no, you can't PWM through the 74HC595).
//
// The 74HC595 contains 8-sets of master/slave flip-flop logic circuits running on an operating voltage range of 2vDC
// to 6vDC (the logic runs at the data-input voltage level), 80μA (maximum draw), and is the coolest little gadget to
// entertain one's self with. The more I learn, the more I realize how simple this device really is. When I begin
// programming FPGAs (soon), one of my first goals is to create an operational bit shifter. I'm lovin' it!
//
// There are three states that the parallel output can be set to: ON, OFF, and high impedance. High impedance
// blocks any data shifts (and is toggled by the OE (with a bar above the OE) pin). If you want inputs/outputs
// turned off? Simply set the OE pin HIGH, otherwise, it defaults to LOW. The shift register can also be directly
// overridden and cleared by setting the SRCLR (with a bar above the SRCLR) pin LOW, otherwise, it defaults to HIGH.
//
// The best reference I've found for the 74HC595 is: lastminuteengineers.com/74hc595-shift-register-arduino-tutorial/
// They do a great job of explaining the internal operations of the 74HC595 shift register in simple terms.
And yes, the previous post was premature. I meant to say more with additional links, but the main jist of the idea came through.
It's probably not appropriate, but here's the entire .ino file. It doesn't read as well here, but C & P it into the Arduino IDE; play around, have some fun.
//øøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøø//
//øøøøø[ Begin: Global variables ]]øøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøø//
#include // a library of functions for using flash memory and stuff.
#define OP_SPEED 0x64 // used to set the speed at which the 74HC595 is updated
#define ARRAYSIZE 0xf0 // used to define the size of the dataArray[] and to end loop iterations
const int dataPin = SDA; // Arduino UNO digital SDA pin connected to the DS pin of the 74HC595 shift register (Serial data input)
const int clockPin = SCL; // Arduino UNO digital SCL pin connected to the SH_CP of the 74HC595 shift register (SHIFT clock pin)
const int latchPin = SCK; // Arduino UNO digital SCK pin (a.k.a. pin 13) connected to the ST_CP of the 74HC595 shift register (STORAGE register clock pin (latch pin))
const byte dataArray[ ARRAYSIZE ] PROGMEM = { // the data array: binary data stored in flash memory used as switches to turn LEDs on and off.
B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001, B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000,
B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001, B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000,
B10000000, B11000000, B11100000, B11110000, B11111000, B11111100, B11111110, B11111111, B11111111, B11111110, B11111100, B11111000, B11110000, B11100000, B11000000, B10000000,
B10000000, B11000000, B11100000, B11110000, B11111000, B11111100, B11111110, B11111111, B11111111, B11111110, B11111100, B11111000, B11110000, B11100000, B11000000, B10000000,
B00000001, B00000011, B00000111, B00001111, B00011111, B00111111, B01111111, B11111111, B11111111, B01111111, B00111111, B00011111, B00001111, B00000111, B00000011, B00000001,
B00000001, B00000011, B00000111, B00001111, B00011111, B00111111, B01111111, B11111111, B11111111, B01111111, B00111111, B00011111, B00001111, B00000111, B00000011, B00000001,
B00000001, B00000011, B00000111, B00001111, B00011111, B00111111, B01111111, B11111111, B11111111, B01111111, B00111111, B00011111, B00001111, B00000111, B00000011, B00000001,
B11111111, B11111111, B11111111, B11111111, B00000000, B00000000, B00000000, B00000000, B11111111, B11111111, B11111111, B11111111, B00000000, B00000000, B00000000, B00000000,
B11111111, B11111111, B11111111, B11111111, B00000000, B00000000, B00000000, B00000000, B11111111, B11111111, B11111111, B11111111, B00000000, B00000000, B00000000, B00000000,
B11000011, B11000011, B11000011, B11000011, B00111100, B00111100, B00111100, B00111100, B11000011, B11000011, B11000011, B11000011, B00111100, B00111100, B00111100, B00111100,
B11000011, B11000011, B11000011, B11000011, B00111100, B00111100, B00111100, B00111100, B11000011, B11000011, B11000011, B11000011, B00111100, B00111100, B00111100, B00111100,
B11001100, B11001100, B00110011, B00110011, B11001100, B11001100, B00110011, B00110011, B11001100, B11001100, B00110011, B00110011, B11001100, B11001100, B00110011, B00110011,
B11001100, B11001100, B00110011, B00110011, B11001100, B11001100, B00110011, B00110011, B11001100, B11001100, B00110011, B00110011, B11001100, B11001100, B00110011, B00110011,
B01010101, B10101010, B01010101, B10101010, B01010101, B10101010, B01010101, B10101010, B01010101, B10101010, B01010101, B10101010, B01010101, B10101010, B01010101, B10101010,
B01010101, B10101010, B01010101, B10101010, B01010101, B10101010, B01010101, B10101010, B01010101, B10101010, B01010101, B10101010, B01010101, B10101010, B01010101, B10101010,
};
//øøøøø[ End: Global variables ]øøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøø//
//øøøøø[ Begin: setup() function ]øøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøø//
void setup() {
pinMode( clockPin, OUTPUT ); // init the clockPin to output
pinMode( latchPin, OUTPUT ); // init the latchPin to output
pinMode( dataPin, OUTPUT ); // init the dataPin to output
}
//øøøøø[ End: setup() function ]øøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøø//
//øøøøø[ Begin: loop() function ]øøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøøø//
void loop() {
byte *buf_p; // a pointer to the dataArray[] memory address at the time we're reading the data
// begin outer for() loop - this loop pushes the data from the 74HC595's SHIFT register into its STORAGE register
for ( int
thisByte = 0x00; // declare an index for the data array starting at zero
thisByte
CORRECTION: you actually can PWM through the 74HC595 using the OE pin with analogWrite() commands. I got in front of myself on that one; my bad.
I kept using eight resistors for these shift register projects, so I cheaped out and stuck them in a DIP socket. Works okay.
Thank you, Sir!
Muito boa aula, parabéns!
thank you so much!!!
Great videos. Very well structured.
Also, being genuine here, serious respect to a guy whose slight speech impediment means he pronounces 'sh' as a kind of 'slzch' having the word workSHop in his title and doing a video on SHift registers. :)
Very Very useful tutorial .I respect you Sir a lot. thanking you very much.
Amazing and great job :)).. I'm just discovering Arduino and programing. Thank You :)
Love all your videos and really appreciate your detailed explanations. Just one thing, I would like to request is that you should zoom in the Arduino Code screen so that the words are readable even on smaller devices.
Thanks so much for another excellent video how can people give a negative view of your kind words and knowledge love this vid thank you,.//.,
Well explain keep it simple thanks
Parabéns! Muito bem explicado. Obrigado por compartilhar o conhecimento para o bem mundial.
Synchronicity: A day before this video came out, I was trying to figure out how I could use, say, n outputs from an Arduino to drive, say, 2^n LEDs. I'm very new to electronics and microcontrollers, but I've been doing software development professionally for several years. I love this circuit because it does exactly what I was trying to solve, the circuits in the IC aren't hard to understand, and it's great I can just buy an IC instead of wiring all that stuff together. In software development we have libraries of pre-defined stuff, just as ICs are packages of functionality. So ICs follow the same principle we do: package and make freely available bunches of commonly used functionality.
Hope systemd or other models of development don't reach this area...
Shift registers are often unknown by hobbyists and forgotten by others. I have seen them in a lot of designs since the 70's. Computers, wending machines and as receiver/decoders in military radar equipment. You find them very cheap on Ebay. Try to get hold of the good old Texas TTL Handbook.There are many fun and interesting chips in the 74 series.Even an ALU.
awesome! thanks!!
Nice! You can also use 7 segment display to demonstrate the operation of this IC.
Helpful video! I would like to ask please, is it possible to use the push buttons in on off setting? Thanks a lot