update

Author: benpaddlejones

.gitignore

@@ -3,6 +3,9 @@ __pycache__/
 *.py[cod]
 *$py.class
 
+tutorials/*
+tutorials/*.pptx
+
 # C extensions
 *.so
 

_includes/youtube.html

@@ -0,0 +1,23 @@
+<div class="embed-container">
+    <iframe width="640" height="390" 
+    src="https://www.youtube.com/embed/{{ include.id }}" 
+    frameborder="0" allowfullscreen></iframe>
+</div>
+<style>
+.embed-container {
+  position: relative;
+  padding-bottom: 56.25%;
+  height: 0;
+  overflow: hidden;
+  max-width: 100%;
+}
+.embed-container iframe,
+.embed-container object,
+.embed-container embed {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+</style>

deleteme.py

@@ -0,0 +1,9 @@
+import pickle
+import numpy as np
+
+filename = 'my_saved_model.sav'
+
+loaded_model = pickle.load(open(filename, 'rb'))
+predict = np.array([4]).reshape(1, -1)
+result = loaded_model.predict(predict)
+print(result[0])

docs/servo.md

@@ -0,0 +1,142 @@
+# Servo Class
+
+The `Servo` class provides an interface for controlling standard hobby servo motors using PWM signals on the Raspberry Pi Pico. It allows you to set the servo angle, control the duty cycle directly, and safely stop or deinitialize the servo.
+
+## Constructor
+
+```python
+Servo(pwm, min_us=500, max_us=2500, dead_zone_us=1500, freq=50)
+```
+- `pwm` (`PWM`): A `machine.PWM` object for the servo control pin.
+- `min_us` (`int`, optional): Minimum pulse width in microseconds (default: 500).
+- `max_us` (`int`, optional): Maximum pulse width in microseconds (default: 2500).
+- `dead_zone_us` (`int`, optional): Pulse width for the servo's neutral position (default: 1500).
+- `freq` (`int`, optional): PWM frequency in Hz (default: 50).
+
+## Example Usage
+
+```python
+from machine import Pin, PWM
+from servo import Servo
+from time import sleep
+
+# Create a PWM object on GPIO 16
+pwm = PWM(Pin(16))
+servo = Servo(pwm, freq=50)
+
+# Move servo to 0, 90, and 180 degrees
+servo.set_angle(0)
+sleep(1)
+servo.set_angle(90)
+sleep(1)
+servo.set_angle(180)
+sleep(1)
+
+# Stop the servo (move to neutral position)
+servo.stop()
+
+# Deinitialize when done
+servo.deinit()
+```
+
+## Methods
+
+- **set_angle(angle)**  
+  Set the servo to a specific angle (0–180 degrees).
+
+- **set_duty(duty_us)**  
+  Set the PWM pulse width in microseconds directly.
+
+- **get_duty()**  
+  Get the current PWM pulse width in microseconds.
+
+- **stop()**  
+  Move the servo to the neutral (dead zone) position.
+
+- **deinit()**  
+  Deinitialize the PWM object to free hardware resources.
+
+---
+
+**Notes:**  
+- The servo must be powered appropriately; do not power directly from the Pico's 3.3V pin if your servo draws significant current.
+- The control pin must support PWM output.
+- Typical servos expect a 50Hz PWM signal with pulse widths between 500μs (0°) and 2500μs (180°).
+
+## Class Unit Test
+
+```python
+from machine import Pin, PWM
+from servo import Servo
+from time import sleep
+
+pwm = PWM(Pin(16))
+servo = Servo(pwm)
+
+print("Testing set_angle()")
+for angle in [0, 90, 180, 90, 0]:
+    servo.set_angle(angle)
+    print(f"Set angle to {angle}°; duty = {servo.get_duty()}us")
+    sleep(1)
+
+print("Testing stop()")
+servo.stop()
+print(f"Servo stopped at duty = {servo.get_duty()}us")
+
+servo.deinit()
+print("Servo deinitialized.")
+```
+
+## Class Implementation
+
+```python
+from machine import PWM
+
+class Servo:
+    """Servo Class for controlling pulse density modulation servos.
+
+    This class provides an interface for controlling servo motors using PWM signals.
+    It handles the conversion between angles (0-180 degrees) and pulse widths.
+
+    Args:
+        pwm (PWM): A PWM object to control the servo.
+        min_us (int, optional): Minimum pulse width in microseconds. Defaults to 500.
+        max_us (int, optional): Maximum pulse width in microseconds. Defaults to 2500.
+        dead_zone_us (int, optional): Pulse width for the servo's neutral position. Defaults to 1500.
+        freq (int, optional): PWM frequency in Hz. Defaults to 50.
+    """
+
+    def __init__(
+        self,
+        pwm: PWM,
+        min_us=500,
+        max_us=2500,
+        dead_zone_us=1500,
+        freq=50,
+    ):
+        self.pwm = pwm
+        self.pwm.freq(freq)
+        self._move_period_ms = 1000 // freq
+        min_us = min_us if min_us > 0 else 0
+        max_us = max_us if min_us < max_us < (1000 // freq) * 1000 else 0
+        self._curr_duty = 0
+        self.dead_zone_us = dead_zone_us
+
+    def set_duty(self, duty_us: int):
+        self._curr_duty = duty_us
+        self.pwm.duty_ns(duty_us * 1000)
+
+    def set_angle(self, angle: int):
+        angle = min(max(angle, 0), 180)
+        duty_us = int(500 + (angle / 180) * 2000)
+        self.set_duty(duty_us)
+
+    def get_duty(self) -> int:
+        return self._curr_duty
+
+    def stop(self):
+        self.set_duty(self.dead_zone_us)
+
+    def deinit(self):
+        self.pwm.deinit()
+```

examples/v03.py

@@ -1,3 +1,6 @@
+"""
+Instantiation Example
+"""
 from machine import Pin
 from time import sleep
 

examples/v04.py

@@ -5,13 +5,11 @@
 from machine import Pin
 from time import sleep
 
-
 class Led_Light(Pin):
-    # Sub Class inherits the 'Pin' Class
+    # Sub Class inherits the 'Pin' Class 
     def __init__(self, pin):
         super().__init__(pin, Pin.OUT)
 
-
 red_light = Led_Light(3)
 
 while True:
@@ -26,4 +24,4 @@ def __init__(self, pin):
     red_light.toggle()
     sleep(4)
     red_light.toggle()
-    sleep(4)
+    sleep(4)

examples/v05.py

@@ -5,7 +5,6 @@
 from machine import Pin
 from time import sleep
 
-
 class Led_Light(Pin):
     # Sub Class inherits the 'Pin' Class
     def __init__(self, pin, flashing=False, debug=False):
@@ -27,10 +26,10 @@ def off(self):
             print(f"LED connected to Pin {self.__pin} is low")
 
 
-red_light = Led_Light(3)
+red_light = Led_Light(3, False, False)
 
 while True:
     red_light.on()
     sleep(1)
     red_light.off()
-    sleep(1)
+    sleep(1)

examples/v08.py

@@ -1,58 +1,23 @@
 """
 Encapsulation Example
+RUN AS PYTHON NOT MICROPYTHON
 """
 
-from machine import Pin
-from time import sleep, time
-
-
-class Led_Light(Pin):
-    # Sub Class inherits the Super 'Pin' Class
+class Led_Light():
     def __init__(self, pin, flashing=False, debug=False):
-        super().__init__(pin, Pin.OUT)
-        self.led_light_state
-        self.__debug = debug
-        self.__pin = pin
-        self.__flashing = flashing
-
-    def on(self):
-        # method overriding polymorphism of the Super Class
-        self.high()
-        if self.__debug:
-            print(f"LED connected to Pin {self.__pin} is {self.led_light_state}")
-
-    def off(self):
-        # method overriding polymorphism of the Super Class
-        self.low()
-        if self.__debug:
-            print(f"LED connected to Pin {self.__pin} is {self.led_light_state}")
-
-    def toggle(self):
-        # method overriding polymorphism of the Super Class
-        if self.value() == 0:
-            self.on()
-        elif self.value() == 1:
-            self.off()
-
-    @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()
-
+        self.debug = debug #PUBLIC attribute
+        self.__pin = pin #Encapsulated PRIVATE attribute
 
 red_light = Led_Light(3, False, False)
 
-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
+try:
+    print(red_light.debug)
+    print("SUCCESS: Accessed a public attribute")
+except AttributeError:
+    print("ERROR: AttributeError not expected!")
+
+try:
+    print(red_light.__pin)
+    print("ERROR: Accessed private attribute when it should be hidden!")
+except AttributeError:
+    print("SUCCESS: AttributeError raised as expected")

examples/v09.py

@@ -51,8 +51,9 @@ def led_light_state(self, value):
 red_light = Led_Light(3, False, False)
 
 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
+    print(red_light.led_light_state)
+    red_light.led_light_state = 1
+    sleep(0.25)
+    print(red_light.led_light_state)
+    red_light.led_light_state = 0
+    sleep(0.25)

examples/v10.py

@@ -2,7 +2,7 @@
 Abstraction Example
 """
 
-from project.py_scripts.LL_unit_Test import Led_Light
+from led_light import Led_Light
 from time import sleep
 
 red_light = Led_Light(3, True, True)