Meeting at the EESI (École Européene Supérieure de l’Image) Espace Scénique 1st floor

21 May from 13:00 to 18:00

26 Rue Jean Alexandre, 86000 Poitiers – France / +33.5.45.92.66.02

(In case of trouble, call Siegfried +33.6.80.62.76.61)

Program, workshops :

• 3D Printers / Guillaume Brunet from PING
• Arduino / Julien Rat from Les Petits débrouillards
• Makey Makey / Espace Mendès France (to be confirmed)
• Processing / Hervé Jolly from the EESI

Register (2 workshops each, 10 participants max. per workshop)

Agenda:

13h00 – 13h30 – Welcome
13h30 – 15h00 – Workshops
15h00 – 15h30 – Break/Tchat/Cigarettes/Coffee
15h30 – 17h00 - Workshops
17h00 – 17h30 – Tchat/Tidyup
18h00 – End

Bring your computers and download the following software

This post contains an application of the data acquisition and analysis from the PlainDSP library.

The credit of the idea goes to Preston who is currently busy at deadening his truck. In his mail of PlainDSP library request, Preston explained to me his current project, and I found it fun and for some reasons, it is related to one of my current domains of interest (from the pro side). So… here it is. Enjoy and have fun!

Preston needs a simple, affordable and portable real time Sound Level Meter in order to perform relative measurements of noise levels inside the cabin of his truck, before and after installing damping material or replacing parts which are suspected to contribute to the noise.

Although PlainDSP could allow much more sophisticated measurements (e.g. Performing targeted measurements at certain frequencies), I decided to stick to Preston’s request. Let’s firstly talk about the electronics. As I have no real idea about the noise level of Preston’s truck (I understand that is significantly above the noise from inside a Cadillac ), I decided to design an autoranging preamplifier. The first stage will raise the level from the microphone to 21 times its original level. Two more amplifying stages are cascaded in order to achieve gains of  336 (21 * 16)  up to 5276 (21 * 16 * 16). To the cost of some resolution loss at high gains, this design boosts the original 10 bits analog to digital converter to an equivalent 18 bits adc!

The autoranging preamplifier is built around a TS924 quad op amp. IC1C is wired as a voltage follower which copies the voltage on its non inverting pin (10) to its buffered output pin (8). The input signal is taken from the midpoint of the voltage divider bridge R1 R2 (20k each)  which is decoupled by C3 (10µF). The output voltage (half 3.3V) is used as a virtual ground for the three amplifying stages (IC1A, B and D).

R7 (1k) biases D1 and D2, and this reference voltage is decoupled by C2 (2.2µF). The microphone cell (electret type) is biased from this reference voltage through R8 (1k). The signal from the microphone is decoupled by C1 (1µF) and the gain of the first amplifying stage is set by R3 (1k) and R4 (20k). Then two identical amplifying stages are mounted in series with the first stage, each of them having a gain of 16 set by R5 and R10 (1k each) and R6 and R9 (15k each)

Note:  The gain values can be changed, but you will have to change the gain settings in the code.

The signal from each amplifying stage is wired to the analog ports of Arduino: IC1A pin 1 goes to A0, IC1B pin 7 goes to A1, IC1D pin 14 goes to A2. Connect VCC to the 3.3V AND to Vref of Arduino and GND to GND. That’s it.

Here is an illustration of the prototype that I built using an Arduino Nano and a middle size breadboard

I am using a lot preassembled passive components which allow to “cable as you think”.

Thanks to some minimal normalization (e.g. Diodes use yellow wires and the live tip is the cathode), the chances of mixing up components is very low. In addition to quick wiring, the use of insulated extension wires prevents short circuits and allows compact wiring. In the present case, keeping wire lengths short is mandatory for avoiding to pick up noise. In the same spirit, if the microphone is to be used out of the board, consider using a shielded extension cable.

Time for coding. Here is the sketch which will allow repetitive prints of some interesting information:

• Selected overall gain (for information)
• Pic to pic noise (in mV)
• Root Mean  Square of noise (in mV)
• Sound Pressure Levels (in dB)

Note: Although the three first results were enough for Preston, I think that adding the SPL gives an additional interesting information that one can relate to the following table which gives examples of sound sources (noise)

•  Jet aircraft, 50 m away: 140 dB
• Threshold of pain: 130 dB
• Threshold of discomfort: 120 dB
• Chainsaw, 1 m distance: 110 dB
• Disco, 1 m from speaker: 100 dB
• Diesel truck, 10 m away: 90 dB
• Kerbside of busy road, 5 m: 80 dB
• Vacuum cleaner, distance 1 m: 70 dB
• Conversational speech, 1 m: 60 dB
• Average home: 50 dB
• Quiet library: 40 dB
• Quiet bedroom at night: 30 dB
• Background in TV studio: 20 dB
• Rustling leaves in the distance: 10 dB
• Hearing threshold: 0 dB

For those who want to learn more about measurement of sounds, please check this excellent site (English version available)

/*

	Micro_DB_MTR: Micro dB meter
	Exemple of use of the PlainDSP library
	Tested with ATmega328 powered Arduino
	Copyright (C) 2012-2013 Didier Longueville

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

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

	You should have received a copy of the GNU General Public License
	along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <PlainDSP.h>

/* Create objects */
PlainDSP DSP; 

/* Acquisition parameters */
const uint16_t _samples = 128; /* Max value depends upon available memory space */
const double _samplingFrequency = 22100.0; /* From 0.125 Hz to 80 kHz */
const uint16_t _defAdcChannel = 0; /* From 0 to 5 on ATmega328 powered Arduinos */
const uint16_t _refVoltage = DSP_REF_VOL_EXTERNAL; /* External: 3.3V */
const uint8_t _options = (DSP_OPT_DIS_TIM_0 | DSP_OPT_DIS_TIM_2 | DSP_OPT_NOI_CANCELLER);
uint8_t _adcChannel;
const float _refPressure = 20E-6;
/* Custom data */
const float _vGains[] = {21.0, 16.0, 16.0}; /* gain of first stage on first place and so on */
const float _microphoneSensitivity = 2.5; /* unit Pa/mV, read from microphone datasheet */

/* Control led parameters */
#define LED_PORT &PORTB
#define LED_PIN PINB5

void setup()
{
	/* Initialize serial comm port */
	Serial.begin(115200); 
	/* Set data acquisition parameters */
	DSP.SetAcquisitionEngine(_defAdcChannel, _refVoltage,  _samplingFrequency, _samples, _options);	
	/* Mark event */
	BlinkLed(3);
};

void loop() 
{		
	/* Start reading the most amplified signal from 3d stage */
	_adcChannel = 3;
	uint8_t saturated = 1;
	/* Reads preamlifier stages sequentially, starting from the highest gain */
	do  {
		/* Set channel */
		_adcChannel -= 1;
		/* Set channel */
		DSP.Channel(_adcChannel);
		/* Acquire data */
		DSP.GetScanData();
		/* Check signal */
		if ((DSP.Min() >= 1.0) && (DSP.Max() <= 1023.0)) {
			saturated = 0;
		}
	} while ((saturated == 1) && (_adcChannel != 0));
	float gain = 1.0;
	for (uint8_t i = 0; i <= _adcChannel; i++) {
		gain *= _vGains[i];
	}
	/* Compute scaling factor for mV */
	float scalingFactor = (3.3 / (1.024 * gain));
	/* Reset offset */
	DSP.ResetOffset();
	/* Rescale data */
	DSP.Gain(scalingFactor);
	/* Compute and print statictics */
	float rmsSignal = DSP.RMS();
	float rmsPressure = (20 * log10(rmsSignal / (_refPressure * _microphoneSensitivity)));
	Serial.print("G: ");
	Serial.print(uint16_t(gain));
	Serial.print(", ");
	Serial.print("P/P: ");
	Serial.print((DSP.Max() - DSP.Min()), 3);
	Serial.print(" mV");
	Serial.print(", ");
	Serial.print("RMS: ");
	Serial.print(rmsSignal, 3);
	Serial.print(" mV");
	Serial.print(", ");
	Serial.print("SPL: ");
	Serial.print(int16_t(rmsPressure));
	Serial.print(" dB");
	Serial.println();
	/* Print raw data */
	// PrintData(); /* Uncomment as appropriate */
	/* Mark event */
	BlinkLed(1);
	/* Uncomment next lines as appropriate */
	// while(true); /* Run Once */
	delay(1000); /* Repeat after delay */
};

