# ============================================================ # COMUNICACIONES 1 # Unidad 4: Cableado estructurado # 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_no_negativo(valor, nombre): if valor < 0: raise ValueError(f"{nombre} no puede ser negativo.") def validar_positivo(valor, nombre): if valor <= 0: raise ValueError(f"{nombre} debe ser mayor que cero.") # ============================================================ # EJERCICIO 1: CÁLCULO DE LONGITUD DE CANAL # ============================================================ # Fórmula: # L_canal = L_permanente + L_patch_TR + L_patch_usuario # # Criterio habitual: # L_permanente <= 90 m # L_canal <= 100 m def calcular_longitud_canal(L_permanente, L_patch_TR, L_patch_usuario): """ Calcula la longitud total del canal de cableado estructurado. Parámetros: L_permanente : longitud del enlace permanente en metros L_patch_TR : longitud del patch cord en sala técnica/rack L_patch_usuario : longitud del patch cord del usuario Retorna: longitud total del canal en metros """ validar_no_negativo(L_permanente, "L_permanente") validar_no_negativo(L_patch_TR, "L_patch_TR") validar_no_negativo(L_patch_usuario, "L_patch_usuario") L_canal = L_permanente + L_patch_TR + L_patch_usuario return L_canal def verificar_longitud_canal(L_permanente, L_canal): """ Verifica si el enlace cumple con los límites típicos: - enlace permanente <= 90 m - canal completo <= 100 m """ cumple_permanente = L_permanente <= 90 cumple_canal = L_canal <= 100 return cumple_permanente, cumple_canal # ============================================================ # EJERCICIO 2: CANTIDAD MÍNIMA DE BOCAS DE RED # ============================================================ # Fórmulas: # B_base = N_puestos * B_por_puesto # B_total = B_base * (1 + R) # # Como no se pueden instalar fracciones de bocas: # B_total_redondeado = ceil(B_total) def calcular_bocas_red(N_puestos, B_por_puesto, reserva_porcentaje): """ Calcula la cantidad total de bocas de red necesarias. Parámetros: N_puestos : cantidad de puestos de trabajo B_por_puesto : bocas por puesto reserva_porcentaje : reserva en porcentaje, por ejemplo 20 para 20% Retorna: B_base, B_total, B_total_redondeado """ validar_positivo(N_puestos, "N_puestos") validar_positivo(B_por_puesto, "B_por_puesto") validar_no_negativo(reserva_porcentaje, "reserva_porcentaje") R = reserva_porcentaje / 100 B_base = N_puestos * B_por_puesto B_total = B_base * (1 + R) B_total_redondeado = math.ceil(B_total) return B_base, B_total, B_total_redondeado # ============================================================ # EJERCICIO 3: CANTIDAD DE PATCH PANELS # ============================================================ # Fórmula: # N_patch = ceil(B_total / P_patch) def calcular_patch_panels(B_total, P_patch): """ Calcula la cantidad de patch panels necesarios. Parámetros: B_total : cantidad total de bocas o puertos a terminar P_patch : cantidad de puertos por patch panel Retorna: cantidad de patch panels necesarios """ validar_positivo(B_total, "B_total") validar_positivo(P_patch, "P_patch") N_patch = math.ceil(B_total / P_patch) puertos_totales = N_patch * P_patch puertos_libres = puertos_totales - B_total return N_patch, puertos_totales, puertos_libres # ============================================================ # EJERCICIO 4: OCUPACIÓN DE RACK # ============================================================ # Fórmulas: # U_ocupadas = suma de unidades ocupadas # Ocupacion(%) = (U_ocupadas / U_total) * 100 def calcular_ocupacion_rack(U_total, elementos): """ Calcula la ocupación de un rack. Parámetros: U_total : unidades totales del rack elementos : diccionario con elementos y unidades ocupadas Ejemplo: elementos = { "Patch panels": 4, "Switches": 3, "UPS": 3 } Retorna: U_ocupadas, porcentaje_ocupacion, U_libres """ validar_positivo(U_total, "U_total") U_ocupadas = sum(elementos.values()) if U_ocupadas > U_total: advertencia = True else: advertencia = False porcentaje_ocupacion = (U_ocupadas / U_total) * 100 U_libres = U_total - U_ocupadas return U_ocupadas, porcentaje_ocupacion, U_libres, advertencia # ============================================================ # EJERCICIO 5: POTENCIA ESTIMADA DE SALA TÉCNICA # ============================================================ # Fórmulas: # P_base = suma de potencias # P_total = P_base * (1 + M) def calcular_potencia_total(equipos_watts, margen_porcentaje): """ Calcula la potencia total estimada de una sala técnica. Parámetros: equipos_watts : diccionario con equipos y potencia en W margen_porcentaje : margen de crecimiento en porcentaje Retorna: P_base, P_total """ validar_no_negativo(margen_porcentaje, "margen_porcentaje") P_base = sum(equipos_watts.values()) M = margen_porcentaje / 100 P_total = P_base * (1 + M) return P_base, P_total def calcular_corriente_monofasica(P_watts, V_volts, factor_potencia=1.0): """ Calcula corriente aproximada en una alimentación monofásica. Fórmula: I = P / (V * FP) Parámetros: P_watts : potencia en watts V_volts : tensión en volts factor_potencia : factor de potencia Retorna: corriente en amperes """ validar_positivo(P_watts, "P_watts") validar_positivo(V_volts, "V_volts") validar_positivo(factor_potencia, "factor_potencia") I = P_watts / (V_volts * factor_potencia) return I # ============================================================ # RESOLUCIÓN DE LOS EJERCICIOS PROPUESTOS # ============================================================ # ------------------------------------------------------------ # EJERCICIO 1 # ------------------------------------------------------------ mostrar_titulo("EJERCICIO 1: Cálculo de longitud de canal") L_permanente = 88 # metros L_patch_TR = 3 # metros L_patch_usuario = 4 # metros L_canal = calcular_longitud_canal( L_permanente, L_patch_TR, L_patch_usuario ) cumple_permanente, cumple_canal = verificar_longitud_canal( L_permanente, L_canal ) print(f"Longitud del enlace permanente : {L_permanente} m") print(f"Patch cord en rack/sala técnica: {L_patch_TR} m") print(f"Patch cord del usuario : {L_patch_usuario} m") print(f"Longitud total del canal : {L_canal} m") print("\nVerificación:") print(f"¿Enlace permanente <= 90 m? : {'Sí' if cumple_permanente else 'No'}") print(f"¿Canal completo <= 100 m? : {'Sí' if cumple_canal else 'No'}") if cumple_permanente and cumple_canal: print("Resultado: el canal cumple con el criterio de longitud.") else: print("Resultado: el canal NO cumple con el criterio de longitud.") # ------------------------------------------------------------ # EJERCICIO 2 # ------------------------------------------------------------ mostrar_titulo("EJERCICIO 2: Cantidad mínima de bocas de red") N_puestos = 18 B_por_puesto = 2 reserva_porcentaje = 20 B_base, B_total, B_total_redondeado = calcular_bocas_red( N_puestos, B_por_puesto, reserva_porcentaje ) print(f"Cantidad de puestos de trabajo : {N_puestos}") print(f"Bocas por puesto : {B_por_puesto}") print(f"Reserva prevista : {reserva_porcentaje}%") print(f"Bocas base : {B_base}") print(f"Bocas con reserva : {B_total:.2f}") print(f"Bocas a instalar : {B_total_redondeado}") print("Resultado: se deben prever", B_total_redondeado, "bocas de red.") # ------------------------------------------------------------ # EJERCICIO 3 # ------------------------------------------------------------ mostrar_titulo("EJERCICIO 3: Cantidad de patch panels") B_total = 92 P_patch = 24 N_patch, puertos_totales, puertos_libres = calcular_patch_panels( B_total, P_patch ) print(f"Bocas a terminar : {B_total}") print(f"Puertos por patch panel : {P_patch}") print(f"Patch panels necesarios : {N_patch}") print(f"Puertos totales disponibles : {puertos_totales}") print(f"Puertos libres : {puertos_libres}") print("Resultado: se necesitan", N_patch, "patch panels de", P_patch, "puertos.") # ------------------------------------------------------------ # EJERCICIO 4 # ------------------------------------------------------------ mostrar_titulo("EJERCICIO 4: Ocupación de rack") U_total = 42 elementos_rack = { "4 patch panels de 1U": 4, "3 switches de 1U": 3, "1 UPS de 3U": 3, "2 organizadores horizontales de 1U": 2, "1 bandeja de 2U": 2, "1 router de 1U": 1 } U_ocupadas, porcentaje_ocupacion, U_libres, advertencia = calcular_ocupacion_rack( U_total, elementos_rack ) print(f"Rack total : {U_total}U") print("\nElementos instalados:") for elemento, unidades in elementos_rack.items(): print(f"- {elemento}: {unidades}U") print(f"\nUnidades ocupadas : {U_ocupadas}U") print(f"Unidades libres : {U_libres}U") print(f"Ocupación del rack : {porcentaje_ocupacion:.2f}%") if advertencia: print("Advertencia: la ocupación supera la capacidad del rack.") else: print("Resultado: la ocupación del rack es válida.") # ------------------------------------------------------------ # EJERCICIO 5 # ------------------------------------------------------------ mostrar_titulo("EJERCICIO 5: Potencia estimada de sala técnica") equipos_sala = { "Switch 1": 180, "Switch 2": 180, "Router": 90, "ONT o equipo de acceso": 40, "Ventilación auxiliar": 120 } margen_porcentaje = 30 P_base, P_total = calcular_potencia_total( equipos_sala, margen_porcentaje ) print("Equipos considerados:") for equipo, potencia in equipos_sala.items(): print(f"- {equipo}: {potencia} W") print(f"\nPotencia base : {P_base:.2f} W") print(f"Margen de crecimiento : {margen_porcentaje}%") print(f"Potencia total estimada : {P_total:.2f} W") # Cálculo opcional de corriente para alimentación monofásica V_volts = 220 factor_potencia = 0.9 I_aprox = calcular_corriente_monofasica( P_total, V_volts, factor_potencia ) print(f"\nTensión de alimentación : {V_volts} V") print(f"Factor de potencia estimado : {factor_potencia}") print(f"Corriente aproximada : {I_aprox:.2f} A")