NeuralBlitz What I do
- Design and analyze electrical circuits
- Calculate power distribution and loads
- Specify electronic components and subsystems
- Analyze electromagnetic fields and interference
- Design digital and analog electronic systems
- Calculate thermal management for power electronics
- Create wiring diagrams and circuit schematics
When to use me
When designing electronic circuits, calculating power requirements, analyzing signal integrity, or specifying electrical components for systems.
Core Concepts
- Ohm's law and Kirchhoff's laws
- AC/DC circuit analysis
- Semiconductor devices and circuit design
- Power calculation and distribution
- Electromagnetic field theory
- Signal integrity and EMC/EMI
- Digital logic and embedded systems
- Analog filter design
- Power electronics and motor drives
- Printed circuit board design
Code Examples
Circuit Analysis Tools
import numpy as np
from dataclasses import dataclass
from typing import List, Tuple
import cmath
@dataclass
class Component:
value: float
unit: str
@dataclass
class Resistor(Component):
def impedance(self, frequency: float = 0) -> complex:
return self.value
@dataclass
class Capacitor(Component):
def impedance(self, frequency: float) -> complex:
if frequency == 0:
return complex(float('inf'))
return -1j / (2 * np.pi * frequency * self.value)
@dataclass
class Inductor(Component):
def impedance(self, frequency: float) -> complex:
if frequency == 0:
return 0
return 1j * 2 * np.pi * frequency * self.value
def nodal_analysis(
conductances: np.ndarray,
current_sources: np.ndarray
) -> np.ndarray:
"""Solve nodal analysis using modified nodal analysis."""
return np.linalg.solve(conductances, current_sources)
def thevenin_equivalent(
V_th: float,
R_th: float,
R_load: float
) -> Tuple[float, float, float]:
"""Calculate Thevenin equivalent circuit parameters."""
V_load = V_th * R_load / (R_th + R_load)
P_load = V_load**2 / R_load
return V_load, P_load, V_load / R_load
def power_factor_correction(
apparent_power: float,
current_power_factor: float,
target_power_factor: float
) -> Tuple[float, float]:
"""Calculate required capacitor for power factor correction."""
theta1 = np.arccos(current_power_factor)
theta2 = np.arccos(target_power_factor)
Q1 = apparent_power * np.sin(theta1)
Q2 = apparent_power * np.sin(theta2)
Qc = Q1 - Q2
return Qc, Qc / (2 * np.pi * 60)
# Example: Power factor correction
S = 100e3 # VA
pf_current = 0.8
pf_target = 0.95
Qc, C = power_factor_correction(S, pf_current, pf_target)
print(f"Required reactive power compensation: {Qc/1000:.1f} kVAR")
print(f"Required capacitance: {C*1e6:.1f} µF")
Semiconductor Calculations
from dataclasses import dataclass
@dataclass
class MOSFETParameters:
Vds_max: float # V
Id_max: float # A
Rds_on: float # ohms
Vgs_th: float # V
Qg: float # nC
trr: float # ns
@dataclass
class DiodeParameters:
Vr_max: float # V
If_max: float # A
Vf: float # V
trr: float # ns
Ir: float # µA
def mosfet_conduction_loss(
Id: float,
Rds_on: float,
D: float
) -> float:
"""Calculate MOSFET conduction loss."""
return Id**2 * Rds_on * D
def mosfet_switching_loss(
Vds: float,
Ids: float,
tr: float,
tf: float,
fs: float
) -> float:
"""Calculate MOSFET switching loss."""
return 0.5 * Vds * Ids * (tr + tf) * fs
def diode_reverse_recovery_loss(
Irr: float,
trr: float,
Vr: float,
fs: float
) -> float:
"""Calculate diode reverse recovery loss."""
return 0.5 * Vr * Irr * trr * fs
def calculate_ripple_current(
Vin: float,
Vout: float,
L: float,
fs: float,
D: float
) -> float:
"""Calculate inductor ripple current for buck converter."""
return (Vin - Vout) * D / (L * fs)
def buck_converter_design(
Vin: float,
Vout: float,
Io: float,
fs: float,
ripple_percent: float = 0.3
) -> dict:
"""Design basic buck converter parameters."""
D = Vout / Vin
Iripple_max = Io * ripple_percent
L = (Vin - Vout) * D / (Iripple_max * fs)
Ic = Iripple_max / 2
return {
"duty_cycle": D,
"inductance_mH": L * 1000,
"ripple_current": Iripple_max,
"capacitor_ripple": Ic
}
# Example: Buck converter
design = buck_converter_design(12, 5, 2, 100e3)
print(f"Duty cycle: {design['duty_cycle']:.3f}")
print(f"Required inductance: {design['inductance_mH']:.2f} mH")
print(f"Ripple current: {design['ripple_current']:.3f} A")
PCB Design Calculations
def trace_current_capacity(
width: float, # mils
thickness: float, # oz/ft²
temp_rise: float # °C
) -> float:
"""Calculate PCB trace current carrying capacity using IPC-2221."""
if temp_rise <= 10:
return 0.048 * width**0.44 * thickness**0.725
else:
return 0.024 * width**0.44 * thickness**0.725 * (temp_rise / 10)**0.44
def microstrip_impedance(
w: float, # mm
h: float, # mm
Er: float # dielectric constant
) -> float:
"""Calculate microstrip trace impedance."""
if w / h <= 1:
return (87 / (Er + 1.41)**0.5) * np.log(5.98 * h / (0.8 * w + t))
else:
return (87 / (Er + 1.41)**0.5) * np.log(5.98 * h / (0.8 * w + t))
def via_inductance(
length: float, # mm
diameter: float # mm
) -> float:
"""Estimate via inductance."""
return 0.2 * length * np.log(4 * length / diameter)
def decoupling_capacitor_selection(
Cload: float,
Vsupply: float,
allowed_ripple: float,
target_impedance: float,
frequency: float
) -> float:
"""Calculate required decoupling capacitance."""
C = Cload * allowed_ripple / Vsupply
Z = 1 / (2 * np.pi * frequency * C)
return max(C, Vsupply / (target_impedance * 2 * np.pi * frequency * Vsupply))
# Example: PCB trace sizing
trace_width = 50 # mils
copper_thickness = 1 # oz
temp_rise = 20 # °C
current = trace_current_capacity(trace_width, copper_thickness, temp_rise)
print(f"Current capacity: {current:.2f} A")
Power System Calculations
def three_phase_power(
Vll: float, # line-to-line voltage
I: float,
pf: float
) -> float:
"""Calculate three-phase power."""
return np.sqrt(3) * Vll * I * pf
def short_circuit_current(
S_sc: float, # MVA
V: float, # kV
Z_percent: float
) -> float:
"""Calculate short-circuit current."""
return (S_sc * 1000) / (np.sqrt(3) * V * Z_percent / 100)
def voltage_drop_calculation(
I: float,
R: float,
X: float,
pf: float
) -> float:
"""Calculate voltage drop in percent."""
return I * (R * pf + X * np.sin(np.arccos(pf))) / 10
def cable_sizing_current(
I_load: float,
derating_factor: float = 0.8,
correction_factor: float = 1.0
) -> float:
"""Calculate required cable ampacity."""
return I_load / (derating_factor * correction_factor)
def transformer_sizing(
S_kVA: float,
efficiency: float = 0.97,
load_factor: float = 0.8
) -> float:
"""Calculate transformer kVA rating."""
return S_kVA / (efficiency * load_factor)
# Example: Power distribution
load_current = 150 # A
voltage = 480 # V
pf = 0.85
power = three_phase_power(voltage, load_current, pf)
print(f"Three-phase power: {power/1000:.1f} kW")
Best Practices
- Use proper grounding techniques to minimize noise and ensure safety
- Include appropriate margins in component ratings for reliability
- Perform thermal analysis for power electronic components
- Consider EMI/EMC requirements early in the design process
- Use decoupling capacitors near IC power pins for noise suppression
- Follow IPC standards for PCB design and manufacturing
- Calculate worst-case conditions including temperature extremes
- Include proper fusing and overcurrent protection in designs
- Use appropriate wire gauges based on current carrying requirements
- Document schematics with clear component values and tolerances