JoyPi-Advanced-RaspberryPi 2.0.0__py3-none-any.whl

JoyPi_Advanced_RaspberryPi/LEDMatrix.py

@@ -0,0 +1,166 @@
+import time
+from rpi_ws281x import PixelStrip, Color
+
+
+class LEDMatrix:
+    """
+    The Joy-Pi Advanced 2 is no longer compatible with this library for the LED 
+    matrix. To ensure compatibility with the Raspberry Pi 5, the LED matrix is now 
+    controlled via I²C because of the RP2040 microcontroller chip. The LED matrix 
+    can now be controlled with the Joy-Pi Advanced via this repository
+    http://github.com/joy-it/JoyPi_RGB_Matrix_RaspberryPi
+    """
+    def __init__(self, pin = 18, brightness = 100):
+        # LED strip configuration
+        self.LED_COUNT = 64              # Number of pixels
+        self.LED_PIN = pin               # GPIO pin to which the module is connected
+        self.LED_FREQ_HZ = 800000        # LED signal frequency
+        self.LED_DMA = 10                # DMA channel used to generate the signal
+        self.LED_BRIGHTNESS = brightness # Brightness setting
+        self.LED_INVERT = False          # Signal inversion
+        self.LED_CHANNEL = 0             # Set to 1 if GPIOs 13, 19, 41, 45 or 53 are used
+
+        self.RIGHT_BORDER = [7,15,23,31,39,47,55,63]
+        self.LEFT_BORDER = [0,8,16,24,32,40,48,56]
+        
+        # Create NeoPixel object
+        self.strip = PixelStrip(self.LED_COUNT, self.LED_PIN, self.LED_FREQ_HZ, self.LED_DMA, self.LED_INVERT, self.LED_BRIGHTNESS, self.LED_CHANNEL)
+        
+        # Initialize library
+        self.strip.begin()
+
+
+    def clean(self):
+        """ 
+        Switch off all LEDs
+        """
+        for i in range(self.strip.numPixels()):
+            self.strip.setPixelColor(i, Color(0, 0, 0))
+        self.strip.show()
+
+
+    def setPixel(self, position, colour):
+        """
+        set Pixel on position to given colour
+        """
+        try:
+            r, g, b = colour
+        except ValueError:
+            print("Colour is not a tuple!")
+            
+        self.strip.setPixelColor(position, Color(r, g, b))
+
+
+    def RGB_on(self,colour):
+        """
+        set all pixels to given colour
+        """
+        try:
+            r, g, b = colour
+        except ValueError:
+            print("Colour is not a tuple!")
+        
+        for i in range(64):
+            self.strip.setPixelColor(i,Color(r, g, b))
+        self.strip.show()
+
+
+    def wheel(self,pos):
+        """
+        generate rainbow colours over positions 0-255
+        """
+        if pos < 85:
+            return Color(pos * 3, 255 - pos * 3, 0)
+        elif pos < 170:
+            pos -= 85
+            return Color(255 - pos * 3, 0, pos * 3)
+        else:
+            pos -= 170
+            return Color(0, pos * 3, 255 - pos * 3)
+
+
+    def rainbow(self, wait_ms=20, iterations=1):
+        """
+        Rainbow effect on all LEDs
+        """
+        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)
+        self.clean()
+
+
+    def colourWipe(self, colour, wait_ms=50):
+        """
+        Move colours pixel by pixel over the LEDs with a given colour
+        """
+        try:
+            r, g, b = colour
+        except ValueError:
+            print("Colour is not a tuple!")
+        
+        for i in range(self.strip.numPixels()):
+            self.strip.setPixelColor(i, Color(r, g, b))
+            self.strip.show()
+            time.sleep(wait_ms / 1000.0)
+
+
+    def theaterChase(self, colour, wait_ms=50, iterations=10):
+        """
+        Chaser animation with a given colour
+        """
+        try:
+            r, g, b = colour
+        except ValueError:
+            print("Colour is not a tuple!")
+        
+        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(r, g, b))
+                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((127, 127, 127))  # White chaser
+        self.theaterChase((127, 0, 0))  # Red chaser
+        self.theaterChase((0, 0, 127))  # Blue chaser
+
+        self.rainbow()
+
+        self.clean()
+
+
+    def show(self):
+        """
+        displays set pixels
+        """
+        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 j in range(256):
+                    for i in heart:
+                        self.strip.setPixelColor(i,Color(j,0,0))
+                    self.strip.show()
+                for j in range(256, 0, -1):
+                    for i in heart:
+                        self.strip.setPixelColor(i,Color(j,0,0))
+                    self.strip.show()
+        except KeyboardInterrupt:
+             self.clean()

