Modul `modules`¶

Klasse `Ultrasonic`¶

Beispiel

# Import Ultrasonic and Pin class
from robot_hat import Ultrasonic, Pin

# Create Motor object
us = Ultrasonic(Pin("D2"), Pin("D3"))

# Read distance
distance = us.read()
print(f"Distance: {distance}cm")

API

class robot_hat.modules.Ultrasonic(trig, echo, timeout=0.02)¶

__init__(trig, echo, timeout=0.02)¶

Klasse `ADXL345`¶

Beispiel
# Import ADXL345 class
from robot_hat import ADXL345

# Create ADXL345 object
adxl = ADXL345()
# or with a custom I2C address
adxl = ADXL345(address=0x53)

# Read acceleration of each axis
x = adxl.read(adxl.X)
y = adxl.read(adxl.Y)
z = adxl.read(adxl.Z)
print(f"Acceleration: {x}, {y}, {z}")

# Or read all axis at once
x, y, z = adxl.read()
print(f"Acceleration: {x}, {y}, {z}")
# Or print all axis at once
print(f"Acceleration: {adxl.read()}")
API

class robot_hat.ADXL345(*args, address: int = 83, bus: int = 1, **kwargs)¶

Basisklasse: I2C

ADXL345-Module

X = 0¶

X

Y = 1¶

Y

Z = 2¶

Z

__init__(*args, address: int = 83, bus: int = 1, **kwargs)¶

ADXL345 initialisieren

Parameter

address (int) – Adresse des ADXL345

read(axis: int = None) → Union[float, List[float]]¶

Eine Achse des ADXL345 lesen

Parameter

axis (int) – Wert (g) einer Achse lesen, ADXL345.X, ADXL345.Y oder ADXL345.Z, None für alle Achsen

Rückgabe

Wert der Achse oder Liste aller Achsen

Rückgabetyp

float/list

Klasse `RGB_LED`¶

Beispiel
# Import RGB_LED and PWM class
from robot_hat import RGB_LED, PWM

# Create RGB_LED object for common anode RGB LED
rgb = RGB_LED(PWM(0), PWM(1), PWM(2), common=RGB_LED.ANODE)
# or for common cathode RGB LED
rgb = RGB_LED(PWM(0), PWM(1), PWM(2), common=RGB_LED.CATHODE)

# Set color with 24 bit int
rgb.color(0xFF0000) # Red
# Set color with RGB tuple
rgb.color((0, 255, 0)) # Green
# Set color with RGB List
rgb.color([0, 0, 255]) # Blue
# Set color with RGB hex string starts with “#”
rgb.color("#FFFF00") # Yellow
API

class robot_hat.RGB_LED(r_pin: PWM, g_pin: PWM, b_pin: PWM, common: int = 1)¶

Einfache 3-Pin-RGB-LED

ANODE = 1¶

Gemeinsame Anode

CATHODE = 0¶

Gemeinsame Kathode

__init__(r_pin: PWM, g_pin: PWM, b_pin: PWM, common: int = 1)¶

RGB-LED initialisieren

Parameter

r_pin (robot_hat.PWM) – PWM-Objekt für Rot

g_pin (robot_hat.PWM) – PWM-Objekt für Grün

b_pin (robot_hat.PWM) – PWM-Objekt für Blau

common (int) – RGB_LED.ANODE oder RGB_LED.CATHODE, Standard ist ANODE

Verursacht

ValueError – wenn gemeinsam weder ANODE noch CATHODE ist

TypeError – wenn r_pin, g_pin oder b_pin kein PWM-Objekt ist

color(color: Union[str, Tuple[int, int, int], List[int], int])¶

Farbe an RGB-LED schreiben

Parameter

color (str/int/tuple/list) – Zu schreibende Farbe, Hex-String beginnend mit „#“, 24-Bit-Integer oder Tupel aus (Rot, Grün, Blau)

Klasse `Buzzer`¶

Beispiel

Importieren und Initialisieren

# Import Buzzer class
from robot_hat import Buzzer
# Import Pin for active buzzer
from robot_hat import Pin
# Import PWM for passive buzzer
from robot_hat import PWM
# import Music class for tones
from robot_hat import Music
# Import time for sleep
import time

music = Music()
# Create Buzzer object for passive buzzer
p_buzzer = Buzzer(PWM(0))
# Create Buzzer object for active buzzer
a_buzzer = Buzzer(Pin("D0"))

Aktives Summer-Signal

while True:
    a_buzzer.on()
    time.sleep(0.5)
    a_buzzer.off()
    time.sleep(0.5)

Passiver Summer Einfache Nutzung

# Play a Tone for 1 second
p_buzzer.play(music.note("C3"), duration=1)
# take adventage of the music beat as duration
# set song tempo of the beat value
music.tempo(120, 1/4)
# Play note with a quarter beat
p_buzzer.play(music.note("C3"), music.beat(1/4))

Passiver Summer Manuelle Steuerung

# Play a tone
p_buzzer.play(music.note("C4"))
# Pause for 1 second
time.sleep(1)
# Play another tone
p_buzzer.play(music.note("C5"))
# Pause for 1 second
time.sleep(1)
# Stop playing
p_buzzer.off()

Ein Lied spielen! Babyhai!

music.tempo(120, 1/4)

