RDS 工作笔记

话说西元一千九百七十四年，欧洲有一帮不安分份子开始密谋策划，妄想利用有限的无线电频谱资源，去传送更多的资信讯息。六年后的1980年，他们在瑞士的伯尔尼进行了第一次的实用性试验。之后82年和83年又分别进行了各一次试验。至84年，首份正式的RDS技术规范EBU 3244横空出世----历经10年，RDS胚胎总算孕育成形；同年，美国福特公司开始汽车RDS收音机的研发工作。

85年，大规模的预运作试验在德国进行；同年，EUB（European Broadcast Union,欧洲广播联盟）确定了第一部实用RDS接收机面世的时间----1987年。

米国佬眼看欧洲在按部就班的进行着RDS的推广活动，再也坐不住了。1986年，他们在达拉斯向全国广播工作者协会推广介绍RDS系统。同年，国际无线电咨询委员会的RDS推荐文件正式发行。

好了，终于等到87年。在柏林IFA大展览会上，人们终于见到RDS接收机的倩影。德国VOLVO上市全球第一部RDS汽车收音机。88年，根德和菲力浦亦开始量产RDS汽车收音机。

再说回米国，直至89年，还在华盛顿D.C和拉斯维加斯向全国广播工作者协会介绍RDS系统----咳，由此可见，一项新鲜事物的接受程度哪怕是在科技发达的米帝国亦是步步唯艰。（哈哈，89年，诸位都干了些啥呢？）来到92年，米国的RDS国家标准----RBDS（Radio Broadcast Data System）技术规范才正式出炉。同年，RDS欧洲标准CENELEC EN 50067:1992出版发行。（注：CENELEC=欧洲电工技术标准化委员会）

RDS硬件规范
1）副载波导频：57KHz +/- 6Hz，对主载波标称频偏+/-1.0KHz 至 +/-7.5KHz;
2）调制方法：PSK（相移键控）
3）数据传输比特率：1187.5bit/s

进一步调查，知道的都说RDS家教甚好！举止文雅、谈吐不俗自不需多说，另外18般武艺也样样精通。都有些啥子本事？嘿嘿......
1。PI----节目识别。能使接收机依据节目身份代码正确切换。
2。PS----节目业务名称。使接收机能显示正在收听的电台节目业务名。
3。PTY----节目类型。随节目同时发出，共分31类，如音乐、体育、新闻等。
4。TP----交通节目识别。是一个开关信号，指明正在收听的节目业务是否播送交通公告的节目。
5。TA----交通公告识别。是一个切换信号，指明是否正在播送交通公告。
6。AF----替换频率表。此表给出在同一或相邻区域内播送同一节目的各发射机的频率信息。
7。DI----解码器识别。是一个切换信号，指明广播节目使用的16种工作模式的哪一种（或其合成）。
8。RT----广播文本。播音同时可在接收机显示屏显示的文本信息。
9。EON----增强的其他网络信息。有此功能的接收机既可收听调谐节目，又可通过EON功能收听相互参照的其他节目的交通公告。
10。CT----时间和日期。广播节目和日期码，使用UTC制式，并又接收机自动转为当地时。
11。EWS----紧急报警系统。紧急情况下使用的，接收机可自动调谐且识别此信息。
12。LN----定位和导航。给出发射台的位置信息，为导航和定位提供数据。
13。M/S----音乐/语言切换。听众可根据此信号调整接收机的音量和音调以达到最佳效果。
14。TMC----交通信息通道。用于传送交通编码信息，格式待定。
15。RP----广播寻呼。功能类似寻呼机。
16。IH----内部应用。由各个广播机构自行决定。
17。PIN----节目栏目号。广播电台所公布的预定的节目开始日期和时间，接收机用此设置预收听节目。
18。TDC----透明数据信道。用以传送图形数据的信道，有32个子信道。

）

检查揭示：RDS共有16组编码），每条上有四个块，每块里又各有26个bit。其中16bit是信息字，10bit是校验字。
首先，要将RDS信号运送出来

（RDS编码发送过程）

再看接应一方的手段

（RDS接收解码过程）

说到这里，该是进入实用话题的时候了。

话题一：关于RDS广播特点及RDS广播接收机

RDS系统除了传送实用的信息数据外，同时也传送开关信号。人们利用这套编码系统，从而实现FM频段的一台多频点的发射方案----方法是：一个电台，利用小功率的多个频点完成对某一区域的覆盖，从而替代单频点大功率的发射模式；优点是：节省发射功率，减少电磁污染，可以使覆盖范围信号强度均匀，避免强的过载，弱的收不到的烦恼。（手机移动通讯系统应该从这里偷了师）

RDS系统一开始开发，就有一个很特定目标：满足汽车收音的移动特性，使之能有满意的移动接收效果。所以，PI、TP、TA、AF、EON等编码都是为满足这个目的而设计的。至于家用收音机的RDS功能，只不过是拾人家一点牙惠而已。最近亦有便携式收音机做些汽车机的功能，呵呵，它也有移动特性啊。

问题：移动接收的效果是如何满足的？首先，每个RDS电台都有自己的身份证---PI码，然后AF码里面又包含有本台的各发射频率列表，利用这两个编码，接收机便能比较出哪一个频率的信号最强，使之始终接收最强的那个频点，并实现无缝切换。

