Eğer bu projeyi yapmayı amaçlıyorsanız “ Yeni başlayanlar için ESP-NOW ” adlı blog yazımı incelemenizi tavsiye ederim. Koddaki ESP-NOW protokolüne ait tüm komutların açıklamaları o blog yazımda mevcut.

1. Adım: İhtiyaç Listesi

İsteğe bağlı ESP kartları

ESP32-Wroom-32 Wifi ve Bluetooth Geliştirme Kartı: https://www.robo90.com/esp32-wroom-32-wifi-ve-bluetooth-gelistirme-karti

Altyazı

Eğer elinizde ESP32-CAM modülünüz yoksa veya satın almak istemiyorsanız bu yazılımların hepsi ESP32 işlemcisine sahip tüm cihazlarda çalışacaktır. ESP32-CAM modülü de adından da anlaşılabileceği gibi ESP32 işlemcisi taşımaktadır. Sadece ESP32-CAM modülünün bacak sayısı daha az olduğu için verici kodunda çıkışını 0 ve 5V yani HIGH ve LOW yapabildiğiniz herhangi bir pini değiştirip ESP32 kartında da aynı yazılımı kullanabilirsiniz. Ancak minimum 2 adet ESP kartı olmalı.

ESP32-CAM Wifi Bluetooth Geliştirme Kartı ve OV2640 Kamera Modülü: https://www.robo90.com/esp32-cam-wifi-bluetooth-gelistirme-karti-ve-ov2640-kamera-modulu

Gerekli Yan Malzemeler

10mm RGB LED 4 Bacaklı Ortak Katot: https://www.robo90.com/10mm-rgb-led-4-bacakli-ortak-katot

Mini Breadboard – 170 Pin – Yeşil – Çıkıntısız: https://www.robo90.com/mini-breadboard-170-pin-yesil-cikintisiz

220R Direnç Paketi – 1/4 W – 10 Adet: https://www.robo90.com/220r-direnc-paketi-1-4-w-10-adet

40lı Ayrılabilen Dişi-Erkek Jumper Kablo – 20cm – Arduino Uyumlu: https://www.robo90.com/40li-ayrilabilen-disi-erkek-jumper-kablo-20cm-arduino-uyumlu

6X6 8mm Tach Buton (2 Bacak): https://www.robo90.com/6×6-8mm-tach-buton-2-bacak

2. Adım: Nasıl Kodlarız ?

Verici ( TX ) kodu

#include <esp_now.h>
#include <WiFi.h>
//kanal belirliyoruz alıcı ve verici aynı kanalda olmalı 
#define CHANNEL 1
#define BUTTON_PIN 21  // GIOP21 pin connected to button
#define BUTTON_PIN_1 19  // GIOP21 pin connected to button
#define BUTTON_PIN_2 18  // GIOP21 pin connected to button
//Alıcının MAC adresini esp_now_peer_info yapısına tanıttığımız kod
esp_now_peer_info_t slave;
//göndermek istediğimiz veri
uint8_t data=0; 
int lastState = LOW;  // the previous state from the input pin
int currentState;     // the current reading from the input pin
int lastState_1 = LOW;  // the previous state from the input pin
int currentState_1;     // the current reading from the input pin
int lastState_2 = LOW;  // the previous state from the input pin
int currentState_2;     // the current reading from the input pin
void setup ()
{
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(BUTTON_PIN_1, INPUT_PULLUP);
  pinMode(BUTTON_PIN_2, INPUT_PULLUP);
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  esp_now_init();
  esp_now_register_send_cb(OnDataSent);
  ScanForSlave();
  esp_now_add_peer(&slave);
}
void loop(){
  currentState = digitalRead(BUTTON_PIN);
  if (lastState == HIGH && currentState == LOW)
    esp_now_send(slave.peer_addr, &data, sizeof(data));
  else if (lastState == LOW && currentState == HIGH)
    Serial.println("The button is released");
  lastState = currentState;
  currentState_1 = digitalRead(BUTTON_PIN_1);
  if (lastState_1 == HIGH && currentState_1 == LOW){
    data=1;
    esp_now_send(slave.peer_addr, &data, sizeof(data));
  }
  else if (lastState_1 == LOW && currentState_1 == HIGH){
    Serial.println("The button is released");
    data=0;
  }
  lastState_1 = currentState_1;
  currentState_2 = digitalRead(BUTTON_PIN_2);
  if (lastState_2 == HIGH && currentState_2 == LOW){
    data=2;
    esp_now_send(slave.peer_addr, &data, sizeof(data));
  }
  else if (lastState_2 == LOW && currentState_2 == HIGH){
    Serial.println("The button is released");
    data=0;
  }
  lastState_2 = currentState_2;
  
  
}
//CallBack fonksiyonu
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status ) {
  Serial.print("Datayı gönderdim->");
  Serial.println(data);
}
void ScanForSlave() 
{
  int16_t scanResults = WiFi.scanNetworks(); // Scan only on one channel
  
    for (int i = 0; i < scanResults; ++i) 
    {
      // Print SSID and RSSI for each device found
      String SSID = WiFi.SSID(i);
      String BSSIDstr = WiFi.BSSIDstr(i);
      // Check if the current device starts with `Slave`
      if (SSID.indexOf("RX") == 0) 
      {
        int mac[6];
        if ( 6 == sscanf(BSSIDstr.c_str(), "%x:%x:%x:%x:%x:%x",  &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5] ) ) {
          for (int ii = 0; ii < 6; ++ii ) {
            slave.peer_addr[ii] = (uint8_t) mac[ii];
          }
        }
        slave.channel = CHANNEL; // pick a channel
        slave.encrypt = 0; // no encryption
        break;
      }
    }
}

Gördüğünüz gibi bir önceki yazımızdaki tüm ESP-NOW komutlarını bu yazımızda da kullandık. Farklı olarak “ #define BUTTON_PIN 21 ” ile butonlarımızı tanımladık. Sonrasında “ lastState ” ve “ currentState ” gibi değişlenlerle butonlara bastığımız anı ve çektiğimiz anı kaydetmek için tanımladık. Setup kısmında ise “ pinMode(BUTTON_PIN, INPUT_PULLUP); ” komutu sayesinde BUTTON_PIN pinini giriş olarak belirledik ve PULL_UP yaptık. Bu sayede butonumuza dışarıdan bir direnç yardımıyla pull up yapmamıza gerek kalmadı.

Sonrasında loop kısmında “ currentState = digitalRead(BUTTON_PIN); ” komutu ile currentState değişkenimizi BUTTON_PIN pinimize yani IO21 numaralı pinimize eşitledik. Diğer butonlar için de aynı işlemi yaptık.

 currentState = digitalRead(BUTTON_PIN);
  if (lastState == HIGH && currentState == LOW)
    esp_now_send(slave.peer_addr, &data, sizeof(data));
  else if (lastState == LOW && currentState == HIGH)
    Serial.println("The button is released");
  lastState = currentState;

Kodumuzun yukarıdaki kısmında ise eğer BUTTON_PIN yani IO21 numaraya bağlı butonumuza basılırsa “ esp_now_send(slave.peer_addr, &data, sizeof(data)); ” komutumuzun çalışması gerektiğini kodladık. Bir önceki blog yazımızdan hatırlarsak bu kod “ slave.peer_addr ” MAC adresine sahip alıcı cihazımıza “ &data, sizeof(data) ” komutları ile data verimizi ve datamızın boyutunu gönderir. Diğer buton kodlamalarında ise data verisini “ data=1; ” kodu sayesinde bir sayısına eşitleriz. Bu değer her buton için farklıdır. Bu sayede alıcı cihaza hangi butona basıldıysa onun numarasını gönderebiliriz ve ona göre RGB LED’ imizi kontrol edebiliriz.

Sonradan “ else if ” komutu ile butondan parmağımızı çektiğimizi algılarız ve tekrar “ data “ değişkenimizi sıfıra eşitleriz. Bu sayede herhangi bir karışıklık olmasının önüne geçeriz.

Verici kodumuz bu kadardı. Şimdi alıcı kodumuzu inceleyelim.

Alıcı ( RX ) kodu

#include <esp_now.h>
#include <WiFi.h>
#define CHANNEL 1 
#define LED_PIN 12   
#define LED_PIN_1 13
#define LED_PIN_2 15    
int data_1;
void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_AP);
  WiFi.softAP("RX_1","RX_1_Password",CHANNEL, 0);
  esp_now_init();
  esp_now_register_recv_cb(OnDataRecv);
  pinMode(LED_PIN, OUTPUT);
  pinMode(LED_PIN_1, OUTPUT);
  pinMode(LED_PIN_2, OUTPUT);
}
void loop() {
  if(data_1==0){
    digitalWrite(LED_PIN,HIGH);
    delay(1000);
    digitalWrite(LED_PIN,LOW);
  }
    digitalWrite(LED_PIN,HIGH);
  if(data_1==1){
    digitalWrite(LED_PIN_1,HIGH);
    delay(1000);
    digitalWrite(LED_PIN_1,LOW);
  }
  if(data_1==2){
    digitalWrite(LED_PIN_2,HIGH);
    delay(1000);
    digitalWrite(LED_PIN_2,LOW);
  }
}
void OnDataRecv(const uint8_t *mac_addr, const uint8_t *data, int data_len){
  data_1=*data;
  Serial.print(data_1);
}

Alıcı kodumuzda da bu sefer RGB LED pinlerinin ESP kartımızın hangi pinleri ile kontrol edeceğimizi tanımladık. Sonrasında ise tekrar data_1 adlı bir değişken oluşturduk. Bunu neden yaptığıma değineceğim.

Setup kısmında ise LED pinlerimizin pin durumlarını çıkış olarak ayarladık. Sonrasında önceki yazımızda bahsettiğimiz ESP-NOW komutlarımızı çalıştırdık.

OnDataRecv fonksiyonuna bakacak olursak da önceki blog yazısından da hatırlayacağımız gibi data değişkeni bize geliyordu. Bu değişkeni ise bir arttırıp seri monitöre yazdırıyorduk. Şimdi ise bu değişkenden gelen verileri kontrol ederek RGB LED yakıp söndüreceğimiz için bu değişkeni kendi blog satırından loop satırına almamız gerekir. Ancak değişken sadece OnDataRecv fonksiyonu içerisinde tanımlanmıştır. Bunun önüne geçmek için kütüphaneleri de tanımladığımız tüm fonksiyonların dışındaki alana bir “ data_1 ” değişkeni tanımlayıp data değişkenini bu değişkene eşitledim. Bu sayede gelen verileri diğer tüm fonksiyonlarda kullanabileceğim. Sonrasında da “ Serial.print(data_1); ” komutu ile alıcı cihazımıza gelen verileri seri monitöre yazdıralım.

Loop kısmında ise daha önceden oluşturduğumuz data_1 değişkenini kullanaraka if komutları oluşturduk. Hatırlarsanız verici kısmında butonlara basıldığında sırasıyla 0, 1 ve 2 komutları alıcı cihazımıza geliyordu. Bu verileri kullanarak eğer data_1 değişkeni 1 sayısına eşitse RGB LED’in kırmızı bacağını kontrol et, eğer data_1 değişkeni 0 a eşitse mavi LED ‘i kontrol et gibi if komutları yazabiliriz.

Şimdi ise kodlarımızı sırasıyla alıcı ve verici cihazlarımıza yüklemeniz gerekmekte. Eğer daha önce ESP32 veya ESP32-CAM modüllerine kod yüklemediyseniz ve nasıl yükleneceğini bilmiyorsanz sırasıyla aşağıdaki blog yazılarımı da inceleyebilirsiniz. Bu yazımda kodun nasıl yükleneceğine değinmeyeceğim.

Donanım Kısmı ve Blog Şeması

Eğer bu kısma kadar geldiyseniz harika bir iş çıkardınız. Şimdi devre şemamızı sırasıyla alıcı ve verici cihazlarımız için inceleyelim.

Verici Devre Şeması

Gördüğünüz gibi yukarıdan aşağıya doğru sırasıyla D21, D19, D18 pinlerini butonlara bağladık. Sonrasında butonların diğer bacaklarını da ESP32 kartımızın GND bacağına bağladık. Bu sayede butona basğtığımızda seçtiğimiz pinler GND ‘ye çekilerek butona basıldığını anlayacağız. Şimdi Alıcı cihazımızın devre şemasını inceleyelim. ( Fotoğraf 1.0 )

Alıcı Devre Şeması

Gördüğünüz gibi sırasıyla RGB LED’imizin pinlerini ESP32-CAM modülünün IO12, IO13, IO15 numaralı pin bacaklarına bağladık. RGB LED imiz ortak katot yapısına sahip olduğu için bir direnç yardımıyla ESP32-CAM modülümüzün GND bacağına bağladık. Bu sayede seçtiğimiz pinlerden herhangi birsini HIGH yaparsak ( yani 0V’dan 5V ) RGB LED in kırmızı mavi ve yeşil renklerinden birisi yanacaktır. Alıcı cihazımızın devre şeması da bu kadardı. Şimdi isterseniz projemizi test kısmına geçelim. ( Fotoğraf 1.1 )

Test Kısmı

Şimdi iki cihazımız da ayrı ayrı bilgisayarıma bağlı ve ayrı Arduino IDE programında açıklar. Bu sayede hangi verinin nereye nasıl gittiğini görebileceğim.

Ve evet ! İlk butona bastığım anda mavi LED’imin yandığını görebiliyorum. ( Fotoğraf 1.2 ) Şimdi sırasıyla diğer butonlara basarak diğer LED’leri kontrol edelim. Yeşil ledi kontrol etmek için ortadaki butona bastığımda; ( Fotoğraf 1.3 )

Gördüğünüz gibi ortadaki butona basınca yeşil RGB LED’i yanıyor ve verici seri monitöründe 1 datasını gönderdiğini gösteriyor. ( Fotoğraf 1.3- 1.4 ) Alıcı monitöründe ise 1 datasının geldiğini görebiliyoruz. Şimdi aynı durumu kırmızı LED için de inceleyelim.

Ve evet ! Gördüğünüz gibi butona bastığım anda 2 datası verici cihazdan alıcı cihaza gönderildi ve alıcı cihazın da seri monitöründe 2 datası göründü. ( Fotoğraf 1.5– 1.6 ) Fotoğrafa bacakak olursak da kırmızı ışığın yandığını gözlemleyebiliriz.

Bu projemiz bu kadardı. İki adet ESP32 cihazını kablosuz haberleştirerek yapabileceklerinizi bir düşünsenize. Ne kadar fazla. Bunun gibi daha fazla projeyi görmek istiyorsanız aşağıdaki bağlantıdan tüm projelerimi görebilirsiniz.

Diğer proje yazıları: https://blog.robo90.com/kategori/projeler/

Bir sonraki bloğumda ise ESP mesh Networking kavramını inceleyeceğim.

ESP-NOW ile RGB LED Kontrolü 🎛️ yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

Eğer bloğumdaki önceki yazıları okuyan birisiyseniz ESP32 ve ESP8266 kartlarına aşina olabilirsiniz. Yine de benimle bu yazımda tanışıyorsanız diğer blog yazılarımı da incelemenizi tavsiye ederim.

https://blog.robo90.com/kategori/projeler/

ESP kartları gerek Wi-Fi modülü, gerek Bluetooth modülüne sahip olup ayrıca 32 bit işlemcileri sayesinde IOT projeleri ve haberleşme projeleri için süper ucuz ve çok kullanışlı kartlardır. Peki nedir bu ESP-NOW protokolü?

ESP-NOW, bir çok ESP cihazının Wi-Fi kullanmadan birbirleriyle iletişim kurmaların sağlayan bir protokoldür. Bu kablosuz mouse cihazlarında kullandığımız 2.4GHz kablosuz bağlantısına benzer bir protokoldür. ESP-NOW’da tüm cihazlar birbirleriyle senkron bir şekilde de çalışabildikleri için bir kablosuz sensör ağı kurmak istiyorsanız muhteşem cihazlardır. Şimdilik bir cihazdan diğer cihaza gönderebileceğiniz verinin boyutu 250 Byte’tır. Yani bir ESP cihazından diğerine ses dosyası veya bir video akışı yapamazsınız. Ancak sensör okumak istiyorsanız veya küçük bir pakete sığacak bir veri göndermek istiyorsanız 250 byte oldukça yeterli. Tüm bu bilgileri anladığımıza göre şimdi ESP-NOW’u olabildiğince hızlı kullanmanızı sağlayacak adımlara geçelim.

