FM Alıcısı Nedir, RDA5807 ile Arduino FM Radyo Nasıl Yapılır

Piyasadaki çoğu akıllı telefonun yerleşik FM alıcılarına sahip olduğunu biliyor musunuz? Evet, gerçekten! Ancak iPhone kullanıcıları için üzgünüm, bu özellik mevcut değil çünkü donanımı bunu desteklemiyor. Android gibi diğerleri için, FN çipinin kullanımına izin veren NextRadio uygulamasını indirmeniz yeterli!

Uydu İletişimi

Uydu iletişimi/veri iletimi, uzun mesafe telefon görüşmeleri, uzay istasyonu yayınları, uzay aracı doğrudan yayınları gibi tüketicilere uydu radyo alıcılarının sinyallerini gönderen FM alıcıları ve vericileri içerir.

Modemler

FM alıcıları, onlara kadar uzanan kablosuz verileri ileterek özel radyo ağları (PRN) oluşturan radyo modemlerinde bulunur. Bu tür modemler, gerçek zamanlı veri iletişiminin gerekli olduğu endüstriyel kullanımlarda anahtar rol oynamaktadır.

Veri iletiminde yüksek güvenilirlik ve çok yüksek çalışma süresi gerektiren uygulamalar için radyo iletişimi tercih edilmektedir.

RDA5807’ye Giriş

RDA5807’nin yaygın bir miniaturize FM alıcısı olduğunu söylediğimde hatırlıyor musunuz? Şimdi bunun ne hakkında olduğunu inceleyelim!

RDA5807M serisi, tamamen entegre bir sentezleyici ile en yeni nesil tek çipli yayın FM stereo radyo alıcısıdır. FM alıcısı, düşük maliyetli olmasına rağmen doğrudan dönüşümle ilgili zorlukları aşan dijital düşük-IF mimarisini kullanır!

Özellikleri şunlardır:

• Entegre düşük gürültü amplifikatörü, 50 ile 115MHz arasında dünya çapında bir yayın bandını destekler.
• Sentezleyici, tamamen entegre bir yonga üzerindeki RF, IF VCO ve yonga üzerindeki döngü filtresine sahiptir.
• Dijital düşük IF alıcısı.
• RDS/RBDS desteği.
• 32.768KHz kristal osilatör desteği.
• Otonom arama ayarı.
• Doğrudan otomatik kazanç kontrolü (AGC).
• Dijital adaptif gürültü iptali.

Daha fazla bilgi için, RDA5807M veri sayfasını buradan ziyaret edebilirsiniz!

RDA5807 ve TEA5767 Karşılaştırması

TEA5767 ile karşılaştırıldığında, aşağıdaki faktörlerde avantajlar sunmaktadır:

• RDA5807, kullanım için daha az harici bileşen gerektirir.
• 32 Ohm hoparlörlerle yüklenebilen ek entegre ses güç amplifikatörü.
• Bas artırma işlevi gibi bonus özellikler.

Not: RDA5807 çipinin kendisi, bir Arduino ile kullanılmak üzere ağır bir lehimleme gerektirdiğinden, daha kolay arayüzleme için entegre bir modül öneriyoruz!

Zaten ucuz ve kullanımı basit bir RDA5807 modülü arıyorsanız, bunu Seeed’de bulabilirsiniz!

Grove – I2C FM Alıcısı v1.1

Grove – I2C FM Alıcısı v1.1 RDA5807M tabanlı olduğundan, benzer özellikler paylaşacaktır. Ancak bu entegre modül ile bir Grove portu ve kulaklık arayüzü elde ediyorsunuz.

Grove ve kulaklık arayüzü desteği ile, harici bir kulaklık jakı lehimleme veya bir FM radyo inşa etmek için jumper kabloları kullanma konusunda endişelenmenize gerek kalmaz. Kullanım kolaylığı ve işlevselliği ile size büyük bir rahatlık sağlar!

Faydalarına inanmıyor musunuz? Kendiniz görün!

Ne kadar basit olduğunu görüyor musunuz? Grove sistemimiz yalnızca bu modül için değil, 200’den fazla modül destekliyoruz!

