VKV přijímač 87 - 108 MHz (senior edition)

pro Arduino

Programy zdarma, Arduino návody, tratě pro Open Rails a MSTS.

Celé toto "dílo" vzniklo, když moje mamka v již dost pokročilém věku projevila zájem o nové rádio s hodinami na noční stolek. Dosud používala asi třicet let starý radiobudík, který byl už hodně vychozený, včetně praskajícího potenciometru.
Na první pohled jednoduchá záležitost. Jenže nastal problém. Žádný prodávaný přijímač nevyhovoval. Buď neměl hodiny, nebo je měl, ale s moc malým displejem, špatně podsvíceným a podobně. Kapitola sama pro sebe bylo složité ovládání. Ono to asi jinak udělat nejde, ale pokud posloucháte jen jednu jedinou stanici, kupa věcí je zbytečných. Takže jsem se rozhodl pokusit se něco postavit sám. Požadavky byly:

velký hodinový displej s časem aktualizovaným z RDS
velmi jednoduché ovládání a zároveň aby nebylo úplně snadné přeladit stanici.

V běžném použití se ovládá pouze hlasitost pomocí potenciometru s vypínačem u jedné "pevně" naladěné stanice (ladění je samozřejmě možné, viz dále). Tedy něco, co připomíná bývalý rozhlas po drátě, jistěže mimo hodin, ty dráťák neměl. V dobách minulých byl poměrně rozšířený, hlavně v různých veřejných provozovnách, například u holiče, v kancelářích, v dílnách a podobně. Hrála tam stanice Praha (dnešní ČRO 2). Myšlenka dobrá, ale tehdejší obsah poněkud nezajímavý.
K naladění "pevné" stanice slouží tři tlačítka. Musí se držet T1 a pomocí T2/T3 se ladí vpřed/zpět (viz schéma) s krokem 0.1 MHz. Pokud T1 stisknuto nebude, tak samotná T2/T3 ovládají jas hodinového displeje. Tedy nějaké náhodné zavadění o tlačítko přijímač nerozladí. Výsledek je toto:
schema

stáhnout toto schéma v PDF

Po prvním pospojování modulů jsem zjistil, že LCD hodinový displej pořádně ruší. Z reproduktoru se ozývalo nepříjemné pískání. Po vložení filtru do napájení displeje, sestávající z tlumivky Tl1 a kondenzátoru C1, pískot zmizel.
Další problém nastal s časovou značkou z RDS. U slabších stanic, nebo při nějakém rušení, byl čas přečten chybně. Nevím, jestli existuje nějaký způsob, jak ověřit správnost přes CRC, či něco podobného. Na nic jsem nepřišel, takže jsem to řešil postupným čtením několika časů, a pokud časy šly po sobě v minutových intervalech, tak jsem jej považoval za správný a aktualizoval modul RTC. Po úspěšné aktualizaci se čas zase kontroluje až následující den. Ono není třeba čas načítat pořád dokola.
Upozorňuji, že modul radiopřijímače VKV s RDA5807 vyžaduje napájení 3.3V. Pokud jej připojíte k 5V a více, riskujete jeho zničení. Zde je napájen z vývodu 3V3 z Arduina.

Moduly a součástky:
Většina modulů, ani součástek není úplně kritická. Místo Arduino Nano můžete klidně použít UNO, nebo i Megu. Displej můžete dát i jiný a jinak barevný, stejně tak i nf zesilovač. Tento může být libovolný, kterému vyhoví napájení 8-12V. Tato verze je mono, kde VKV modul má připojen pouze jeden kanál. Zesilovač však můžete použít stereofonní, kdy připojíte oba kanály (v programu pak vymažte řádek rx.setMono(true)). Potenciometr nemusí být s vypínačem, vypínač se namontuje zvlášť, atd, atd... Pokud moduly "pověsite" na jiné piny Arduina, nebo použijete modul jiný, musíte tyto změny zohlednit v programu.