1. Adım: İhtiyaç Listesi

ESP-NOW protokolünü kullanmak istiyorsanız en az 2 adet ESP geliştirme cihazına ihtiyacınız var. Ben bu yazımda iki adet ESP32 kartını kullanacağım. Aşağıdaki linkten ESP32 veya ESP8266 kartlarına ulaşabilirsiniz.

ESP32-Wroom-32 Wifi ve Bluetooth Geliştirme Kartı: https://www.robo90.com/esp32-wroom-32-wifi-ve-bluetooth-gelistirme-karti

Nodemcu V3 – ESP8266 Geliştirme Kartı – CH340G: https://www.robo90.com/nodemcu-v3-esp8266-gelistirme-karti-ch340g

2. Adım: Nasıl Kodlarız?

ESP32 kartını kullanabilmek için Arduino IDE uygulamasına doğru kütüphaneyi indirmemiz ve birkaç önemli işleme dikkat etmemiz gerekir. Bu yazımda ESP32 kartlarına nasıl kod yükleyebileceğimizden bahsetmeyeceğim. Eğer ESP kartlarına nasıl yazılım yükleneceğini merak ediyorsanız aşağıdaki blog yazımı inceleyebilirsiniz.

Bu yazımızda ESP32 ’ ye Arduino IDE kullanarak ESP32’ye nasıl yazılım yükleneceğini ve örnek bir kod olarak ESP32’ye blink kodunu yükleyeceğiz.

Eğer ESP kartlarından birisini ilk defa kullanacaksanız yukarıdaki yazımdaki aşamaları sırasıyla inceleyip kartınızda basit bir blink programı çalıştırmanızı tavsiye ederim. Bu sayede kartınızı hızlı bir şekilde test edip yazılım yüklenebildiğini görmüş olursunuz.

3. Adım: Yazılım Kısmı.

kodu incelerken kodun en ama en basite indirgenmiş halini teker teker açıklayıp hangi kodun ne işe yaradığından bahsedeceğim. Bu sayede ezbere bir sistem çalıştırmaktansa hangi kodun ne işe yaradığını biliyor olacağız. Bana sorarsanız bunu bilmek önemli. Çünkü her yeni bir proje yaptığımızda önceki bilgilerimizi kullanıp üstüne koyarak ilerliyor, hataları bu sayede görüp sorunları olabildiğince hızlı çözüyoruz. Şimdi gelin projenin kodlarını incelemeye başlayalım.

Proje iki ayrı koddan oluşuyor olacak. Birisi Transmitter Device veya Master Device ( İleten cihaz veya Master Cihaz ), diğer cihaz ise Receiver device veya Slave Device ( Alıcı Cihaz veya Köle Cihaz ). Bu isimler karmaşık geliyorsa olaya sadece ileten ve dinleyen cihaz gözüyle bakabilirsiniz. Kod ESP-NOW protokolünün çalışması için minimum gereken koda sahiptir.

Daha fazla bilgiye Espressif API referans sayfasından ulaşabilirsiniz. Kodumuzu incelerken şu kod şu işlevi gerçekleştirir dediğimizde hepsi aşağıdaki sitede belgelenmiştir. Belgeyi incelediğimizde 18 adet işlev var gibi görünüyor ve gerçekten fazla değil.

https://docs.espressif.com/projects/esp-idf/en/latest/esp32c3/api-reference/network/esp_now.html

Verici Kodu

#include <esp_now.h>
#include <WiFi.h>

//kanal belirliyoruz alıcı ve verici aynı kanalda olmalı 
#defie CHANNEL 1

esp_now_peer_info_t slave;

Kodumuzun başlangıcına bakacak olursak önce kütüphanelerimizi tanımlamışız. Daha sonrasında ise ESP cihazlarımızın konuşacakları kanalı “ #defie CHANNEL 1 ” kodu ile 1. kanala atıyorum. Aslında varsayılan olarak 1. kanal olarak tanımlanmıştır ancak biz bu kısımda kanalımızı belirleyeceğiz.

Burada bir diğer dikkat etmemiz gereken kısım ise MAC adresidir. Eğer cihazınız verici ( Transmitter ) konumunda ise alıcı hakkında bazı bilgilere sahip olması gerekir. Özellikle bilmemiz gereken bilgi alıcının MAC adresidir. MAC adresi donanıma atanmış benzeri olmayan, her cihazın farklı olduğu benzersiz bir ağ adresidir. Bu bizim belirlediğimiz bir şey değil zaten donanımda olan bir şeydir. Bu MAC adresi vericiyle birlikte kaydedilir. Kodumuzdaki “ esp_now_peer_info_t ” alıcı cihazın MAC adresinin eşlenildiği kısımdır. “ esp_now_peer_info_t ” veri türünde “ slave ” adlı bir değişken oluştururuz.

Espressif firmasının belgelerini incelersek eğer aslında bu kodun bir Structures ( Yapı ) olduğunu da anlarız. ( Fotoğraf 1.0 ) Ancak fotoğraftaki peer_addr alıcının MAC adresini bu yapıya kaydettiğimiz kısımdır. Kodun devamına bakacak olursak;

uint8_t data=0; 

void ()
{
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  esp_now_init();
  esp_now_register_send_cb(OnDataSent);
  ScanForSlave();
  esp_now_add_peer(&slave);
}

Kodumuzun bu kısmında ise göndereceğimiz int formunda bir data değişkeni tanımlıyoruz. formatın int ( integer, sayısal ) formunda olması zorunlu değil. Sensör verilerini içerisinde tuttuğumuz bir dizi veya başka bir veri türü olabilir. Buradaki tek kıstas verinin 250 byte boyutundan düşük olması gerekmesi.

Sonrasında ise “ Serial.begin(115200); ” kodu ile seri monitörümüzü kartımızda 115200 baudrate hızıyla haberleşebileceği şekilde ayarlıyoruz. ESP-NOW için gerekli değil ama bazı verileri bilgisayar ekranımızda görmek istiyoruz.

Vericinin modunu “ Wifi.mode(WIFI_STA); ” kodu sayesinde istasyon moduna alıyoruz. Sonrasında ise ESP-NOW protokolünü başlatacak olan “ esp_now_init(); ” fonksiyonunu çağırıyoruz.

Sonrasında ise “ esp_now_register_send_cb(OnDataSent); ” fonksiyonu ile bir Callback Function ( Geri arama fonksiyonu ) başlatmamız ve ona bir isim vermemiz gerekiyor. Biz OnDataSent ismini verdik. Daha sonra OnDataSent fonksiyonunu ayrıca tanımlamamız ve ne iş yapacağını fonksiyonun içerisine yazmamız gerekir. Bu kısma sonradan tekrar değineceğiz. Şimdi Callback fonksiyonumuzu inceleyelim.

//CallBack fonksiyonu
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status ) {
  Serial.print("Datayı gönderdim->");
  Serial.println(data);
}

CallBack fonksiyonu oluşturduğumuzda 2 parametre gerekecek, bir EROR( hata ) durum kodu ve MAC adresi işaretçisi.

Sonrasında önceki kod satırındaki “ ScanForSlave(); ” fonksiyonunu anlamamız gerek. Bu fonksiyon açık ara koddaki en karmaşık fonksiyon. Şimdi fonksiyonu inceleyelim.

ScanForSlave() Fonksiyonu

void ScanForSlave() 
{
  int16_t scanResults = WiFi.scanNetworks(); 
  
    for (int i = 0; i < scanResults; ++i) 
    {
      String SSID = WiFi.SSID(i);
      String BSSIDstr = WiFi.BSSIDstr(i);

      if (SSID.indexOf("RX") == 0) 
      {
        int mac[6];
        if ( 6 == sscanf(BSSIDstr.c_str(), "%x:%x:%x:%x:%x:%x",  &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5] ) ) {
          for (int ii = 0; ii < 6; ++ii ) {
            slave.peer_addr[ii] = (uint8_t) mac[ii];
          }
        }

        slave.channel = CHANNEL; 
        slave.encrypt = 0; 

        break;
      }
    }
}

Bu kodun çalışma mantığını derinlemesine incelemeyeceğiz ama temel olarak ne yaptığından bahsedeceğim. Yaptığı şey aslında WiFi ismi RX ile başlayan cihazları bulmak. Sonrasında onların MAC adreslerini almak. İstersek sabit kullanacağımız cihazların MAC adreslerine ulaşıp kodumuzun içerisine direk de yazabiliriz. Ancak bu yolla yeni bir cihaz eklemek istediğimizde sadece WiFi ismini RX ile başlayan bir isim koymamız yeterli. Master cihaz çevreyi tarayıp otomatik o cihazın MAC adresini alacaktır.

Alt Yazı

Eğer bu tarama işlemindense direk slave ( alıcı ) cihazımızın MAC adresini kodumuzun içine sabitlemek istiyorsak tek yapmamız gereken şey ” WiFi.macAddress(); “ kodunu alıcı cihazımızda çalıştırıp sonucunu seri monitöre yazdırmaktır. Bu sayede alıcı cihazımızın MAC adresini elde etmiş oluruz. Sonrasında o adresi “ esp_now_peer_info_t slave; ” kodunda slave değişkenine kaydedip yazarsak verici cihazımıza alıcı cihazın MAC adresini kaydetmiş oluruz.

Sonrasında “ esp_now_add_peer(&slave); ” koduna bakacak olursak burada da elde edip slave değişkenine kaydettiğimiz tüm alıcı bilgilerini bu komut ile ESP ağımızın içerisine entegre ediyoruz.

void loop(){
  esp_now_send(slave.peer_addr, &data, sizeof(data));
  data++;
  delay(1000);
}

“ esp_now_send ” fonksiyonu gerçekten göndermek istediğimiz verileri alıcıya gönderir. Bu yüzden ona “ slave.peer_addr ” kodu ile MAC adresini ve “ &data, sizeof(data) ” kodu ile de göndereceğimiz datayı ve datanın boyutunu vermemiz gerekir. Sonrasında “ data++; ” komutu ile data verisini “ delay( 1000 ); “ komutu ile bir bir arttıracağız.

Verici Kodunun Tamamı

#include <esp_now.h>
#include <WiFi.h>

//kanal belirliyoruz alıcı ve verici aynı kanalda olmalı 
#define CHANNEL 1

//Alıcının MAC adresini esp_now_peer_info yapısına tanıttığımız kod
esp_now_peer_info_t slave;
//göndermek istediğimiz veri
uint8_t data=0; 

void setup ()
{
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  esp_now_init();
  esp_now_register_send_cb(OnDataSent);
  ScanForSlave();
  esp_now_add_peer(&slave);
}

void loop(){
  esp_now_send(slave.peer_addr, &data, sizeof(data));
  data++;
  delay(1000);
}


//CallBack fonksiyonu
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status ) {
  Serial.print("Datayı gönderdim->");
  Serial.println(data);

}
void ScanForSlave() 
{
  int16_t scanResults = WiFi.scanNetworks(); // Scan only on one channel
  
    for (int i = 0; i < scanResults; ++i) 
    {
      // Print SSID and RSSI for each device found
      String SSID = WiFi.SSID(i);
      String BSSIDstr = WiFi.BSSIDstr(i);

      // Check if the current device starts with `Slave`
      if (SSID.indexOf("RX") == 0) 
      {
        int mac[6];
        if ( 6 == sscanf(BSSIDstr.c_str(), "%x:%x:%x:%x:%x:%x",  &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5] ) ) {
          for (int ii = 0; ii < 6; ++ii ) {
            slave.peer_addr[ii] = (uint8_t) mac[ii];
          }
        }

        slave.channel = CHANNEL; // pick a channel
        slave.encrypt = 0; // no encryption

        break;
      }
    }
}

Evet. Master kodumuzun sonuna geldik. Çok şey oluyormuş gibi duruyor ama gördüğünüz üzere anlaşılmayacak bir kod değil. Şimdi alıcı kodunu inceleye başlayalım.

Alıcı Kodu

Alıcı kodunun tamamı

#include <esp_now.h>
#include <WiFi.h>

#define CHANNEL 1 


void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_AP);
  WiFi.softAP("RX_1","RX_1_Password",CHANNEL, 0);

  esp_now_init();
  esp_now_register_recv_cb(OnDataRecv);

}

void loop() {

}

void OnDataRecv(const uint8_t *mac_addr, const uint8_t *data, int data_len){
  Serial.print("Bir veri aldım->");
  Serial.println(*data);
}

İşte alıcı kodumuz. Ne kadar kısa değil mi? Hepsi bu kadar. Kodumuzun başlangıcında tıpkı vericideki gibi sonrasında alıcımızı vericimizdeki gibi “ #define CHANNEL 1 ” kodu ile aynı kanada ayarlıyoruz.

Sonrasında Setup fonksiyonundaki “ WiFi.mode(WIFI_AP); ” fonksiyonu ile alıcımızı AP moduna alıyoruz.

Sonrasında “ WiFi.softAP(“RX_1″,”RX_1_Password”,CHANNEL 0); ” kodu ile AP modunu yapılandırıyoruz. Kodumuzun içerisindeki “RX_1” kısmını vericimizin arayacağı bir şeye ayarlamamız gerekiyor. Hatırlarsanız vericimizdeki “ ScanForSlave() ” kodu sayesinde alıcıların MAC adresini almadan sadece WiFi isimlerinin ilk karakterleri ile alıcılarımızın MAC adreslerini elde edebiliyorduk. Verici baş harfleri RX olan isimleri arayacak. Biz de alıcımızın ismini RX_1 koyduk. Bu sayede verici alıcıyı kolay bir şekilde bulabiliyor.

Sonrasında ise “ esp_now_init(); ” kodu ile ESP-NOW protokolünü başlatıyoruz.

Sonrasında ise “ esp_now_register_recv_cb(OnDataRecv) ” fonksiyonu ile bir Receive Callback ( alıcı geri arama ) fonksiyonu başlatıyoruz. Bu kod alıcı her vericiden veri aldığında çalışacaktır. Bu yüzden OnDataReceive fonksiyonuna bir göz atalım.

void OnDataRecv(const uint8_t *mac_addr, const uint8_t *data, int data_len){
  Serial.print("Bir veri aldım->")
  Serial.print(*data);
}

OnDataRecv fonksiyonuna baktığımızda üç parametre görmekteyiz. İlki “ const uint8_t*mac_addr ” kodu. Bu kod sayesinde fonksiyona alıcımızın MAC adresini tanımlıyoruz. Sonrasında bir data değişkeni tanımlayıp içerisine gelen verilerimizi yazdırıyoruz.

Evet, Kod kısmını bitirdik. Şimdi ise test edelim.

4. Test Kısmı

Bir cihazımızı alıcı, diğer cihazımızı verici olarak seçiyoruz. Daha sonrasında yazdığımız alıcı kodunu seçtiğimiz alıcı cihazına, verici kodunu ise seçtiğimiz verici cihazına yüklüyoruz.

Daha sonra alıcı kodunu ise alıcı cihaza yüklüyoruz. ( Fotoğraf 1.1 )

Sonrasında iki ESP32 kartına da Reset attıktan sonra ayrı Arduino IDE programlarında kartları seri monitöre bağlıyoruz. ( Fotoğraf 1.3 )

Ve evet ! Gördüğünüz gibi verici cihazımız saniyede bir data verisini gönderirken alıcı cihazımız ise o veriyi alıyor. Bugünkü yazımızda ESP-NOW protokolünü inceledik ve kullanabileceğimiz minimum gereklilikteki kodları kullanarak basitçe ESP-NOW arayüzünü inceledik. Bir sonraki yazımızda bu kodumuzu geliştirerek basit bir haberleşme projesi gerçekleştireceğiz. Aşağıdaki linkten o yazıma ulaşabilirsiniz.

📡 Yeni Başlayanlar için ESP-NOW yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

