La traduction de cette page n'est pas à jour. Cliquez ici pour voir la dernière version en anglais.

awgn

Ajouter du bruit blanc gaussien à un signal

Syntaxe

Y = awgn(X,snr)

Y = awgn(X,snr,signalpower)

Y = awgn(X,snr,signalpower,randobject)

Y = awgn(X,snr,signalpower,seed)

Y = awgn(___,powertype)

[Y,var] = awgn(___)

Description

Y = awgn(X,snr) ajoute du bruit blanc gaussien au signal vectoriel X. Cette syntaxe suppose que X a une puissance de 0 dBW. Pour plus d’informations sur le bruit blanc gaussien additif, veuillez consulter Qu’est-ce que le bruit AWGN ?

Y = awgn(X,snr,signalpower) accepte une valeur de puissance de signal d’entrée en dBW. Pour mesurer la puissance de X avant d’ajouter du bruit, définissez signalpower à 'measured'. L’option 'measured' ne génère pas le rapport signal à bruit (SNR) moyen demandé pour des appels de fonction awgn répétés en boucle si la puissance du signal d’entrée varie dans le temps en raison de l’évanouissement, mais aussi si le temps de cohérence du canal est supérieur à la durée de l’entrée.

Y = awgn(X,snr,signalpower,randobject) accepte également un objet de stream de nombres aléatoires pour générer des échantillons de bruit aléatoires normaux. Pour plus d’informations sur la génération d’échantillons de bruit reproductibles, veuillez consulter Conseils.

Y = awgn(X,snr,signalpower,seed) spécifie une valeur initiale pour initialiser le générateur de nombres aléatoires normaux qui sert à ajouter du bruit blanc gaussien au signal d’entrée.

Y = awgn(___,powertype) définit le type de puissance du signal et du bruit à 'dB' ou 'linear', en plus des arguments en entrée indiqués dans les syntaxes précédentes. Pour plus d’informations sur les relations entre le SNR et d’autres mesures de puissance relative du bruit telles que E_s/N₀ et E_b/N₀, veuillez consulter AWGN Channel Noise Level.

[Y,var] = awgn(___) renvoie également la variance totale du bruit utilisée pour générer des échantillons de bruit aléatoires en échelle linéaire.

Exemples

Ajouter du bruit AWGN à un signal en dents de scie

Créez une onde en dents de scie.

t = (0:0.1:60)';
x = sawtooth(t);

Ajoutez du bruit blanc gaussien et tracez les résultats.

y = awgn(x,10,'measured');
plot(t,[x y])
legend('Original Signal','Signal with AWGN')

Estimer le taux de symbole pour la modulation QAM générale dans un canal AWGN

Émettez et recevez des données avec une constellation « 16-aire » non rectangulaire en présence de bruit gaussien. Affichez le diagramme de dispersion de la constellation bruitée et estimez le taux d’erreur de symbole (SER) pour deux SNR différents.

Créez une constellation 16-QAM basée sur la norme V.29 pour les modems de ligne téléphonique.

c = [-5 -5i 5 5i -3 -3-3i -3i 3-3i 3 3+3i 3i -3+3i -1 -1i 1 1i];
sigpower = pow2db(mean(abs(c).^2));
M = length(c);

Générez des symboles aléatoires.

data = randi([0 M-1],2000,1);

Modulez les données avec la fonction genqammod. La modulation QAM générale est nécessaire car la constellation personnalisée n’est pas rectangulaire.

modData = genqammod(data,c);

Passez le signal à travers un canal AWGN avec un SNR de 20 dB.

rxSig = awgn(modData,20,sigpower);

Affichez un diagramme de dispersion du signal reçu et de la constellation de référence c.

h = scatterplot(rxSig);
hold on
scatterplot(c,[],[],'r*',h)
grid
hold off

Démodulez le signal reçu avec la fonction genqamdemod. Déterminez le nombre d’erreurs de symbole et le SER.

demodData = genqamdemod(rxSig,c);
[numErrors,ser] = symerr(data,demodData)

numErrors = 
4

ser = 
0.0020

Répétez le processus d’émission et de démodulation en utilisant un canal AWGN avec un SNR de 10 dB. Déterminez le SER pour ce SNR réduit. Comme on pouvait s’y attendre, les performances se dégradent lorsque le SNR est réduit.

rxSig = awgn(modData,10,sigpower);
demodData = genqamdemod(rxSig,c);
[numErrors,ser] = symerr(data,demodData)

numErrors = 
457

ser = 
0.2285

Simulation AWGN reproductible

Générez des symboles de données aléatoires et le signal modulé 4-PSK.