void PrintData() 
{
	for (uint16_t i = 0; i < _samples; i++) {
		double abscissa = (i / _samplingFrequency);
		Serial.print(abscissa, 6);
		Serial.print("\t");
		double ordinate = DSP.ReadData(i);
		Serial.print(ordinate , 6);
		Serial.println();
	}
	Serial.println();
}

void BlinkLed(uint16_t cycles) 
/* Blink control led */
{
	/* Make the led pin an output pin */
	*(LED_PORT - 1) |= (1 << LED_PIN);
	/* Reset pin state */
	*LED_PORT &= ~(1 << LED_PIN); /* Turn control led off */
	for (uint8_t i = 0; i < (cycles << 1); i++)	{
		delay(200);
		*LED_PORT ^= (1 << LED_PIN);
	}
};

Except for the SPL calculation, PlainDSP contains all the functions required to make this application work.

Do not expect to get down to 0dB using a breadboard assembled module! The measured noise on the illustrated assembly shows a background RMS noise of 0.006 mV, leading to 40dB SPL!

Important: Please do not test the equipment next to loud noises without ear protections. I will accept no complains from those who will try it next to a rocket launch pad.

Coming next: same as before with LCD for portable applications.

The next lines of code illustrate how PlainDSP simplifies the combination of data acquisition and data analysis. You no longer need to worry about the vectors of data. PlainDSP creates dynamically  and transparently the required vectors. On the other hand you must keep in mind that they exist and take 8 times the number of samples… So that no more that 128 samples shall be used when PlainDSP is running on an arduino UNO.

The first part of the code contains the instruction for including PlainDDS library and the creation of the DSP object. Then come the data acquisition parameters. Note that PlainDSP allows you to selectively deactivate the unused timers in order to improve the sampling rate stability, along with the activation of the noise canceler function. The sampling rate is now limited to 80kHz, which is the price to pay for the simplification of use of the library. On the other hand, this limit is far above the 44.1kHz sampling rate required for achieving CD sound quality

#include <PlainDSP.h>
/* Create objects */
PlainDSP DSP; /* Create DSP object */
/* Acquisition parameters */
const uint16_t _samples = 128; /* Max value depends upon available memory space */
const float _samplingFrequency = 2000.0; /* From 0.125 Hz to 80 kHz */
const uint16_t _adcChannel = 0; /* From 0 to 5 on ATmega328 powered Arduinos */
const uint16_t _refVoltage = DSP_REF_VOL_DEFAULT; /* VCC: 5V */
const uint8_t _options = (DSP_OPT_DIS_TIM_0 | DSP_OPT_DIS_TIM_2 | DSP_OPT_NOI_CANCELLER);
const float _targetPeakFrequency = 10000.0;
/* Local scale constants */
#define SCL_INDEX 0x00
#define SCL_TIME 0x01
#define SCL_FREQUENCY 0x02

The second part deals with the set up section of the code. This is where the data acquisition parameters are set: adc channel index (0 to 5 for arduino UNO), reference voltage, sampling rate frequency (0.125Hz to 80kHz), samples (1 to 128 for arduino UNO) and noise reduction options.

void setup()
{
	/* Initialize serial comm port */
	Serial.begin(115200); 
	/* Set data acquisition parameters and get memory location of data */
	DSP.SetAcquisitionEngine(_adcChannel, _refVoltage, _samplingFrequency, _samples, _options);	
};