RDA5807 ile FM Radyo Eğitimi

Tamam, FM alıcıları ve RDA5807 hakkında temel bilgileri geçtik, şimdi bir FM radyo inşa etme eğitimimize geçelim!

• Bu eğitim için Grove – I2C FM Receiver v1.1 kullanacağız.

İhtiyacınız olanlar:

• Seeeduino, Seeed’in kendi Arduino kartıdır ve orijinaline göre bazı avantajlar sunar
  • Arduino UNO, bu eğitim için uygundur.
• Seeeduino V4.2’nin yalnızca 3 grove portu olduğu için, tüm modülleri barındırmak için Grove-Base Shield’e ihtiyacınız olacak.

Donanımı yapılandırmaya başlamadan önce, lütfen aşağıdakileri dikkate alın:

• Lütfen veri aktarımını gerçekleştiremeyen 2 telli kablo yerine içinde 4 tel bulunan USB kablosu kullanın. Elinizdeki kablodan emin değilseniz, buraya tıklayarak satın alabilirsiniz.
• Her Grove modülü bir Grove kablosu ile birlikte gelir, ancak kaybederseniz buraya tıklayarak satın alabilirsiniz.

Donanım yapılandırmaları:

• Adım 1: Grove – I2C FM Receiver v1.1’i Grove-Base Shield’in IIC portuna bağlayın.
• Adım 2: İlk Grove butonunu D2 portuna ve diğer butonu D3 portuna bağlayın.
• Adım 3: Grove – Rotary Angle sensörünü Grove – Base Shield’in A0 portuna bağlayın.
• Adım 4: Grove – Base Shield’i Seeeduino’ya takın.
• Adım 5: Kulaklık veya hoparlörü Grove – I2C FM Receiver’ın 3.5mm jakına takın.
• Adım 6: Seeeduino’yu bir USB kablosu ile PC’ye bağlayın.

Yukarıdaki adımları tamamladıktan sonra şöyle görünmelidir:

Yazılım yapılandırmaları:

• Adım 1: Grove -I2C FM Alıcı kütüphanesini indirin ve ardından kurun
• Adım 2: Arduino için kütüphaneyi kurun, emin değilseniz Kütüphane nasıl kurulur bölümüne bakın
• Adım 3: Aşağıdaki kodu Arduino IDE’nize kopyalayın, ardından kaydedin ve derleyin

/*
 * I2C_FM.ino
 * Grove-I2C_FM_Receiver modülü için demo kodu
 *
 * Copyright (c) 2012 seeed technology inc.
 * Yazar     : Jack Shao (jacky.shaoxg@gmail.com)
 * Oluşturma Tarihi: Tem 2014
 * Değişiklik Günlüğü :
 *
 * MIT Lisansı (MIT)
 *
 * Bu yazılım ve ilgili belgelerin (bundan böyle "Yazılım" olarak anılacaktır) bir kopyasını edinme izni, herhangi bir kişi için ücretsiz olarak verilmiştir.
 * Yazılım üzerinde kısıtlama olmaksızın işlem yapma hakları dahil, ancak bunlarla sınırlı olmamak üzere, kullanma, kopyalama, değiştirme, birleştirme, yayımlama, dağıtma, alt lisans verme ve/veya Yazılımın kopyalarını satma hakları verilmiştir.
 * Yazılımın sağlandığı kişilerin de bunu yapmasına izin verilir, aşağıdaki koşullara tabi olarak:
 *
 * Yukarıdaki telif hakkı bildirimi ve bu izin bildirimi, Yazılımın tüm kopyalarında veya önemli bölümlerinde yer almalıdır.
 *
 * YAZILIM "OLDUĞU GİBİ" SAĞLANMAKTADIR, HERHANGİ BİR TÜR GARANTİ YAPILMAKSIZIN, AÇIK VEYA ZIMNİ, TİCARİ ELVERİŞLİLİK, BELİRLİ BİR AMACA UYGUNLUK VE İHLAL ETMEME GARANTİLERİ DAHİL, ANCAK BUNLARLA SINIRLI OLMAMAK ÜZERE. YAZARLAR VEYA TELİF HAKKI SAHİPLERİ, YAZILIMDAN VEYA YAZILIMIN KULLANIMINDAN VEYA DİĞER İŞLEMLERDEN KAYNAKLANAN HERHANGİ BİR TALEP, ZARAR VEYA DİĞER SORUMLULUKLARDAN SORUMLU DEĞİLDİR.
 */
