JoyPi-RGB-Matrix-RaspberryPi 1.0.0__py3-none-any.whl

JoyPi_RGB_Matrix_RaspberryPi/RGB_Matrix.py

@@ -0,0 +1,154 @@
+from ._RGBW import RGBW
+from ._PixelStrip import PixelStrip
+import time
+
+class RGB_Matrix:
+    """
+    New version using the I2C-based PixelStrip instead of rpi_ws281x.
+    """
+
+    def __init__(self, bus = None, bus_id = 1, i2c_adress = 0x66, count = 64, brightness = 10, 
+                 right_border = [7,15,23,31,39,47,55,63], left_border = [0,8,16,24,32,40,48,56]):
+        """
+        initiliaze LED matrix
+        
+        :param count: amount of LEDs in matrix
+        :param brightness: brightness level of all pixels
+        :param right_border: reference values for all pixel on the right side
+        :param left_border: reference values for all pixel on the left side
+        """
+        # LED configuration
+        self.LED_COUNT = count
+        self.LED_BRIGHTNESS = brightness
+
+        # For reference if needed
+        self.RIGHT_BORDER = right_border
+        self.LEFT_BORDER  = left_border
+
+        # Create the I2C-based PixelStrip instance
+        self.strip = PixelStrip(num=self.LED_COUNT, brightness=self.LED_BRIGHTNESS,
+                                bus = bus, bus_id = bus_id, i2c_adress=i2c_adress)
+        self.strip.begin()
+
+    def clean(self):
+        """
+        Turn off all pixels
+        """
+        self.RGB_off()
+
+    def setPixel(self, position, colour):
+        """
+        set pixel at position to colour
+        
+        :param position: Pixel position index
+        :param colour: RGBW value 32 bit integer
+        """
+        self.strip.setPixelColor(position, colour)
+
+    def RGB_on(self, colour):
+        """
+        set all pixel of matrix to colour
+        
+        :param colour: RGBW value 32 bit integer
+        """
+        for i in range(self.strip.numPixels()):
+            self.strip.setPixelColor(i, colour)
+        self.strip.show()
+
+    def RGB_off(self):
+        """
+        turn all LEDs in matrix off
+        """
+        for i in range(self.strip.numPixels()):
+            self.strip.setPixelColor(i, RGBW(0, 0, 0, 0))
+        self.strip.show()
+
+    def wheel(self, pos):
+        """
+        generate rainbow colours over positions 0-255
+
+        :param pos: selected pixel
+        """
+        if pos < 85:
+            return RGBW(pos * 3, 255 - pos * 3, 0, 0)
+        elif pos < 170:
+            pos -= 85
+            return RGBW(255 - pos * 3, 0, pos * 3, 0)
+        else:
+            pos -= 170
+            return RGBW(0, pos * 3, 255 - pos * 3, 0)
+
+    def rainbow(self, wait_ms=20, iterations=1):
+        """
+        Rainbow effect on all LEDs
+
+        :param wait_ms: time in between colour change per pixel
+        :param iterations: iterations of animation
+        """
+        for j in range(256 * iterations):
+            for i in range(self.strip.numPixels()):
+                self.strip.setPixelColor(i, self.wheel((i + j) & 255))
+            self.strip.show()
+            time.sleep(wait_ms / 1000.0)
+
+    def colourWipe(self, color, wait_ms=50):
+        """
+        Move colours pixel by pixel over the LEDs with a given colour
+
+        :param color: RGB value to set pixels to
+        :param wait_ms: time between each pixel
+        """
+        for i in range(self.strip.numPixels()):
+            self.strip.setPixelColor(i, color)
+            self.strip.show()
+            time.sleep(wait_ms / 1000.0)
+
+    def theaterChase(self, color, wait_ms=50, iterations=10):
+        """
+        Chaser animation with a given colour
+
+        :param color: RGB value to set pixels to
+        :param wait_ms: time in between colour change per pixel
+        :param iterations: iterations of animation
+        """
+        for j in range(iterations):
+            for q in range(3):
+                for i in range(0, self.strip.numPixels(), 3):
+                    self.strip.setPixelColor(i + q, color)
+                self.strip.show()
+                time.sleep(wait_ms / 1000.0)
+                for i in range(0, self.strip.numPixels(), 3):
+                    self.strip.setPixelColor(i + q, 0)
+
+    def demo1(self):
+        """
+        Simple demo programm
+        """
+        self.theaterChase(RGBW(127, 127, 127, 0))  # White chaser
+        self.theaterChase(RGBW(127, 0, 0, 0))  # Red chaser
+        self.theaterChase(RGBW(0, 0, 127, 0)) # Blue chaser
+        self.rainbow()
+        self.clean()
+
+    def show(self):
+        """
+        show changes on LED matrix
+        """
+        self.strip.show()
+
+    def demo2(self):
+        """
+        More complex demo programm in a continuous loop
+        """
+        heart = [1,6,8,9,10,13,14,15,16,17,18,19,20,21,22,23,
+                         24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,
+                         41,42,43,44,45,46,50,51,52,53,59,60]
+        try:
+            for i in range(3):
+                self.demo1()
+            while True:
+                for i in heart:
+                    self.strip.setPixelColor(i, RGBW(255, 0, 0, 0))
+                self.strip.show()
+        except KeyboardInterrupt:
+            self.clean()

