Il mio articolo di oggi è il pensiero ad alta voce di una persona che ha intrapreso la strada della programmazione quasi per caso (anche se in modo naturale).

Sì, capisco che la mia esperienza è solo la mia esperienza, ma mi sembra che si adatti bene alla tendenza generale. Inoltre, l'esperienza descritta di seguito si riferisce più al campo dell'attività scientifica, ma che diavolo non sto scherzando: può essere utile all'esterno.

Fonte: https://xkcd.com/664/

In generale, dedicato a tutti gli attuali studenti di un ex studente!

aspettative

Quando ho conseguito la laurea triennale in Tecnologie dell’infocomunicazione e sistemi di comunicazione nel 2014, non sapevo quasi nulla del mondo della programmazione. Sì, come molti altri, ho seguito la materia "Informatica" al primo anno - ma, Signore, era al primo anno! È passata un'eternità!

In generale non mi aspettavo nulla di particolarmente diverso da una laurea triennale, e quando sono entrato nel programma magistrale "Comunicazione ed elaborazione del segnale" Istituto russo-tedesco di nuove tecnologie.

Ma invano...

Eravamo solo alla seconda assunzione, e i ragazzi della prima stavano ancora facendo le valigie per la lontana Germania (lo stage dura sei mesi al secondo anno di master). In altre parole, nessuno della cerchia ristretta aveva ancora incontrato seriamente i metodi dell'educazione europea, e non c'era nessuno a cui chiedere i dettagli.

Nel nostro primo anno, ovviamente, abbiamo avuto vari tipi di pratiche, in cui di solito ci veniva offerta democraticamente una scelta tra scrivere script (principalmente nel linguaggio MATLAB) e utilizzare varie GUI altamente specializzate (nel senso che senza scrivere script - simulazione ambienti di modellazione).

Inutile dire che noi, futuri Master of Science, a causa della nostra stupidità giovanile, abbiamo evitato di scrivere codici come il fuoco. Ecco, ad esempio, Simulink di MathWorks: qui ci sono i blocchi, qui ci sono le connessioni, qui ci sono tutti i tipi di impostazioni e interruttori.

Una visione nativa e comprensibile per una persona che ha precedentemente lavorato nella progettazione di circuiti e nell'ingegneria dei sistemi!

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

Così ci è sembrato...

realtà

Uno dei lavori pratici del primo semestre è stato lo sviluppo di un ricetrasmettitore di segnale OFDM come parte dell'argomento "Metodi di modellazione e ottimizzazione". L'idea ha molto successo: la tecnologia è ancora attuale e molto popolare grazie al suo utilizzo, ad esempio, nelle reti Wi-Fi e LTE/LTE-A (sotto forma di OFDMA). Questa è la cosa migliore per i maestri per mettere in pratica le proprie abilità nella modellazione di sistemi di telecomunicazioni.

E ora ci vengono date diverse opzioni di specifiche tecniche con parametri di frame ovviamente poco pratici (per non cercare una soluzione su Internet), e ci avventiamo sul già citato Simulink... E veniamo colpiti in testa con una teiera della realtà:

• Ogni blocco è pieno di molti parametri sconosciuti, che è spaventoso modificare in un batter d'occhio.
• Le manipolazioni con i numeri devono essere fatte, a quanto pare, semplici, ma devi comunque agitarti, Dio non voglia.
• Le macchine cattedrale rallentano notevolmente a causa dell'uso frenetico della GUI, anche nella fase di navigazione tra le librerie di blocchi disponibili.
• Per finire qualcosa a casa, devi avere lo stesso Simulink. E, in effetti, nessuna alternativa.

Sì, alla fine, ovviamente, abbiamo completato il progetto, ma lo abbiamo completato con una forte espirazione di sollievo.

Passò un po' di tempo e arrivammo alla fine del primo anno di laurea magistrale. La quantità di compiti a casa che utilizzano le GUI ha cominciato a diminuire proporzionalmente all’aumento della percentuale di materie tedesche, sebbene non si fosse ancora arrivati ​​​​al punto di un cambiamento di paradigma. Molti di noi, me compreso, superando la nostra considerevole ampiezza di costruire, hanno utilizzato sempre di più Matlab nei nostri progetti scientifici (anche se sotto forma di Toolbox), e non l'apparentemente familiare Simulink.

Il punto nei nostri dubbi era la frase di uno degli studenti del secondo anno (a quel tempo erano appena tornati in Russia):

• Dimenticatevi, almeno per la durata dello stage, di Similink, MathCad e altri LabView: oltretutto è tutto scritto in MATLAB, utilizzando MatLab stesso o la sua “versione” gratuita Octave.

L'affermazione si è rivelata in parte vera: a Ilmenau anche la disputa sulla scelta degli strumenti non è stata del tutto risolta. È vero, la scelta era principalmente tra MATLAB, Python e C.