M = 4;
k = log2(M);
snr = 3;
data = randi([0 M-1],2000,1);
x = pskmod(data,M);

Définissez la valeur initiale du générateur de nombres aléatoires.

seed = 12345;

Générez un bruit aléatoire reproductible avec la fonction rng avant d’appeler la fonction awgn.

rng(seed);
y = awgn(x,snr);

Calculez les erreurs sur les bits.

dataHat = pskdemod(y,M);
numErr1 = biterr(data,dataHat,k)

numErr1 = 
309

Réinitialisez la valeur initiale du générateur de nombres aléatoires.

rng(seed);

Démodulez le signal PSK et calculez les erreurs sur les bits.

y = awgn(x,snr);
dataHat = pskdemod(y,M);
numErr2 = biterr(data,dataHat,k)

numErr2 = 
309

Comparez numErr1 et numErr2. Le nombre d’erreurs reste le même après la réinitialisation de la valeur initiale du générateur de nombres aléatoires.

isequal(numErr1, numErr2)

ans = logical
   1

AWGN reproductible avec RandStream

Générez des résultats d’ajout de bruit blanc gaussien avec un objet RandStream et la fonction d’objet reset.

Définissez la puissance du signal d’entrée à 0 dBW, ajoutez du bruit pour obtenir un SNR de 10 dB et utilisez un stream aléatoire local. Ajoutez du bruit blanc gaussien à sigin deux fois pour générer sigout1 et sigout2. Utilisez isequal pour comparer sigout1 et sigout2. Les sorties ne sont pas égales lorsque vous ne réinitialisez pas le stream aléatoire.

S = RandStream('mt19937ar',Seed=5489);
sigin = sqrt(2)*sin(0:pi/8:6*pi);
sigout1 = awgn(sigin,10,0,S);
sigout2 = awgn(sigin,10,0,S);
isequal(sigout1,sigout2)

ans = logical
   0

Réinitialisez l’objet de stream aléatoire pour qu’il revienne à l’état qu’il avait avant l’ajout du bruit AWGN à sigout1. Ajoutez du bruit AWGN à sigin pour générer sigout3, puis comparez sigout1 et sigout3. Les sorties sont égales lorsque vous réinitialisez le stream aléatoire.

reset(S);
sigout3 = awgn(sigin,10,0,S);
isequal(sigout1,sigout3)

ans = logical
   1

Arguments d'entrée

X — Signal d’entrée

scalaire | vecteur | tableau numérique | objet dlarray

Signal d’entrée, défini par un scalaire, un vecteur, un tableau numérique ou un objet dlarray (Deep Learning Toolbox). La puissance du signal d’entrée est supposée égale à 0 dBW. Si X est complexe, awgn ajoute un bruit complexe. Pour plus d’informations, veuillez consulter Support des tableaux.

Types de données : double
Support des nombres complexes : Oui

snr — Rapport signal à bruit

scalaire | vecteur

Rapport signal à bruit en dB, défini par :

• Un scalaire si le signal d’entrée est un scalaire ou un vecteur.

• Un scalaire ou un vecteur si le signal d’entrée est un tableau 3D. Pour plus d’informations, veuillez consulter Support des tableaux.

La fonction applique la même valeur de snr à chaque canal. Les colonnes du signal d’entrée représentent les différents canaux d’un signal multicanal.

Types de données : double

signalpower — Puissance du signal

scalaire | 'measured'

Puissance du signal en dBW, définie par un scalaire ou par 'measured'.

• Scalaire : la valeur indiquée est utilisée comme niveau de signal de X pour déterminer le niveau de bruit nécessaire pour atteindre le snr spécifié.

• 'measured' : le niveau de signal de X est calculé pour déterminer le niveau de bruit nécessaire pour atteindre le snr spécifié. Vous ne pouvez pas utiliser cette valeur si le signal d’entrée est un dlarray ou si snr est un vecteur.

Si le signal d’entrée est multicanal, la fonction calcule une seule valeur signalpower pour tous les canaux. Elle utilise ensuite cette valeur pour calculer le niveau de bruit pour tous les canaux.

Types de données : double

randobject — Objet de stream de nombres aléatoires

objet RandStream

Objet de stream de nombres aléatoires, défini par un objet RandStream. L’état de l’objet de stream aléatoire détermine la série de nombres générée par la fonction randn. Configurez l’objet de stream aléatoire avec la fonction reset (RandStream) et ses propriétés. Vous ne pouvez pas spécifier un objet de stream aléatoire si le signal d’entrée est un dlarray.

Pour plus d’informations sur la génération d’échantillons de bruit reproductibles, veuillez consulter Conseils.