JoyPi_Advanced_RaspberryPi/__init__.py

@@ -0,0 +1,14 @@
+from .servomotor import servomotor
+from .stepmotor import stepmotor
+from .gyroscope import gyroscope
+from .barometer import barometer
+from .buttonmatrix import buttonmatrix
+from .colour import colour
+from .adc import adc
+
+try:
+    from .LEDMatrix import LEDMatrix
+except Exception:
+    LEDMatrix = None
+
+name = "JoyPiAdvanced"

JoyPi_Advanced_RaspberryPi/adc.py

@@ -0,0 +1,91 @@
+from spidev import SpiDev
+from gpiozero import DigitalOutputDevice
+    
+class adc:
+    SYSTEM_STATUS = 0x00
+    READ_CMD = 0x10
+    WRITE_CMD = 0x08
+    CHANNEL_SEL = 0x11
+    PIN_CFG = 0x05
+    SEQUENCE_CFG = 0x10
+    
+    def __init__(self, bus = 0, device = 0, cs = 8):
+        """
+        initialize ADC
+        bus - select bus
+        device - select device
+        """
+        self.bus, self.device = bus, device
+        self.spi = SpiDev()
+        self.open()
+        self.spi.max_speed_hz = 1000000 # 1MHz
+        self.spi.mode = 0
+        self.cs = DigitalOutputDevice(cs, initial_value = True)
+ 
+    def open(self):
+        """
+        start SPI communication
+        """
+        self.spi.open(self.bus, self.device)
+        self.spi.max_speed_hz = 1000000 # 1MHz
+    
+    def read_value(self, channel):      
+        """
+        returns raw value from a specific channel
+        channel - which channel should be read from
+        """ 
+        data = self.read_register(self.SEQUENCE_CFG)
+        self.write_register(self.SEQUENCE_CFG, data[0] & 0xFC)
+        self.write_register(self.PIN_CFG, 0x00)
+        self.write_register(self.SEQUENCE_CFG, 0x00)
+        self.write_register(self.CHANNEL_SEL, channel)
+        self.cs.toggle()
+        self.spi.readbytes(2)
+        self.cs.toggle()
+        self.cs.toggle()
+        data = self.spi.readbytes(2)
+        self.cs.toggle()
+        return ((data[0]<<8) | data[1]) >>4
+ 
+    def read_voltage(self, channel, value = None): 
+        """
+        returns measured voltage from a specific channel
+        channel - which should be read from
+        value - if channel is already read, raw value can be then used to calculate voltage
+        """
+        if value is None:  
+            return round((self.read_value(channel) / 4096) * 5.0, 2)
+        return round((value / 4096) * 5.0, 2)
+
+    def close(self):
+        """
+        end SPI communication
+        """
+        self.spi.close()
+        self.cs.close()
+        
+    def read_register(self, reg):
+        """
+        returns value from a specific register
+        reg - register which should be read from
+        """
+        self.cs.toggle()
+        self.spi.writebytes([self.READ_CMD, reg, 0x00])
+        self.cs.toggle()
+        return self.spi.readbytes(1)
+        
+    def write_register(self, reg, data):
+        """
+        write value into a specific register
+        reg - register in which should be written
+        data - value which should be written into the register
+        """
+        self.cs.toggle()
+        self.spi.writebytes([self.WRITE_CMD, reg, data])
+        self.cs.toggle()
+        
+    def read_status(self):
+        """
+        return status of the ADC
+        """
+        return self.read_register(self.SYSTEM_STATUS)