İnternette hemen hemen hepimiz bir tablanın üstüne bir top bırakıldığında neresinden bırakılırsa bırakılsın motorları sayesinde hemen topu merkezine alıp dengede durmasını sağlayan top dengede tutan robot projelerine denk gelmişizdir. İzlemesi son derece keyifli ve kafamızda hep “ Acaba nasıl üretiliyor, ben de yapabilir miyim ki ? ” sorularını getiriyor. Sizin de kafanıza bu tarz sorular geliyorsa, gerçek toplar ve gerçek sistemler kadar olmasa da dijital top nasıl dengede tutabileceğinizi merak ediyor ve çevrenizi etkilemek istiyorsanız gelin projemizi yapmaya başlayalım.

Fotoğraftan da anlaşılabileceği gibi ne kadar basit bir sistem değil mi ? Proje bir adet eksen sensörü sayesinde hareketi algılayıp 8×8 Dot Matrix Display ekranında hareketin tam tersi yönde dijital top hareket etmesini sağlıyor. Bu sayede dijital top sanki dijital bir ekranda dengede kalmaya çalışıyor.

Ne Kullanmam Gerekiyor ki ?

Projemiz için ihtiyacımız olan tüm malzemelerin listesi ;

• Arduino Uno: https://www.robo90.com/arduino-uno-r3-smd-klonch340-cipli-usb-kablo-hediyeli
• Max7219 8×8 Dot Matrix Display Modülü – Kırmızı: https://www.robo90.com/max7219-8×8-dot-matrix-display-modulu-kirmizi
• MPU6050 6 Eksen İvme ve Gyro Sensörü: https://www.robo90.com/mpu6050-6-eksen-ivme-ve-gyro-sensoru-gy-521
• 40lı Ayrılabilen Dişi-Erkek Jumper Kablo: https://www.robo90.com/40li-ayrilabilen-disi-erkek-jumper-kablo-20cm-arduino-uyu

Donanım kısmı

Önce 8×8 Max7219 8×8 Dot Matrix Display Modülümüzü Arduino Uno ile bağlantılarını yaparak başlayalım. ( Fotoğraf 1.0 )

Göründüğü gibi 8×8 matrix modülümüzün sırasıyla VCC, GND, DIN, CS, CLK pinleri bulunmakta. Biz bu projemizde bu pinlerimizi Arduinonun şu pinlerine bağladık;

• VCC = Arduinonun +5V pini
• GND = Arduinonun GND pini
• DIN = Arduinonun 12. pini
• CS = Arduinonun 11. pini
• CLK = Arduinonun 10. pini

Bu bağlantıları yaptıktan sonra MPU6050 6 Eksen İvme ve Gyro Sensörünü nasıl bağlayacağımıza geçelim. ( Fotoğraf 1.1 )

Göründüğü gibi MPU6050 6 Eksen İvme ve Gyro Sensörünün sırasıyla VCC, GND, SCL, SDA, XDA, XCL, AD0 ve INT pinleri bulunmakta. Biz projemiz için ilk 4 pin olan VCC, GND, SCL ve SDA pinlerini kullanacağız. Bu pinleri sırasıyla Arduinonun şu pinlerine bağladık;

• VCC = Arduinonun +5V pini
• GND = Arduinonun GND pini
• SCL = Arduinonun A5 pinine
• SDA = Arduinonun A4 pinine

Gerekli olan tüm bağlantıları sırasıyla yaptıktan sonra şimdi projenin çalışma mantığına bakalım.

Peki Nasıl Çalışıyor ?

Yazımızın başlarında da bahsettiğimiz gibi aslında Proje bir adet eksen sensörü sayesinde hareketi algılayıp 8×8 Dot Matrix Display ekranında hareketin tam tersi yönde dijital top hareket etmesini sağlıyor. Bu sayede dijital top sanki dijital bir ekranda dengede kalmaya çalışıyormuş gibi görünüyor. Eksen sensörünün sadece X ve Y ekseni için ürettiği verileri kullanıyoruz. Sensörümüzü X ekseni için her bir hareketinde +-10, Y ekseni için de +-10 değerlerini üretecek şekilde ayarlıyoruz. ( İleride kaynak kodu incelerken bu kısıma değineceğiz ) ( Fotoğraf 1.2 )

Göründüğü gibi eksen sensörü her yönde hareket ettirdiğimizde eğime bağlı olarak konumu değişiyor. ( Fotoğraf 1.3 )

Şimdi ise 8×8 Dot Matrix’imizi aşağıdaki fotoğrafta göründüğü gibi dört parçaya bölelim. ( Fotoğraf 1.4 )

Daha sonra bu bölgelere sırasıyla 1, 2, 3, 4 diyelim. Hatırlarsanız eksen sensörü x ve y ekseni için +-10 arasında değerler üretiyordu. Bu yüzden ızgaranın eksenleri kestiği her bir noktayı sayısal parçalara ayırabiliriz ( -5, -2.5, -0, 2.5, 5 gibi ) Bu sayede her bir 64 farklı LED’in konumunu bulabiliriz. ( Fotoğraf 1.5 )

Yukarıdaki resme bakarak her bir LED’in konumunu ve bölgesini rahatlıkla söyleyebiliriz. Mesela 1. satır 2. sütundaki LED’in konumu için -7.5<x<-5 ve 7.5<y<10 , 2. bölgede diyebiliriz.

Hatırlarsanız eksen sensörümüz x ve y ekseni için +- 10 arasında değerler üretiyordu. Yani ben sensörüme doğru eğimi verirsem -7.5<x<-5 ve 7.5<y<10 arasında bir değeri tutturabilirim ve eğer bir if komutu yazıp -7.5<x<-5 ve 7.5<y<10 arasında 1. satır 2. sütundaki LED’ i aç dersem doğru eğimde 8×8 Dot Matrix modülünde o LED açılacaktır.

Peki ya eksen sensörü -7.5<x<-5 ve 7.5<y<10 arasındaki değerleri üretirken 1. satır 2. sütunun başlangıç noktası 0’ a göre aynalarsam ne olur ? Konum 8. satır ve 7. sütun olur. Peki o konumdaki LED’in yanmasını istersem ? İşte bu ! Benim eksen sensörümün tam tersi konumunda topumuz hareket ediyor. Asla düşürülemez dijital bir top !

Tabi ki de düşürebiliriz. Topumuzun ekrandan düşmemesi için bir çerçeve yaparsak eğer if-else sayımız 32’den 25’e düşer. Bu sayede 25 farklı ihtimali kodlarsak Ne olursa olsun düşüremeyeceğimiz bir dijital top yapmış oluruz. ( Fotoğraf 1.6 )

Projenin Yazılımı Nasıl Çalışır ?

Gerekli olan kütüphaneleri programımızın içine yazıyoruz.

#include "LedControl.h"
#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>

Setup kısmında ise hem 8×8 Dot Matrix ekranı hem de MPU-6050 sensörü için gerekli olan kurulum kodlarını yazıyoruz.

void setup() {
  Serial.begin(115200);
  while (!Serial)
    delay(10); // will pause Zero, Leonardo, etc until serial console opens

  Serial.println("Adafruit MPU6050 test!");

  // Try to initialize!
  if (!mpu.begin()) {
    Serial.println("Failed to find MPU6050 chip");
    while (1) {
      delay(10);
    }
  }
  Serial.println("MPU6050 Found!");

  mpu.setAccelerometerRange(MPU6050_RANGE_8_G);
  Serial.print("Accelerometer range set to: ");
  switch (mpu.getAccelerometerRange()) {
  case MPU6050_RANGE_2_G:
    Serial.println("+-2G");
    break;
  case MPU6050_RANGE_4_G:
    Serial.println("+-4G");
    break;
  case MPU6050_RANGE_8_G:
    Serial.println("+-8G");
    break;
  case MPU6050_RANGE_16_G:
    Serial.println("+-16G");
    break;
  }
  mpu.setGyroRange(MPU6050_RANGE_500_DEG);
  Serial.print("Gyro range set to: ");
  switch (mpu.getGyroRange()) {
  case MPU6050_RANGE_250_DEG:
    Serial.println("+- 250 deg/s");
    break;
  case MPU6050_RANGE_500_DEG:
    Serial.println("+- 500 deg/s");
    break;
  case MPU6050_RANGE_1000_DEG:
    Serial.println("+- 1000 deg/s");
    break;
  case MPU6050_RANGE_2000_DEG:
    Serial.println("+- 2000 deg/s");
    break;
  }

  mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);
  Serial.print("Filter bandwidth set to: ");
  switch (mpu.getFilterBandwidth()) {
  case MPU6050_BAND_260_HZ:
    Serial.println("260 Hz");
    break;
  case MPU6050_BAND_184_HZ:
    Serial.println("184 Hz");
    break;
  case MPU6050_BAND_94_HZ:
    Serial.println("94 Hz");
    break;
  case MPU6050_BAND_44_HZ:
    Serial.println("44 Hz");
    break;
  case MPU6050_BAND_21_HZ:
    Serial.println("21 Hz");
    break;
  case MPU6050_BAND_10_HZ:
    Serial.println("10 Hz");
    break;
  case MPU6050_BAND_5_HZ:
    Serial.println("5 Hz");
    break;
  }

  Serial.println("");
  delay(100);


  /*
   The MAX72XX is in power-saving mode on startup,
   we have to do a wakeup call
   */
  lc.shutdown(0,false);
  /* Set the brightness to a medium values */
  lc.setIntensity(0,8);
  /* and clear the display */
  lc.clearDisplay(0);
}

Sonrasında ekranda topun tüm konumlarının LCD için kütüphanesini yazıyoruz.

void middle() {
  /* here is the data for the characters */
  
  byte ball[8]={B11111111,B10000001,B10000001,B10011001,B10011001,B10000001,B10000001,B11111111};
  /* now display them one by one with a small delay */
  
  lc.setRow(0,0,ball[0]);
  lc.setRow(0,1,ball[1]);
  lc.setRow(0,2,ball[2]);
  lc.setRow(0,3,ball[3]);
  lc.setRow(0,4,ball[4]);
  lc.setRow(0,5,ball[5]);
  lc.setRow(0,6,ball[6]);
  lc.setRow(0,7,ball[7]);
  lc.setRow(0,8,ball[8]);
  
  lc.setRow(0,0,0);
  lc.setRow(0,1,0);
  lc.setRow(0,2,0);
  lc.setRow(0,3,0);
  lc.setRow(0,4,0);
  lc.setRow(0,5,0);
  lc.setRow(0,6,0);
  lc.setRow(0,7,0);
  lc.setRow(0,8,0);
  
}

Bu sadece dijital top orta kısımda olduğu ve çevçevenin kodlandığı durum. ( Fotoğraf 1.7 )

Sonrasında ana void loop fonksiyonunda 25 farklı durum için 25 tane if kodluyoruz. Bu İf-Else yapılarının tamamını kodun tamamında bulabilirsiniz.

//y ekseni if-else
  if ( a.acceleration.x<=2.5 && a.acceleration.x>=-2.5 && a.acceleration.y<=5 && a.acceleration.y>=2.5 ){
    middletop1();
  }
  if ( a.acceleration.x<=2.5 && a.acceleration.x>=-2.5 && a.acceleration.y<=7.5 && a.acceleration.y>=5 ){
    middletop2();
  }
  
  if ( a.acceleration.x<=2.5 && a.acceleration.x>=-2.5 && a.acceleration.y<=0 && a.acceleration.y>=-2.5 ){
    middlebottom1();
  }
  if ( a.acceleration.x<=2.5 && a.acceleration.x>=-2.5 && a.acceleration.y<=-2.5 && a.acceleration.y>=-5 ){
    middlebottom2();
  }
  
  //y ekseni if bitiş 

Kodun tamamı ;

Bu projemizde de çevrenize gösterdiğiniz zaman gülümsetecek, insanların şaşıracağı, çözümlerinin de anlaşılmasının da oldukça basit olduğu dengede duramayan dijital top projesini inceledik. Bu tarz çevrenizi şaşırtacak veya bakış açınızı genişletecek başka projeler arıyorsanız aşağıdaki projelerimi inceleyebilirsiniz.

Yazının başındaki fotoğraf https://www.youtube.com/watch?v=tPr6-Rh0m-8 videosundan alınmıştır

Dengede Duramayan Dijital Top Nasıl Yapılır? ⚖️ yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

Günümüzde 3D yazıcılar artık neredeyse herkesin erişebileceği bir seviyeye geldi . Evimizden ofisimize, mesleki hayatımızdan hobilerimize, gerek yedek parçası zor bulunan bir ürünün yedek parçasını tasarlayıp basmaya kadar artık hayatımızın her yerindeler ve hayatımızı kolaylaştırıyorlar. Biz de ofisimizde bir çok 3D printer markasıyla baskılar alıyor ve kendi işlerimiz için kullanıyoruz. Ancak yaşadığımız sorunlardan bir tanesi uzun süreli baskılarda bazen baskılar bozuk çıkabiliyor ve bu durum bazen yetiştirmemiz gereken uzun süreli baskılarda can sıkıcı durumlara yol açabiliyor. Bunun yanında harcadığımız filament ve elektrik de zaman ve para kaybı. Bugün bütün bu sorunların önüne geçebilecek bir projeyi inceleyeceğiz.

Daha önceki ESP32 ile Yerel Ağdan Genel Ağa ( LAN to WAN ) adlı yazımızda ESP32 CAM modülünü ve Ngrok’u kullanarak nasıl LAN’daki ( yerel ağ ) verimizi nasıl WAN’a ( Genel ağ ) taşıyabileceğimizden bahsetmiştik ve ESP32-CAM modülünden gelen kamera görüntülerini canlı yayın gibi telefonumuzdan veya bilgisayarımızdan izlemiştik. Bu yazımızda ise tekrar ESP32-CAM modülü, Ngrok ve bir 5V röle modülü kullanarak istediğimiz zaman 3D yazıcımızın çıktı alırken fotoğrafını çekebilen ve röle modülü sayesinde yazıcının gücünü kesip baskıyı durdurabilen bir proje yapacağız. Bu proje sayesinde filamentleriniz, elektriğiniz ve en önemlisi de zamanınız boşa gitmeyecek.

Ne Kullanmam Gerekiyor ki ?

ESP32-CAM Wifi Bluetooth Geliştirme Kartı ve OV2640 Kamera Modülü: https://www.robo90.com/esp32-cam-wifi-bluetooth-gelistirme-karti-ve-ov2640-kamera-modulu

5V Röle Kartı – 1 Kanal: https://www.robo90.com/5v-role-karti-1-kanal

6×12.5 cm Delikli Pertinaks – Prototip PCB: https://www.robo90.com/6×125-cm-delikli-pertinaks-prototip-pcb

BC337 NPN Transistör – BJT – TO-92: https://www.robo90.com/bc337-npn-transistor-bjt-to-92

4.7kOhm ve 220Ohm direnç: https://www.robo90.com/4-7k-direnc-paketi-1-4-w-10-adet

https://www.robo90.com/220r-direnc-paketi-1-4-w-10-adet

İnce bakır kablo ve jumper: https://www.robo90.com/40li-ayrilabilen-disi-erkek-jumper-kablo-20cm-arduino-uyumlu

DC Jack-Jak Modülü 5.5mm: https://www.robo90.com/dc-jack-jak-modulu-5

5V 2A Adaptör: https://www.robo90.com/5v-2a-adaptor

Elektronik Breadboard – Orta Boy – 400 Pin: https://www.robo90.com/elektronik-breadboard-orta-boy-400-pin

Not

Ürün listesi biraz uzun görünebilir. Ancak projeyi sıfırdan son haline getirene kadar kullandığım bütün malzemeler listede yer almakta.

Yazılım Kısmı

İhtiyacımız olan Kütüphaneler

ESP32 Kütüphanesi: ESP32’ye program nasıl yazılır adlı blog yazımda ESP32’nin kütüphanesinin nasıl kurulacağından bahsetmiştim. Aşağıdaki linkten ulaşabilirsiniz.

ESP32 ‘ye Program Nasıl Yazılır?

