Add new real-time exercise

Set up MVVM architecture with placeholder components for a PyQt5 and VisPy-based real-time RMS signal plotting app. Includes basic files for main logic, signal processing, plot view, main view, and updated dependencies (PyQt5, VisPy). All components are scaffolded with TODOs for future feature development.

Author: RaulSimpetru

exercises/04/04_exercise/README.md

@@ -0,0 +1,163 @@
+# Live RMS Signal Plotting Exercise
+
+This exercise implements a real-time signal plotting application using the MVVM (Model-View-ViewModel) architecture pattern. The application displays a live plot of a signal's Root Mean Square (RMS) value over time, demonstrating the use of PyQt5 for the UI and VisPy for high-performance plotting.
+
+## Application Overview
+
+The application provides:
+- A live plot showing the RMS value of a signal over time
+- A control button to start/stop the plotting
+- A fixed view range for consistent visualization
+- Real-time updates at 30 Hz
+
+## MVVM Architecture
+
+The application follows the MVVM (Model-View-ViewModel) pattern, which separates the application into three main components:
+
+### Model
+- Handles data generation and signal processing
+- Provides raw signal data and RMS calculations
+- Already implemented for you
+
+### View
+- Manages the user interface components
+- Consists of two main classes:
+  1. `MainView`: Main window with plot and controls
+  2. `VisPyPlotWidget`: Custom widget for high-performance plotting
+- Contains TODOs for UI setup and signal connections
+
+### ViewModel
+- Acts as a mediator between Model and View
+- Manages the application state and business logic
+- Handles data updates and plotting state
+- Contains TODOs for signal processing and state management
+
+## Implementation Tasks
+
+### 1. Main Application (`main.py`)
+TODOs:
+- Import necessary classes (MainView and MainViewModel)
+- Create ViewModel instance
+- Create View instance with ViewModel
+- Show the main window
+
+### 2. View Layer (`view/mainView.py`)
+TODOs:
+- Connect ViewModel signals to appropriate slots
+- Implement plotting toggle functionality
+
+### 3. Plot Widget (`view/plotView.py`)
+TODOs:
+- Set up the VisPy canvas and layout
+- Create and configure the plot view
+- Implement the line plot visualization
+- Set up fixed view ranges
+- Implement data update mechanism
+
+### 4. ViewModel Layer (`viewmodel/mainViewModel.py`)
+TODOs:
+- Implement the update_data method to:
+  - Get current window of data
+  - Handle window padding
+  - Emit new data
+  - Update current index
+  - Handle end of data reset
+
+## VisPy Guide
+
+VisPy is a high-performance visualization library that uses OpenGL for efficient plotting. Here's a basic example of how to create a simple line plot with VisPy:
+
+```python
+from PyQt5.QtWidgets import QWidget, QVBoxLayout
+from vispy import scene
+import numpy as np
+
+class SimplePlotWidget(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        
+        # Create layout
+        layout = QVBoxLayout()
+        self.setLayout(layout)
+        
+        # Create canvas
+        self.canvas = scene.SceneCanvas(keys='interactive', size=(800, 400))
+        layout.addWidget(self.canvas.native)
+        
+        # Create view
+        self.view = self.canvas.central_widget.add_view()
+        self.view.camera = 'panzoom'
+        
+        # Create line plot
+        x = np.linspace(0, 10, 100)
+        y = np.sin(x)
+        self.line = scene.Line(np.column_stack((x, y)), parent=self.view.scene)
+        
+        # Set view range
+        self.view.camera.set_range(x=(0, 10), y=(-1, 1))
+```
+
+Key VisPy concepts:
+1. **Canvas**: The main drawing area (SceneCanvas)
+2. **View**: A region of the canvas where visuals are drawn
+3. **Camera**: Controls how the view is displayed (panzoom for interactive navigation)
+4. **Visuals**: Objects that can be drawn (Line, Markers, etc.)
+5. **Scene**: The container for all visuals
+
+Common operations:
+- Creating a line: `scene.Line(data, parent=view.scene)`
+- Updating data: `line.set_data(new_data)`
+- Setting view range: `view.camera.set_range(x=(min, max), y=(min, max))`
+- Updating canvas: `canvas.update()`
+
+## Technical Details
+
+### Signal Processing
+- Window size: 10 seconds
+- Sampling rate: 2048 Hz
+- Update rate: 30 Hz
+- Signal type: Sine wave with added noise
+
+### Dependencies
+- PyQt5: For the user interface
+- NumPy: For numerical computations
+- VisPy: For high-performance OpenGL-based plotting
+
+## Getting Started
+
+1. Review the code structure and TODOs in each file
+2. Implement the missing components in the following order:
+   - Main application setup
+   - Plot widget setup and visualization
+   - View signal connections
+   - ViewModel data update logic
+3. Test the application by running `main.py`
+
+## Tips for Implementation
+
+1. **Main Application**:
+   - Import classes from the correct modules
+   - Create ViewModel before View
+   - Show the window after setup
+
+2. **View Layer**:
+   - Use PyQt5's signal-slot mechanism for UI updates
+   - Connect all necessary signals to their slots
+
+3. **Plot Widget**:
+   - Use VisPy's SceneCanvas for efficient plotting
+   - Maintain fixed view ranges for consistent visualization
+   - Handle data updates efficiently
+
+4. **ViewModel Layer**:
+   - Handle window padding correctly
+   - Update the current index properly
+   - Reset when reaching the end of data
+
+## Testing
+
+After implementation, verify that:
+- The plot updates smoothly in real-time
+- The start/stop button works correctly
+- The view range remains fixed
+- The application handles data updates efficiently 