# Make a Shark-doo-doo function as is all about it
def shark_doo_doo():
    p_buzzer.play(music.note("C5"), music.beat(1/8))
    p_buzzer.play(music.note("C5"), music.beat(1/8))
    p_buzzer.play(music.note("C5"), music.beat(1/8))
    p_buzzer.play(music.note("C5"), music.beat(1/16))
    p_buzzer.play(music.note("C5"), music.beat(1/16 + 1/16))
    p_buzzer.play(music.note("C5"), music.beat(1/16))
    p_buzzer.play(music.note("C5"), music.beat(1/8))

# loop any times you want from baby to maybe great great great grandpa!
for _ in range(3):
    print("Measure 1")
    p_buzzer.play(music.note("G4"), music.beat(1/4))
    p_buzzer.play(music.note("A4"), music.beat(1/4))
    print("Measure 2")
    shark_doo_doo()
    p_buzzer.play(music.note("G4"), music.beat(1/8))
    p_buzzer.play(music.note("A4"), music.beat(1/8))
    print("Measure 3")
    shark_doo_doo()
    p_buzzer.play(music.note("G4"), music.beat(1/8))
    p_buzzer.play(music.note("A4"), music.beat(1/8))
    print("Measure 4")
    shark_doo_doo()
    p_buzzer.play(music.note("C5"), music.beat(1/8))
    p_buzzer.play(music.note("C5"), music.beat(1/8))
    print("Measure 5")
    p_buzzer.play(music.note("B4"), music.beat(1/4))
    time.sleep(music.beat(1/4))

API

class robot_hat.Buzzer(buzzer: Union[PWM, Pin])¶

__init__(buzzer: Union[PWM, Pin])¶

Summer initialisieren

Parameter: pwm (robot_hat.PWM/robot_hat.Pin) – PWM-Objekt für passiven Summer oder Pin-Objekt für aktiven Summer

on()¶: Summer einschalten

off()¶: Summer ausschalten

freq(freq: float)¶

Frequenz des passiven Summers einstellen

Parameter: freq (int/float) – Frequenz des Summers, verwenden Sie Music.NOTES, um die Frequenz der Note zu erhalten
Verursacht: TypeError – wenn auf aktiven Summer eingestellt

play(freq: float, duration: float = None)¶

Frequenz abspielen

Parameter

freq (float) – abzuspielende Frequenz, Sie können Music.note() verwenden, um die Frequenz der Note zu erhalten
duration (float) – Dauer jeder Note in Sekunden, None bedeutet kontinuierliches Abspielen

Verursacht

TypeError – wenn auf aktiven Summer eingestellt

Klasse `Grayscale_Module`¶

Beispiel
# Import Grayscale_Module and ADC class
from robot_hat import Grayscale_Module, ADC

# Create Grayscale_Module object, reference should be calculate from the value reads on white
# and black ground, then take the middle as reference
gs = Grayscale_Module(ADC(0), ADC(1), ADC(2), reference=2000)

# Read Grayscale_Module datas
datas = gs.read()
print(f"Grayscale Module datas: {datas}")
# or read a specific channel
l = gs.read(gs.LEFT)
m = gs.read(gs.MIDDLE)
r = gs.read(gs.RIGHT)
print(f"Grayscale Module left channel: {l}")
print(f"Grayscale Module middle channel: {m}")
print(f"Grayscale Module right channel: {r}")

# Read Grayscale_Module simple states
state = gs.read_status()
print(f"Grayscale_Module state: {state}")
API

class robot_hat.Grayscale_Module(pin0: ADC, pin1: ADC, pin2: ADC, reference: int = None)¶

3-Kanal-Graustufen-Modul

LEFT = 0¶

Linker Kanal

MIDDLE = 1¶

Mittlerer Kanal

RIGHT = 2¶

Rechter Kanal

__init__(pin0: ADC, pin1: ADC, pin2: ADC, reference: int = None)¶

Graustufen-Modul initialisieren

Parameter

pin0 (robot_hat.ADC/int) – ADC-Objekt oder Integer für Kanal 0

pin1 (robot_hat.ADC/int) – ADC-Objekt oder Integer für Kanal 1

pin2 (robot_hat.ADC/int) – ADC-Objekt oder Integer für Kanal 2

reference (1*3 list, [int, int, int]) – Referenzspannung

reference(ref: list = None) → list¶

Referenzwert abrufen oder einstellen

Parameter

ref (list) – Referenzwert, None um den Referenzwert abzurufen

Rückgabe

Referenzwert

Rückgabetyp

list

read_status(datas: list = None) → list¶

Zeilenstatus lesen

Parameter

datas (list) – Liste der Graustufendaten, falls None, vom Sensor lesen

Rückgabe

Liste des Zeilenstatus, 0 für Weiß, 1 für Schwarz

Rückgabetyp

list

read(channel: int = None) → list¶

einen Kanal oder alle Daten lesen

Parameter

channel (int/None) – zu lesender Kanal, leer lassen, um alle zu lesen. 0, 1, 2 oder Grayscale_Module.LEFT, Grayscale_Module.MIDDLE, Grayscale_Module.RIGHT

Rückgabe

Liste der Graustufendaten

Rückgabetyp

list

Modul modules¶

Klasse Ultrasonic¶

Klasse ADXL345¶

Klasse RGB_LED¶

Klasse Buzzer¶

Klasse Grayscale_Module¶