Published November 25, 2017

Tivoli OnionRadio

Adding an omega2 to an old Tivoli PAL radio to get web radio with minimal external modifications

IntermediateWork in progress3,200

Things used in this project

Hardware components

Microchip ATtiny85

DC-DC Buck Converter (12V->5V)

USB Audio Card

USB Bluetooth Audio Receiver

Onion Corporation Omega2

RGB Diffused Common Anode

3 mm LED : White

Resistor 100k ohm

Linear Regulator (Low Dropout)

Hand tools and fabrication machines

Soldering iron (generic)

Story

I have an old Tivoli PAL radio that I wanted to upgrade to get web radio. For the task, I chose to use an Onion Omega2, for a few reasons:

It's cheap, the omega2 costs $5

It's small

It can handle being unplugged without corrupting the memory

My goal is to achieve the following:

Play web radio when the power button is in the FM position

Stream Bluetooth audio when the power button is in the AM position (Alternatively, use Airplay when the knob is in the AM position, guides for that are readily available)

Use the tuner knob to chose web radio stream

preserve the mini-jack input for later use

I've made two external modifications to the radio to achieve this: swapping the green LED for an RGB LED, and removing the FM antenna in favor of a WiFi antenna.

This is still a developing project, so the description is lacking, but it should be possible to use :-)

Parts

1 Onion Omega2

1 ATTiny85

1 USB audio card

1 potentiometer

PCB (or protoboard)

2mm header pins

1 RGB LED

1 small clear LED

1 WiFi antenna with UNF cable

1 Buck DC converter

Removing Tuner PCB

The first step is to remove the tuner PCB.

The inside of the radio with the tuner PCB removed

The old tuner card needed to go, as I needed the room. I've also plucked out the green LED, in order to put in an RGB LED. As it turned out, I couldn't find an RGB LED that fit in the tiny hole in the Tivoli Radio, so I used a small clear LED, clipped of the tip and glued in the hole to use as a "lens" for the larger LED, which I glued on the back of the "lens"

RGB LED in place, glued onto a "lens" made from a small clear LED

Detecting Power Button Position

The next step is to detect the position of the power button. This way, the Omega can turn off the stream when the radio is off, and can later be expanded to stream bluetooth. Shown below is the pins of the power button

Power button pins, photographed from below.

I hooked up a multimeter, to check which pins were grounded in each button position, and got the following:

Testing which button pins are grounded for each button position.

As it turned out, some of the pins are always grounded, but each button state has one pin each grounded. Pins 1, 2, and 6 are always grounded, but pins 5, 9 and 10 are only grounded in the OFF, FM and AM position respectively.

Simple schematic of button position measurement

To measure the button position, I fed 3.3V to each "to-be-grounded" pin through a large resistor (110k), and measured the voltage at the pin. If the pin is grounded, the voltage will read as low, if the pin is not grounded, the voltage will read as high. The resistor prevents current from moving to the ground when the pin is grounded.

Wires soldered to the FM and AM pins

With this in place, it is now possible for the omega2 to know which position the power button is in, and act accordingly (play web radio or bluetooth).

Measuring Tuner Knob Position

Next, we need to measure the position of the tuner knob. This will be used to select the radio stream.

Tuner button

The tuner knob is geared down, so the operation of it feels quite smooth. It also only rotates about half a rotation.

Potentiometer for measuring the tuner knob position

The tuner knob position was measured using a potentiometer. It doesn't really matter what resistance it has, but it shouldn't be too low, as it will then let current pass through it.

Get External Inputs to the Omega

The Omega doesn't have any analog inputs, and I couldn't get any SPI ADCs to work, so I ended up using an ATtiny85. I programmed the ATtiny using an Arduino, as explained in this guide, and in this video

The bonus with this setup, is that the ATtiny can do a lot of the work that the omega would otherwise do, detect both the tuner knob and the power button, divide the tuner knob positions into one zone for each channel, and a few other things. Bottom line: The ATtiny gives the Omega instructions through serial communication, and the Omega only has to listen from instructions from the ATtiny.