použité moduly a součástky

Modul RTC DS1302-hodiny reálného času je napájený baterií CR2032, která se dá běžně koupit. Univerzální plošný spoj jsem použil k připojení modulu přijímače RDA5807 (pozor, je titěrný), osazení odporů, filtru displeje a filtru napájení.
Vypínačem se vypíná pouze nf zesilovač. Hodiny i VKV tuner jsou zapnuty neustále, pokud je zdroj připojen. Zdroj můžete použít libovolný mezi 8V až 12V. Hlavně dobře odrušený. Řada spínaných zdrojů (nabíječek), není z nejkvalitnějších. Pak se v reproduktoru ozývá brum a rušení příjmu dělá problémy aktualizaci času z RDS. Jako anténu můžete použít kus izolovaného lanka dlouhého 60 - 80cm.

Zdrojový kod vkv2.ino stáhnout


/*
 * Radio I2C:
 *  adresa: 16 (0x10)
 *  adresa: 17 (0x11)
 *  adresa: 96 (0x60)
 * 
 */

#define noDBG //define SETD 12

#define CYKLUS_COUNT 8 //pocet cteni RDS casu, nez se aktualizuji RTC 
#define MAX_TRY 32 //maximalni pocet pokusu cteni RDS casu pro naladenou stanici
#define KEY_TIME 16 //casova porodleva tlacitek
#define EPROM_FQ 1 //adresa ulozeni stanice v eprom
#define PIN_UP 5 //piny pro tlacitka
#define PIN_DN 6
#define PIN_PW 9

#include <Wire.h> 
#include <EEPROM.h>
#include <RDA5807.h>
#include <Ds1302.h>
#include <TM1637Display.h>

RDA5807 rx;
Ds1302 rtc(4, 2, 3); // RST, DAT, CLK
TM1637Display dsp(8, 7); // CLK, DIO

Ds1302::DateTime dt;
int minutRDS[CYKLUS_COUNT]; //minut celkem
int elapsed = 0; //cyklus
byte cyklus_index = 0; //poradi prevzeti casu z RDS
byte jas = 11; //jas displeje 8 - 15
byte adjustDay = 0; //den, pro aktualizaci RDS, cas se aktualizuje jednou denne
byte tryRDS = 0; //pocet neuspenych pokusu cteni casu z RDS
byte debug1, debug2; //hodnoty ladeni
bool stoppedRDS = false; //po precteni casu RDS bude pauza
bool colon = true; //blikani dvojtecky
bool writeFq = false; //stamice se do eprom uklada za 20sec po naladeni
bool testMode = false;

#ifdef DBG
byte ddebug1 = 0xff;
byte ddebug2 = 0xff;

void debugWire() {
  Serial.begin(9600);
  while (!Serial) {}
  Serial.println ();
  Serial.println ("Hledam I2C .....");
  Wire.begin();
  for (byte i = 1; i < 120; i++) {
    Wire.beginTransmission (i);
    if (Wire.endTransmission () == 0) {
      Serial.print ("Nalezena adresa: ");
      Serial.print (i, DEC);
      Serial.print (" (0x");
      Serial.print (i, HEX);
      Serial.println (")");
      delay (1);
   }
 }
 Serial.println ("Hotovo");
 testMode = true;
}
#endif  
 
//-- inicializace -------------------------------------------------------------------------------

bool initRadio() {
  rx.setup();
  rx.setRDS(true);
  rx.setVolume(3);
  delay(512);
  rx.setRDS(true);
  rx.setRdsFifo(true);
  rx.setLnaPortSel(3);
  rx.setAFC(true);
  rx.setMono(true); //rx.setFrequency(freq); //9930 evropa2, 10200 CRO2, 10430 F1
  delay(512); //rx.powerUp();
  return true;  
}

void initDisplay() {
  delay(1024);
  dsp.clear();
  dsp.setBrightness(jas);
}

