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

JoyPi_Advanced_RaspberryPi/gyroscope.py

@@ -0,0 +1,134 @@
+from spidev import SpiDev
+import time
+from gpiozero import DigitalOutputDevice
+    
+class gyroscope:
+
+    scaleFactor = 0
+    scale_gyroscope = 700
+    scale_range = 46.5
+    offset = 0
+    
+    def __init__(self, bus = 0, device = 0, cs = 14):
+        self.bus, self.device = bus, device
+        self.spi = SpiDev()
+        self.open()
+        self.spi.max_speed_hz = 1000000 # 1MHz
+        self.cs = DigitalOutputDevice(pin = cs, initial_value = True)
+        tmp = self.read_register(27) & 0x26
+        self.write_register(27, 0x18 | tmp)
+ 
+ 
+    def open(self):
+        """
+        Opens up SPI communication
+        """
+        self.spi.open(self.bus, self.device)
+        self.spi.max_speed_hz = 1000000 # 1MHz
+
+
+    def close(self):
+        """
+        Closes SPI communication
+        """
+        self.spi.close()
+        self.cs.close()
+
+        
+    def read_register(self, reg):
+        """
+        read value from register
+        """
+        self.cs.toggle()
+        tmp = self.spi.xfer3([(reg | 0x80), 0])
+        self.cs.toggle()
+        return tmp[1]
+
+        
+    def write_register(self, reg, data):
+        """
+        write value to register
+        """
+        self.cs.toggle()
+        self.spi.writebytes([ (reg & 0x7F), data])
+        self.cs.toggle()
+       
+        
+    def getTemperature(self):
+        """
+        returns read temnperature
+        """
+        temp = (self.read_register(0x41) << 8) + self.read_register(0x42)
+        return (temp / 100)
+
+    
+    def getXValue(self):
+        """
+        returns x value
+        """
+        x = (self.read_register(0x43) << 8) + self.read_register(0x44)
+        if (x / self.scale_gyroscope > self.scale_range):
+            return x / self.scale_gyroscope - (2 * self.scale_range)
+        else:
+            return x / self.scale_gyroscope
+
+    
+    def getYValue(self):
+        """
+        returns y value
+        """
+        y = (self.read_register(0x45) << 8) + self.read_register(0x46)
+        if (y / self.scale_gyroscope > self.scale_range):
+            return y / self.scale_gyroscope - (2 * self.scale_range)
+        else:
+            return y / self.scale_gyroscope
+
+    
+    def getTilt(self):
+        """
+        returns tilt directions
+        """
+        tiltThreshold = 2
+        y = self.getYValue()
+        x = self.getXValue()
+        if (y > 5):
+            return 'right'
+        elif (y < -5):
+            return 'left'
+        elif (x > 3):
+            return 'forward'
+        elif (x < -3):
+            return 'backward'
+        else:
+            return 'No movement'
+
+        
+    def who_am_i(self):
+        """
+        returns device ID
+        """
+        return (self.read_register(0x75))
+                
+                
+    def scale_Factor(self, scale):
+        """
+        set scale factor of gyroscope
+        """
+        self.scaleFactor = scale
+        self.write_register(0x19, 0)
+        self.write_register(0x1B, scale +1)
+        if (scale == 0):
+            self.scale_gyroscope = 700
+            self.scale_range = 46.5
+        
+        elif (scale == 8): 
+            self.scale_gyroscope = 350
+            self.scale_range = 93
+        
+        elif (scale == 16): 
+            self.scale_gyroscope = 175
+            self.scale_range = 187
+        
+        elif (scale == 24): 
+            self.scale_gyroscope = 87.5
+            self.scale_range = 374        

JoyPi_Advanced_RaspberryPi/servomotor.py

