Meu artigo de hoje traz pensamentos em voz alta de uma pessoa que seguiu o caminho da programação quase por acidente (embora naturalmente).

Sim, entendo que a minha experiência é apenas a minha experiência, mas parece-me que se enquadra bem na tendência geral. Além disso, a experiência descrita a seguir refere-se mais ao campo da atividade científica, mas que diabos não é brincadeira - pode ser útil lá fora.

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

Em geral, dedicado a todos os alunos atuais de um ex-aluno!

Expectativas

Quando concluí meu bacharelado em Tecnologias de Infocomunicação e Sistemas de Comunicação em 2014, não sabia quase nada sobre o mundo da programação. Sim, como muitos outros, fiz a disciplina “Ciência da Computação” no primeiro ano - mas, Senhor, foi no primeiro ano! Já faz uma eternidade!

Em geral, não esperava nada de particularmente diferente de um bacharelado, e quando entrei no mestrado "Comunicação e Processamento de Sinais" Instituto Alemão-Russo de Novas Tecnologias.

Mas em vão...

Éramos apenas o segundo aluno, e os caras do primeiro ainda estavam fazendo as malas para a distante Alemanha (o estágio dura seis meses no segundo ano do mestrado). Por outras palavras, ninguém do círculo imediato tinha ainda conhecido seriamente os métodos da educação europeia e não havia ninguém a quem perguntar sobre os detalhes.

Em nosso primeiro ano, é claro, tivemos vários tipos de práticas, nas quais geralmente nos era oferecida democraticamente a escolha entre escrever scripts (principalmente na linguagem MATLAB) e usar várias GUIs altamente especializadas (no sentido de que sem escrever scripts - simulação ambientes de modelagem).

Escusado será dizer que nós, os futuros Mestres da Ciência, devido à nossa estupidez juvenil, evitámos escrever código como fogo. Aqui, por exemplo, está o Simulink do MathWorks: aqui estão os blocos, aqui estão as conexões, aqui estão todos os tipos de configurações e interruptores.

Uma visão nativa e compreensível para quem já trabalhou em projeto de circuitos e engenharia de sistemas!

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

Assim nos pareceu...

Realidade

Um dos trabalhos práticos do primeiro semestre foi o desenvolvimento de um transceptor de sinal OFDM no âmbito da disciplina “Métodos de Modelação e Otimização”. A ideia dá muito certo: a tecnologia ainda é relevante e bastante popular devido ao seu uso, por exemplo, em redes Wi-Fi e LTE/LTE-A (na forma de OFDMA). Esta é a melhor coisa para os mestres praticarem suas habilidades na modelagem de sistemas de telecomunicações.

E agora nos são dadas várias opções de especificações técnicas com parâmetros de frame obviamente impraticáveis ​​​​(para não procurar solução na Internet), e atacamos o já mencionado Simulink... E levamos uma pancada na cabeça com um bule de chá da realidade:

• Cada bloco está repleto de muitos parâmetros desconhecidos, que são assustadores de mudar num piscar de olhos.
• As manipulações com números precisam ser feitas, ao que parece, simples, mas ainda é preciso se preocupar, Deus me livre.
• As máquinas Cathedral ficam visivelmente mais lentas com o uso frenético da GUI, mesmo na fase de navegação pelas bibliotecas de blocos disponíveis.
• Para finalizar algo em casa, você precisa ter o mesmo Simulink. E, de fato, não há alternativas.

Sim, no final, é claro, concluímos o projeto, mas o concluímos com uma forte exalação de alívio.

Algum tempo se passou e chegamos ao final do primeiro ano do mestrado. A quantidade de trabalhos de casa utilizando GUIs começou a cair proporcionalmente com o aumento da proporção de sujeitos alemães, embora ainda não tivesse atingido o ponto de uma mudança de paradigma. Muitos de nós, inclusive eu, superando nossa considerável amplitude de construção, usamos cada vez mais o Matlab em nossos projetos científicos (embora na forma de caixas de ferramentas), e não o aparentemente familiar Simulink.

O ponto de nossas dúvidas foi a frase de um dos alunos do segundo ano (eles já haviam acabado de voltar para a Rússia):

• Esqueça, pelo menos durante o estágio, Similink, MathCad e outros LabView - acima da colina tudo é escrito em MATLAB, usando o próprio MatLab ou sua “versão” gratuita Octave.

A afirmação revelou-se parcialmente verdadeira: em Ilmenau, a disputa sobre a escolha das ferramentas também não foi totalmente resolvida. É verdade que a escolha foi principalmente entre MATLAB, Python e C.