另外，TA是一个强制执行代码。只要你在汽车里开着音响，哪怕是在听CD或播放磁带，只要有交通消息播报，接收机自动切回收音状态收听。播完后又自动回到原先的工作状态，想干啥继续干啥。
总之，RDS系统在交通管制上可以实现：
一、交通信息广播。
二、交通诱导（交通流量控制）。
三、紧急通告（强迫接收）。
四、单呼（BP机功能）。
五、群呼。
六、报失车辆的锁定与报警。



特别提示：不要指望你能买到一部收音机，它能具有RDS的所有功能。原因之一是RDS本身还在完善之中，之二就是制造商总是针对自己的目标市场选择性的做一些RDS功能。

花絮：曾经参与开发一款RDS汽车机，历时近两年（是干活的时间而不是抄作时间）。光是路试就在欧洲做了一次，香港做了三次，深圳做了两次。。。。。亦苦亦乐


（RDS汽车机）




（NEWS）




(CLASSIC MUSIC)




(SPORTS)






话题二：RDS在中国
1991年RDS首次在中国推介，至1995年，中华人民共和国国家标准《广播数据系统技术规范》出台（GB/T 15770-1995），也就是说RDS在中国的准生证有了。下面呢，我们化整为零说说RDS在中国的情况。

1。大陆

因Car—radio手头资料有限，真的部知道大陆甚麽地方在试播RDS信号，还望各位兄弟告知。
猜想没能迅速推广的原因：1）市场因数。需投入大量人力物力进行设备更新，需进行大量市场宣传。另外，设备不能自己生产亦是重要因数之一。2）技术因数。RDS技术引入中国时，DAB（数码音频广播）技术已经成熟。本着宁超前不滞后的原则，于是先行选择了DAB试播。


顺便贴一贴广东佛山电台数码广播在珠三角地区信号强度实测数据对应图



回澜33dB    罗源24dB  江谷30dB  广利32dB   
炭步35dB  钟落潭33dB  广州45dB  佛山85dB
黄埔39dB    石碣31dB  番愚34dB  厚街33dB
鹤山52dB    长安28dB  新垦28dB  宝安27dB
中山46dB    三江31dB  斗门32dB



下面是中国各省区RDS的识别码对应图，各位可对一下自己所在地是甚麽编码




2。香港
因收大英帝国长期殖民统治，香港的工业体制甚至生活习惯都深受英国影响。目前香港共16个广播频道。其中7个FM频道，除两个没有RDS功能外，剩下的都有。


有RDS功能之五个FM电台之频率和发射基站对应表（频率：MHz）

      电台名      商业电台1  商业电台2  香港电台4  劲歌    金曲
                    CR1        CR2        RTHK4    HIT    FM-S
发射基站

太平山              88.1      90.6      97.6      99.7    104.6 
飞鹅山              89.5      92.1      98.9      101.8    106.3     
青山                88.6      91.2      98.7      100.4    102.5
金山                88.9      90.9      98.4      101.6    105.5
笔架山              89.2      91.1      98.1      100.5    102.4
南丫岛              89.1      91.6      98.2      102.1    104.5
大雾山              88.3      90.7      97.8      100.0    104.7


以上列表还要港人及在香港的朋友收听验证。（深圳不能收到全部频点）


3。澳门

澳门虽曾是葡萄牙的殖民地，但因地域太小，估计未必采用RDS制式。这一点请珠海、中山、澳门和香港的朋友验证。


4。台湾

台湾一直跟在米国和***屁股后面，整天嗅些尾气。但米国的RBDS推广并不普及（***那边也不见啥动静），猜想台湾这方面还在按兵不动。这里烦请米乐.刘以及其他方便出入台湾的朋友来补充。

 

rds源代码解码：

/*

Copyright (C) 2006 Marc Ketel

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

*/

#define INFO "20060629-1 RDS Decoder by Marc Ketel alias DiNo, marc@atoomnet.net."
/*

Works with RDS clock signal and RDS data signal. During design a TDA7300B rds demodulator was used.

This source compiles correctly with WinAVR 20060421.

Use a Atmega168 to flash program into. low fuse: 0xF0, high fuse: 0xDD

Versions:
  20060629-1  Initial version

*/

/*

general word on ISR: it does not seem that ISR has global interrupts disabled.

*/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>
#include <stdio.h>
#include <math.h>

#define RDS_PORT PIND
#define RDS_PIN  PD4

FILE* Uart;

//used for stdout
int uartSend(char data, FILE* stream) {
  //wait for completion of previous send
  loop_until_bit_is_set(UCSR0A, UDRE0);

  //send the data
  UDR0 = data;
  return 0;
}

//used for stdin
int uartRecv(FILE* stream) {
  loop_until_bit_is_set(UCSR0A, RXC0);
  return UDR0;
}

volatile unsigned char event = 0;
#define eventTimerOverflow      _BV(0)
#define eventUsart0RxDInterrupt _BV(1)
#define eventGroupComplete      _BV(2)
#define eventBitstreamSnapshot  _BV(3)
#define eventSyncLost           _BV(4)

volatile unsigned char timerOverflowCount = 0;
volatile unsigned char usart0RxDByte = 0;
volatile unsigned char bitCounter = 0;
volatile unsigned char bitCounterSnapshot = 0;

volatile unsigned char synchronized = 0;
volatile unsigned char syncQuality = 0; //0-31, 0=no useable signal, 15=medium quality, 31=perfect!
volatile unsigned char syncCounter = 0;