//
/*
 * I2C_FM.ino üzerinde Mel Patrick - Wabbit Wanch Design tarafından yapılan değişiklikler
 * FM bandında yukarı veya aşağı tarama için değiştirilmiş rutinler
 * Alınan istasyonun sinyal gücünü test etmek için değiştirilmiş rutin
 * Bas modunu ve MONO sinyalini desteklemek için değiştirilmiş rutinler
 * RSSI, bir istasyon ayarlandıktan hemen sonra okunursa küçük bir değer alırsınız
 * bu yüzden biraz beklemek (50ms) ve denemek daha iyidir. minSignalStrength
 * zayıf sinyale sahip bir istasyona kilitlenmeyi atlayacaktır (daha iyi alım için MONO bitini ayarlayabilirsiniz).
 */
#include <Arduino.h>
#include <Wire.h>
#include <EEPROM.h>

#define BTNUP          2// yukarı tarama için kullanılır (normalde KAPALI buton)
#define VOL_POT        A0// ses POT LOG taper 10K
#define BTNDN          3// aşağı tarama için kullanılır (normalde KAPALI buton)

uint16_t gChipID = 0;
uint8_t RDA5807P_REGW[10];

#define I2C_ADDR       0x10

#define READ            1
#define WRITE           0

#define ADRW            0x20
#define ADRR            0x21
//

// #define                 _SHARE_CRYSTAL_24MHz_
// #define                 _SHARE_CRYSTAL_12MHz_
#define                 _SHARE_CRYSTAL_32KHz_
// #define                 _FM_STEP_50K_

// 5807M,5807FP,5807NN,5807NP
uint8_t RDA5807N_initialization_reg[]={
#if defined(_SHARE_CRYSTAL_24MHz_)
  0xC4, 0x51, //02H:
#elif defined(_SHARE_CRYSTAL_12MHz_)
  0xC4, 0x11, //02H:
#elif defined(_SHARE_CRYSTAL_32KHz_)
  0xC4, 0x01,// 01'i 05 ile değiştirir, RDS/RBDS'yi etkinleştirir
#else
  0xC0, 0x01,
#endif
  0x00, 0x00,
  0x04, 0x00,
  0xC3, 0xad,  //05h
  0x60, 0x00,
  0x42, 0x12,
  0x00, 0x00,
  0x00, 0x00,
  0x00, 0x00,  //0x0ah
  0x00, 0x00,
  0x00, 0x00,
  0x00, 0x00,
  0x00, 0x00,
  0x00, 0x00,
  0x00, 0x00,  //0x10h
  0x00, 0x19,
  0x2a, 0x11,
  0xB0, 0x42,
  0x2A, 0x11,  //
  0xb8, 0x31,  //0x15h
  0xc0, 0x00,
  0x2a, 0x91,
  0x94, 0x00,
  0x00, 0xa8,
  0xc4, 0x00,  //0x1ah
  0xF7, 0xcF,
  0x12, 0x14,  //0x1ch
  0x80, 0x6F,
  0x46, 0x08,
  0x00, 0x86,  //10000110
  0x06, 0x61,  //0x20H
  0x00, 0x00,
  0x10, 0x9E,
  0x23, 0xC8,
  0x04, 0x06,
  0x0E, 0x1C,  //0x25H     //0x04 0x08
};

