Elektronik Parçalar;

1-Nokia 5110 LCD Ekran – 84×48 – Arduino Uyumlu https://www.robo90.com/nokia-5110-lcd-ekran-84×48-arduino-uyumlu

2-TEA5767 FM Stereo Radyo Modülü: FM sinyalleri almak için tercih ettiğim radyo modülü. https://www.robo90.com/tea5767-fm-stereo-radyo-modulu

3-Arduino Nano Klon: Projenin beyni olarak görev yapan Arduino Nano. https://www.robo90.com/arduino-nano-klon-usb-kablo-hediyeli

4-PAM8403 2x3W Mini Ses Yükseltici Kartı – Stereo – Amfi-Potlu: Stereo amfi olarak kullanılarak sesi hoparlöre aktarıyor. https://www.robo90.com/pam8403-2x3w-mini-ses-yukseltici-karti-stereo-amfi-potlu

5-Rotary Encoder Modülü – KY-040 – Arduino Uyumlu: Radyo frekansını ayarlamak için kullanılan döner enkoder. https://www.robo90.com/rotary-encoder-modulu-ky-040-arduino-uyumlu

6-Hoparlör: 4 ohm 3 watt

7-Seetronic MTP3C Stereo 3.5mm Jak (TEA5767 hoparlör çıkışı için)

FM radyo projemizde, Arduino Nano ile frekans ayarlamalarını yapabiliyoruz ve radyo sinyallerini TEA5767 modülü ile alıyoruz. Ekran olarak Nokia 5110 kullanarak radyo frekansını ve kanal bilgilerini görüntüleyebiliyoruz. Ses yükseltme kartı (PAM8403) ise sinyali hoparlöre aktarıyor. Rotary Encoder, frekans ayarını hassas bir şekilde yapmamızı sağlıyor.

FM Radyo Uygulama Videosu

FM radyo devremizin nasıl çalıştığını görmek isterseniz aşağıdaki video bağlantısından uygulama videosunu izleyebilirsiniz.

Arduino kod yazılımını da aşağıya ekliyorum. 

Dikkat etmeniz gerekenler için;

1- Kod içinde kullanılan kütüphanelerin linkleri aynı satırda verilmiştir. Bu linkleri kullanarak kütüphaneleri indirebilirsiniz.

2- FreeSerif18pt7b, FreeSerifItalic9pt7b ve FreeMono12pt7b kütüphanelerini indirdikten sonra, aşağıdaki kodlarla oluşturacağınız .ino uzantılı arduino programının yer aldığı klasör içine taşıyın ve sırasında program kodlarınızı Arduino Nano içine yükleyin.

Kablo Şeması ve Bağlantılar

Bu devrede Arduino Nano, TEA5767 radyo modülü, PAM8403 ses yükseltici ve Nokia 5110 ekranı belirli pin bağlantıları üzerinden birbirine bağlanır. Kablo bağlantılarını doğru yapmak, projenin sorunsuz çalışması açısından önemlidir.

Arduino Kodu

Aşağıda projenin Arduino kodlarını göreceksiniz. Bu kodlar sayesinde radyo frekansını ayarlayabilir, kanalları kaydedebilir ve LCD ekranda kanal bilgilerini görüntüleyebilirsiniz. Kodlar, frekans değişimlerini hafızaya alarak en son ayarlanan frekansa geri dönme işlevine de sahiptir.

#include <TEA5767N.h>  //https://github.com/mroger/TEA5767
#include <SPI.h>
#include <Adafruit_GFX.h>  //https://github.com/adafruit/Adafruit-GFX-Library
#include <Adafruit_PCD8544.h> //https://github.com/adafruit/Adafruit-PCD8544-Nokia-5110-LCD-library

#include "FreeSerif18pt7b.h" //https://github.com/adafruit/Adafruit-GFX-Library/blob/master/Fonts/FreeSerif18pt7b.h
#include "FreeSerifItalic9pt7b.h" //https://github.com/adafruit/Adafruit-GFX-Library/blob/master/Fonts/FreeSerifItalic9pt7b.h
#include "FreeMono12pt7b.h" //https://github.com/adafruit/Adafruit-GFX-Library/blob/master/Fonts/FreeMono12pt7b.h

#include "splash.h"
#include <ClickEncoder.h> //https://github.com/0xPIT/encoder
#include <TimerOne.h>  //https://github.com/PaulStoffregen/TimerOne
#include <EEPROM.h>

Adafruit_PCD8544 display = Adafruit_PCD8544(5, 4, 3);

int SaniyeOtoKayit = 300;
float onceki_frekans = 0;
float frekans = 95.0f;

ClickEncoder *encoder;
int16_t son_deger, value;

boolean yukari = false;
boolean asagi = false;
boolean orta = false;

long saniye_degeri = 0;
long oncekiler = 0; 

bool arkaisikACIK = false;

long aralik = 1000; 
  
TEA5767N radyo = TEA5767N();

void setup() 
{
  pinMode(7, OUTPUT);
  digitalWrite(7,HIGH);
  
  initDisplay();
  
  acilissayfasigoster();
  
  radyo.setMonoReception();
  
  radyo.setStereoNoiseCancellingOn();

  RotaryEncoderVeri();
  
  Serial.begin(9600);

  frekans = readFrequencyFromEEPROM();

  if(isnan(frekans))
  {
    Serial.println("setup(): EEPROM icinde frekans degeri yoktur.");
    frekans = 88.0;
    writeFrequencyToEEPROM(&frekans);
  }
    
  printText(String(frekans,1),String(frekans,1));
}

