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

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

Arduino Başlangıç ​​Led ve Direnç Bağlantıları

Proje adı:  ARAÇLARINIZI BİLMEK İÇİN GET

Ekler: 

Bu projede, şu parçalara ihtiyacınız vardı:

1.Aruduino Uno R3 (Arduino’nun diğer sürümünü de kullanabilirsiniz)

2. atlama kabloları

3. Anlık anahtarları 2 adet

4. Direnç 1 adet (220 Om)

5. Breadboard yarım boy 

6. LED (herhangi bir renk) 1 adet

GENEL

Elektrik, ısı, yerçekimi veya ışık gibi bir enerji türüdür. Elektrik enerjisi, kablo gibi iletkenlerin arasından geçer. Elektrik enerjisini, ilginç bir şey yapmak için, ışığı açmak veya hoparlörden biraz ses çıkarmak gibi, başka enerji biçimlerine dönüştürebilirsiniz. Elektrik Devresi Nedir? Bir devre temelde başlangıç ​​noktası ve bitiş noktası olan elektronik bir döngüdür – bunların arasında herhangi bir sayıda bileşen vardır. Devreler, dirençler, diyotlar, indüktörler, her boyutta ve şekildeki sensörler, motorlar ve yüz binlerce bileşenden herhangi bir avuç içerebilir. Devreler genellikle üç kategoriye ayrılır – analog devreler, dijital devreler veya karışık sinyal devreleri. Baktığın her yerde devreleri bulacaksın. Cebinizdeki cep telefonu, arabanızın emisyon sistemini kontrol eden bilgisayar, video oyun konsolunuz – tüm bunlar devrelerle dolu. Elektriği farklı bileşenlerden geçirmek için devreler inşa edeceksiniz. Devreler, güç kaynağına sahip (pil gibi) kapalı tel halkaları ve enerji olarak faydalı bir şey yapacak yüke denir.

Bir devrede, elektrik, daha yüksek potansiyel bir enerji noktasından (genellikle güç veya + olarak adlandırılır) daha düşük potansiyel bir enerji noktasına gelir. Toprak (genellikle bir – veya GND ile temsil edilir) genellikle bir devredeki en düşük potansiyel enerjinin noktasıdır. Yaptığınız devrelerde, elektrik yalnızca bir yönde açılır. Bu devre tipine doğru akım veya DC denir. Alternatif akımda (AC) devrelerde elektrik yönünü saniyede 50 veya 60 kez değiştirir (nerede yaşadığınıza bağlı olarak). Bu bir prize gelen elektrik türüdür. Elektrik devreleriyle çalışırken bilmeniz gereken birkaç terim vardır. Akım (amper veya amp; A sembolüyle ölçülür) devrenizdeki belirli bir noktadan geçen elektriksel yükün miktarıdır. Voltaj (volt olarak ölçülür; V sembolüyle), enerjideki bir devredeki bir nokta ile diğeri arasındaki farktır. Ve son olarak, direnç (ohm olarak ölçülür; Ω sembolüyle), bir bileşenin elektrik enerjisi akımına ne kadar dayandığıdır. Bir devre oluşturmak için enerji kaynağından (güç) en az enerji (toprak) noktasına kadar tam bir yol olması gerekir. Enerjinin hareket etmesi için bir yol yoksa, devre çalışmaz. Tüm elektrik enerjisi, içindeki bileşenler tarafından bir devrede tüketilir. Her bileşen enerjinin bir kısmını başka bir enerji şekline dönüştürür. Herhangi bir devrede, voltajın tamamı başka bir enerji türüne (ışık, ısı, ses vb.) Dönüştürülür. Bir devredeki belirli bir noktadaki akımın akışı her zaman gelen ve çıkan aynı olacaktır. Elektrik akımı toprağa en az dirençli yolu arayacaktır. İki olası yol göz önüne alındığında, elektrik akımı daha az dirençli yolda aşağı gidecek. Gücü ve toprağı dirençsiz olarak birbirine bağlayan bir bağlantınız varsa, kısa devreye neden olacaksınız ve akım bu yolu izlemeye çalışacaktır. Kısa devrede, güç kaynağı ve teller, elektrik enerjisini genellikle kıvılcım veya patlama olarak, ışığa ve ısıya dönüştürür. Bataryayı kısalttıysanız ve kıvılcım çıkardıysanız, kısa devrenin ne kadar tehlikeli olabileceğini bilirsiniz. 

Breadboard, inşaat devreleri kuracağınız birincil yerdir. Kitinize gelen, daha az lehimdir, yani bir şeyi birlikte lehimlemeniz gerekmediğinden adlandırılır. Breadboard’un yatay ve dikey sıraları, plastiği delikli ince metal konektörlerden elektrik taşır. Her yatay sıradaki 5 delik elektriksel olarak breadboard’un içindeki metal şeritler vasıtasıyla bağlanır. Orta sıra, tahtanın iki tarafı arasındaki bağlantıyı keser. Breadboard’un uzunluğunu taşıyan dikey şeritler elektriksel olarak bağlanmıştır. Şeritler genellikle güç ve toprak bağlantıları için kullanılır.

Projelerimiz boyunca, iki devre görünümü göreceksiniz: bunlardan biri kitinizdeki gibi görünen ekmek tahtası görünümünde.

The other is a schematic view, which is a more abstract way of showing the relationships between components in a circuit.

Schematics don’t always show where components are placed relative to each other, but they show how they are connected.

THE FIRST COMPONENTS

An LED, or light-emiting diode, is a component that converts electrical energy into light energy. LEDs are polarized components, which means they only allow electricity to flow through them in one direction. The longer leg on the LED is called an anode, it will connect to power. The shorter leg is a cathode and will connect to ground. When voltage is applied to the anode of the LED, and the cathode is connected to ground, the LED emits light.

A resistor is a component that resists the flow of electrical energy (see the components list for an explanation on the colored stripes on the side). It converts some of the electrical energy into heat. If you put a resistor in series with a component like an LED, the resistor will use up some of the electrical energy and the LED will receive less energy as a result. This allows you to supply components with the amount of energy they need. You use a resistor in series with the LED to keep it from receiving too much voltage. Without the resistor, the LED would be brighter for a few moments, but quickly burn out.

A switch interrupts the flow of electricity, breaking the circuit when open. When a switch is closed, it will complete a circuit. There are many types of switches. The ones in your kit are called momentary switches, or pushbutons, because they are only closed when pressure is applied.

SWITCH CONNECTIONS

A and C, B and D pins of a switch are connected to each other

A and B, C and D are not. They form the switch

SWITCH SCHEMATIC VIEW

THE CIRCUIT

Let us make the first circuit, using a switch, a resistor and an LED.

Arduino is just the power source for this circuit; in later projects, you’ll connect its input and output pins to control more complex circuits. You’re going to use the Arduino in this project, but only as a source of power. When plugged into a USB port or a 9-volt battery, the Arduino will provide 5 volts between its 5V pin and its ground pin that you can use. 5V = 5 volts, you’ll see it written this way a lot. If your Arduino is connected to a battery or computer via USB, unplug it before building the circuit! Connect a red wire to the 5V pin on the Arduino, and put the other end in one of the long bus lines in your breadboard. Connect ground on the Arduino to the adjacent bus line with a black wire. It’s helpful to keep your wire color consistent (red for power, black for ground) throughout your circuit. Now that you have power on your board, place your switch across the center of the board. The switch will sit across the center in one direction. The bend in the legs of the switch point to the center of the board. Use a 220-ohm resistor to connect power to one side of the switch. Your starter kit may have a mix of 4 and 5 band resistors. Use the illustration on the side to check for the right one for this project. Look here for a detailed explanation of the color codes for resistors. On the other side of the switch, connect the anode (long leg) of the LED. With a wire connect the cathode (short leg) of the LED to ground. When you’re ready, plug the USB cable into the Arduino.

THE START

Once everything is set to go, press the button. You should see the LED light up. Congratulations, you just made a circuit! Once you’ve tired of pressing the button to turn the light on, it’s time to shake things up by adding a second button

You’ll be placing components on the breadboard in series and in parallel. Components in series come one after another. Components in parallel run side by side.

1. Series circuit

SERİ BİLEŞENLER BİLEŞENLERDEN SONRA BİRİNDEN SONRA. Güç kaynağınızı çıkardıktan sonra, zaten breadboard’unuzun yanına bir anahtar ekleyin. Bunları gösterildiği gibi seri olarak birbirine bağlayın. LED’i yukarı anottan (uzun bacak) ikinci anahtara bağlayın. LED katodu toprağa bağlayın. Arduino’yu tekrar çalıştırın: LED’i açmak için şimdi iki düğmeye de basmanız gerekir. Bunların seri olması nedeniyle, devrenin tamamlanması için ikisinin de kapatılması gerekir. İki anahtar seri halindedir. Bu, aynı elektrik akımının her ikisinden de geçtiği, böylece her ikisinin de LED’in yanması için bastırılması gerektiği anlamına gelir.

Paralel devrePARALEL RUN YAN TARAFINDAN BİLEŞENLERArtık serideki şeylerin sanatında ustalaştığınıza göre, anahtarları paralel olarak bağlamanın zamanı geldi. Anahtarları ve LED’i oldukları yerde tutun, ancak iki anahtar arasındaki bağlantıyı çıkarın. Her iki şalteri rezistöre bağlayın. Her iki anahtarın diğer ucunu Şekil 12’de gösterildiği gibi LED’e takın. Şimdi, her iki düğmeye de bastığınızda, devre tamamlandı ve ışık yanıyor.Bu iki anahtar paraleldir. Bu, elektrik akımının aralarında bölündüğü anlamına gelir. Herhangi bir düğmeye basılırsa, LED yanacaktır.

2. Paralel devre

PARALEL ÇALIŞAN YAN TARAFINDAN BİLEŞENLER YAN. Şimdi anahtarları paralel olarak bağlamanın zamanı geldi. Anahtarları ve LED’i oldukları yerde tutun, ancak iki anahtar arasındaki bağlantıyı çıkarın. Her iki şalteri rezistöre bağlayın. Her iki anahtarın diğer ucunu LED’e takın. Şimdi herhangi bir tuşa bastığınızda, devre tamamlandı ve ışık yanıyor. Bu iki anahtar paraleldir. Bu, elektrik akımının aralarında bölündüğü anlamına gelir. Herhangi bir düğmeye basılırsa, LED yanacaktır.

UNUTMAYIN: DEVREDE BİR ŞEYİ DEĞİŞTİRMEDEN ÖNCE HER ZAMAN GÜCÜ KALDIRIN !!!!

3. İSG Yasasını Anlamak

V = I * R

I = V / R

R = V / I

Gerilim, akım ve direnç arasındaki ilişkileri hatırlamak için bu kareyi kullanabilirsiniz. Parmağınızı üçten birinin üzerine getirin ve diğer ikisiyle nasıl ilişkili olduğunu görün.

Akım, voltaj ve direnç birbiriyle ilişkilidir. Bir devrede bunlardan birini değiştirdiğinizde, diğerlerini de etkiler. Aralarındaki ilişki, onu keşfeden Georg Simon Ohm adlı Ohm Yasası olarak bilinir.

GERİLİM (V) = GÜNCEL (I) * DAYANIM (R)

BONUS

Yapacağınız devrelerde amper ölçerken, değerler miliamper aralığında olacaktır. Bu bir amperin binde biri. Örneğin: Devrede 5 volt veriyorsunuz. Direnç 220 ohm’luk bir direnç sağlar. LED tarafından kullanılan amperi bulmak için denklemdeki değerleri değiştirin. 5 = I * 220 değerine sahip olmalısınız. Denklemin iki tarafını da 220’ye bölerek I = 0,023 olduğunu göreceksiniz. Bu LED’in kullandığı 23 bin amper veya 23 miliamper (23 mA). Bu değer, bu LED’ler ile güvenle kullanabileceğiniz maksimum değerdir, bu yüzden 220-ohm’luk bir direnç kullandınız.

Multimetre, devrenizdeki direnç, akım ve volt yaş miktarını doğrulayabilen bir araçtır. Bu projeler için bir tane kullanmak gerekmese de, herhangi bir mühendisin araç kutusunun yararlı bir parçası olabilir. Burada nasıl kullanılacağının iyi bir açıklaması var .

ÖZET

Bu noktada, gerilim ve akım arasındaki farkı hatırlatmakta fayda var. Bir teldeki elektronların davranışı için mükemmel bir benzetme yoktur, ancak borulardaki suyla yapılan benzetme, özellikle gerilim, akım ve dirençle başa çıkmada yardımcı olmak için kullanılır. Bu üç şey arasındaki ilişkiye Ohm Kanunu denir.

Diyagramın sol tarafı, diyagramın üst kısmının diyagramın tabanından daha yüksek (yükseklik olarak) olduğu bir boru devresini gösterir. Böylece su doğal olarak diyagramın tepesinden dibine akacaktır. Suyun devrede herhangi bir noktadan belirli bir zamanda (akım) ne kadar su geçtiğini belirleyen iki faktör:

• Suyun yüksekliği (veya isterseniz pompa tarafından üretilen basıncı). Bu elektronikteki voltaj gibidir.
• Boru tesisatındaki daralma tarafından sunulan akıma karşı direnç

Pompa ne kadar güçlü olursa, su da o kadar yüksek pompalanabilir ve sistemden geçen akım o kadar büyük olur. Diğer taraftan, boru tesisatının sunduğu direnç arttıkça, akım da düşer. Resmin sağ yarısında, boru hattımızın elektronik eşdeğerini görebiliriz. Bu durumda, akım aslında saniyede bir noktadan kaç elektronun geçtiğinin bir ölçüsüdür. Ve evet, direnç elektron akışına karşı dirençtir. Yükseklik veya basınç yerine, voltaj kavramımız vardır. Diyagramın dibi 0V veya topraktadır ve diyagramın tepesini 5V olarak gösterdik. Böylece akan akım (I), direnç R’ye bölünen voltaj farkı (5) olacaktır.

Bu projeyi, kendi anahtarınızı oluşturarak (iyi kablolanmış iki folyo parçası) veya paralel ve seri olarak anahtarlar ve LED’lerin bir kombinasyonunu oluşturarak birkaç şekilde genişletebilirsiniz. 

Bir breadboard’a devre kurarken gerilim, akım ve direncin elektriksel özelliklerini öğrendiniz. LED’ler, dirençler ve anahtarlar gibi bazı bileşenlerle en basit etkileşimli sistemi yarattınız: bir kullanıcı düğmeye basar, ışıklar yanar. Elektronikle çalışmanın bu temelleri gelecek projelerde referans alınacak ve genişletilecektir.

Arduino Başlangıç ​​Seti: Proje 15

Proje adı: HACKING BUTTONS

Keşfedin: diğer bileşenlerle bağlanan optocoupler

Kod:

/*
 Project: 15 HACKING BUTTONS
 */
//*************************************************************
const int optoPin = 2;//optocoupler attached to digital pin 2
//*************************************************************
void setup(){
pinMode(optoPin, OUTPUT);//sets optoPin as OUTPUT
}
void loop(){
digitalWrite(optoPin, HIGH);//optocoupler is on
delay(15);//delay set for 15 ms
digitalWrite(optoPin, LOW);//optocoupler is off
delay(21000);//delay set for 21 seconds
}

 sketch

Bu projede, şu parçalara ihtiyacınız var:

1.Aruduino Uno R3 (Arduino’nun diğer sürümünü de kullanabilirsiniz)

2. atlama kabloları

3. Direnç 1 adet (220 Ohm)

4. Breadboard yarım boy 

5. Arduino IDE (siz indirebilirsiniz burada  )

6. Optocoupler 4N35 1 adet

GENEL

İlk birkaç projeniz için tecrübe ve güven kazanana kadar zarar vermeyeceğiniz ucuz ürünler kullanmanızı öneririz. Arduino bir çok şeyi kontrol edebilirken, bazen belirli amaçlar için oluşturulan araçları kullanmak daha kolaydır. Belki bir televizyonu veya müzik çaları kontrol etmek ya da uzaktan kumandalı bir araba kullanmak istiyorsunuz. Elektronik cihazların çoğunda düğmelerin bulunduğu bir kontrol paneli bulunur ve bu düğmelerin çoğu saldırıya uğrayabilir ve böylece bir Arduino ile “basabilirsiniz”. Kaydedilen sesi kontrol etmek iyi bir örnektir. Kaydedilen sesi kaydetmek ve çalmak istiyorsanız, Arduino’nun bunu yapması çok fazla zaman alır. Sesi kaydeden ve çalan küçük bir cihaza sahip olmak ve düğmelerini Arduino’nuz tarafından kontrol edilen çıkışlarla değiştirmek çok daha kolay.

Optocouplers, bir devreyi diğeri arasındaki herhangi bir elektrik bağlantısı olmadan farklı bir hattan kontrol etmenizi sağlayan entegre devrelerdir. Bir optokuplörün içinde bir LED ve bir ışık detektörü bulunur. Optocoupler’daki LED, Arduino’nuz tarafından açıldığında, ışık detektörü bir şalteri dahili olarak kapatır. Anahtar, optocoupler’ın çıkış pinlerinden (4 ve 5) ikisine bağlanır. Dahili anahtar kapatıldığında, iki çıkış pini bağlanır. Anahtar açıldığında, bağlı değillerdir. Bu şekilde, diğer cihazlardaki anahtarları Arduino’nuza bağlamadan kapatmak mümkündür.

Optocoupler 4N35’in veri sayfasına buradan bakın .

DEVRE

Bu projede, 20 saniyelik sesi kaydetmenize ve çalmanıza izin veren dijital bir kayıt modülünü kontrol etmek için çizimler yapılmıştır, ancak temelde erişebileceğiniz bir anahtara sahip herhangi bir cihaz için aynıdır. 

