Macduino

PDC1211: a simple clock sketch

noreply@blogger.com (Maczinga) — Sun, 17 Dec 2017 21:24:00 +0000

Hello! Upon request I've written a very simple clock sketch. It uses the PDC1211 library for that I wrote for a 7 segments lcd with 12 digits and 1 row. In its own turn this library is based on the HT1621 and LiquidCrystal7S libraries. Please see them all for more informations. Enjoy!

The sketch

It is assumed that you use a PDC1211 module. The clock is pretty precise but to be more precise I've added some compensation to correct the millis lost during the lcd update operations. The compensation has been measure on an Arduino Uno module, if you use a different module, please recompute the compensation.

Indeed, an update is performed every 500 millis. If the variable Blink is true then only the two '-' symbols are updated. Otherwise, a second is passed and all the time variables are updated suitably. The first phase costs about 5 millis, the second 9 millis. If the updating period is changed, then don't forget to measure and change those values.

See here for more informations about pin connections.

/**
 * \file clock.ino
 * \brief Simple clock for the PDC1211 library.
 * \author Enrico Formenti
 * \date 12 17 2017
 * \version 1.0
 * \copyright BSD license, check the License page on the blog for more information. All this text must be
 *  included in any redistribution.
 *  <br><br>
 *  See macduino.blogspot.com for more details.
 */

#include "PDC1211.h"

#define SS 2
#define RW 3
#define DATA 4

PDC1211 lcd(SS,RW,DATA);


uint8_t seconds = 55;
uint8_t minutes = 59;
uint8_t hours = 23;

bool hasToUpdateHours = true;
bool hasToUpdateMinutes = true;
bool Blink = false;
uint16_t compensation = 0;


void setup() {
    lcd.begin();
}

void loop() {

    delay(500);
    if(Blink) {
        lcd.setCursor(2,0);
        lcd.print(" ");
        lcd.setCursor(5,0);
        lcd.print(" ");
        compensation += 5;

    }
    else
    {
        lcd.home();
        ++seconds;
        if(compensation>=1000) {
            ++seconds;
            compensation = 0;
        }
        if(seconds==60) {
            seconds = 0;
            ++minutes;
            hasToUpdateMinutes = true;
        }
        if(minutes==60) {
            minutes = 0;
            ++hours;
            hasToUpdateHours = true;
        }
        if(hours == 24)
            hours=0;
        if(hasToUpdateHours) {
            if(hours<10)
                lcd.print('0');
            lcd.print(hours);
        }
        else
            lcd.setCursor((uint8_t)2,(uint8_t)0);

        lcd.print("-");

        if(minutes<10)
            lcd.print('0');
        if(hasToUpdateMinutes)
            lcd.print(minutes);
        else
            lcd.setCursor((uint8_t)5,(uint8_t)0);
      
        lcd.print("-");
  
        if(seconds<10)
            lcd.print('0');
        lcd.print(seconds);
  
        hasToUpdateHours = false;
        hasToUpdateMinutes = false;
        compensation += 9;
    }
    Blink ^= true;
}

New tone music page!

noreply@blogger.com (Maczinga) — Tue, 24 Jan 2017 21:55:00 +0000

Hello! Do you like tone music? Maybe I've something for you! I've just started a new blog page containing my collection of tone music for Arduino. The page is accessible here and from the main menu. You will find 24 items at present but the list is (slowly) growing.

Please have a look the following posts for the playing software and how the musics are encoded.

Tone music surprises!
Tone music: advanced playing software
Tone music: how to encode songs

Enjoy!

ASOM (sensor library): now supporting MCP7941X

noreply@blogger.com (Maczinga) — Mon, 06 Jun 2016 16:44:00 +0000

Another great contribution of Daniele Ratti (aka ilFuria) who added support for SRAM and EEPROM for MCP7941X. Hope it may help. Many thanks to him.

The new version of the sensor library can be downloaded from GitHub here.

Some other developments are in preparation (September 2016). Please come back soon!

Enjoy!

Too bad! Norway abandoning FM Radio transmission as 2017

noreply@blogger.com (Maczinga) — Tue, 09 Jun 2015 22:11:00 +0000

Bad news for the FM radio lovers. Indeed, FM radio transmission is being progressively dismissed in favor of digital radio. This should sound like a progress but I feel it like a loss!

Indeed, if FM radio transmission and reception needs a pretty limited amount of electronic components. This "easy access" played a fundamental role in the past (think of the famous "Radio Londres" service of BBC during the II world war and to the multitude of homemade receivers). Digital radio receivers won't have the same accessibility degree since they need more sophisticated electronics.

According to BBC (see here) Norway will be the first country to stop FM transmissions. Hope the others will follow as later as possible!

Hey, dear deciders!
I just achieved my FM radio library for Arduino, please let us enjoy it!!!

:-)

How to distinguish Arduino's models at compile time?

noreply@blogger.com (Maczinga) — Sun, 07 Jun 2015 07:38:00 +0000

This is a question that you probably already asked yourself when trying to write code that must work with different Arduino's variants. Indeed, when using I2C, timers or PWM, the pins concerned on the Arduino Uno for these operations are different from Arduino Mega or form Due, etc. Hence, how to avoid the multiplication of the source files, of the classes or to excessively overload functions?

Solution: use conditional compilation!

In this short note we try to explain how to do that. Indeed, digging into the avr include files (see io.h for example) one can find the following constants are used:

__AVR_ATmega328P__
__AVR_ATmega328__

These are used to recognize that we are compiling for Arduino Uno. For the Arduino Mega we find:

__AVR_ATmega1280__
__AVR_ATmega2560__

Therefore your code might look like:

#if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega328P__)
  
  [your arduino uno code here]
  
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)

  [your arduino mega code here]

Enjoy!

Sonar robot (multiple HC-SR04): Gastaud's version

noreply@blogger.com (Maczinga) — Sat, 06 Jun 2015 06:56:00 +0000

Here is one more version of the sonar robot we have seen here. I would like to stress how fluid is the navigation of the robot. Give a look at the short movie to get convinced!

Photos

Bottom view.

Front view.

Top view.

The movie

Look at the robot moving in an homemade arena. It seems human operated but it is not! Just try yourself if you don't trust me.

High quality (345MB)
Low quality (35MB)

The sketch

Look at here for the libraries. The main program is not yet greatly optimized (not the main goal at present) but it works smoothly.

gastaud2.ino

Enjoy!

ASOM (sensor library): update and bug fixes

noreply@blogger.com (Maczinga) — Sun, 31 May 2015 20:04:00 +0000

Many many thanks to Daniele Ratti who made a lot of improvements to the section concerning the RTC module. He made also some bug fixes and tested all the procedures.

The new version of the sensor library can be downloaded from GitHub here.

Enjoy!

Sonar robot (multiple HC-SR04): the components list

noreply@blogger.com (Maczinga) — Sat, 30 May 2015 10:39:00 +0000

Here is the list of the modules, motors etc. that has been used to build the sonar robot. All the material can be easily found in specialized shop or on Ebay for few Euros. Pay attention to the version of the motor shield you have. It has to match the version of the library you have installed.

	2x DC Motor 3-6V and their wheels and tyres
	1x fixed wheel caster
	Motor Shield Adafruit 1438
	3x Ultrasonic sensor HC-SR04 (or similar)
	180 points prototype mini-breadboard (or similar)
	A bunch of cables (male-female and male-male)
	Patafix or blue tack
	Bi-adesive velcro stripe
	8mm acrylic sheet
	...and your friend Arduino!

Sonar Robot (multiple HC-SR04)

noreply@blogger.com (Maczinga) — Sat, 30 May 2015 10:39:00 +0000

A big bravo to the students of Complexity class of Nice Sophia Antipolis University (France)!

Following the guidelines of this post, the students realized an explorer robot which can perform some basic obstacle avoidance.

Some photos

The material

The complete list of components and all the materials used to build the robot can be found here.

The software

AF_Motor library (download it from GitHub here and follow this guidelines for its installation)
HC-SR04 programming guidelines found here (see also the connected links)
Homebrewed artificial intelligence inspired from here.

More photos, movies and software

Gastaud's version
{Balde, Diallo, Moulayeely, Yacoub}'s version (source code only)
More to come!

Enjoy!

PIR sensors: exploiting passivity

noreply@blogger.com (Maczinga) — Sun, 15 Mar 2015 21:30:00 +0000

We have already spoken about the PIR sensor in these pages (see here) and many other pointers can be found on the web. However, the example sketches does never consider the main aspect of this sensor: passivity! The sketches always employ busy waiting (ie they continuously loop on the test for changes over the alarm pin).

The PIR sensor used in the sketch.

The idea

Use interrupts! The idea is that the alarm function is activated by the state change of the signal pin of the sensor. In this way the CPU can perform other tasks when the alarm is not activated.

Remark

When the alarm is triggered on the PIR sensor it remains in this state for a certain amount of time. Since we chose to implement the CHANGE option for the interrupt routine we have to prevent that the service routine is run twice instead of once. This is implemented using a simple flag.

The sketch

Since the sketch has only prototyping purposes, the only effect of the alarm trigger is to print a message to the serial monitor. To see the message open the serial monitor, choose the right port and communication speed.

/**
 * PIRpassExploit
 *
 * A convenient way to use PIR sensors
 *
 * \author Enrico Formenti
 * \version 1.0
 * \date 15 March 2015
 * \copyright BSD license, check the License page on the blog for
 * more information. All this text must be included in any 
 * redistribution.
 * <br><br>
 * See macduino.blogspot.com for more details.
 *
 * Remarks:
 * - OUT pin is connected to digital pin 2 of Arduino, change this
 *   if needed
 * - DELAY times depend on the type of module and/or its 
 *   configuration.
 */

// OUT pin on PIR sensor connected to digital pin 2
// (any other digital pin will do, just change the value below)
#define PIRSensorPin 2

// This is the amount that the sensor takes to setup internals
// Check your sensor datasheet for the correct value
// Mine is about 17 seconds
#define PIR_INIT_DELAY 17000

// This is used to avoid triggering alarm twice when signal returns
// to normal state
volatile bool alarmUnarmed;

void doAlarm() {
  if(alarmUnarmed) {
    alarmUnarmed = false;    
    Serial.println("Alarm triggered!");
  }
  else
    alarmUnarmed = true;
}

void setup() {
  Serial.begin(9600);
  
  pinMode(PIRSensorPin, INPUT);
  delay(PIR_INIT_DELAY);
  
  alarmUnarmed = true;
  attachInterrupt(0, doAlarm, CHANGE);
}

void loop() {

  // do some good work here ;-)
}

Enjoy!

PDC1211: a 7 segments LCD

noreply@blogger.com (Maczinga) — Sat, 28 Feb 2015 11:36:00 +0000

Abstract
The PDC1211 is a 7-segments display LCD. In this post we provide a library for dealing with this display. The library is strongly inspired by the classical LiquidCrystal library.

Main Characteristics

Module size (WxH):

95.6 x 32.6 mm

Active area (W x H):

77.4 x 16.8 mm

Viewing angle:

6:00

Driving voltage:

Driving IC:

HT1621

Operating temp.:

-2O°C to 60°C

Storage temp.:

-30°C to 70°C

Manifacturer:

Nanjing Guoxian Electronics Corp

Figure 1. PDC1211: special symbols and pinout.

Introduction
The PDC1211 is a 7 segments LCD which is (was?) used mainly for telephony purposes. It has 12 7-segments digits and 7 special symbols. Figure 1 provides an overall view of the display and the position of the special symbols (numbered 1 to 7 in red). Indeed, more than symbols these seems to be sentences written in Chinese. Since I don't know Chinese, I have no idea of their meaning. Except for the 4th one which I got translated from a Chineese girl that I met in the train: "Local phone (number)". I would be grateful to any of you that could provide a translation for the remaining symbols/sentences.

Encoding a character
Concerning the representation of the digits, the PDC1211 follows the requirements of the HT1211 chip. Figure 2 shows the wiring of the backpane and Figure 3 the wiring of the frontpane. These are useful to compute the code values for the printable characters.