void loop() {

  unsigned long mevcutlar = millis();

  RotaryEncoderKontrol();

  if(mevcutlar - oncekiler > aralik) 
  {
    if(frekans!=onceki_frekans)
    {
      onceki_frekans = frekans;
      radyo.selectFrequency(frekans);  
      saniye_degeri = 0;
    }else
    {
      saniye_degeri++;
      if(saniye_degeri == SaniyeOtoKayit)
      {
          float frekans_oku = readFrequencyFromEEPROM();
          if(frekans_oku!=frekans)
          {
            Serial.println("Dongu(): Yeni frekans EEPROM icine kaydediliyor.");
            writeFrequencyToEEPROM(&frekans);
          }
      }
    }
    oncekiler = mevcutlar; 
    Serial.println("loop(): "+String(saniye_degeri));  
  }

 readRotaryEncoder();

 if(yukari)
 {
  yukari = false;
  onceki_frekans = frekans;
  frekans = frekans+0.1f;
  printText(String(frekans,1),String(onceki_frekans,1));
 }

 if(asagi)
 {
  asagi = false;
  onceki_frekans = frekans;
  frekans = frekans-0.1f;
  printText(String(frekans,1),String(onceki_frekans,1));
 }
}

void printText(String yazi, String onceki_yazi)
{
  display.clearDisplay();   // clears the screen and, WHITE buffer  

  if(onceki_yazi.length() == 4)
  {
    display.setFont(&FreeSerifItalic9pt7b);
  }else
  {
    display.setFont(&FreeSerifItalic9pt7b);
  }
  display.setTextColor(WHITE);
  display.setCursor(5,11);
  display.println("Gulru FM");
   display.setFont(&FreeSerif18pt7b);
  display.setCursor(4,44);
  display.println(onceki_yazi);
  display.display();
  
  if(yazi.length() == 4)
  {
    
    display.setFont(&FreeSerifItalic9pt7b);
  }else
  {
    display.setFont(&FreeSerifItalic9pt7b);
  }
  display.setTextColor(BLACK);
  display.setCursor(5,11);
  display.println("Gulru FM");
   display.setFont(&FreeSerif18pt7b);
  display.setCursor(4,44);
  display.println(yazi);
  display.display();
}

void RotaryEncoderVeri()
{
  encoder = new ClickEncoder(A1, A0, A2);
  encoder->setAccelerationEnabled(false);
   
  Timer1.initialize(1000);
  Timer1.attachInterrupt(timerIsr); 

  son_deger = encoder->getValue();  
}

void initDisplay()
{
  display.begin();
  display.setContrast(60);
  display.clearDisplay();   // clears the screen and, WHITE buffer  
  display.display();
}

 void timerIsr() 
{
  encoder->service();
}

void acilissayfasigoster()
{
  display.clearDisplay();
  //display.drawBitmap(0, 0,  SPLASH, 84, 48, 1);
  
display.setTextSize(2);
  display.setCursor(3, 0);
  display.print(" GULRU");
  display.setCursor(3, 20);
  display.print(" RADYO");
  display.display();
  delay(5000);
  display.clearDisplay();   // clears the screen and, WHITE buffer  
  
display.setTextSize(1);
}

void writeFrequencyToEEPROM(float *freq)
{
 byte ByteArray[4];
 memcpy(ByteArray, freq, 4);
 for(int x = 0; x < 4; x++)
 {
   EEPROM.write(x, ByteArray[x]);
 }  
 Serial.println("writeFrequencyFromEEPROM(): "+String(frekans));
}

float readFrequencyFromEEPROM()
{
  float frekans = 86.0;
  byte ByteArray[4];
  for(int x = 0; x < 4; x++)
  {
   ByteArray[x] = EEPROM.read(x);    
  }
  memcpy(&frekans, ByteArray, 4);
  Serial.println("readFrequencyFromEEPROM(): "+String(frekans));
  return frekans;
}

void RotaryEncoderKontrol()
{
    ClickEncoder::Button b = encoder->getButton();
  if (b != ClickEncoder::Open) {
    if(b==ClickEncoder::Clicked)
    {
      Serial.println("Toggle BackLight");
      if(arkaisikACIK == false)
      {
        arkaisikACIK = true;
        turnOnBacklight();
      }else
      {
        arkaisikACIK = false;
        turnOffBacklight();
      }
    }
  }
}

void turnOnBacklight()
{
  digitalWrite(7,LOW);
}

void turnOffBacklight()
{
  digitalWrite(7,HIGH);
}

void readRotaryEncoder()
{
  value += encoder->getValue();
  
  if (value/2 > son_deger) {
    son_deger = value/2;
    yukari = true;
    delay(50);
  }else   if (value/2 < son_deger) {
    son_deger = value/2;
    asagi = true;
    delay(50);
  }
}

Bu proje ile ilgili sorularınız veya yardıma ihtiyaç duyduğunuz konular varsa yorum yaparak bana ulaşabilirsiniz. Keyifli projeler dilerim!

Arduino ile FM Radyo Uygulaması yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

Malzemeler

• STM32F411
• STLINK
• 128×64 Oled Lcd Ekran 0.96 inch – Mavi

Adım 1: CubeIDE Üzerinde STM32 Projesi Oluşturma

Projemizi oluşturmadan önce STM32CubeIDE üzerinde projemizde kullanacağımız mikrodenetleyiciyi seçmemiz gerekiyor. Ben elimde bulunduğu için F411CEU6 modelini seçeceğim. Siz elinizdeki modeli seçerek ilerleyeceksiniz.

Mikrodenetleyicimizi seçip Next dedikten sonra projemize isim vererek devam ediyoruz. Burada gelen ekranda mikrodenetleyicimizin birimlerini düzenleyeceğiz.

İlk olarak sol tarafta bulunan menüden System Core kategorisi altında bulunan SYS menüsüne geliyoruz ve Debug’ı fotoğraftaki gibi Serial Wire yapıyoruz.

