Método + software

01 · Punto de partida

Del tema suelto al análisis completo

Sabés Ohm, equivalentes, Kirchhoff, divisores, transitorios y fuentes. Lo que falta es el orden de batalla que los combina ante un circuito desconocido, y las herramientas que hacen el trabajo repetitivo: tu toolkit Python de 34 temas, una planilla ordenada o un simulador. Método + software = análisis en serio.

Este tema es el manual de operaciones del proyecto final (Tema 36).

• ¿Cuál es el paso a paso ante un circuito nuevo?
• ¿Qué resuelvo a mano y qué delego?
• ¿Cómo uso un simulador sin creerle todo?
• ¿Cómo se cierra con un informe?

02 · Método

Los 7 pasos, con entregable cada uno

1. 1
   Leer el esquema.

   Símbolos, valores, GND, fuente (Tema 20, curso 1). Entregable: nodos nombrados.

2. 2
   Contar y clasificar.

   Nodos, ramas, mallas (Tema 16); serie/paralelo/mixto o Kirchhoff. Entregable: plan (qué leyes aplican).

3. 3
   Predecir con números.

   Ohm, equivalentes, divisores, τ; a mano lo chico, con toolkit lo repetitivo. Entregable: tabla de predicciones.

4. 4
   Montar y auditar en frío.

   Protoboard + continuidad (curso 1). Entregable: montaje verificado sin energía.

5. 5
   Medir lo predicho.

   V por nodo, R sin pila, I inferida (Tema 6). Entregable: tabla de medidas.

6. 6
   Dictaminar.

   Error % por magnitud, KCL/KVL con tolerancia (Tema 20). Entregable: verde o causa.

7. 7
   Documentar.

   Esquema + mapa + BOM + tablas + dictamen (Tema 28, curso 1). Entregable: informe repetible.

03 · Toolkit

Tu biblioteca de 34 temas en una función

Todo el curso cabe en un puñado de funciones que ya escribiste por partes. Acá, reunidas y listas para el proyecto:

def ohm_req(vs, r_total):
    return vs / r_total


def req_serie(rs):
    return sum(rs)


def req_paralelo(rs):
    return 1 / sum(1 / r for r in rs)


def divisor(vs, r1, r2):
    return vs * r2 / (r1 + r2)


def tau_rc(r, c_uF):
    return r * c_uF * 1e-6


def veredicto(predicho, medido, tol_pct=10.0):
    err = abs(medido - predicho) / abs(predicho) * 100
    print(f"pred {predicho} med {medido} -> error {err:.1f}% ->",
          "OK" if err <= tol_pct else "REVISAR")
    return err


# Chequeo del toolkit con el serie clásico
I = ohm_req(9, req_serie([470, 1000]))
print(f"I = {I*1000:.1f} mA")
veredicto(7.05, 6.8)

Agregá tau_rl() y potencia() de temas anteriores: el toolkit crece con vos.

Análisis integral de ejemplo

Divisor 9 V 2k/1k con carga 10k, resuelto punta a punta:

def req_paralelo(rs):
    return 1 / sum(1 / r for r in rs)


vs, r1, r2, rl = 9, 2000, 1000, 10000
v_vacio = divisor(vs, r1, r2)
r2eq = req_paralelo([r2, rl])
v_car = divisor(vs, r1, r2eq)
itot = vs / (r1 + r2eq)
print(f"Vacío {v_vacio:.2f}V Cargado {v_car:.2f}V Error {(v_car-3)/3*100:+.0f}%")
print(f"Itot={itot*1000:.1f}mA P_R1={(vs-v_car)*itot*1000:.0f}mW P_R2={v_car**2/r2*1000:.0f}mW")
veredicto(3.0, round(v_car, 2), tol_pct=10.0)

04 · Simuladores

Qué son y cómo usarlos sin autoengañarse

Un simulador (CircuitJS/Falstad en el navegador, LTspice en PC) resuelve las ecuaciones por vos y anima corrientes. Úsalo como tercer opinante: cálculo ↔ simulación ↔ medición deben coincidir las tres.

Regla de las tres coincidencias

Cálculo, simulación y medida deben cerrar entre sí dentro de tolerancia. Dos que coinciden contra una tercera señalan dónde buscar.

Basura entra, basura sale

Un esquema mal dibujado simula perfecto... lo incorrecto. Verificar el esquema antes de simular (Tema 20, curso 1).

Transitorios gratis

La curva RC/RL que a ojo cuesta, el simulador la dibuja: úsalo para los Temas 30–32 antes de medir.

Límites honestos

No modela temperatura, tolerancias ni protoboard real. Para diseño fino se agrega margen manual (Tema 5).

05 · Analogía programador

CI/CD del hardware

1. 1
   Toolkit = librería interna.

   Funciones probadas que encapsulan el dominio: importar en vez de recalcular. Tu ohm_req() es un package.

2. 2
   Simulador = staging.

   Entorno que imita prod sin sus costos: se rompe gratis. Pero staging no es prod (tolerancias).

3. 3
   Informe = release.

   El deploy termina en release notes con métricas: predicción, medida, error y dictamen por magnitud.

06 · Guía interactiva

Laboratorio: ¿en qué fase estoy?

Elegí tu fase del método: el laboratorio te dice la tarea, el entregable y la trampa típica. Usalo como checklist del Tema 36.

Preguntas para explorar

1. ¿Qué fase saltean los apurados y qué les cuesta después?
2. ¿Dónde entra el simulador sin romper el método?
3. ¿Qué entregable te falta más seguido en tu cuaderno?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios de método

Ejercicio 1: triple coincidencia

Divisor 9 V 2k/1k + RL 10k: predecí con taller_divisor() (Tema 25), simulá mentalmente con Req y medí en mesa. ¿Cierran las tres dentro del 10 %?

Ejercicio 2: cazar el error plantado

Alguien informa “serie 9 V [1k, 2k2]: I = 12 mA, V1 = 12 V”. Aplicá el método (fases 1–3 en papel): ¿qué está mal y cómo lo detectás sin montar?

Ejercicio 3: ampliar el toolkit

Agregá a tu toolkit tau_rc(), divisor_i() y kcl() de temas previos en un solo bloque. Ejecutá un chequeo integral del mixto (470+1k)∥2k2.

09 · Síntesis

Ideas para recordar

Método y herramientas listos. Solo falta la obra completa: en el próximo y último tema, el proyecto integrador calculado.