TEA5767N FM Philips Library for Arduino explained

 Gostaria de ver este post em português?

Motivation

TEA 5767 FM radio module

In this post I´ll explain the library I wrote  for TEA5767 FM module.

In my first experiments with TEA5767 in a breadboard I used the libraries from Simon Monk and Andy Karpov. Their code helped me a lot to understand how to control the TEA5767.

Then, to make a more complete application, I felt the need to organize my code a little bit and, with the help of the TEA5767 Application Note, I encapsulated the TEA5767 commands in several convenient methods.

Data Structure

To send or receive TEA5767 commands there are always five bytes involved. Even if you need to send a single bit, all five bytes must be resent. So I kept transmission and reception data bytes as instance attributes of the object, as seen below.

	class TEA5767N {
	private:
	//...
	byte transmission_data[5];
	byte reception_data[5];
	//...
	public:
	//...
	};

view raw tea5767_data_bytes.cpp hosted with ❤ by GitHub

The transmission bytes are initialized in the private method initializeTransmissionData() with the most common options and is called in the constructor. The comments were removed to make the reading more pleasant.

	TEA5767N::TEA5767N() {
	Wire.begin();
	initializeTransmissionData();
	}
	void TEA5767N::initializeTransmissionData() {
	transmission_data[FIRST_DATA] = 0;
	transmission_data[SECOND_DATA] = 0;
	transmission_data[THIRD_DATA] = 0xB0;
	transmission_data[FOURTH_DATA] = 0x10;
	transmission_data[FIFTH_DATA] = 0x00;
	}

view raw transm_const.cpp hosted with ❤ by GitHub

Now I can change only one or two bits and send all the five bytes with the values they had and were not affected by the change For example, a method to turn the radio mute on (or turn the sound off), has to manipulate only one bit of the five transmission bytes before resend them:

	void TEA5767N::mute() {
	setSoundOff();
	transmitData();
	}
	void TEA5767N::setSoundOff() {
	transmission_data[FIRST_DATA] |= 0b10000000;
	}
	void TEA5767N::transmitData() {
	Wire.beginTransmission(TEA5767_I2C_ADDRESS);
	for (int i=0 ; i<6 ; i++) {
	Wire.write(transmission_data[i]);
	}
	Wire.endTransmission();
	delay(100);
	}

view raw mute_transm.cpp hosted with ❤ by GitHub

And to set the sound on again:

	void TEA5767N::setSoundOn() {
	transmission_data[FIRST_DATA] &= 0b01111111;
	}

view raw set_sound_on.cpp hosted with ❤ by GitHub

And most of the methods are like this, switching bits on or off.
And as said earlier, there are also five bytes that can be read from the TEA5767 module. They are stored in the reception_data array and depending on the operation there is the need to update the transmission_data array too so they can be in sync. Here is an example:

	void TEA5767N::loadFrequency() {
	readStatus();
	transmission_data[FIRST_DATA] = (transmission_data[FIRST_DATA] & 0xC0) | (reception_data[FIRST_DATA] & 0x3F);
	transmission_data[SECOND_DATA] = reception_data[SECOND_DATA];
	}
	void TEA5767N::readStatus() {
	Wire.requestFrom (TEA5767_I2C_ADDRESS, 5);
	if (Wire.available ()) {
	for (int i = 0; i < 5; i++) {
	reception_data[i] = Wire.read();
	}
	}
	delay(100);
	}

view raw load_freq_status.cpp hosted with ❤ by GitHub

Note: Wire is an Arduino library that deals with I2C communication.

Algorithms

Reading the TEA5767 application note, you´ll find formulas and algorithms to set and read the station frequency. For example, to select a station frequency it´s necessary first calculate the optimal hi / lo injection which consists in select the (frequency - delta) and (frequency + delta), and choose the one that offers a better signal level. Delta is a constant that represents 450 kHz.

	void TEA5767N::selectFrequency(float frequency) {
	calculateOptimalHiLoInjection(frequency);
	transmitFrequency(frequency);
	}
	void TEA5767N::calculateOptimalHiLoInjection(float freq) {
	byte signalHigh;
	byte signalLow;
	setHighSideLOInjection();
	transmitFrequency((float) (freq + 0.45));
	signalHigh = getSignalLevel();
	setLowSideLOInjection();
	transmitFrequency((float) (freq - 0.45));
	signalLow = getSignalLevel();
	hiInjection = (signalHigh < signalLow) ? 1 : 0;
	}

view raw select_frequency_hilo.cpp hosted with ❤ by GitHub

And with this hi / lo injection value, the code can call the formula that calculates the 14-bit PLL that represents the station selected.

	void TEA5767N::transmitFrequency(float frequency) {
	setFrequency(frequency);
	transmitData();
	}
	void TEA5767N::setFrequency(float _frequency) {
	frequency = _frequency;
	unsigned int frequencyW;
	if (hiInjection) {
	setHighSideLOInjection();
	frequencyW = 4 * ((frequency * 1000000) + 225000) / 32768;
	} else {
	setLowSideLOInjection();
	frequencyW = 4 * ((frequency * 1000000) - 225000) / 32768;
	}
	transmission_data[FIRST_DATA] = ((transmission_data[FIRST_DATA] & 0xC0) | ((frequencyW >> 8) & 0x3F));
	transmission_data[SECOND_DATA] = frequencyW & 0XFF;
	}

