When connecting a sensor to a microcontroller, you often need to adjust voltage levels for compatibility and safety. A common approach is to use a voltage divider, which consists of two resistors (`R1` and `R2`) in series. The output voltage (`Vout`) is taken across `R2`, and is given by the formula:

```
Vout = Vin * (R2 / (R1 + R2))
```

Here, `Vin` is the input voltage from the sensor, and you want `Vout` to match the microcontroller's maximum input voltage. Selecting resistor values that are both practical and available is crucial. The E12 series (values like 1.0kΩ, 1.2kΩ, 1.5kΩ, etc.) is a standard set of resistor values commonly found in electronics. Using standard values ensures your circuit can be built with off-the-shelf components, reducing cost and complexity.

In this challenge, you will design a voltage divider to safely connect a 5V sensor output to a 3.3V microcontroller input. You will calculate resistor values, verify if they are standard E12 values, and adjust if necessary to achieve the closest possible output voltage.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_find_closest_e12_exact(self):
        import user_code
        importlib.reload(user_code)
        # Test if exact E12 value is returned
        result = user_code.find_closest_e12(4700)
        _dynamic_test(
            self,
            result == 4700,
            "find_closest_e12 returns the exact value for E12 input (4700)",
            f"Expected 4700, got {result}",
        )

    def test_find_closest_e12_nearest(self):
        import user_code
        importlib.reload(user_code)
        # 5000 is not E12, closest is 4.7k (4700)
        result = user_code.find_closest_e12(5000)
        _dynamic_test(
            self,
            result == 4700 or result == 5600,  # both are valid, check proximity
            "find_closest_e12 returns nearest E12 value for non-E12 input (5000)",
            f"Expected 4700 or 5600, got {result}",
        )

    def test_design_voltage_divider_default(self):
        import user_code
        importlib.reload(user_code)
        # Standard task: 5V to 3.3V, preferred R2 = 10k
        r1, r2, vout = user_code.design_voltage_divider(5.0, 3.3)
        _dynamic_test(
            self,
            r2 in [10000, 12000],
            "R2 is a standard E12 value near 10k",
            f"R2 not standard E12 value: {r2}",
        )
        _dynamic_test(
            self,
            r1 in [4700, 5600],
            "R1 is a standard E12 value near calculated ideal",
            f"R1 not standard E12 value: {r1}",
        )
        v_expected = 5.0 * (r2 / (r1 + r2))
        _dynamic_test(
            self,
            abs(vout - v_expected) < 0.01,
            "Output voltage is correctly calculated",
            f"Expected output voltage {v_expected}, got {vout}",
        )

    def test_design_voltage_divider_other(self):
        import user_code
        importlib.reload(user_code)
        # 12V to 5V, preferred R2 = 4700
        r1, r2, vout = user_code.design_voltage_divider(12.0, 5.0, preferred_r2=4700)
        _dynamic_test(
            self,
            r2 in [4700, 5600],
            "R2 is a standard E12 value near 4700",
            f"R2 not standard E12 value: {r2}",
        )
        # Calculate ideal R1
        r1_ideal = r2 * (12.0 - 5.0) / 5.0
        # The closest E12 value should be selected
        e12_vals = [1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 6.8, 8.2]
        multipliers = [1, 10, 100, 1000, 10000, 100000, 1000000]
        candidates = [base * m for m in multipliers for base in e12_vals]
        r1_expected = min(candidates, key=lambda x: abs(x - r1_ideal))
        _dynamic_test(
            self,
            r1 == r1_expected,
            "R1 is the closest E12 value to the ideal",
            f"Expected R1 {r1_expected}, got {r1}",
        )
        v_expected = 12.0 * (r2 / (r1 + r2))
        _dynamic_test(
            self,
            abs(vout - v_expected) < 0.01,
            "Output voltage is correctly calculated for 12V to 5V",
            f"Expected output voltage {v_expected}, got {vout}",
        )

    def test_design_voltage_divider_small_values(self):
        import user_code
        importlib.reload(user_code)
        # 3.3V to 1.8V, preferred R2 = 1000
        r1, r2, vout = user_code.design_voltage_divider(3.3, 1.8, preferred_r2=1000)
        _dynamic_test(
            self,
            r2 in [1000, 1200],
            "R2 is a standard E12 value near 1k",
            f"R2 not standard E12 value: {r2}",
        )
        v_expected = 3.3 * (r2 / (r1 + r2))
        _dynamic_test(
            self,
            abs(vout - v_expected) < 0.01,
            "Output voltage is correctly calculated for 3.3V to 1.8V",
            f"Expected output voltage {v_expected}, got {vout}",
        )

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: Design a Sensor Interface

Lösning