somme_de_2_sinus_CSP.py

Contenu du fichier

#!/usr/bin/env python
# coding: utf-8

# # Somme de 2 sinus de même frequence dont on fait varier la phase
# Author : Delphine Chareyron pour CultureSciencesPhysique.ens-lyon.fr
# In[1]:


# import de la bibliothèque numpy (gestion de matrices et routines mathématiques) en lui donnant le surnom np
import numpy as np
# import de la bibliothèque matplotlib (graphiques) en lui donnant le surnom plt
import matplotlib.pyplot as plt


# In[51]:


# Définition des signaux Y1, Y2 et Y3

f = 200 # fréquence des signaux (200Hz)

temps_total = 1 # en seconde
dt = 1*10**(-5)   # pas de temps en seconde
nb_points = int(temps_total/dt)
temps = np.linspace(0,nb_points,nb_points)*dt 

phi = np.pi/4 # valeur du déphasage

Y1 = np.sin(2*np.pi*f*temps)
Y2 = np.sin(2*np.pi*f*temps+phi)

Y3 = Y1+Y2


# # Affichage et axe temporel

# In[52]:


# Définition de la fonction sinusoïdale Y
f = 200 # fréquence du signal (200Hz)

temps_total = 1 # en seconde
dt = 1*10**(-5)   # pas de temps en seconde
nb_points = int(temps_total/dt)
temps = np.linspace(0,nb_points,nb_points)*dt 

Y = np.sin(2*np.pi*f*temps)

# Tracé du signal Y
plt.plot(temps,Y,"b-")
plt.title("Y = sin(2$\pi$f)")
plt.xlabel("temps (s)")  
plt.ylabel("Amplitude")
plt.grid(True)
plt.ticklabel_format(style='scientific', axis='x', scilimits=(0,0))


# In[53]:


# Définition de la fonction sinusoïdale Y
f = 200 # fréquence du signal (200Hz)

temps_total = 1 # en seconde
dt = 1*10**(-5)   # pas de temps en seconde
nb_points = int(temps_total/dt)
temps = np.linspace(0,nb_points,nb_points)*dt 

Y = np.sin(2*np.pi*f*temps)

# Tracé du signal Y
plt.plot(temps,Y,"b-")
plt.title("Y = sin(2$\pi$f)")
plt.xlabel("temps (s)")  
plt.ylabel("Amplitude")
plt.grid(True)
plt.xlim(0, 0.02)
plt.ticklabel_format(style='scientific', axis='x', scilimits=(0,0))


# # Apparté sur le pas de temps

# In[67]:


# Définition de la fonction sinusoïdale Y
f = 200 # fréquence du signal (200Hz)

temps_total = 1 # en seconde
dt_1 = 1*10**(-3)   # pas de temps en seconde
nb_points_1 = int(temps_total/dt_1)
temps_1 = np.linspace(0,nb_points_1,nb_points_1)*dt_1

Y = np.sin(2*np.pi*f*temps_1)

# Affichage de la période et du pas de temps
T = 1/f
print('la période du signal est : T =',T, 's')
print('le pas de temps est défini comme dt_1 =', dt_1, 's')

# Tracé du signal Y
plt.plot(temps_1,Y,"b-")
plt.title("Y = sin(2$\pi$f)")
plt.xlabel("temps (s)")  
plt.ylabel("Amplitude")
plt.grid(True)
plt.xlim(0, 0.02)
plt.ticklabel_format(style='scientific', axis='x', scilimits=(0,0))


# # Tracé des 3 sinus sur le même graphe

# In[55]:


# Tracé des signaux 
fig = plt.figure(figsize=(9,6)) # Taille de la figure

plt.plot(temps,Y1,"b-", label="Y1 = sin(2$\pi$f)")
plt.plot(temps,Y2,"g-", label="Y2 = sin(2$\pi$f+$\phi$)")
plt.plot(temps,Y3,"m-", label="Y3 = Y1+Y2")

