# ============================================================
# COMUNICACIONES 1
# Unidad 5: Cable coaxial
# Resolución de ejercicios propuestos
# Google Colab / Python
# ============================================================

import math

# ------------------------------------------------------------
# FUNCIONES AUXILIARES
# ------------------------------------------------------------

def mostrar_titulo(titulo):
    print("\n" + "=" * 70)
    print(titulo)
    print("=" * 70)


def validar_positivo(valor, nombre):
    if valor <= 0:
        raise ValueError(f"{nombre} debe ser mayor que cero.")


def validar_no_negativo(valor, nombre):
    if valor < 0:
        raise ValueError(f"{nombre} no puede ser negativo.")


# ============================================================
# EJERCICIO 1: ATENUACIÓN TOTAL DEL CABLE COAXIAL
# ============================================================
# Fórmula:
# A_total = alpha_100m * (L / 100)
#
# Donde:
# A_total   = atenuación total en dB
# alpha_100m = atenuación del cable en dB/100m
# L         = longitud del cable en metros

def calcular_atenuacion_total(alpha_100m, longitud_m):
    """
    Calcula la atenuación total de un cable coaxial.

    Parámetros:
    alpha_100m : atenuación del cable en dB/100m
    longitud_m : longitud del cable en metros
    """
    validar_no_negativo(alpha_100m, "alpha_100m")
    validar_no_negativo(longitud_m, "longitud_m")

    A_total = alpha_100m * (longitud_m / 100)
    return A_total


# ============================================================
# EJERCICIO 2: POTENCIA DE SALIDA
# ============================================================
# Fórmula:
# Pout = Pin * 10^(-A_dB/10)
#
# Donde:
# Pout = potencia de salida
# Pin  = potencia de entrada
# A_dB = atenuación total en dB

def calcular_potencia_salida(Pin, A_dB):
    """
    Calcula la potencia de salida luego de una atenuación en dB.

    Pin y Pout quedan en la misma unidad:
    W, mW, uW, etc.
    """
    validar_positivo(Pin, "Pin")
    validar_no_negativo(A_dB, "A_dB")

    Pout = Pin * 10 ** (-A_dB / 10)
    return Pout


# ============================================================
# EJERCICIO 3: COEFICIENTE DE REFLEXIÓN
# ============================================================
# Fórmula:
# Gamma = (ZL - Z0) / (ZL + Z0)
#
# Donde:
# Gamma = coeficiente de reflexión
# ZL    = impedancia de carga
# Z0    = impedancia característica del cable

def calcular_coeficiente_reflexion(ZL, Z0):
    """
    Calcula el coeficiente de reflexión de una línea coaxial.
    """
    validar_positivo(ZL, "ZL")
    validar_positivo(Z0, "Z0")

    gamma = (ZL - Z0) / (ZL + Z0)
    return gamma


# ============================================================
# EJERCICIO 4: RETURN LOSS
# ============================================================
# Fórmula:
# RL_dB = -20 * log10(|Gamma|)
#
# Donde:
# RL_dB = pérdida de retorno
# Gamma = coeficiente de reflexión

def calcular_return_loss_desde_gamma(gamma):
    """
    Calcula el return loss en dB a partir del coeficiente de reflexión.
    """
    gamma_abs = abs(gamma)

    if gamma_abs == 0:
        return math.inf

    if gamma_abs >= 1:
        raise ValueError("|Gamma| debe ser menor que 1 para una línea pasiva.")

    RL_dB = -20 * math.log10(gamma_abs)
    return RL_dB


def calcular_return_loss_por_potencia(P_incidente, P_reflejada):
    """
    Calcula el return loss en dB a partir de potencias.

    Fórmula:
    RL_dB = 10 * log10(P_incidente / P_reflejada)
    """
    validar_positivo(P_incidente, "P_incidente")
    validar_positivo(P_reflejada, "P_reflejada")

    RL_dB = 10 * math.log10(P_incidente / P_reflejada)
    return RL_dB


# ============================================================
# EJERCICIO 5: VSWR
# ============================================================
# Fórmula:
# VSWR = (1 + |Gamma|) / (1 - |Gamma|)
#
# Donde:
# VSWR  = relación de onda estacionaria
# Gamma = coeficiente de reflexión

def calcular_vswr(gamma):
    """
    Calcula el VSWR a partir del coeficiente de reflexión.
    """
    gamma_abs = abs(gamma)

    if gamma_abs >= 1:
        raise ValueError("|Gamma| debe ser menor que 1 para calcular VSWR.")

    VSWR = (1 + gamma_abs) / (1 - gamma_abs)
    return VSWR


# ============================================================
# EJERCICIO 6: RETARDO DE PROPAGACIÓN
# ============================================================
# Fórmulas:
# v = VF * c
# tp = L / v
#
# Donde:
# v  = velocidad de propagación en el cable
# VF = factor de velocidad
# c  = velocidad de la luz en el vacío
# L  = longitud del cable
# tp = retardo de propagación

def calcular_velocidad_propagacion(VF):
    """
    Calcula la velocidad de propagación en el cable coaxial.
    """
    validar_positivo(VF, "VF")

    c = 3e8  # m/s
    v = VF * c
    return v


def calcular_retardo_propagacion(longitud_m, VF):
    """
    Calcula el retardo de propagación de un cable coaxial.
    """
    validar_no_negativo(longitud_m, "longitud_m")
    validar_positivo(VF, "VF")

    v = calcular_velocidad_propagacion(VF)
    tp = longitud_m / v
    return tp, v


