# Código en Python para resolver los ejercicios propuestos de la Unidad 1: Medios guiados: 
# atenuación, retardo de propagación y capacidad teórica del canal. 

# ============================================================
# COMUNICACIONES 1
# Unidad 1: Medios guiados
# Resolución de ejercicios propuestos
# ============================================================

import math

# ------------------------------------------------------------
# 1) CÁLCULO DE ATENUACIÓN
# ------------------------------------------------------------
# Fórmula:
# A_dB = 10 * log10(Pin / Pout)

def calcular_atenuacion_db(Pin, Pout):
    """
    Calcula la atenuación en dB.

    Parámetros:
    Pin  : Potencia de entrada
    Pout : Potencia de salida

    Las potencias deben estar en la misma unidad:
    mW, W, uW, etc.
    """
    if Pin <= 0 or Pout <= 0:
        raise ValueError("Las potencias deben ser mayores que cero.")

    A_db = 10 * math.log10(Pin / Pout)
    return A_db

def calcular_potencia_salida(Pin, A_db):
    """
    Calcula la potencia de salida a partir de la potencia de entrada
    y la atenuación en dB.

    Fórmula:
    Pout = Pin * 10^(-A_dB/10)
    """
    Pout = Pin * 10 ** (-A_db / 10)
    return Pout

def calcular_atenuacion_por_km(A_db, longitud_km):
    """
    Calcula la atenuación por kilómetro.

    Fórmula:
    alpha = A_dB / L
    """
    if longitud_km <= 0:
        raise ValueError("La longitud debe ser mayor que cero.")

    alpha = A_db / longitud_km
    return alpha


# ------------------------------------------------------------
# 2) CÁLCULO DE RETARDO DE PROPAGACIÓN
# ------------------------------------------------------------
# Fórmula:
# tp = L / v

def calcular_retardo_propagacion(longitud_m, velocidad_m_s):
    """
    Calcula el retardo de propagación.

    Parámetros:
    longitud_m    : longitud del enlace en metros
    velocidad_m_s : velocidad de propagación en m/s
    """
    if longitud_m < 0:
        raise ValueError("La longitud no puede ser negativa.")
    if velocidad_m_s <= 0:
        raise ValueError("La velocidad debe ser mayor que cero.")

    tp = longitud_m / velocidad_m_s
    return tp


def metros_desde_km(longitud_km):
    """
    Convierte kilómetros a metros.
    """
    return longitud_km * 1000


# ------------------------------------------------------------
# 3) CÁLCULO DE CAPACIDAD TEÓRICA DEL CANAL
# ------------------------------------------------------------
# Fórmula de Shannon-Hartley:
# C = B * log2(1 + S/N)

def convertir_snr_db_a_lineal(SNR_db):
    """
    Convierte la relación señal-ruido desde dB a escala lineal.

    Fórmula:
    S/N = 10^(SNR_dB/10)
    """
    SNR_lineal = 10 ** (SNR_db / 10)
    return SNR_lineal


def calcular_capacidad_shannon(B_hz, SNR_db):
    """
    Calcula la capacidad teórica máxima del canal usando Shannon-Hartley.

    Parámetros:
    B_hz   : ancho de banda en Hz
    SNR_db : relación señal-ruido en dB
    """
    if B_hz <= 0:
        raise ValueError("El ancho de banda debe ser mayor que cero.")

    SNR_lineal = convertir_snr_db_a_lineal(SNR_db)
    C_bps = B_hz * math.log2(1 + SNR_lineal)

    return C_bps


# ------------------------------------------------------------
# FUNCIÓN AUXILIAR PARA MOSTRAR VELOCIDADES
# ------------------------------------------------------------

def mostrar_bps(valor_bps):
    """
    Muestra una tasa de bits en bps, kbps, Mbps o Gbps según corresponda.
    """
    if valor_bps >= 1e9:
        return f"{valor_bps / 1e9:.3f} Gbps"
    elif valor_bps >= 1e6:
        return f"{valor_bps / 1e6:.3f} Mbps"
    elif valor_bps >= 1e3:
        return f"{valor_bps / 1e3:.3f} kbps"
    else:
        return f"{valor_bps:.3f} bps"


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

