Soup_Pad

hackpads/Soup-Pad/firmware/code.py

@@ -0,0 +1,117 @@
+from kmk.kmk_keyboard import KMKKeyboard
+from kmk.keys import KC
+from kmk.modules.neopixel import Neopixel
+from lib.adafruit_hid.keyboard import Keyboard
+from lib.adafruit_hid.keycode import Keycode
+import board
+import busio
+import digitalio
+import time
+from adafruit_ssd1306 import SSD1306_I2C
+from adafruit_dht import DHT11  
+from mcp23008 import MCP23008  
+
+
+keyboard = KMKKeyboard()
+
+
+i2c = busio.I2C(scl=board.SCL, sda=board.SDA)
+mcp = MCP23008(i2c)
+
+
+rows = [mcp.get_pin(i) for i in range(4)]  # GP0, GP1, GP2, GP3
+cols = [mcp.get_pin(i) for i in range(4, 7)]  # GP4, GP5, GP6
+
+
+for row in rows:
+    row.switch_to_input(pull=mcp.Pull.UP)
+for col in cols:
+    col.switch_to_input(pull=mcp.Pull.UP)
+
+
+keyboard.row_pins = rows 
+keyboard.col_pins = cols  
+keyboard.diode_orientation = DiodeOrientation.COLUMNS
+
+
+keyboard.keymap = [
+    [KC.N1, KC.N2, KC.N3],  # First row also i will adjust them as needed later as it would e very much time consuming to adjust them now
+    [KC.N4, KC.N5, KC.N6],  # Second row
+    [KC.N7, KC.N8, KC.N9],  # Third row
+    [KC.KP_PLUS, KC.N0, KC.KP_MINUS],  # Fourth row
+]
+
+pixel = Neopixel(pin=board.D0, num_pixels=12, colors=[(255, 0, 0)], brightness=0.2)
+keyboard.modules.append(pixel)
+
+
+encoder1_a = digitalio.DigitalInOut(board.D6)
+encoder1_b = digitalio.DigitalInOut(board.D10)
+encoder2_a = digitalio.DigitalInOut(board.D3)
+encoder2_b = digitalio.DigitalInOut(board.D9)
+
+
+encoder1_a.switch_to_input(pull=digitalio.Pull.UP)
+encoder1_b.switch_to_input(pull=digitalio.Pull.UP)
+encoder2_a.switch_to_input(pull=digitalio.Pull.UP)
+encoder2_b.switch_to_input(pull=digitalio.Pull.UP)
+
+
+oled = SSD1306_I2C(128, 64, i2c)
+
+
+dht_sensor = DHT11(digitalio.DigitalInOut(board.D2))  # DHT11 sensor on D2 pin
+
+
+encoder1_pos = 0
+encoder2_pos = 0
+
+
+def read_distance():
+
+    return 50  #its for now i will add the sensor code later
+
+
+while True:
+    keyboard.process()
+
+
+    try:
+        temperature = dht_sensor.temperature
+        humidity = dht_sensor.humidity
+    except Exception as e:
+        temperature = None
+        humidity = None
+        print("Failed to read DHT11:", e)
+
+
+    if not encoder1_a.value:
+        if not encoder1_b.value: 
+            encoder1_pos += 1
+            keyboard.send(KC.VOLD)  
+        else:  
+            encoder1_pos -= 1
+            keyboard.send(KC.VOLU)  
+
+
+    if not encoder2_a.value:
+        if not encoder2_b.value:  
+            encoder2_pos += 1
+            keyboard.send(KC.MPRV)  
+        else:  
+            encoder2_pos -= 1
+            keyboard.send(KC.MNXT)  
+
+
+    distance = read_distance()
+    volume_level = max(0, min(100, 100 - distance))  # conveting distance to volume level
+
+   #oled
+    oled.fill(0)  
+    oled.text("Temp: {}C".format(temperature), 0, 0)
+    oled.text("Hum: {}%".format(humidity), 0, 10)
+    oled.text("Distance: {}cm".format(distance), 0, 20)
+    oled.text("Volume: {}".format(volume_level), 0, 30)
+    oled.show()  
+
+    time.sleep(0.01)  #for rest lol

hackpads/Soup-Pad/firmware/kmk/bootcfg.py