Bu projeyi yapmayı planlıyorsanız, şimdi ileri düzeyde bir kullanıcısınız. Değiştirmek için bir elektronik cihaz açacağınız için dikkatli olun. Cihazın garantisini düşünün ve dikkatli olmazsanız, cihaza zarar verebilirsiniz.

Arduino ile ekmek tabağınıza toprak bağlayın. Optocoupler’ı board tahtasının üzerine oturması için breadboard’unuza yerleştirin. Optocoupler üzerindeki 1 pimini 220 ohm’luk bir dirençle seri olarak Arduino 2 pimine bağlayın (içindeki bir LED’i açtığınızı, yanmak istemediğinizi unutmayın). Optokuplörün 2 pimini toprağa bağlayın. Ses modülünün ana kartında, oynatma düğmesi de dahil olmak üzere çok sayıda elektrikli bileşen vardır. Düğmeyi kontrol etmek için düğmeyi çıkarmak zorunda kalacaksınız. Devre kartını ters çevirin ve düğmeyi yerinde tutan tırnakları bulun. Tırnakları yavaşça geriye doğru bükün ve düğmeyi karttan çıkarın. Düğmenin altında iki küçük metal plaka bulunur. Bu model, butonlu birçok elektronik cihaz için tipiktir. Bu desenin iki “çatal” ı anahtarın iki yüzüdür. Basma düğmenin içindeki küçük bir metal disk, düğmeye bastığınızda bu iki çatalı birbirine bağlar. Çatallar bağlandığında, devre kartındaki anahtar kapatılır. Anahtarı optocoupler ile kapatıyor olacaksınız. Bir anahtarı bir optocoupler ile kapatarak bu yöntem, yalnızca düğmenin anahtarının iki tarafından biri cihazınızdaki toprağa bağlıysa çalışır. Emin değilseniz, bir multimetre alın ve çatallardan biri ile cihazınızdaki toprak arasındaki voltajı ölçün. Bunu cihaz açıkken yapmanız gerekir, bu nedenle panodaki başka hiçbir yere dokunmamaya dikkat edin. Hangi çatalın topraklandığını öğrendikten sonra, cihazınıza gelen gücü kesin. Sonra, küçük metal plakaların her birine bir kablo bağlayın. Bu telleri lehimliyorsanız, anahtarın iki tarafını birleştirmemeye dikkat edin. Lehimleme ve bant kullanmıyorsanız, bağlantınızın sağlam olduğundan emin olun, aksi halde anahtar kapanmaz. Kablonun diğer çatala bağlanmamasına dikkat edin, aksi halde anahtarınız her zaman kapalı olacaktır. İki kabloyu, optocoupler’in 4 ve 5 numaralı pinlerine takın. Optocoupler pimine 4 topraklanmış anahtarın tarafını bağlayın. Optocoupler pimine 5 diğer çatalı bağlayın.

KOD

Pimi 2 HIGH konumuna getirerek sesi her 20 saniyede bir çalacaksınız. Optocoupler kontrol pimi için bir sabit oluşturun. Gelen kurulumu () , bir çıkış içine optik bağlayıcı piminin. Döngü () döner optoPin cihazda anahtarını kapatmak için optik bağlayıcı için yeterince uzun, birkaç milisaniye HIGH. Ardından optoPin DÜŞÜK olur. Döngüye () tekrar başlamadan önce tüm mesajın çalması için 21 saniye bekleyin .

BAŞLANGIÇ

Pili ses kaydediciye takın. Cihazdaki kayıt düğmesini basılı tutun. Düğmeyi basılı tutarken, sesi mikrofona kaydedebilirsiniz. Sesini kullan. Bir ses kaydettikten sonra, Arduino’nuza USB kablosu ile güç verin. Kaydınız çalmaya başlar. 20 saniye boyunca kayıt yaptıysanız, ses sona erdikten birkaç dakika sonra tekrar başlamalıdır. Programınızdaki gecikme () ile farklı sesler ve çalma işlemini değiştirme sürelerini denemeyi deneyin . Bir ses çalarken anahtarı tetiklerseniz, durur.

ÖZET

Entegre devreler hemen hemen her elektronik cihazdadır. Arduino’nuzdaki 28 pinli büyük çip, kartın beynini barındıran bir IC’dir. Bunu iletişim ve güçle destekleyen başka IC’ler var. Arduino’daki optocoupler ve ana yonga, Çift Sıralı Paket (DIP) yongalarıdır. Bu DIP yongaları, bir breadboard’a kolayca yerleştirilir ve kullanmak için kalıcı olarak lehimlenmeleri gerekmez.

Optocouplers farklı bir devrede bulunan cihazları kontrol edebilir. İki devre, bileşen içinde elektriksel olarak birbirinden ayrılır.

Proje sadece düzenli aralıklarla geri çaldı. Bir optocoupler ile elektronik bir cihazı bir anahtarın iki tarafına bağlayarak kontrol etme tekniği, diğer birçok cihazda da kullanılabilir. 

Elektrikli Su Isıtıcısı için IoT Tabanlı Zamanlayıcı Anahtarı Yapımı

Elektrikli su ısıtıcısı için bu zamanlayıcı anahtarı NodeMCU ve Blynk IoT bulut çözümüne dayanmaktadır . Soğuk mevsimde banyolarda sıcak su ile banyo yapmak için elektrikli su ısıtıcısı kullanılır. Yaygın bir sorun, sabah uyandığınızda, elektrikli ısıtıcının soğuk suyu yeterince ısıtması için 20 dakika beklemeniz gerektiğidir. Bu soruna olası bir çözüm, bir zamanlayıcı anahtarı kullanmaktır.

Burada sunulan zamanlayıcı anahtarı, akıllı telefonunuzdaki Blynk uygulamasından elektrikli su ısıtıcısını başlatmak ve durdurmak için kullanılabilir. Bunu kullanarak, uyandığınızda sıcak su hazır olacaktır. Yazarın prototipi Şekil 1’de gösterilmiştir.

1: Yazarın prototipi

Devre ve çalışma

Su ısıtıcı için Nesnelerin İnterneti (IoT) tabanlı zamanlayıcı anahtarının devre şeması Şekil 2’de gösterilmektedir. NodeMCU mikrodenetleyici (MCU) olarak kullanılır. Devre ayrıca NodeMCU’yu çalıştırmak için 5V voltaj regülatörü 7805’e (IC1) sahiptir. Su ısıtıcısını BC547 röle sürücü transistörü (T1) üzerinden açmak ve kapatmak için 12 voltluk bir röle (RL1) kullanılır.

Şekil 2: Su ısıtıcı için IoT tabanlı zamanlayıcı anahtarının devre şeması

NodeMCU, ESP8266 Wi-Fi modülünde çalışan bellenim içeren açık kaynaklı bir IoT platformudur. NodeMCU’nun pim diyagramı Şekil 3’te verilmiştir.

3: NodeMCU pin detayları

NodeMCU’yu IoT platformuna bağlama

NodeMCU, Board Manager’dan tercih edilen kart olarak NodeMCU 1.0 (ESP-12E Modülü) seçilerek Arduino IDE kullanılarak ESP8266_standalone.ino ile programlanır. Arduino IDE’ye NodeMCU kartı eklemek için aşağıdaki bağlantıdaki eğiticiye bakın .

IoT platformuna, aşağıdaki adımlar kullanılarak iOS ve Android cihazlarda Blynk uygulaması kullanılarak erişilebilir.

1. Akıllı telefonunuza Blynk uygulamasını indirin ve yeni bir hesap oluşturun ya da mevcut Facebook kimlik bilgilerinizi kullanarak giriş yapın.
2. Uygulamada Yeni Proje Oluştur’a gidin ve proje adını girin (örneğin, IoT_ ısıtıcı). Aygıt, örneğin, NodeMCU’yu seçin ve Oluştur’a tıklayın.
3. Yeni bir proje oluşturduktan sonra, e-posta hesabınıza bir yetkilendirme jeton numarası gönderilir.
4. https://github.com/blynkkk/blynk-library adresinden Blynk kütüphanesini indirin. Arduino IDE’den kütüphaneyi kurun. Eskiz> Kitaplığı Dahil Et> Kitaplıkları yönet> .zip ekle’ye gidin ve zip kitaplığına göz atın veya kitaplığı çıkardıktan sonra, bilgisayarınızdaki / dizüstü bilgisayarınızdaki Arduino IDE’nin Kitaplık klasörüne ekleyin.
5. Blynk kitaplığını yükledikten sonra Windows klasörüne göz atın, Dosya>

Örnekler> Blynk> Boards_wifi> ESP8266_Standalone.ino çizimi. Yetkilendirme simgenizi yapıştırın ve çizimde Kablosuz ağ SSID adınızı ve ağ şifrenizi girin.

6. NodeMCU’yu USB kablosuyla bağlayın ve Arduino IDE’deki COM bağlantı noktasını seçin. ESP8266_Standalone.ino dosyasını açın, çizimi derleyip NodeMCU kartına yükleyin. Ardından, kartınızın Blynk ile bağlı olup olmadığını kontrol etmek için seri monitörü açın (Şek. 4).