Figure 2. Wiring of the backpane.

Figure 3. Wiring of the frontpne.

Segment 0 of the memory mapping of the HT1621 corresponds to the leftmost digit. As illustrated in Figure 3, two memory segment adresses are used to encode a single character. Segments named a, b, c, d are the least significant bits and e, f, g, h. So to encode a 0 for example, one would set segments b, c, d in the first address and e, f, h in the other. Hence we obtain 0xE (or 0B1110) for the first segment and 0xB for the second. However, it is not recommended to write directly these values to the HT1621 but pass either through the write function or through the standard Print interface (see the dedicated section).

Configuration

Libraries. In order to work this library needs the following libraries installed:

HT1621 (version 1.0 or later)
LiquidCrystal7S (version 1.1 or later)

both of them can be downloaded from this website.
Pinout. The pins on the module are numbered 1 (leftmost) to 5 (rightmost) and are associated as in Figure 1 where SS is pin 1 and Vcc is the number 5. In our examples, pin 1 is connected to Arduino pin 2, pin 2 to Arduino pin 3 and pin 3 to Arduino pin 4.

Installing the library
As all Arduino's additional libraries, PDC1211 has to be installed in your local Arduino's library directory (look into Preference pane of your Arduino IDE to discover the path) in a directory called PDC1211/src. The documentation can be installed into PDC1211/doc.

Communication protocol
The communication between Arduino and the PDC1211 follows the same protocol as for the HT1621 but here Read/Write signals are on the same pin (RW) (see the documentation here for more details).

The print interface
This library implements the method of the Print interface of LiquidCrystal with all its advantages and all of its drawbacks. Moreover, remark that the type of the value to print is important, for example the following instructions all have the same effect of printing a '0' symbol on the LCD

lcd.print((char)0xBE);
lcd.print('0');
lcd.print("0");

while the following

lcd.print(0xBE);

will print a three character string "190" ie. the integer value of 0xBE.
Finally, since this is a 7 segments display and hence not all characters can be displayed. The set of displayable characters is reduced to: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, b, C, c, d, E, F, H, h, L, N, n, o, P, r, t, U, u, -, . and space.

The examples
The following snippet shows the typical usage of the library

// mandatory include files
#include "HT1621.h"
#include "LiquidCrystal7S.h"
#include "PDC1211.h"
// Pin connections 
#define SS 2
#define RW 3
#define DATA 4
// LCD class instantiation
PDC1211 lcd(SS,RW,DATA);


void setup() {
  ...
  lcd.begin();
  ...
}


void loop() {
    ...
    
    lcd.print("HELLO"); // print something
    ...
}

All the examples shipped with LiquidCrystal library run as well exception made, of course, for those implying unsupported methods (see section next section).

Supported LiquidCrystal methods
Since PDC1211 is a child class of the LiquidCrystal7S class, it supports all of the methods of this class. However, they are a subset of those implemented by the LiquidCrystal library since they are impossible to implement in the context of a 7 segments display. Here is the full list of the unsupported methods:

cursor()
noCursor()
blink()
noBlink()
createChar()
blink()
noBlink()
createChar()

Downloads

The library consists in only one header and an implementation files:

And here it is the documentation both in pdf and html (zipped) formats:

PDC1211-man-v1_0.pdf (pdf format)
PDC1211-man-v1_0.zip (html format)

Enjoy!

LiquidCrystal7S: a library for 7 segments LCD based on HT1621 chipset

noreply@blogger.com (Maczinga) — Sun, 15 Feb 2015 11:20:00 +0000

Abstract

This project aims at implementing the same functionalities as the classical LiquidCrystal library for 7 segments LCD based on the HT1621 chipset. The LCD is supposed to communicate with the HT1621 through a 3-wire or a 4-wire serial protocol. Remark that this wants to be a generic driver, hence only the basic features of 7 segments displays are implemented. All the other features such as displaying special characters or fine tuning should be implemented in a child class. Indeed, the driver is not aware of how memory is mapped to the LCD screen.

Configuration

LCD initialization.The display is initialized with 256KHz internal RC clock frequency, 1/3 Bias and 4 Commons. Refer to the manual of class HT1621 on how to change these settings.

Communication protocol. The communication protocol (3-Wire vs. 4-Wire) is chosen at the constructor level. Using the k-parameters constructor selects the k-Wire protocol.

The examples

As usual, here is a small example for testing the library. The sketch initializes the LCD and then writes a line of symbols 0xBE (this corresponds to '0' on my LCD). The sketch assumes a 12 digits LCD, if you has more (or less) digits please modify the range in the for loop.

/**
 * \file LiquidCrystal7S-test.ino
 * \brief Simple test sketch for the LiquidCrystal7S library.
 * \author Enrico Formenti
 * \date 8 february 2015
 * \version 1.0
 * \copyright BSD license, check the License page on the blog for more information. All this text must be
 *  included in any redistribution.
 *  <br><br>
 *  See macduino.blogspot.com for more details.
 */
#include "HT1621.h"
#include "LiquidCrystal7S.h"

// refer to Macduino website for pin connections 
// and their meaning

#define SS 2
#define RW 3
#define DATA 4

LiquidCrystal7S lcd(SS,RW,DATA);

void setup() {
  uint8_t i;
  
  lcd.begin(12, 1);

  // write all zeroes
  for(i=0; i<12; i++)  
    lcd.print((char)0xBE); // remark the cast here
}

void loop() {}

As a second example, here is a sketch which prints a string of three characters 0xBE (a '0' on my LCD).

/**
 * \file LiquidCrystal7S-test.ino
 * \brief Print a string using LiquidCrystal7S library.
 * \author Enrico Formenti
 * \date 8 february 2015
 * \version 1.0
 * \copyright BSD license, check the License page on the blog for more information. All this text must be
 *  included in any redistribution.
 *  <br><br>
 *  See macduino.blogspot.com for more details.
 */
#include "HT1621.h"
#include "LiquidCrystal7S.h"

// refer to Macduino website for pin connections 
// and their meaning

#define SS 2
#define RW 3
#define DATA 4

LiquidCrystal7S lcd(SS,RW,DATA);
const char str[] = {0xBE, 0xBE, 0xBE, 0};

void setup() {
  
  lcd.begin(12, 1);

  // write 3 zeroes
  lcd.print(str); // remark the definition of str here
}

void loop() {}

Downloads

The library consists just in the header and implementations files:

LiquidCrystal7S.h (ver. 1.11)
LiquidCrystal7S.cpp (ver. 1.11)

The documentation is provided both in html and pdf formats:

HC-SR04 : using an ultrasonic module as a motion detector

noreply@blogger.com (Maczinga) — Wed, 11 Feb 2015 23:41:00 +0000

Abstract

This week we are going to use our preferred ultrasonic sensor as a motion detection module. This is an alternative to the classical PIR sensors (see here) with its pros and contras that we will try to illustrate.

The idea

We are going to use the HC-SR04 to measure some default distance (background distance) B. At regular time frames we are going to measure a new distance, say D. If D is different from A, then this means that there is an obstacle between the sonar and B.

Computing the background distance

We assume that the sensor has been fixed on some support and that for a certain interval of time there are no objects that enter in the scene. From this post, the safe interval of times between two distinct distance measurements is 26ms. Therefore we are going to perform SAMPLESIZE measurements and take the average distance (rounded up) as background distance.

uint16_t SetupDefaultDistance() {
  
  uint64_t averageMillis;
  uint32_t i;

  for(i=0, averageMillis=0; i<SAMPLESIZE; i++) {
    averageMillis += readoutSensor();
    delay(INITDELAYMS);
  }
 
  // return the mean (rounded up)
  return (uint16_t)(averageMillis/SAMPLESIZE); 
}

Configuring the sketch

Using a different ultrasonic module. To configure the sketch for a different ultrasonic module, the just change the definition of INITDELAYMS which is the minimal time between two valid distance measurements. The duration of the trigger signal is configured by changing TRIGLENUS (expressed in microseconds).

Choosing sample size. The duration and precision of the computation of the calibration phase is regulated by the macro SAMPLESIZE which accounts for the number of measurements over which take the mean distance (ie the background distance). Of course, the larger this number the more precise will be the value of the background distance. However, remark that larger sample sizes require greater times to be computed. We think that setting it to 100 is a good trade-off.

Sensibility. As it is well-known, the measurements of our sensor are not perfect. Therefore, if we don't want to trigger alarm just because a measuring error, it is better to setup some tolerance for measurement errors. Tolerance is controlled by the macro


TOLERANCE

which contains a float number between 0 and 1 which stands for the percentage of errors that we accept. Of course, it is not wise to setup a tolerance which is lower than your sensor precision ;-)

The pinout. The sketch uses digital pins 2 (ECHO signal) and 4 (TRIGGER signal). If one needs to change them, just change the corresponding macro definitions TRIGPIN and ECHOPIN.

The complete sketch

/**
 * \file MotionDetection.ino
 * \brief Motion detection using an HC-SR04
 * \author Enrico Formenti
 * \date 9 february 2015
 * \version 1.0
 * \copyright BSD license, check the License page on the blog for more information. All this text must be
 *  included in any redistribution.
 *  <br><br>
 *  See macduino.blogspot.com for more details.
 */

// the include below is for old versions of the IDE
// #include <Serial.h>

#define SAMPLESIZE 100
#define TOLERANCE .01
#define INITDELAYMS 26
#define TRIGLENUS 10

// trigger pin of HC-SR04
#define TRIGPIN 4 
// echo pin of HC-SR04
#define ECHOPIN 2

uint16_t defaultMS;
uint16_t curMillis;
uint16_t millisTolerance;

uint16_t readoutSensor() {
  // The sensor is triggered by a HIGH pulse of 10us or more.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  digitalWrite(TRIGPIN, LOW);
  delayMicroseconds(3);

  // Start trigger signal

  digitalWrite(TRIGPIN, HIGH);
  delayMicroseconds(TRIGLENUS);
  digitalWrite(TRIGPIN, LOW);
 
  // Read the signal from the sensor: a HIGH pulse whose
  // duration is the time (in microseconds) from the sending
  // of the ping to the reception of its echo off of an object.
 
  return pulseIn(ECHOPIN, HIGH);
}

uint16_t SetupDefaultDistance() {
  
  uint64_t averageMillis;
  uint32_t i;

  for(i=0, averageMillis = 0; i<SAMPLESIZE; i++) {
    averageMillis += readoutSensor();
    delay(INITDELAYMS);
  }
 
  // return the mean (rounded up)
  return (uint16_t)(averageMillis/SAMPLESIZE); 
}



void setup() {

  // setup pins
  pinMode(TRIGPIN, OUTPUT);
  pinMode(ECHOPIN, INPUT);

  // init serial communication
  Serial.begin(9600);

  // compute background distance
  Serial.print("Computing defaults...");

  defaultMS = SetupDefaultDistance();
  millisTolerance = (uint16_t)(defaultMS * TOLERANCE);
  
  Serial.println("Done."); 
}

void loop() {
  uint16_t val;
  
  curMillis = readoutSensor();

  if ( curMillis>defaultMS) 
    val = curMillis-defaultMS;
  else
    val = defaultMS - curMillis;
        
  if( val > millisTolerance)
    Serial.println("Motion detected!");
 
  delay(INITDELAYMS);
}

Remark that in the sketch all the distances etc. are expressend in milliseconds since there is no point to transform them into real distance. Indeed, we just want to measure differences!

Detection failures

If an object runs through the sensing cone of the HC-SR04 fast enough, then the sensor may fail to detect it. Indeed, assume that the sensing cone is 30 degrees wide (horizontally) and that an object traverses the cone at some distance d in a direction which is parallel to the sensor as illustrated in Figure 1. The HC-SR04 is positioned at the bottom of the triangle.

Fig. 1. Example of detection failure.

