From f427dbf4b78be6649faa800a839c51bbf6b41124 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emil=20Gaj=C5=A1ak?= <emil.gajsak@gmail.com>
Date: Fri, 16 Feb 2024 13:12:07 +0100
Subject: [PATCH] Added Clockstar library

---
 libraries/Clockstar-Library/.gitignore        |   4 +
 libraries/Clockstar-Library/CMakeLists.txt    |   4 +
 .../Clockstar-Library/Clockstar-Library.ino   |  87 +++++++
 .../Clockstar-Library/library.properties      |  10 +
 .../src/Battery/BatteryService.cpp            |  94 +++++++
 .../src/Battery/BatteryService.h              |  43 ++++
 libraries/Clockstar-Library/src/Clockstar.cpp | 232 ++++++++++++++++++
 libraries/Clockstar-Library/src/Clockstar.h   |  91 +++++++
 .../src/ClockstarDisplay.cpp                  |  54 ++++
 .../Clockstar-Library/src/ClockstarDisplay.h  |  16 ++
 libraries/Clockstar-Library/src/Notes.h       |  94 +++++++
 libraries/Clockstar-Library/src/Pins.hpp      |  37 +++
 .../Clockstar-Library/src/RGBController.cpp   |  94 +++++++
 .../Clockstar-Library/src/RGBController.h     |  42 ++++
 libraries/Clockstar-Library/src/RGBLed.cpp    |  70 ++++++
 libraries/Clockstar-Library/src/RGBLed.h      |  22 ++
 16 files changed, 994 insertions(+)
 create mode 100644 libraries/Clockstar-Library/.gitignore
 create mode 100644 libraries/Clockstar-Library/CMakeLists.txt
 create mode 100644 libraries/Clockstar-Library/Clockstar-Library.ino
 create mode 100644 libraries/Clockstar-Library/library.properties
 create mode 100644 libraries/Clockstar-Library/src/Battery/BatteryService.cpp
 create mode 100644 libraries/Clockstar-Library/src/Battery/BatteryService.h
 create mode 100644 libraries/Clockstar-Library/src/Clockstar.cpp
 create mode 100644 libraries/Clockstar-Library/src/Clockstar.h
 create mode 100644 libraries/Clockstar-Library/src/ClockstarDisplay.cpp
 create mode 100644 libraries/Clockstar-Library/src/ClockstarDisplay.h
 create mode 100644 libraries/Clockstar-Library/src/Notes.h
 create mode 100644 libraries/Clockstar-Library/src/Pins.hpp
 create mode 100644 libraries/Clockstar-Library/src/RGBController.cpp
 create mode 100644 libraries/Clockstar-Library/src/RGBController.h
 create mode 100644 libraries/Clockstar-Library/src/RGBLed.cpp
 create mode 100644 libraries/Clockstar-Library/src/RGBLed.h