4: Seri monitör

7. Blynk uygulamasında yukarıda oluşturulan projeye (IoT_heater) gidin, widget (+ işareti) ekleyin ve cep telefonunuzda zamanlayıcı widget’ını seçin.
8. Zamanlayıcı Widget Ayarları’na gidin. Isıtıcıyı kontrol etmek için çıkış olarak kullanacağınız NodeMCU’nun GPIO’sunu (örneğin, D0, D1, D2, vb.) Bildirin. Uygulamadaki zamanlayıcının başlangıç ​​(7:00 am) ve durdurma (7:30 am) zamanlarını seçin.

İnşaat ve test

IoT bazlı su ısıtıcısının PCB yerleşimi Şekil 5’te ve bileşen yerleşimi Şekil 6’da gösterilmiştir. Bileşenleri devre şemasına göre PCB’ye monte edin.

Şekil 5: IoT tabanlı su ısıtıcısının PCB’si6: PCB için bileşen yerleşimi

PCB ve Bileşen Düzeni PDF’lerini indirin: Buraya Tıklayın

Su ısıtıcısını, RL1’in normal bağlantı (NC) kontağı üzerinden CON1 konnektöründeki 230V AC şebekesine bağlayın. 230V AC ana şebekeyi CON2’ye bağlayın. Blynk uygulamasında Oynat’ı tıkladığınızda zamanlayıcı başlayacaktır. Zamanlayıcı, uygulamada tanımlandığı gibi önceden belirlenmiş veya ayarlanmış süreye ulaştığında otomatik olarak başlar. Röleye enerji verilir ve ısıtıcı açılır. Durma süresinden sonra rölenin enerjisi kesilir ve ısıtıcı kapatılır. Artık proje kullanıma hazırdır.

 

https://drive.google.com/file/d/1LxQ5v66BNzRgh7LGs8k_LUDBjFUw7WFw/view?usp=sharing

TCS3200 Sensör Modülünü Kullanarak RGB Renk Dedektörü Yapımı

Bu, Arduino Uno R3 ve TCS3200 renk sensörü modülünü kullanan basit bir renk sensörüdür . Gıda işleme üniteleri, renkli yazıcı uygulamaları, boya karıştırma uygulamaları ve robotik de dahil olmak üzere diğer endüstriyel uygulamalar için renk tanımlama ve algılama için yararlı olabilir.

Bu proje, tek bir pakette LED’lerde fiziksel olarak bulunan birincil renkleri (kırmızı, yeşil ve mavi veya RGB) tespit etmek için kullanılır; örneğin, ortak katot veya ortak katot RGB LED. Arduino kodunu değiştirerek birincil renkleri görüntüleyebilir ve belirli renkler oluşturabiliriz. Proje, TCS3200 sensörü, Arduino Uno ve ortak katot RGB LED’in temel arayüzünü göstermektedir.

Şekil 1: TCS3200 renk sensörü modülü

TCS3200 renk sensörü modülü (SEN0101) Şekil 1’de ve RGB dizilerinin mikroskobik görünümü Şekil 2’de gösterilmektedir. Mikroskobik düzeyde, sensör üzerindeki gözün içindeki kare kutuları görebilirsiniz. Bu kare kutular RGB matrisinin dizileridir. Bu kutuların her biri üç sensör içerir: her biri kırmızı ışığı, yeşil ışığı ve mavi ışık yoğunluğunu algılamak için. TCS230 renk sensörü modülünden daha iyidir. Bu sensör, doğru programlama koduyla istediğiniz sayıda rengi tanımlamak için kullanılabilir.

Şekil 2: TCS3200 yongasının mikroskobik görünümü

Devre ve çalışma

Şekil 3, TCS3200 kullanan RGB renk detektörünün devre şemasını gösterir. CON1 konnektörüne bağlı 9V güç kaynağında çalışır. Ancak, bir Arduino Uno kartı sadece 5V gerektirir. Bu nedenle, 9V’yi 5V mantığına dönüştüren bir regülatörlü bir köprü doğrultucuya sahiptir, bu da LM1117 voltaj regülatörü yardımıyla 3.3V’a dönüştürülebilir.

Şekil 3: TCS3200 kullanan RGB renk dedektörünün devre şeması

Devrenin beyni, ATmega328 veya ATmega328P mikrodenetleyicisine (MCU) sahip Arduino Uno R3 kartıdır . 14 dijital giriş / çıkış (I / O) pimi ve altı analog giriş pimi, 32k flash bellek, 16MHz kristal osilatör, USB bağlantısı, güç girişi, ICSP başlığı ve sıfırlama düğmesi vardır.

TCS3200 modülü, Şekil 4’te gösterildiği gibi sekiz pime sahiptir. Bu modül, yapılandırılabilir silikon fotodiyotları ve akım-frekans dönüştürücüyü tek bir monolitik CMOS entegre devresinde birleştiren programlanabilir renkli ışık-frekans dönüştürücülerden oluşur. Çıktı kare frekanstır (yüzde 50 görev döngüsü) ve frekans ışık yoğunluğu (ışınım) ile doğru orantılıdır.

4: TCS3200 renk sensörü modülünün pim diyagramı

Dijital girişler ve çıkışlar, MCU veya diğer mantık devrelerine doğrudan arabirim sağlar. Output enable (OE), bir MCU giriş hattını paylaşan birden fazla ünite için çıkışı yüksek empedans durumuna getirir. TCS3200’de, ışık-frekans dönüştürücü 8 × 8 dizi fotodiyot okur. On altı fotodiyotun mavi filtresi var, bir diğer on altısı yeşil, yine bir diğer on altısı kırmızı ve kalan on altısı filtre olmadan net.

Aynı renkteki tüm fotodiyotlar paralel bağlanır. TCS3200’ün S2 ve S3 pinleri, aktif olan fotodiyotlar grubunu (kırmızı, yeşil, mavi ve berrak) seçmek için kullanılır. Ayrıntılı pim açıklaması sırasıyla Tablo I, II ve III’te gösterilmiştir.

Bu üç dizideki her sensör dizisi, gereksinime bağlı olarak ayrı ayrı seçilir. Bu nedenle, programlanabilir bir sensör olarak bilinir.

Modül yalnızca belirli bir rengi algılamak için kullanılabilir. Seçim amaçlı filtreler içerir. Filtresiz dördüncü bir mod var. Filtre olmadan sensör beyaz ışığı algılar.

İnşaat ve test

TCS3200 kullanan RGB renk detektörünün tek taraflı bir PCB düzeni Şekil 5’te ve bileşen Şekil 6’da gösterilmiştir.

Şekil 5: TCS3200 kullanan RGB renk dedektörünün gerçek boyutlu PCB düzeni6: PCB’nin bileşen yerleşimi

PCB ve bileşen yerleşim PDF’lerini indirin: buraya tıklayın

Projenin çalışması basittir, çünkü bu bir TCS3200 sensörünü bağlamak için temel bir devredir. Kırmızı renk sensörün yakınında tutulduğunda, fotodiyot dizileri yardımıyla rengi otomatik olarak algılar ve ardından RGB renk yoğunluğu değeri Arduino seri monitör penceresinde renk adıyla birlikte görüntülenir. Aynı zamanda, RGB LED’de kırmızı bir LED yanar. Benzer şekilde, kalan iki renk (yeşil ve mavi) Arduino seri monitör penceresinde gösterilir ve ilgili renk LED’i RGB LED’de yanar.

Yazılım

Yazılım Arduino programlama dilinde yazılmıştır . Arduino Uno Board1, Arduino IDE yazılımı kullanılarak programlanır. Arduino Uno kartındaki ATmega328P, harici bir donanım programcısı kullanmadan yeni kod yüklemenizi sağlayan önceden programlanmış bir önyükleyici ile birlikte gelir.

Arduino kartını PC’ye bağlayın ve Arduino IDE’de doğru COM portunu seçin. Programı / çizimi derleyin (TCS3200.ino). Arduino IDE’deki Araçlar → Pano menüsünden doğru kartı seçin ve çizimi yükleyin.

Programı MCU’nun dahili belleğine yükleyin. Eskiz, sistemin kalbinde yer alır ve tüm önemli işlevleri yerine getirir. Arduino IDE 1.6.4 kullanılarak derlenir ve yüklenir.

Kaynak kodu indir

Bu projede, programlama için harici başlık dosyaları gerekli değildir. Seri porttaki RGB renk yoğunluklarını tespit etmenin basit bir yoludur. Yazarın prototipi Şekil 7’de gösterilmiştir.

7: Yazarın prototipi

 

https://drive.google.com/file/d/1n1WvFp3mrJfAjBtBDq1nLQokWaBr6Q7n/view?usp=sharing

RGB Color Detector Using TCS3200 Sensor Module

LM35 ile Sıcaklığı Sesli Uyarılarla İzleme devresi

