Before diving into the simulation, recall that an RC circuit consists of a resistor (`R`) and a capacitor (`C`) connected in series. When a voltage is suddenly applied, the capacitor voltage rises gradually, following the equation:  
`Vc(t) = V * (1 - exp(-t/(R*C)))`  
where `Vc(t)` is the voltage across the capacitor at time `t`, `V` is the supply voltage, `R` is resistance, and `C` is capacitance. The time constant `τ = R*C` indicates how quickly the capacitor charges. After one time constant, the capacitor voltage reaches approximately **63%** of its final value. This property is fundamental for timing, filtering, and transient response analysis in electrical engineering.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
import sys
import numpy as np
from unittest.mock import patch
import matplotlib
matplotlib.use('Agg')  # Use non-interactive backend for testing

class TestTask(unittest.TestCase):
    def test_time_constant_calculation(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show to prevent plot window
        with patch('matplotlib.pyplot.show'):
            captured = io.StringIO()
            sys.stdout = captured
            user_code.simulate_rc_charging(1000, 10e-6, 5, 5)
            sys.stdout = sys.__stdout__
            output = captured.getvalue().strip()
        try:
            tau_printed = float(output)
        except Exception:
            tau_printed = None
        _dynamic_test(
            self,
            tau_printed is not None and abs(tau_printed - 0.01) < 1e-6,
            "Time constant is correctly calculated and printed as 0.01",
            f"Expected time constant 0.01, got {output}",
        )

    def test_voltage_curve_calculation(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show to prevent plot window
        with patch('matplotlib.pyplot.show'):
            R, C, V, t_end = 1000, 10e-6, 5, 5
            t = np.linspace(0, t_end, 500)
            expected_vc = V * (1 - np.exp(-t / (R * C)))
            # Patch plt.plot to capture data
            with patch('matplotlib.pyplot.plot') as mock_plot:
                user_code.simulate_rc_charging(R, C, V, t_end)
                called = False
                for call in mock_plot.call_args_list:
                    args, kwargs = call
                    if len(args) >= 2:
                        t_arg, vc_arg = args[0], args[1]
                        if isinstance(t_arg, np.ndarray) and isinstance(vc_arg, np.ndarray):
                            # Check that curves match closely
                            if np.allclose(vc_arg, expected_vc, rtol=1e-3, atol=1e-3):
                                called = True
                                break
                _dynamic_test(
                    self,
                    called,
                    "Voltage curve is computed and plotted using RC charging equation.",
                    "Voltage curve was not correctly computed or plotted.",
                )

    def test_63_percent_voltage_line(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show to prevent plot window
        with patch('matplotlib.pyplot.show'):
            V = 5
            tau_voltage = V * (1 - np.exp(-1))
            with patch('matplotlib.pyplot.axhline') as mock_axhline:
                user_code.simulate_rc_charging(1000, 10e-6, 5, 5)
                found = False
                for call in mock_axhline.call_args_list:
                    args, kwargs = call
                    if 'y' in kwargs:
                        yval = kwargs['y']
                    elif len(args) > 0:
                        yval = args[0]
                    else:
                        continue
                    if abs(yval - tau_voltage) < 1e-3:
                        found = True
                        break
                _dynamic_test(
                    self,
                    found,
                    "63% voltage level is marked on the plot.",
                    "63% voltage level was not marked on the plot.",
                )

    def test_time_constant_vertical_line(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show to prevent plot window
        with patch('matplotlib.pyplot.show'):
            tau = 1000 * 10e-6
            with patch('matplotlib.pyplot.axvline') as mock_axvline:
                user_code.simulate_rc_charging(1000, 10e-6, 5, 5)
                found = False
                for call in mock_axvline.call_args_list:
                    args, kwargs = call
                    if 'x' in kwargs:
                        xval = kwargs['x']
                    elif len(args) > 0:
                        xval = args[0]
                    else:
                        continue
                    if abs(xval - tau) < 1e-6:
                        found = True
                        break
                _dynamic_test(
                    self,
                    found,
                    "Time constant is marked on the plot.",
                    "Time constant was not marked on the plot.",
                )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Explore how Python empowers electrical engineers to analyze circuits, process signals, and model systems. This course blends practical coding with real-world electrical engineering scenarios, using Python and its scientific libraries to solve authentic engineering problems.

Learn how Python can be used to analyze electrical circuits, calculate parameters, and visualize circuit behavior.

Discover how Python can be used to analyze, visualize, and process electrical signals relevant to engineering applications.

Use Python to model, simulate, and visualize electrical systems and their dynamic behavior.

Challenge: Simulate an RC Charging Circuit

Oplossing

Challenge: Simulate an RC Charging Circuit

Oplossing