upgrading to the latest version of the firmware for addons

Author: noaglaserdocusign

analog_write.py

@@ -0,0 +1,16 @@
+#Import ElectroBlocks library
+from electroblocks import ElectroBlocks
+import time # imports the time library
+
+
+# Variable Declaration
+
+# Initialise the program settings and configurations
+eb = ElectroBlocks(verbose=True) # Create an instance of the ElectroBlocks class
+eb.analog_config(6)
+
+for i in range(1, 200):
+  eb.analog_write(6, i)
+  time.sleep(0.2)
+
+print("COMPLETE")

digital_write.py

@@ -0,0 +1,17 @@
+#Import ElectroBlocks library
+from electroblocks import ElectroBlocks
+import time # imports the time library
+
+
+# Variable Declaration
+
+# Initialise the program settings and configurations
+eb = ElectroBlocks(verbose=True) # Create an instance of the ElectroBlocks class
+eb.digital_config(13)
+for _ in range(1, 10):
+  eb.digital_write(13, 1)
+  time.sleep(1)
+  eb.digital_write(13, 0)
+  time.sleep(1)
+
+print("COMPLETE")

electroblocks/core.py

@@ -1,13 +1,24 @@
 import serial
 import serial.tools.list_ports
 import time
+from enum import Enum
+
+class ComponentPins(Enum):
+    UNKNOWN = 0
+    LCD = 1
+    RGBLED = 2
+    DIGITAL_WRITE = 3
+    ANALOG_WRITE = 4
+    RGB_LED_STRIP = 5
+    SERVO = 6
 
 class ElectroBlocks:
 
     last_sense_data = ""
     verbose = False
+    pins = {}
 
-    def __init__(self, baudrate=9600, timeout=2, verbose = False):
+    def __init__(self, baudrate=115200, timeout=2, verbose = False):
         self.ser = self._auto_connect(baudrate, timeout)
         self.verbose = verbose
         self._wait_for_ready()
@@ -31,6 +42,13 @@ def _drain_serial(self):
             self.ser.reset_input_buffer()
 
 
+    def _add_pin(self, pinType, pin):
+        if pinType not in self.pins:
+            self.pins[pinType] = [str(pin)]
+        else:
+            self.pins[pinType].append(str(pin))
+
+
     def _wait_for_message(self, message):
         count = 0
         while count < 10:
@@ -71,7 +89,7 @@ def _wait_for_ready(self):
 
     def _send(self, cmd):
         self.ser.write((cmd + "|\n").encode())
-        self._wait_for_message("DONE_NEXT_COMMAND")
+        self._wait_for_message("OK")
 
     # Digital Write Method
     def config_digital_read(self, pin):
@@ -89,8 +107,18 @@ def rfid_tag_number(self):
 
     def rfid_sensed_card(self):
         return len(self._find_sensor_str("0", "rfid")) > 0
+    
+    #IR Remote
+
+    def config_ir_remote(self, pin):
+        self._send(f"config:ir={pin}")
 
+    def ir_remote_has_sensed_code(self):
+        return len(self._find_sensor_str("0", "ir")) > 0
 
+    def ir_remote_get_code(self):
+        return self._find_sensor_str("0", "ir")
+
     # Motion Sensors
     def config_motion_sensor(self, echoPin, trigPin):
         self._send(f"config:m={echoPin},{trigPin}")
@@ -107,49 +135,116 @@ def is_button_pressed(self, pin):
 
     # Servo Methods
     def config_servo(self, pin):
-        self._send(f"config:servo={pin}")
+        self._send(f"register::servo::{pin}")
 
     def move_servo(self, pin, angle):
-        self._send(f"s:{pin}:{angle}")
+        self._send(f"write::servo::{pin}::{angle}")
 
     # RGB Methods
-    def config_rgb(self, r_pin, g_pin, b_pin):
-        self._send(f"config:rgb={r_pin},{g_pin},{b_pin}")
+    def config_rgbled(self, r_pin, g_pin, b_pin):
+        self._add_pin(ComponentPins.RGBLED, r_pin)
+        self._add_pin(ComponentPins.RGBLED, g_pin)
+        self._add_pin(ComponentPins.RGBLED, b_pin)
+        self._send(f"register::rgb::{r_pin}::{g_pin}::{b_pin}")
 