void initRTC() {
  rtc.init();
  rtc.getDateTime(&dt);
 #ifdef SETD
  rtc.halt();
  while (!rtc.isHalted());
  dt.day = SETD;
  rtc.setDateTime(&dt);
  rtc.start(); 
  debug1 = 0xdc; debug2 = dt.day;
 #endif    
 #ifdef DBG
  Serial.print(dt.day); Serial.print("."); Serial.print(dt.month); Serial.print(".");Serial.println(dt.year);
  Serial.print(dt.hour); Serial.print(":"); Serial.print(dt.minute); Serial.print(" - ");Serial.println(dt.dow);
 #endif    
}

//-- Display -----------------------------------------------------------------------------------------

void showReset() {
  dsp.showNumberDec(dt.day, true, 2, 0);
  dsp.showNumberDec(dt.month, true, 2, 2);
  delay(1024);
}

void showHM() {
  rtc.getDateTime(&dt);
  byte c;
  if (testMode) {
    c = 0b01000000;
  }
  else {
    if (colon) c = 0b01000000; else c = 0b00000000;
    colon = !colon;
  }  
  word n = (dt.hour * 100) + dt.minute;
  dsp.showNumberDecEx(n, c, true); //dsp.showNumberDecEx(dt.minute, c, true, 2, 2);
}

void showDebug() {
 #ifdef DBG
  if ((ddebug1 != debug1) || (ddebug2 != debug2)) {
    Serial.print("debug1 = "); Serial.print(debug1, HEX); Serial.print("; debug2 = "); Serial.println(debug2);
  }  
  ddebug1 = debug1; ddebug2 = debug2; 
 #endif
  if ((debug1 + debug2) == 0) {
    showHM();
    return;
  }
  dsp.showNumberHexEx(debug1, 0b01000000, true, 2, 0);
  if (debug2 > 99) debug2 = 99;
  dsp.showNumberDec(debug2, true, 2, 2);
}

void showFq() {
  word f = rx.getFrequency();
  dsp.showNumberDec(f / 10, true); //
  elapsed = 0;
}

void showInfo() {
  if (testMode) showDebug(); else showHM();
}

void jasInc() {
  if (jas < 15) jas++;
  dsp.setBrightness(jas);
  showInfo();
}

void jasDec() {
  if (jas > 8) jas--;
  dsp.setBrightness(jas);
  showInfo();
}

//-- RTC --------------------------------------------------------------------------------------------

void setRTC(byte hh, byte mm) {
  rtc.halt();
  while (!rtc.isHalted());
  dt.hour = hh; dt.minute = mm; dt.second = 0;
  rtc.setDateTime(&dt);  
  rtc.start();
  #ifdef DBG
  Serial.println("setRTC");
  #endif
}

void updateTime(int m) {
  byte H = m / 60;
  byte M = m % 60;
  rtc.getDateTime(&dt);
  adjustDay = dt.day;
  #ifdef DBG
  Serial.print("adjustDay = "); Serial.println(dt.day);
  #endif
  if ((dt.hour != H) || (dt.minute != M) || (dt.second > 10)) {
    setRTC(H, M);    
    if (testMode) {
      showHM();
      delay(1024);
    } else {
      showReset();      
    }
  }  
  debug1 = 0xad; debug2 = dt.second;
}

//-- radio / RDS -------------------------------------------------------------------------------------

word getFq() {
  word result = 8750 + (10 * EEPROM.read(EPROM_FQ));
  if ((result < 8750) || (result > 10800)) {    
    rx.setFrequency(9400);
    result = rx.getFrequency();
    if ((result < 8750) || (result > 10800)) result = 8750;
  }
  return result;
}

void updateFq(word f) {
  byte n = (f - 8750) / 10;
  if (n <= 205) EEPROM.update(EPROM_FQ, n);
  writeFq = false;
}

