refactor: cleaner python project
This commit is contained in:
@@ -0,0 +1,40 @@
|
||||
import argparse
|
||||
import time
|
||||
|
||||
from .display import (
|
||||
debug_image,
|
||||
generate_background_image,
|
||||
generate_loading_image,
|
||||
get_display,
|
||||
)
|
||||
from .forge_data import ForgeData
|
||||
from .i2c import I2C
|
||||
|
||||
|
||||
def host_generate() -> None:
|
||||
data = ForgeData().mock()
|
||||
generate_loading_image()
|
||||
generate_background_image()
|
||||
image = get_display(data, 0)
|
||||
debug_image(image)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--generate", action="store_true")
|
||||
args = parser.parse_args()
|
||||
|
||||
if args.generate:
|
||||
host_generate()
|
||||
return
|
||||
|
||||
t0 = time.time()
|
||||
with ForgeData() as data, I2C() as device:
|
||||
device.update_display(get_display(data, t0))
|
||||
|
||||
while True:
|
||||
if not data.update():
|
||||
time.sleep(0.01)
|
||||
continue
|
||||
|
||||
device.update_display(get_display(data, t0))
|
||||
@@ -0,0 +1,37 @@
|
||||
import pathlib
|
||||
|
||||
PROJECT_PATH = pathlib.Path(__file__).parent.parent.parent
|
||||
RESOURCES_PATH = PROJECT_PATH / "resources"
|
||||
|
||||
FORGE_SAVE_PATH = PROJECT_PATH / "forge_default_save.txt"
|
||||
FORGE_SAVE_BACKUP_PATH = PROJECT_PATH / "forge_default_save.txt.bck"
|
||||
MOCK_SAVE_PATH = RESOURCES_PATH / "mock_data.txt"
|
||||
|
||||
|
||||
FONT_1_PATH = RESOURCES_PATH / "TinyAndChunkyRegular.ttf"
|
||||
FONT_2_PATH = RESOURCES_PATH / "Px437_IBM_BIOS.ttf"
|
||||
|
||||
LOADING_IMG_PATH = RESOURCES_PATH / "loading.png"
|
||||
BACKGROUND_IMG_PATH = RESOURCES_PATH / "background.png"
|
||||
|
||||
ESTIMATED_BOOT_TIME_SECONDS = 18.0
|
||||
|
||||
SELECTED_RECT_BOUNDS = [
|
||||
(10, 14, 28, 32),
|
||||
(10, 38, 28, 56),
|
||||
(39, 14, 57, 32),
|
||||
(39, 38, 57, 56),
|
||||
(0, 0, 0, 0),
|
||||
(97, 26, 115, 44),
|
||||
]
|
||||
|
||||
ACTIVE_SRC_RECT_BOUNDS = [
|
||||
(10, 32, 28, 32),
|
||||
(10, 56, 28, 56),
|
||||
]
|
||||
|
||||
ACTIVE_FX_RECT_BOUNDS = [
|
||||
(39, 32, 57, 32),
|
||||
(39, 56, 57, 56),
|
||||
(97, 44, 115, 44),
|
||||
]
|
||||
@@ -0,0 +1,167 @@
|
||||
import time
|
||||
|
||||
from PIL import Image, ImageDraw, ImageFont, ImageMath
|
||||
|
||||
from .constants import (
|
||||
ACTIVE_FX_RECT_BOUNDS,
|
||||
ACTIVE_SRC_RECT_BOUNDS,
|
||||
BACKGROUND_IMG_PATH,
|
||||
ESTIMATED_BOOT_TIME_SECONDS,
|
||||
FONT_1_PATH,
|
||||
FONT_2_PATH,
|
||||
LOADING_IMG_PATH,
|
||||
SELECTED_RECT_BOUNDS,
|
||||
)
|
||||
from .enums import ForgeState
|
||||
from .forge_data import ForgeData
|
||||
|
||||
FONT_1 = ImageFont.truetype(FONT_1_PATH, 5)
|
||||
FONT_2 = ImageFont.truetype(FONT_2_PATH, 8)
|
||||
LOADING_IMG = Image.open(LOADING_IMG_PATH)
|
||||
BACKGROUND_IMG = Image.open(BACKGROUND_IMG_PATH)
|
||||
BLANK_IMG = Image.new("1", (128, 64), "black")
|
||||
|
||||
|
||||
def __xor(img1: Image.Image, img2: Image.Image) -> Image.Image:
|
||||
return ImageMath.lambda_eval(
|
||||
lambda args: args["convert"](args["a"] ^ args["b"], "1"), a=img1, b=img2
|
||||
)
|
||||
|
||||
|
||||
def __get_loading_display(data: ForgeData, t0: float) -> Image.Image:
|
||||
im = LOADING_IMG.copy()
|
||||
draw = ImageDraw.Draw(im)
|
||||
|
||||
now = time.time()
|
||||
|
||||
percent = min(1.0, (now - t0) / ESTIMATED_BOOT_TIME_SECONDS)
|
||||
|
||||
draw.rectangle((24, 35, 24 + 80 * percent, 40), fill="white")
|
||||
|
||||
if data.state == ForgeState.INITIAL:
|
||||
draw.circle((4, 4), 1, fill="white")
|
||||
|
||||
return im
|
||||
|
||||
|
||||
def __get_running_display(data: ForgeData) -> Image.Image:
|
||||
im = BACKGROUND_IMG.copy()
|
||||
draw = ImageDraw.Draw(im)
|
||||
|
||||
im_overlay = BLANK_IMG.copy()
|
||||
draw2 = ImageDraw.Draw(im_overlay)
|
||||
|
||||
# tempo
|
||||
draw.text((42, -2), f"{int(data.tempo)}", fill="white", font=FONT_1)
|
||||
draw.rectangle((6, 7, 6 + int(53 * data.beat_progress), 10), fill="white", width=0)
|
||||
|
||||
# time
|
||||
draw.text((94, -2), f"{int(data.time)}", fill="white", font=FONT_1)
|
||||
draw.rectangle(
|
||||
(67, 7, 67 + int(53 * data.time_progress), 10), fill="white", width=0
|
||||
)
|
||||
|
||||
# page
|
||||
draw.circle((55 + 8 * data.page, 61), 2, fill="white")
|
||||
|
||||
# selected
|
||||
draw.rectangle(SELECTED_RECT_BOUNDS[data.selected], outline="white", fill=None)
|
||||
|
||||
# active
|
||||
draw.rectangle(ACTIVE_SRC_RECT_BOUNDS[data.active(0)], fill="white")
|
||||
draw.rectangle(ACTIVE_FX_RECT_BOUNDS[data.active(1)], fill="white")
|
||||
|
||||
# fx/mix values
|
||||
draw.rectangle((41, 16 + round(14 * (1 - data.fxa_value)), 55, 30), fill="white")
|
||||
draw.rectangle((41, 40 + round(14 * (1 - data.fxb_value)), 55, 54), fill="white")
|
||||
draw.rectangle((99, 28 + round(14 * (1 - data.mfx_value)), 113, 42), fill="white")
|
||||
draw.rectangle((70, 28 + round(14 * (1 - data.mix_value)), 84, 42), fill="white")
|
||||
|
||||
# active shaders
|
||||
draw2.text((16, 20), hex(data.frag_state(0))[2].upper(), fill="white", font=FONT_2)
|
||||
draw2.text((16, 44), hex(data.frag_state(1))[2].upper(), fill="white", font=FONT_2)
|
||||
draw2.text((45, 20), hex(data.frag_state(2))[2].upper(), fill="white", font=FONT_2)
|
||||
draw2.text((45, 44), hex(data.frag_state(3))[2].upper(), fill="white", font=FONT_2)
|
||||
draw2.text((103, 32), hex(data.frag_state(5))[2].upper(), fill="white", font=FONT_2)
|
||||
# TODO print when random
|
||||
|
||||
draw2.text((74, 32), "K" if data.mix_mode_key else "M", fill="white", font=FONT_2)
|
||||
|
||||
# TODO show feedback
|
||||
|
||||
return __xor(im, im_overlay)
|
||||
|
||||
|
||||
def get_display(data: ForgeData, t0: float) -> Image.Image:
|
||||
if data.state == ForgeState.RUNNING:
|
||||
return __get_running_display(data)
|
||||
return __get_loading_display(data, t0)
|
||||
|
||||
|
||||
def generate_loading_image() -> None:
|
||||
global LOADING_IMG
|
||||
|
||||
im = BLANK_IMG.copy()
|
||||
|
||||
draw = ImageDraw.Draw(im)
|
||||
|
||||
draw.text((26, 24), "F.O.R.G.E.", fill="white", font=FONT_2)
|
||||
draw.rectangle((24, 35, 104, 40), outline="white", fill="black")
|
||||
|
||||
im.save(LOADING_IMG_PATH)
|
||||
|
||||
LOADING_IMG = im
|
||||
|
||||
|
||||
def generate_background_image() -> None:
|
||||
global BACKGROUND_IMG
|
||||
|
||||
im = BLANK_IMG.copy()
|
||||
|
||||
draw = ImageDraw.Draw(im)
|
||||
|
||||
# tempo
|
||||
draw.text((7, -2), "TEMPO:", fill="white", font=FONT_1)
|
||||
draw.rectangle((6, 6, 60, 11), outline="white", fill="black")
|
||||
|
||||
# time
|
||||
draw.text((68, -2), "TIME:", fill="white", font=FONT_1)
|
||||
draw.rectangle((67, 6, 121, 11), outline="white", fill="black")
|
||||
|
||||
# pipes
|
||||
draw.rectangle((26, 22, 78, 24), fill="white")
|
||||
draw.rectangle((26, 46, 78, 48), fill="white")
|
||||
draw.rectangle((78, 34, 128, 36), fill="white")
|
||||
draw.rectangle((76, 23, 78, 46), fill="white")
|
||||
|
||||
# squares
|
||||
draw.rectangle((12, 16, 26, 30), outline="white", fill="black")
|
||||
draw.rectangle((41, 16, 55, 30), outline="white", fill="black")
|
||||
|
||||
draw.rectangle((12, 40, 26, 54), outline="white", fill="black")
|
||||
draw.rectangle((41, 40, 55, 54), outline="white", fill="black")
|
||||
|
||||
draw.rectangle((70, 28, 84, 42), outline="white", fill="black")
|
||||
draw.rectangle((99, 28, 113, 42), outline="white", fill="black")
|
||||
|
||||
# page
|
||||
draw.circle((55, 61), 2, outline="white", fill="black")
|
||||
draw.circle((63, 61), 2, outline="white", fill="black")
|
||||
draw.circle((71, 61), 2, outline="white", fill="black")
|
||||
|
||||
im.save(BACKGROUND_IMG_PATH)
|
||||
|
||||
BACKGROUND_IMG = im
|
||||
|
||||
|
||||
def debug_image(im: Image.Image) -> None:
|
||||
im = im.resize((1280, 640)).convert("RGB")
|
||||
|
||||
draw2 = ImageDraw.Draw(im)
|
||||
|
||||
for x in range(1, 128):
|
||||
draw2.line((x * 10, 0, x * 10, 640), fill=(50, 50, 50))
|
||||
for y in range(1, 64):
|
||||
draw2.line((0, y * 10, 1280, y * 10), fill=(50, 50, 50))
|
||||
|
||||
im.resize((1280, 640)).save("debug.png")
|
||||
@@ -0,0 +1,8 @@
|
||||
import enum
|
||||
|
||||
|
||||
class ForgeState(enum.Enum):
|
||||
INITIAL = enum.auto()
|
||||
RESTORED = enum.auto()
|
||||
STARTED = enum.auto()
|
||||
RUNNING = enum.auto()
|
||||
@@ -0,0 +1,132 @@
|
||||
import collections
|
||||
import pathlib
|
||||
import typing
|
||||
|
||||
from .constants import FORGE_SAVE_BACKUP_PATH, FORGE_SAVE_PATH, MOCK_SAVE_PATH
|
||||
from .enums import ForgeState
|
||||
|
||||
|
||||
class ForgeRawData:
|
||||
def __init__(self) -> None:
|
||||
self.__data: dict[str, float] = collections.defaultdict(lambda: 0)
|
||||
|
||||
def try_restore_backup(self) -> bool:
|
||||
if FORGE_SAVE_BACKUP_PATH.exists() and self.read(FORGE_SAVE_BACKUP_PATH):
|
||||
FORGE_SAVE_PATH.write_text(FORGE_SAVE_BACKUP_PATH.read_text())
|
||||
return True
|
||||
return False
|
||||
|
||||
def read(self, file: pathlib.Path = FORGE_SAVE_PATH) -> bool:
|
||||
try:
|
||||
content = file.read_text()
|
||||
except: # noqa: E722
|
||||
return False
|
||||
for line in content.splitlines():
|
||||
key, value = line.split("=", maxsplit=2)
|
||||
self.__data[key] = float(value)
|
||||
if "time" in self.__data:
|
||||
FORGE_SAVE_BACKUP_PATH.write_text(content)
|
||||
return True
|
||||
return False
|
||||
|
||||
def __getitem__(self, key: str) -> float:
|
||||
return self.__data[key]
|
||||
|
||||
def __contains__(self, key: str) -> bool:
|
||||
return key in self.__data
|
||||
|
||||
|
||||
class ForgeData:
|
||||
def __init__(self) -> None:
|
||||
self.__data = ForgeRawData()
|
||||
self.state = ForgeState.INITIAL
|
||||
|
||||
def __enter__(self) -> typing.Self:
|
||||
if self.__data.try_restore_backup() or self.__data.read():
|
||||
self.state = ForgeState.RESTORED
|
||||
return self
|
||||
|
||||
def __exit__(self, *_) -> None:
|
||||
pass
|
||||
|
||||
def __update_state(self) -> None:
|
||||
if self.state == ForgeState.RUNNING:
|
||||
return
|
||||
elif self.state == ForgeState.STARTED:
|
||||
if self.time > 0:
|
||||
self.state = ForgeState.RUNNING
|
||||
elif "time" in self.__data and self.time == 0:
|
||||
self.state = ForgeState.STARTED
|
||||
|
||||
def update(self) -> bool:
|
||||
if self.__data.read():
|
||||
self.__update_state()
|
||||
return True
|
||||
return False
|
||||
|
||||
def value(self, n: int) -> tuple[float, float, float]:
|
||||
return (
|
||||
self.__data[f"value_{n}_x"] / 127,
|
||||
self.__data[f"value_{n}_y"] / 127,
|
||||
self.__data[f"value_{n}_z"] / 127,
|
||||
)
|
||||
|
||||
def frag_state(self, n: int) -> int:
|
||||
return int(self.__data[f"state_{n}"])
|
||||
|
||||
def active(self, n: int) -> int:
|
||||
return int(self.__data[f"active_{n}"])
|
||||
|
||||
@property
|
||||
def time(self) -> float:
|
||||
return self.__data["time"]
|
||||
|
||||
@property
|
||||
def time_progress(self) -> float:
|
||||
return self.time - int(self.time)
|
||||
|
||||
@property
|
||||
def tempo(self) -> float:
|
||||
return self.__data["tempo"]
|
||||
|
||||
@property
|
||||
def beats(self) -> float:
|
||||
return self.__data["beats"]
|
||||
|
||||
@property
|
||||
def beat_progress(self) -> float:
|
||||
return self.beats - int(self.beats)
|
||||
|
||||
@property
|
||||
def page(self) -> int:
|
||||
return int(self.__data["page"])
|
||||
|
||||
@property
|
||||
def selected(self) -> int:
|
||||
return int(self.__data["selected"])
|
||||
|
||||
@property
|
||||
def fxa_value(self) -> float:
|
||||
# todo random and time based
|
||||
return self.value(18)[0]
|
||||
|
||||
@property
|
||||
def fxb_value(self) -> float:
|
||||
return self.value(25)[0]
|
||||
|
||||
@property
|
||||
def mfx_value(self) -> float:
|
||||
return self.value(32)[0]
|
||||
|
||||
@property
|
||||
def mix_value(self) -> float:
|
||||
return self.value(34)[0]
|
||||
|
||||
@property
|
||||
def mix_mode_key(self) -> bool:
|
||||
return self.value(33)[0] > 0.
|
||||
|
||||
def mock(self) -> typing.Self:
|
||||
self.__data.read(MOCK_SAVE_PATH)
|
||||
self.state = ForgeState.RUNNING
|
||||
return self
|
||||
@@ -0,0 +1,49 @@
|
||||
import sys
|
||||
import typing
|
||||
|
||||
from luma.core.error import DeviceNotFoundError
|
||||
from luma.core.interface.serial import i2c
|
||||
from luma.oled.device import device, sh1106
|
||||
from PIL import Image
|
||||
|
||||
|
||||
class I2C:
|
||||
def __init__(self) -> None:
|
||||
self.__device: device | None = None
|
||||
|
||||
def __enter__(self) -> typing.Self:
|
||||
self.__open_device()
|
||||
return self
|
||||
|
||||
def __exit__(self, *_) -> None:
|
||||
assert self.__device is not None
|
||||
self.__device.cleanup()
|
||||
|
||||
def __open_device(self) -> None:
|
||||
# Pin definitions: I2C Bus 1 (SDA=GPIO2, SCL=GPIO3)
|
||||
# Default SSD1306 I2C address is 0x3C
|
||||
serial_interface = i2c(port=1, address=0x3C)
|
||||
|
||||
try:
|
||||
# Initialize the device. If using SH1106, change ssd1306 to sh1106
|
||||
self.__device = sh1106(serial_interface, width=128, height=64, rotate=0)
|
||||
except DeviceNotFoundError:
|
||||
print("Fatal: OLED not found at 0x3C. Check wiring and run i2cdetect -y 1")
|
||||
sys.exit(1)
|
||||
except OSError as e:
|
||||
if e.errno == 121:
|
||||
print(
|
||||
"Fatal: Remote I/O error. I2C bus is locked or physically disconnected."
|
||||
)
|
||||
else:
|
||||
print(f"Fatal OS Error: {e}")
|
||||
sys.exit(1)
|
||||
|
||||
def update_display(self, image: Image.Image) -> None:
|
||||
assert self.__device is not None
|
||||
try:
|
||||
self.__device.display(image)
|
||||
except OSError as e:
|
||||
if e.errno == 121:
|
||||
print("Runtime Error: I2C bus dropped. Check physical connections.")
|
||||
raise
|
||||
Reference in New Issue
Block a user