ESPAsyncWebServer Kütüphanesi: ESP32 kütüphanesi dışında ESPAsyncWebServer kütüphanesini de Arduino IDE’mize kurmamız gerekir. Aşağıdaki GitHub linkinden Kütüphaneye ulaşabilirsiniz.

https://github.com/me-no-dev/ESPAsyncWebServer

Bilmeyenler için alt yazı;

Linkteki GitHub sayfasından kütüphaneyi nasıl indireceğinizi bilmiyorsanız sadece karşınıza çıkan ekrandan <> Code butonuna tıkladıktan sonra Download ZIP butonuna tıklamamız gerekir. Sonrasında kütüphanemiz ZIP dosyası şeklinde inecektir. ( Fotoğraf 1.0 )

Daha sonra Arduino IDE programının arayüzünden Sketch> Include Library > Add.ZIP Libraries kısmından indirdiğiniz ZIP kütüphanenizi dahil edebilirsiniz. ( Fotoğraf 1.1 )

Kodun Açıklamaları

Kodumuzun başlangıç kısmında ihtiyacımız olan kütüphaneler bulunmakta. Daha sonrasında ise ESP32-CAM modülünü bağlayacağımız internet ismimizi ve şifremizi sırasıyla ssid ve password kısmına yazmamız gerek.

ESP32-CAM sadece 2.4GHz internete bağlanabilir. 5GHz internetinize bağlanamaz. 5Ghz internetinize bağlamayı denerseniz ESP32-CAM modülü internete bağlanamayacaktır. Telefonunuzun mobil erişim noktasını paylaşıp ESP32-CAM modülünü bağlamayı deneyebilirsiniz ancak telefonunuzun da 2.4GHz internet Wi-Fi paylaşımı yaptığından emin olmanız gerek.

Daha sonra AsyncWebServer server(80); kodu ile 80. portta LAN’da bir Webserver kurmamızı sağlar. Bu sayıyı değiştirip istediğiniz portta Webserver açabilirsiniz.

Sonrasında ise ESP32-CAM modülümüzün kamerasının bağlanacağı pinler tanımlanmıştır.

#include "WiFi.h"
#include "esp_camera.h"
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "soc/soc.h"           
#include "soc/rtc_cntl_reg.h"  
#include "driver/rtc_io.h"
#include <ESPAsyncWebServer.h>
#include <StringArray.h>
#include <SPIFFS.h>
#include <FS.h>


const char* ssid = "****************";       //İnternet İsminiz (Örnek Mahmut_2.4GHz)
const char* password = "****************";   //İnternet Şifreniz 
int relay = 2;
int flash = 4;

AsyncWebServer server(80);

boolean takeNewPhoto = false;


#define FILE_PHOTO "/photo.jpg"


#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27
#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22

Not

Bu projede tanımlanan kamera pinleri CAMERA_MODEL_WROVER_KIT için tanımlanmıştır.

Kodumuzun bu kısmında ise Webserver’e tanımlayacağımız HTML kodlarımız bulunmakta. Bu kodun içerisinde ESP32-CAM modülüne çeşitli işler yaptırmamızı sağlayan butonlar ve modülümüze çektirdiğimiz fotoğraf bulunmakta.

const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML><html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <style>
    body { text-align:center; }
    .vert { margin-bottom: 10%; }
    .hori{ margin-bottom: 0%; }
  </style>
</head>
<body>
  <div id="container">
    <h2>ESP32-CAM Last Photo</h2>
    <p>It might take more than 5 seconds to capture a photo.</p>
    <p>
      <button onclick="rotatePhoto();">ROTATE</button>
      <button onclick="capturePhoto()">CAPTURE PHOTO</button>
      <button onclick="location.reload();">REFRESH PAGE</button>
      <button onclick="RELAYON();">RELAYON</button>
      <button onclick="RELAYOFF();">RELAYOFF</button>
      <button onclick="FLASHON();">FLASHON</button>
      <button onclick="FLASHOFF();">FLASHOFF</button>
    </p>
  </div>
  <div><img src="saved-photo" id="photo" width="70%"></div>
</body>
<script>
  var deg = 0;
  function capturePhoto() {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', "/capture", true);
    xhr.send();
  }

  function RELAYON() {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', "/RelayOn", true);
    xhr.send();
  }
  function RELAYOFF() {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', "/RelayOff", true);
    xhr.send();
  }
  function FLASHON () {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', "/FlashOn", true);
    xhr.send();
  }
  function FLASHOFF() {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', "/FlashOff", true);
    xhr.send();
  }

  function rotatePhoto() {
    var img = document.getElementById("photo");
    deg += 90;
    if(isOdd(deg/90)){ document.getElementById("container").className = "vert"; }
    else{ document.getElementById("container").className = "hori"; }
    img.style.transform = "rotate(" + deg + "deg)";
  }
  function isOdd(n) { return Math.abs(n % 2) == 1; }
</script>
</html>)rawliteral";

Kodumuzun setup kısmında ise Webserveri, kamera modülü ve HTML kodumuzda tanımladığımız butonlardan bildirim geldiği zaman ne yapacağını tanımlayan çeşitli komutlar bulunmakta.

Loop kısmında ise yeni bir fotoğraf çekildiği zaman capturePhotoSaveSpiffs(); fonksiyonunu çağıran bir komut bulunmakta. Bunların harici çekilen fotoğrafı modülün çalışmasını ve çekilen fotoğrafları hafızasına kaydetmesini sağlayan çeşitli fonksiyonlar mevcut.

//İhtiyacımız olan kütüphaneler 
#include "WiFi.h"
#include "esp_camera.h"
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "soc/soc.h"           
#include "soc/rtc_cntl_reg.h"  
#include "driver/rtc_io.h"
#include <ESPAsyncWebServer.h>
#include <StringArray.h>
#include <SPIFFS.h>
#include <FS.h>
//İnternet ismimiz,şifremiz ve röle modülünü bağlayacağımız pin tanımlaması bulunmakta. Modülün üzerindeki flash ise 4. pine bağlı. 
const char* ssid = "****************";       //İnternet İsminiz (Örnek Mahmut_2.4GHz)
const char* password = "****************";   //İnternet Şifreniz 
int relay = 2;
int flash = 4;
//Webserver'imizin hangi portta başlatacağımızı tanımlıyoruz.
AsyncWebServer server(80);
boolean takeNewPhoto = false;
//Modüle bağlayacağımız pin'lerin tanımlaması 
#define FILE_PHOTO "/photo.jpg"
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27
#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22
//Webserver'imize tanımlayacağımız çeşitli butonların ve çektiğimiz fotoğrafın ekrana gelmesini sağlayan HTML kodları 
const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML><html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <style>
    body { text-align:center; }
    .vert { margin-bottom: 10%; }
    .hori{ margin-bottom: 0%; }
  </style>
</head>
<body>
  <div id="container">
    <h2>ESP32-CAM Baskılarımız Yanmasın</h2>
    <p>Fotoğrafı çekmesi 5 saniyeden fazla sürebilir</p>
    <p>
      <button onclick="rotatePhoto();">ROTATE</button>
      <button onclick="capturePhoto()">CAPTURE PHOTO</button>
      <button onclick="location.reload();">REFRESH PAGE</button>
      <button onclick="RELAYON();">RELAYON</button>
      <button onclick="RELAYOFF();">RELAYOFF</button>
      <button onclick="FLASHON();">FLASHON</button>
      <button onclick="FLASHOFF();">FLASHOFF</button>
    </p>
  </div>
  <div><img src="saved-photo" id="photo" width="70%"></div>
</body>
<script>
  var deg = 0;
  function capturePhoto() {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', "/capture", true);
    xhr.send();
  }
  
  function RELAYON() {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', "/RelayOn", true);
    xhr.send();
  }
  function RELAYOFF() {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', "/RelayOff", true);
    xhr.send();
  }
  function FLASHON () {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', "/FlashOn", true);
    xhr.send();
  }
  function FLASHOFF() {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', "/FlashOff", true);
    xhr.send();
  }
  function rotatePhoto() {
    var img = document.getElementById("photo");
    deg += 90;
    if(isOdd(deg/90)){ document.getElementById("container").className = "vert"; }
    else{ document.getElementById("container").className = "hori"; }
    img.style.transform = "rotate(" + deg + "deg)";
  }
  function isOdd(n) { return Math.abs(n % 2) == 1; }
</script>
</html>)rawliteral";
//Bu kısımda kameramızı, Webserver'ımızı ve Webserverden gelen verilerin programımızda ne yapması gerektiği mevcut.
void setup() {
  Serial.begin(115200);
  //
  pinMode(relay, OUTPUT);
  pinMode(flash, OUTPUT);
  digitalWrite(relay,LOW);
  digitalWrite(flash,LOW);
  //
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
  if (!SPIFFS.begin(true)) {
    Serial.println("An Error has occurred while mounting SPIFFS");
    ESP.restart();
  }
  else {
    delay(500);
    Serial.println("SPIFFS mounted successfully");
  }
  
  Serial.print("IP Address: http://");
  Serial.println(WiFi.localIP());
  
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
 
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;
  if (psramFound()) {
    config.frame_size = FRAMESIZE_UXGA;
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }
  
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    ESP.restart();
  }
  
  server.on("/", HTTP_GET, [](AsyncWebServerRequest * request) {
    request->send_P(200, "text/html", index_html);
  });
  server.on("/capture", HTTP_GET, [](AsyncWebServerRequest * request) {
    takeNewPhoto = true;
    request->send_P(200, "text/plain", "Taking Photo");
  });
  server.on("/saved-photo", HTTP_GET, [](AsyncWebServerRequest * request) {
    request->send(SPIFFS, FILE_PHOTO, "image/jpg", false);
  });
  
  server.on("/FlashOn", HTTP_GET, [](AsyncWebServerRequest * request) {
  digitalWrite(flash, HIGH);
  Serial.print("flash on ");
  
  request->send(200, "text/plain", "Flash açıldı");
  });
  server.on("/FlashOff", HTTP_GET, [](AsyncWebServerRequest * request) {
  digitalWrite(flash, LOW);
  Serial.print("flash OFF ");
  request->send(200, "text/plain", "Flash kapatıldı");
  });
  server.on("/RelayOn", HTTP_GET, [](AsyncWebServerRequest * request) {
  digitalWrite(relay, HIGH);
  request->send(200, "text/plain", "Röle Açıldı");
  });
  server.on("/RelayOff", HTTP_GET, [](AsyncWebServerRequest * request) {
  digitalWrite(relay, LOW);
  request->send(200, "text/plain", "Röle Kapatıldı");
  });
  
  server.begin();
  
  
}
//Yeni bir fotoğraf çekildiğinde fotoğrafı kaydetmesini sağlayan kod
void loop() {
  if (takeNewPhoto) {
    capturePhotoSaveSpiffs();
    takeNewPhoto = false;
  }
  delay(1);
}
bool checkPhoto(fs::FS &fs) {
  File f_pic = fs.open(FILE_PHOTO);
  unsigned int pic_sz = f_pic.size();
  return (pic_sz > 100);
}
//fotoğrafı modülümüze kaydetmemizi sağalyan fonksiyon
void capturePhotoSaveSpiffs(void) {
  
  
  camera_fb_t * fb = NULL; 
  bool ok = 0; 
  do {
    
    Serial.println("Taking a photo...");
    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      return;
    }
    
    Serial.printf("Picture file name: %s\n", FILE_PHOTO);
    File file = SPIFFS.open(FILE_PHOTO, FILE_WRITE);
    
    if (!file) {
      Serial.println("Failed to open file in writing mode");
    } else {
      file.write(fb->buf, fb->len); 
      Serial.print("The picture has been saved in ");
      Serial.print(FILE_PHOTO);
      Serial.print(" - Size: ");
      Serial.print(file.size());
      Serial.println(" bytes");
    }
    
    file.close();
    esp_camera_fb_return(fb);
    
    ok = checkPhoto(SPIFFS);
  } while (!ok);
}

Not

ESP32-CAM modülüne yazılım atarken IO0 pini GND’ye bağlanmalıdır. Bu sayede modül nasıl ESP32’ye yazılım yüklerken butona basıyorsak bu modülde de IO0 pini grounda bağlanmalıdır. ( Fotoğraf 1.2 )

ESP32-CAM modülüne nasıl yazılım yükleyebileceğimizi merak ediyorsanız ESP32-CAM ile Yemekleriniz Yanmasın yazımızı inceleyebilirsiniz. Bu blog yazısında nasıl yazılım yükleneceğine, ESP32 kütüphanesinin nasıl kurulabileceğine değinilmemiştir.

Sonrasında kodumuzu yüklemeye başlayabiliriz. Kodun nasıl yükleneceğine ve yüklenirken nelere dikkat edileceğine ESP32-CAM ile Yemekleriniz Yanmasın adlı blog yazımda bahsetmiştim. Kodu derleyip ESP32-CAM modülümüzün içerisine başarıyla yükleyebilirseniz Serial Monitor’de karşınıza LAN’daki IP adresi gelecektir. ( Fotoğraf 1.3 )

Ve evet. Projemizin yerel ağdaki hali hazır. Buraya kadar geldiyseniz test etmek için çıkan http linkini tarayıcına kopyalayıp WebServer üzerinden ESP32-CAM modülünün üzerindeki Flash LED’ini kontrol edebilirsiniz. ( Fotoğraf 1.4 )

Daha sonra ESP32 ile Yerel Ağdan Genel Ağa ( LAN to WAN ) blog yazısında bahsettiğimiz gibi çıkan IP adresi Ngrok’a girip yerel ağdaki projemizi genel ağa taşıyoruz. Bu sayede gerek ofisimizde gerek evimizde 3D printerin yanında olmamıza gerek olmadan istediğimiz yerden 3D printerin fotoğrafını çekebilir, ışık olmasa bile ESP32-CAM modülü üzerindeki flash’ı yakabilir. Çektiğimiz fotoğrafları kaydedebilir, röle modülü sayesinde 3D printermizi kapatabileceğiz.

Donanım Kısmı

Bağlantı Şemaları

Bu kısma kadar gelebilmeyi başardıysanız işin %80’ini halletmişsiniz demektir. Çünkü önemli olan ESP32-CAM modülünün pin bacaklarını kontrol edebilmemizdir. Sonrasında tek yapmamız gereken röle sürmek ve sistemi toplamaktır. Röle sürme konusunda şöyle bir problemimiz var. ESP32-CAM modülümüz pinlerinden 3.3V çıkış verebiliyor ancak süreceğimiz röle 5V olduğundan aradaki 2.7V’luk voltaj farkından dolayı röleyi açıp kapatamıyoruz. Bunun önüne geçmek için transistörlü bir sürme devresi kullanıyoruz. Transistörlü sürme devresinin ne olduğunu anlamadıysanız endişelenmenize gerek yok. Çok basit. Aşağıda tüm sistemin açıklamasında bahsedeceğiz.

Alt yazı ( Not Gate )

Transistörlü NOT kapısı, bir elektronik devredir. Bu devre, giriş sinyalini tersine çevirir. Örneğin, devreye “0” verirseniz, devreden “1” çıkar. Devreye “1” verirseniz, devreden “0” çıkar.

Bu devrede, bir transistör kullanılır. Transistör, bir anahtar görevi görür. Anahtarın bir tarafına enerji verirseniz, diğer tarafından enerji akışı sağlanır. Devrenin girişindeki enerjiyi bu anahtar sayesinde tersine çeviriyoruz.

Bu şekilde, transistörlü NOT kapısı, giriş sinyalini tersine çevirir ve bize yeni bir sinyal verir. Bu sinyali kullanarak başka cihazları kontrol edebiliriz.

Fotoğraftan da anlaşılabileceği üzere girişten ( Input ) kısmından 5V verirsek transistör iletime geçeceği için çıkış ( Output ) transistör üstünden toprağa gider. Eğer giriş 0V olursa transistör iletime geçemeyeceği için çıkışta direk Vcc voltajı yani 5V görünür. ( Fotoğraf 1.5 )