The third part deals with the loop section of the code. This is where the data acquisition and data analysis take place. Acquiring data is as simple as GetScanData(). Once executed, data can be read using the ReadData() function. Again, no need to care about where and how data is strored. In the example, some additional functions are used prior to applying FFT: ResetOffset() which nulls the offset of a periodic (e.g. sinusoidal) signal. The Rescale() function converts the ordinate scale so that 1024 counts translate to 5V. Use the  PrintVector() function in order to visualize the signal on completion of the successive steps. The ClearVector() function must be used to erase the content of the vector which contains the imaginary data. Failing to do so may lead to unexpected results.

Note: This vector is not automatically cleared in order to allow the reversal use of FFT, in the context of denoising function.

Use the ComputeFFT()  function with appropriate argument, depending upon the the nature of the original signal. Finally execute the Complex to real function in order to get the frequency domain data, so as to say, the frequency spectrum.

Both MajorPeak() and TargetPeak() which perform automatic peak picking and peak quantification (apex location, interpolated peak apex location, peak height). Once again, you do not have to worry about the location of data

void loop() 
{
	/* Acquire data */
	DSP.GetScanData();
	/* Null offset */
	DSP.ResetOffset();
	/* Rescale signal */
	DSP.Rescale((5.0 / 1024.0), 0);
	/* Print raw data */
	PrintVector(SCL_TIME); /* Comment line if not needed */
	/* Weigh data */
	DSP.Windowing(DSP_WIN_TYP_HANN, DSP_FORWARD);	
	PrintVector(SCL_TIME); /* Comment line if not needed */
	/* Compute FFT */
	DSP.ClearVector(DSP_IMG_DATA);
	DSP.ComputeFFT(DSP_FORWARD);	
	/* Print real and imag data */
	PrintVector(SCL_INDEX); /* Comment line if not needed */
	/* Compute magnitudes */
	DSP.ComplexToReal(DSP_SCL_TYP_AMPLITUDE);
	/* Print frequency spectrum */
	PrintVector(SCL_FREQUENCY); /* Comment line if not needed */
	/* Find major peak */
	struct strPeakProperties majorPeak;
	DSP.MajorPeak(_targetPeakFrequency - (_targetPeakFrequency * .5), _targetPeakFrequency + (_targetPeakFrequency * .5), &majorPeak);
	Serial.print("Major peak ");
	Serial.print("bin: ");
	Serial.print(majorPeak.bin);	
	Serial.print(", feq.: ");
	Serial.print(majorPeak.position, 6);	
	Serial.print(", height: ");
	Serial.print(majorPeak.height, 6);	
	Serial.println();
	/* Find target peak */
	struct strPeakProperties targetPeak;
	DSP.TargetPeak(_targetPeakFrequency, (_targetPeakFrequency * 0.1), &targetPeak);
	Serial.print("Target peak ");
	Serial.print("bin: ");
	Serial.print(targetPeak.bin);	
	Serial.print(", feq.: ");
	Serial.print(targetPeak.position, 6);	
	Serial.print(", height: ");
	Serial.print(targetPeak.height, 6);	
	Serial.println();
	/* Mark event */
	BlinkLed(1);
	while(true); /* Run Once */
	// delay(3000); /* Repeat after delay */
};

Ultimately, the PrintVector() function allows the export of abscissa and ordinate data taken from the time domain and frequency domain.

void PrintVector(uint8_t scaleType)
{	
	uint16_t bufferSize = _samples;
	if (scaleType == SCL_FREQUENCY) {
		bufferSize >>= 1;
	}
	for (uint16_t i = 0; i < bufferSize; i++) {
		float abscissa;
		/* Print abscissa value */
		switch (scaleType) {
		case SCL_INDEX:
			abscissa = float(i);
			break;
		case SCL_TIME:
			abscissa = (i / _samplingFrequency);
			break;
		case SCL_FREQUENCY:
			abscissa = ((i * _samplingFrequency) / _samples);
			break;
		}
		Serial.print(abscissa, 6);
		Serial.print('\t');
		/* Print ordinate */
		Serial.print(DSP.ReadData(i), 6);
		Serial.println();
	}
	Serial.println();
};