Daha sonra RCC menüsüne giriyoruz ve fotoğraftaki gibi High Speed Clock (HSE) seçeneğini Crystal/Ceramic Resonator seçiyoruz.

Daha sonra Connectivity menüsü altında bulunan I2C birimlerinden birini seçiyoruz. Ben I2C1’i seçerek devam ediyorum. Bu menü altında I2C’yi fotoğraftaki gibi I2C seçip aşağıda açılan Configuration sekmesinde fotoğraftaki gibi I2C Speed Modunu Fast Mode’a ayarlıyoruz. Bu ayarlamadan sonra bu sekmedeki işimizi bitiriyoruz.

Bu işlemleri yaptıktan sonra ekranda bulunan mikrodenetleyicimizin ön izlemesinde bazı pinlerin yeşil olduğunu göreceksiniz.

Şimdi sırada mikrodenetleyicimizin çalışacağı frekansı ayarlamakta bunun için üst tarafta bulunan sekmelerden Clock Configuration sekmesine geliyoruz burada fotoğraftaki ayarları uygulayıp ALT+K tuşlarına basarak kodumuzu oluşturuyoruz.

Şimdi yapmamız gereken kütüphane dosyalarımızı indirip projede ilgili klasörlerine atmak. Ben kullanım kolaylığı ve işlevsel fonksiyonlarından dolayı Controllers Tech’in hazırladığı kütüphaneyi tercih ediyorum. Inc klasörü içine fonts.h ve ssd1306.h dosyalarını atıyoruz. Src klasörü içine ise fonts.c ve ssd1306.c dosyalarını kopyalıyoruz.

Adım 2: CubeIDE Üzerinde Kodları Yazma

Projemizi başarı ile oluşturup kütüphane dosyalarını ekledikten sonra main.c içerisinde ilk önce kütüphanemizi import ediyoruz bunun için aşağıdaki kodu kullanıyoruz.

/* USER CODE BEGIN Includes */
#include "ssd1306.h"
#include "fonts.h"
/* USER CODE END Includes */

Yazdığımız kodları ve projemize eklediğimiz kütüphaneleri USER CODE yorum satırları arasına yazmamız çok önemli. Çünkü CubeIDE her mikrodenetleyici ayarı yaptığımızda kodu sıfırdan oluşturuyor. Bu işlem sırasında kodlarımızın silinmemesi için kodlarımızı USER CODE yorum satırları arasına alarak silinmelerin önüne geçiyoruz. Kütüphanemizi import ettikten sonra main loopumuzda ssd1306 oled ekranımızı başlatmalıyız bunun için aşağıdaki kodu kullanıyoruz.

/* USER CODE BEGIN 2 */
SSD1306_Init();
/* USER CODE END 2 */

Şu andan itibaren oled ekranımız kullanıma hazır hale geliyor. Şimdi ilk örnek olarak oled ekranımızda belirli konumlarda yazı yazdıralım. Yine USER CODE yorum satırları arasında aşağıdaki kodu kullanabiliriz.

SSD1306_GotoXY (0,0); 
SSD1306_Puts ("Merhaba", &Font_11x18, 1); 
SSD1306_GotoXY (10, 30); 
SSD1306_Puts ("ROBO90 !!", &Font_11x18, 1); 
SSD1306_UpdateScreen(); 

Burada SSD1306_GotoXY fonksiyonu ekran imlecimizin gideceği x ve y koordinatlarını ayarlıyor. SSD1306_Puts fonksiyonu ise imlecin bulunduğu konuma bir string verisi yazdırıyor. Buradaki en önemli kod olan SSD1306_UpdateScreen(); ise oled ekranımızı güncelliyor ve ona yazdırdığımız şeylerin gözükmesini sağlıyor.

Adım 3: Devre Şeması, Bağlantı ve İlk Test

STM32 OLED LCD Devre Şeması ve Bağlantı

Oled ekranımızın çalışması için güç ve veri hatlarını mikrodenetleyicimize bağlamalıyız. I2C pinlerimiz B6 ve B7’de olduğu için karşılığı oldukları sinyalleri bağlıyoruz. Uygun devre şemasını fotoğrafta görebilirsiniz.

İlk Test

Oled ekranımızı ve STM32’mizi birbirine bağladıktan sonra sıra STLink üzerinden kodumuzu atmaya geliyor. Bunun için önce kodumuzu derleyip (Fotoğrafta en soldaki üzerinde 010 yazan kağıt ikonlu tuş ) daha sonra debug modunda kodumuzu çalıştırıyoruz. (Fotoğrafın en sağındaki örümcek ikonu)

Bunları yaptıktan sonra alt fotoğrafta gözüken kısım ile karşılaşacağız fotoğrafın en soldan ikinci ikonuna tıklayıp kodumuzun mikrodenetleyici içerisinde çalışmasını başlatıyoruz.

Bunları yaptıktan sonra OLED ekranımızda aşağıdaki gibi bir görüntü olması gerekiyor. Eğer bu sonucu elde edebildiyseniz STM32 ile başarılı bir şekilde OLED ekranını kullanabildiniz demektir.

Diğer STM32 Projeleri Yazılarımızı İnceleyin

Kullanışlı Linkler

STM32 ile Debug İşlemi: STM32 ile Debug İşlemi
Instagram: https://www.instagram.com/yusuf_cosgun04/
Discord sunucusu: https://discord.gg/8MVnu59tkx
Discord: reevee0

STM32 ile I2C Oled Ekran Kullanımı yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

Kullanılan Malzemeler

1. 2 Adet Step Motor Ve ULN2003 Step Motor Sürücü Seti
2. Arduino UNO
3. SG90 Mini Servo Motor
4. Dişi-Erkek Jumper Kablo
5. Erkek-Erkek Jumper Kablo
6. Mini Breadboard
7. Minyatür Rulman