Peki neden Değil kapısı ( NOT gate ) kullandık ? Donanım kısmı başlığının ilk yazısında bahsettiğimiz gibi 5V’luk bir röleyi 3.3V ile süremiyoruz ama transistörün base kısmı 0.7V ile tetikleyerek rölenin IN pinine giren voltajı 5V ile kontrol edebiliriz. Ayrıca Röle IN pinine 0V verdiğimiz zaman anahtar kapanır iletken olur, 5V verdiğimiz zaman anahtar açılır yani yalıtkan olur. Yani ters bir anahtarmış gibi çalışır. Biz de tekrar bir değil kapısı kurarak röleyi normal bir anahtara çevirdik. Ne kadar mantıklı değil mi. Değilin değilini aldık yani. Artık IO2 pinini etkinleştirdiğimizde Röle kapanır yani iletken olur. IO2 pinini kapattığımızda da röle açılır yani yalıtkan olur. Bu sayede internet arayüzü üzerinden 3D printerlarımızı kontrol edebiliriz. Şimdi önce devreyi Breadboard’da kuralım. Daha sonrasında Pertinaks’a devreyi nasıl daha kompak kurabileceğimizi inceleyelim.

Peki neden 5V 1-2A’lik bir adaptör kullanıyoruz ? Bilgisayarımızın USB portu projeyi çalıştıramaz mı ? Tasarladığımız sistem Güç kaynağından da anlaşılabileceği gibi tüm sistemleri devredeyken ( Flash, röle, fotoğraf çekme ) 0.4-0.5A çekiyor. Eğer kartı yeterli bir güç ile besleyemezseniz sistemin flashı titremeye başlar ve kart otomatik olara kapanır, kendisine reset atar ve sisteme yeniden bağlanır. Eğer yeterli bir kaynak ile beslemezseniz 3D printerinizi gece yarısı kontrol ederken flashı açıp fotoğraf çekerken kart bir anda kendisine reset atabilir ve eğer 3D printerinizin güç gidip geldiğinde çıktı almaya devam etmesi gibi bir özelliği yoksa çıktınız yarım kalacaktır. Ancak yeterli bir kaynak ile beslerseniz bu sorun ortadan kalkacaktır. ( Fotoğraf 1.6 )

BreadBoard Kurulumu

Önce DC-DC Jack modülümüze kullanacağımız kaynaktan gücümüzü veriyoruz. Ben laboratuvar tipi bir güç kaynağı kullandım. Yukarıda da uyardığım gibi tasarımımızın voltajı 5V ve çekeceği akım maksimum 0.5A oluyor. Bu durumda harici bir adaptörle besleyecekseniz dikkat etmeniz gerekir. ( Fotoğraf 1.7 )

Sonrasında DC jack’ımızı BreadBoard’ımızın artı ve eksi hattına takıyoruz. ( Fotoğraf 1.8 )

Sonrasında Değil kapımızın bağlantılarını yapabiliriz. ( 4.7kOhm’luk direnç 5V’a bağlı ) ( Fotoğraf 1.9 )

Daha sonra ESP32-CAM modülümüzün 5V pinini BreadBoard’ın artı hattına, GND pinini ise BreadBoard’ın eksi hattına takıyoruz. Burada dikkat etmemiz gereken en önemli şey ESP32-CAM modülünün 5V ve GND bacaklarını karıştırıp ters bağlamaktır. Bunu yaparsanız ESP32-CAM modülünüzü bozabilirsiniz. Birkaç defa kontrol ederek gerekli önleminizi alabilirsiniz. ( Fotoğraf 2.0 )

Sonrasında 5V’luk röle modülümüzün güç bağlantılarını yapıyoruz. ( 5V→Vcc, GND→GND ) ( Fotoğraf 2.1 )

Sonrasında Rölenin IN bacağını Transistörün Collectör bacağına bağlıyoruz. 1. Yeşil yol ( IN→Transistörün Collectörü ) ( Fotoğraf 2.2 )

Sonrasında ESP32-CAM modülünün IO2 numaralı pinini Transistörün base kısmına bağlı olan 220 ohm’luk dirence bağlıyoruz. ( 2.Yeşil yol ) ( Fotoğraf 2.3 )

Son olarak transistörün Emitter bacağını BreadBoard’ımızın GND ( Toprak ) hattına bağlıyoruz. ( Siyah olan kablo ) ( Fotoğraf 2.4 )

Ve evet! Sistemimiz hazır. Şimdi test zamanı. Gördüğünüz gibi CAPTURE PHOTO butonuna basarsam kamera nereye bakıyorsa oranın fotoğrafını çeker. Birkaç saniye sonra REFLESH PAGE butonuna basarsam sayfa yenilenir ve çektiğimiz fotoğraf karşımıza çıkar. Fotoğraftan da anlaşılabileceği üzere röle modülü kapalı. LED’i yanmıyor. Şimdi RELAYON butonuna basıp rölemizi aktifleştirelim. Sonrasında ise tekrar rölemizin bir fotoğrafını çekelim. Sonra sayfayı yenileyip rölenin ışığının yanıp yanmadığına bakalım. ( Fotoğraf 2.5 )

Gördüğünüz gibi rölemizi aktifleştirmeyi başardık. ( Fotoğraf 2.6 )

Şimdi sistemimizi yazının başındaki gibi Pertinaks’a nasıl aktarabiliriz onu inceleyelim.

Pertinaks

Fotoğraflardan da anlaşılabileceği gibi aslında yaptığımız tek şey Breadboard üzerindeki kabloları pertinaks ile birleştirmek oldu. Ancak röle ve DC Jack modüllerinin pinlerini söküp aşağıya doğru kaydıramayabilirsiniz. Bunun yerine bu iki modülü pertinaksa yapıştırıp bir kablo yardımıyla iki modülün pinlerini de pertinaksın deliklerinden geçirebilirsiniz. ( Fotoğraf 2.7 )

Test Edelim

Fotoğraftan da anlaşılabileceği gibi test düzeneğimizi kurduk. Ben Pertinaksa kurduğum devremi bir Üçüncü El Mercekli Elektronik PCB-Kart Tutucuya sabitledim. Daha sonra ofiste bir mini bilgisayarda Ngrok açarak projenin LAN adresini oraya girdim. Bu sayede evimden de ofisteki kamera modülüne erişebilirdim. İlk fotoğrafımı çekerek teste başladım. ( Fotoğraf 2.8 )

Sonrasında eve gittim ve biraz zaman geçmesini bekledim. Bir süre sonra röle modülü testi için röleyi kapatarak 3D printeri kapatıp evden işlemi durdurdum ve tekrar fotoğraf çektim. ( Fotoğraf 2.9 )

Göründüğü üzere modül kapanmış, baskı durmuştu. Ertesi gün ofise geldiğimde şöyle bir görüntüyle karşılaştım. ( Fotoğraf 3.0 )

Testlerim sonucunda sabah sadece ESP32-CAM modülünün biraz fazla ısındığını gördüm. Bunun önüne biraz olsun geçebilmek için Rasberry Pi modüllerinin soğutucu bloklarından kullanmaya karar verdim. Bu bloğu kamera modülün altındaki ESP32 işlemcisinin metal yüzeyine yapıştırdım. Bu sayede biraz olsun koruma sağlayabilecektim. ( Fotoğraf 3.1 )

Alüminyum Soğutucu Blok Seti – Rasberry Pi 4B Uyumlu: https://www.robo90.com/aluminyum-sogutucu-blok-seti-rasberry-pi-4b-uyumlu

Görüldüğü üzere test başarıyla tamamlanmış. Projenin çalıştığını ispatlamıştım. Bu sayede artık aklım baskılarımda kalmayacak, elektriğim ve filamentlerim boşa gitmeyecekti.

Bu yazımızda ESP32-CAM modülü, nesnelerin interneti, Webserver, pertinaks ile prototip tasarımı, yazılım, donanım alanları gibi bir sürü konu öğrendik. Tüm bu öğrendiğiniz bilgilerle neler yapabileceğinizi ekrandan biraz uzaklaşıp hayal edin. Geliştirebileceğiniz projeleri, CV’nize katabilecekleri artıları. Bu projeyi yaparak çevrenizdeki insanlara araştırarak, uğraşarak bir şeyleri başarabileceğinizi de ispatlayabilir, saygınlık toplayabilirsiniz. Bir sonraki yazımızda görüşmek üzere.

ESP32-CAM ile Baskılarınız Yanmasın 📛 yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

ESP32-CAM ile Yemekleriniz Yanmasın

İhtiyaç Listesi

ESP32-CAM Wifi Bluetooth Geliştirme Kartı ve OV2640 Kamera Modülü: https://www.robo90.com/esp32-cam-wifi-bluetooth-gelistirme-karti-ve-ov2640-kamera-modulu

40lı Ayrılabilen Dişi-Dişi Jumper Kablo – 20cm – Arduino Uyumlu: https://www.robo90.com/40li-ayrilabilen-disi-disi-jumper-kablo-20cm-arduino-uyum

FT232RL FTDI USB-TTL Dönüştürücü-Programlayıcı: https://www.robo90.com/ft232rl-ftdi-usb-ttl-donusturucu-programlayici

Not

Tüm bu ihtiyaç listesindeki ürünlerin nasıl bağlanacağı yukarıda linkini bıraktığım “Yemekleriniz Yanmasın” adlı blog yazımda mevcut.

Ngrok programı aslında basitçe tanımlamak gerekirse açık olduğu bilgisayarı bir Webserver’a çevirir. Nasıl oyunları online oynayabilmek için oyunların Serverlarına ihtiyacımız varsa, ESP32-CAM modülüne de istediğimiz her yerden ulaşabilmek için bir servera ihtiyacımız var. Daha önceki yazılarımda incelediğim ESP32 ve IOT blog yazımda Arduino IOT serverlarını kullanarak ESP32’mizi kontrol ediyorduk. Bu tarz başka platformlar da var ( Ör. 000WebHost, Bylnk vs ) ancak canlı yayın özelliği fazla veri tükettiği için genellikle bu özellikler paralı oluyor. Bunun önüne geçmek için kullanmadığınız bir bilgisayarınız, bir Raspberry Pi modülünüz veya kendi bilgisayarınızı bir servera dönüştürüp yerel ağdaki video canlı yayınınıza istediğiniz yerden ulaşabilirsiniz. Şimdi o zaman sırasıyla Windows bir bilgisayara Ngrok’u kurup yerel ağdaki verimizi genel ağa taşıyalım.

Ngrok Nasıl Kurulur ?

Aşağıdaki Linkten Ngrok’un sitesine gidebilirsiniz. Sonrasında ise üye olmamız gerekiyor. ( Fotoğraf 1.0 )

https://ngrok.com/

Daha sonra Getting Started kısmından Ngrok’u Windows için indirmeniz gerekir. Daha sonra Getting Started kısmından Ngrok’u Windows için indirmeniz gerekir. ( Fotoğraf 1.1 )

Daha sonra inen ZIP dosyasını klasöre çıkartmanız gerekmektedir. ( Fotoğraf 1.2 )

Zaten çıkardığınız ZIP dosyasının içinde sadece Ngrok uygulaması olacaktır. Direk çift tıklayıp açabilirsiniz. ( Fotoğraf 1.3 )

Ngrok Nasıl Kullanılır?

Ve Ngrok’u kurmayı başardınız. Şimdi kayıt olduğunuz Ngrok hesabınızı bu uygulamaya bağlamamız gerekmekte. En başta karşımıza çıkan sitede biraz aşağıya kaydırırsak 2. Connect your account kısmını görmekteyiz. ( Fotoğraf 1.4 )

Buradaki kodu kopyalayıp daha önce açtığımız Ngrok komut ekranına yapıştırıyoruz. Enter’a bastığımızda hesabımız Ngrok’a bağlanmış oluyor. ( Fotoğraf 1.5 )

Sonrasında Yemekleriniz yanmasın projesindeki gibi ESP32’nin bize verdiği http://192.168.1.53/ gibi IP linkini kopyalıyoruz. Bu kısmın ne olduğunu bilmiyorsanız Yemekleriniz yanmasın blog yazımı inceleyebilirsiniz. ( Fotoğraf 1.6 )

Sonrasında aşağıdaki gibi Ngrok’un komut ekranına ngrok http yazıp üstteki kopyaladığımız IP adresini bu kısma yapıştırıyoruz ( Fotoğraf 1.7 )

ngrok http http://192.168.1.53/

Ve evet! Serverimiz başlamış bulunmakta. Aşağıdaki ekranı siz de kendi bilgisayarınızda görebildiyseniz her şeyi başarıyla yapmışsınız demektir. Forwarding kısmındaki https://faa3-78-179-1-19.ngrok-free.ap linkini sizdekini kopyalayıp tarayıcınıza yapıştırırsanız tebrikler. Artık dünyada internetin olduğu her yerden ESP32’nize ulaşabilirsiniz. telefonunuzun hücresel ağını açıp test edebilirsiniz. Ancak bu sistem aşağıdaki uygulama bilgisayarınızda ve bilgisayarınız da açık kaldıkça uygulamaya devam edecektir. ( Fotoğraf 1.8 )

Sonrasında ise Forwarding kısmında yazan https://faa3-78-179-1-19.ngrok-free.app linkini kendi tarayıcımıza yazıp açtığımızda aynı Wi-Fi adresine bağlı kalmamıza gerek olmadan istediğimiz yerden ve konumdan haberleşebiliriz.

Gördüğünüz gibi farklı bir internete bağlı olmama rağmen Ngrok üzerinden istediğim zaman WebServer’ime ulaşabiliyorum. ( Fotoğraf 1.9 )

Aynı zamanda telefonumda hücresel açıkken de ESP32 modülüme ulaşabiliyorum. Tabii bu Yemekleriniz yanmasın projesindeki ekranın değil. Neden mi? Bu Baskılarınız Yanmasın adlı blog yazısının projesi. Bir sonraki yazımızda o projede Ngrok kullanacağız. Aşağıdaki linkten o yazıma da ulaşabilirsiniz.

Daha fazla IOT ( Nesnelerin İnterneti ) yazısı için IoT Projeleri kategorimizi inceleyebilirsiniz.

ESP32-CAM ile Yerel Ağdan Genel Ağa ( LAN to WAN ) 📶 yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

İhtiyaç Listesi

ESP32-CAM Wifi Bluetooth Geliştirme Kartı ve OV2640 Kamera Modülü: https://www.robo90.com/esp32-cam-wifi-bluetooth-gelistirme-karti-ve-ov2640-kamera-modulu

40lı Ayrılabilen Dişi-Dişi Jumper Kablo – 20cm – Arduino Uyumlu: https://www.robo90.com/40li-ayrilabilen-disi-disi-jumper-kablo-20cm-arduino-uyum

FT232RL FTDI USB-TTL Dönüştürücü-Programlayıcı: https://www.robo90.com/ft232rl-ftdi-usb-ttl-donusturucu-programlayici

Donanım Kısmı

Yapmamız gereken ilk şey USB-TTL dönüştürücü ile ESP32-CAM modülünün bağlantılarını yapmaktır. Yukarıdan aşağıya doğru sırasıyla bağlamamız gereken pinler; ( Fotoğraf 1.0 )

USB-TTL→ ESP-CAM

1. GND → GND
2. Boş
3. VCC → 5V
4. TX → UOR
5. RX → UOT

Bir diğer dikkat etmemiz gereken konu ise USB-TTL dönüştürücünün üzerindeki 5V pinini fotoğraftaki gibi bağlamamız gerekir. 3.3V pinine bağlı olup ttl dönüştürücüyü ESP32-CAM modülünün 5V pinine bağlayamazsınız.

Gerekli bağlantıları yaptıktan sonra USB-TTL dönüştürücümüzü bilgisayarımıza bağlamadan önce ESP32’ye ait gerekli kütüphaneleri indirmemiz gerekir. ESP32’ye Program Nasıl Yazılır? adlı blog yazımı okuyabilirsiniz. ESP32-CAM modülü ESP32’ye kamera eklenmiş hali gibi düşünebileceğimizden aynı kütüphaneyle çalışmaktadırlar.