# Affichage
plt.legend(loc = 'upper right') 
plt.title("Y3 = Y1+Y2")
plt.xlabel("temps (s)")  
plt.ylabel("Amplitude")
plt.text(0.0175,1,"$\phi$ = " + str(round(phi,2))+' rad',size=12,  
         # On crée une boite aux coins ronds, au bord noir et remplie en cyan 
         bbox=dict(boxstyle="round",ec=("k"),fc=("c"))) 

plt.xlim(0, 0.02)
plt.ylim(-2.2, 2.2)
plt.ticklabel_format(style='scientific', axis='x', scilimits=(0,0))
plt.grid(True)

# Sauvegarde de la figure
plt.savefig('somme_sinus_'+chr(934)+'='+str(round(phi,2))+'.png')  


# # Lecture audio des signaux Y1, Y2 et de leur somme Y3

# In[41]:


# Install a pip package in the current Jupyter kernel
import sys
get_ipython().system('{sys.executable} -m pip install pygame')


# In[1]:


clear


# In[2]:


# import de la bibliothèque numpy (gestion de matrices et routines mathématiques) en lui donnant le surnom np
import numpy as np
# import de la bibliothèque matplotlib (graphiques) en lui donnant le surnom plt
import matplotlib.pyplot as plt
# import de la bibliothèques pygame et du module wave pour gérer les sons 
import pygame
import wave


# In[6]:


# Définition des signaux Y1, Y2 et Y3  
# Les sons sont échantillonnés à la fréquence 44100Hz

f = 200 # fréquence des signaux (200Hz)

temps_total = 4 # en seconde
fech = 44100 # nombres d'échantillons par seconde 
dt = 1/fech  # pas de temps en seconde
  
nb_points = int(temps_total/dt)
temps = np.linspace(0,nb_points,nb_points)*dt 

#phi = np.pi # valeur du déphasage
phi=0
Y1 = np.sin(2*np.pi*f*temps)
Y2 = np.sin(2*np.pi*f*temps+phi)

Y3 = Y1+Y2


# In[4]:


print('Le nombre d échantillons pour un signal de',temps_total,'s est', 44100*temps_total)
print('Le nombre d échantillons dans le vecteur Y1 est de',len(Y1))     


# In[7]:


# Création des fichiers "son" 

# Pour chaque signal Y1, Y2 et Y3 on définit un fichier son différent sous la forme d'un wave
NomSon1 = 'sonY1.wav'
Son1 = wave.open(NomSon1,'wb') # Son1 correspond à Y1
NomSon2 = 'sonY2.wav'
Son2 = wave.open(NomSon2,'wb') # Son2 correspond à Y2
NomSon3 = 'sonY3_'+chr(934)+'='+str(round(phi,2))+'.wav'
Son3 = wave.open(NomSon3,'wb') # Son3 correspond à Y3

# Définition des paramètres audio 
nChannels = 1  # mono
nOctet = 1  # taille d'un échantillon : 1 octet = 8 bits
frameRate = fech   # fréquence d'échantillonnage
nFrames = nb_points  # nombre total d'échantillons dans les fichiers son

parametres = (nChannels,nOctet,frameRate,nFrames,'NONE','not compressed')

# On attribue les paramètres à chaque fichier son
Son1.setparams(parametres)
Son2.setparams(parametres)
Son3.setparams(parametres)

amplitude = 64

for i in range (0,nb_points,1) :
    val1 = wave.struct.pack('B',int(128.0 + Y1[i] * amplitude))
    val2 = wave.struct.pack('B',int(128.0 + Y2[i] * amplitude))
    val3 = wave.struct.pack('B',int(128.0 + Y3[i] * amplitude))
    
    # écriture des fichiers sons
    Son1.writeframes(val1) 
    Son2.writeframes(val2)
    Son3.writeframes(val3)
    
Son1.close()
Son2.close()
Son3.close()


# In[17]:


pygame.mixer.init(frequency=frameRate)
pygame.mixer.Sound('sonY1.wav').play()


# In[18]:


pygame.mixer.init(frequency=frameRate)
pygame.mixer.Sound('sonY2.wav').play()


# In[66]:


pygame.mixer.init(frequency=frameRate)
pygame.mixer.Sound('sonY3_'+chr(934)+'='+str(round(phi,2))+'.wav').play()