fix: use original self._reset.switch_to_output(value=True) from main branch

[hackapet/Adafruit_Blinka_Displayio.git] / displayio / _fourwire.py

diff --git a/displayio/_fourwire.py b/displayio/_fourwire.py
index 0aae5dad212a0239c5f26ae68414a05f13463b33..df1704af5a2db5ed0db9bddf79d79bc08c218bec 100644 (file)
--- a/displayio/_fourwire.py
+++ b/displayio/_fourwire.py
@@ -22,7 +22,7 @@ from typing import Optional
 import digitalio
 import busio
 import microcontroller
 import digitalio
 import busio
 import microcontroller

-import _typing
+from circuitpython_typing import ReadableBuffer

 from ._constants import (
     CHIP_SELECT_TOGGLE_EVERY_BYTE,
     CHIP_SELECT_UNTOUCHED,
 from ._constants import (
     CHIP_SELECT_TOGGLE_EVERY_BYTE,
     CHIP_SELECT_UNTOUCHED,


@@ -30,7 +30,7 @@ from ._constants import (
     DISPLAY_DATA,
 )
 
     DISPLAY_DATA,
 )
 

-__version__ = "0.0.0-auto.0"
+__version__ = "0.0.0+auto.0"

 __repo__ = "https://github.com/adafruit/Adafruit_Blinka_displayio.git"
 
 
 __repo__ = "https://github.com/adafruit/Adafruit_Blinka_displayio.git"
 
 


@@ -44,7 +44,7 @@ class FourWire:
         spi_bus: busio.SPI,
         *,
         command: microcontroller.Pin,
         spi_bus: busio.SPI,
         *,
         command: microcontroller.Pin,

-        chip_select: microcontroller.Pin,
+        chip_select: Optional[microcontroller.Pin] = None,

         reset: Optional[microcontroller.Pin] = None,
         baudrate: int = 24000000,
         polarity: int = 0,
         reset: Optional[microcontroller.Pin] = None,
         baudrate: int = 24000000,
         polarity: int = 0,


@@ -61,8 +61,13 @@ class FourWire:
         """
         self._dc = digitalio.DigitalInOut(command)
         self._dc.switch_to_output(value=False)
         """
         self._dc = digitalio.DigitalInOut(command)
         self._dc.switch_to_output(value=False)

-        self._chip_select = digitalio.DigitalInOut(chip_select)
-        self._chip_select.switch_to_output(value=True)
+
+        if chip_select is not None:
+            self._chip_select = digitalio.DigitalInOut(chip_select)
+            self._chip_select.switch_to_output(value=True)
+        else:
+            self._chip_select = None
+

         self._frequency = baudrate
         self._polarity = polarity
         self._phase = phase
         self._frequency = baudrate
         self._polarity = polarity
         self._phase = phase


@@ -78,7 +83,10 @@ class FourWire:
         self.reset()
         self._spi.deinit()
         self._dc.deinit()
         self.reset()
         self._spi.deinit()
         self._dc.deinit()

-        self._chip_select.deinit()
+
+        if self._chip_select is not None:
+            self._chip_select.deinit()
+

         if self._reset is not None:
             self._reset.deinit()
 
         if self._reset is not None:
             self._reset.deinit()
 


@@ -93,7 +101,11 @@ class FourWire:
             time.sleep(0.001)
 
     def send(
             time.sleep(0.001)
 
     def send(

-        self, command, data: _typing.ReadableBuffer, *, toggle_every_byte: bool = False
+        self,
+        command,
+        data: ReadableBuffer,
+        *,
+        toggle_every_byte: bool = False,

     ) -> None:
         """
         Sends the given command value followed by the full set of data. Display state,
     ) -> None:
         """
         Sends the given command value followed by the full set of data. Display state,


@@ -108,13 +120,22 @@ class FourWire:
             else CHIP_SELECT_UNTOUCHED
         )
         self._begin_transaction()
             else CHIP_SELECT_UNTOUCHED
         )
         self._begin_transaction()

-        self._send(DISPLAY_COMMAND, chip_select, command)
+        self._send(DISPLAY_COMMAND, chip_select, bytes([command]))

         self._send(DISPLAY_DATA, chip_select, data)
         self._end_transaction()
 
         self._send(DISPLAY_DATA, chip_select, data)
         self._end_transaction()
 

-    def _send(self, data_type: int, chip_select: int, data: _typing.ReadableBuffer):
+    def _send(
+        self,
+        data_type: int,
+        chip_select: int,
+        data: ReadableBuffer,
+    ):

         self._dc.value = data_type == DISPLAY_DATA
         self._dc.value = data_type == DISPLAY_DATA

-        if chip_select == CHIP_SELECT_TOGGLE_EVERY_BYTE:
+
+        if (
+            self._chip_select is not None
+            and chip_select == CHIP_SELECT_TOGGLE_EVERY_BYTE
+        ):

             for byte in data:
                 self._spi.write(bytes([byte]))
                 self._chip_select.value = True
             for byte in data:
                 self._spi.write(bytes([byte]))
                 self._chip_select.value = True


@@ -123,16 +144,29 @@ class FourWire:
         else:
             self._spi.write(data)
 
         else:
             self._spi.write(data)
 

-    def _begin_transaction(self):
+    def _free(self) -> bool:
+        """Attempt to free the bus and return False if busy"""
+        if not self._spi.try_lock():
+            return False
+        self._spi.unlock()
+        return True
+
+    def _begin_transaction(self) -> bool:

         """Begin the SPI transaction by locking, configuring, and setting Chip Select"""
         """Begin the SPI transaction by locking, configuring, and setting Chip Select"""

-        while not self._spi.try_lock():
-            pass
+        if not self._spi.try_lock():
+            return False

         self._spi.configure(
             baudrate=self._frequency, polarity=self._polarity, phase=self._phase
         )
         self._spi.configure(
             baudrate=self._frequency, polarity=self._polarity, phase=self._phase
         )

-        self._chip_select.value = False

 
 

-    def _end_transaction(self):
+        if self._chip_select is not None:
+            self._chip_select.value = False
+
+        return True
+
+    def _end_transaction(self) -> None:

         """End the SPI transaction by unlocking and setting Chip Select"""
         """End the SPI transaction by unlocking and setting Chip Select"""

-        self._chip_select.value = True
+        if self._chip_select is not None:
+            self._chip_select.value = True
+

         self._spi.unlock()
         self._spi.unlock()