Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITUR P.452

Equation Chapter 1 Section 1 Dpto. Teoría de la Señal y Comunicaciones Escuela Técnica Superior de Ingeniería Universidad de Sevilla Trabajo Fin de GradoSevilla Grado en Ingeniería de las Tecnologías de Telecomunicación Sevilla, 2020 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 Autor: Lázaro Rodríguez Márquez Tutor: Susana Hornillo Mellado ii iii Proyecto Fin de Carrera Ingeniería de Telecomunicación Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU- R P.452 Autor: Lázaro Rodríguez Márquez Tutor: Susana Hornillo Mellado Profesor titular Dpto. de Teoría de la Señal y Comunicaciones Escuela Técnica Superior de Ingeniería Universidad de Sevilla Sevilla, 2020 iv v Proyecto Fin de Carrera: Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 Autor: Lázaro Rodríguez Márquez Tutor: Susana Hornillo Mellado El tribunal nombrado para juzgar el Proyecto arriba indicado, compuesto por los siguientes miembros: Presidente: Vocales: Secretario: Acuerdan otorgarle la calificación de: Sevilla, 2020 El Secretario del Tribunal vi vii A mi familia y amigos A mis maestros viii ix Agradecimientos Me gustaría aprovechar estas líneas para agradecer a todas aquellas personas que de un modo u otro han contribuido en el desarrollo y finalización en este duro y largo camino. A mi familia, por todo el sacrificio realizado para que yo tuviera la oportunidad de estudiar una carrera universitaria. A mis amigos, un apoyo incondicional, que, en los momentos mas difíciles en los que ni yo confiaba en mi, me alentaban a continuar sin excepción. A mis compañeros de clase y estudio, amigos también, por que sin ellos el camino habría sido mucho mas duro. A mis profesores, por toda la ayuda aportada y por todo lo que me han enseñado. Mención especial para Susana Hornillo, quien ha compartido todos sus conocimientos y me ha guiado en este proyecto. Lázaro Rodríguez Márquez Sevilla, 2020 xvi 3.3.2. Funcionalidad 15 3.3.3. Datos SRTM 16 4 Funcionamieno del programa 19 4.1. Pestaña principal 19 4.2. Pestaña secundaria o de gráficas 22 4.3. Ventanas emergentes de Warnings 24 4.4. Programa Python 28 4.4.1. Fichero programa.py 28 4.4.2. Fichero menu.py 28 4.4.3. Fichero funciones.py 30 5 Casos prácticos y comparación de resultados 31 5.1. Caso 1 31 5.2. Caso 2 34 6 Conclusiones y futuras lineas de trabajo 39 Apéndice A 41 Código fuente 41 Referencias 61 Índice de Códigos 63 Glosario 65 xvii Índice de Tablas Tabla 4.1 Alturas y distancias nominales de la ocupación del suelo 21 xviii xix Índice de Figuras Figura 2-1. Espectro elecromagnético 5 Figura 2-2. Transmisor isotrópico 6 Figura 2-3. Caminos de propagación 6 a) Rayo directo y reflexión desde la superficie de la tierra. 6 b) Onda ionosférica. 6 c) Onda de superficie. 6 Figura 2-4. Mecanismos de propagación de la interferencia (I) [1]. 7 Figura 2-5. Mecanismos de propagación de la interferencia (II) [1]. 8 Figura 3-1. Ejemplo ventana TkInter 15 Figura 3-2. Ejemplo de uso de Pycraf 16 Figura 3-3. Resultados ejemplo Pycraf 16 Figura 4-1. Ventana principal 20 Figura 4-2. Ayuda para el parámetro "ht" 20 Figura 4-3. Desplegable para activar el cuadro de texto 21 Figura 4-4. Pestaña de gráficas 22 Figura 4-5. Ejemplo de gráficas 23 Figura 4-6. Ventana de selcción de formatode las gráficas 23 Figura 4-7. Warning debido a campos sin rellenar 24 Figura 4-8. Warning debido a los parámetros geográficos 25 Figura 4-9. Warning debido al parámetro "d" fuera de rango 25 Figura 4-10. Warning debido al parámetro "f" fuera de rango 26 Figura 4-11. Warning debido a no elegir una opción en la ocupacion del suelode la estación interferida 26 Figura 4-12. Warning en la pestaña de gráficas (I) 27 xx Figura 4-13. Warning en la pestaña de gráficas (II) 27 Figura 4-14. Warning en la pestaña de gráficas (III) 28 Figura 5-1. Enlace caso 1 31 Figura 5-2. Perfil del trayecto caso 1 32 Figura 5-3. Datos de entrada para el caso 1 32 Figura 5-4. Resultado caso 1 32 Figura 5-5. Módulo Pycraf para el caso 1 33 Figura 5-6. Resultado de la simulación con el módulo Pycraf para el caso 1 33 Figura 5-7. Gráfica caso 1 34 Figura 5-8. Enlace caso 2 35 Figura 5-9. Perfil del trayecto caso 2 35 Figura 5-10. Datos de entrada para el caso 2 36 Figura 5-11. Resultado caso 2 36 Figura 5-12. Módulo Pycraf para el caso 2 37 Figura 5-13. Resultado de la simulación con el módulo Pycraf para el caso 2 37 Figura 5-14. Gráfica caso 2 38 xxi Notación EM Electromagnetismo p Porcentaje de tiempo requerido durante el cual no se rebasa la pérdida básica de transmisión pw Pérdidas básicas de transmisión para el porcentaje de tiempo del mes más desfavorable β0 Porcentaje de tiempo en el que pueden esperarse sobretasas de la variación de la refracción en la atmosfera inferior e Número e k50 Factor del valor mediano del radio efectivo de la Tierra kβ Factor del radio efectivo de la Tierra excedido durante el β0 % del tiempo N0 Refractividad de la superficie a nivel del mar ae Radio efectivo de la Tierra aβ Radio efectivo de la Tierra rebasado durante el β0 % del tiempo ΔN Proporción de variación del índice medio de refracción radioeléctrica ≤ Menor o igual ≥ Mayor o igual < Menor > Mayor ◦ Grados 1 3 1 INTRODUCCIÓN l mundo de las tecnologías y la telecomunicación ha cambiado de forma radical en los últimos 20 años. Todo empezó con las teorías de James C. Maxwell, quien sentó las bases de la propagación de ondas electromagnéticas. A partir de estos estudios se desarrolló todo lo que hoy conocemos acerca de la transmisión por radio, televisión, telefonía móvil… Por otro lado, la programación como base para el cálculo y simulación de diferentes entornos puede llegar a ser fundamental para el estudio. En este ámbito debemos mencionar el lenguaje de programación que usaremos, Python, el cual se caracteriza por su simplicidad, rapidez, flexibilidad y por su gran comunidad de desarrolladores. Es aquí donde unimos ambos conceptos, telecomunicaciones y programación, para realizar nuestro trabajo. Este tratará de simular el proceso detallado en la recomendación ITU-R P.452-16, en concreto el capitulo dedicado a los modelos de propagación en cielo despejado. Una predicción para evaluar la interferencia entre estaciones situadas en la superficie de la Tierra a frecuencias superiores a 0.1 GHz en cielo despejado. En una propagación con cielo despejado deberemos tener en cuenta: - La interferencia sufrida por otra antena con visibilidad directa. - Difracción. - Dispersión troposférica. - Interferencia debida a la propagación por conductos y reflexión en las capas. - Pérdidas adicionales debidas a la ocupación del suelo. La simulación estará compuesta por un entorno gráfico donde deberemos introducir varios parámetros iniciales para el posterior cálculo de la interferencia. E 4 4 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 11 11 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 2.4.4. Radio efectivo de la Tierra Teniendo en cuenta que vamos a suponer un radio real de la Tierra de 6371 km, el valor mediano del radio efectivo de la tierra queda determinado por: ae = 6371· k50 (2.7) donde: (2.8) Para el radio efectivo de la Tierra rebasado durante el β0% del tiempo queda determinado por: aβ = 6371 · kβ (2.9) donde kβ = 3.0. 2.4.5. Parámetros del análisis del trayecto Por último, necesitaremos una serie de parámetros resultantes del análisis del trayecto que describieremos acontinuación: • d, distancia del trayecto a lo largo del circulo máximo. • dlt y dlr, si el trayecto es transhorizonte, serán la distancia desde las antenas a sus respectivos horizontes. En el caso de que el trayecto fuese de visibilidad directa, ambos parámetros se fijaran a la distancia desde los terminales a los puntos de perfil indentificados como bordes principales. • θt y � θ r , ángulos de elevación de las antenas. • θ, distancia angular del trayecto. • hts y hrs, altura del centro de las antenas sobre el nivel del mar. • hte y hre, alturas efectivas de las antenas sobre el terreno. • db, longitud combinada de las secciones del trayecto sobre el agua. • 𝜔 , fracción del trayecto sobre el agua. • dct y dcr, distancia sobre tierra desde las antenas hasta la costa. Con todos estos datos disponibles ya podríamos calcular la interferencia producida entre dos terminales siguiendo el procedimiento descrito en la recomendación. 12 12 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 13 13 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 3 HERRAMIENTAS DE DESARROLLO l simulador está desarrollado en leguaje Python, dando uso a una de sus librerías para el entorno gráfico, TkInter, para dar al usuario mayor simplicidad y poder sacarle el mayor rendimiento posible. Este software es libre y no requiere licencia. Además, el usuario no tendrá que preocuparse por instalar nada, ya que todo lo necesario para que funcione correctamente se le proporcionará en una carpeta comprimida. 3.1 Python 3.8.2 Python es el lenguaje elegido para desarrollar el software del simulador por la legibilidad de su código. Es un lenguaje multiplataforma, dinámico e interpretado capaz de soportar una programación orientada a objetos, programación imperativa y programación funcional. La version utilizda ha sido la 3.8.2. También se han instalado paquetes y añadido librerías para dessarollar nuestro trabajo. Aquí debemos mencionar el instalador de paquetes pip que ha sido el usado para la instalacion de dichos paquetes y librerías sin tener que descargarlas por internet. Código 3.1 Ejemplo de uso del instalador de paquetes pip. pip install [package] 3.1.1 Librerías usadas Es muy común en los proyectos de programación el incluir nuevas librerías para el uso de funciones que no estén entre las predeterminadas. Para el desarrollo de nuestro proyecto hemos tenido que incorporar las siguientes: • Math, para funciones matemáticas que no incorpora Python. • NumPy, para otras funciones matemáticas y soporte de arrays. • Matplotlib, para la generación de gráficas. • Astropy, esta librería incluye muchos paquetes que son muy útiles en el ámbito de la astronomía, en nuestro caso la usasmos por su funcionalidad con las unidades. • PIL, para el uso de Widget con imágenes. E 14 14 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 • Itu676, este paquete nos proporciona diversas funciones para el cálculo de la atenuación debida a los gases. 3.2 TkInter TkInter es la biblioteca gráfica de Python usada para el desarrollo de la interfaz gráfica del proyecto. Esta facilita la construcción y configuración de ventanas con widgets. Estos widgets muestran información al usuario y les permiten interconectar con la aplicación. Ventana principal: • La creación de la ventana principal se hace con la instancia Tk(). Luego se hace la llamada a la ventana, como si fuera una función. Algunos de los elementos (widgets) más usados son: • Label, para las etiquetas de texto. • Entry, casilla para la introducción de texto o algún parámetro. • Button, para la utilización de botones a los que aplicar eventos. • OptionMenu, para seleccionar una opción entre una lista. • Frame, contenedor para otros widgets. • Checkbuttom, casillas de verificación. • Messagebox, para ventanas emergentes de información. Código 3.2 Ejemplo de ventana con widgets from tkinter import * ventana = Tk() ventana.title("Welcome to LikeGeeks app") ventana.geometry('350x200') lbl = Label(ventana, text="Hello") lbl.grid(column=0, row=0) def clicked(): lbl.configure(text="Button was clicked !!") btn = Button(ventana, text="Click Me", command=clicked) btn.grid(column=1, row=0) window.mainloop() 15 15 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 Figura 3.1. Ejemplo ventana TkInter. 3.3 Pycraf Pycraft es un paquete de Python que nos proporciona funciones y procedimientos para el cálculo de diversas tareas, entre ellas, el cálculo de la atenuación entre una fuente interferente y la estación servicio. Y es por esto último por lo que lo hemos incluido en nuestro proyecto a modo de verificación de nuestro trabajo. 3.3.1 Instalación Para el uso de este paquete hemos tenido que instalar varias bibliotecas y softwares adicionales que se complementan entre sí: • Setuptools, usada para la instalación correcta del paquete. • Cython, compilador estático. • SciPy, conjunto de librerías de código abierto para funciones matemáticas, ciencia e ingeniería. • Pytest, herramienta de testeo de la instalación del paquete Pycraf. • NumPy, Astropy y Matplotlib, ya mencionadas anteriormente. 3.3.2 Funcionalidad El uso de Pycraf es muy sencillo, una vez instalados todos los paquetes, inicializamos los datos de partida necesarios, calculamos el perfil del trayecto con la función pathprof.PathProp(), y ya podremos hacer uso de las distintas funciones para el cálculo de las diferentes atenuaciones. Los datos iniciales serán: • Latitud y longitud de ambas estaciones. • Frecuencia. • Una resolución de la altura del perfil que llamaremos, hprof_step. • Omega, w, que será la fracción del trayecto sobre el agua. • Temperatura y presión. • Porcentaje de tiempo requerido durante el cual no se rebasa la pérdida básica de transmisión, p. • Altura de las antenas sobre el nivel del suelo. 16 16 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 • Ganancia de las antenas. • Categoría de la ocupación del suelo, clutter zones. La función pathprof.PathProp() calcula el perfil del trayecto entre las dos estaciones proporcionadas, esto nos supone conocer todos los parámetros y características al detalle del trayecto, muy útil para comparar y validar datos a la hora de identificar las características de nuestro trayecto. Para el uso de las diferentes funciones de cálculo de atenuaciones será necesario el resultado del análisis proporcionado por la función pathprof.PathProp(). En la siguiente imagen tenemos un ejemplo de código de todo lo explicado hasta el momento del uso de Pycraf. Figura 3.2. Ejemplo de uso de Pycraf. Figura 3.3. Resultados ejemplo Pycraf. 3.3.3 Datos SRTM Llegados a este punto debemos destacar la línea 3 del código de la figura 3.2. Esta es la causante del uso de los datos SRTM, pero ¿qué son estos datos y para qué sirven? En la complejidad del cálculo de la interferecia encontramos un problema, necesitamos datos 17 17 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 cartográficos para el análisis del trayecto y la generación del perfil de altura, estos son los datos SRTM. El programa descarga los datos necesarios automáticamente con dicha línea de código (línea 3). Estos archivos tienen extensión .htg y se descargan en el mismo directorio donde se encuentra el código fuente del programa. Están nombrados de una manera muy simple, el primer carácter es una “N” (norte) o “S” (sur) que indica si el siguiente número es una latitud positiva o negativa. De la misma forma, el cuarto carácter, es una “W” (oeste) o “E” (este) e indica si la longitud es positiva o negativa. Un ejemplo del formato de estos datos podría ser: N50W006.htg. 18 18 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 19 19 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 4 FUNCIONAMIENO DEL PROGRAMA n este capítulo vamos a describir el funcionamiento de nuestro software así como el código usado para el desarrollo de este. El simulador se basa en una sencilla interfaz gráfica para interactuar con el usuario. 4.1 Pestaña principal Para iniciar la aplicación, será necesario ejecutar el siguiente código por línea de comando una vez estemos en el directorio donde tengamos nuestro código fuente, usando el comando “cd” para cambiar de carpeta: Código 4.1 Comando para iniciar la aplicación cd programa python programa.py Una vez iniciado el programa nos aparecerá una ventana emergente con dos pestañas, la primera la llamaremos pestaña principal, en la que podremos meter los datos iniciales necesarios y elegir algunas opciones para calcular correctamente la interferencia. Esta ventana tiene un tamaño de 950x450 px ajustable a gusto del usuario. Esta programado con este tamaño ya que es el mínimo para tener una buena visión de todos los campos existentes en la ventana. La pestaña principal podríamos decir que está dividida en dos secciones por el símbolo “||”. La primera, la parte izquierda, a su vez dividida en dos columnas, está dedicada a todos los parámetros que debemos introducir por cuadro de texto (widget “Entry”). Cada parámetro tiene su nombre, la unidad en la que trabajaremos con dicho parámetro, entre paréntesis, y un botón señalizado con una “?” que hace referencia a una pequeña explicacion del parámetro, es lo que llamaremos un botón de ayuda. E 20 20 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 Figura 4.1. Ventana principal. Figura 4.2. Ayuda para el parámetro “ht”. En cuanto a la parte derecha, está dedicada a la ocupación del suelo. En este caso hemos usado dos desplegables para que el usuario elija entre las diferentes opciones, dentro de las cuales está la de introducir el parámetro por cuadro de texto. En este caso el botón de ayuda proporcionado no ejecutará un cuadro de diálogo del tipo menssagebox(), sino más bien una foto explicativa, ya que es mucho más gráfico y fácil de entender. La foto emergente contiene la siguiente tabla: 27 27 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 Figura 4.12. Warning en la pestaña de graficas (I). Figura 4.13. Warning en la pestaña de graficas (II). 28 28 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 Figura 4.14. Warning en la pestaña de graficas (III). 4.4 Programa Python Python es un lenguaje de programación muy potente y usado en la actualidad, con un gran crecimiento a nivel mundial, caracterizado por una gran flexibilidad y claridad que favorece a un código legible. Cuenta con una gran cantidad de librerías muy completas, ideales para implementar fórmulas y algoritmos matemáticos que nos facilitan la elaboración de programas. 4.4.1 Fichero programa.py Este fichero marca el inicio de nuestro programa. Únicamente contiene la creación de la interfaz gráfica, de la cual haremos uso para introducir todos los valores iniciales, así como elegir las diferentes opciones de simulación y la llamada a una función “principal” (abrirVentana) en la que desarrollaremos el grueso de nuestro trabajo. Además, cuenta con la definición de todos los parámetros que usaremos a modo de comentario para una mayor aclaración de cada uno de ellos. 4.4.2 Fichero menu.py Contiene nuestra función principal (abrirVentana) que usaremos para desarrollar nuestra interfaz gráfica y contendrá las llamadas a las distintas funciones para la simulación seleccionada. Comenzamos importando las distintas librerías necesarias. A continuación, tenemos una línea de código muy importante, es la encargada de descargar los datos cartográficos, los anteriormente mencionados como datos SRTM. Nuestra función principal (abrirVentana()) está compuesta por varias funciones a su vez. Primero definimos unos parámetros necesarios para la interfaz gráfica, como son la geometría, el titulo o las distintas pestañas que podremos seleccionar. Funciones para usar en abrirVentana(): 1. Funciones ayuda (clicked_num(), siendo “num” un número entero del 1 al 28, ayuda1() y ayuda2()): estas funciones, las cuales llamaremos al pulsar sobre un botón de ayuda, nos permitirán conocer la definición de cada parámetro que debamos introducir en los valores iniciales. Son funciones 29 29 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 puramente informativas. En el caso de ayuda1() y ayuda2() están destinadas a la pestaña de gráficas como información de ayuda de uso. 2. Función seleccionar1() y selccionar2(): funciones cuyo uso es desbloquear o bloquear la entrada de un parámetro según la opción que hayamos elegido. Si deseamos que el valor de dicho parámetro sea uno de los valores estándar proporcionados, bloqueará la introducción del parámetro por el entorno gráfico. Si nuestra opción es introducirlo manualmente, nos desbloqueará el cuadro de entrada del parámetro. 3. Función cierraPrincipal(): función principal de la parte simulada de la propagación en cielo despejado. Lo primero que haremos será una pequeña comprobación de parámetros a modo de evitar un cuelgue del programa. Se comprobará que todos los campos de introducción de parámetros no estén vacios. Seguido, se transformarán dichos parámetros en variables para su uso en la ejecución del programa. Una vez que tenemos todos los parámetros en variables y los campos no son nulos, comprobaremos que aquellos parámetros que necesariamente tengan que estar acotados estén correctamente dentro de su rango de uso. Puesto que los últimos parámetros que comprobamos son los referentes a la ocupación del suelo y con motivo de que el código sea lo mas claro y legible posible, el primer cálculo que haremos será el de las pérdidas adicionales por la ocupación del suelo, así todo el código referente a esto estará seguido y en la misma sección. La siguiente sección de código viene referida a la difracción, donde le daremos uso al paquete Pycraf ya descrito anteriormente. Inicializamos párametros, llamamos a la función pathprof.PathProp() para analizar el trayecto y de esta forma podremos calcular la difracción con la función implementada en la librería pathprof.loss_diffraction(). Una vez llegados a este punto, calcularemos algunos parámetros necesarios para continuar con nuestra simulación como son el radio efectivo de la tierra, los parámetros mu_x (siendo x un valor del 1-4), beta_0 o la corrección por la rugosidad del terreno. Con todos los parámetros ya calculados, hacemos las llamadas a las distintas funciones que nos calcularán el resto de las atenuaciones sufridas (atenuación por visibilidad directa, difracción, dispersión troposférica y por conductos y reflexión en las capas). Por último y, en cuanto a cálculos se refiere, calcularemos la interfrencia total según el procedimiento de la recomendación. 4. Función cierraSecundaria(): esta función tiene como único objetivo cerrar el programa. 5. Función grafica1(): esta función genera una gráfica que representa la pérdida de transmisión básica debida a la propagación en espacio libre en función de la frecuencia. Primero se comprueba que los campos no estén vacíos y que los parámetros de entrada no estén fuera de rango. Una vez hecha las comprobaciones pertinentes se ejecuta el código necesario para a representación de la gráfica. 6. Función grafica2(): esta función genera una gráfica que representa la pérdida de transmisión básica debida a la propagación en espacio libre en función de la distancia. Al igual que en la función anterior, se comprueba que los campos no estén vacíos, que los parámetros de entrada no estén fuera de rango y se ejecuta el código necesario para a representación gráfica. 7. Todo el código restante pertenece a la creación, configuración y uso de los distintos widgets para la representación de nuestra interfaz gráfica. Para la creación de las etiquetas de texto hemos usado el widget Label() que se complementa junto con el widget Entry() y formaremos cada linea de parámetros de entrada. El formato sería: • Label – Entry – Label. Lo que equivale en el entorno gráfico al nombre del parámetro, cuadro de introducción de texto y unidad del parámetro. 30 30 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 Además de estos widgets, hay que añadirles el Buttom(), con “?” como texto de botón, al que le adjudicaremos cada función de ayuda. Para la parte derecha de la pestaña principal, aparte de los widgets Label() y Entry(), ya mencionados anteriormente, hemos hecho uso del elemento OptionMenu() para la creación de las dos listas de opciones que proporcionamos. En cuanto a la pestaña de Gráficas, debemos comentar que los widgets usados son los mismos descritos anteriormente, Label() para las etiquetas de texto, Entry() para los campos con cuadro de texto y Button() para la asignación de eventos. 4.4.3 Fichero funciones.py Este fichero contiene todas aquellas funciones que debemos ir usando para el desarrollo de nuestro programa. Las agrupamos en otro fichero para una mayor organización y comprensión del código. Como en todos los ficheros anteriores, lo primero es añadir las distintas librerías y paquetes que usemos. Funciones disponibles: 1. calcula_beta (lat_c, mu_1, mu_4): función que calcula la “beta_0” a partir de la latitud del centro de trayecto y de dos parámetros calculados al inicio de cierraPrincipal(). Este parámetro es muy importante y tendrá una gran influencia en la simulación. 2. calcula_absorcion_gaseosa(f, d, rho): función que nos permite calcular la absorción gaseosa dada una frecuencia, la distancia del trayecto y la densidad de vapor de agua. Esta función a su vez, usa una función contenida en una de las librerías de la ITU-R, importadas para el cálculo total de la absorción gaseosa (itur.models.itu676.gamma_exact(f, P, rho, T), siendo “P” la presión atmosférica y “T” la temperatura). 3. calcula_propagacion_visibilidad_directa(p_o_beta, f, w, d, d_lt, d_lr): función que calcula la interferencia producida por una antena con la que comparte visibilidad directa. Esta función depende del primer argumento que le pasemos, “p” (% de tiempo requerido durante el cual no se rebasa la perdida básica de transmisión) o “beta”. Los parámetros siguientes requeridos respectivamente son la frecuencia, la fracción del trayecto total sobre el agua, la distancia del trayecto a lo largo del círculo máximo y la distancia desde las antenas de transmisión y recepción a sus respectivos horizontes. 4. calcula_dispersion_troposferica(d, f, G_t, G_r, teta, p, N0): función que nos permite calcular las pérdidas básicas de transmisión debida a la dispersión troposférica. Dicha función usa como argumentos de entrada la distancia del trayecto a lo largo del círculo máximo, la frecuencia, la ganancia de ambas antenas, la distancia angular del trayecto, p (parámetro comentado anteriormente) y la refractividad de la superficie a nivel del mar. 5. calcula_propagacion_conductos_reflexion(d_lt, d_lr, f, teta_t, teta_r, w, d_ct, d_cr, h_ts, h_rs, a_e, d, p, beta_0, mu_2, mu_3): esta función calcula las pérdidas básicas de transmisión debidas a la propagación por conductos y reflexión en las capas. Entre sus argumentos de entrada destacamos aquellos que no hemos mencionado con anterioridad como son: los ángulos de elevación de las antenas de transmisión y recepción respecto del horizonte (teta_t y teta_r,), distancia sobre tierra desde las antenas hasta la costa a lo largo del trayecto de círculo máximo de la interferencia (d_ct y d_cr), altura del centro de la antena interferente e interferida sobre el nivel del mar (h_ts y h_rs), el valor mediano del radio efectivo de la Tierra (a_e) y dos parámetros calculados en la función cierraPrincipal() como son mu_2 y mu_3. 31 31 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 5 CASOS PRÁCTICOS Y COMPARACIÓN DE RESULTADOS Para terminar, vamos a presentar algunos ejemplos prácticos de estaciones terrenas existentes a las que les calcularemos la interferencia sufrida y comprobaremos los resultados con el fin de asegurarnos el correcto funcionamiento de nuestro programa. Para la comprobación de resultados usaremos el paquete Pycraf. 5.1 Caso 1 En este primer caso vamos a usar una estación situada en Sevilla y vamos a suponer que queremos instalar otra estación cerca de la ciudad de Córdoba. Veremos que interferencia puden sufrir. • Sevilla: latitud = 37.345555, longitud = -5.971388 • Córdoba: latitud = 37.877222, longitud = -4.787777 Figura 5.1. Enlace caso 1. 32 32 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 Figura 5.2. Perfil del trayecto caso 1. Para este caso vamos a utilizar los datos mostrados en la Figura 5.2. Figura 5.3. Datos de entrada para el caso 1. Con estos datos de partida nuestro programa nos da un resultado de la interferencia de: Figura 5.4. Resultado caso 1. Para comprobar que nuestros resultados son correctos, vamos a usar el módulo Pycraf con los mismos datos de entrada y así verificar que nuestro resultado se asemeja a lo deseable. En la Figura 5.5 podemos 33 33 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 observar el código fuente para el uso de Pycraf que equivale al uso de nuestro software. Figura 5.5. Módulo Pycraf para el caso 1. Como resultado de este código tenemos: Figura 5.6. Resultado de la simulación con el módulo Pycraf para el caso 1. Como podemos observar, el resultado es muy similar al obtenido en nuestros cálculos. Los decimales en los que varían ambas simulaciones son prácticamente despreciables, por lo que podemos eventuar que nuestro programa simula bastante bien la interferencia sufrida en las estaciones. Como contenido adicional y usando los datos de este mismo ejemplo, hemos elaborado una gráfica con la intención de comparar los resultados al variar la frecuencia de trabajo. 34 34 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 Figura 5.7. Gráfica caso 1. Como podemos observar, la influencia de la frecuencia es muy grande, a medida que aunmentamos la frecuencia, la interferencia aumenta. Cabe destacar el pico en torno a los 25 GHz en los que la interfrencia se dis para. 5.2 Caso 2 Para nuestro segundo caso vamos a usar de nuevo nuestra estación terrena de Sevilla, utilizada en el caso anterior y como emplazamiento de la estación receptora, una localización cerca de la ciudad de Jerez de la Frontera. En este caso las latitudes y longitudes de estas estaciones se corresponden con: • Sevilla: latitud = 37.345555, longitud = -5.971388 • Jerez de la Frontera: latitud = 36.739112, longitud = -6.131243 35 35 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 Figura 5.8. Enlace caso 2. Figura 5.9. Perfil del trayecto caso 2. Para nuestro caso número dos, los datos inicales introducidos son los ilustrados en la Figura 5.10. 36 36 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 Figura 5.10. Datos de entrada para el caso 2. Estos datos nos proporcionan un nivel de interferencia de: Figura 5.11. Resultado caso 2. De nuevo para contrastar los resultados obtenidos en nuestro trabajo vamos a usar el módulo Pycraf. En la Figura 5.12 tenemos el código usado para este objetivo. 43 43 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 Lf = 25*math.log10(f) - 2.5*((math.log10(f/2))**2) L_bs = 190 + Lf + 20*math.log10(d) + 0.573*teta - 0.15*N0 + Lc + Ag.value - 10.1*((- 1*math.log10(p/50))**0.7) return L_bs ########################################################################################################## ############ ##### Función para calcular la propagación por conductos y por reflexión en las capas (L_ba = Af + Ad + Ag) ##### ########################################################################################################## ############ def calcula_propagacion_conductos_reflexion(d_lt, d_lr, f, teta_r, teta_t, w, d_ct, d_cr, h_ts, h_rs, a_e, d, p, beta_0, mu_2, mu_3): # Af perdidas totales fijas de acoplamiento ##### Alf: correccion empirica para tener en cuenta el aumento de la atenuacion con la longitud de onda en la propagacion por conductos if (f < 0.5): Alf = 45.375 - 137.0 * f + 92.5 * f**2 else : Alf = 0 teta_2_t = teta_t - 0.1 * d_lt teta_2_r = teta_r - 0.1 * d_lr ##### Ast, Asr: perdidas de difraccion debidas al apantallamiento del emplazamiento if (teta_2_t > 0): Ast = 20*math.log10(1+0.361*teta_2_t*(f*d_lt)**0.5) + 0.264*teta_2_t * f**(1/3) else : Ast = 0 if (teta_2_r > 0): Asr = 20*math.log10(1+0.361*teta_2_r*(f*d_lr)**0.5) + 0.264*teta_2_r * f**(1/3) else : Asr = 0 ##### Act, Acr : correciones del acoplamiento por conductos en la superficie sobre el mar if (w >= 0.75 and d_ct >= d_lt and d_ct <= 5): Act = -3*math.e**(-0.25*d_ct**2)*(1 + math.tanh(0.07*(50-h_ts/1000))) else : Act = 0 if (w >= 0.75 and d_cr >= d_lr and d_cr <= 5): Acr = -3*math.e**(-0.25*d_cr**2)*(1 + math.tanh(0.07*(50-h_rs/1000))) else : Acr = 0 Af = 102.45 + 20*math.log10(f) + 20*math.log10(d_lt+d_lr) + Alf + Ast + Asr + Act + Acr ####################################################################### # Ad perdidas dependientes del % de tiempo y de la distancia angular ganma_d = 5*10**(-5)*a_e*f**(1/3) # atenuacion especifica if (teta_t <= 0.1*d_lt): teta_1_t = teta_t else: teta_1_t = 0.1*d_lt if (teta_r <= 0.1*d_lr): teta_1_r = teta_r else: teta_1_r = 0.1*d_lr teta_1 = ((d*10**3)/a_e) + teta_1_t + teta_1_r # distancia angular beta = beta_0*mu_2*mu_3 44 44 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 r = 1.076/((2.0058-math.log10(beta))**1.012) * math.e**(-(9.51- 4.8*math.log10(beta)+0.198*(math.log10(beta))**2)*10**(-6)*d**1.13) Ap = -12 + (1.2+3.7*10**(-3)*d)*math.log10(p/beta) + 12*(p/beta)**r # Ap variabilidad del % de tiempo Ad = ganma_d*teta_1 + Ap ######################################################################### rho = 7.5 + 2.5*w Ag = calcula_absorcion_gaseosa(f, d, rho) ######################################################################### L_ba = Af + Ad + Ag.value return L_ba menu.py import math import itur import itur.models.itu676 as itu676 import itur.models.itu835 as itu835 from pylab import * import matplotlib.pyplot as plt from tkinter import * from tkinter import scrolledtext from tkinter import messagebox from funciones import * from PIL import ImageTk, Image from astropy import units as u from pycraf import pathprof, conversions as cnv import numpy as np ##################################################################### pathprof.SrtmConf.set(download='missing') optionlist = [ 'Elija una opción', 'Opción 1', 'Opción 2', 'Opción 3', 'Opción 4', 'Opción 5', 'Opción 6', 'Opción 7', 'Opción 8', 'Opción 9', 'Opción 10', 'Opción 11', 'Introducir parámetros' ] def abrirVentana(win): win.title("Parametros de entrada") win.geometry('950x450') nb = Notebook(win) nb.pack(fill = "both", expand = "yes") p1 = Frame(nb) p2 = Frame(nb) opcion1 = StringVar() opcion2 = StringVar() ######## Funciones de ayuda del parametro ############################ def clicked_1(): 45 45 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 messagebox.showinfo('Definición del parámetro', 'Latitud del centro del trayecto (grados)') def clicked_2(): messagebox.showinfo('Definición del parámetro', 'Sección continua mas larga sobre la tierra (interior + costera) del trayecto en el circulo máximo (km)') def clicked_3(): messagebox.showinfo('Definición del parámetro', 'Sección continua mas larga sobre la tierra (interior) del trayecto en el círculo máximo (km)') def clicked_4(): messagebox.showinfo('Definición del parámetro', 'Longitud combinada de las secciones del trayecto sobre el agua (km)') def clicked_5(): messagebox.showinfo('Definición del parámetro', 'Distancia del trayecto a lo largo del círculo máximo (km)') def clicked_6(): messagebox.showinfo('Definición del parámetro', 'Frecuencia (Ghz)') def clicked_7(): messagebox.showinfo('Definición del parámetro', 'Latitud de la estación interferente (grados)') def clicked_8(): messagebox.showinfo('Definición del parámetro', 'Latitud de la estación interferida (grados)') def clicked_9(): messagebox.showinfo('Definición del parámetro', 'Longitud de la estación interferente (grados)') def clicked_10(): messagebox.showinfo('Definición del parámetro', 'Longitud de la estación interferida (grados)') def clicked_11(): messagebox.showinfo('Definición del parámetro', 'Altura del centro de la antena interferente sobre el nivel del suelo (m)') def clicked_12(): messagebox.showinfo('Definición del parámetro', 'Altura del centro de la antena interferida sobre el nivel del suelo (m)') def clicked_13(): messagebox.showinfo('Definición del parámetro', 'Altura del centro de la antena interferente sobre el nivel del mar (m)') def clicked_14(): messagebox.showinfo('Definición del parámetro', 'Altura del centro de la antena interferida sobre el nivel del mar (m)') def clicked_15(): messagebox.showinfo('Definición del parámetro', 'Alturas efectiva de la antena interferente sobre el terreno (m)') def clicked_16(): messagebox.showinfo('Definición del parámetro', 'Altura efectiva de la antena interferida sobre el terreno (m)') def clicked_17(): 46 46 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 messagebox.showinfo('Definición del parámetro', 'Ganancia de la antena interferente en la dirección del horizonte a lo largo del trayecto ortodrómico o del círculo máximo de interferencia (dBi)') def clicked_18(): messagebox.showinfo('Definición del parámetro', 'Ganancia de la antena interferida en la dirección del horizonte a lo largo del trayecto ortodrómico o del círculo máximo de interferencia (dBi)') def clicked_19(): messagebox.showinfo('Definición del parámetro', 'Para un trayecto transhorizonte, la distancia desde la antena de transmision a su horizonte.\nPara un trayecto de visibilidad directa, cada uno se fija a la distancia desde la terminal hasta el punto de perfil identificado como el borde principal en el método de difracción para el 50% (km).') def clicked_20(): messagebox.showinfo('Definición del parámetro', 'Para un trayecto transhorizonte, la distancia desde la antena de recepcion a su horizonte.\nPara un trayecto de visibilidad directa, cada uno se fija a la distancia desde la terminal hasta el punto de perfil identificado como el borde principal en el método de difracción para el 50% (km).') def clicked_21(): messagebox.showinfo('Definición del parámetro', 'Para un trayecto transhorizonte, el ángulo de elevación de la antena de transmisión respecto del horizonte.\nPara un trayecto de visibilidad directa, cada uno se fija al ángulo de elevación del otro terminal (mrad).') def clicked_22(): messagebox.showinfo('Definición del parámetro', 'Para un trayecto transhorizonte, el ángulo de elevación de la antena de recepción respecto del horizonte.\nPara un trayecto de visibilidad directa, cada uno se fija al ángulo de elevación del otro terminal (mrad).') def clicked_24(): messagebox.showinfo('Definición del parámetro', 'Distancia sobre tierra desde la antena transmisora hasta la costa a lo largo del trayecto de círculo máximo de la interferencia (km)\nSe fija en 0 en el caso de un terminal ubicado en un barco o en una plataforma marítima') def clicked_25(): messagebox.showinfo('Definición del parámetro', 'Distancia sobre tierra desde la antena receptora hasta la costa a lo largo del trayecto de círculo máximo de la interferencia (km)\nSe fija en 0 en el caso de un terminal ubicado en un barco o en una plataforma marítima') def clicked_26(): messagebox.showinfo('Definición del parámetro', 'Altura de la antena interferente por encima del nivel local del suelo (m)') def clicked_27(): messagebox.showinfo('Definición del parámetro', 'Altura de la antena interferida por encima del nivel local del suelo (m)') def clicked_28(): root = Toplevel(win) root.geometry('800x550') load = Image.open("Cuadro4.png") render = ImageTk.PhotoImage(load) img = Label(root, image=render) img.pack(fill=BOTH, expand = YES) img.image = render img.place(x=0, y=0) def seleccionar1(p1): if (opcion1.get() == 'Introducir parámetros') : txt_ha_1.config(state='enabled') txt_dk_1.config(state='enabled') else : txt_ha_1.config(state='disabled') 47 47 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 txt_dk_1.config(state='disabled') def seleccionar2(p1): if (opcion2.get() == 'Introducir parámetros') : txt_ha_2.config(state='enabled') txt_dk_2.config(state='enabled') else : txt_ha_2.config(state='disabled') txt_dk_2.config(state='disabled') ####### Funcion principal del modelo de cielo despejado def cierraPrincipal(): if (txt_1.get()=='' or txt_2.get()=='' or txt_3.get()=='' or txt_4.get()=='' or txt_5.get()=='' or txt_6.get()=='' or txt_7.get()=='' or txt_8.get()=='' or txt_9.get()=='' or txt_10.get()=='' or txt_11.get()=='' or txt_12.get()=='' or txt_13.get()=='' or txt_14.get()=='' or txt_15.get()=='' or txt_16.get()=='' or txt_17.get()=='' or txt_18.get()=='' or txt_19.get()=='' or txt_20.get()=='' or txt_21.get()=='' or txt_22.get()=='' or txt_24.get()=='' or txt_25.get()=='' or txt_26.get()=='' or txt_27.get()==''): messagebox.showwarning('Warning', 'Todos los campos deben estar rellenos') else: lat_c = float(txt_1.get()) d_tm = float(txt_2.get()) d_lm = float(txt_3.get()) d_b = float(txt_4.get()) d = float(txt_5.get()) f = float(txt_6.get()) lat_est_t = float(txt_7.get()) lat_est_r = float(txt_8.get()) long_est_t = float(txt_9.get()) long_est_r = float(txt_10.get()) h_tg = float(txt_11.get()) h_rg = float(txt_12.get()) h_ts = float(txt_13.get()) h_rs = float(txt_14.get()) h_te = float(txt_15.get()) h_re = float(txt_16.get()) G_t = float(txt_17.get()) G_r = float(txt_18.get()) d_lt = float(txt_19.get()) d_lr = float(txt_20.get()) teta_t = float(txt_21.get()) teta_r = float(txt_22.get()) # teta = float(txt_23.get()) d_ct = float(txt_24.get()) d_cr = float(txt_25.get()) ht = float(txt_26.get()) hr = float(txt_27.get()) if (lat_c > 90 or lat_c <-90 or lat_est_t > 90 or lat_est_t <-90 or lat_est_r > 90 or lat_est_r <-90 or long_est_t > 180 or long_est_t <-180 or long_est_r > 180 or long_est_r <-180): messagebox.showwarning('Warning', 'Los parametros geográficos lat_est_t, lat_est_r y lat_c deben estar comprendidos entre -90 y 90 grados, así como long_est_t y long_est_r deben estar entre -180 y 180 grados.') else: if (d > 10000): messagebox.showwarning('Warning', 'La distancia no puede ser mayor de 10000 Km.') else: if (f < 0.1 or f > 50): messagebox.showwarning('Warning', 'La frecuencia debe estar comprendida entre 0.1 y 50 GHz.') else: ######################################################################################### Perdidas adicionales por la ocupacion del suelo ######################################################################################### #Estacion interferente 48 48 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 if (opcion1.get() == 'Elija una opción' or opcion2.get() == 'Elija una opción'): messagebox.showwarning('Warning', 'Elija una opción de suelo') else: if (opcion1.get() == 'Opción 1'): ha_t = 4 dk_t = 0.1 zone_t = pathprof.CLUTTER.SPARSE elif (opcion1.get() == 'Opción 2'): ha_t = 5 dk_t = 0.07 zone_t = pathprof.CLUTTER.VILLAGE elif (opcion1.get() == 'Opción 3') : ha_t = 15 dk_t = 0.05 zone_t = pathprof.CLUTTER.DECIDIOUS_TREES elif (opcion1.get() == 'Opción 4') : ha_t = 20 dk_t = 0.05 zone_t = pathprof.CLUTTER.CONIFEROUS_TREES elif (opcion1.get() == 'Opción 5') : ha_t = 20 dk_t = 0.03 zone_t = pathprof.CLUTTER.TROPICAL_FOREST elif (opcion1.get() == 'Opción 6') : ha_t = 9 dk_t = 0.025 zone_t = pathprof.CLUTTER.SUBURBAN elif (opcion1.get() == 'Opción 7') : ha_t = 12 dk_t = 0.02 zone_t = pathprof.CLUTTER.DENSE_SUBURBAN elif (opcion1.get() == 'Opción 8') : ha_t = 20 dk_t = 0.02 zone_t = pathprof.CLUTTER.URBAN elif (opcion1.get() == 'Opción 9') : ha_t = 25 dk_t = 0.02 zone_t = pathprof.CLUTTER.DENSE_URBAN elif (opcion1.get() == 'Opción 10') : ha_t = 35 dk_t = 0.02 zone_t = pathprof.CLUTTER.HIGH_URBAN elif (opcion1.get() == 'Opción 11') : ha_t = 20 dk_t = 0.05 zone_t = pathprof.CLUTTER.INDUSTRIAL_ZONE else : ha_t = float(txt_ha_1.get()) dk_t = float(txt_dk_1.get()) zone_t = pathprof.CLUTTER.UNKNOWN #Estacion Interferida if (opcion2.get() == 'Opción 1'): ha_r = 4 dk_r = 0.1 zone_r = pathprof.CLUTTER.SPARSE elif (opcion2.get() == 'Opción 2'): ha_r = 5 dk_r = 0.07 zone_r = pathprof.CLUTTER.VILLAGE elif (opcion2.get() == 'Opción 3') : ha_r = 15 dk_r = 0.05 zone_r = pathprof.CLUTTER.DECIDIOUS_TREES elif (opcion2.get() == 'Opción 4') : ha_r = 20 dk_r = 0.05 zone_r = pathprof.CLUTTER.CONIFEROUS_TREES elif (opcion2.get() == 'Opción 5') : ha_r = 20 dk_r = 0.03 49 49 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 zone_r = pathprof.CLUTTER.TROPICAL_FOREST elif (opcion2.get() == 'Opción 6') : ha_r = 9 dk_r = 0.025 zone_r = pathprof.CLUTTER.SUBURBAN elif (opcion2.get() == 'Opción 7') : ha_r = 12 dk_r = 0.02 zone_r = pathprof.CLUTTER.DENSE_SUBURBAN elif (opcion2.get() == 'Opción 8') : ha_r = 20 dk_r = 0.02 zone_r = pathprof.CLUTTER.URBAN elif (opcion2.get() == 'Opción 9') : ha_r = 25 dk_r = 0.02 zone_r = pathprof.CLUTTER.DENSE_URBAN elif (opcion2.get() == 'Opción 10') : ha_r = 35 dk_r = 0.02 zone_r = pathprof.CLUTTER.HIGH_URBAN elif (opcion2.get() == 'Opción 11') : ha_r = 20 dk_r = 0.05 zone_r = pathprof.CLUTTER.INDUSTRIAL_ZONE else : ha_r = float(txt_ha_2.get()) dk_r = float(txt_dk_2.get()) zone_r = pathprof.CLUTTER.UNKNOWN F_fc = 0.25 + 0.375*(1+math.tanh(7.5*(f-0.5))) A_ht = 10.25 * F_fc * math.e**(-dk_t) * (1-math.tanh(6*(ht/ha_t - 0.625))) - 0.33 A_hr = 10.25*F_fc*math.e**(-dk_r)*(1-math.tanh(6*(hr/ha_r - 0.625))) - 0.33 ############################################################################ ######### Calculo de la difracción ############################################################################ Temp = 290 * u.K # Temperatura Pres = 1013.25 * u.hPa # Presion p_p = 0.01 * u.percent # hprof_step = 100 * u.m # resolution of height profile freq = f * u.GHz lat_tx = lat_est_t * u.deg lat_rx = lat_est_r * u.deg lon_tx = long_est_t * u.deg lon_rx = long_est_r * u.deg h_tg_1 = h_tg * u.m h_rg_1 = h_rg * u.m pprop = pathprof.PathProp( freq, Temp, Pres, lon_tx, lat_tx, lon_rx, lat_rx, h_tg_1, h_rg_1, hprof_step, p_p, zone_t=zone_t, zone_r=zone_r, ) L_bd = pathprof.loss_diffraction(pprop)[3].value #################################################################################### ##################### Radio efectivo de la tierra ################################# hm = pprop.h_m.value # rugosidad del terreno incremento_N = pprop.delta_N.value N0 = pprop.N0.value ## Refractividad de la superficie a nivel del mar k_beta = 3.0 #estimacion del factor del radio efectivo de la Tierra excecido duerante el beta_0 % del tiempo 50 50 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 k_50 = 157 /(157-incremento_N) a_e = 6371*k_50 #valor mediano del radio efectivo de la Tierra (Km) a_beta = 6371*k_beta #radio efectivo de la Tierra rebasado durante el beta_0 % (Km) p = 0.01 #### calculo teta teta = 10**3*d/a_e + teta_t + teta_r #################################################################################### ########### calculo mu #################################################### #################################################################################### E = 3.5 tau = 1-(math.e**-(0.000412*(d_lm**2.41))) mu_1 = (10**(-d_tm/(16-6.6*tau))+(10**-(0.496+0.354*tau))**5)**0.2 alfa = -0.6 - E*(10**-9) * d**3.1 * tau mu_2 = ((500 * d**2) / (a_e * (math.sqrt(h_te) + math.sqrt(h_re))**2))**alfa # correccion por la geometria del trayecto dI = min(d-d_lt-d_lr, 40) # mu_3 correccion por la rugosidad del terreno if (hm <= 10): mu_3 = 1 else: mu_3 = math.e**(-4.6*(10**-5)*(hm-10)*(43+6*dI)) # mu_4 if (math.fabs(lat_c) <= 70) : mu_4 = 10**((-0.935+0.0176*math.fabs(lat_c))*math.log10(mu_1)) else : mu_4 = 10**(0.3*math.log10(mu_1) #################################################### beta_0 = calcula_beta (lat_c,mu_1,mu_4) if (d_b == 0): w = 0 else : w = d_b/d #fraccion del trayecto total sobre el agua ############################################################################ L_b0p = calcula_propagacion_visibilidad_directa(p, f, w, d, d_lt, d_lr) L_b0b = calcula_propagacion_visibilidad_directa(beta_0, f, w, d, d_lt, d_lr) L_bs = calcula_dispersion_troposferica(d, f, G_t, G_r, teta, p, N0) L_ba = calcula_propagacion_conductos_reflexion(d_lt, d_lr, f, teta_r, teta_t, w, d_ct, d_cr, h_ts, h_rs, a_e, d, p, beta_0, mu_2, mu_3) ########################################################################### L_dp = pathprof.loss_diffraction(pprop)[1].value L_bd_50 = pathprof.loss_diffraction(pprop)[2].value S_tim = pprop.S_tim_50.value S_tr = pprop.S_tr_50.value Fj = 1 - 0.5 * (1 + math.tanh(3 * 0.8 * (S_tim - S_tr)/0.3)) ### factor de interpolacion para tener en cuenta la distancia angular del trayecto Fk = 1 - 0.5 * (1 + math.tanh(3 * 0.5 * (d - 20)/20)) ### factor de interpolacion para tener en cuenta la distancia del circulo maximo if (50 > p and p > beta_0): Fi = func_I(p/100) / func_I(beta_0/100) else: Fi = 1 if (p < beta_0): L_min_b0p = L_b0p + (1 - w)*L_dp else: 51 51 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 L_min_b0p = L_bd_50 + (L_b0b + (1-w)*L_dp - L_bd_50)*Fi L_min_bap = 2.5*math.log(math.e**(L_ba/2.5) + math.e**(L_b0p/2.5)) if (L_min_bap > L_bd): L_bda = L_bd else: L_bda = L_min_bap + (L_bd - L_min_bap)*Fk L_bam = L_bda + (L_min_b0p - L_bda)*Fj L_b = -5 * math.log10(10**(-0.2*L_bs) + 10**(-0.2*L_bam)) + A_ht + A_hr L = L_b - G_t - G_r print("L = ", "{0:.4f}".format(L), " dBs") win.quit() ############## Fin función principal 1 ############################## ########################################################################### ############# Widgets ventana 1 ######################################### ########################################################################### lbl_1 = Label(p1, text="lat_c", font=("Arial Bold", 10)) lbl_1.grid(column=0, row=0) txt_1 = Entry(p1,width=10) txt_1.insert(0, "41.131580") txt_1.grid(column=1, row=0) lbl_1_1 = Label(p1, text="(grados)", font=("Arial Bold", 10)) lbl_1_1.grid(column=2, row=0) lbl_2 = Label(p1, text="d_tm", font=("Arial Bold", 10)) lbl_2.grid(column=0, row=1) txt_2 = Entry(p1,width=10) txt_2.insert(0, "510.375760") txt_2.grid(column=1, row=1) lbl_2_1 = Label(p1, text="(km)", font=("Arial Bold", 10)) lbl_2_1.grid(column=2, row=1) lbl_3 = Label(p1, text="d_lm", font=("Arial Bold", 10)) lbl_3.grid(column=0, row=2) txt_3 = Entry(p1,width=10) txt_3.insert(0, "510.375760") txt_3.grid(column=1, row=2) lbl_3_1 = Label(p1, text="(km)", font=("Arial Bold", 10)) lbl_3_1.grid(column=2, row=2) lbl_4 = Label(p1, text="d_b", font=("Arial Bold", 10)) lbl_4.grid(column=0, row=3) txt_4 = Entry(p1,width=10) txt_4.insert(0, "0") txt_4.grid(column=1, row=3) lbl_4_1 = Label(p1, text="(km)", font=("Arial Bold", 10)) lbl_4_1.grid(column=2, row=3) lbl_5 = Label(p1, text="d", font=("Arial Bold", 10)) lbl_5.grid(column=0, row=4) txt_5 = Entry(p1,width=10) txt_5.insert(0, "510.375760") txt_5.grid(column=1, row=4) lbl_5_1 = Label(p1, text="(km)", font=("Arial Bold", 10)) lbl_5_1.grid(column=2, row=4) lbl_6 = Label(p1, text="f", font=("Arial Bold", 10)) lbl_6.grid(column=0, row=5) txt_6 = Entry(p1,width=10) txt_6.insert(0, "10") txt_6.grid(column=1, row=5) lbl_6_1 = Label(p1, text="(Ghz)", font=("Arial Bold", 10)) lbl_6_1.grid(column=2, row=5) lbl_7 = Label(p1, text="lat_est_t", font=("Arial Bold", 10)) lbl_7.grid(column=0, row=6) txt_7 = Entry(p1,width=10) txt_7.insert(0, "38.893610") txt_7.grid(column=1, row=6) 52 52 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 lbl_7_1 = Label(p1, text="(grados)", font=("Arial Bold", 10)) lbl_7_1.grid(column=2, row=6) lbl_8 = Label(p1, text="lat_est_r", font=("Arial Bold", 10)) lbl_8.grid(column=0, row=7) txt_8 = Entry(p1,width=10) txt_8.insert(0, "43.364160") txt_8.grid(column=1, row=7) lbl_8_1 = Label(p1, text="(grados)", font=("Arial Bold", 10)) lbl_8_1.grid(column=2, row=7) lbl_9 = Label(p1, text="long_est_t", font=("Arial Bold", 10)) lbl_9.grid(column=0, row=8) txt_9 = Entry(p1,width=10) txt_9.insert(0, "-6.989160") txt_9.grid(column=1, row=8) lbl_9_1 = Label(p1, text="(grados)", font=("Arial Bold", 10)) lbl_9_1.grid(column=2, row=8) lbl_10 = Label(p1, text="long_est_r", font=("Arial Bold", 10)) lbl_10.grid(column=0, row=9) txt_10 = Entry(p1,width=10) txt_10.insert(0, "-8.398800") txt_10.grid(column=1, row=9) lbl_10_1 = Label(p1, text="(grados)", font=("Arial Bold", 10)) lbl_10_1.grid(column=2, row=9) lbl_11 = Label(p1, text="h_tg", font=("Arial Bold", 10)) lbl_11.grid(column=0, row=10) txt_11 = Entry(p1,width=10) txt_11.insert(0, "20") txt_11.grid(column=1, row=10) lbl_11_1 = Label(p1, text="(m)", font=("Arial Bold", 10)) lbl_11_1.grid(column=2, row=10) lbl_12 = Label(p1, text="h_rg", font=("Arial Bold", 10)) lbl_12.grid(column=0, row=11) txt_12 = Entry(p1,width=10) txt_12.insert(0, "40") txt_12.grid(column=1, row=11) lbl_12_1 = Label(p1, text="(m)", font=("Arial Bold", 10)) lbl_12_1.grid(column=2, row=11) lbl_13 = Label(p1, text="h_ts", font=("Arial Bold", 10)) lbl_13.grid(column=0, row=12) txt_13 = Entry(p1,width=10) txt_13.insert(0, "206.354497") txt_13.grid(column=1, row=12) lbl_13_1 = Label(p1, text="(m)", font=("Arial Bold", 10)) lbl_13_1.grid(column=2, row=12) lbl_14 = Label(p1, text="h_rs", font=("Arial Bold", 10)) lbl_14.grid(column=5, row=0) txt_14 = Entry(p1,width=10) txt_14.insert(0, "42.333698") txt_14.grid(column=6, row=0) lbl_14_1 = Label(p1, text="(m)", font=("Arial Bold", 10)) lbl_14_1.grid(column=7, row=0) lbl_15 = Label(p1, text="h_te", font=("Arial Bold", 10)) lbl_15.grid(column=5, row=1) txt_15 = Entry(p1,width=10) txt_15.insert(0, "20") txt_15.grid(column=6, row=1) lbl_15_1 = Label(p1, text="(m)", font=("Arial Bold", 10)) lbl_15_1.grid(column=7, row=1) lbl_16 = Label(p1, text="h_re", font=("Arial Bold", 10)) lbl_16.grid(column=5, row=2) txt_16 = Entry(p1,width=10) txt_16.insert(0, "40") txt_16.grid(column=6, row=2) lbl_16_1 = Label(p1, text="(m)", font=("Arial Bold", 10)) lbl_16_1.grid(column=7, row=2) lbl_17 = Label(p1, text="G_t", font=("Arial Bold", 10)) 59 59 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 button = Button(p2, text="Gráfica", command=grafica2) button.grid(column=15, row=6) button = Button(p2, text="OK", command=cierraSecundaria) button.grid(column=18, row=20) ############# Fin Widgets ventana 2 #################################### ############################################################################ nb.add(p1, text ="Propagación por cielo despejado") nb.add(p2, text ="Gráficas") win.mainloop() 60 60 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 61 61 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 REFERENCIAS [1] Procedimiento de predicción para evaluar la interferencia entre estaciones situadas en la superficie de la Tierra a frecuencias superiores a unos 0,1 GHz. Rec. UIT-R P.452-16 [2] John A. Richards, Radio Waves Propagation. Springer. [3] Abdollah Ghasemi, Ali Abedi, Farshid Ghasemi, Propagation Engineering in Radio Links Design. Springer. [4] Charles R. Severance, Python para todos. [5] Atenuación debida a los gases atmosféricos. Rec. UIT-R P.676-6 62 62 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 63 63 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 Índice de Códigos 3.1 Ejemplo del uso del instalador de paquetes pip 13 3.2 Ejemplo de ventana con Widgets 14 4.1 Comando para inicar la aplicación 19 64 64 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 65 65 Simulador en Python del procedimiento de predicción de la interferencia entre estaciones a frecuencias superiores a 0,1 GHz según la Rec. ITU-R P.452 GLOSARIO ITU: International Telecommunications Union 3 SRTM: Shuttle Radar Topography Mission 14