Bu proje, sıcaklığı izlemek ve sesli uyarılar göndermek için Arduino Uno ve Processing yazılımına dayanmaktadır. İşleme, verileri görselleştirmek ve diğer işlevleri uygulamak için kullanılabilen açık kaynaklı bir IDE’dir.

Devre ve çalışma

Devre Arduino Uno kartı ve LM35 sıcaklık sensörü etrafında inşa edilmiştir. LM35 çıkış pinini (V0) Arduino kartının A0 pinine, Vcc pinini kartın 5V pinine ve toprak pinini ortak bağlayın. LM35’in Arduino Uno ile devre bağlantıları Şekil 1’de gösterilmektedir.

1: LM35’in Arduino Uno ile devre bağlantıları

Arduino, ortam sıcaklığını hesaplamak için LM35 sıcaklık sensörünün çıkış pimini izler. Ardından, bağlandığı seri bağlantı noktasındaki değeri gönderir. İşleme yazılımı bağlantı noktasından gelen verileri alır ve grafik kullanıcı arabiriminde (GUI) görüntüler. Ayrıca sıcaklığı da kontrol eder. Sıcaklık 40 ° C’nin altındaysa, yeşil LED yanar. 40 ° C’nin üzerindeyse, dizüstü bilgisayar hoparlöründe kırmızı LED yanar ve önceden kaydedilmiş bir sesli uyarı duyulur.

Arduino’daki mikro denetleyicide (MCU) dahili 10 bit analog-dijital dönüştürücü (ADC) bulunur. Arduino, ADC’sini kullanarak A35 analog pimi aracılığıyla LM35’in çıkışını izler. Arduino’daki program (efy_temp.ino), aşağıda verildiği gibi, gerçek sıcaklığı vermek için belirli faktörleri kullanarak çarpma ve bölme gerçekleştirir.

Sıcaklık = (val x 4.88) / 10; // değeri sıcaklığa dönüştürmek için çarpım faktörü

Yukarıdaki ilişkiyi anlamak için, Arduino’daki ADC’nin varsayılan olarak referans olarak 5V aldığını unutmayın. Bu nedenle, adım boyutunu hesaplamak için aşağıda verilen ilişkiyi kullanın.

Adım boyutu = Vref / 2 ⁿ
burada n = bit sayısı

Burada, Arduino’da 10 bitlik bir ADC var. Yani,
Stepsize = 5/1024 = 0.0048828 = 4.88mV

LM35’in veri sayfası, her 1 ° C artış için çıktıda 10mV’lik bir artış olduğunu söylüyor.

Bu nedenle, sıcaklık = (val × 4.88mV) / 10mV

GUI’yi anlama

IDE’nin işlenmesi Kartezyen koordinatları kullanır (Şekil 2). Dikdörtgen GUI penceresinin sol üst köşesinin (0,0) koordinatına sahip olduğunu varsayar ve diğer tüm koordinatlar buna göre alınır. İstenen işlevselliği elde etmek için, seri ve minim olmak üzere iki kütüphane kullanılır.

Şekil 2: Kartezyen koordinatlar

Minim kitaplığı İşleme IDE ile önceden yüklenmiş olarak gelir; test adımları bölümünde açıklandığı gibi indirilmesi ve kurulması gerekir.

GUI penceresini oluşturmak için işlem kodu (dee_efy.pde) kullanılır. Setup () içindeki kod bir kez çalışır ve GUI penceresinin boyutunu ayarlar ve temel bağımlılıkları yükler. Çizim döngüsünün içindeki kod tekrar tekrar çalışır. seri bağlantı noktasına her veri geldiğinde serialEvent () işlevi çağrılır. İşleme dizeyi okur ve data adlı bir değişkende saklar.

Led () işlevi, sıcaklık değerine bağlı olarak kırmızı ve yeşil LED’lerle ilgilenir.

Uygulama ayrıca Dosya> Uygulamayı Dışa Aktar’a giderek Windows, Mac veya Linux platformları için bağımsız bir uygulama olarak çalışacak şekilde dışa aktarılabilir. Dışa aktarmak istediğiniz platformu seçin ve Tamam’ı tıklayın.

Test adımları

1. Arduino IDE’yi web sitesindenindirin ve  bu web sitesinden İşleme yazılımı yükleyin .
2. Arduino kartını bir USB kablosu kullanarak dizüstü bilgisayara veya bilgisayara bağlayın ve Arduino IDE yazılımını kullanarak Arduino kodunu (efy_temp.ino) açın. Araçlar altında, kartı Arduino / Genuino Uno olarak seçin ve COM bağlantı noktasını düzeltin. Ardından kodu derleyin ve Arduino kartına yükleyin.
3. İşleme yazılımını kullanarak İşleme kaynak kodunu (dee_efy.pde) açın. Sesli uyarılar için bu yazılıma ses kitaplığını (minim) ekleyin. Bunun için Çizim> Kitaplığı İçe Aktar…> Kitaplık Ekle…> minim’e gidin. Filtre kutusunda, minim’i arayın ve Yükle’ye tıklayın ve birkaç saniye bekleyin.
4. GUI’niz için yazı tipleri ekleyin. Bunun için Araçlar> Yazı Tipi Oluştur’a gidin, Arial-black-48’i seçin ve Tamam’ı tıklayın. Renk kodları Araçlar> Renk Seçici seçeneğinden edinilebilir.
5. İşleme kodundaki COM12 port numarasını kendi COM port numaranızla değiştirin. Windows Aygıt Yöneticisi altındaki COM bağlantı noktasını kontrol edin. Kodu çalıştırmadan önce kaydedin. Çalınacak önceden kaydedilmiş ses dosyalarının, renkli yazı tipi dosyasının ve Arduino kodunun PC’nizdeki veri klasörünün içinde olması gerektiğini unutmayın.
6. Kodu çalıştırın, Şekil 3’te gösterildiği gibi bir GUI sıcaklık değeriyle açılacaktır.

3: GUI’de sıcaklık okuması

GUI’de, sıcaklık önceden tanımlanmış sınırın (40 ° C) altında olduğunda yeşil LED yanar ve sesli uyarı ile birlikte sıcaklık önceden tanımlanmış sınırın üzerinde olduğunda kırmızı LED yanar.

Kaynak Klasörü İndir

Not

Sesli uyarının sesini (tempSafe.mp3 ve tempWar.mp3) istediğiniz diğer uyarı sesleriyle değiştirebilirsiniz, ancak formatın, yani .mp3’ün aynı olduğundan emin olun.

Uyarıyı kullanmak istediğiniz sıcaklık sınırını değiştirmek isterseniz, kaynak kodunu işlerken if (convertedData> 40) değerinden değiştirebilirsiniz.

 

https://drive.google.com/file/d/1juPV2RD8rlnmV5rZ4jw1Pifsivg1wewH/view?usp=sharing

Gece olunca Otomatik Yanan Minik LED

Burada sunulan minik LED gece işaretçisi, gece veya ortamında yeterli ortam ışığı olmadığında uyanan otomatik bir ışık işaretidir. Karanlıkta aktif olan herkes (yürüme, binme, yüzme, vb.) Bu taşınabilir işaretçiyi karanlıkta net ve belirgin bir işaret koymak için bir güvenlik aracı olarak kullanabilir. Yazarın prototipi Şekil 1’de gösterilmiştir.

1: Yazarın prototipi

Devre ve Çalışma

LED gece işaretçisinin devre şeması Şekil 2’de gösterilmektedir. Digispark kartı, 9V pil ve diğer birkaç bileşenden oluşur. Devrenin merkezinde Digispark Attiny85 kurulu bulunuyor. Digispark kartı konektörleri CON1 konektörü ile temsil edilir. Donanım, Vin pimi aracılığıyla 6F22 (9V) alkalin pil ile güçlendirilmiştir. Harici sinyal (LED1), küçük sinyal transistörü BC547 (T1) etrafına kablolanmış düşük güçlü bir sürücü etkinleştirilerek kullanılır.

Şekil 2: LED gece işaretleyicisinin devre şeması

Anakartın analog giriş pimine P2 bağlı fotoğraf direnci (LDR1), yeterli ortam ışığı olmadığında yanıp sönen yerleşik P1 piminden harici LED1 işaretçisini kontrol etmek için kullanılır.

Program (night_marker.ino) Arduino programlama dilinde yazılmıştır. Digispark kartında, bilgisayardaki Arduino IDE üzerinden programlamak için bir USB arayüzü olarak bir konektör bulunur. Ayrıca, küçük kod iyi yorumlanmıştır, bu da gereksinime göre kolay modifikasyon sağlar.

İnşaat ve test

LED gece işaretçisinin PCB yerleşimi Şekil 3’te ve bileşen yerleşimi Şekil 4’te gösterilmiştir. Bileşenleri PCB’ye devre şemasına göre monte edin.

3: LED gece işaretleyicisinin PCB düzeni4: PCB için bileşen yerleşimi

PCB ve Bileşen Düzeni PDF’lerini indirin: Buraya Tıklayın

Kaynak Klasörü İndir