Then, with simple trigonometric calculations we may find that the speed v is given by the formula given in Figure 1, where t_d is the time that takes the sound wave emitted by the HC-SR04 to travel the distance d. For example, if d=4m then v is about 91 m/s.

HC-SR04 vs. PIR sensor

Each of these two modules has its own precise purpose which is distance measuring for HC-SR04 and motion detection for a PIR sensor. It is pretty clear that a PIR sensor cannot be used for distance measuring; however, an HC-SR04 can be used as a motion detector as it is proved by our previous sketch. Let us try to list advantages and disadvantages.

Advantages

Multipurpose: the HC-SR04 can be reverted for measuring distances; then back to motion detection and so on.
Configuration: the HC-SR04 can be quickly reconfigured completely via software; while, in general, PIR sensors need manual hardware configuration.
Initialization: can be pretty fast on the HC-SR04 (2-3 seconds); while it is a least 10 seconds on most PIR sensors.

Disadvantages

Sensing cone: PIR sensors have large sensing cones while the cone of HC-SR04 is very few degrees wide vertically and less than 30 degrees horizontally.
Speed: of course, light speed (PIR sensor) is incomparably higher than sound speed (HC-SR04).
CPU usage: the HC-SR04 needs to send signals periodically in order to detect motion and this uses CPU of course. On the other hand, PIR sensors are passive sensors, so they need CPU only when a motion is detected (if they are attached to an interrupt).
Detection failures: because of its low speed, the HC-SR04 may fail to detect a fast enough moving object (see the dedicated section); while this is nearly impossible for PIR sensors.

Conclusions

Each module is designed for its own purpose. However, turning an HC-SR04 into a motion detector can be useful in some situations.

Enjoy!

HT1621: a seven segments LCD driver

noreply@blogger.com (Maczinga) — Fri, 06 Feb 2015 22:11:00 +0000

Abstract
This note resumes the main characteristics of the HT1621 chip that are useful to drive 7-segments displays on Arduino boards.

Main Characteristics

Memory:

32x4 bits RAM (i.e. enough for 32x 7-seg displays with dot)

Operating voltage:

2.4V-5.2V

Power Consumption:

<3mA (@5V)

Power Consumption:

<600μA (@5V with no load, LCD on, internal RC oscillator on)

Clock (built-in):

256kHz RC oscillator

Clock (external):

32kHz quartz oscillator or 256kHZ external input

Comm. interface:

3-wire serial interface

Additional features

Comm. interface:

3-wire serial interface

Tone buzzer:

built-in 2kHz or 4kHz tone buzzer

Data accessing:

three accessing modes

Block diagram

Here is the functional block diagram directly extracted from the Holtek datasheet. In the sequel we will describe each of these blocks.

Figure 1. HT1621: functional block diagram.

Display RAM

This chip has a 32x4 bits static display RAM which is mapped directly to the display driver. Adresses are organized as displayed in Figure 2. The content of the RAM is directly mapped to the content of the LCD driver and may be affected by the commands READ, WRITE, READ-MODIFY-WRITE.

Figure 1. Memory structure of the HT1621. Remark that we have

restructure the adresses so to be able to take care of a full digit.

System oscillator

The system clock is used in a variety of tasks included LCD driving clock and tone frequency generation. HT1621 has a built-in RC oscillator (256kHZ) and a crystal oscillator (32768Hz). An external 256KHz oscillator can also be used. The type of oscillator used can be selecting by issuing XTAL32K, RC256K or EXT256K commands.
Issuing a SYS_DIS command stops the system clock, the LCD bias generator and the time base/WDT. The LCD screen will appear blank. An LCD_OFF command will turn off the bias generator but not the system clock. Issuing a SYS_DIS command will power down the system reducing power consumption.
Warning: The SYS_DIS command affects the system only when the internal RC 256kHZ or the 32.768kHz crystal clocks are used.

Tone output

The HT1621 can provide a tone output at the pins BZ and BZ. There are only two tone frequencies, namely: 2kHz and 4kHz that can be selected using the TONE2K or TONE4K, respectively. Then, the buzzer (if connected to BZ and BZ) start playing at the TONE_ON command. Sound is stopped issuing the TONE_OFF command.

Power-on

At power-on the system is in SYS_DIS state. A generic LCD initialization sequence will consist of the following steps:

Oscillator configuration
Bias/com configuration
System Enable
Bias generator start (LCD_ON)

The library

We have written a library to deal with all the features of HT1621. Since we could test the HT1621 only through a LCD which did not allow to read the on-chip RAM. We provide procedures to software simulate the internal HT1621 internal RAM and have transparent reading procedures. The simulated RAM is used as a default. To change this and use internal HT1621 RAM you need to add

#define __HT1621_READ

right before including the library header file in your sketch.

The test sketch

We provide a very basic sketch for testing the main functions. The pins are connected as follows:

HT1621	Arduino
SS	2
R/W	3
DATA	4

/**
 * \file HT1621-test.ino
 * \brief Simple test sketch for the HT1621 class.
 * \author Enrico Formenti
 * \date 4 february 2015
 * \version 1.0
 * \copyright BSD license, check the License page on the blog for more information. All this text must be
 *  included in any redistribution.
 *  <br><br>
 *  See macduino.blogspot.com for more details.
 */

#include "HT1621.h"

// refere to Macduino website for pin connections and their meaning
HT1621 ht(2,3,4);

void setup() {

  register uint8_t i;
  
  ht.begin();
  
  ht.sendCommand(HT1621::RC256K);
  ht.sendCommand(HT1621::BIAS_THIRD_4_COM);
  ht.sendCommand(HT1621::SYS_EN);
  ht.sendCommand(HT1621::LCD_ON);

  // clear memory
  for(i=0; i<16; i++)
    ht.write(i,0);

  // write all zeroes
  for(i=0; i<16; i++)  
    ht.write(i, 0xBE);
}

void loop() {}

A more comprehensive test set will come with the next post.

Downloads

The library consists in only one header and an implementation files:

And here it is the documentation both in pdf and html (zipped) formats:

Datasheets and application notes

And here it is the datasheets and application notes taken directly from Holtek

What's next

In the next post we will provide a class for dealing with a generic 7-segments LCD module based on the HT1621 chip with instruction set similar to the classical LiquidCrystal library (here). Finally, a class for a specific 7-seg LCD module that I found at bargains.

Enjoy!

FM radio receiver for your Arduino (TEA5767/TEA5768/TEA5757)(Part 4/4)

noreply@blogger.com (Maczinga) — Sun, 01 Feb 2015 21:24:00 +0000

Abstract

In this last part we provide a basic front-end for the FM radio and a simple example program. Moreover, we provide full documentation for all the TEA library and their classes.

This project is a simple implementation of a FM Radio player based on the FM module. The radio has a simple front-end consisting of the LCD module and its buttons. The are five possible working modes. For more details on the working modes see the Section "Using the radio".

Building the radio

Just stack the LCD module (more infos here) on your Arduino and connect the FM module as explained here. That's all!

Display and buttons

In all working modes (except for the sub-modes) the information is displayed in a standard format on the LCD. The first line indicates the frequency of the current station being reproduced (approx to 2 decimal digits) and the current working mode. The second line displays the audio level (a number between 0 and 16) and if the reception is stereo or mono. The following figure gives a more visual illustration of the display organisation.

Figure 1. Display organisation in main working modes.

The radio uses 4 out the 5 buttons on the LCD module (the leftmost ones). The leftmost button (button 1) and the its neighbor (button 2) are used as navigation buttons. In standard mode (STD), they are used to search backward (resp. forward) for the next station to reproduce. In recording mode (REC) and in memory mode (MEM), they are used to move backward or forward in the memory array. Button 3 is called mode button and it is used to change the working mode. Button 4 is called action button and it is used to confirm actions for the current working mode. For example, when choosing a memory slot for memorizing the current station in the memory array, if this button is pressed then the frequency of the current station is recorded and the radio returns in STD mode. The following figure illustrates buttons positions.

Figure 2. Buttons of the LCD module.

Warning For lack of space when displaying information on the LCD, some shortcuts are used. For example, btn means "button" and act means "action", etc.

Using the radio

At power on time, the radio is tuned at frequence 87.5 MHz on the US/European FM band, if a station is present then the radio starts reproducing it, otherwise noise is heard. Standard mode (STD) is activated. All entries of the memory array are initialized at 87.5MHz. The backward and forward buttons can be used to select other stations in the band. The search for the next station wraps around the band limits.

Using the mode button, the working mode can be changed. The radio has five operating modes:

standard (STD): we just described this.
recording (REC): in this mode the user can save the current frequency to memory. The user is prompted to choose a slot in the memory in which to store the frequency of the current station. Once the slot number is chosen, press the action button to confirm selection. Use the forward/backward buttons to navigate in the memory array.
memory (MEM): reproduces the station memorized at current position in the memory array. Use the forward/ backward buttons to navigate in the memory array.
preselect (PRE): this mode automatically preselects the stations with better reception level (SEARCH_LEV_MEDIUM) and memorize them into the memory array. The scan is started from the current frequency toward the superior band limit and restarts from the inferior band limit if the memory has not been completely filled. The filling of the memory follows a greedy policy. The scan is stopped if after two successive trials no station is found.
standby (SBY): sets the radio in standby. Press action button to return in STD mode.

Configuration and fine tuning

Configuring the front-end. The radio class has been kept as simple as possible. In this way its configuration is very simple. All you need to edit it is the file FM_Radio_Config.h and update information about the pins used by the LCD module. You need also to specify the size of the memory array (constant MEMOMAX) that will be used by the radio to store the frequency of your preferred radio stations.

Configuring the FM module. The radio is configured to work with EU/US band limits. If you want to change japanese band limits, then you have to replace EUROPEAN_FM_BAND by JAPANESE_FM_BAND in function TEA576X::begin(). Please check also the working parameters of your FM module (crystal frequency, etc) and configure them accordingly. Remark also that high side injection is selected by default.

Delays. In the reading and write operations (immediately after them) it is often used a delay to allow the operation to finish. The delays are sometimes overestimated to be sure to work with most modules. Maybe the user can change them to adapt more closely to his module and increase the overall performances.

Also in the front-end (FM_Radio.cpp) a number of delays are set. Also those can be change to improve performance or user experience.

Test sketch

The simplicity of the design allows to run our radio with a very simple sketch.

#include <SPI.h>
#include <Wire.h>
#include <LiquidCrystal.h>
#include "FM_Radio.h"
FM_Radio radio;
void setup() {
  radio.begin(LCD_BTN, MEMOMAX);
}
void loop() {
  radio.loop();
}

Documentation

You may download the full documentation about all classes in this article series in the following formats:

A spinning top for your LCD

noreply@blogger.com (Maczinga) — Fri, 30 Jan 2015 18:26:00 +0000

Sometimes we need to wait for the end of a task or for an event to occur and at the same time to keep the user informed that the system is not hung. This is the right occasion for a spinning top!

In this post we propose a very simple one. Indeed, it is a good occasion to see how to use the character generator of the LCD and insert new character. The module that we are going to use is based on the famous Hitachi HD44780 chip. This chip has the possibility to increase its char set with 4 additional user defined chars. This easily done using the command createChar which take in input the id code for the new char (an integer between 0 and 3) and an array of 8 bytes which are interpreted as a bitmap (here we use the 5x8 charset).

What you need

1x Arduino Uno
1x LCD module

Just that! For more on the LCD module you can also have a look here.

Configuration

Modify the definitions of the pins to adapt to your LCD module. In order to change the speed of the spinner decrease the value of FRAMETIME. This variable control the frame rate. Indeed, frame rate is approx 1/FRAMETIME.

The sketch

/**
 * Spinning top
 *
 * \author Enrico Formenti
 * \version 1.0
 * \date 30 january 2015
 *  \copyright BSD license, check the License page on the blog for more information. All this text must be 
 *  included in any redistribution.
 *  <br><br>
 *  See macduino.blogspot.com for more details.
 */

#include <LiquidCrystal.h>

// modify the definitions below according to your LCD module
 