volatile unsigned char block = 0;
volatile unsigned long bitstream = 0;
volatile unsigned long bitstreamData = 0;
volatile unsigned int block1 = 0;
volatile unsigned int block2 = 0;
volatile unsigned int block3 = 0;
volatile unsigned int block4 = 0;

//ISR is executed when there is a new rds bit to read
ISR(INT0_vect) {
  cli();
  unsigned int syndrome = 0;
  
  //Copy global vars to local vars for performance
  unsigned long bitstreamLocal = bitstream;
  unsigned char blockLocal = block;
  
  //shift rds bit in on right side
  bitstreamLocal *= 2; 
  if (RDS_PORT & _BV(RDS_PIN))
    bitstreamLocal++;
    
  bitCounter++;
  
  //collect data for raw bitstream snapshots
  bitCounterSnapshot++;
  if (bitCounterSnapshot == 26) {
    bitstreamData = (bitstreamLocal & 0x3FFFFFF);
    bitCounterSnapshot = 0;
    
    event |= eventBitstreamSnapshot;
  }
  
  //when we have 26 bits or are not synchronized to the stream
  //check the CRC and maybe store a rds block
  if (bitCounter == 26 || !synchronized) {
  
    bitstreamLocal &= 0x3FFFFFF; //we only need 26 bits
  
    syndrome = (bitstreamLocal / 0x10000); //bits 16-31 (2^16)
  
    if (bitstreamLocal & _BV(0))
      syndrome ^= 0x031b;
    
    if (bitstreamLocal & _BV(1))
      syndrome ^= 0x038f;
    
    if (bitstreamLocal & _BV(2))
      syndrome ^= 0x02a7;
      
    if (bitstreamLocal & _BV(3))
      syndrome ^= 0x00f7;
    
    if (bitstreamLocal & _BV(4))
      syndrome ^= 0x01ee;
    
    if (bitstreamLocal & _BV(5))
      syndrome ^= 0x03dc;
    
    if (bitstreamLocal & _BV(6))
      syndrome ^= 0x0201;
    
    if (bitstreamLocal & _BV(7))
      syndrome ^= 0x01bb;
    
    if (bitstreamLocal & _BV(8))
      syndrome ^= 0x0376;
    
    if (bitstreamLocal & _BV(9))
      syndrome ^= 0x0355;
  
    if (bitstreamLocal & _BV(10))
      syndrome ^= 0x0313;
    
    if (bitstreamLocal & _BV(11))
      syndrome ^= 0x039f;
  
    if (bitstreamLocal & _BV(12))
      syndrome ^= 0x0287;
      
    if (bitstreamLocal & _BV(13))
      syndrome ^= 0x00b7;
    
    if (bitstreamLocal & _BV(14))
      syndrome ^= 0x016e;

    if (bitstreamLocal & 0b1000000000000000) // _BV(15) does not work!!!
      syndrome ^= 0x02dc;

    //Block A?
    if (blockLocal == 0 && syndrome == 0x03d8) {
      block1 = bitstreamLocal / 0x400; //bits 10-25 (2^10)
      synchronized = 1;
      blockLocal++;
    } else 
    //Block B?
    if (blockLocal == 1 && syndrome == 0x03d4) {
      block2 = bitstreamLocal / 0x400; //bits 10-25 (2^10)
      synchronized = 1;
      blockLocal++;
    } else  
    //Block C type A?
    if (blockLocal == 2 && !(block2 & _BV(11)) && syndrome == 0x025c) {
      block3 = bitstreamLocal / 0x400; //bits 10-25 (2^10)
      synchronized = 1;
      blockLocal++;
    } else
    //Block C type B?
    if (blockLocal == 2 && (block2 & _BV(11)) && syndrome == 0x03cc) {
      block3 = bitstreamLocal / 0x400; //bits 10-25 (2^10)
      synchronized = 1;
      blockLocal++;
    } else
    //Block D?
    if (blockLocal == 3 && syndrome == 0x0258) {
      block4 = bitstreamLocal / 0x400; //bits 10-25 (2^10)
      synchronized = 1;
      blockLocal = 0;
      //we have a complete group!
      event |= eventGroupComplete;
    } else {
      //sync lost..
      synchronized = 0;
      blockLocal = 0;
      event |= eventSyncLost;
    }
    
    bitCounter = 0; 
  }
  
  if (event & eventGroupComplete) {
    PORTC |= _BV(PC1);
    
    if (syncQuality < 31)
      syncQuality++;
    
  } else if (!synchronized) {
    PORTC &= ~_BV(PC1);
    
    syncCounter++;
    if (syncQuality > 0 && syncCounter == 26) {
      syncQuality--;
      syncCounter = 0;
    }
      
  }
  
  if (syncQuality >= 15)
    PORTC |= _BV(PC2);
  else
    PORTC &= ~_BV(PC2);
  
  //Store local vars into global vars to remember state
  bitstream = bitstreamLocal;
  block = blockLocal;
  sei();
}

//timer0 overflowed
ISR(TIMER0_OVF_vect) {
  cli();
  timerOverflowCount++;
  if (timerOverflowCount > 4) {
    event |= eventTimerOverflow;
    timerOverflowCount = 0;
  }
  sei();
}

ISR(USART_RX_vect) {
  cli();
  usart0RxDByte = UDR0;
  event |= eventUsart0RxDInterrupt;
  sei();
}