Stripping Down the USB Audio Adapter

The Omega doesn't have any audio outputs, so we need to add that.

USB sound card, ready for modification

I bought a cheap USB sound card from ebay to play audio. To minimize it, I removed the cable, plug and casing.

USB card with casing removed

I also chose to solder the audio cable directly on the PCB, in stead of using a mini-jack plug.

Sound card with audio cable soldered on. The red cable is the signal from one channel

I only soldered on the signal wire for one of the audio channels, since the Tivoli radio only has a single speaker.

Custom "PCB" mounted in the radio

The PCB now contains the following:

Omega2

Buck 3.3V regulator

ATTiny85

Potentiometer

USB audio card

Software:

Set up WiFi using the following;

wifisetup

Type in the correct information for your WiFi. Verity that you are connected by running

ping www.google.com

If you are still not connected, try running

wifimanager

This will reapply the network settings.

Update the firmware by running

opkg update
oupgrade

install the necessary programs to the onion by running the following:

opkg update
opkg install python-light python-logging python-pyserial alsa-lib alsa-utils mpg123 libmpg123 pyOnionGpio

Download the OnionRadio.py python file to the /root folder of you omega, along with a channels.txt file. (channels.txt is a simple text file, each line containing the URL of a web radio channel. Modify this to add/remove channels)

Schematics

File missing, please reupload.

Code

#!/usr/bin/python
import onionGpio
import time
import subprocess
import serial
import socket
import logging

serialName = '/dev/ttyS1'
baudRate = 9600
mySerial = serial.Serial(serialName, baudRate, timeout=1)

logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

formatter = logging.Formatter('%(asctime)s:%(levelname)s:%(message)s')
file_handler = logging.FileHandler('/root/radioErrors.log')
file_handler.setFormatter(formatter)

logger.addHandler(file_handler)

gpioR = onionGpio.OnionGpio(19)
gpioG = onionGpio.OnionGpio(15)
gpioB = onionGpio.OnionGpio(17)

status = gpioR.setOutputDirection(0)
status = gpioG.setOutputDirection(0)
status = gpioB.setOutputDirection(0)

def getChannelList():   # Imports channel list from text file
        myFile = open("/root/channels.txt", "r")
        myFile.seek(0,0)
        channels = myFile.readlines()
        myFile.close()
        channels = [channel.rstrip("\n") for channel in channels]
        channels = channels + channels
        return channels

def updateChannelNumbers(ser, channelList):     # sends the new number of channels to the ATtiny
        nChannels = len(channelList)
        n = str(nChannels)
        ser.write(n)
        x = ser.readline()
        if(x):
                chan = int(x)-1
        else:
                chan = 0
        return chan


def is_connected():                     # checks for internet connectivity
        try:
                socket.create_connection(("www.google.com", 80))
                return True
        except:
                blink()
        return False

def reconnect():                        # Attempts to restart the wifi
        print "attempting to reconnect"
        netProc = subprocess.Popen(["wifimanager"], shell=False)
        netProc.wait()

def setColor(color):                    # changes the color of the RGB LED
        if (color=='red'):
                        gpioR.setValue(1)
                        gpioG.setValue(0)
                        gpioB.setValue(0)
        elif (color=='blue'):
                        gpioR.setValue(0)
                        gpioG.setValue(0)
                        gpioB.setValue(1)
        elif (color=='green'):
                        gpioR.setValue(0)
                        gpioG.setValue(1)
                        gpioB.setValue(0)
        else:
                        gpioR.setValue(0)
                        gpioG.setValue(0)
                        gpioB.setValue(0)

def blink():                            # blink red light. (not in use)
        setColor('red')
        time.sleep(100)
        setColor('off')
        time.sleep(200)
        setColor('red')
        time.sleep(100)
        setColor('off')
        time.sleep(200)

channels = getChannelList()
chan = updateChannelNumbers(mySerial, channels)
P1 = channels[chan]