void setFreq(byte up) {
  cyklus_index = 0; tryRDS = 0;
  word f = rx.getFrequency();
  if (up) {
    if (f < 10800) rx.setFrequencyUp(); else rx.setFrequency(8750);
  }  
  else {
    if (f > 8750) rx.setFrequencyDown(); else rx.setFrequency(10800);
  }
  writeFq = true;
  showFq();  
}

bool testRDS() { //pokud nesedi predesly, nema smysl jet dal, pojede znovu
  if (cyklus_index > 0) {
    int n = (minutRDS[cyklus_index] - minutRDS[cyklus_index - 1]);
    bool result = ((n == 1) || (n == 2));
    if (result) debug1 = 0xd0 + cyklus_index; else debug1 = 0xe0 + cyklus_index;
    debug2 = n;
    if (!result) tryRDS++;
    return result;
  }
  return true;  
}

bool timeRDS() {
  bool result = ((rx.getRdsReady() &&  rx.hasRdsInfo()));
  if (result) {
    char *rdsTime;
    rdsTime = rx.getRdsLocalTime(); 
    result = false;
    if (rdsTime != NULL ) {
      if (strlen(rdsTime) == 5) {
        char h[3] = {0,0,0};
        char m[3] = {0,0,0};
        strncpy(h, &rdsTime[0], 2);
        strncpy(m, &rdsTime[3], 2);
        byte H = atoi(h);
        byte M = atoi(m);
        minutRDS[cyklus_index] = (60 * H) + M;
        debug1 = 0xd0 + cyklus_index; debug2 = 1;
        result = rdsTime[2] == ':';
      }  
    }
  }
  return result;
}

//-- tlacitka ----------------------------------------------------------------------------

bool shiftPressed() {
  return (!digitalRead(PIN_PW));  
}

byte keyPressed() {
  byte result = 0;
  byte cnt = 0;
  bool pressed;
  do {
    pressed = false;
    if (shiftPressed()) {
      bitSet(result, 7); //80 - shift
    }
    if (!digitalRead(PIN_DN)) {
      bitSet(result, 0); //01 - predesly
      pressed = true;
    }
    if (!digitalRead(PIN_UP)) {
      bitSet(result, 1); //02 - dalsi
      pressed = true;
    }
    if (pressed) {
      cnt++;
      delay(8);
    }
  } while (pressed && (cnt < KEY_TIME));
  if (cnt < KEY_TIME) result = 0;
  return result;
}

//-- Main -------------------------------------------------------------------------------

void setup() {
 #ifdef DBG
  debugWire();
 #endif  
  pinMode(PIN_UP, INPUT);
  pinMode(PIN_DN, INPUT);
  pinMode(PIN_PW, INPUT);
  initRTC();
  initRadio();  
  initDisplay();
  rx.setFrequency(getFq());
  showReset();
}

void loop() {  
  elapsed++;

  bool s = shiftPressed();
  byte k = keyPressed();
  if (k || s) {
    if (s) showFq(); //pri stisknutem shiftu zobrazuje naladeny kmitocet
    if (k == 1) jasDec(); // jas -
    if (k == 2) jasInc(); //jas +
    if ((k == 0x81) || (k == 0x82)) setFreq(k == 0x82); //ladeni vpred / zpet
    if (k == 0x83) {
      while (keyPressed()); //pocka na key up
      testMode = !testMode;  //stisk vech tri tlacitek najednou nahodi/shodi test mod
    } //debug1 = k; debug2 = s;
    return;
  }
  if ((elapsed % 125) == 0) showInfo();
  if (elapsed > 2500) {
    elapsed = 0;
    stoppedRDS = ((adjustDay != 0) && (adjustDay == dt.day));  //false;
    if (stoppedRDS) debug1 = 0xdb; else debug1 = 0xda;
    debug2 = tryRDS; 
    if (writeFq) updateFq(rx.getFrequency());
  }  
  delay(8);
  if (stoppedRDS) return; //zatim RDS netestovat
  if (tryRDS > MAX_TRY) { //vycerpan pocet pokusu cteni RDS pro naladenou stanici
    debug1 = 0xef; debug2 = tryRDS;
    return;
  }
  
  if (timeRDS()) {
    stoppedRDS = true;
    if (cyklus_index < CYKLUS_COUNT) {
      if (testRDS()) cyklus_index++; else cyklus_index = 0;      
    }  
    if (cyklus_index >= CYKLUS_COUNT) {
      updateTime(minutRDS[CYKLUS_COUNT - 1]);
      cyklus_index = 0;
    }
    delay(512);
  }
}