JoyPi_Advanced_RaspberryPi/barometer.py

@@ -0,0 +1,104 @@
+import busio
+from adafruit_bus_device import i2c_device
+import time
+
+class barometer:
+    
+    RESET = 0x1E
+    READ = 0x00
+    CONV = 0x40
+    D1 = 0x00
+    D2 = 0x10
+    PROM_RD = 0xA0
+    ADC_RESOLUTION = {256: 0x00,
+                      512: 0x02,
+                      1024: 0x04,
+                      2048: 0x06,
+                      4096: 0x08}
+    ADC_DELAY = {0x00: 0.001,
+                  0x02: 0.003,
+                  0x04: 0.004,
+                  0x06: 0.006,
+                  0x08: 0.01}
+   
+    def __init__(self, i2c: busio.I2C, i2c_address = 0x77, resolution=4096):
+        """
+        i2c - i2c port
+        i2c_address - address of the barometer
+        resolution - resolution of the ADC, possible values: 256, 512, 1024, 2048, 4096
+        """
+        self.i2c_address = i2c_address
+        self.device = i2c_device.I2CDevice(i2c, self.i2c_address)
+        self.resolution = self.ADC_RESOLUTION[resolution]
+        self.reset()
+        self._coefficients = self.read_coefficients()
+    
+
+    def reset(self):
+        """
+        resets barometer
+        """
+        with self.device as bus_device:
+            bus_device.write(bytes([self.RESET]))
+        
+    def read_coefficient(self, index):
+        """
+        read value for a specific coefficient
+        """
+        with self.device as bus_device:
+            time.sleep(0.01)
+            bus_device.write(bytes([self.PROM_RD + index * 2]))
+            result = bytearray(2)
+            bus_device.readinto(result)
+        result1, result2 = result[0], result[1]
+        return (256 * result1) + result2
+
+    def read_coefficients(self):
+        """
+        set values too all coefficients
+        """
+        coef = [0] * 6
+        for i in range(6):
+            coef[i] = self.read_coefficient(i+1)
+            if coef[i] == 0 : coef[i] = self.read_coefficient(i+1)
+        return coef
+
+    def conversion(self, data):
+        """
+        read digital data
+        """
+        with self.device as bus_device:
+            time.sleep(0.01)
+            bus_device.write(bytes([0x40 | data | self.resolution]))
+            time.sleep(self.ADC_DELAY[self.resolution])
+            bus_device.write(bytes([self.READ]))
+            result = bytearray(3)
+            bus_device.readinto(result)
+        return 65536 * result[0] + 256 * result[1] + result [2]
+        
+    def get_pressure(self):
+        """
+        calculates the measured pressure
+        """
+        d1 = self.conversion(self.D1)
+        d2 = self.conversion(self.D2)
+        dT = d2 - self._coefficients[4] * 256
+        off = self._coefficients[1] * 131072 + (self._coefficients[3] * dT)/ 64
+        sens = self._coefficients[0] * 65536 + (self._coefficients[2] * dT) / 128
+        return round(((d1 * sens / 2097152 - off) / 32768) / 100, 2)
+
+    def get_temperature(self):
+        """
+        calculates the measured temperature
+        """
+        d2 = self.conversion(self.D2)
+        dT = d2 - self._coefficients[4] * 256
+        return round((2000 + dT * self._coefficients[5] / 8388608) / 100, 2)
+
+    def get_altitude(self, reference_pressure = 1013.25):
+        """
+        calculates altitude from the measured pressure
+        reference_pressure - mean sea level pressure,  should be adjusted to local QNH
+        """
+        pressure = self.get_pressure()
+        return round(44330 * (1 - (pressure / reference_pressure) ** (1/5.255)), 2)