print("============================================================")
print("EJERCICIO 1: Cálculo de atenuación")
print("============================================================")

Pin = 1      # mW
Pout = 0.1   # mW

A_db = calcular_atenuacion_db(Pin, Pout)

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


print("\n============================================================")
print("EJERCICIO 2: Cálculo de retardo de propagación")
print("============================================================")

longitud_km = 20
longitud_m = metros_desde_km(longitud_km)

# Aproximación típica para fibra óptica
velocidad_fibra = 2e8  # m/s

tp = calcular_retardo_propagacion(longitud_m, velocidad_fibra)

print(f"Longitud del enlace        : {longitud_km} km")
print(f"Longitud del enlace        : {longitud_m} m")
print(f"Velocidad de propagación   : {velocidad_fibra:.2e} m/s")
print(f"Retardo de propagación     : {tp:.6f} s")
print(f"Retardo de propagación     : {tp * 1e6:.2f} us")


print("\n============================================================")
print("EJERCICIO 3: Capacidad teórica del canal")
print("============================================================")

B_mhz = 100
B_hz = B_mhz * 1e6

SNR_db = 30

SNR_lineal = convertir_snr_db_a_lineal(SNR_db)
C_bps = calcular_capacidad_shannon(B_hz, SNR_db)

print(f"Ancho de banda             : {B_mhz} MHz")
print(f"Ancho de banda             : {B_hz:.2e} Hz")
print(f"SNR                        : {SNR_db} dB")
print(f"SNR lineal                 : {SNR_lineal:.2f}")
print(f"Capacidad teórica          : {C_bps:.2f} bps")
print(f"Capacidad teórica          : {mostrar_bps(C_bps)}")

EJERCICIO 1: Cálculo de atenuación
Potencia de entrada: 1 mW
Potencia de salida : 0.1 mW
Atenuación         : 10.00 dB

EJERCICIO 2: Cálculo de retardo de propagación
Longitud del enlace        : 20 km
Longitud del enlace        : 20000 m
Velocidad de propagación   : 2.00e+08 m/s
Retardo de propagación     : 0.000100 s
Retardo de propagación     : 100.00 us

EJERCICIO 3: Capacidad teórica del canal
Ancho de banda             : 100 MHz
SNR                        : 30 dB
SNR lineal                 : 1000.00
Capacidad teórica          : 996578428.47 bps
Capacidad teórica          : 996.578 Mbps

También puedes agregar esta celda interactiva en Colab para que los alumnos prueben otros valores: 

# ============================================================
# CELDA INTERACTIVA PARA GOOGLE COLAB
# ============================================================

print("Cálculo interactivo de medios guiados")

print("\n--- Atenuación ---")
Pin = float(input("Ingrese la potencia de entrada Pin: "))
Pout = float(input("Ingrese la potencia de salida Pout: "))

A_db = calcular_atenuacion_db(Pin, Pout)
print(f"Atenuación = {A_db:.2f} dB")


print("\n--- Retardo de propagación ---")
longitud_km = float(input("Ingrese la longitud del enlace en km: "))
velocidad_m_s = float(input("Ingrese la velocidad de propagación en m/s: "))

longitud_m = metros_desde_km(longitud_km)
tp = calcular_retardo_propagacion(longitud_m, velocidad_m_s)

print(f"Retardo = {tp:.6e} s")
print(f"Retardo = {tp * 1e6:.2f} us")


print("\n--- Capacidad del canal ---")
B_mhz = float(input("Ingrese el ancho de banda en MHz: "))
SNR_db = float(input("Ingrese la relación señal-ruido en dB: "))

B_hz = B_mhz * 1e6
C_bps = calcular_capacidad_shannon(B_hz, SNR_db)

print(f"Capacidad teórica = {C_bps:.2f} bps")
print(f"Capacidad teórica = {mostrar_bps(C_bps)}")