Mon article d'aujourd'hui est le reflet des réflexions d'une personne qui a choisi le chemin de la programmation presque par accident (bien que naturellement).

Oui, je comprends que mon expérience n'est que mon expérience, mais il me semble qu'elle s'inscrit bien dans la tendance générale. De plus, l'expérience décrite ci-dessous concerne davantage le domaine de l'activité scientifique, mais ce n'est pas une blague, elle peut être utile à l'extérieur.

Source: https://xkcd.com/664/

En général, dédié à tous les étudiants actuels d'un ancien élève !

Attentes

Lorsque j’ai complété mon baccalauréat en technologies de l’infocommunication et systèmes de communication en 2014, je ne connaissais presque rien au monde de la programmation. Oui, comme beaucoup d’autres, j’ai suivi la matière « Informatique » en première année – mais, Seigneur, c’était en première année ! Cela fait une éternité !

En général, je ne m’attendais pas à quelque chose de particulièrement différent d’un baccalauréat, et lorsque je suis entré en master "Communication et traitement du signal" Institut germano-russe des nouvelles technologies.

Mais en vain...

Nous n'étions que la deuxième promotion, et les gars de la première étaient encore en train de faire leurs valises pour la lointaine Allemagne (le stage dure six mois en deuxième année de master). En d’autres termes, personne dans l’entourage immédiat n’avait encore sérieusement rencontré les méthodes de l’éducation européenne, et il n’y avait personne pour s’enquérir des détails.

Au cours de notre première année, bien sûr, nous avons eu différents types de pratiques, dans lesquelles on nous offrait généralement démocratiquement le choix entre écrire des scripts (principalement dans le langage MATLAB) et utiliser diverses interfaces graphiques hautement spécialisées (dans le sens où sans écrire de scripts - simulation environnements de modélisation).

Inutile de dire que nous, les futurs maîtres en sciences, à cause de notre stupidité juvénile, avons évité d'écrire du code comme le feu. Voici, par exemple, Simulink de MathWorks : voici les blocs, voici les connexions, voici toutes sortes de paramètres et de commutateurs.

Une vision native et compréhensible pour une personne ayant déjà travaillé dans la conception de circuits et l’ingénierie des systèmes !

Source: https://ch.mathworks.com/help/comm/examples/parallel-concatenated-convolutional-coding-turbo-codes.html

Il nous a donc semblé...

La réalité

L'un des travaux pratiques du premier semestre a été le développement d'un émetteur-récepteur de signaux OFDM dans le cadre du sujet « Méthodes de modélisation et d'optimisation ». L'idée est très réussie : la technologie est toujours d'actualité et très populaire en raison de son utilisation, par exemple, dans les réseaux Wi-Fi et LTE/LTE-A (sous forme d'OFDMA). C'est la meilleure façon pour les maîtres de mettre en pratique leurs compétences en matière de modélisation de systèmes de télécommunications.

Et maintenant, on nous propose plusieurs options de spécifications techniques avec des paramètres de cadre évidemment peu pratiques (pour ne pas chercher de solution sur Internet), et on se jette sur le Simulink déjà évoqué... Et on se prend un coup de théière sur la tête de la réalité :

• Chaque bloc regorge de nombreux paramètres inconnus, qu'il est effrayant de modifier en un clin d'œil.
• Les manipulations avec les chiffres doivent être faites, semble-t-il, simples, mais il faut quand même s'embêter, à Dieu ne plaise.
• Les machines cathédrale ralentissent sensiblement à cause de l'utilisation frénétique de l'interface graphique, même au stade de la navigation dans les bibliothèques de blocs disponibles.
• Pour terminer quelque chose à la maison, vous devez disposer du même Simulink. Et, en fait, aucune alternative.

Oui, à la fin, bien sûr, nous avons terminé le projet, mais nous l'avons terminé avec un grand soupir de soulagement.

Un certain temps s'est écoulé et nous sommes arrivés à la fin de la première année de master. La quantité de devoirs effectués à l'aide d'interfaces graphiques a commencé à diminuer proportionnellement à l'augmentation de la proportion de sujets allemands, même si elle n'avait pas encore atteint le point de changement de paradigme. Beaucoup d'entre nous, dont moi, surmontant notre amplitude considérable de construction, ont de plus en plus utilisé Matlab dans nos projets scientifiques (bien que sous la forme de boîtes à outils), et non le Simulink apparemment familier.