JoyPi_Advanced_RaspberryPi/buttonmatrix.py

@@ -0,0 +1,130 @@
+import board
+import busio
+import digitalio
+import time
+from adafruit_mcp230xx.mcp23008 import MCP23008
+
+class buttonmatrix:
+
+    # values shown on the button matrix
+    dictionary = {(0, 0) : "7",
+                  (0, 1) : "4",
+                  (0, 2) : "1",
+                  (0, 3) : "0",
+                  (1, 0) : "8",
+                  (1, 1) : "5",
+                  (1, 2) : "2",
+                  (1, 3) : "#",
+                  (2, 0) : "9",
+                  (2, 1) : "6",
+                  (2, 2) : "3",
+                  (2, 3) : "=",
+                  (3, 0) : "*",
+                  (3, 1) : "/",
+                  (3, 2) : "+",
+                  (3, 3) : "-"}
+    
+    def __init__(self, i2c: busio.I2C, bounce_time = 0.15, i2c_address = 0x22):
+        """
+        i2c - i2c port
+        i2c_address - address of the barometer
+        bounce_time - buffer time for buttons
+        """
+        self.i2c_address = i2c_address
+        mcp = MCP23008(i2c, address = self.i2c_address)
+        self.rows = [mcp.get_pin(4), mcp.get_pin(5), mcp.get_pin(6), mcp.get_pin(7)]
+        self.columns = [mcp.get_pin(0), mcp.get_pin(1), mcp.get_pin(2), mcp.get_pin(3)]
+        self.calculated = ""
+        self.bounce_time = bounce_time
+        self._last_key = None
+        self._last_time = 0
+        for i in range(len(self.rows)):
+            self.rows[i].direction = digitalio.Direction.INPUT
+            self.rows[i].pull = digitalio.Pull.UP
+            
+            self.columns[i].direction = digitalio.Direction.OUTPUT
+            self.columns[i].value = False
+
+    
+    def _checkMatrix(self):
+        """
+        returns the column and row which was pressed
+        """
+        column_value, row_value = None, None
+        for i in range(len(self.rows)):
+            if self.rows[i].value == False :
+                row_value = i
+
+        # flip columns and rows to get the column
+        for i in range(len(self.columns)):
+            self.columns[i].direction = digitalio.Direction.INPUT
+            self.columns[i].pull = digitalio.Pull.UP
+            self.rows[i].direction = digitalio.Direction.OUTPUT
+            self.rows[i].value = False
+                
+        for i in range(len(self.columns)):
+            if self.columns[i].value == False :
+                column_value = i
+        
+        # set columns and rows back
+        for i in range(len(self.rows)):
+            self.rows[i].direction = digitalio.Direction.INPUT
+            self.rows[i].pull = digitalio.Pull.UP
+            self.columns[i].direction = digitalio.Direction.OUTPUT
+            self.columns[i].value = False
+
+        time.sleep(.1)
+        return column_value, row_value
+            
+
+    def getKey(self):
+        """
+        returns the name of the button which was pressed
+        """
+        key = None
+        try:
+            key = self.dictionary[self._checkMatrix()]
+        except KeyError:
+            key = None
+        current_time = time.monotonic()
+
+        if key is None:
+            self._last_key = None
+            return None
+        if key == self._last_key and (current_time - self._last_time) < self.bounce_time:
+            return None
+        self._last_key = key
+        self._last_time = current_time
+        return key
+
+    def clearMemory(self):
+        """
+        clears class variable calculated
+        """
+        self.calculated = ""
+        
+
+    def calculate(self):
+        """
+        method to use button matrix as calculator
+        """
+        value = self.getKey()
+        if value is None:
+            return self.calculated
+        if value == "=":
+            try:
+                self.calculated = str(eval(self.calculated))
+                return self.calculated
+            # catch if number should be divided by zero
+            except ZeroDivisionError :
+                self.clearMemory()
+                raise ValueError("You can not divide by zero!")
+            # catch if string is not convertable to a number
+            except SyntaxError:
+                self.clearMemory()
+                raise ValueError("Term can not be calculated!")
+        elif value == "#":
+            self.clearMemory()
+        else:
+            self.calculated += value
+            return self.calculated