@@ -0,0 +1,88 @@
+from gpiozero import AngularServo
+import time
+
+class servomotor:
+    
+    def __init__(self, pin = 18, position = 0, 
+                 min_angle = -90, max_angle = 90, 
+                 min_pulse_width = 0.0005, max_pulse_width = 0.0025):
+        self.position = position
+        self.start_pos = position
+        self.min_angle = min_angle
+        self.max_angle = max_angle
+        
+        self.motor = AngularServo(pin, initial_angle=position, 
+                                    min_angle=min_angle, max_angle=max_angle, 
+                                    min_pulse_width=min_pulse_width, 
+                                    max_pulse_width=max_pulse_width)
+        
+    def setDirection(self, set_pos, speed = 5):
+        """
+        moves servomotor to a specified position with a specified speed
+        
+        :param set_pos: set_pos (-90 to 90 / right to left)
+        :param speed: speed (1 to 5 / slow to fast)
+        """
+        # catch values out of the intervall
+        set_pos = max(self.min_angle, min(set_pos, self.max_angle))
+        speed = max(1, min(speed, 5))
+
+        # map speed to motion profile
+        step_deg = {1: 1.0, 2: 2.0, 3: 3.0, 4: 5.0, 5: 8.0}[speed]
+        delay_s  = {1: 0.03, 2: 0.02, 3: 0.015, 4: 0.01, 5: 0.008}[speed]
+
+        # define direction
+        direction = 1 if set_pos > self.position else -1
+        # setup cariable with current position
+        current_position = self.position
+
+        # turn from current position to set_pos with a certain speed      
+        while True:
+            # check if servo is in right position or overshooted then end loop
+            if (direction == 1 and self.position >= set_pos) or (direction == -1 and self.position <= set_pos):
+                break
+            # calculate next angular step
+            current_position += direction * step_deg
+
+            # check if servo would overshoot target
+            if direction == 1: current_position = min(current_position, set_pos)
+            else: current_position = max(current_position, set_pos)
+
+            # set servo to calculated position
+            self.motor.angle = current_position
+            self.position = current_position
+
+            # delay to controll speed of turning
+            time.sleep(delay_s)
+        # ensure that position of servo is right
+        self.motor.angle = set_pos
+        self.position = set_pos
+    
+
+    def setPosition(self, pos):
+        """
+        set angular position of servomotor
+        
+        :param pos: angle to which the servomotor moves min = -90 and max = 90
+        """
+        self.motor.angle = pos
+        self.position = pos
+
+    def setHome(self):
+        """
+        set servo back to start position
+        """
+        self.setDirection(self.start_pos)
+        
+    def getPosition(self):
+        """
+        returns the position of the servomotor
+        """
+        return self.position
+    
+    def end(self):
+        """
+        moves servo to start position, stops PWM communication and cleans up
+        """
+        self.setHome()
+        self.motor.close()

JoyPi_Advanced_RaspberryPi/stepmotor.py

@@ -0,0 +1,116 @@
+import math
+from gpiozero import DigitalOutputDevice
+import time
+
+class stepmotor:
+
+    def __init__(self, pin1 = 22, pin2 = 23, pin3 = 24, pin4 = 4):
+        self.pin_A = DigitalOutputDevice(pin1, initial_value = False)
+        self.pin_B = DigitalOutputDevice(pin2, initial_value = False)
+        self.pin_C = DigitalOutputDevice(pin3, initial_value = False)
+        self.pin_D = DigitalOutputDevice(pin4, initial_value = False)
+        self.interval = 0.0011
+
+    def step1(self):
+        self.pin_D.on()
+        time.sleep(self.interval)
+        self.pin_D.off()
+
+    def step2(self):
+        self.pin_D.on()
+        self.pin_C.on()
+        time.sleep(self.interval)
+        self.pin_D.off()
+        self.pin_C.off()
+
+    def step3(self):
+        self.pin_C.on()
+        time.sleep(self.interval)
+        self.pin_C.off()
+
+    def step4(self):
+        self.pin_B.on()
+        self.pin_C.on()
+        time.sleep(self.interval)
+        self.pin_B.off()
+        self.pin_C.off()
+
+    def step5(self):
+        self.pin_B.on()
+        time.sleep(self.interval)
+        self.pin_B.off()
+
+    def step6(self):
+        self.pin_A.on()
+        self.pin_B.on()
+        time.sleep(self.interval)
+        self.pin_A.off()
+        self.pin_B.off()
+
+    def step7(self):
+        self.pin_A.on()
+        time.sleep(self.interval)
+        self.pin_A.off()
+
+    def step8(self):
+        self.pin_D.on()
+        self.pin_A.on()
+        time.sleep(self.interval)
+        self.pin_D.off()
+        self.pin_A.off()
+
+    def turn(self,count):
+        for i in range (int(count)):
+            self.step1()
+            self.step2()
+            self.step3()
+            self.step4()
+            self.step5()
+            self.step6()
+            self.step7()
+            self.step8()
+
+    def turnReverse(self, count):
+        for i in range(int(count)):
+            self.step8()
+            self.step7()
+            self.step6()
+            self.step5()
+            self.step4()
+            self.step3()
+            self.step2()
+            self.step1()
+
+    def close(self):
+        self.pin_A.close()
+        self.pin_B.close()
+        self.pin_C.close()
+        self.pin_D.close()
+
+    def turnSteps(self, steps):
+        """ 
+        Rotate by n steps
+        """
+        if steps < 0:
+            self.turnReverse(abs(int(steps)))
+        else:
+            self.turn(int(steps))
+
+    def turnDegrees(self, deg):
+        """ 
+        Rotate n degrees
+        """
+        if deg < 0:
+            self.turnReverse(abs(round(deg*512/360,0)))
+        else:
+            self.turn(round(deg*512/360,0))
+
+
+    def turnDistance(self, dist, rad):
+        """
+        Rotation by distance value
+        """
+        if dist < 0:
+            self.turnReverse(abs(round(512*dist/(2*math.pi*rad),0)))
+        else:
+            self.turn(round(512*dist/(2*math.pi*rad),0))

