static void Main(string[] args)
{
string argument;
// script python a executer pour ploter les resultats
//-------------------------------------------------
argument = "C:\\C#\\MathsLib\\Test_sysarg-v4.py" + " ";
//test de plusieurs fonctionnalites
//-------------------------------------------------
int nbechant;
double Fe;
Fe = 1000.0; //1000 Hz
//calcul du nombre de points a echantillonner
//sur un crénau de 0.25 secondes (250 milisecondes) avec une fréquence d'échantillonnage de 1000 Hz
// échantillonnage a 1 points toutes les 1/1000 = 0.001 secondes
nbechant = SiTest.Nbechant(1000, 0.25);
Console.WriteLine("nbechant = {0}", nbechant);
decimal[] S2 = new decimal[nbechant];
double[] S1 = new double[nbechant];
//Form a signal containing a 50 Hz sinusoid of amplitude 4
//S2 = 4*sin(2*pi*50*t)
S2 = SiTest.GenSin2piF(nbechant, 50.0, 4.0, Fe);
// resultat de la DFT (Discret Fourier Transform) dans le tableau de complexe : Ts[]
//----------------------------------------------------------------------------------
Complex[] Ts = new Complex[nbechant];
Ts = DFT.DFTv2(S2);
//Recuperation du module de la DFT
decimal[] Module = new decimal[nbechant];
//Module = DFT.Dsdec(Ts);
//Densite spectrale de puissance du signal
//---------------------------------------------------------------------------
decimal[] Module1 = new decimal[nbechant];
Module1 = DSP.Dspdeci(Ts);
//plot signal de test : Tableau Ti1[]
//-------------------------------------------------------------------
PlotPython.Plot1(S2, argument);
//plot Densite spectrale de puissance du sgignal
//------------------------------------------------------------------
PlotPython.Plot1(Module1, argument);
}
static void Main(string[] args)
{
string argument;
// script python a executer pour ploter les resultats
//-------------------------------------------------
argument = "C:\\C#\\MathsLib\\Test_sysarg-v4.py" + " ";
int nbechant;
double Fe; //Frequence d echantllonnage
//calcul de la frequence d echantillonnage FE
//sampling frequency of Fe Hz and a signal duration of 2 secondes. avec une fréquence d'échantillonnage de Fe
nbechant = 256;
double Duree = 2; // 2 secondes
double Te; //pas temporel d echantillonnage : Te
Te = Duree / nbechant;
Fe = 1 / Te; // frequence d echantillonnage : Fe
Console.WriteLine("Frequence d echantillonnage : Fe = {0}", Fe);
double Freq; //Frequence de base (max) du signal de test : 1*sin(2*pi*40*t)
Freq = 40; // 40 Hz
//autre méthode pour calculer la fréquence d'écahntillonnage adéquate '
Fe = DFT.CalcFreqSamp(nbechant, Freq, Duree);
Console.WriteLine("Frequence d echantillonnage recalculée : Fe = {0}", Fe);
decimal[] S2 = new decimal[nbechant];
decimal[] S3 = new decimal[nbechant];
decimal[] Si = new decimal[nbechant];
// Generation du signal de test suivant : avec les parametres :
// frequence dechantillonnage Fe
// nombre dechantillons : nbechant
// amplitude et frequence propre de chaque sinus
//S = 1 * sin(2 * pi * 40 * t) + 0.5*sin(2 * pi * 80 * t)
S2 = SiTest.GenSin2piF(nbechant, Freq, 1, Fe);
//S3 = SiTest.GenSin2piF(nbechant, Freq*2, 0.5, Fe);
// signal resultant "Additopn des deux signaux sinusoidaux
for (int i = 0; i < nbechant; i++)
{
Si[i] = S2[i] + S3[i];
}
// resultat de la DFT (Discret Fourier Transform) dans le tableau de complexe : Ts[]
//----------------------------------------------------------------------------------
Complex[] Ts = new Complex[nbechant];
Ts = DFT.DFTv2(S2);
//Densite spectrale de puissance du signal
//---------------------------------------------------------------------------
decimal[] Module1 = new decimal[nbechant];
Module1 = DSP.Dspdeci(Ts);
//plot signal de test : Tableau Ti1[]
//-------------------------------------------------------------------
PlotPython.Plot1(S2, argument);
//plot Densite spectrale de puissance du sgignal
//------------------------------------------------------------------
PlotPython.Plot1(Module1, argument);
}
static void Main(string[] args)
{
int nbechant;
double Fe; //Frequence d echantllonnage
double Duree; // Duree du signal (en secondes)
double Te; //pas temporel d echantillonnage : Te
Console.WriteLine(" nombre d'échantillons ? ");
string rep;
rep = Console.ReadLine();
nbechant = Convert.ToInt32(rep);
//String reppad = "0";
//if ( nbechant <= 128)
//{ Console.WriteLine("-----------------------------------------------------------------");
// Console.WriteLine("nombre echantillons bas . voulez vous du 0 padding ? ");
// Console.WriteLine(" oui (1) non (0) ? ");
// Console.WriteLine("-----------------------------------------------------------------");
// reppad = Console.ReadLine();
//}
Console.WriteLine(" durée d<echantillonnage (en secondes) ? ");
rep = Console.ReadLine();
Duree = Convert.ToDouble(rep);
Te = Duree / nbechant;
Fe = 1 / Te; // frequence d echantillonnage : Fe
Console.WriteLine("-----------------------------------------------------------------");
Console.WriteLine("Frequence d echantillonnage : Fe = {0} Hz ", Fe);
//pas frequentiel
double pas;
pas = Fe / (double)nbechant;
Console.WriteLine("--------------------------------------------------------------------");
Console.WriteLine("pas de Frequence (resolution frequentielle) (axe des X pour la DFT");
Console.WriteLine("un point de mesure de DFT touts les : {0} Hz pas = {0} Hz ", pas, pas);
Console.WriteLine("---------------------------------------------------------------------");
decimal[] S2 = new decimal[nbechant];
decimal[] S3 = new decimal[nbechant];
decimal[] Si = new decimal[nbechant];
decimal[] Sign = new decimal[nbechant];
decimal[] H = new decimal[nbechant];
// Generation du signal de test suivant : avec les parametres :
// frequence dechantillonnage Fe
// nombre dechantillons : nbechant
// frequence snusoidale : 2 Khz et 2.35 Khz
//----------------------------------------------------------
// S = 1 * sin(2 * pi * Freq1 * t) + 1*sin(2 * pi * Freq2 * t)
//---------------------------------------------------------
double Freq1, Freq2;
Console.WriteLine(" frequence du signal 1 (en Hz) : 1*sin(2*pi*Freq1*t) ? ");
rep = Console.ReadLine();
Freq1 = Convert.ToDouble(rep);
Console.WriteLine(" frequence du signal 2 (en Hz): 1*sin(2*pi*Freq2*t) ? ");
rep = Console.ReadLine();
Freq2 = Convert.ToDouble(rep);
S2 = SiTest.GenSin2piF(nbechant, Freq1, 1, Fe);
S3 = SiTest.GenSin2piF(nbechant, Freq2, 1, Fe);
// signal resultant "Addition des deux signaux sinusoidaux
for (int i = 0; i < nbechant; i++)
{
Si[i] = S2[i] + S3[i];
}
Console.WriteLine(" Fenetre de Hamming (1) ou fenetre de Hanning (2) ? ");
rep = Console.ReadLine();
if (rep == "1")
{ //----------------------------------------------------
// Fenetre de Hamming
//--------------------------------------------------
H = Fenetre.HammingD(nbechant);
}
else if (rep == "2")
{ //----------------------------------------------------
// Fenetre de Hanning
//--------------------------------------------------
H = Fenetre.HanningD(nbechant);
}
// Mutiplication du signal par la fenetre choisie
//---------------------------------------------------------
for (int i = 0; i < nbechant; i++)
{
Sign[i] = Si[i] * H[i];
}
//Sauvegarde dans fichier pour v/rifications ou traitement ulterieur
//-------------------------------------------------------------------
StoficSign(Sign, "Signal.txt", Fe, nbechant);
//affichage du signal de test
//--------------------------------------------------------------------------------
PlotPython.Plot5signal("Signal.txt");
// resultat de la DFT (Discret Fourier Transform)
//----------------------------------------------------------------------------------
Complex[] Ts = new Complex[nbechant];
Ts = DFT.DFTv2(Sign);
//----------------------------------------------------------------------------
//Densite spectrale de puissance du signal
//---------------------------------------------------------------------------
decimal[] Module1 = new decimal[nbechant];
Module1 = DSP.Dspdeci(Ts);
//Sauvegarde dans fichier pour v/rifications ou traitement ulterieur
//-------------------------------------------------------------------
StoficSign(Module1, "DFT.txt", Fe, nbechant);
//plot Densite spectrale de puissance du sgignal
//------------------------------------------------------------------
PlotPython.Plot5DSP("DFT.txt");
}
static void Main(string[] args)
{
string argument;
// script python a executer pour ploter les resultats
//-------------------------------------------------
argument = "C:\\C#\\MathsLib\\Test_sysarg-v4.py" + " ";
//test de plusieurs fonctionnalites
//-------------------------------------------------
int nbechant;
//nombre de points a echantillonner
nbechant = SiTest.Nbechant(1000, 0.25); //crenau de 0.25 secondes (250 milisecondes) et frequence de 1000 Hz
//Form a signal containing a 50 Hz sinusoid of amplitude 1 and a 120 Hz sinusoid of amplitude 1.
//S = 1*sin(2*pi*50*t) + sin(2*pi*120*t);
decimal[] S1 = new decimal[nbechant];
decimal[] S2 = new decimal[nbechant];
S1 = SiTest.GenSin(nbechant, 50, 1);
S2 = SiTest.GenSin(nbechant, 120, 1);
// Instantiate random number generator using system-supplied value as seed.
// signal de bruit blanc ( random noise signal)
//-----------------------------------------------------------------------
decimal[] Rand = new decimal[nbechant];
Rand = SiTest.Random(nbechant);
// genere le signal de test : s1 + s2 + bruit blanc d Amplidtude 2
//-----------------------------------------------------------------------
decimal[] Ti = new decimal[nbechant];
for (int i = 0; i < nbechant; i++)
{
Ti[i] = S1[i] + S2[i] + (2 * Rand[i]);
}
// resultat de la DFT (Discret Fourier Transform) dans le tableau de complexe : Ts[]
//----------------------------------------------------------------------------------
Complex[] Ts = new Complex[nbechant];
Ts = DFT.DFTv2(Ti);
//Recuperation du module de la DFT
decimal[] Module = new decimal[nbechant];
//Module = DFT.Dsdec(Ts);
//Densite spectrale de puissance du signal
//---------------------------------------------------------------------------
decimal[] Module1 = new decimal[nbechant];
Module1 = DSP.Dspdeci(Ts);
// Densite spectrale de puissance du signal
double[] Module3 = new double[nbechant];
//Module3 = DSP.Dspdoub(Ts);
//impression partie reelle (amplitude du signal transforme par la DFT
//PlotPython.Plot1(Ti1, argument);
//impression partie imaginaire (phase du signal transforme par la DFT
//PlotPython.Plot1(Tc2, argument);
//plot signal de test : Tableau Ti1[]
//-------------------------------------------------------------------
PlotPython.Plot1(Ti, argument);
//plot magnitude du sgignal calcule par DFTv2
//PlotPython.Plot1(Module, argument);
//plot Densite spectrale de puissance du sgignal
//------------------------------------------------------------------
PlotPython.Plot1(Module1, argument);
}
static void Main(string[] args)
{
string argument;
// script python a executer pour ploter les resultats
//-------------------------------------------------
argument = "C:\\C#\\MathsLib\\Test_sysarg-v4.py" + " ";
int nbechant;
double Fe; //Frequence d echantllonnage
//calcul de la frequence d echantillonnage FE
//sampling frequency of Fe Hz and a signal duration of 2 secondes. avec une fréquence d'échantillonnage de Fe
nbechant = 256;
double Duree = 0.05; // 0.05 secondes
double Te; //pas temporel d echantillonnage : Te
Te = Duree / nbechant;
Fe = 1 / Te; // frequence d echantillonnage : Fe
Console.WriteLine("Frequence d echantillonnage : Fe = {0}", Fe);
decimal[] S2 = new decimal[nbechant];
decimal[] S3 = new decimal[nbechant];
decimal[] Si = new decimal[nbechant];
decimal[] Sign = new decimal[nbechant];
decimal[] H = new decimal[nbechant];
// Generation du signal de test suivant : avec les parametres :
// frequence dechantillonnage Fe
// nombre dechantillons : nbechant
// frequence snusoidale : 2 Khz et 2.35 Khz
//----------------------------------------------------------
// S = 1 * sin(2 * pi * 2000 * t) + 1*sin(2 * pi * 2350 * t)
//---------------------------------------------------------
S2 = SiTest.GenSin2piF(nbechant, 2000, 1, Fe);
S3 = SiTest.GenSin2piF(nbechant, 2350, 1, Fe);
// signal resultant "Addition des deux signaux sinusoidaux
for (int i = 0; i < nbechant; i++)
{
Si[i] = S2[i] + S3[i];
}
//----------------------------------------------------
// Fenetre de Hamming
//--------------------------------------------------
H = Fenetre.HammingD(nbechant);
// Mutiplication du signal par la fenetre de Hamming
for (int i = 0; i < nbechant; i++)
{
Sign[i] = Si[i] * H[i];
}
//--------------------------------------------------------------------------------
// resultat de la DFT (Discret Fourier Transform)
//----------------------------------------------------------------------------------
Complex[] Ts = new Complex[nbechant];
Ts = DFT.DFTv2(Sign);
//----------------------------------------------------------------------------
//Densite spectrale de puissance du signal
//---------------------------------------------------------------------------
decimal[] Module1 = new decimal[nbechant];
Module1 = DSP.Dspdeci(Ts);
//Magnitude du signal
//------------------------------------------
decimal[] Module2 = new decimal[nbechant];
Module2 = DFT.DspMagnDec(Ts);
//plot signal de test :
//-------------------------------------------------------------------
PlotPython.Plot1(Si, argument);
//plot signal multiplié parla fenetre de Hamming
//-------------------------------------------------------------------
PlotPython.Plot1(Sign, argument);
//plot Densite spectrale de puissance du sgignal
//------------------------------------------------------------------
PlotPython.Plot1(Module1, argument);
//plot MAgnitude du sgignal
//------------------------------------------------------------------
PlotPython.Plot1(Module2, argument);
}