int16_t freq = 10110;
uint16_t vol = 1;
//
// eklenen öğeler - Mel
boolean bassBit = true;// bas artırma
boolean monoBit = false;// MONO'yu zorla, stereo değil
const boolean seekUP = true;
const boolean seekDN = false;
uint8_t minSignalStrength = 36;// bunun altındaki her şey muhtemelen daha iyi alım için MONO bayrağını ayarlayın
uint8_t signalStrength;
long previousMillis = 0;// fonksiyonun en son çağrıldığı zaman
long interval = 2000;// sinyal seviyesi fonksiyonu için aralık (2 saniye)
int8_t stationStep = 10;// istasyonlar arasındaki kHz adımları (Kuzey Amerika = 10)
boolean hasVolumePot = true;// POT'un bağlı olup olmadığını gösteren bayrak
//
void setup()
{
  Wire.begin();
  loadDefaults();// önceki radyo ayarlarından varsayılanları yükle
  Serial.begin(9600);
  Serial.println("Başlatıldı");
  //=======================
  // rda5807 güç açma sıfırlama
  RDA5807P_PowerOnReset();
  RDA5807P_SetMute(false);

  //=======================
  pinMode(BTNUP, INPUT_PULLUP);
  pinMode(VOL_POT, INPUT);
  pinMode(BTNDN, INPUT_PULLUP);
  //=======================
  RDA5807P_SetVolumeLevel(vol);// ses için bir POT'unuz yoksa bunu kullanın (0-15)
  RDA5807P_SetFreq( freq );
}

void loop()
{
  unsigned long currentMillis = millis();

  if(currentMillis - previousMillis > interval) {
    // LED'in en son ne zaman yanıp söndüğünü kaydedin
    previousMillis = currentMillis;
    showSignalStrength();
  }
  //
  if (digitalRead(BTNUP) == 1)
  {
    delay(100);
    if (digitalRead(BTNUP) == 1)
      fmSeek(seekUP);
    while(digitalRead(BTNUP) == 1);
  }
  if (digitalRead(BTNDN) == 1)
  {
    delay(100);
    if (digitalRead(BTNDN) == 1)
      fmSeek(seekDN);
    while(digitalRead(BTNDN) == 1);
  }
  if (hasVolumePot == true) setVolume();// POT'u okumak için bunu kullanın
}
//
void setVolume() {
  unsigned int temp_vol;
  temp_vol = analogRead( VOL_POT );
  if (abs(temp_vol - vol)>5)
  {
    if (vol != temp_vol) {// pot hareket etmedikçe ses seviyesini değiştirmeye gerek yok
      vol = temp_vol;
      unsigned char hex_vol = map(vol, 0, 1023, 0, 0xf);
      RDA5807P_SetVolumeLevel(hex_vol);
      saveDefaults();// yeni sesi EEPROM'a kaydet
    }
  }
}
//
void fmSeek(boolean theDir) {
  int signalStrength;
  if (!theDir) {
    Serial.println("Aşağı taramaya başla...");
  }
  else
  {
    Serial.println("Yukarı taramaya başla...");
  }
  do {
    do{
      if (theDir == seekUP) {
        freq += stationStep;
      }
      else
      {
        freq -= stationStep;
      }
      if (freq > 10800) freq = 8800;
      if (freq < 8800) freq = 10800;
      // Serial.println(freq);
    }
    while(!RDA5807P_ValidStop(freq));
    delay(50);
    signalStrength = RDA5807P_GetSigLvl(freq);// veri sayfasına göre maksimum 63, ama daha fazlasını gördüm
  }
  while (signalStrength < minSignalStrength);// minimum sinyal gücü, aramaya devam et
  showRadioStation();
  saveDefaults();// yeni istasyon seçimlerini EEPROM'a kaydet
}
//
void showRadioStation() {
  Serial.print("Kararlı Frekans:");
  Serial.print(((float)freq)/100.0f);
  Serial.println("MHz");
}
//
void showSignalStrength() {
  signalStrength = RDA5807P_GetSigLvl(freq);// maksimum 63... belirtildiği gibi
  Serial.print("Sinyal Gücü: ");
  Serial.println(signalStrength);
}

//===========================================================
// FM fonksiyonları
//===========================================================
unsigned char OperationRDAFM_2w(unsigned char operation, unsigned char *data, int numBytes)
{
  if(operation == READ)
  {
    Wire.requestFrom(I2C_ADDR, numBytes);
    for(int i=0;i<numBytes;i++)
    {
      *data++ = Wire.read();
    }
  }
  else
  {
    Wire.beginTransmission(I2C_ADDR);
    for(int i=0;i<numBytes;i++)
    {
      Wire.write(*data++);
    }
    Wire.endTransmission();
  }
  return 0;
}