Tüm gerekli kütüphaneleri indirdikten sonra ESP32-CAM modülümüzü bilgisayara doğru port ve doğru kartı seçmemiz gerekir. Doğru portu bazen Arduino IDE ile göremeye biliriz. Bu tarz durumlarda Aygıt yöneticisini açıp Ports kısmından doğru bağlantıyı görebiliriz. Eğer sizde her şeye rağmen cihazınızı göremiyorsanız kullandığınız USB-TTL dönüştürücünün Driver’larını indirmeniz gerekebilir. ( Fotoğraf 1.1 )

Eğer ESP32-CAM modülünün Driver’larının nasıl kurulacağını bilmiyorsanız aşağıdaki bloğumu inceleyebilirsiniz.

Sonrasında IDE programından cihazımızı seçmemiz gerekir. ( Fotoğraf 1.2 )

Tüm bu işlemleri doğru yaptıktan sonra Kartımızın bağlandığını görebiliriz; ( Fotoğraf 1.3 )

Gerekli Kodlar

Kodumuzun ilk kısmında ihtiyacımız olan kütüphaneler bulunmakta. Sadece ESP32’nin ilk başta kütüphanesini yüklemeniz gerekli. “Fazla kütüphane var bunları da indirmem gerekmez mi?” diye düşünebilirsiniz ancak zaten yüklü olacaktır.

#include "esp_camera.h"
#include <WiFi.h>
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "fb_gfx.h"
#include "soc/soc.h" //disable brownout problems
#include "soc/rtc_cntl_reg.h"  //disable brownout problems
#include "esp_http_server.h"

Daha sonrasında ise ESP32-CAM modülünü bağlayacağımız internet ismimizi ve şifremizi sırasıyla ssid ve password kısmına yazmamız gerek.

UYARI

ESP32-CAM sadece 2.4GHz internete bağlanabilir. 5GHz internetinize bağlanamaz. 5Ghz internetinize bağlamayı denerseniz ESP32-CAM modülü internete bağlanamayacaktır. Telefonunuzun mobil erişim noktasını paylaşıp ESP32-CAM modülünü bağlamayı deneyebilirsiniz ancak telefonunuzun da 2.4GHz internet Wi-Fi paylaşımı yaptığından emin olmanız gerek.

const char* ssid = "****************";       //İnternet İsminiz (Örnek Mahmut_2.4GHz)
const char* password = "****************";   //İnternet Şifreniz 

Sonrasında ise ESP-CAM modülünün kamerası için gerekli pinleri tanımlamamız gerekir. Kullandığımız kameraya göre pinler değişiklik gösterebilir. Ben ilk denediğimde kameram çalışmamıştı. Sonra ESP32 kütüphanesinin içerisinde gelen CameraWebServer örnek kodundaki genel kamera pinlerini de denedim ancak çalışmamıştı. Eğer siz de aynı sorunla karşılaşırsanız aşağıdaki koddaki CAMERA_MODEL_WROVER_KIT’e ait kamera pin bağlantılarını kodunuza yapıştırabilir, kodunuzdaki hazır kamera pinleriyle yer değiştirebilirsiniz.

#define PART_BOUNDARY "123456789000000000000987654321"
#define BLYNK_TEMPLATE_ID "TMPL6Dn_JnPjn"
#define BLYNK_TEMPLATE_NAME "esp32cam"
#define BLYNK_AUTH_TOKEN "AXhKUN1qbCIsVzwIDjuSPf-yAHr4BDtB"

#define CAMERA_MODEL_AI_THINKER

//Deneyebilceğiniz kamera pini 
#if defined(CAMERA_MODEL_WROVER_KIT)
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27

#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22
//

#elif defined(CAMERA_MODEL_AI_THINKER)
  #define PWDN_GPIO_NUM     32
  #define RESET_GPIO_NUM    -1
  #define XCLK_GPIO_NUM      0
  #define SIOD_GPIO_NUM     26
  #define SIOC_GPIO_NUM     27
  
  #define Y9_GPIO_NUM       35
  #define Y8_GPIO_NUM       34
  #define Y7_GPIO_NUM       39
  #define Y6_GPIO_NUM       36
  #define Y5_GPIO_NUM       21
  #define Y4_GPIO_NUM       19
  #define Y3_GPIO_NUM       18
  #define Y2_GPIO_NUM        5
  #define VSYNC_GPIO_NUM    25
  #define HREF_GPIO_NUM     23
  #define PCLK_GPIO_NUM     22
#else
  #error "Camera model not selected"
#endif

Aşağıda ise kodumuzun tamamı mevcut. Kodun geri kalanında kamera, WebServer, Wi-Fi kurulum kodları ( Setup kısmında ) ve kameradan gelen canlı yayını WebServer’a veri ileten kodlar mevcut. Kodumuzun tamamını kopyalayıp gerekli kütüphaneleri indirdiğinizden emin olduktan sonra kodu yüklerken nelere dikkat etmemiz gerektiğini inceleyelim.

#include "esp_camera.h"
#include <WiFi.h>
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "fb_gfx.h"
#include "soc/soc.h" //disable brownout problems
#include "soc/rtc_cntl_reg.h"  //disable brownout problems
#include "esp_http_server.h"
const char* ssid = "****************";       //İnternet İsminiz (Örnek Mahmut_2.4GHz)
const char* password = "****************";   //İnternet Şifreniz 
#define PART_BOUNDARY "123456789000000000000987654321"
#define BLYNK_TEMPLATE_ID "TMPL6Dn_JnPjn"
#define BLYNK_TEMPLATE_NAME "esp32cam"
#define BLYNK_AUTH_TOKEN "AXhKUN1qbCIsVzwIDjuSPf-yAHr4BDtB"
#define CAMERA_MODEL_AI_THINKER
#if defined(CAMERA_MODEL_WROVER_KIT)
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27
#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22
#elif defined(CAMERA_MODEL_AI_THINKER)
  #define PWDN_GPIO_NUM     32
  #define RESET_GPIO_NUM    -1
  #define XCLK_GPIO_NUM      0
  #define SIOD_GPIO_NUM     26
  #define SIOC_GPIO_NUM     27
  
  #define Y9_GPIO_NUM       35
  #define Y8_GPIO_NUM       34
  #define Y7_GPIO_NUM       39
  #define Y6_GPIO_NUM       36
  #define Y5_GPIO_NUM       21
  #define Y4_GPIO_NUM       19
  #define Y3_GPIO_NUM       18
  #define Y2_GPIO_NUM        5
  #define VSYNC_GPIO_NUM    25
  #define HREF_GPIO_NUM     23
  #define PCLK_GPIO_NUM     22
#else
  #error "Camera model not selected"
#endif
static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
static const char* _STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";
httpd_handle_t stream_httpd = NULL;
static esp_err_t stream_handler(httpd_req_t *req){
  camera_fb_t * fb = NULL;
  esp_err_t res = ESP_OK;
  size_t _jpg_buf_len = 0;
  uint8_t * _jpg_buf = NULL;
  char * part_buf[64];
  res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);
  if(res != ESP_OK){
    return res;
  }
  while(true){
    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      res = ESP_FAIL;
    } else {
      if(fb->width > 400){
        if(fb->format != PIXFORMAT_JPEG){
          bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
          esp_camera_fb_return(fb);
          fb = NULL;
          if(!jpeg_converted){
            Serial.println("JPEG compression failed");
            res = ESP_FAIL;
          }
        } else {
          _jpg_buf_len = fb->len;
          _jpg_buf = fb->buf;
        }
      }
    }
    if(res == ESP_OK){
      size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len);
      res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
    }
    if(res == ESP_OK){
      res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
    }
    if(res == ESP_OK){
      res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
    }
    if(fb){
      esp_camera_fb_return(fb);
      fb = NULL;
      _jpg_buf = NULL;
    } else if(_jpg_buf){
      free(_jpg_buf);
      _jpg_buf = NULL;
    }
    if(res != ESP_OK){
      break;
    }
    //Serial.printf("MJPG: %uB\n",(uint32_t)(_jpg_buf_len));
  }
  return res;
}
void startCameraServer(){
  httpd_config_t config = HTTPD_DEFAULT_CONFIG();
  config.server_port = 80;
  httpd_uri_t index_uri = {
    .uri       = "/",
    .method    = HTTP_GET,
    .handler   = stream_handler,
    .user_ctx  = NULL
  };
  
  //Serial.printf("Starting web server on port: '%d'\n", config.server_port);
  if (httpd_start(&stream_httpd, &config) == ESP_OK) {
    httpd_register_uri_handler(stream_httpd, &index_uri);
  }
}
void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector
 
  Serial.begin(115200);
  Serial.setDebugOutput(false);
  
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG; 
  
  if(psramFound()){
    config.frame_size = FRAMESIZE_VGA;
    config.jpeg_quality = 20;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_VGA;
    config.jpeg_quality = 30;
    config.fb_count = 1;
  }
  
  // Camera init
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }
  // Wi-Fi connection
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  
  Serial.print("Camera Stream Ready! Go to: http://");
  Serial.print(WiFi.localIP());
  
  // Start streaming web server
  startCameraServer();
}
void loop() {
  delay(1);
}

UYARI

ESP32-CAM modülüne yazılım atarken IO0 pini GND’ye bağlanmalıdır. Bu sayede modül nasıl ESP32’ye yazılım yüklerken butona basıyorsak bu modülde de IO0 pini grounda bağlanmalıdır. Siz jumperlarla da bağlantıyı yapabilirsiniz.

UYARI

Eğer ESP32-CAM modülünüze program attığınız sırada IO0 ve GND pinlerini jumper ile birbirine bağlıyorsanız şu hatayı alma ihtimaliniz vardır:

A fatal error occurred: Invalid head of packet (0x65): Possible serial noise or corruption.

Bu hatanın anlamı jumper kablonuz çok uzun olduğundan çevre gürültülerini kapabiliyor. Bu hatanın kısa çözümü benim gibi kısa bağlantı şekilleri kullanabilirsiniz. Bu hatanın sebebi bazı ESP32 kartlarında bu hattın gürültü kapmaması için kapasitör konulur. Ancak bazı kartlarda konulmamış bir şekilde geliyor.

Sonrasında kodumuzu yüklemeye başlayabiliriz. Bir diğer dikkat etmemiz gereken kısım ise yükle butonuna tıkladığımızda önce kodumuz derlenecektir. Derlenme işleminin hemen sonrasında “ Connectting. . . ” yazısını göreceksiniz. Bu yazıyı gördüğünüz anda ESP32-CAM modülünün altındaki reset butonuna bir kere basıp çekmeniz gerekmektedir.,

Sonrasında ise kodumuz yüklenmeye başlayacaktır. Kodumuzun yüklenmesi tamamlandıktan sonra ise karşımıza şöyle bir ekranın çıkması gerekir.

Ve kodumuzu başarıyla yüklemeye başardık. Serial monitörü açmadan önce IO0 ve GND pinlerini birbirine bağlamamızı sağlayan, sadece kod atarken kullandığımız pimi veya jumper kablosunu çıkartmayı unutmamamız gerekir.

Daha sonra ESP32-CAM modülü USB ile bilgisayarımıza bağlıyken Serial Monitor’ü açtığımız zaman karşımıza şöyle bir ekran çıkması gerekir;

UYARI

Burada bilmemiz gereken diğer bir şey ise bu yayına sadece ama sadece ESP32-CAM ile aynı Wi-Fi ağına bağlıysanız ulaşabileceğinizdir. Eğer bilgisayarınız örnek vermek gerekirse Mahmut_5GHz ağına bağlıysa ve ESP32-CAM modülünüz sadece 2.4GHz ağlara bağlanabildiği için Mahmut_2.4GHz ağına bağlıysa aynı yayına katılamazsınız. Bilgisayarınızın da Mahmut_2.4GHz ağına bağlı olması gerekir.

Göründüğü gibi ESP32-CAM modülümüzle doğru bağlantı kurmayı başardık. Şimdi bize verilen http://192.168.1.53 linkini arama motorumuza yazarak kameramıza ulaşabiliriz.

Ve evet! Başardık. İstersek kamera modülünü gerekli güç kaynağıyla beraber yemeğimizi görebileceği bir yere koyarsak canlı yayında yemeklerimizin pişmesini yatağımızda yatarken izleyenbiliriz. Gördüğünüz gibi kamera hareketlerini takip edebiliyoruz. Tabii az önce de bahsettiğimiz gibi bu yayını sadece LAN’dan yani aynı Wi-Fi ağına bağlıysak görebilmekteyiz. Yani yemeklerinizi takip etmek istiyorsanız Wi-Fi’nizin kapsama alanı içerisinde olduğunuzdan emin olun. Peki ya yatağımızda uzanırken Wi-Fi miz çekmiyorsa o zaman ne yapacağız ? Tabi ki buna da mühendisçe bir çözüm üretip bir sonraki ESP32 ile LAN’dan WAN’a blog yazımı okuyabilirsiniz. Bu sayede ESP’nize internetin olduğu herhangi bir yerden istediğiniz an aynı yerel ağa bağlı olmak zorunda kalmadan ulaşabilirsiniz.

ESP32-CAM ile Yemekleriniz Yanmasın 🥘 yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

ESP32 Driver Kurulumu

Burada dikkat etmeniz gereken en önemli şeylerden bir tanesi de ESP32’nizin DRIVER’lerinin bilgisayarınıza yüklü olup olmadığıdır. Bilgisayarımıza USB portu üzerinden bağlanan herhangi bir cihaz üzerlerinde bulunan UART köprüsü dediğimiz minik çipler kullanırlar. Her ESP32 üreticisi gereği farklı UART çipleri kullanabilir. Bu yüzden ESP32’mizin üzerinde bulunan UART çipini tespit edip internetten Driverlerini yüklememiz gerekmektedir. Aksi halde bilgisayarımız cihazımızı tanımayacaktır. Eğer bunu yapmazsanız bilgisayarınız kartınızı görmeyecektir.

Benim kullandığım ESP32, Fotoğraf 1.0’daki WCH’nin CH9102X çipini kullanmakta. İnternetten gerekli araştırmaları yapıp kendi ESP32’nizin UART çipinin doğru driverini bulup kullanabilirsiniz. Gerekli kurulumları yaptıktan sonra bilgisayarınızın aygıt yöneticisinden Ports kısmından ESP32’nizin UART çipini görebilirsiniz. ( Fotoğraf 1.0 )

Malzemeler

• 1 Adet – ESP32-Wroom-32 Wifi ve Bluetooth Geliştirme Kartı

Kütüphane Kurulumu

Daha sonra Arduino IDE’nize ESP32’nin kütüphanesini kurmanız gerekmekte. Bunun iki yolu var. Birinci yolu IDE’nizin Board Manager kısmında ESP32’yi aratıp çıkan kütüphaneyi kurabilirsiniz. Bu yolda ESP32 kütüphanesinin en son sürümünü indiremeyebilirsiniz. ( Fotoğraf 1.1 )

İkinci yolu ise https://docs.espressif.com/projects/arduino-esp32/en/latest/installing.html sitesinden;

Fotoğraf 1.2 deki kısma ulaşıyoruz. Bu linklerden Stable release link ( Kararlı sürüm bağlantısı ) Linkini kopyalıyoruz. Linki aynı zamanda aşağıya da koyacağım;

Link: https://espressif.github.io/arduino-esp32/package_esp32_index.json

Daha sonra Arduino IDE’mizin sol üstteki file kısmından Fotoğraf 1.3’teki gibi Preferences kısmına giriyoruz. ( Fotoğraf 1.3 )

Preferences kısmını açınca karşımıza şöyle bir ekran çıkacak; ( Fotoğraf 1.4 )

Aldığımız Fotoğraf 1.2‘deki linki Additional boards manager URLs yazan kısma kopyalayıp tamam butonuna basınca otomatik yüklemeye başlayacaktır. Tüm bu işlemleri yaptıktan sonra ESP32’mizi Arduino’ya bağlayalım. ( Fotoğraf 1.5 )

Burada bir diğer dikkat etmeniz gereken şey her üreticinin ayrı bir ESP32 modeli olabiliyor. Fotoğraf 1.5‘ten de anlaşılabileceği gibi farklı ESP32 modelleri için farklı seçenekler mevcut. Doğru kart için doğru ESP32 modelini ve portu seçmemiz gerek.