Breadboard prototipi, boşta 20mA’nın (> 200 lux) hemen üstünde ve aktif durumda (<10 lux) 25mA’nın hemen altında akım tüketimi ile iyi çalışan 9V pil (6F22) ile test edildi. 6F22 9V pil yerine 2S lityum-iyon / lityum-polimer pil (7.4V) önerilir. Yanlış pil girişi Digispark kartını kızartabileceğinden, pilin doğru kutuplarla bağlandığından emin olun.

Tamamlanmış cihazı su geçirmez, şeffaf / yarı saydam bir kutuya, tercihen bir güç açma / kapama anahtarına (şematikte gösterilmemiştir) yerleştirin. LDR1, LED1 ve güç anahtarını monte etmek için muhafazanın ön / üst panelinde yeterli delikler açın. Ek olarak, Digispark kartının USB konektörü için kutunun bir tarafına dikdörtgen bir pencere ekleyin.

https://drive.google.com/file/d/1x5Wc4CuRRcIA96l07o-756wbI49ZVGUH/view?usp=sharing

Akıllı Telefonda Dijital Pano ile IoT Özellikli Hava Kirliliği Ölçme Devresi

Burada, Blynk uygulamasını ve Arduino kartını kullanarak akıllı telefonunuzdaki hava kalitesini izlemek için IoT özellikli bir hava kirliliği ölçer sunulmaktadır . Blynk, Arduino, Raspberry Pi’yi kontrol etmek için Nesnelerin İnterneti (IoT) platformudur ve benzerlerini İnternet üzerinden . Bu projede Blynk, akıllı telefonunuzda yakın çevre için gerçek zamanlı hava kalitesi okumaları görüntüleyen dijital bir gösterge paneli sağlar.

Blynk belirli bir kart veya kalkan için tasarlanmamıştır. Arduino veya Raspberry Pi’nin Wi-Fi, Ethernet veya ESP8266 üzerinden İnternet’e bağlı olup olmadığına bakılmaksızın sizi çevrimiçi ve IoT’ye hazır hale getirecek çipi .

Blynk nasıl çalışır

Blynk donanımı uzaktan kontrol edebilir. Sensör verilerini görüntüleyebilir, diğer harika şeylerin yanı sıra saklayabilir ve görselleştirebilir. Platformda aşağıda belirtildiği gibi üç ana bileşen vardır:

Blynk uygulaması

Çeşitli widget’lar kullanarak projeleriniz için şaşırtıcı arayüzler oluşturmanıza olanak tanır.

Blynk sunucusu

Akıllı telefon ve donanım arasındaki tüm iletişimden sorumludur. Blynk Cloud’u kullanabilir veya özel Blynk sunucunuzu yerel olarak çalıştırabilirsiniz. Açık kaynak kodludur ve binlerce cihazı işleyebilir. Raspberry Pi’de de başlatılabilir.

Blynk kütüphaneleri

Kütüphaneler tüm popüler donanım platformları için mevcuttur. Kütüphaneler, sunucu ile iletişimi sağlar ve gelen ve giden tüm komutları işler.
Telefondaki Blynk uygulamasında bir düğmeye bastığınızda, sinyal Blynk Bulut’a gider ve donanıma gider. Ters yönde de aynı şekilde çalışır ve her şey göz açıp kapayıncaya kadar gerçekleşir. Konsept Şekil 1’de gösterilmiştir.

1: Blynk gömülü donanım ile bağlanıyor

IoT özellikli hava kirliliği ölçer

Hava kirliliği ölçüm cihazında aşağıdaki donanım bileşenleri kullanılır:

Kontrolör ve sensörler

Arduino Uno, kontrol ve ölçüm birimi ve Blynk Cloud’a bağlantı için Arduino Uno Ethernet kalkanı olarak kullanılır. Sensörler arasında nova PM sensörü SDS011, gaz sensörü MQ135 ve sıcaklık ve nem sensörü DHT11 bulunur.

Akıllı telefon ve dijital gösterge paneli

Android telefon bir akıllı sayaç olarak kullanılır. Blynk uygulaması iyi tasarlanmış bir arayüz oluşturucudur. İOS ve Android’de çalışır ve LCD, basma düğmeleri, açma / kapama düğmeleri, LED göstergesi, RTC ve daha fazlası için kullanımı kolay widget’lar sağlar. Bir akıllı telefonda Blynk dijital gösterge paneli özelliklerinin kullanılması, geleneksel LCD ekran, mekanik düğmeler, LED’ler, RTC ve benzeri gerekmediği için projenin maliyetini düşürmeye yardımcı olur. Dijital gösterge paneli veya akıllı sayaç ekranı Şekil 2’de gösterilmiştir.

Şekil 2: Android telefonda dijital gösterge tablosu

Devre ve çalışma

Dijital gösterge panosuna sahip IoT özellikli hava kirliliği ölçüm cihazının devre şeması Şekil 3’te gösterilmektedir. Devrenin kalbi Arduino korumalı Arduino Uno kartıdır. Kullanılan diğer bileşenler, 7805 voltaj regülatörleri (IC1 ve IC2), CON3 konnektörüne bağlı sıcaklık ve nem modülü DHT11, CON2 konnektörüne bağlı gaz sensörü MQ135, CON1 konnektörüne bağlı PM2.5 / PM10 sensörü ve birkaçıdır.

Şekil 3: PM2.5 / 10 IoT özellikli hava kirliliği ölçüm cihazının devre şeması

PM2.5 / PM10 sensörü (SDS011)

Partikül madde (veya PM) olarak da adlandırılan partikül kirliliği, havada yüzen katı partiküllerin ve sıvı damlacıklarının bir karışımıdır. Bazı parçacıklar doğrudan belirli bir kaynaktan salınırken, diğerleri atmosferdeki karmaşık kimyasal reaksiyonlarda oluşur.

CON1’e bağlı PM2.5 / PM10 sensörü, Çin Jinan Üniversitesi’nden bir spin-off olan INOVAFIT tarafından geliştirilmiştir. Havada lazer saçılması ilkesini kullanır ve 0,3 ila 10 mikron arasında değişen asılı partikül madde konsantrasyonunu tespit edebilir. Sensör tarafından toplanan veriler kararlı ve güvenilirdir. SDS011 sensörü Arduino Uno kartının UART portuna (TX ve RX) bağlanır.

Gaz sensörü (MQ135)

Sensörün hassas malzemesi, iletkenliği gaz konsantrasyonu ile artan kalay dioksittir. İletkenlikteki değişiklik, yanıcı gaz konsantrasyonuna karşılık gelen çıkış voltaj sinyaline dönüştürülür. MQ135, amonyak, sülfür ve benzen buharları, duman ve diğer zararlı gazlara karşı oldukça duyarlıdır. Farklı uygulamalar için uygun düşük maliyetli bir sensördür. Gaz sensörünün çıkışı, CON2 konnektörü aracılığıyla Arduino Uno kartının analog giriş pimine A3 bağlanır.

Sıcaklık ve nem sensörü (DHT11)

Bu kompozit sensör, sıcaklık ve nem için kalibre edilmiş dijital sinyal çıkışları içerir. CON3 konnektörüne bağlı olarak, dirençli bir nem ölçüm bileşeni ve bir NTC sıcaklık ölçüm cihazı içerir. Çıkış pimi, Arduino Uno kartının dijital pimine 5 bağlanır. Performansı için nispeten ucuz bir sensördür.

Ek özellikler

RL1 ve RL2 röleleriyle ek alarm göstergesi ve kontrolü sağlanmıştır. İki cihaz (ışık ve fan) CON5 ve CON6 konektörlerine bağlanabilir, ancak ihtiyacınıza göre daha fazlasını ekleyebilirsiniz. CON4 konnektörü, sırasıyla CON5 ve CON6’ya bağlı lambayı ve fanı çalıştırmak için 230V AC şebeke elektriğini bağlamak için kullanılır.

Güç kaynağı

7805 regülatörler (IC1 ve IC2) kullanılarak 5V’ye ayarlanan CON7 konnektörüne bir 12V pil veya besleme bağlanır. Sistem açıldığında, cihazın çalışmaya hazır olması için gaz sensörünü önceden ısıtması bir dakika alır. Tüm sensör devresi 9V veya 12V adaptör veya pil ile güçlendirilebilir. Burada, devrenin çeşitli kısımlarını sürmek için IC1 ve IC2 kullanılmıştır.

Tüm sensör devresini (Şekil 3) hava kalitesini veya kirliliği izlemek istediğiniz yere yerleştirmeniz gereken uygun bir kutuya yerleştirin.

Ethernet kalkanı

Arduino Ethernet kalkanı, Arduino’yu İnternet’e kolayca bağlamanızı sağlar. Bu kalkan, Arduino’nun dünyanın herhangi bir yerinden internet bağlantısıyla veri gönderip almasını sağlar.

Dijital gösterge paneli kurulumu

Adım 1. Ethernet korumasını Arduino Uno’ya takın ve Board1’i bir USB kablosu kullanarak PC’ye bağlayın.