/**
 * @brief RDA5807P'yi güç açma sırasında sıfırlayın
 * @yazar RDA RDA Ri'an Zeng
 * @tarih 2008-11-05
 * @param void
 * @return void
 * @retval
 */
void  RDA5807P_PowerOnReset(void)
{
  RDA5807P_Intialization();
}

/**
 * @brief RDA5807P güç kapatma fonksiyonu
 * @yazar RDA Ri'an Zeng
 * @tarih 2008-11-05
 * @param void
 * @return void
 * @retval
 */
void  RDA5807P_PowerOffProc(void)
{
  RDA5807P_REGW[1] &= (~1);
  OperationRDAFM_2w(WRITE, &(RDA5807P_REGW[0]), 2);
}

/**
 * @brief RDA5807P'yi sessiz moda ayarlayın
 * @yazar RDA Ri'an Zeng
 * @tarih 2008-11-05
 * @param bool mute: eğer mute true ise, sessiz yap; eğer mute false ise, sessiz yapma
 * @return void
 * @retval
 */
void RDA5807P_SetMute(boolean mute)
{
  if(mute)
    RDA5807P_REGW[0] &=  ~(1<<6);
  else
    RDA5807P_REGW[0] |= 1<<6;
  RDA5807P_REGW[0] |= monoBit<<5;
  RDA5807P_REGW[0] |= bassBit<<4;
  OperationRDAFM_2w(WRITE, &(RDA5807P_REGW[0]), 2);// RDA5807M_REGW
  delay(50);    // 50 ms bekle
}
//
/*************************************************
 * @brief Frekans ayarlama fonksiyonu
 * @yazar RDA Ri'an Zeng
 * @tarih 2008-11-05
 * @param int16_t curFreq: frekans değeri
 * @return void
 * @retval
 ***********************************************/
void RDA5807P_SetFreq(int16_t curFreq)
{
  uint16_t curChan;
  curChan=RDA5807P_FreqToChan(curFreq);

  if((curFreq >= 6500)&&(curFreq < 7600))
  {
    RDA5807P_REGW[3] = 0x0c;
  }
  else if((curFreq >= 7600)&&(curFreq < 10800))
  {
    RDA5807P_REGW[3] = 0x08;// BAND bitlerini ayarlar (00xx = 87-108, 01xx=76-91, 10xx=76-108, 11xx=65-76
    // Kuzey Amerika için bunun bazı bilinmeyen nedenlerden dolayı 10xx olarak ayarlanması gerekir
  }
  // Sessiz yapma
  RDA5807P_REGW[0] |= 1<<6;
  RDA5807P_REGW[0] |= monoBit<<5;
  RDA5807P_REGW[0] |= bassBit<<4;
  // handleBits();
  RDA5807P_REGW[2]=curChan>>2;
  RDA5807P_REGW[3]=(((curChan&0x0003)<<6)|0x10) | (RDA5807P_REGW[3]&0x0f);    // ayar bitini ayarla

  OperationRDAFM_2w(WRITE, &(RDA5807P_REGW[0]), 4);
  delay(50);     // 5 ms bekle
  showRadioStation();
}
//
/**
 * @brief Otomatik arama için istasyon yargısı
 * @Otomatik arama modunda, bu fonksiyonu frekansın bir istasyona sahip olup olmadığını yargılamak için kullanır
 * @yazar RDA Ri'an Zeng
 * @tarih 2008-11-05
 * @param int16_t freq: frekans değeri
 * @return bool: eğer true dönerse, frekans gerçek bir istasyona sahiptir; aksi takdirde bir istasyon yoktur
 * @retval
 */