Sonrasında kodumuzu yazalım. Basit bir blink kodu yazalım. ESP32’nin üzerindeki led D2 pinine bağlı. Bu pini çıkış gibi gösterip bir saniyede bir kapatıp açtıralım.

void setup() {
    pinMode(2,OUTPUT);
}

void loop() {


    digitalWrite(2,HIGH);
    delay(1000);
    digitalWrite(2,LOW);
    delay(1000);

}

Kodu yazdıktan sonra yüklemeden önce dikkat etmemiz gereken önemli bir diğer adım ise ESP32 modülünün üzerindeki Boot butonudur. ( Fotoğraf 1.6 )

Kodu yükleme butonuna bastıktan sonra Uploading ( Yükleme ) aşamasında ekranda Connecting… yazısını gördüğümüzde ESP32’nin boot butonuna basılı tutacağız. ( Fotoğraf 1.7 )

Daha sonra yükleme işlemi başladıktan sonra butondan elimizi çekebiliriz. ( Fotoğraf 1.8 )

Daha sonra kodumuz başarıyla yüklenecektir ( Fotoğraf 1.9 )

Göründüğü gibi ESP32’nin üstündeki mavi LED saniyede bir yanıp sönmektedir. ( Fotoğraf 2.0 )

Bu yazımızda ESP32’nin içerisine nasıl yazılım atılabileceğini öğrendik. Aşağıdaki bağlantıdan sıradaki yazımıza bakabilirsiniz.

ESP32 ve Arduino IOT ile LED Nasıl Kontrol Edilir?

🧑‍💻 ESP32 Kullanımı – Esp32’ye Nasıl Kod Atılır? yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

Bu projeyi yaptıktan sonra Sadece bir LED’i açıp kapatarak bile IOT dünyasına giriş yapmış olacaksınız. Bundan sonra röle modülü kullanarak istediğiniz tüm cihazlarınızın uzaktan bağlantılarını kesebilir veya bir sensör yardımıyla odanızın sıcaklığını ölçebilirsiniz. Yani düşünsenize yapabileceklerinizin sonu yok !

İhtiyaç Listesi

Bu proje için ihtiyacımız olan malzemeler arasında;

1 adet ESP32: ESP32-Wroom-32 Wifi ve Bluetooth Geliştirme Kartı

1 adet Breadboard: Elektronik Breadboard – Orta Boy – 400 Pin

1 adet LED: Kırmızı Led – 5mm – 10 Adet

1 adet Direnç: 220R Direnç Paketi – 1/4 W – 10 Adet

2 adet Jumper(40lı olarak satılıyor 1 tane almanız yeterli): 40lı Ayrılabilen Dişi-Erkek Jumper Kablo – 20cm – Arduino Uyumlu

Projenin yapılışı

ESP32, üzerindeki Wi-fi özelliği sayesinde internete bağlanabilir. ESP32’nin örnek kodlarını incelerseniz internet projeleri olduğunu görebilirsiniz. Ama tüm projeler LAN üzerinden çalışmakta. Tıpkı çocukken arkadaşımızla yan yana oyun oynamak istediğimizde aynı internete bağlı olmamız gerektiği gibi. Yani arkadaşınız çok uzaklardaysa LAN üzerinden oyun oynayamazsınız. Bir servera ihtiyacınız var. Yani internet dünyasına oluşturulmuş bir alana ihtiyacınız var. Bu ihtiyacımızı tıpkı oyunların serverları gibi Arduino Cloud dediğimiz Arduino’nun platformu ile karşılayacağız.

İlk adım olarak https://docs.arduino.cc/arduino-cloud/ internet sitesine girip oradan ARDUINO IOT CLOUD butonuna basmamız gerekiyor. ( Fotoğraf 1.0 )

Daha sonra karşımıza çıkan ekrandan kayıt oluyoruz. ( Fotoğraf 1.1 )

Daha sonra karşımıza çıkan ekrandan Create Thing butonuna basmamız gerekiyor ( Fotoğraf 1.2 )

Sonrasında ise çıkan erkandan Add Variable butonuna basmamız gerekmekte. ( Fotoğraf 1.3 )

Daha sonra ise karşımıza çıkan ekrandan değişkenimize bir isim veriyoruz. Ben led ismini seçtim. Sonrasında hemen altındaki select variable type kısmında değişkenimizin ne olduğunu seçmemiz gerekiyor. ( Fotoğraf 1.4 )

Light yazınca karşınıza çıkmazsa yandaki resimdeki gibi Light and color kutucuğunu da işaretlemeniz gerekir. ( Fotoğraf 1.5 )

Daha sonra değişkenimizin sadece Read & Write ( Okuma ve yazma mı ? ) veya Read Only ( sadece yazma ) mı olduğunu seçmemiz gerek. Eğer bir sensör kullanıyorsak sadece Read Only kutucuğunu seçmemiz, eğer led gibi çıkış vermemiz gereken bir cihaz kullanıyorsak Read & Write kutucuğunu seçmemiz gerek ( Fotoğraf 1.6 )

Daha sonra Variable Update Policy ( Değişken Güncelleme Politikası ) kısmını seçmemiz gerek. Burada dikkat etmemiz gereken Değişkenimiz değişir değişmez mi veri geliyor yoksa periyodik olarak sürekli mi geliyor. Buton veya LED gibi bileşenler kullanacaksak On Change kutucuğunu işaretlememiz gerekir. Sonrasında ise Add Variable kutucuğuna basarak yaptıklarımızı kaydedebiliriz.

Göründüğü gibi projemiz Cloud Variables ( Bulut değişkenleri ) kısmına geldi. ( Fotoğraf 1.7 )

Daha sonra ise Associated Device ( İlişkili Cihaz ) kısmına tıklıyoruz. ( Fotoğraf 1.7 )

ESP32 Arduino IOT Bağlantısı

Karşımıza çıkan ekrandan bağlayacağımız cihazı seçmemiz gerekiyor. Biz Third Party Device ( 3. part cihazlar ) seçeneğini seçmemiz gerekiyor. ( Fotoğraf 1.8 )

Sonrasında karşımıza çıkan ekrandan cihazımızı seçmemiz gerekiyor. kullanacağımız cihaz ESP32 ama ESP32 de üreticisine göre alt başlıklara ayrılmakta. Ben ESP32 DEVKİT V1 kullanacağım. Siz de cihazınızın arkasını çevirip öğrenebilirsiniz. ( Fotoğraf 1.9 – Fotoğraf 2.0 )

UYARI

Burada dikkat etmeniz gereken en önemli şeylerden bir tanesi de ESP32’nizin DRIVER’lerinin bilgisayarınıza yüklü olup olmadığıdır. Bilgisayarımıza USB portu üzerinden bağlanan herhangi bir cihaz üzerlerinde bulunan UART köprüsü dediğimiz minik çipler kullanırlar. Her ESP32 üreticisi gereği farklı UART çipleri kullanabilir. Bu yüzden ESP32’mizin üzerinde bulunan UART çipini tespit edip internetten Driverlerini yüklememiz gerekmektedir. Aksi halde bilgisayarımız ESP32 cihazımızı tanımayacaktır. Bu kısmı daha detaylı incelediğimiz; “ESP32’ye yazılım nasıl yüklenir” blog yazımızı inceleyebilirsiniz. Eğer bunu yapmazsanız bilgisayarınız ESP32 kartınızı görmeyecektir. ( Fotoğraf 2.1 )

Eğer ESP32 ‘ye nasıl yazılım yükleneceğini bilmiyorsanız aşağıdaki blog yazımı okuyabilirsiniz.

Esp32’ye Nasıl Program Yazılır?

Kullandığımız kartı seçtikten sonra devam butonuna basıyoruz. Sonrasında ise cihazımıza istediğimiz ismi verebiliriz. Ben ESP32-Mahmut koyuyorum. ( Fotoğraf 2.2 )

Daha sonra karşınıza Device ID ( Cihazınızın ID’si ) ve Secret Key kısımları çıkacak. Bu iki kısmı kaybetmeyin ve paylaşmamaya özen gösterin. Aksi halde birisi sizin cihazınızı kontrol edebilir. Bu iki kısmı not alabilir veya direk dowload the PDF kısmından bu bilgilerin yazılı olduğu bir PDF indirebilirsiniz. Bilgileri kaydettiğinizden emin olduktan sonra I saved my device ID and Secret Key kutucuğunu seçip devam butonuna tıklıyoruz. ( Fotoğraf 2.3 )

Tebrikler! Cihazınızı Arduino Cloud hesabına bağladınız. ( Fotoğraf 2.4 )

Sonrasını da ana ekranımızın sağ alt kısmında bulunan Network kısmından ESP32 için kullanacağımız internetimizi Arduino IOT’ye tanımlamamız gerekli. Bunu yapmamızın sebebi mantıken ESP32’nin internete bağlanması gerekir. ( Fotoğraf 2.5 )

Sonrasında karşımıza çıkan ekrandan kullanacağımız Wi-Fi ismini, Wi-Fi’nin şifresini ve saklamamız gereken Secret Key’i bu kısma yazacağız. ( Fotoğraf 2.6 )

Sonrasında ana ekranımızda sol üstte Things sekmesinin sağında olan Dashboards sekmesini açıyoruz. ( Fotoğraf 2.7 )

Karşımıza çıkan ekranda Build Dashboard butonuna tıklıyoruz. ( Fotoğraf 2.8 )

Sonrasında ADD kısmına bastığımızda bir çok widgets görmekteyiz. Tıpkı windows 8 de güzel göründüğü için masaüstünün sağ kısmına eklediğimiz gibi. Buradan Switch Widgetini ekliyoruz. ( Fotoğraf 2.9 )

Sonrasında karşımıza çıkan ekrandan Widget’imize bir isim verip daha sonrasında hemen altındaki Linked Variable butonuna basıyoruz. ( Fotoğraf 3.0 )

Daha sonrasında karşımıza çıkan ekrandan Things kısmından oluşturduğumuz kartı ve Variables kısmından ise oluşturduğumuz LED değişkenini seçip LINK VARIABLE butonuna basıyoruz. ( Fotoğraf 3.1 )

Göründüğü gibi gerekli bağlantıyı kurarak Widget’imizle eşleştirdik. ( Fotoğraf 3.2 )

Sonrasında tekrar Things kısmına gelip sağ üstteki Sketch kısmına basıyoruz. ( Fotoğraf 3.3 )

Karşımıza çıkan ekrandan sağ üstteki </> Open Full Editor Butonuna tıklıyoruz. ( Fotoğraf 3.4 )

Nasıl Kodlarız?

Daha sonra gerekli kodları yazıyoruz. Önce karşımıza çıkan editörde void setup kısmına kullanacağımız 2 numaralı pini çıkış olarak gösteriyoruz.

void setup() {
  // Initialize serial and wait for port to open:
  Serial.begin(9600);
  pinMode(2,OUTPUT);
  // This delay gives the chance to wait for a Serial Monitor without blocking if none is found
  delay(1500); 

  // Defined in thingProperties.h
  initProperties();

  // Connect to Arduino IoT Cloud
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
  
  /*
     The following function allows you to obtain more information
     related to the state of network and IoT Cloud connection and errors
     the higher number the more granular information you’ll get.
     The default is 0 (only errors).
     Maximum is 4
 */
  setDebugMessageLevel(2);
  ArduinoCloud.printDebugInfo();
}

Daha sonra void onLedChange() fonksiyonuna hatırlarsanız Widget’a bağlı led değişkenini kullanarak basit bir fonksiyon yazıyoruz. Widget açıkken 1, kapalıyken 0 değerini döndüreceği için if(led) koşulu widget açıksa içine, kapalıysa else komutunu döndürecektir.

void onLedChange()  {
  if(led){
    digitalWrite(2,HIGH);
  }
  else{
    digitalWrite(2,LOW);
  }
  
}

Sonrasında kodu yüklemek istediğimizde ESP32’nin bulunamadığını göreceğiz. Bunun için bilgisayarımıza bir uygulama yüklememiz gerek. Mantıken birisi internette birisi bilgisayarımıza bağlı bir bağlantı olması gerek. Bu köprü görevini Arduino Create Agent görecek. Şimdi nasıl kurduğumuzu inceleyelim.

Önce arama kısmına Arduino Create Agent yazıp install the arduino creage agent sitesine tıklyoruz. Sitenin linki aşağıda da var.

https://support.arduino.cc/hc/en-us/articles/360014869820-Install-the-Arduino-Create-Agent

Daha sonra aşağıdan da anlaşılabileceği gibi mavi yazı olan Arduino Create agent installation page yazısına tıklıyoruz. ( Fotoğraf 3.5 )

Start butonuna bastıktan sonra uygulamayı kendi Windows sürümümüze göre indiriyoruz. Ben Windows 64 bit kullandığım için win64 uygulamasını indirdim. ( Fotoğraf 3.6 )

Daha sonra yüklenen kurulum dosyasını kurarak ESP32’nizin internet üzerinden Arduino Sketch ile kodlayabilirsiniz. Gördüğünüz gibi benim kullandığım DOIT ESP32 DEVKIT V1 kartı internet üzerinden Sketch ile bağlantı kurdu. Şimdi kodumuzu yükleyebiliriz. ( Fotoğraf 3.7 )

UYARI

Kodumuzu yüklerken yapmamız gereken en önemli şeylerden bir tanesi ESP32 üzerindeki BOOT butonuna bir süre basılı tutup çekmektir. Bunu yapmazsak kodumuz yüklenmeyecektir. “Eğer ESP32 geliştirme kartına nasıl yazılım atılacağını bilmiyorsanız ESP32’ye Program Nasıl Atılır? ” adlı blog yazımı okuyabilirsiniz. ( Fotoğraf 3.8 )

Devrenin Kurulumu

Önce breadboard üzerine LED’imizi ve direncimizi bağlayalım. Ben direnci LED’in eksi ucundan toprağa verdim. Siz isterseniz artı ucuna da takabilirsiniz. ( Fotoğraf 3.9 )

Daha sonra ESP32’miz ile LED’imizin bağlantılarını yapalım. LED’in artı kısmı ESP32’nin D2 pinine, eksi kısmı ise ESP32’nin herhangi bir GND pinine bağlamamız gerek. ( Fotoğraf 4.0 )

Sonunda! Tüm devre ve yazılım hazır. ( Fotoğraf 4.1 )

Test Kısmı

Dashboard kısmından ayarladığımız switch widgeti açıp kapattıkça ledimizin yanıp söndüğünü gözlemleyebiliriz. ( Fotoğraf 4.2 )

Aynı zamanda telefonunuza Arduino IOT uygulamasını yükleyerek kayıt olduğunuz hesap üzerinden de LED’inizi istediğiniz gibi kontrol edebilirsiniz. ( Fotoğraf 4.3 )

Evet. Bu blog yazımızda Arduino IOT ile kolay bir şekilde ESP32’mizi internetin çektiği her yerden nasıl kontrol edebileceğimiz öğrendik. Diğer Arduino IOT araçlarını kullanarak neler yapabileceğiniz bir hayal etsenize. ESP32’ye bir sıcaklık ve nem sensörü bağlayarak telefonunuzdan ortamın sıcaklığını görebilir, LED yerine bir röle modülü bağlayarak istediğiniz cihazı açıp kapatabilirsiniz. Kısacası yapabileceğiniz şeylerin tek sınırı hayal gücünüz. Bir sonraki yazımızda da hayal gücünüzün sınırlarının genişlemesine yardımcı olacağını düşündüğüm bir projeyi inceleyeceğiz. Aşağıdaki linkten ESP32-CAM ile Yemekleriniz Yanmasın yazımı inceleyebilirsiniz.

🌐 ESP32 ve Arduino IOT ile LED Nasıl Kontrol Edilir? yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

Creality Ender 3 Neo 3D Yazıcı Satın Al

Ender 3 Neo, Ender 3’e özgü 220 x 220 x 250 mm yapı hacmine, 440 x 440 x 465 mm boyut hacmine, göze çarpan PSU yerleşimiyle ikonik görünümüne ve 3 inç LCD ekranı ve döner düğme kullanıcı arabirimiyle Ender 3 ile aynı özelliklere sahiptir.

Ender 3 Neo Özellikleri

32 Bitlik Anakart