diff --git a/libraries/Clockstar-Library/.gitignore b/libraries/Clockstar-Library/.gitignore
new file mode 100644
index 0000000..2475bc0
--- /dev/null
+++ b/libraries/Clockstar-Library/.gitignore
@@ -0,0 +1,4 @@
+.idea
+cmake-build-debug
+build
+.vscode
diff --git a/libraries/Clockstar-Library/CMakeLists.txt b/libraries/Clockstar-Library/CMakeLists.txt
new file mode 100644
index 0000000..e22adac
--- /dev/null
+++ b/libraries/Clockstar-Library/CMakeLists.txt
@@ -0,0 +1,4 @@
+# Source directories
+file(GLOB_RECURSE SOURCES "src/**.cpp" "src/**.c" "src/**.hpp" "src/**.h")
+
+idf_component_register(SRCS ${SOURCES} INCLUDE_DIRS "src")
diff --git a/libraries/Clockstar-Library/Clockstar-Library.ino b/libraries/Clockstar-Library/Clockstar-Library.ino
new file mode 100644
index 0000000..0a08240
--- /dev/null
+++ b/libraries/Clockstar-Library/Clockstar-Library.ino
@@ -0,0 +1,87 @@
+#include <Arduino.h>
+#include <CircuitOS.h>
+#include "src/Clockstar.h"
+#include "src/Battery/BatteryService.h"
+#include <Loop/LoopManager.h>
+#include <unordered_map>
+Display* display;
+
+std::unordered_map<int, const char*> btnMap = {
+		{ BTN_SELECT, "Select" },
+		{ BTN_DOWN,  "Down" },
+		{ BTN_UP, "Up" },
+		{ BTN_B,     "Alt" }
+};
+
+class InputTest : public InputListener, public LoopListener {
+public:
+	InputTest(){
+		LoopManager::addListener(this);
+		Input::getInstance()->addListener(this);
+
+		pinMode(PIN_CHARGE, INPUT);
+		imu = Clockstar.getIMU();
+	}
+
+private:
+
+	LSM6DS3* imu;
+	float ax = 0;
+	float ay = 0;
+	float az = 0;
+
+	void buttonPressed(uint i) override{
+		button = i;
+	}
+
+	void buttonReleased(uint i) override{
+		button = -1;
+	}
+
+	void draw(){
+		auto btn = btnMap.find(button);
+
+		Sprite* canvas = display->getBaseSprite();
+		canvas->clear(TFT_RED);
+
+		if(btn != btnMap.end()){
+			canvas->setCursor(50, 90);
+			canvas->print(btn->second);
+		}
+
+		canvas->setCursor(4, 105);
+		canvas->printf("%.1f, %.1f, %.1f", ax, ay, az);
+
+		display->commit();
+	}
+
+	void loop(uint micros) override{
+
+		ax = imu->readFloatAccelX();
+		ay = imu->readFloatAccelY();
+		az = imu->readFloatAccelZ();
+
+		draw();
+	}
+
+	int button = -1;
+};
+
+void setup(){
+	Clockstar.begin();
+	display = Clockstar.getDisplay();
+
+	RGB.setSolid(Pixel::Red);
+	new InputTest();
+}
+
+void loop(){
+	LoopManager::loop();
+//	Clockstar.getDisplay()->clear(TFT_RED);
+//	const auto sprite = Clockstar.getDisplay()->getBaseSprite();
+//
+//	sprite->setCursor(0,0);
+//	sprite->printf("bat: %d, charge: %d\n", Battery.getPercentage(), Battery.charging());
+//	Clockstar.getDisplay()->commit();
+//	delay(100);
+}
\ No newline at end of file
diff --git a/libraries/Clockstar-Library/library.properties b/libraries/Clockstar-Library/library.properties
new file mode 100644
index 0000000..0ba0393
--- /dev/null
+++ b/libraries/Clockstar-Library/library.properties
@@ -0,0 +1,10 @@
+name=Clockstar-Library
+version=1.0
+author=CircuitMess
+maintainer=Filip Budiša <filip@circuitmess.com>
+sentence=An Arduino library to program Clockstar, a DIY smartwatch.
+paragraph=See more on https://circuitmess.com/clockstar/
+category=Device Control
+url=https://circuitmess.com/clockstar/
+architectures=esp32
+includes=Clockstar.h
\ No newline at end of file
diff --git a/libraries/Clockstar-Library/src/Battery/BatteryService.cpp b/libraries/Clockstar-Library/src/Battery/BatteryService.cpp
new file mode 100644
index 0000000..9199adc
--- /dev/null
+++ b/libraries/Clockstar-Library/src/Battery/BatteryService.cpp
@@ -0,0 +1,94 @@
+#include "BatteryService.h"
+#include <Loop/LoopManager.h>
+#include <soc/efuse_reg.h>
+#include "../Pins.hpp"
+#include "../Clockstar.h"
+
+BatteryService Battery;
+
+uint16_t BatteryService::mapReading(uint16_t reading){
+	int mapped = map(reading, MIN_READ, MAX_READ, MIN_VOLT, MAX_VOLT);
+	return mapped;
+}
+
+void BatteryService::begin(){
+	LoopManager::addListener(this);
+	pinMode(PIN_CHARGE, INPUT_PULLDOWN);
+	pinMode(PIN_BATT, INPUT);
+	analogSetPinAttenuation(PIN_BATT, ADC_0db);
+
+	for(int i = 0; i < MeasureCount; i++){
+		measureVoltage += analogRead(PIN_BATT);
+	}
+
+	voltage = mapReading(measureVoltage / MeasureCount);
+
+	measureVoltage = 0;
+	measureCount = 0;
+	measureTime = millis();
+
+	if(getVoltage() < MIN_VOLT && !charging()){
+		Clockstar.shutdown();
+		return;
+	}
+}
+
+void BatteryService::loop(uint micros){
+	if(millis() - measureTime <= 1000.0f * MeasureInverval / MeasureCount) return;
+
+	measureVoltage += analogRead(PIN_BATT);
+	measureTime = millis();
+
+	if(++measureCount < MeasureCount) return;
+
+	voltage = mapReading(measureVoltage / MeasureCount);
+	measureVoltage = 0;
+	measureCount = 0;
+
+	if(getVoltage() < MIN_VOLT && !charging()){
+		Clockstar.shutdown();
+		return;
+	}
+}
+
+uint8_t BatteryService::getLevel() const{
+	uint8_t percentage = getPercentage();
+	if(percentage > 80){
+		return 5;
+	}else if(percentage > 60){
+		return 4;
+	}else if(percentage > 40){
+		return 3;
+	}else if(percentage > 20){
+		return 2;
+	}else if(percentage >= 5){
+		return 1;
+	}else if(percentage < 5){
+		return 0;
+	}
+}
+
+uint8_t BatteryService::getPercentage() const{
+	int16_t percentage = map(getVoltage(), MIN_VOLT, MAX_VOLT, 0, 100);
+	if(percentage < 0){
+		return 0;
+	}else if(percentage > 100){
+		return 100;
+	}else{
+		return percentage;
+	}
+}
+
+uint16_t BatteryService::getVoltage() const{
+	return voltage + getVoltOffset();
+}
+
+int16_t BatteryService::getVoltOffset(){
+	uint32_t upper = REG_GET_FIELD(EFUSE_BLK3_RDATA3_REG, EFUSE_RD_ADC1_TP_HIGH);
+	uint32_t lower = REG_GET_FIELD(EFUSE_BLK3_RDATA3_REG, EFUSE_RD_ADC1_TP_LOW);
+	return (upper << 7) | lower;
+}
+
+bool BatteryService::charging() const{
+	return digitalRead(PIN_CHARGE);
+}
\ No newline at end of file
diff --git a/libraries/Clockstar-Library/src/Battery/BatteryService.h b/libraries/Clockstar-Library/src/Battery/BatteryService.h
new file mode 100644
index 0000000..a862820
--- /dev/null
+++ b/libraries/Clockstar-Library/src/Battery/BatteryService.h
@@ -0,0 +1,43 @@
+#ifndef CLOCKSTAR_LIBRARY_BATTERYSERVICE_H
+#define CLOCKSTAR_LIBRARY_BATTERYSERVICE_H
+
+#include <Arduino.h>
+#include <Loop/LoopListener.h>
+
+#define MAX_VOLT 4200
+#define MIN_VOLT 3600
+#define MAX_READ 3550 // 4.2V
+#define MIN_READ 3050 // 3.6V
+
+
+class BatteryService : private LoopListener {
+public:
+	BatteryService() = default;
+
+	void loop(uint micros) override;
+	void begin();
+	uint8_t getLevel() const;
+	uint8_t getPercentage() const;
+	uint16_t getVoltage() const;
+
+	static uint16_t mapReading(uint16_t reading);
+
+	static int16_t getVoltOffset();
+
+	bool charging() const;
+
+private:
+	static constexpr float MeasureInverval = 2;
+	static constexpr uint8_t MeasureCount = 30;
+
+	uint32_t measureVoltage = 0;
+	uint8_t measureCount = 0;
+	uint32_t measureTime = 0;
+
+	uint16_t voltage = 0;
+
+};
+
+extern BatteryService Battery;
+
+#endif //CLOCKSTAR_LIBRARY_BATTERYSERVICE_H
diff --git a/libraries/Clockstar-Library/src/Clockstar.cpp b/libraries/Clockstar-Library/src/Clockstar.cpp
new file mode 100644
index 0000000..bf9552b
--- /dev/null
+++ b/libraries/Clockstar-Library/src/Clockstar.cpp
@@ -0,0 +1,232 @@
+#include "Clockstar.h"
+#include <Loop/LoopManager.h>
+#include "Pins.hpp"
+#include <SPIFFS.h>
+#include <Audio/Piezo.h>
+#include <ctime>
+#include "Battery/BatteryService.h"
+
+ClockstarImpl Clockstar;
+ChirpSystem Audio;
+RGBController RGB;
+
+ClockstarImpl::ClockstarImpl() : display(128, 128, -1, -3), rtc(I2C_BM8563_DEFAULT_ADDRESS, Wire), imu(I2C_MODE, 0x6a){
+
+}
+
+void ClockstarImpl::begin(bool backlight){
+
+	analogSetAttenuation(ADC_6db);
+
+	SPIFFS.begin();
+
+	display.getTft()->setPanel(ClockstarDisplay::panel1());
+	display.begin();
+	display.getTft()->setRotation(2);
+	display.swapBytes(false);
+	display.clear(TFT_BLACK);
+	display.commit();
+
+	input.setInverseLogic(true);
+	input.preregisterButtons({ BTN_A, BTN_LEFT, BTN_RIGHT, BTN_B });
+	LoopManager::addListener(&input);
+
+	led.begin();
+	led.setColor(Pixel::Black);
+	RGB.begin(&led);
+
+	Piezo.begin(PIN_BUZZ);
+	Piezo.noTone();
+
+	pinMode(PIN_BL, OUTPUT);
+	digitalWrite(PIN_BL, 1);
+
+	// Init RTC
+	Wire.begin(I2C_SDA, I2C_SCL);
+	Wire.setClock(100000);
+	rtc.begin();
+
+	//check rtc time, if outside unixtime or invalid, set to unixtime 0
+	I2C_BM8563_DateTypeDef dateStruct;
+	rtc.getDate(&dateStruct);
+	if(dateStruct.year < 1970 || dateStruct.year >= 2038 ||
+	   dateStruct.date < 1 || dateStruct.date > 31 ||
+	   dateStruct.month < 1 || dateStruct.month > 12){
+		setUnixTime(0);
+	}
+
+
+	imu.begin();
+
+	Battery.begin();
+
+	if(backlight){
+		fadeIn();
+	}
+}
+
+Input* ClockstarImpl::getInput(){
+	return &input;
+}
+
+Display* ClockstarImpl::getDisplay(){
+	return &display;
+}
+
+void ClockstarImpl::initPWM(){
+	ledcSetup(6, 5000, 8);
+	ledcAttachPin(PIN_BL, 6);
+	pwmInited = true;
+}
+
+void ClockstarImpl::deinitPWM(){
+	ledcDetachPin(PIN_BL);
+	digitalWrite(PIN_BL, HIGH);
+	pwmInited = false;
+}
+
+void ClockstarImpl::setBrightness(uint8_t brightness){
+	if(!pwmInited){
+		initPWM();
+	}
+
+	ledcWrite(6, mapDuty(brightness));
+}
+
+bool ClockstarImpl::backlightPowered() const{
+	return pwmInited;
+}
+
+void ClockstarImpl::backlightOff(){
+	deinitPWM();
+}
+
+uint8_t ClockstarImpl::mapDuty(uint8_t brightness){
+	return map(brightness, 0, 255, 240, 0);
+}
+
+void ClockstarImpl::fadeOut(uint8_t d){
+	if(!pwmInited){
+		initPWM();
+	}
+
+	uint8_t dutyOn = mapDuty(255);
+
+	for(int i = 0; i <= 255; i++){
+		uint8_t val = map(i, 0, 255, dutyOn, 255);
+		ledcWrite(6, val);
+		delay(d);
+	}
+
+	deinitPWM();
+}
+
+void ClockstarImpl::fadeIn(uint8_t d){
+	if(!pwmInited){
+		initPWM();
+	}
+
+	uint8_t dutyOn = mapDuty(255);
+
+	for(int i = 0; i <= 255; i++){
+		uint8_t val = map(i, 0, 255, 255, dutyOn);
+		ledcWrite(6, val);
+		delay(d);
+	}
+}
+
+void ClockstarImpl::setUnixTime(time_t unixtime){
+	std::tm* t = std::localtime(&unixtime);
+	I2C_BM8563_DateTypeDef dateStruct{ (int8_t) t->tm_wday, (int8_t) (t->tm_mon + 1), (int8_t) t->tm_mday, (int16_t) (t->tm_year + 1900) };
+	I2C_BM8563_TimeTypeDef timeStruct{ (int8_t) t->tm_hour, (int8_t) t->tm_min, (int8_t) t->tm_sec };
+
+	rtc.setDate(&dateStruct);
+	rtc.setTime(&timeStruct);
+}
+
+time_t ClockstarImpl::getUnixTime(){
+
+	std::time_t timestampCandidates[RTCRedundancy];
+	I2C_BM8563_DateTypeDef dateStruct;
+	I2C_BM8563_TimeTypeDef timeStruct;
+
+	for(uint8_t i = 0; i < RTCRedundancy; i++){
+		// Get RTC
+		rtc.getDate(&dateStruct);
+		rtc.getTime(&timeStruct);
+
+		std::tm t{ timeStruct.seconds,
+				   timeStruct.minutes,
+				   timeStruct.hours,
+				   dateStruct.date,
+				   dateStruct.month - 1,
+				   dateStruct.year - 1900 };
+
+		timestampCandidates[i] = mktime(&t);
+	}
+
+	uint8_t votes[RTCRedundancy] = { 0 };
+	for(int i = 0; i < RTCRedundancy; ++i){
+		for(int j = 0; j < RTCRedundancy; ++j){
+			if(i == j) continue;
+			if(abs(difftime(timestampCandidates[i], timestampCandidates[j])) <= 2.0f){
+				votes[i]++;
+			}
+		}
+	}
+
+	return timestampCandidates[*std::max_element(votes, votes + RTCRedundancy)];
+}
+
+void ClockstarImpl::shutdown(){
+	RGB.setColor(Pixel::Red);
+	delay(350);
+	RGB.setColor(Pixel::Black);
+	delay(700);
+	RGB.setColor(Pixel::Red);
+	delay(350);
+	RGB.setColor(Pixel::Black);
+
+	ledcDetachPin(PIN_BUZZ);
+	ledcDetachPin(RGB_R);
+	ledcDetachPin(RGB_G);
+	ledcDetachPin(RGB_B);
+	esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_SLOW_MEM, ESP_PD_OPTION_OFF);
+	esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_FAST_MEM, ESP_PD_OPTION_OFF);
+	esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF);
+	esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_ALL);
+	esp_deep_sleep_start();
+}
+
+void ClockstarImpl::sleep(){
+	Piezo.noTone();
+	RGB.setColor(Pixel::Black);
+
+	esp_sleep_enable_gpio_wakeup();
+	gpio_wakeup_enable((gpio_num_t) BTN_LEFT, GPIO_INTR_LOW_LEVEL);
+	gpio_wakeup_enable((gpio_num_t) BTN_RIGHT, GPIO_INTR_LOW_LEVEL);
+	gpio_wakeup_enable((gpio_num_t) BTN_A, GPIO_INTR_LOW_LEVEL);
+	gpio_wakeup_enable((gpio_num_t) BTN_B, GPIO_INTR_LOW_LEVEL);
+
+	auto perc = std::max(Battery.getPercentage(), (uint8_t) 10);
+	esp_sleep_enable_timer_wakeup((172800000000 / 100) * perc); // 2 days
+
+	fadeOut();
+	esp_light_sleep_start();
+
+	auto cause = esp_sleep_get_wakeup_cause();
+	if(cause == ESP_SLEEP_WAKEUP_TIMER){
+		shutdown();
+		return;
+	}
+
+	fadeIn();
+}
+
+const I2C_BM8563& ClockstarImpl::getRTC() const{
+	return rtc;
+}
+
+LSM6DS3* ClockstarImpl::getIMU(){
+	return &imu;
+}
diff --git a/libraries/Clockstar-Library/src/Clockstar.h b/libraries/Clockstar-Library/src/Clockstar.h
new file mode 100644
index 0000000..8769068
--- /dev/null
+++ b/libraries/Clockstar-Library/src/Clockstar.h
@@ -0,0 +1,91 @@
+#ifndef CLOCKSTAR_LIBRARY_CIRCUITPET_H
+#define CLOCKSTAR_LIBRARY_CIRCUITPET_H
+
+#include <Arduino.h>
+#include <CircuitOS.h>
+#include <Loop/LoopListener.h>
+#include "Pins.hpp"
+#include <Display/Display.h>
+#include <Input/InputGPIO.h>
+#include "RGBLed.h"
+#include "ClockstarDisplay.h"
+#include "RGBController.h"
+#include <Audio/ChirpSystem.h>
+#include <Wire.h>
+#include <I2C_BM8563.h>
+#include <SparkFunLSM6DS3.h>
+
+class ClockstarImpl {
+public:
+	ClockstarImpl();
+
+	void begin(bool backlight = true);
+
+	Input* getInput();
+	Display* getDisplay();
+
+	/**
+	 * Set backlight brightness. Value 0 is minimum brightness so screen is still on.
+	 * @param brightness brightness value from 0 to 255, internally scaled to 51 - 255
+	 */
+	void setBrightness(uint8_t brightness);
+
+	/**
+	 * Fades in from OFF to configured brightness.
+	 */
+	void fadeIn(uint8_t delay = 2);
+
+	/**
+	 * Fades out from configured brightness to OFF.
+	 */
+	void fadeOut(uint8_t delay = 2);
+
+	/**
+	 * Whether backlight is ON.
+	 * @return False if backlight is completely off, true otherwise.
+	 */
+	bool backlightPowered() const;
+
+	/**
+	 * Turns off backlight.
+	 */
+	void backlightOff();
+
+	time_t getUnixTime();
+	void setUnixTime(time_t unixtime);
+
+	void shutdown();
+	void sleep();
+
+	const I2C_BM8563& getRTC() const;
+	LSM6DS3* getIMU();
+
+private:
+	Display display;
+	InputGPIO input;
+	I2C_BM8563 rtc;
+	RGBLed led;
+	LSM6DS3 imu;
+
+	bool powerCutFlag = false;
+
+	bool pwmInited = false;
+	void initPWM();
+	void deinitPWM();
+
+	/**
+	 * Return backlight duty cycle for desired brightness.
+	 * @param brightness 0-255
+	 * @return duty cycle 0-255
+	 */
+	static uint8_t mapDuty(uint8_t brightness);
+
+	constexpr static uint8_t RTCRedundancy = 5;
+};
+
+extern ClockstarImpl Clockstar;
+extern ChirpSystem Audio;
+extern RGBController RGB;
+
+
+#endif //CLOCKSTAR_LIBRARY_CIRCUITPET_H
diff --git a/libraries/Clockstar-Library/src/ClockstarDisplay.cpp b/libraries/Clockstar-Library/src/ClockstarDisplay.cpp
new file mode 100644
index 0000000..1af7252
--- /dev/null
+++ b/libraries/Clockstar-Library/src/ClockstarDisplay.cpp
@@ -0,0 +1,54 @@
+#include "ClockstarDisplay.h"
+#include "Pins.hpp"
+
+lgfx::Panel_ST7735S* ClockstarDisplay::panel1(){
+	auto bus = new lgfx::Bus_SPI();
+	auto panel = new lgfx::Panel_ST7735S();
+
+	{
+		auto cfg = bus->config();
+
+
+		cfg.spi_host = VSPI_HOST;
+		cfg.spi_mode = 0;
+		cfg.freq_write = 27000000;
+		cfg.freq_read = 27000000;
+		cfg.spi_3wire = false;
+		cfg.use_lock = true;
+		cfg.dma_channel = 1;
+		cfg.pin_sclk = TFT_SCL;
+		cfg.pin_mosi = TFT_SDA;
+		cfg.pin_miso = -1;
+		cfg.pin_dc = TFT_DC;
+
+		bus->config(cfg);
+		panel->setBus(bus);
+	}
+
+	{
+		auto cfg = panel->config();
+
+		cfg.pin_cs = -1;
+		cfg.pin_rst = TFT_RST;
+		cfg.pin_busy = -1;
+
+
+		cfg.memory_width = 132;
+		cfg.memory_height = 132;
+		cfg.panel_width = 128;
+		cfg.panel_height = 128;
+		cfg.offset_x = 2;
+		cfg.offset_y = 1;
+		cfg.offset_rotation = 0;
+		cfg.readable = true;
+		cfg.invert = false;
+		cfg.rgb_order = false;
+		cfg.dlen_16bit = false;
+		cfg.bus_shared = false;
+
+		panel->config(cfg);
+	}
+
+
+	return panel;
+}
diff --git a/libraries/Clockstar-Library/src/ClockstarDisplay.h b/libraries/Clockstar-Library/src/ClockstarDisplay.h
new file mode 100644
index 0000000..330665b
--- /dev/null
+++ b/libraries/Clockstar-Library/src/ClockstarDisplay.h
@@ -0,0 +1,16 @@
+#ifndef CLOCKSTAR_LIBRARY_CIRCUITPETDISPLAY_H
+#define CLOCKSTAR_LIBRARY_CIRCUITPETDISPLAY_H
+
+#include <Arduino.h>
+
+#define LGFX_USE_V1
+#define ARDUINO_LOLIN_D32_PRO
+
+#include <LovyanGFX.hpp>
+
+class ClockstarDisplay : public lgfx::LGFX_Device {
+public:
+	static lgfx::Panel_ST7735S* panel1();
+};
+
+#endif //CLOCKSTAR_LIBRARY_CIRCUITPETDISPLAY_H
diff --git a/libraries/Clockstar-Library/src/Notes.h b/libraries/Clockstar-Library/src/Notes.h
new file mode 100644
index 0000000..c73c248
--- /dev/null
+++ b/libraries/Clockstar-Library/src/Notes.h
@@ -0,0 +1,94 @@
+#ifndef CLOCKSTAR_LIBRARY_NOTES_H
+#define CLOCKSTAR_LIBRARY_NOTES_H
+
+#define NOTE_B0  31
+#define NOTE_C1  33
+#define NOTE_CS1 35
+#define NOTE_D1  37
+#define NOTE_DS1 39
+#define NOTE_E1  41
+#define NOTE_F1  44
+#define NOTE_FS1 46
+#define NOTE_G1  49
+#define NOTE_GS1 52
+#define NOTE_A1  55
+#define NOTE_AS1 58
+#define NOTE_B1  62
+#define NOTE_C2  65
+#define NOTE_CS2 69
+#define NOTE_D2  73
+#define NOTE_DS2 78
+#define NOTE_E2  82
+#define NOTE_F2  87
+#define NOTE_FS2 93
+#define NOTE_G2  98
+#define NOTE_GS2 104
+#define NOTE_A2  110
+#define NOTE_AS2 117
+#define NOTE_B2  123
+#define NOTE_C3  131
+#define NOTE_CS3 139
+#define NOTE_D3  147
+#define NOTE_DS3 156
+#define NOTE_E3  165
+#define NOTE_F3  175
+#define NOTE_FS3 185
+#define NOTE_G3  196
+#define NOTE_GS3 208
+#define NOTE_A3  220
+#define NOTE_AS3 233
+#define NOTE_B3  247
+#define NOTE_C4  262
+#define NOTE_CS4 277
+#define NOTE_D4  294
+#define NOTE_DS4 311
+#define NOTE_E4  330
+#define NOTE_F4  349
+#define NOTE_FS4 370
+#define NOTE_G4  392
+#define NOTE_GS4 415
+#define NOTE_A4  440
+#define NOTE_AS4 466
+#define NOTE_B4  494
+#define NOTE_C5  523
+#define NOTE_CS5 554
+#define NOTE_D5  587
+#define NOTE_DS5 622
+#define NOTE_E5  659
+#define NOTE_F5  698
+#define NOTE_FS5 740
+#define NOTE_G5  784
+#define NOTE_GS5 831
+#define NOTE_A5  880
+#define NOTE_AS5 932
+#define NOTE_B5  988
+#define NOTE_C6  1047
+#define NOTE_CS6 1109
+#define NOTE_D6  1175
+#define NOTE_DS6 1245
+#define NOTE_E6  1319
+#define NOTE_F6  1397
+#define NOTE_FS6 1480
+#define NOTE_G6  1568
+#define NOTE_GS6 1661
+#define NOTE_A6  1760
+#define NOTE_AS6 1865
+#define NOTE_B6  1976
+#define NOTE_C7  2093
+#define NOTE_CS7 2217
+#define NOTE_D7  2349
+#define NOTE_DS7 2489
+#define NOTE_E7  2637
+#define NOTE_F7  2794
+#define NOTE_FS7 2960
+#define NOTE_G7  3136
+#define NOTE_GS7 3322
+#define NOTE_A7  3520
+#define NOTE_AS7 3729
+#define NOTE_B7  3951
+#define NOTE_C8  4186
+#define NOTE_CS8 4435
+#define NOTE_D8  4699
+#define NOTE_DS8 4978
+
+#endif //CLOCKSTAR_LIBRARY_NOTES_H
diff --git a/libraries/Clockstar-Library/src/Pins.hpp b/libraries/Clockstar-Library/src/Pins.hpp
new file mode 100644
index 0000000..453da45
--- /dev/null
+++ b/libraries/Clockstar-Library/src/Pins.hpp
@@ -0,0 +1,37 @@
+#ifndef CLOCKSTAR_LIBRARY_PINS_HPP
+#define CLOCKSTAR_LIBRARY_PINS_HPP
+
+
+#define BTN_DOWN 14
+#define BTN_UP 15
+#define BTN_SELECT 27
+#define BTN_ALT 39
+
+#define BTN_LEFT BTN_UP
+#define BTN_RIGHT BTN_DOWN
+#define BTN_A BTN_SELECT
+#define BTN_B BTN_ALT
+
+#define RGB_R 21
+#define RGB_G 22
+#define RGB_B 23
+
+#define PIN_BL 4
+#define PIN_BUZZ 2
+#define PIN_BATT 36
+#define PIN_CHARGE 19
+
+#define I2C_SDA 26
+#define I2C_SCL 25
+
+#define TFT_SCL 16
+#define TFT_SDA 17
+#define TFT_DC 5
+#define TFT_RST 18
+
+#define JIG_STATUS 13
+
+#define IMU_INT1 35
+#define IMU_INT2 34
+
+#endif //CLOCKSTAR_LIBRARY_PINS_HPP
diff --git a/libraries/Clockstar-Library/src/RGBController.cpp b/libraries/Clockstar-Library/src/RGBController.cpp
new file mode 100644
index 0000000..9a1452d
--- /dev/null
+++ b/libraries/Clockstar-Library/src/RGBController.cpp
@@ -0,0 +1,94 @@
+#include "RGBController.h"
+#include <Devices/Matrix/Matrix.h>
+#include <Loop/LoopManager.h>
+#include <SPIFFS.h>
+#include <FS/RamFile.h>
+
+RGBController::RGBController(){
+
+}
+
+void RGBController::begin(RGBLed* led){
+	this->led = led;
+	LoopManager::addListener(this);
+}
+
+void RGBController::setColor(Pixel color){
+	slotColors = color;
+
+	if(slotStates == Solid){
+		led->setColor(color);
+	}
+}
+
+void RGBController::clear(){
+	slotStates = Solid;
+	blinkStates = false;
+	blinkColors = Pixel::Black;
+	blinkStartTimes = 0;
+
+	slotColors = Pixel::Black;
+	led->setColor(Pixel::Black);
+}
+
+void RGBController::setSolid(Pixel color){
+
+	slotStates = Solid;
+
+	setColor(color);
+}
+
+void RGBController::blink(Pixel color){
+	slotStates = Once;
+	blinkColors = color;
+	blinkStartTimes = millis();
+	blinkStates = true;
+
+	led->setColor(color);
+}
+
+void RGBController::blinkTwice(Pixel color){
+	blink(color);
+	slotStates = Twice;
+}
+
+void RGBController::blinkContinuous(Pixel color){
+	blink(color);
+	slotStates = Continuous;
+}
+
+void RGBController::loop(uint micros){
+	if(slotStates == Solid) return;
+	if(millis() - blinkStartTimes < blinkDuration) return;
+
+	if(slotStates == Continuous){
+		if(millis() - blinkStartTimes < blinkContinuousDuration) return;
+
+		blinkStates = !blinkStates;
+		blinkStartTimes = millis();
+		led->setColor(blinkStates ? blinkColors : Pixel::Black);
+	}else if(slotStates == Twice && blinkStates){
+		blinkStates = false;
+		blinkStartTimes = millis();
+		led->setColor(Pixel::Black);
+	}else if(slotStates == Twice && !blinkStates){
+		blinkStates = true;
+		blinkStartTimes = millis();
+		slotStates = Once;
+		led->setColor(blinkColors);
+	}else if(slotStates == Once){
+		blinkStates = false;
+		blinkStartTimes = 0;
+		blinkColors = Pixel::Black;
+		slotStates = Solid;
+		led->setColor(slotColors);
+	}
+}
+
+void RGBController::setBrightness(uint8_t brightness){
+	led->setBrightness(brightness);
+}
+
+uint8_t RGBController::getBrightness() const{
+	return led->getBrightness();
+}
diff --git a/libraries/Clockstar-Library/src/RGBController.h b/libraries/Clockstar-Library/src/RGBController.h
new file mode 100644
index 0000000..f9dfbc7
--- /dev/null
+++ b/libraries/Clockstar-Library/src/RGBController.h
@@ -0,0 +1,42 @@
+#ifndef CIRCUITPET_FIRMWARE_RGBCONTROLLER_H
+#define CIRCUITPET_FIRMWARE_RGBCONTROLLER_H
+
+#include <Arduino.h>
+#include <Loop/LoopListener.h>
+#include <Display/Color.h>
+#include "RGBLed.h"
+
+class RGBController : private LoopListener {
+public:
+	RGBController();
+	void begin(RGBLed* led);
+
+	void setColor(Pixel color = { 0, 0, 0 });
+	void clear();
+	void setSolid(Pixel color);
+	void blink(Pixel color);
+	void blinkTwice(Pixel color);
+	void blinkContinuous(Pixel color);
+
+	void loop(uint micros) final;
+
+	void setBrightness(uint8_t brightness);
+	uint8_t getBrightness() const;
+
+private:
+	RGBLed* led = nullptr;
+
+	enum {
+		Solid, Once, Twice, Continuous
+	} slotStates = Solid;
+
+	Pixel slotColors = Pixel::Black;
+
+	Pixel blinkColors = Pixel::Black;
+	uint32_t blinkStartTimes = 0;
+	bool blinkStates = false;
+	const uint32_t blinkDuration = 100; //[ms]
+	const uint32_t blinkContinuousDuration = 500; //[ms]
+};
+
+#endif //CIRCUITPET_FIRMWARE_RGBCONTROLLER_H
diff --git a/libraries/Clockstar-Library/src/RGBLed.cpp b/libraries/Clockstar-Library/src/RGBLed.cpp
new file mode 100644
index 0000000..10e4a06
--- /dev/null
+++ b/libraries/Clockstar-Library/src/RGBLed.cpp
@@ -0,0 +1,70 @@
+#include "RGBLed.h"
+#include "Pins.hpp"
+#include <Arduino.h>
+
+void RGBLed::begin(){
+	pinMode(RGB_R, OUTPUT);
+	pinMode(RGB_G, OUTPUT);
+	pinMode(RGB_B, OUTPUT);
+	digitalWrite(RGB_R, LOW);
+	digitalWrite(RGB_G, LOW);
+	digitalWrite(RGB_B, LOW);
+
+	ledcSetup(4, 1000, 8);
+	ledcSetup(2, 1000, 8);
+	ledcSetup(3, 1000, 8);
+
+	ledcAttachPin(RGB_R, 4);
+	ledcAttachPin(RGB_G, 2);
+	ledcAttachPin(RGB_B, 3);
+	attached = true;
+}
+
+const Pixel& RGBLed::getColor() const{
+	return color;
+}
+
+void RGBLed::setColor(Pixel color){
+	double brightness = pow((double) this->brightness / 255.0, 2.0);
+	color.r = floor((float) color.r * brightness);
+	color.g = floor((float) color.g * brightness);
+	color.b = floor((float) color.b * brightness);
+
+	if(color == Pixel::Black){
+		ledcDetachPin(RGB_R);
+		ledcDetachPin(RGB_G);
+		ledcDetachPin(RGB_B);
+
+		pinMode(RGB_R, OUTPUT);
+		pinMode(RGB_G, OUTPUT);
+		pinMode(RGB_B, OUTPUT);
+
+		digitalWrite(RGB_R, LOW);
+		digitalWrite(RGB_G, LOW);
+		digitalWrite(RGB_B, LOW);
+
+		attached = false;
+	}else if(!attached){
+		attached = true;
+		ledcAttachPin(RGB_R, 4);
+		ledcAttachPin(RGB_G, 2);
+		ledcAttachPin(RGB_B, 3);
+
+		ledcSetup(4, 1000, 8);
+		ledcSetup(2, 1000, 8);
+		ledcSetup(3, 1000, 8);
+	}
+	RGBLed::color = color;
+
+	ledcWrite(4, (color.r));
+	ledcWrite(2, (color.g));
+	ledcWrite(3, (color.b));
+}
+
+uint8_t RGBLed::getBrightness() const{
+	return brightness;
+}
+
+void RGBLed::setBrightness(uint8_t brightness){
+	RGBLed::brightness = brightness;
+}
diff --git a/libraries/Clockstar-Library/src/RGBLed.h b/libraries/Clockstar-Library/src/RGBLed.h
new file mode 100644
index 0000000..fc22927
--- /dev/null
+++ b/libraries/Clockstar-Library/src/RGBLed.h
@@ -0,0 +1,22 @@
+#ifndef CLOCKSTAR_LIBRARY_RGBLED_H
+#define CLOCKSTAR_LIBRARY_RGBLED_H
+
+#include <Display/Color.h>
+
+class RGBLed {
+public:
+	void begin();
+	const Pixel& getColor() const;
+	void setColor(Pixel color);
+	uint8_t getBrightness() const;
+	void setBrightness(uint8_t brightness);
+
+private:
+	Pixel color = { 0, 0, 0 };
+	bool attached = false;
+
+	uint8_t brightness = 200;
+};
+
+
+#endif //CLOCKSTAR_LIBRARY_RGBLED_H