Arduino ile EggBot Projesi Nasıl Çalışır?

Projemizin temel amacı pinpon topuna ya da yumurta üzerine çizim yapmaktır. 2 Step motordan bir tanesi yumurtayı kendi etrafında döndürürken 2. step motorumuz servo motorun ve kalemin monteli olduğu kolu sağa ve sola olmak üzere iki yönlü hareket ettirmektedir. 2. step motorumuzun hareket ettirdiği kola montajlı olan servo motorumuz ise kalemin takıldığı kolu yukarı aşağı hareket ettirerek çizeceğimiz görselde çizgiler arası atlamaya yarar. Şimdi ise Inkscape uygulamamızdaki aşamalara geçelim. Uygulamamıza gerekli kütüphaneleri ekledikten sonra uygulamamıza giriş yapıyoruz. Sol üst kısımdan Dosya> template > eggbot adımlarını izliyoruz ve çıkan yeni sekmede istediğimiz görseli çiziyoruz. Üst satırda Etkinlikler > eggbot > eggbot control adımlarını izleyerek çıkan ekranda plot sekmesinde uygula diyerek çiziminizi yapabiliyorsunuz. Aşağıdaki görselde anlattığımız şekilde step ve servo motorlarını görebilirsiniz.

Arduino Kodu

#include "AccelStepper.h" // nice lib from http://www.airspayce.com/mikem/arduino/AccelStepper/
#include "VarSpeedServo.h" // variable speed servo lib https://github.com/netlabtoolkit/VarSpeedServo
#include "SerialCommand.h" //nice lib from Stefan Rado, https://github.com/kroimon/Arduino-SerialCommand
#include <avr/eeprom.h>
#include "button.h"


#define initSting "EBBv13_and_above Protocol emulated by Eggduino-Firmware V1.x"

#define BOARD_ULN2003
//#define BOARD_ZAGGO
//#define BOARD_CNCSHIELD

#ifdef BOARD_ULN2003
	// Mini Spherebot using 28BYJ-48 Steppers with ULN2003 Drivers
	// http://www.thingiverse.com/thing:1461709
	#define rotMicrostep 16
	#define penMicrostep 16
	#define servoPin 13
	#define engraverPin 12
  #define en1_1 4
#define en2_1 5
#define en3_1 6
#define en4_1 7

#define en1_2 8
#define en2_2 9
#define en3_2 10
#define en4_2 11
	// These values work for my 28BYJ-48's, Your's might 
	// be different and may need adjustment.
	
	#define rotStepsPerRev 4096
	#define penStepsUseable 1100
	
	//Buttons (uncomment to enable)
	//#define prgButton 2 // PRG button
	//#define penToggleButton 12 // pen up/down button
	//#define motorsButton 4 // motors enable button
#endif


#define penUpPosEEAddress ((uint16_t *)0)
#define penDownPosEEAddress ((uint16_t *)2)
#define penUpRateEEAddress ((uint16_t *)4)
#define penDownRateEEAddress ((uint16_t *)6)

void setprgButtonState();
void doTogglePen();
void toggleMotors();
void makeComInterface();
void initHardware();
void moveOneStep();

//make Objects
#ifdef BOARD_ULN2003
AccelStepper rotMotor(AccelStepper::HALF4WIRE, en1_1,en3_1,en2_1,en4_1);
AccelStepper penMotor(AccelStepper::HALF4WIRE, en1_2,en3_2,en2_2,en4_2);
//AccelStepper penMotor(AccelStepper::HALF4WIRE, 2,4,3,5, true);
//AccelStepper rotMotor(AccelStepper::HALF4WIRE, 8,10,9,11, true);
#else
AccelStepper rotMotor(1, step1, dir1);
AccelStepper penMotor(1, step2, dir2);
#endif

VarSpeedServo penServo;
SerialCommand SCmd;
//create Buttons
#ifdef prgButton
	Button prgButtonToggle(prgButton, setprgButtonState);
#endif
#ifdef penToggleButton
	Button penToggle(penToggleButton, doTogglePen);
#endif
#ifdef motorsButton
	Button motorsToggle(motorsButton, toggleMotors);
#endif
// Variables... be careful, by messing around here, everything has a reason and crossrelations...
int penMin=0;
int penMax=0;
int penUpPos=5;  //can be overwritten from EBB-Command SC
int penDownPos=20; //can be overwritten from EBB-Command SC
int servoRateUp=0;
int servoRateDown=0;
long rotStepError=0;
long penStepError=0;
int penState=penUpPos;
uint32_t nodeCount=0;
unsigned int layer=0;
boolean prgButtonState=0;
uint8_t rotStepCorrection = 16/rotMicrostep ; //devide EBB-Coordinates by this factor to get EGGduino-Steps
uint8_t penStepCorrection = 16/penMicrostep ; //devide EBB-Coordinates by this factor to get EGGduino-Steps
float rotSpeed=0;
float penSpeed=0; // these are local variables for Function SteppermotorMove-Command, but for performance-reasons it will be initialized here
boolean motorsEnabled = 0;
//float rotScale = (float)rotStepsPerRev / 3200.0;
//float penScale = (float)penStepsUseable / 800.0;

void setup() {   
	Serial.begin(9600);
	makeComInterface();
	initHardware();
}

void loop() {
	moveOneStep();

	SCmd.readSerial();

#ifdef penToggleButton
	penToggle.check();
#endif

#ifdef motorsButton
	motorsToggle.check();
#endif

#ifdef prgButton
	prgButtonToggle.check();
#endif
}