view raw set_frequency.cpp hosted with ❤ by GitHub

Note that before the data are sent, they are stored in transmission_data so that it keeps always up to date.

Searching stations

Before actually starting a search, there are a few things that you have to set up: if  the search is up or down, the signal level a station must have to stop the search, and is recommended to mute the radio so that users don't hear that station change annoying sound.

To choose up or down search direction is also just change one bit in the transmission_data array.

	void TEA5767N::setSearchUp() {
	transmission_data[THIRD_DATA] |= 0b10000000;
	}
	void TEA5767N::setSearchDown() {
	transmission_data[THIRD_DATA] &= 0b01111111;
	}

view raw set_search_up_down.cpp hosted with ❤ by GitHub

There are three search stop levels: lo, mid and high.

	#define LOW_STOP_LEVEL 1
	#define MID_STOP_LEVEL 2
	#define HIGH_STOP_LEVEL 3

view raw search_stop_level.cpp hosted with ❤ by GitHub

To set one of these levels is a matter of changing two bits in the transmission_data.

	void TEA5767N::setSearchLowStopLevel() {
	transmission_data[THIRD_DATA] &= 0b10011111;
	transmission_data[THIRD_DATA] |= (LOW_STOP_LEVEL << 5);
	}
	void TEA5767N::setSearchMidStopLevel() {
	transmission_data[THIRD_DATA] &= 0b10011111;
	transmission_data[THIRD_DATA] |= (MID_STOP_LEVEL << 5);
	}
	void TEA5767N::setSearchHighStopLevel() {
	transmission_data[THIRD_DATA] &= 0b10011111;
	transmission_data[THIRD_DATA] |= (HIGH_STOP_LEVEL << 5);
	}

view raw search_stop_levels.cpp hosted with ❤ by GitHub

And to effectively start searching, after setting direction and level, you just call the searchNext() method.

	byte TEA5767N::searchNext() {
	byte bandLimitReached;
	if (isSearchUp()) {
	selectFrequency(readFrequencyInMHz() + 0.1);
	} else {
	selectFrequency(readFrequencyInMHz() - 0.1);
	}
	//Turns the search on
	transmission_data[FIRST_DATA] |= 0b01000000;
	transmitData();
	while(!isReady()) { }
	//Read Band Limit flag
	bandLimitReached = isBandLimitReached();
	//Loads the new selected frequency
	loadFrequency();
	//Turns de search off
	transmission_data[FIRST_DATA] &= 0b10111111;
	transmitData();
	return bandLimitReached;
	}

view raw search_next.cpp hosted with ❤ by GitHub

What this method does is
. Add or subtract 100 kHz from current station (so search doesn´t find current station again), depending on search direction;
. Sets the search bit;
. Waits for radio search;
. When search is ready, checks whether band limit has been reached or not;
. Update transmission_data array with the new selected frequency;
. Turn off the search bit;
. Returns band limit status.

Search_next() does not mute before search and is useful for debug purpose. To mute before search you can call mute() method yourself or you can use the convenient searchNextMuting() method.

	byte TEA5767N::searchNextMuting() {
	byte bandLimitReached;
	mute();
	bandLimitReached = searchNext();
	turnTheSoundBackOn();
	return bandLimitReached;
	}

view raw search_next_muting.cpp hosted with ❤ by GitHub

This only wraps searchNext() method with calls to mute on and off and also returns is band limit has been reached.

Two other useful search methods are startsSearchFromBeginning() and startsSearchFromEnd(). What they do is set the direction and start frequency before call searchNext().
I used these methods in a project to scan and record all avalilable stations. That project, as I said, will be my next post here.

	byte TEA5767N::startsSearchFromBeginning() {
	setSearchUp();
	return startsSearchFrom(87.0);
	}
	byte TEA5767N::startsSearchFromEnd() {
	setSearchDown();
	return startsSearchFrom(108.0);
	}
	byte TEA5767N::startsSearchFrom(float frequency) {
	selectFrequency(frequency);
	return searchNext();
	}

view raw search_from_beginning_end.cpp hosted with ❤ by GitHub

And as you could expect there are the muting versions.

	byte TEA5767N::startsSearchMutingFromBeginning() {
	byte bandLimitReached;
	mute();
	bandLimitReached = startsSearchFromBeginning();
	turnTheSoundBackOn();
	return bandLimitReached;
	}
	byte TEA5767N::startsSearchMutingFromEnd() {
	byte bandLimitReached;
	mute();
	bandLimitReached = startsSearchFromEnd();
	turnTheSoundBackOn();
	return bandLimitReached;
	}

view raw search_muting_beginning_end.cpp hosted with ❤ by GitHub

Conclusion

Thanks to the ability to write this library in C++, an object oriented language, I could write more cohesive methods that are easy to use by other client software. This way, using this library you can build your system step-by-step as you try the module features. Separating methods in public and private members also helps to understand how the library is supposed to be used.

Another good practice you can find in this library is the careful choice of the variables and methods names. They reveal the intention, what´s the variable role and what the methods do.

In the post Complete FM Radio using Arduino, TEA5767 library and LCD Shield

I show how I used this library with Arduino, TEA5767 FM module and the LCD Keypad Shield to build a complete radio application.

Thank you!

Thank you for reading!
Please let me know if this library somehow helped you in your projects.
To follow my updates to this library and my other projects:

Follow @mr0ger