No mesmo dia, fui tomado por uma excitação natural: não deveria transferir minha parte do modelo do transmissor OFDM para um formato roteirizado? Apenas por diversão.

E comecei a trabalhar.

Passo a passo

Em vez de cálculos teóricos, simplesmente darei um link para este excelente artigo 2011 de tgx e nos slides Camada física LTE professores Michel Tila (TU Ilmenau). Acho que isso será suficiente.

“Então”, pensei, “vamos repetir, o que vamos modelar?”
Nós vamos modelar Gerador de quadros OFDM (gerador de quadros OFDM).

O que incluirá:

• símbolos de informação
• sinais piloto
• zeros (DC)

Do que (por uma questão de simplicidade) abstraímos:

• da modelagem de um prefixo cíclico (se você conhece o básico, não será difícil adicioná-lo)

Diagrama de blocos do modelo em consideração. Pararemos no bloco FFT inverso (IFFT). Para completar, cada um pode continuar o resto - prometi aos professores do departamento deixar algo para os alunos.

Vamos defini-los para nós mesmos. exercício:

• número fixo de subportadoras;
• comprimento fixo do quadro;
• devemos adicionar um zero no meio e um par de zeros no início e no final do quadro (total, 5 peças);
• os símbolos de informação são modulados usando M-PSK ou M-QAM, onde M é a ordem de modulação.

Vamos começar com o código.

O script completo pode ser baixado em link.

Vamos definir os parâmetros de entrada:

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

Agora determinamos os índices dos símbolos de informação, aceitando a premissa de que os sinais piloto devem necessariamente ir antes e/ou depois dos zeros:

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

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

Então as posições podem ser determinadas usando a função espaço de linha, reduzindo os valores ao menor dos inteiros mais próximos:

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

Vamos adicionar índices de zeros a isso e classificar:

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

Conseqüentemente, os índices do sinal piloto são todo o 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); 

Agora vamos entender os sinais piloto.

Temos um modelo (variável pilotos), e digamos que queremos que os pilotos deste modelo sejam inseridos em nosso quadro sequencialmente. Claro, isso pode ser feito em loop. Ou você pode brincar um pouco com matrizes - felizmente, o MATLAB permite que você faça isso com conforto suficiente.

Primeiro, vamos determinar quantos desses modelos cabem completamente no quadro:

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

A seguir, formamos um vetor que consiste em nossos modelos:

% 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 definimos um pequeno vetor que contém apenas um pedaço do modelo - a “cauda”, que não cabe completamente no quadro:

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

Temos personagens piloto:

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

Passemos aos símbolos de informação, ou seja, formaremos uma mensagem e a modularemos:

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 

Tudo está pronto! Montagem da moldura:

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

Você deve obter algo assim:

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

"Bênção!" — pensei contente e fechei o laptop. Levei algumas horas para fazer tudo: incluindo escrever código, aprender algumas funções do Matlab e pensar em truques matemáticos.

Que conclusões tirei então?

Subjetivo:

• Escrever código é agradável e semelhante à poesia!
• Scripting é o método de pesquisa mais conveniente para a área de Comunicação e Processamento de Sinais.

Objetivo:

• Não há necessidade de atirar em pardais com um canhão (a menos que tal objetivo educacional valha a pena): usando o Simulink, resolvemos um problema simples com uma ferramenta sofisticada.
• A GUI é boa, mas entender o que está contido “nos bastidores” é melhor.

E agora, longe de ser estudante, quero dizer o seguinte à fraternidade estudantil:

• Desafio!

Tente escrever código, mesmo que seja ruim no início. Na programação, como em qualquer outra atividade, o mais difícil é o começo. E é melhor começar mais cedo: se você é um cientista ou apenas um técnico, mais cedo ou mais tarde precisará dessa habilidade.

• Demanda!

Exija abordagens e ferramentas progressivas de professores e supervisores. Se isso for possível, é claro...

• Seja criativo!

Onde mais é melhor superar todas as feridas de um iniciante, senão no âmbito de um programa educacional? Crie e aprimore suas habilidades – mais uma vez, quanto mais cedo você começar, melhor.

Aspirantes a programadores de todos os países, uni-vos!

PS

Para registrar minha relação direta com os alunos, anexo uma foto memorável de 2017 com dois reitores: Peter Scharff (à direita) e Albert Kharisovich Gilmutdinov (à esquerda).

Valeu a pena terminar o programa pelo menos por essas fantasias! (brincando)

Fonte: habr.com