Adım 2. Arduino sketch ethernetclient.ino’daki IPAddress IP’sindeki (IP adresiniz) IP adresini değiştirin. Bu çizim / program kodu makalenin sonundan indirilebilir.

Kodu derleyin ve Arduino IDE’den Arduino Uno’ya yükleyin. Bu kod, Ethernet kalkanı kullanarak nasıl HTTP isteği yapacağınızı gösterir. Arduino kelimesi için bir Google araması döndürür. Bu aramanın sonuçları Arduino’nun seri penceresinden HTML olarak görüntülenebilir.

Adım 3. ethernetserver.ino taslağını derleyin ve Arduino Uno kartına yükleyin. Çizimdeki IPAdresi IP’sinde (IP adresiniz) IP adresinizi değiştirin. Bu örnekte, basit bir Web sunucusu oluşturmak için Ethernet kalkanınızı ve Arduino kartınızı kullanın. Ethernet kütüphanesini kullanarak, cihazınız bir HTTP isteğini Ethernet kalkanı ile cevaplayabilecektir.

Ethernet kalkanı IP adresine gittikten sonra, Arduino HTML tarayıcısı aracılığıyla yanıt verecektir ve Board1’in analog pinlerinden (A0 ila A5) giriş değerlerini kabul etmeye hazır olacaktır.

Adım 4. Cep telefonunuzu Wi-Fi ile bağlayın. Google Play Store’dan Blynk uygulamasını indirin ve yükleyin. Ardından, yeni bir Blynk hesabı oluşturun (Şekil 4). Bu hesap, zaten bir hesabınız olması durumunda Blynk Forumları için kullanılan hesaplardan ayrıdır.

4: Blynk’te yeni bir hesap oluşturma

Projelerinizi kaydetmek ve bunlara dünyanın herhangi bir yerindeki birden fazla cihazdan erişebilmek için bir hesaba ihtiyaç vardır. Aynı zamanda bir güvenlik önlemidir. Daha sonra işleri basitleştireceği için gerçek bir e-posta adresi kullanmanızı öneririz.

Adım 5. Hesabınıza başarıyla giriş yaptıktan sonra, yeni bir proje oluşturarak başlayın (Şek. 5) ve buna bir isim verin.

5: Yeni bir proje penceresi oluşturma

Adım 6. Kullanmak istediğiniz donanım modelini seçin. Bu durumda Arduino Uno’dur (Şekil 6).

6: Donanımın seçilmesi

Adım 7. Yetkilendirme (veya Yetkilendirme) belirteci, donanımı akıllı telefonunuza bağlamak için gereken benzersiz bir tanımlayıcıdır. Oluşturduğunuz her yeni projenin kendi Auth jetonu olacaktır (Şekil 7). E-posta düğmesini tıklayın, belirteç kayıt için kullandığınız e-posta adresine gönderilecektir. Pollense.ino dosyasındaki auth [] = “belirteciniz” içinde bu belirteci kullanın.

7: Tipik yetkilendirme jetonu

Https://github.com/blynkkk/blynk-library/releases/tag/v0.3.4 adresinden Blynk kütüphanesini (Blynk_v0.3.4.zip) indirin ve Arduino IDE’ye ekleyin. Polution.ino kodunu derleyin ve Arduino kartına yükleyin.

Adım 8. Oluştur’a basın (Şek. 8).

8: Oluştur düğmesine basma

Adım 9. Proje tuvaliniz şu anda boş. Widget kutusunu açmak için tuvalin herhangi bir yerine dokunun; kullanılabilir tüm widgetlar burada bulunur. Widget ekleyin (Şek. 9).

9: Widget Kutusu penceresi

Ayarlara aşağıdaki widget’ları ekleyin ve ekranın Şekil 2’de gösterildiği gibi dijital bir gösterge panosu gibi görünmesini sağlayın. Buna LCD (Şekil 10), LED, açma / kapama düğmesi, butonlar ve RTC widget’larının eklenmesi dahildir.

10: LCD widget ayarı

Adım 10. Projeyi çalıştırın. Ayarları tamamladığınızda Oynat’a basın (Şek. 11). Bu, ekranı donanımdan etkileşim kurabileceğiniz düzenleme modundan çalma moduna geçirir. Oynatma modundayken, yeni widget’ları sürükleyemez veya ayarlayamazsınız. Durdur’a basın ve düzenleme moduna dönün. Oynatma modunda, Şekil 12’de gösterilen ekranı bulacaksınız.

11: Oynat düğmesi12: Oynatma modu

EFY notları: Uygun bir IoT tabanlı test için Android mobil cihazınız ve Arduino sensör kartınız için farklı Wi-Fi ağları kullanın.

Kaynak klasörü indir

https://drive.google.com/file/d/18a0kLJCwfYt28QnhipTiCTyLH_F7TwF7/view?usp=sharing

Bu makalede, ESP8266-12E / F modül programcısı yapmak için bir yöntem açıklanmakta ve aynı zamanda gerçek zamanlı uygulamalar için gereken destek devresi açıklanmaktadır.

NodeMCU kartı, ESP8266 Wi-Fi özellikli çip ve diğer birçok destek devresinden oluşan bir geliştirme kitidir. Wi-Fi ile ilgili projelerde çalışmak için kullanışlı olan popüler bir panodur. Ancak ürün geliştirme ve test aşamaları tamamlandığında, NodeMCU kartının tamamı gerekli değildir – son ürün için sadece ESP8266 yongası gereklidir. Bu, ürünün toplam maliyetini azaltır, güç tüketimini azaltır ve daha küçük bir PCB alanı ve kod güvenliği sağlar.

Ancak ESP8266 yongasını NodeMCU kartından ayırmak kolay değildir. Alternatif bir çözüm, ayrıca NodeMCU kartından çok daha ucuz olan ESP8266 yongasını ayrı olarak satın almaktır. Bu seçenekle, bu makalede açıklanan gibi uygun bir programlayıcı kullanarak kodu doğrudan ESP8266 yongasına yazabilirsiniz. Bundan sonra, ESP8266 yongasını programlayıcıdan çıkarabilir ve son ürününüzde kullanabilirsiniz.

Yazar tarafından kullanılan ESP8266-12 E / F modülü programlayıcı Şekil 1’de gösterilmektedir.

1: Yazar tarafından kullanılan ESP8266-12 E / F modülü programcısı

ESP8266 kullanarak bir proje tasarlama ve inşa etme işlemi iki ayrı adıma ayrılabilir: donanım ve yazılım. Donanım, GPIO’lara destek devresi oluşturma etrafında dönerken, yazılım çizimin çip içine yazılması, derlenmesi ve yüklenmesi etrafında döner. Böyle bir uygulama yine iki aşamadan oluşur: geliştirme ve dağıtım.

Geliştirme aşaması

Geliştirme aşamasında, yazılımı yazmak için ESP8266 Board Manager ve destekleyici kütüphanelerle Arduino IDE gibi bir yazılım geliştirme kitine (SDK) veya daha yeni bir PlatformIO IDE’ye ihtiyacınız vardır.

1. Yazılım kodu, yerleşik seri TTL-USB adaptörü (bazen USB-UART köprüsü olarak adlandırılır) kullanılarak ESP8266 yongasına yanıp söner. Yeni bir yazılımın yanıp sönmesi için, ESP8266 yongasının flaş modunda yeniden başlatılması ve bilgisayardan gelen USB sinyallerinin seri UART sinyallerine dönüştürülmesi ve Rx0 ve Tx0 pinleri (GPIO3 ve GPIO1) kullanılarak çipe aktarılması gerekir.
2. NodeMCU kartında, destek devresi tüm bunları sorunsuz bir şekilde otomatik olarak gerçekleştirir. Bu, NodeMCU veya WemosD1 Mini gibi benzer bir kartı hobiler arasında popüler hale getirir. Sıfırlama ve Flash düğmelerinin, otomatik yüklemenin başarısız olması durumunda NodeMCU kartına da yerleştirildiğini unutmayın.

Dağıtım / üretim aşaması

Bu aşamada, nihai üründe sadece ESP8266 yongası gereklidir.

Şimdi sorun ESP8266-12E / F (veya ESP-12E / F) çipinin nasıl kullanılacağını anlamak ve yine de kodu yükleyip NodeMCU veya benzeri bir kart olmadan yazılımı geliştirebilmektir. Bunun için öncelikle ESP-12E / F çipinin fiziksel boyutunu, çalışma, önyükleme ve yanıp sönme sürecini ayrıntılı olarak bilmemiz gerekir.

ESP-12E / F modülü. Modülün dış boyutu Şekil 2’de gösterildiği gibi 16mm x 24mm x 3mm’dir. 4MB SPI flaşı ve yerleşik PCB anteni vardır. Pim aralığı 2 mm’dir.

Şekil 2: ESP-12E modülünün pim ayrıntıları