oldproc = subprocess.Popen(["mpg123", "-q", "-m", P1], shell=False)
subprocess.call(["kill", "-9", "%d" %oldproc.pid])
oldproc.wait()


oldButtonPos = 0;
buttonPos = 0;

nTries = 0
setColor('blue')
while (is_connected()!=True):
        reconnect()
        nTries += 1
        if(nTries>3):
                #raise Exception('failed to connect to the internet')
                break
if(nTries>3):
        setColor('red')
else:
        setColor('green')

while True:

        try:
                x = mySerial.readline()
                #interpret data from the ATtiny (button change + tuner change)
                if(x):
                        print "Received data: " + x.replace('\r\n', '')
                        if x=='BT\r\n':
                                buttonPos=2;

                        elif x=='OF\r\n':
                                buttonPos=0;

                        elif x=='FM\r\n':
                                buttonPos=1;
                        else:
                                chan = int(x)-1
                                print "Channel: " + str(chan)
                                P1 = channels[chan]
                                proc = subprocess.Popen(["mpg123", "-q", "-m", P1], shell=False);
                                time.sleep(1)
                                subprocess.call(["kill", "-9", "%d" % oldproc.pid]);
                                oldproc.wait()
                                oldproc = proc

                else:
                        #print "timeout"
                        pass
                # Perform actions when the button has changed position

                if(oldButtonPos!=buttonPos):
                        oldButtonPos = buttonPos;

                        print "Button position: " + str(buttonPos)
                        if(buttonPos==0):
                                print "Radio has been swithed off"
                                print "Changing to red"
                                setColor('red')
                                subprocess.call(["killall", "mpg123"]);
                                oldproc.wait()
                                #subprocess.call(["killall", "shairport-sync"]);
                        elif(buttonPos==1):
                                print "Radio mode"
                                print "Changing to green"
                                setColor('green');
                                P1 = channels[chan]
                                oldproc = subprocess.Popen(["mpg123", "-q", "-m", P1], shell=False);
                                #subprocess.call(["killall", "shairport-sync"]);
                        else:
                                print "Bluetooth mode"
                                print "Changing to blue"
                                setColor('blue')
                                subprocess.call(["kill", "-9", "%d" % oldproc.pid]);
                                oldproc.wait()
                                #subprocess.call(["shairport-sync", "-d"]);
                                print "loading new channel list"
                                channels = getChannelList()
                                chan = updateChannelNumbers(mySerial, channels)
                                print "channel list updated"

        except IOError:
                logger.debug("IOError")
        except IndexError:
                logger.debug("IndexError")
        except ValueError:
                logger.debug("ValueError")
        except KeyboardInterrupt:
                setColor('off')
                if (buttonPos==1):
                        subprocess.call(["kill", "-9", "%d" % oldproc.pid]);
                        oldproc.wait()
                gpioR._freeGpio
                gpioG._freeGpio
                gpioB._freeGpio
                print "Good bye"
                logger.debug("Safe exit")
                exit()
        except:
                setColor('off')
                if (buttonPos==1):
                        subprocess.call(["kill", "-9", "%d" % oldproc.pid]);
                        oldproc.wait()
                gpioR._freeGpio
                gpioG._freeGpio
                gpioB._freeGpio
                #open('/root/radioErrors.log', 'w').close()
                logger.exception("well, this is embarrassing...")

#include <SoftwareSerial.h>

#define RX 3
#define TX 4

SoftwareSerial Serial(RX, TX);  // RX, TX according to
                                // http://arduino.cc/en/Reference/SoftwareSerial


int adc1;
int zones = 1;
int oldZone = 1;
int newZone = 1;
int oldPos = 0;
int newPos = 0;
int tempPos = 0;
int nStable = 0;
int nZones = 8;
int reps = 0;
char data;

float adcFrac;

void setup() {
Serial.begin(9600);
Serial.println("Initializing...");
}