#define LCD_RS_PIN 7
#define LCD_ENABLE_PIN 6
#define LCD_DATA4_PIN 5
#define LCD_DATA5_PIN 4
#define LCD_DATA6_PIN 3
#define LCD_DATA7_PIN 2

LiquidCrystal lcd(LCD_RS_PIN, LCD_ENABLE_PIN, LCD_DATA4_PIN,
                  LCD_DATA5_PIN, LCD_DATA6_PIN, LCD_DATA7_PIN);


// modify the value below to change the frame rate
// framerate per second is approx 1/FRAMETIME 
#define FRAMETIME 120


// the backslash character is not in the standard char set
// of the LCD so let's redefine it

uint8_t backslash[8] = {
    0b00000,
    0b10000,
    0b01000,
    0b00100,
    0b00010,
    0b00001,
    0b00000,
    0b00000
};

// we use special character 0 here
char spinningTop[] = {'/', '-', 0, '|'};
uint8_t k;

void setup() {
  // put your setup code here, to run once:
  k = 0; // init spinner
  
  // init screen
  lcd.begin(16, 2);
  lcd.createChar(0, backslash);
  lcd.clear();
  lcd.print("Look at me... ");
}

void loop() {
  // update spinner and...
  lcd.setCursor(14,0);
  lcd.write(spinningTop[k%4]);
  k = (k+1) & 0b11;
  // ...waste some time to let user see it spinning
  delay(FRAMETIME);
}

Suggestions

Remark that our implementation of the spinner uses busy waiting. In order to avoid it one can use interrupts. However, if you decide to use interrupts, recall that they can interfere with other modules or sensors and that Arduino Uno only has two of them!

Enjoy!

FM radio receiver for your Arduino (TEA5767/TEA5768/TEA5757)(Part 3/4)

noreply@blogger.com (Maczinga) — Sun, 11 Jan 2015 22:14:00 +0000

Abstract

In this third part we provide a class for the FM module and a simple test program. The next post will provide a basic FM Radio front-end as an application of the FM module.

The FM module

As we have already said in past posts, this is a decoration module for a module based on the TEA5767HN chip. In particular, it fixes some important parameters such as the clock and the bus. Here are the main characteristics of the module:

Main characteristics

Supply voltage:

3V-6V

Working current:

25mA

Audio output:

2x10mW

Clock:

32768Hz

Bus:

I2C

I2C address:

0x60

We have therefore conceived a wrap class which hides all the details about TEA5767HN, sets up the above constraints and provides few basic methods for the final user. Please look into the code below for the methods and for documentation. The pinout of the module is given here.

We start with the file FM_Module.h:

/**
 *  \file FM_Module.h
 *
 *  \brief A class for the FM module based on the TEA5767HN chip.
 *
 *  \author Enrico Formenti
 *  \date 23 dec 2014
 *  \version 1.0
 *  \copyright BSD license, check the License page on the blog for more information. All this text must be
 *  included in any redistribution.
 *  <br><br>
 *  See macduino.blogspot.com for more details.
 */

#ifndef ____FM_Module__h
#define ____FM_Module__h

#include "TEA5767HN.h"

/**
 * \class FM_Module
 * \brief A class for the FM module based on the TEA5767HN chip.
 * \details This is a simple class for a FM module based on the TEA5767HN chip. The class implements
 * faithfully the module functioning. Moreover, it provides some basic commands for FM radio playing.
*/

class FM_Module {
    /**
     * \var TEA5767HN FM
     * \brief This is the internal FM receiver which pratically does all the job.
     * \see TEA5767HN
     */
    TEA5767HN FM;
    /**
     * \var bool standby
     * \brief Flag for signalling if the standby is enabled. This is a quick trick to avoid unuseful call to the TEA5767HN module.
     */
    bool _standby;
public:
    /**
     * \fn void begin()
     * \brief Initialize the FM module. This command has always to be issued before using the module.
     */
    void begin();
    /**
     * \fn void setFrequency(float f)
     * \brief Set the frequency of the FM receiver.
     * @param float f The desired frequency in MHz.
     * \see getFrequency()
     */
    inline void setFrequency(float f) { FM.setFrequency(f); };
    /**
     * \fn float getFrequency()
     * \brief Returns the frequency on which the receiver is tuned
     * \return Returns the frequency in MHz on which the tuner is tuned.
     */
    inline float getFrequency() { return FM.getFrequency(); };
    /**
     * \fn bool searchForward()
     * \brief Search for a station in the direction of the superior band limit. 
     * \return \c true if the search is successful, \c false otherwise.
     * \see searchBackward()
     *
     * Search for a station in the direction of the superior band limit. If the superior band limit is reached, then the search restarts from the inferior band limit.
     * The search is abandoned after one complete loop.
     */
    inline bool searchForward() { return FM.search(SEARCH_DIR_FORWARD, SEARCH_LEV_MEDIUM); };
    /**
     * \fn bool searchBackward()
     * \brief Search for a station in the direction of the inferior band limit.
     * \return \c true if the search is successful, \c false otherwise.
     * \see searchForward()
     *
     * Search for a station in the direction of the inferior band limit. If the inferior band limit is reached, then the search restarts from the superior band limit.
     * The search is abandoned after one complete loop.
     */
    inline bool searchBackward() { return FM.search(SEARCH_DIR_BACKWARD, SEARCH_LEV_MEDIUM); };
    /**
     * \fn void refresh()
     * \brief Refreshes the internal state of the FM module.
     *
     * Refreshes the internal state of the FM module. This is particularly useful before issuing commands like isStereo() or getLevel()
     */
    inline void refresh() { FM.read(); }
    /**
     * \fn void standby()
     * \brief Put the FM module in standby state
     */
    inline void standby() { if(!_standby){_standby = true; FM.standby(STANDBY_ON); FM.write();}};
    /**
     * \fn void play()
     * \brief The tuner is set into play state.
     */
    inline void play() { if(_standby) {FM.standby(STANDBY_OFF); FM.write(); _standby=false;}};
    /**
     * \fn bool isStereo()
     * \brief This function queries for the current quality of the reproduction: stereo or mono.
     * \return \c true if the reproduction is stereo, \c false if it is mono.
     * \see refresh()
     * \warning It is better to issue a \c refresh() command before calling this function in order to have fresh informations from the receiver.
     */
    inline bool isStereo(){ return FM.isStereo(); };
    /**
     * \fn uint8_t getLevel()
     * \brief This function returns the output level of the receiver.
     * \return An integer between 0 and 15 indicating the output level of the receiver.
     * \see refresh()
     * \warning It is better to issue a \c refresh() command before calling this function in order to have fresh informations from the receiver.
     */
    inline uint8_t getLevel() { return FM.getLevel(); };
};


#endif /* defined(____FM_Module__h) */

Here is the file FM_Module.cpp:

/**
 *  \file FM_Module.cpp
 *
 *  \brief Implementation of a class for the FM module based on the TEA5767HN chip.
 *
 *  \author Enrico Formenti
 *  \date 18 dec 2014
 *  \version 1.0
 *  \copyright BSD license, check the License page on the blog for more information. All this text must be
 *  included in any redistribution.
 *  <br><br>
 *  See macduino.blogspot.com for more details.
 */

#include "FM_Module.h"

void FM_Module::begin() {
    Wire.begin();               // Init I2C bus
    FM.begin(TEA576X_XTAL_32768Hz, TEA5767HN_I2CBUS); // Init TEA receiver
    _standby = false;
}

And finally a very basic test sketch :-)

#include <Wire.h>
#include <SPI.h>
#include "FM_Module.h"
#include "TEA5767HL.h"

FM_Module mod;
TEA5767HL tea;

void setup() {

  mod.begin();

  mod.searchForward();
  
  mod.play();
}

void loop() {
  // listening to Radio don't care here ;-)

}

What's next

As promised in the last post of this series we will see a basic FM Radio front-end with LCD support.

FM radio receiver for your Arduino (TEA5767/TEA5768/TEA5757)(Part 2/4)

noreply@blogger.com (Maczinga) — Wed, 31 Dec 2014 14:59:00 +0000

Abstract

In this second part we provide C++ classes to deal with TEA576X family of chips. We also provide a basic sketch for using the TEA5767HN module that one may buy for few bucks. The next post will be concerned with the FM module and the last one will provide an example of (basic) FM Radio as an application of the FM module.

Updated

After further tests some bugs were found. Here is the list:

Read procedures in TEA5767HN.cpp and TEA5768HL.cpp
#define constants in TEA576X.h
Search procedure in TEA576X.cpp

Please download all those files again!

TEA576X

Recall that the chips of the family TEA576X differ only for the communication protocol (SPI or I2C). We have therefore conceived an abstract class, TEA576X, which implements all the methods except the write and read functions that are delegated to the derived classes. Both the header and the implementation files are pretty long, you can download them below:

The headers
Choose the header you need for your sketches. Save these files as ClassName.h

Collapse Expand

Class TEA5767HL

class TEA5767HL : public TEA576X {
private:
    uint8_t _SSPin; // Slave Select pin
public:
    void begin(float xtal, uint8_t SSpin);
    void write();
    void read();
};

/**
 *  \file TEA5767HL.h
 *
 *  \brief A class for dealing with TEA5767HL chip.
 *
 *  \author Enrico Formenti
 *  \date 23 dec 2014
 *  \version 1.0
 *
 *  \copyright BSD license, check the License page on the blog for more information
 *  All this text must be included in any redistribution.
 *  <br><br>
 *  See macduino.blogspot.com for more details.
 */

#ifndef ____TEA5767HL__
#define ____TEA5767HL__

#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif


#include "TEA576X.h"
#include <SPI.h>

#define M_FM_TEA5767HL 0xC8189CB3

/**
 \class TEA5767HL TEA5767HL.h
 \brief A class for TEA5767HL component.
 
 This class implements the methods to interact with the TEA5767HL component
 which is a FM receiver. For more on this component refer to
 http://macduino.blogspot.com/2014/12/FM-Radio-TEA5767.html
 
 \see TEA576X
 */

class TEA5767HL : public TEA576X {
private:
    /**
     * \var _SSPin
     * \brief Slave Select pin for the SPI protocol.
     */
    uint8_t _SSPin; // Slave Select pin
public:
    /**
        \fn void begin(float xtal, uint8_t SSpin)
        \brief Init TEA5767HL chip.
        @param SSpin Slave Select pin.
    */
    void begin(float xtal, uint8_t SSpin);
    /**
     \fn void write()
     \brief Send the current write sequence to the TEA5767HL.
     \warning All the operations or changes to the module settings have no effect
     untill a write() operation is issued.
     */
    void write();
    /**
     \fn void read()
     \brief Read-in the current read sequence of the TEA5767HL.
     */
    void read();
};


#endif /* defined(____TEA5767HL__) */

Collapse Expand

Class TEA5768HL

class TEA5768HL : public TEA576X {
public:
    void write();
    void read();
};

/**
 *  \file TEA5768HL.h
 *
 *  \brief A class for dealing with TEA5768HL chip.
 *
 *  \author Enrico Formenti,
 *  \date 23 dec 2014
 *  \version 1.0
 *
 *  \copyright BSD license, check the License page on the blog for more information. All this text must be 
 *  included in any redistribution.
 *  <br><br>
 *  See macduino.blogspot.com for more details.
 */

#ifndef ____TEA5768HL__h
#define ____TEA5768HL__h

#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

#include "TEA576X.h"
#include <Wire.h>

#define M_FM_TEA5767HL 0x717D6A52

/**
 \class TEA5768HL TEA5768HL.h
 \brief A class for TEA5768HL component.
 
 This class implements the methods to interact with the TEA5768HL component
 which is a FM receiver. For more on this component refer to
 http://macduino.blogspot.com/2014/12/FM-Radio-TEA5767.html
 
 \see TEA576X
 */