JoyPi_RGB_Matrix_RaspberryPi/_LEDTransferData.py

@@ -0,0 +1,156 @@
+class LEDTransferData:
+    """
+    Data container class used to prepare and store parameters for I2C
+    communication with the LED controller.
+
+    This class encapsulates all fields required to build a command packet,
+    including function identifiers, pixel position, color values, brightness,
+    and range parameters for bulk operations.
+    """
+    def __init__(self, func=0, pos=0, r=0, g=0, b=0, w=0, c=0, bright=5, first=0, count=0):
+        """
+        Initialize the data structure for an LED control command
+        
+        :param func: Function ID (see FunctionEnum)
+        :param pos: Pixel position index
+        :param r: Red color component (0–255)
+        :param g: Green color component (0–255)
+        :param b: Blue color component (0–255)
+        :param w: White color component (for RGBW LEDs)
+        :param c: Additional color or control parameter (device-dependent)
+        :param bright: Global brightness level
+        :param first: First pixel index for range operations
+        :param count: Number of pixels affected in range operations
+        """
+        self.func   = func
+        self.pos    = pos
+        self.r      = r
+        self.g      = g
+        self.b      = b
+        self.w      = w
+        self.c      = c
+        self.bright = bright
+        self.first  = first
+        self.count  = count
+        self.data   = 0
+        self.data1  = 0
+
+    def setFunc(self, func=0):
+        """
+        set Function ID
+
+        :param func: Function ID - default = 0 - SHOW
+        """
+        self.func = func
+    
+    def setPos(self, pos=0):
+        """
+        set Pixel position index
+        
+        :param pos: Pixel position index - default = 0
+        """
+        self.pos = pos
+    
+    def setR(self, r=0):
+        """
+        set Red color component
+
+        :param r: Red color component - default = 0
+        """
+        self.r = r
+    
+    def setG(self, g=0):
+        """
+        set Green color component 
+
+        :param g: Green color component - default = 0
+        """
+        self.g = g
+    
+    def setB(self, b=0):
+        """
+        set Blue color component
+        
+        :param b: Blue color component - default = 0
+        """
+        self.b = b
+    
+    def setW(self, w=0):
+        """
+        set White color component
+        
+        :param w: White color component - default = 0
+        """
+        self.w = w
+    
+    def setC(self, c=0):
+        """
+        set Additional color or control parameter
+        
+        :param c: Additional color or control parameter - default = 0
+        """
+        self.c = c
+    
+    def setFirst(self, first=0):
+        """
+        set First pixel index for range operations
+        
+        :param first: First pixel index for range operations - default = 0
+        """
+        self.first = first
+    
+    def setCount(self, count=0):
+        """
+        set Number of pixels affected in range operations
+        
+        :param count: Number of pixels affected in range operations - default = 0
+        """
+        self.count = count
+    
+    def setBright(self, bright=0):
+        """
+        set Global brightness level
+
+        :param bright: Global brightness level - default = 0
+        """
+        self.bright = bright
+    
+    def setData(self, data=0):
+        """
+        Sets the primary data value for the I²C command packet.
+
+        This value is typically used to store a processed or combined
+        parameter (e.g., color value, gamma result, or control data)
+        before transmission.
+        
+        :param data: Integer value to be assigned to the primary data field - default = 0
+        """
+        self.data = data
+    
+    def setData1(self, data=0):
+        """
+        Sets the secondary data value for the I²C command packet.
+
+        This field is commonly used for additional parameters such as
+        high/low bytes, extended data, or supplementary command values.
+        
+        :param data: Integer value to be assigned to the secondary data field - default = 0
+        """
+        self.data1 = data
+
+    def clean(self):
+        """
+        Reset all internal fields to zero after transmission
+        """
+        self.func   = 0
+        self.pos    = 0
+        self.r      = 0
+        self.g      = 0
+        self.b      = 0
+        self.w      = 0
+        self.c      = 0
+        self.bright = 0
+        self.first  = 0
+        self.count  = 0
+        self.data   = 0
+        self.data1  = 0

JoyPi_RGB_Matrix_RaspberryPi/_PixelStrip.py

@@ -0,0 +1,292 @@
+from ._LEDTransferData import LEDTransferData
+from enum import Enum
+import smbus2
+import time
+
+class FunctionEnum(Enum):
+    """
+    Enumeration of command identifiers used for controlling the LED matrix
+    via I2C communication.
+
+    Each value represents a specific function that can be executed by the
+    LED controller firmware, such as pixel manipulation, brightness control,
+    gamma correction, color conversion, or data transmission.
+    """
+    SHOW                = 0
+    SETPIXELCOLOR       = 1
+    FILL                = 2
+    SETBRIGHTNESS       = 3
+    WHITEOVERRAINBOW    = 4
+    GAMMA8              = 5
+    GAMMA32             = 6
+    NUMPIXEL            = 7
+    COLORHSV            = 8
+    CLEAR               = 9
+    SENDDATA2SHOW       = 10
+    SENDALLPIXRGB0      = 11
+    SENDALLPIXRGB1      = 12
+    SENDALLPIXRGB2      = 13
+    SENDALLPIXRGB3      = 14
+    SENDALLPIXRGB4      = 15
+    SENDALLPIXRGB5      = 16
+
+class PixelStrip:
+    """
+    Controls a strip of LEDs (WS281x / SK6812) via I2C.
+    """
+
+    def __init__(self, num, brightness=255, bus = None, bus_id = 1, i2c_adress = 0x66):
+        """
+        initilize LED controll class
+        
+        :param num: amount of pixel to controll
+        :param brightness: brightness of all pixels
+        """
+        self.num = num
+        self.bus = bus if bus is not None else smbus2.SMBus(bus_id)
+        self.Address = i2c_adress
+        self.transfer_data = LEDTransferData()
+        self.transfer_data.setBright(brightness)
+
+    def begin(self):
+        """
+        Set the initial brightness on the hardware side via I2C
+        """
+        self.transfer_data.setFunc(FunctionEnum.SETBRIGHTNESS.value)
+        self.send(0x00)
+
+    def send(self, cmd):
+        """
+        Send a block of data to the device using I2C
+
+        :param cmd: block of data to send
+        """
+        self.bus.write_block_data(
+            self.Address, cmd, [
+                self.transfer_data.func,
+                self.transfer_data.pos,
+                self.transfer_data.r,
+                self.transfer_data.g,
+                self.transfer_data.b,
+                self.transfer_data.w,
+                self.transfer_data.c,
+                self.transfer_data.bright,
+                self.transfer_data.first,
+                self.transfer_data.count,
+                self.transfer_data.data,
+                self.transfer_data.data1
+            ]
+        )
+        time.sleep(0.003)  # Hardware timing delay
+        self.transfer_data.clean()
+
+    def __len__(self):
+        """
+        Return the total number of pixels
+        """
+        return self.num
+
+    def clear(self):
+        """
+        Clear the entire LED strip (turn off all pixels)
+        """
+        self.transfer_data.setFunc(FunctionEnum.CLEAR.value)
+        self.send(0x00)
+
+    def show(self):
+        """
+        Show updated pixel data on the LED strip
+        """
+        self.transfer_data.setFunc(FunctionEnum.SHOW.value)
+        self.send(0x00)
+
+    def getWRGB(self, color):
+        """
+        Extract W, R, G, B values from a single color int
+
+        :param color: single color int
+        """
+        return (
+            (color >> 24) & 0xff, 
+            (color >> 16) & 0xff, 
+            (color >> 8)  & 0xff, 
+            color & 0xff
+        )
+
+    def setPixelColor(self, n, color):
+        """
+        Set a single pixel (at index n) to the specified 32-bit color
+
+        :param n: Pixel position index
+        :param color: 32-bit color or tupel of (r,g,b) or (r,g,b,w)
+        """
+        self.transfer_data.setPos(n)
+        if isinstance(color, tuple):
+            if len(color) == 3:
+                r, g, b = color
+                w = 0
+            elif len(color) == 4:
+                r, g, b, w = color
+        else:
+            w, r, g, b = self.getWRGB(color)
+        self.setPixelColorRGB(n, r, g, b, w)
+
+    def setPixelColorRGB(self, n, red, green, blue, white=0):
+        """
+        set Pixel colour at specific index
+
+        :param n: Pixel position index
+        :param red: colour value of red
+        :param green: colour value of green
+        :param blue: colour value of blue
+        :param white: colour value of white - default 0
+        """
+        self.transfer_data.setPos(n)
+        self.transfer_data.setR(red)
+        self.transfer_data.setG(green)
+        self.transfer_data.setB(blue)
+        self.transfer_data.setW(white)
+        self.transfer_data.setC(0)
+        self.transfer_data.setFunc(FunctionEnum.SETPIXELCOLOR.value)
+        self.send(0x00)
+
+    def sendPos2Show(self, pos, r=0, g=0, b=0):
+        """
+        Sends color data to selected pixel positions and immediatly dislpays update
+        
+        :param pos: Pixel position index
+        :param r: colour value of red
+        :param g: colour value of green
+        :param b: colour value of blue
+        """
+        self.transfer_data.setR(r)
+        self.transfer_data.setG(g)
+        self.transfer_data.setB(b)
+        for i in pos:
+            if 0 <= i <= 7:
+                self.transfer_data.pos |= 1 << i
+            elif 8 <= i <= 15:
+                self.transfer_data.w |= 1 << (i - 8)
+            elif 16 <= i <= 23:
+                self.transfer_data.c |= 1 << (i - 16)
+            elif 24 <= i <= 31:
+                self.transfer_data.bright |= 1 << (i - 24)
+            elif 32 <= i <= 39:
+                self.transfer_data.first |= 1 << (i - 32)
+            elif 40 <= i <= 47:
+                self.transfer_data.count |= 1 << (i - 40)
+            elif 48 <= i <= 55:
+                self.transfer_data.data |= 1 << (i - 48)
+            elif 56 <= i <= 63:
+                self.transfer_data.data1 |= 1 << (i - 56)
+        self.transfer_data.setFunc(FunctionEnum.SENDDATA2SHOW.value)
+        self.send(0x00)
+
+    def sendColor2Show(self, pos, color=0):
+        """
+        write RGB value onto pixel at specific index
+        
+        :param pos: Pixel position index
+        :param color: RGB value to write onto pixel
+        """
+        w, r, g, b = self.getWRGB(color)
+        self.transfer_data.setR(r)
+        self.transfer_data.setG(g)
+        self.transfer_data.setB(b)
+        self.sendPos2Show(pos, r, g, b)
+
+    def sendAllPixRGB(self, rgb):
+        """
+        Send large RGB data (6 chunks of 32 bytes each) to fill multiple pixels
+
+        :param self: Description
+        :param rgb: RGB value to write onto pixels
+        """
+        for i in range(6):
+            start = 32 * i
+            end = start + 32
+            self.bus.write_block_data(
+                self.Address,
+                FunctionEnum.SENDALLPIXRGB0.value + i,
+                rgb[start:end]
+            )
+
+    def fill(self, r=0, g=0, b=0, w=0, first=0, end=64):
+        """
+        write same RGB value from pixel with one index to another 
+
+        :param r: colour value of red
+        :param g: colour value of green
+        :param b: colour value of blue
+        :param w: colour value of white
+        :param first: index of pixel to begin writing color on
+        :param end: index of pixel to end writing colour on
+        """
+        self.transfer_data.setR(r)
+        self.transfer_data.setG(g)
+        self.transfer_data.setB(b)
+        self.transfer_data.setW(w)
+        self.transfer_data.setFirst(first)
+        self.transfer_data.setCount(end - first)
+        self.transfer_data.setFunc(FunctionEnum.FILL.value)
+        self.send(0x00)
+
+    def fillColor(self, color, first=0, end=63):
+        """
+        write same RGB value from pixel with one index to another 
+
+        :param color: RGBW value to write onto pixels
+        :param first: index of pixel to begin writing color on
+        :param end: index of pixel to end writing colour on
+        """
+        w, r, g, b = self.getWRGB(color)
+        self.fill(r, g, b, w, first, end)
+
+    def setBrightness(self, brightness):
+        """
+        Set global brightness for all pixels
+        
+        :param brightness: set brightness to all pixels
+        """
+        self.transfer_data.setBright(brightness)
+        self.transfer_data.setFunc(FunctionEnum.SETBRIGHTNESS.value)
+        self.send(0x00)
+
+    def numPixels(self):
+        """
+        Return the number of pixels in this strip
+        """
+        return self.num
+
+    def getGamma8(self, x):
+        """
+        Applies 8-bit gamma correction to the given input value.
+
+        :param x: 8-bit input value (0-255)
+        """
+        self.transfer_data.setFunc(FunctionEnum.GAMMA8.value)
+        self.transfer_data.setData(x)
+        self.send(0x01)
+        return self.bus.read_byte(self.Address)
+
+    def getGamma32(self, x):
+        """
+        Applies 32-bit gamma correction to the given input value.
+
+        :param x: 32-bit input value
+        """
+        self.transfer_data.setFunc(FunctionEnum.GAMMA32.value)
+        self.transfer_data.setData(x)
+        self.send(0x01)
+        return self.bus.read_byte(self.Address)
+
+    def ColorHSV(self, x):
+        """
+        Converts an HSV color value into the device-specific RGB format.
+
+        :param x: HSV input value (device-dependent encoding)
+        """
+        self.transfer_data.setFunc(FunctionEnum.COLORHSV.value)
+        self.transfer_data.setData(x)
+        self.send(0x01)
+        return self.bus.read_byte(self.Address)

