=BANDSCAN= 88.80 54 95.10 52 96.50 47 99.20 48 101.30 53 102.40 43 103.30 51 104.20 60 106.70 52 ==========

Der Quelltext des BandScan in Textform und Chip-Scan:

void bandscan()
{boolean done=false;int last,f;
 setFrequency(875);delay(500);
 while(!done)
 {//SEEK UP CONT      xxxxxx1xxxxxxxxx 
   setRegister(0x02,0b1100001100001101);   
  while(bitRead(getRegister(0x0B),8)==0); //FM TRUE   
  delay(200);      
  last=f;
  f=getFrequency();
  done=f<last;
  if(done)continue;
  Serial.print(f);Serial.print('\t');Serial.println(2*getRSSI());
 }   
 Serial.println("==========");
}

Ein einmaliger Scan konnte nur ohne Registerabfrage realisiert werden, da es Widersprüche im Verhalten bei den Registerbits oder im Verständnis des Datenblatts gab.

• radioRead(), auslesen der 6 Register mit den Radiodaten
• radioStatus(), Informationen aus den Daten isolieren
• radioiInit(), die Initialisierung jetzt als eigene Routine; übersichtliches setup()
• loop(), Benutzerschnittstelle über eingehende serielle Daten

Eine Beispielausgabe sieht wie folgt aus:

Die Arduino-Schleife loop() fragt nun eingegende Zeichen ab und verzweigt entsprechend. Folgende Zeichen bewirken Aktionen:

• D - Einstellen der Frequenz Deutschlandfunk 102,8 MHz (kein Empfang)
• W - Einstellen der Frequenz WDR5 auf 88,8 MHz
• A - Einstellen auf Antenne Düsseldorf als stärkster Sender vor Ort
• 4 - Suchlauf abwärts
• 6 - Suchlauf aufwärts
• 0 - Feldstärke
• f - aktuelle Frequenz in MHz
• Enter - Informationen zu einzelnen Flags wie Mono, RDS-SenderID, RDS-Fehler, usw.

Dieses Listing, welches noch in seiner vollen Länge hier erscheint, liefert diese Funktionalität.

#include <Wire.h>
#define ADDR 0x11
#define WDR5 888
#define DLF 1028
#define ANTENNE 1042
#define STRONGSTATION ANTENNE

unsigned int data[7]; //Register 0A-10 RadioRead
boolean Stereo, RDS_Ready, Tune_Complete, Seek_Fail, RDS_Sync, FM_TRUE, FM_READY;
byte    Channel, RSSI, BLERA,BLERB,BLERC,BLERD;

unsigned int getRegister(byte reg)
{Wire.beginTransmission(ADDR); // Device 0x11 for random access
 Wire.write(reg);             
 Wire.endTransmission();      
 Wire.requestFrom(ADDR,2);     
 unsigned int x = 256*Wire.read()+Wire.read();          
 Wire.endTransmission();   
 return x;
}

void setRegister(byte reg,unsigned int val)
{Wire.beginTransmission(ADDR);
 Wire.write(reg); Wire.write(val >> 8); Wire.write(val & 0xFF);
 Wire.endTransmission();
 delay(50);
}

void setFrequency(int freq) //88.8 as 888
{word ch = freq-870;  // Reg 0x03 10 bit 15:6
 ch = ch << 6;        // SHIFT
 bitSet(ch,4);        // TUNE ON
 setRegister(0x03,ch); 
}

unsigned getFrequency(void)
{radioRead();
 return Channel+870;
}

int radioRead() // READ REGISTER 0A-10
{Wire.requestFrom(ADDR-1, 14); //Sequence Addr
 for (int i=0; i<7; i++) { data[i] = 256*Wire.read ()+Wire.read(); }
 Wire.endTransmission();
 radioStatus();
}