Kodumuzu yazdıktan sonra kütüphanelerimizin çalıştığını kontrol edelim. Benim projeyi yaparken karşılaştığım sıkıntılardan biriside kütüphanelerin güncelleme almasından dolayı çalışmamasıydı. Eğer kütüphanelerde bir sıkıntı yaşarsanız güncel sürümlerini yükleyerek tekrar denemenizi tavsiye ederim.

Kütüphanelerinde çalıştığına eminsek eğer ki şimdi sırada devremizi kurmada. Kullanacağımız malzemeleri ilk önce çalışıyor mu diye kontrol ediyoruz. Malzemelerimiz de çalıştığına göre şimdi devremizi kurmaya hazırız.

Devre Şeması

Evet devremizi kurduğumuza göre şimdi sırada 3D çizimlerimizi baskıya vermekte ben kullanmış olduğum baskıları aşağıya link şeklinde bırakıyorum dilerseniz oradan dilerseniz de kendiniz bir çizim yaparak stand yapabilirsiniz.

Eggbot 3D Thingiverse

3D Printer’ımızdan parçaları da aldıysak artık dilediğimizi resmedebiliriz.

Arduino ile EGGBOT Yapımı yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

Merhaba Robo90 Blog Okuyucuları! Bu proje rehberinde, Thonny programını kullanarak Raspberry Pi Pico ile LED yakma projesini ayrıntılı olarak anlatacağım. Eğer programlama veya elektronik konusunda yeniyseniz, endişelenmeyin! Adım adım rehberimiz sayesinde projeyi kolayca takip edebilirsiniz. Raspberry Pi Pico, mikrodenetleyicileri öğrenmek ve denemek isteyenler için harika bir platformdur. Bu projede, bir düğme kullanarak LED’i nasıl kontrol edeceğinizi öğreneceksiniz.

Malzemeler

• Raspberry Pi Pico
• Breadboard
• LED (Tercih ettiğiniz bir renk)
• 220Ω direnç
• Buton
• Erkek-Dişi Jumper Kablolar
• USB-C kablosu (Pico’yu Bağlamak için)

Adım 1: Thonny ve Malzeme Hazırlığı

Önce Thonny programını açmalıyız. Nasıl indirileceğini bilmiyorsanız Raspberry Pi Pico Eğitim Serisinin 1. Bölümü’nde buna değinmiştim.

Adım 2: Devre Tasarımı

1. Raspberry Pi Pico’yu breadboard üzerine doğru pinleri takarak yerleştirin.
2. LED’i breadboard’a bağlayın; uzun bacak (+) anot, kısa bacak (-) katot anlamına gelir.
3. LED’in katod bacağına 220Ω direnci bağlayın.
4. LED’in anodu, Raspberry Pi Pico’nun GPIO 9 (Pin 9) piniyle bağlayın.
5. Düğmeyi breadboard’a yerleştirin.
6. Düğmenin bir bacağını Raspberry Pi Pico’nun GPIO 14 (Pin 14) piniyle bağlayın.
   

Adım 3: Thonny ile Kodlama

1. Thonny programını açın ve yeni bir dosya oluşturun.
2. Aşağıdaki kodu kopyalayın ve yeni dosyaya yapıştırın:

import machine
import utime

led = machine.Pin(9, machine.Pin.OUT)
button = machine.Pin(14, machine.Pin.IN, machine.Pin.PULL_DOWN)

while True:
    if button.value() == 1:
        led.toggle()
        while button.value() == 1:
            pass  # Düğme serbest bırakılana kadar bekle
    utime.sleep(0.01)

3. Kodunuzu kaydedin ve adını verin, örneğin “ButonileLedkontrolu.py”.

Adım 4: Kodu Pico’ya Yükleme

1. Raspberry Pi Pico’yu bilgisayarınıza bağlayın.
2. Thonny programını açın, kodunuzu yüklemek istediğiniz dosyayı açın.
3. Üst menüden “Çalıştır” (Run) düğmesine tıklayarak kodunuzu Raspberry Pi Pico’ya yükleyin.

Sonuç: Raspberry Pi Pico ile LED Yakma Örneği

Projeyi tamamladınız! Artık düğmeye basarak LED’inizi kontrol edebilirsiniz. Bu rehber sayesinde, mikrodenetleyicilerin temel prensiplerini anlayarak kendi projelerinizi oluşturmanızı umuyorum.

Son Söz

Bu yazıda Thonny kullanarak Raspberry Pi Pico ile LED Yakma / LED kontrolünü en ayrıntılı şekilde adım adım öğrenmek için detaylı bir rehber sunduk. Projeyi tamamladığınızda temel kodlama ve devre tasarımı becerilerinizin yanı sıra yaratıcılığınızı daha karmaşık projelerde de kullanabileceksiniz. Başarılar ve keyifli deneyimler dilerim!

Raspberry Pi Pico ile LED Yakma – Bölüm 2 yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

Projenin Amacı

Bu projede amacımız güneş pilini iki Servo motor ve Pan-Tilt kullanarak güneş ışınlarının geldiği yöne döndürmek ve bu sayede sabit olan güneş piline kıyasla daha fazla ışına maruz kalmasını sağlayarak verimi artırmaktır.

Malzemeler

• Arduino UNO R3 – SMD Klon (CH340 Çipli) – USB Kablo Hediyeli
• 4 adet LDR – 5mm – Işığa Duyarlı Direnç
• 2 adet Tower Pro SG90 Mini Servo Motor
• Pan-Tilt Seti – 2 Eksen Servo Tutucu
• 4 adet 10K Direnç
• Elektronik Breadboard
• Erkek/Erkek Jumper Kablo

Kendi Eklentilerim

Güneş pilini ve LDR sensörleri sabitlemek için benimde kullandığım 3D yazıcıdan çıktı alabileceğiniz modellerimi de kullanabilirsiniz.