exercises/04/04_exercise/main.py

@@ -0,0 +1,17 @@
+from PyQt5.QtWidgets import QApplication
+import sys
+
+# TODO: Import the MainView class from view.mainView
+# TODO: Import the MainViewModel class from viewmodel.mainViewModel
+
+def main():
+    app = QApplication(sys.argv)
+    
+    # TODO: Create an instance of MainViewModel
+    # TODO: Create an instance of MainView and pass the viewmodel
+    # TODO: Show the main window
+    
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    main() 

exercises/04/04_exercise/services/signal_processor.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+class SignalProcessor:
+    """
+    Service class for signal processing and generation.
+    
+    This class is part of the Model layer in the MVVM architecture.
+    """
+    
+    def __init__(self, window_size=10, sampling_rate=2048):
+        """
+        Initialize the signal processor.
+        
+        Args:
+            window_size: Size of the time window in seconds
+            sampling_rate: Sampling rate in Hz
+        """
+        self.window_size = window_size
+        self.sampling_rate = sampling_rate
+        self.points_per_window = window_size * sampling_rate
+        
+    def generate_test_signal(self, duration=60):
+        """
+        Generate a test signal (sine wave with noise).
+        
+        Args:
+            duration: Duration of the signal in seconds
+            
+        Returns:
+            tuple: (time_points, signal_data)
+        """
+        # Generate time points
+        time_points = np.linspace(0, duration, int(duration * self.sampling_rate))
+        
+        # Generate sine wave (1 Hz) with noise
+        signal = np.sin(2 * np.pi * time_points) + 0.1 * np.random.randn(len(time_points))
+        
+        return time_points, signal
+        
+    def get_window(self, data, start_idx, window_size):
+        """
+        Get a window of data.
+        
+        Args:
+            data: Full signal data array
+            start_idx: Starting index
+            window_size: Size of the window in samples
+            
+        Returns:
+            numpy.ndarray: Window of data
+        """
+        # TODO: Implement window extraction
+        # - Extract window of data
+        # - Handle end of data case
+        pass 

exercises/04/04_exercise/view/mainView.py