Lo stesso giorno sono stato preso da un’eccitazione naturale: non dovrei trasferire la mia parte del modello del trasmettitore OFDM in una forma scritta? Solo per divertimento.

E devo lavorare.

Passo dopo passo

Invece di calcoli teorici, fornirò semplicemente un collegamento a questo articolo eccellente 2011 da tgx e sulle diapositive Strato fisico LTE professore Michel-Tila (TU Ilmenau). Penso che questo sarà sufficiente.

“Allora”, ho pensato, “ripetiamo, cosa modelleremo?”
Faremo il modello Generatore di frame OFDM (Generatore di frame OFDM).

Cosa includerà:

• simboli di informazione
• segnali pilota
• zeri (DC)

Da cosa (per semplicità) astraiamo:

• dal modellare un prefisso ciclico (se conosci le basi, aggiungerlo non sarà difficile)

Schema a blocchi del modello in esame. Ci fermeremo al blocco FFT inverso (IFFT). Per completare il quadro, ognuno può continuare il resto da solo: ho promesso agli insegnanti del dipartimento di lasciare qualcosa per gli studenti.

Definiamoli da soli. esercizio:

• numero fisso di sottoportanti;
• lunghezza del telaio fissa;
• dobbiamo aggiungere uno zero al centro e una coppia di zeri all'inizio e alla fine del fotogramma (totale, 5 pezzi);
• i simboli di informazione sono modulati utilizzando M-PSK o M-QAM, dove M è l'ordine di modulazione.

Cominciamo con il codice.

L'intero script può essere scaricato da collegamento.

Definiamo i parametri di input:

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

Ora determiniamo gli indici dei simboli di informazione, accettando la premessa che i segnali pilota debbano necessariamente andare prima e/o dopo gli zeri:

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

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

Quindi le posizioni possono essere determinate utilizzando la funzione spazio di lino, riducendo i valori al più piccolo degli interi più vicini:

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

Aggiungiamo indici di zeri a questo e ordiniamo:

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

Di conseguenza, gli indici del segnale pilota sono tutto il resto:

%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); 

Ora comprendiamo i segnali pilota.

Abbiamo un modello (variabile piloti), e diciamo che vogliamo che i piloti di questo modello vengano inseriti nel nostro frame in sequenza. Naturalmente, questo può essere fatto in un ciclo. Oppure puoi giocare un po' con le matrici: fortunatamente MATLAB ti consente di farlo con sufficiente comodità.

Innanzitutto, determiniamo quanti di questi modelli si adattano completamente alla cornice:

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

Successivamente, formiamo un vettore composto dai nostri modelli:

% 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

E definiamo un piccolo vettore che contiene solo un pezzo del modello - la "coda", che non si adatta completamente alla cornice:

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

Otteniamo personaggi pilota:

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

Passiamo ai simboli informativi, ovvero formeremo un messaggio e lo moduleremo:

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 

Tutto è pronto! Assemblaggio del telaio:

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

Dovresti ottenere qualcosa del genere:

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

"Beatitudine!" — Ho pensato soddisfatto e ho chiuso il portatile. Mi ci sono volute un paio d'ore per fare tutto: scrivere codice, imparare alcune funzioni Matlab e pensare con trucchi matematici.

Quali conclusioni ho tratto allora?

Soggettivo:

• Scrivere codice è piacevole e simile alla poesia!
• Lo scripting è il metodo di ricerca più conveniente per il campo della comunicazione e dell'elaborazione del segnale.

Obbiettivo:

• Non è necessario sparare ai passeri da un cannone (a meno che, ovviamente, non ne valga la pena un simile obiettivo educativo): utilizzando Simulink, abbiamo deciso di risolvere un semplice problema con uno strumento sofisticato.
• La GUI è buona, ma capire cosa è contenuto "sotto il cofano" è migliore.

E ora, lungi dall’essere uno studente, voglio dire quanto segue alla confraternita studentesca:

• Essere di buon umore!

Prova a scrivere il codice, anche se all'inizio è pessimo. Nella programmazione, come in ogni altra attività, la parte più difficile è l'inizio. Ed è meglio iniziare prima: se sei uno scienziato o anche solo un tecnico, prima o poi avrai bisogno di questa abilità.

• Richiesta!

Richiedere approcci e strumenti progressisti da parte di insegnanti e supervisori. Se questo è possibile, ovviamente...

• Essere creativo!

Dove altro è meglio superare tutte le piaghe di un principiante, se non nell'ambito di un programma educativo? Crea e affina le tue abilità: ancora una volta, prima inizi, meglio è.

Aspiranti programmatori di tutti i paesi, unitevi!

PS

Per documentare il mio rapporto diretto con gli studenti, allego una foto memorabile del 2017 con due rettori: Peter Scharff (a destra) e Albert Kharisovich Gilmutdinov (a sinistra).

Valeva la pena finire il programma almeno per questi costumi! (prendere in giro)

Fonte: habr.com