# ============================================================
# EJERCICIO 7: LONGITUD DE ONDA EN EL CABLE COAXIAL
# ============================================================
# Fórmula:
# lambda = (VF * c) / f
#
# Donde:
# lambda = longitud de onda en metros
# VF     = factor de velocidad
# c      = velocidad de la luz en el vacío
# f      = frecuencia en Hz

def calcular_longitud_onda(frecuencia_hz, VF):
    """
    Calcula la longitud de onda dentro del cable coaxial.
    """
    validar_positivo(frecuencia_hz, "frecuencia_hz")
    validar_positivo(VF, "VF")

    v = calcular_velocidad_propagacion(VF)
    lambda_m = v / frecuencia_hz
    return lambda_m, v


# ============================================================
# RESOLUCIÓN DE LOS EJERCICIOS PROPUESTOS
# ============================================================

# ------------------------------------------------------------
# EJERCICIO 1
# ------------------------------------------------------------

mostrar_titulo("EJERCICIO 1: Atenuación total de un cable coaxial")

alpha_100m = 6   # dB/100m
longitud_m = 50  # m

A_total = calcular_atenuacion_total(alpha_100m, longitud_m)

print(f"Atenuación del cable        : {alpha_100m} dB/100m")
print(f"Longitud del cable          : {longitud_m} m")
print(f"Atenuación total            : {A_total:.2f} dB")


# ------------------------------------------------------------
# EJERCICIO 2
# ------------------------------------------------------------

mostrar_titulo("EJERCICIO 2: Potencia de salida")

Pin = 10    # mW
A_dB = 3    # dB

Pout = calcular_potencia_salida(Pin, A_dB)

print(f"Potencia de entrada Pin     : {Pin} mW")
print(f"Atenuación total            : {A_dB} dB")
print(f"Potencia de salida Pout     : {Pout:.2f} mW")


# ------------------------------------------------------------
# EJERCICIO 3
# ------------------------------------------------------------

mostrar_titulo("EJERCICIO 3: Coeficiente de reflexión")

Z0 = 75   # ohm
ZL = 50   # ohm

gamma = calcular_coeficiente_reflexion(ZL, Z0)

print(f"Impedancia característica Z0 : {Z0} ohm")
print(f"Impedancia de carga ZL       : {ZL} ohm")
print(f"Coeficiente de reflexión Γ   : {gamma:.4f}")

if gamma < 0:
    print("Interpretación: el signo negativo indica inversión de fase en la onda reflejada.")
elif gamma > 0:
    print("Interpretación: hay reflexión sin inversión de fase.")
else:
    print("Interpretación: línea adaptada, sin reflexión ideal.")


# ------------------------------------------------------------
# EJERCICIO 4
# ------------------------------------------------------------

mostrar_titulo("EJERCICIO 4: Return Loss")

RL_dB = calcular_return_loss_desde_gamma(gamma)

print(f"Coeficiente de reflexión Γ   : {gamma:.4f}")
print(f"|Γ|                           : {abs(gamma):.4f}")
print(f"Return Loss                   : {RL_dB:.2f} dB")


# ------------------------------------------------------------
# EJERCICIO 5
# ------------------------------------------------------------

mostrar_titulo("EJERCICIO 5: VSWR")

VSWR = calcular_vswr(gamma)

print(f"Coeficiente de reflexión Γ   : {gamma:.4f}")
print(f"|Γ|                           : {abs(gamma):.4f}")
print(f"VSWR                          : {VSWR:.2f}:1")


# ------------------------------------------------------------
# EJERCICIO 6
# ------------------------------------------------------------

mostrar_titulo("EJERCICIO 6: Retardo de propagación")

longitud_m = 100  # m
VF = 0.66

tp, velocidad = calcular_retardo_propagacion(longitud_m, VF)

print(f"Longitud del cable            : {longitud_m} m")
print(f"Factor de velocidad VF        : {VF}")
print(f"Velocidad de propagación      : {velocidad:.2e} m/s")
print(f"Retardo de propagación        : {tp:.3e} s")
print(f"Retardo de propagación        : {tp * 1e9:.2f} ns")


# ------------------------------------------------------------
# EJERCICIO 7
# ------------------------------------------------------------

mostrar_titulo("EJERCICIO 7: Longitud de onda en el coaxial")

frecuencia_mhz = 100
frecuencia_hz = frecuencia_mhz * 1e6
VF = 0.66

lambda_m, velocidad = calcular_longitud_onda(frecuencia_hz, VF)

print(f"Frecuencia                    : {frecuencia_mhz} MHz")
print(f"Frecuencia                    : {frecuencia_hz:.2e} Hz")
print(f"Factor de velocidad VF        : {VF}")
print(f"Velocidad de propagación      : {velocidad:.2e} m/s")
print(f"Longitud de onda en el cable  : {lambda_m:.2f} m")


# ============================================================
# RESUMEN FINAL
# ============================================================

mostrar_titulo("RESUMEN DE RESULTADOS")

print(f"Ejercicio 1 - Atenuación total       : {A_total:.2f} dB")
print(f"Ejercicio 2 - Potencia de salida     : {Pout:.2f} mW")
print(f"Ejercicio 3 - Coeficiente Γ          : {gamma:.4f}")
print(f"Ejercicio 4 - Return Loss            : {RL_dB:.2f} dB")
print(f"Ejercicio 5 - VSWR                   : {VSWR:.2f}:1")
print(f"Ejercicio 6 - Retardo propagación    : {tp * 1e9:.2f} ns")
print(f"Ejercicio 7 - Longitud de onda       : {lambda_m:.2f} m")