WTV020-SD-16P in automation home

The WTV020-SD-16P module for Arduino to play files in order of arrival (use buffer).

The particularity of this sketching is its characteristic of being easily integrated in other projects and accept multiple file numbers to play even if they arrive while the card WTV020-SD-16P it is playing one. It works thanks to a buffer in which to store the files which then sends one behind the other to the wtv020-sd-16p module to play them without interruption. Namely send one, expected to be finished playing before sending the second carrier and so on.

As I mentioned these are routine to add to your program. Routines that are called from Wtv_PlaySong (x).

The following listing allows you to test its functionality. The contents of the loop () generate the calls to the function to play some files. For use remember to insert audio files in memory card with that number (Ex: for Wtv_PlaySong (2) there must be a file named 0002.ADF for Wtv_PlaySong (32) a file named 0032.ADF and so on.) The schematic of the connections is as follows:

Some audio files, in italian language to test the schetch, below:

To insert the sketch in other programs, you have to copy the declarative and all the routines in the queue to your program and enter in the loop () the if statement that contains the call to the routine Wtv_SendToWtv020sd16 (). This routine is the one that sends the first element of the buffer to form WTV020-SD-16P and then expect it to be finished to be performed before starting to send in a new file.

The routine WTV020SD16P is called multiple times per second so that its functions are performed in parallel to the program that hosts it.

The code (arduino sketch):

// Questo progaramma è inteso per essere inserito in un programma più complesso.
// Le sue funzioni permettono di suonare diversi file con la schedina WTV020SD16p.
// I file da suonare possono arrivare insieme o in modo casuale ed inseriti in un vettore. Poi verranno suonati, per intero, uno dietro l’altro.
// Collegare i pin così:
// Wtv20sd16p Pin <-> Arduino Pin
//              1 <-> 2
//              7 <-> 3
//              8 <-> to GND
//             10 <-> 4
//             15 <-> 5
//             16 <-> to 3,3V
//
// Collegare una resistenza da 1K in serie ad un led tra i pin 16 e 15 della scheda Wtv20sd16p. Il positivo del led verso il 16

#include <Wtv020sd16p.h>

int resetPin = 2; // The pin number of the reset pin.
int clockPin = 3; // The pin number of the clock pin.
int dataPin = 4; // The pin number of the data pin.
int busyPin = 5; // The pin number of the busy pin.

Wtv020sd16p wtv020sd16p(resetPin,clockPin,dataPin,busyPin);

double old_millis;
double old_millis2;
double old_millis3;

int Wtv_ElementiVettore=11;
int Wtv_VettArrivo[12] = {0,0,0,0,0,0,0,0,0,0,0}; //il vettore va da 0 a 11

void setup() {
//Initializes the wtv020-sd-16p module.
Serial.begin(115200); // set up Serial library at 115200 bps
wtv020sd16p.reset();
old_millis=0;

old_millis2=0;
old_millis3=0;
}

void loop() {

//ciclo da eliminare, utile per testarlo, dopo 90 secondi suona il file 98
if (millis()-old_millis3 >= 100000 )
{
Serial.println(“———————–  metto il 98 ————-“);
Wtv_PlaySong(98);
old_millis3 = millis();
}

//ciclo da eliminare, utile per testarlo, dopo 50 secondi suona un pò di file
if (millis()-old_millis2 >= 60000 )
{
Serial.println(“———————–  metto un po di play ————-“);
Wtv_PlaySong(1);
Wtv_PlaySong(99);
Wtv_PlaySong(2);
Wtv_PlaySong(32);
Wtv_PlaySong(2);
Wtv_PlaySong(2);
Wtv_PlaySong(2);
Wtv_PlaySong(2);

Wtv_PlaySong(3);
old_millis2 = millis();
}

//L’if seguente è quello da mettere nel loop del programma principale
//Poi da qualsiasi punto del programma si può mettere l’istruzione Wtv_PlaySong(3) per fargli suonare, in questo caso, il file 0003.ad4;
if (millis()-old_millis >= 50 )
{
Wtv_SendToWtv020sd16();
old_millis = millis();
}
}