int determineButtonPos(){             // Reads the position of the power button
  int BT = not(digitalRead(1));
  int FM = not(digitalRead(0));

    if(BT){
      return 2;
    }
    else if(FM){
      return 1;
    }
    else {
      return 0;
    }
}

void loop() {

  newPos = determineButtonPos();
  
  if (newPos != oldPos) {             // This will only execute if the button position has changed
    
    /* --- To avoid jitter in the button switching, check if the new position remains the same -- */
    nStable = 0;                                                                                  //
    while (nStable<3){                                                                            //
       delay(100);                                                                                //
       tempPos = determineButtonPos();                                                            //
       if(tempPos==newPos){                                                                       //
        nStable++;                                                                                //        
       }                                                                                          //
       else{                                                                                      //
        nStable=0;                                                                                //
        newPos = tempPos;                                                                         //
       }                                                                                          //
    }                                                                                             //
    /* --------------- New button position is now stable ---------------------------------------  */

    oldPos = newPos;

    /* ---------------------------- Output the button position to the serial buffer --------------*/
    if(newPos==1){                                                                                //
      Serial.println("FM");                                                                       //
      reps = 0;                                                                                   //
    }                                                                                             //
    else if(newPos == 2){                                                                         //
      Serial.println("BT");                                                                       //
    }                                                                                             //
    else{                                                                                         //
      Serial.println("OF");                                                                       //
    }                                                                                             //
    /* ---------------------------- Button position has now been communicated to serial ----------*/
  }
  

  while (newPos == 1){            // Executes as long as the power button is in the "FM"-position

    newPos = determineButtonPos();  // Detect if the button has changed away from the "FM"-position

    
    adc1 = analogRead(1);
    adcFrac = (1023-float(adc1)) / 1023;
    
    /* ---------------- Check if the Onion has said anything about the number of zones -----------*/
    if(Serial.available()) {                                                                      //
       nZones = Serial.parseInt();                                                                //
       newZone = (int) (adcFrac * nZones);                                                        //
       oldZone = newZone;                                                                         //
       Serial.println(newZone);                                                                   //
    }                                                                                             //
    else {                                                                                        //
     newZone = (int) (adcFrac * nZones)+1;                                                        //
    }                                                                                             //
    /* -------------------------------------------------------------------------------------------*/

    /* --------------------- If the zone has changed, write it to serial -------------------------*/
    if (newZone != oldZone){                                                                      //
      reps+=1;                                                                                    //
      if (reps>=10){                  // Check if the zone change is stable (avoid jitter)        //
        Serial.println(newZone);                                                                  //
        oldZone = newZone;                                                                        //
      }                                                                                           //
    }                                                                                             //
    else {                                                                                        //
      reps = 0;                                                                                   //
    }                                                                                             //
    /* -------------------------------------------------------------------------------------------*/
    delay(20);
  }
  delay(50);
}

Credits

Carl Bergan

1 project • 0 followers

Tivoli OnionRadio

Things used in this project

Hardware components

Hand tools and fabrication machines

Story

Parts

Removing Tuner PCB

Detecting Power Button Position

Measuring Tuner Knob Position

Get External Inputs to the Omega

Stripping Down the USB Audio Adapter

Software:

Custom parts and enclosures

Tuner knob adapter

Schematics

PCB Schematic

PCB Fabrication Files (Gerber)

Code

Main python program

ATtiny-code

Credits

Carl Bergan

Comments

Embed the widget on your own site

Tivoli OnionRadio

Tivoli OnionRadio

Things used in this project

Hardware components

Hand tools and fabrication machines

Story

Parts

Removing Tuner PCB

Detecting Power Button Position

Measuring Tuner Knob Position

Get External Inputs to the Omega

Stripping Down the USB Audio Adapter

Software:

Custom parts and enclosures

Tuner knob adapter

Schematics

PCB Schematic

PCB Fabrication Files (Gerber)

Code

Main python program

ATtiny-code

Credits

Carl Bergan

Comments

Related channels and tags