In previous chapters, you explored the basics of signals, waveforms, and filtering techniques in Python. Now, you will apply these concepts to a practical scenario—reducing noise in sensor data. Sensor readings in real-world electrical engineering applications are often affected by random noise, making it challenging to interpret the true signal. To address this, you can simulate a noisy sensor signal by generating a sine wave (representing the ideal temperature variation) and adding random noise to it. The next step is to apply a moving average filter, which is a simple yet effective way to smooth out short-term fluctuations and highlight longer-term trends in the data. By plotting both the original noisy signal and the filtered output, you can visually compare the effectiveness of the noise reduction technique.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import numpy as np

class TestTask(unittest.TestCase):
    def test_generate_noisy_signal_length(self):
        import user_code
        importlib.reload(user_code)
        length = 100
        amplitude = 2.0
        frequency = 1.5
        noise_level = 0.3
        t, noisy_signal = user_code.generate_noisy_signal(length, amplitude, frequency, noise_level)
        _dynamic_test(
            self,
            isinstance(t, np.ndarray) and isinstance(noisy_signal, np.ndarray) and len(t) == length and len(noisy_signal) == length,
            "generate_noisy_signal returns arrays of correct length",
            f"Expected arrays of length {length}, got {len(t)} and {len(noisy_signal)}"
        )

    def test_generate_noisy_signal_variation(self):
        import user_code
        importlib.reload(user_code)
        length = 200
        amplitude = 1.0
        frequency = 2.0
        noise_level = 0.7
        t, noisy_signal1 = user_code.generate_noisy_signal(length, amplitude, frequency, noise_level)
        _, noisy_signal2 = user_code.generate_noisy_signal(length, amplitude, frequency, noise_level)
        # Check that signals with different noise are not identical
        _dynamic_test(
            self,
            not np.array_equal(noisy_signal1, noisy_signal2),
            "Noisy signal contains random variation",
            "Noisy signal should vary between runs but identical outputs were produced"
        )

    def test_moving_average_filter_length(self):
        import user_code
        importlib.reload(user_code)
        data = np.random.rand(120)
        window_size = 11
        filtered = user_code.moving_average_filter(data, window_size)
        _dynamic_test(
            self,
            isinstance(filtered, np.ndarray) and len(filtered) == len(data),
            "moving_average_filter returns array of same length as input",
            f"Expected filtered length {len(data)}, got {len(filtered)}"
        )

    def test_moving_average_filter_smoothness(self):
        import user_code
        importlib.reload(user_code)
        np.random.seed(0)
        length = 200
        t, noisy_signal = user_code.generate_noisy_signal(length, 1.0, 2.0, 0.5)
        window_size = 15
        filtered = user_code.moving_average_filter(noisy_signal, window_size)
        # Smoother means lower standard deviation of first derivative (difference)
        noisy_diff = np.diff(noisy_signal)
        filtered_diff = np.diff(filtered)
        _dynamic_test(
            self,
            np.std(filtered_diff) < np.std(noisy_diff),
            "Filtered signal is smoother than original noisy signal",
            f"Filtered signal not smoother: std(diff) noisy={np.std(noisy_diff)}, filtered={np.std(filtered_diff)}"
        )

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: Noise Reduction in Sensor Data

Solução