$ pip install pyflipper

from pyflipper import PyFlipper

# Lokaler serieller Port
flipper = PyFlipper(com="/dev/ttyACM0")

# ODER

# Remote serial2websocket Server
flipper = PyFlipper(ws="ws://192.168.1.5:1337")

# TCP
flipper = PyFlipper(tcp='192.168.89.222:22170')

# Info (liest auf aktueller Firmware im Hintergrund `info power`)
info = flipper.power.info()

# Ausschalten
flipper.power.off()

# Neustarten
flipper.power.reboot()

# Neustarten im DFU-Modus
flipper.power.reboot2dfu()

# 5V OTG-Pin am GPIO-Header umschalten
flipper.power.otg_on()
flipper.power.otg_off()

# Update von .fuf-Datei installieren
flipper.update.install(fuf_file="/ext/update.fuf")

# Flipper als .tar-Datei sichern
flipper.update.backup(dest_tar_file="/ext/backup.tar")

# Flipper aus einer Backup-.tar-Datei wiederherstellen
flipper.update.restore(bak_tar_file="/ext/backup.tar")

# Installierte Apps auflisten
apps = flipper.loader.list()

# App öffnen
flipper.loader.open(app_name="Clock")

# Flipper-Datum abrufen (datetime-Objekt)
date = flipper.date.datetime()

# Flipper-Zeitstempel abrufen
timestamp = flipper.date.timestamp()

# Geräteinfo-Dict abrufen (aktuelle Firmware `info device`, durch Punkte getrennte Schlüssel)
device_info = flipper.info.device_info()

# Power-Info-Dict abrufen (aktuelle Firmware `info power`)
power_info = flipper.info.power_info()

# Erweiterte Power/Gauge-Debug-Informationen
power_debug = flipper.info.power_debug_info()

# Legacy `device_info` Befehl (durch Unterstriche getrennte Schlüssel, weiterhin unterstützt)
legacy_info = flipper.device_info.info()

# Heap-Info-Dict abrufen
heap = flipper.free.info()

# free_blocks-String abrufen
free_blocks = flipper.free.blocks()

# Bluetooth-Info abrufen
bt_info = flipper.bt.info()

# Dateisystem-Info des Storages abrufen
ext_info = flipper.storage.info(fs="/ext")

# Storage /ext Dict abrufen
ext_list = flipper.storage.list(path="/ext")

# Storage /ext Tree-Dict abrufen
ext_tree = flipper.storage.tree(path="/ext")

# Dateiinfo abrufen
file_info = flipper.storage.stat(file="/ext/foo/bar.txt")

# Verzeichnis erstellen
flipper.storage.mkdir(new_dir="/ext/foo")

# Datei lesen
plain_text = flipper.storage.read(file="/ext/foo/bar.txt")

# Datei löschen
flipper.storage.remove(file="/ext/foo/bar.txt")

# Datei kopieren
flipper.storage.copy(src="/ext/foo/source.txt", dest="/ext/bar/destination.txt")

# Datei umbenennen
flipper.storage.rename(file="/ext/foo/bar.txt", new_file="/ext/foo/rab.txt")

# MD5-Hash einer Datei
md5_hash = flipper.storage.md5(file="/ext/foo/bar.txt")

# Datei in einem Block schreiben
file = "/ext/bar.txt"

text = """There are many variations of passages of Lorem Ipsum available, 
but the majority have suffered alteration in some form, by injected humour, 
or randomised words which don't look even slightly believable. 
If you are going to use a passage of Lorem Ipsum, 
you need to be sure there isn't anything embarrassing hidden in the middle of text. 
"""

flipper.storage.write.file(path=file, text=text)

# Datei mit einem Listener schreiben
file = "/ext/foo.txt"

text_one = """There are many variations of passages of Lorem Ipsum available, 
but the majority have suffered alteration in some form, by injected humour, 
or randomised words which don't look even slightly believable. 
If you are going to use a passage of Lorem Ipsum, 
you need to be sure there isn't anything embarrassing hidden in the middle of text. 
"""

flipper.storage.write.start(file)

time.sleep(2)

flipper.storage.write.send(text_one)

text_two = """All the Lorem Ipsum generators on the Internet tend to repeat predefined chunks as 
necessary, making this the first true generator on the Internet.
 It uses a dictionary of over 200 Latin words, combined with a handful of 
 model sentence structures, to generate Lorem Ipsum which looks reasonable. 
The generated Lorem Ipsum is therefore always free from repetition, injected humour, or non-characteristic words etc.
"""
flipper.storage.write.send(text_two)

time.sleep(3)

# Nicht vergessen, zu stoppen
flipper.storage.write.stop()

# Generische LED setzen (r,b,g,bl)
flipper.led.set(led='r', value=255)

# Blaue LED ausschalten
flipper.led.blue(value=0)

# Grüne LED auf Wert setzen
flipper.led.green(value=175)

# Hintergrundbeleuchtung einschalten
flipper.led.backlight_on()

# Hintergrundbeleuchtung ausschalten
flipper.led.backlight_off()

# LED ausschalten
flipper.led.off()

# Vibro auf True oder False setzen
flipper.vibro.set(True)

# Vibro einschalten
flipper.vibro.on()

# Vibro ausschalten
flipper.vibro.off()

# GPIO-Modus setzen: 0 - Eingang, 1 - Ausgang
flipper.gpio.mode(pin_name=PIN_NAME, value=1)

# GPIO-Pin-Wert setzen: 0 - aus, 1 - ein
flipper.gpio.set(pin_name=PIN_NAME, value=1)