I was just a project in the sparkling eyes of my parents at the time this letter was written, and I understand that computers where far from the short term preoccupations of Bill and Dave. What’s incredible is that “02″ (nickname of the “computer” division at the time I joined HP) overlapped, not to say vampirized, the whole company which was “01″ mainly for years (“01″ was the “measure” division). I am not sure neither Bill nor Dave were big fans of computers, except for those who were designed for driving their ultimate measuring devices.

I got a chance to get to Page Mill road while I was working at the “Analytical Chemistry Division” (“04″). Actually I missed my way on the first time I visited SID (Scientific Instruments Division), one road ahead in California Avenue! These times are long gone now, memories remain: the smell of hot insulation material, the hiss of crashing hard disk drives, the crackling of short circuits… That reminds me of the b….y A26, (in)famous switching controller board which could blow up the whole boards from the first micro controlled gas chromatograph from HP. Oh noooooooooo. That happened to best of us!

Among the most popular subjects covered in this blog, FFT is far ahead any other subject (22%!), followed by data acquisition functions. I got many, many requests for PlainFFT and PlainADC libraries and thanks to your explicit messages, I have a quite good understanding of who is using them and for which type of application. It is now clear to me that most of PlainFFT and PlainADC users have an average level in math and that they do not feel comfortable with advanced DSP functions. On the other hand, these advanced functions are extremely useful for building awesome applications, mainly in the field of arts, or should I say, interactive arts.

Based on this review, I decided to pack all the DSP functions that you like and need the most in a single, compact, fit for purpose library. The code has been optimized in order to simplify the use of the functions, e.g. unless you wish to do so, you do not have to care about vectors of data, you just use some nicknames such as DATA, REAL or IMAGINARY to name them, if you need to do so, do you?.  The PlainDSP performances have been optimized for speed, although it is not quick enough to allow real time processing. When run on an Arduino UNO, the data acquisition engine allows 0.125Hz to 80kHz sampling rates, and it does not take any longer than 75ms to acquire data and compute a 64 bins frequency spectra out of signal captured at a sampling rate of 44.1kHz. The maximum number of samples is limited to 128 when run on the Arduino UNO which includes 2kB; under these conditions, 1k is used for data storage. How come? 128 samples for real data, 128 samples for imaginary data, 4 bytes each samples (32 bits floats) = 2 x 128 x 4 = 1024 bytes. CQFD.

Here is a list of the public functions from the PlainDSP library:

Average();
ClearVector(dataType);
ComplexToReal(scaleType);
Compute(dir);
GetDataAddress(dataType);
GetScanData();
MajorPeak(*result);
MajorPeak(loFrequency, upFrequency, *result); 
Max(); 
Min(); 
Normalize(normalizingValue); 
ReadData(index);	
ReadData(dataType, index);	
ReleaseAcquisitionEngine();
ReleaseVector(dataType);
Rescale(offset, gain);
ResetOffset();
RMS();
SetAcquisitionEngine(adcChannel, refVoltage, samplingFrequency, samples, options);
SizeVector(dataType);
SizeVector(*vData, samples);
TargetPeak(targetPosition, tolerance, *result);
Windowing(windowType, dir); 
WriteData(index, data);
WriteData(dataType, index, data);

The input voltage must lie in the 4.5 et 35 V range, and its output swings from 1.25 to 12V under 3A. It features a simple switcher Power Converter 150kHz, 3A Step-Down VRegulator [Datasheet]. The power supply output can be redirected to the blue terminal or to the Vin pin from the Arduino board to which it is connected. The power supply can be controlled by digital pin 13 and also redirected to Analog pin 0 for voltage control. Clever. And it is affordable: less than 20€ as far as I can read from some vendors.

A must see!

Some more information

http://goo.gl/GPjt0 

http://goo.gl/1YIHO