Le point de nos doutes était la phrase d'un des étudiants de deuxième année (ils venaient alors de rentrer en Russie) :

• Oubliez, au moins pour la durée du stage, Similink, MathCad et autres LabView - d'un autre côté, tout est écrit en MATLAB, en utilisant MatLab lui-même ou sa « version » gratuite Octave.

Cette affirmation s'est avérée en partie vraie : à Ilmenau, le différend sur le choix des outils n'a pas non plus été complètement résolu. Certes, le choix s'est principalement porté entre MATLAB, Python et C.

Le même jour, j’ai été pris d’une excitation naturelle : ne devrais-je pas transférer ma partie du modèle d’émetteur OFDM sous forme scriptée ? Juste pour le fun.

Et je me suis mis au travail.

Pas à pas

Au lieu de calculs théoriques, je donnerai simplement un lien vers ceci excellent article 2011 à partir de TGx et sur les diapositives Couche physique LTE professeurs Michel Tila (TU Ilmenau). Je pense que ce sera suffisant.

"Alors, pensai-je, répétons, qu'allons-nous modéliser ?"
Nous modéliserons Générateur de trames OFDM (Générateur de trames OFDM).

Ce qu'il comprendra :

• symboles d'information
• signaux pilotes
• zéros (DC)

De quoi (par souci de simplicité) nous résumons :

• de la modélisation d'un préfixe cyclique (si vous connaissez les bases, l'ajouter ne sera pas difficile)

Schéma fonctionnel du modèle considéré. Nous nous arrêterons au bloc FFT inverse (IFFT). Pour compléter le tableau, chacun peut continuer le reste lui-même - j'ai promis aux professeurs du département de laisser quelque chose aux élèves.

Définissons-les par nous-mêmes. exercice:

• nombre fixe de sous-porteuses ;
• longueur de cadre fixe ;
• il faut ajouter un zéro au milieu et une paire de zéros au début et à la fin du cadre (total, 5 pièces) ;
• les symboles d'information sont modulés à l'aide de M-PSK ou M-QAM, où M est l'ordre de modulation.

Commençons par le code.

L'intégralité du script peut être téléchargée depuis lien.

Définissons les paramètres d'entrée :

clear all; close all; clc

M = 4; % e.g. QPSK 
N_inf = 16; % number of subcarriers (information symbols, actually) in the frame
fr_len = 32; % the length of our OFDM frame
N_pil = fr_len - N_inf - 5; % number of pilots in the frame
pilots = [1; j; -1; -j]; % pilots (QPSK, in fact)

nulls_idx = [1, 2, fr_len/2, fr_len-1, fr_len]; % indexes of nulls

Nous déterminons maintenant les indices des symboles d'information, en acceptant le principe selon lequel les signaux pilotes doivent nécessairement être avant et/ou après les zéros :

idx_1_start = 4;
idx_1_end = fr_len/2 - 2;

idx_2_start = fr_len/2 + 2;
idx_2_end =  fr_len - 3;

Ensuite, les positions peuvent être déterminées à l'aide de la fonction espace lin, en réduisant les valeurs au plus petit des entiers les plus proches :

inf_idx_1 = (floor(linspace(idx_1_start, idx_1_end, N_inf/2))).'; 
inf_idx_2 = (floor(linspace(idx_2_start, idx_2_end, N_inf/2))).';

inf_ind = [inf_idx_1; inf_idx_2]; % simple concatenation

Ajoutons à ceci des index de zéros et trions :

%concatenation and ascending sorting
inf_and_nulls_idx = union(inf_ind, nulls_idx); 

En conséquence, les indices des signaux pilotes sont tout le reste :

%numbers in range from 1 to frame length 
% that don't overlape with inf_and_nulls_idx vector
pilot_idx = setdiff(1:fr_len, inf_and_nulls_idx); 

Comprenons maintenant les signaux pilotes.

Nous avons un modèle (variable pilotes), et disons que nous voulons que les pilotes de ce modèle soient insérés séquentiellement dans notre cadre. Bien sûr, cela peut être fait en boucle. Ou vous pouvez jouer un peu délicatement avec les matrices - heureusement, MATLAB vous permet de le faire avec suffisamment de confort.

Tout d'abord, déterminons combien de ces modèles s'intègrent complètement dans le cadre :

pilots_len_psudo = floor(N_pil/length(pilots));

Ensuite, nous formons un vecteur composé de nos modèles :