Popis a chování programu:
Program si samozřejmě můžete upravit podle libosti a k obrazu svému. Popíšu pouze pár nejzákladnějších věcí. Pro ovládání modulu radiopřijímače RDA5807, jsem použil knihovnu RDA5807.h. Pro hodiny reálného času knihovnu Ds1302.h ve verzi 1.1.0. Knihovna pro hodinový displej TM1637 je ke stažení v návodu drátek.cz. Další použité knihovny Wire.h a EEPROM.h jsou součástí instalačního balíčku Arduino IDE.
Naladěná stanice se uloží do EEPROM až po dvaceti sekundách po naladění, aby se EEPROM zbytečně nepřepisovala při přelaďování.
Vzhledem k tomu, že program pracuje pouze s časem (hodiny a minuty). Je dobré při prvním nahrání do Arduina doplnit kompletní datum, i když to není úplně nutné. Hlavně je dúležité mít v modulu RTC vloženou baterii CR2032, jinak po odpojení zdroje čas "zapomene".
Pomocí definice #define DBG nastavíte testovací režim přes seriový monitor. Program pak bude v Arduino IDE do seriového monitoru vypisovat hlášky o jeho průběhu.
Konstanta CYKLUS_COUNT určuje, kolikrát se má načíst čas, než se potvrdí jeho správnost. Pokud se předešlý načtený čas liší o více jak dvě minuty, nebo je větší, cyklus se zruší a začne nanovo. Zde je konstanta nastavená na osm. Možná je to zbytečně moc, ale takto mi to připada spolehlivější.
Konstanta MAX_TRY udává maximální počet pokusů o přečtení času. Ono je zbytečně neustále se pokoušet o čtení ze slabého signálu. Pak je ale vhodné naladit nějakou silnější stanici. A jak zjistíte správnost čtení, aniž byste přijímač připojovali k PC s Arduino IDE? Je implementován jakýsi kontrolní režim, který se aktivuje i ruší stiskem všech tří tlačítek najednou. Na hodinovém displeji přestane blikat dvojtečka a pak se po chvíli místo času začnou zobrazovat tato stavová slova:

první bajt	druhý bajt
D0 začátek cyklu čtení času	01
D1 až D6 průběžné čtení času	rozdíl proti předešlému v minutách (1, nebo 2)
DA probíhá cyklus čtení	kolikátý pokus
DB cyklus čtení času OK, čas aktualizován, další bude příští den	na kolikátý pokus
DC inicializace modulu RTC	den v měsíci
E1 až E6 čas byl přečten chybně	rozdíl proti předešlému v minutách
EF počet pokusů o čtení času byl vyčerpán	počet pokusů

Po přeladění na jinou stanici se probíhající cyklus i počet pokusů vynuluje. Čtení začíná nanovo, pokud čas dosud nebyl úspěšně přečten. Pokud již čas aktualizován úspěšně byl (stavové slovo DBxx), čtení času se již ten den neprovádí.

Programy zdarma, Arduino návody, tratě pro Open Rails a MSTS.

Vzkazník - dotazy, názory, připominky, hlášení chyb, atd:
jméno (e-mail): E-mail nebude nikde zveřejněn, uveďte jej, pouze pokud si přejete odpověď.
text: