Arduino ile 74HC595

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

Reklam ad2

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

  1. Adruino Uno tahtanızı PC’nize takın ve doğru tahtayı ve bağlantı noktasını seçin
  2. Seri monitörü açın ve baudunuzu 9600 baud’a ayarlayın
  3. 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
Reklam ad3
Posted in Makaleler.