boolean RDA5807P_ValidStop(int freq)
{
  uint8_t RDA5807P_reg_data[4]={
    0                                                  };
  uint8_t falseStation = 0;
  uint8_t i=0;
  uint16_t curChan;

  if((freq >= 6500)&&(freq < 7600))
  {
    RDA5807P_REGW[3] = 0x0c;
  }
  else if((freq >= 7600)&&(freq < 10800))
  {
    RDA5807P_REGW[3] = 0x08;// BAND bitlerini ayarlar (00xx = 87-108, 01xx=76-91, 10xx=76-108, 11xx=65-76
    // Kuzey Amerika için bunun bazı bilinmeyen nedenlerden dolayı 10xx olarak ayarlanması gerekir
  }
  curChan=RDA5807P_FreqToChan(freq);
  // Sessiz yapma bit 9, tarama yönüdür (0=aşağı tarama, 1=yukarı tarama).
  // 02H 14
  RDA5807P_REGW[0] |=   1<<6;// sıfır kaydı, bit 15'ten bit 8'e kadar (bu bit 14'e kaydırılır)
  RDA5807P_REGW[0] |= monoBit<<5;
  RDA5807P_REGW[0] |= bassBit<<4;
  // handleBits();
  RDA5807P_reg_data[0]=RDA5807P_REGW[0];
  RDA5807P_reg_data[1]=RDA5807P_REGW[1];
  RDA5807P_reg_data[2]=curChan>>2;// 03H 15:8 CHAN
  RDA5807P_reg_data[3]=(((curChan&0x0003)<<6)|0x10) | (RDA5807P_REGW[3]&0x0f);//
  OperationRDAFM_2w(WRITE,&(RDA5807P_reg_data[0]), 4);

  delay(50);    // 25 ms bekle

  if (0x5808 == gChipID)
    OperationRDAFM_2w(READ,&(RDA5807P_reg_data[0]), 4); //
  else
  {
    do
    {
      i++;
      if(i>5) return 0;

      delay(30);
      // REG0A&0B'yi oku
      OperationRDAFM_2w(READ,&(RDA5807P_reg_data[0]), 4);
    }
    while((RDA5807P_reg_data[0]&0x40)==0);
  }

  // FM_TRUE'yu kontrol et
  if((RDA5807P_reg_data[2] &0x01)==0) falseStation=1;// 0B 8  FM TRUE

  if(freq==9600) falseStation=1;// Kuzey Amerika - eğer aşağı tarıyorsanız, radyo bir nedenle 9600'e kilitlenecektir!
  delay(50);
  if (falseStation==1)
    return 0;
  else
    return 1;
}

/**
 * @brief Mevcut frekansın sinyal seviyesini (RSSI) alın
 * @yazar RDA Ri'an Zeng
 * @tarih 2008-11-05
 * @param int16_t curf: frekans değeri
 * @return uint8_t: sinyal seviyesi (RSSI)
 * @retval
 */
uint8_t RDA5807P_GetSigLvl( int16_t curf )
{
  uint8_t RDA5807P_reg_data[4]={
    0                                                  };
  OperationRDAFM_2w(READ,&(RDA5807P_reg_data[0]), 4);
  delay(50);    // 50 ms bekle
  return  (RDA5807P_reg_data[2]>>1);  /*??rssi*/
}

/**
 * @brief FM ses seviyesini ayarlayın
 * @Bu fonksiyonu değiştirmek için sistem ses işlemini kullanmak daha iyidir
 * @yazar RDA Ri'an Zeng
 * @tarih 2008-11-05
 * @param uint8_t level: ses değeri
 * @return void
 * @retval
 */
void RDA5807P_SetVolumeLevel(uint8_t level)
{
  uint8_t RDA5807P_reg_data[8];
  uint8_t i = 0;

  for (i=0;i<8;i++)
    RDA5807P_reg_data[i] = RDA5807P_REGW[i];

  RDA5807P_reg_data[7]=(( RDA5807P_REGW[7] & 0xf0 ) | (level & 0x0f));

  RDA5807P_reg_data[3] &= (~(0x10));// ayarı devre dışı bırak

  OperationRDAFM_2w(WRITE, &(RDA5807P_reg_data[0]), 8);
  delay(50);    // 50 ms bekle
}

/**
 * @brief RDA5807P'yi başlat
 * @yazar RDA Ri'an Zeng
 * @tarih 2008-11-05
 * @param void
 * @return bool: eğer true ise, işlem başarılıdır; aksi takdirde başarısızdır
 * @retval
 **/