seed — Valeur initiale du générateur de nombres aléatoires

scalaire

Valeur initiale du générateur de nombres aléatoires, définie par un scalaire. Vous ne pouvez pas spécifier une valeur initiale si le signal d’entrée est un dlarray.

Types de données : double

powertype — Unité de puissance du signal

'dB' (par défaut) | 'linear'

Unité de puissance du signal, définie à 'dB' ou 'linear'.

• Lorsque powertype est défini à 'dB', snr est mesuré en dB et signalpower en dBW.

• Lorsque powertype est défini à 'linear', snr est mesuré sous forme de rapport et signalpower est mesuré en watts en supposant une charge de référence égale à 1 ohm.

Pour définir l’argument powertype, vous devez aussi définir snr et signalpower.

Arguments de sortie

Y — Signal de sortie

scalaire | vecteur | objet dlarray

Signal de sortie, renvoyé sous la forme d’un scalaire, d’un vecteur ou d’un objet dlarray (Deep Learning Toolbox). Le signal de sortie renvoyé est le signal d’entrée avec le bruit blanc gaussien ajouté. Si le signal d’entrée X est un dlarray, la sortie Y est également un dlarray. Pour plus d’informations, veuillez consulter Support des tableaux.

var — Variance totale du bruit en échelle linéaire

scalaire | vecteur

Variance totale du bruit en échelle linéaire, renvoyée sous la forme d’un scalaire positif ou d’un vecteur lorsque snr est un vecteur. La fonction utilise la variance du bruit pour générer des échantillons de bruit aléatoires.

En savoir plus

Qu’est-ce que le bruit AWGN ?

Le bruit blanc gaussien additif (AWGN, Additive White Gaussian Noise) est un modèle de bruit simple qui représente le mouvement des électrons dans le front-end RF d’un récepteur. Comme son nom l’indique, ce bruit est ajouté au signal. On dit qu’il s’agit d’un bruit blanc parce que son spectre est plat sur toute la bande passante d’échantillonnage. De la même manière, la couleur blanche contient des niveaux égaux de puissance spectrale à toutes les fréquences du spectre de la lumière visible. Le bruit est gaussien car son amplitude peut être modélisée avec une loi de probabilité normale.

Le canal AWGN est souvent utilisé pour modéliser un canal de communications par satellite. En effet, un tel canal ne subit généralement pas les imperfections terrestres comme l’évanouissement, les trajets multiples et les interférences. Un canal AWGN est un bon point de départ pour l’analyse des liaisons de télécommunications terrestres car il établit la limite idéale du taux d’erreur binaire d’une telle liaison.

Support des tableaux

La fonction awgn supporte les signaux d’entrée représentés par un tableau numérique, un dlarray (Deep Learning Toolbox) ou un gpuArray (Parallel Computing Toolbox).

Le nombre d’observations par batch (N_B) est une dimension facultative qui peut être ajoutée à ces entrées pour tous les types de données supportés.

• X : le signal d’entrée peut être un tableau à trois dimensions maximum, spécifié en tant que tableau N_S x N_C x N_B.

• snr peut être un scalaire ou un vecteur de taille N_B.

N_S est le nombre d’échantillons et N_C est le nombre de canaux.

Pour une liste des fonctionnalités de Communications Toolbox™ qui supportent les objets dlarray, veuillez consulter L’IA pour les télécommunications.

Conseils

• Pour plus d’informations sur les relations entre le SNR et d’autres mesures de puissance relative du bruit telles que E_s/N₀ et E_b/N₀, veuillez consulter AWGN Channel Noise Level.

• Pour générer des échantillons de bruit blanc gaussien reproductibles, procédez de l’une des manières suivantes :

  • Utilisez rng (seed) avant d’appeler la fonction awgn pour générer un bruit aléatoire reproductible.

  • Indiquez une valeur seed statique en entrée de awgn sauf si l’entrée est un objet dlarray.

  • Utilisez la fonction reset (RandStream) avec l’objet randobject avant de le passer en entrée à awgn sauf si l’entrée est un objet dlarray.

  • Indiquez un objet randobject dont l’état est connu en entrée de awgn sauf si l’entrée est un objet dlarray. Pour plus d’informations, veuillez consulter RandStream.

• Pour reproduire les streams de nombres aléatoires d’un CPU sur un GPU, vous devez aligner leurs générateurs de nombres aléatoires respectifs. Pour plus d’informations, veuillez consulter Random Number Streams on a GPU (Parallel Computing Toolbox).

Capacités étendues

Génération de code C/C++

Générez du code C et C++ avec MATLAB® Coder™.

Notes d'usage et limitations :