Enjoy

I got a mail with an interesting question (Thanks Andrew!) regarding the performances of the DUE versus the UNO using PlainFFT.

I built this simple sketch based on the example which comes with the PlainFFT package:

#include "PlainFFT.h"
#include "math.h"

PlainFFT FFT; /* Create FFT object */
/* Simulation parameters */
#define TWO_PI 6.283185307179586476925286766559
const uint16_t _samples = 128;
const float _samplingFrequency = 200.0;
const float _signalFrequency = 50.0;
const float _signalIntensity = 100.0;
/* 
These are the input and output vectors 
Input vectors receive computed results from FFT
*/
float _vReal[_samples]; 
float _vImag[_samples];

void setup()
{
	Serial.begin(115200);
	// BlinkLed(3, 200);
	/* Build raw data */
	for (uint16_t i = 0; i < _samples; i++) {
		float abscissa = (i / _samplingFrequency);
		_vReal[i] = (sin(abscissa * TWO_PI * _signalFrequency) * (_signalIntensity / 2.0));
		_vImag[i] = 0.0;
	}
};

void loop() 
{
	uint32_t tip = millis();
	for (uint16_t i = 0; i < 100; i++) {
		/* Weigh data */
		FFT.Windowing(_vReal, _samples, FFT_WIN_TYP_HANN, FFT_FORWARD);	
		/* Compute FFT */
		FFT.Compute(_vReal, _vImag, _samples, FFT_FORWARD);	
		/* Compute magnitudes */
		FFT.ComplexToReal(_vReal, _vImag, _samples, FFT_SCL_TYP_AMPLITUDE);
	}
	uint32_t top = millis();
	Serial.println((top - tip) / 100.0, 2);
	while(true);
};

Plain trivial!

Running this sketch on the UNO shows that each conversion lasts 62 ms, while running it on the DUE will cuts down the execution time to … 11 ms. That’s still a lot. Why? Well, the DUE is running approximately 5 times faster than the UNO (100MHz vs 16MHz). However PlainFFT is using 32 bits… floats, that the DUE’s micro-controller does not like so much. The ultimate performances would be achieved in fixed point maths…

Here is an other example which illustrates the situation at using an other library: PlainFIR. The lastest version that I am preparing performs real time filtering which lead me to use integer maths. The results were obtained for a 17 taps FIR filter.  Here are the results: UNO 100ms, DUE 5us! Whaow! How come! In this case, I took full advantage of the 32 bits architecture. Under these conditions, integer math on large numbers take … 4 times less  time.

Let’s recap: [gain of 4 (32 bits vs 8 bits)]  x [gain of 5 (100Mhz vs 16Mhz)] = bingo! The code executes 20 times faster on the DUE compared to the UNO, which is more or less the expected figure. And that makes a huge difference. Let’s consider real time processing of a signal which is sampled 44100 times per second, so as to say  in  ”CD quality” conditions. This means that we have less than 25µs for: converting the analog signal to digital, storing the acquired data, executing the filtering process, setting the filtered value and converting the digital value  to an analog signal! That’s a lot of work to do in a short period of time where every µs counts! In other words, performing simple audio mods with the UNO is possible but it definitely fails to execute the least loop within the time interval between two signal samples.

Let’s see what we can get from the DUE. Unfortunately, the DUE suffers from a couple of drawback which drove me to use external components in order to achieve acceptable performances. Among these drawbacks, the slowness of analogRead and of the analogWrite is the worst, and  DAC pins do not provide rail to rail output voltage. That’s really sad. The good news for the followers/fans of Arduinoos is that I will explain in the the next weeks how to overcome these problems to the cost of a few € (6€). So far, I managed to perform ADC and DAC within a 3.5µs time frame, which leaves quite sometime to perform additional tasks.

Open music labs is a real source of  high quality information and amazing products. The ADC page and its subsidiaries are of particular interest for those who try to challenge the performances of their ATMEGAs. A must visit.

I am currently evaluating their Audio Codec Shield which “sounds” great!