Mi artículo de hoy es un pensamiento en voz alta de una persona que tomó el camino de la programación casi por accidente (aunque de forma natural).

Sí, entiendo que mi experiencia es sólo mi experiencia, pero me parece que encaja bien en la tendencia general. Además, la experiencia que se describe a continuación se relaciona más con el campo de la actividad científica, pero qué diablos no es broma: puede resultar útil en el exterior.

Fuente: https://xkcd.com/664/

En general, ¡dedicado a todos los alumnos actuales de un ex alumno!

Las expectativas

Cuando completé mi licenciatura en Tecnologías de la Infocomunicación y Sistemas de Comunicación en 2014, no sabía casi nada sobre el mundo de la programación. Sí, como muchos otros, tomé la asignatura “Informática” en mi primer año - ¡pero, Señor, fue en mi primer año! ¡Ha sido una eternidad!

En general, no esperaba nada particularmente diferente de una licenciatura, y cuando ingresé al programa de maestría "Comunicación y Procesamiento de Señales" Instituto Germano-Ruso de Nuevas Tecnologías.

Pero en vano...

Éramos sólo la segunda promoción y los chicos de la primera todavía estaban haciendo las maletas para ir a la lejana Alemania (las prácticas duran seis meses en el segundo año del máster). En otras palabras, nadie del círculo inmediato se había topado todavía seriamente con los métodos de educación europea y no había nadie a quien preguntar sobre los detalles.

En nuestro primer año, por supuesto, tuvimos varios tipos de prácticas, en las que generalmente se nos ofrecía democráticamente elegir entre escribir scripts (principalmente en el lenguaje MATLAB) y usar varias GUI altamente especializadas (en el sentido de que sin escribir scripts - simulación entornos de modelado).

No hace falta decir que nosotros, los futuros Maestros en Ciencias, debido a nuestra estupidez juvenil, evitamos escribir código como el fuego. Aquí, por ejemplo, está Simulink de MathWorks: aquí están los bloques, aquí están las conexiones, aquí hay todo tipo de configuraciones e interruptores.

¡Una vista nativa y comprensible para una persona que haya trabajado anteriormente en diseño de circuitos e ingeniería de sistemas!

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

Así nos pareció...

La realidad

Uno de los trabajos prácticos del primer semestre fue el desarrollo de un transceptor de señales OFDM como parte de la asignatura “Métodos de Modelado y Optimización”. La idea tiene mucho éxito: la tecnología sigue siendo relevante y bastante popular debido a su uso, por ejemplo, en redes Wi-Fi y LTE/LTE-A (en forma de OFDMA). Esto es lo mejor para que los maestros practiquen sus habilidades en el modelado de sistemas de telecomunicaciones.

Y ahora nos dan varias opciones de especificaciones técnicas con parámetros de marco obviamente poco prácticos (para no buscar una solución en Internet), y nos abalanzamos sobre el ya mencionado Simulink... Y nos golpean en la cabeza con una tetera. de la realidad:

• Cada bloque está plagado de muchos parámetros desconocidos, que da miedo cambiar en un abrir y cerrar de ojos.
• Las manipulaciones con números deben hacerse, al parecer, simples, pero aún así hay que preocuparse, Dios no lo quiera.
• Las máquinas Cathedral se ralentizan notablemente debido al uso frenético de la GUI, incluso en la etapa de navegación por las bibliotecas de bloques disponibles.
• Para terminar algo en casa, necesitas tener el mismo Simulink. Y, de hecho, no hay alternativas.

Sí, al final, por supuesto, completamos el proyecto, pero lo completamos con un fuerte suspiro de alivio.

Pasó un tiempo y llegamos al final del primer año del máster. La cantidad de deberes que utilizaban GUI comenzó a disminuir proporcionalmente con el aumento de la proporción de estudiantes alemanes, aunque todavía no había llegado al punto de un cambio de paradigma. Muchos de nosotros, incluyéndome a mí, superando nuestra considerable amplitud para construir, utilizamos cada vez más Matlab en nuestros proyectos científicos (aunque en forma de Cajas de Herramientas), y no el aparentemente familiar Simulink.

El punto de nuestras dudas fue la frase de uno de los estudiantes de segundo año (en ese momento acababan de regresar a Rusia):

• Olvídese, al menos durante la pasantía, de Similink, MathCad y otros LabView: al final, todo está escrito en MATLAB, utilizando el propio MatLab o su “versión” gratuita Octave.

La afirmación resultó ser parcialmente cierta: en Ilmenau el conflicto sobre la elección de las herramientas tampoco se resolvió del todo. Es cierto que la elección fue principalmente entre MATLAB, Python y C.