@@ -0,0 +1,72 @@
+from PyQt5.QtWidgets import QMainWindow, QWidget, QVBoxLayout, QPushButton
+from PyQt5.QtCore import Qt
+from .plotView import VisPyPlotWidget
+
+# TODO: Import the PlotView class from plotView
+
+class MainView(QMainWindow):
+    """
+    Main application window that combines the plot widget and controls.
+    
+    This class is part of the View layer in the MVVM architecture. It:
+    - Creates and manages the main window layout
+    - Contains the plot widget and control buttons
+    - Connects the ViewModel signals to the View
+    - Handles user interactions
+    
+    The window provides a simple interface with:
+    - A plot widget showing the live signal
+    - A button to start/stop the plotting
+    """
+    
+    def __init__(self, view_model):
+        """
+        Initialize the main window with plot widget and controls.
+        
+        Args:
+            view_model: The ViewModel that manages the data and plotting state
+        """
+        super().__init__()
+        self.view_model = view_model
+        
+        # Set up the main window
+        self.setWindowTitle("Live RMS Plot")
+        self.setGeometry(100, 100, 800, 500)
+        
+        # Create central widget and layout
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        layout = QVBoxLayout(central_widget)
+        
+        # Create plot widget
+        self.plot_widget = VisPyPlotWidget()
+        layout.addWidget(self.plot_widget)
+        
+        # Create control button
+        self.control_button = QPushButton("Start Plotting")
+        self.control_button.clicked.connect(self.toggle_plotting)
+        layout.addWidget(self.control_button)
+        
+        # TODO: Connect view model signals
+        # In MVVM, the View needs to connect to the ViewModel's signals to receive updates
+        # The ViewModel has a signal called 'data_updated' that emits new data
+        # You need to connect this signal to the plot widget's update_data method
+        # This is how the ViewModel communicates new data to the View
+        # Hint: Use the connect() method on the signal, similar to how the button's clicked signal is connected
+        
+    def toggle_plotting(self):
+        """
+        Toggle the plotting state and update button text.
+        """
+        # TODO: Implement plotting toggle
+        # This method is called when the control button is clicked
+        # You need to:
+        # 1. Check the current plotting state using view_model.is_plotting
+        # 2. If plotting is active:
+        #    - Update button text to "Start Plotting"
+        #    - Call view_model.stop_plotting() to stop the data flow
+        # 3. If plotting is inactive:
+        #    - Update button text to "Stop Plotting"
+        #    - Call view_model.start_plotting() to start the data flow
+        # This method demonstrates the View's role in handling user input and updating the UI
+        pass 

exercises/04/04_exercise/view/plotView.py

@@ -0,0 +1,75 @@
+from PyQt5.QtWidgets import QWidget, QVBoxLayout
+from vispy import app, scene
+import numpy as np
+
+class VisPyPlotWidget(QWidget):
+    """
+    A widget that displays live plotting using VisPy.
+    
+    This class is part of the View layer in the MVVM architecture. It:
+    - Creates and manages the VisPy canvas
+    - Handles the visualization of the signal
+    - Maintains a fixed view range
+    - Updates the plot with new data
+    
+    The widget uses VisPy for high-performance OpenGL-based plotting,
+    which is essential for smooth real-time updates.
+    """
+    
+    def __init__(self, parent=None):
+        """
+        Initialize the plot widget with VisPy canvas and view.
+        
+        Args:
+            parent: Parent widget (optional)
+        """
+        super().__init__(parent)
+        
+        # TODO: Set up the widget
+        # First, create a QVBoxLayout to organize the widget's contents
+        # Then, set this layout as the widget's layout using setLayout()
+        # This layout will hold the VisPy canvas
+        
+        # TODO: Create VisPy canvas
+        # Create a SceneCanvas with size (800, 400) for the plot
+        # The canvas is the main drawing area for VisPy
+        # Add the canvas to the layout using addWidget(canvas.native)
+        # The .native property is needed because VisPy's canvas needs to be converted to a Qt widget
+        
+        # TODO: Create view
+        # Add a view to the canvas's central widget
+        # Set the camera to 'panzoom' to allow interactive navigation
+        # The view is where we'll add our plot elements
+        
+        # TODO: Create line plot
+        # Create a Line visual with initial data [[0, 0]]
+        # Add this line to the view's scene
+        # This line will be updated with new data points
+        
+        # TODO: Set up view range
+        # Set a fixed range for the x-axis (0 to 10 seconds)
+        # Set a fixed range for the y-axis (-10 to 10 for RMS values)
+        # This ensures the plot maintains a consistent view
+        
+    def update_data(self, time_points, data):
+        """
+        Update the plot with new data.
+        
+        This method is called whenever new data is available. It:
+        - Creates a new line data array from time and signal data
+        - Updates the plot with the new data
+        - Maintains the fixed view range
+        
+        Args:
+            time_points (np.ndarray): Array of time values
+            data (np.ndarray): Array of signal values
+        """
+        # TODO: Update plot data
+        # 1. Create the line data by stacking time_points and data arrays
+        #    Use np.column_stack() to combine them into a 2D array
+        #    Each row will be [time, value] pair
+        # 2. Update the line visual with the new data using set_data()
+        # 3. Keep the view range fixed by setting the camera range again
+        # 4. Update the canvas to show the changes
+        # This method is called by the ViewModel when new data is available
+        pass