update

Author: benpaddlejones

images/physical_prototype.png

@@ -7,7 +7,7 @@
 sleep(0.1)
 
 # File name of the script to import
-file_name = "v02"
+file_name = "v01"
 
 # Add the path to the sys.path
 sys.path.append("/py_scripts")

project/main.py

@@ -26,17 +26,6 @@ def off(self):
         if self.__debug:
             print(f"LED connected to Pin {self.__pin} is low")
 
-    def toggle(self):
-        # method overriding polymorphism of the parent class
-        if self.value() == 0:
-            self.high()
-            if self.__debug:
-                print(f"LED connected to Pin {self.__pin} is high")
-        elif self.value() == 1:
-            self.low()
-            if self.__debug:
-                print(f"LED connected to Pin {self.__pin} is low")
-
 
 red_light = Led_Light(3, False, False)
 

project/py_scripts/v05.py

@@ -8,7 +8,7 @@
 
 ## Introduction Projects
 
-The Introduction projects should be completed before starting the OOP Mini Project. Ultimately, students should have a basic understanding of the following concepts: different sensors and actuators, wiring a breadboard, Unit Testing, and debugging software and hardware.
+The Introduction projects should be completed before starting the OOP Mini Project. Ultimately, students should have a basic understanding of the following concepts: different sensors and actuators, wiring a breadboard, Unit Testing, and debugging both software and hardware.
 
 | | |
 | --- | --- |
@@ -45,11 +45,10 @@ First students should copy the provided script [v02.py](..\project\py_scripts\v0
 2. The buzzer should emit animated musical note on screen and if volume is turned up a constant tone.
 3. The momentary switch should return `1` to the IDE terminal when closed (pressed) and 0 when not closed (depressed).
 
-## Physical Wiring
-
+## Physical Breadboard Protoytype
 Watch the [Pi Pico Breadboard Introduction Video](https://www.youtube.com/watch?v=Ex7AJll-FsM). Students should wire their board, then unit test using the provided script [v02.py](..\project\py_scripts\v02.py). 
 
-### Physical Prototype
+### Finished Prototype
 
 ![Physical Prototype](/images/physical_prototype.png)
 

tutorials/Lecture0.md

@@ -93,7 +93,7 @@ The PWM Library provides an interface for controlling PWM signals on a specified
 
 ## Instantiation
 
-A class is like a blueprint for an object—it defines what attributes and methods the object will have, but by itself, it isn’t an actual object. Instantiation is when you use the class to create an actual, usable object in memory.
+A class is like a blueprint for an object—it defines the attributes and methods the object will have, but it isn’t an actual object itself. Instantiation is the process of using the class to create a real, usable object in memory.
 
 ```python
 from machine import Pin
@@ -112,9 +112,9 @@ while(True):
 
 ## Inheritance
 
-Inheritance is a fundamental concept in object-oriented programming (OOP). It allows a class (called a child or subclass) to acquire properties and behaviours (methods and attributes) from another class (called a parent or superclass).
+Inheritance is a fundamental concept in object-oriented programming (OOP). It allows a class (called a child or subclass) to inherit properties and behaviours (methods and attributes) from another class (called a parent or superclass).
 
-In this case the Led_Light class inherits the Pin class and without any further instrcutions the sub class inherits and can call all the mthods of the super class including `on()`, `off()`, `high()`, `low()`, `toggle()`, etc.
+In this case, the `Led_Light` class inherits from the Pin class, and without any further instructions, the subclass inherits and can call all the methods of the superclass, including `on()`, `off()`, `high()`, `low()`, `toggle()`, etc.
 
 
 ```python

tutorials/Lecture1.md

@@ -8,7 +8,6 @@
 
 ## UML Class Diagrams
 
-What is a UML Class Diagram?
 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
@@ -23,7 +22,7 @@ A UML (Unified Modelling Language) class diagram visually describes the structur
 ----------------------
 ```
 
-Mermaid Markdown UML Class Diagram Example
+### 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
@@ -54,19 +53,17 @@ 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/Operations (Bottom Section): This section lists the methods (or operations/functions) that belong to the class.
+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.”**
 
-Overriding is when a child (subclass) provides a new implementation for a method that it inherits from its parent (superclass).
+Polymorphism Overriding occurs when a child class (subclass) provides a new implementation for a method it inherits from its parent class (superclass).
 
-The child class method has the same name and parameters as the method in the parent class. When you call the method on a child class object, Python (or any OOP language) uses the child’s version—even if the object is referenced by the parent type.
-
-It is called 'overriding' or also compilation polymorphism, as in many languages like C++ or C#, the overridden (parent method) is not compiled at all.
+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
@@ -172,8 +169,6 @@ Overloading occurs when a child (subclass) and/or parent (superclass) have multi
 
 When you call the method, depending on the parameters passed, the corresponding method is executed.
 
-It is called 'overloading' or also known as runtime polymorphism, as in many languages like C++ or C#, all the methods are compiled. However, depending on the parameters, the appropriate method is executed at runtime. 
-
 Because Python is dynamically typed, it does not support overloaded polymorphism, as the last definition of a method overwrites any previous ones.
 
 ```pseudocode

tutorials/Lecture2.md

@@ -8,7 +8,7 @@
 - Complete led light class
 
 ## Encapsulation
-Encapsulation restricts direct access to some of an object's components (attributes or methods), which means that the internal representation of an object is hidden from the outside. This is typically achieved by making certain attributes or methods private (i.e., not accessible from outside the class) and providing public methods (such as getters and setters) to access or modify those private members.
+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: