Revision 2:93bba36e0c06, committed 2018-05-16

Comitter:

pinofal

Date:

Wed May 16 15:28:15 2018 +0000

Parent:

1:ffc7a5d0f629

Child:

3:3895d3f389b5

Commit message:

Amaldi 9 Exercise

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Sound-Generation.cpp	Wed May 16 15:28:15 2018 +0000
@@ -0,0 +1,319 @@
+// Tested : NUCLEO F207ZG
+#include "mbed.h"
+
+// Definizione periferiche
+Serial pc(USBTX, USBRX);
+AnalogOut OutWave(PA_5);
+//DigitalOut DigitalWave(PA_5);
+DigitalOut led1(LED1);
+DigitalOut led2(LED2);
+DigitalOut led3(LED3);
+
+// definizione della frequenza delle note ottava centrale del pianoforte
+#define C 261.63
+#define Cd 277.18
+#define Db 277.18
+#define D 293.66
+#define Dd 311.13
+#define Eb 311.13
+#define E 329.63
+#define F 349.23
+#define Fd 369.99
+#define Gb 369.99
+#define G 392.9
+#define Gd 415.3
+#define Ab 415.3
+#define A 440.0
+#define Ad 466.16
+#define Bb 466.16
+#define B 493.18
+
+
+
+
+
+
+// numero di campioni che compongono un periodo della sinusoide in Output sull'ADC
+#define SAMPLESINENUM   45// consigliabile avere  multipli di 45
+
+// parametri dell'onda coseno da generare
+#define PI        (3.141592653589793238462)
+#define AMPLITUDE 32767 //(1.0)    // x * 3.3V
+#define PHASE     (PI/2) // 2*pi è un periodo
+#define OFFSET    32767 //(0x7FFF)
+
+// numero di note componenti la scala diatonica
+#define NUMTONE 120
+
+// Output LED di diagnostica
+DigitalOut led(LED1);
+
+// ticker per la generazione dell'onda con DAC
+Ticker SampleOutTicker;
+
+// Buffer contenente la sinusoide da porre in output.
+unsigned short usaSine[SAMPLESINENUM];
+
+// prototipo di funzione che genera i campioni della sinusoide da utilizzare per la generazione tramite DAC
+void CalculateSinewave(void);
+
+// carattere in arrivo dal PC
+volatile char cReadChar;
+ 
+// indice, nell'array, del campione da porre in output
+volatile int nSampleOutIndex;
+// contatore dei campioni in output sul DAC
+volatile int nSampleOutCount;
+// Periodo di generazione campioni in output DeltaT = T/NumSample
+double fDeltaT;
+// amplificazione per il dato da spedire sull'ADC
+volatile double fAmp;
+//volatile double fAmpNew;
+// flag per bloccare la generazione del segnale
+volatile bool bStop;
+// frequenza segnale da generare
+volatile double fFreq;
+// periodo della sinusoide da generare
+double fPeriod;
+double dDiatonic[NUMTONE];
+
+//****************************
+// Create the sinewave buffer
+//****************************
+void CalculateSinewave(int nOffset, int nAmplitude, double fPhase)
+{
+    // variabile contenente l'angolo in radianti
+    double fRads;
+    // indici per i cicli
+    int nIndex;
+    // passo in frequenza fissato dal numero di campioni in cui voglio dividere un periodo di sinusoide: DeltaF = 360°/NUMSAMPLE
+    double fDeltaF;
+    // angolo per il quale bisogna calcolare il valore di sinusoide: fAngle = nIndex*DeltaF
+    double fAngle;
+    
+    fDeltaF = 360.0/SAMPLESINENUM;
+    for (nIndex = 0; nIndex < SAMPLESINENUM; nIndex++) 
+    {
+        fAngle = nIndex*fDeltaF; // angolo per il quale bisogna calcolare il campione di sinusoide
+        fRads = (PI * fAngle)/180.0; // Convert degree in radian
+        //usaSine[nIndex] = AMPLITUDE * cos(fRads + PHASE) + OFFSET;
+        usaSine[nIndex] = nAmplitude * cos(fRads + fPhase) + nOffset;
+    }
+}
+
+
+//**********************************************
+// Crea le frequenze delle note del pianoforte
+//**********************************************
+void CreateDiatonic()
+{
+    int nTono;
+    int nOttava;
+    
+    // ottava centrale = ottava 4
+    dDiatonic[4*12+0]=261.63;   // C
+    dDiatonic[4*12+1]=277.18;   // C#/Db
+    dDiatonic[4*12+2]=293.66;   // D
+    dDiatonic[4*12+3]=311.13;   // D#/Eb
+    dDiatonic[4*12+4]=329.63;   // E
+    dDiatonic[4*12+5]=349.23;   // F
+    dDiatonic[4*12+6]=369.99;   // F#/Gb
+    dDiatonic[4*12+7]=392.00;   // G
+    dDiatonic[4*12+8]=415.30;   // G#/Ab
+    dDiatonic[4*12+9]=440.00;   // A
+    dDiatonic[4*12+10]=466.16;  // A#/Bb
+    dDiatonic[4*12+11]=493.88;  // B
+    
+    // dalla ottava 5 alla 9
+    for(nOttava=5; nOttava<9; nOttava++)
+    {
+        for(nTono=0; nTono<12; nTono++)
+        {
+            dDiatonic[(nOttava*12)+nTono]=dDiatonic[((nOttava-1)*12)+nTono]*2;
+        }
+    }
+    
+    // dalla ottava 0 alla 3
+    for(nOttava=3; nOttava>=0; nOttava--)
+    {
+        for(nTono=0; nTono<12; nTono++)
+        {
+            dDiatonic[(nOttava*12)+nTono]=dDiatonic[((nOttava+1)*12)+nTono]/2;
+        }
+    }
+}
+
+//***************************
+// generazione sample da DAC
+//***************************
+void SampleOut() 
+{
+    // se è stato inviato il comando Stop, non fare niente fino a nuovo comando
+    if(bStop)
+    {
+    }
+    else // se non è stato inviato il comando di bStop continua
+    {
+        // output del campione della forma d'onda
+        OutWave.write_u16(usaSine[nSampleOutIndex]);
+        
+        // incrementa l'indice del campione in output, modulo NUMSAMPLE: se NUMSAMPLE è 360, nSampleOutIndex va da 0 a 359
+        nSampleOutIndex++;
+        if(nSampleOutIndex >= SAMPLESINENUM) 
+        {
+            nSampleOutIndex=0; 
+        }
+        
+    }
+}
+
+
+
+
+//*******************
+// Loop Principale
+//*******************  
+int main()
+{
+    // configura velocità della comunicazione seriale su USB-VirtualCom e invia messaggio di benvenuto
+    pc.baud(921600); //921600 bps
+    
+    
+    // messaggio di benvenuto
+    pc.printf("\r\nHallo Amaldi Students - Exercise 9 \r\n");
+    pc.printf("\r\n*** SineWave Generation ***\r\n");
+    
+    //inizializza variabili
+    cReadChar = 0;
+    nSampleOutIndex=0;
+    nSampleOutCount=0;
+    bStop=true;
+    
+    // test dei LED
+    led1=1; //Verde
+    wait_ms(1000);
+    led1=0;
+    led2=1; // Blu
+    wait_ms(1000);
+    led2=0;
+    led3=1; //Rosso
+    wait_ms(1000);
+    led3=0;
+    
+    
+    while(true)
+    {     
+        // verifica se è arrivato un carattere dalla seriale del pc
+        if(pc.readable())
+        {
+            cReadChar = pc.getc(); // Read hyperterminal  
+             
+             // genera la nota corrispondente al carattere ricevuto
+            switch(cReadChar)
+            {
+                //DO
+                case 'c':
+                case 'C':
+                {
+                    fFreq=261.63;// frequenza della sinusoide DO da generare
+                    pc.printf("\n\r--- Generazione DO = %.2f Hz ampiezza nominale ---\n\r", fFreq);
+                    bStop = false;
+                } break;
+                // RE
+                case 'd':
+                case 'D':
+                {
+                    fFreq=293.66;// frequenza della sinusoide RE da generare
+                    pc.printf("\n\r--- Generazione RE = %.2f Hz ampiezza nominale ---\n\r", fFreq);
+                    bStop = false;
+                } break;
+                // RE#/MIb
+                case 'm':
+                case 'M':
+                {
+                    fFreq=311.13;
+                    pc.printf("\n\r--- Generazione Mib = %.2f Hz ampiezza nominale ---\n\r", fFreq);
+                    bStop = false;
+                } break;
+                case 'e':
+                case 'E':
+                {
+                    fFreq=329.63; // frequenza della sinusoide MI da generare
+                    pc.printf("\n\r--- Generazione MI = %.2f Hz ampiezza nominale ---\n\r", fFreq);
+                    bStop = false;
+                } break;
+                case 'f':
+                case 'F':
+                {
+                    fFreq=349.23;// frequenza della sinusoide FA da generare
+                    pc.printf("\n\r--- Generazione FA = %.2f Hz ampiezza nominale ---\n\r", fFreq);
+                    bStop = false;
+                } break;
+                
+                // SOL
+                case 'g':
+                case 'G':
+                {
+                    fFreq=392.0;
+                    pc.printf("\n\r--- Generazione SOL = %.2f Hz ampiezza nominale ---\n\r", fFreq);
+                    bStop = false;
+                } break;
+                // LA
+                case 'a':
+                case 'A':
+                {
+                    fFreq=440.0; // frequenza della sinusoide LA da generare
+                    pc.printf("\n\r--- Generazione LA = %.2f Hz ampiezza nominale ---\n\r", fFreq);
+                    bStop = false;
+                } break;
+                //SI
+                case 'b':
+                case 'B':
+                {
+                    fFreq=493.88;// frequenza della sinusoide SI da generare
+                    pc.printf("\n\r--- Generazione SI = %.2f Hz ampiezza nominale ---\n\r", fFreq);
+                    bStop = false;
+                } break;
+                
+                // pausa
+                case ' ':
+                {
+                    bStop=true;
+                    pc.printf("\n\r--- Generation Stopped ---\n\r");
+                } break;
+                default:
+                {
+                    bStop=true; // se la nota non è riconosciuta blocca la generazione
+                    pc.printf("\n\r--- Wrong Tone ---\n\r");
+                } break;  
+            } // switch (cReadChar)
+            
+            // genera la frequenza relativa alla nota che è stata selezionata
+            fAmp = 0.1; // coefficiente per il quale viene moltiplicato l'ampiezza massima
+            fDeltaT = 1.0/(fFreq*SAMPLESINENUM);
+            CalculateSinewave(32767, (32767*fAmp), (PI/2.0)); // generazione della sinusoide con valori nominali
+            SampleOutTicker.attach(&SampleOut,fDeltaT); // avvia output della sinusoide per generazione
+             
+            
+        }
+        else // se non è stato premuto nessun tasto
+        {
+           
+        } 
+     }   
+ 
+    /******* START ONDA DIGITALE FUNZIONA *****
+    led1=1;
+    led2=1;
+    led3=1;
+    while(true)
+    {
+        DigitalWave=0;
+        //wait_us(2024); //SI
+        //wait_us(2551); //SOL
+        wait_us(1515); //MI
+        DigitalWave=1;
+        wait_us(1515);   
+    }
+    ****** END ONDA DIGITALE FUNZIONA ******/
+}
\ No newline at end of file

--- a/main.cpp	Tue Jan 30 16:30:54 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,452 +0,0 @@
-#include "mbed.h"
-
-AnalogIn InLocale(PA_6);
-AnalogOut OutLocale(PA_4);
-AnalogOut OutCampagna(PA_5);
-Serial pc(SERIAL_TX, SERIAL_RX);
-
-#if !DEVICE_ANALOGOUT
-#error You cannot use this example as the AnalogOut is not supported on this device.
-#else
-#endif
-
-
-// Numero di periodi di sinusoide di cui è composto ciascuno step della PSK
-#define fPerStep1  23.0
-#define fPerStep2  1.25
-#define fPerStep3  15.0
-#define fPerStep4  1.25
-#define fPerStep5  7.0
-#define fPerStep6  1.25
-#define fPerStep7  7.0
-#define fPerStep8  1.25
-
-// numero di campioni che compongono un periodo della sinusoide in Output sull'ADC
-#define SAMPLESINENUM   45 // consigliabile avere  multipli di 45
-// numero di campioni generati durante una intera modulazione PSK. Nominalmente la somma del numero di periodi degli step è 57. 
-#define nNumPeriodi (fPerStep1 + fPerStep2 + fPerStep3 + fPerStep4 + fPerStep5 + fPerStep6 + fPerStep7 + fPerStep8)
-#define SAMPLEOUTNUM    (SAMPLESINENUM*nNumPeriodi)
-// numero di campioni acquisiti dall'ADC e che compongono l'array
-#define SAMPLEINNUM (SAMPLESINENUM*nNumPeriodi*2)+2   // contiene una intera onda (in Byte) generata con PSK, + 2 caratteri 
-
-// periodo in millisecondi della 83.3 Hz
-#define T833   (1/83.3) 
-// periodo in millisecondi della 50 Hz
-#define T50    (1/50.0)
-// periodo in millisecondi del Bridge tra le diverse fasi = 9,6 ms
-#define T96     (0.0096)
-// periodo di acquisizione dall'ADC
-#define TADC (0.0048) // impostato aper avere 3 campioni nel periodo di bridge (1.25 * 9.6 ms)
-// numero di campioni in 1/4 di periodo
-#define QUARTERSAMPLEOUTNUM SAMPLESINENUM/4
-
-
-// parametri dell'onda coseno da generare
-#define PI        (3.141592653589793238462)
-#define AMPLITUDE 32767 //(1.0)    // x * 3.3V
-#define PHASE     (PI/2) // 2*pi è un periodo
-#define OFFSET    32767 //(0x7FFF)
-
-// Output LED di diagnostica
-DigitalOut led(LED1);
-
-// ticker per la generazione dell'onda con DAC
-Ticker SampleOutTicker;
-// ticker per l'acquisizione dell'onda con ADC
-//Ticker SampleInTicker;
-
-// Buffer contenente la sinusoide da porre in output.
-unsigned short usaSine[SAMPLESINENUM];
-
-// array con i dati acquisiti dall'ADC Locale
-//volatile unsigned short usaLocaleADC[SAMPLEINNUM];
-volatile char caTxPacket[(int)SAMPLEINNUM];
-
-// prototipo di funzione che genera i campioni della sinusoide da utilizzare per la generazione tramite DAC
-void CalculateSinewave(void);
-
-// carattere in arrivo dal PC
-volatile char cReadChar;
-// valore letto dall'ADC
-volatile unsigned short usReadADC;
- 
-// Tipo di PSK da generare
-volatile int nPSK;
-// indice, nell'array, del campione da porre in output
-volatile int nSampleOutIndex;
-// indice, nell'array, del campione acquisito in input
-volatile int nSampleInIndex;
-// contatore dei campioni in output sul DAC
-volatile int nSampleOutCount;
-// contatore dei campioni in input dall'ADC
-volatile int nSampleInCount;
-// Periodo di generazione campioni in output DeltaT = T/NumSample
-double fDeltaT;
-// amplificazione per il dato da spedire sull'ADC
-volatile double fAmp;
-//volatile double fAmpNew;
-// Step attuale e nuovo Step nella generazione di una PSK
-volatile int nStep;
-volatile int nNewStep;
-//variabili ausiliarie
-volatile unsigned short usAux;
-volatile char cAux;
-// flag per bloccare la generazione del segnale
-volatile bool bStop;
-// frequenza segnale da generare
-volatile double fFreq;
-
-
-
-//****************************
-// Create the sinewave buffer
-//****************************
-void CalculateSinewave(int nOffset, int nAmplitude, double fPhase)
-{
-    // variabile contenente l'angolo in radianti
-    double fRads;
-    // indici per i cicli
-    int nIndex;
-    // passo in frequenza fissato dal numero di campioni in cui voglio dividere un periodo di sinusoide: DeltaF = 360°/NUMSAMPLE
-    double fDeltaF;
-    // angolo per il quale bisogna calcolare il valore di sinusoide: fAngle = nIndex*DeltaF
-    double fAngle;
-    
-    fDeltaF = 360.0/SAMPLESINENUM;
-    for (nIndex = 0; nIndex < SAMPLESINENUM; nIndex++) 
-    {
-        fAngle = nIndex*fDeltaF; // angolo per il quale bisogna calcolare il campione di sinusoide
-        fRads = (PI * fAngle)/180.0; // Convert degree in radian
-        //usaSine[nIndex] = AMPLITUDE * cos(fRads + PHASE) + OFFSET;
-        usaSine[nIndex] = nAmplitude * cos(fRads + fPhase) + nOffset;
-    }
-}
-
-
-
-//***************************
-// generazione sample da DAC
-//***************************
-void SampleOut() 
-{
-   
-    
-    // se è stato inviato il comando Stop, non fare niente fino a nuovo comando
-    if(bStop)
-    {
-    }
-    else // se non è stato inviato il comando di bStop continua
-    {
-        // output del campione della forma d'onda
-        //usAux=(usaSine[nSampleOutIndex])/fAmp;
-        //usAux=usaSine[nSampleOutIndex];
-        OutLocale.write_u16(usaSine[nSampleOutIndex]);
-        OutCampagna.write_u16(usaSine[nSampleOutIndex]);
-        
-        // incrementa l'indice del campione in output, modulo NUMSAMPLE: se NUMSAMPLE è 360, nSampleOutIndex va da 0 a 359
-        nSampleOutIndex++;
-        if(nSampleOutIndex >= SAMPLESINENUM) 
-        {
-            nSampleOutIndex=0; 
-        }
-        
-        // acquisisce dato da ADC
-        usReadADC = InLocale.read_u16();
-        // prepara il pacchetto di dati acquisiti  da restituire al PC
-        caTxPacket[nSampleInCount]= (char)(usReadADC&0xFF);
-        //+++caTxPacket[nSampleInCount]= 'a';
-        nSampleInCount++;
-        caTxPacket[nSampleInCount] = (char)((usReadADC>>8)&0xFF);
-        //++++caTxPacket[nSampleInCount]= 'b';
-        
-        // incrementa il numero di campioni inviati, e individua la fase in cui ci si trova, relativamente alla modulazione PSK selezionata
-        nSampleOutCount++;
-        nSampleInCount = nSampleOutCount*2;
-        
-                
-        switch(nPSK)
-        {
-            case 0: 
-            {
-                // in questo caso sto generando sinusoidi a frequenza fissa, senza PSK; reinizializza gli indici degli array di campioni acquisiti e generati
-                if(nSampleOutCount >= SAMPLEOUTNUM) // nSampleInCount è sempre pari a nSampleOutCount*2
-                {
-                    nSampleOutCount=0;
-                }
-            } break;
-            case 1:
-            {
-                switch(nSampleOutCount)
-                {
-                    case 0: //if(nSampleOutCount == 0) // dopo il ciclo completo, si ritorna allo step 1
-                    {
-                        nNewStep = 1; // genera 23 periodi di sinusoide
-                        //pc.printf(" nStep = %1d \n\r",nNewStep);
-                    } break;
-                    case (fPerStep1*SAMPLESINENUM): //if(nSampleOutCount == (23*SAMPLESINENUM)) // dopo 23 periodi a 83.3 Hz, passa allo step 2 in cui genera il primo Bridge
-                    {
-                        nNewStep = 2; // genera Bridge
-                        //pc.printf(" nStep = %1d \n\r",nNewStep);
-                    } break;
-                    case ((fPerStep1+fPerStep2)*SAMPLESINENUM): //if(nSampleOutCount == ((23*SAMPLESINENUM)+(1.25*SAMPLESINENUM))) // dopo 23 periodi a 83.3 Hz, e un Bridge genera 15 sinusoidi a 83.3 Hz
-                    {
-                        nNewStep = 3; // genera 15 periodi di sinusoide
-                        //pc.printf(" nStep = %1d \n\r",nNewStep);
-                    }
-                    case ((fPerStep1+fPerStep2+fPerStep3)*SAMPLESINENUM): //if(nSampleOutCount == ((23*SAMPLESINENUM)+(1.25*SAMPLESINENUM)+(15*SAMPLESINENUM))) // dopo 23 periodi a 83.3 Hz, Bridge e 15 periodi a 83.3 Hz, genera un bridge
-                    {
-                        nNewStep = 4; // Genera Bridge
-                        //pc.printf(" nStep = %1d \n\r",nNewStep);
-                    } break;
-                    case ((fPerStep1+fPerStep2+fPerStep3+fPerStep4)*SAMPLESINENUM): //if(nSampleOutCount == ((23*SSAMPLESINENUM)+(1.25*SAMPLESINENUM)+(15*SAMPLESINENUM)+(1.25*SAMPLESINENUM))) // dopo 23 periodi a 83.3 Hz, Bridge, 15 periodi a 83.3 Hz, bridge, genera 7 periodi a 83.3Hz
-                    {
-                        nNewStep = 5; // genera 7 periodi di sinusoide
-                        //pc.printf(" nStep = %1d \n\r",nNewStep);
-                    } break;
-                    case ((fPerStep1+fPerStep2+fPerStep3+fPerStep4+fPerStep5)*SAMPLESINENUM):  //if(nSampleOutCount == ((23*SAMPLESINENUM)+(1.25*SAMPLESINENUM)+(15*SAMPLESINENUM)+(1.25*SAMPLESINENUM)+(7*SAMPLESINENUM))) // dopo 23 periodi a 83.3 Hz, Bridge, 15 periodi a 83.3 Hz, bridge,7 periodi a 83.3Hz, genera bridge
-                    {
-                        nNewStep = 6; // Genera Bridge
-                        //pc.printf(" nStep = %1d \n\r",nNewStep);
-                    } break;
-                    case ((fPerStep1+fPerStep2+fPerStep3+fPerStep4+fPerStep5+fPerStep6)*SAMPLESINENUM): //if(nSampleOutCount == ((23*SAMPLESINENUM)+(1.25*SAMPLESINENUM)+(15*SAMPLESINENUM)+(1.25*SAMPLESINENUM)+(7*SAMPLESINENUM)+(1.25*SAMPLESINENUM))) // dopo 23 periodi a 83.3 Hz, Bridge, 15 periodi a 83.3 Hz, bridge,7 periodi a 83.3Hz, bridge, genera 7 periodi a 83.3Hz
-                    {
-                        nNewStep = 7; // genera 7 periodi di sinusoide
-                        //pc.printf(" nStep = %1d \n\r",nNewStep);
-                    } break;
-                    case ((fPerStep1+fPerStep2+fPerStep3+fPerStep4+fPerStep5+fPerStep6+fPerStep7)*SAMPLESINENUM): //if(nSampleOutCount == ((23*SAMPLESINENUM)+(1.25*SAMPLESINENUM)+(15*SAMPLESINENUM)+(1.25*SAMPLESINENUM)+(7*SAMPLESINENUM)+(1.25*SAMPLESINENUM)+(7*SAMPLESINENUM))) // dopo 23 periodi a 83.3 Hz, Bridge, 15 periodi a 83.3 Hz, bridge,7 periodi a 83.3Hz, bridge, 7 periodi a 83.3Hz, genera bridge
-                    {
-                        nNewStep =8; // genera bridge
-                        //pc.printf(" nStep = %1d \n\r",nNewStep);
-                    } break;
-                    case ((fPerStep1+fPerStep2+fPerStep3+fPerStep4+fPerStep5+fPerStep6+fPerStep7+fPerStep8)*SAMPLESINENUM): //if(nSampleOutCount == ((23*SAMPLESINENUM)+(1.25*SAMPLESINENUM)+(15*SAMPLESINENUM)+(1.25*SAMPLESINENUM)+(7*SAMPLESINENUM)+(1.25*SAMPLESINENUM)+(7*SAMPLESINENUM)+(1.25*SAMPLESINENUM))) // dopo 23 periodi a 83.3 Hz, Bridge, 15 periodi a 83.3 Hz, bridge,7 periodi a 83.3Hz, bridge, 7 periodi a 83.3Hz, bridge, ritorna a generare 23 periodi a 83.3Hz    
-                    {
-                        nNewStep =1;
-                        nSampleOutCount =0;
-                        //pc.printf(" nStep = %1d \n\r",nNewStep);
-                    } break;
-                    default: {} break;
-                }    
-            } break;
-            default:{} break;
-        }
-    }
-}
-
-
-
-
- //*******************
- // Loop Principale
- //*******************  
-int main()
-{
-    // indice per i cicli
-    int nIndex;
-    
-    // configura velocità della comunicazione seriale su USB-VirtualCom e invia messaggio di benvenuto
-    pc.baud(921600); //921600 bps
-    //pc.baud(256000); //256000 bps
-    pc.printf("*** SineWave Generation ***\n\r");
-    
-    //inizializza variabili
-    nSampleInIndex =0;
-    fAmp = 1.0;
-    cReadChar = 0;
-    nSampleOutIndex=0;
-    nSampleOutCount=0;
-    nPSK =0;
-    bStop= false;
-    fFreq = 83.3;
-    for(nIndex =0; nIndex < SAMPLEINNUM; nIndex++)
-    {
-        caTxPacket[nIndex]='\0';
-    }
-    
-    
-    
-        
-    // genera sinusoide
-    //+++SampleInTicker.attach(&SampleIn,TADC);  // Ticker di acquisizione dall'ADC  
-    // avvia il ciclo di generazione sinusoide
-    while(true) 
-    {
-                             
-        // verifica se è arrivato un carattere dalla seriale del PC
-        if(pc.readable())
-        {
-            cReadChar = pc.getc(); // Read hyperterminal
-            bStop = false; // è stato inviato un comando, quindi resetta il flag di Stop: bStop = False
-            
-            if(cReadChar == '1') // genera sinusoide a 83.3Hz con ampiezza ridotta a metà della nominale
-            {
-                pc.printf("\n\r--- Selezionato PSK-I ---\n\r");
-                bStop = false; // è stato inviato un comando, quindi bStop = False
-                nPSK = 1;
-                fAmp = 1.0;
-                nSampleOutIndex=0;
-                nSampleOutCount=0;
-                // generazione della sinusoide con valori nominali
-                CalculateSinewave(32767, 32767, (PI/2.0));
-                nStep = 0; // inizializza lo step che sarà aggiornato nella routine di generazione campione
-                //fAmpNew = 1.0;
-                //fDeltaT= T833/SAMPLEOUTNUM; // frequenza di generazione iniziale
-            }    
-            if (cReadChar == 'a') // genera sinusoide a 83.3Hz con ampiezza nominale
-            {
-                bStop = true;
-                nPSK = 0; // nessuna PSK da generare
-                fFreq = 83.3;
-                pc.printf("\n\r--- Generazione %.1f Hz ampiezza nominale ---\n\r", fFreq);
-                //nSampleOutIndex=0;
-                //nSampleOutCount=0;
-                fAmp = 1.0;
-                // generazione della sinusoide con valori nominali
-                CalculateSinewave(32767, 32767, (PI/2.0));
-                fDeltaT = 1.0/(fFreq*SAMPLESINENUM);
-                bStop = false;
-                SampleOutTicker.attach(&SampleOut,fDeltaT);
-            }
-            if (cReadChar == 'b') // genera sinusoide a 50 Hz con ampiezza ridotta a metà della nominale
-            {
-                bStop = true;
-                nPSK = 0; // nessuna PSK da generare
-                fFreq = 50.0;
-                pc.printf("\n\r--- Generazione %.1f Hz ampiezza 1/2 della nominale ---\n\r", fFreq);
-                //nSampleOutIndex=0;
-                //nSampleOutCount=0;
-                fAmp = 1.0;
-                // genera sinusoide
-                CalculateSinewave(32767, (32767/2), (PI/2.0));
-                // attach ticker
-                fDeltaT = 1.0/(fFreq*SAMPLESINENUM);
-                bStop = false;
-                SampleOutTicker.attach(&SampleOut,fDeltaT);
-            }
-            if (cReadChar == 'c') // genera sinusoide a 45 Hz con ampiezza ridotta a 1/4 del valore nominale
-            {
-                bStop = true;
-                nPSK = 0; // nessuna PSK da generare
-                fFreq = 45.0;
-                pc.printf("\n\r--- Generazione %.1f Hz ampiezza 1/4 della nominale ---\n\r", fFreq);
-                //nSampleOutIndex=0;
-                //nSampleOutCount=0;
-                fAmp = 1.0;
-                // genera sinusoide
-                CalculateSinewave(32767, (32767/4), (PI/2.0));
-                // attach ticker
-                fDeltaT = (double)(1.0/((double)fFreq*(double)SAMPLESINENUM));
-                bStop = false; // è stato inviato un comando, quindi bStop = False     
-                SampleOutTicker.attach(&SampleOut,fDeltaT);
-            }
-            
-            if (cReadChar == 'z') // Stop
-            {
-                nPSK = 0; // nessuna PSK da generare
-                pc.printf("\n\r--- Stop Generazione ---\n\r");
-                bStop=true;
-            }
-            //led.write(1);
-        }  // if (pc.readable())
-        
-                                                    
-        // In base alla PSK selezionata, ci saranno diversi step da seguire
-        switch (nPSK)
-        {
-            case 0: {} break;
-            case 1: // PSK-I
-            {
-                // Avvia il primo step della PSK selezionata. Nello Step 0 non si ritornerà più
-                if(nStep == 0)
-                {
-            //pc.printf("*** Avvio generazione ***\n\r");
-                    nNewStep = 1;
-                }
-                // se è stato raggiunto il numero di campioni per la variazione di Step, aggiorna il numero di Step e modifica i parametri di generazione
-                if(nStep != nNewStep)
-                {
-                    // aggiorna il numero di Step e modifica i parametri di generazione
-                    nStep = nNewStep;
-                    switch (nStep)
-                    {
-                        case 1:
-                        {
-                            // invia il buffer di campioni relativi ad una intera generazione PSK con sfasamento totale di 360°
-                            pc.printf("%s", caTxPacket); // 50 caratteri
-
-                            // genera 23 periodi a 83.3 Hz
-                            //+++pc.printf("+++ 23 sinusoidi a 83,3Hz +++\n\r");
-                            fDeltaT = double((double)T833/(double)SAMPLESINENUM);
-                            SampleOutTicker.attach(&SampleOut,fDeltaT);
-                                                         
-                        } break;
-                        case 2:
-                        {
-                            // dopo 23 periodi a 83.3 Hz, genera il primo Bridge
-                            //+++pc.printf("+++ Primo Bridge +++\n\r");
-                            fDeltaT = (double)((double)T96/(double)(SAMPLESINENUM));
-                            SampleOutTicker.attach(&SampleOut,fDeltaT);
-                        } break;   
-                        case 3:
-                        {
-                            // dopo 23 periodi a 83.3 Hz, e un Bridge genera 15 sinusoidi a 83.3 Hz
-                            //+++pc.printf("+++ 15 sinusoidi a 83,3Hz +++\n\r");
-                            fDeltaT = double((double)T833/(double)SAMPLESINENUM);
-                            SampleOutTicker.attach(&SampleOut, fDeltaT);
-                        } break;
-                        case 4:
-                        {
-                            // dopo 23 periodi a 83.3 Hz, Bridge e 15 periodi a 83.3 Hz, genera un bridge
-                            //+++pc.printf("+++ Secondo Bridge +++\n\r");
-                            fDeltaT = (double)((double)T96/(double)(SAMPLESINENUM));
-                            SampleOutTicker.attach(&SampleOut, fDeltaT);
-                        } break;
-                        case 5:
-                        {
-                            // dopo 23 periodi a 83.3 Hz, Bridge, 15 periodi a 83.3 Hz, bridge, genera 7 periodi a 83.3Hz
-                            //+++pc.printf("+++ 7 Sinusoidi a 83.3Hz +++\n\r");
-                            fDeltaT = double((double)T833/(double)SAMPLESINENUM);
-                            SampleOutTicker.attach(&SampleOut, fDeltaT);
-                        } break;
-                        case 6:
-                        {
-                            // dopo 23 periodi a 83.3 Hz, Bridge, 15 periodi a 83.3 Hz, bridge,7 periodi a 83.3Hz, genera bridge
-                            //+++pc.printf("+++ Terzo Bridge +++\n\r");
-                            fDeltaT = (double)((double)T96/(double)(SAMPLESINENUM));
-                            SampleOutTicker.attach(&SampleOut, fDeltaT);
-                        } break;
-                        case 7:
-                        {
-                            // dopo 23 periodi a 83.3 Hz, Bridge, 15 periodi a 83.3 Hz, bridge,7 periodi a 83.3Hz, bridge, genera 7 periodi a 83.3Hz
-                            //+++pc.printf("+++ 7 sinusoidi a 83.3Hz +++\n\r");
-                            fDeltaT = double((double)T833/(double)SAMPLESINENUM);
-                            SampleOutTicker.attach(&SampleOut, fDeltaT);
-                        } break;
-                        case 8:
-                        {
-                            // dopo 23 periodi a 83.3 Hz, Bridge, 15 periodi a 83.3 Hz, bridge,7 periodi a 83.3Hz, bridge, 7 periodi a 83.3Hz, genera bridge
-                            //+++pc.printf("+++ Quarto Bridge +++\n\r");
-                            fDeltaT = (double)((double)T96/(double)(SAMPLESINENUM));
-                            SampleOutTicker.attach(&SampleOut, fDeltaT);
-                        } break;
-                        default: break;
-                    } //switch (nStep)
-                } // if(nStep != nNewStep) 
-            } break; //case 1:
-            default: {} break;
-        } //switch (nPSK)    
-    } // while(true)
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-