# GPIO-Pin-Wert lesen
flipper.gpio.read(pin_name=PIN_NAME)

# Lied im RTTTL-Format abspielen
rttl_song = "Littleroot Town - Pokemon:d=4,o=5,b=100:8c5,8f5,8g5,4a5,8p,8g5,8a5,8g5,8a5,8a#5,8p,4c6,8d6,8a5,8g5,8a5,8c#6,4d6,4e6,4d6,8a5,8g5,8f5,8e5,8f5,8a5,4d6,8d5,8e5,2f5,8c6,8a#5,8a#5,8a5,2f5,8d6,8a5,8a5,8g5,2f5,8p,8f5,8d5,8f5,8e5,4e5,8f5,8g5"

# In Schleife abspielen
flipper.music_player.play(rtttl_code=rttl_song)

# Schleife stoppen
flipper.music_player.stop()

# 20 Sekunden abspielen
flipper.music_player.play(rtttl_code=rttl_song, duration=20)

# Piepsen
flipper.music_player.beep()

# 5 Sekunden piepsen
flipper.music_player.beep(duration=5)

# Tag-Typ erkennen -> {'protocols': ['Mifare Classic'], 'raw': '...'} oder None
tag = flipper.nfc.scan(timeout=5)

# NFC-Feld für einige Sekunden einschalten
flipper.nfc.field(timeout=3)

# Eine APDU senden (ISO14443-4 / ISO15693-3); Protokoll wird bei Auslassung automatisch erkannt
resp = flipper.nfc.apdu(["00A4 04 00", "A0 00"], protocol="14_4a")

# Rohe Bytes mit angehängter CRC senden
flipper.nfc.raw("93 20", protocol="14a", crc=True)

# Mifare Ultralight Helfer
info = flipper.nfc.mfu_info()
block4 = flipper.nfc.mfu_read_block(4)
flipper.nfc.mfu_write_block(4, "00 01 02 03")

# Eine gespeicherte .nfc-Datei emulieren
flipper.nfc.emulate(file="/ext/nfc/mycard.nfc", timeout=10)

# Schlüssel aus einem nativen .nfc-Dump in den pro-UID-Schlüssel-Cache laden
uid, cache_path = flipper.nfc.import_nfc_keys("/path/to/card.nfc")

# Jetzt kann der CLI-Dump die Karte lesen (Protokoll-Token: mfc, mfu, 14_4a, ...)
flipper.nfc.dump(protocol="mfc", file="/ext/nfc/card_dump.nfc")

# Synchroner Standard-Timeout 5 Sekunden

# RFID lesen
rfid = flipper.rfid.read()

# RFID emulieren
emulated = flipper.rfid.emulate(key_type="EM4100", key_data="5500824806")

# RFID schreiben
written = flipper.rfid.write(key_type="EM4100", key_data="5500824806")

# Hex-Key N-mal senden (Standard count=10, device=0 -> CC1101_INT, 1 -> CC1101_EXT)
flipper.subghz.tx(hex_key="DEADBEEF", frequency=433920000, count=5, device=0)

# Empfangen (Standard frequency=433920000 device=0 raw=False timeout=5 Sekunden)
received = flipper.subghz.rx(frequency=433920000, device=0, raw=True, timeout=10)

# Aufgezeichnete Übertragung wiederholen
flipper.subghz.tx_from_file("/ext/subghz/foo.sub")

# Rohe .sub-Datei dekodieren
decoded = flipper.subghz.decode_raw(sub_file="/ext/subghz/foo.sub")

# Die von der angeschlossenen Firmware unterstützten Protokolle auflisten (live aus der `ir`-Hilfe gelesen)
protocols = flipper.ir.protocols()

# Hex-Address und Hex-Command unter Auswahl eines Protokolls senden
flipper.ir.tx(protocol="Samsung32", hex_address="C000FFEE", hex_command="DEADBEEF")

# NECext wird jetzt unterstützt (Protokollliste wird von der Firmware gelesen, nicht hartcodiert)
flipper.ir.tx(protocol="NECext", hex_address="EF00", hex_command="FD02")

# Rohe Sendebeispiele
flipper.ir.tx_raw(frequency=38000, duty_cycle=0.33, samples=[1337, 8888, 3000, 5555])

# Synchroner Standard-Timeout 5 Sekunden
# Empfangen
r = flipper.ir.rx(timeout=10)

# Lesen (Standard-Timeout 5 Sekunden)
ikey = flipper.ikey.read()

# Schreiben (Standard-Timeout 5 Sekunden)
flipper.ikey.write(key_type="Dallas", key_data="DEADBEEFCOOOFFEE")

# Emulieren (Standard-Timeout 5 Sekunden)
flipper.ikey.emulate(key_type="Dallas", key_data="DEADBEEFCOOOFFEE")

# Ereignislogger anhängen (Standard-Timeout 10 Sekunden)
logs = flipper.log.attach()

# Debug-Modus aktivieren (gibt `sysctl debug 1` auf aktueller Firmware aus)
flipper.debug.on()

# Debug-Modus deaktivieren
flipper.debug.off()

# Suchen
response = flipper.onewire.search()

# Abrufen
response = flipper.i2c.get()

# Eingabe-Dump
dump = flipper.input.dump()

# Eingabe senden
flipper.input.send("up", "press")

# Alles (Hardware-Tests überspringen sich selbst, wenn kein Flipper angeschlossen ist)
python -m unittest discover -s tests -p "test_*.py" -v

# Nur hardwarefreie Tests
python -m unittest tests.test_serial_wrapper tests.test_commands -v