joypi_advanced_raspberrypi-2.0.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: JoyPi_Advanced_RaspberryPi
+Version: 2.0.0
+Summary: This library enables usage of some sensors and actors of the Joy-Pi Advanced on the Raspberry Pi.
+Project-URL: Homepage, https://github.com/joy-it/JoyPi_Advanced_RaspberryPi
+Project-URL: Issues, https://github.com/joy-it/JoyPi_Advanced_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
+
+# Joy-Pi Advanced Library for Raspberry Pi
+This library is a collection for the Raspberry Pi for several modules on the Joy-Pi Advanced. See [here](https://www.joy-pi.net) for more information.
+
+## Included modules
+This library includes the following modules:
+- ADC
+- Gyroscope
+- Barometer
+- Button Matrix
+- Color Sensor
+- LED Matrix
+- Servo Motor
+- Stepper Motor
+
+> [!WARNING]
+> 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).
+
+## Dependencies
+This library has some dependencies which are used to control the modules of the Joy Pi Advanced. To use this library, you will need to install the following dependencies:
+
+- [`rpi_ws281x`](https://github.com/jgarff/rpi_ws281x) - for the LED matrix - with `pip install rpi_ws281x` 
+- [`Adafruit CircuitPython BusDevice`](https://github.com/adafruit/Adafruit_CircuitPython_BusDevice) - for the barometer - with `pip install adafruit-circuitpython-busdevice` 
+- [`Adafruit_CircuitPython_MCP230xx`](https://github.com/adafruit/Adafruit_CircuitPython_MCP230xx) - for the button matrix - with `pip install adafruit-circuitpython-mcp230xx` 
+
+## Installation
+```
+pip install JoyPi_Advanced_RaspberryPi
+```
+## Library Guide
+### ADC
+- `adc(bus = 0, device = 0)` - initialize ADC with default values
+- `open()` - starts communication
+- `read_value(channel)` - returns raw value from a selected channel
+- `read_voltage(channel, value=None)` - returns measured voltage from a selected channel, raw value can also be calculated into voltage with this method
+- `close()` - ends communication
+### Gyroscope
+- `gyroscope(bus = 0, device = 2)`- initialize gyroscope with default values
+- `open()` - starts communication
+- `close()` - ends communication
+- `getTemperature()` - returns measured temperature
+- `getTilt()` - returns the tilted direction
+- `scale_Factor(scale)` - sets scale factor of the gyroscope (0, 8, 16 or 24)
+### Barometer
+- `barometer(i2c: busio.I2C, i2c_address = 0x77, resolution=4096)` - initialize barometer with default values
+- `get_pressure()` - returns the measured pressure
+- `get_temperature()`- returns the measured temperature
+- `get_altitude(reference_pressure = 1013.25)` - return the calculated altitude with the measured pressure and your local pressure (`reference_pressure`)
+### Button matrix
+- `buttonmatrix(i2c: busio.I2C, i2c_address = 0x22)`- initialize button matrix with default values
+- `getKey()` - returns the pressed button
+- `clearMemory()` - clears class variable `calculated`
+- `calculate()` - method to use the button matrix as a calculator
+### Color sensor
+- `colour(i2c_address = 0x10)`- initialize colour sensor with default values
+- `enableSensor()` - start communication
+- `disableSensor()`- end communication
+- `getRGBW()` - returns measured RGBW values
+- `setIntegrationTime()` - set integration time (`0`-40ms, `1`-80ms, `2`-160ms, `3`-320ms, `4`-640ms or `5`-1280ms)
+- `forceMode()` - forces measurement mode
+- `autoMode()`- automatic measurement mode
+- `readAll()` - returns RGB colours as well as raw values
+### LED matrix
+- `LEDMatrix( pin = 18, brightness = 100)`- initialize LED matrix with default values
+- `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
+- `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 
+### Servo motor
+- `servomotor(pin = 18, position = 0)` - initialize servo motor with default values
+- `setDirection(set_pos, speed = 5)` - moves servomotor to a selected position in specified speed (1-5 : slowest - fastest)
+- `setPosition(pos)` -  moves servomotor to a selected position with default speed
+- `setHome()` - sets servomotor to start position
+- `getPosition()` - returns position of servo motor
+- `end()` - moves servo into start position, stops communication and cleans up communication
+### Stepper motor
+- `stepmotor(pin1 = 22, pin2 = 23, pin3 = 24, pin4 = 4)`- initialize step motor with default values
+- `turnSteps(steps)` - turns a selected amount of steps
+- `turnDegrees(deg)` - turns a selected amount of degree
+- `turnDistance(dist, rad)` - rotates by distance value
+- `close()` - close all used pins

joypi_advanced_raspberrypi-2.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+JoyPi_Advanced_RaspberryPi/LEDMatrix.py,sha256=8JNh0ohQopWtbCIX28R5eOXBPeopK0b0lDJQfMOjaM4,5386
+JoyPi_Advanced_RaspberryPi/__init__.py,sha256=f3EEO5VotY0d15Cr35XwMq7iQ1SSwYId-gf-qrCba_o,339
+JoyPi_Advanced_RaspberryPi/adc.py,sha256=uD8kx5AQzXrzkqTWWQsznt6Tmp--rxhD1XrmmlfizoQ,2851
+JoyPi_Advanced_RaspberryPi/barometer.py,sha256=Pvhtg77Fi9LMMIrnrmDk9MBdnho93kzy574HNbbt698,3503
+JoyPi_Advanced_RaspberryPi/buttonmatrix.py,sha256=REaGy0q2C0iYvoDr2WidsITNT67dp49il6u9eVNkSCY,4369
+JoyPi_Advanced_RaspberryPi/colour.py,sha256=ExkvKWuBeBnu344YoJhFYRoDhq1hK0wMzKkZkJ7WZBM,3987
+JoyPi_Advanced_RaspberryPi/gyroscope.py,sha256=pP6V2upAqPfajaKcJBPrgQSSpUFVUSDId0k8uli7abw,3516
+JoyPi_Advanced_RaspberryPi/servomotor.py,sha256=H-soLiQqiyvR6gNu0LffV19QIBWAiokwg2Kc9WYzblM,3169
+JoyPi_Advanced_RaspberryPi/stepmotor.py,sha256=YpggJICaSLzTvSDpGDJK8kC2VDP6aM__I-phwGiP6dA,2957
+joypi_advanced_raspberrypi-2.0.0.dist-info/METADATA,sha256=GyP76-xTNSkhb9f-z66YJks5wykuM1Dsy44vuJBZkXc,5393
+joypi_advanced_raspberrypi-2.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+joypi_advanced_raspberrypi-2.0.0.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+joypi_advanced_raspberrypi-2.0.0.dist-info/RECORD,,

joypi_advanced_raspberrypi-2.0.0.dist-info/WHEEL

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