class TEA5768HL : public TEA576X {
public:
    /**
     \fn void write()
     \brief Send the current write sequence to the TEA5768HL.
     \warning All the operations or changes to the module settings have no effect
     untill a write() operation is issued.
     */
    voidwrite

Collapse Expand

Class TEA5767HN

class TEA5767HN : public TEA5767X {
private:
    bool _bustype;
    uint8_t _SSPin; // Slave Select pin
public:
    void begin(float xtal, bool bus, uint8_t SSpin=0);
    void write();
    void read();
};

/*
 *  TEA5767HN.h
 *
 *  A class for dealing with TEA5767HN.
 *
 *  Written by Enrico Formenti, 23 dec 2014
 *
 *  BSD license, check the License page on the blog for more information
 *  All this text must be included in any redistribution.
 *
 *  See macduino.blogspot.com for more details.
 */

#ifndef ____TEA5767HN__
#define ____TEA5767HN__

#include "TEA576X.h"
#include <SPI.h>
#include <Wire.h>

#define M_FM_TEA5767HL 0x728E2149
#define TEA5767HN_3WIREBUS true
#define TEA5767HN_I2CBUS false

/**
 \class TEA5767HN TEA5767HN.h
 \brief A class for TEA5767HN component.
 
 This class implements the methods to interact with the TEA5767HN component
 which is a stereo FM receiver. For more on this component refer to
 http://macduino.blogspot.com/2014/12/FM-Radio-TEA5767.html
 
 \see TEA576X
 */

class TEA5767HN : public TEA5767X {
private:
    bool _bustype;
    uint8_t _SSPin; // Slave Select pin
public:
    /**
        \fn void begin(float xtal, uint8_t SSpin)
        \brief Init TEA5767HL chip.
        @param SSpin Slave Select pin.
    */
    void begin(float xtal, bool bus, uint8_t SSpin=0);
    /**
     \fn void write()
     \brief Send the current write sequence to the TEA5767HN.
     \warning All the operations or changes to the module settings have no effect
     untill a write() operation is issued.
     */
    void write();
    /**
     \fn void read()
     \brief Read-in the current read sequence of the TEA5767HN.
     */
    void read();
};
#endif /* defined(____TEA5767HL__) */

Warning: If you have installed Arduino 1.5.8 Beta, then you need to install SPI library manually from GitHub. It can be found here. If you have an older version (1.0.6 for example) then there is no problem since it comes with the SPI library pre-installed.

Implementing the classes
Choose the files you need for your sketches and save the files as ClassName.cpp

Collapse Expand

Implementation of the class TEA5767HL

void TEA5767HL::write() {
    register uint8_t i;
    
    digitalWrite(_SSPin, LOW);   
    for(i=0; i<5; i++)
        SPI.transfer(wbuf[i]);
    digitalWrite(_SSPin, HIGH);
}

void TEA5767HL::read() {
    register uint8_t i;
    
    digitalWrite(_SSPin, LOW);    
    for(i=0; i<5; i++)
        rbuf[i] = SPI.transfer(0x0);    
    digitalWrite(_SSPin, HIGH);
}

/**
 *  \file TEA5767HL.cpp
 *
 *  \brief Implementation of a class for dealing with TEA5767HL chip.
 *
 *  \author Enrico Formenti
 *  \date 23 dec 2014
 *  \version 1.0
 *
 *  \copyright BSD license, check the License page on the blog for more information
 *  All this text must be included in any redistribution.
 *  <br><br>
 *  See macduino.blogspot.com for more details.
 */

#include "TEA5767HL.h"

void TEA5767HL::begin(float xtal, uint8_t SSpin) {
    TEA576X::begin(xtal);
    _SSPin = SSpin;
}

void TEA5767HL::write() {
    register uint8_t i;
    
    // take the SS pin low to select the chip:
    digitalWrite(_SSPin,LOW);
    
    // send buffer data
    for(i=0; i<5; i++)
        SPI.transfer(wbuf[i]);

    // take the SS pin high to de-select the chip:
    digitalWrite(_SSPin,HIGH);
}

void TEA5767HL::read() {
    register uint8_t i;
    
    // take the SS pin low to select the chip:
    digitalWrite(_SSPin,LOW);
    
    // read-in buffer data
    for(i=0; i<5; i++)
        rbuf[i] = SPI.transfer(0x0);
    
    // take the SS pin high to de-select the chip:
    digitalWrite(_SSPin,HIGH);
}

Collapse Expand

Implementation of the class TEA5768HL

#include "TEA5768HL.h"

void TEA5768HL::write() {
    register uint8_t i;
    
    Wire.beginTransmission(TEA576X_I2C_ADDRESS);
    for(i=0; i<5; i++)
        Wire.write(wbuf[i]);
    Wire.endTransmission();
}

void TEA5768HL::read() {
    register uint8_t i = 0;
    
    Wire.requestFrom(TEA576X_I2C_ADDRESS, 5);    
    while(Wire.available())
        rbuf[i++] = Wire.read();
}

/**
 *  \file TEA5768HL.cpp
 *
 *  \brief Implementation of a class for dealing with TEA5768HL chip.
 *
 *  \author Enrico Formenti
 *  \date 23 dec 2014
 *  \date 22 jan 2015
 *  \version 1.1
 *  \copyright BSD license, check the License page on the blog for more information
 *  All this text must be included in any redistribution.
 *  <br><br>
 *  See macduino.blogspot.com for more details.
 */

#include "TEA5768HL.h"

void TEA5768HL::write() {
    register uint8_t i;
    
    Wire.beginTransmission(TEA576X_I2C_ADDRESS);
    
    for(i=0; i<5; i++)
        Wire.write(wbuf[i]);
    
    Wire.endTransmission();
}

void TEA5768HL::read() {
    register uint8_t i = 0;
    
    Wire.requestFrom(TEA576X_I2C_ADDRESS, 5);
    
    while(Wire.available())
        rbuf[i++] = Wire.read();
}

Collapse Expand

Implementation of the class TEA5767HN

#include "TEA5767HN.h"

void TEA5767HN::begin(float xtal, bool bus, uint8_t SSpin) {
    _bustype = bus;
    _SSPin = SSpin;
    TEA576X::begin(xtal);
}

void TEA5767HN::write() {
    register uint8_t i;
    
    if(_bustype) {
        digitalWrite(_SSPin,LOW);
        for(i=0; i<5; i++)
            SPI.transfer(wbuf[i]);
        digitalWrite(_SSPin,HIGH);
    }
    else {
        Wire.beginTransmission(TEA576X_I2C_ADDRESS);        
        for(i=0; i<5; i++)
            Wire.write(wbuf[i]);
        Wire.endTransmission();
    }
}

void TEA5767HN::read() {
    register uint8_t i = 0;

    if(_bustype) {
        // take the SS pin low to select the chip:
        digitalWrite(_SSPin,LOW);
    
        // read-in buffer data
        for(; i<5; i++)
            rbuf[i] = SPI.transfer(0x0);
    
        // take the SS pin high to de-select the chip:
        digitalWrite(_SSPin,HIGH);
    }
    else {
        
        Wire.requestFrom(TEA576X_I2C_ADDRESS, 5);
        
        while(Wire.available())
            rbuf[i++] = Wire.read();
    }
}

/**
 *  \file TEA5767HN.cpp
 *
 *  \brief Implementation of a class for dealing with TEA5767HN chip.
 *
 *  \author Enrico Formenti
 *  \date 23 dec 2014
 *  \date 22 jan 2015
 *  \version 1.1
 *  \copyright BSD license, check the License page on the blog for more information
 *  All this text must be included in any redistribution.
 *  <br><br>
 *  See macduino.blogspot.com for more details.
 */

#include "TEA5767HN.h"

void TEA5767HN::begin(float xtal, bool bus, uint8_t SSpin) {
    _bustype = bus;
    _SSPin = SSpin;
    TEA576X::begin(xtal);
}

void TEA5767HN::write() {
    register uint8_t i;
    
    if(_bustype) {
        // take the SS pin low to select the chip:
        digitalWrite(_SSPin,LOW);
    
        // send buffer data
        for(i=0; i<5; i++)
            SPI.transfer(wbuf[i]);

        // take the SS pin high to de-select the chip:
        digitalWrite(_SSPin,HIGH);
    }
    else {
        Wire.beginTransmission(TEA576X_I2C_ADDRESS);
        
        for(i=0; i<5; i++)
            Wire.write(wbuf[i]);
        
        Wire.endTransmission();

    }
}

void TEA5767HN::read() {
    register uint8_t i = 0;

    if(_bustype) {
        // take the SS pin low to select the chip:
        digitalWrite(_SSPin,LOW);
    
        // read-in buffer data
        for(; i<5; i++)
            rbuf[i] = SPI.transfer(0x0);
    
        // take the SS pin high to de-select the chip:
        digitalWrite(_SSPin,HIGH);
    }
    else {
        
        Wire.requestFrom(TEA576X_I2C_ADDRESS, 5);
        
        while(Wire.available())
            rbuf[i++] = Wire.read();
    }
}

The sketch

In order to test the the above classes here is a simple sketch. To run the sketch you need the files TEA5767.* (see above), TEA5767HN.* (see above) and, of course, a TEA5767 FM module (see Figure 2 in this post). The sketch initialises the TEA5767HN and then search for a station. If one is found then the module is tuned at this frequency. Pay attention that by default the tuner uses the US/European FM band (87.5-108MHz), if you need the Japanese FM band (76-91MHz), then you should add the following instruction after tea.begin(...);:

tea.setBandLimits(JAPANESE_FM_BAND);

Collapse Expand

The sketch TEA5767HN-test.ino

#include "TEA5767HN.h"

TEA5767HN tea;

void setup() {
  Serial.begin(9600);
  
  tea.begin(TEA576X_XTAL_32768Hz, TEA5767HN_I2CBUS);
  
  if(!tea.search(SEARCH_DIR_FORWARD, SEARCH_LEV_MEDIUM)) {
    Serial.print("Couldn't find any station!");
  }
  else {
    Serial.print("Playing station at ");
    Serial.print(tea.getFrequency()/1000000.0);
    Serial.print("MHz");
  }
}

/**
 *  \file TEA5767HN-test.ino
 *
 *  \brief A quick example for testing the TEA5767HN chip.
 *
 *  \author Enrico Formenti
 *  \date 27 dec 2014
 *  \version 1.0
 *  \copyright BSD license, check the License page on the blog for more information. All this text must be 
 *  included in any redistribution.
 *  <br><br>
 *  See macduino.blogspot.com for more details.
 */
 
#include "TEA5767HN.h"

TEA5767HN tea;

void setup() {
  Serial.begin(9600);
  
  tea.begin(TEA576X_XTAL_32768Hz, TEA5767HN_I2CBUS);
  
  if(!tea.search(SEARCH_DIR_FORWARD, SEARCH_LEV_MEDIUM)) {
    Serial.print("Couldn't find any station!");
  }
  else {
    Serial.print("Playing station at ");
    Serial.print(tea.getFrequency()/1000000.0);
    Serial.print("MHz");
  }
}

void loop() {
  // nothing to do at present...
}

To run this sketch you need:

1x Arduino Uno (or one of his brothers)
1x TEA5767HN chip
1x louspeaker 4Ω 1/4 Watt (or similar)
7x Dupont connection cables
1x long enough cable for the antenna (more details here)

Figure 1. shows how to connect the material. Remark that the output level of the module is very weak. This is the reason for which one finds many modules that adds to TEA5767HN an amplification stage, like the one that we will see in the next post.

Figure 1. Basic connections for the TEA5767HN module.

What's next

As promised in the abstract we will provide a class for dealing with the FM module and finally an application example building a simple FM radio player front-end.

Tone music: changing the Tempo of your melodies

noreply@blogger.com (Maczinga) — Wed, 24 Dec 2014 16:17:00 +0000

Abstract

In our past programs for playing tone music on Arduino (see the basic program here and its advanced version here) are based on a fixed Tempo which is about 90 crotchets per minute. In this article we give a simple routine which allows to change the Tempo. We also provide some basic conversion constants for the main Tempos.

Hey all! While transcribing some music sheet (game music) I've seen that the tempo was somewhat strange and it wasn't due only to the deformation of my poor loudspeaker. Indeed, our past sketches for playing tone music on Arduino (see the basic program here and its advanced version here) are based on a fixed Tempo which is approx 90 crotchets per minute. This is the same for all other sketches that I could find on the web.
Therefore, here is a simple sketch function which changes the Tempo in your melody.

The sketch

The code below contain just one function. Call it with your own tempo value or choose one constant among those provided in the next section. The formula to compute the transformation takes into account the pause that we put between a note and the following which was useful to distinguish the notes (this was set to 130% of the note duration in our previous programs). Whenever the duration is not standard (in the case of an augmentation for example), a simple approximation formula is used.

Warning: some older version of melodies that you can find over the net use const int noteDurations[] as data type. Of course, you should change this into uint16_t noteDurations[] to be able to use the setTempo() routine.

#include "durations.h"

#define INTERNOTE_PAUSE 1.3

void setTempo(uint16_t durs[], uint16_t tempo, uint16_t istart, uint16_t iend) {
  register uint16_t i;
  uint16_t base;
  
  base = (uint16_t)(1000.0/((tempo/60.0)*(1+INTERNOTE_PAUSE)));
  
  for(i=istart; i<iend; i++) {
    switch(durs[i]) {
      case DUR_SEMIBREVE: 
        durs[i] = base << 2;
        break;
      case DUR_MINIM: 
        durs[i] = base << 1;
        break;
      case DUR_CROTCHET: 
        durs[i] = base;
        break;
      case DUR_QUAVER:
        durs[i] = base >> 1;
        break;
      case DUR_SEMIQUAVER:
        durs[i] = base >> 2;
        break;
      case DUR_DEMISEMIQUAVER:
        durs[i] = base >> 3;
        break;
      case DUR_HEMIDEMISEMIQUAVER:
        durs[i] = base >> 4;
        break;
      default:
        durs[i] = (uint16_t)(durs[i]/(DUR_CROTCHET*1.0)*base);
        break;      
    }
  }
}

The tempos

In most of the music sheets, the tempo is indicated a phrase or a word (usually in Italian) and the interpretation of such words/phrases is often a matter of taste or of long discussions. Along with the previous sketch, below you can find Tempos.h: my personal interpretation of most known tempos.

/*
 *  Tempos.h
 *
 *  This is part of PlayMelodyAdv projet
 *  A more advanced program for playing melodies on Arduino.
 *
 *
 *  Written by Enrico Formenti, 22 dec 2014
 *
 *  BSD license, check the License page on the blog for more information
 *  All this text must be included in any redistribution.
 *
 *  See macduino.blogspot.com for more details.
 */

#ifndef _Tempos_h
#define _Tempos_h

#define TEMPO_LARGHISSIMO 24
#define TEMPO_GRAVE 32
#define TEMPO_LENTISSIMO 40
#define TEMPO_LENTO 46
#define TEMPO_LARGO 50
#define TEMPO_ADAGISSIMO 52
#define TEMPO_LARGHETTO 56
#define TEMPO_LENTO 60
#define TEMPO_ADAGIO 70
#define TEMPO_ADAGIETTO 76
#define TEMPO_ANDANTE 88
#define TEMPO_MODERATO 100
#define TEMPO_ALLEGRETTO 116
#define TEMPO_ALLEGRO 130
#define TEMPO_VIVACE 140
#define TEMPO_VIVACISSIMO 152
#define TEMPO_ALLEGRISSIMO 160
#define TEMPO_ALLEGRO_VIVACE 160
#define TEMPO_PRESTO 170
#define TEMPO_PRESTISSIMO 188

#endif

See also
Tone music surprises!
Tone music: advanced playing software
Tone music: how to encode songs

Enjoy! Credits

The image opening this post comes from Wikipedia.com

Tone music: advanced playing software

noreply@blogger.com (Maczinga) — Mon, 22 Dec 2014 09:08:00 +0000

Abstract

In this post we are going to present a more sophisticated program for playing melodies on your Arduino. It allows you to encode repetitions and alternate endings, compacting your longer melodies.

Keywords: tone music; pauses; augmentations; ties; repetitions.

The new playing routine

The new play function implements more sophisticated management of melodies allowing pauses, ties, augmentations (like the past routine) and it also introduces the possibility to use repetitions and alternate endings. This post explains how to encode all this.

The sketch with the new routine is given below. Remark that it makes use of a support class that implements a simple stack. Source files can found here: Stack.h, Stack.cpp. In order to be able to compile the sketch you should open this two files in other tabs of your Arduino IDE. You also need instructions.h which contains the encoding for the new instructions used to encode the melodies.

Compatibility

All the songs encoded for the previous version of the playing routine still work for this new version without any modification. Indeed, the new melody encoding is an extension of the older one.

See also
Tone music surprises!
Tone music: how to encode songs
Tone music: changing the Tempo of your melodies

Enjoy!

/*
 *  PlayMelodyAdv
 *
 *  A more advanced program for playing melodies on Arduino. 
 *
 *  Define the label DEBUG to have some debug support
 *
 *  Written by Enrico Formenti, 22 dec 2014
 *
 *  BSD license, check the License page on the blog for more information
 *  All this text must be included in any redistribution.
 *
 *  See macduino.blogspot.com for more details.
 */

#include "pitches.h"
#include "durations.h"
#include "instructions.h"
#include "Stack.h"
#include "Stack.cpp"
#include "SilentNight.h"
 
#define TONEPIN 8

typedef struct {
  struct {
  uint16_t N;  // position in melody array
  uint16_t D;  // position in durations array
  } I;         // individual addressing
  uint32_t A;  // addressing all together
} POS;

void playMusic( uint16_t *instr, uint16_t *durs, uint16_t len) {

  POS coda;      // address of coda symbol
  POS segno;     // address of segno symbol
  POS invRepeat; // position of inv repeat sign
  POS nskip;     // posistion of the first note to skip
  POS fine;      // end of music symbol position
  POS askip;     // position of the first note to skip in alternate ending
  POS curPos; 

  // reset all internal variables
  coda.A = 0;
  segno.A = 0;
  invRepeat.A = 0;
  nskip.A = 0;
  fine.A = 0;
  askip.A = 0;
  curPos.A = 0;
  
  // start looping
  while(curPos.I.N < len) {
    Stack<POS> reps; // make the stack local so it is emptied when the loop 
                     // is over

    switch(instr[curPos.I.N]) {
      case NOTE_PAUSE:
        // noTone(TONEPIN);
        delay(durs[curPos.I.D]);
        curPos.A += 0x11;
        break;
      case NOTE_CODA:
        if(nskip.A) {
          curPos.A = nskip.A;
          nskip.A = 0;
          coda.A = 0;
          break;
        }
        coda.A = curPos.A+0x10; // start from next position
        (curPos.I.N)++;
        break;
      case NOTE_DACAPO:
        if(reps.isEmpty() || (reps.topElement().A!=curPos.A)) { // if this event has not already occurred
          reps.push(curPos); // add this event
          curPos.A=0;  // repeat from the beginning
          break;
        }
        // otherwise we simply skip and update the instruction pointer
        reps.pop();
        (curPos.I.N)++;
        break;
      case NOTE_SEGNO:
        segno.A=curPos.A+0x10; // start from next position in note array
        (curPos.I.N)++;        
        break;
      case NOTE_REPEAT:
        if(reps.isEmpty() || (reps.topElement().A != curPos.A)) {
          if(invRepeat.A) { // repeat from last inv repeat sign if any
            curPos.A=invRepeat.A+0x11; // add +1 to both N and D pointers
            invRepeat.A=0;
            reps.push(curPos);// push the event on the stack
            break;
          }
          // otherwise repeat from the beginning
          reps.push(curPos);// push the event on the stack
          curPos.A=0;
          break;
        }
        // if this is the sign that issued the event
        reps.pop();
        (curPos.I.N)++;
        break;
      case NOTE_INVREPEAT:
        invRepeat.A=curPos.A+0x10; // start from the next position in notes array
        (curPos.I.N)++;
        break;
      case NOTE_DALSEGNO:
        if(reps.isEmpty() || (reps.topElement().A!=curPos.A)) { // if this has not generated the event
          reps.push(curPos);
          curPos.A=segno.A;
          segno.A=0;
          break;
        }
        // otherwise skip and update N only
        reps.pop();
        segno.A=0;
        (curPos.I.N)++;
        break;
      case NOTE_DALSEGNOCODA:
        if(reps.isEmpty() || (reps.topElement().A!=curPos.A)) {
          reps.push(curPos);
          curPos.A = segno.A;
          segno.A = 0;
          nskip.A = coda.A+0x10;
          break;
        }
        // otherwise skip and update N only
        reps.pop();
        (curPos.I.N)++;
        break;
        case NOTE_DACAPOCODA:
        if(reps.isEmpty() || (reps.topElement().A!=curPos.A)) {
          reps.push(curPos);
          curPos.A = 0;
          segno.A = 0;
          nskip.A = coda.A+0x10;
          break;
        }
        // otherwise skip and update N only
        reps.pop();
        (curPos.I.N)++;
        break;
      case NOTE_FINE:
        if(fine.A) { // we already passed through the music end symbol
          curPos.I.N = len; // then stop playing
          break;
        }
        fine.A = curPos.A;
        (curPos.I.N)++;
        break;
      case NOTE_DACAPOFINE:
        curPos.A = 0;
        break;
      case NOTE_DALSEGNOFINE:
        curPos.A = segno.A;
        break;
      case NOTE_ALTBEGIN:
        if(askip.A) { // we are repeating the sequence, hence skip
          curPos.A = askip.A;
          askip.A = 0;
          break;
        }
        // not repeating so just keep playing
        (curPos.I.N)++;
        break;
      case NOTE_ALTEND:
        askip.A = curPos.A+0x10; // set the skip to the next instruction
                                 // so that it will be skipped during the
                                 // repetition
        break;   
      default: // it is a note instruction
        tone(TONEPIN, instr[curPos.I.N], durs[curPos.I.D]);
        // to distinguish the notes, set a minimum time between them.
        // the note's duration + 30% seems to work well:
        delay(durs[curPos.I.D] * 1.3);
        // stop the tone playing:
        noTone(TONEPIN);
        curPos.A += 0x11; // update both N and D pointers
        break;
    }
  }
}

void setup() {
  
#ifdef DEBUG
  Serial.begin();
#endif
  
  playMusic((uint16_t *)melody,(uint16_t *)noteDurations,(uint16_t)melody_len);  
}

void loop() {
  // no need to repeat the melody.
}

Tone music: how to encode songs

noreply@blogger.com (Maczinga) — Mon, 22 Dec 2014 09:08:00 +0000

Abstract

In this article we explain how to encode tone music for your Arduino projects. In particular, we explain how to encode pauses, ties, repetitions, etc. This new encoding extends the one we have proposed in a past post. The main advantage is that it can considerably shorten melodies physical description and hence save memory space.

Keywords: tone music; pauses; augmentations; ties; repetitions.

Which music sheets to use?

It is not clear which sheets translate better into tone music. I prefer to use easy piano music sheets, or simply start from scratch by trials and errors.

Basic encoding

Encoding a music sheet essentially consists in defining the following three objects:

`uint16_t instr_len`:	this is the length of the array `melody`. Remark that the size of a melody is limited by the size of `int`. This is not a true limitation since this is far beyond the memory capabilities of Arduino Uno.
`uint16_t instr[]`:	array containing the instructions for playing the melody
`uint16_t durs[]`:	array containing the instructions for the duration of the current note or of the current pause.

Encoding pauses

Pauses are encoded similarly to notes. Indeed, one has to add NOTE_PAUSE instruction in the melody array and adding the corresponding duration in the noteDurations array.

Encoding augmentations

An augmentation is graphically represented by a dot which follows a note and it is meant to augment the duration of the note by one half. Therefore, to encode a note with an augmentation it is enough to encode the value of the pitch as usual; in the durs array we will add the note duration plus the duration of its half. For example, considering the situation in Figure 1, one would add NOTE_RE4 to the instr array and DUR_MINIM+DUR_CROTCHET to the durs array.

Figure 1. Example of an augmentation.

Encoding ties

A tie is a symbol which connects two notes or three notes of the same pitch. Even if the two (or three) notes have different durations, their tie should be played as if it was a unique note with a duration which is the sum of the durations of the composing notes. For example, the tie in Figure 2 is encoded by adding NOTE_SOL3 in the melody array and DUR_MINIM+DUR_SEMIBREVE in the noteDurations array.

Figure 2. Example of tie.

Encoding repetitions

Repetitions are a bit complicated and consists in some symbols and some Italian phrases. If you are not familiar with them you can learn more in this excellent tutorial. We implemented all repetition types and symbols. In order to add a repetition one just needs to add its corresponding encoding to the instr array and nothing to the durs array. The coding for the coda symbol (NOTE_CODA) has to be inserted right before to the note that it refers to. Here is a table of the repetitions sign/phrases and their corresponding encoding.

Symbol/Phrase	Encoding
Repeat	NOTE_REPEAT
Inverse repeat	NOTE_INVREPEAT
Coda	NOTE_CODA
Da capo (DC)	NOTE_DACAPO
Da capo a coda	NOTE_DACAPOCODA
Segno	NOTE_SEGNO
Dal segno (DS)	NOTE_DALSEGNO
Dal segno a coda	NOTE_DALSEGNOCODA
Fine	NOTE_FINE
Da capo a fine (DC fine)	NOTE_DACAPOFINE
Dal segno a fine (DS fine)	NOTE_DALSEGNOFINE

Warning:

In order to get a code as short as possible no effort is made to check if the sequence of repetition symbols/phrases is correct (for example, if a NOTE_DACAPO is preceded by a NOTE_CAPO). In the case of incorrect encoding the behavior is unpredictable.

Alternate endings

The program allows to encode alternate ending by putting the instruction NOTE_ALTBEGIN at the beginning of the alternate ending and NOTE_ALTEND at the end. You may add as many alternate ending as needed. The instruction NOTE_ALTEND has to be omitted for the very last one. For example, considering the situation in Figure 3, one should have encoded

      ..., NOTE_ALTBEGIN, ..., NOTE_ALTEND, NOTE_ALTBEGIN, ...

Remark that in order to keep the code as simple (and compact) as possible, the technique described here allows to describe only "linear" ending sequences. Indeed, in complex music sheets you may find several endings by groups, for example one should play the first ending, the second; then the first one again, followed by the second one, etc. In such complicated case, you should "unroll" the music yourself by duplicating some parts.

Figure 3. Example of alternate ending.

Encoding chords

Another difficulty is to encode chords. Indeed, due to the limited capabilities of the speaker, the best and quickest way to encode chords is by encoding just the fundamental note of the chord and forget about the others (recall that the fundamental note of a chord is normally the one that is at the bottom of the chord). Figure 4 illustrates this idea.

Figure 4. Illustration of how to encode chords.

FM radio receiver for your Arduino (TEA5767/TEA5768/TEA5757)(Part 1/4)

noreply@blogger.com (Maczinga) — Wed, 17 Dec 2014 23:25:00 +0000

Abstract

In this post we are going to play with an FM Radio module based on TEA5767 chip (for TEA5768 the only difference is at the bus level, we will made this precise when writing the source code).The module is essentially based on the TEA5767 to which is adds a small stereo amplifier and a connector for headphones. Indeed, the output level of TEA5767 is very weak and one needs an amplifier to make a serious use out of it. As usual we will explain both hardware and software aspects. However, since the article is pretty long, we split it into two parts. In this first part, we look more closely at the hardware aspects. The second part will provide some useful functions and it will be assorted of interesting application examples. In the examples, we use the usual LCD module based on the classical 1602 LCD screen which accompanies many Arduino experiments.

Table of contents (part 1)

The FM stereo module
TEA5767 vs. TEA5768
Datasheets
Module pinout
The antenna
Basic operation
Write sequence

Write sequence defaults
Read sequence
Read sequence defaults
Search mode
The PLL register
Side injection
Software ports

Band limits
Clock frequency
Software mute
High control cut
Stereo noise cancelling
De-emphasis time constant
Alternate modules

Warning: Click on the "more" button below to be able to fully exploit the links in the list above.

The FM stereo module

The module is represented in Figure 1. Indeed, it is essentially a "decoration" for the TEA5767 module which can be seen in the central part of the picture. Figure 2 zooms on the TEA5767 module.

Figure 1. The FM stereo module for Arduino.

Figure 2. TEA5767 module.

TEA5767 vs. TEA5768

Essentially TEA5767 and TEA5768 differ for the set of communication protocols that they support and/or the packaging; all other characteristics are identical. There are three models:

TEA5767HN: FM stereo radio, 40 leads with I2C and 3-Wire bus. Body 6*6*0.85 mm, SOT1618 package.
TEA5767HL: FM stereo radio, 32 leads with 3-Wire bus. Body: 7*7*1.4 mm, SOT358 package.
TEA5768HL: FM stereo radio, 32 leads with I2C bus. Body: 7*7*1.4 mm, SOT358 package.

In the second part of this article, we will specialize the read/write function according to the model used.

Datasheets

TEA5767HN	Revision 2007.
TEA5767HN	Revision 2003.
TEA5767HL	Revision 2004.
TEA5768HL	Revision 2008 (indeed identical to rev. 2003).
TEA5768HL	Revision 2003.
AN10133	Application note for TEA5767/TEA5768.
TEA576X	Brochure.

The pin out

The pins are pretty well signalled on the module and should be connect to your Arduino as follows

Module	Uno	Mega	Leonardo	Due
SDA	A4	20	2	20 or SDA1
SCL	A5	21	3	21 or SCL1
GND	GND	GND	GND	GND
Vcc	+5V	+5V	+5V	+5V
ANT	Antenna, see the dedicated section.

The antenna

If you don't have an antenna then you can easily build one by yourself. For example, in my experiments I've just used a 30cm long cable with female Dupont endpoints. Of course, this is not very efficient. Better results can be obtained with cables of length proportional to the length of the FM wave. Usually they use 1/4 or 1/2 of the length of the 100MHz wave that is 713mm or 1416mm, respectively. For even better reception one can build a dipole antenna, many instructions for that can be found over the internet, for example here.

Basic operation

The module communicates with the Arduino via the I2C bus. Its unique address is 0x60. Commands are sent on the I2C bus and consists of a 5 bytes sequence. The sequence is different according to read or write operations. Therefore a basic command sequence is as follows.

Wire.beginTransmission(0x60);   // address of TEA5767 module
                                // on the I2C bus
                                
  Wire.write( byte1 );
  Wire.write( byte2 );
  Wire.write( byte3 );
  Wire.write( byte4 );
  Wire.write( byte5 );

Wire.endTransmission();

At power on both the left and right channels are muted. Both the frequency of the receiver and the configurations bytes must be provided. No default power-on configuration is provided.

Write sequence

It is used to configure the FM receiver and consists of 5 bytes with the following meaning.

Byte 1
Bit	Name	Description
7 (MSB)	MUTE	MUTE=1 then both L and R channels are muted. MUTE=0 then L and R channels are not muted.
6	SM	If SM=1 then search mode is enabled, disabled otherwise. See here for more details.
5	PLL13	14th bit of the PLL word.
4	PLL12	13th bit of the PLL word.
3	PLL11	12th bit of the PLL word.
2	PLL10	11th bit of the PLL word.
1	PLL09	10th bit of the PLL word.
0 (LSB)	PLL08	9th bit of the PLL word.

Byte 2
Bit	Name	Description
7 (MSB)	PLL07	8th bit of the PLL word.
6	PLL06	7th bit of the PLL word.
5	PLL05	6th bit of the PLL word.
4	PLL04	5th bit of the PLL word.
3	PLL03	4th bit of the PLL word.
2	PLL02	3rd bit of the PLL word.
1	PLL01	2nd bit of the PLL word.
0 (LSB)	PLL00	1st bit of the PLL word.

Byte 3
Bit	Name	Description
7 (MSB)	SUD	If SUD=1 then search forward mode is activated, otherwise search backward is activated. See this section for details.
6	SSL1	Search stop level MSB. See this section for details.
5	SSL0	Search stop level LSB. See this section for details.
4	HLSI	If HLSI=1, then high side injection is activated, otherwise low side injection is activated. See here for details.
3	MS	If MS=1, then mono is forced, stereo otherwise.
2	ML	If ML=1, then the left channel is muted, non-muted otherwise.
1	MR	If MR=1, then the right channel is muted, non-muted otherwise.
0 (LSB)	SWP1	If SWP1=1, then the software port 1 is HIGH, LOW otherwise. See here for details.

Byte 4
Bit	Name	Description
7 (MSB)	SWP2	If SWP2=1 then software port 2 is HIGH, LOW otherwise.
6	STBY	If STBY=1, then stand-by mode is activated, unactivated otherwise.
5	BL	If BL=1, then Japanese FM band is used, otherwise US/Europe FM band is used.
4	XTAL	Clock frequency. See here for details.
3	SMUTE	If SMUTE=1, then software mute is on, off otherwise.
2	HCC	If HCC=1, then High Control Cut is on, off otherwise.
1	SNC	If SNC=1, then Stereo Noise Canceling is on, off otherwise.
0 (LSB)	SI	(Search Indicator) If SI=1, then the software port 1 is output for the ready flag, otherwise the SWP1 pin is software port 1.

Byte 5
Bit	Name	Description
7 (MSB)	PLLREF	If PLLREF=1 then the 6.5MHz is used as reference frequency for the PLL, not used otherwise.
6	DTC	(De-emphasis time constant) If DTC=1, then de-emphasis time constant is 75μS; 50μS otherwise.
5	-	Unused.
4	-	Unused
3	-	Unused.
2	-	Unused.
1	-	Unused.
0 (LSB)	-	Unused.

Write sequence defaults

Being in Europe, then DTC=0 and BL=0. Moreover, as we have already seen, our module is clocked at 32768Hz and hence PLLREF=0 and XTAL=1. I would set also SWP2=0 since I've not understood what is the usage of this bit.

Read sequence

The read sequence allow to inquiry for the current FM station frequency, the Intermediate Frequency and the level of reception of the current FM station. It consists of 5 bytes (like the write sequence) which are detailed in the following tables.

Byte 1
Bit	Name	Description
7 (MSB)	RF	If RF=1 then a station has been found or the band limit is reached, not station otherwise.
6	BLF	If BLF=1, then the band limit is reached; unreached otherwise.
5	PLL13	14th bit of the PLL register.
4	PLL12	13th bit of the PLL register
3	PLL11	12th bit of the PLL register.
2	PLL10	11th bit of the PLL register.
1	PLL09	10th bit of the PLL register.
0 (LSB)	PLL08	9th bit of the PLL register.

Byte 2
Bit	Name	Description
7 (MSB)	PLL07	8th bit of the PLL register.
6	PLL06	7th bit of the PLL register.
5	PLL05	6th bit of the PLL register.
4	PLL04	5th bit of the PLL register.
3	PLL03	4th bit of the PLL register.
2	PLL02	3rd bit of the PLL register.
1	PLL01	2nd bit of the PLL register.
0 (LSB)	PLL00	1st bit of the PLL register.

Byte 3
Bit	Name	Description
7 (MSB)	STEREO	If STEREO=1 then stereo reception, mono otherwise.
6	PLL-IF6	Bit 7 of IF counter result.
5	PLL-IF05	Bit 6 of IF counter result.
4	PLL-IF04	Bit 4 of IF counter result.
3	PLL-IF03	Bit 3 of IF counter result.
2	PLL-IF02	Bit 2 of IF counter result.
1	PLL-IF01	Bit 1 of IF counter result.
0 (LSB)	PLL-IF00	Bit 0 ofIF counter result.

Byte 4
Bit	Name	Description
7 (MSB)	LEV3	Bit 3 of ADC level output.
6	LEV2	Bit 2 of ADC level output.
5	LEV1	Bit 1 of ADC level output.
4	LEV0	Bit 0 of ADC level output.
3	CI3	Bit 3 of chip identification. Set to 0.
2	CI2	Bit 2 of chip identification. Set to 0.
1	CI1	Bit 1 of chip identification. Set to 0.
0 (LSB)	CI0	Bit 0 of chip identification. Set to 0.

Byte 5
Bit	Name	Description
[7:0]	UNUSED	Unused. Future purpose.

Read sequence defaults

As recommended by the datasheet, first four bits of byte 4 must be set to 0. Byte 5 is set to 0.

Search mode

TEA5767 can search span the FM band searching for the next transmitting station. Search mode is activated setting bit 7 of byte 1. The search direction is controlled by bit 7 of byte 3 (1 for forward, 0 for backward). The search is stopped when a station having a reception level higher than a given threshold is reached. The threshold is specified by bits 6 and 5 of byte 3 as follows

Search mode stop levels
Bit 6	Bit 5	Description
0	0	Invalid.
0	1	(low) ADC output level=5.
1	0	(medium) ADC output level=7.
1	1	(high) ADC output level=10.

The PLL register

The PLL register is a 14 bits register which is used to set the frequency of the PLL of TEA5767. The desired frequency is expressed in MHz and it is a float number F_des (ranging between 76.0 and 108.0). The formulas for converting this number into an integer to feed the PLL register depends on: the clock reference frequency (F_REF), the intermediate frequency (F_IF) and the type of side injection (high or low, see here for more about side injection).
The formula when high side injection is chosen is as follows:

Remark that when the clock is 32.768KHz then F_REF is 32.768KHz (it is 50KHz when the clock is 13MHz or 6.5MHz). Moreover F_IF is fixed at 225KHz. Hence our previous formula simplifies as follows

In the case of low side injection, the previous formulas are changed as follows

and

Warning: in the formula integer division is used! Hence, for example, 5/3=1 and 11/3=3.

The effect of setting the PLL register (and performing a write operation immediately afterwards) is to tune the FM receiver on F_des.

Side injection

The frequency of the local oscillator f_LO is set so the desired reception radio frequency f_RF mixes to f_IF. There are two choices for the local oscillator frequency because the dominant mixer products are at f_RF ± f_LO. If the local oscillator frequency is less than the desired reception frequency, it is called low-side injection (f_IF = f_RF - f_LO); if the local oscillator is higher, then it is called high-side injection (f_IF = f_LO - f_RF).

Software ports

The TEA5757 has two software programmable ports (with open collector). If SWP1 is set then the soft port 1 operates as a tuning indicator output. As long as the IC has not completed a tuning action, pin SWP1 remains LOW. The pin becomes HIGH, when a preset or search tuning is completed or when a band limit is reached.
However, remark that this feature cannot be exploited by our module. So the information for the tuning action complete has to be extracted using the corresponding RF flag in byte 1 of the reading sequence.
I've not understood what is the purpose of software port 2. Sorry!

Band limits

The module supports two bands:

Japanese (76MHz - 91MHz)
European/American (87.5MHz - 108MHz)

Clock frequency

The FM receiver can work at three different clock speeds. These can be specified using Bit PLLREF of Byte 5 and Bit XTAL of Byte 4. Remark that our module has an external crystal clocked at 32.768 KHz.

Clock frequency setting
PLLREF	XTAL	Description
0	0	13 MHz
0	1	32.768 kHz
1	0	6.5 MHz
1	1	Not allowed.

Soft Mute

The “soft-mute” function suppresses the inter-station noise and prevents excessive noise from being heard when the signal level drops to a low level.

High control cut

HCC is a reduction of higher audio frequencies. The most annoying audio distortions are in the higher frequency band, so a low pass filter is activated which reduces the higher frequencies.

Stereo noise cancelling

Stereo Noise Cancelling -also named SDS (Signal dependant stereo)- consists in switching the stereo decoder from stereo to mono in case a weak signal is received. This will limit the output noise of the decoder. Also by the absence of the pilot or when the stereo control is switched to “force mono”, switching SNC on or off will not affect the audio reception so that only mono information will be passed to the audio output.

De-emphasis Time Constant

(This section is taken from Wikipedia)

Random noise has a triangular spectral distribution in an FM system, with the effect that noise occurs predominantly at the highest frequencies within the baseband. This can be offset, to a limited extent, by boosting the high frequencies before transmission and reducing them by a corresponding amount in the receiver. Reducing the high frequencies in the receiver also reduces the high-frequency noise. These processes of boosting and then reducing certain frequencies are known as pre-emphasis and de-emphasis, respectively. The amount of pre-emphasis and de-emphasis used is defined by the time constant of a simple RC filter circuit. In most of the world a 50 µs time constant is used. In the Americas and South Korea, 75 µs is used. This applies to both mono and stereo transmissions. For stereo, pre-emphasis is applied to the left and right channels before multiplexing. The amount of pre-emphasis that can be applied is limited by the fact that many forms of contemporary music contain more high-frequency energy than the musical styles which prevailed at the birth of FM broadcasting. They cannot be pre-emphasized as much because it would cause excessive deviation of the FM carrier.

Alternate modules

Many similar modules can be found on the market. You can find below the photos of some which work similarly to the one used for our experiments.


Figure 3. An example of alternate FM Stereo modules.

What's next

As promised at the very beginning, we are going to provide a complete library for programming the TEA5767/TEA5768 assorted with an application example. So stay tuned!

Tone music surprises

noreply@blogger.com (Maczinga) — Sun, 14 Dec 2014 20:46:00 +0000

Hey all! It's almost Christmas and time for the traditional carols. I've found a 8Ω loudspeaker from an old PC and I went through a classic Arduino Sketch for beginners. I've optimized it a little bit. Moreover, I've translated into French/Italian the notes and introduced standardized length for durations and the possibility to add pauses.

The carols

And here are some carols that I've just encoded.

Silent Night
(German: Stille Nacht, French: Douce Nuit, Italian: Astro del ciel)

Popular Christmas carol, composed in 1818 by Franz Xaver Gruber to lyrics by Joseph Mohr. It was declared an intangible cultural heritage by UNESCO in March 2011.

Download this tone music for Arduino here.

Jingle Bells

This is one of the most known Christmas carols. It was written by James Lord Pierpont (1822–1893) and published under the title "One Horse Open Sleigh" in the autumn of 1857.

Download this tone music for Arduino here.

Hark! The herald-angels sing

Another very popular carol first appeared in 1739 in the collection "Hymns and Sacred Poems" by Charles Wesley. Successively, it has been adapted by many musicians among which we also find Felix Mendelssohn and William H. Cummings.

Download this tone music for Arduino here.

The sketch

In order to run the sketch for playing tone music with your Arduino, you need to download the following header files: pitches.h, durations.h

/*
 *  Adapted by Enrico Formenti
 *  from an original sketch by Tom Igoe
 *  
 *  BSD license, check license.txt for more information
 *  All text above must be included in any redistribution.
 *
 *  See macduino.blogspot.com for more details.
 */

#include "pitches.h"
#include "durations.h"
#include "SilentNight.h"
 
#define TONEPIN 8

void setup() {
  
  for (int curNote = 0; curNote < melody_len; curNote++) {

    if(melody[curNote])
      tone(TONEPIN, melody[curNote],noteDurations[curNote]);
    else {
      noTone(TONEPIN);
      delay(noteDurations[curNote]);
    }

    // to distinguish the notes, set a minimum time between them.
    // the note's duration + 30% seems to work well:
    delay(noteDurations[curNote] * 1.3);
    // stop the tone playing:
    noTone(TONEPIN);
  }
}

void loop() {
  // no need to repeat the melody.
}

The circuit
It is a real Arduino's classic. You need:

1KΩ resistor 1/4W
8Ω 1/4W loudspeaker
your Arduino and 3 cables

Here is the Fritzing scheme for the circuit

What's next

Indeed, I'm translating lots of tone music of various genres. So expect a post with lots of new music tones! In the meanwhile, you can send me your own, I will publish and credit all of them!

Enjoy!

Credits

The image opening this post comes from Amagico.com website and according to them it is believed to be in the public domain. The icons illustrating the three tone musics come from Wikipedia.com

LCD : static driving

noreply@blogger.com (Maczinga) — Fri, 05 Dec 2014 19:44:00 +0000

Abstract

The static driving technique is the basic driving of a LCD which has the advantage of needing fewer external support but needs lots of pins for the segments of the LCD and hence allows less dense design.

The idea

For each digit, each segment is directly connected to a pin. In order to save some pins, all the other electrodes of each segment is linked together into a common pin.

The example
Consider an LCD with two digits. It is composed of a front plane and a back plane. In the front pane, each segment of a digit is connected to a distinct pin as illustrated in Figure 1, remark the density of connections. In the back pane all the electrodes of all the digits are connected each other and finally to a common (com) pin as illustrated in Figure 2. Therefore, if we count pins, there are 8 pins per digit in the front pane, plus one pin for the back plane. Summing up with a formula, the number of pins is 8N+1, where N is the number of digits in the display.

Figure 1. Front pane for two-digits LCD with static driving.

Figure 2. Back pane for two-digits LCD with static driving.

Frame frequency and bias

LCD are AC devices and hence one must specify the AC frequency used. Frame frequency ranges between 20Hz and 200Hz. Below 20Hz, one might experience the refreshes of the LCD (recall that human eye can distinguish frames up to 18 frames/second). A frequency higher than 200Hz might cause problems with the capacitive elements of the LCD.

The bias is the number of voltage levels that are used. Indeed, in static driving only two levels are used, say V₀ and V₁. As an example, consider a given segment SEG. In oder to deduce the waveforms passing through the backpane COM and SEG, let us impose that V_COM- V_SEG= 0 whenever SEG is unselected (see Figure 3). Since we should switch of value during the frame and there are only two possible values, then the waveform of SEG signal when SEG is selected, it is the complement of the signal unselected signal. As a consequence, when SEG is selected, the COM-SEG signal has a peak-to-peak amplitude equal to 2V₁. See Figure 4.

Figure 3. Waveforms when SEG is unselected.

Figure 4. Waveforms when SEG is selected.

See also
LCD : the multiplexing technique

LCD: the multiplexing technique

noreply@blogger.com (Maczinga) — Sat, 15 Feb 2014 15:54:00 +0000

Abstract

The multiplexing technique for LCD aims at reducing the number of pins that are necessary for driving segments of the display. This results in a simplified LCD design.

The principle

The basic idea is to group segments connections backplanes or segment commons. A group is affected to a unique backplane. Therefore, to address a given segment it is enough to ‘access’ to the given group and then specify which element of the group is desired.

The example

Consider a seven segments LCD (with decimal dot) and assume that it has 4 backplanes, named com1, com2, com3, com4. Then, the segments of a given digit can be grouped by 2 as follows: ah (com1), bg (com2), fe (com3), cd (com4). The following figure illustrates the wiring of the segments of a multiple digits display.

Wiring of the segments in the backplanes for a multiplexed LCD.

Moreover, the segments on the front conductive plane are grouped by 4: abfc and hged as pictured in the following figure.

Wiring of the frontplane in a multiplexed LCD.

What we gain

The attentive reader should already have remarked that these groups are not chosen randomly. Indeed, groups in the front plane are chosen so elements belonging to a group belongs to distinct backplanes. In this way, specifying a group and a backplane we uniquely address a segment. Moreover, remark that backplanes are common to all digits in the display. In this way if N is the number of digits in the display, one need only 2N+4 pins instead of 8N+1 as in static driving technique (to be seen in a next post).

What we loose

This great simplification in display design has not only advantages. Indeed, recall that each LCD must be driven by an alternated current. Multiplexing the backplanes makes more complex the AC driving section of the module. This will be explained in a next post.

What's next

- LCD: static driving

- LCD: multiplexing and bias

Enjoy!