void radioStatus()
{RDS_Ready      = bitRead(data[0],15); //Register 0x0A

 Tune_Complete  = bitRead(data[0],14);
 Seek_Fail      = bitRead(data[0],13);
 RDS_Sync       = bitRead(data[0],12);
 Stereo         = bitRead(data[0],10);
 Channel        = data[0] & 0b111111111;
 RSSI           = (data[1] >> 10) & 0b111111; //Register 0x0B

 FM_TRUE        = bitRead(data[1],8);
 FM_READY       = bitRead(data[1],7); 
 BLERA          = data[1] >> 2 & 3;
 BLERB          = data[1] >> 0 & 3;
 BLERC          = data[6] >> 14 & 3; //Register 0x10
 BLERD          = data[6] >> 12 & 3;
}

void radioInit()
{setRegister(0x02,0b1100000000001011); //RESET
 setRegister(0x03,0b0000000000000000);
 setRegister(0x04,0b0000101000000000);
 setRegister(0x05,0b1000100000001111); 
 setRegister(0x06,0b0000000000000000);
 setRegister(0x07,0b0100001000000010);
 setRegister(0x02,0b1100000000001101); //NO RESET
}

void setup()
{Serial.begin(9600);
 delay(200);
 Wire.begin(); 
 radioInit(); 
 setFrequency(STRONGSTATION);
 delay(100);
 Serial.print(getFrequency()/10.0);
 Serial.println(" MHz");
}

void loop()
{char s[80]; 
 if(Serial.available()>0)
  {radioRead();
   switch(Serial.read())
   {case 'D':setFrequency(DLF);break;
    case 'W':setFrequency(WDR5);break;
    case 'A':setFrequency(ANTENNE);break;
    case '4'://SEEK DOWN        xxxxxx0xxxxxxxxx
             setRegister(0x02,0b1100000100001101);
             break;//DOWN BIT 9
    case '0':Serial.println(RSSI);
             break;
    case '6'://SEEK UP          xxxxxx1xxxxxxxxx 
             setRegister(0x02,0b1100001100001101);   
             break;  
    case 'f':Serial.println(getFrequency()/10.0);
             break;
    default: sprintf(s,"f=%d RSSI=%d %s Tune_Complete=%d FM_READY=%d",
             Channel+870,RSSI,Stereo?"Stereo":"Mono",Tune_Complete,FM_READY);
             Serial.println(s);
             sprintf(s,"PI=%04X RDS=%d BLERA=%d BLERB=%d BLERC=%d BLERD=%d",
             data[2],RDS_Ready,BLERA,BLERB,BLERC,BLERD);
             Serial.println(s);
             break;
  }
 }   
 delay(100);
}

Das obige Listing erinnert etwas an den Beitrag Si4735 - Digitales Analogradio, der auf dieser Seite erschienen ist. Das ist kein Zufall, denn während der Bibliothekssuche kamen einige Erinnerungen an dieses Projekt hoch. Die RDS-Dekodierung war damals nicht perfekt, aber zumindest Datum und Uhrzeit waren integriert, wie die alte Abbildung zeigt. Da RDS immer noch nach dem gleichen Prinzip ausgestrahlt wird, stellt sich die Frage, ob der alte Code recycelbar ist und so zum Ziel führt. Unten auf der dortigen Seite, die die RDS-Einbindung zur damaligen Zeit beschreibt, ist unter dem Titel Radiobausatz ein zip-Archiv mit allen Routinen abrufbar. Die dort enthaltene Routine RDS() wird übernommen und so verändert, dass alles über globale Variablen läuft. Dadurch entfallen die Parameter und der Sketch kann überall auf die decodierten RDS-Daten zugreifen und kommt weiterhin ohne Bibliothek aus. Lediglich die Registerinhalte, die mit radioRead() vom RDA-Chip geholt werden müssen in die damals benutzen Byte-Variablen R[] umkopiert werden. Die jetzigen globalen RDS-Variablen sind