Cihaz 32 bitlik sessiz bir anakartla gelmekte. Creality’nin kendi sitesinde makinanın 45-50 db bir ses ile çalıştığını iddia ediyor. Sessiz ve iyi çalıştığını söyleyebiliriz. Ender 3 modelinin ilk çıktığı zamanları hatırlarsak 8 bitlik bir anakart kullanıyordu. Bu kartı kullanan cihazlarda BL Touch modifiyesini yaptığımız zaman yazılımını karta atmak istediğimizde bile kartın hafızası yetmiyordu. Kodu yeniden derlememiz gerekiyordu. Nihayet Creality bu sorundan köklü bir kurtuluş gerçekleştirdi. İncelediğimiz Ender 3 Neo modeline de 32 bitlik bir sessiz anakart koymuşlar. Bu konuda bizden iyi bir not aldığını söyleyebiliriz.

BL-Touch

Bu üründe Neo ile birlikte gelen BL Touch çok dikkat çekti. Ender 3’ler çıktığından beri bu zamana kadar yapılan en popüler geliştirme ne diye sorsak her halde insanların bir çoğu muhtemelen BL Touch özelliğini seçer. Creality de bu talebi görmüş ve Neo modeline CR Touch’ı yani kendi markalarının BL Touch özelliğini stok olarak koymuş.

CR Touch 16 noktadan tablanıza dokunarak seviyelememize yardımcı oluyor. Creality bunu Otomatik tabla seviyeleme olarak pazarlasa da bu sensörler bunu yapamazlar. Bizim cihazın tablasının altındaki tekerleklerle bunu ayarlamamız gerekir. Ancak bizden arta kalan pürüzleri buradaki CR Touch ile giderebiliriz. Kısacası CR Touch’a oto kalibrasyon değil bir kalibrasyon yardımcısı olarak bakabiliriz.

Carborundum Cam Tabla

Creality Ender 3 Neo modeline stok olarak yeni bir carborundum cam tabla getirmiş. Normalde Ender 3’ler manyetik stickerlarla gelirken Creality carborundum cam tablaların daha kuvvetli olduğunu savunuyor. Isındığında tutma etkisinin arttığını, soğuduğunda ise azaldığını iddia ediyor. Biz ise yaptığımız testlerde tablanın tutma hissiyatının daha iyi olduğunun söyleyebiliriz.

Bowden Ekstruder

Bowden Ekstruder denildiğinde aklımıza Creality gelecek kadar Creality’nin çok makina çıkarttığını söyleyebiliriz. Neo modelinde de aynı özelliği stok olarak eklemiş ama üzerindeki Ekstruder’i tamamen metalden tasarlamış. Ender 3 modellerinde bu parça plastik olarak geliyordu. Tamamen metal Ekstruder’a geçtikten sonra Creality’nin iddiasına göre filamenti çok daha iyi tutup kontrol edebiliyor. Bu sayede de baskı hassasiyeti arttığını söylüyor. Kendi deneyimlerimize kıyasla söylemek gerekirse metal olması plastik olmasına göre tercihimizdir. Creality’nin iddiasının doğruluğunu zamanla göreceğiz.

Neo Serisi Hotend Alüminyum Radyatör

Ender 3 serisine kıyasla Neo modelinde yeni bir Radyatör tasarımı kullanmış. Bu yeni tasarım sayesinde filamentlerimizi daha iyi soğutacağını iddia ediyor.

Radyatörün en önemli görevi Hotend’den ( filamentin çıktığı kısım ) gelen sıcaklığın yukarı çıkmasını, filamentin extruder’in üst taraflarında erimesini engellemesidir. Yoksa bu üst kısımlarda şişkinlikler olabilir ve tıkanıklıklara yol açabilir ve çıktınız bozulabilir. Bu noktada radyatörün görevi çok önemli. Creality ise yeni modeli olan Neo’da bu problemi daha iyi çözdüğünü söylüyor. Bunun ne kadar etkili olduğunu bize zaman gösterecek. Görünüş olarak ise güzel durduğunu söyleyebiliriz.

Sertleştirilmiş Tabla Yayı

Normal Ender 3 modelinde kullanılan düz yaylar tekerleklerin ayarını iyi tutamıyorlar. Sarsıntı yaptıkça tabla da kaçmaya başlıyor. Ama Ender 3 Neo modelinde kullanılan Alaşımlı çelik kapama yaylar baya sıkılar.

Tek Z Ekseni

En göze çarpan şey makinanın tek Z eksenine sahip olması, ikinci bir Z ekseni yok. Küçük modellerde bir sorun olmaz ama özellikle boy olarak yüksek modellemelerde Z ekseni yükseldikçe salınım yaşandığını gözlemliyoruz. Cihaz tek Z ekseni olduğu için Yüksek boylu model basarken zorlanabilir. Hepsini kötü basarı ifade etmiyoruz ama çift Z ekseni, tek Z eksenine kıyasla daha avantajlı. Aradaki farkı kullanıcı deneyimi ve basılan modellerin zorluk seviyesi belirliyor.

Ender 3 Neo Kurulumu

Uzun zamandır 3D yazıcı ürünlerinde do it yourself ( Kendin yap ) metodunu görmüyorduk. Son zamanlarda çıkan makinalar genellikle kutudan çıktığı gibi kullanılabilir oluyordu. Sonrasında ise üst gövdeyi alt gövdeye monteledikten sonra cıvatalarını sıkınca makine kullanım hazır hale geliyordu. Creality bu ürünüyle bütçe dostu ürün olmaya giden yolda bazı fedakarlıkları da bizden bekliyor. Şu anda fiyatına göre iddialı makinalardan bir tanesi. Fiyat avantajı öne çıktığı zaman demonte gelmesinin negatifliği geriye düşüyor.

Kurulum sürecine bakacak olursak kutu içerisinde ürünün yanında kullanım kılavuzları ve SD kart geliyor. SD kartın içerisinde bastırmaya hazır G-code, kullanım kılavuzu, driverlar ve kurulum videosu bulunmakta.

Ürünün kutu halinden kurulması 50 dakika, bir de kalibrasyon işlemi yapması 10 dakika sürdü. Yani yaklaşık bir saat içerisinde makine baskı almaya hazır hale geldi. Şimdi SD kartın içerisinde gelen örnek baskı ve kutunun içinden çıkan örnek filament ile ilk baskımızı alalım.

İlk baskınızı da almayı başardıktan sonra makinanın kullanıma hazır olduğunu söyleyebiliriz. Bu gemi modelini çıkartmayı yaklaşık iki saatte başardı.

Biz Ender 3 Neo’yu kurarken sadece SD kartın içindeki videoyu kullandık. Video kurulum, kalibrasyon ve ilk baskı sürecini net bir şekilde anlatıyordu. Bu konuda Creality’nin iyi bir iş çıkardığını söyleyebiliriz.

Sonuç

Fiyatının göze aldığımızda Ender 3 Neo tercih edilebilecek bir makine. Ürünün fiyatına aşağıdaki link üzerinden internet sitemizde bakabilirsiniz. Creality Ender 3 serisindeki kullanıcı deneyimlerine kulak asmış ve Neo modelini çıkartmış gibi görünüyor. Bu ürünü daha sonra mağazamızın hemen girişine koyacağız, gelip orada görebilirsiniz. Biz de bu süreçte ürünün iddia ettiği özellikleri karşılayıp karşılamadığını inceleyeceğiz. Vadettiği gibi ABS, PLA, TPU ve PETG filamentlerle bol bol baskılar alacağız. Bu dediklerimizi test ettikten sonra da uzun kullanım test videosu yayınlayacağız.

🐉 Creality Ender 3 Neo İnceleme Yazısı yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

Ürün, 0V ile 100V aralığındaki gerilimi ve 0 ile 10 Amper aralığındaki akımı ölçmek için tasarlanmıştır.

Ürün Linki – Malzemeler

0-100V / 0-10A Dijital Voltampermetre

Ürünün +-%5’lik bir ölçümde hata payı bulunmakta. Bu hata payını düşük voltajlarda daha az görürken yüksek voltajlarda daha fazla görmekteyiz.

0-100V gerilimlerini yukarıdaki gibi ölçmek istiyorsak voltampermetreyi harici bir kaynak ( pil gibi ) ile besleyerek kullanmalıyız. Çünkü ürünümüzün besleme voltajı 0-30V olduğu için ürünümüzü bozabiliriz.

Çalışma gerilimi ise 4.5V ile 30V aralığındadır. İçerisinden bir adet Voltampermetre ve iki adet dişi soketli kablo çıkmaktadır. Gelin hep beraber ürünün teknik özelliklerini inceleyelim.

Teknik Özellikler

• Çalışma Gerilimi: 4.5V – 30V
• Çalışma Akımı: 20mA
• Ölçüm Aralığı: 0-100VDC – 0-10A
• Çözünürlük: 0.1V – 0.01A
• Çalışma Sıcaklığı: -15 ile +70°C
• Pano tipi montaja uygundur.

Ürünün dikkat etmemiz gereken en önemli özellikleri çözünürlüğü ve çalışma gerilimidir. Bu Voltampermetre voltaj için 0.1V, akım için 0.01A değişimi tespit edebilir. Örnek vermek gerekirse ölçmek istediğiniz değerler sırasıyla 5.77V-0.345A ise ekranda voltaj için 5.7-5.8V değerlerinden birisini, akım için ise 0.34-0.35A değerlerinden birisini görebilirsiniz.

Ürünün aynı zamanda arka kısmında bulunan iki adet potansiyometre sayesinde akım ve voltaj ayarlamalarınızı doğru sonucu gösterecek şekilde ayarlayabilirsiniz. Bu potansiyometreleri yıldız tornavida yardımıyla ayarlayıp voltaj ve akım değerlerinizi ayarlayabilirsiniz.

Ürün hem harici bir kaynaktan ( Pil gibi ) beslenip kullanılabilirken hem de ölçülmek istenilen yerden beslenebilir. Burada dikkat edilmesi gereken şey ölçülmek istenilen yerden beslenirken 30V üstü kaynakları ölçmek istediğimizde cihazı yakabiliriz. Pil gibi harici bir kaynaktan besleniyorsa 0-100V aralığında istediğimiz değeri ölçebiliriz. Önce ürünü ölçmek istediğimiz yerden güç almasını sağlayarak kullanalım. Sonra bir pil ile güç almasını sağlayarak kullanalım.

Voltampermetre Ölçülmek İstenilen Yerden Beslenirse;

Dikkat: Ölçülmek istenilen yerden beslenirse bu modülü 0-30V aralığında beslememiz gerekir. Aksi taktirde modülü yakabiliriz.

1- Ürünümüzü paketinden çıkardıktan sonra önce gerekli kabloların klemensini yerine takacağız. Sağdaki fotoğraftan da anlaşılabileceği gibi önce kalın olan kabloların bağlantı kısmını kırmızı daire ile gösterilen yere takıyoruz. ( Fotoğraf 1.0 )

2- Daha sonra ürünün içerisinden çıkan daha ince olan kabloların klemensini soldaki fotoğraftan da anlaşılabileceği gibi kırmızı dairenin olduğu yerine takacağız. ( Fotoğraf 1.1 )

3- Daha sonra üstteki fotoğraftan da anlaşılabileceği gibi önce ince olan kablolardan kırmızı ve sarı olanını birbirine bağlıyoruz. ( Fotoğraf 1.2 )

4- Daha sonra ölçmek istediğimiz noktanın pozitif voltajın düşeceği kısmını bu bağladığımız iki kabloya tutturuyoruz. Yukarıdaki fotoğrafta pozitif voltajın düşeceği kısmı artı ile görebilirsiniz. ( Fotoğraf 1.3 )

5- Daha sonra daha kalın olan siyah kabloyu voltajını ve amperini ölçeceğimiz noktanın negatif gerilimine bağlıyoruz. Üstteki fotoğrafta da anlaşılabileceği gibi buraya kadarki adımları doğru yaptıysanız voltampermetrenizin ekranınızın gelmesi gerek. ( Fotoğraf 1.4 )

6- Daha sonra voltampermetremizin ölçüm yapacağı yükü temsil etmesi için biz 12V’luk bir LED kullanacağız. Bu yük bir motor veya başka akım çeken bir elektronik ürün olabilir. Soldaki fotoğraftan da anlaşılabileceği gibi LED’in sol tarafındaki lehim eksiyi, sağ tarafındaki lehim ise artıyı temsil etmekte. ( Fotoğraf 1.5 )

7- Daha sonra ise yandaki üstteki fotoğraftan da anlaşılabileceği gibi kırmızı kıskaçlı kabloyu artıya, siyah kıskaçlı kabloyu ise eksiye bağladık. Adım adım hem uygulamalı hem de şemada devreyi oluşturmaya devam ediyoruz. ( Fotoğraf 1.6 )

8- Daha sonra ise 4. adımdaki birbirine bağladığımız ince sarı ve ince kırmızı kablolara LED’in kırmızı kablosunu bağlıyoruz. ( Fotoğraf 1.7 )

9- Son olarak ise üstteki fotoğraftan da anlaşılabileceği gibi LED’in siyah ( eksi ) olan kablosunu ise Voltampermetremizin kırmızı kalın olan kablosuna bağlıyoruz. ( Fotoğraf 1.8 )

10. Üstteki fotoğraftan da anlaşılabileceği gibi LED’in üzerinden geçen voltajı ve akımı Voltampermetremizin ekranında görebiliyoruz. ( Fotoğraf 1.9 )

Voltampermetre Bir Pil ile Beslenmek İstenirse

1- Ürünü paketinden çıkartıp tekrar çıkan kabloları yerine takalım. Bu sefer ekstra olarak ürünü beslemek için bir pile ihtiyacımız var. ( Fotoğraf 2.0 )

2- Fotoğraftan da anlaşılabileceği gibi yeşil olan kablo pilin artısına, sonra ise Voltampermetrenin ince kırmızı olan kablosuna bağlı. Beyaz olan kablo ise pilin eksisine, Voltampermetrenin ise ince siyah olan kablosuna bağlı. bu işlemi yaptıktan sonra göründüğü üzere Voltampermetremizin ekranı geldi. ( Fotoğraf 2.1 )

3- Daha sonra ise yukarıdaki fotoğraftan da anlaşılabileceği gibi kırmızı kıskaçlı kabloyu artıya, siyah kıskaçlı kabloyu ise eksiye bağladık. ( Fotoğraf 2.2 )

4- Daha sonra yukarıdaki fotoğraftan da anlaşılabileceği gibi daha kalın olan siyah kabloyu voltajını ve amperini ölçeceğimiz noktanın negatif gerilimine bağlıyoruz. Sonrasında ölçmek istediğimiz kaynağın artısını voltampermetrenin ince sarı kablosuna bağladık. Sonra LED’imizin kırmızı kablosunu da bu birbirine bağladığımız kabloya bağlıyoruz. ( Fotoğraf 2.3 )

Sonra yapmamız gereken LED’in siyah kablosunu voltampermetrenin kalın kırmızı kablosuna bağlamamız gerek. Tüm bu işlemleri yaptıktan sonra Ekranımızda LED’in çektiği akım miktarını ve voltaj değerini görebilmekteyiz. ( Fotoğraf 2.4 )

Bu yazımızda da 0-100V / 0-10A Dijital Voltampermetreyi inceledik ve nasıl kullanıldığını anlattık. Ürünü bir sistemin çalışır durumda olduğunu, ne kadar güç tükettiği gibi durumları tespit etmek için kullanabiliriz ama eğer ürünü bir Multimetre gibi kullanmayı düşünüyorsanız düşüncenizi tekrar gözden geçirmenizi tavsiye ederiz. Çünkü ürün hassas ölçümler ve laboratuvar ortamı için tasarlanmamış. Eğer bir Multimetre arayışı içindeyseniz aşağıdaki ürünlerimize göz atmanızı tavsiye ederiz .
Bir sonraki ürün incelememizde görüşmek üzere.

DT-830D Dijital Multimetre Ölçü Aleti

Dijital Multimetre- Avometre – Mini Ölçü Aleti – XL830L

📏0-100V / 0-10A Dijital Voltampermetre Nasıl Çalışır? yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.