Temel bilgiler: Proje 018k
Arduino ile 74HC595 – Seriden Paralel Kaymaya Çıkış
Kodlar:
//**************************************************************//
// Name : shiftOutCode, Hello World
// Author : Carlyn Maw,Tom Igoe, David A. Mellis
// Date : 25 Oct, 2006
// Modified: 23 Mar 2010
// Version : 2.0
// Notes : Code for using a 74HC595 Shift Register //
// : to count from 0 to 255
//****************************************************************
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
void setup() {
//set pins to output so you can control the shift register
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}
void loop() {
// count from 0 to 255 and display the number
// on the LEDs
for (int numberToDisplay = 0; numberToDisplay < 256; numberToDisplay++) {
// take the latchPin low so
// the LEDs don't change while you're sending in bits:
digitalWrite(latchPin, LOW);
// shift out the bits:
shiftOut(dataPin, clockPin, MSBFIRST, numberToDisplay);
//take the latch pin high so the LEDs will light up:
digitalWrite(latchPin, HIGH);
// pause before next value:
delay(500);
}
}
/*
Shift Register Example
for 74HC595 shift register
This sketch turns reads serial input and uses it to set the pins
of a 74HC595 shift register.
Hardware:
* 74HC595 shift register attached to pins 8, 12, and 11 of the Arduino,
as detailed below.
* LEDs attached to each of the outputs of the shift register.
Created 22 May 2009
Created 23 Mar 2010
by Tom Igoe
*/
//Pin connected to latch pin (ST_CP) of 74HC595
const int latchPin = 8;
//Pin connected to clock pin (SH_CP) of 74HC595
const int clockPin = 12;
////Pin connected to Data in (DS) of 74HC595
const int dataPin = 11;
void setup() {
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
Serial.begin(9600);
Serial.println("reset");
}
void loop() {
if (Serial.available() > 0) {
// ASCII '0' through '9' characters are
// represented by the values 48 through 57.
// so if the user types a number from 0 through 9 in ASCII,
// you can subtract 48 to get the actual value:
int bitToSet = Serial.read() - 48;
// write to the shift register with the correct bit set high:
registerWrite(bitToSet, HIGH);
}
}
// This method sends bits to the shift register:
void registerWrite(int whichPin, int whichState) {
// the bits you want to send
byte bitsToSend = 0;
// turn off the output so the pins don't light up
// while you're shifting bits:
digitalWrite(latchPin, LOW);
// turn on the next highest bit in bitsToSend:
bitWrite(bitsToSend, whichPin, whichState);
// shift the bits out:
shiftOut(dataPin, clockPin, MSBFIRST, bitsToSend);
// turn on the output so the LEDs can light up:
digitalWrite(latchPin, HIGH);
}
/*
Shift Register Example
Turning on the outputs of a 74HC595 using an array
Hardware:
* 74HC595 shift register
* LEDs attached to each of the outputs of the shift register
*/
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
//holders for infromation you're going to pass to shifting function
byte data;
byte dataArray[10];
void setup() {
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
Serial.begin(9600);
//Binary notation as comment
dataArray[0] = 0xFF; //0b11111111
dataArray[1] = 0xFE; //0b11111110
dataArray[2] = 0xFC; //0b11111100
dataArray[3] = 0xF8; //0b11111000
dataArray[4] = 0xF0; //0b11110000
dataArray[5] = 0xE0; //0b11100000
dataArray[6] = 0xC0; //0b11000000
dataArray[7] = 0x80; //0b10000000
dataArray[8] = 0x00; //0b00000000
dataArray[9] = 0xE0; //0b11100000
//function that blinks all the LEDs
//gets passed the number of blinks and the pause time
blinkAll_2Bytes(2,500);
}
void loop() {
for (int j = 0; j < 10; j++) {
//load the light sequence you want from array
data = dataArray[j];
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//move 'em out
shiftOut(dataPin, clockPin, data);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(300);
}
}
// the heart of the program
void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {
// This shifts 8 bits out MSB first,
//on the rising edge of the clock,
//clock idles low
//internal function setup
int i=0;
int pinState;
pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, OUTPUT);
//clear everything out just in case to
//prepare shift register for bit shifting
digitalWrite(myDataPin, 0);
digitalWrite(myClockPin, 0);
//for each bit in the byte myDataOut�
//NOTICE THAT WE ARE COUNTING DOWN in our for loop
//This means that %00000001 or "1" will go through such
//that it will be pin Q0 that lights.
for (i=7; i>=0; i--) {
digitalWrite(myClockPin, 0);
//if the value passed to myDataOut and a bitmask result
// true then... so if we are at i=6 and our value is
// %11010100 it would the code compares it to %01000000
// and proceeds to set pinState to 1.
if ( myDataOut & (1<<i) ) {
pinState= 1;
}
else {
pinState= 0;
}
//Sets the pin to HIGH or LOW depending on pinState
digitalWrite(myDataPin, pinState);
//register shifts bits on upstroke of clock pin
digitalWrite(myClockPin, 1);
//zero the data pin after shift to prevent bleed through
digitalWrite(myDataPin, 0);
}
//stop shifting
digitalWrite(myClockPin, 0);
}
//blinks the whole register based on the number of times you want to
//blink "n" and the pause between them "d"
//starts with a moment of darkness to make sure the first blink
//has its full visual effect.
void blinkAll_2Bytes(int n, int d) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(200);
for (int x = 0; x < n; x++) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 255);
shiftOut(dataPin, clockPin, 255);
digitalWrite(latchPin, 1);
delay(d);
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(d);
}
}
//**************************************************************//
// Name : shiftOutCode, Dual Binary Counters //
// Author : Carlyn Maw, Tom Igoe //
// Date : 25 Oct, 2006 //
// Version : 1.0 //
// Notes : Code for using a 74HC595 Shift Register //
// : to count from 0 to 255 //
//**************************************************************//
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
void setup() {
//Start Serial for debuging purposes
Serial.begin(9600);
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
}
void loop() {
//count up routine
for (int j = 0; j < 256; j++) {
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//count up on GREEN LEDs
shiftOut(dataPin, clockPin, j);
//count down on RED LEDs
shiftOut(dataPin, clockPin, 255-j);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(1000);
}
}
void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {
// This shifts 8 bits out MSB first,
//on the rising edge of the clock,
//clock idles low
..//internal function setup
int i=0;
int pinState;
pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, OUTPUT);
. //clear everything out just in case to
. //prepare shift register for bit shifting
digitalWrite(myDataPin, 0);
digitalWrite(myClockPin, 0);
//for each bit in the byte myDataOut�
//NOTICE THAT WE ARE COUNTING DOWN in our for loop
//This means that %00000001 or "1" will go through such
//that it will be pin Q0 that lights.
for (i=7; i>=0; i--) {
digitalWrite(myClockPin, 0);
//if the value passed to myDataOut and a bitmask result
// true then... so if we are at i=6 and our value is
// %11010100 it would the code compares it to %01000000
// and proceeds to set pinState to 1.
if ( myDataOut & (1<<i) ) {
pinState= 1;
}
else {
pinState= 0;
}
//Sets the pin to HIGH or LOW depending on pinState
digitalWrite(myDataPin, pinState);
//register shifts bits on upstroke of clock pin
digitalWrite(myClockPin, 1);
//zero the data pin after shift to prevent bleed through
digitalWrite(myDataPin, 0);
}
//stop shifting
digitalWrite(myClockPin, 0);
}
//**************************************************************//
// Name : shiftOutCode, Dual One By One //
// Author : Carlyn Maw, Tom Igoe //
// Date : 25 Oct, 2006 //
// Version : 1.0 //
// Notes : Code for using a 74HC595 Shift Register //
// : to count from 0 to 255 //
//**************************************************************//
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
//holder for infromation you're going to pass to shifting function
byte data = 0;
void setup() {
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
}
void loop() {
//function that blinks all the LEDs
//gets passed the number of blinks and the pause time
blinkAll_2Bytes(1,500);
// light each pin one by one using a function A
for (int j = 0; j < 8; j++) {
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//red LEDs
lightShiftPinA(7-j);
//green LEDs
lightShiftPinA(j);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(1000);
}
// light each pin one by one using a function A
for (int j = 0; j < 8; j++) {
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//red LEDs
lightShiftPinB(j);
//green LEDs
lightShiftPinB(7-j);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(1000);
}
}
//This function uses bitwise math to move the pins up
void lightShiftPinA(int p) {
//defines a local variable
int pin;
//this is line uses a bitwise operator
//shifting a bit left using << is the same
//as multiplying the decimal number by two.
pin = 1<< p;
//move 'em out
shiftOut(dataPin, clockPin, pin);
}
//This function uses that fact that each bit in a byte
//is 2 times greater than the one before it to
//shift the bits higher
void lightShiftPinB(int p) {
//defines a local variable
int pin;
//start with the pin = 1 so that if 0 is passed to this
//function pin 0 will light.
pin = 1;
for (int x = 0; x < p; x++) {
pin = pin * 2;
}
//move 'em out
shiftOut(dataPin, clockPin, pin);
}
// the heart of the program
void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {
// This shifts 8 bits out MSB first,
//on the rising edge of the clock,
//clock idles low
//internal function setup
int i=0;
int pinState;
pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, OUTPUT);
//clear everything out just in case to
//prepare shift register for bit shifting
digitalWrite(myDataPin, 0);
digitalWrite(myClockPin, 0);
//for each bit in the byte myDataOut�
//NOTICE THAT WE ARE COUNTING DOWN in our for loop
//This means that %00000001 or "1" will go through such
//that it will be pin Q0 that lights.
for (i=7; i>=0; i--) {
digitalWrite(myClockPin, 0);
//if the value passed to myDataOut and a bitmask result
// true then... so if we are at i=6 and our value is
// %11010100 it would the code compares it to %01000000
// and proceeds to set pinState to 1.
if ( myDataOut & (1<<i) ) {
pinState= 1;
}
else {
pinState= 0;
}
//Sets the pin to HIGH or LOW depending on pinState
digitalWrite(myDataPin, pinState);
//register shifts bits on upstroke of clock pin
digitalWrite(myClockPin, 1);
//zero the data pin after shift to prevent bleed through
digitalWrite(myDataPin, 0);
}
//stop shifting
digitalWrite(myClockPin, 0);
}
//blinks both registers based on the number of times you want to
//blink "n" and the pause between them "d"
//starts with a moment of darkness to make sure the first blink
//has its full visual effect.
void blinkAll_2Bytes(int n, int d) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(200);
for (int x = 0; x < n; x++) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 255);
shiftOut(dataPin, clockPin, 255);
digitalWrite(latchPin, 1);
delay(d);
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(d);
}
}
//**************************************************************//
// Name : shiftOutCode, Predefined Dual Array Style //
// Author : Carlyn Maw, Tom Igoe //
// Date : 25 Oct, 2006 //
// Version : 1.0 //
// Notes : Code for using a 74HC595 Shift Register //
// : to count from 0 to 255 //
//****************************************************************
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
//holders for infromation you're going to pass to shifting function
byte dataRED;
byte dataGREEN;
byte dataArrayRED[10];
byte dataArrayGREEN[10];
void setup() {
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
Serial.begin(9600);
//Arduino doesn't seem to have a way to write binary straight into the code
//so these values are in HEX. Decimal would have been fine, too.
dataArrayRED[0] = 0xFF; //11111111
dataArrayRED[1] = 0xFE; //11111110
dataArrayRED[2] = 0xFC; //11111100
dataArrayRED[3] = 0xF8; //11111000
dataArrayRED[4] = 0xF0; //11110000
dataArrayRED[5] = 0xE0; //11100000
dataArrayRED[6] = 0xC0; //11000000
dataArrayRED[7] = 0x80; //10000000
dataArrayRED[8] = 0x00; //00000000
dataArrayRED[9] = 0xE0; //11100000
//Arduino doesn't seem to have a way to write binary straight into the code
//so these values are in HEX. Decimal would have been fine, too.
dataArrayGREEN[0] = 0xFF; //11111111
dataArrayGREEN[1] = 0x7F; //01111111
dataArrayGREEN[2] = 0x3F; //00111111
dataArrayGREEN[3] = 0x1F; //00011111
dataArrayGREEN[4] = 0x0F; //00001111
dataArrayGREEN[5] = 0x07; //00000111
dataArrayGREEN[6] = 0x03; //00000011
dataArrayGREEN[7] = 0x01; //00000001
dataArrayGREEN[8] = 0x00; //00000000
dataArrayGREEN[9] = 0x07; //00000111
//function that blinks all the LEDs
//gets passed the number of blinks and the pause time
blinkAll_2Bytes(2,500);
}
void loop() {
for (int j = 0; j < 10; j++) {
//load the light sequence you want from array
dataRED = dataArrayRED[j];
dataGREEN = dataArrayGREEN[j];
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//move 'em out
shiftOut(dataPin, clockPin, dataGREEN);
shiftOut(dataPin, clockPin, dataRED);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(300);
}
}
// the heart of the program
void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {
// This shifts 8 bits out MSB first,
//on the rising edge of the clock,
//clock idles low
//internal function setup
int i=0;
int pinState;
pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, OUTPUT);
//clear everything out just in case to
//prepare shift register for bit shifting
digitalWrite(myDataPin, 0);
digitalWrite(myClockPin, 0);
//for each bit in the byte myDataOut�
//NOTICE THAT WE ARE COUNTING DOWN in our for loop
//This means that %00000001 or "1" will go through such
//that it will be pin Q0 that lights.
for (i=7; i>=0; i--) {
digitalWrite(myClockPin, 0);
//if the value passed to myDataOut and a bitmask result
// true then... so if we are at i=6 and our value is
// %11010100 it would the code compares it to %01000000
// and proceeds to set pinState to 1.
if ( myDataOut & (1<<i) ) {
pinState= 1;
}
else {
pinState= 0;
}
//Sets the pin to HIGH or LOW depending on pinState
digitalWrite(myDataPin, pinState);
//register shifts bits on upstroke of clock pin
digitalWrite(myClockPin, 1);
//zero the data pin after shift to prevent bleed through
digitalWrite(myDataPin, 0);
}
//stop shifting
digitalWrite(myClockPin, 0);
}
//blinks the whole register based on the number of times you want to
//blink "n" and the pause between them "d"
//starts with a moment of darkness to make sure the first blink
//has its full visual effect.
void blinkAll_2Bytes(int n, int d) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(200);
for (int x = 0; x < n; x++) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 255);
shiftOut(dataPin, clockPin, 255);
digitalWrite(latchPin, 1);
delay(d);
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(d);
}
}
sketch1 , sketch2 , sketch3 ve sketch4 , sketch5 , sketch6
Bu projede, şu parçalara ihtiyacınız vardı:
1.Aruduino Uno R3 (Arduino’nun diğer sürümünü de kullanabilirsiniz)
2.Arduino IDE (siz indirebilirsiniz burada )
3. atlama kabloları
4. Breadboard
5.74HC595 (kaydırma kaydı) 2 adet
6. LED’ler 8 adet (kırmızı) ve 8 adet (yeşil)
7. Direnç 16 adet (her biri 220 Ohm)
8. Kondansatör 0.1 uF 1 adet
Genel
Bu projede bir veya iki 74HC595’i Arduino kartına nasıl bağlayacağımızı öğreneceğiz .
74HC595’i Anlamak
74HC595, 8 bitlik kaydırma yazmacı ve üç durumlu paralel çıkışlara sahip bir depolama yazmacından oluşur. Seri girişi paralel çıkışa dönüştürür, böylece bir MCU’nun IO portlarını kaydedebilirsiniz. MR (pin10) yüksek ve OE (pin13) düşük seviyedeyken, veri SHcp’nin yükselen kenarına girer ve bellek kaydına gider. SHcp’nin yükselen kenarı. İki saat birbirine bağlanırsa, kaydırma yazmacı her zaman bellek yazmacından bir atım daha erken olur. Bellek kaydında bir seri kaydırma giriş pimi (Ds), bir seri çıkış pimi (Q) ve bir asenkron sıfırlama düğmesi (düşük seviye) bulunmaktadır. Bellek kaydı, paralel bir 8-bit ve üç durumda bir Veri Yolu çıkışı verir. OE etkinleştirildiğinde (düşük seviye), hafıza kaydındaki veriler veri yoluna gönderilir. Bir süre veya bir süre sonra Arduino kartınızdaki pimler tükenebilir ve vardiya kayıtlarıyla genişletmeniz gerekir. Bu proje 74HC595’e dayanmaktadır. Veri sayfası 74HC595’i “Çıkış mandallı 8 bit seri giriş, seri veya paralel çıkış kaydırma yazmacı; 3-durumu. “Başka bir deyişle, bir seferde 8 çıkışı kontrol etmek için kullanabilirsiniz, ancak mikrodenetleyicinizde yalnızca birkaç pimi çeker. Çıktınızı daha da uzatmak için birden fazla kaydı birbirine bağlayabilirsiniz. (Kullanıcılar ayrıca başka bir sürücü de bulmak isteyebilir. parça numaralarında “595” veya “596” olan yongalar, çok sayıda var. Örneğin STP16C596, 16 LED’i sürecek ve dahili sabit akım kaynaklarına sahip seri dirençleri ortadan kaldıracak.) Tüm bunlar nasıl işler “denilen bir şeyden geçer. senkronize seri haberleşme“, yani bir pimi yukarı ve aşağı atabilir ve böylece bir veri baytını kayıt defterine bit bit olarak iletebilirsiniz. Bu, ikinci pimi, saat pimini, bitler arasında tanımladığınız zaman darbesiyle. Bu” asenkron seri iletişimi kullanmanın tersine ” Seri.begin () ‘inBelirlenen veri hızına kararlaştırılan vericiye bağımsız olarak ayarlanacak gönderici ve alıcıya dayanan işlev. Tüm bayt kayıt defterine iletildiğinde, her bir bitte tutulan YÜKSEK veya DÜŞÜK mesajlar, her bir çıkış pimine ayrıştırılır. Bu, “paralel çıktı” kısmıdır, tüm pimlerin hepsini bir defada yapmalarını istediğiniz şeyi yapmalarıdır. Bu bileşenin “seri çıkışı” kısmı, mikrodenetleyiciden alınan seri bilgisini tekrar değiştirmeden iletebilen ekstra piminden gelir. Bu, 16 bit’i arka arkaya (2 bayt) aktarabileceğiniz anlamına gelir ve ilk 8 ilk yazmacın içinden ikinci yazmacın içine akar ve burada ifade edilir. Bunu ikinci örnekten yapmayı öğrenebilirsin. “3 durum”, çıkış pimlerini yüksek, düşük veya “olarak ayarlayabileceğiniz anlamına gelir” yüksek empedans. “YÜKSEK ve DÜŞÜK durumların aksine, pinleri ayrı ayrı yüksek empedans durumlarına ayarlayamazsınız. Tüm yongayı sadece bir araya getirebilirsiniz. Bu yapılacak oldukça özel bir şey. Projenize özgü bir mod ayarına bağlı olarak tamamen farklı bir mikrodenetleyici tarafından kontrol edilmesi gerekebilecek bir LED dizisi düşünün. Her iki örnek de bu özellikten faydalanmaz ve genellikle sahip olduğu bir fişi almak için endişelenmenize gerek yoktur.
Phillip’in veri sayfasından uyarlanan pin-out’ları açıklayan bir tablo .
74HC595’in sinyalleri ve bağlantıları
74HC595’in pimleri ve işlevleri:
Q0-Q7: 8-bit paralel veri çıkış pinleri, 8 LED’i veya 7 pinli ekranın 8 pinini doğrudan kontrol edebilen.
Q7 ‘: Birden fazla 74HC595’i seri bağlamak için başka bir 74HC595’in DS’sine bağlı seri çıkış pimi
MR: Pimi sıfırla, düşük seviyede aktif; burada doğrudan 5V’a bağlanır.
SHcp: Vardiya kaydının zaman sırası girişi. Yükselen kenarında, kaydırma yazmacındaki veriler art arda bir bit, yani Q1’deki veriler Q2’ye vb. Taşınır. Düşen kenardayken, kaydırma yazmacındaki veriler değişmeden kalır.
STcp: Depolama kaydının zaman sırası girişi. Yükselen kenarda, vardiya kaydındaki veriler hafıza kaydına taşınır.
OE: Düşük seviye aktif çıkış pimi. İşte GND’ye bağlı.
DS: Seri veri giriş pimi
VCC: Pozitif besleme gerilimi
GND: Toprak
Sen yonganın şartname kontrol edebilirsiniz 74HC595 burada .
Devreyi kur
1. İlk adım Arduino’nuzu bir vardiya kaydında genişletmek.
1. Açma.
Aşağıdaki bağlantıları yapın:
GND (pin 8) yere,
Vcc (pin 16) ila 5V
OE (pim 13) toprağa
MR (pim 10) ila 5V
Bu ayar, tüm çıkış pinlerinin her zaman aktif ve adreslenebilir olmasını sağlar. Bu kurulumun bir kusuru, ışıklar çalışmaya başladıktan önce devreyi ilk açışınızda, son durumlarına veya isteğe bağlı olarak yanan bir şeye neden olmanızdır. Arduino kartınızdan MR ve OE pimlerini de kontrol ederek bu sorunu çözebilirsiniz, ancak bu şekilde çalışır ve sizi daha açık pimlerle bırakır.
2. Arduino kurulu için Bağlan
DS (pim 14) – Ardunio DigitalPin 11 (mavi kablo)
SH_CP (pin 11) – Ardunio DigitalPin 12 (sarı kablo)
ST_CP (pin 12) – Ardunio DigitalPin 8 (yeşil kablo)
Bundan sonra, bunlar sırasıyla dataPin, clockPin ve latchPin olarak adlandırılacaktır. LatchPin’deki 0.1 uf kapasitöre dikkat edin, mandal pimi darbeye girdiğinde biraz titriyorsanız, eşitlemek için bir kapasitör kullanabilirsiniz.
3. 8 LED ekleyin.
Bu durumda, her LED’in katodunu (kısa pim) ortak bir toprağa ve her LED’in anotunu (uzun pim) ilgili kaydırma yazmacı çıkış pimine bağlamalısınız. Bu şekilde güç sağlamak için vardiya kaydının kullanılması kaynak akımı olarak adlandırılır. Bazı vardiya kayıtları akım besleyemez, yalnızca batan akım denilen şeyi yapabilirler. Bunlardan birine sahipseniz, anotları doğrudan güce ve katotları (topraklama pimleri) vites değiştirme yazıcısının çıkışlarına yerleştirerek, LED’lerin yönünü çevirmeniz gerekeceği anlamına gelir. 595 serisi bir yonga kullanmıyorsanız, kendi veri sayfanızı kontrol etmelisiniz. LED’lerin aşırı yüklenmesini önlemek için seri olarak 220 ohm’luk bir direnç eklemeyi unutmayın.
2. İkinci adım, Arduino’nuzu bir tane daha vardiya kaydıyla genişletmektir.1. İkinci bir vardiya kaydı ekleyin.Önceki örnekten başlayarak, tahtaya ikinci bir vardiya kaydı koymalısınız. Aynı elektriğe güç ve toprak vermelidir.
1. İlk vardiya yazıcısını ve 8 kırmızı LED’i Arduino’nuza daha önce anlatıldığı gibi bağlayın.
2. İkinci bir vardiya kaydı ekleyin. Önceki örnekten başlayarak, tahtaya ikinci bir vardiya kaydı koymalısınız. Aynı elektriğe güç ve toprak vermelidir.
3. 2 kaydı bağlayın.
Bu bağlantılardan ikisi Arduino’dan ikinci kaydırma yazmacına (sarı ve yeşil teller) aynı saat ve mandallama sinyalini uzatır. Mavi kablo, ilk kaydırma yazmacının seri çıkış piminden (pim 9) ikinci yazıcının seri veri girişine (pim 14) geçmektedir.4. İkinci bir LED seti ekleyin.Bu durumda yeşil olanları ekledim, bu yüzden kodu okurken hangi baytın hangi LED’lere gideceği açıktır.
KOD (BİR ÜSTKRK KAYIT)
Kod, veri sayfasındaki iki bilgiye dayanmaktadır: zamanlama diyagramı ve mantık tablosu.
Mantık tablosu, temelde önemli olan her şeyin bir atışta gerçekleştiğini söyleyen şeydir. Ne zaman clockPin alçaktan yükseğe doğru gider, kaydırma yazmacı veri pimi durumunu okur. Veriler kaydıkça dahili bir hafıza kaydına kaydedilir. Ne zaman latchPin alçaktan yükseğe doğru gider gönderileceği ile veri LED’leri aydınlatma, çıkış pimleri içine vardiya kayıtları yukarıda belirtilen bellek kasadan başına taşınır.
Adım adım talimat
- Adruino Uno tahtanızı PC’nize takın ve doğru tahtayı ve bağlantı noktasını seçin
- Seri monitörü açın ve baudunuzu 9600 baud’a ayarlayın
- Taslağı doğrulayın ve Adruino Uno panonuza yükleyin
KOD (İKİ ÜSTKRK KAYIT KAYDI)
Merak ediyorsanız, sadece ne olduğunu görmek için bu devreyi kurmuş olan ilk örnekten örnekleri denemek isteyebilirsiniz.
Sketch 4 İkili İkili Sayıcılar
Eskiz 1’deki ilk kod örneğiyle karşılaştırıldığında yalnızca bir ekstra kod satırı var. İkinci bir bayt gönderir. Bu, doğrudan Arduino’ya bağlı olan ilk kaydırma yazmacını, yeşil LED’leri aydınlatmak için gönderilen ikinci byte’dan geçen ilk baytı geçmeye zorlar. İkinci bayt daha sonra kırmızı LED’lerde görünecektir.
5 Bayt Teker Teker Eskiz
Bu kodu Sketch 1 ‘deki benzer kodla karşılaştırarak, biraz daha fazlasının değişmesi gerektiğini görürsünüz. BlinkAll () işlevi, şu anda kontrol edilecek 16 LED bulunduğunu yansıtmak için blinkAll_2Bytes () işlevine değiştirildi. Ayrıca, 1. versiyonda, latchPin’in darbeleri, lightShiftPinA ve lightShiftPinB () alt fonksiyonlarının içine yerleştirilmiştir. Burada, her bir alt işlevi arka arkaya iki kez, yeşil LED’ler için bir kez ve kırmızı olanlar için bir kez çalıştırmak zorunda kalmaları için ana döngüye geri taşınmaları gerekir.
Çizim 6 – İkili Tanımlanmış Diziler
Çizim 5 gibi, Çizim 6 da yeni blinkAll_2bytes () işlevinden faydalanır. Eskiz 6’nın Eskiz 3’teki büyük farkı, yalnızca “data” adı verilen tek bir değişken ve “dataArray” adlı tek bir dizinin yerine, yukarıda tanımlanmış bir dataRED, dataGREEN, dataArrayRED, dataArrayGREEN’e sahip olmanız gerektiğidir. Bu, bu çizgiyi ifade eder
data = dataArray [j];
olur
dataRED = dataArrayRED [j];
dataGREEN = dataArrayGREEN [j];
ve
shiftOut (dataPin, clockPin, veri);
olur
shiftOut (dataPin, clockPin, dataGREEN);
shiftOut (dataPin, clockPin, dataRED);özet
Bir veya iki 74HC595’i Arduino kartına nasıl bağlayacağımızı öğrendik
Kütüphane:
- Bu proje için kütüphaneye gerek yok
Skeçler:
- Bu proje açıklamasının başlangıcındaki eklere bakınız.
- Çizim 1 ila Çizim 3. Birincisi, sadece 0 ile 255 arasında bir byte değeri veren sadece bir “merhaba dünya” kodudur. İkinci çizim bir seferde bir LED yanar. Üçüncü dizi boyunca döner.
- Sketch 4 İkili İkili Sayıcılar, Sketch 5 Byte Birer, Sketch 6 – İki Tanımlı Diziler
