¶ Detecteur de DTMF (FFT)
Le module micro KY-037/KY-038 doit posséder une sortie analogique.
Utilisation de la bibliothèque Goertzel
Excel générateur de code Matrice Led 8x8
/**
* Connections:
* [ Mic to Arduino ]
* - Out -> A0
* - Vcc -> 3.3V
* - Gnd -> Gnd
* - Arduino: AREF -> 3.3V
* [ Display to Arduino ]
* - Vcc -> 5V
* - Gnd -> Gnd
* - DIN -> D11
* - CLK -> D12
* - CS -> D10
*/
#include <LedControl.h>
#define CS_PIN 10
#define DIN_PIN 11
#define CLK_PIN 12
#define N 256
#define IX_LEN 8
#define THRESHOLD 300
#define PI 3.1415926535897932384626433832795
LedControl lc=LedControl(DIN_PIN, CLK_PIN, CS_PIN, 0);
uint8_t samples[N];
volatile uint16_t samplePos = 0;
float spectrum[IX_LEN];
const float Frequence[IX_LEN] = { 697.0, 770.0, 852.0, 941.0, 1209.0, 1336.0, 1477.0, 1633.0 };
// Pre-Calculated for 9615Hz 256 samples
const float cos_t[IX_LEN] PROGMEM = {
0.89258700774419, 0.87007126323246, 0.84242154326079, 0.80967741240410,
0.69503622983150, 0.63304362193344, 0.55913188371563, 0.47185704970687
};
const float sin_t[IX_LEN] PROGMEM = {
0.450875186283596, 0.492925954781321, 0.538819026622219, 0.586875189322741,
0.718974713895851, 0.774116123543094, 0.829078727632433, 0.881675067494782
};
const char convert[16] = {
'1', '4', '7', '*', '2', '5', '8', '0', '3', '6', '9', '#', 'A', 'B', 'C', 'D'
};
// Résultat du fichier led_matrix_8x8.xlsx
byte font[16][8] = {
{0x00,0x18,0x08,0x08,0x08,0x08,0x1C,0x00}, // 1
{0x00,0x22,0x22,0x3E,0x02,0x02,0x02,0x00}, // 4
{0x00,0x7E,0x02,0x04,0x08,0x10,0x10,0x00}, // 7
{0x00,0x42,0x24,0x18,0x18,0x24,0x42,0x00}, // *
{0x00,0x7C,0x02,0x3E,0x40,0x40,0x7E,0x00}, // 2
{0x00,0x7c,0x40,0x3C,0x02,0x02,0x7C,0x00}, // 5
{0x00,0x3c,0x42,0x3C,0x42,0x42,0x3C,0x00}, // 8
{0x00,0x3C,0x42,0x42,0x42,0x42,0x3C,0x00}, // 0
{0x00,0x3C,0x02,0x1C,0x02,0x02,0x3C,0x00}, // 3
{0x00,0x3C,0x40,0x7C,0x42,0x42,0x3C,0x00}, // 6
{0x00,0x3C,0x42,0x3E,0x02,0x02,0x3C,0x00}, // 9
{0x00,0x14,0x3E,0x14,0x28,0x7C,0x28,0x00}, // #
{0x00,0x18,0x24,0x42,0x7E,0x42,0x42,0x00}, // A
{0x00,0x7C,0x42,0x7C,0x42,0x42,0x7C,0x00}, // B
{0x00,0x3c,0x42,0x40,0x40,0x42,0x3C,0x00}, // C
{0x00,0x7c,0x22,0x22,0x22,0x22,0x7C,0x00} // D
};
void initADC() {
// Init ADC; f = ( 16MHz/prescaler ) / 13 cycles/conversion
ADMUX = 0; // Channel sel, right-adj, use AREF pin
ADCSRA = _BV(ADEN) | // ADC enable
_BV(ADSC) | // ADC start
_BV(ADATE) | // Auto trigger
_BV(ADIE) | // Interrupt enable
_BV(ADPS2) | _BV(ADPS1) | _BV(ADPS0); // 128:1 ==> 13 * 1/125000 = 9615 Hz (1 converision = 13 ADC Clock)
ADCSRB = 0; // Free-run mode
DIDR0 = _BV(0); // Turn off digital input for ADC pin
TIMSK0 = 0; // Timer0 off
}
void goertzel(uint8_t *samples, float *spectrum) {
float v_0, v_1, v_2;
float re, im, amp; // real imaginary amplitude
for (uint8_t k = 0; k < IX_LEN; k++) {
float c = pgm_read_float(&(cos_t[k]));
float s = pgm_read_float(&(sin_t[k]));
float a = 2. * c;
v_0 = v_1 = v_2 = 0;
for (uint16_t i = 0; i < N; i++) {
v_0 = v_1;
v_1 = v_2;
v_2 = (float)(samples[i]) + a * v_1 - v_0;
}
re = c * v_2 - v_1;
im = s * v_2;
amp = sqrt(re * re + im * im);
spectrum[k] = amp;
}
}
int detect_digit(float *spectrum) {
float FmemL = 0;
float FmemC = 0;
int CmemL = -1;
int CmemC = -1;
for (uint8_t k = 0; k < 4; k++) {
if ( spectrum[k] > THRESHOLD ) {
if( spectrum[k] > FmemL ) {
FmemL = spectrum[k];
CmemL = k;
}
}
}
for (uint8_t k = 4; k < IX_LEN; k++) {
if ( spectrum[k] > THRESHOLD ) {
if( spectrum[k]> FmemC ) {
FmemC = spectrum[k];
CmemC = k-4;
}
}
}
if (CmemL != -1 && CmemC != -1) {
return CmemL + CmemC * 4;
} else {
return -1;
}
}
void setup() {
Serial.begin(115200);
delay(500);
Serial.println("Hello boss !!!");
delay(100);
lc.shutdown(0,false);
lc.setIntensity(0,7);
lc.clearDisplay(0);
// Décomenter pour afficher le calcul des tableaux cos_t et sin_t en fonction du tableau Frequence
// displaySinCosTables();
cli();
initADC();
sei();
delay(1000);
}
unsigned long z = 0;
bool bound = false;
void loop() {
int value;
int touch;
while(ADCSRA & _BV(ADIE)); // Wait for audio sampling to finish
goertzel(samples, spectrum);
touch = detect_digit(spectrum);
if ( touch != -1 ) {
if (!bound) {
bound = true;
Serial.print("Touche = ");
Serial.print(touch);
Serial.print(" ==> ");
Serial.print(convert[touch]);
Serial.println("");
for(int i=0;i<8;i++) {
lc.setRow(0,i,font[touch][i]);
}
}
} else {
bound = false;
lc.clearDisplay(0);
}
z++;
samplePos = 0;
ADCSRA |= _BV(ADIE); // Resume sampling interrupt
}
ISR(ADC_vect) {
uint16_t sample = ADC;
samples[samplePos++] = sample - 400;
if(samplePos >= N) {
ADCSRA &= ~_BV(ADIE); // Buffer full, interrupt off
}
}
void displaySinCosTables() {
//
// Frequence Arduino = 16MHz
// Diviseur = 128 ==> Fdiv = 125KHz soit Tdiv= 8us
// Tadc = 13 x Tdiv = 13 x 8u = 104 us ==> Fadc = 9615 Hz
//
// N = Nombre d'échantillons
// Fc = fréquence à détecter (Fréquence cible);
// Fe = fréquence échantillonnage;
// k = 0.5 + N*Fc/Fe =
// Oméga = 2 * pi * k / N;
//
// k
// Cr = cos ( 2.pi --- )
// N
//
// k
// Ci = sin ( 2.pi --- )
// N
//
double cos_v[IX_LEN] = { 0, 0, 0, 0, 0, 0, 0, 0 };
double sin_v[IX_LEN] = { 0, 0, 0, 0, 0, 0, 0, 0 };
char cos_buff[20];
char sin_buff[20];
double k = 0;
float Fe = 9615;
String _listCos = "const float cos_t[IX_LEN] PROGMEM = { ";
String _listSin = "const float sin_t[IX_LEN] PROGMEM = { ";
Serial.print(" Fréquence d'échantillonage: ");
Serial.println(Fe);
Serial.print(" Nombre d'échantillons: ");
Serial.println(N);
for (int i = 0; i < IX_LEN; i++) {
k = 0.5 + N * Frequence[i] / Fe;
cos_v[i] = cos(2 * PI * k / N);
sin_v[i] = sin(2 * PI * k / N);
dtostrf(cos_v[i], 8, 8, cos_buff);
dtostrf(sin_v[i], 8, 8, sin_buff);
_listCos += cos_buff;
_listSin += sin_buff;
if (i < IX_LEN-1) {
_listCos += ", ";
_listSin += ", ";
}
}
_listCos += " };";
_listSin += " };";
Serial.println(_listCos);
Serial.println(_listSin);
Serial.println("##################################################");
Serial.println(" ");
}