Add missing command methods to provide complete interface to all firmware commands (#47)

* Add missing command methods to provide complete interface to all firmware commands

- I2C commands: i2c_reset, i2c_read_no_register_uint8, i2c_write_no_register_uint8,
  i2c_read_payload_uint16, i2c_begin_transaction, i2c_write, i2c_end_transaction,
  i2c_buffer_size
- I2C_1 commands: i2c_1_reset, i2c_1_read_no_register_uint8, i2c_1_write_no_register_uint8,
  i2c_1_read_payload_uint16, i2c_1_begin_transaction, i2c_1_write, i2c_1_end_transaction,
  i2c_1_buffer_size
- SPI commands: spi_buffer_size, spi_set_clock_divider
- Register commands: register_read_uint8, register_write_uint8, register_read_uint32,
  register_write_uint32
- Startup/Demo commands: post_serial_startup_commands_available, read_post_serial_startup_command
- Utility commands: sleep_seconds
- Info commands: info, reboot, serialnumber, license

* Add i2c_write_bulk and i2c_1_write_bulk methods for large data transfers

- Implement chunked writing with automatic transaction management
- Support writing up to 8k bytes by automatically splitting into buffer-sized chunks
- Use try/finally to ensure proper transaction cleanup
- Add comprehensive docstrings explaining the functionality

* Update the HISTORY.md to reflect the actual date

* Add nop command and comprehensive test suite

- Add nop_func to commandconstants.hpp and main.cpp
- Add nop method to TeensyToAny Python class
- Create comprehensive test suite with pytest
- Add test for oversized input handling (>2k bytes)
- Test buffer size limits and normal command functionality
- Update HISTORY.md with nop command addition

* Simplify tests and add pytest hardware markers

- Replace complex mock-based tests with simple hardware tests
- Add @pytest.mark.hardware to all hardware-dependent tests
- Add pytest.ini and pyproject.toml configuration to skip hardware tests by default
- Tests are now skipped unless explicitly run with '-m hardware'

* Fix pylint issues in test file

- Fix import order: pytest before local imports
- Add pylint disable comments for protected access to _ask method
- Achieve 10.00/10 pylint score for test file

Author: hmaarrfk

.gitattributes

@@ -1 +1,3 @@
 teensytoany/_version.py export-subst
+# SCM syntax highlighting & preventing 3-way merges
+pixi.lock merge=binary linguist-language=YAML linguist-generated=true

.gitignore

@@ -100,3 +100,8 @@ ENV/
 
 # mypy
 .mypy_cache/
+# pixi environments
+.pixi/*
+!.pixi/config.toml
+pixi.toml
+pixi.lock

HISTORY.md

@@ -1,5 +1,24 @@
 # History
 
+## 0.12.0 (2025-08-21)
+
+* Add missing command methods to provide complete interface to all firmware commands:
+  - I2C commands: `i2c_reset`, `i2c_read_no_register_uint8`, `i2c_write_no_register_uint8`,
+    `i2c_read_payload_uint16`, `i2c_begin_transaction`, `i2c_write`, `i2c_end_transaction`,
+    `i2c_buffer_size`, `i2c_write_bulk`
+  - I2C_1 commands: `i2c_1_reset`, `i2c_1_read_no_register_uint8`, `i2c_1_write_no_register_uint8`,
+    `i2c_1_read_payload_uint16`, `i2c_1_begin_transaction`, `i2c_1_write`, `i2c_1_end_transaction`,
+    `i2c_1_buffer_size`, `i2c_1_write_bulk`
+  - SPI commands: `spi_buffer_size`, `spi_set_clock_divider`
+  - Register commands: `register_read_uint8`, `register_write_uint8`, `register_read_uint32`,
+    `register_write_uint32`
+  - Startup/Demo commands: `post_serial_startup_commands_available`, `read_post_serial_startup_command`
+  - Utility commands: `sleep_seconds`
+  - Info commands: `info`, `reboot`, `serialnumber`, `license`, `nop`
+* Add `i2c_write_bulk` and `i2c_1_write_bulk` methods for writing up to 8k bytes with automatic
+  chunking and transaction management
+* Add `nop` command for testing purposes and comprehensive test suite
+
 ## 0.11.1 (2025-07-18)
 
 * Provide an ability to define the device name at initialization time.

pytest.ini

@@ -0,0 +1,4 @@
+[pytest]
+markers =
+    hardware: marks tests as requiring hardware (deselect with '-m "not hardware"')
+addopts = -m "not hardware"

teensytoany/teensytoany.py

@@ -604,6 +604,77 @@ def i2c_ping(self, address: int):
         cmd = f"i2c_ping 0x{address:02x}"
         self._ask(cmd)
 
+    def i2c_reset(self):
+        """Reset the I2C PORT in case of lockup."""
+        self._ask("i2c_reset")
+
+    def i2c_read_no_register_uint8(self, address: int):
+        """Read a uint8_t from the I2C bus without specifying a register address."""
+        cmd = f"i2c_read_no_register_uint8 0x{address:02x}"
+        returned = self._ask(cmd)
+        return int(returned, base=0)
+
+    def i2c_write_no_register_uint8(self, address: int, data: int):
+        """Write a uint8_t to the I2C bus without specifying a register address."""
+        data = data & 0xFF
+        cmd = f"i2c_write_no_register_uint8 0x{address:02x} 0x{data:02x}"
+        self._ask(cmd)
+
+    def i2c_read_payload_uint16(self, address: int, register_address: int,
+                                num_bytes: int) -> Sequence:
+        """Read up to 256 bytes from the I2C bus starting at a specified 16 bit register address."""
+        cmd = f"i2c_read_payload_uint16 0x{address:02x} 0x{register_address:04x} {num_bytes}"
+        returned = self._ask(cmd)
+        register_data = [int(val, base=0) for val in returned.split()]
+        return register_data
+
+    def i2c_begin_transaction(self, address: int):
+        """Begin a transaction with the I2C device."""
+        cmd = f"i2c_begin_transaction 0x{address:02x}"
+        self._ask(cmd)
+
+    def i2c_write(self, data: Sequence):
+        """Write data to the I2C device."""
+        data_str = ' '.join([f"{val}" for val in data])
+        cmd = f"i2c_write {data_str}"
+        self._ask(cmd)
+
+    def i2c_end_transaction(self, stop: bool = True):
+        """End a transaction with the I2C device."""
+        cmd = f"i2c_end_transaction {str(stop).lower()}"
+        self._ask(cmd)
+
+    def i2c_write_bulk(self, address: int, data: Sequence):
+        """Write large amounts of data to the I2C device in chunks.
+
+        This method automatically handles chunking data to fit within the I2C buffer
+        size and manages the transaction lifecycle.
+
+        Parameters
+        ----------
+        address: int
+            I2C device address
+        data: Sequence
+            Data to write (up to 8k bytes)
+        """
+        if len(data) > 8192:
+            raise ValueError("Data size exceeds maximum of 8192 bytes")
+
+        buffer_size = self.i2c_buffer_size()
+        self.i2c_begin_transaction(address)
+
+        try:
+            for i in range(0, len(data), buffer_size):
+                chunk = data[i:i + buffer_size]
+                self.i2c_write(chunk)
+        finally:
+            self.i2c_end_transaction()
+
+    def i2c_buffer_size(self):
+        """Get the maximum I2C buffer size for this board."""
+        returned = self._ask("i2c_buffer_size")
+        return int(returned, base=0)
+
     def i2c_1_init(self, baud_rate: int=100_100, timeout=200_000, register_space=1):
         cmd = f"i2c_1_init {baud_rate:d} {timeout:d} {register_space:d}"
         self._ask(cmd)
@@ -701,6 +772,77 @@ def i2c_1_ping(self, address: int):
         cmd = f"i2c_1_ping 0x{address:02x}"
         self._ask(cmd)
 
+    def i2c_1_reset(self):
+        """Reset the I2C_1 PORT in case of lockup."""
+        self._ask("i2c_1_reset")
+
+    def i2c_1_read_no_register_uint8(self, address: int):
+        """Read a uint8_t from the I2C_1 bus without specifying a register address."""
+        cmd = f"i2c_1_read_no_register_uint8 0x{address:02x}"
+        returned = self._ask(cmd)
+        return int(returned, base=0)
+
+    def i2c_1_write_no_register_uint8(self, address: int, data: int):
+        """Write a uint8_t to the I2C_1 bus without specifying a register address."""
+        data = data & 0xFF
+        cmd = f"i2c_1_write_no_register_uint8 0x{address:02x} 0x{data:02x}"
+        self._ask(cmd)
+
+    def i2c_1_read_payload_uint16(self, address: int, register_address: int,
+                                  num_bytes: int) -> Sequence:
+        """Read up to 256 bytes from the I2C_1 bus at a specified 16 bit register address."""
+        cmd = f"i2c_1_read_payload_uint16 0x{address:02x} 0x{register_address:04x} {num_bytes}"
+        returned = self._ask(cmd)
+        register_data = [int(val, base=0) for val in returned.split()]
+        return register_data
+
+    def i2c_1_begin_transaction(self, address: int):
+        """Begin a transaction with the I2C_1 device."""
+        cmd = f"i2c_1_begin_transaction 0x{address:02x}"
+        self._ask(cmd)
+
+    def i2c_1_write(self, data: Sequence):
+        """Write data to the I2C_1 device."""
+        data_str = ' '.join([f"{val}" for val in data])
+        cmd = f"i2c_1_write {data_str}"
+        self._ask(cmd)
+
+    def i2c_1_end_transaction(self, stop: bool = True):
+        """End a transaction with the I2C_1 device."""
+        cmd = f"i2c_1_end_transaction {str(stop).lower()}"
+        self._ask(cmd)
+
+    def i2c_1_write_bulk(self, address: int, data: Sequence):
+        """Write large amounts of data to the I2C_1 device in chunks.
+
+        This method automatically handles chunking data to fit within the I2C_1 buffer
+        size and manages the transaction lifecycle.
+
+        Parameters
+        ----------
+        address: int
+            I2C_1 device address
+        data: Sequence
+            Data to write (up to 8k bytes)
+        """
+        if len(data) > 8192:
+            raise ValueError("Data size exceeds maximum of 8192 bytes")
+
+        buffer_size = self.i2c_1_buffer_size()
+        self.i2c_1_begin_transaction(address)
+
+        try:
+            for i in range(0, len(data), buffer_size):
+                chunk = data[i:i + buffer_size]
+                self.i2c_1_write(chunk)
+        finally:
+            self.i2c_1_end_transaction()
+
+    def i2c_1_buffer_size(self):
+        """Get the maximum I2C_1 buffer size for this board."""
+        returned = self._ask("i2c_1_buffer_size")
+        return int(returned, base=0)
+
     def gpio_digital_write(self, pin, value):
         """Call the ardunio DigitalWrite function.
 
@@ -821,6 +963,64 @@ def register_read_uint16(self, register_address):
         returned = self._ask(f"register_read_uint16 {register_address}")
         return int(returned, base=0)
 
+    def register_read_uint8(self, register_address):
+        """Read value directly from a teensy register.
+
+        Parameters
+        ----------
+        register_address: int
+            Register address to read from.
+
+        Returns
+        -------
+        value: int
+            Read value. Will be from 0 to 255.
+
+        """
+        returned = self._ask(f"register_read_uint8 {register_address}")
+        return int(returned, base=0)
+
+    def register_write_uint8(self, register_address, value):
+        """Write value directly to teensy register.
+
+        Parameters
+        ----------
+        register_address: int
+            Register address to write to.
+        value: int
+            Value to write to address. Should be between 0 and 255.
+        """
+        self._ask(f"register_write_uint8 {register_address} {value}")
+
+    def register_read_uint32(self, register_address):
+        """Read value directly from a teensy register.
+
+        Parameters
+        ----------
+        register_address: int
+            Register address to read from.
+
+        Returns
+        -------
+        value: int
+            Read value. Will be from 0 to 4294967295.
+
+        """
+        returned = self._ask(f"register_read_uint32 {register_address}")
+        return int(returned, base=0)
+
+    def register_write_uint32(self, register_address, value):
+        """Write value directly to teensy register.
+
+        Parameters
+        ----------
+        register_address: int
+            Register address to write to.
+        value: int
+            Value to write to address. Should be between 0 and 4294967295.
+        """
+        self._ask(f"register_write_uint32 {register_address} {value}")
+
     @property
     def version(self):
         return self._version
@@ -915,6 +1115,15 @@ def spi_read_byte(self, data):
         value = self._ask(f"spi_read_byte {data}")
         return int(value, base=0)
 
+    def spi_buffer_size(self):
+        """Get the maximum SPI buffer size for this board."""
+        returned = self._ask("spi_buffer_size")
+        return int(returned, base=0)
+
+    def spi_set_clock_divider(self, divider: int):
+        """Set the SPI clock divider."""
+        self._ask(f"spi_set_clock_divider {divider}")
+
     def analog_write_frequency(self, pin: int, frequency: int):
         frequency = int(frequency)
         self._ask(f"analog_write_frequency {pin} {frequency}")
@@ -1051,6 +1260,20 @@ def disable_demo_commands(self):
         """Disable the demo commands on startup."""
         self._ask("disable_demo_commands")
 
+    def post_serial_startup_commands_available(self):
+        """Return the number of post serial startup commands available."""
+        returned = self._ask("post_serial_startup_commands_available")
+        return int(returned, base=0)
+
+    def read_post_serial_startup_command(self, index):
+        """Read the post serial startup command at the specified index."""
+        returned = self._ask(f"read_post_serial_startup_command {index}")
+        return returned
+
+    def sleep_seconds(self, duration: float):
+        """Sleep (and block) for the desired duration in seconds."""
+        self._ask(f"sleep {duration}")
+
     def fastled_add_leds(self, led_class, has_white, pin, n_leds):
         has_white = int(bool(has_white))
         self._ask(f"fastled_add_leds {led_class} {has_white} {pin} {n_leds}")
@@ -1076,3 +1299,23 @@ def fastled_set_hsv(self, led_index, h, s, v):
 
     def fastled_set_hue(self, led_index, hue):
         self._ask(f"fastled_set_hue {led_index} {hue}")
+
+    def info(self):
+        """Displays information about this TeensyToAny device."""
+        return self._ask("info")
+
+    def reboot(self):
+        """Runs setup routine again, for this device."""
+        self._ask("reboot")
+
+    def serialnumber(self):
+        """Displays the serial number of the board."""
+        return self._ask("serialnumber")
+
+    def license(self):
+        """Display the license information for the source code running on the teensy."""
+        return self._ask("license")
+
+    def nop(self):
+        """No operation (does nothing)."""
+        self._ask("nop")

teensytoany/tests/test_teensytoany.py

@@ -1,8 +1,34 @@
-import teensytoany
+import pytest
 
-# import pytest
+import teensytoany
+from teensytoany import TeensyToAny
 
 
 def test_project_import():
     assert teensytoany.__version__
     assert teensytoany.TeensyToAny
+
+
+@pytest.mark.hardware
+def test_nop():
+    with TeensyToAny() as t:
+        t.nop()
+
+
+@pytest.mark.hardware
+@pytest.mark.parametrize("i", range(256, 2048, 256))
+def test_nop_buffer_size(i):
+    # We shouldn't fail with up to 2048 bytes of input
+    with TeensyToAny() as t:
+        # pylint: disable=protected-access
+        t._ask("nop" + " " * (2048 - len("nop\n") - i))
+
+
+@pytest.mark.hardware
+@pytest.mark.parametrize("i", range(2048, 8096 + 1, 2048))
+def test_nop_buffer_size_fail(i):
+    with TeensyToAny() as t:
+        # We should fail with more than 2048 bytes of input
+        with pytest.raises(Exception):
+            # pylint: disable=protected-access
+            t._ask("nop" + " " * (i + 1 - len("nop\n")))