JoyPi_RGB_Matrix_RaspberryPi/_RGBW.py

@@ -0,0 +1,57 @@
+class RGBW(int):
+    """
+    Represents a 32-bit RGBW color value.
+
+    This class allows combining separate red, green, blue, and optional white
+    components into a single 32-bit integer while still providing convenient
+    access to each color channel via properties.
+
+    Format (32-bit):
+        [ W (8 bit) | R (8 bit) | G (8 bit) | B (8 bit) ]
+    """
+
+    def __new__(self, r, g=None, b=None, w=None):
+        """
+        Create a new RGBW color value. The object can be initialized in two ways:
+        1) With a single integer: RGBW(0xWWRRGGBB)
+        2) With individual color components: RGBW(r, g, b, w=0)
+
+        :param r: Red value (0–255) or packed 32-bit integer
+        :param g: Green value (0–255)
+        :param b: Blue value (0–255)
+        :param w: White value (0–255), optional (default = 0)
+        """
+        if (g, b, w) == (None, None, None):
+            return int.__new__(self, r)
+        else:
+            if w is None:
+                w = 0
+            return int.__new__(self, (w << 24) | (r << 16) | (g << 8) | b)
+
+    @property
+    def getR(self):
+        """
+        get red value
+        """
+        return (self >> 16) & 0xff
+
+    @property
+    def getG(self):
+        """
+        get green value
+        """
+        return (self >> 8) & 0xff
+
+    @property
+    def getB(self):
+        """
+        get blue value
+        """
+        return self & 0xff
+
+    @property
+    def getW(self):
+        """
+        get white value
+        """
+        return (self >> 24) & 0xff

JoyPi_RGB_Matrix_RaspberryPi/__init__.py

@@ -0,0 +1,3 @@
+from .RGB_Matrix import RGB_Matrix
+
+__all__ = ["RGB_Matrix"]

joypi_rgb_matrix_raspberrypi-1.0.0.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: JoyPi_RGB_Matrix_RaspberryPi
+Version: 1.0.0
+Summary: This library enables usage of RGB matrix with RP2040 microcontroller chip on the Raspberry Pi.
+Project-URL: Homepage, https://github.com/joy-it/JoyPi_RGB_Matrix_RaspberryPi
+Project-URL: Issues, https://github.com/joy-it/JoyPi_RGB_Matrix_RaspberryPi/issues
+Author-email: Joy-IT <service@joy-it.net>
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# JoyPi_RGB_Matrix_RaspberryPi
+This library enables usage of RGB matrix with RP2040 microcontroller chip on the Raspberry Pi.
+
+>[!WARNING]
+> This library was written for the usage of the LED matrix of the Joy-Pi Advanced 2 and Joy-Pi Note 2. Both Joy-Pis have the RP2040 microcontroller chip to control the LED matrix. This is to ensure compatibility with the Raspberry Pi 5 because the library which was used beforehand is not compatible up to this date.
+
+## Installation
+You can install this library from PyPI.
+To install it for the current user on your Raspberry Pi, use the following command:
+```
+pip install JoyPi_RGB_Matrix_RaspberryPi
+```
+
+## Library Guide
+- `LEDMatrix( count = 64, brightness = 10, right_border = [7,15,23,31,39,47,55,63], left_border = [0,8,16,24,32,40,48,56])`- initialize LED matrix with default values for Joy-Pi
+- `clean()` - clears the LED matrix
+- `setPixel(position, colour)` - sets specific pixel to a selected colour
+- `RGB_on(colour)` - sets the complete matrix to one selected colour
+- `RGB_off()` - turns the complete matrix off
+- `rainbow(wait_ms=20, iterations=1)` - rainbow effect on the whole matrix with default values
+- `colourWipe(colour, wait_ms=50)` - Move selected colour pixel by pixel onto the matrix with default speed
+- `theaterChase( colour, wait_ms=50, iterations=10)` - chaser animation with a selected colour with deafult speed
+- `show()` - displays set pixels
+- `demo1()` - demo program version 1
+- `demo2()` - demo program version 2 