JoyPi_Advanced_RaspberryPi/colour.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#  
+###################################################################################
+# Edited by Joy-IT
+# 
+###################################################################################
+#  Copyright 2020  <pi@kb>
+#  
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#  
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#  
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#  MA 02110-1301, USA.
+#  
+#  Written by BitHead (Britany Head)
+#  https://forums.raspberrypi.com/viewtopic.php?t=263498
+# Step 1) Enable I2C in Raspi-Config (Interfacing Options)
+# Step 2) sudo apt-get install i2c-tools python3-smbus
+# Step 3) plug it in (don't forget your pull-up resistors) and run this program
+
+import smbus
+import time
+import threading
+import numpy as np
+
+class colour:
+
+    def __init__(self, i2c_address = 0x10):
+        """
+        initialize colour sensor
+        i2c_address - i2c_address of colour sensor (default 0x10)
+        """
+        self.address = i2c_address
+        self.bus = smbus.SMBus(1)
+        self.enableSensor()
+    
+    def write(self, cmd, val):
+        """
+        write value into register on the colour sensor
+        cmd - register
+        val - value to be written
+        """
+        self.bus.write_word_data(self.address, cmd, val)
+    
+    def read(self, cmd):
+        """
+        read value from register on the colour sensor
+        cmd - register
+        """
+        return self.bus.read_word_data(self.address, cmd)
+        
+    def enableSensor(self):
+        """
+        activate Sensor
+        """
+        conf = self.read(0x00) & 0x00FE
+        self.write(0x00, conf)
+        
+    def disableSensor(self):
+        """
+        deactivate Sensor
+        """
+        conf = (self.read(0x00) & 0x00FE) | 0x000
+        self.write(0x00, conf)
+        time.sleep(.001)
+    
+    def getRGBW(self):
+        """
+        returns colour values from colour sensor - red, green, blue, white
+        """
+        return self.read(0x08), self.read(0x09), int(self.read(0x0A) * 1.5), self.read(0x0B)
+        
+    def setIntegrationTime(self, int_time):
+        """
+        set integration time with variable int_time
+        int_time - integration time 
+            0 = 40 ms
+            1 = 80 ms
+            2 = 160 ms
+            3 = 320 ms
+            4 = 640 ms
+            5 = 1280 ms
+        """
+        if int_time < 0 or int_time > 5:
+            raise ValueError('int_time is not in range')
+        conf = self.read(0x00) & 0x0003
+        self.write(0x00, (conf | (int_time << 4)))
+        
+    def forceMode(self):
+        """
+        forces measurement mode - triggers to start
+        """
+        conf = (self.read(0x00) & 0x0072) | 0x0002
+        self.write(0x00, conf)
+        
+    def autoMode(self):
+        """
+        automatic measurement mode
+        """
+        conf = self.read(0x00) & 0x0070
+        self.write(0x00, conf)
+    
+    def readAll(self):
+        """
+        returns most recognized colour and raw values
+        """
+        r, g, b, w = self.getRGBW()
+        raw_val = [r, g, b, w]
+        dominant_col, dominant_val = "red", r
+        if g > dominant_val: dominant_col, dominant_val = "green", g
+        if b > dominant_val: dominant_col, dominant_val = "blue", b
+        
+        return dominant_col, raw_val