boolean  RDA5807P_Intialization(void)
{
  uint8_t error_ind = 0;
  uint8_t RDA5807P_REGR[10]={
    0                                                  };
  uint8_t i = 0;

  RDA5807P_REGW[0] = 0x00;
  RDA5807P_REGW[0] |= monoBit<<5;
  RDA5807P_REGW[0] |= bassBit<<4;
  RDA5807P_REGW[1] = 0x02;

  error_ind = OperationRDAFM_2w(WRITE, (uint8_t *)&RDA5807P_REGW[0], 2);// yumuşak sıfırlama
  delay(50);

  error_ind = OperationRDAFM_2w(READ, (uint8_t *)&RDA5807P_REGR[0], 10);
  delay(50);

  gChipID = RDA5807P_REGR[8];
  gChipID = ((gChipID << 8) | RDA5807P_REGR[9]);

  Serial.print("Çip ID: 0x");
  Serial.println(gChipID, HEX);

  for (i=0;i<8;i++) {
    RDA5807P_REGW[i] = RDA5807N_initialization_reg[i];
  }

  error_ind = OperationRDAFM_2w(WRITE, (uint8_t *)&RDA5807N_initialization_reg[0], 2); // güç aç
  delay(600);
  // Serial.println(sizeof(RDA5807N_initialization_reg));
  error_ind = OperationRDAFM_2w(WRITE, (uint8_t *)&RDA5807N_initialization_reg[0], sizeof(RDA5807N_initialization_reg));

  delay(50);         // 50 ms bekle

  if (error_ind )
    return 0;
  else
    return 1;
}
//
/**
 * @brief frekansı kanal değerine dönüştür
 * @yazar RDA Ri'an Zeng
 * @tarih 2008-11-05
 * @param uint16 frekans: dönüştürülen frekans
 * @return uint16: kanal değeri
 * @retval
 * Amerika Birleşik Devletleri'nde, frekans modülasyonlu yayın istasyonları 87.8 MHz ile 108.0 MHz arasında bir frekans bandında çalışır,
 * toplam 20.2 MHz. 101 kanala bölünmüştür, her biri 0.2 MHz genişliğinde, "kanal 200" ile "kanal 300" arasında adlandırılmıştır.
 * Gerçekte, kimse (FCC dışında) bu kanal numaralarını kullanmaz; bunun yerine frekanslar kullanılır.
 */
uint16_t RDA5807P_FreqToChan(uint16_t frequency) {
  uint8_t channelSpacing = 10;
  uint16_t channel = 0;

  if((frequency >= 6500)&&(frequency < 7600))
  {
    channel = (frequency - 6500)/channelSpacing;
  }
  else if((frequency >= 7600)&&(frequency < 10800))
  {
    channel = (frequency - 7600)/channelSpacing;
  }
  return (channel);
}
//
void loadDefaults() {
  char myCode[9] = "Grove_FM";
  char myInit[9] = "blank123";
  /*
  * EEPROM'daki byte haritası
   * 8, 9 yeniden başlatma için varsayılan frekans
   * 10, 11 radyonun mevcut ön ayar sesi (eğer pot yoksa kullanılır)
   */
  for (int i=0; i < 8; i++) {
    myInit[i] = EEPROM.read(i);// şeyin BAŞLATILIP BAŞLATILMADIĞINI görmek için oku
  }
  if (strcmp(myCode, myInit) == 0) {// eğer bu SIFIRSA (daha önce bazılarını yazdık), o zaman değerleri oku
    freq = epReadINT(8);// frekansı EEPROM 8 ve 9'dan (bir INT için iki byte) geri oku
    if (!hasVolumePot) vol = epReadINT(10);// ses ayarını geri oku ama bayrak yanlış değilse kullanma
  }
  else// varsayılanlarımız yok, bu yüzden önce bazılarını kaydetmemiz gerekiyor
  {
    for (int i=0; i < 8; i++) {
      EEPROM.write(i, myCode[i]);// bunu EEPROM'a yazın, böylece kaydedildiğini gösterir
    }
    saveDefaults();// mevcut varsayılan ayarları yaz
  }
}
//
void saveDefaults() {
  epWriteINT(8, freq);// yeniden başlatma için INT için iki byte yaz
  epWriteINT(10, vol);// mevcut ses POT ayarını yaz
}
//
void epWriteINT(int where, int theVal) {
  union uData
  {
    byte stuff[2];
    int f1;// 2 byte bellek
  }
  u;
  u.f1 = theVal;// birliğe kopyala
  for (int j=0; j < 2; j++) {// şimdi 2 byte bellek yazmamız gerekiyor
    EEPROM.write(where + j, u.stuff[j]);// EEPROM'a yaz
  }
}
//
long epReadINT(int where) {
  union uData
  {
    byte stuff[2];
    int f1;// 2 byte bellek
  }
  u;
  for (int j=0; j < 2; j++) {
    u.stuff[j]=EEPROM.read(where + j);// bu bellek konumundaki 2 byte'ı geri oku
  }
  return u.f1;
}
//
void epWriteLong(int where, long theVal) {
  union uData
  {
    byte stuff[4];
    long f1;// 4 byte bellek
  }
  u;
  u.f1 = theVal;// birliğe kopyala
  for (int j=0; j < 4; j++) {// şimdi 4 byte bellek yazmamız gerekiyor
    EEPROM.write(where + j, u.stuff[j]);// EEPROM'a yaz
  }
}
//
long epReadLong(int where) {
  union uData
  {
    byte stuff[4];
    long f1;// 4 byte bellek
  }
  u;
  for (int j=0; j < 4; j++) {
    u.stuff[j]=EEPROM.read(where + j);// bu bellek konumundaki 4 byte'ı geri oku
  }
  return u.f1;
}