Ese mismo día, me invadió una emoción natural: ¿no debería transferir mi parte del modelo del transmisor OFDM a un formato escrito? Solo por diversión.

Y me puse manos a la obra.

Paso a paso

En lugar de cálculos teóricos, simplemente daré un enlace a este excelente articulo 2011 desde tgx y en las diapositivas capa física LTE profesores michel-tila (TU Ilmenau). Creo que esto será suficiente.

“Entonces”, pensé, “repitamos, ¿qué vamos a modelar?”
modelaremos Generador de cuadros OFDM (Generador de tramas OFDM).

Qué incluirá:

• símbolos de información
• señales piloto
• ceros (CC)

De qué (en aras de la simplicidad) abstraemos:

• desde modelar un prefijo cíclico (si conoces los conceptos básicos, agregarlo no será difícil)

Diagrama de bloques del modelo considerado. Nos detendremos en el bloque FFT inverso (IFFT). Para completar el cuadro, cada uno puede continuar con el resto por sí mismo: prometí a los profesores del departamento dejar algo para los estudiantes.

Definamos esos por nosotros mismos. ejercicio:

• número fijo de subportadoras;
• longitud fija del marco;
• debemos agregar un cero en el medio y un par de ceros al principio y al final del cuadro (en total, 5 piezas);
• Los símbolos de información se modulan utilizando M-PSK o M-QAM, donde M es el orden de modulación.

Comencemos con el código.

El script completo se puede descargar desde enlace.

Definamos los 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

Ahora determinamos los índices de los símbolos de información, aceptando la premisa de que las señales piloto necesariamente deben ir antes y/o después de los ceros:

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

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

Entonces las posiciones se pueden determinar usando la función espacio lineal, reduciendo los valores al menor de los enteros más cercanos:

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

Agreguemos índices de ceros a esto y ordenemos:

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

En consecuencia, los índices de señales piloto son todo lo demás:

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

Ahora comprendamos las señales piloto.

Disponemos de una plantilla (variable pilotos), y digamos que queremos que los pilotos de esta plantilla se inserten en nuestro marco de forma secuencial. Por supuesto, esto se puede hacer en bucle. O puede jugar un poco con las matrices; afortunadamente, MATLAB le permite hacerlo con suficiente comodidad.

Primero, determinemos cuántas de estas plantillas encajan completamente en el marco:

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

A continuación, formamos un vector que consta de nuestras plantillas:

% 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

Y definimos un pequeño vector que contiene solo una parte de la plantilla: la "cola", que no encaja completamente en el marco:

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

Obtenemos personajes piloto:

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

Pasemos a los símbolos de información, es decir, formaremos un mensaje y lo 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 

¡Todo está listo! Montaje del marco:

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

Deberías obtener algo como esto:

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

"¡Dicha!" — Pensé contento y cerré la laptop. Me tomó un par de horas hacer todo: incluso escribir código, aprender algunas funciones de Matlab y pensar en trucos matemáticos.

¿Qué conclusiones saqué entonces?

Subjetivo:

• ¡Escribir código es agradable y parecido a la poesía!
• El scripting es el método de investigación más conveniente para el campo de la comunicación y el procesamiento de señales.

Objetivo:

• No es necesario disparar a los gorriones con un cañón (a menos que, por supuesto, ese objetivo educativo valga la pena): utilizando Simulink, nos propusimos resolver un problema simple con una herramienta sofisticada.
• La GUI es buena, pero es mejor comprender lo que contiene "debajo del capó".

Y ahora, lejos de ser estudiante, quiero decirle a la fraternidad estudiantil lo siguiente:

• ¡Tened ánimo!

Intente escribir código, incluso si al principio no es bueno. En la programación, como en cualquier otra actividad, la parte más difícil es el comienzo. Y es mejor empezar antes: si eres científico o simplemente un aficionado a la tecnología, tarde o temprano necesitarás esta habilidad.

• ¡Demanda!

Exigir enfoques y herramientas progresistas a profesores y supervisores. Si esto es posible, por supuesto...

• ¡Ser creativo!

¿Dónde más es mejor curar todas las llagas de un principiante, si no en el marco de un programa educativo? Crea y perfecciona tus habilidades. Una vez más, cuanto antes empieces, mejor.

Aspirantes a programadores de todos los países, ¡únanse!

PS

Para dejar constancia de mi relación directa con los estudiantes, adjunto una foto memorable de 2017 con dos rectores: Peter Scharff (a la derecha) y Albert Kharisovich Gilmutdinov (a la izquierda).

¡Valió la pena terminar el programa al menos con estos disfraces! (bromear)

Fuente: habr.com