Güneş Takip Sistemi Model 1

Güneş Takip Sistemi Model 2

Pan-tilt ve Servo Motorların Kurulmuş Hali

Devre Şeması

Pin 9’a bağlı servo motor Pan-Tilt’in alt kısmında ,pin 10’a bağlı olan servo motor ise Pan-Tilt’in üst kısmında kullanılmıştır.

Projenin Kodlanması

Kütüphane Kurulumu

Öncelikle Arduino 0016 ve daha eski sürümlerde, Servo kütüphanesi sadece 9 ve 10 numaralı pinleri desteklemektedir. Eğer Arduino 0016 veya daha eski bir sürüm kullanmıyorsak Servo motorumuzu herhangi bir PWM pinine bağlayarak kullanabiliriz. Kütüphanenin kurulumuna geçelim.Sırasıyla Sketch(Taslak)-Include Library(Kitaplığı dahil et)-Manage Libraries(Kitaplıkları yönet ) seçeneklerini tıklıyoruz.Karşımıza çıkan ekranda arama kısmına Servo yazarak karşımıza çıkan kütüphanelerden tercih ettiğimizi indir (install) seçeneğine tıklayarak indiriyoruz.

Servo Motor Testi

#include<Servo.h> //kütüphane
Servo servo1;
int aciDegeri=90;
 
void setup() {
 servo1.attach(9); //pwm pini
}
 
