fix

Author: benpaddlejones

tutorials/Lecture1.md

@@ -2,18 +2,71 @@
 
 ## Lecture 1 Concepts
 - Unit Testing
+- UML (Unified Modelling Language)
 - Generalisation
 - Parent/Child Class
 - Pin & PWM Parent Classes
 - Instantiation
 - Inheritance
 
+
 ## Unit Testing
 
 Unit testing is the process of writing and running small, isolated tests that check the correctness of individual pieces of code (such as functions or modules). The goal is to ensure that each unit of your embedded software works as expected, independently from the rest of the system.
 
 Unit testing is especially valuable in embedded systems, such as the Pi Pico, where debugging can be challenging due to limited resources and hardware complexity. By ensuring each component works independently, you can build more complex mechatronic solutions.
 
+## UML Class Diagrams
+
+A UML (Unified Modelling Language) class diagram visually describes the structure of a system by showing its classes, their attributes (variables), methods (functions), and relationships (like inheritance).
+
+```text
+----------------------
+|     Student        |   <-- Class Name
+----------------------
+| -name: String      |   <-- Attributes
+| -age: int          |
+----------------------
+| +getName(): String |   <-- Methods
+| +setAge(int): void |
+----------------------
+```
+
+### Mermaid Markdown UML Class Diagram Example
+Below is a Mermaid class diagram for a Pi Pico GPIO Pin and a custom Led_Light class that inherits from it.
+
+```mermaid
+classDiagram
+
+    class Pin {
+        -pin: int
+        +__init__(pin: int)
+        +value()
+        +high()
+        +low()
+        +toggle()
+    }
+
+    class Led_Light {
+        -debug: bool
+        -pin: int
+        -flashing: bool
+        +__init__(pin: int, flashing: bool, debug: bool)
+        +on()
+        +off()
+        +toggle()
+    }
+    Pin <|-- Led_Light : inherits
+```
+
+Explanation:
+
+1. Class Name (Top Section): This is the uppermost part of the box. It displays the name of the class (e.g., Student, Order, Car).
+2. Attributes (Middle Section): This section lists the attributes (or properties/fields) of the class. Each attribute is typically shown with its visibility (+ for public, - for private, # for protected), name, and type.
+3. Methods (Bottom Section): This section lists the methods (or operations/functions) that belong to the class.
+Each method is shown with its visibility, name, parameters, and return type.
+4. Connections (lines and arrows): These lines and arrows represent relationships (such as inheritance, association, aggregation, and composition) between class boxes.
+
 ## Generalisation
 
 On the Pi Pico, the Pin and PWM libraries are designed to be generalised to provide flexible and reusable interfaces for interacting with the microcontroller’s hardware. The simple `on()`, `off()` or `high()`, `low()` methods are not specific to any hardware but are generalised to the nature of a digital GPIO Pin. As a generalised class is inherited and the classes are extended, they become more specific (less generalised) and functional to specific hardware for which they are designed.

tutorials/Lecture2.md

@@ -1,69 +1,19 @@
 # Lecture 2
 
 ## Lecture 2 Concepts
-- UML (Unified Modelling Language)
 - Overriding Polymorphism
 - DRY
+- Encapsulation
+- Setters & Getters
 - Overloading Polymorphism
 
-## UML Class Diagrams
-
-A UML (Unified Modelling Language) class diagram visually describes the structure of a system by showing its classes, their attributes (variables), methods (functions), and relationships (like inheritance).
-
-```text
-----------------------
-|     Student        |   <-- Class Name
-----------------------
-| -name: String      |   <-- Attributes
-| -age: int          |
-----------------------
-| +getName(): String |   <-- Methods
-| +setAge(int): void |
-----------------------
-```
-
-### Mermaid Markdown UML Class Diagram Example
-Below is a Mermaid class diagram for a Pi Pico GPIO Pin and a custom Led_Light class that inherits from it.
-
-```mermaid
-classDiagram
-
-    class Pin {
-        -pin: int
-        +__init__(pin: int)
-        +value()
-        +high()
-        +low()
-        +toggle()
-    }
-
-    class Led_Light {
-        -debug: bool
-        -pin: int
-        -flashing: bool
-        +__init__(pin: int, flashing: bool, debug: bool)
-        +on()
-        +off()
-        +toggle()
-    }
-    Pin <|-- Led_Light : inherits
-```
-
-Explanation:
-
-1. Class Name (Top Section): This is the uppermost part of the box. It displays the name of the class (e.g., Student, Order, Car).
-2. Attributes (Middle Section): This section lists the attributes (or properties/fields) of the class. Each attribute is typically shown with its visibility (+ for public, - for private, # for protected), name, and type.
-3. Methods (Bottom Section): This section lists the methods (or operations/functions) that belong to the class.
-Each method is shown with its visibility, name, parameters, and return type.
-4. Connections (lines and arrows): These lines and arrows represent relationships (such as inheritance, association, aggregation, and composition) between class boxes.
-
 ## Overriding Polymorphism
 
 **Polymorphism means “many forms.”**
 
 Polymorphism Overriding occurs when a child class (subclass) provides a new implementation for a method it inherits from its parent class (superclass).
 
-The method in the child class has the same name and parameters as the one in the parent class. When the method is called on an object of the child class, Python (or any object-oriented language) uses the child’s version—even if the object is referenced using the parent type.
+The method in the child class has the same name and parameters as the one in the parent class. When the method is called on an object of the child class, Python (or any object-oriented language) uses the child’s version, even if the object is referenced using the parent type.
 
 ```python
 from machine import Pin
@@ -107,6 +57,7 @@ while True:
 ```
 
 ## DRY
+
 The DRY pattern stands for "**Don't Repeat Yourself**"; it is a fundamental principle of programming aimed at reducing repetition of code and logic. This is to avoid duplicating code, logic, or data.
 
 ### Why Use DRY?
@@ -160,6 +111,59 @@ The DRY pattern stands for "**Don't Repeat Yourself**"; it is a fundamental prin
            self.off()
 
 ```
+## Encapsulation
+Encapsulation restricts direct access to some of an object's components (such as attributes or methods), meaning the internal representation of the object is hidden from the outside. This is typically achieved by making certain attributes or methods private (i.e., inaccessible from outside the class) and providing public methods (such as getters and setters) to access or modify those private members.
+
+### Benefits of Encapsulation:
+
+- Data Hiding: Internal object details are hidden, exposing only what is necessary.
+- Improved Security: Prevents external code from directly modifying internal state in unexpected ways.
+- Modularity: Each object manages its own state and behaviour, making code more modular and easier to maintain.
+- Flexibility: Implementation can change without affecting code that uses the object, as long as the public interface remains the same.
+
+```python
+while True:
+    print(red_light.led_light_state) # Allowed
+    red_light.led_light_state = 1 # Allowed
+    print(f"Not allowed: {red_light.__pin} ???") # Not allowed, should raise AttributeError
+```
+
+> [!Note]
+> In Python, identifiers (variable or method names) that start with double underscores (e.g., `__my_var`) are not truly private in the sense of other languages like C# or C++. Instead, Python uses a mechanism called name mangling. When you define a variable with double underscores, Python changes its name internally to `_ClassName__my_var`. This means it is harder (but not impossible) to access it from outside the class.
+
+## Setters & Getters
+
+Setters and getters are special methods used in object-oriented programming to access (get) or modify (set) the values of private or protected attributes of a class. They help encapsulate the internal state of an object, providing controlled access.
+
+### Getter
+
+- A getter is a method that retrieves (gets) the value of a private attribute.
+- It allows you to read the value without providing direct access to the underlying variable.
+
+### Setter
+
+- A setter is a method that sets (updates) the value of a private attribute.
+- It allows you to validate or restrict changes before updating the attribute.
+
+```python
+    @property
+    def led_light_state(self):
+        # method overloading polymorphism in this class
+        return self.value()
+
+    @led_light_state.setter
+    def led_light_state(self, value):
+        # method overloading polymorphism in this class
+        if value == 1:
+            self.off()
+        elif value == 0:
+            self.on()
+```
+
+### Why Use Setters & Getters
+- Encapsulation: Protects the internal state of the object.
+- Validation: Allows you to add checks before changing values.
+- Abstraction: Hides implementation details from users of the class.
 
 ## Overloading Polymorphism
 

tutorials/Lecture3.md

@@ -1,65 +1,9 @@
 # Lecture 3
 
-## Lecture 2 Concepts
-- Encapsulation
-- Setters & Getters
+## Lecture 3 Concepts
 - Abstraction
-- Extend LED functionality
-- Complete led light class
-- Unit test the led light class
-
-## Encapsulation
-Encapsulation restricts direct access to some of an object's components (such as attributes or methods), meaning the internal representation of the object is hidden from the outside. This is typically achieved by making certain attributes or methods private (i.e., inaccessible from outside the class) and providing public methods (such as getters and setters) to access or modify those private members.
-
-### Benefits of Encapsulation:
-
-- Data Hiding: Internal object details are hidden, exposing only what is necessary.
-- Improved Security: Prevents external code from directly modifying internal state in unexpected ways.
-- Modularity: Each object manages its own state and behaviour, making code more modular and easier to maintain.
-- Flexibility: Implementation can change without affecting code that uses the object, as long as the public interface remains the same.
-
-```python
-while True:
-    print(red_light.led_light_state) # Allowed
-    red_light.led_light_state = 1 # Allowed
-    print(f"Not allowed: {red_light.__pin} ???") # Not allowed, should raise AttributeError
-```
-> [!Note]
-> In Python, identifiers (variable or method names) that start with double underscores (e.g., `__my_var`) are not truly private in the sense of other languages like C# or C++. Instead, Python uses a mechanism called name mangling. When you define a variable with double underscores, Python changes its name internally to `_ClassName__my_var`. This means it is harder (but not impossible) to access it from outside the class.
-
-## Setters & Getters
-
-Setters and getters are special methods used in object-oriented programming to access (get) or modify (set) the values of private or protected attributes of a class. They help encapsulate the internal state of an object, providing controlled access.
-
-### Getter
-
-- A getter is a method that retrieves (gets) the value of a private attribute.
-- It allows you to read the value without providing direct access to the underlying variable.
-
-### Setter
-
-- A setter is a method that sets (updates) the value of a private attribute.
-- It allows you to validate or restrict changes before updating the attribute.
-
-```python
-    @property
-    def led_light_state(self):
-        # method overloading polymorphism in this class
-        return self.value()
-
-    @led_light_state.setter
-    def led_light_state(self, value):
-        # method overloading polymorphism in this class
-        if value == 1:
-            self.off()
-        elif value == 0:
-            self.on()
-```
-
-### Why Use Setters & Getters
-- Encapsulation: Protects the internal state of the object.
-- Validation: Allows you to add checks before changing values.
-- Abstraction: Hides implementation details from users of the class.
+- Implement a non blocking flash method
+- Complete and Unit Test led light class
 
 ## Abstraction
 
@@ -90,7 +34,7 @@ while True:
     sleep(0.25)
 ```
 
-## Extend the functionality of the led_light class
+## Implement a non blocking flash method
 
 > [!Important]
 > Make sure you edit the class in the `project\lib\led_light.py`, not your main.py implementation.