Arduino on Ice: Internet Radio via Shoutcast

I’ve seen plenty Internet Radio examples out there on various platforms, but none on Arduino. Is 2K memory just too little to stream radio effectively? Thought it was time to find out. Turns out it’s no problem at all. Using uIP on ENC28J60 for networking and VS1053 for playback, a stock ATmega328p-based Arduino can stream Internet Radio no problem with plenty RAM to spare.

The example sketch discussed here is something of a “Hello, world.” of Internet Radio. It starts up, connects to a single hard-coded stream, and plays it forever. This makes it simple! Plug and listen. For this example, I’ll use the stream from www.c895.org, “Seattle’s Hottest Music” 🙂

Hardware

The easiest way to combine Arduino and ENC28J60-based Ethernet is the Nanode. Alternately, you could use an Arduino Uno with an inexpensive (non-official) EtherShield. I’ve also hooked this up with my own Custom Arduino board with a Custom ENC28J60-based Ethernet board. It’s all the same. The Nanode is the easiest, though.

For the player, I use the Breakout board for VS1053 MP3 and MIDI available from MDFly.com for $25. They are for sale elsewhere on the web too, so anything that breaks out the primary control lines will do the job.

Total off the shelf cost, $65. $40 for a Nanode, $25 for the player module.

Software

EtherBright Library, based on avr-uip

Get the EtherBright library, and put it in your sketchbook libraries. The key to making this project work was finding a small, memory-efficient TCP/IP stack in software that’s mature and well-tested. For the longest time, I thought such a thing did not exist. Then I found uIP, which is part of the Contiki OS. More importantly, I found the avr-uip port which extracts uIP out of Contiki, and pairs it with the ENC28J60 driver. Even with all of its restrictions and compromises, it was able to download files from the web at 180kbytes/sec with only a 500-byte packet buffer. That’s plenty fast enough to keep up with a 128kbits/sec Icecast stream with plenty of time left over for dealing with network hiccups.

Unfortunately, avr-uip is not packaged to work with the Arduino IDE, so I extracted a few key pieces, and repackaged it as the EtherBright library. From avr-uip, it contains:

• TCP/IP stack (‘uip’ directory)
• ENC28J60 drivers (‘drivers/enc28j60’ and ‘drivers/interfaces’)
• Webclient applet. Basic logic for making HTTP requests and parsing the response. Minor changes from the avr-uip project, to use PROGMEM for string storage and to support the ICY protocol.

VS1053 Library

Get the VS1053 library. For the player, I just followed the code in this thread on the VLSI forum, and cleaned it up a bit into a nice library.

IcyArduino Sketch

Get the IcyArduino sketch, and put it in your sketchbook.

Connections

Hooking up the hardware is easy, especially with Nanode. The VS1053 unit is attached to the secondary connector outside the digital pins. This table details the setup I’ve used here. It is straightforward to modify it for other EtherShield setups. Do be aware that the Nanode uses pin 8 for SPI chip select, so I’m using pin 10 for the VS1033 chip select. Other shields use pin 10 for the Ethernet, so you’d have to hook up the VS1053 to a different pin and change the software.

Nanode	Wire	VS1053
5V	brown	5V
0V	red	GND
13 SCK	green	SCLK
12 MISO	orange	SO
11 MOSI	yellow	SI
10 SS	blue	XCS
INT	–	–
3V3	–	–
7 MAC	white	XDCS
6 LED	–	–
5	purple	XRESET
4	grey	DREQ

IcyArduino explained

Now let’s take a tour through IcyArduino.ino.

setup

First, we initialize serial and printf, then print out some information so we know that all is well sofar.