joypi_rgb_matrix_raspberrypi-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+JoyPi_RGB_Matrix_RaspberryPi/RGB_Matrix.py,sha256=u3bVOw9-weDAANFtf3VnPQMWbJRDDDm86cMlezzUvbM,5114
+JoyPi_RGB_Matrix_RaspberryPi/_LEDTransferData.py,sha256=pFT0s87GIUvcorLBMoP6SaVyG1a4VFFd3ZFemH0SvIw,4612
+JoyPi_RGB_Matrix_RaspberryPi/_PixelStrip.py,sha256=Ogmkn6v5e2GfzOG2qiYrwVhBVukL4JRTNMklIsXcEEI,9584
+JoyPi_RGB_Matrix_RaspberryPi/_RGBW.py,sha256=EcaedZUnIVB30MQiqcV5YPxvjxWJKUdMZLnERE1nLho,1577
+JoyPi_RGB_Matrix_RaspberryPi/__init__.py,sha256=TmM6J8HmbztmrjNjyOO3-xGrS1FeNlc0TZKVW7do4mA,62
+joypi_rgb_matrix_raspberrypi-1.0.0.dist-info/METADATA,sha256=-UXhIi_ysnCUTmjU3gak8aByBLDyoZNLuxRF9LQ6X-M,2051
+joypi_rgb_matrix_raspberrypi-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+joypi_rgb_matrix_raspberrypi-1.0.0.dist-info/licenses/LICENSE,sha256=huySC1quQxrIchKLo7iaLAiFssUwfkKHjAEcXDJ5XXk,1085
+joypi_rgb_matrix_raspberrypi-1.0.0.dist-info/RECORD,,

joypi_rgb_matrix_raspberrypi-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

joypi_rgb_matrix_raspberrypi-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 KeeckAOE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.