• Génération de code supportée sauf pour les syntaxes qui contiennent un objet RandStream.

GPU Arrays

Accélérez le code en exécutant les calculs sur une unité de traitement graphique (GPU) avec Parallel Computing Toolbox™.

Cette fonction supporte les GPU arrays en entrée. Pour plus d’informations, veuillez consulter Exécuter les fonctions MATLAB sur un GPU (Parallel Computing Toolbox).

Notes d'usage et limitations :

• Lorsque le signal d’entrée X est un objet gpuArray, vous ne pouvez pas spécifier les arguments d’entrée seed et randobject ni définir l’argument d’entrée snr à "measured".

Historique des versions

Introduit avant R2006a

R2023b: Ajout du support des tableaux de Deep Learning

La fonction awgn ajoute le support du traitement d’objets dlarray (Deep Learning Toolbox) pour les applications de Deep Learning.

R2023b: Ajout du support des GPU arrays

La fonction awgn ajoute le support du traitement d’objets gpuArray (Parallel Computing Toolbox) pour l’exécution de code sur un processeur graphique (GPU).

R2023b: La fonction awgn offre de meilleures performances lors de l’ajout d’un bruit complexe à des entrées complexes

La fonction awgn offre de meilleures performances lors de l’ajout d’un bruit complexe à des entrées complexes. Pour plus d’informations, veuillez consulter Match complexity with like, and use like with RandStream object.

Cette mise à jour de la fonction entraîne des modifications de la sortie numérique dues à la génération de nombres aléatoires différents pour le bruit ajouté au signal. Si vous avez besoin de reproduire la sortie de awgn telle qu’elle était avant la version R2023b, examinez les exemples de code suivants :

Avant R2023b	Code pour reproduire la sortie antérieure à R2023b
x = ones(2)+1i*ones(2); y_23a = awgn(x,5,1) y_23a = 2×2 complex 1.2399 + 1.1422i -0.0078 + 0.8066i 1.8182 + 0.4166i 1.3847 + 1.1529i	x = ones(2)+1i*ones(2); y_23b = complex(awgn(real(x),5,1 - 10*log10(2)), ... awgn(imag(x),5,1 - 10*log10(2))) y_23b = 2×2 complex 1.2399 + 1.1422i -0.0078 + 0.8066i 1.8182 + 0.4166i 1.3847 + 1.1529i
y_23a = awgn(x,1,'measured') y_23a = 2×2 complex 1.4792 + 1.2841i -1.0132 + 0.6136i 2.6345 - 0.1655i 1.7684 + 1.3054i	y_23b = complex(awgn(real(x),1,'measured'), ... awgn(imag(x),1,'measured')) y_23b = 2×2 complex 1.4792 + 1.2841i -1.0132 + 0.6136i 2.6345 - 0.1655i 1.7684 + 1.3054i
y_23a = awgn(x,5,1,'linear') y_23a = 2×2 complex 1.1700 + 1.1008i 0.2857 + 0.8629i 1.5799 + 0.5865i 1.2726 + 1.1083i	y_23b = complex(awgn(real(x),5,1/2,'linear'), ... awgn(imag(x),5,1/2,'linear')) y_23b = 2×2 complex 1.1700 + 1.1008i 0.2857 + 0.8629i 1.5799 + 0.5865i 1.2726 + 1.1083i

R2023b: awgn utilise le générateur de nombres aléatoires Mersenne Twister lorsque la valeur initiale est spécifiée en entrée

Lorsqu’une valeur initiale est spécifiée dans l’appel de la fonction awgn, le générateur de nombres aléatoires (RNG) utilise désormais Mersenne Twister au lieu du RNG normal v5.

Cette mise à jour de la fonction entraîne des modifications de la sortie numérique dues à la génération de nombres aléatoires différents pour le bruit ajouté au signal. La fonction awgn mise à jour améliore les statistiques du bruit ajouté, mais si vous avez besoin de reproduire la sortie de awgn telle qu’elle était avant la version R2023b, examinez les exemples de code suivants :

Avant R2023b	Code pour reproduire la sortie antérieure à R2023b
x = ones(2); seed = 5; y_23a = awgn(x,1,1,seed) y_23a = 2×2 1.9876 0.6199 1.2590 1.1726	x = ones(2); stream = RandStream('shr3cong','Seed',5); y_23b = awgn(x,1,1,stream); y_23b = 2×2 1.9876 0.6199 1.2590 1.1726

Voir aussi

Fonctions

• convertSNR | wgn | randn | bsc | RandStream

Objets

• comm.AWGNChannel

Blocs

• AWGN Channel

Rubriques

• AWGN Channel Noise Level