% linear algebra tricks:
mat_1 = pilots*ones(1, pilots_len_psudo); % rank-one matrix
resh = reshape(mat_1, pilots_len_psudo*length(pilots),1); % vectorization

Et nous définissons un petit vecteur qui ne contient qu'un morceau du modèle - la « queue », qui ne rentre pas complètement dans le cadre :

tail_len = fr_len  - N_inf - length(nulls_idx) ...
                - length(pilots)*pilots_len_psudo; 
tail = pilots(1:tail_len); % "tail" of pilots vector

Nous obtenons des personnages pilotes :

vec_pilots = [resh; tail]; % completed pilots vector that frame consists

Passons aux symboles d'information, à savoir, nous allons former un message et le moduler :

message = randi([0 M-1], N_inf, 1); % decimal information symbols

if M >= 16
    info_symbols = qammod(message, M, pi/4);
else
    info_symbols = pskmod(message, M, pi/4);
end 

Tout est prêt ! Assemblage du cadre :

%% Frame construction
frame = zeros(fr_len,1);
frame(pilot_idx) = vec_pilots;
frame(inf_ind) = info_symbols

Vous devriez obtenir quelque chose comme ceci :

frame =

   0.00000 + 0.00000i
   0.00000 + 0.00000i
   1.00000 + 0.00000i
  -0.70711 - 0.70711i
  -0.70711 - 0.70711i
   0.70711 + 0.70711i
   0.00000 + 1.00000i
  -0.70711 + 0.70711i
  -0.70711 + 0.70711i
  -1.00000 + 0.00000i
  -0.70711 + 0.70711i
  -0.70711 - 0.70711i
   0.00000 - 1.00000i
   0.70711 + 0.70711i
   1.00000 + 0.00000i
   0.00000 + 0.00000i
   0.00000 + 1.00000i
   0.70711 - 0.70711i
  -0.70711 + 0.70711i
  -1.00000 + 0.00000i
  -0.70711 + 0.70711i
   0.70711 + 0.70711i
   0.00000 - 1.00000i
  -0.70711 - 0.70711i
   0.70711 + 0.70711i
   1.00000 + 0.00000i
   0.70711 - 0.70711i
   0.00000 + 1.00000i
   0.70711 - 0.70711i
  -1.00000 + 0.00000i
   0.00000 + 0.00000i
   0.00000 + 0.00000i

"Bonheur!" — J'ai pensé avec contentement et j'ai fermé l'ordinateur portable. Il m'a fallu quelques heures pour tout faire : y compris écrire du code, apprendre certaines fonctions de Matlab et réfléchir à des astuces mathématiques.

Quelles conclusions ai-je alors tirées ?

Subjectif:

• Écrire du code est agréable et s’apparente à de la poésie !
• Le scripting est la méthode de recherche la plus pratique dans le domaine de la communication et du traitement du signal.

Objectif:

• Il n'est pas nécessaire de tirer sur des moineaux avec un canon (à moins bien sûr qu'un tel objectif pédagogique en vaille la peine) : à l'aide de Simulink, nous avons décidé de résoudre un problème simple avec un outil sophistiqué.
• L’interface graphique, c’est bien, mais comprendre ce qui est contenu « sous le capot », c’est mieux.

Et maintenant, étant loin d'être étudiant, je tiens à dire ce qui suit à la fraternité étudiante :

• Soyez de bonne humeur!

Essayez d'écrire du code, même si c'est mauvais au début. En programmation, comme dans toute autre activité, le plus difficile est le début. Et il vaut mieux commencer plus tôt : si vous êtes un scientifique ou même juste un technicien, tôt ou tard vous aurez besoin de cette compétence.

• Demande!

Exigez des approches et des outils progressistes de la part des enseignants et des superviseurs. Si c'est possible, bien sûr...

• Sois créatif!

Où est-il préférable de guérir tous les bobos d'un débutant, si ce n'est dans le cadre d'un programme pédagogique ? Créez et perfectionnez vos compétences – encore une fois, plus tôt vous commencerez, mieux ce sera.

Aspirants programmeurs de tous les pays, unissez-vous !

PS

Afin d'enregistrer ma relation directe avec les étudiants, je joins une photo mémorable de 2017 avec deux recteurs : Peter Scharff (à droite) et Albert Kharisovich Gilmutdinov (à gauche).

Cela valait la peine de terminer le programme au moins pour ces costumes ! (blague)

Source: habr.com