Projeyi oluşturmak için 2.54 mm’lik bir pim aralığına sahip genel amaçlı bir PCB kullanılıyorsa, ESP8266 yongası için bir kesme kartı kullanılabilir. Bu projede kullanılan ayırma panosu Şekil 3’te gösterilmektedir. Ancak, projeye özgü bir PCB kullanılıyorsa, ayırma panosuna gerek yoktur. ESP8266-12x kesme tahtası düşük bir maliyetle kolayca temin edilebilir.

ESP-12E / F yongası, verilen pedlerde ayırma kartına lehimlenir ve başlık pimleri de ayırma kartına lehimlenir. Başlık pimleri 2.54 mm aralıklı. ESP-12E / F modülü herhangi bir genel amaçlı PCB’ye takılabilir.

Ara kartında üç SMD direnci de vardır (Şekil 3). Kartın ön tarafında, düşük düşmeli 3.3V voltaj regülatörü olan HT7333A’yı sabitlemek için alan var. Alternatif olarak, devreye güç vermek için harici bir 3.3V regülatör kullanılabilir.

3: ESP-12E / F çip için kesme kartının ön ve arka tarafları

Manuel ESP-12E / F programlayıcı

ESP-12x tabloda gösterildiği gibi üç farklı modda önyükleme yapabilir. İlk iki önyükleme modu ile ilgileniyoruz.

Tablodan görülebileceği gibi, önyükleme sırasında GPIO2 ve Ch_PD / En pinleri daima yüksek, GPIO15 ise düşük tutulmalıdır. Bağımsız ESP-12E / F yongasını kullanırken, Ch_PD ve GPIO2 pinlerine 10k / 12k yukarı çekme dirençleri ve GPIO15 pinine aşağı çekme (10k / 12k) dirençleri ekleyin. Çekme ve çekme dirençlerinin kesme kartında önceden oluşturulduğunu unutmayın.

Sıfırlama pimi ve GPIO0 normalde yüksek tutulmalı, ancak Şekil 4’teki devrede gösterildiği gibi mikro anahtarlarla toprağa bağlanmalıdır. Bu, ESP-12E / F modülünü kullanmak için gereken minimum yapılandırmadır. Bu modülün etrafında inşa edilen her projede bu beş adet 12k direnç bulunmalıdır. Bu dirençler NodeMCU kartında önceden oluşturulmuştur.

4: Manuel ESP8266-12E / F Modül Programlayıcısının devre şeması

Manuel yanıp sönme işlemi

Manuel ESP-12E / F programcısı Şekil 4’te gösterilmiştir. Herhangi bir çizim / kodu ESP8266 çipine manuel olarak yanıp sönmek için, önce aşağıdaki gibi adım adım flash / programlama moduna getirin:

1. Sıfırla (S1) ve Flaş (S2) düğmelerini basılı tutun.
2. S2 düğmesini basılı tutarak S1’i serbest bırakın. GPIO0 düşük tutulurken bu güç açmaya eşdeğerdir.
3. ESP8266 önyükleme yaptıktan sonra S2’yi bırakın.
4. Yazılımı Tx ve Rx pinleri aracılığıyla yükleyin. Bilgisayarlarda artık donanım seri bağlantı noktaları bulunmadığından, USB’den UART’a dönüştürücü kullanılabilir. Bu dönüşüm NodeMCU’da dahili CH340G veya CP2102 USB-UART çipi üzerinden gerçekleşir. Kolayca bulunabilen FTDI USB-UART modülü bu programcı için kullanılır.
5. Yanıp sönme işlemi tamamlandığında, ESP8266’yı normal modda başlatmak için S1 anahtarına basarak ESP8266’yı yeniden başlatın.

ESP8266-12E / F Modül Programlayıcı’nın farklı önyükleme modları

Yanıp sönen işlemi otomatikleştirme

Yukarıdaki işlem, yeni yazılımların her yanıp sönmesinde manuel müdahale gerektirse de, NodeMCU kullanma deneyimine benzer şekilde yazılım kodunu yükleme kolaylığına ihtiyacımız var. Bu işlem, ESP8266 yongasındaki Reset ve Flash (GPIO0) pinlerini bildirmek için kullanılan USB-UART yongasının veri terminali hazır (DTR) ve gönderilmeye hazır (RTS) sinyalleri kullanılarak otomatikleştirilebilir.

DTR ve RTS pinlerine FT232x USB-UART modülü etrafında inşa edilen popüler FTDI modülünden kolayca erişilebilir (Şekil 5’de gösterilmiştir). CH340 yongaları kullanan harici USB-UART modülleri de mevcuttur, ancak bu modüllerde DTR ve RTS pinlerine erişilemez.

Şekil 5: FT232 USB-UART modülü

FT232x USB-UART modülündeki RTS sinyali, Şekil 5’te gösterildiği gibi ayrı bir pim üzerinde mevcuttur. Programlayıcı ile kullanım kolaylığı için, erkek çıkış pimlerini gerekli tüm çıkışların (deliklerin) bulunduğu modüle takın. Altı pinden oluşan isteğe bağlı bir seri adaptör, dikey olarak değil, modül üzerine yatay olarak monte edilir.

FT232 modülü ayrıca USB I / O için entegre 3.3V seviye dönüştürücüsüne sahiptir. ESP8266-12x 3.3V üzerinde çalıştığından, modül üzerindeki atlama kablosu 3.3V olarak ayarlanmalıdır, böylece sinyaller ESP8266 ile uyumludur. 3.3V, harici mantık sağlamak için de kullanılabilir. Bununla birlikte, FT232’deki maksimum akım değeri 100mA, ESP8266-12E / F ise 170mA’lık tepe akımları çekebilir. FT232 cihazının hasar görmesini önlemek için ESP8266-12E / F’ye güç sağlamak için harici bir 3.3V modülü kullanılır.

Programcı devresi

Otomatik programlayıcının devre şeması Şekil 6’da gösterilmiştir. ESP8266-12E modülü (MOD1), FT232 modülü (MOD2), 3.3V modülü (MOD3), iki anahtar (S1 ve S2), iki BC547 transistör etrafında inşa edilmiştir. (T1 ve T2) ve diğer birkaç bileşen.

6: Otomatik ESP8266-12E / F Modül Programlayıcısının devre şeması

Otomatik ESP-12E / F programlayıcı devresi yukarıda tartışılan manuel programlayıcıya benzer. RTS sinyali ESP8266’yı sıfırlamak için kullanılırken, DTR sinyali çipi flaş moduna almak için kullanılır. T1 ve T2, hem DTR hem de RTS sinyalleri düşük olduğunda ESP8266’nın sıfırlanmaması için kullanılır. Yükleme komutunun algılanması üzerine, ESP modülü otomatik olarak flaş moduna geçirilir ve sorunsuz bir şekilde yeni bir çizim yüklenebilir. Yükleme komutunun yokluğunda, ESP-12E / F normal modda başlar ve programlanmış ESP-12E / F kartı bir uygulamada test edilebilir veya kullanılabilir.

ESP-12E / F kartını test etmek için, bu makalede basit bir LED yanıp sönen uygulama sunulmuştur. Yazılım kodu (NewBlink.ino) Arduino programlama dilinde yazılmıştır.

Programlayıcı nasıl kullanılır

Programlayıcı, Şekil 7’de gösterildiği gibi genel amaçlı bir PCB üzerine veya Şekil 8 ve 9’da gösterildiği gibi tasarlanmış PCB üzerine kurulabilir.

7: Yazar tarafından kullanılan modüller ve genel amaçlı PCB8: Otomatik ESP8266-12E / F Modül Programlayıcı’nın PCB düzeni9: PCB için bileşen yerleşimi

PCB ve Bileşen Düzeni PDF’lerini indirin: buraya tıklayın

Kaynak Klasörü İndir

Dişi Berg şerit konnektörleri, ESP8266 yongasını ve programlayıcı kartındaki FTDI kartını (FT232 modülü) takmak için kullanılır. Modülleri ve konektörleri PCB’ye monte edin. Modüllerin doğru yönde takıldığından emin olun.

Şimdi FT232 modülünü bir USB kablosuyla bilgisayara bağlayın. Arduino IDE’yi açın ve kodunuzu yazın veya bilgisayarınızda kayıtlı mevcut kodu açın. Burada, LED yanıp sönen uygulamanın kodunu (NewBlink.ino) açmanız yeterlidir.

Arduino IDE’de doğru Com portunu seçin ve kartı NodeMCU 1.0 (ESP-12E Modülü) olarak ayarlayın. Yükleme hızının 115200 olduğunu kontrol edin. Normalde NodeMCU kullanarak yaptığınız gibi derleyin ve yükleyin. ESP-12E / F kartındaki yerleşik LED (GPIO 2’de), başarılı yüklemede yanıp sönmeye başlayacaktır.

Programlanan ESP-12E / F modülü programlayıcıdan çıkarılabilir ve projeye özgü kartınıza kaydırılabilir. Artık dağıtım için hazır olan daha ucuz ve daha küçük bir NodeMCU sürümüne sahipsiniz.

 

 

 

https://drive.google.com/file/d/1H8TGZ39DN2mhjHOwNZcs5HUSTocxo3NO/view?usp=sharing