@@ -0,0 +1,107 @@
+try:
+    from typing import Optional
+except ImportError:
+    pass
+
+import digitalio
+import microcontroller
+import usb_hid
+
+
+def bootcfg(
+    sense: [microcontroller.Pin, digitalio.DigitalInOut],
+    source: Optional[microcontroller.Pin, digitalio.DigitalInOut] = None,
+    autoreload: bool = True,
+    boot_device: int = 0,
+    cdc_console: bool = True,
+    cdc_data: bool = False,
+    consumer_control: bool = True,
+    keyboard: bool = True,
+    midi: bool = True,
+    mouse: bool = True,
+    nkro: bool = False,
+    pan: bool = False,
+    storage: bool = True,
+    usb_id: Optional[tuple[str, str]] = None,
+    **kwargs,
+) -> bool:
+
+    if len(kwargs):
+        print('unknown option', kwargs)
+
+    if isinstance(sense, microcontroller.Pin):
+        sense = digitalio.DigitalInOut(sense)
+        sense.direction = digitalio.Direction.INPUT
+        sense.pull = digitalio.Pull.UP
+
+    if isinstance(source, microcontroller.Pin):
+        source = digitalio.DigitalInOut(source)
+        source.direction = digitalio.Direction.OUTPUT
+        source.value = False
+
+    if not autoreload:
+        import supervisor
+
+        supervisor.runtime.autoreload = False
+
+    # configure HID devices
+    devices = []
+    if keyboard:
+        if nkro:
+            from kmk.hid_reports import nkro_keyboard
+
+            devices.append(nkro_keyboard.NKRO_KEYBOARD)
+        else:
+            devices.append(usb_hid.Device.KEYBOARD)
+    if mouse:
+        if pan:
+            from kmk.hid_reports import pointer
+
+            devices.append(pointer.POINTER)
+        else:
+            devices.append(usb_hid.Device.MOUSE)
+    if consumer_control:
+        devices.append(usb_hid.Device.CONSUMER_CONTROL)
+    if devices:
+        usb_hid.enable(devices, boot_device)
+    else:
+        usb_hid.disable()
+
+    # configure midi over usb
+    if not midi:
+        import usb_midi
+
+        usb_midi.disable()
+
+    # configure usb vendor and product id
+    if usb_id is not None:
+        import supervisor
+
+        if hasattr(supervisor, 'set_usb_identification'):
+            supervisor.set_usb_identification(*usb_id)
+
+    # configure data serial
+    if cdc_data:
+        import usb_cdc
+
+        usb_cdc.enable(data=True)
+
+    # sense pulled low -> Skip boot configuration that may disable debug or
+    # rescue facilities.
+    if not sense.value:
+        return False
+
+    # Entries for serial console (REPL) and storage are intentionally evaluated
+    # last to ensure the board is debuggable, mountable and rescueable, in case
+    # any of the previous code throws an exception.
+    if not cdc_console:
+        import usb_cdc
+
+        usb_cdc.enable(console=False)
+
+    if not storage:
+        import storage
+
+        storage.disable_usb_drive()
+
+    return True

hackpads/Soup-Pad/firmware/kmk/extensions/__init__.py

@@ -0,0 +1,54 @@
+class InvalidExtensionEnvironment(Exception):
+    pass
+
+
+class Extension:
+    _enabled = True
+
+    def enable(self, keyboard):
+        self._enabled = True
+
+        self.on_runtime_enable(keyboard)
+
+    def disable(self, keyboard):
+        self._enabled = False
+
+        self.on_runtime_disable(keyboard)
+
+    # The below methods should be implemented by subclasses
+
+    def on_runtime_enable(self, keyboard):
+        raise NotImplementedError
+
+    def on_runtime_disable(self, keyboard):
+        raise NotImplementedError
+
+    def during_bootup(self, keyboard):
+        raise NotImplementedError
+
+    def before_matrix_scan(self, keyboard):
+        '''
+        Return value will be injected as an extra matrix update
+        '''
+        raise NotImplementedError
+
+    def after_matrix_scan(self, keyboard):
+        '''
+        Return value will be replace matrix update if supplied
+        '''
+        raise NotImplementedError
+
+    def before_hid_send(self, keyboard):
+        raise NotImplementedError
+
+    def after_hid_send(self, keyboard):
+        raise NotImplementedError
+
+    def on_powersave_enable(self, keyboard):
+        raise NotImplementedError
+
+    def on_powersave_disable(self, keyboard):
+        raise NotImplementedError
+
+    def deinit(self, keyboard):
+        pass