• Adım 4: Demo’yu yükleyin, kodu nasıl yükleyeceğinizden emin değilseniz, lütfen kılavuzumuza bakın
• Adım 5: Arduino IDE’nin Seri Monitörünü açmak için Araçlar -> Seri Monitör’e tıklayın veya klavyenizde CTRL + Shift + M tuşlarına basın.

Her şey yolunda giderse, aşağıdaki sonucu elde edeceksiniz:

Başladı
Çip ID: 0x5808
Stabil Frekans: 102.60MHz
Sinyal Gücü: 46
Sinyal Gücü: 46
Sinyal Gücü: 45
Sinyal Gücü: 45
Sinyal Gücü: 45
Sinyal Gücü: 45
Aşağıya doğru aramaya başla...
Stabil Frekans: 94.00MHz
Sinyal Gücü: 44
Sinyal Gücü: 51
Sinyal Gücü: 51
Sinyal Gücü: 50
Sinyal Gücü: 50
Sinyal Gücü: 51

Artık kendi FM radyonuza sahipsiniz!

• Radyo istasyonları arasında basitçe geçiş yapmak için Grove – butonlarına basabilirsiniz.
• Ses seviyesini ayarlamak için Grove – döner açılı sensörü döndürebilirsiniz.

İsterseniz, tüm kurulumu daha çok bir radyo gibi görünmesi için konut kutuları tasarlayabilirsiniz!

Kaynaklar ve İleriye Dönük

Eğer şu anda bir RDA5807 çipine sahipseniz ve bir FM Radyo inşa etmeyi düşünüyorsanız, Hackster Topluluğundan bazı proje eğitimleri burada!

• Frekans Ekranlı FM Radyo – Tauno Erik
• RDA5807 ile Mini Stereo Radyo – Mirko Pavelski
• Arduino Nano ve RDA8057M ile FM Radyo – Neeraj Rane

Grove – I2C FM Alıcı v1.1 kaynakları:

• [Zip]Grove-I2C FM Alıcı v1.1 eagle dosyası

Özet

FM alıcıları ve RDA5807 hakkında bugünlük bu kadar. Umarım bugünkü blog ile bunun ne olduğu, nasıl çalıştığı, kullanımları ve bir FM radyo nasıl inşa edilir konusunda daha derin bir anlayışa sahip olursunuz!

Kendi FM radyonuzu Grove – I2C FM Alıcı v1.1 ile inşa etmeye bugün başlayın!