void Wtv_PlaySong(int numerofile)
{
//metti il valore in numero file in coda al vettore.
//Però se è 98 allora cancella tutti i 99 presenti nel vettore e metti il 98 per primo in modo da suonarlo subito.
//Se invece il valore in numerofile è uguale all’ultimo elemento precedentmente inserito allora non fa nulla.

int Wtv_appo = 0;
int Wtv_esci=0  ;
//il primo valore è vuoto allora mettilo direttamente
if (Wtv_VettArrivo[0] == 0)
{
Wtv_VettArrivo[0] = numerofile;  //è il 98
Wtv_esci=1;

}

if (numerofile!=98 && Wtv_esci==0)
{
Wtv_appo = 0;
Wtv_appo = Wtv_posizione();
if  (Wtv_appo >=1 && Wtv_VettArrivo[Wtv_appo-1]==numerofile )
{
//in pratica se il valore è uguale a quello precedente allora non lo metti nel buffer
}
else
{
Wtv_VettArrivo[Wtv_appo] = numerofile;
}
}

//Se 98 elimina tutti i 99 e mettilo nel buffer
if (numerofile==98)
{
Wtv_appo = 0;
Wtv_appo = Wtv_posizione();   //trova il primo valore a zero, così non faccio il for per tutti gli elementi
int Wtv_i = 0;
//elimina tutti i 99 e 98 nel vettore
while (Wtv_i <= Wtv_appo )
{
if (Wtv_VettArrivo[Wtv_i] == 99 || Wtv_VettArrivo[Wtv_i] == 98 )
{
Wtv_shiftvettore (Wtv_i);
}
else
{
Wtv_i=Wtv_i+1;
}
}

//sposta tutto il vettore in basso per poter mettere in prima posizione il 98
for (int Wtv_i = Wtv_appo ; Wtv_i>=1 ; Wtv_i–)
{
Wtv_VettArrivo[Wtv_i] = Wtv_VettArrivo[Wtv_i-1];
}

Wtv_VettArrivo[0] = numerofile;  //è il 98
}
}

void Visualizza()
{
//Per visualizzare gli elementi del vettore
int i=0;
for (i=0; i<=Wtv_ElementiVettore; i++)
{
Serial.print( i ) ;
Serial.print( ” -> ” ) ;
Serial.println(  Wtv_VettArrivo[i]) ;
}
Serial.println(“”) ;
}

void Wtv_SendToWtv020sd16()
{
int Wtv_appo =0;
if (digitalRead(busyPin) == 0 )    //solo se la scheda non sta suonando faccio quanto segue
{

//Se è 99 allora riproponilo in coda sempre
if (Wtv_VettArrivo[0] == 99)
{
Wtv_appo = Wtv_posizione();
if (Wtv_appo == 1 || Wtv_VettArrivo[Wtv_appo – 1] != 99)
{ //se l’ultimo valore è già 99 allora non farlo
Wtv_VettArrivo[Wtv_appo] = 99;
}
}

if (Wtv_VettArrivo[0]!=0)   //se non è zero suonalo
{
wtv020sd16p.playVoice(Wtv_VettArrivo[0]);  //suonalo
Wtv_shiftvettore(0);                       //shift-a il vettore cosi che la prima posizione viene sostituita dalla seconda e così via…
Visualizza();
}
}

}

void Wtv_shiftvettore(int start)
{
//sposta tutti gli elementi. Da START+1 vengono portati di una posizione indietro.
int Wtv_esci = 0;
int Wtv_i=0;
Wtv_i = start;
while (Wtv_i <= Wtv_ElementiVettore – 1 && Wtv_esci == 0)
{
Wtv_VettArrivo[Wtv_i] = Wtv_VettArrivo[Wtv_i + 1];
if (Wtv_VettArrivo[Wtv_i] == 0 && Wtv_VettArrivo[Wtv_i + 1] == 0)
{Wtv_esci = 1;}
Wtv_i = Wtv_i + 1;
}
Wtv_VettArrivo[Wtv_ElementiVettore] = 0;

}

int Wtv_posizione()
{
//Questa funzione restituice il numero del primo elemento libero del vettore al fine di poterlo utilizzarlo.
//La ricerca avviene tramite metodo dicotomico per ridurre il numero di cofronti necessari
if (Wtv_VettArrivo[0] == 0 )
{
return 0  ;
}
else
{
int Wtv_inizio = 0;
int Wtv_mezzo = 0;
int Wtv_fine = 0;
Wtv_fine = Wtv_ElementiVettore;
while (Wtv_fine – Wtv_inizio > 1)
{
Wtv_mezzo = int((Wtv_inizio + Wtv_fine) / 2);
if (Wtv_VettArrivo[Wtv_mezzo] == 0 )
{
Wtv_fine = Wtv_mezzo;
}
else
{
Wtv_inizio = Wtv_mezzo;
}
}
return Wtv_fine;  //restituisci valore
}
}

Update 15/01/2017:
The SD card, after years of operation, has stopped working and the new SD 1GB and 2GB (same brand SANDISK) wtv020-sd-16p module did not work. Finally, after many tests, only SD cards 1GB have resumed to work again due to formatting done with SDFORMATTER.