void displayInfo(void) {
  printf_P(PSTR("INFO: 0x01, "));
  printf_P(PSTR(INFO));
  printf_P(PSTR("\r\n"));
}

int main(void) {

  wdt_reset(); //reset inmediately in case of a previous system reset
  //lets enable watchdog with 1 second timeout
  wdt_enable(WDTO_1S);

  unsigned int  programmeIdentificationCode = 0;
  unsigned char groupType = 0;
  unsigned char groupVersion = 0;
  unsigned char trafficProgrammeIdentificationCode = 0;
  unsigned char programmeTypeCode = 0;
  unsigned char trafficAnnouncementCode = 0;
  unsigned char musicSpeechSwitchScode = 0;
  unsigned char group0CodeBits = 0;
  unsigned char group0CodeBitsSteadyCount = 0;
  unsigned char programmeServiceName[8];
  unsigned char programmeServiceNameNew[8];
  unsigned char decoderIdentificationControlCode = 0;
  unsigned char decoderIdentificationControlCodeNew = 0;
  unsigned char alternativeFrequencyCodes[27];
  unsigned char syncMessage = 0;
  unsigned char displayRaw = 0;
  unsigned char displayBitstream = 0;
  unsigned char linkageActuator = 0;
  unsigned char extendedCountryCode = 0;
  unsigned char textSegmentAddress = 0;
  unsigned char textSegmentAddressPrevious = 0;
  unsigned char textVersion = 0;
  unsigned char textVersionPrevious = 0; 
  unsigned char radioText[64];
  unsigned char radioTextPrevious[64];
  unsigned char textSegmentAddress0Seen = 0;
  unsigned int  modifiedJulianDay = 0;
  unsigned int  utcYear = 0;
  unsigned char utcMonth = 0;
  unsigned char utcDay = 0;
  signed   char localHours = 0;
  unsigned char utcHours = 0;
  signed   char localMinutes = 0;
  unsigned char utcMinutes = 0;
  unsigned char utcMinutesPrevious = 0xFF;
  unsigned char localSign = 0;
  unsigned int  localTimeOffset = 0;
  
  //general purpose vars
  unsigned int  m;
  unsigned char h;
  unsigned char i;
  unsigned char j;
  
  //1.8mhz crystal
  //baudrate 115.2K
  //UBRR0 = 0;
  //baudrate 9600
  //UBRR0 = 11;
  
  //16mhz crystal
  //38.4k
  //UBRR0 = 25;
  
  //4.332Mhz crystal
  //baudrate 38K4
  UBRR0 = 6;
  
  //enable RxD interrupt, RxD, TxD
  UCSR0B |= _BV(RXCIE0) | _BV(RXEN0) | _BV(TXEN0);
  
  //8 bit
  //UCSR0C |= _BV(UCSZ00) | _BV(UCSZ01);
  
  //UART is stdout and stdin;
  Uart = fdevopen(uartSend, uartRecv);

  //enable int0
  EIMSK = _BV(INT0);
  
  //INT0 raising edge
  EICRA |= _BV(ISC01) | _BV(ISC00);
  
  //PC0, PC1, PC2 are outputs;
  DDRC |= _BV(PC0) | _BV(PC1) | _BV(PC2);

  //timer0 prescaler clk/1024
  TCCR0B |= _BV(CS02) | _BV(CS00);
  //enable overflow interrupt
  TIMSK0 |= _BV(TOIE0);
  
  displayInfo();
  
  sei(); //enable interrupts;
  
  for (;;) {
    
    do {} while (!event);
    wdt_reset(); //reset watchdog, we are still alive!
    
    cli();
    if (event & eventUsart0RxDInterrupt) {
      event &= ~eventUsart0RxDInterrupt;
      sei();
      
      //collect the command
      
      //switch group display on (G) or off (g)
      if (usart0RxDByte == 'G')
        displayRaw = 0;
      else if (usart0RxDByte == 'g')
        displayRaw = 1;
        
      //reset decoder
      if (usart0RxDByte == 'r') {
        wdt_enable(WDTO_15MS);
        for(;;) {};
      }
        
      //switch group display on (B) or off (b)
      if (usart0RxDByte == 'B')
        displayBitstream = 0;
      else if (usart0RxDByte == 'b')
        displayBitstream = 1;
        
    } else {
      sei();
    }
    
    //we have got 26 bits raw rds data
    cli();
    if (event & eventBitstreamSnapshot) {
      event &= ~eventBitstreamSnapshot;
      sei();
      
      if (displayBitstream) {
        printf_P(PSTR("B: 0x%07lX\r\n"), bitstreamData);
      }
    } else {
      sei();
    }
    
    cli();
    if (event & eventTimerOverflow) {
      event &= ~eventTimerOverflow;
      sei();
      
      /* no rds signal message */
      if (syncQuality == 0 && syncMessage < 12) {
        syncMessage++;
        if (syncMessage == 12) {
          printf_P(PSTR("INFO: 0x02, No RDS signal.\r\n"));
          programmeIdentificationCode = 0;
        }
      }
          
      if (syncQuality > 0)
          syncMessage = 0;
          
      if (PORTC & _BV(PC0))
        PORTC &= ~_BV(PC0); //heartbeat led off
      else
        PORTC |= _BV(PC0); //heartbeat led on
      
    } else {
      sei();
    }
    
    //reset vars when sync lost. Warning, sync lost happens 26 times as many as groupcomlete, do not do anything lenghty here
    cli();
    if (event & eventSyncLost) {
      event &= ~eventSyncLost;
      sei();
      group0CodeBitsSteadyCount = 5;
    } else {
      sei();
    }
    
    cli();
    if (event & eventGroupComplete) {
        event &= ~eventGroupComplete;
        sei();
        
      //Group type code
      groupType = block2 / 0x1000; //bits 12-15 (2^12)
      
      //Group version code
      if (block2 & _BV(11))
        groupVersion = 'B';
      else
        groupVersion = 'A';
      
      if (displayRaw)
        printf_P(PSTR("GROUP%02u%c: 0x%04X 0x%04X 0x%04X 0x%04X\r\n"), groupType, groupVersion, block1, block2, block3, block4);
      
      //PI Codes of block 3 B-version groups are not decoded.
      
      //Programme Identification code
      if (programmeIdentificationCode != block1) {
        displayInfo();
        programmeIdentificationCode = block1;
        printf_P(PSTR("PI: 0x%04X, Detected new station.\r\n"), programmeIdentificationCode);
        
        /* reset variables because PI code changed */
        trafficProgrammeIdentificationCode = 0xFF;
        programmeTypeCode = 0xFF;
        trafficAnnouncementCode = 0xFF;
        musicSpeechSwitchScode = 0xFF;
  
        group0CodeBitsSteadyCount = 0;
        for(i = 0; i < sizeof(programmeServiceName); i++)
          programmeServiceName[i] = 0xFF;
          
        decoderIdentificationControlCode = 0xFF;
        
        for(i = 0; i < sizeof(alternativeFrequencyCodes); i++)
          alternativeFrequencyCodes[i] = 0;
          
        linkageActuator = 0xFF;
        
        extendedCountryCode = 0;
        
        for(i = 0; i < sizeof(radioText); i++) {
          radioText[i] = 0;
          radioTextPrevious[i] = 0;
        }
        
        textSegmentAddress0Seen = 0;
          
        textVersionPrevious = 0;
        textSegmentAddressPrevious = 0;
        
        utcMinutesPrevious = 0xFF;
        
      }
  
      //Programme Type code
      if (programmeTypeCode != ((block2 / 0x20) & 0x1F)) {
        programmeTypeCode = ((block2 / 0x20) & 0x1F); //bits 5-9 (2^5)
        printf_P(PSTR("PTY: 0x%02X, "), programmeTypeCode);
        switch(programmeTypeCode) {
          case 0:
            printf_P(PSTR("None."));
            break;
          case 1:
            printf_P(PSTR("News."));
            break;
          case 2:
            printf_P(PSTR("Current Affairs."));
            break;
          case 3:
            printf_P(PSTR("Information."));
            break;
          case 4:
            printf_P(PSTR("Sport."));
            break;
          case 5:
            printf_P(PSTR("Education."));
            break;
          case 6:
            printf_P(PSTR("Drama."));
            break;
          case 7:
            printf_P(PSTR("Cultures."));
            break;
          case 8:
            printf_P(PSTR("Science."));
            break;
          case 9:
            printf_P(PSTR("Varied Speech."));
            break;
          case 10:
            printf_P(PSTR("Pop Music."));
            break;
          case 11:
            printf_P(PSTR("Rock Music."));
            break;
          case 12:
            printf_P(PSTR("Easy Listening."));
            break;
          case 13:
            printf_P(PSTR("Light Classics."));
            break;
          case 14:
            printf_P(PSTR("Serious Classics."));
            break;
          case 15:
            printf_P(PSTR("Other Music."));
            break;
          case 16:
            printf_P(PSTR("Weather."));
            break;
          case 17:
            printf_P(PSTR("Finance."));
            break;
          case 18:
            printf_P(PSTR("Children."));
            break;
          case 19:
            printf_P(PSTR("Social Affairs."));
            break;
          case 20:
            printf_P(PSTR("Religion."));
            break;
          case 21:
            printf_P(PSTR("Phone In."));
            break;
          case 22:
            printf_P(PSTR("Travel & Touring."));
            break;
          case 23:
            printf_P(PSTR("Leisure & Hobby."));
            break;
          case 24:
            printf_P(PSTR("Jazz Music."));
            break;
          case 25:
            printf_P(PSTR("Country Music."));
            break;
          case 26:
            printf_P(PSTR("National Music."));
            break;
          case 27:
            printf_P(PSTR("Oldies Music."));
            break;
          case 28:
            printf_P(PSTR("Folk Music."));
            break;
          case 29:
            printf_P(PSTR("Documentary."));
            break;
          case 30:
            printf_P(PSTR("Alarm Test."));
            break;
          case 31:
            printf_P(PSTR("Alarm - Alarm !"));
            break;
          default:
            printf_P(PSTR("Unknown."));
            break;
        }
        printf_P(PSTR("\r\n"));
      }
  
      //Type 0 groups: Basic tuning and switching information
      if (groupType == 0) {
      
        //Traffic Programme Identification code
        //Traffic announcement code
        if (trafficAnnouncementCode != ((block2 / 0x10) & 0x01) ||
            trafficProgrammeIdentificationCode != (block2 & _BV(10)) / 0x400) {
          
          trafficAnnouncementCode = (block2 / 0x10) & 0x01; //bit 4 (2^4)
          trafficProgrammeIdentificationCode = (block2 & _BV(10)) / 0x400; //bit 10
          
          printf_P(PSTR("TP&TA: 0x%02X 0x%02X, "), trafficProgrammeIdentificationCode, trafficAnnouncementCode);

          if (trafficProgrammeIdentificationCode == 0) {
          
            if (trafficAnnouncementCode == 0) {
              printf_P(PSTR("No traffic announcements available."));
            } else {
              printf_P(PSTR("Traffic announcements available via EON on another station."));
            }
          
          } else {
          
            if (trafficAnnouncementCode == 0) {
              printf_P(PSTR("Traffic announcements available on this station and maybe via EON on another station."));
            } else {
              printf_P(PSTR("Traffic announcement in progress."));
            }
            
          }
          
          printf_P(PSTR("\r\n"));
          
        }
      
        //Music Speech switch code
        if (musicSpeechSwitchScode != ((block2 / 0x08) & 0x01)) {
          musicSpeechSwitchScode = (block2 / 0x08) & 0x01;  //bit 3 (2^3)
          printf_P(PSTR("MS: 0x%02X, "), musicSpeechSwitchScode);

          if (musicSpeechSwitchScode) 
            printf_P(PSTR("Music is being broadcasted or station does not use MS flag."));
          else
            printf_P(PSTR("Speech is being broadcasted."));
          printf_P(PSTR("\r\n"));
        }
        
        //Decode program service name and decoder identification control code
        group0CodeBits = block2 & 0x03; //0, 1, 2, 3;
        
        
        //TODO: improve decoderIdentificationControlCode detection, decouple from PS name
        //Decoder-identification control code-bit is bit 3 in block2
        if (group0CodeBits == 0) {
          if (block2 & 0x04)
            decoderIdentificationControlCodeNew |= _BV(3);
          else 
            decoderIdentificationControlCodeNew &= ~_BV(3);
        }
        if (group0CodeBits == 1) {
          if (block2 & 0x04)
            decoderIdentificationControlCodeNew |= _BV(2);
          else 
            decoderIdentificationControlCodeNew &= ~_BV(2);
        }
        if (group0CodeBits == 2) {
          if (block2 & 0x04)
            decoderIdentificationControlCodeNew |= _BV(1);
          else 
            decoderIdentificationControlCodeNew &= ~_BV(1);
        }
        if (group0CodeBits == 3) {
          if (block2 & 0x04)
            decoderIdentificationControlCodeNew |= _BV(0);
          else 
            decoderIdentificationControlCodeNew &= ~_BV(0);
        }
  
        //fill in information
        i = group0CodeBits * 2;
        programmeServiceNameNew[i] = block4 / 0xFF; //bits 8-16 (2^8)
        programmeServiceNameNew[i + 1] = block4; //bit 0-8
        
        if (programmeServiceNameNew[i] != programmeServiceName[i] ||
            programmeServiceNameNew[i + 1] != programmeServiceName[i + 1]) {
          //detected change, reset counter if not already counting
          if (group0CodeBitsSteadyCount > 4)
                group0CodeBitsSteadyCount = 0;
        }
        
        //increase counter only when there are less then 4 received words
        if (group0CodeBitsSteadyCount < 4)
          group0CodeBitsSteadyCount++;
        
        programmeServiceName[i] = programmeServiceNameNew[i];
        programmeServiceName[i + 1] = programmeServiceNameNew[i + 1];
        
        //when we detected 4 new PS words then display it
        if (group0CodeBitsSteadyCount == 4) {
          printf_P(PSTR("PS: "));
          for(i = 0; i < sizeof(programmeServiceName); i++) {
            printf_P(PSTR("%c"), programmeServiceName[i]);
          }
          printf_P(PSTR("\r\n"));
          //prevent redisplay
          group0CodeBitsSteadyCount++;
          
          if (decoderIdentificationControlCode != decoderIdentificationControlCodeNew) {
            decoderIdentificationControlCode = decoderIdentificationControlCodeNew;
            printf_P(PSTR("DI: 0x%02X"), decoderIdentificationControlCode);
            
            if (decoderIdentificationControlCode & 0b0001)
              printf_P(PSTR(", Stereo"));
            else
              printf_P(PSTR(", Mono"));
              
            if (decoderIdentificationControlCode & 0b0010)
              printf_P(PSTR(", Artificial Head"));
              
            if (decoderIdentificationControlCode & 0b0100)
              printf_P(PSTR(", Compressed"));
              
            if (decoderIdentificationControlCode & 0b1000)
              printf_P(PSTR(", Static PTY"));
            else
              printf_P(PSTR(", Dynamic PTY"));
              
            printf_P(PSTR(".\r\n"));
          }
        }
        
  
        if (groupVersion == 'A') {
        
          //Alternative frequency codes
          for (h = 0; h < 2; h++) {
            if (h == 0)
              j = block3; //first AF is in bits 0-7 of block3
            else
              j = block3 / 256; //second bits 8-15
              
            //only frequencies we want, no control codes
            if (j >= 1 && j <= 204) {
              for(i = 0; i < sizeof(alternativeFrequencyCodes); i++) {
                if (alternativeFrequencyCodes[i] == j) {
                  break;
                } 
                if (alternativeFrequencyCodes[i] == 0) {
                  alternativeFrequencyCodes[i] = j;
                  printf_P(PSTR("AF: 0x%02X, "), alternativeFrequencyCodes[i]);
                  
                  m = 875 + j;
                  printf_P(PSTR("%u.%uMHz.\r\n"), m / 10, m % 10);
                  break;
                }
              }
            }
            
            if (j == 224 && alternativeFrequencyCodes[25] != j) {
              alternativeFrequencyCodes[25] = 224;
              printf_P(PSTR("AF: 0x%02X, This station has no alternate frequenties.\r\n"), j);
            }
          }
          
          //TODO: LF/MF untested because lack of LM/MF station
          //Station transmits on LF/MF
          if (block3 == 250 && alternativeFrequencyCodes[26] != block3) {
            alternativeFrequencyCodes[26] = block3;
            j = block3 / 256;
            
            printf_P(PSTR("AF: 0x%02X 0x%02X, "), block3, j);
            
            //LF 153kHz-279kHz in 9 KHz steps
            if (j >= 1 && j <= 15) {
              m = 144 + (j * 9);
              printf_P(PSTR("%uKHz.\r\n"), m);
            } else
            //MF 531KHz-1602kHz in 9 KHz steps
            if (j >= 16 && j <= 135) {
              m = 387 + (j * 9);
              printf_P(PSTR("%uKHz.\r\n"), m);
            }
          }
        }
        //version B contains PI code in block3
  
      } else
      //Type 1 groups: Programme Item Number and slow labelling codes
      if (groupType == 1) {
      
        if (groupVersion == 'A') {
          //TODO: 5 bit Radio Paging Codes, bits 0-4 block2
          
          //TODO: Add textual description of LA
          //Linkage Actuator
          if (linkageActuator != (block3 & _BV(15))) {
            linkageActuator = (block3 & _BV(15));
            printf_P(PSTR("LA: 0x%02X\r\n"), linkageActuator);
          }
          
          //store variant code, bits 13-15
          i = (block3 / 0x2000) & 0x07;
          
          //TODO: Paging
          if (i == 0) {
            
            //TODO: Add textual description of ECC code
            //Extended Country Code, bits 0-7 block3
            if (extendedCountryCode != (block3 & 0xFF)) {
              extendedCountryCode = (block3 & 0xFF);
              printf_P(PSTR("ECC: 0x%02X\r\n"), extendedCountryCode);
            }
            
          
          } else 
          //TODO: TMC identification
          if (i == 1) {
          
          } else
          //TODO: Paging identification
          if (i == 2) {
          
          } else
          //TODO: Language codes
          if (i == 3) {
          
          } else
          //TODO: not assigned
          if (i == 4) {
          
          } else
          //TODO: not assigned
          if (i == 5) {
          
          } else
          //TODO: For use by broadcasters
          if (i == 6) {
          
          } else
          //TODO: Identification of EWS channel
          if (i == 7) {
          
          }
        }
        
        //TODO: Programme Item Number, block 4
      
      } else 
      //Type 2 groups: RadioText
      if (groupType == 2) {
      
        //text version A or B, bit 5 block 2
        if (block2 & 0x10) 
          textVersion = 'B';
        else
          textVersion = 'A';
        
        //block2 bit 0-3
        textSegmentAddress = (block2 & 0x0F);
        
        //clean radioText when version changes
        if (textVersionPrevious != 0 &&
            textVersionPrevious != textVersion) {
            
          for(i = 0; i < sizeof(radioText); i++) {
            radioText[i] = 0;
           }
           
          textSegmentAddressPrevious = 0;
          textSegmentAddress0Seen = 0;
        }
        
        //detected new start of text segment, normally address 0x00
        if (textSegmentAddressPrevious > textSegmentAddress) {
            
          if (groupVersion == 'A')
            h = 64;
          else
            h = 32;
          
          //detect new radioText
          j = 0;
          for (i = 0; i < h; i++) {
            if (radioText[i] != 0 && radioText[i] != ' ') {
              if (radioText[i] != radioTextPrevious[i]) {
                j = 1;
                break;
              }
            }
          }
          
          //only print when we have received address 0 once.
          if (textSegmentAddress0Seen == 0)
            j = 0;
           
          if (j) {
            printf_P(PSTR("RT%c: "), textVersion);

            for (i = 0; i < h; i++) {
            
              if (radioText[i] == 0) 
                break;
              else if (!(radioText[i] == '\r' || radioText[i] == '\n'))
                printf_P(PSTR("%c"), radioText[i]);

                
              radioTextPrevious[i] = radioText[i];
            }
            printf_P(PSTR("\r\n"));
          }
          
          
        }
        
        //64 bit messages in block 3 & 4
        if (groupVersion == 'A') {
          
          radioText[(textSegmentAddress * 4)] = block3 / 256;
          radioText[(textSegmentAddress * 4) + 1] = block3;
          radioText[(textSegmentAddress * 4) + 2] = block4 / 256;
          radioText[(textSegmentAddress * 4) + 3] = block4;
          
          //fill bytes smaller then textSegmentAddress with spaces when they are '0'
          if (textSegmentAddress > 0) {
            for (i = 0; i < (textSegmentAddress - 1) * 4; i++) {
              if (radioText[i] == 0)
                radioText[i] = ' ';
            }
          }
          
        }
        //TODO: 32 bit messages not tested because of lack station transmitting it.
        //32 bit messages in block 4
        else {
          radioText[(textSegmentAddress * 2)] = block4 / 256;
          radioText[(textSegmentAddress * 2) + 1] = block4;
          
          //fill bytes smaller then textSegmentAddress with spaces when they are '0'
          if (textSegmentAddress > 0) {
            for (i = 0; i < (textSegmentAddress - 1) * 2; i++) {
              if (radioText[i] == 0)
                radioText[i] = ' ';
            }
          }
          
        }
        
        if (textSegmentAddress == 0)
          textSegmentAddress0Seen = 1;
        
        
        textVersionPrevious = textVersion;
        textSegmentAddressPrevious = textSegmentAddress;
        
      } else
      //Type 3A groups: Application identification for Open data
      if (groupType == 3 && groupVersion == 'A') {
      
      } else
      //Type 3B groups: Open Data Application
      if (groupType == 3 && groupVersion == 'B') {
      
      } else
      //Type 4A groups : Clock-time and date
      if (groupType == 4 && groupVersion == 'A') {
      
        //bits 0-5 are in block4 as bits 6-11
        utcMinutes = (block4  / 64) & 0x3F;
      
        if (utcMinutesPrevious != utcMinutes) {
        
          utcMinutesPrevious = utcMinutes;
        
          //bits 0-14 are in block3 as bits 1-15
          //bits 15-16 are in block2 as bits 0-1
          modifiedJulianDay = (block3 / 2) + (block2 & 0x03) * 32768;
          
          //bits 0-3 are in block4 as bits 12-15
          //bit 4 is in block3 as bit 1
          utcHours = (block4 / 4096) + (block3 & 0x01) * 16;
          
          //local time offset are bits 0-4 in block 4
          localTimeOffset = block4 & 0x1F;
          //sign is in bit 5 of block4, 0=+ 1=-
          if (block4 & 0x20) 
            localSign = '-';
          else
            localSign = '+';
          
          //multiply by 30 so that we have offset in minutes (offset is in multiples of .5 hours)
          localTimeOffset *= 30;
  
          printf_P(PSTR("CT: 0x%01X%04X%04X, "), (block2 & 0x03), block3, block4);
          
          //Modified Julian date to year-month-day conversion
          utcYear = floor((modifiedJulianDay - 15078.2) / 365.25);
          utcMonth = floor((modifiedJulianDay - 14956.1 - floor(utcYear * 365.25)) / 30.6001);
          utcDay = modifiedJulianDay - 14956 - floor(utcYear * 365.25) - floor(utcMonth * 30.6001);
        
          if (utcMonth == 14 || utcMonth == 15)
            i = 1; 
          else 
            i = 0;
        
          utcYear = utcYear + i + 1900;
          utcMonth = utcMonth - 1 - (i * 12);
  
          printf_P(PSTR("UTC %04u-%02u-%02u (MJD %u) %02u:%02u:00 %c%02u:%02u, "),
                   utcYear, utcMonth, utcDay,
                   modifiedJulianDay,
                   utcHours, utcMinutes, localSign,
                   localTimeOffset / 60, localTimeOffset % 60);
          
          //TODO: half hour timezones and negative timezones not tested because lack of station transmitting it.
          //lets calulate local time
          if (localSign == '-') {
            localHours = utcHours - (localTimeOffset / 60);
            localMinutes = utcMinutes - (localTimeOffset % 60);
          } else {
            localHours = utcHours + (localTimeOffset / 60);
            localMinutes = utcMinutes + (localTimeOffset % 60);
          }
          
          if (localMinutes < 0) {
            localMinutes += 60;
            localHours--;
          }
            
          if (localMinutes > 59) {
            localMinutes -= 60;
            localHours++;
          }
          
          if (localHours < 0)
            localHours += 24;
  
          if (localHours > 23)
            localHours -= 24;
            
          printf_P(PSTR("TIME %02u:%02u:00\r\n"), localHours, localMinutes);
        }

      } else
      //Type 4B groups: Open data application
      if (groupType == 4 && groupVersion == 'B') {
        
      } else
      //Type 5 groups: Transparent data channels or ODA
      if (groupType == 5) {
      
      } else
      //Type 6 groups: In-house applications or ODA
      if (groupType == 6) {
      
      } else 
      //Type 7A groups: Radio Paging or ODA
      if (groupType == 7 && groupVersion == 'A') {
      
      } else 
      //Type 7B groups: Open data application
      if (groupType == 7 && groupVersion == 'B') {
      
      } else 
      //Type 8 groups: Traffic Message Channel or ODA
      if (groupType == 8) {
      
      } else 
      //Type 9 groups: Emergency warning systems or ODA
      if (groupType == 9) {
      
      } else 
      //Type 10A groups: Programme Type Name
      if (groupType == 10 && groupVersion == 'A') {
      
      } else
      //Type 10B groups: Open data
      if (groupType == 10 && groupVersion == 'A') {
      
      } else
      //Type 11 groups: Open Data Application
      if (groupType == 11) {
      
      } else 
      //Type 12 groups: Open Data Application
      if (groupType == 12) {
      
      } else 
      //Type 13A groups: Enhanced Radio Paging or ODA
      if (groupType == 13 && groupVersion == 'A') {
      
      } else
      //Type 13B groups: Open Data Application
      if (groupType == 13 && groupVersion == 'B') {
      
      } else
      //Type 14 groups: Enhanced Other Networks information
      if (groupType == 14) {
      
      } else
      //Type 15A groups: 'currently unavailable'
      if (groupType == 15 && groupVersion == 'A') {
      
      } else
      //Type 15B groups: Fast basic tuning and switching information
      if (groupType == 15 && groupVersion == 'B') {
      
      }
    } else {
      sei();
    }
    
    
  }
}