void setup(void)
{
  // Bring up serial and print some hello text
  Serial.begin(57600);
  printf_begin();
  printf_P(PSTR(__FILE__ "\r\n"));
  printf_P(PSTR("Free memory = %u bytes\r\n"),SP-(__brkval?(uint16_t)__brkval:(uint16_t)&__heap_start));


Second, we bring up the three layers of uIP, first the chip driver, then the uIP stack, then the webclient applet. Note that this sketch uses static IP addresses for simplicity.

  // Bring up ENC28J60 driver
  network_prepare_MAC(mac.addr);
  network_init();
  enc28j60Write(ECOCON, 1 & 0x7); //Get a 25MHz signal from enc28j60
  
  // Bring up uIP
  uip_init();
  
  // Setup MAC address
  uip_setethaddr(mac);
  
  // Setup our IP, gateway, and netmask -- all statically
  uip_ipaddr_t ipaddr;
  uip_ipaddr(ipaddr, 192,168,1,55);
  uip_sethostaddr(ipaddr);
  uip_ipaddr(ipaddr, 192,168,1,1);
  uip_setdraddr(ipaddr);
  uip_ipaddr(ipaddr, 255,255,255,0);
  uip_setnetmask(ipaddr);
  
  // Bring up the webclient applet
  webclient_init();
  
  // Now that everything is set up, start periodic timers for uIP
  timer_set(&periodic_timer, CLOCK_SECOND / 2);
  timer_set(&arp_timer, CLOCK_SECOND * 10);


Finally, once uIP is up, we can finish up by starting the player and connect to our stream.

  // Bring up the MP3 player
  player.begin();
  
  // Launch a connection to our stream
  connect();
}


loop

The loop() is a stock uIP main loop, which is looking for new packets and handing them off to uIP correctly. The one thing I added is some reconnection logic to the arp timer. This fires every 10 seconds, which I thought was a good time to reconnect if we’ve lost the connection. Also, commented out by default, is a troubleshooting mechanism to print uIP statistics. This is a good thing to turn on if things aren’t working right.

    if(timer_expired(&arp_timer))
    {
      timer_reset(&arp_timer);
      uip_arp_timer();
    
      // Uncomment to get a periodic dump of stats.
      //dump_uip_stats();
    
      // Also use this timer to reconnect if we've lost connection
      if (!connected)
        connect();
    }


callbacks

This section contains the pre-defined callbacks which the webclient applet will use to signal changes.

The datahandler is called by the webclient applet when there is data to handle. This simply passes it off to the driver to be played, plus captures some statistics about the transfer.

void webclient_datahandler(char *data, u16_t len)
{
  Serial.print('.');
 
  if ( ! started_at )
    started_at = millis();
 
  size_received += len;
 
  player.playChunk(reinterpret_cast<uint8_t*>(data),len);
 
  if (!data)
  {
    Serial.println();
    printf_P(PSTR("%lu: DONE. Received %lu bytes in %lu msec.\r\n"),millis(),size_received,millis()-started_at);
  }
}


The rest of the file simply deals with the start and stop conditions, setting the current status as appropriate and printing status messages.

void webclient_connected(void)
{
  uip_log_P(PSTR("webclient_connected"));
  player.startSong();
  connected = true;
}
  
void webclient_timedout(void)
{
  uip_log_P(PSTR("TIMEOUT.  Reconnecting within 10s.\r\n"));
  player.stopSong();
  connected = false;
}
  
void webclient_aborted(void)
{
  uip_log_P(PSTR("ABORTED.  Reconnecting within 10s.\r\n"));
  player.stopSong();
  connected = false;
}
  
void webclient_closed(void)
{
  uip_log_P(PSTR("webclient_closed\r\n"));
  player.stopSong();
  connected = false;
}


Nanode For the Win

This project will work fine using a generic Arduino clone of any sort and nearly any ENC28J60-based Ethernet module or shield. But it’s best on Nanode for a few reasons:

• Nanode has a secondary pinout that is much more rational than Arduino. All of the VS1053 wires can plug in neatly and securely into a single 12-pin connector attached to the side of the board.
• Nanode has a its own MAC address. So rather than making up a MAC and hoping it doesn’t conflict with anyone else’s out there, we know we have a proper address.
• Nanode has a LED that doesn’t conflict with SCK, so we can actually use it on a project that relies on SPI. Can’t do that with the stock Arduino LED.