// GLOBAL RDS VARS
char Station[9]="Radiuino";
char RadioText[65]="RadioTXT";
char Time[12]="UTC  /Time ";
char Date[11]="Date      ";
word PID;
word ABFlag=0,r;
bool AFflag=false;
byte R[16];// Response is 12 bytes
word A,B,C,D; //RDS Blocks
word PTY,TP,GT,AB,TA,MS,C12,T16;
/* ---------------------------------------------------------------*/

mit 64 Bytes für Radiotext, 9 Bytes für den Sendernamen, 12 Bytes für die Zeit in UTC und Lokale Zeit, 11 Bytes für den Datumstring. Die 5 Register müssen in die 12 Bytes von R[] umkopiert werden. darum ändert sich nur der Anfang der RDS()-Routine. C-Strings enden mit dem Byte 0, darum ein Byte länger.

int RDS() //Page 77
{int i,loopcount=1;
 while(loopcount--)
 {// added lines
  radioRead();
  R[4]=data[2]/256;
  R[5]=data[2]&255;
  R[6]=data[3]/256;
  R[7]=data[3]&255;
  R[8]=data[4]/256;
  R[9]=data[4]&255;
  R[10]=data[5]/256;
  R[11]=data[5]&255;
  // end added lines
...

Das gesamte Listing der Erweiterung wird nun zu lang für diese Seite und ist unter der Überschrift gespeichert. Der schnellste Weg ist das Kopieren des Textes aus dem Browser in einen neuen, leeren Sketch der Arduino-IDE. Das Ergebnis bei der Eingabe der Taste Enter kann nun wie folgt aussehen:

Etwa zur vollen Minute überträgt der RDS-Sender die Daten zur Uhrzeit. Somit steht diese Information dem Arduino zur Verfügung. Es ergibt sich eine weitere Variante zur Synchronisierung der Rheinturmuhr. Neben DCF77, GPS und Internet jetzt auch RDS.

Wegen der Störungen ist es nicht möglich die RDS-Zeit mit Datum einfach zu übernehmen und anzuzeigen. Vielmehr kann die RDS-Zeit nur als sporadische Synchronisationsquelle herangezogen werden, wenn fehlerfreie Daten vorliegen. Dieses Prinzip wohnt ja auch DCF-Uhren inne. Durch die verschiedenen Rheinturmuhrvarianten auf dieser Seite ist die TimeLib-Bibliothek vertraut. Sie bildet eine eigene Zeit und Datumsquelle ab, die mit externen Quellen synchronisiert werden kann. Sie beginnt am Donnerstag, den 1.1.1970 um 0:00 Uhr. Wird diese Arduino-Uhr mit der RDS-Uhr gestellt, stehen auch Wochentag und Sekunden zur Verfügung. All dies benötigt folgende Bibliotheken von github.com

• Multi_Oled
• Multi_BitBang
• TimeLib

Mit Multi-Oled/BitBang lassen sich viele Anzeigen mit gleicher Adresse an verschiedenen I2C Leitungen betreiben. Es stehen Zeichensätze in drei Größen zur Verfügung. Der Initialisierungteil zu den benutzten drei Bibliotheken enthält auch die Anschlüsse in rot:

// OLED MULTI BITBANG
#include <Multi_BitBang.h>
#include <Multi_OLED.h>

#define NUM_DISPLAYS 2
#define NUM_BUSES 1
// I2C bus info
uint8_t scl_list[NUM_BUSES] = {5};
uint8_t sda_list[NUM_BUSES] = {6};
int32_t speed_list[NUM_BUSES] = {1000000L};
// OLED display info
uint8_t bus_list[NUM_DISPLAYS] = {0,0}; // multiple displays per bus
uint8_t addr_list[NUM_DISPLAYS] = {0x3c, 0x3d};
uint8_t type_list[NUM_DISPLAYS] = {OLED_132x64, OLED_132x64};
uint8_t flip_list[NUM_DISPLAYS] = {0,0};
uint8_t invert_list[NUM_DISPLAYS] = {0,0};

// TIMELIB ARDUINO CLOCK
#include <TimeLib.h>
char *days[]={"...","Sonntag","Montag","Dienstag","Mittwoch",
                    "Donnerstag","Freitag","Sonnabend"};

In der Arduino loop() findet dauerhaft die Darstellung der Arduino-Uhr statt. Falls die Bedingungen es zulassen wird die Uhr nach der RDS-Zeit gestellt und die komplette Anzeige einmal gelöscht. Der Ausschnitt:

    // OLED
    Multi_OLEDFill(0, 0); //CLEAR
    int hh=atoi(strncpy(s,&Time[6],2));
    int mm=atoi(strncpy(s,&Time[9],2));
    int dd=atoi(strncpy(s,&Date[0],2));
    int mt=atoi(strncpy(s,&Date[3],2));
    int yy=atoi(strcpy(s,&Date[6]));
    setTime(hh,mm,0,dd,mt,yy); //ARDUINO CLOCK = RDS CLOCK
   }
 // OLED LIVE RDS INFO LINES
 int f=getFrequency()/10;int g=getFrequency()%10;
 sprintf(s, "%s %d.%d %04X %02d", Station,f,g,PID,RSSI);
 Multi_OLEDWriteString(0, 0, 0, s, FONT_SMALL, 0);
 sprintf(s, "%s %s%c%c%c%c%c", &Time[6],Date, Stereo?'S':'M',
  TP?'T':'t',TA?'A':'a',RDS_Ready?'R':'r',RDS_Sync?'S':'s');
 Multi_OLEDWriteString(0, 0, 1, s, FONT_SMALL, 0);
 Multi_OLEDWriteString(0, 0, 2, (char *)"---------------------", 
   FONT_SMALL, 0);
 // OLED CLOCK
 int ss=second();
 if(ss!=last)
 {sprintf(s, "%s ",days[weekday()]);
  Multi_OLEDWriteString(0, 0, 7, s, FONT_SMALL, 0);
  sprintf(s, "%02d.%02d.%04d",day(),month(),year());
  Multi_OLEDWriteString(0, 66, 7, s, FONT_SMALL, 0);
  sprintf(s, "%2d:%02d:%02d", hour(),minute(),ss);
  Multi_OLEDWriteString(0, 0, 3, s, FONT_LARGE, 0);
  last=ss; 
 }
 delay(100);
}