-    def set_rgb(self, r, g, b):
-        self._send(f"rgb:{r},{g},{b}")
+    def set_color_rgbled(self, r, g, b):
+        redpin = self.pins[ComponentPins.RGBLED][0]
+        self._send(f"write::rgb::{redpin}::{r}::{g}::{b}")
 
     # LCD Methods
-    def config_lcd(self, rows=2, cols=16):
-        self._send(f"config:lcd={rows},{cols}")
+    def config_lcd(self, rows=2, cols=16, addr=39):
+        self._add_pin(ComponentPins.DIGITAL_WRITE, "A5")
+        self._add_pin(ComponentPins.DIGITAL_WRITE, "A4")
+        self._send(f"register::lcd::{rows}::{cols}::{addr}")
 
     def lcd_print(self, row, col, message):
-        self._send(f"l:{row}:{col}:{message}")
+        self._send(f"write::lcd::A5::9::{row}::{col}::{message}")
 
     def lcd_clear(self):
-        self._send("l:clear")
+        self._send("write::lcd::A5::1")
 
     def lcd_toggle_backlight(self, on):
         if on:
-            self._send("l:backlighton")
+            self._send("write::lcd::A5::2")
         else:
-            self._send("l:backlightoff")
+            self._send("write::lcd::A5::3")
 
     def lcd_blink_curor(self, row, col, on):
         if on == True:
-            self._send(f"l:cursor_on:{row}:{col}")
+            self._send(f"write::lcd::A5::5::{row}::{col}")
         else:
-            self._send(f"l:cursor_off:{row}:{col}")
+            self._send(f"write::lcd::A5::4")
 
     def lcd_scrollright(self):
-        self._send("l:scroll_right")
+        self._send("write::lcd::A5::6")
 
     def lcd_scrollleft(self):
-        self._send("l:scroll_left")
+        self._send("write::lcd::A5::7")
 
     # LED Methods
+
+    def digital_config(self, pin):
+        self._add_pin(ComponentPins.DIGITAL_WRITE, pin)
+        self._send(f"register::dw::{pin}")
+
     def digital_write(self, pin, value):
-        self._send(f"dw:{pin}:{value}")
+        self._send(f"write::dw::{pin}::{value}")
+
+    def analog_write(self, pin, value):
+        self._send(f"write::aw::{pin}::{value}")
+    
+    def analog_config(self, pin):
+        self._send(f"register::aw::{pin}")
+        self._add_pin(ComponentPins.ANALOG_WRITE, pin)
+
+    # NEO PIXELS
+
+    def config_rgb_strip(self, pin, count, colorOrderString, brightness):
+        orderToNumber = {
+            "RGB": 128,
+            "GRB": 129,
+            "RBG": 130,
+            "GBR": 131,
+            "BRG": 132,
+            "BGR": 133,
+        }
+        colorOrder = orderToNumber.get(colorOrderString) or 128
+        self._add_pin(ComponentPins.RGB_LED_STRIP, pin)
+        self._send(f"register::leds::{pin}::{count}::{colorOrder}::{brightness}")
+
+
+    def rgb_strip_set_color(self, position, red, green, blue):
+        """Set color for RGB LED strip at specified position"""
+        pin = self.pins[ComponentPins.RGB_LED_STRIP][0]
+        color = self.rgb_to_hex(red, green, blue)
+        self._send(f"write::leds::{pin}::2::{position}::{color}")
+
+    def rgb_strip_show_all(self):
+        pin = self.pins[ComponentPins.RGB_LED_STRIP][0]
+        self._send(f"write::leds::{pin}::1")
+
+    # Helpers
+
+    def rgb_to_hex(self, red, green, blue):
+        """
+        Convert RGB values (0-255) to a hex color string format (#RRGGBB)
+        
+        Args:
+            red (int): Red value (0-255)
+            green (int): Green value (0-255)  
+            blue (int): Blue value (0-255)
+            
+        Returns:
+            str: Hex color string in format RRGGBB
+        """
+        # Ensure values are within valid range (0-255)
+        red = max(0, min(255, int(red)))
+        green = max(0, min(255, int(green)))
+        blue = max(0, min(255, int(blue)))
+        
+        # Convert to hex and format with leading zeros if needed
+        return f"{red:02x}{green:02x}{blue:02x}".upper()
+
 
     def close(self):
         if self.ser and self.ser.is_open:

ir_remote.py

@@ -0,0 +1,17 @@
+#Import ElectroBlocks library
+from electroblocks import ElectroBlocks
+import time # imports the time library
+
+
+# Variable Declaration
+
+# Initialise the program settings and configurations
+eb = ElectroBlocks(verbose=True) # Create an instance of the ElectroBlocks class
+eb.config_ir_remote(2) # Configures the LCD Screen pins
+
+for _ in range(1, 10):
+  sensed_code = eb.ir_remote_has_sensed_code()
+  code = eb.ir_remote_get_code()
+  print(f"Sensed Code: {sensed_code} | Code: {code}")  
+  time.sleep(10)
+  print("CONTINUE")

lcd.py

@@ -0,0 +1,39 @@
+
+  
+#Import ElectroBlocks library
+from electroblocks import ElectroBlocks
+import time # imports the time library
+
+
+# Initialise the program settings and configurations
+eb = ElectroBlocks() # Create an instance of the ElectroBlocks class
+eb.config_lcd(2, 16, 39) # Configures the LCD Screen pins
+
+
+
+for _ in range(1, 3):
+  eb.lcd_toggle_backlight(False) # Turn off the LCD backlight
+  time.sleep(2) # Wait for the given/defined seconds.
+  eb.lcd_toggle_backlight(True) # Turn on the LCD backlight
+  time.sleep(2) # Wait for the given/defined seconds.
+  eb.lcd_clear() # Clear the LCD screen
+  eb.lcd_print(0, 0, "HELLO") # Print the first row text on the LCD screen
+  eb.lcd_print(1, 0, "WORLD") # Print the second row text on the LCD screen
+  time.sleep(3) # Pause / Wait
+  time.sleep(2) # Wait for the given/defined seconds.
+  eb.lcd_print(0, 0, "Hi") # Print a message on the LCD screen at specified row and column
+  time.sleep(2) # Wait for the given/defined seconds.
+  eb.lcd_clear() # Clear the LCD screen
+  time.sleep(2) # Wait for the given/defined seconds.
+  eb.lcd_print(0, 6, "Hi") # Print a message on the LCD screen at specified row and column
+  time.sleep(2) # Wait for the given/defined seconds.
+  eb.lcd_scrollright()
+  time.sleep(2) # Wait for the given/defined seconds.
+  eb.lcd_scrollleft()
+  time.sleep(2) # Wait for the given/defined seconds.
+  eb.lcd_blink_curor(0, 0, True) # Turn on the blink.
+  time.sleep(4) # Wait for the given/defined seconds.
+  eb.lcd_blink_curor(0, 0, False) # Turn off the blink.
+  time.sleep(4) # Wait for the given/defined seconds.
+
+print("COMPLETE")

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "electroblocks"
-version = "0.1.11"
+version = "0.1.12"
 description = "Python client library to interact with ElectroBlocks Arduino firmware"
 authors = [
     { name = "Noah Glaser", email = "glaserpower@gmail.com" }

rgb_strip.py

@@ -0,0 +1,18 @@
+#Import ElectroBlocks library
+from electroblocks import ElectroBlocks
+import time # imports the time library
+
+
+# Variable Declaration
+
+# Initialise the program settings and configurations
+eb = ElectroBlocks(verbose=True) # Create an instance of the ElectroBlocks class
+eb.config_rgb_strip("A0", 30, "GRB", 10)
+
+for i in range(0, 29):
+  eb.rgb_strip_set_color(i, 100, 0, 100)
+
+eb.rgb_strip_show_all()
+time.sleep(4)
+
+print("COMPLETE")

rgbled.py

@@ -0,0 +1,20 @@
+#Import ElectroBlocks library
+from electroblocks import ElectroBlocks
+import time # imports the time library
+
+
+# Variable Declaration
+
+# Initialise the program settings and configurations
+eb = ElectroBlocks(verbose=True) # Create an instance of the ElectroBlocks class
+eb.config_rgbled(9,10,11) # Configures the LCD Screen pins
+
+for _ in range(1, 10):
+  eb.set_color_rgbled(100, 0, 0)
+  time.sleep(1)
+  eb.set_color_rgbled(0, 100, 0)
+  time.sleep(1)
+  eb.set_color_rgbled(0, 0, 100)
+  time.sleep(1)
+
+print("COMPLETE")