void loop() {
servo1.write(aciDegeri);

LDR Testi

void setup() {
  
  Serial.begin(9600); //seri haberleşme başlatıyoruz
}
void loop() {
  int ldr = analogRead(A1); //Işık değişkenini A1 pinindeki LDR ile okuyoruz
  Serial.println(ldr); //Okunan değeri seri iletişim ekranına yansıtıyoruz
  delay(50);
  

}

Son Aşama Projenin Asıl Kodu

#include <Servo.h>// servo kütüphanesi
Servo horizontal; // yatay servo
int servoh = 180;
int servohLimitHigh = 175;
int servohLimitLow = 5;


Servo vertical; // dikey servo
int servov = 45;
int servovLimitHigh = 100;
int servovLimitLow = 1;


 
// LDR  pinleri
int ldrlt = A2; //LDR sol üst
int ldrrt = A3; //LDR sağ üst
int ldrld = A0; //LDR sol alt
int ldrrd = A1; //LDR sağ alt

void setup(){
horizontal.attach(9);
vertical.attach(10);
horizontal.write(180);
vertical.write(45);
delay(2500);
}
void loop() {
  int lt = analogRead(ldrlt); // sol üst
  int rt = analogRead(ldrrt); // sağ üst
  int ld = analogRead(ldrld); // sol alt
  int rd = analogRead(ldrrd); // sağ alt
  
 
  int dtime = 10;
  int tol = 90;
  
  int avt = (lt + rt) / 2; // Ortalama üst değer
  int avd = (ld + rd) / 2; // Ortalama alt değer
  int avl = (lt + ld) / 2; // Ortalama sol değer
  int avr = (rt + rd) / 2; // Ortalama sağ değer

  int dvert = avt - avd; // üst ile altın  farkı
  int dhoriz = avl - avr;// sağ ile solun farkı
 
  Serial.print(avt);
  Serial.print(" ");
  Serial.print(avd); 
  Serial.print(" ");
  Serial.print(avl); 
  Serial.print(" ");
  Serial.print(avr); 
  Serial.print("   ");
  Serial.print(dtime);
  Serial.print("   ");
  Serial.print(tol);
  Serial.println(" ");

 
if (-1*tol > dvert || dvert > tol)
{
if (avt < avd)
{
servov = ++servov;
if (servov > servovLimitHigh)
{servov = servovLimitHigh;}
}
else if (avt > avd)
{servov= --servov;
if (servov < servovLimitLow)
{ servov = servovLimitLow;}
}
vertical.write(servov);
}
if (-1*tol > dhoriz || dhoriz > tol) 
{
if (avl > avr)
{
servoh = --servoh;
if (servoh < servohLimitLow)
{
servoh = servohLimitLow;
}
}
else if (avl < avr)
{
servoh = ++servoh;
if (servoh > servohLimitHigh)
{
servoh = servohLimitHigh;
}
}
else if (avl = avr)
{
delay(5000);
}
horizontal.write(servoh);
}

delay(dtime);

}

Servo Motor ve LDR ile Güneş Takip Sistemi yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

HC-06 Nedir? Ne İçin Kullanılır?

HC-06, kablosuz haberleşmeyi sağlayan ve Bluetooth protokolünü kullanan bir kablosuz haberleşme modülüdür. Bu modül sayesinde belirli mesafeler içinde kablosuz haberleşme yoluyla seri haberleşme sağlanır. HC-06, Bluetooth 2.0’ı destekleyen bu kart, 2.4GHz frekansında haberleşme yapılmasına imkan sağlayıp açık alanda yaklaşık 10 metrelik bir haberleşme mesafesine sahiptir. Sadece Slave modda çalışır.

HC-05 Nedir? Ne İçin Kullanılır?

HC-05, seri haberleşme protokolü olan Bluetooth’u kullanan bir kablosuz haberleşme modülüdür. Bu modül sayesinde belirli mesafeler içinde kablosuz haberleşme yoluyla seri haberleşme sağlanır. HC-05, UART tarzı iletişim modu sayesinde Arduino meraklıları için favori bir seçimdir. Bu kart, düşük maliyetli, çok yönlü ve kullanımı kolaydır. HC-05 modülü hem Master hem de Slave olarak çalışabilir. HC-05, UART tarzı iletişim modu sayesinde HC-06 ya göre daha çok tercih edilmektedir.

Malzemeler

• Arduino UNO R3 – SMD Klon (CH340 Çipli) – USB Kablo Hediyeli
• HC-06 Bluetooth Modülü
• HC-05 Bluetooth Modülü
• 1K Direnç Paketi – 1/4 W – 10 Adet
• Elektronik Breadboard – Büyük Boy – 830 Pin
• Jumper Kablo

Peki Nedir Bu Slave /Master Mod?

Bluetooth modüllerinde Slave ve Master modlar, iki cihaz arasındaki iletişim için kullanılır. Slave modunda, Bluetooth modülüne dışarıdan bir bağlantı yapılabilirken, modül ile başka bir Bluetooth cihazına ilk bağlantı yapılamaz. Master mod ise elinizdeki modül ile dışardaki bir Bluetooth cihazına doğrudan ilk bağlantıyı yapmanıza olanak sağlar.

İki bluetooth modülü birbiri ile haberleşirken biri Slave diğeri Master modda olmalıdır.HC-06 sadece Slave modda çalışabildiği için HC-05’i Master olarak atamalıyız.

HC-05’i Master Olarak Atama

HC-05’i Master olarak atama işlemi AT komutları ile yapılacaktır. Bunun için aşağıda gördüğünüz şemada ki gibi bağlantıları yapıyoruz. Burada dikkat edilmesi gereken bağlantıları yapmadan kodun atılmış olması ve modüle güç verilmeden modül üzerinde bulunan butona basılı tutup daha sonra güç verilmesidir. Eğer buton bulunmuyorsa 34. pine bir jumper kablo lehimleyebilirsiniz.

Bağlantımızı yaptıktan sonra kodumuzu yükleyelim.

#include <SoftwareSerial.h>
SoftwareSerial bluetooth(7, 6); // RX, TX
 
void setup() {
  Serial.begin(9600);
  Serial.println("Enter AT commands:");
  bluetooth.begin(38400);// HC-05 38400 baud ile çalışmaktadır.
}
 
void loop()
{
  if (bluetooth.available())//bluetooth'dan gelen veriler porta yazılır.
    Serial.write(bluetooth.read());
  if (Serial.available())//porttan gönderilen veriler bluetooth'a yazılır.
    bluetooth.write(Serial.read());
}

• Serial ekrana ‘AT‘ yazıp gönderdiğimizde cevap olarak ‘OK‘ ifadesi geldiğinde AT komutlarına hazırdır. Şimdi AT komutlarıyla bluetooth modülü master moda alabiliriz.
• ‘AT+ROLE=1‘ yazarak modülü Master moda alıyoruz.
• ‘AT+ROLE‘ komutunu kullanarak modumuzu teyit ediyoruz. (1=Master – 0=Slave)

Böylece HC-05’i Master olarak atamış bulunuyoruz.

Peki HC-05 ile HC-06 Nasıl Birbiriyle Haberleşir?

HC-05 ve HC-06’nın birbiriyle haberleşmesini anlatmak için bir potansiyometre ve buton kullanacağım. Butona bastığımda haberleşme başlayacak ve tekrar bastığımda ise haberleşme kesilecek. Veriler Master –> Slave yönlü iletildiğinden dolayı potansiyometre ve butonu HC-05’e bağlayacağız.

Slave için Kod

#include <SoftwareSerial.h>
SoftwareSerial mySerial(7, 6);  // RX, TX
String cmd = "";
void setup() {
  Serial.begin(9600);
  mySerial.begin(9600);
}

void loop() {
  
while (mySerial.available() > 0) {
    cmd += mySerial.read();
    
  }Serial.println(cmd);
  cmd = ' ';

  delay(50);

}

Master için Kod

Potansiyometreden okunan değer 0 ile 1023 arasındadır yani 10 bite kadar değer yazdırabiliriz ama modüllerimiz arasındaki iletişim 8 bit ile sınırlıdır.
Bu yüzden “potValue= map(potValue,0,1023,0,255);” satırında olduğu gibi haritalama komutu kullandım. Bu sayede potansiyometreden gelen değer artık 0 ile 255 değerleri arasında olmuş oldu.

#include <SoftwareSerial.h>

int Button = 8;

const byte potPin = A0;
SoftwareSerial mySerial(7, 6); // RX, TX
int potValue;
bool countingStatus = false; // Saymayı başlatmak ve durdurmak için bayrak değişkeni

void setup() {

  Serial.begin(9600);
 
  pinMode(Button, INPUT);
 
  mySerial.begin(9600);
}

void loop()
{
  potValue = analogRead(potPin);

  if (digitalRead(Button) == 1) {
    delay(50); // Butonun mekanik tepkisini düzeltmek için küçük bir gecikme ekledik
    if (!countingStatus) { //  saymaDurumu false ise, yani sayma başlamamışsa
      countingStatus = true; // Saymayı başlat
      Serial.println("Counting Started!");
      
    }
    else { // Eğer  saymaDurumu true ise, yani sayma başlamışsa
      countingStatus = false; // Saymayı durdur
      Serial.println("Counting stopped!"); 
    }
  }

  if (countingStatus) { // Eğer saymaDurumu true ise, yani sayma başlamışsa
    

     potValue=  map(potValue,0,1023,0,255);//(Değişken adı,dönüştürülecek veri aralığı,dönüştürülmüş veri aralığı)
     mySerial.write(potValue);//potValue'da depolanan değeri tek bir bayt olarak seri porta gönderir
     Serial.print("Pot Value: ");//Seri monitöre yazdırır
    Serial.println(potValue);//potValue'da depolanan değeri seri monitöre yazdırır
     

  }
  delay(500);
}

Projemiz bitmiştir. Yazımı okuduğunuz için teşekkürler. Umarım yararlı olmuştur

Arduino ile yapılan diğer projelerimize göz atmak için:

Arduino Projeleri

HC-06 ve HC-05 Aralarında Nasıl Haberleşir? yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

Malzemeler

• ESP32CAM WIFI Bluetooth Geliştirme Kartı ve OV2640 Kamera Modülü
• Dişi-Dişi Jumper Kablo
• FT232RL FTDI USB-TTL Dönüştürücü-Programlayıcı

ESP32CAM Nasıl Kullanılır?

İlk olarak bu kart Arduino IDE programına otomatik olarak gelmediği için kart seçme menüsüne eklememiz gerekiyor. Bunun için de;

1. Öncelikle Arduino IDE programını açıyoruz ve Dosya > Tercihler kısmına geliyoruz ve altta “Ek Devre Kartları Yöneticisi URL’leri:” yazısının yanındaki boşluğa https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json linkini yapıştırıyoruz.
2. Daha sonra Araçlar > Kart > Kart Yöneticisi kısmına geliyoruz ve önümüzde açılan ekranın arama kısmına “ESP32” yazıyoruz. Ve aşağıdaki resimde gördüğümüz kart dizininin 1.0.6 versiyonunu ve 2.0.2 versiyonunu yüklüyoruz.
   
3. Şimdi Dosya > Örnekler > ESP32 > Camera > CameraWebServer örneğini açıyoruz. Bu örnek kodda değiştirmemiz gereken bazı satırlar var. Bunlardan ilki:
   
   Yukarıdaki resimdeki satırlardan sondan önceki satırı yorum olmaktan çıkarıp diğer satırları yorum haline getiriyoruz. İkinci olarak da:
   
   Yukarıdaki satırlarda ssid satırındaki tırnaklar içine internet ağımızın adını, password satırındaki tırnaklar içine de internet ağımızın şifresini giriyoruz. Burada modülümüzün bağlanacağı ağ ile kamera yayınını izleyeceğimiz cihazın aynı ağa bağlı olması gerekmektedir ve bu ağın 2.4 GHz olması gerekmektedir.
4. Şimdi kodumuzu modülümüze yüklemek için modülümüzün ftdi dönüştürücü modülü ile bağlantısını aşağıdaki resimdeki gibi gerçekleştiriyoruz.
5. Sıradaki adımda ftdi modülümüzü usb kablo aracılığıyla bilgisayarımıza bağlıyoruz.
6. Modülü bağladıktan sonra Araçlar > Kart > ESP32 Arduino > ESP32 Wrover Module seçeneğini seçiyoruz. Seçtikten sonra Araçlar > Partition Scheme > Huge APP seçeneğini de seçiyoruz. En son olarak da Araçlar > Port menüsünden ESP32 Modülümüzün bağlı olduğu portu seçiyoruz.
7. Kodumuzu artık yükleyebiliriz. Arduino IDE programı “Yükleme Tamamlandı” uyarısını verdikten sonra kartımızın bağlantısını bilgisayarımızdan hemen koparmamamız lazım. “Yükleme Tamamlandı” yazısının altında, aşağıdaki resimdeki gibi bazı yazılar belirmekte.
   
   İlk başta “Connecting” yazısı çıkmakta. Tam bu esnada modülümüzün reset tuşuna bir kere basmamız gerekmektedir.
   
   Daha sonra “Writing at 0x….” Yazılarının yanındaki ifadenin %100’e ulaşmasını bekliyoruz.
   
   En son olarak da “Hard resetting via RTS pin…” yazısını görmekteyiz. Bu yazı kodumuzun sorunsuz bir şekilde modülümüze yüklendiğini göstermektedir. (Eğer bu adımlara kadar herhangi bir hata ile karşılaştıysanız “ESP32-CAM WIFI Bluetooth Geliştirme Kartı ile Sıkça Karşılaşılan Hatalar ve Çözümleri” adlı yazımıza göz atmak isteyebilirsiniz.
8. Kodumuz yüklendikten sonra modülümüzün bilgisayarla bağlantısını ayırmamız gerekiyor. ESP32 CAM modülümüzün GPIO0 ve GND pinlerini kısa devre yapan jumper kablomuzu çıkarıyoruz ve modülümüzü yeniden bilgisayara bağlıyoruz.
9. Bağlantı gerçekleştikten sonra Arduino IDE üzerinden Seri Port Ekranını açıyoruz. Ekran açıldığı zaman ESP32 Cam modülümüz üzerindeki reset tuşuna bir defa basıyoruz.
   
   Modülümüze reset attıktan bir süre sonra yukarıdaki resimdeki gibi yazılar yazması gerekmekte. “http://” ile başlayan linki kopyalıyoruz ve internet tarayıcımızın arama çubuğuna yapıştırıyoruz.
10. Linkimizi yapıştırdıktan sonra bizi aşağıdaki resimdeki arayüz karşılıyor. Kamera yayınını başlatmak için sol alttaki kırmızı “Start Stream” tuşuna basıyoruz.
11. Son olarak karşımıza bu şekilde bir ekran çıkacak.
    
    bastığımız modülümüz aşağıdaki gibi kamera yayınına başlamaktadır.
    

Dilerseniz yandaki “Resolution” seçeneğinden kameranızın görüntü kalitesini değiştirebilirsiniz. Ancak görüntü kalitesi arttıkça kameranızın yayın kalitesinin akıcılığının azaldığını unutmayın. Ayrıca internet hızınıza göre en yüksek bazı görüntü kaliteleri açılmayabilir.

ESP32CAM ile İlgili Diğer Yazılarımız

ESP32CAM ve OV2640 Nasıl Kullanılır? yazısı ilk önce Robo90 - Blog üzerinde ortaya çıktı.

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ı.