Dieser Gesamtsketch ist hier abgelegt.

// TIMELIB TIMEZONE ARDUINO CLOCK
#include <TimeLib.h>
#include <Timezone.h> 
TimeChangeRule CEST = {"", Last, Sun, Mar, 2, 120};     
TimeChangeRule CET = {"", Last, Sun, Oct, 3, 60}; 
Timezone CE(CEST, CET);
TimeChangeRule *tcr; 

    //CLOCK SYNC
    int hh=atoi(strncpy(s,&Time[0],2));//UTC
    int mm=atoi(strncpy(s,&Time[3],2));
    int dd=atoi(strncpy(s,&Date[0],2));
    int mt=atoi(strncpy(s,&Date[3],2));
    int yy=atoi(strcpy(s,&Date[6]));
    setTime(hh,mm,1,dd,mt,yy); //UTC
    time_t cet=CE.toLocal(now(),&tcr);
    setTime(cet);//TimeZone: UTC --> LOCAL

Die obere Zeile besteht jetzt aus

Die zweite Zeile zeigt Ausschnitte aus dem Maschinenraum des RDS-Decoders:

Wechselt das R/r für RDS Ready vor sich hin, so ist der Empfang in Ordnung.
Der finale Sketch als RDA_OLED_FINAL.ino

Möglicherweise ging hier ein besonders unempfindliches Exemplar des RDA an den Start - das Sonntagsnachmittagprojekt mit drei Klicks hat sich dann doch um einige Tage verlängert. Mit Ausflügen zu anderen Bibliotheken und eigenen Routinen aus früheren Tagen funktioniert die RDS-Uhr dann doch noch - meist - so, wie sie sollte. Auch entstand ein Dudelfunk-Blocker.