MarinoDev/blk_box_tc
4
0
Fork 0
Code Issues 9 Pull Requests Packages Projects Releases 1 Wiki Activity

Compare commits

base: MarinoDev:main
Branches Tags
MarinoDev:main
MarinoDev:cpp
MarinoDev:v0.0.0
..
compare: MarinoDev:v0.0.0
Branches Tags
MarinoDev:cpp
MarinoDev:main
MarinoDev:v0.0.0

No commits in common. "main" and "v0.0.0" have entirely different histories.
main ... v0.0.0

128 changed files with 1983 additions and 8555 deletions
Show Stats Expand all files Collapse all files

58
README.md
View File

@ -1,19 +1,53 @@
# BLK_BOX_TC | Supported Targets | ESP32 | ESP32-C2 | ESP32-C3 | ESP32-C6 | ESP32-H2 | ESP32-P4 | ESP32-S2 | ESP32-S3 | Linux |
| ----------------- | ----- | -------- | -------- | -------- | -------- | -------- | -------- | -------- | ----- |
ESP-IDF version `v5.3.2` # Hello World Example
Firmware for the BLK_BOX Top control board for the puzzle `PDE001`. Starts a FreeRTOS task to print "Hello World".
## Resources (See the README.md file in the upper level 'examples' directory for more information about examples.)
All the files in the `resources/` folder should be loaded onto a micro SD card placed in the BLK_BOX. ## How to use example
Developer Note: You can convert mp3 files to 44100Hz mono signed 16 uncompressed .wav files with the following command: Follow detailed instructions provided specifically for this example.
```ffmpeg -i input.mp3 -ac 1 -ar 44100 -sample_fmt s16 output.wav```
File names must be no longer than `8` characters not including the extention Select the instructions depending on Espressif chip installed on your development board:
File extentions must be no longer than `3` characters.
To build images, use the lvgl image converter [`https://lvgl.io/tools/imageconverter`]. - [ESP32 Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/stable/get-started/index.html)
Use v8. - [ESP32-S2 Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/latest/esp32s2/get-started/index.html)
I have had the best luck with `CF_RGB565A8`.
## Example folder contents
The project **hello_world** contains one source file in C language [hello_world_main.c](main/hello_world_main.c). The file is located in folder [main](main).
ESP-IDF projects are built using CMake. The project build configuration is contained in `CMakeLists.txt` files that provide set of directives and instructions describing the project's source files and targets (executable, library, or both).
Below is short explanation of remaining files in the project folder.
```
├── CMakeLists.txt
├── pytest_hello_world.py Python script used for automated testing
├── main
│ ├── CMakeLists.txt
│ └── hello_world_main.c
└── README.md This is the file you are currently reading
```
For more information on structure and contents of ESP-IDF projects, please refer to Section [Build System](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/build-system.html) of the ESP-IDF Programming Guide.
## Troubleshooting
* Program upload failure
* Hardware connection is not correct: run `idf.py -p PORT monitor`, and reboot your board to see if there are any output logs.
* The baud rate for downloading is too high: lower your baud rate in the `menuconfig` menu, and try again.
## Technical support and feedback
Please use the following feedback channels:
* For technical queries, go to the [esp32.com](https://esp32.com/) forum
* For a feature request or bug report, create a [GitHub issue](https://github.com/espressif/esp-idf/issues)
We will get back to you as soon as possible.

8
main/Kconfig.projbuild
View File

@ -1,8 +0,0 @@
menu "BLK_BOX Config"
config USE_NEW_DISPLAY
bool "use new TFT display"
default y
help
Whether or not you have a new TFT display.
Incorrectly selecting may result in wrong colors.
endmenu

13
main/drivers/CMakeLists.txt
View File

@ -1,28 +1,15 @@
set(SOURCES set(SOURCES
"all.cpp"
"TM1640/TM16xx.cpp" "TM1640/TM16xx.cpp"
"TM1640/TM1640.cpp" "TM1640/TM1640.cpp"
"SparkFunBQ27441/SparkFunBQ27441.cpp"
"esp_lcd_ili9488/esp_lcd_ili9488.c"
"bottom_half.cpp" "bottom_half.cpp"
"char_lcd.cpp" "char_lcd.cpp"
"game_info.cpp"
"game_timer.cpp" "game_timer.cpp"
"hwdata.cpp"
"i2c_lcd_pcf8574.c"
"i2c.cpp"
"leds.cpp" "leds.cpp"
"nvs.cpp"
"perh.cpp"
"power.cpp"
"sd.cpp" "sd.cpp"
"speaker.cpp" "speaker.cpp"
"sseg.cpp" "sseg.cpp"
"starcode.cpp"
"state_tracking.cpp"
"tft.cpp" "tft.cpp"
"wires.cpp" "wires.cpp"
"wlvgl.cpp"
) )
target_sources(${COMPONENT_LIB} PRIVATE ${SOURCES}) target_sources(${COMPONENT_LIB} PRIVATE ${SOURCES})

186
main/drivers/SparkFunBQ27441/BQ27441_Definitions.h
View File

@ -1,186 +0,0 @@
// Modified or adapted from https://github.com/sparkfun/SparkFun_BQ27441_Arduino_Library
//
// Originally Licensed under the MIT
/*
The MIT License (MIT)
Copyright (c) 2016 SparkFun Electronics, Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/******************************************************************************
BQ27441_Definitions.h
BQ27441 LiPo Fuel Gauge Definitions
Jim Lindblom @ SparkFun Electronics
May 9, 2016
https://github.com/sparkfun/SparkFun_BQ27441_Arduino_Library
BQ27441 hardware constants, register addresses, and bit positions.
Hardware Resources:
- Arduino Development Board
- SparkFun Battery Babysitter
Development environment specifics:
Arduino 1.6.7
SparkFun Battery Babysitter v1.0
Arduino Uno (any 'duino should do)
******************************************************************************/
#define BQ72441_I2C_ADDRESS 0x55 // Default I2C address of the BQ27441-G1A
///////////////////////
// General Constants //
///////////////////////
#define BQ27441_UNSEAL_KEY 0x8000 // Secret code to unseal the BQ27441-G1A
#define BQ27441_DEVICE_ID 0x0421 // Default device ID
///////////////////////
// Standard Commands //
///////////////////////
// The fuel gauge uses a series of 2-byte standard commands to enable system
// reading and writing of battery information. Each command has an associated
// sequential command-code pair.
#define BQ27441_COMMAND_CONTROL 0x00 // Control()
#define BQ27441_COMMAND_TEMP 0x02 // Temperature()
#define BQ27441_COMMAND_VOLTAGE 0x04 // Voltage()
#define BQ27441_COMMAND_FLAGS 0x06 // Flags()
#define BQ27441_COMMAND_NOM_CAPACITY 0x08 // NominalAvailableCapacity()
#define BQ27441_COMMAND_AVAIL_CAPACITY 0x0A // FullAvailableCapacity()
#define BQ27441_COMMAND_REM_CAPACITY 0x0C // RemainingCapacity()
#define BQ27441_COMMAND_FULL_CAPACITY 0x0E // FullChargeCapacity()
#define BQ27441_COMMAND_AVG_CURRENT 0x10 // AverageCurrent()
#define BQ27441_COMMAND_STDBY_CURRENT 0x12 // StandbyCurrent()
#define BQ27441_COMMAND_MAX_CURRENT 0x14 // MaxLoadCurrent()
#define BQ27441_COMMAND_AVG_POWER 0x18 // AveragePower()
#define BQ27441_COMMAND_SOC 0x1C // StateOfCharge()
#define BQ27441_COMMAND_INT_TEMP 0x1E // InternalTemperature()
#define BQ27441_COMMAND_SOH 0x20 // StateOfHealth()
#define BQ27441_COMMAND_REM_CAP_UNFL 0x28 // RemainingCapacityUnfiltered()
#define BQ27441_COMMAND_REM_CAP_FIL 0x2A // RemainingCapacityFiltered()
#define BQ27441_COMMAND_FULL_CAP_UNFL 0x2C // FullChargeCapacityUnfiltered()
#define BQ27441_COMMAND_FULL_CAP_FIL 0x2E // FullChargeCapacityFiltered()
#define BQ27441_COMMAND_SOC_UNFL 0x30 // StateOfChargeUnfiltered()
//////////////////////////
// Control Sub-commands //
//////////////////////////
// Issuing a Control() command requires a subsequent 2-byte subcommand. These
// additional bytes specify the particular control function desired. The
// Control() command allows the system to control specific features of the fuel
// gauge during normal operation and additional features when the device is in
// different access modes.
#define BQ27441_CONTROL_STATUS 0x00
#define BQ27441_CONTROL_DEVICE_TYPE 0x01
#define BQ27441_CONTROL_FW_VERSION 0x02
#define BQ27441_CONTROL_DM_CODE 0x04
#define BQ27441_CONTROL_PREV_MACWRITE 0x07
#define BQ27441_CONTROL_CHEM_ID 0x08
#define BQ27441_CONTROL_BAT_INSERT 0x0C
#define BQ27441_CONTROL_BAT_REMOVE 0x0D
#define BQ27441_CONTROL_SET_HIBERNATE 0x11
#define BQ27441_CONTROL_CLEAR_HIBERNATE 0x12
#define BQ27441_CONTROL_SET_CFGUPDATE 0x13
#define BQ27441_CONTROL_SHUTDOWN_ENABLE 0x1B
#define BQ27441_CONTROL_SHUTDOWN 0x1C
#define BQ27441_CONTROL_SEALED 0x20
#define BQ27441_CONTROL_PULSE_SOC_INT 0x23
#define BQ27441_CONTROL_RESET 0x41
#define BQ27441_CONTROL_SOFT_RESET 0x42
#define BQ27441_CONTROL_EXIT_CFGUPDATE 0x43
#define BQ27441_CONTROL_EXIT_RESIM 0x44
///////////////////////////////////////////
// Control Status Word - Bit Definitions //
///////////////////////////////////////////
// Bit positions for the 16-bit data of CONTROL_STATUS.
// CONTROL_STATUS instructs the fuel gauge to return status information to
// Control() addresses 0x00 and 0x01. The read-only status word contains status
// bits that are set or cleared either automatically as conditions warrant or
// through using specified subcommands.
#define BQ27441_STATUS_SHUTDOWNEN (1<<15)
#define BQ27441_STATUS_WDRESET (1<<14)
#define BQ27441_STATUS_SS (1<<13)
#define BQ27441_STATUS_CALMODE (1<<12)
#define BQ27441_STATUS_CCA (1<<11)
#define BQ27441_STATUS_BCA (1<<10)
#define BQ27441_STATUS_QMAX_UP (1<<9)
#define BQ27441_STATUS_RES_UP (1<<8)
#define BQ27441_STATUS_INITCOMP (1<<7)
#define BQ27441_STATUS_HIBERNATE (1<<6)
#define BQ27441_STATUS_SLEEP (1<<4)
#define BQ27441_STATUS_LDMD (1<<3)
#define BQ27441_STATUS_RUP_DIS (1<<2)
#define BQ27441_STATUS_VOK (1<<1)
////////////////////////////////////
// Flag Command - Bit Definitions //
////////////////////////////////////
// Bit positions for the 16-bit data of Flags()
// This read-word function returns the contents of the fuel gauging status
// register, depicting the current operating status.
#define BQ27441_FLAG_OT (1<<15)
#define BQ27441_FLAG_UT (1<<14)
#define BQ27441_FLAG_FC (1<<9)
#define BQ27441_FLAG_CHG (1<<8)
#define BQ27441_FLAG_OCVTAKEN (1<<7)
#define BQ27441_FLAG_ITPOR (1<<5)
#define BQ27441_FLAG_CFGUPMODE (1<<4)
#define BQ27441_FLAG_BAT_DET (1<<3)
#define BQ27441_FLAG_SOC1 (1<<2)
#define BQ27441_FLAG_SOCF (1<<1)
#define BQ27441_FLAG_DSG (1<<0)
////////////////////////////
// Extended Data Commands //
////////////////////////////
// Extended data commands offer additional functionality beyond the standard
// set of commands. They are used in the same manner; however, unlike standard
// commands, extended commands are not limited to 2-byte words.
#define BQ27441_EXTENDED_OPCONFIG 0x3A // OpConfig()
#define BQ27441_EXTENDED_CAPACITY 0x3C // DesignCapacity()
#define BQ27441_EXTENDED_DATACLASS 0x3E // DataClass()
#define BQ27441_EXTENDED_DATABLOCK 0x3F // DataBlock()
#define BQ27441_EXTENDED_BLOCKDATA 0x40 // BlockData()
#define BQ27441_EXTENDED_CHECKSUM 0x60 // BlockDataCheckSum()
#define BQ27441_EXTENDED_CONTROL 0x61 // BlockDataControl()
////////////////////////////////////////
// Configuration Class, Subclass ID's //
////////////////////////////////////////
// To access a subclass of the extended data, set the DataClass() function
// with one of these values.
// Configuration Classes
#define BQ27441_ID_SAFETY 2 // Safety
#define BQ27441_ID_CHG_TERMINATION 36 // Charge Termination
#define BQ27441_ID_CONFIG_DATA 48 // Data
#define BQ27441_ID_DISCHARGE 49 // Discharge
#define BQ27441_ID_REGISTERS 64 // Registers
#define BQ27441_ID_POWER 68 // Power
// Gas Gauging Classes
#define BQ27441_ID_IT_CFG 80 // IT Cfg
#define BQ27441_ID_CURRENT_THRESH 81 // Current Thresholds
#define BQ27441_ID_STATE 82 // State
// Ra Tables Classes
#define BQ27441_ID_R_A_RAM 89 // R_a RAM
// Calibration Classes
#define BQ27441_ID_CALIB_DATA 104 // Data
#define BQ27441_ID_CC_CAL 105 // CC Cal
#define BQ27441_ID_CURRENT 107 // Current
// Security Classes
#define BQ27441_ID_CODES 112 // Codes
/////////////////////////////////////////
// OpConfig Register - Bit Definitions //
/////////////////////////////////////////
// Bit positions of the OpConfig Register
#define BQ27441_OPCONFIG_BIE (1<<13)
#define BQ27441_OPCONFIG_BI_PU_EN (1<<12)
#define BQ27441_OPCONFIG_GPIOPOL (1<<11)
#define BQ27441_OPCONFIG_SLEEP (1<<5)
#define BQ27441_OPCONFIG_RMFCC (1<<4)
#define BQ27441_OPCONFIG_BATLOWEN (1<<2)
#define BQ27441_OPCONFIG_TEMPS (1<<0)

739
main/drivers/SparkFunBQ27441/SparkFunBQ27441.cpp
View File

@ -1,739 +0,0 @@
// Modified or adapted from https://github.com/sparkfun/SparkFun_BQ27441_Arduino_Library
//
// Originally Licensed under the MIT
/*
The MIT License (MIT)
Copyright (c) 2016 SparkFun Electronics, Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/******************************************************************************
SparkFunBQ27441.cpp
BQ27441 Arduino Library Main Source File
Jim Lindblom @ SparkFun Electronics
May 9, 2016
https://github.com/sparkfun/SparkFun_BQ27441_Arduino_Library
Implementation of all features of the BQ27441 LiPo Fuel Gauge.
Hardware Resources:
- Arduino Development Board
- SparkFun Battery Babysitter
Development environment specifics:
Arduino 1.6.7
SparkFun Battery Babysitter v1.0
Arduino Uno (any 'duino should do)
******************************************************************************/
#include "SparkFunBQ27441.h"
#include "../i2c.h"
/*****************************************************************************
************************** Initialization Functions *************************
*****************************************************************************/
// Initializes class variables
BQ27441::BQ27441() : _deviceAddress(BQ72441_I2C_ADDRESS), _sealFlag(false), _userConfigControl(false)
{
}
static uint8_t constrain(uint8_t x, uint8_t min, uint8_t max) {
if (x < min) return min;
if (x > max) return max;
return x;
}
// Initializes I2C and verifies communication with the BQ27441.
bool BQ27441::begin(void)
{
uint16_t deviceID = 0;
// Assume the I2C is already initialized from other things
deviceID = deviceType(); // Read deviceType from BQ27441
if (deviceID == BQ27441_DEVICE_ID)
{
return true; // If device ID is valid, return true
}
return false; // Otherwise return false
}
// Configures the design capacity of the connected battery.
bool BQ27441::setCapacity(uint16_t capacity)
{
// Write to STATE subclass (82) of BQ27441 extended memory.
// Offset 0x0A (10)
// Design capacity is a 2-byte piece of data - MSB first
// Unit: mAh
uint8_t capMSB = capacity >> 8;
uint8_t capLSB = capacity & 0x00FF;
uint8_t capacityData[2] = {capMSB, capLSB};
return writeExtendedData(BQ27441_ID_STATE, 10, capacityData, 2);
}
// Configures the design energy of the connected battery.
bool BQ27441::setDesignEnergy(uint16_t energy)
{
// Write to STATE subclass (82) of BQ27441 extended memory.
// Offset 0x0C (12)
// Design energy is a 2-byte piece of data - MSB first
// Unit: mWh
uint8_t enMSB = energy >> 8;
uint8_t enLSB = energy & 0x00FF;
uint8_t energyData[2] = {enMSB, enLSB};
return writeExtendedData(BQ27441_ID_STATE, 12, energyData, 2);
}
// Configures the terminate voltage.
bool BQ27441::setTerminateVoltage(uint16_t voltage)
{
// Write to STATE subclass (82) of BQ27441 extended memory.
// Offset 0x0F (16)
// Termiante voltage is a 2-byte piece of data - MSB first
// Unit: mV
// Min 2500, Max 3700
if(voltage<2500) voltage=2500;
if(voltage>3700) voltage=3700;
uint8_t tvMSB = voltage >> 8;
uint8_t tvLSB = voltage & 0x00FF;
uint8_t tvData[2] = {tvMSB, tvLSB};
return writeExtendedData(BQ27441_ID_STATE, 16, tvData, 2);
}
// Configures taper rate of connected battery.
bool BQ27441::setTaperRate(uint16_t rate)
{
// Write to STATE subclass (82) of BQ27441 extended memory.
// Offset 0x1B (27)
// Termiante voltage is a 2-byte piece of data - MSB first
// Unit: 0.1h
// Max 2000
if(rate>2000) rate=2000;
uint8_t trMSB = rate >> 8;
uint8_t trLSB = rate & 0x00FF;
uint8_t trData[2] = {trMSB, trLSB};
return writeExtendedData(BQ27441_ID_STATE, 27, trData, 2);
}
/*****************************************************************************
********************** Battery Characteristics Functions ********************
*****************************************************************************/
// Reads and returns the battery voltage
uint16_t BQ27441::voltage(void)
{
return readWord(BQ27441_COMMAND_VOLTAGE);
}
// Reads and returns the specified current measurement
int16_t BQ27441::current(current_measure type)
{
int16_t current = 0;
switch (type)
{
case AVG:
current = (int16_t) readWord(BQ27441_COMMAND_AVG_CURRENT);
break;
case STBY:
current = (int16_t) readWord(BQ27441_COMMAND_STDBY_CURRENT);
break;
case MAX:
current = (int16_t) readWord(BQ27441_COMMAND_MAX_CURRENT);
break;
}
return current;
}
// Reads and returns the specified capacity measurement
uint16_t BQ27441::capacity(capacity_measure type)
{
uint16_t capacity = 0;
switch (type)
{
case REMAIN:
return readWord(BQ27441_COMMAND_REM_CAPACITY);
break;
case FULL:
return readWord(BQ27441_COMMAND_FULL_CAPACITY);
break;
case AVAIL:
capacity = readWord(BQ27441_COMMAND_NOM_CAPACITY);
break;
case AVAIL_FULL:
capacity = readWord(BQ27441_COMMAND_AVAIL_CAPACITY);
break;
case REMAIN_F:
capacity = readWord(BQ27441_COMMAND_REM_CAP_FIL);
break;
case REMAIN_UF:
capacity = readWord(BQ27441_COMMAND_REM_CAP_UNFL);
break;
case FULL_F:
capacity = readWord(BQ27441_COMMAND_FULL_CAP_FIL);
break;
case FULL_UF:
capacity = readWord(BQ27441_COMMAND_FULL_CAP_UNFL);
break;
case DESIGN:
capacity = readWord(BQ27441_EXTENDED_CAPACITY);
}
return capacity;
}
// Reads and returns measured average power
int16_t BQ27441::power(void)
{
return (int16_t) readWord(BQ27441_COMMAND_AVG_POWER);
}
// Reads and returns specified state of charge measurement
uint16_t BQ27441::soc(soc_measure type)
{
uint16_t socRet = 0;
switch (type)
{
case FILTERED:
socRet = readWord(BQ27441_COMMAND_SOC);
break;
case UNFILTERED:
socRet = readWord(BQ27441_COMMAND_SOC_UNFL);
break;
}
return socRet;
}
// Reads and returns specified state of health measurement
uint8_t BQ27441::soh(soh_measure type)
{
uint16_t sohRaw = readWord(BQ27441_COMMAND_SOH);
uint8_t sohStatus = sohRaw >> 8;
uint8_t sohPercent = sohRaw & 0x00FF;
if (type == PERCENT)
return sohPercent;
else
return sohStatus;
}
// Reads and returns specified temperature measurement
uint16_t BQ27441::temperature(temp_measure type)
{
uint16_t temp = 0;
switch (type)
{
case BATTERY:
temp = readWord(BQ27441_COMMAND_TEMP);
break;
case INTERNAL_TEMP:
temp = readWord(BQ27441_COMMAND_INT_TEMP);
break;
}
return temp;
}
/*****************************************************************************
************************** GPOUT Control Functions **************************
*****************************************************************************/
// Get GPOUT polarity setting (active-high or active-low)
bool BQ27441::GPOUTPolarity(void)
{
uint16_t opConfigRegister = opConfig();
return (opConfigRegister & BQ27441_OPCONFIG_GPIOPOL);
}
// Set GPOUT polarity to active-high or active-low
bool BQ27441::setGPOUTPolarity(bool activeHigh)
{
uint16_t oldOpConfig = opConfig();
// Check to see if we need to update opConfig:
if ((activeHigh && (oldOpConfig & BQ27441_OPCONFIG_GPIOPOL)) ||
(!activeHigh && !(oldOpConfig & BQ27441_OPCONFIG_GPIOPOL)))
return true;
uint16_t newOpConfig = oldOpConfig;
if (activeHigh)
newOpConfig |= BQ27441_OPCONFIG_GPIOPOL;
else
newOpConfig &= ~(BQ27441_OPCONFIG_GPIOPOL);
return writeOpConfig(newOpConfig);
}
// Get GPOUT function (BAT_LOW or SOC_INT)
bool BQ27441::GPOUTFunction(void)
{
uint16_t opConfigRegister = opConfig();
return (opConfigRegister & BQ27441_OPCONFIG_BATLOWEN);
}
// Set GPOUT function to BAT_LOW or SOC_INT
bool BQ27441::setGPOUTFunction(gpout_function function)
{
uint16_t oldOpConfig = opConfig();
// Check to see if we need to update opConfig:
if ((function && (oldOpConfig & BQ27441_OPCONFIG_BATLOWEN)) ||
(!function && !(oldOpConfig & BQ27441_OPCONFIG_BATLOWEN)))
return true;
// Modify BATLOWN_EN bit of opConfig:
uint16_t newOpConfig = oldOpConfig;
if (function)
newOpConfig |= BQ27441_OPCONFIG_BATLOWEN;
else
newOpConfig &= ~(BQ27441_OPCONFIG_BATLOWEN);
// Write new opConfig
return writeOpConfig(newOpConfig);
}
// Get SOC1_Set Threshold - threshold to set the alert flag
uint8_t BQ27441::SOC1SetThreshold(void)
{
return readExtendedData(BQ27441_ID_DISCHARGE, 0);
}
// Get SOC1_Clear Threshold - threshold to clear the alert flag
uint8_t BQ27441::SOC1ClearThreshold(void)
{
return readExtendedData(BQ27441_ID_DISCHARGE, 1);
}
// Set the SOC1 set and clear thresholds to a percentage
bool BQ27441::setSOC1Thresholds(uint8_t set, uint8_t clear)
{
uint8_t thresholds[2];
thresholds[0] = constrain(set, 0, 100);
thresholds[1] = constrain(clear, 0, 100);
return writeExtendedData(BQ27441_ID_DISCHARGE, 0, thresholds, 2);
}
// Get SOCF_Set Threshold - threshold to set the alert flag
uint8_t BQ27441::SOCFSetThreshold(void)
{
return readExtendedData(BQ27441_ID_DISCHARGE, 2);
}
// Get SOCF_Clear Threshold - threshold to clear the alert flag
uint8_t BQ27441::SOCFClearThreshold(void)
{
return readExtendedData(BQ27441_ID_DISCHARGE, 3);
}
// Set the SOCF set and clear thresholds to a percentage
bool BQ27441::setSOCFThresholds(uint8_t set, uint8_t clear)
{
uint8_t thresholds[2];
thresholds[0] = constrain(set, 0, 100);
thresholds[1] = constrain(clear, 0, 100);
return writeExtendedData(BQ27441_ID_DISCHARGE, 2, thresholds, 2);
}
// Check if the SOC1 flag is set
bool BQ27441::socFlag(void)
{
uint16_t flagState = flags();
return flagState & BQ27441_FLAG_SOC1;
}
// Check if the SOCF flag is set
bool BQ27441::socfFlag(void)
{
uint16_t flagState = flags();
return flagState & BQ27441_FLAG_SOCF;
}
// Check if the ITPOR flag is set
bool BQ27441::itporFlag(void)
{
uint16_t flagState = flags();
return flagState & BQ27441_FLAG_ITPOR;
}
// Check if the FC flag is set
bool BQ27441::fcFlag(void)
{
uint16_t flagState = flags();
return flagState & BQ27441_FLAG_FC;
}
// Check if the CHG flag is set
bool BQ27441::chgFlag(void)
{
uint16_t flagState = flags();
return flagState & BQ27441_FLAG_CHG;
}
// Check if the DSG flag is set
bool BQ27441::dsgFlag(void)
{
uint16_t flagState = flags();
return flagState & BQ27441_FLAG_DSG;
}
// Get the SOC_INT interval delta
uint8_t BQ27441::sociDelta(void)
{
return readExtendedData(BQ27441_ID_STATE, 26);
}
// Set the SOC_INT interval delta to a value between 1 and 100
bool BQ27441::setSOCIDelta(uint8_t delta)
{
uint8_t soci = constrain(delta, 0, 100);
return writeExtendedData(BQ27441_ID_STATE, 26, &soci, 1);
}
// Pulse the GPOUT pin - must be in SOC_INT mode
bool BQ27441::pulseGPOUT(void)
{
return executeControlWord(BQ27441_CONTROL_PULSE_SOC_INT);
}
/*****************************************************************************
*************************** Control Sub-Commands ****************************
*****************************************************************************/
// Read the device type - should be 0x0421
uint16_t BQ27441::deviceType(void)
{
return readControlWord(BQ27441_CONTROL_DEVICE_TYPE);
}
// Enter configuration mode - set userControl if calling from an Arduino sketch
// and you want control over when to exitConfig
bool BQ27441::enterConfig(bool userControl)
{
if (userControl) _userConfigControl = true;
if (sealed())
{
_sealFlag = true;
unseal(); // Must be unsealed before making changes
}
if (executeControlWord(BQ27441_CONTROL_SET_CFGUPDATE))
{
int16_t timeout = BQ72441_I2C_TIMEOUT;
while ((timeout--) && (!(flags() & BQ27441_FLAG_CFGUPMODE)))
vTaskDelay(pdMS_TO_TICKS(1));
if (timeout > 0)
return true;
}
return false;
}
// Exit configuration mode with the option to perform a resimulation
bool BQ27441::exitConfig(bool resim)
{
// There are two methods for exiting config mode:
// 1. Execute the EXIT_CFGUPDATE command
// 2. Execute the SOFT_RESET command
// EXIT_CFGUPDATE exits config mode _without_ an OCV (open-circuit voltage)
// measurement, and without resimulating to update unfiltered-SoC and SoC.
// If a new OCV measurement or resimulation is desired, SOFT_RESET or
// EXIT_RESIM should be used to exit config mode.
if (resim)
{
if (softReset())
{
int16_t timeout = BQ72441_I2C_TIMEOUT;
while ((timeout--) && ((flags() & BQ27441_FLAG_CFGUPMODE)))
vTaskDelay(pdMS_TO_TICKS(1));
if (timeout > 0)
{
if (_sealFlag) seal(); // Seal back up if we IC was sealed coming in
return true;
}
}
return false;
}
else
{
return executeControlWord(BQ27441_CONTROL_EXIT_CFGUPDATE);
}
}
// Read the flags() command
uint16_t BQ27441::flags(void)
{
return readWord(BQ27441_COMMAND_FLAGS);
}
// Read the CONTROL_STATUS subcommand of control()
uint16_t BQ27441::status(void)
{
return readControlWord(BQ27441_CONTROL_STATUS);
}
/***************************** Private Functions *****************************/
// Check if the BQ27441-G1A is sealed or not.
bool BQ27441::sealed(void)
{
uint16_t stat = status();
return stat & BQ27441_STATUS_SS;
}
// Seal the BQ27441-G1A
bool BQ27441::seal(void)
{
return readControlWord(BQ27441_CONTROL_SEALED);
}
// UNseal the BQ27441-G1A
bool BQ27441::unseal(void)
{
// To unseal the BQ27441, write the key to the control
// command. Then immediately write the same key to control again.
if (readControlWord(BQ27441_UNSEAL_KEY))
{
return readControlWord(BQ27441_UNSEAL_KEY);
}
return false;
}
// Read the 16-bit opConfig register from extended data
uint16_t BQ27441::opConfig(void)
{
return readWord(BQ27441_EXTENDED_OPCONFIG);
}
// Write the 16-bit opConfig register in extended data
bool BQ27441::writeOpConfig(uint16_t value)
{
uint8_t opConfigMSB = value >> 8;
uint8_t opConfigLSB = value & 0x00FF;
uint8_t opConfigData[2] = {opConfigMSB, opConfigLSB};
// OpConfig register location: BQ27441_ID_REGISTERS id, offset 0
return writeExtendedData(BQ27441_ID_REGISTERS, 0, opConfigData, 2);
}
// Issue a soft-reset to the BQ27441-G1A
bool BQ27441::softReset(void)
{
return executeControlWord(BQ27441_CONTROL_SOFT_RESET);
}
// Read a 16-bit command word from the BQ27441-G1A
uint16_t BQ27441::readWord(uint16_t subAddress)
{
uint8_t data[2];
i2cReadBytes(subAddress, data, 2);
return ((uint16_t) data[1] << 8) | data[0];
}
// Read a 16-bit subcommand() from the BQ27441-G1A's control()
uint16_t BQ27441::readControlWord(uint16_t function)
{
uint8_t subCommandMSB = (function >> 8);
uint8_t subCommandLSB = (function & 0x00FF);
uint8_t command[3] = {0, subCommandLSB, subCommandMSB};
uint8_t data[2] = {0, 0};
i2cWriteBytes((uint8_t) 0, command, 2);
if (i2cReadBytes((uint8_t) 0, data, 2))
{
return ((uint16_t)data[1] << 8) | data[0];
}
return false;
}
// Execute a subcommand() from the BQ27441-G1A's control()
bool BQ27441::executeControlWord(uint16_t function)
{
uint8_t subCommandMSB = (function >> 8);
uint8_t subCommandLSB = (function & 0x00FF);
uint8_t command[2] = {subCommandLSB, subCommandMSB};
if (i2cWriteBytes((uint8_t) 0, command, 2))
return true;
return false;
}
/*****************************************************************************
************************** Extended Data Commands ***************************
*****************************************************************************/
// Issue a BlockDataControl() command to enable BlockData access
bool BQ27441::blockDataControl(void)
{
uint8_t enableByte = 0x00;
return i2cWriteBytes(BQ27441_EXTENDED_CONTROL, &enableByte, 1);
}
// Issue a DataClass() command to set the data class to be accessed
bool BQ27441::blockDataClass(uint8_t id)
{
return i2cWriteBytes(BQ27441_EXTENDED_DATACLASS, &id, 1);
}
// Issue a DataBlock() command to set the data block to be accessed
bool BQ27441::blockDataOffset(uint8_t offset)
{
return i2cWriteBytes(BQ27441_EXTENDED_DATABLOCK, &offset, 1);
}
// Read the current checksum using BlockDataCheckSum()
uint8_t BQ27441::blockDataChecksum(void)
{
uint8_t csum;
i2cReadBytes(BQ27441_EXTENDED_CHECKSUM, &csum, 1);
return csum;
}
// Use BlockData() to read a byte from the loaded extended data
uint8_t BQ27441::readBlockData(uint8_t offset)
{
uint8_t ret;
uint8_t address = offset + BQ27441_EXTENDED_BLOCKDATA;
i2cReadBytes(address, &ret, 1);
return ret;
}
// Use BlockData() to write a byte to an offset of the loaded data
bool BQ27441::writeBlockData(uint8_t offset, uint8_t data)
{
uint8_t address = offset + BQ27441_EXTENDED_BLOCKDATA;
return i2cWriteBytes(address, &data, 1);
}
// Read all 32 bytes of the loaded extended data and compute a
// checksum based on the values.
uint8_t BQ27441::computeBlockChecksum(void)
{
uint8_t data[32];
i2cReadBytes(BQ27441_EXTENDED_BLOCKDATA, data, 32);
uint8_t csum = 0;
for (int i=0; i<32; i++)
{
csum += data[i];
}
csum = 255 - csum;
return csum;
}
// Use the BlockDataCheckSum() command to write a checksum value
bool BQ27441::writeBlockChecksum(uint8_t csum)
{
return i2cWriteBytes(BQ27441_EXTENDED_CHECKSUM, &csum, 1);
}
// Read a byte from extended data specifying a class ID and position offset
uint8_t BQ27441::readExtendedData(uint8_t classID, uint8_t offset)
{
uint8_t retData = 0;
if (!_userConfigControl) enterConfig(false);
if (!blockDataControl()) // // enable block data memory control
return false; // Return false if enable fails
if (!blockDataClass(classID)) // Write class ID using DataBlockClass()
return false;
blockDataOffset(offset / 32); // Write 32-bit block offset (usually 0)
computeBlockChecksum(); // Compute checksum going in
retData = readBlockData(offset % 32); // Read from offset (limit to 0-31)
if (!_userConfigControl) exitConfig();
return retData;
}
// Write a specified number of bytes to extended data specifying a
// class ID, position offset.
bool BQ27441::writeExtendedData(uint8_t classID, uint8_t offset, uint8_t * data, uint8_t len)
{
if (len > 32)
return false;
if (!_userConfigControl) enterConfig(false);
if (!blockDataControl()) // // enable block data memory control
return false; // Return false if enable fails
if (!blockDataClass(classID)) // Write class ID using DataBlockClass()
return false;
blockDataOffset(offset / 32); // Write 32-bit block offset (usually 0)
computeBlockChecksum(); // Compute checksum going in
// Write data bytes:
for (int i = 0; i < len; i++)
{
// Write to offset, mod 32 if offset is greater than 32
// The blockDataOffset above sets the 32-bit block
writeBlockData((offset % 32) + i, data[i]);
}
// Write new checksum using BlockDataChecksum (0x60)
uint8_t newCsum = computeBlockChecksum(); // Compute the new checksum
writeBlockChecksum(newCsum);
if (!_userConfigControl) exitConfig();
return true;
}
/*****************************************************************************
************************ I2C Read and Write Routines ************************
*****************************************************************************/
// Read a specified number of bytes over I2C at a given subAddress
int16_t BQ27441::i2cReadBytes(uint8_t subAddress, uint8_t * dest, uint8_t count)
{
int16_t timeout = BQ72441_I2C_TIMEOUT;
xSemaphoreTake(main_i2c_mutex, portMAX_DELAY);
i2c_master_write_read_device(BQ72441_I2C_NUM, _deviceAddress, &subAddress, 1, dest, count, timeout);
xSemaphoreGive(main_i2c_mutex);
return timeout;
}
// Write a specified number of bytes over I2C to a given subAddress
uint16_t BQ27441::i2cWriteBytes(uint8_t subAddress, uint8_t * src, uint8_t count)
{
int16_t timeout = BQ72441_I2C_TIMEOUT;
// prepend the subAddress to the data.
uint8_t w_buff[count+1] = {0};
w_buff[0] = subAddress;
for (int i = 0; i < count; i ++) {
w_buff[i+1] = src[i];
}
xSemaphoreTake(main_i2c_mutex, portMAX_DELAY);
esp_err_t ret = i2c_master_write_to_device(BQ72441_I2C_NUM, _deviceAddress, src, count+1, timeout);
xSemaphoreGive(main_i2c_mutex);
return ret == ESP_OK;
}
BQ27441 lipo;

564
main/drivers/SparkFunBQ27441/SparkFunBQ27441.h
View File

@ -1,564 +0,0 @@
// Modified or adapted from https://github.com/sparkfun/SparkFun_BQ27441_Arduino_Library
//
// Originally Licensed under the MIT
/*
The MIT License (MIT)
Copyright (c) 2016 SparkFun Electronics, Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/******************************************************************************
SparkFunBQ27441.h
BQ27441 Arduino Library Main Header File
Jim Lindblom @ SparkFun Electronics
May 9, 2016
https://github.com/sparkfun/SparkFun_BQ27441_Arduino_Library
Definition of the BQ27441 library, which implements all features of the
BQ27441 LiPo Fuel Gauge.
Hardware Resources:
- Arduino Development Board
- SparkFun Battery Babysitter
Development environment specifics:
Arduino 1.6.7
SparkFun Battery Babysitter v1.0
Arduino Uno (any 'duino should do)
******************************************************************************/
#ifndef SparkFunBQ27441_h
#define SparkFunBQ27441_h
#include "BQ27441_Definitions.h"
#include <stdint.h>
#include "driver/i2c.h"
#define BQ72441_I2C_NUM I2C_NUM_0
#define BQ72441_I2C_TIMEOUT 2000
// Parameters for the current() function, to specify which current to read
typedef enum {
AVG, // Average Current (DEFAULT)
STBY, // Standby Current
MAX // Max Current
} current_measure;
// Parameters for the capacity() function, to specify which capacity to read
typedef enum {
REMAIN, // Remaining Capacity (DEFAULT)
FULL, // Full Capacity
AVAIL, // Available Capacity
AVAIL_FULL, // Full Available Capacity
REMAIN_F, // Remaining Capacity Filtered
REMAIN_UF, // Remaining Capacity Unfiltered
FULL_F, // Full Capacity Filtered
FULL_UF, // Full Capacity Unfiltered
DESIGN // Design Capacity
} capacity_measure;
// Parameters for the soc() function
typedef enum {
FILTERED, // State of Charge Filtered (DEFAULT)
UNFILTERED // State of Charge Unfiltered
} soc_measure;
// Parameters for the soh() function
typedef enum {
PERCENT, // State of Health Percentage (DEFAULT)
SOH_STAT // State of Health Status Bits
} soh_measure;
// Parameters for the temperature() function
typedef enum {
BATTERY, // Battery Temperature (DEFAULT)
INTERNAL_TEMP // Internal IC Temperature
} temp_measure;
// Parameters for the setGPOUTFunction() funciton
typedef enum {
SOC_INT, // Set GPOUT to SOC_INT functionality
BAT_LOW // Set GPOUT to BAT_LOW functionality
} gpout_function;
class BQ27441 {
public:
//////////////////////////////
// Initialization Functions //
//////////////////////////////
/**
Initializes class variables
*/
BQ27441();
/**
Initializes I2C and verifies communication with the BQ27441.
Must be called before using any other functions.
@return true if communication was successful.
*/
bool begin(void);
/**
Configures the design capacity of the connected battery.
@param capacity of battery (unsigned 16-bit value)
@return true if capacity successfully set.
*/
bool setCapacity(uint16_t capacity);
/**
Configures the design energy of the connected battery.
@param energy of battery (unsigned 16-bit value)
@return true if energy successfully set.
*/
bool setDesignEnergy(uint16_t energy);
/**
Configures terminate voltage (lowest operational voltage of battery powered circuit)
@param voltage of battery (unsigned 16-bit value)
@return true if energy successfully set.
*/
bool setTerminateVoltage(uint16_t voltage);
bool setTaperRate(uint16_t rate);
/////////////////////////////
// Battery Characteristics //
/////////////////////////////
/**
Reads and returns the battery voltage
@return battery voltage in mV
*/
uint16_t voltage(void);
/**
Reads and returns the specified current measurement
@param current_measure enum specifying current value to be read
@return specified current measurement in mA. >0 indicates charging.
*/
int16_t current(current_measure type = AVG);
/**
Reads and returns the specified capacity measurement
@param capacity_measure enum specifying capacity value to be read
@return specified capacity measurement in mAh.
*/
uint16_t capacity(capacity_measure type = REMAIN);
/**
Reads and returns measured average power
@return average power in mAh. >0 indicates charging.
*/
int16_t power(void);
/**
Reads and returns specified state of charge measurement
@param soc_measure enum specifying filtered or unfiltered measurement
@return specified state of charge measurement in %
*/
uint16_t soc(soc_measure type = FILTERED);
/**
Reads and returns specified state of health measurement
@param soh_measure enum specifying filtered or unfiltered measurement
@return specified state of health measurement in %, or status bits
*/
uint8_t soh(soh_measure type = PERCENT);
/**
Reads and returns specified temperature measurement
@param temp_measure enum specifying internal or battery measurement
@return specified temperature measurement in degrees C
*/
uint16_t temperature(temp_measure type = BATTERY);
////////////////////////////
// GPOUT Control Commands //
////////////////////////////
/**
Get GPOUT polarity setting (active-high or active-low)
@return true if active-high, false if active-low
*/
bool GPOUTPolarity(void);
/**
Set GPOUT polarity to active-high or active-low
@param activeHigh is true if active-high, false if active-low
@return true on success
*/
bool setGPOUTPolarity(bool activeHigh);
/**
Get GPOUT function (BAT_LOW or SOC_INT)
@return true if BAT_LOW or false if SOC_INT
*/
bool GPOUTFunction(void);
/**
Set GPOUT function to BAT_LOW or SOC_INT
@param function should be either BAT_LOW or SOC_INT
@return true on success
*/
bool setGPOUTFunction(gpout_function function);
/**
Get SOC1_Set Threshold - threshold to set the alert flag
@return state of charge value between 0 and 100%
*/
uint8_t SOC1SetThreshold(void);
/**
Get SOC1_Clear Threshold - threshold to clear the alert flag
@return state of charge value between 0 and 100%
*/
uint8_t SOC1ClearThreshold(void);
/**
Set the SOC1 set and clear thresholds to a percentage
@param set and clear percentages between 0 and 100. clear > set.
@return true on success
*/
bool setSOC1Thresholds(uint8_t set, uint8_t clear);
/**
Get SOCF_Set Threshold - threshold to set the alert flag
@return state of charge value between 0 and 100%
*/
uint8_t SOCFSetThreshold(void);
/**
Get SOCF_Clear Threshold - threshold to clear the alert flag
@return state of charge value between 0 and 100%
*/
uint8_t SOCFClearThreshold(void);
/**
Set the SOCF set and clear thresholds to a percentage
@param set and clear percentages between 0 and 100. clear > set.
@return true on success
*/
bool setSOCFThresholds(uint8_t set, uint8_t clear);
/**
Check if the SOC1 flag is set in flags()
@return true if flag is set
*/
bool socFlag(void);
/**
Check if the SOCF flag is set in flags()
@return true if flag is set
*/
bool socfFlag(void);
/**
Check if the ITPOR flag is set in flags()
@return true if flag is set
*/
bool itporFlag(void);
/**
Check if the FC flag is set in flags()
@return true if flag is set
*/
bool fcFlag(void);
/**
Check if the CHG flag is set in flags()
@return true if flag is set
*/
bool chgFlag(void);
/**
Check if the DSG flag is set in flags()
@return true if flag is set
*/
bool dsgFlag(void);
/**
Get the SOC_INT interval delta
@return interval percentage value between 1 and 100
*/
uint8_t sociDelta(void);
/**
Set the SOC_INT interval delta to a value between 1 and 100
@param interval percentage value between 1 and 100
@return true on success
*/
bool setSOCIDelta(uint8_t delta);
/**
Pulse the GPOUT pin - must be in SOC_INT mode
@return true on success
*/
bool pulseGPOUT(void);
//////////////////////////
// Control Sub-commands //
//////////////////////////
/**
Read the device type - should be 0x0421
@return 16-bit value read from DEVICE_TYPE subcommand
*/
uint16_t deviceType(void);
/**
Enter configuration mode - set userControl if calling from an Arduino
sketch and you want control over when to exitConfig.
@param userControl is true if the Arduino sketch is handling entering
and exiting config mode (should be false in library calls).
@return true on success
*/
bool enterConfig(bool userControl = true);
/**
Exit configuration mode with the option to perform a resimulation
@param resim is true if resimulation should be performed after exiting
@return true on success
*/
bool exitConfig(bool resim = true);
/**
Read the flags() command
@return 16-bit representation of flags() command register
*/
uint16_t flags(void);
/**
Read the CONTROL_STATUS subcommand of control()
@return 16-bit representation of CONTROL_STATUS subcommand
*/
uint16_t status(void);
private:
uint8_t _deviceAddress; // Stores the BQ27441-G1A's I2C address
bool _sealFlag; // Global to identify that IC was previously sealed
bool _userConfigControl; // Global to identify that user has control over
// entering/exiting config
/**
Check if the BQ27441-G1A is sealed or not.
@return true if the chip is sealed
*/
bool sealed(void);
/**
Seal the BQ27441-G1A
@return true on success
*/
bool seal(void);
/**
UNseal the BQ27441-G1A
@return true on success
*/
bool unseal(void);
/**
Read the 16-bit opConfig register from extended data
@return opConfig register contents
*/
uint16_t opConfig(void);
/**
Write the 16-bit opConfig register in extended data
@param New 16-bit value for opConfig
@return true on success
*/
bool writeOpConfig(uint16_t value);
/**
Issue a soft-reset to the BQ27441-G1A
@return true on success
*/
bool softReset(void);
/**
Read a 16-bit command word from the BQ27441-G1A
@param subAddress is the command to be read from
@return 16-bit value of the command's contents
*/
uint16_t readWord(uint16_t subAddress);
/**
Read a 16-bit subcommand() from the BQ27441-G1A's control()
@param function is the subcommand of control() to be read
@return 16-bit value of the subcommand's contents
*/
uint16_t readControlWord(uint16_t function);
/**
Execute a subcommand() from the BQ27441-G1A's control()
@param function is the subcommand of control() to be executed
@return true on success
*/
bool executeControlWord(uint16_t function);
////////////////////////////
// Extended Data Commands //
////////////////////////////
/**
Issue a BlockDataControl() command to enable BlockData access
@return true on success
*/
bool blockDataControl(void);
/**
Issue a DataClass() command to set the data class to be accessed
@param id is the id number of the class
@return true on success
*/
bool blockDataClass(uint8_t id);
/**
Issue a DataBlock() command to set the data block to be accessed
@param offset of the data block
@return true on success
*/
bool blockDataOffset(uint8_t offset);
/**
Read the current checksum using BlockDataCheckSum()
@return true on success
*/
uint8_t blockDataChecksum(void);
/**
Use BlockData() to read a byte from the loaded extended data
@param offset of data block byte to be read
@return true on success
*/
uint8_t readBlockData(uint8_t offset);
/**
Use BlockData() to write a byte to an offset of the loaded data
@param offset is the position of the byte to be written
data is the value to be written
@return true on success
*/
bool writeBlockData(uint8_t offset, uint8_t data);
/**
Read all 32 bytes of the loaded extended data and compute a
checksum based on the values.
@return 8-bit checksum value calculated based on loaded data
*/
uint8_t computeBlockChecksum(void);
/**
Use the BlockDataCheckSum() command to write a checksum value
@param csum is the 8-bit checksum to be written
@return true on success
*/
bool writeBlockChecksum(uint8_t csum);
/**
Read a byte from extended data specifying a class ID and position offset
@param classID is the id of the class to be read from
offset is the byte position of the byte to be read
@return 8-bit value of specified data
*/
uint8_t readExtendedData(uint8_t classID, uint8_t offset);
/**
Write a specified number of bytes to extended data specifying a
class ID, position offset.
@param classID is the id of the class to be read from
offset is the byte position of the byte to be read
data is the data buffer to be written
len is the number of bytes to be written
@return true on success
*/
bool writeExtendedData(uint8_t classID, uint8_t offset, uint8_t * data, uint8_t len);
/////////////////////////////////
// I2C Read and Write Routines //
/////////////////////////////////
/**
Read a specified number of bytes over I2C at a given subAddress
@param subAddress is the 8-bit address of the data to be read
dest is the data buffer to be written to
count is the number of bytes to be read
@return true on success
*/
int16_t i2cReadBytes(uint8_t subAddress, uint8_t * dest, uint8_t count);
/**
Write a specified number of bytes over I2C to a given subAddress
@param subAddress is the 8-bit address of the data to be written to
src is the data buffer to be written
count is the number of bytes to be written
@return true on success
*/
uint16_t i2cWriteBytes(uint8_t subAddress, uint8_t * src, uint8_t count);
};
extern BQ27441 lipo; // Use lipo.[] to interact with the library in an Arduino sketch
// Thanks for reading!
#endif

20
main/drivers/all.cpp
View File

@ -1,20 +0,0 @@
#include "all.h"
void init_drivers() {
init_i2c();
// init char_lcd so we can use it to report other initialization errors.
init_lcd();
init_nvs();
init_star_code_system();
// init the bottom half so that we can get user input.
init_bottom_half();
init_sd();
init_speaker();
init_sseg();
init_game_timers();
init_tft();
init_leds();
init_power_board();
set_lcd_header_enabled(true);
}

21
main/drivers/all.h
View File

@ -1,21 +0,0 @@
#ifndef ALL_H
#define ALL_H
#include "bottom_half.h"
#include "char_lcd.h"
#include "game_timer.h"
#include "i2c.h"
#include "leds.h"
#include "nvs.h"
#include "power.h"
#include "sd.h"
#include "speaker.h"
#include "sseg.h"
#include "starcode.h"
#include "state_tracking.h"
#include "tft.h"
#include "wires.h"
void init_drivers();
#endif /* ALL_H */

408
main/drivers/bottom_half.cpp
View File

@ -1,250 +1,33 @@
#include "bottom_half.h" #include "bottom_half.h"
#include <esp_log.h>
#include "state_tracking.h"
#include "starcode.h"
static const char *TAG = "bottom_half"; static const char *TAG = "bottom_half";
static uint16_t keypad_state; static uint16_t keypad_state;
static uint8_t button_state; static uint16_t button_state;
static uint8_t switch_state;
static uint8_t switch_touch_state;
static uint8_t touch_state; static uint8_t touch_state;
static uint16_t keypad_pressed; static uint16_t keypad_pressed;
static uint8_t button_pressed; static uint16_t button_pressed;
static uint8_t switch_flipped_up;
static uint8_t switch_touch_pressed;
static uint8_t touch_pressed; static uint8_t touch_pressed;
static uint16_t keypad_released; static uint16_t keypad_released;
static uint8_t button_released; static uint16_t button_released;
static uint8_t switch_flipped_down;
static uint8_t switch_touch_released;
static uint8_t touch_released; static uint8_t touch_released;
/// read buffer /// read buffer
static uint8_t buf[8]; static uint8_t buf[8];
static void poll_bottom_task(void *arg);
static void receive_keypad();
static void receive_button_switch();
static void receive_touch();
static bool replay_handler(const char* event, char* arg) {
// no reply neccesary
return false;
}
// TODO: add intrupt on bottom half delta pin
// static void IRAM_ATTR gpio_isr_handler(void* arg)
// {
// // TODO: do somthing
// ESP_LOGI("BOTTOM_HALF", "Hit");
// }
void init_bottom_half() {
ESP_LOGI(TAG, "Initializing bottom half...");
gpio_config_t int_conf = {
.pin_bit_mask = 1ULL << BOTTOM_PIN_INTERUPT,
.mode = GPIO_MODE_INPUT,
.pull_up_en = GPIO_PULLUP_ENABLE,
.pull_down_en = GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE,
};
ESP_ERROR_CHECK(gpio_config(&int_conf));
// TODO: do interupt stuff.
// ESP_ERROR_CHECK(gpio_intr_enable(BOTTOM_PIN_INTERUPT));
// ESP_ERROR_CHECK(gpio_install_isr_service(ESP_INTR_FLAG))
//install gpio isr service
// gpio_install_isr_service(0);
//hook isr handler for specific gpio pin
// gpio_isr_handler_add(BOTTOM_INTERUPT_PIN, gpio_isr_handler, NULL);
receive_keypad();
receive_button_switch();
receive_touch();
xTaskCreate(poll_bottom_task, "poll_bottom", 4096, NULL, 10, NULL);
register_replay_fn(replay_handler);
ESP_LOGI(TAG, "Bottom half initialized!");
}
static uint8_t receive_delta(void) {
uint8_t reg = 1;
xSemaphoreTake(main_i2c_mutex, portMAX_DELAY);
esp_err_t result = i2c_master_write_read_device(BOTTOM_I2C_NUM, BOTTOM_I2C_ADDR, &reg, 1, buf, 1, (100 / portTICK_PERIOD_MS));
ESP_ERROR_CHECK_WITHOUT_ABORT(result);
if (result != ESP_OK) {
return 0;
}
return buf[0];
}
static void receive_keypad(void) {
// TODO: change the bottom half polling scheme from a state-based protocol to an event based protocol
uint8_t reg = 2;
xSemaphoreTake(main_i2c_mutex, portMAX_DELAY);
esp_err_t result = i2c_master_write_read_device(BOTTOM_I2C_NUM, BOTTOM_I2C_ADDR, &reg, 1, buf, 2, (100 / portTICK_PERIOD_MS));
xSemaphoreGive(main_i2c_mutex);
ESP_ERROR_CHECK_WITHOUT_ABORT(result);
if (result != ESP_OK) {
return;
}
uint16_t new_keypad_state = buf[0] | (buf[1] << 8);
uint16_t just_pressed = new_keypad_state & ~keypad_state;
if (is_state_tracking() && just_pressed) {
char buf[6];
sprintf(buf, "%d", just_pressed);
event_occured("KP_PRESS", buf);
}
uint16_t just_released = ~new_keypad_state & keypad_state;
if (is_state_tracking() && just_released) {
char buf[6];
sprintf(buf, "%d", just_released);
event_occured("KP_RELEASE", buf);
}
star_code_handle_keypad(&just_pressed, &just_released);
keypad_pressed |= just_pressed;
keypad_released |= just_released;
keypad_state = new_keypad_state;
}
static void receive_button_switch(void) {
uint8_t reg = 3;
xSemaphoreTake(main_i2c_mutex, portMAX_DELAY);
esp_err_t result = i2c_master_write_read_device(BOTTOM_I2C_NUM, BOTTOM_I2C_ADDR, &reg, 1, buf, 2, (100 / portTICK_PERIOD_MS));
xSemaphoreGive(main_i2c_mutex);
ESP_ERROR_CHECK_WITHOUT_ABORT(result);
if (result != ESP_OK) {
return;
}
uint8_t new_button_state = buf[1] & 0xF;
uint8_t new_switch_state = (~buf[0]) & 0xF;
uint8_t new_switch_touch_state = (buf[1] >> 4) & 0xF;
// button
uint8_t just_pressed = new_button_state & ~button_state;
button_pressed |= just_pressed;
if (is_state_tracking() && just_pressed) {
char buf[4];
sprintf(buf, "%d", just_pressed);
event_occured("BTN_PRESS", buf);
}
uint8_t just_released = ~new_button_state & button_state;
button_released |= just_released;
if (is_state_tracking() && just_released) {
char buf[4];
sprintf(buf, "%d", just_released);
event_occured("BTN_RELEASE", buf);
}
button_state = new_button_state;
// switch
uint8_t just_flipped_up = new_switch_state & ~switch_state;
switch_flipped_up |= just_flipped_up;
if (is_state_tracking() && just_flipped_up) {
char buf[4];
sprintf(buf, "%d", just_flipped_up);
event_occured("SW_UP", buf);
}
uint8_t just_flipped_down = ~new_switch_state & switch_state;
switch_flipped_down |= just_flipped_down;
if (is_state_tracking() && just_flipped_down) {
char buf[4];
sprintf(buf, "%d", just_flipped_down);
event_occured("SW_DOWN", buf);
}
switch_state = new_switch_state;
// switch touch
uint8_t touch_just_pressed = new_switch_touch_state & ~switch_touch_state;
switch_touch_pressed |= touch_just_pressed;
if (is_state_tracking() && touch_just_pressed) {
char buf[4];
sprintf(buf, "%d", touch_just_pressed);
event_occured("SW_TOUCH", buf);
}
uint8_t touch_just_released = ~new_switch_touch_state & switch_touch_state;
switch_touch_released |= touch_just_released;
if (is_state_tracking() && touch_just_released) {
char buf[4];
sprintf(buf, "%d", touch_just_released);
event_occured("SW_UNTOUCH", buf);
}
switch_touch_state = new_switch_touch_state;
}
static void receive_touch(void) {
uint8_t reg = 4;
buf[0] = 0;
xSemaphoreTake(main_i2c_mutex, portMAX_DELAY);
ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_read_device(BOTTOM_I2C_NUM, BOTTOM_I2C_ADDR, &reg, 1, buf, 1, (100 / portTICK_PERIOD_MS)));
xSemaphoreGive(main_i2c_mutex);
bool new_touch_state = buf[0] != 0;
bool just_pressed = new_touch_state & !touch_state;
touch_pressed |= just_pressed;
if (is_state_tracking() && just_pressed) {
event_occured("FINGER_TOUCHED", NULL);
}
bool just_released = (!new_touch_state) & touch_state;
touch_released |= just_released;
if (is_state_tracking() && just_released) {
event_occured("FINGER_UNTOUCHED", NULL);
}
touch_state = new_touch_state;
}
static void poll_bottom_task(void *arg) {
// TODO: if using an interupt, switch this to use a queue
while (1) {
bool new_data = gpio_get_level(BOTTOM_PIN_INTERUPT) == 0;
if (new_data) {
uint8_t delta = receive_delta();
// ESP_LOGI(_TAG, "delta: %d", delta);
if (delta == 0) ESP_LOGW(TAG, "delta pin was low, but delta register returned 0");
if (delta & (1 << DELTA_BIT_KP)) receive_keypad();
if (delta & (1 << DELTA_BIT_BUTTON_SWITCH)) receive_button_switch();
if (delta & (1 << DELTA_BIT_TOUCH)) receive_touch();
}
vTaskDelay(pdMS_TO_TICKS(10));
}
vTaskDelete(NULL);
}
void clear_all_pressed_released(void) { void clear_all_pressed_released(void) {
keypad_pressed = 0; keypad_pressed = 0;
button_pressed = 0; button_pressed = 0;
switch_flipped_up = 0;
touch_pressed = 0; touch_pressed = 0;
keypad_released = 0; keypad_released = 0;
button_released = 0; button_released = 0;
switch_flipped_down = 0;
touch_released = 0; touch_released = 0;
} }
// TODO: this is public, but it won't need to be after the event-based protocol refactor static bool _take_key(KeypadKey* kp, uint16_t* keypad_bitfield) {
bool take_key(KeypadKey* kp, uint16_t* keypad_bitfield) {
for (int i = 0; i < 16; i++) { for (int i = 0; i < 16; i++) {
int bit_selector = (1 << i); int bit_selector = (1 << i);
if ((*keypad_bitfield) & bit_selector) { if ((*keypad_bitfield) & bit_selector) {
@ -259,11 +42,11 @@ bool take_key(KeypadKey* kp, uint16_t* keypad_bitfield) {
return false; return false;
} }
bool get_keypad_pressed(KeypadKey* kp) { bool get_pressed_keypad(KeypadKey* kp) {
return take_key(kp, &keypad_pressed); return _take_key(kp, &keypad_pressed);
} }
bool get_keypad_released(KeypadKey* kp) { bool get_released_keypad(KeypadKey* kp) {
return take_key(kp, &keypad_released); return _take_key(kp, &keypad_released);
} }
char char_of_keypad_key(KeypadKey kp) { char char_of_keypad_key(KeypadKey kp) {
@ -305,12 +88,9 @@ char char_of_keypad_key(KeypadKey kp) {
} }
} }
static bool _take_button(ButtonKey* button, uint8_t* button_bitfield) { static bool _take_button(ButtonKey* button, uint16_t* button_bitfield) {
if (((*button_bitfield) & 0xF) == 0) return false;
// scan the 4 button bits for one that is set
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
int bit_selector = (1 << i); int bit_selector = (1 << (i+8));
if ((*button_bitfield) & bit_selector) { if ((*button_bitfield) & bit_selector) {
if (button != nullptr) { if (button != nullptr) {
*button = (ButtonKey) i; *button = (ButtonKey) i;
@ -322,70 +102,56 @@ static bool _take_button(ButtonKey* button, uint8_t* button_bitfield) {
} }
return false; return false;
} }
static bool _take_switch(SwitchKey* switch_, uint8_t* switch_bitfield) { static bool _take_switch(SwitchKey* switch_, uint16_t* button_bitfield) {
if (((*switch_bitfield) & 0xF) == 0) return false;
// scan the 4 switch bits for one that is set
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
int bit_selector = (1 << i); int bit_selector = (1 << i);
if ((*switch_bitfield) & bit_selector) { if ((*button_bitfield) & bit_selector) {
if (switch_ != nullptr) { if (switch_ != nullptr) {
*switch_ = (SwitchKey) i; *switch_ = (SwitchKey) i;
} }
// clear bit // clear bit
*switch_bitfield &= ~bit_selector; *button_bitfield &= ~bit_selector;
return true; return true;
} }
} }
return false; return false;
} }
bool get_button_pressed(ButtonKey* button) { bool get_pressed_button(ButtonKey* button) {
return _take_button(button, &button_pressed); return _take_button(button, &button_pressed);
} }
bool get_button_released(ButtonKey* button) { bool get_released_button(ButtonKey* button) {
return _take_button(button, &button_released); return _take_button(button, &button_released);
} }
uint8_t get_button_state() { uint8_t get_button_state() {
return button_state; return (uint8_t)((button_state >> 8) & 0xF);
} }
bool get_switch_flipped_up(SwitchKey* switch_) { bool get_flipped_up_switch(SwitchKey* switch_) {
return _take_switch(switch_, &switch_flipped_up); return _take_switch(switch_, &button_released);
} }
bool get_switch_flipped_down(SwitchKey* switch_) { bool get_flipped_down_switch(SwitchKey* switch_) {
return _take_switch(switch_, &switch_flipped_down); return _take_switch(switch_, &button_released);
} }
bool get_switch_flipped(SwitchKey* switch_) { bool get_flipped_switch(SwitchKey* switch_) {
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
int bit_selector = (1 << i); int bit_selector = (1 << (i+4));
if ( if (button_pressed & bit_selector || button_released & bit_selector) {
((switch_flipped_up & bit_selector) != 0) ||
((switch_flipped_down & bit_selector) != 0)
) {
if (switch_ != nullptr) { if (switch_ != nullptr) {
*switch_ = (SwitchKey) i; *switch_ = (SwitchKey) i;
} }
// clear bit // clear bit
switch_flipped_up &= ~bit_selector; button_pressed &= ~bit_selector;
switch_flipped_down &= ~bit_selector; button_released &= ~bit_selector;
return true; return true;
} }
} }
return false; return false;
} }
uint8_t get_switch_state() {
return switch_state;
}
bool get_switch_touch_pressed(SwitchKey* switch_) { uint8_t get_switch_state() {
return _take_switch(switch_, &switch_touch_pressed); return (uint8_t)(~button_state & 0xF);
}
bool get_switch_touch_released(SwitchKey* switch_) {
return _take_switch(switch_, &switch_touch_released);
}
uint8_t get_switch_touch_state(){
return switch_touch_state;
} }
bool get_touch_state(void) { bool get_touch_state(void) {
@ -401,3 +167,121 @@ bool get_touch_released(void) {
touch_released = false; touch_released = false;
return return_; return return_;
} }
static void poll_bottom_task(void *arg);
static void receive_keypad(void);
static void receive_button(void);
static void receive_touch(void);
// static void IRAM_ATTR gpio_isr_handler(void* arg)
// {
// // TODO: do somthing
// ESP_LOGI("BOTTOM_HALF", "Hit");
// }
void init_bottom_half() {
i2c_config_t conf = {
.mode = I2C_MODE_MASTER,
.sda_io_num = GPIO_NUM_5,
.scl_io_num = GPIO_NUM_6,
.sda_pullup_en = GPIO_PULLUP_ENABLE,
.scl_pullup_en = GPIO_PULLUP_ENABLE,
.master = {
.clk_speed = 100000,
}
};
ESP_ERROR_CHECK(i2c_param_config(BOTTOM_I2C_NUM, &conf));
ESP_ERROR_CHECK(i2c_driver_install(BOTTOM_I2C_NUM, conf.mode, 0, 0, 0));
gpio_config_t delta_pin_conf = {};
// delta_pin_conf.intr_type = GPIO_INTR_LOW_LEVEL;
delta_pin_conf.mode = GPIO_MODE_INPUT;
// GPIO 0
delta_pin_conf.pin_bit_mask = (1ULL<<BOTTOM_PIN_INTERUPT);
delta_pin_conf.pull_up_en = GPIO_PULLUP_ENABLE;
gpio_config(&delta_pin_conf);
//install gpio isr service
// gpio_install_isr_service(0);
//hook isr handler for specific gpio pin
// gpio_isr_handler_add(BOTTOM_INTERUPT_PIN, gpio_isr_handler, NULL);
receive_keypad();
receive_button();
receive_touch();
xTaskCreate(poll_bottom_task, "poll_bottom", 4096, NULL, 10, NULL);
}
static uint8_t receive_delta(void) {
uint8_t reg = 1;
buf[0] = 0;
ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_read_device(BOTTOM_I2C_NUM, BOTTOM_I2C_ADDR, &reg, 1, buf, 1, (100 / portTICK_PERIOD_MS)));
return buf[0];
}
static void receive_keypad(void) {
uint8_t reg = 2;
buf[0] = 0;
buf[1] = 0;
ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_read_device(BOTTOM_I2C_NUM, BOTTOM_I2C_ADDR, &reg, 1, buf, 2, (100 / portTICK_PERIOD_MS)));
uint16_t new_keypad_state = buf[0] | (buf[1] << 8);
uint16_t just_pressed = new_keypad_state & ~keypad_state;
keypad_pressed |= just_pressed;
uint16_t just_released = ~new_keypad_state & keypad_state;
keypad_released |= just_released;
keypad_state = new_keypad_state;
}
static void receive_button(void) {
uint8_t reg = 3;
buf[0] = 0;
buf[1] = 0;
ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_read_device(BOTTOM_I2C_NUM, BOTTOM_I2C_ADDR, &reg, 1, buf, 2, (100 / portTICK_PERIOD_MS)));
uint16_t new_button_state = buf[0] | (buf[1] << 8);
uint16_t just_pressed = new_button_state & ~button_state;
button_pressed |= just_pressed;
uint16_t just_released = ~new_button_state & button_state;
button_released |= just_released;
button_state = new_button_state;
}
static void receive_touch(void) {
uint8_t reg = 4;
buf[0] = 0;
ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_read_device(BOTTOM_I2C_NUM, BOTTOM_I2C_ADDR, &reg, 1, buf, 1, (100 / portTICK_PERIOD_MS)));
bool new_touch_state = buf[0] != 0;
bool just_pressed = new_touch_state & !touch_state;
touch_pressed |= just_pressed;
bool just_released = (!new_touch_state) & touch_state;
touch_released |= just_released;
touch_state = new_touch_state;
}
static void poll_bottom_task(void *arg) {
while (1) {
bool new_data = gpio_get_level(BOTTOM_PIN_INTERUPT) == 0;
if (new_data) {
uint8_t delta = receive_delta();
// ESP_LOGI(_TAG, "delta: %d", delta);
if (delta == 0) ESP_LOGW(TAG, "delta pin was low, but delta register returned 0");
if (delta & (1 << DELTA_BIT_KP)) receive_keypad();
if (delta & (1 << DELTA_BIT_BUTTON)) receive_button();
if (delta & (1 << DELTA_BIT_TOUCH)) receive_touch();
}
vTaskDelay(pdMS_TO_TICKS(10));
}
vTaskDelete(NULL);
}

123
main/drivers/bottom_half.h
View File

@ -3,48 +3,42 @@
#include "driver/i2c.h" #include "driver/i2c.h"
#include "driver/gpio.h" #include "driver/gpio.h"
#include "esp_log.h"
#define BOTTOM_I2C_NUM I2C_NUM_0 #define BOTTOM_I2C_NUM I2C_NUM_0
#define BOTTOM_I2C_ADDR 126 #define BOTTOM_I2C_ADDR 126
#define BOTTOM_PIN_INTERUPT GPIO_NUM_13 #define BOTTOM_PIN_INTERUPT GPIO_NUM_0
#define DELTA_BIT_KP 0 #define DELTA_BIT_KP 0
#define DELTA_BIT_BUTTON_SWITCH 1 #define DELTA_BIT_BUTTON 1
#define DELTA_BIT_TOUCH 2 #define DELTA_BIT_TOUCH 2
/// @brief An enum for the possible keypad buttons.
typedef enum { typedef enum {
kd = 0, k1 = 0,
pound = 1, k4 = 1,
k0 = 2, k7 = 2,
star = 3, star = 3,
kc = 4, k2 = 4,
k9 = 5, k5 = 5,
k8 = 6, k8 = 6,
k7 = 7, k0 = 7,
kb = 8, k3 = 8,
k6 = 9, k6 = 9,
k5 = 10, k9 = 10,
k4 = 11, pound = 11,
ka = 12, ka = 12,
k3 = 13, kb = 13,
k2 = 14, kc = 14,
k1 = 15, kd = 15,
} KeypadKey; } KeypadKey;
/// @brief An enum for the possible buttons.
typedef enum { typedef enum {
b1 = 0, b1 = 0,
b2 = 1, b2 = 1,
b3 = 2, b3 = 2,
b4 = 3, b4 = 3,
button_green = 0,
button_red = 1,
button_yellow = 2,
button_blue = 3,
} ButtonKey; } ButtonKey;
/// @brief An enum for the possible switches.
typedef enum { typedef enum {
s1 = 0, s1 = 0,
s2 = 1, s2 = 1,
@ -52,88 +46,25 @@ typedef enum {
s4 = 3, s4 = 3,
} SwitchKey; } SwitchKey;
/// @brief Initializes communication with the bottom half. void clear_all_pressed_released(void);
void init_bottom_half();
/// Clears all pending pressed/released switches/buttons/keys/touch sensors. bool get_pressed_keypad(KeypadKey* kp);
void clear_all_pressed_released(); bool get_released_keypad(KeypadKey* kp);
/// @brief Gets the key that was just pressed (if any)
/// @param kp an OUT variable for the key that was pressed (if any)
/// @return true if there was a key that was just pressed
bool get_keypad_pressed(KeypadKey* kp);
/// @brief Gets the key that was just released (if any)
/// @param kp an OUT variable for the key that was released (if any)
/// @return true if there was a key that was just released
bool get_keypad_released(KeypadKey* kp);
/// @brief Converts a `KeypadKey` to a char
/// @param kp The value to convert
/// @return The char representing the key
char char_of_keypad_key(KeypadKey kp); char char_of_keypad_key(KeypadKey kp);
// TODO: add a get_keypad state?
bool get_pressed_button(ButtonKey* button);
/// @brief Gets the button that was just pressed (if any) bool get_released_button(ButtonKey* button);
/// @param button an OUT variable for the button that was pressed (if any)
/// @return true if there was a button that was just pressed
bool get_button_pressed(ButtonKey* button);
/// @brief Gets the button that was just released (if any)
/// @param button an OUT variable for the button that was released (if any)
/// @return true if there was a button that was just released
bool get_button_released(ButtonKey* button);
/// @brief Gets the raw state of the buttons b1-b4 as bitflags.
/// B1 is MSB and B4 is LSB.
/// @return Bitflags for b1-b4.
uint8_t get_button_state(); uint8_t get_button_state();
/// @brief Gets the switch that was just flipped up (if any) bool get_flipped_up_switch(SwitchKey* switch_);
/// @param switch_ an OUT variable for the switch that was flipped up (if any) bool get_flipped_down_switch(SwitchKey* switch_);
/// @return true if there was a switch that was just flipped up bool get_flipped_switch(SwitchKey* switch_);
bool get_switch_flipped_up(SwitchKey* switch_);
/// @brief Gets the switch that was just flipped down (if any)
/// @param switch_ an OUT variable for the switch that was flipped down (if any)
/// @return true if there was a switch that was just flipped down
bool get_switch_flipped_down(SwitchKey* switch_);
/// @brief Gets the switch that was just flipped (if any)
/// @param switch_ an OUT variable for the switch that was flipped (if any)
/// @return true if there was a switch that was just flipped
bool get_switch_flipped(SwitchKey* switch_);
/// @brief Gets the raw state of the switches s1-s4 as bitflags.
/// S1 is MSB and S4 is LSB.
/// @return Bitflags for s1-s4.
uint8_t get_switch_state(); uint8_t get_switch_state();
/// @brief Gets the switch that was just touched (if any) bool get_touch_state(void);
/// @param switch_ an OUT variable for the switch that was touched (if any) bool get_touch_pressed(void);
/// @return true if there was a switch that was just touched bool get_touch_released(void);
bool get_switch_touch_pressed(SwitchKey* switch_);
/// @brief Gets the switch that was just un-touched (if any)
/// @param switch_ an OUT variable for the switch that was un-touched (if any)
/// @return true if there was a switch that was just un-touched
bool get_switch_touch_released(SwitchKey* switch_);
/// @brief Gets the raw state of the touched switches s1-s4 as bitflags.
/// S1 is MSB and S4 is LSB.
/// @return Bitflags for the touched state of S1-S4.
uint8_t get_switch_touch_state();
/// @brief Gets the state of the fingerprint sensor void init_bottom_half();
/// @return true if the fingerprint sensor is touched
bool get_touch_state();
/// @brief Gets whether or not the touch sensor was just pressed
/// @return true if the touch sensor was just pressed
bool get_touch_pressed();
/// @brief Gets whether or not the touch sensor was just released
/// @return true if the touch sensor was just released
bool get_touch_released();
/// @brief A helper function for internal use.
///
/// Takes one key from the bitfield and sets the `kp` variable accordingly if the bitfield is not 0.
/// @param kp Out. The keypad key to set.
/// @param keypad_bitfield A pointer to the keypad bitfield to take a key from
/// @return true if a key was taken from the bitfield
bool take_key(KeypadKey* kp, uint16_t* keypad_bitfield);
// TODO: add touch sensor for switch
#endif /* BOTTOM_HALF_HPP */ #endif /* BOTTOM_HALF_HPP */

330
main/drivers/char_lcd.cpp
View File

@ -1,338 +1,14 @@
#include "char_lcd.h" #include "char_lcd.h"
#include "./i2c_lcd_pcf8574.h"
#include <esp_log.h>
#include "state_tracking.h"
#include <cstring>
#include "power.h"
#include "starcode.h"
#include "game_info.h"
i2c_lcd_pcf8574_handle_t lcd; i2c_lcd_pcf8574_handle_t lcd;
SemaphoreHandle_t lcd_mutex;
static volatile bool cursor_visible = false;
static volatile uint8_t cursor_resting_row = 0;
static volatile uint8_t cursor_resting_col = 0;
static volatile bool header_enabled = false;
static const char *TAG = "char_lcd"; static const char *TAG = "char_lcd";
static const char* EMPTY_ROW = " ";
static char buf[65];
// TODO: move this to power.cpp
static void monitor_battery_task(void* _arg) {
(void) _arg;
while (true) {
vTaskDelay(pdMS_TO_TICKS(1'000));
lcd_print_header_bat();
}
}
static bool replay_handler(const char* event, char* arg) {
if (strcmp(event, "LCD_CLEAR") == 0) {
lcd_clear();
}
else if (strcmp(event, "LCD_SET_DISPLAY") == 0) {
lcd_set_display(strcmp(arg, "true") == 0);
}
else if (strcmp(event, "LCD_CURSOR_VIS") == 0) {
lcd_set_cursor_vis(strcmp(arg, "true") == 0);
}
else if (strcmp(event, "LCD_CURSOR_BLINK") == 0) {
lcd_set_cursor_blink(strcmp(arg, "true") == 0);
}
else if (strcmp(event, "LCD_SCROLL_DISPLAY_LEFT") == 0) {
lcd_scroll_display_left();
}
else if (strcmp(event, "LCD_SCROLL_DISPLAY_RIGHT") == 0) {
lcd_scroll_display_right();
}
else if (strcmp(event, "LCD_LEFT_TO_RIGHT") == 0) {
lcd_left_to_right();
}
else if (strcmp(event, "LCD_RIGHT_TO_LEFT") == 0) {
lcd_right_to_left();
}
else if (strcmp(event, "LCD_AUTOSCROLL") == 0) {
lcd_set_autoscroll(strcmp(arg, "true") == 0);
}
else if (strcmp(event, "LCD_BACKLIGHT") == 0) {
lcd_set_backlight(strcmp(arg, "true") == 0);
}
else if (strcmp(event, "LCD_CREATE_CHAR") == 0) {
char* location_str = strtok(arg, ",");
uint8_t location = atoi(location_str);
uint8_t charmap[8];
for (int i = 0; i < 8; i++) {
char* str = strtok(NULL, ",");
charmap[i] = atoi(str);
}
lcd_create_char(location, charmap);
}
else if (strcmp(event, "LCD_PRINT") == 0) {
char* str = strtok(arg, ",");
uint8_t row = atoi(str);
str = strtok(NULL, ",");
uint8_t col = atoi(str);
// get remaining part of string.
str = strtok(NULL, "");
// TODO: handle \r and \n
lcd_print(row, col, str);
} else {
return false;
}
return true;
}
void init_lcd() {
ESP_LOGI(TAG, "Initializing LCD...");
lcd_mutex = xSemaphoreCreateMutex();
assert(lcd_mutex != NULL);
void init_char_lcd(void) {
lcd_init(&lcd, LCD_ADDR, CHAR_LCD_I2C_NUM); lcd_init(&lcd, LCD_ADDR, CHAR_LCD_I2C_NUM);
lcd_begin(&lcd, LCD_COLS, LCD_ROWS); lcd_begin(&lcd, LCD_COLS, LCD_ROWS);
lcd_set_backlight_to(&lcd, 1); lcd_set_backlight(&lcd, 255);
register_replay_fn(replay_handler); ESP_LOGI(TAG, "LCD initialized");
xTaskCreate(monitor_battery_task, "bat_monitor", 1024*2, nullptr, 0, nullptr);
ESP_LOGI(TAG, "LCD initialized!");
}
void lcd_clear(bool no_lock) {
if (!header_enabled) {
if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
lcd_clear(&lcd);
if (!no_lock) xSemaphoreGive(lcd_mutex);
if (is_state_tracking()) {
event_occured("LCD_CLEAR", NULL);
}
} else {
if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
lcd_print(1, 0, EMPTY_ROW, true);
lcd_print(2, 0, EMPTY_ROW, true);
lcd_print(3, 0, EMPTY_ROW, true);
if (!no_lock) xSemaphoreGive(lcd_mutex);
}
}
void lcd_set_display(bool display, bool no_lock) {
if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
if (display) {
lcd_display(&lcd);
} else {
lcd_no_display(&lcd);
}
if (!no_lock) xSemaphoreGive(lcd_mutex);
if (is_state_tracking()) {
event_occured("LCD_SET_DISPLAY", display ? "true" : "false");
}
}
void lcd_set_cursor_vis(bool cursor, bool no_lock) {
if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
if (cursor) {
lcd_cursor(&lcd);
} else {
lcd_no_cursor(&lcd);
}
if (!no_lock) xSemaphoreGive(lcd_mutex);
cursor_visible = cursor;
if (is_state_tracking()) {
event_occured("LCD_CURSOR_VIS", cursor ? "true" : "false");
}
}
void lcd_set_cursor_blink(bool blink, bool no_lock) {
if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
if (blink) {
lcd_blink(&lcd);
} else {
lcd_no_blink(&lcd);
}
if (!no_lock) xSemaphoreGive(lcd_mutex);
if (is_state_tracking()) {
event_occured("LCD_CURSOR_BLINK", blink ? "true" : "false");
}
}
void lcd_scroll_display_left(bool no_lock) {
if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
lcd_scroll_display_left(&lcd);
if (!no_lock) xSemaphoreGive(lcd_mutex);
if (is_state_tracking()) {
event_occured("LCD_SCROLL_DISPLAY_LEFT", NULL);
}
}
void lcd_scroll_display_right(bool no_lock) {
if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
lcd_scroll_display_right(&lcd);
if (!no_lock) xSemaphoreGive(lcd_mutex);
if (is_state_tracking()) {
event_occured("LCD_SCROLL_DISPLAY_RIGHT", NULL);
}
}
void lcd_left_to_right(bool no_lock) {
if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
lcd_left_to_right(&lcd);
if (!no_lock) xSemaphoreGive(lcd_mutex);
if (is_state_tracking()) {
event_occured("LCD_LEFT_TO_RIGHT", NULL);
}
}
void lcd_right_to_left(bool no_lock) {
if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
lcd_right_to_left(&lcd);
if (!no_lock) xSemaphoreGive(lcd_mutex);
if (is_state_tracking()) {
event_occured("LCD_RIGHT_TO_LEFT", NULL);
}
}
void lcd_set_autoscroll(bool autoscroll, bool no_lock) {
if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
if (autoscroll) {
lcd_autoscroll(&lcd);
} else {
lcd_no_autoscroll(&lcd);
}
if (!no_lock) xSemaphoreGive(lcd_mutex);
if (is_state_tracking()) {
event_occured("LCD_AUTOSCROLL", autoscroll ? "true" : "false");
}
}
void lcd_set_backlight(bool backlight, bool no_lock) {
if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
lcd_set_backlight_to(&lcd, backlight);
if (!no_lock) xSemaphoreGive(lcd_mutex);
if (is_state_tracking()) {
sprintf(buf, "%d", backlight);
event_occured("LCD_BACKLIGHT", backlight ? "true" : "false");
}
}
void lcd_create_char(uint8_t location, const uint8_t charmap[], bool no_lock) {
if (location == 8) location = 0;
if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
lcd_create_char(&lcd, location, charmap);
if (!no_lock) xSemaphoreGive(lcd_mutex);
if (is_state_tracking()) {
snprintf(buf, sizeof(buf),
"%d,%d,%d,%d,%d,%d,%d,%d,%d", location,
charmap[0], charmap[1], charmap[2], charmap[3], charmap[4], charmap[5], charmap[6], charmap[7]
);
event_occured("LCD_CREATE_CHAR", buf);
}
}
void lcd_print(uint8_t row, uint8_t col, const char* str, bool no_lock) {
if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
lcd_set_cursor(&lcd, col, row);
lcd_print(&lcd, str);
if (cursor_visible) {
lcd_set_cursor(&lcd, cursor_resting_col, cursor_resting_row);
}
if (!no_lock) xSemaphoreGive(lcd_mutex);
if (is_state_tracking()) {
// TODO: handle \r and \n and others
snprintf(buf, sizeof(buf), "%d,%d,%s", row, col, str);
event_occured("LCD_PRINT", buf);
}
}
void set_lcd_header_enabled(bool enable) {
bool old_header_enabled = header_enabled;
header_enabled = enable;
// update header in response to enabling/disabling the header
if (enable && !old_header_enabled) {
lcd_print_header();
} else if (!enable && old_header_enabled) {
lcd_print(0, 0, EMPTY_ROW);
}
}
bool lcd_header_enabled() {
return header_enabled;
}
void lcd_print_header() {
lcd_print_header_star_code();
lcd_print_header_step();
lcd_print_header_bat();
}
void lcd_do_splash() {
const uint8_t custom_char[6][8] = {
{ 0x01, 0x01, 0x02, 0x02, 0x07, 0x07, 0x0F, 0x0D },
{ 0x10, 0x10, 0x18, 0x18, 0x1C, 0x0C, 0x0E, 0x06 },
{ 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x07, 0x07 },
{ 0x19, 0x1B, 0x13, 0x17, 0x07, 0x0F, 0x0F, 0x1F },
{ 0x13, 0x1B, 0x1F, 0x1F, 0x00, 0x1F, 0x1F, 0x1F },
{ 0x00, 0x00, 0x10, 0x10, 0x00, 0x18, 0x1C, 0x1C },
};
// TODO: make the lcd_lib somehow support the custom character 0 which would otherwise be a null terminator
xSemaphoreTake(lcd_mutex, portMAX_DELAY);
lcd_create_char(1, custom_char[0], true);
lcd_create_char(2, custom_char[1], true);
lcd_create_char(3, custom_char[2], true);
lcd_create_char(4, custom_char[3], true);
lcd_create_char(5, custom_char[4], true);
lcd_create_char(6, custom_char[5], true);
lcd_print(1, 6, "\x01\x02Marino", true);
lcd_print(2, 5, "\x03\x04\x05\x06""DEV", true);
xSemaphoreGive(lcd_mutex);
}
bool lcd_lock(uint32_t ticks_to_wait) {
return xSemaphoreTake(lcd_mutex, ticks_to_wait);
}
void lcd_unlock() {
xSemaphoreGive(lcd_mutex);
}
void lcd_set_cursor_resting_position(uint8_t row, uint8_t col) {
cursor_resting_row = row;
cursor_resting_col = col;
}
void lcd_get_cursor_resting_position(uint8_t* row, uint8_t* col) {
if (row) *row = cursor_resting_row;
if (col) *col = cursor_resting_col;
}
bool lcd_is_cursor_visible() {
return cursor_visible;
} }

89
main/drivers/char_lcd.h
View File

@ -1,96 +1,17 @@
#ifndef CHAR_LCD_H #ifndef CHAR_LCD_H
#define CHAR_LCD_H #define CHAR_LCD_H
#include <cstdint> #include "i2c_lcd_pcf8574.h"
#include <esp_log.h>
#define CHAR_LCD_I2C_NUM I2C_NUM_0 #define CHAR_LCD_I2C_NUM I2C_NUM_0
#define LCD_ADDR 0x27 #define LCD_ADDR 0x27
#define LCD_ROWS 4
#define LCD_COLS 20 #define LCD_COLS 20
#define LCD_ROWS 4
/// @brief Initializes the 2004 Character LCD extern i2c_lcd_pcf8574_handle_t lcd;
void init_lcd();
/// @brief Clear the LCD void init_char_lcd(void);
void lcd_clear(bool no_lock = false);
/// @brief Move cursor to home position
void lcd_cursor_home(bool no_lock = false);
/// @brief Turn the display on/off
void lcd_set_display(bool display, bool no_lock = false);
/// @brief Turn the cursor's visibility on/off
void lcd_set_cursor_vis(bool cursor, bool no_lock = false);
/// @brief Turn blinking cursor on/off
void lcd_set_cursor_blink(bool blink, bool no_lock = false);
/// @brief Scroll the display left
void lcd_scroll_display_left(bool no_lock = false);
/// @brief Scroll the display right
void lcd_scroll_display_right(bool no_lock = false);
/// @brief Set the text to flows automatically left to right
void lcd_left_to_right(bool no_lock = false);
/// @brief Set the text to flows automatically right to left
void lcd_right_to_left(bool no_lock = false);
/// @brief Turn on/off autoscroll
void lcd_set_autoscroll(bool autoscroll, bool no_lock = false);
/// @brief Set backlight brightness
void lcd_set_backlight(bool backlight, bool no_lock = false);
/// @brief Create a custom character. You get 8 custom characters.
/// You can print custom characters by using escape characters in strings:
/// use '\x01' - '\x07' for custom characters 1-7. Use '\x08' for custom char 0.
void lcd_create_char(uint8_t location, const uint8_t charmap[], bool no_lock = false);
/// @brief Print a string to the LCD at a given pos.
/// @param row the row the print the string at.
/// @param col the column to print the string at.
/// @param str the string to print.
void lcd_print(uint8_t row, uint8_t col, const char* str, bool no_lock = false);
/// @brief Enables or disables the header on the LCD.
/// @param enable `true` to enable the header, `false` to disable.
void set_lcd_header_enabled(bool enable);
/// @brief Returns weather or not the lcd_header is enabled.
/// @return `true` if the header is enabled, `false` otherwise.
bool lcd_header_enabled();
/// @brief Prints the header in the LCD.
void lcd_print_header();
/// @brief Prints the splash screen for the BLK_BOX.
void lcd_do_splash();
/// @brief Locks the LCD to allow chaining multiple commands without interuptions.
///
/// Commands you call while you lock the LCD, you must call with the `no_lock` flag set to true.
///
/// Do not hold this lock for an extended period of time.
/// @return `true` iff the lock was aquired.
bool lcd_lock(uint32_t ticks_to_wait);
/// @brief Unlocks the LCD to give away the mutex access to it.
void lcd_unlock();
/// @brief Set the resting position for the cursor
/// @param row the row where the cursor should rest
/// @param col the column where the cursor should rest
void lcd_set_cursor_resting_position(uint8_t row, uint8_t col);
/// @brief Get the current resting position of the cursor
/// @param row pointer to store the resting row
/// @param col pointer to store the resting column
void lcd_get_cursor_resting_position(uint8_t* row, uint8_t* col);
/// @brief Check if the cursor is currently visible
/// @return true if cursor is visible, false otherwise
bool lcd_is_cursor_visible();
#endif /* CHAR_LCD_H */ #endif /* CHAR_LCD_H */

467
main/drivers/esp_lcd_ili9488/esp_lcd_ili9488.c
View File

@ -1,467 +0,0 @@
// Addapted from:
// https://github.com/atanisoft/esp_lcd_ili9488
/*
* SPDX-FileCopyrightText: 2022 atanisoft (github.com/atanisoft)
*
* SPDX-License-Identifier: MIT
*/
#include <driver/gpio.h>
#include <esp_lcd_panel_interface.h>
#include <esp_lcd_panel_io.h>
#include <esp_lcd_panel_vendor.h>
#include <esp_lcd_panel_ops.h>
#include <esp_lcd_panel_commands.h>
#include <esp_log.h>
#include <esp_rom_gpio.h>
#include <esp_check.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <memory.h>
#include <stdlib.h>
#include <sys/cdefs.h>
static const char *TAG = "ili9488";
typedef struct
{
uint8_t cmd;
uint8_t data[16];
uint8_t data_bytes;
} lcd_init_cmd_t;
typedef struct
{
esp_lcd_panel_t base;
esp_lcd_panel_io_handle_t io;
int reset_gpio_num;
bool reset_level;
int x_gap;
int y_gap;
uint8_t memory_access_control;
uint8_t color_mode;
size_t buffer_size;
uint8_t *color_buffer;
} ili9488_panel_t;
enum ili9488_constants
{
ILI9488_INTRFC_MODE_CTL = 0xB0,
ILI9488_FRAME_RATE_NORMAL_CTL = 0xB1,
ILI9488_INVERSION_CTL = 0xB4,
ILI9488_FUNCTION_CTL = 0xB6,
ILI9488_ENTRY_MODE_CTL = 0xB7,
ILI9488_POWER_CTL_ONE = 0xC0,
ILI9488_POWER_CTL_TWO = 0xC1,
ILI9488_POWER_CTL_THREE = 0xC5,
ILI9488_POSITIVE_GAMMA_CTL = 0xE0,
ILI9488_NEGATIVE_GAMMA_CTL = 0xE1,
ILI9488_ADJUST_CTL_THREE = 0xF7,
ILI9488_COLOR_MODE_16BIT = 0x55,
ILI9488_COLOR_MODE_18BIT = 0x66,
ILI9488_INTERFACE_MODE_USE_SDO = 0x00,
ILI9488_INTERFACE_MODE_IGNORE_SDO = 0x80,
ILI9488_IMAGE_FUNCTION_DISABLE_24BIT_DATA = 0x00,
ILI9488_WRITE_MODE_BCTRL_DD_ON = 0x28,
ILI9488_FRAME_RATE_60HZ = 0xA0,
ILI9488_INIT_LENGTH_MASK = 0x1F,
ILI9488_INIT_DONE_FLAG = 0xFF
};
static esp_err_t panel_ili9488_del(esp_lcd_panel_t *panel)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
if (ili9488->reset_gpio_num >= 0)
{
gpio_reset_pin(ili9488->reset_gpio_num);
}
if (ili9488->color_buffer != NULL)
{
heap_caps_free(ili9488->color_buffer);
}
ESP_LOGI(TAG, "del ili9488 panel @%p", ili9488);
free(ili9488);
return ESP_OK;
}
static esp_err_t panel_ili9488_reset(esp_lcd_panel_t *panel)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
esp_lcd_panel_io_handle_t io = ili9488->io;
if (ili9488->reset_gpio_num >= 0)
{
ESP_LOGI(TAG, "Setting GPIO:%d to %d", ili9488->reset_gpio_num,
ili9488->reset_level);
// perform hardware reset
gpio_set_level(ili9488->reset_gpio_num, ili9488->reset_level);
vTaskDelay(pdMS_TO_TICKS(10));
ESP_LOGI(TAG, "Setting GPIO:%d to %d", ili9488->reset_gpio_num,
!ili9488->reset_level);
gpio_set_level(ili9488->reset_gpio_num, !ili9488->reset_level);
vTaskDelay(pdMS_TO_TICKS(10));
}
else
{
ESP_LOGI(TAG, "Sending SW_RESET to display");
esp_lcd_panel_io_tx_param(io, LCD_CMD_SWRESET, NULL, 0);
vTaskDelay(pdMS_TO_TICKS(20));
}
return ESP_OK;
}
static esp_err_t panel_ili9488_init(esp_lcd_panel_t *panel)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
esp_lcd_panel_io_handle_t io = ili9488->io;
// ORIGINAL
lcd_init_cmd_t ili9488_init[] =
{
#if CONFIG_USE_NEW_DISPLAY
{ ILI9488_POSITIVE_GAMMA_CTL, { 0x00, 0x08, 0x0c, 0x02, 0x0e, 0x04, 0x30, 0x45, 0x47, 0x04, 0x0C, 0x0a, 0x2e, 0x34, 0x0F }, 15 },
{ ILI9488_NEGATIVE_GAMMA_CTL, { 0x00, 0x11, 0x0d, 0x01, 0x0f, 0x05, 0x39, 0x36, 0x51, 0x06, 0x0f, 0x0d, 0x33, 0x37, 0x0F }, 15 },
#else
{ ILI9488_POSITIVE_GAMMA_CTL, { 0x00, 0x03, 0x09, 0x08, 0x16, 0x0A, 0x3F, 0x78, 0x4C, 0x09, 0x0A, 0x08, 0x16, 0x1A, 0x0F }, 15 },
{ ILI9488_NEGATIVE_GAMMA_CTL, { 0x00, 0x16, 0x19, 0x03, 0x0F, 0x05, 0x32, 0x45, 0x46, 0x04, 0x0E, 0x0D, 0x35, 0x37, 0x0F }, 15 },
#endif /* CONFIG_USE_NEW_DISPLAY */
{ ILI9488_POWER_CTL_ONE, { 0x17, 0x15 }, 2 },
{ ILI9488_POWER_CTL_TWO, { 0x41 }, 1 },
{ ILI9488_POWER_CTL_THREE, { 0x00, 0x12, 0x80 }, 3 },
{ LCD_CMD_MADCTL, { ili9488->memory_access_control }, 1 },
{ LCD_CMD_COLMOD, { ili9488->color_mode }, 1 },
{ ILI9488_INTRFC_MODE_CTL, { ILI9488_INTERFACE_MODE_USE_SDO }, 1 },
{ ILI9488_FRAME_RATE_NORMAL_CTL, { ILI9488_FRAME_RATE_60HZ }, 1 },
{ ILI9488_INVERSION_CTL, { 0x02 }, 1 },
{ ILI9488_FUNCTION_CTL, { 0x02, 0x02, 0x3B }, 3},
{ ILI9488_ENTRY_MODE_CTL, { 0xC6 }, 1 },
{ ILI9488_ADJUST_CTL_THREE, { 0xA9, 0x51, 0x2C, 0x02 }, 4 },
{ LCD_CMD_NOP, { 0 }, ILI9488_INIT_DONE_FLAG },
};
// WITH CONSTS INLINED:
// lcd_init_cmd_t ili9488_init[] =
// {
// { 0xE0,
// { 0x00, 0x03, 0x09, 0x08, 0x16,
// 0x0A, 0x3F, 0x78, 0x4C, 0x09,
// 0x0A, 0x08, 0x16, 0x1A, 0x0F },
// 15
// },
// { 0xE1,
// { 0x00, 0x16, 0x19, 0x03, 0x0F,
// 0x05, 0x32, 0x45, 0x46, 0x04,
// 0x0E, 0x0D, 0x35, 0x37, 0x0F},
// 15
// },
// { 0xC0, { 0x17, 0x15 }, 2 },
// { 0xC1, { 0x41 }, 1 },
// { 0xC5, { 0x00, 0x12, 0x80 }, 3 },
// { 0x36, { ili9488->memory_access_control }, 1 },
// { 0x3A, { ili9488->color_mode }, 1 },
// { 0xB0, { ILI9488_INTERFACE_MODE_USE_SDO }, 1 },
// { 0xB1, { ILI9488_FRAME_RATE_60HZ }, 1 },
// { 0xB4, { 0x02 }, 1 },
// { 0xB6, { 0x02, 0x02, 0x3B }, 3},
// { 0xB7, { 0xC6 }, 1 },
// { 0xF7, { 0xA9, 0x51, 0x2C, 0x02 }, 4 },
// { 0x00, { 0 }, ILI9488_INIT_DONE_FLAG },
// };
// code from LCD manufacturer. (Not working):
// lcd_init_cmd_t ili9488_init[] = {
// { 0xF7, { 0xA9, 0x51, 0x2C, 0x82 }, 4 },
// { 0x36, { 0x48 }, 1 },
// { 0x3A, { 0x55 }, 1 },
// { 0xB4, { 0x02 }, 1 },
// { 0xB1, { 0xA0, 0x11 }, 2 },
// { 0xC0, { 0x0F, 0x0F }, 2 },
// { 0xC1, { 0x41 }, 1 },
// { 0xC2, { 0x22 }, 1 },
// { 0xB7, { 0xC6 }, 1 },
// { 0xc5, { 0x00, 0x53, 0x80 }, 3 },
// { 0xE0, { 0x00, 0x08, 0x0c, 0x02, 0x0e, 0x04, 0x30, 0x45, 0x47, 0x04, 0x0C, 0x0a, 0x2e, 0x34, 0x0F }, 15 },
// { 0xE1, { 0x00, 0x11, 0x0d, 0x01, 0x0f, 0x05, 0x39, 0x36, 0x51, 0x06, 0x0f, 0x0d, 0x33, 0x37, 0x0F }, 15 },
// { 0x21, { 0x00 }, 1 },
// { 0x3A, { 0x55 }, 1 },
// { LCD_CMD_NOP, { 0 }, ILI9488_INIT_DONE_FLAG },
// };
ESP_LOGI(TAG, "Initializing ILI9488");
int cmd = 0;
while ( ili9488_init[cmd].data_bytes != ILI9488_INIT_DONE_FLAG )
{
ESP_LOGD(TAG, "Sending CMD: %02x, len: %d", ili9488_init[cmd].cmd,
ili9488_init[cmd].data_bytes & ILI9488_INIT_LENGTH_MASK);
esp_lcd_panel_io_tx_param(
io, ili9488_init[cmd].cmd, ili9488_init[cmd].data,
ili9488_init[cmd].data_bytes & ILI9488_INIT_LENGTH_MASK);
cmd++;
}
// Take the display out of sleep mode.
esp_lcd_panel_io_tx_param(io, LCD_CMD_SLPOUT, NULL, 0);
vTaskDelay(pdMS_TO_TICKS(100));
// Turn on the display.
esp_lcd_panel_io_tx_param(io, LCD_CMD_DISPON, NULL, 0);
vTaskDelay(pdMS_TO_TICKS(100));
ESP_LOGI(TAG, "Initialization complete");
return ESP_OK;
}
#define SEND_COORDS(start, end, io, cmd) \
esp_lcd_panel_io_tx_param(io, cmd, (uint8_t[]) { \
(start >> 8) & 0xFF, \
start & 0xFF, \
((end - 1) >> 8) & 0xFF, \
(end - 1) & 0xFF, \
}, 4)
static esp_err_t panel_ili9488_draw_bitmap(
esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end,
const void *color_data)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
assert((x_start < x_end) && (y_start < y_end) &&
"starting position must be smaller than end position");
esp_lcd_panel_io_handle_t io = ili9488->io;
x_start += ili9488->x_gap;
x_end += ili9488->x_gap;
y_start += ili9488->y_gap;
y_end += ili9488->y_gap;
size_t color_data_len = (x_end - x_start) * (y_end - y_start);
SEND_COORDS(x_start, x_end, io, LCD_CMD_CASET);
SEND_COORDS(y_start, y_end, io, LCD_CMD_RASET);
// When the ILI9488 is used in 18-bit color mode we need to convert the
// incoming color data from RGB565 (16-bit) to RGB666.
//
// NOTE: 16-bit color does not work via SPI interface :(
if (ili9488->color_mode == ILI9488_COLOR_MODE_18BIT)
{
uint8_t *buf = ili9488->color_buffer;
uint16_t *raw_color_data = (uint16_t *) color_data;
for (uint32_t i = 0, pixel_index = 0; i < color_data_len; i++) {
buf[pixel_index++] = (uint8_t) (((raw_color_data[i] & 0xF800) >> 8) |
((raw_color_data[i] & 0x8000) >> 13));
buf[pixel_index++] = (uint8_t) ((raw_color_data[i] & 0x07E0) >> 3);
buf[pixel_index++] = (uint8_t) (((raw_color_data[i] & 0x001F) << 3) |
((raw_color_data[i] & 0x0010) >> 2));
}
esp_lcd_panel_io_tx_color(io, LCD_CMD_RAMWR, buf, color_data_len * 3);
}
else
{
// 16-bit color we can transmit as-is to the display.
esp_lcd_panel_io_tx_color(io, LCD_CMD_RAMWR, color_data, color_data_len * 2);
}
return ESP_OK;
}
#undef SEND_COORDS
static esp_err_t panel_ili9488_invert_color(
esp_lcd_panel_t *panel, bool invert_color_data)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
esp_lcd_panel_io_handle_t io = ili9488->io;
if (invert_color_data)
{
esp_lcd_panel_io_tx_param(io, LCD_CMD_INVON, NULL, 0);
}
else
{
esp_lcd_panel_io_tx_param(io, LCD_CMD_INVOFF, NULL, 0);
}
return ESP_OK;
}
static esp_err_t panel_ili9488_mirror(
esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
esp_lcd_panel_io_handle_t io = ili9488->io;
if (mirror_x)
{
ili9488->memory_access_control &= ~LCD_CMD_MX_BIT;
}
else
{
ili9488->memory_access_control |= LCD_CMD_MX_BIT;
}
if (mirror_y)
{
ili9488->memory_access_control |= LCD_CMD_MY_BIT;
}
else
{
ili9488->memory_access_control &= ~LCD_CMD_MY_BIT;
}
esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, &ili9488->memory_access_control, 1);
return ESP_OK;
}
static esp_err_t panel_ili9488_swap_xy(esp_lcd_panel_t *panel, bool swap_axes)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
esp_lcd_panel_io_handle_t io = ili9488->io;
if (swap_axes)
{
ili9488->memory_access_control |= LCD_CMD_MV_BIT;
}
else
{
ili9488->memory_access_control &= ~LCD_CMD_MV_BIT;
}
esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, &ili9488->memory_access_control, 1);
return ESP_OK;
}
static esp_err_t panel_ili9488_set_gap(
esp_lcd_panel_t *panel, int x_gap, int y_gap)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
ili9488->x_gap = x_gap;
ili9488->y_gap = y_gap;
return ESP_OK;
}
static esp_err_t panel_ili9488_disp_on_off(esp_lcd_panel_t *panel, bool on_off)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
esp_lcd_panel_io_handle_t io = ili9488->io;
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
// In ESP-IDF v4.x the API used false for "on" and true for "off"
// invert the logic to be consistent with IDF v5.x.
on_off = !on_off;
#endif
if (on_off)
{
esp_lcd_panel_io_tx_param(io, LCD_CMD_DISPON, NULL, 0);
}
else
{
esp_lcd_panel_io_tx_param(io, LCD_CMD_DISPOFF, NULL, 0);
}
// give time for the ILI9488 to recover after an on/off command
vTaskDelay(pdMS_TO_TICKS(100));
return ESP_OK;
}
esp_err_t esp_lcd_new_panel_ili9488(
const esp_lcd_panel_io_handle_t io,
const esp_lcd_panel_dev_config_t *panel_dev_config,
const size_t buffer_size,
esp_lcd_panel_handle_t *ret_panel)
{
esp_err_t ret = ESP_OK;
ili9488_panel_t *ili9488 = NULL;
ESP_GOTO_ON_FALSE(io && panel_dev_config && ret_panel, ESP_ERR_INVALID_ARG,
err, TAG, "invalid argument");
ili9488 = (ili9488_panel_t *)(calloc(1, sizeof(ili9488_panel_t)));
ESP_GOTO_ON_FALSE(ili9488, ESP_ERR_NO_MEM, err, TAG, "no mem for ili9488 panel");
if (panel_dev_config->reset_gpio_num >= 0)
{
gpio_config_t cfg;
memset(&cfg, 0, sizeof(gpio_config_t));
esp_rom_gpio_pad_select_gpio(panel_dev_config->reset_gpio_num);
cfg.pin_bit_mask = BIT64(panel_dev_config->reset_gpio_num);
cfg.mode = GPIO_MODE_OUTPUT;
ESP_GOTO_ON_ERROR(gpio_config(&cfg), err, TAG,
"configure GPIO for RESET line failed");
}
if (panel_dev_config->bits_per_pixel == 16)
{
ili9488->color_mode = ILI9488_COLOR_MODE_16BIT;
}
else
{
ESP_GOTO_ON_FALSE(buffer_size > 0, ESP_ERR_INVALID_ARG, err, TAG,
"Color conversion buffer size must be specified");
ili9488->color_mode = ILI9488_COLOR_MODE_18BIT;
// Allocate DMA buffer for color conversions
ili9488->color_buffer =
(uint8_t *)heap_caps_malloc(buffer_size * 3, MALLOC_CAP_DMA);
ESP_GOTO_ON_FALSE(ili9488->color_buffer, ESP_ERR_NO_MEM, err, TAG,
"Failed to allocate DMA color conversion buffer");
}
ili9488->memory_access_control = LCD_CMD_MX_BIT | LCD_CMD_BGR_BIT;
switch (panel_dev_config->color_space)
{
case ESP_LCD_COLOR_SPACE_RGB:
ESP_LOGI(TAG, "Configuring for RGB color order");
ili9488->memory_access_control &= ~LCD_CMD_BGR_BIT;
break;
case ESP_LCD_COLOR_SPACE_BGR:
ESP_LOGI(TAG, "Configuring for BGR color order");
break;
default:
ESP_GOTO_ON_FALSE(false, ESP_ERR_INVALID_ARG, err, TAG,
"Unsupported color mode!");
}
ili9488->io = io;
ili9488->reset_gpio_num = panel_dev_config->reset_gpio_num;
ili9488->reset_level = panel_dev_config->flags.reset_active_high;
ili9488->base.del = panel_ili9488_del;
ili9488->base.reset = panel_ili9488_reset;
ili9488->base.init = panel_ili9488_init;
ili9488->base.draw_bitmap = panel_ili9488_draw_bitmap;
ili9488->base.invert_color = panel_ili9488_invert_color;
ili9488->base.set_gap = panel_ili9488_set_gap;
ili9488->base.mirror = panel_ili9488_mirror;
ili9488->base.swap_xy = panel_ili9488_swap_xy;
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
ili9488->base.disp_off = panel_ili9488_disp_on_off;
#else
ili9488->base.disp_on_off = panel_ili9488_disp_on_off;
#endif
*ret_panel = &(ili9488->base);
ESP_LOGI(TAG, "new ili9488 panel @%p", ili9488);
return ESP_OK;
err:
if (ili9488)
{
if (panel_dev_config->reset_gpio_num >= 0)
{
gpio_reset_pin(panel_dev_config->reset_gpio_num);
}
if (ili9488->color_buffer != NULL)
{
heap_caps_free(ili9488->color_buffer);
}
free(ili9488);
}
return ret;
}

45
main/drivers/esp_lcd_ili9488/esp_lcd_ili9488.h
View File

@ -1,45 +0,0 @@
// Addapted from:
// https://github.com/atanisoft/esp_lcd_ili9488
/*
* SPDX-FileCopyrightText: 2022 atanisoft (github.com/atanisoft)
*
* SPDX-License-Identifier: MIT
*/
#pragma once
#include "esp_lcd_panel_vendor.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Create LCD panel for model ILI9488
*
* @param[in] io LCD panel IO handle
* @param[in] panel_dev_config general panel device configuration
* @param[in] buffer_size size of buffer to allocate for color conversions.
* @param[out] ret_panel Returned LCD panel handle
* @return
* - ESP_ERR_INVALID_ARG if parameter is invalid
* - ESP_ERR_NO_MEM if out of memory
* - ESP_OK on success
*
* NOTE: If you are using the SPI interface you *MUST* 18-bit color mode
* in @param panel_dev_config field bits_per_pixel and @param buffer_size
* must be provided.
*
* NOTE: For parallel IO (Intel 8080) interface 16-bit color mode should
* be used and @param buffer_size will be ignored.
*/
esp_err_t esp_lcd_new_panel_ili9488(const esp_lcd_panel_io_handle_t io,
const esp_lcd_panel_dev_config_t *panel_dev_config,
const size_t buffer_size,
esp_lcd_panel_handle_t *ret_panel);
#ifdef __cplusplus
}
#endif

21
main/drivers/game_info.cpp
View File

@ -1,21 +0,0 @@
#include "game_info.h"
#include "starcode.h"
#include <stdio.h>
#include "char_lcd.h"
static char game_state[GAME_STATE_MAX_LEN+2] = " MENU ";
void set_game_state(const char* new_state) {
snprintf(game_state, sizeof(game_state), " %-5s", new_state);
}
void reset_game_state() {
set_game_state("");
}
void lcd_print_header_step() {
if (!lcd_header_enabled()) return;
if (lcd_starcode_displaying_result()) return;
lcd_print(0, 10, game_state);
}

17
main/drivers/game_info.h
View File

@ -1,17 +0,0 @@
#ifndef GAME_INFO_H
#define GAME_INFO_H
#define GAME_STATE_MAX_LEN 5
/// @brief Sets the game state, used for the header.
///
/// Must be <= 5 characters
void set_game_state(const char* new_state);
/// @brief Resets the game state to be blank.
void reset_game_state();
/// @brief Prints the game state section of the header to the char_lcd. (row 0, columns 11-15)
void lcd_print_header_step();
#endif /* GAME_INFO_H */

39
main/drivers/game_timer.cpp
View File

@ -1,7 +1,4 @@
#include "game_timer.h" #include "game_timer.h"
#include <esp_log.h>
static const char* TAG = "game_timer";
static bool is_module_playing; static bool is_module_playing;
static bool is_game_playing; static bool is_game_playing;
@ -15,14 +12,6 @@ static uint32_t module_time_left;
static void game_timer_task(void *arg); static void game_timer_task(void *arg);
static uint32_t sat_sub(uint32_t x, uint32_t y); static uint32_t sat_sub(uint32_t x, uint32_t y);
void init_game_timers() {
ESP_LOGI(TAG, "Initializing game timers...");
xTaskCreate(game_timer_task, "game_timers", 4096, NULL, 10, NULL);
ESP_LOGI(TAG, "Game timers initialized!");
}
static void write_game_time(uint32_t millis) { static void write_game_time(uint32_t millis) {
if (millis > 60'000) { if (millis > 60'000) {
int disp_time = (millis / 60'000) * 100; int disp_time = (millis / 60'000) * 100;
@ -42,23 +31,27 @@ static void write_module_time(uint32_t millis) {
} }
} }
void start_game_timer() { void init_game_module_timer(void) {
xTaskCreate(game_timer_task, "game_module_timer", 4096, NULL, 10, NULL);
}
void start_game_timer(void) {
is_game_playing = true; is_game_playing = true;
} }
void stop_game_timer() { void stop_game_timer(void) {
is_game_playing = false; is_game_playing = false;
} }
void start_module_timer() { void start_module_timer(void) {
is_module_playing = true; is_module_playing = true;
} }
void stop_module_timer() { void stop_module_timer(void) {
is_module_playing = false; is_module_playing = false;
} }
void set_game_time(int32_t new_time) { void set_game_time(uint32_t new_time) {
if (new_time > 0) { if (new_time > 0) {
game_time_count_up = false; game_time_count_up = false;
game_time_left = new_time; game_time_left = new_time;
@ -69,12 +62,8 @@ void set_game_time(int32_t new_time) {
write_game_time(game_time_left); write_game_time(game_time_left);
} }
int32_t get_game_time() { uint32_t get_game_time() {
if (game_time_count_up) { return game_time_left;
return -((int32_t) game_time_left);
} else {
return ((int32_t) game_time_left);
}
} }
void set_module_time(uint32_t new_time) { void set_module_time(uint32_t new_time) {
@ -98,7 +87,8 @@ void time_penalty(uint32_t penalty) {
} }
} }
static void game_timer_task(void *arg) { static void game_timer_task(void *arg)
{
TickType_t lastWakeTime = xTaskGetTickCount(); TickType_t lastWakeTime = xTaskGetTickCount();
const uint32_t frequency = 100; const uint32_t frequency = 100;
@ -124,7 +114,8 @@ static void game_timer_task(void *arg) {
vTaskDelete(NULL); vTaskDelete(NULL);
} }
static uint32_t sat_sub(uint32_t x, uint32_t y) { static uint32_t sat_sub(uint32_t x, uint32_t y)
{
uint32_t res = x - y; uint32_t res = x - y;
res &= -(res <= x); res &= -(res <= x);
return res; return res;

14
main/drivers/game_timer.h
View File

@ -5,22 +5,22 @@
#include "sseg.h" #include "sseg.h"
/// Initializes the game and module timers. /// Initializes the game and module timers.
void init_game_timers(); void init_game_module_timer(void);
/// Starts the game timer /// Starts the game timer
void start_game_timer(); void start_game_timer(void);
/// Stops the game timer /// Stops the game timer
void stop_game_timer(); void stop_game_timer(void);
/// Starts the module timer /// Starts the module timer
void start_module_timer(); void start_module_timer(void);
/// Stops the module timer /// Stops the module timer
void stop_module_timer(); void stop_module_timer(void);
/// Sets the game time in ms /// Sets the game time in ms
void set_game_time(int32_t new_time); void set_game_time(uint32_t new_time);
/// Gets the current game time in ms /// Gets the current game time in ms
int32_t get_game_time(); uint32_t get_game_time();
/// Gets the current game time in ms /// Gets the current game time in ms
void time_penalty(uint32_t penalty); void time_penalty(uint32_t penalty);

494
main/drivers/hwdata.cpp
View File

@ -1,494 +0,0 @@
#include "hwdata.h"
#include "esp_err.h"
#include "esp_log.h"
#include "bottom_half.h"
#include "char_lcd.h"
#include "../helper.h"
#include "nvs.h"
static const char* TAG = "hwdata";
HWData::HWData()
: compat_mode(true)
{}
HWData::HWData(HWData1 data, bool compat_mode)
: compat_mode(compat_mode),
inner(data)
{}
esp_err_t HWData::save(nvs_handle_t handle, bool force) {
if (compat_mode && !force) {
ESP_LOGW(TAG, "Not saving due to being in compatability mode.");
return ESP_OK;
}
return inner.save(handle);
}
HWData HWData::load(nvs_handle_t handle) {
esp_err_t err;
uint16_t stored_version = 0;
err = nvs_get_u16(handle, "version", &stored_version);
if (err == ESP_ERR_NVS_NOT_FOUND) {
ESP_LOGE(TAG, "No NVS data found! using defaults");
return HWData();
} else if (err != ESP_OK) {
ESP_ERROR_CHECK_WITHOUT_ABORT(err);
ESP_LOGE(TAG, "Other esp error! using defaults");
return HWData();
}
HWData1 data;
switch (stored_version) {
case 0:
ESP_LOGE(TAG, "HWData version was 0! using defaults");
return HWData();
case 1:
data.load(handle);
return HWData(data, false);
default:
ESP_LOGW(TAG, "Max currently supported version is %d, but saved version is %d. Loading version %d anyway!", CURRENT_HWDATA_VERSION, stored_version, CURRENT_HWDATA_VERSION);
data.load(handle);
return HWData(data, true);
}
}
HWData1::HWData1() {}
esp_err_t HWData1::save(nvs_handle_t handle) const {
ESP_ERROR_CHECK(nvs_set_u16(handle, "version", 1));
// Serial number
ESP_ERROR_CHECK(nvs_set_str(handle, "serial_num", serial_num.c_str()));
// Revisions
ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_ctrl_maj", rev_ctrl_maj));
ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_ctrl_min", rev_ctrl_min));
ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_exp_maj", rev_exp_maj));
ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_exp_min", rev_exp_min));
ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_ft_maj", rev_ft_maj));
ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_ft_min", rev_ft_min));
ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_fb_maj", rev_fb_maj));
ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_fb_min", rev_fb_min));
// Enums
ESP_ERROR_CHECK(nvs_set_u8(handle, "sseg_color_t", static_cast<uint8_t>(sseg_color_t)));
ESP_ERROR_CHECK(nvs_set_u8(handle, "sseg_color_b", static_cast<uint8_t>(sseg_color_b)));
ESP_ERROR_CHECK(nvs_set_u8(handle, "lcd_color", static_cast<uint8_t>(lcd_color)));
ESP_ERROR_CHECK(nvs_set_u8(handle, "button_type", static_cast<uint8_t>(button_type)));
ESP_ERROR_CHECK(nvs_set_u8(handle, "tft_type", static_cast<uint8_t>(tft_type)));
ESP_ERROR_CHECK(nvs_set_u8(handle, "bat_type", static_cast<uint8_t>(bat_type)));
ESP_ERROR_CHECK(nvs_set_u8(handle, "shape1", static_cast<uint8_t>(shape1)));
ESP_ERROR_CHECK(nvs_set_u8(handle, "shape2", static_cast<uint8_t>(shape2)));
ESP_ERROR_CHECK(nvs_set_u8(handle, "shape3", static_cast<uint8_t>(shape3)));
ESP_ERROR_CHECK(nvs_set_u8(handle, "shape4", static_cast<uint8_t>(shape4)));
// Other fields
ESP_ERROR_CHECK(nvs_set_u8(handle, "switch_pos", switch_pos));
ESP_ERROR_CHECK(nvs_set_u8(handle, "has_speaker", has_speaker));
ESP_ERROR_CHECK(nvs_set_u8(handle, "has_mic", has_mic));
ESP_ERROR_CHECK(nvs_set_u8(handle, "has_ir", has_ir));
ESP_ERROR_CHECK(nvs_set_u8(handle, "has_rfid", has_rfid));
ESP_ERROR_CHECK(nvs_set_u8(handle, "has_fp", has_fp));
ESP_ERROR_CHECK(nvs_set_u8(handle, "has_fp_hall", has_fp_hall));
ESP_ERROR_CHECK(nvs_set_u8(handle, "has_close_hall", has_close_hall));
// Battery capacity
ESP_ERROR_CHECK(nvs_set_u16(handle, "bat_cap", bat_cap));
return nvs_commit(handle);
}
void HWData1::load(nvs_handle_t handle) {
char buf[128];
size_t required_size = sizeof(buf);
esp_err_t err = nvs_get_str(handle, "serial_num", buf, &required_size);
serial_num = (err == ESP_OK) ? std::string(buf) : "";
nvs_get_u8(handle, "rev_ctrl_maj", &rev_ctrl_maj);
nvs_get_u8(handle, "rev_ctrl_min", &rev_ctrl_min);
nvs_get_u8(handle, "rev_exp_maj", &rev_exp_maj);
nvs_get_u8(handle, "rev_exp_min", &rev_exp_min);
nvs_get_u8(handle, "rev_ft_maj", &rev_ft_maj);
nvs_get_u8(handle, "rev_ft_min", &rev_ft_min);
nvs_get_u8(handle, "rev_fb_maj", &rev_fb_maj);
nvs_get_u8(handle, "rev_fb_min", &rev_fb_min);
uint8_t tmp;
if (nvs_get_u8(handle, "sseg_color_t", &tmp) == ESP_OK) sseg_color_t = static_cast<SSegColor>(tmp);
if (nvs_get_u8(handle, "sseg_color_b", &tmp) == ESP_OK) sseg_color_b = static_cast<SSegColor>(tmp);
if (nvs_get_u8(handle, "lcd_color", &tmp) == ESP_OK) lcd_color = static_cast<LCDColor>(tmp);
if (nvs_get_u8(handle, "button_type", &tmp) == ESP_OK) button_type = static_cast<ButtonType>(tmp);
if (nvs_get_u8(handle, "tft_type", &tmp) == ESP_OK) tft_type = static_cast<TFTType>(tmp);
if (nvs_get_u8(handle, "bat_type", &tmp) == ESP_OK) bat_type = static_cast<BatType>(tmp);
nvs_get_u16(handle, "bat_cap", &bat_cap);
if (nvs_get_u8(handle, "shape1", &tmp) == ESP_OK) shape1 = static_cast<ShapeType>(tmp);
if (nvs_get_u8(handle, "shape2", &tmp) == ESP_OK) shape2 = static_cast<ShapeType>(tmp);
if (nvs_get_u8(handle, "shape3", &tmp) == ESP_OK) shape3 = static_cast<ShapeType>(tmp);
if (nvs_get_u8(handle, "shape4", &tmp) == ESP_OK) shape4 = static_cast<ShapeType>(tmp);
nvs_get_u8(handle, "switch_pos", &switch_pos);
nvs_get_u8(handle, "has_speaker", &tmp); has_speaker = tmp;
nvs_get_u8(handle, "has_mic", &tmp); has_mic = tmp;
nvs_get_u8(handle, "has_ir", &tmp); has_ir = tmp;
nvs_get_u8(handle, "has_rfid", &tmp); has_rfid = tmp;
nvs_get_u8(handle, "has_fp", &tmp); has_fp = tmp;
nvs_get_u8(handle, "has_fp_hall", &tmp); has_fp_hall = tmp;
nvs_get_u8(handle, "has_close_hall", &tmp); has_close_hall = tmp;
}
static void handle_uint8(KeypadKey key, uint8_t& val) {
char key_c = char_of_keypad_key(key);
bool is_digit = std::isdigit(static_cast<unsigned char>(key_c));
uint8_t digit = is_digit ? static_cast<uint8_t>(key_c - '0') : 0;
if (key == KeypadKey::star) {
val = 0;
} else if (is_digit) {
uint16_t new_digit = ((uint16_t) val) * 10 + (uint16_t) digit;
if (new_digit < 255) val = new_digit;
}
}
static void handle_uint16(KeypadKey key, uint16_t& val) {
char key_c = char_of_keypad_key(key);
bool is_digit = std::isdigit(static_cast<unsigned char>(key_c));
uint8_t digit = is_digit ? static_cast<uint8_t>(key_c - '0') : 0;
if (key == KeypadKey::star) {
val = 0;
} else if (is_digit) {
uint32_t new_digit = ((uint32_t) val) * 10 + (uint32_t) digit;
if (new_digit < 65535) val = new_digit;
}
}
static void handle_enum(ButtonKey key, uint8_t& val, uint8_t n_items) {
if (key == ButtonKey::b1) {
// dec
val = (val + n_items - 1) % n_items;
} else if (key == ButtonKey::b2) {
// inc
val = (val + 1) % n_items;
}
}
void hardware_config() {
clean_bomb();
uint8_t current_item = 0;
const uint8_t n_items = 28;
HWData1& hwdata = get_hw_data().inner;
ButtonKey btn;
KeypadKey key;
bool dirty = true;
while (true) {
if (dirty) {
// display
char name[21];
char value[21];
switch (current_item) {
case 0: // serial_num
snprintf(name, sizeof(name), "%-20s", "serial_num");
snprintf(value, sizeof(value), "%s", hwdata.serial_num.c_str());
break;
case 1: // rev_ctrl_maj
snprintf(name, sizeof(name), "%-20s", "rev_ctrl_maj");
snprintf(value, sizeof(value), "%d", hwdata.rev_ctrl_maj);
break;
case 2: // rev_ctrl_min
snprintf(name, sizeof(name), "%-20s", "rev_ctrl_min");
snprintf(value, sizeof(value), "%d", hwdata.rev_ctrl_min);
break;
case 3: // rev_exp_maj
snprintf(name, sizeof(name), "%-20s", "rev_exp_maj");
snprintf(value, sizeof(value), "%d", hwdata.rev_exp_maj);
break;
case 4: // rev_exp_min
snprintf(name, sizeof(name), "%-20s", "rev_exp_min");
snprintf(value, sizeof(value), "%d", hwdata.rev_exp_min);
break;
case 5: // rev_ft_maj
snprintf(name, sizeof(name), "%-20s", "rev_ft_maj");
snprintf(value, sizeof(value), "%d", hwdata.rev_ft_maj);
break;
case 6: // rev_ft_min
snprintf(name, sizeof(name), "%-20s", "rev_ft_min");
snprintf(value, sizeof(value), "%d", hwdata.rev_ft_min);
break;
case 7: // rev_fb_maj
snprintf(name, sizeof(name), "%-20s", "rev_fb_maj");
snprintf(value, sizeof(value), "%d", hwdata.rev_fb_maj);
break;
case 8: // rev_fb_min
snprintf(name, sizeof(name), "%-20s", "rev_fb_min");
snprintf(value, sizeof(value), "%d", hwdata.rev_fb_min);
break;
case 9: // sseg_color_t
snprintf(name, sizeof(name), "%-20s", "sseg_color_t");
snprintf(value, sizeof(value), "%s", SSEG_COLOR_NAMES[static_cast<uint8_t>(hwdata.sseg_color_t)]);
break;
case 10: // sseg_color_b
snprintf(name, sizeof(name), "%-20s", "sseg_color_b");
snprintf(value, sizeof(value), "%s", SSEG_COLOR_NAMES[static_cast<uint8_t>(hwdata.sseg_color_b)]);
break;
case 11: // lcd_color
snprintf(name, sizeof(name), "%-20s", "lcd_color");
snprintf(value, sizeof(value), "%s", LCD_COLOR_NAMES[static_cast<uint8_t>(hwdata.lcd_color)]);
break;
case 12: // switch_pos
snprintf(name, sizeof(name), "%-20s", "switch_pos");
snprintf(value, sizeof(value), "%d", hwdata.switch_pos);
break;
case 13: // button_type
snprintf(name, sizeof(name), "%-20s", "button_type");
snprintf(value, sizeof(value), "%s", BUTTON_TYPE_NAMES[static_cast<uint8_t>(hwdata.button_type)]);
break;
case 14: // tft_type
snprintf(name, sizeof(name), "%-20s", "tft_type");
snprintf(value, sizeof(value), "%s", TFT_TYPE_NAMES[static_cast<uint8_t>(hwdata.tft_type)]);
break;
case 15: // bat_type
snprintf(name, sizeof(name), "%-20s", "bat_type");
snprintf(value, sizeof(value), "%s", BAT_TYPE_NAMES[static_cast<uint8_t>(hwdata.bat_type)]);
break;
case 16: // bat_cap
snprintf(name, sizeof(name), "%-20s", "bat_cap");
snprintf(value, sizeof(value), "%d", hwdata.bat_cap);
break;
case 17: // shape1
snprintf(name, sizeof(name), "%-20s", "shape1");
snprintf(value, sizeof(value), "%s", SHAPE_TYPE_NAMES[static_cast<uint8_t>(hwdata.shape1)]);
break;
case 18: // shape2
snprintf(name, sizeof(name), "%-20s", "shape2");
snprintf(value, sizeof(value), "%s", SHAPE_TYPE_NAMES[static_cast<uint8_t>(hwdata.shape2)]);
break;
case 19: // shape3
snprintf(name, sizeof(name), "%-20s", "shape3");
snprintf(value, sizeof(value), "%s", SHAPE_TYPE_NAMES[static_cast<uint8_t>(hwdata.shape3)]);
break;
case 20: // shape4
snprintf(name, sizeof(name), "%-20s", "shape4");
snprintf(value, sizeof(value), "%s", SHAPE_TYPE_NAMES[static_cast<uint8_t>(hwdata.shape4)]);
break;
case 21: // has_speaker
snprintf(name, sizeof(name), "%-20s", "has_speaker");
snprintf(value, sizeof(value), "%s", hwdata.has_speaker ? "true" : "false");
break;
case 22: // has_mic
snprintf(name, sizeof(name), "%-20s", "has_mic");
snprintf(value, sizeof(value), "%s", hwdata.has_mic ? "true" : "false");
break;
case 23: // has_ir
snprintf(name, sizeof(name), "%-20s", "has_ir");
snprintf(value, sizeof(value), "%s", hwdata.has_ir ? "true" : "false");
break;
case 24: // has_rfid
snprintf(name, sizeof(name), "%-20s", "has_rfid");
snprintf(value, sizeof(value), "%s", hwdata.has_rfid ? "true" : "false");
break;
case 25: // has_fp
snprintf(name, sizeof(name), "%-20s", "has_fp");
snprintf(value, sizeof(value), "%s", hwdata.has_fp ? "true" : "false");
break;
case 26: // has_fp_hall
snprintf(name, sizeof(name), "%-20s", "has_fp_hall");
snprintf(value, sizeof(value), "%s", hwdata.has_fp_hall ? "true" : "false");
break;
case 27: // has_close_hall
snprintf(name, sizeof(name), "%-20s", "has_close_hall");
snprintf(value, sizeof(value), "%s", hwdata.has_close_hall ? "true" : "false");
break;
default:
break;
}
lcd_print(1, 0, name);
lcd_print(2, 0, value);
dirty = false;
}
if (get_button_pressed(&btn)) {
dirty = true;
switch (btn) {
case ButtonKey::b3: // dec
current_item = (current_item + n_items - 1) % n_items;
break;
case ButtonKey::b4: // inc
current_item = (current_item + 1) % n_items;
break;
default:
switch (current_item) {
case 9: // sseg_color_t
handle_enum(btn, reinterpret_cast<uint8_t&>(hwdata.sseg_color_t), SSEG_COLOR_COUNT);
break;
case 10: // sseg_color_b
handle_enum(btn, reinterpret_cast<uint8_t&>(hwdata.sseg_color_b), SSEG_COLOR_COUNT);
break;
case 11: // lcd_color
handle_enum(btn, reinterpret_cast<uint8_t&>(hwdata.lcd_color), LCD_COLOR_COUNT);
break;
case 13: // button_type
handle_enum(btn, reinterpret_cast<uint8_t&>(hwdata.button_type), BUTTON_TYPE_COUNT);
break;
case 14: // tft_type
handle_enum(btn, reinterpret_cast<uint8_t&>(hwdata.tft_type), TFT_TYPE_COUNT);
break;
case 15: // bat_type
handle_enum(btn, reinterpret_cast<uint8_t&>(hwdata.bat_type), BAT_TYPE_COUNT);
break;
case 17: // shape1
handle_enum(btn, reinterpret_cast<uint8_t&>(hwdata.shape1), SHAPE_TYPE_COUNT);
break;
case 18: // shape2
handle_enum(btn, reinterpret_cast<uint8_t&>(hwdata.shape2), SHAPE_TYPE_COUNT);
break;
case 19: // shape3
handle_enum(btn, reinterpret_cast<uint8_t&>(hwdata.shape3), SHAPE_TYPE_COUNT);
break;
case 20: // shape4
handle_enum(btn, reinterpret_cast<uint8_t&>(hwdata.shape4), SHAPE_TYPE_COUNT);
break;
case 21: // has_speaker
hwdata.has_speaker = btn == ButtonKey::button_green;
break;
case 22: // has_mic
hwdata.has_mic = btn == ButtonKey::button_green;
break;
case 23: // has_ir
hwdata.has_ir = btn == ButtonKey::button_green;
break;
case 24: // has_rfid
hwdata.has_rfid = btn == ButtonKey::button_green;
break;
case 25: // has_fp
hwdata.has_fp = btn == ButtonKey::button_green;
break;
case 26: // has_fp_hall
hwdata.has_fp_hall = btn == ButtonKey::button_green;
break;
case 27: // has_close_hall
hwdata.has_close_hall = btn == ButtonKey::button_green;
break;
default:
break;
}
break;
}
}
if (get_keypad_pressed(&key)) {
dirty = true;
if (key == KeypadKey::pound) {
// TODO: ask the user to save
return; // done
}
char key_c = char_of_keypad_key(key);
bool is_digit = std::isdigit(static_cast<unsigned char>(key_c));
uint8_t digit = is_digit ? static_cast<uint8_t>(key_c - '0') : 0;
// update the current value
switch (current_item) {
case 0: // serial_num
if (key == KeypadKey::star) {
hwdata.serial_num.clear();
} else {
hwdata.serial_num.push_back(char_of_keypad_key(key));
}
break;
case 1: // rev_ctrl_maj
handle_uint8(key, hwdata.rev_ctrl_maj);
break;
case 2: // rev_ctrl_min
handle_uint8(key, hwdata.rev_ctrl_min);
break;
case 3: // rev_exp_maj
handle_uint8(key, hwdata.rev_exp_maj);
break;
case 4: // rev_exp_min
handle_uint8(key, hwdata.rev_exp_min);
break;
case 5: // rev_ft_maj
handle_uint8(key, hwdata.rev_ft_maj);
break;
case 6: // rev_ft_min
handle_uint8(key, hwdata.rev_ft_min);
break;
case 7: // rev_fb_maj
handle_uint8(key, hwdata.rev_fb_maj);
break;
case 8: // rev_fb_min
handle_uint8(key, hwdata.rev_fb_min);
break;
case 12: // switch_pos
if (digit == 2 || digit == 3) hwdata.switch_pos = digit;
break;
case 16: // bat_cap
handle_uint16(key, hwdata.bat_cap);
break;
default:
break;
}
}
vTaskDelay(pdMS_TO_TICKS(10));
}
}

199
main/drivers/hwdata.h
View File

@ -1,199 +0,0 @@
#ifndef HWDATA_H
#define HWDATA_H
#include <string>
#include <cstdint>
#include <cstring>
#include "esp_err.h"
#include "nvs_flash.h"
#define CURRENT_HWDATA_VERSION 1
#define CURRENT_HWDATA_STRUCT HWData1
#define SSEG_COLOR_COUNT 10
static constexpr const char* SSEG_COLOR_NAMES[SSEG_COLOR_COUNT] = {
"UNKNOWN",
"NONE",
"OTHER",
"RED",
"ORANGE",
"YELLOW",
"GREEN",
"BLUE",
"PURPLE",
"WHITE"
};
enum class SSegColor : uint8_t {
UNKNOWN = 0,
NONE = 1,
OTHER = 2,
RED = 3,
ORANGE = 4,
YELLOW = 5,
GREEN = 6,
BLUE = 7,
PURPLE = 8,
WHITE = 9,
};
#define LCD_COLOR_COUNT 8
static constexpr const char* LCD_COLOR_NAMES[LCD_COLOR_COUNT] = {
"UNKNOWN",
"NONE",
"OTHER",
"BLACK_GREEN",
"WHITE_BLUE",
"BLACK_SKY",
"BLACK_WHITE",
"WHITE_BLACK"
};
enum class LCDColor : uint8_t {
UNKNOWN = 0,
NONE = 1,
OTHER = 2,
BLACK_GREEN = 3,
WHITE_BLUE = 4,
BLACK_SKY = 5,
BLACK_WHITE = 6,
WHITE_BLACK = 7,
};
#define BUTTON_TYPE_COUNT 6
static constexpr const char* BUTTON_TYPE_NAMES[BUTTON_TYPE_COUNT] = {
"UNKNOWN",
"NONE",
"OTHER",
"WHITE",
"BROWN",
"RED"
};
enum class ButtonType : uint8_t {
UNKNOWN = 0,
NONE = 1,
OTHER = 2,
WHITE = 3,
BROWN = 4,
RED = 5,
};
#define TFT_TYPE_COUNT 5
static constexpr const char* TFT_TYPE_NAMES[TFT_TYPE_COUNT] = {
"UNKNOWN",
"NONE",
"OTHER",
"EAST_RISING",
"SHENZHEN"
};
enum class TFTType : uint8_t {
UNKNOWN = 0,
NONE = 1,
OTHER = 2,
EAST_RISING = 3,
SHENZHEN = 4,
};
#define BAT_TYPE_COUNT 5
static constexpr const char* BAT_TYPE_NAMES[BAT_TYPE_COUNT] = {
"UNKNOWN",
"NONE",
"OTHER",
"BAT_18650",
"LIPO"
};
enum class BatType : uint8_t {
UNKNOWN = 0,
NONE = 1,
OTHER = 2,
BAT_18650 = 3,
LIPO = 4,
};
#define SHAPE_TYPE_COUNT 11
static constexpr const char* SHAPE_TYPE_NAMES[SHAPE_TYPE_COUNT] = {
"UNKNOWN",
"OTHER",
"CIRCLE",
"SQUARE",
"TRIANGLE",
"X",
"STAR",
"SPADE",
"DIAMOND",
"CLUB",
"HEART"
};
enum class ShapeType : uint8_t {
UNKNOWN = 0,
OTHER = 1,
CIRCLE = 2,
SQUARE = 3,
TRIANGLE = 4,
X = 5,
STAR = 6,
SPADE = 7,
DIAMOND = 8,
CLUB = 9,
HEART = 10,
};
/// @brief Version 1 of HWData, kept constant for migrations
struct HWData1 {
std::string serial_num;
uint8_t rev_ctrl_maj;
uint8_t rev_ctrl_min;
uint8_t rev_exp_maj;
uint8_t rev_exp_min;
uint8_t rev_ft_maj;
uint8_t rev_ft_min;
uint8_t rev_fb_maj;
uint8_t rev_fb_min;
SSegColor sseg_color_t;
SSegColor sseg_color_b;
LCDColor lcd_color;
uint8_t switch_pos;
ButtonType button_type;
TFTType tft_type;
BatType bat_type;
uint16_t bat_cap;
ShapeType shape1;
ShapeType shape2;
ShapeType shape3;
ShapeType shape4;
bool has_speaker;
bool has_mic;
bool has_ir;
bool has_rfid;
bool has_fp;
bool has_fp_hall;
bool has_close_hall;
HWData1();
esp_err_t save(nvs_handle_t handle) const;
void load(nvs_handle_t handle);
// Add migration method as necessary
};
/// @brief The current version of HWData, to be stored
struct HWData {
/// @brief `true` if there is some issue in loading, and we are doing a "best effort" to be compatible
/// We should make no writes to NVS if this is `true`.
volatile bool compat_mode;
HWData1 inner;
HWData();
HWData(HWData1 data, bool compat_mode);
esp_err_t save(nvs_handle_t handle, bool force = false);
static HWData load(nvs_handle_t handle);
};
void hardware_config();
#endif /* HWDATA_H */

35
main/drivers/i2c.cpp
View File

@ -1,35 +0,0 @@
#include "i2c.h"
#include "esp_log.h"
#include "esp_err.h"
#include "driver/i2c.h"
static const char *TAG = "i2c";
SemaphoreHandle_t main_i2c_mutex;
void init_i2c() {
ESP_LOGI(TAG, "Initializing i2c...");
i2c_config_t conf = {
.mode = I2C_MODE_MASTER,
.sda_io_num = PIN_I2C_SDA,
.scl_io_num = PIN_I2C_SCL,
.sda_pullup_en = GPIO_PULLUP_DISABLE,
.scl_pullup_en = GPIO_PULLUP_DISABLE,
// .sda_pullup_en = GPIO_PULLUP_ENABLE,
// .scl_pullup_en = GPIO_PULLUP_ENABLE,
.master = {
// TODO: 400k?
.clk_speed = 100*1000,
},
.clk_flags = I2C_SCLK_SRC_FLAG_FOR_NOMAL
};
ESP_ERROR_CHECK(i2c_param_config(MAIN_I2C_BUS_NUM, &conf));
ESP_ERROR_CHECK(i2c_driver_install(MAIN_I2C_BUS_NUM, conf.mode, 0, 0, 0));
main_i2c_mutex = xSemaphoreCreateMutex();
assert(main_i2c_mutex != NULL);
ESP_LOGI(TAG, "i2c initialized!");
}

26
main/drivers/i2c.h
View File

@ -1,26 +0,0 @@
#ifndef I2C_H
#define I2C_H
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#define MAIN_I2C_BUS_NUM I2C_NUM_0
#define PIN_I2C_SDA GPIO_NUM_7
#define PIN_I2C_SCL GPIO_NUM_15
/// The mutex for accessing `I2C_NUM_0`.
extern SemaphoreHandle_t main_i2c_mutex;
/// @brief Initializes `I2C_NUM_0`.
///
/// This is hooked up the to:
/// - The bottom half
/// - The char lcd
/// - The power board
/// - The MPU6050
/// - The PERH port
/// - The Capacitive Touch Panel
void init_i2c();
#endif /* I2C_H */

366
main/drivers/i2c_lcd_pcf8574.c
View File

@ -1,366 +0,0 @@
/// \file i2c_lcd_pcf8574.c
/// \brief Liquid Crystal display driver with PCF8574 adapter for esp-idf
///
/// \author Femi Olugbon, https://iamflinks.github.io
/// \copyright Copyright (c) 2024 by Femi Olugbon
///
/// ChangeLog see: i2c_lcd_pcf8574.h
#include <stdio.h>
#include "i2c_lcd_pcf8574.h"
#include "esp_log.h"
#include "esp_check.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "i2c.h"
#define TAG "I2C_LCD_PCF8574"
#define I2C_MASTER_TIMEOUT_MS 1000
// private functions
static void lcd_send(i2c_lcd_pcf8574_handle_t* lcd, uint8_t value, bool is_data);
static void lcd_write_nibble(i2c_lcd_pcf8574_handle_t* lcd, uint8_t half_byte, bool is_data, i2c_cmd_handle_t cmd);
static void lcd_write_i2c(i2c_lcd_pcf8574_handle_t* lcd, uint8_t data, bool is_data, bool enable);
void lcd_init(i2c_lcd_pcf8574_handle_t* lcd, uint8_t i2c_addr, i2c_port_t i2c_port) {
lcd->i2c_addr = i2c_addr;
lcd->i2c_port = i2c_port;
lcd->backlight = 0;
lcd->entrymode = 0x02; // Init the LCD with an internal reset
lcd->displaycontrol = 0x04;
lcd->rs_mask = 0x01;
lcd->rw_mask = 0x00;
lcd->enable_mask = 0x04;
lcd->data_mask[0] = 0x10;
lcd->data_mask[1] = 0x20;
lcd->data_mask[2] = 0x40;
lcd->data_mask[3] = 0x80;
lcd->backlight_mask = 0x08;
}
void lcd_begin(i2c_lcd_pcf8574_handle_t* lcd, uint8_t cols, uint8_t rows) {
// Ensure the cols and rows stay within max limit
lcd->cols = (cols > 80) ? 80 : cols;
lcd->lines = (rows > 4) ? 4 : rows;
lcd->row_offsets[0] = 0x00;
lcd->row_offsets[1] = 0x40;
lcd->row_offsets[2] = 0x00 + cols;
lcd->row_offsets[3] = 0x40 + cols;
// Initialize the LCD
lcd_write_i2c(lcd, 0x00, false, false);
esp_rom_delay_us(50000);
// This follows after the reset mode
lcd->displaycontrol = 0x04;
lcd->entrymode = 0x02;
// The following are the reset sequence: Please see "Initialization instruction in the PCF8574 datasheet."
xSemaphoreTake(main_i2c_mutex, portMAX_DELAY);
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
i2c_master_start(cmd);
// We left-shift the device addres and add the read/write command
i2c_master_write_byte(cmd, (lcd->i2c_addr << 1) | I2C_MASTER_WRITE, true);
lcd_write_nibble(lcd, 0x03, false, cmd);
i2c_master_stop(cmd);
i2c_master_cmd_begin(lcd->i2c_port, cmd, I2C_MASTER_TIMEOUT_MS / portTICK_PERIOD_MS);
i2c_cmd_link_delete(cmd);
esp_rom_delay_us(4500);
cmd = i2c_cmd_link_create();
i2c_master_start(cmd);
i2c_master_write_byte(cmd, (lcd->i2c_addr << 1) | I2C_MASTER_WRITE, true);
lcd_write_nibble(lcd, 0x03, false, cmd);
i2c_master_stop(cmd);
i2c_master_cmd_begin(lcd->i2c_port, cmd, I2C_MASTER_TIMEOUT_MS / portTICK_PERIOD_MS);
i2c_cmd_link_delete(cmd);
esp_rom_delay_us(200);
cmd = i2c_cmd_link_create();
i2c_master_start(cmd);
i2c_master_write_byte(cmd, (lcd->i2c_addr << 1) | I2C_MASTER_WRITE, true);
lcd_write_nibble(lcd, 0x03, false, cmd);
i2c_master_stop(cmd);
i2c_master_cmd_begin(lcd->i2c_port, cmd, I2C_MASTER_TIMEOUT_MS / portTICK_PERIOD_MS);
i2c_cmd_link_delete(cmd);
esp_rom_delay_us(200);
// Set the data interface to 4-bit interface (PCF8574 uses 4-bit interface)
cmd = i2c_cmd_link_create();
i2c_master_start(cmd);
i2c_master_write_byte(cmd, (lcd->i2c_addr << 1) | I2C_MASTER_WRITE, true);
lcd_write_nibble(lcd, 0x02, false, cmd);
i2c_master_stop(cmd);
i2c_master_cmd_begin(lcd->i2c_port, cmd, I2C_MASTER_TIMEOUT_MS / portTICK_PERIOD_MS);
i2c_cmd_link_delete(cmd);
xSemaphoreGive(main_i2c_mutex);
// Instruction: function set = 0x20
lcd_send(lcd, 0x20 | (rows > 1 ? 0x08 : 0x00), false);
// Set the display parameters (turn on display, clear, and set left to right)
lcd_display(lcd);
lcd_clear(lcd);
lcd_left_to_right(lcd);
} // lcd_begin()
// Clear the display content
void lcd_clear(i2c_lcd_pcf8574_handle_t* lcd) {
// Instruction: Clear display = 0x01
lcd_send(lcd, 0x01, false);
// Clearing the display takes a while: takes approx. 1.5ms
esp_rom_delay_us(2000);
} // lcd_clear()
// Set the display to home
void lcd_home(i2c_lcd_pcf8574_handle_t* lcd) {
// Instruction: Return home = 0x02
lcd_send(lcd, 0x02, false);
// Same as clearing the display: takes approx. 1.5ms
esp_rom_delay_us(2000);
} // lcd_home()
// Set the cursor to a new position.
void lcd_set_cursor(i2c_lcd_pcf8574_handle_t* lcd, uint8_t col, uint8_t row) {
// Check the display boundaries
if (row >= lcd->lines) {
row = lcd->lines - 1;
}
if (col >= lcd->cols) {
col = lcd->cols - 1;
}
// Instruction: Set DDRAM address = 080
lcd_send(lcd, 0x80 | (lcd->row_offsets[row] + col), false);
} // lcd_set_cursor()
// Turn off the display: fast operation
void lcd_no_display(i2c_lcd_pcf8574_handle_t* lcd) {
// Display Control: Display on/off control = 0x04
lcd->displaycontrol &= ~0x04;
// Instruction: Display mode: 0x08
lcd_send(lcd, 0x08 | lcd->displaycontrol, false);
} // lcd_no_display()
// Turn on the display: fast operation
void lcd_display(i2c_lcd_pcf8574_handle_t* lcd) {
// Display Control: Display on/off control = 0x04
lcd->displaycontrol |= 0x04;
// Instruction: Display mode: 0x08
lcd_send(lcd, 0x08 | lcd->displaycontrol, false);
} // lcd_display()
// Turn on the cursor
void lcd_cursor(i2c_lcd_pcf8574_handle_t* lcd) {
// Display Control: Cursor on/off control = 0x02
lcd->displaycontrol |= 0x02;
// Instruction: Display mode: 0x08
lcd_send(lcd, 0x08 | lcd->displaycontrol, false);
} // lcd_cursor()
// Turn off the cursor
void lcd_no_cursor(i2c_lcd_pcf8574_handle_t* lcd) {
// Display Control: Cursor on/off control = 0x02
lcd->displaycontrol &= ~0x02;
// Instruction: Display mode: 0x08
lcd_send(lcd, 0x08 | lcd->displaycontrol, false);
} // lcd_no_cursor()
// Turn on the blinking
void lcd_blink(i2c_lcd_pcf8574_handle_t* lcd) {
// Display Control: Blink on/off control = 0x01
lcd->displaycontrol |= 0x01;
// Instruction: Display mode: 0x08
lcd_send(lcd, 0x08 | lcd->displaycontrol, false);
} // lcd_blink()
// Turn off the blinking
void lcd_no_blink(i2c_lcd_pcf8574_handle_t* lcd) {
// Display Control: Blink on/off control = 0x01
lcd->displaycontrol &= ~0x01;
// Instruction: Display mode: 0x08
lcd_send(lcd, 0x08 | lcd->displaycontrol, false);
} // lcd_no_blink()
// This command will scroll the display left by one step without changing the RAM
void lcd_scroll_display_left(i2c_lcd_pcf8574_handle_t* lcd) {
// Instruction: Cursor or display shift - 0x10
// Instruction: Display mode: 0x08
// Control: Left shift control = 0x00
// 0x10 | 0x08 | 0x00 = 0x18
lcd_send(lcd, 0x18, false);
} // lcd_scroll_display_left()
// This command will scroll the display right by one step without changing the RAM
void lcd_scroll_display_right(i2c_lcd_pcf8574_handle_t* lcd) {
// Instruction: Cursor or display shift - 0x10
// Instruction: Display mode: 0x08
// Control: Left shift control = 0x04
// 0x10 | 0x08 | 0x04 = 0x1C
lcd_send(lcd, 0x1C, false);
} // lcd_scroll_display_right()
// Controlling the entry mode: This is for text that flows left to right
void lcd_left_to_right(i2c_lcd_pcf8574_handle_t* lcd) {
// Instruction: Entry mode set, set increment/decrement = 0x02
lcd->entrymode |= 0x02;
lcd_send(lcd, 0x04 | lcd->entrymode, false);
} // lcd_left_to_right()
// Controlling the entry mode: This is for text that flows right to left
void lcd_right_to_left(i2c_lcd_pcf8574_handle_t* lcd) {
// Instruction: Entry mode set, clear increment/decrement = 0x02
lcd->entrymode &= ~0x02;
lcd_send(lcd, 0x04 | lcd->entrymode, false);
} // lcd_right_to_left()
// This will justify the text to the right from the cursor
void lcd_autoscroll(i2c_lcd_pcf8574_handle_t* lcd) {
// Instruction: Entry mode set, set shift = 0x01
lcd->entrymode |= 0x01;
lcd_send(lcd, 0x04 | lcd->entrymode, false);
} // lcd_autoscroll()
// This will justify the text to the left from the cursor
void lcd_no_autoscroll(i2c_lcd_pcf8574_handle_t* lcd) {
// Instruction: Entry mode set, clear shift = 0x01
lcd->entrymode &= ~0x01;
lcd_send(lcd, 0x04 | lcd->entrymode, false);
} // lcd_no_autoscroll()
// Setting the backlight: It can only be turn on or off.
// Current backlight value is saved in the i2c_lcd_pcf8574_handle_t struct for further data transfers
void lcd_set_backlight_to(i2c_lcd_pcf8574_handle_t* lcd, uint8_t brightness) {
// Place the backlight value in the lcd struct
lcd->backlight = brightness;
// Send no data
lcd_write_i2c(lcd, 0x00, true, false);
} // lcd_set_backlight()
// Custom character creation: allows us to create up to 8 custom characters in the CGRAM locations
void lcd_create_char(i2c_lcd_pcf8574_handle_t* lcd, uint8_t location, const uint8_t charmap[]) {
location &= 0x7; // Only 8 locations are available
// Set the CGRAM address
lcd_send(lcd, 0x40 | (location << 3), false);
for (int i = 0; i < 8; i++) {
lcd_write(lcd, charmap[i]);
}
} // lcd_create_char()
// Write a byte to the LCD
void lcd_write(i2c_lcd_pcf8574_handle_t* lcd, uint8_t value) {
lcd_send(lcd, value, true);
} // lcd_write()
// Print characters to the LCD: cursor set or clear instruction must preceded this instruction, or it will write on the current text.
void lcd_print(i2c_lcd_pcf8574_handle_t* lcd, const char* str) {
while (*str) {
if (*str == '\x08') {
lcd_write(lcd, '\x00');
str++;
} else {
lcd_write(lcd, *str++);
}
}
} // lcd_print()
// Additional function to print numbers as formatted string
void lcd_print_number(i2c_lcd_pcf8574_handle_t* lcd, uint8_t col, uint8_t row, uint8_t buf_len, const char *str, ...) {
// Ensure the buffer length is greater than zero
if (buf_len == 0)
{
ESP_LOGE(TAG, "Buffer length must be greater than 0");
}
// Create a buffer to hold the characters
char buffer[buf_len];
va_list args;
va_start(args, str);
int chars_written = vsniprintf(buffer, buf_len, str, args);
va_end(args);
if (chars_written < 0) {
ESP_LOGE(TAG, "Encoding error in vsnprintf");
}
if ((size_t)chars_written >= buf_len) {
ESP_LOGW(TAG, "Buffer overflow: %d characters needed, but only %d available", chars_written + 1, buf_len);
}
lcd_set_cursor(lcd, col, row);
lcd_print(lcd, buffer);
} // lcd_print_number()
// Private functions: derived from the esp32 i2c_master driver
static void lcd_send(i2c_lcd_pcf8574_handle_t* lcd, uint8_t value, bool is_data) {
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
i2c_master_start(cmd);
i2c_master_write_byte(cmd, (lcd->i2c_addr << 1) | I2C_MASTER_WRITE, true);
xSemaphoreTake(main_i2c_mutex, portMAX_DELAY);
lcd_write_nibble(lcd, (value >> 4 & 0x0F), is_data, cmd);
lcd_write_nibble(lcd, (value & 0x0F), is_data, cmd);
i2c_master_stop(cmd);
esp_err_t ret = i2c_master_cmd_begin(lcd->i2c_port, cmd, I2C_MASTER_TIMEOUT_MS / portTICK_PERIOD_MS);
xSemaphoreGive(main_i2c_mutex);
i2c_cmd_link_delete(cmd);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to send data to LCD: %s", esp_err_to_name(ret));
}
} // lcd_send()
// Write a nibble / half byte with ACK
static void lcd_write_nibble(i2c_lcd_pcf8574_handle_t* lcd, uint8_t half_byte, bool is_data, i2c_cmd_handle_t cmd) {
// Map the data to the given pin connections
uint8_t data = is_data ? lcd->rs_mask : 0;
// Don't use rw_mask here
if (lcd->backlight > 0) {
data |= lcd->backlight_mask;
}
// Allow arbitrary pin configuration
if (half_byte & 0x01) data |= lcd->data_mask[0];
if (half_byte & 0x02) data |= lcd->data_mask[1];
if (half_byte & 0x04) data |= lcd->data_mask[2];
if (half_byte & 0x08) data |= lcd->data_mask[3];
i2c_master_write_byte(cmd, data | lcd->enable_mask, true);
i2c_master_write_byte(cmd, data, true);
} // lcd_write_nibble()
// Private function to change the PCF8574 pins to the given value.
static void lcd_write_i2c(i2c_lcd_pcf8574_handle_t* lcd, uint8_t data, bool is_data, bool enable) {
if (is_data) {
data |= lcd->rs_mask;
}
if (enable) {
data |= lcd->enable_mask;
}
if (lcd->backlight > 0) {
data |= lcd->backlight_mask;
}
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
i2c_master_start(cmd);
i2c_master_write_byte(cmd, (lcd->i2c_addr << 1) | I2C_MASTER_WRITE, true);
i2c_master_write_byte(cmd, data, true);
i2c_master_stop(cmd);
xSemaphoreTake(main_i2c_mutex, portMAX_DELAY);
esp_err_t ret = i2c_master_cmd_begin(lcd->i2c_port, cmd, I2C_MASTER_TIMEOUT_MS / portTICK_PERIOD_MS);
xSemaphoreGive(main_i2c_mutex);
i2c_cmd_link_delete(cmd);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to write to LCD: %s", esp_err_to_name(ret));
}
} // lcd_write_i2c()

112
main/drivers/i2c_lcd_pcf8574.h
View File

@ -1,112 +0,0 @@
/// \file i2c_lcd_pcf8574.h
/// \brief Liquid Crystal display driver with PCF8574 adapter for esp-idf
///
/// \author Femi Olugbon, https://iamflinks.github.io
/// \copyright Copyright (c) 2024 by Femi Olugbon
///
/// The library work is lincensed under a BSD style license.
///
/// \details
/// This library can drive a LCD based on the Hitachi's HD44790 display chip that is wired through a PCF8574 I2C converter. It uses the esp-idf i2c_driver component for communication. The library was adapted from the LiquidCrystal_PCF8574 (Mathias Hertel) and LiquidCrystal_I2C Arduino libraries.
///
///
/// ChangeLog:
/// ===========
/// * 07/22/2024 --> Created
/// * 07/23/2024 --> Added number printing functionality
///
#pragma once
#ifndef I2C_LCD_PCF8574_H
#define I2C_LCD_PCF8574_H
#include <stdint.h>
#include <stdbool.h>
#include "esp_err.h"
#include "driver/i2c.h"
#ifdef __cplusplus
extern "C" {
#endif
#define LCD_MAX_ROWS 4
typedef struct
{
uint8_t i2c_addr;
uint8_t backlight;
uint8_t cols;
uint8_t lines;
uint8_t entrymode;
uint8_t displaycontrol;
uint8_t row_offsets[LCD_MAX_ROWS];
uint8_t rs_mask;
uint8_t rw_mask;
uint8_t enable_mask;
uint8_t backlight_mask;
uint8_t data_mask[4];
i2c_port_t i2c_port;
} i2c_lcd_pcf8574_handle_t;
// Initialize the LCD
void lcd_init(i2c_lcd_pcf8574_handle_t* lcd, uint8_t i2c_addr, i2c_port_t i2c_port);
// Begin using the LCD
void lcd_begin(i2c_lcd_pcf8574_handle_t* lcd, uint8_t cols, uint8_t rows);
// Clear the LCD
void lcd_clear(i2c_lcd_pcf8574_handle_t* lcd);
// Move cursor to home position
void lcd_home(i2c_lcd_pcf8574_handle_t* lcd);
// Set cursor position
void lcd_set_cursor(i2c_lcd_pcf8574_handle_t* lcd, uint8_t col, uint8_t row);
// Turn the display on/off
void lcd_no_display(i2c_lcd_pcf8574_handle_t* lcd);
void lcd_display(i2c_lcd_pcf8574_handle_t* lcd);
// Turn the cursor on/off
void lcd_cursor(i2c_lcd_pcf8574_handle_t* lcd);
void lcd_no_cursor(i2c_lcd_pcf8574_handle_t* lcd);
// Turn blinking cursor on/off
void lcd_blink(i2c_lcd_pcf8574_handle_t* lcd);
void lcd_no_blink(i2c_lcd_pcf8574_handle_t* lcd);
// Scroll the display
void lcd_scroll_display_left(i2c_lcd_pcf8574_handle_t* lcd);
void lcd_scroll_display_right(i2c_lcd_pcf8574_handle_t* lcd);
// Set the direction for text that flows automatically
void lcd_left_to_right(i2c_lcd_pcf8574_handle_t* lcd);
void lcd_right_to_left(i2c_lcd_pcf8574_handle_t* lcd);
// Turn on/off autoscroll
void lcd_autoscroll(i2c_lcd_pcf8574_handle_t* lcd);
void lcd_no_autoscroll(i2c_lcd_pcf8574_handle_t* lcd);
// Set backlight brightness
void lcd_set_backlight_to(i2c_lcd_pcf8574_handle_t* lcd, uint8_t brightness);
// Create a custom character
void lcd_create_char(i2c_lcd_pcf8574_handle_t* lcd, uint8_t location, const uint8_t charmap[]);
// Write a character to the LCD
void lcd_write(i2c_lcd_pcf8574_handle_t* lcd, uint8_t value);
// Print a string to the LCD
void lcd_print(i2c_lcd_pcf8574_handle_t* lcd, const char* str);
void lcd_print_number(i2c_lcd_pcf8574_handle_t* lcd, uint8_t col, uint8_t row, uint8_t buf_len, const char *str, ...);
#ifdef __cplusplus
}
#endif // C++ extern
#endif // I2C_LCD_PCF8574_H

68
main/drivers/leds.cpp
View File

@ -1,36 +1,8 @@
#include "leds.h" #include "leds.h"
#include "led_strip.h"
#include <esp_log.h>
#include "state_tracking.h"
#include <cstring>
static const char* TAG = "leds"; led_strip_handle_t leds;
static led_strip_handle_t leds;
// TODO: rename these to playback_handler
static bool replay_handler(const char* event, char* arg) {
if (strcmp(event, "LED_SET") == 0) {
uint32_t led = atoi(strtok(arg, ","));
uint32_t color = atoi(strtok(NULL, ","));
led_set(led, color);
return true;
}
if (strcmp(event, "LED_FLUSH") == 0) {
leds_flush();
return true;
}
if (strcmp(event, "LED_CLR") == 0) {
leds_clear();
return true;
}
return false;
}
void init_leds() {
ESP_LOGI(TAG, "Initializing LEDs...");
void init_leds(void) {
led_strip_config_t strip_config = { led_strip_config_t strip_config = {
.strip_gpio_num = NEOPIXEL_PIN, .strip_gpio_num = NEOPIXEL_PIN,
.max_leds = LED_COUNT, .max_leds = LED_COUNT,
@ -45,39 +17,11 @@ void init_leds() {
rmt_config.flags.with_dma = false; rmt_config.flags.with_dma = false;
ESP_ERROR_CHECK(led_strip_new_rmt_device(&strip_config, &rmt_config, &leds)); ESP_ERROR_CHECK(led_strip_new_rmt_device(&strip_config, &rmt_config, &leds));
register_replay_fn(replay_handler);
ESP_LOGI(TAG, "LEDs initialized!");
} }
void led_set(uint32_t led, uint8_t r, uint8_t g, uint8_t b) { void example_leds(void) {
led_strip_set_pixel(leds, led, r, g, b); for (int i = 0; i < LED_COUNT; i++) {
ESP_ERROR_CHECK(led_strip_set_pixel(leds, i, i, LED_COUNT-i, 0));
if (is_state_tracking()) {
char buf[32];
uint32_t color = (r << 16) | (g << 8) | b;
sprintf(buf, "%ld,%ld", led, color);
event_occured("LED_SET", buf);
}
}
void led_set(uint32_t led, uint32_t color) {
led_set(led, (color >> 16) & 0xFF, (color >> 8) & 0xFF, color & 0xFF);
}
void leds_flush() {
led_strip_refresh(leds);
if (is_state_tracking()) {
event_occured("LED_FLUSH", NULL);
}
}
void leds_clear() {
led_strip_clear(leds);
if (is_state_tracking()) {
event_occured("LED_CLR", NULL);
} }
ESP_ERROR_CHECK(led_strip_refresh(leds));
} }

90
main/drivers/leds.h
View File

@ -1,74 +1,40 @@
#ifndef LEDS_H #ifndef LEDS_H
#define LEDS_H #define LEDS_H
#include <stdint.h> #include "led_strip.h"
#define LED_COUNT 21 #define LED_COUNT 21
#define NEOPIXEL_PIN GPIO_NUM_0 #define NEOPIXEL_PIN GPIO_NUM_7
// 10MHz resolution, 1 tick = 0.1us (led strip needs a high resolution) // 10MHz resolution, 1 tick = 0.1us (led strip needs a high resolution)
#define LED_STRIP_RMT_RES_HZ (10 * 1000 * 1000) #define LED_STRIP_RMT_RES_HZ (10 * 1000 * 1000)
enum LEDColor: uint32_t { extern led_strip_handle_t leds;
LED_COLOR_OFF = 0x00'00'00,
LED_COLOR_RED = 0x17'00'00,
LED_COLOR_RED_STRONG = 0xFF'00'00,
LED_COLOR_ORANGE = 0x17'02'00,
LED_COLOR_ORANGE_STRONG = 0xFF'20'00,
LED_COLOR_YELLOW = 0x07'07'00,
LED_COLOR_YELLOW_STRONG = 0xFF'FF'00,
LED_COLOR_GREEN = 0x00'07'00,
LED_COLOR_GREEN_STRONG = 0x00'FF'00,
LED_COLOR_BLUE = 0x00'00'17,
LED_COLOR_BLUE_STRONG = 0x00'00'FF,
LED_COLOR_PINK = 0x10'00'04,
LED_COLOR_PINK_STRONG = 0xFF'00'80,
LED_COLOR_WHITE = 0x04'04'04,
LED_COLOR_WHITE_STRONG = 0xFF'FF'FF,
};
// TODO: sepperate the indicator leds from the shape display. typedef enum {
enum IndicatorLED { shape1 = 0,
LED_SHAPE1 = 0u, shape2 = 1,
LED_SHAPE2 = 1u, shape3 = 2,
LED_SHAPE3 = 2u, shape4 = 3,
LED_SHAPE4 = 3u, module_sseg = 4,
LED_MODULE_SSEG = 4u, game_sseg = 5,
LED_GAME_SSEG = 5u, tft = 6,
LED_TFT = 6u, mic = 7,
LED_MIC = 7u, ir_led = 8,
LED_IR_LED = 8u, speaker = 9,
LED_SPEAKER = 9u, rfid = 10,
LED_RFID = 10u, keypad = 11,
LED_KEYPAD = 11u, char_lcd = 12,
LED_LCD = 12u, switch4 = 13,
LED_S4 = 13u, switch3 = 14,
LED_S3 = 14u, switch2 = 15,
LED_S2 = 15u, switch1 = 16,
LED_S1 = 16u, button4 = 17,
LED_B4 = 17u, button3 = 18,
LED_B3 = 18u, button2 = 19,
LED_B2 = 19u, button1 = 20,
LED_B1 = 20u, } Led;
LED_MAX = 20u,
};
/// @brief Initializes the indicator LEDs void init_leds(void);
void init_leds(); void example_leds(void);
/// Sets the color of an LED.
///
/// Call `flush_leds()` to send the data to the LEDs.
void led_set(uint32_t led, uint32_t color);
/// Sets the color of an LED with rgb.
///
/// Call `flush_leds()` to send the data to the LEDs.
void led_set(uint32_t led, uint8_t r, uint8_t g, uint8_t b);
/// Outputs the data to the leds.
void leds_flush();
/// Clears the LEDs
void leds_clear();
#endif /* LEDS_H */ #endif /* LEDS_H */

63
main/drivers/nvs.cpp
View File

@ -1,63 +0,0 @@
#include "nvs.h"
#include "esp_log.h"
#include "bottom_half.h"
#include "char_lcd.h"
static const char* TAG = "nvs";
static const char* HWDATA_NAMESPACE = "hwdata";
static HWData hw_data;
bool init_nvs() {
ESP_LOGI(TAG, "Initializing NVS...");
esp_err_t ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
// NVS partition was truncated, erase and retry
ESP_LOGE(TAG, "Failed to init nvs flash: %s.", esp_err_to_name(ret));
lcd_print(1, 0, "NVS: ");
lcd_print(1, 4, esp_err_to_name(ret));
lcd_print(2, 0, "Press Yellow to skip");
lcd_print(3, 0, "Press Red to erase");
ButtonKey button;
while (!( get_button_pressed(&button) && (button == ButtonKey::button_red || button == ButtonKey::button_yellow) )) vTaskDelay(pdMS_TO_TICKS(10));
lcd_clear();
if (button == ButtonKey::button_yellow) {
return false;
}
if (button == ButtonKey::button_red) {
ESP_ERROR_CHECK(nvs_flash_erase());
ret = nvs_flash_init();
}
}
ESP_ERROR_CHECK(ret);
nvs_handle_t hw_handle;
ret = nvs_open(HWDATA_NAMESPACE, NVS_READONLY, &hw_handle);
if (ret == ESP_ERR_NVS_NOT_FOUND) {
ESP_LOGW(TAG, "Partition \"%s\" has not been initialized. Loading defaults.", HWDATA_NAMESPACE);
hw_data = HWData();
} else {
ESP_ERROR_CHECK(ret);
hw_data = HWData::load(hw_handle);
nvs_close(hw_handle);
}
ESP_LOGI(TAG, "NVS initialized!");
return true;
}
HWData& get_hw_data() {
return hw_data;
}
void save_hw_data(bool force) {
nvs_handle_t hw_handle;
ESP_ERROR_CHECK(nvs_open(HWDATA_NAMESPACE, NVS_READWRITE, &hw_handle));
hw_data.save(hw_handle);
nvs_close(hw_handle);
}

13
main/drivers/nvs.h
View File

@ -1,13 +0,0 @@
#ifndef NVS_H
#define NVS_H
#include "nvs_flash.h"
#include "hwdata.h"
/// @brief Initializes the NVS.
bool init_nvs();
/// Gets the HWData stored in NVS.
HWData& get_hw_data();
#endif /* NVS_H */

2
main/drivers/perh.cpp
View File

@ -1,2 +0,0 @@
#include "perh.h"

12
main/drivers/perh.h
View File

@ -1,12 +0,0 @@
#ifndef PERH_H
#define PERH_H
#include "driver/gpio.h"
#define PIN_PERH0 GPIO_NUM_6
#define PIN_PERH1 GPIO_NUM_5
#define PIN_PERH2 GPIO_NUM_4
#define PIN_PERH3 GPIO_NUM_2
#define PIN_PERH4 GPIO_NUM_1
#endif /* PERH_H */

100
main/drivers/power.cpp
View File

@ -1,100 +0,0 @@
#include "power.h"
#include "char_lcd.h"
#include "starcode.h"
#include <esp_log.h>
static const char* TAG = "power";
void bat_monitor_task(void* arg) {
while (1) {
char str_buf[33] = {0};
uint16_t voltage = lipo.voltage();
sprintf(str_buf, "%d.%03dV", voltage / 1000, voltage % 1000);
lcd_clear();
lcd_print(0, 1, str_buf);
int16_t current = lipo.current();
sprintf(str_buf, "%dmA", current);
lcd_print(1, 1, str_buf);
int16_t total_cap = lipo.capacity(capacity_measure::FULL);
sprintf(str_buf, "%dmAh", total_cap);
lcd_print(2, 1, str_buf);
int16_t soc = lipo.soc(soc_measure::FILTERED);
sprintf(str_buf, "%d%%", soc);
lcd_print(3, 1, str_buf);
vTaskDelay(pdMS_TO_TICKS(250));
}
vTaskDelete(NULL);
}
void init_power_board() {
ESP_LOGI(TAG, "Initializing power board...");
if (!lipo.begin()) {
ESP_LOGE(TAG, "Failed to init communication with the battery gas guage");
return;
}
auto voltage = lipo.voltage();
ESP_LOGI(TAG, "Battery Voltage: %d", voltage);
ESP_LOGI(TAG, "Power board initialized!");
}
uint16_t get_bat_voltage() {
return lipo.voltage();
}
void lcd_print_header_bat() {
if (!lcd_header_enabled()) return;
if (lcd_starcode_displaying_result()) return;
uint8_t soc = lipo.soc();
int16_t current = lipo.current();
char buf[6];
if (soc < 5 && current <= 0) {
snprintf(buf, sizeof(buf), " LOW");
} else if (soc == 100) {
snprintf(buf, sizeof(buf), " 100");
} else {
if (current > 0) {
snprintf(buf, sizeof(buf), " %2d+", soc);
} else {
snprintf(buf, sizeof(buf), " %2d%%", soc);
}
}
lcd_print(0, 16, buf);
}
// memory version
// void lcd_print_header_bat() {
// if (!lcd_header_enabled()) return;
// if (lcd_starcode_displaying_result()) return;
// // Show memory usage percentage instead of battery percentage
// char buf[6];
// size_t free_heap = heap_caps_get_free_size(MALLOC_CAP_DEFAULT);
// size_t total_heap = heap_caps_get_total_size(MALLOC_CAP_DEFAULT);
// uint8_t mem_percent = 0;
// if (total_heap > 0) {
// mem_percent = (uint8_t)(100 - ((free_heap * 100) / total_heap));
// }
// if (mem_percent >= 100) {
// snprintf(buf, sizeof(buf), " 100");
// } else {
// snprintf(buf, sizeof(buf), " %2d%%", mem_percent);
// }
// lcd_print(0, 16, buf);
// }

20
main/drivers/power.h
View File

@ -1,20 +0,0 @@
#ifndef POWER_H
#define POWER_H
#include "SparkFunBQ27441/SparkFunBQ27441.h"
extern volatile uint32_t battery_charge;
void bat_monitor_task(void* arg);
/// Initializes the battery gas guage for getting battery stats.
void init_power_board();
/// @brief Gets the battery voltage.
/// @return battery voltage in mV.
uint16_t get_bat_voltage();
/// @brief Prints the battery section of the header to the char_lcd. (row 0, columns 17-19)
void lcd_print_header_bat();
#endif /* POWER_H */

98
main/drivers/sd.cpp
View File

@ -1,86 +1,74 @@
#include "sd.h" #include "sd.h"
#include "char_lcd.h"
#include "bottom_half.h"
sdmmc_card_t *card; sdmmc_card_t *card;
static const char* mount_point = MOUNT_POINT; static const char* mount_point = MOUNT_POINT;
static const char* TAG = "sd"; static const char* TAG = "sd";
bool init_sd() { void init_sd() {
ESP_LOGI(TAG, "Initializing SD card...");
esp_err_t ret; esp_err_t ret;
// Options for mounting the filesystem.
// If format_if_mount_failed is set to true, SD card will be partitioned and
// formatted in case when mounting fails.
esp_vfs_fat_sdmmc_mount_config_t mount_config = { esp_vfs_fat_sdmmc_mount_config_t mount_config = {
.format_if_mount_failed = false, .format_if_mount_failed = false,
.max_files = 8, .max_files = 5,
.allocation_unit_size = 16 * 1024, .allocation_unit_size = 16 * 1024,
.disk_status_check_enable = true, .disk_status_check_enable = false,
.use_one_fat = false,
}; };
ESP_LOGI(TAG, "Initializing SD card");
// Use settings defined above to initialize SD card and mount FAT filesystem.
// Note: esp_vfs_fat_sdmmc/sdspi_mount is all-in-one convenience functions.
// Please check its source code and implement error recovery when developing
// production applications.
ESP_LOGI(TAG, "Using SDMMC peripheral"); ESP_LOGI(TAG, "Using SDMMC peripheral");
sdmmc_host_t host = SDMMC_HOST_DEFAULT(); sdmmc_host_t host = SDMMC_HOST_DEFAULT();
sdmmc_slot_config_t slot_config = { // This initializes the slot without card detect (CD) and write protect (WP) signals.
.clk = SD_PIN_CLK, // Modify slot_config.gpio_cd and slot_config.gpio_wp if your board has these signals.
.cmd = SD_PIN_CMD, sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
.d0 = SD_PIN_D0,
.d1 = SD_PIN_D1, // Set bus width to use:
.d2 = SD_PIN_D2, slot_config.width = 4;
.d3 = SD_PIN_D3,
.d4 = GPIO_NUM_NC, // On chips where the GPIOs used for SD card can be configured, set them in
.d5 = GPIO_NUM_NC, // the slot_config structure:
.d6 = GPIO_NUM_NC, slot_config.clk = SD_PIN_CLK;
.d7 = GPIO_NUM_NC, slot_config.cmd = SD_PIN_CMD;
.cd = GPIO_NUM_NC, slot_config.d0 = SD_PIN_D0;
.wp = GPIO_NUM_NC, slot_config.d1 = SD_PIN_D1;
.width = 4, slot_config.d2 = SD_PIN_D2;
.flags = 0 slot_config.d3 = SD_PIN_D3;
// .flags = SDMMC_SLOT_FLAG_INTERNAL_PULLUP
}; // Enable internal pullups on enabled pins. The internal pullups
// are insufficient however, please make sure 10k external pullups are
// connected on the bus. This is for debug / example purpose only.
slot_config.flags |= SDMMC_SLOT_FLAG_INTERNAL_PULLUP;
try_mount:
ESP_LOGI(TAG, "Mounting filesystem"); ESP_LOGI(TAG, "Mounting filesystem");
ret = esp_vfs_fat_sdmmc_mount(mount_point, &host, &slot_config, &mount_config, &card); ret = esp_vfs_fat_sdmmc_mount(mount_point, &host, &slot_config, &mount_config, &card);
if (ret == ESP_OK) { if (ret != ESP_OK) {
ESP_LOGI(TAG, "Filesystem mounted"); if (ret == ESP_FAIL) {
} else { ESP_LOGE(TAG, "Failed to mount filesystem. "
ESP_LOGE(TAG, "Failed to mount sd card: %s.", esp_err_to_name(ret)); "If you want the card to be formatted, set the EXAMPLE_FORMAT_IF_MOUNT_FAILED menuconfig option.");
} else {
lcd_print(0, 0, "SD: "); ESP_LOGE(TAG, "Failed to initialize the card (%s). "
lcd_print(0, 4, esp_err_to_name(ret)); "Make sure SD card lines have pull-up resistors in place.", esp_err_to_name(ret));
lcd_print(1, 0, "Press Green to retry");
lcd_print(2, 0, "Press Yellow to skip");
lcd_print(3, 0, "Press Red to format");
ButtonKey button;
while (!( get_button_pressed(&button) && (button == ButtonKey::button_green || button == ButtonKey::button_red || button == ButtonKey::button_yellow) )) vTaskDelay(pdMS_TO_TICKS(10));
lcd_clear();
if (button == ButtonKey::button_green) {
goto try_mount;
}
if (button == ButtonKey::button_yellow) {
return false;
}
if (button == ButtonKey::button_red) {
mount_config.format_if_mount_failed = true;
goto try_mount;
} }
return;
} }
ESP_LOGI(TAG, "Filesystem mounted");
// Card has been initialized, print its properties // Card has been initialized, print its properties
sdmmc_card_print_info(stdout, card); sdmmc_card_print_info(stdout, card);
ESP_LOGI(TAG, "SD card initialized!");
return true;
} }
void deinit_sd() { void deinit_sd() {
ESP_ERROR_CHECK_WITHOUT_ABORT(esp_vfs_fat_sdcard_unmount(mount_point, card)); esp_vfs_fat_sdcard_unmount(mount_point, card);
ESP_LOGI(TAG, "Card unmounted"); ESP_LOGI(TAG, "Card unmounted");
} }

22
main/drivers/sd.h
View File

@ -8,24 +8,18 @@
#include "sdmmc_cmd.h" #include "sdmmc_cmd.h"
#include "driver/sdmmc_host.h" #include "driver/sdmmc_host.h"
#define MOUNT_POINT "/sd" #define MOUNT_POINT "/sdcard"
extern sdmmc_card_t *card; extern sdmmc_card_t *card;
#define SD_PIN_CLK GPIO_NUM_39 #define SD_PIN_CLK GPIO_NUM_48
#define SD_PIN_CMD GPIO_NUM_40 #define SD_PIN_CMD GPIO_NUM_45
#define SD_PIN_D0 GPIO_NUM_38 #define SD_PIN_D0 GPIO_NUM_47
#define SD_PIN_D1 GPIO_NUM_45 #define SD_PIN_D1 GPIO_NUM_21
#define SD_PIN_D2 GPIO_NUM_42 #define SD_PIN_D2 GPIO_NUM_39
#define SD_PIN_D3 GPIO_NUM_41 #define SD_PIN_D3 GPIO_NUM_38
/// @brief Initializes the SD card void init_sd();
///
/// This requires the char_lcd to have been initialized.
/// @return true if the sd card was successfully initialized
bool init_sd();
/// @brief Unmounts the sd card
void deinit_sd(); void deinit_sd();
#endif /* SD_H */ #endif /* SD_H */

353
main/drivers/speaker.cpp
View File

@ -1,261 +1,136 @@
#include "speaker.h" #include "speaker.h"
#include "state_tracking.h"
static const char *TAG = "speaker";
static size_t audio_block_size = 4096;
typedef struct {
/// The path to the file being played.
char* file_name;
/// The handle to the file being played.
FILE* file_handle;
/// A number that all samples will be shifted right by.
uint8_t prescaler;
/// A flag for repeating.
bool repeat;
} playing_audio_clip_t;
// It's hard to get the tx_chan's internal state, so instead, we keep track of it here.
bool channel_enabled = false;
i2s_chan_handle_t tx_chan; i2s_chan_handle_t tx_chan;
/// A queue of owned `char*` to be stopped from playing. static const char *TAG = "speaker_driver";
///
/// the speaker driver system will free the given char* when it is done with it.
QueueHandle_t stop_clip_queue;
/// A queue of `audio_clip_t`s to be played once there is nothing being played
QueueHandle_t play_clip_queue;
/// The clips that are currently playing esp_err_t play_raw_stop_queue(const char *fp, QueueHandle_t stop_handle) {
std::vector<playing_audio_clip_t> playing_clips; FILE *fh = fopen(fp, "rb");
if (fh == NULL)
{
ESP_LOGE(TAG, "Failed to open file");
return ESP_ERR_INVALID_ARG;
}
static bool replay_handler(const char* event, char* arg) { // create a writer buffer
if (strcmp(event, "PLAY_WAV") == 0) { uint8_t *read_buf = (uint8_t*) calloc(AUDIO_BUFFER, sizeof(uint8_t));
char* file_name = strtok(arg, ":"); uint16_t *write_buf = (uint16_t*) calloc(AUDIO_BUFFER, sizeof(uint16_t));
char* play_immediately_str = strtok(NULL, ":"); size_t bytes_read = 0;
char* repeat_str = strtok(NULL, ":"); size_t bytes_written = 0;
char* prescaler_str = strtok(NULL, ":");
bool play_immediately = strcmp(play_immediately_str, "true") == 0; esp_err_t channel_enable_result = i2s_channel_enable(tx_chan);
bool repeat = strcmp(repeat_str, "true") == 0; ESP_ERROR_CHECK_WITHOUT_ABORT(channel_enable_result);
uint8_t prescaler = atoi(prescaler_str); if (channel_enable_result != ESP_OK) {
play_clip_wav(file_name, play_immediately, repeat, prescaler, 0); return channel_enable_result;
return true; }
}
if (strcmp(event, "STOP_WAV") == 0) {
stop_clip(arg, 0);
return true;
}
return false; bytes_read = fread(read_buf, sizeof(uint8_t), AUDIO_BUFFER, fh);
for (int i = 0; i < bytes_read; i++) {
write_buf[i] = read_buf[i] << 4;
}
// i2s_channel_enable(tx_handle);
while (bytes_read > 0) {
// write the buffer to the i2s
// ESP_LOGI(TAG, "Writing: ");
// for (int i = 0; i < words_read; i++) {
// int16_t val = buf[i];
// printf("%s0x%04X ", (val < 0 ? "-" : "+"), (val < 0 ? -val : val));
// }>
i2s_channel_write(tx_chan, write_buf, bytes_read * sizeof(int16_t), &bytes_written, portMAX_DELAY);
bytes_read = fread(read_buf, sizeof(uint8_t), AUDIO_BUFFER, fh);
for (int i = 0; i < bytes_read; i++) {
write_buf[i] = read_buf[i] << 4;
}
uint8_t recv = 0;
if (xQueueReceive(stop_handle, &recv, 0)) {
break;
}
vTaskDelay(pdMS_TO_TICKS(10));
}
i2s_channel_disable(tx_chan);
free(read_buf);
free(write_buf);
fclose(fh);
return ESP_OK;
} }
static bool push_clip(audio_clip_t clip) { esp_err_t play_raw(const char *fp) {
ESP_LOGD(TAG, "playing %s", clip.file_name); FILE *fh = fopen(fp, "rb");
FILE* fh = fopen(clip.file_name, "rb"); if (fh == NULL)
if (fh == NULL) { {
ESP_LOGW(TAG, "failed to open %s", clip.file_name); ESP_LOGE(TAG, "Failed to open file");
return false; return ESP_ERR_INVALID_ARG;
} else { }
// skip the .wav header
fseek(fh, 44, SEEK_SET);
playing_audio_clip_t playing_clip = { // create a writer buffer
.file_name = clip.file_name, uint8_t *read_buf = (uint8_t*) calloc(AUDIO_BUFFER, sizeof(uint8_t));
.file_handle = fh, uint16_t *write_buf = (uint16_t*) calloc(AUDIO_BUFFER, sizeof(uint16_t));
.prescaler = clip.prescaler, size_t bytes_read = 0;
.repeat = clip.repeat, size_t bytes_written = 0;
};
playing_clips.push_back(playing_clip);
return true;
}
}
/// @brief Disables the channel if neccesary. esp_err_t channel_enable_result = i2s_channel_enable(tx_chan);
static void disable_channel() { ESP_ERROR_CHECK_WITHOUT_ABORT(channel_enable_result);
if (channel_enabled) { if (channel_enable_result != ESP_OK) {
ESP_ERROR_CHECK_WITHOUT_ABORT(i2s_channel_disable(tx_chan)); return channel_enable_result;
channel_enabled = false; }
}
}
/// @brief Enables the channel if neccesary
static void enable_channel() {
if (!channel_enabled) {
ESP_ERROR_CHECK_WITHOUT_ABORT(i2s_channel_enable(tx_chan));
channel_enabled = true;
}
}
static void speaker_task(void* arg) { bytes_read = fread(read_buf, sizeof(uint8_t), AUDIO_BUFFER, fh);
audio_clip_t next_clip; for (int i = 0; i < bytes_read; i++) {
char* clip_to_stop; write_buf[i] = read_buf[i] << 4;
}
int16_t* audio_buf = (int16_t*) malloc(audio_block_size * sizeof(int16_t)); // i2s_channel_enable(tx_handle);
int16_t* file_buf = (int16_t*) malloc(audio_block_size * sizeof(int16_t));
while (1) { while (bytes_read > 0) {
// first, take all "play immediatly" clips from the queue. // write the buffer to the i2s
while (xQueuePeek(play_clip_queue, &next_clip, 0) == pdTRUE && next_clip.play_immediatly) { // ESP_LOGI(TAG, "Writing: ");
if (xQueueReceive(play_clip_queue, &next_clip, 0) == pdTRUE) { // for (int i = 0; i < words_read; i++) {
push_clip(next_clip); // int16_t val = buf[i];
} // printf("%s0x%04X ", (val < 0 ? "-" : "+"), (val < 0 ? -val : val));
} // }>
i2s_channel_write(tx_chan, write_buf, bytes_read * sizeof(int16_t), &bytes_written, portMAX_DELAY);
bytes_read = fread(read_buf, sizeof(uint8_t), AUDIO_BUFFER, fh);
for (int i = 0; i < bytes_read; i++) {
write_buf[i] = read_buf[i] << 4;
}
vTaskDelay(pdMS_TO_TICKS(10));
}
// handle any stop requests i2s_channel_disable(tx_chan);
while (xQueueReceive(stop_clip_queue, &clip_to_stop, 0) == pdTRUE) { free(read_buf);
// delete clip from list free(write_buf);
bool found = false; fclose(fh);
for (int clip_idx = playing_clips.size()-1; clip_idx >= 0; clip_idx--) {
playing_audio_clip_t& clip = playing_clips.at(clip_idx);
if (strcmp(clip.file_name, clip_to_stop) == 0) {
found = true;
ESP_LOGV(TAG, "stopping %s", clip.file_name);
fclose(clip.file_handle);
free(clip.file_name);
playing_clips.erase(playing_clips.begin() + clip_idx);
}
}
if (!found) {
ESP_LOGW(TAG, "Could not find clip \"%s\" to stop", clip_to_stop);
}
// free the string that was passed into the queue
free(clip_to_stop);
}
// if we aren't playing any clips, wait for the next one. return ESP_OK;
if (playing_clips.empty()) {
if (xQueueReceive(play_clip_queue, &next_clip, 0) == pdTRUE) {
push_clip(next_clip);
} else {
// we must wait before our next clip
disable_channel();
// now wait for next clip
if (xQueueReceive(play_clip_queue, &next_clip, portMAX_DELAY) == pdTRUE) {
push_clip(next_clip);
}
}
}
// send 1 block
std::memset(audio_buf, 0, audio_block_size * sizeof(int16_t));
for (int clip_idx = playing_clips.size()-1; clip_idx >= 0; clip_idx--) {
playing_audio_clip_t& clip = playing_clips.at(clip_idx);
size_t samples_read = fread(file_buf, sizeof(uint16_t), audio_block_size, clip.file_handle);
if (samples_read == 0) {
if (clip.repeat) {
ESP_LOGV(TAG, "repeating %s", clip.file_name);
fseek(clip.file_handle, 44, SEEK_SET);
} else {
ESP_LOGV(TAG, "finishing %s", clip.file_name);
fclose(clip.file_handle);
free(clip.file_name);
playing_clips.erase(playing_clips.begin() + clip_idx);
}
continue;
}
for (int i = 0; i < samples_read; i++) {
audio_buf[i] += (file_buf[i] >> clip.prescaler);
}
}
size_t bytes_to_write = audio_block_size * sizeof(int16_t);
size_t bytes_written;
if (!channel_enabled) {
ESP_ERROR_CHECK_WITHOUT_ABORT(i2s_channel_preload_data(tx_chan, audio_buf, bytes_to_write, &bytes_written));
enable_channel();
} else {
ESP_ERROR_CHECK_WITHOUT_ABORT(i2s_channel_write(tx_chan, audio_buf, bytes_to_write, &bytes_written, portMAX_DELAY));
}
if (bytes_written != bytes_to_write) {
ESP_LOGW(TAG, "only %d bytes written to the i2s channel! (expected %d)", bytes_written, bytes_to_write);
}
}
vTaskDelete(NULL);
}
bool play_clip_wav(const char* file_name, bool play_immediately, bool repeat, uint8_t prescaler, TickType_t ticks_to_wait) {
// clone the passed in string to the heap.
size_t len = strlen(file_name);
char* dynamic_file_name = (char*) malloc(len+1);
strcpy(dynamic_file_name, file_name);
audio_clip_t clip = {
.file_name = dynamic_file_name,
.prescaler = prescaler,
.repeat = repeat,
.play_immediatly = play_immediately,
};
if (is_state_tracking()) {
char buf[64];
sprintf(buf, "%s:%d:%d:%d", file_name, play_immediately, repeat, prescaler);
event_occured("PLAY_WAV", buf);
}
if (play_immediately) {
return xQueueSendToFront(play_clip_queue, &clip, ticks_to_wait) == pdTRUE;
}
return xQueueSend(play_clip_queue, &clip, ticks_to_wait) == pdTRUE;
}
bool stop_clip(const char* file_name, TickType_t ticks_to_wait) {
// clone the passed in string to the heap.
size_t len = strlen(file_name);
char* dynamic_file_name = (char*) malloc(len+1);
strcpy(dynamic_file_name, file_name);
if (is_state_tracking()) {
event_occured("STOP_WAV", file_name);
}
return xQueueSend(stop_clip_queue, &dynamic_file_name, ticks_to_wait) == pdTRUE;
} }
void init_speaker(void) { void init_speaker(void) {
ESP_LOGI(TAG, "Initializing speaker..."); i2s_chan_config_t tx_chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_AUTO, I2S_ROLE_MASTER);
ESP_ERROR_CHECK(i2s_new_channel(&tx_chan_cfg, &tx_chan, NULL));
i2s_chan_config_t tx_chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_AUTO, I2S_ROLE_MASTER); i2s_std_config_t tx_std_cfg = {
ESP_ERROR_CHECK(i2s_new_channel(&tx_chan_cfg, &tx_chan, NULL)); .clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(SAMPLE_RATE),
.slot_cfg = I2S_STD_MSB_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO),
i2s_std_config_t tx_std_cfg = { .gpio_cfg = {
.clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(SAMPLE_RATE), .mclk = I2S_GPIO_UNUSED,
.slot_cfg = I2S_STD_MSB_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO), .bclk = SPEAKER_PIN_BCLK,
.gpio_cfg = { .ws = SPEAKER_PIN_WS,
.mclk = I2S_GPIO_UNUSED, .dout = SPEAKER_PIN_DOUT,
.bclk = SPEAKER_PIN_BCLK, .din = GPIO_NUM_NC,
.ws = SPEAKER_PIN_WS, .invert_flags = {
.dout = SPEAKER_PIN_DOUT, .mclk_inv = false,
.din = GPIO_NUM_NC, .bclk_inv = false,
.invert_flags = { .ws_inv = false,
.mclk_inv = false, },
.bclk_inv = false, },
.ws_inv = false, };
}, ESP_ERROR_CHECK(i2s_channel_init_std_mode(tx_chan, &tx_std_cfg));
}, }
};
ESP_ERROR_CHECK(i2s_channel_init_std_mode(tx_chan, &tx_std_cfg)); void play_example() {
ESP_ERROR_CHECK_WITHOUT_ABORT(play_raw("/sdcard/o.pcm"));
i2s_chan_info_t info = {};
i2s_channel_get_info(tx_chan, &info);
if (info.total_dma_buf_size != 0) {
audio_block_size = info.total_dma_buf_size / sizeof(int16_t);
}
// init queues
play_clip_queue = xQueueCreate(CLIP_QUEUE_SIZE, sizeof(audio_clip_t));
stop_clip_queue = xQueueCreate(CLIP_QUEUE_SIZE, sizeof(char*));
// start task
xTaskCreate(speaker_task, "play_audio", 4096, NULL, 5, NULL);
play_clip_wav(MOUNT_POINT "/startup.wav", true, false, 4, 0);
register_replay_fn(replay_handler);
ESP_LOGI(TAG, "Speaker initialized!");
} }

51
main/drivers/speaker.h
View File

@ -3,9 +3,6 @@
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <string>
#include <cstring>
#include <vector>
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "freertos/queue.h" #include "freertos/queue.h"
#include "freertos/task.h" #include "freertos/task.h"
@ -15,49 +12,21 @@
#include "sdkconfig.h" #include "sdkconfig.h"
#include "sd.h" #include "sd.h"
#define SPEAKER_PIN_BCLK GPIO_NUM_11 #define SPEAKER_PIN_BCLK GPIO_NUM_46
#define SPEAKER_PIN_WS GPIO_NUM_12 #define SPEAKER_PIN_WS GPIO_NUM_9
#define SPEAKER_PIN_DOUT GPIO_NUM_3 #define SPEAKER_PIN_DOUT GPIO_NUM_3
#define SAMPLE_RATE 44100 #define SAMPLE_RATE 44100
// The maximum number of clips that can be queued at one time. #define AUDIO_BUFFER 2048
#define CLIP_QUEUE_SIZE 64
extern i2s_chan_handle_t tx_chan; extern i2s_chan_handle_t tx_chan;
typedef struct { /// Plays a audio file stopping when something is received on `stop_handle`
/// A dynamically allocated string specifying the name of the ///
/// file to play. The speaker system will free this once it /// `stop_handle` should be of size `uint8_t`.
/// is done. esp_err_t play_raw_stop_queue(const char *fp, QueueHandle_t stop_handle);
char* file_name; esp_err_t play_raw(const char *fp);
/// A number that all samples will be shifted right by.
uint8_t prescaler;
/// A flag for repeating.
bool repeat;
/// A flag for starting the clip immediatly,
/// even if there is another clip playing.
bool play_immediatly;
} audio_clip_t;
/// @brief Initalizes the speaker void init_speaker(void);
void init_speaker(); void play_example();
/// @brief Plays a wav audio clip.
/// @param file_name The name of the file to play. Fully qualified with the `.wav` extention.
/// @param play_immediatly If `true`, the file will play immediatly even if there is already
/// another clip being played. The two clips will play simultaniously. If `false` the clip
/// will play once all the previous clips have finished.
/// @param repeat If `true` the clip will repeat until stopped. If `false` the clip will
/// stop when finished.
/// @param prescaler A number to shift right all samples by. This makes the music half as
/// loud. Useful for loud audio files.
/// @param ticks_to_wait The number of ticks to wait if the queue is full.
/// @return true if the clip was added to the queue.
bool play_clip_wav(const char* file_name, bool play_immediately, bool repeat, uint8_t prescaler, TickType_t ticks_to_wait);
/// @brief Stops an audio clip from playing.
/// @param file_name The file name of the audio clip that was played.
/// @param ticks_to_wait The number of ticks to wait if the queue is full.
/// @return true if the clip was added to the queue.
bool stop_clip(const char* file_name, TickType_t ticks_to_wait);
#endif /* SPEAKER_H */ #endif /* SPEAKER_H */

125
main/drivers/sseg.cpp
View File

@ -1,138 +1,39 @@
#include "sseg.h" #include "sseg.h"
#include <esp_log.h>
#include "state_tracking.h"
#include <cstring>
TM1640* sseg = nullptr; TM1640* sseg = nullptr;
static const char *TAG = "sseg"; static const char *TAG = "sseg_driver";
static bool replay_handler(const char* event, char* arg) {
if (strcmp(event, "SSEG_G_RAW") == 0) {
uint8_t segments[4];
segments[0] = atoi(strtok(arg, ","));
for (int i = 1; i < 4; i++) {
segments[i] = atoi(strtok(NULL, ","));
}
set_game_sseg_raw(segments);
return true;
}
if (strcmp(event, "SSEG_G_CLR") == 0) {
clear_game_sseg();
return true;
}
if (strcmp(event, "SSEG_M_RAW") == 0) {
uint8_t segments[4];
segments[0] = atoi(strtok(arg, ","));
for (int i = 1; i < 4; i++) {
segments[i] = atoi(strtok(NULL, ","));
}
set_module_sseg_raw(segments);
return true;
}
if (strcmp(event, "SSEG_M_CLR") == 0) {
clear_module_sseg();
return true;
}
if (strcmp(event, "SSEG_G") == 0) {
uint32_t value = atoi(strtok(arg, ","));
uint8_t dot_pos = atoi(strtok(NULL, ","));
set_game_sseg_num(value, dot_pos);
return true;
}
if (strcmp(event, "SSEG_M") == 0) {
uint32_t value = atoi(strtok(arg, ","));
uint8_t dot_pos = atoi(strtok(NULL, ","));
set_module_sseg_num(value, dot_pos);
return true;
}
return false;
}
void init_sseg() { void init_sseg() {
ESP_LOGI(TAG, "Initializing sseg...");
sseg = new TM1640(SSEG_PIN_DATA, SSEG_PIN_CLK, 8); sseg = new TM1640(SSEG_PIN_DATA, SSEG_PIN_CLK, 8);
register_replay_fn(replay_handler);
ESP_LOGI(TAG, "Sseg initialized!");
} }
void set_game_sseg_raw(const uint8_t* segments) { void set_game_sseg_raw(const uint8_t* digits) {
sseg->setSegments(segments[0], 0); sseg->setSegments(digits[0], 0);
sseg->setSegments(segments[1], 1); sseg->setSegments(digits[1], 1);
sseg->setSegments(segments[2], 2); sseg->setSegments(digits[2], 2);
sseg->setSegments(segments[3], 3); sseg->setSegments(digits[3], 3);
if (is_state_tracking()) {
char buf[32];
sprintf(buf, "%d,%d,%d,%d", segments[0], segments[1], segments[2], segments[3]);
event_occured("SSEG_G_RAW", buf);
}
}
void clear_game_sseg() {
sseg->setSegments(0, 0);
sseg->setSegments(0, 1);
sseg->setSegments(0, 2);
sseg->setSegments(0, 3);
if (is_state_tracking()) {
event_occured("SSEG_G_CLR", NULL);
}
} }
void set_module_sseg_raw(const uint8_t* segments) { void set_module_sseg_raw(const uint8_t* digits) {
sseg->setSegments(segments[0], 4); sseg->setSegments(digits[0], 4);
sseg->setSegments(segments[1], 5); sseg->setSegments(digits[1], 5);
sseg->setSegments(segments[2], 6); sseg->setSegments(digits[2], 6);
sseg->setSegments(segments[3], 7); sseg->setSegments(digits[3], 7);
if (is_state_tracking()) {
char buf[32];
sprintf(buf, "%d,%d,%d,%d", segments[0], segments[1], segments[2], segments[3]);
event_occured("SSEG_M_RAW", buf);
}
} }
void clear_module_sseg() { void set_game_sseg_num(unsigned int value, int dot_pos) {
sseg->setSegments(0, 4);
sseg->setSegments(0, 5);
sseg->setSegments(0, 6);
sseg->setSegments(0, 7);
if (is_state_tracking()) {
event_occured("SSEG_M_CLR", NULL);
}
}
void set_game_sseg_num(uint32_t value, uint8_t dot_pos) {
uint32_t initial_value = value;
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
auto idx = value % 10; auto idx = value % 10;
sseg->sendChar(3-i, TM16XX_NUMBER_FONT[idx], i == dot_pos); sseg->sendChar(3-i, TM16XX_NUMBER_FONT[idx], i == dot_pos);
value = value / 10; value = value / 10;
} }
if (is_state_tracking()) {
char buf[16];
sprintf(buf, "%ld,%d", initial_value, dot_pos);
event_occured("SSEG_G", buf);
}
} }
void set_module_sseg_num(uint32_t value, uint8_t dot_pos) { void set_module_sseg_num(unsigned int value, int dot_pos) {
uint32_t initial_value = value;
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
auto idx = value % 10; auto idx = value % 10;
sseg->sendChar(7-i, TM16XX_NUMBER_FONT[idx], i == dot_pos); sseg->sendChar(7-i, TM16XX_NUMBER_FONT[idx], i == dot_pos);
value = value / 10; value = value / 10;
} }
if (is_state_tracking()) {
char buf[16];
sprintf(buf, "%ld,%d", initial_value, dot_pos);
event_occured("SSEG_M", buf);
}
} }

22
main/drivers/sseg.h
View File

@ -4,38 +4,32 @@
#include "TM1640/TM1640.h" #include "TM1640/TM1640.h"
#include <esp_log.h> #include <esp_log.h>
#define SSEG_PIN_DATA GPIO_NUM_46 #define SSEG_PIN_DATA GPIO_NUM_10
#define SSEG_PIN_CLK GPIO_NUM_48 #define SSEG_PIN_CLK GPIO_NUM_11
extern TM1640* sseg; extern TM1640* sseg;
/// Initializes the seven segment driver /// Initializes the seven segment driver
void init_sseg(); void init_sseg();
/// @brief Sets the game seven segment to the value of `segments`. /// sets the game seven segment to the value of the digits
/// ///
/// the bits 0-6 map to segments A-G, and bit 7 is DP. /// the bits 0-6 map to segments A-G, and bit 7 is DP.
/// ///
/// `digits` must have len >= 4. /// `digits` must have len >= 4.
void set_game_sseg_raw(const uint8_t* segments); void set_game_sseg_raw(const uint8_t* digits);
/// @brief Clears the game seven segment display. /// sets the module seven segment to the value of the digits
void clear_game_sseg();
/// @brief Sets the module seven segment to the value of the `segments`.
/// ///
/// the bits 0-6 map to segments A-G, and bit 7 is DP. /// the bits 0-6 map to segments A-G, and bit 7 is DP.
/// ///
/// `digits` must have len >= 4. /// `digits` must have len >= 4.
void set_module_sseg_raw(const uint8_t* segments); void set_module_sseg_raw(const uint8_t* digits);
/// @brief Clears the game seven segment display.
void clear_module_sseg();
/// sets the game timer to the given number, with the dot at position `dot_pos` from the right (0 => right-most digit). /// sets the game timer to the given number, with the dot at position `dot_pos` from the right (0 => right-most digit).
void set_game_sseg_num(uint32_t value, uint8_t dot_pos); void set_game_sseg_num(unsigned int value, int dot_pos);
/// sets the module timer to the given number, with the dot at position `dot_pos` from the right (0 => right-most digit). /// sets the module timer to the given number, with the dot at position `dot_pos` from the right (0 => right-most digit).
void set_module_sseg_num(uint32_t value, uint8_t dot_pos); void set_module_sseg_num(unsigned int value, int dot_pos);
#endif /* SSEG_H */ #endif /* SSEG_H */

275
main/drivers/starcode.cpp
View File

@ -1,275 +0,0 @@
#include "starcode.h"
#include <vector>
#include <algorithm>
#include <string.h>
#include <stdint.h>
#include <esp_log.h>
#include "drivers/bottom_half.h"
#include "char_lcd.h"
#include "esp_timer.h"
#include "freertos/task.h"
static const char* TAG = "star_code";
volatile bool handling_new_starcodes = false;
static volatile bool system_initialized = false;
// TODO: use the semaphore, convert to RWLock?
static volatile SemaphoreHandle_t star_codes_mutex;
static std::vector<StarCodeEntry> star_codes;
static const char EMPTY_STAR_CODE_HEADER[] = " ";
esp_timer_handle_t starcode_delay_timer;
/// @brief `true` if we are delaying for a starcode
static volatile bool delaying_for_starcode;
static volatile StarCodeEntry* current_starcode = nullptr;
/// @brief `true` when we are handling user input for a starcode
static volatile bool doing_starcode = false;
static uint16_t starcode_waiting_on_release;
static char current[STARCODE_MAX_LEN + 1];
static size_t current_idx;
// Task handle for the starcode callback task
static TaskHandle_t starcode_callback_task_handle = nullptr;
static void starcode_callback_task(void* arg) {
(void) arg;
while (true) {
// Wait for notification from starcode_trigger_cb
uint32_t notification_value;
if (xTaskNotifyWait(0, ULONG_MAX, &notification_value, portMAX_DELAY) == pdTRUE) {
// Process the starcode callback
delaying_for_starcode = false;
lcd_print_header();
if (current_starcode != nullptr) {
if (current_starcode->triggered_sem != nullptr)
xSemaphoreGive(current_starcode->triggered_sem);
if (current_starcode->callback != nullptr)
(current_starcode->callback)();
current_starcode = nullptr;
}
}
}
}
static void starcode_trigger_cb(void* arg) {
(void) arg;
if (starcode_callback_task_handle != nullptr) {
xTaskNotify(starcode_callback_task_handle, 1, eSetBits);
}
}
// TODO: rename star code everywhere to starcode
void star_code_handle_keypad(uint16_t* just_pressed, uint16_t* just_released) {
if ((!delaying_for_starcode) && handling_new_starcodes && (*just_pressed & (1 << KeypadKey::star))) {
current_idx = 0;
current[current_idx] = '\0';
doing_starcode = true;
}
if (doing_starcode) {
// If we get a press while handling a starcode, we also want to capture the release of that key.
starcode_waiting_on_release |= *just_pressed;
KeypadKey key;
while (take_key(&key, just_pressed)) {
if (key == KeypadKey::star) {
current_idx = 0;
current[current_idx] = '\0';
} else if (key == KeypadKey::pound) {
doing_starcode = false;
if (current_idx != 0) {
trigger_star_code(current);
}
} else {
// shift the digits left if neccesary
if (current_idx >= STARCODE_MAX_LEN) {
for (int i = 1; i < current_idx; i++) {
current[i-1] = current[i];
}
current_idx--;
}
// append the character
current[current_idx++] = char_of_keypad_key(key);
current[current_idx] = '\0';
}
lcd_print_header_star_code();
}
}
// capture any releases from starcodes
uint16_t new_just_released = (*just_released) & (~starcode_waiting_on_release);
starcode_waiting_on_release = starcode_waiting_on_release & (~*just_released);
*just_released = new_just_released;
}
void init_star_code_system() {
star_codes_mutex = xSemaphoreCreateMutex();
xTaskCreate(starcode_callback_task, "starcode_cb", 4096, NULL, 3, &starcode_callback_task_handle);
const esp_timer_create_args_t timer_args = {
.callback = &starcode_trigger_cb,
.arg = nullptr,
.dispatch_method = ESP_TIMER_TASK,
.name = "starcode_trigger",
.skip_unhandled_events = false,
};
ESP_ERROR_CHECK(esp_timer_create(&timer_args, &starcode_delay_timer));
handling_new_starcodes = true;
system_initialized = true;
}
/// Checks if a triggered code matches an expected code.
/// @return true iff the codes match, where '*'s in the expected code can match any character in the triggered code
static bool check_code_match(const char* triggered, const char* expected) {
size_t triggered_len = strlen(triggered);
size_t match_len = strlen(triggered);
if (triggered_len != match_len)
return false;
for (int i = 0; i < triggered_len; i++) {
if (!(expected[i] == '*' || expected[i] == triggered[i])) {
return false;
}
}
return true;
}
bool add_star_code(StarCodeEntry code) {
ESP_LOGI(TAG, "Adding starcode: %s", code.code);
if (code.code == nullptr || strlen(code.code) > STARCODE_MAX_LEN) {
ESP_LOGW(TAG, "invalid code");
return false;
}
if (code.display_text != nullptr && strlen(code.display_text) > STARCODE_DISPLAY_TEXT_MAX_LEN) {
ESP_LOGW(TAG, "invalid display_text");
return false;
}
// check for a existing entry
auto it = std::find_if(star_codes.begin(), star_codes.end(), [&](const StarCodeEntry& other) {
return check_code_match(code.code, other.code);
});
if (it != star_codes.end()) {
// existing star code found!
ESP_LOGW(TAG, "Duplicate starcode %s", code.code);
return false;
}
star_codes.push_back(code);
return true;
}
bool add_star_codes(const StarCodeEntry* codes, size_t len) {
bool success = true;
for (int i = 0; i < len; i++) {
if (!add_star_code(codes[i])) {
success = false;
}
}
return success;
}
bool rm_star_code(const char* code) {
ESP_LOGI(TAG, "Removing starcode: %s", code);
auto it = std::find_if(star_codes.begin(), star_codes.end(), [&](const StarCodeEntry& star_code) {
return strcmp(code, star_code.code) == 0;
});
if (it == star_codes.end()) {
ESP_LOGW(TAG, "Failed to remove star code %s", code);
return false;
}
star_codes.erase(it);
return true;
}
bool rm_star_codes(const StarCodeEntry* codes, size_t len) {
bool success = true;
for (int i = 0; i < len; i++) {
if (!rm_star_code(codes[i].code)) {
success = false;
}
}
return success;
}
bool rm_star_codes_str(const char** codes, size_t len) {
bool success = true;
for (int i = 0; i < len; i++) {
if (!rm_star_code(codes[i])) {
success = false;
}
}
return success;
}
void clear_star_codes() {
star_codes.clear();
}
bool trigger_star_code(const char* code) {
auto it = std::find_if(star_codes.begin(), star_codes.end(), [&](const StarCodeEntry& other) {
return check_code_match(code, other.code);
});
uint64_t delay_us = 2'000'000;
delaying_for_starcode = true;
if (it != star_codes.end()) {
current_starcode = &*it;
delay_us = current_starcode->delay_us;
}
ESP_ERROR_CHECK(esp_timer_start_once(starcode_delay_timer, delay_us));
return current_starcode != nullptr;
}
void pause_star_code_system() {
doing_starcode = false;
handling_new_starcodes = false;
}
void resume_star_code_system() {
handling_new_starcodes = system_initialized;
}
void lcd_print_header_star_code() {
if (!lcd_header_enabled()) return;
// TODO: consider upping the display text size to be able to overwrite the game_state area.
if (delaying_for_starcode) {
if (current_starcode == nullptr) {
lcd_print(0, 0, "Invalid starcode ");
} else if (current_starcode->display_text != nullptr) {
char buf[21];
snprintf(buf, sizeof(buf), "%-20s", current_starcode->display_text);
lcd_print(0, 0, buf);
} else {
lcd_print(0, 0, EMPTY_STAR_CODE_HEADER);
}
} else if (doing_starcode) {
char buf[STARCODE_MAX_LEN + 2];
snprintf(buf, sizeof(buf), "*%-9s", current);
lcd_print(0, 0, buf);
} else {
lcd_print(0, 0, EMPTY_STAR_CODE_HEADER);
}
}
bool lcd_starcode_displaying_result() {
return delaying_for_starcode;
}

90
main/drivers/starcode.h
View File

@ -1,90 +0,0 @@
#ifndef STAR_CODE_H
#define STAR_CODE_H
#include <stddef.h>
#include <freertos/FreeRTOS.h>
#include <freertos/semphr.h>
/// The max length of a starcode (not counting the star)
#define STARCODE_MAX_LEN 9
#define STARCODE_DISPLAY_TEXT_MAX_LEN 20
/// @brief A handler for a specific star code
struct StarCodeEntry {
/// @brief The star code without the star
///
/// This must be <= 9 characters.
///
/// You may include a * in the code to match on any character
const char* code;
/// @brief The text to display when the star code is entered (or null).
///
/// This must be <= 20 characters.
const char* display_text;
/// @brief The number of microseconds to delay when the star code is entered before calling the handler.
uint64_t delay_us;
/// @brief The function to call when the star code is entered.
/// Can be null.
void (*callback)(void);
/// @brief The binary semaphore that will be given when this star code is triggered.
/// Can be null.
SemaphoreHandle_t triggered_sem;
};
/// @brief Initializes the star code system.
void init_star_code_system();
/// @brief Handles any keypad presses and releases before they bubble up to the rest of the BLK_BOX.
void star_code_handle_keypad(uint16_t* just_pressed, uint16_t* just_released);
/// @brief Adds a star code to be handled.
/// @param code the star code to add
/// @return true iff the star code was added
bool add_star_code(StarCodeEntry code);
/// @brief Adds a list of star codes to be handled.
/// @param codes the list of star codes to add
/// @param len the length of the list
/// @return true iff all the star codes were added
bool add_star_codes(const StarCodeEntry* codes, size_t len);
/// @brief removes a star code to stop handling it.
/// @param code the star code to remove
/// @return true iff the star code was removed
bool rm_star_code(const char* code);
/// @brief removes all given star codes to stop handling them.
/// @param codes the list of star codes to remove
/// @param len the length of the list
/// @return true iff all star codes were removed
bool rm_star_codes(const StarCodeEntry* codes, size_t len);
/// @brief removes all given star codes to stop handling them.
/// @param codes the list of star codes to remove
/// @param len the length of the list
/// @return true iff all star codes were removed
bool rm_star_codes_str(const char** codes, size_t len);
/// @brief clears all star codes.
void clear_star_codes();
/// @brief Triggers the given star code.
/// @param code the star code to trigger (without the *)
/// @return true iff a star code was triggered
bool trigger_star_code(const char* code);
/// @brief Starts/stops the star code system from handling new star codes.
/// If one is being handled currently, it is canceled.
void set_star_code_sys_enabled(bool enable);
/// @return `true` iff the star code system is handling star codes.
bool star_code_sys_enabled();
/// @brief Prints the star code section of the header to the char_lcd. (row 0, columns 0-9)
void lcd_print_header_star_code();
/// @return `true` iff the starcode system is using the full header.
bool lcd_starcode_displaying_result();
#endif /* STAR_CODE_H */

225
main/drivers/state_tracking.cpp
View File

@ -1,225 +0,0 @@
#include "state_tracking.h"
#include <unistd.h>
#include <vector>
#include "wlvgl.h"
static const char* PLAYBACK_TAG = "playback";
enum state_t {
STATE_IDLE = 0,
STATE_RECORDING = 1,
STATE_PLAYBACK = 2,
};
static std::vector<bool(*)(const char*, char*)> replay_fns;
static bool should_close_recording_stream;
static FILE* recording_stream;
static uint32_t recording_start_time;
TaskHandle_t flush_file_task_handle;
static bool should_close_playback_stream;
static FILE* playback_stream;
static uint32_t playback_start_time;
TaskHandle_t playback_task_handle;
static volatile state_t state = STATE_IDLE;
/// @brief Periodically flushes and syncs (if neccesary) the output stream.
/// @param arg unused.
static void flush_file_task(void* arg) {
while (state == STATE_RECORDING && recording_stream != nullptr) {
fflush(recording_stream);
int fd = fileno(recording_stream);
if (fd != -1) {
fsync(fd);
}
vTaskDelay(pdMS_TO_TICKS(5000));
}
flush_file_task_handle = NULL;
vTaskDelete(NULL);
}
static void playback_task(void* arg) {
const size_t size = 16*1024;
char* buf = (char*) malloc(size*sizeof(char));
if (buf == nullptr) {
ESP_LOGE(PLAYBACK_TAG, "buf alloc failure");
vTaskDelete(NULL);
}
while (state == STATE_PLAYBACK && playback_stream != nullptr) {
char* ret = fgets(buf, size, playback_stream);
if (ret == nullptr) {
break;
}
if (buf[0] == '\0') {
ESP_LOGI(PLAYBACK_TAG, "playback done");
break;
}
// get rid of the '\n' and possibly '\r' in the string
for (int i = 0; i < size; i++) {
if (buf[i] == '\0') break;
if (buf[i] == '\r' || buf[i] == '\n') {
buf[i] = '\0';
break;
}
}
ESP_LOGI(PLAYBACK_TAG, "handling: %s", buf);
// look for a comma, indicating the end of the "ticks" part
// TODO: replace with strtok
size_t comma_pos = 0;
for (int i = 0; i < 11; i++) {
if (buf[i] == ',') {
comma_pos = i;
break;
}
}
if (comma_pos == 0) {
ESP_LOGE(PLAYBACK_TAG, "Failed to find comma in playback line");
continue;
}
buf[comma_pos] = '\0';
uint32_t tick = atoi(buf);
// now look for the colon to indicate the end of the event name
size_t colon_pos = 0;
int i = comma_pos + 1; // start looking right after the comma
while (i < size) {
if (buf[i] == ':') {
colon_pos = i;
break;
}
i++;
}
if (colon_pos == 0) {
ESP_LOGE(PLAYBACK_TAG, "Failed to find colon in playback line");
continue;
}
buf[colon_pos] = '\0';
char* event_name = buf + (comma_pos + 1);
char* arg = buf + (colon_pos + 1);
int32_t ticks_to_wait = ((int32_t) tick) - (int32_t)(xTaskGetTickCount() - playback_start_time);
if (ticks_to_wait < 0) {
ESP_LOGW(PLAYBACK_TAG, "Playback is behind by %ld ticks!", ticks_to_wait);
}
if (ticks_to_wait > 0) {
vTaskDelay(ticks_to_wait);
}
bool matched = false;
for (const auto& fn : replay_fns) {
matched = (fn)(event_name, arg);
if (matched) break;
}
if (!matched) {
ESP_LOGW(PLAYBACK_TAG, "Failed to match event: %s!", event_name);
}
}
free(buf);
playback_task_handle = NULL;
stop_playback();
vTaskDelete(NULL);
}
void register_replay_fn(bool (*replay_fn)(const char*, char*)) {
replay_fns.push_back(replay_fn);
}
void event_occured(const char* name, const char* arg) {
if (state != STATE_RECORDING) return;
if (name == nullptr) return;
if (recording_stream == nullptr) {
ESP_LOGE("state_tracking", "We are in state recording, but recording stream is null");
return;
}
arg = (arg == nullptr) ? "" : arg;
uint32_t ticks = xTaskGetTickCount() - recording_start_time;
fprintf(recording_stream, "%ld,%s:%s\n", ticks, name, (arg == nullptr) ? "" : arg);
}
bool set_recording_source(FILE* stream, bool should_close) {
if (state == STATE_RECORDING) return false;
recording_stream = stream;
should_close_recording_stream = should_close;
return true;
}
bool set_playback_source(FILE* stream, bool should_close) {
if (state == STATE_PLAYBACK) return false;
playback_stream = stream;
should_close_playback_stream = should_close;
return true;
}
bool start_recording() {
if (state != STATE_IDLE) return false;
if (recording_stream == nullptr) return false;
state = STATE_RECORDING;
recording_start_time = xTaskGetTickCount();
xTaskCreate(flush_file_task, "flush_recording", 2048, NULL, 2, &flush_file_task_handle);
reset_wlv_tables(); // TODO: generify this
return true;
}
bool stop_recording() {
if (state != STATE_RECORDING) return false;
state = STATE_IDLE;
fflush(recording_stream);
if (should_close_recording_stream) {
fclose(recording_stream);
recording_stream = nullptr;
}
if (flush_file_task_handle != nullptr) {
vTaskDelete(flush_file_task_handle);
flush_file_task_handle = NULL;
}
return true;
}
bool start_playback() {
if (state != STATE_IDLE) return false;
if (playback_stream == nullptr) return false;
state = STATE_PLAYBACK;
playback_start_time = xTaskGetTickCount();
xTaskCreate(playback_task, "playback", 4096, NULL, 2, &playback_task_handle);
reset_wlv_tables(); // TODO: generify this
return true;
}
bool stop_playback() {
if (state != STATE_PLAYBACK) return false;
state = STATE_IDLE;
if (should_close_playback_stream) {
fclose(playback_stream);
playback_stream = nullptr;
}
if (playback_task_handle != nullptr) {
// TODO: NO!! This leaks the malloc. Instead, use a queue to request a graceful stop
vTaskDelete(playback_task_handle);
playback_task_handle = NULL;
}
return true;
}
bool is_state_tracking() {
return state == STATE_RECORDING;
}

53
main/drivers/state_tracking.h
View File

@ -1,53 +0,0 @@
#ifndef STATE_TRACKING_H
#define STATE_TRACKING_H
#include <stdint.h>
#include "esp_vfs_fat.h"
/// @brief Registers function to be called on replay.
/// @param replay_callback A function to call to playback the event.
void register_replay_fn(bool (*replay_fn)(const char*, char*));
// TODO: add one for generically responding to all events.
/// @brief Call this to indicate that the bomb state has transitioned.
/// @param name The name of the event that has occured.
/// @param arg The serialized data associated with the event.
/// This must not contain newline characters such as '\n' or '\r'
void event_occured(const char* name, const char* arg);
/// @brief Sets the recording source.
/// @param stream The stream to record to.
/// @param should_close whether or not the stream should be closed when finished.
/// @return true if the source was updated.
bool set_recording_source(FILE* stream, bool should_close);
/// @brief Sets the playback source.
/// @param stream The stream to playback from.
/// @param should_close whether or not the stream should be closed when finished.
/// @return true if the source was updated.
bool set_playback_source(FILE* stream, bool should_close);
/// @brief Starts recording to the stream specified by `set_recording_source()`.
/// @return true if starting recording is successful.
bool start_recording();
/// @brief Stops recording the state.
/// @return true if stopping the recording is successful.
bool stop_recording();
/// @brief Starts playing back the recording specified by `set_playback_source()`.
/// @return true if starting playback is successful.
bool start_playback();
/// @brief Stops playing back the recording.
/// @return true if stopping the playback is successful.
bool stop_playback();
/// @brief Gets weather or not we are tracking the state
/// This can be helpful to conditionally do extra computation only
/// when we are tracking the state.
/// @return
bool is_state_tracking();
#endif /* STATE_TRACKING_H */

73
main/drivers/tft.cpp
View File

@ -1,5 +1,4 @@
#include "tft.h" #include "tft.h"
#include "state_tracking.h"
static const char* TAG = "tft"; static const char* TAG = "tft";
@ -17,28 +16,16 @@ static lv_style_t style_screen;
SemaphoreHandle_t xGuiSemaphore; SemaphoreHandle_t xGuiSemaphore;
static bool replay_handler(const char* event, char* arg) {
return false;
}
static bool notify_lvgl_flush_ready( static bool notify_lvgl_flush_ready(
esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_io_handle_t panel_io,
esp_lcd_panel_io_event_data_t *edata, esp_lcd_panel_io_event_data_t *edata,
void *user_ctx void *user_ctx
) { ) {
lv_disp_drv_t* disp_driver = (lv_disp_drv_t *)user_ctx; lv_disp_drv_t *disp_driver = (lv_disp_drv_t *)user_ctx;
lv_disp_flush_ready(disp_driver); lv_disp_flush_ready(disp_driver);
return false; return false;
} }
const char base64_chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/// Base 64 encodes a u16... sort of. This doesn't do any of the fancy padding stuff.
static void encode_base64(char* buf, size_t start_idx, uint16_t value) {
buf[start_idx+0] = base64_chars[(value >> 10) & 0x3F];
buf[start_idx+1] = base64_chars[(value >> 4) & 0x3F];
buf[start_idx+2] = base64_chars[(value << 2) & 0x3F];
}
static void lvgl_flush_cb(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map) { static void lvgl_flush_cb(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map) {
esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t) drv->user_data; esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t) drv->user_data;
@ -46,46 +33,7 @@ static void lvgl_flush_cb(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t
int offsetx2 = area->x2; int offsetx2 = area->x2;
int offsety1 = area->y1; int offsety1 = area->y1;
int offsety2 = area->y2; int offsety2 = area->y2;
esp_lcd_panel_draw_bitmap(panel_handle, offsetx1, offsety1, offsetx2 + 1, offsety2 + 1, color_map); esp_lcd_panel_draw_bitmap(panel_handle, offsetx1, offsety1, offsetx2 + 1, offsety2 + 1, color_map);
// TODO: change this to be a kconfig value
#if false
if (is_state_tracking()) {
size_t size = (offsetx2 + 1 - offsetx1) * (offsety2 + 1 - offsety1) + 1;
// if (size > 1024) {
// ESP_LOGW("tft_track_state", "Write too big (%d)! truncating to 1024!", size);
// }
// size = MIN(1024, size);
// 24 bytes for the offsets
// 3 bytes per encoded color
// 1 byte for null terminator
size_t alloc_size = 24 + size * 3 + 1;
char* buf = (char*)malloc(alloc_size);
if (buf != nullptr) {
size_t initial_offset = sprintf(buf, "%d,%d,%d,%d:", offsetx1, offsety1, offsetx2 + 1, offsety2 + 1);
for (size_t i = 0; i < size; i++) {
size_t index = initial_offset + i * 3;
// we assume that the size of the color data is 16b
static_assert(sizeof(lv_color_t) == sizeof(uint16_t), "lv_color_t must be 16b wide");
encode_base64(buf, index, color_map[i].full);
}
buf[initial_offset + (size-1) * 3 + 1] = '\0';
event_occured("TFT_W", buf);
free(buf);
} else {
ESP_LOGE("tft_track_state", "buffer alloc failed!");
}
}
#endif
} }
static void IRAM_ATTR lv_tick_task(void *param) { static void IRAM_ATTR lv_tick_task(void *param) {
@ -139,6 +87,7 @@ static void initialize_display() {
} }
}; };
const esp_lcd_panel_dev_config_t lcd_config = { const esp_lcd_panel_dev_config_t lcd_config = {
.reset_gpio_num = TFT_PIN_RESET, .reset_gpio_num = TFT_PIN_RESET,
.color_space = LCD_RGB_ELEMENT_ORDER_BGR, .color_space = LCD_RGB_ELEMENT_ORDER_BGR,
@ -202,10 +151,10 @@ static void guiTask(void *pvParameter) {
ESP_ERROR_CHECK(esp_timer_create(&lvgl_tick_timer_args, &periodic_timer)); ESP_ERROR_CHECK(esp_timer_create(&lvgl_tick_timer_args, &periodic_timer));
ESP_ERROR_CHECK(esp_timer_start_periodic(periodic_timer, LVGL_UPDATE_PERIOD_MS * 1000)); ESP_ERROR_CHECK(esp_timer_start_periodic(periodic_timer, LVGL_UPDATE_PERIOD_MS * 1000));
screen = lv_scr_act(); screen = lv_disp_get_scr_act(NULL);
lv_style_init(&style_screen); lv_style_init(&style_screen);
lv_style_set_bg_color(&style_screen, lv_color_black()); lv_style_set_bg_color(&style_screen, lv_color_black());
lv_obj_add_style(screen, &style_screen, LV_STATE_DEFAULT); lv_obj_add_style(lv_scr_act(), &style_screen, LV_STATE_DEFAULT);
while (1) { while (1) {
/* Delay 1 tick (assumes FreeRTOS tick is 10ms */ /* Delay 1 tick (assumes FreeRTOS tick is 10ms */
@ -221,14 +170,20 @@ static void guiTask(void *pvParameter) {
vTaskDelete(NULL); vTaskDelete(NULL);
} }
void init_tft() { static void tick_timer_task(void* arg) {
ESP_LOGI(TAG, "Initializing TFT..."); while (1)
{
lv_task_handler();
vTaskDelay(pdMS_TO_TICKS(10));
}
}
void init_tft() {
initialize_spi(); initialize_spi();
initialize_display(); initialize_display();
xTaskCreatePinnedToCore(guiTask, "gui", 4096*2, NULL, 5, NULL, 1); xTaskCreatePinnedToCore(guiTask, "gui", 4096*2, NULL, 5, NULL, 1);
register_replay_fn(replay_handler); // xTaskCreatePinnedToCore(tick_timer_task, "tick_lvgl", 4096, NULL, 5, NULL, 1);
ESP_LOGI(TAG, "TFT initialized!"); ESP_LOGI(TAG, "TFT initialization Successful");
} }

10
main/drivers/tft.h
View File

@ -22,7 +22,7 @@
#include <esp_lcd_panel_io.h> #include <esp_lcd_panel_io.h>
#include <esp_lcd_panel_vendor.h> #include <esp_lcd_panel_vendor.h>
#include <esp_lcd_panel_ops.h> #include <esp_lcd_panel_ops.h>
#include "esp_lcd_ili9488/esp_lcd_ili9488.h" #include <esp_lcd_ili9488.h>
#include <esp_timer.h> #include <esp_timer.h>
#include <freertos/FreeRTOS.h> #include <freertos/FreeRTOS.h>
#include <freertos/task.h> #include <freertos/task.h>
@ -44,11 +44,11 @@
#define SPI_MAX_TRANSFER_SIZE 32768 #define SPI_MAX_TRANSFER_SIZE 32768
#define TFT_PIN_MOSI GPIO_NUM_17 #define TFT_PIN_MOSI GPIO_NUM_17
#define TFT_PIN_MISO GPIO_NUM_16 #define TFT_PIN_MISO GPIO_NUM_18
#define TFT_PIN_CLK GPIO_NUM_18 #define TFT_PIN_CLK GPIO_NUM_16
#define TFT_PIN_CS GPIO_NUM_NC #define TFT_PIN_CS GPIO_NUM_NC
#define TFT_PIN_DC GPIO_NUM_8 #define TFT_PIN_DC GPIO_NUM_15
#define TFT_PIN_RESET GPIO_NUM_9 #define TFT_PIN_RESET GPIO_NUM_8
#define TFT_INVERT_COLOR false #define TFT_INVERT_COLOR false

43
main/drivers/wires.cpp
View File

@ -1,17 +1,10 @@
#include "wires.h" #include "wires.h"
extern uint32_t current_step;
/// The mutex for accessing `I2C_NUM_1` (wires I2C bus).
SemaphoreHandle_t wires_i2c_mutex;
uint32_t total_strikes; uint32_t total_strikes;
uint32_t step_strikes[N_STEPS] = {0};
uint32_t step_finish_times[N_STEPS] = {0};
static const char *TAG = "wires"; static const char *TAG = "wires";
const uint32_t STRIKE_TIME_PENALTY = 30'000; static const uint32_t STRIKE_TIME_PENALTY = 30'000;
static bool button_state; static bool button_state;
static bool button_pressed; static bool button_pressed;
@ -29,25 +22,21 @@ static void receive_button(void);
void init_wires(void) { void init_wires(void) {
i2c_config_t wires_conf = { i2c_config_t wires_conf = {
.mode = I2C_MODE_MASTER, .mode = I2C_MODE_MASTER,
.sda_io_num = PIN_WIRES_SDA, .sda_io_num = GPIO_NUM_41,
.scl_io_num = PIN_WIRES_SCL, .scl_io_num = GPIO_NUM_42,
.sda_pullup_en = GPIO_PULLUP_ENABLE, .sda_pullup_en = GPIO_PULLUP_ENABLE,
.scl_pullup_en = GPIO_PULLUP_ENABLE, .scl_pullup_en = GPIO_PULLUP_ENABLE,
.master = { .master = {
.clk_speed = 100000, .clk_speed = 100000,
}, }
}; };
gpio_reset_pin(PIN_WIRES_SDA); gpio_reset_pin(GPIO_NUM_41);
gpio_reset_pin(PIN_WIRES_SCL); gpio_reset_pin(GPIO_NUM_42);
ESP_ERROR_CHECK(i2c_param_config(WIRES_I2C_NUM, &wires_conf)); ESP_ERROR_CHECK(i2c_param_config(WIRES_I2C_NUM, &wires_conf));
ESP_ERROR_CHECK(i2c_driver_install(WIRES_I2C_NUM, wires_conf.mode, 0, 0, 0)); ESP_ERROR_CHECK(i2c_driver_install(WIRES_I2C_NUM, wires_conf.mode, 0, 0, 0));
// Create mutex for wires I2C bus
wires_i2c_mutex = xSemaphoreCreateMutex();
assert(wires_i2c_mutex != NULL);
gpio_config_t int_pin_conf = {}; gpio_config_t int_pin_conf = {};
// delta_pin_conf.intr_type = GPIO_INTR_LOW_LEVEL; // delta_pin_conf.intr_type = GPIO_INTR_LOW_LEVEL;
int_pin_conf.mode = GPIO_MODE_INPUT; int_pin_conf.mode = GPIO_MODE_INPUT;
@ -90,43 +79,33 @@ void clear_wires_pressed_released_cut(void) {
button_released = false; button_released = false;
} }
void strike(const char* reason) { void strike(char* reason) {
ESP_LOGW("strike!", "%s", reason); ESP_LOGW("strike!", "%s", reason);
lcd_print(3, 0, reason); lcd_set_cursor(&lcd, 0, 3);
lcd_print(&lcd, reason);
time_penalty(STRIKE_TIME_PENALTY); time_penalty(STRIKE_TIME_PENALTY);
if (current_step > 0 && current_step <= N_STEPS) { total_strikes += 1;
total_strikes += 1;
step_strikes[current_step - 1] += 1;
}
uint8_t reg = 6; uint8_t reg = 6;
xSemaphoreTake(wires_i2c_mutex, portMAX_DELAY);
ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_to_device(WIRES_I2C_NUM, WIRES_I2C_ADDR, &reg, 1, (100 / portTICK_PERIOD_MS))); ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_to_device(WIRES_I2C_NUM, WIRES_I2C_ADDR, &reg, 1, (100 / portTICK_PERIOD_MS)));
xSemaphoreGive(wires_i2c_mutex);
} }
void set_leds(uint8_t led_states) { void set_leds(uint8_t led_states) {
buf[0] = 5; // register 5 buf[0] = 5; // register 5
buf[1] = led_states; buf[1] = led_states;
xSemaphoreTake(wires_i2c_mutex, portMAX_DELAY);
ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_to_device(WIRES_I2C_NUM, WIRES_I2C_ADDR, buf, 2, (100 / portTICK_PERIOD_MS))); ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_to_device(WIRES_I2C_NUM, WIRES_I2C_ADDR, buf, 2, (100 / portTICK_PERIOD_MS)));
xSemaphoreGive(wires_i2c_mutex);
} }
static uint8_t receive_delta(void) { static uint8_t receive_delta(void) {
uint8_t reg = 1; uint8_t reg = 1;
buf[0] = 0; buf[0] = 0;
xSemaphoreTake(wires_i2c_mutex, portMAX_DELAY);
ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_read_device(WIRES_I2C_NUM, WIRES_I2C_ADDR, &reg, 1, buf, 1, (100 / portTICK_PERIOD_MS))); ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_read_device(WIRES_I2C_NUM, WIRES_I2C_ADDR, &reg, 1, buf, 1, (100 / portTICK_PERIOD_MS)));
xSemaphoreGive(wires_i2c_mutex);
return buf[0]; return buf[0];
} }
static void receive_wires(void) { static void receive_wires(void) {
uint8_t reg = 2; uint8_t reg = 2;
buf[0] = 0; buf[0] = 0;
xSemaphoreTake(wires_i2c_mutex, portMAX_DELAY);
ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_read_device(WIRES_I2C_NUM, WIRES_I2C_ADDR, &reg, 1, buf, 1, (100 / portTICK_PERIOD_MS))); ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_read_device(WIRES_I2C_NUM, WIRES_I2C_ADDR, &reg, 1, buf, 1, (100 / portTICK_PERIOD_MS)));
xSemaphoreGive(wires_i2c_mutex);
uint8_t new_wires = buf[0]; uint8_t new_wires = buf[0];
uint8_t just_cut = ~new_wires & wires_state; uint8_t just_cut = ~new_wires & wires_state;
@ -138,9 +117,7 @@ static void receive_wires(void) {
static void receive_button(void) { static void receive_button(void) {
uint8_t reg = 3; uint8_t reg = 3;
buf[0] = 0; buf[0] = 0;
xSemaphoreTake(wires_i2c_mutex, portMAX_DELAY);
ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_read_device(WIRES_I2C_NUM, WIRES_I2C_ADDR, &reg, 1, buf, 1, (100 / portTICK_PERIOD_MS))); ESP_ERROR_CHECK_WITHOUT_ABORT(i2c_master_write_read_device(WIRES_I2C_NUM, WIRES_I2C_ADDR, &reg, 1, buf, 1, (100 / portTICK_PERIOD_MS)));
xSemaphoreGive(wires_i2c_mutex);
bool new_button = buf[0] != 0; bool new_button = buf[0] != 0;
bool just_pressed = new_button & !button_state; bool just_pressed = new_button & !button_state;

17
main/drivers/wires.h
View File

@ -5,29 +5,16 @@
#include <driver/i2c.h> #include <driver/i2c.h>
#include <driver/gpio.h> #include <driver/gpio.h>
#include <esp_log.h> #include <esp_log.h>
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "drivers/char_lcd.h" #include "drivers/char_lcd.h"
#include "drivers/game_timer.h" #include "drivers/game_timer.h"
#include "main.h"
#include "perh.h"
#define WIRES_PIN_DELTA PIN_PERH3 #define WIRES_PIN_DELTA GPIO_NUM_2
#define PIN_WIRES_SDA PIN_PERH1
#define PIN_WIRES_SCL PIN_PERH2
#define WIRES_I2C_NUM I2C_NUM_1 #define WIRES_I2C_NUM I2C_NUM_1
#define WIRES_I2C_ADDR 125 #define WIRES_I2C_ADDR 125
/// The mutex for accessing `I2C_NUM_1` (wires I2C bus).
extern SemaphoreHandle_t wires_i2c_mutex;
#define DELTA_BIT_WIRES 0 #define DELTA_BIT_WIRES 0
#define DELTA_BIT_BUTTON 1 #define DELTA_BIT_BUTTON 1
extern const uint32_t STRIKE_TIME_PENALTY;
extern uint32_t step_strikes[N_STEPS];
extern uint32_t step_finish_times[N_STEPS];
extern uint32_t total_strikes; extern uint32_t total_strikes;
void init_wires(void); void init_wires(void);
@ -42,6 +29,6 @@ void clear_wires_pressed_released_cut(void);
void set_leds(uint8_t led_states); void set_leds(uint8_t led_states);
void strike(const char* reason); void strike(char* reason);
#endif /* WIRES_HPP */ #endif /* WIRES_HPP */

152
main/drivers/wlvgl.cpp
View File

@ -1,152 +0,0 @@
#include "wlvgl.h"
#include <vector>
/// A table that maps an incrementing integer to a style reference
static std::vector<lv_style_t*> style_table;
/// A table that maps an incrementing integer to a style reference
static std::vector<lv_obj_t*> obj_table;
static int index_of_style(lv_style_t* style) {
for (size_t i = 0; i < style_table.size(); i++) {
if (style_table[i] == style) {
return i;
}
}
return -1;
}
static int index_of_obj(lv_obj_t* obj) {
for (size_t i = 0; i < obj_table.size(); i++) {
if (obj_table[i] == obj) {
return i;
}
}
return -1;
}
void reset_wlv_tables() {
style_table.clear();
obj_table.clear();
}
lv_obj_t * wlv_obj_create(lv_obj_t* parent) {
// initialize the obj
lv_obj_t* value = lv_obj_create(parent);
if (is_state_tracking()) {
// add the style to the table
obj_table.push_back(value);
size_t obj_index = obj_table.size();
char buf[8];
sprintf(buf, "%d", obj_index);
event_occured("lv_obj_create", buf);
}
return value;
}
void wlv_style_init(lv_style_t* style) {
// initialize the style
lv_style_init(style);
if (is_state_tracking()) {
// add the style to the table
style_table.push_back(style);
size_t style_index = style_table.size();
char buf[8];
sprintf(buf, "%d", style_index);
event_occured("lv_style_init", buf);
}
}
void wlv_obj_set_style_bg_color(lv_obj_t* obj, lv_color_t value, lv_style_selector_t selector) {
lv_obj_set_style_bg_color(obj, value, selector);
if (is_state_tracking()) {
int obj_index = index_of_obj(obj);
char buf[64];
sprintf(buf, "%d,%d,%ld", obj_index, value.full, selector);
event_occured("lv_obj_set_style_bg_color", buf);
}
}
void wlv_style_set_text_color() {
}
void wlv_style_set_text_align() {
}
void wlv_obj_align() {
}
void wlv_obj_set_size() {
}
void wlv_obj_add_style() {
}
void wlv_obj_set_style_text_align() {
}
void wlv_label_set_text() {
}
void wlv_scr_load() {
}
void wlv_scr_act() {
}
void wlv_style_set_bg_color() {
}
void wlv_style_set_bg_opa() {
}
void wlv_obj_set_width() {
}
void wlv_style_set_text_font() {
}
void wlv_label_create() {
}
void wlv_obj_del() {
}
void wlv_obj_center() {
}
void wlv_obj_remove_style() {
}
void wlv_obj_add_flag() {
}
void wlv_obj_clear_flag() {
}

32
main/drivers/wlvgl.h
View File

@ -1,32 +0,0 @@
#ifndef WLVGL_H
#define WLVGL_H
#include "lvgl.h"
#include "state_tracking.h"
void reset_wlv_tables();
lv_obj_t* wlv_obj_create(lv_obj_t* parent);
void wlv_style_init(lv_style_t* style);
void wlv_obj_set_style_bg_color(struct _lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
void wlv_style_set_text_color();
void wlv_style_set_text_align();
void wlv_obj_align();
void wlv_obj_set_size();
void wlv_obj_add_style();
void wlv_obj_set_style_text_align();
void wlv_label_set_text();
void wlv_scr_load();
void wlv_scr_act();
void wlv_style_set_bg_color();
void wlv_style_set_bg_opa();
void wlv_obj_set_width();
void wlv_style_set_text_font();
void wlv_label_create();
void wlv_obj_del();
void wlv_obj_center();
void wlv_obj_remove_style();
void wlv_obj_add_flag();
void wlv_obj_clear_flag();
#endif /* WLVGL_H */

167
main/helper.cpp
View File

@ -1,14 +1,13 @@
#include "helper.h" #include "helper.h"
// TODO: move to driver
void clean_bomb(void) { void clean_bomb(void) {
// clear pending inputs // clear pending inputs
clear_all_pressed_released(); clear_all_pressed_released();
clear_wires_pressed_released_cut(); clear_wires_pressed_released_cut();
// clear leds // clear leds
leds_clear(); led_strip_clear(leds);
leds_flush(); led_strip_refresh(leds);
// clear module timer // clear module timer
stop_module_timer(); stop_module_timer();
@ -17,111 +16,89 @@ void clean_bomb(void) {
set_module_sseg_raw(clear); set_module_sseg_raw(clear);
// clear char lcd // clear char lcd
lcd_set_cursor_vis(false); lcd_clear(&lcd);
lcd_clear(); lcd_no_cursor(&lcd);
lcd_set_cursor(&lcd, 0, 0);
// TODO: add stuff for starcode system
} }
static lv_obj_t* old_scr; void poster_child_task(void* arg) {
static lv_obj_t* scr; while (1) {
if (get_help_button_pressed()) {
static lv_style_t game_results_style; play_raw(MOUNT_POINT "/poster.pcm");
static lv_obj_t* overall_results_label; }
static lv_obj_t* breakdown_results_label; vTaskDelay(pdMS_TO_TICKS(10));
static lv_obj_t* strike_numbers_label;
static lv_obj_t* step_times_label;
static void write_time(char* buf, int32_t game_time) {
char minus[2] = "\0";
if (game_time < 0) {
minus[0] = '-';
game_time = -game_time;
} }
uint8_t hours = (game_time / (1000*60*60)) % 10; vTaskDelete(NULL);
uint8_t minutes = (game_time / (1000*60)) % 60;
uint8_t seconds = (game_time / (1000)) % 60;
sprintf(buf, "%s%d:%02d:%02d", minus, hours, minutes, seconds);
} }
extern uint32_t initial_game_time;
void display_game_results(void) {
while (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdFALSE) vTaskDelay(pdMS_TO_TICKS(10));
scr = lv_obj_create(NULL);
lv_obj_set_style_bg_color(scr, lv_color_black(), LV_STATE_DEFAULT);
lv_style_init(&game_results_style); static const int STRING_MAX_LEN = 8;
lv_style_set_text_color(&game_results_style, lv_color_white()); void do_star_codes(StarCodeHandler* star_codes, int star_codes_len) {
lv_style_set_text_align(&game_results_style, LV_TEXT_ALIGN_LEFT); KeypadKey key;
overall_results_label = lv_label_create(scr); int current_idx = 0;
lv_obj_align(overall_results_label, LV_ALIGN_TOP_LEFT, 20, 20); char current[STRING_MAX_LEN+1] = {0};
lv_obj_set_size(overall_results_label, 460, 140);
lv_obj_add_style(overall_results_label, &game_results_style, LV_STATE_DEFAULT);
breakdown_results_label = lv_label_create(scr); while (1) {
lv_obj_align(breakdown_results_label, LV_ALIGN_BOTTOM_LEFT, 20, 0); while (get_pressed_keypad(&key)) {
lv_obj_set_size(breakdown_results_label, 460, 140); if (key == KeypadKey::star) {
lv_obj_add_style(breakdown_results_label, &game_results_style, LV_STATE_DEFAULT); current[0] = '*';
for (int i = 1; i < STRING_MAX_LEN; i++) {
current[i] = 0;
}
current_idx = 1;
} else if (key == KeypadKey::pound) {
// submit
if (current[0] == '\0') {
continue;
}
strike_numbers_label = lv_label_create(scr); bool hit = false;
lv_obj_align(strike_numbers_label, LV_ALIGN_BOTTOM_LEFT, 90, 0); for (int i = 0; i < star_codes_len; i++) {
lv_obj_set_size(strike_numbers_label, 60, 140); StarCodeHandler sch = star_codes[i];
lv_obj_add_style(strike_numbers_label, &game_results_style, LV_STATE_DEFAULT); if (strcmp(current, sch.code) == 0) {
lv_obj_set_style_text_align(strike_numbers_label, LV_TEXT_ALIGN_RIGHT, LV_STATE_DEFAULT); hit = true;
lcd_set_cursor(&lcd, 1, 2);
lcd_print(&lcd, sch.display_text);
vTaskDelay(pdMS_TO_TICKS(2000));
if (sch.callback != nullptr) {
(sch.callback)();
}
if (sch.should_exit) {
return;
}
break;
}
}
step_times_label = lv_label_create(scr); if (!hit) {
lv_obj_align(step_times_label, LV_ALIGN_BOTTOM_LEFT, 140, 0); lcd_set_cursor(&lcd, 1, 2);
lv_obj_set_size(step_times_label, 80, 140); lcd_print(&lcd, "Invalid Star Code");
lv_obj_add_style(step_times_label, &game_results_style, LV_STATE_DEFAULT); vTaskDelay(pdMS_TO_TICKS(2000));
lv_obj_set_style_text_align(step_times_label, LV_TEXT_ALIGN_RIGHT, LV_STATE_DEFAULT); }
char buf[1024] = {0}; // clear
for (int i = 0; i < STRING_MAX_LEN; i++) {
current[i] = 0;
}
current_idx = 0;
} else {
// out of room. skip
if (current_idx >= STRING_MAX_LEN) break;
// no code started.
if (current[0] != '*') continue;
char time_buf_1[32] = {0}; char c = char_of_keypad_key(key);
char time_buf_2[32] = {0}; current[current_idx++] = c;
char time_buf_3[32] = {0}; }
char time_buf_4[32] = {0}; // ESP_LOGI(STEP0_TAG, "Pressed: %c", c);
char time_buf_5[32] = {0};
char time_buf_6[32] = {0};
int32_t time_left = get_game_time(); lcd_clear(&lcd);
int32_t time_spent = initial_game_time - time_left; lcd_set_cursor(&lcd, 1, 1);
int32_t true_time_spent = time_spent - (total_strikes * STRIKE_TIME_PENALTY); lcd_print(&lcd, current);
write_time(time_buf_1, time_left); }
write_time(time_buf_2, time_spent);
write_time(time_buf_3, true_time_spent);
sprintf(buf, vTaskDelay(pdMS_TO_TICKS(10));
"Finished!\n\tTotal Strikes: %ld\n\tTime Left (w/ penalties): %s\n\tTime Spent (w/ penalties): %s\n\tTrue Time Spent: %s\n\n", }
total_strikes, time_buf_1, time_buf_2, time_buf_3
);
lv_label_set_text(overall_results_label, buf);
lv_label_set_text(breakdown_results_label, "Step Breakdown:\n\tStep 1: \n\tStep 2:\n\tStep 3:\n\tStep 4:\n\tStep 5:\n\tStep 6:");
sprintf(buf,
"\n%ld strikes\n%ld strikes\n%ld strikes\n%ld strikes\n%ld strikes\n%ld strikes",
step_strikes[0], step_strikes[1], step_strikes[2], step_strikes[3], step_strikes[4], step_strikes[5]
);
lv_label_set_text(strike_numbers_label, buf);
write_time(time_buf_1, initial_game_time - step_finish_times[0]);
write_time(time_buf_2, step_finish_times[0] - step_finish_times[1]);
write_time(time_buf_3, step_finish_times[1] - step_finish_times[2]);
write_time(time_buf_4, step_finish_times[2] - step_finish_times[3]);
write_time(time_buf_5, step_finish_times[3] - step_finish_times[4]);
write_time(time_buf_6, step_finish_times[4] - step_finish_times[5]);
sprintf(buf,
"\n%s\n%s\n%s\n%s\n%s\n%s",
time_buf_1, time_buf_2, time_buf_3, time_buf_4, time_buf_5, time_buf_6
);
lv_label_set_text(step_times_label, buf);
old_scr = lv_scr_act();
lv_scr_load(scr);
xSemaphoreGive(xGuiSemaphore);
} }

11
main/helper.h
View File

@ -8,13 +8,20 @@
#include "drivers/char_lcd.h" #include "drivers/char_lcd.h"
#include "drivers/leds.h" #include "drivers/leds.h"
#include "drivers/speaker.h" #include "drivers/speaker.h"
#include "drivers/tft.h"
struct StarCodeHandler {
char* code;
char* display_text;
bool should_exit;
void (*callback)(void);
};
// TODO: add something for RNG. // TODO: add something for RNG.
// TODO: add something for colors, to make everything consistant.
/// Clears most persistant bomb state /// Clears most persistant bomb state
void clean_bomb(void); void clean_bomb(void);
void poster_child_task(void* arg); void poster_child_task(void* arg);
void display_game_results(); void do_star_codes(StarCodeHandler* star_codes, int star_codes_len);
#endif /* HELPER_H */ #endif /* HELPER_H */

2
main/idf_component.yml
View File

@ -3,7 +3,7 @@ dependencies:
# iamflinks/i2c_lcd_pcf8574: "^1.0.1" # iamflinks/i2c_lcd_pcf8574: "^1.0.1"
espressif/led_strip: "^2.5.4" espressif/led_strip: "^2.5.4"
lvgl/lvgl: "^8.1" lvgl/lvgl: "^8.1"
# atanisoft/esp_lcd_ili9488: "^1.0.9" atanisoft/esp_lcd_ili9488: "^1.0.9"
## Required IDF version ## Required IDF version
idf: idf:
version: ">=4.1.0" version: ">=4.1.0"

101
main/main.cpp
View File

@ -1,14 +1,18 @@
#include "main.h"
#include <stdio.h> #include <stdio.h>
#include "sdkconfig.h" #include "sdkconfig.h"
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "freertos/task.h" #include "freertos/task.h"
#include "driver/uart.h"
#include "driver/i2c.h"
#include "drivers/tft.h"
#include "drivers/wires.h"
#include "drivers/bottom_half.h"
#include "drivers/sd.h"
#include "drivers/game_timer.h"
#include "drivers/speaker.h"
#include "drivers/char_lcd.h"
#include "esp_rom_gpio.h" #include "esp_rom_gpio.h"
#include "esp_heap_caps.h" #include "drivers/leds.h"
#include "drivers/all.h"
#include "drivers/state_tracking.h"
#include "helper.h" #include "helper.h"
@ -21,68 +25,77 @@
#include "steps/step6.h" #include "steps/step6.h"
static const char *TAG = "main"; static const char *TAG = "main";
uint32_t initial_game_time = 90*60*1000 + 1000; uint32_t initial_game_time = 60*60*1000;
uint32_t skip_to_step = 0; uint32_t skip_to_step = 0;
uint32_t current_step = 0;
extern uint32_t total_strikes; static void print_bin(char* out_str, uint8_t n) {
out_str[0] = ((n & 0b1000) ? '1' : '0');
out_str[1] = ((n & 0b0100) ? '1' : '0');
out_str[2] = ((n & 0b0010) ? '1' : '0');
out_str[3] = ((n & 0b0001) ? '1' : '0');
}
static void debug_switches() {
uint8_t switch_state = 0;
uint8_t button_state = 0;
char buff[5] = {0};
while (1) {
uint8_t new_button_state = get_button_state();
if (new_button_state != button_state) {
button_state = new_button_state;
print_bin(buff, button_state);
ESP_LOGI("main", "b: 0b%s", buff);
}
uint8_t new_switch_state = get_switch_state();
if (new_switch_state != switch_state) {
switch_state = new_switch_state;
print_bin(buff, switch_state);
ESP_LOGI("main", "s: 0b%s", buff);
}
vTaskDelay(pdMS_TO_TICKS(10));
}
}
extern "C" void app_main(void) { extern "C" void app_main(void) {
printf("app_main\n"); printf("app_main\n");
init_drivers(); init_sd();
init_tft();
// TODO: get wires out of the drivers init_speaker();
// TODO: generify the strike system out of wires init_sseg();
init_game_module_timer();
init_leds();
init_wires(); init_wires();
vTaskDelay(pdMS_TO_TICKS(1000));
init_bottom_half();
init_char_lcd();
// debug_switches();
clean_bomb(); clean_bomb();
lcd_do_splash();
step0(); step0();
set_game_time(initial_game_time + 1000);
// set_recording_source(stdout, false);
FILE* record_file = fopen(MOUNT_POINT "/record.txt", "w");
if (record_file == nullptr) {
ESP_LOGE("main", "failed to open record.txt");
}
set_recording_source(record_file, true);
start_recording();
set_game_time(initial_game_time);
start_game_timer(); start_game_timer();
total_strikes = 0;
clean_bomb(); clean_bomb();
current_step = 1;
if (skip_to_step <= 1) step1(); if (skip_to_step <= 1) step1();
step_finish_times[current_step-1] = get_game_time();
clean_bomb(); clean_bomb();
current_step = 2;
if (skip_to_step <= 2) step2(); if (skip_to_step <= 2) step2();
step_finish_times[current_step-1] = get_game_time();
clean_bomb(); clean_bomb();
current_step = 3;
if (skip_to_step <= 3) step3(); if (skip_to_step <= 3) step3();
step_finish_times[current_step-1] = get_game_time();
clean_bomb(); clean_bomb();
current_step = 4;
if (skip_to_step <= 4) step4(); if (skip_to_step <= 4) step4();
step_finish_times[current_step-1] = get_game_time();
clean_bomb(); clean_bomb();
current_step = 5;
if (skip_to_step <= 5) step5(); if (skip_to_step <= 5) step5();
step_finish_times[current_step-1] = get_game_time();
clean_bomb(); clean_bomb();
current_step = 6;
if (skip_to_step <= 6) step6(); if (skip_to_step <= 6) step6();
start_game_timer();
step_finish_times[current_step-1] = get_game_time();
clean_bomb(); clean_bomb();
stop_game_timer(); stop_game_timer();
ESP_LOGI(TAG, "Bomb has been diffused. Counter-Terrorists win."); ESP_LOGI(TAG, "Bomb has been diffused. Counter-Terrorists win.");
play_clip_wav(MOUNT_POINT "/diffuse.wav", true, false, 3, 0); ESP_ERROR_CHECK_WITHOUT_ABORT(play_raw("/sdcard/diffused.pcm"));
display_game_results();
stop_recording();
} }

8
main/main.h
View File

@ -1,8 +0,0 @@
#ifndef MAIN_H
#define MAIN_H
#include <cstddef>
constexpr size_t N_STEPS = 6;
#endif /* MAIN_H */

2
main/steps/CMakeLists.txt
View File

@ -10,6 +10,4 @@ set(SOURCES
"wires_puzzle.cpp" "wires_puzzle.cpp"
) )
add_subdirectory(tetris_resources)
target_sources(${COMPONENT_LIB} PRIVATE ${SOURCES}) target_sources(${COMPONENT_LIB} PRIVATE ${SOURCES})

22
main/steps/setup_wires.cpp
View File

@ -6,13 +6,16 @@ void print_wires(WireColor* wires, int editing_idx) {
bool cut[NUM_WIRES]; bool cut[NUM_WIRES];
solve_wires(wires, cut); solve_wires(wires, cut);
lcd_set_cursor(&lcd, 1, 1);
char string_buf[NUM_WIRES+1] = {0}; char string_buf[NUM_WIRES+1] = {0};
wires_to_string(wires, string_buf); wires_to_string(wires, string_buf);
lcd_print(1, 1, string_buf); lcd_print(&lcd, string_buf);
lcd_set_cursor(&lcd, 1, 2);
cut_to_string(cut, string_buf); cut_to_string(cut, string_buf);
lcd_print(2, 1, string_buf); lcd_print(&lcd, string_buf);
lcd_set_cursor(&lcd, 1, 3);
wires_state = get_wires(); wires_state = get_wires();
for (int i = 0; i < NUM_WIRES; i++) { for (int i = 0; i < NUM_WIRES; i++) {
if (wires_state & (1<<i)) { if (wires_state & (1<<i)) {
@ -21,17 +24,16 @@ void print_wires(WireColor* wires, int editing_idx) {
string_buf[i] = '!'; string_buf[i] = '!';
} }
} }
lcd_print(3, 1, string_buf); lcd_print(&lcd, string_buf);
lcd_set_cursor_vis(true); lcd_set_cursor(&lcd, editing_idx+1, 1);
lcd_set_cursor_resting_position(1, editing_idx+1);
} }
void setup_wires(void) { void setup_wires(void) {
clear_all_pressed_released(); clear_all_pressed_released();
get_cut_wires(); get_cut_wires();
lcd_clear(); lcd_clear(&lcd);
lcd_set_cursor_vis(true); lcd_cursor(&lcd);
WireColor wires[NUM_WIRES]; WireColor wires[NUM_WIRES];
load_wires_from_sd_card(wires); load_wires_from_sd_card(wires);
@ -43,18 +45,18 @@ void setup_wires(void) {
ButtonKey button; ButtonKey button;
while (1) { while (1) {
while (get_keypad_pressed(&key)) { while (get_pressed_keypad(&key)) {
if (key == KeypadKey::k1) { if (key == KeypadKey::k1) {
generate_new_wires(wires); generate_new_wires(wires);
save_wires_to_sd_card(wires); save_wires_to_sd_card(wires);
print_wires(wires, editing_idx); print_wires(wires, editing_idx);
} else if (key == KeypadKey::pound) { } else if (key == KeypadKey::pound) {
lcd_set_cursor_vis(false); lcd_no_cursor(&lcd);
return; return;
} }
} }
while (get_button_pressed(&button)) { while (get_pressed_button(&button)) {
if (button == ButtonKey::b1) { if (button == ButtonKey::b1) {
// left // left
editing_idx = editing_idx - 1; editing_idx = editing_idx - 1;

396
main/steps/step0.cpp
View File

@ -1,271 +1,177 @@
#include "step0.h" #include "step0.h"
#include "drivers/state_tracking.h"
static const char* TAG = "step0"; static const char* TAG = "step0";
extern uint32_t initial_game_time; extern uint32_t initial_game_time;
extern uint32_t skip_to_step; extern uint32_t skip_to_step;
static void set_game_time(); static void set_game_time(void);
static void skip_to_step1() { skip_to_step = 1; } static void skip_to_step1(void) { skip_to_step = 1; }
static void skip_to_step2() { skip_to_step = 2; } static void skip_to_step2(void) { skip_to_step = 2; }
static void skip_to_step3() { skip_to_step = 3; } static void skip_to_step3(void) { skip_to_step = 3; }
static void skip_to_step4() { skip_to_step = 4; } static void skip_to_step4(void) { skip_to_step = 4; }
static void skip_to_step5() { skip_to_step = 5; } static void skip_to_step5(void) { skip_to_step = 5; }
static void skip_to_step6() { skip_to_step = 6; } static void skip_to_step6(void) { skip_to_step = 6; }
static void try_step1() { clean_bomb(); step1(); } static void try_step1(void) { clean_bomb(); step1(); }
static void try_step2() { clean_bomb(); step2(); } static void try_step2(void) { clean_bomb(); step2(); }
static void try_step3() { clean_bomb(); step3(); } static void try_step3(void) { clean_bomb(); step3(); }
static void try_step4() { clean_bomb(); step4(); } static void try_step4(void) { clean_bomb(); step4(); }
static void try_step5() { clean_bomb(); step5(); } static void try_step5(void) { clean_bomb(); step5(); }
static void try_step6() { clean_bomb(); step6(); } static void try_step6(void) { clean_bomb(); step6(); }
static void issue_strike() { strike("Strike Issued"); } static void issue_strike(void) { strike("Strike Issued"); }
static void flashbang();
static void debug_switches();
static void battery_stats() {
BaseType_t xReturned;
TaskHandle_t xHandle = NULL;
xReturned = xTaskCreate(bat_monitor_task, "bat_monitor", 4096, NULL, 5, &xHandle);
KeypadKey k; /// Wait for "*9819"
while (!get_keypad_pressed(&k) || k != KeypadKey::pound) vTaskDelay(pdMS_TO_TICKS(10)); void step0(void) {
StarCodeHandler star_codes[] = {
if (xReturned == pdPASS) {
vTaskDelete(xHandle);
}
}
// TODO: remove. This is temperary
static void replay_last() {
FILE* record_file = fopen(MOUNT_POINT "/record.txt", "r");
if (record_file == nullptr) {
ESP_LOGE("main", "failed to open record.txt");
}
set_playback_source(record_file, true);
start_playback();
}
void step0() {
led_set(IndicatorLED::LED_SPEAKER, LEDColor::LED_COLOR_BLUE);
leds_flush();
SemaphoreHandle_t continue_sem = xSemaphoreCreateBinary();
if (continue_sem == nullptr) {
ESP_LOGE(TAG, "could not create semaphore");
return;
}
StarCodeEntry star_codes[] = {
{ {
.code = "9819", .code = "*9819",
.display_text = "Diffusal Initiated", .display_text = "Diffusal Initiated",
.delay_us = 2'000'000, .should_exit = true,
.callback = nullptr, .callback = nullptr,
.triggered_sem = continue_sem,
}, },
{ {
.code = "59860", .code = "*59861",
.display_text = "Hardware Config", .display_text = "Set Up Wires",
.delay_us = 2'000'000, .should_exit = false,
.callback = hardware_config,
.triggered_sem = nullptr,
},
{
.code = "59861",
.display_text = "Setup Wires",
.delay_us = 2'000'000,
.callback = setup_wires, .callback = setup_wires,
.triggered_sem = nullptr,
}, },
{ {
.code = "59862", .code = "*59862",
.display_text = "Set Game Time", .display_text = "Set Game Time",
.delay_us = 2'000'000, .should_exit = false,
.callback = set_game_time, .callback = set_game_time,
.triggered_sem = nullptr,
}, },
{ {
.code = "59863", .code = "*59871",
.display_text = "Debug switches",
.delay_us = 2'000'000,
.callback = debug_switches,
.triggered_sem = nullptr,
},
{
.code = "59864",
.display_text = "Battery Stats",
.delay_us = 2'000'000,
.callback = battery_stats,
.triggered_sem = nullptr,
},
{
.code = "59871",
.display_text = "Try Step 1", .display_text = "Try Step 1",
.delay_us = 2'000'000, .should_exit = false,
.callback = try_step1, .callback = try_step1,
.triggered_sem = nullptr,
}, },
{ {
.code = "59872", .code = "*59872",
.display_text = "Try Step 2", .display_text = "Try Step 2",
.delay_us = 2'000'000, .should_exit = false,
.callback = try_step2, .callback = try_step2,
.triggered_sem = nullptr,
}, },
{ {
.code = "59873", .code = "*59873",
.display_text = "Try Step 3", .display_text = "Try Step 3",
.delay_us = 2'000'000, .should_exit = false,
.callback = try_step3, .callback = try_step3,
.triggered_sem = nullptr,
}, },
{ {
.code = "59874", .code = "*59874",
.display_text = "Try Step 4", .display_text = "Try Step 4",
.delay_us = 2'000'000, .should_exit = false,
.callback = try_step4, .callback = try_step4,
.triggered_sem = nullptr,
}, },
{ {
.code = "59875", .code = "*59875",
.display_text = "Try Step 5", .display_text = "Try Step 5",
.delay_us = 2'000'000, .should_exit = false,
.callback = try_step5, .callback = try_step5,
.triggered_sem = nullptr,
}, },
{ {
.code = "59876", .code = "*59876",
.display_text = "Try Step 6", .display_text = "Try Step 6",
.delay_us = 2'000'000, .should_exit = false,
.callback = try_step6, .callback = try_step6,
.triggered_sem = nullptr,
}, },
{ {
.code = "59881", .code = "*59881",
.display_text = "Skip To Step 1", .display_text = "Skip To Step 1",
.delay_us = 2'000'000, .should_exit = true,
.callback = skip_to_step1, .callback = skip_to_step1,
.triggered_sem = continue_sem,
}, },
{ {
.code = "59882", .code = "*59882",
.display_text = "Skip To Step 2", .display_text = "Skip To Step 2",
.delay_us = 2'000'000, .should_exit = true,
.callback = skip_to_step2, .callback = skip_to_step2,
.triggered_sem = continue_sem,
}, },
{ {
.code = "59883", .code = "*59883",
.display_text = "Skip To Step 3", .display_text = "Skip To Step 3",
.delay_us = 2'000'000, .should_exit = true,
.callback = skip_to_step3, .callback = skip_to_step3,
.triggered_sem = continue_sem,
}, },
{ {
.code = "59884", .code = "*59884",
.display_text = "Skip To Step 4", .display_text = "Skip To Step 4",
.delay_us = 2'000'000, .should_exit = true,
.callback = skip_to_step4, .callback = skip_to_step4,
.triggered_sem = continue_sem,
}, },
{ {
.code = "59885", .code = "*59885",
.display_text = "Skip To Step 5", .display_text = "Skip To Step 5",
.delay_us = 2'000'000, .should_exit = true,
.callback = skip_to_step5, .callback = skip_to_step5,
.triggered_sem = continue_sem,
}, },
{ {
.code = "59886", .code = "*59886",
.display_text = "Skip To Step 6", .display_text = "Skip To Step 6",
.delay_us = 2'000'000, .should_exit = true,
.callback = skip_to_step6, .callback = skip_to_step6,
.triggered_sem = continue_sem,
}, },
{ {
.code = "1111", .code = "*1111",
.display_text = "Issue Strike", .display_text = "Issue Strike",
.delay_us = 2'000'000, .should_exit = false,
.callback = issue_strike, .callback = issue_strike,
.triggered_sem = nullptr,
},
{
.code = "1112",
.display_text = "????",
.delay_us = 2'000'000,
.callback = flashbang,
.triggered_sem = nullptr,
},
{
.code = "1113",
.display_text = "replay",
.delay_us = 2'000'000,
.callback = replay_last,
.triggered_sem = continue_sem,
}, },
}; };
size_t len = sizeof(star_codes)/sizeof(star_codes[0]); int len = sizeof(star_codes)/sizeof(StarCodeHandler);
do_star_codes(star_codes, len);
add_star_codes(star_codes, len);
xSemaphoreTake(continue_sem, portMAX_DELAY);
rm_star_codes(star_codes, len);
vSemaphoreDelete(continue_sem);
} }
static const int CURSOR_POS_MAP[5] = {1, 3, 4, 6, 7}; static const char* SECONDS_OR_MINUTES[] = {
static char str_buf[18] = {0}; "Minutes",
static void _update_display(uint8_t* digits, uint8_t cursor_pos) { "Seconds",
sprintf(str_buf, "%d:%d%d:%d%d", digits[0], digits[1], digits[2], digits[3], digits[4]); };
lcd_clear();
lcd_print(1, 1, str_buf);
cursor_pos = MAX(0, MIN(4, cursor_pos));
int mapped_cursor_pos = CURSOR_POS_MAP[cursor_pos];
lcd_set_cursor_resting_position(1, mapped_cursor_pos);
}
static void set_game_time() {
uint8_t hours = (initial_game_time / (1000*60*60)) % 10;
uint8_t minutes = (initial_game_time / (1000*60)) % 60;
uint8_t seconds = (initial_game_time / (1000)) % 60;
uint8_t digits[5] = {hours, (uint8_t)(minutes / 10), (uint8_t)(minutes % 10), (uint8_t)(seconds / 10), (uint8_t)(seconds % 10)};
uint8_t cursor_pos = 0;
lcd_set_cursor_vis(true);
_update_display(digits, cursor_pos);
static const int STRING_MAX_LEN = 8;
static void set_game_time(void) {
KeypadKey key; KeypadKey key;
ButtonKey button; bool seconds = true;
int current = initial_game_time / 1000;
char str_buf[21] = {0};
lcd_clear(&lcd);
lcd_set_cursor(&lcd, 1, 1);
sprintf(str_buf, "%d", current);
lcd_print(&lcd, str_buf);
lcd_set_cursor(&lcd, 1, 2);
lcd_print(&lcd, SECONDS_OR_MINUTES[seconds]);
while (1) { while (1) {
while (get_keypad_pressed(&key)) { while (get_pressed_keypad(&key)) {
if (key == KeypadKey::star) { if (key == KeypadKey::star) {
digits[0] = 0; current = 0;
digits[1] = 0;
digits[2] = 0;
digits[3] = 0;
digits[4] = 0;
cursor_pos = 0;
} else if (key == KeypadKey::pound) { } else if (key == KeypadKey::pound) {
// submit // submit
if (digits[0] != 0 || digits[1] != 0 || digits[2] != 0 || digits[3] != 0 || digits[4] != 0) { if (current == 0) {
uint32_t new_game_time = 0; clean_bomb();
new_game_time += digits[0] * (1000*60*60); return;
new_game_time += (digits[1] * 10 + digits[2]) * (1000*60);
new_game_time += (digits[3] * 10 + digits[4]) * (1000);
initial_game_time = new_game_time;
} }
if (seconds) {
initial_game_time = current * 1000;
} else {
initial_game_time = current * 60*1000;
}
clean_bomb(); clean_bomb();
led_set(IndicatorLED::LED_SPEAKER, LEDColor::LED_COLOR_BLUE);
leds_flush();
return; return;
} else if (key == KeypadKey::ka) {
if (seconds) {
current = current / 60;
} else {
current = current * 60;
}
seconds = !seconds;
} else { } else {
int just_pressed = -1; int just_pressed = 0;
switch (key) { switch (key) {
case KeypadKey::k0:
just_pressed = 0;
break;
case KeypadKey::k1: case KeypadKey::k1:
just_pressed = 1; just_pressed = 1;
break; break;
@ -297,129 +203,17 @@ static void set_game_time() {
break; break;
} }
if (just_pressed != -1) { current = (current * 10) + just_pressed;
digits[cursor_pos] = just_pressed;
cursor_pos = MIN(4, cursor_pos+1);
}
} }
_update_display(digits, cursor_pos); lcd_clear(&lcd);
} lcd_set_cursor(&lcd, 1, 1);
sprintf(str_buf, "%d", current);
while (get_button_pressed(&button)) { lcd_print(&lcd, str_buf);
if (button == ButtonKey::b1) { lcd_set_cursor(&lcd, 1, 2);
cursor_pos = MAX(0, cursor_pos-1); lcd_print(&lcd, SECONDS_OR_MINUTES[seconds]);
} else if (button == ButtonKey::b2) {
cursor_pos = MIN(4, cursor_pos+1);
}
_update_display(digits, cursor_pos);
} }
vTaskDelay(pdMS_TO_TICKS(10)); vTaskDelay(pdMS_TO_TICKS(10));
} }
} }
static void print_4bin_rev(char* out_str, uint8_t n) {
out_str[0] = ((n & 0b0001) ? '1' : '0');
out_str[1] = ((n & 0b0010) ? '1' : '0');
out_str[2] = ((n & 0b0100) ? '1' : '0');
out_str[3] = ((n & 0b1000) ? '1' : '0');
out_str[4] = '\0';
}
static void debug_switches() {
clean_bomb();
uint8_t switch_state = 0xFF;
uint8_t switch_touch_state = 0xFF;
uint8_t button_state = 0xFF;
char bin_buf[5] = {0};
char buf[21] = {0};
KeypadKey key;
ButtonKey button;
SwitchKey switch_;
while (1) {
if (get_button_pressed(&button)) {
sprintf(buf, "Button Pressed: %d ", button);
lcd_print(3, 0, buf);
ESP_LOGI(TAG, "%s", buf);
}
if (get_button_released(&button)) {
sprintf(buf, "Button Released: %d", button);
lcd_print(3, 0, buf);
ESP_LOGI(TAG, "%s", buf);
}
if (get_switch_flipped_down(&switch_)) {
sprintf(buf, "Switch Down: %d ", switch_);
lcd_print(3, 0, buf);
ESP_LOGI(TAG, "%s", buf);
}
if (get_switch_flipped_up(&switch_)) {
sprintf(buf, "Switch Up: %d ", switch_);
lcd_print(3, 0, buf);
ESP_LOGI(TAG, "%s", buf);
}
if (get_switch_touch_pressed(&switch_)) {
sprintf(buf, "Switch Touch: %d ", switch_);
lcd_print(3, 0, buf);
ESP_LOGI(TAG, "%s", buf);
}
if (get_switch_touch_released(&switch_)) {
sprintf(buf, "Switch Un-touch: %d", switch_);
lcd_print(3, 0, buf);
ESP_LOGI(TAG, "%s", buf);
}
uint8_t new_switch_touch_state = get_switch_touch_state();
if (new_switch_touch_state != switch_touch_state) {
switch_touch_state = new_switch_touch_state;
print_4bin_rev(bin_buf, switch_touch_state);
sprintf(buf, "t: %s", bin_buf);
lcd_print(0, 1, buf);
ESP_LOGI(TAG, "%s", buf);
}
uint8_t new_switch_state = get_switch_state();
if (new_switch_state != switch_state) {
switch_state = new_switch_state;
print_4bin_rev(bin_buf, switch_state);
sprintf(buf, "s: %s", bin_buf);
lcd_print(1, 1, buf);
ESP_LOGI(TAG, "%s", buf);
}
uint8_t new_button_state = get_button_state();
if (new_button_state != button_state) {
button_state = new_button_state;
print_4bin_rev(bin_buf, button_state);
sprintf(buf, "b: %s", bin_buf);
lcd_print(2, 1, buf);
ESP_LOGI(TAG, "%s", buf);
}
if (get_keypad_pressed(&key) && key == KeypadKey::pound) {
return;
}
vTaskDelay(pdMS_TO_TICKS(10));
}
}
static void flashbang() {
play_clip_wav(MOUNT_POINT "/flash.wav", true, false, 1, 0);
vTaskDelay(pdMS_TO_TICKS(4000));
for (int bright = 255; bright >= 0; bright -= 2) {
for (int led_idx = 0; led_idx < IndicatorLED::LED_MAX; led_idx++) {
led_set(led_idx, bright, bright, bright);
}
leds_flush();
vTaskDelay(pdMS_TO_TICKS(10));
}
leds_clear();
leds_flush();
}

7
main/steps/step0.h
View File

@ -1,9 +1,12 @@
#ifndef STEP_0_H #ifndef STEP_0_H
#define STEP_0_H #define STEP_0_H
#include "../drivers/all.h" #include "../drivers/bottom_half.h"
#include "../drivers/char_lcd.h"
#include "../drivers/wires.h"
#include "setup_wires.h" #include "setup_wires.h"
#include "../helper.h"
#include "step1.h" #include "step1.h"
#include "step2.h" #include "step2.h"
#include "step3.h" #include "step3.h"

94
main/steps/step1.cpp
View File

@ -1,27 +1,26 @@
#include "step1.h" #include "step1.h"
__attribute__((unused))
static const char *TAG = "step1"; static const char *TAG = "step1";
static const char* COLOR_NAMES[] = { static char* COLOR_NAMES[] = {
"green", "green",
"red", "red",
"yellow", "yellow",
"blue" "blue"
}; };
static const char* NUM_NAMES[] = { static char* NUM_NAMES[] = {
"one", "one",
"two", "two",
"three", "three",
"four" "four"
}; };
static uint32_t NEOPIXEL_COLORS[4] = { static uint8_t NEOPIXEL_COLORS[4][3] = {
LEDColor::LED_COLOR_GREEN, {0, 20, 0},
LEDColor::LED_COLOR_RED, {20, 0, 0},
LEDColor::LED_COLOR_YELLOW, {20, 20, 0},
LEDColor::LED_COLOR_BLUE, {0, 0, 20},
}; };
static std::random_device my_rd; static std::random_device my_rd;
@ -30,7 +29,6 @@ static std::uniform_int_distribution<> zero_to_one(0, 1);
static std::uniform_int_distribution<> zero_to_two(0, 2); static std::uniform_int_distribution<> zero_to_two(0, 2);
static std::uniform_int_distribution<> zero_to_three(0, 3); static std::uniform_int_distribution<> zero_to_three(0, 3);
static lv_obj_t *old_scr;
static lv_obj_t *scr; static lv_obj_t *scr;
static lv_obj_t *text = NULL; static lv_obj_t *text = NULL;
@ -59,18 +57,18 @@ static int part = 0;
static void init_step(void) { static void init_step(void) {
if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) { if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) {
scr = lv_obj_create(NULL); scr = lv_disp_get_scr_act(NULL);
// Set the background color of the display to black. // Set the background color of the display to black.
lv_style_init(&style_screen); lv_style_init(&style_screen);
lv_style_set_bg_color(&style_screen, lv_color_black()); lv_style_set_bg_color(&style_screen, lv_color_black());
lv_style_set_text_font(&style_screen, &lv_font_montserrat_32); lv_style_set_text_font(&style_screen, &lv_font_montserrat_32);
lv_obj_add_style(scr, &style_screen, LV_STATE_DEFAULT); lv_obj_add_style(lv_scr_act(), &style_screen, LV_STATE_DEFAULT);
// rgb565 // rgb565
lv_color_t green = { .full = 0x0560 }; lv_color_t green = { .full = 0x0640 };
lv_color_t red = { .full = 0xf800 }; lv_color_t red = { .full = 0xf800 };
lv_color_t yellow = { .full = 0xfce0 }; lv_color_t yellow = { .full = 0xfe80 };
lv_color_t blue = { .full = 0x045f }; lv_color_t blue = { .full = 0x045f };
lv_style_init(&green_text); lv_style_init(&green_text);
@ -86,18 +84,15 @@ static void init_step(void) {
lv_style_set_text_color(&blue_text, blue); lv_style_set_text_color(&blue_text, blue);
text = lv_label_create(scr); text = lv_label_create(scr);
old_scr = lv_scr_act();
lv_scr_load(scr);
xSemaphoreGive(xGuiSemaphore); xSemaphoreGive(xGuiSemaphore);
} }
} }
static void clean_up_step(void) { static void clean_up_step(void) {
while (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdFALSE) vTaskDelay(pdMS_TO_TICKS(10)); if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) {
lv_scr_load(old_scr); lv_obj_clean(scr);
lv_obj_del(scr); xSemaphoreGive(xGuiSemaphore);
xSemaphoreGive(xGuiSemaphore); }
} }
static void generate_switch_leds(void) { static void generate_switch_leds(void) {
@ -118,21 +113,29 @@ static void generate_switch_leds(void) {
switch_leds[3] = colors[0]; switch_leds[3] = colors[0];
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
led_set(IndicatorLED::LED_S1 - i, NEOPIXEL_COLORS[switch_leds[i]]); uint8_t* rgb = NEOPIXEL_COLORS[switch_leds[i]];
led_strip_set_pixel(leds, Led::switch1 - i, rgb[0], rgb[1], rgb[2]);
} }
leds_flush(); led_strip_refresh(leds);
} }
static void set_text_and_color(const char* text_str, int color) { static void set_text_and_color(char* text_str, int color) {
if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) { if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) {
ESP_LOGI(TAG, "set_text_and_color: setting text: %s", text_str);
lv_label_set_text(text, text_str); lv_label_set_text(text, text_str);
ESP_LOGI(TAG, "set_text_and_color: set text");
lv_obj_center(text); lv_obj_center(text);
ESP_LOGI(TAG, "set_text_and_color: setting %d", color);
if (last_style != nullptr) { if (last_style != nullptr) {
ESP_LOGI(TAG, "set_text_and_color: removing %d", color);
lv_obj_remove_style(text, last_style, LV_STATE_DEFAULT); lv_obj_remove_style(text, last_style, LV_STATE_DEFAULT);
} }
ESP_LOGI(TAG, "set_text_and_color: adding %d", color);
lv_obj_add_style(text, color_styles[color], LV_STATE_DEFAULT); lv_obj_add_style(text, color_styles[color], LV_STATE_DEFAULT);
last_style = color_styles[color]; last_style = color_styles[color];
ESP_LOGI(TAG, "set_text_and_color: style");
xSemaphoreGive(xGuiSemaphore); xSemaphoreGive(xGuiSemaphore);
ESP_LOGI(TAG, "set_text_and_color: give");
} }
} }
@ -140,7 +143,7 @@ static int generate_part_a(void) {
int text_color = zero_to_three(my_gen); int text_color = zero_to_three(my_gen);
int text_idx = zero_to_three(my_gen); int text_idx = zero_to_three(my_gen);
const char* text_string = COLOR_NAMES[text_idx]; char* text_string = COLOR_NAMES[text_idx];
set_text_and_color(text_string, text_color); set_text_and_color(text_string, text_color);
generate_switch_leds(); generate_switch_leds();
@ -158,7 +161,7 @@ static int generate_part_b(void) {
int text_color = zero_to_three(my_gen); int text_color = zero_to_three(my_gen);
int text_number = zero_to_three(my_gen); int text_number = zero_to_three(my_gen);
const char* text_string = NUM_NAMES[text_number]; char* text_string = NUM_NAMES[text_number];
set_text_and_color(text_string, text_color); set_text_and_color(text_string, text_color);
generate_switch_leds(); generate_switch_leds();
@ -174,7 +177,7 @@ static int generate_part_c(void) {
} }
int text_color = zero_to_three(my_gen); int text_color = zero_to_three(my_gen);
const char* text_string = "switch"; char* text_string = "switch";
set_text_and_color(text_string, text_color); set_text_and_color(text_string, text_color);
generate_switch_leds(); generate_switch_leds();
@ -197,30 +200,33 @@ static int generate_part(void) {
} }
static void update_lcd_count(int times) { static void update_lcd_count(int times) {
char buf[16] = {0}; char buf[6] = {0};
sprintf(buf, "%d/15", times); sprintf(buf, "%d/15", times);
lcd_print(1, 14, buf); lcd_set_cursor(&lcd, 14, 1);
lcd_print(&lcd, buf);
} }
static bool play_part(uint32_t time) { static bool play_part(uint32_t time) {
stop_module_timer();
set_module_time(time); set_module_time(time);
lcd_clear(); lcd_clear(&lcd);
lcd_set_cursor(&lcd, 1, 1);
switch (part) { switch (part) {
case 0: case 0:
lcd_print(1, 1, "COLOR"); lcd_print(&lcd, "COLOR");
led_set(IndicatorLED::LED_LCD, LEDColor::LED_COLOR_PINK); led_strip_set_pixel(leds, Led::char_lcd, 20, 0, 20);
break; break;
case 1: case 1:
lcd_print(1, 1, "NUMBER"); lcd_print(&lcd, "NUMBER");
led_set(IndicatorLED::LED_LCD, LEDColor::LED_COLOR_BLUE); led_strip_set_pixel(leds, Led::char_lcd, 0, 0, 30);
break; break;
case 2: case 2:
lcd_print(1, 1, "SWITCH"); lcd_print(&lcd, "SWITCH");
led_set(IndicatorLED::LED_LCD, LEDColor::LED_COLOR_YELLOW); led_strip_set_pixel(leds, Led::char_lcd, 20, 20, 0);
break; break;
} }
leds_flush(); led_strip_refresh(leds);
int times = 0; int times = 0;
int correct = generate_part(); int correct = generate_part();
@ -230,7 +236,7 @@ static bool play_part(uint32_t time) {
SwitchKey switch_; SwitchKey switch_;
while (times < 15) { while (times < 15) {
while (get_button_pressed(&button)) { while (get_pressed_button(&button)) {
start_module_timer(); start_module_timer();
if ((int)(button) == correct) { if ((int)(button) == correct) {
times++; times++;
@ -241,7 +247,7 @@ static bool play_part(uint32_t time) {
strike("Incorrect action"); strike("Incorrect action");
} }
} }
while (get_switch_flipped(&switch_)) { while (get_flipped_switch(&switch_)) {
start_module_timer(); start_module_timer();
if (switch_leds[(int)(switch_)] + 4 == correct) { if (switch_leds[(int)(switch_)] + 4 == correct) {
times++; times++;
@ -254,29 +260,23 @@ static bool play_part(uint32_t time) {
} }
if (get_module_time() <= 0) { if (get_module_time() <= 0) {
strike("Out of time"); strike("Out of time");
vTaskDelay(pdMS_TO_TICKS(2000));
return false; return false;
} }
vTaskDelay(pdMS_TO_TICKS(10)); vTaskDelay(pdMS_TO_TICKS(10));
} }
stop_module_timer();
if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) { if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) {
lv_label_set_text(text, ""); lv_label_set_text(text, "");
xSemaphoreGive(xGuiSemaphore); xSemaphoreGive(xGuiSemaphore);
} }
if (part < 2) { vTaskDelay(pdMS_TO_TICKS(80));
play_clip_wav(MOUNT_POINT "/partdone.wav", true, false, 0, 0); play_raw(MOUNT_POINT "/correct.pcm");
vTaskDelay(pdMS_TO_TICKS(2000));
} else {
play_clip_wav(MOUNT_POINT "/stepdone.wav", true, false, 1, 0);
}
return true; return true;
} }
void step1(void) { void step1(void) {
while (get_switch_flipped(nullptr)); while (get_flipped_switch(nullptr));
init_step(); init_step();
while (!play_part(40*1000)); while (!play_part(40*1000));

9
main/steps/step1.h
View File

@ -2,8 +2,13 @@
#define STEP_1_H #define STEP_1_H
#include <random> #include <random>
#include "../drivers/all.h" #include "../drivers/bottom_half.h"
#include "../helper.h" #include "../drivers/tft.h"
#include "../drivers/leds.h"
#include "../drivers/wires.h"
#include "../drivers/speaker.h"
#include "../drivers/game_timer.h"
#include "../drivers/char_lcd.h"
void step1(void); void step1(void);

47
main/steps/step2.cpp
View File

@ -1,10 +1,7 @@
#include "step2.h" #include "step2.h"
__attribute__((unused))
static const char *TAG = "step2"; static const char *TAG = "step2";
static const int NUM_SOLVES = 4;
// one: 0b00000110 // one: 0b00000110
// seven: 0b00000111 // seven: 0b00000111
static const uint8_t SSEG_NUMS[8] = {0b00111111, 0b01011011, 0b01001111, 0b01100110, 0b01101101, 0b01111101, 0b01111111, 0b01101111}; static const uint8_t SSEG_NUMS[8] = {0b00111111, 0b01011011, 0b01001111, 0b01100110, 0b01101101, 0b01111101, 0b01111111, 0b01101111};
@ -16,13 +13,9 @@ static const uint8_t SSEG_MAPS[5][4] = {
{0b01000111, 0b00011001, 0b01111000, 0b00111110} {0b01000111, 0b00011001, 0b01111000, 0b00111110}
}; };
static const uint32_t INDICATOR_COLORS[5] = { static const int INDICATOR_RED[5] = {15, 0, 0, 10, 5};
LEDColor::LED_COLOR_RED, static const int INDICATOR_GREEN[5] = {0, 0, 10, 5, 7};
LEDColor::LED_COLOR_BLUE, static const int INDICATOR_BLUE[5] = {0, 10, 0, 0, 5};
LEDColor::LED_COLOR_GREEN,
LEDColor::LED_COLOR_YELLOW,
LEDColor::LED_COLOR_WHITE,
};
// random number generators // random number generators
static std::random_device rd; static std::random_device rd;
@ -52,8 +45,8 @@ std::map<int, int> number_map = {
static void new_puzzle(void) { static void new_puzzle(void) {
// scramble lights // scramble lights
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
led_set(IndicatorLED::LED_SPEAKER, INDICATOR_COLORS[map_dist(gen)]); led_strip_set_pixel(leds, 9, INDICATOR_RED[map_dist(gen)], INDICATOR_GREEN[map_dist(gen)], INDICATOR_BLUE[map_dist(gen)]);
leds_flush(); led_strip_refresh(leds);
uint8_t random_segments[4] = {0, 0, 0, 0}; uint8_t random_segments[4] = {0, 0, 0, 0};
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
@ -76,8 +69,8 @@ static void new_puzzle(void) {
} }
// ESP_LOGI(TAG, "Chosen Map: %i", chosen_map); // ESP_LOGI(TAG, "Chosen Map: %i", chosen_map);
led_set(IndicatorLED::LED_SPEAKER, INDICATOR_COLORS[chosen_map]); ESP_ERROR_CHECK(led_strip_set_pixel(leds, 9, INDICATOR_RED[chosen_map], INDICATOR_GREEN[chosen_map], INDICATOR_BLUE[chosen_map]));
leds_flush(); ESP_ERROR_CHECK(led_strip_refresh(leds));
for (int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
bool bit = (answer_sseg >> i) & 1; bool bit = (answer_sseg >> i) & 1;
@ -88,7 +81,6 @@ static void new_puzzle(void) {
// ESP_LOGI(TAG, "Flipping bit %i on display %i", i, display); // ESP_LOGI(TAG, "Flipping bit %i on display %i", i, display);
} }
} }
set_module_sseg_raw(display_map);
} }
void step2(void) { void step2(void) {
@ -96,32 +88,35 @@ void step2(void) {
int solved_times = 0; int solved_times = 0;
new_puzzle(); new_puzzle();
int strike_time = 0; int strike_time = xTaskGetTickCount();
while(solved_times < NUM_SOLVES) { bool striked = false;
while(solved_times < 4) {
// for every bit in the answer- // for every bit in the answer-
if (get_keypad_pressed(&key)) { set_module_sseg_raw(display_map);
lcd_clear(); if (get_pressed_keypad(&key)) {
lcd_clear(&lcd);
char c = char_of_keypad_key(key); char c = char_of_keypad_key(key);
// ESP_LOGI(TAG, "Pressed: %c", c); // ESP_LOGI(TAG, "Pressed: %c", c);
if (c == answer_char) { if (c == answer_char) {
play_raw(MOUNT_POINT "/correct.pcm");
solved_times++; solved_times++;
if (solved_times < NUM_SOLVES) { if (solved_times < 3) {
play_clip_wav(MOUNT_POINT "/partdone.wav", true, false, 0, 0);
clean_bomb(); clean_bomb();
new_puzzle(); new_puzzle();
} else { } else {
play_clip_wav(MOUNT_POINT "/stepdone.wav", true, false, 1, 0); uint8_t display_tmp[4] = {0b00000000, 0b00000000, 0b00000000, 0b00000000};
clear_module_sseg(); set_module_sseg_raw(display_tmp);
} }
} else { } else {
strike_time = xTaskGetTickCount(); strike_time = xTaskGetTickCount();
striked = true;
strike("Incorrect Character!"); strike("Incorrect Character!");
} }
} }
if (strike_time != 0 && xTaskGetTickCount() - strike_time > pdMS_TO_TICKS(5000)) { if (xTaskGetTickCount() - strike_time > pdMS_TO_TICKS(5000)) {
strike_time = 0; striked = false;
lcd_clear(); lcd_clear(&lcd);
} }
vTaskDelay(pdMS_TO_TICKS(10)); vTaskDelay(pdMS_TO_TICKS(10));
} }

6
main/steps/step2.h
View File

@ -1,7 +1,11 @@
#ifndef STEP_2_H #ifndef STEP_2_H
#define STEP_2_H #define STEP_2_H
#include "../drivers/all.h" #include "../drivers/bottom_half.h"
#include "../drivers/wires.h"
#include "../drivers/game_timer.h"
#include "../drivers/leds.h"
#include "../drivers/speaker.h"
#include "../helper.h" #include "../helper.h"
#include <iostream> #include <iostream>
#include <random> #include <random>

149
main/steps/step3.cpp
View File

@ -4,25 +4,20 @@
#define THREE_SECOND_TIME 90'000 #define THREE_SECOND_TIME 90'000
#define SIX_SECOND_TIME 75'000 #define SIX_SECOND_TIME 75'000
#define TIMES_TO_COMPLETE 4
__attribute__((unused))
static const char *TAG = "step3"; static const char *TAG = "step3";
static int tone = 0; static int tone = 0;
static int times = 0; static int times = 0;
static const char* TONE_FILES[] = { static const char* TONE_FILES[] = {
MOUNT_POINT "/low-1.wav", MOUNT_POINT "/low-1.pcm",
MOUNT_POINT "/low-3.wav", MOUNT_POINT "/low-3.pcm",
MOUNT_POINT "/low-6.wav", MOUNT_POINT "/low-6.pcm",
MOUNT_POINT "/high-1.wav", MOUNT_POINT "/high-1.pcm",
MOUNT_POINT "/high-3.wav", MOUNT_POINT "/high-3.pcm",
MOUNT_POINT "/high-6.wav", MOUNT_POINT "/high-6.pcm",
}; };
static const size_t LCD_STRING_SOMETHING = 0;
static const size_t LCD_STRING_NOTHING = 1;
static const char* LCD_STRINGS[] = { static const char* LCD_STRINGS[] = {
"something", "something",
"nothing", "nothing",
@ -37,7 +32,7 @@ static const char* LCD_STRINGS[] = {
static int indicator_led_idxs[LED_COUNT] = {0}; static int indicator_led_idxs[LED_COUNT] = {0};
static bool contains_coconut = false; static bool contains_coconut = false;
static const char* COCONUT = "coconut"; static char* COCONUT = "coconut";
static char lcd_random_char_set[] = "aeiou tnsrhldm"; static char lcd_random_char_set[] = "aeiou tnsrhldm";
static char random_lcd_text[21] = {0}; static char random_lcd_text[21] = {0};
@ -51,21 +46,14 @@ static std::uniform_int_distribution<> lcd_rand_char_dist(0, sizeof(lcd_random_c
static std::uniform_int_distribution<> has_coconut_dist(0, 2); static std::uniform_int_distribution<> has_coconut_dist(0, 2);
static std::uniform_int_distribution<> coconut_position_dist(0, 13); static std::uniform_int_distribution<> coconut_position_dist(0, 13);
const static uint32_t NEOPIXEL_COLOR_IDX_RED = 0; static uint8_t NEOPIXEL_COLORS[7][3] = {
const static uint32_t NEOPIXEL_COLOR_IDX_YELLOW = 1; {20, 0, 0}, // red
const static uint32_t NEOPIXEL_COLOR_IDX_GREEN = 2; {20, 10, 0}, // orange
const static uint32_t NEOPIXEL_COLOR_IDX_BLUE = 3; {20, 20, 0}, // yellow
const static uint32_t NEOPIXEL_COLOR_IDX_PINK = 4; {0, 20, 0}, // green
const static uint32_t NEOPIXEL_COLOR_IDX_WHITE = 5; {0, 0, 20}, // blue
const static uint32_t NEOPIXEL_COLOR_IDX_OFF = 6; {20, 0, 20}, // purple
static uint32_t NEOPIXEL_COLORS[7] = { {0, 0, 0}, // off
LEDColor::LED_COLOR_RED,
LEDColor::LED_COLOR_YELLOW,
LEDColor::LED_COLOR_GREEN,
LEDColor::LED_COLOR_BLUE,
LEDColor::LED_COLOR_PINK,
LEDColor::LED_COLOR_WHITE,
LEDColor::LED_COLOR_OFF,
}; };
static bool one_second(); static bool one_second();
@ -73,33 +61,24 @@ static bool three_second();
static bool six_second(); static bool six_second();
void step3(void) { void step3(void) {
SemaphoreHandle_t continue_sem = xSemaphoreCreateBinary(); StarCodeHandler star_codes[] = {
if (continue_sem == nullptr) { {
ESP_LOGE(TAG, "could not create semaphore"); .code = "*1642",
return; .display_text = "Starting...",
} .should_exit = true,
.callback = nullptr,
StarCodeEntry start_code = { },
.code = "1642",
.display_text = "Starting...",
.delay_us = 2'000'000,
.callback = nullptr,
.triggered_sem = continue_sem,
}; };
int len = sizeof(star_codes)/sizeof(StarCodeHandler);
do_star_codes(star_codes, len);
add_star_code(start_code); while (times < 4) {
xSemaphoreTake(continue_sem, portMAX_DELAY);
rm_star_code(start_code.code);
vSemaphoreDelete(continue_sem);
while (times < TIMES_TO_COMPLETE) {
tone = tone_dist(gen); tone = tone_dist(gen);
// tone = 2; // tone = 2;
while (get_button_pressed(nullptr)) vTaskDelay(pdMS_TO_TICKS(10)); while (get_pressed_button(nullptr)) vTaskDelay(pdMS_TO_TICKS(10));
play_clip_wav(MOUNT_POINT "/ready.wav", true, false, 3, 0); play_raw(MOUNT_POINT "/que.pcm");
// The high pitched tones need to be scaled down by 3 more play_raw(TONE_FILES[tone]);
play_clip_wav(TONE_FILES[tone], false, false, 1 + (tone/3) * 4, 0);
bool correct = false; bool correct = false;
switch (tone % 3) { switch (tone % 3) {
@ -116,11 +95,7 @@ void step3(void) {
if (correct) { if (correct) {
times++; times++;
clean_bomb(); clean_bomb();
if (times < TIMES_TO_COMPLETE) { play_raw(MOUNT_POINT "/correct.pcm");
play_clip_wav(MOUNT_POINT "/partdone.wav", true, false, 0, 0);
} else {
play_clip_wav(MOUNT_POINT "/stepdone.wav", true, false, 1, 0);
}
} else { } else {
vTaskDelay(pdMS_TO_TICKS(1500)); vTaskDelay(pdMS_TO_TICKS(1500));
} }
@ -156,9 +131,10 @@ static void rng_leds() {
static void write_leds() { static void write_leds() {
// update all the leds // update all the leds
for (int i = 0; i < LED_COUNT; i++) { for (int i = 0; i < LED_COUNT; i++) {
led_set(i, NEOPIXEL_COLORS[indicator_led_idxs[i]]); auto colors = NEOPIXEL_COLORS[indicator_led_idxs[i]];
led_strip_set_pixel(leds, i, colors[0], colors[1], colors[2]);
} }
leds_flush(); led_strip_refresh(leds);
} }
static uint8_t four_bit_flag(bool b0, bool b1, bool b2, bool b3) { static uint8_t four_bit_flag(bool b0, bool b1, bool b2, bool b3) {
@ -170,7 +146,7 @@ static uint8_t four_bit_flag(bool b0, bool b1, bool b2, bool b3) {
; ;
} }
static void print_4bin(char* out_str, uint8_t n) { static void print_bin(char* out_str, uint8_t n) {
out_str[0] = ((n & 0b1000) ? '1' : '0'); out_str[0] = ((n & 0b1000) ? '1' : '0');
out_str[1] = ((n & 0b0100) ? '1' : '0'); out_str[1] = ((n & 0b0100) ? '1' : '0');
out_str[2] = ((n & 0b0010) ? '1' : '0'); out_str[2] = ((n & 0b0010) ? '1' : '0');
@ -194,19 +170,19 @@ static void print_4bin(char* out_str, uint8_t n) {
static void debug_correct_values(uint8_t correct_buttons, uint8_t button_mask, uint8_t correct_switches) { static void debug_correct_values(uint8_t correct_buttons, uint8_t button_mask, uint8_t correct_switches) {
char buf[20] = {0}; char buf[20] = {0};
print_4bin(buf, correct_switches); print_bin(buf, correct_switches);
ESP_LOGI(TAG, "Expected Switch State: 0b%s", buf); ESP_LOGI(TAG, "Expected Switch State: 0b%s", buf);
print_4bin(buf, correct_buttons); print_bin(buf, correct_buttons);
ESP_LOGI(TAG, "Expected Button State: 0b%s", buf); ESP_LOGI(TAG, "Expected Button State: 0b%s", buf);
print_4bin(buf, button_mask); print_bin(buf, button_mask);
ESP_LOGI(TAG, "Button Mask: 0b%s", buf); ESP_LOGI(TAG, "Button Mask: 0b%s", buf);
} }
static void debug_actual_values(uint8_t buttons, uint8_t switch_) { static void debug_actual_values(uint8_t buttons, uint8_t switch_) {
char buf[20] = {0}; char buf[20] = {0};
print_4bin(buf, switch_); print_bin(buf, switch_);
ESP_LOGI(TAG, "Actual Switch State: 0b%s", buf); ESP_LOGI(TAG, "Actual Switch State: 0b%s", buf);
print_4bin(buf, buttons); print_bin(buf, buttons);
ESP_LOGI(TAG, "Actual Button State: 0b%s", buf); ESP_LOGI(TAG, "Actual Button State: 0b%s", buf);
ESP_LOGI(TAG, ""); ESP_LOGI(TAG, "");
} }
@ -214,7 +190,7 @@ static void debug_actual_values(uint8_t buttons, uint8_t switch_) {
static void wait_for_timer(void) { static void wait_for_timer(void) {
KeypadKey key; KeypadKey key;
while (get_module_time() > 0) { while (get_module_time() > 0) {
if (get_keypad_pressed(&key) && key == KeypadKey::kd) { if (get_pressed_keypad(&key) && key == KeypadKey::kd) {
set_module_time(0); set_module_time(0);
return; return;
} }
@ -228,36 +204,37 @@ static bool one_second() {
start_module_timer(); start_module_timer();
rng_leds(); rng_leds();
int speaker_color = indicator_led_idxs[IndicatorLED::LED_SPEAKER]; int speaker_color = indicator_led_idxs[Led::speaker];
int lcd_string_idx = lcd_string_dist(gen); int lcd_string_idx = lcd_string_dist(gen);
bool was_high = (tone / 3) == 1; bool was_high = (tone / 3) == 1;
write_leds(); write_leds();
lcd_clear(); lcd_clear(&lcd);
lcd_print(1, 1, LCD_STRINGS[lcd_string_idx]); lcd_set_cursor(&lcd, 1, 1);
lcd_print(&lcd, LCD_STRINGS[lcd_string_idx]);
int red_led_count = 0; int red_led_count = 0;
int blue_led_count = 0; int blue_led_count = 0;
for (int i = 0; i < LED_COUNT; i++) { for (int i = 0; i < LED_COUNT; i++) {
if (indicator_led_idxs[i] == NEOPIXEL_COLOR_IDX_RED) { if (indicator_led_idxs[i] == 0) {
red_led_count++; red_led_count++;
} else if (indicator_led_idxs[i] == NEOPIXEL_COLOR_IDX_BLUE) { } else if (indicator_led_idxs[i] == 4) {
blue_led_count++; blue_led_count++;
} }
} }
uint8_t correct_switches = four_bit_flag( uint8_t correct_switches = four_bit_flag(
speaker_color == NEOPIXEL_COLOR_IDX_RED || speaker_color == NEOPIXEL_COLOR_IDX_YELLOW || speaker_color == NEOPIXEL_COLOR_IDX_PINK, speaker_color == 0 || speaker_color == 1 || speaker_color == 2,
lcd_string_idx == LCD_STRING_SOMETHING || lcd_string_idx == LCD_STRING_NOTHING, lcd_string_idx == 0 || lcd_string_idx == 1,
was_high, was_high,
!was_high !was_high
); );
uint8_t correct_button_mask = 0b1011; uint8_t correct_button_mask = 0b1011;
uint8_t correct_buttons = four_bit_flag( uint8_t correct_buttons = four_bit_flag(
indicator_led_idxs[IndicatorLED::LED_LCD] != 6, // green indicator_led_idxs[Led::char_lcd] != 6, // green
red_led_count > blue_led_count, // red red_led_count > blue_led_count, // red
0, // yellow UNCHECKED 0, // yellow UNCHECKED
indicator_led_idxs[IndicatorLED::LED_RFID] == 4 || indicator_led_idxs[IndicatorLED::LED_RFID] == 6 // blue indicator_led_idxs[Led::rfid] == 4 || indicator_led_idxs[Led::rfid] == 6 // blue
); );
debug_correct_values(correct_buttons, correct_button_mask, correct_switches); debug_correct_values(correct_buttons, correct_button_mask, correct_switches);
@ -288,7 +265,8 @@ static bool three_second() {
int lcd_number = lcd_number_dist(gen); int lcd_number = lcd_number_dist(gen);
char lcd_number_string[9] = {0}; char lcd_number_string[9] = {0};
sprintf(lcd_number_string, "%d", lcd_number); sprintf(lcd_number_string, "%d", lcd_number);
lcd_print(1, 1, lcd_number_string); lcd_set_cursor(&lcd, 1, 1);
lcd_print(&lcd, lcd_number_string);
bool was_high = (tone / 3) == 1; bool was_high = (tone / 3) == 1;
@ -297,9 +275,9 @@ static bool three_second() {
int red_led_count = 0; int red_led_count = 0;
int blue_led_count = 0; int blue_led_count = 0;
for (int i = 0; i < LED_COUNT; i++) { for (int i = 0; i < LED_COUNT; i++) {
if (indicator_led_idxs[i] == NEOPIXEL_COLOR_IDX_RED) { if (indicator_led_idxs[i] == 0) {
red_led_count++; red_led_count++;
} else if (indicator_led_idxs[i] == NEOPIXEL_COLOR_IDX_BLUE) { } else if (indicator_led_idxs[i] == 4) {
blue_led_count++; blue_led_count++;
} }
} }
@ -350,7 +328,8 @@ static bool six_second() {
generate_random_lcd_text(); generate_random_lcd_text();
vTaskDelay(pdMS_TO_TICKS(10)); vTaskDelay(pdMS_TO_TICKS(10));
lcd_print(0, 0, random_lcd_text); lcd_set_cursor(&lcd, 0, 0);
lcd_print(&lcd, random_lcd_text);
int vowels = 0; int vowels = 0;
for (int i = 0; i < 20; i++) { for (int i = 0; i < 20; i++) {
@ -362,7 +341,7 @@ static bool six_second() {
bool was_high = (tone / 3) == 1; bool was_high = (tone / 3) == 1;
bool second_switch_correct_state = (indicator_led_idxs[IndicatorLED::LED_S2] == NEOPIXEL_COLOR_IDX_RED) || (indicator_led_idxs[IndicatorLED::LED_S2] == NEOPIXEL_COLOR_IDX_OFF); bool second_switch_correct_state = (indicator_led_idxs[Led::switch2] == 0) || (indicator_led_idxs[Led::switch2] == 6);
second_switch_correct_state = second_switch_correct_state || was_high; second_switch_correct_state = second_switch_correct_state || was_high;
rng_leds(); rng_leds();
@ -371,17 +350,17 @@ static bool six_second() {
int green_led_count = 0; int green_led_count = 0;
int blue_led_count = 0; int blue_led_count = 0;
for (int i = 0; i < LED_COUNT; i++) { for (int i = 0; i < LED_COUNT; i++) {
if (indicator_led_idxs[i] == NEOPIXEL_COLOR_IDX_BLUE) { if (indicator_led_idxs[i] == 4) {
blue_led_count++; blue_led_count++;
} else if (indicator_led_idxs[i] == NEOPIXEL_COLOR_IDX_GREEN) { } else if (indicator_led_idxs[i] == 3) {
green_led_count++; green_led_count++;
} }
} }
int pink_led_on_bottom_count = 0; int purple_led_on_bottom_count = 0;
for (int i = IndicatorLED::LED_RFID; i < LED_COUNT; i++) { for (int i = Led::rfid; i < LED_COUNT; i++) {
if (indicator_led_idxs[i] == NEOPIXEL_COLOR_IDX_PINK) { if (indicator_led_idxs[i] == 5) {
pink_led_on_bottom_count++; purple_led_on_bottom_count++;
} }
} }
@ -389,12 +368,12 @@ static bool six_second() {
vowels > 7, vowels > 7,
second_switch_correct_state, second_switch_correct_state,
true, true,
!(pink_led_on_bottom_count > 1) !(purple_led_on_bottom_count > 1)
); );
uint8_t correct_button_mask = 0b1101; uint8_t correct_button_mask = 0b1101;
uint8_t correct_buttons = four_bit_flag( uint8_t correct_buttons = four_bit_flag(
(!was_high) || (green_led_count >= 2) || indicator_led_idxs[IndicatorLED::LED_KEYPAD] == 4, // green (!was_high) || (green_led_count >= 2) || indicator_led_idxs[Led::keypad] == 4, // green
0, // red UNCHECKED 0, // red UNCHECKED
blue_led_count >= 3, // yellow blue_led_count >= 3, // yellow
contains_coconut // blue contains_coconut // blue

7
main/steps/step3.h
View File

@ -2,7 +2,12 @@
#define STEP_3_H #define STEP_3_H
#include <random> #include <random>
#include "../drivers/all.h" #include "../drivers/bottom_half.h"
#include "../drivers/wires.h"
#include "../drivers/speaker.h"
#include "../drivers/leds.h"
#include "../drivers/char_lcd.h"
#include "../drivers/game_timer.h"
#include "../helper.h" #include "../helper.h"
void step3(void); void step3(void);

281
main/steps/step4.cpp
View File

@ -1,12 +1,14 @@
#include "step4.h" #include "step4.h"
__attribute__((unused))
static const char *TAG = "step4"; static const char *TAG = "step4";
static lv_obj_t *old_scr;
static lv_obj_t* scr; static lv_obj_t* scr;
static lv_style_t scr_style;
static lv_obj_t* img; static lv_obj_t* img;
static bool invisible_blocks = false;
static bool text_output = false;
static const int height = 22; static const int height = 22;
static const int width = 10; static const int width = 10;
@ -17,51 +19,24 @@ static lv_obj_t* line_clear_img;
static lv_style_t game_over_style; static lv_style_t game_over_style;
static lv_obj_t* game_over_label; static lv_obj_t* game_over_label;
#define MUSIC_FILE MOUNT_POINT "/piano.wav" static const void* LINE_CLEAR_SRC = (void*)"A:/sdcard/clear.bin";
static const void* BACKGROUND_SRC = (void*)"A:/sdcard/bg.bin";
// LV_IMG_DECLARE(background);
// static const void* BACKGROUND_SRC = (void*)&background;
#ifdef TETRIS_USE_FLASH_BG_IMG static QueueHandle_t stop_music;
LV_IMG_DECLARE(bg); static bool playing_music = true;
static const void* BACKGROUND_SRC = (void*) &bg;
#else
static const void* BACKGROUND_SRC = (void*)"A:" MOUNT_POINT "/bg.bin";
#endif
#ifdef TETRIS_USE_FLASH_IMG static const char* PIECE_IMG_SRC[] = {
LV_IMG_DECLARE(clear);
LV_IMG_DECLARE(db);
LV_IMG_DECLARE(green);
LV_IMG_DECLARE(lb);
LV_IMG_DECLARE(orange);
LV_IMG_DECLARE(purple);
LV_IMG_DECLARE(red);
LV_IMG_DECLARE(yellow);
static const void* LINE_CLEAR_SRC = (void*) &clear;
static const void* PIECE_IMG_SRC[] = {
NULL, NULL,
&lb, "A:/sdcard/lb.bin",
&db, "A:/sdcard/db.bin",
&orange, "A:/sdcard/orange.bin",
&yellow, "A:/sdcard/yellow.bin",
&green, "A:/sdcard/green.bin",
&purple, "A:/sdcard/purple.bin",
&red, "A:/sdcard/red.bin",
}; };
#else
static const void* LINE_CLEAR_SRC = (void*)"A:" MOUNT_POINT "/clear.bin";
static const void* PIECE_IMG_SRC[] = {
NULL,
"A:" MOUNT_POINT "/lb.bin",
"A:" MOUNT_POINT "/db.bin",
"A:" MOUNT_POINT "/orange.bin",
"A:" MOUNT_POINT "/yellow.bin",
"A:" MOUNT_POINT "/green.bin",
"A:" MOUNT_POINT "/purple.bin",
"A:" MOUNT_POINT "/red.bin",
};
#endif
static bool game = true; static bool game = true;
@ -80,27 +55,27 @@ static int piece_nodes[4][2] = {
lv_obj_t* piece_imgs[4] = {}; lv_obj_t* piece_imgs[4] = {};
static bool music_playing; TaskHandle_t music_handle;
static std::random_device rd; static std::random_device rd;
static std::mt19937 gen(rd()); static std::mt19937 gen(rd());
static std::uniform_int_distribution<> piece_dist(2, 7); static std::uniform_int_distribution<> piece_dist(2, 7);
static void generate_block(); static void generate_block(void);
static void show_board(); static void show_board(void);
static void get_node_locations(); static void get_node_locations(void);
static bool check_overlap(); static bool check_overlap(void);
static void line_clear(int hi); static void line_clear(int hi);
static void check_line_clears(); static void check_line_clears(void);
static void place_piece(); static void place_piece(void);
static void move_left(); static void move_left(void);
static void move_right(); static void move_right(void);
static void drop(); static void drop(void);
static void rotate_block(); static void rotate_block(void);
static void update_score(); static void update_score(void);
static void clear_board(); static void clear_board(void);
static int bbcc(int i) { // [0,1,2,3] -> [ 0, 0,+1,+1] static int bbcc(int i) { // [0,1,2,3] -> [ 0, 0,+1,+1]
@ -111,6 +86,10 @@ static int bccb(int i) { // [0,1,2,3] -> [ 0,+1,+1, 0]
const int map[] = {0, 1, 1, 0}; const int map[] = {0, 1, 1, 0};
return map[i]; return map[i];
} }
static int cbbc(int i) { // [0,1,2,3] -> [+1, 0, 0,+1]
const int map[] = {1, 0, 0, 1};
return map[i];
}
static int ccbb(int i) { // [0,1,2,3] -> [+1,+1, 0, 0] static int ccbb(int i) { // [0,1,2,3] -> [+1,+1, 0, 0]
const int map[] = {1, 1, 0, 0}; const int map[] = {1, 1, 0, 0};
return map[i]; return map[i];
@ -150,15 +129,28 @@ static int bdca(int i) { // [0,1,2,3] -> [ 0,+2,+1,-1]
return map[i]; return map[i];
} }
static void init_screen() { static void music_task(void* arg) {
while (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdFALSE) vTaskDelay(pdMS_TO_TICKS(10)); stop_music = xQueueCreate(2, sizeof (uint8_t));
scr = lv_obj_create(NULL); if (stop_music == 0) {
ESP_LOGW(TAG, "Could not create stop_music queue!");
vTaskDelete(NULL);
}
img = lv_img_create(scr); while (playing_music) {
play_raw_stop_queue(MOUNT_POINT "/tetris.pcm", stop_music);
}
vTaskDelete(NULL);
}
static void init_screen(void) {
while (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdFALSE) vTaskDelay(pdMS_TO_TICKS(10));
img = lv_img_create(lv_scr_act());
lv_img_set_src(img, BACKGROUND_SRC); lv_img_set_src(img, BACKGROUND_SRC);
lv_obj_align(img, LV_ALIGN_CENTER, 0, 0); lv_obj_align(img, LV_ALIGN_CENTER, 0, 0);
line_clear_img = lv_img_create(scr); line_clear_img = lv_img_create(lv_scr_act());
lv_obj_add_flag(line_clear_img, LV_OBJ_FLAG_HIDDEN); lv_obj_add_flag(line_clear_img, LV_OBJ_FLAG_HIDDEN);
lv_img_set_src(line_clear_img, LINE_CLEAR_SRC); lv_img_set_src(line_clear_img, LINE_CLEAR_SRC);
lv_obj_align(line_clear_img, LV_ALIGN_BOTTOM_LEFT, 159, -(height*16)); lv_obj_align(line_clear_img, LV_ALIGN_BOTTOM_LEFT, 159, -(height*16));
@ -169,62 +161,39 @@ static void init_screen() {
lv_style_set_bg_opa(&game_over_style, LV_OPA_100); lv_style_set_bg_opa(&game_over_style, LV_OPA_100);
lv_style_set_text_align(&game_over_style, LV_TEXT_ALIGN_CENTER); lv_style_set_text_align(&game_over_style, LV_TEXT_ALIGN_CENTER);
game_over_label = lv_label_create(scr); game_over_label = lv_label_create(lv_scr_act());
lv_obj_add_flag(game_over_label, LV_OBJ_FLAG_HIDDEN); lv_obj_add_flag(game_over_label, LV_OBJ_FLAG_HIDDEN);
lv_obj_align(game_over_label, LV_ALIGN_LEFT_MID, 0, 0); lv_obj_align(game_over_label, LV_ALIGN_CENTER, 0, 0);
lv_obj_set_width(game_over_label, 160);
lv_obj_add_style(game_over_label, &game_over_style, LV_STATE_DEFAULT); lv_obj_add_style(game_over_label, &game_over_style, LV_STATE_DEFAULT);
for (int h = 0; h < height; h++) { // for (int h = 0; h < height; h++) {
for (int w = 0; w < width; w++) { // for (int w = 0; w < width; w++) {
visual_board[h][w] = lv_img_create(scr); // visual_board[h][w] = lv_img_create(lv_scr_act());
lv_obj_align(visual_board[h][w], LV_ALIGN_BOTTOM_LEFT, 159 + w*16, -(h*16)); // lv_obj_align(visual_board[h][w], LV_ALIGN_BOTTOM_LEFT, 159 + w*16, -(h*16));
lv_obj_add_flag(visual_board[h][w], LV_OBJ_FLAG_HIDDEN); // lv_img_set_src(visual_board[h][w], PIECE_IMG_SRC[((w+h)%7)+1]);
} // }
} // }
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
piece_imgs[i] = lv_img_create(scr); piece_imgs[i] = lv_img_create(lv_scr_act());
lv_obj_align(piece_imgs[i], LV_ALIGN_BOTTOM_LEFT, 159, -320); lv_obj_align(piece_imgs[i], LV_ALIGN_BOTTOM_LEFT, 159, -320);
} }
old_scr = lv_scr_act();
lv_scr_load(scr);
xSemaphoreGive(xGuiSemaphore); xSemaphoreGive(xGuiSemaphore);
play_clip_wav(MUSIC_FILE, true, true, 4, 0); xTaskCreate(music_task, "music", 4096, NULL, 5, NULL);
music_playing = true;
} }
static void deinit_screen() { static void deinit_screen(void) {
while (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdFALSE) vTaskDelay(pdMS_TO_TICKS(10)); while (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdFALSE) vTaskDelay(pdMS_TO_TICKS(10));
lv_scr_load(old_scr);
lv_obj_del(scr); lv_obj_clean(lv_scr_act());
xSemaphoreGive(xGuiSemaphore); xSemaphoreGive(xGuiSemaphore);
if (!stop_clip(MUSIC_FILE, pdMS_TO_TICKS(1000))) { playing_music = false;
ESP_LOGW(TAG, "Can't stop, addicted to the shindig."); uint8_t value = 0;
} if (!xQueueSend(stop_music, &value, pdMS_TO_TICKS(1000))) {
music_playing = false; ESP_LOGE(TAG, "Faild to send stop queue");
}
static void reveal_board() {
for (int h = 0; h < height; h++) {
for (int w = 0; w < width; w++) {
if (PIECE_IMG_SRC[board[h][w]]) {
lv_img_set_src(visual_board[h][w], PIECE_IMG_SRC[board[h][w]]);
lv_obj_clear_flag(visual_board[h][w], LV_OBJ_FLAG_HIDDEN);
}
}
}
}
static void hide_board() {
for (int h = 0; h < height; h++) {
for (int w = 0; w < width; w++) {
lv_obj_add_flag(visual_board[h][w], LV_OBJ_FLAG_HIDDEN);
lv_img_set_src(visual_board[h][w], NULL);
}
} }
} }
@ -242,7 +211,7 @@ bool play_game(int time, int required_score) {
show_board(); show_board();
ButtonKey button; ButtonKey button;
while (get_button_pressed(&button)); while (get_pressed_button(&button));
// SwitchKey switch_; // SwitchKey switch_;
const TickType_t first_repeat_time = pdMS_TO_TICKS(700); const TickType_t first_repeat_time = pdMS_TO_TICKS(700);
@ -251,7 +220,7 @@ bool play_game(int time, int required_score) {
TickType_t last_repeat = 0; TickType_t last_repeat = 0;
while(game) { while(game) {
while (get_button_pressed(&button)) { if (get_pressed_button(&button)) {
switch (button) { switch (button) {
case ButtonKey::b1: case ButtonKey::b1:
move_left(); move_left();
@ -276,26 +245,12 @@ bool play_game(int time, int required_score) {
return true; return true;
} }
} }
while (get_button_released(&button)) { if (get_released_button(&button)) {
if (button == ButtonKey::b3) { if (button == ButtonKey::b3) {
down_held = 0; down_held = 0;
} }
} }
// Toggle music with switch4
SwitchKey switch_;
while (get_switch_flipped(&switch_)) {
if (switch_ == SwitchKey::s4) {
if (music_playing) {
stop_clip(MUSIC_FILE, 0);
music_playing = false;
} else {
play_clip_wav(MUSIC_FILE, true, true, 4, 0);
music_playing = true;
}
}
}
if (down_held != 0) { if (down_held != 0) {
// check repeat // check repeat
TickType_t now = xTaskGetTickCount(); TickType_t now = xTaskGetTickCount();
@ -319,7 +274,7 @@ bool play_game(int time, int required_score) {
strike("Out of time"); strike("Out of time");
return false; return false;
} }
// if (get_switch_flipped(&switch_)) { // if (get_flipped_switch(&switch_)) {
// printf("%d\n", piece); // printf("%d\n", piece);
// for (int i = 0; i < sizeof(piece_nodes)/sizeof(piece_nodes[0]); i++) { // for (int i = 0; i < sizeof(piece_nodes)/sizeof(piece_nodes[0]); i++) {
// int* p = piece_nodes[i]; // int* p = piece_nodes[i];
@ -338,84 +293,64 @@ bool play_game(int time, int required_score) {
return false; return false;
} }
static void complete() { static void complete(void) {
if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) { if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) {
reveal_board();
lv_label_set_text(game_over_label, "Winner!\nPress any button to continue"); lv_label_set_text(game_over_label, "Winner!\nPress any button to continue");
lv_obj_clear_flag(game_over_label, LV_OBJ_FLAG_HIDDEN); lv_obj_clear_flag(game_over_label, LV_OBJ_FLAG_HIDDEN);
xSemaphoreGive(xGuiSemaphore); xSemaphoreGive(xGuiSemaphore);
} }
vTaskDelay(pdMS_TO_TICKS(500)); vTaskDelay(pdMS_TO_TICKS(500));
while (get_button_pressed(nullptr)); while (get_pressed_button(nullptr));
while (1) { while (1) {
if (get_button_pressed(nullptr)) break; if (get_pressed_button(nullptr)) break;
vTaskDelay(pdMS_TO_TICKS(10)); vTaskDelay(pdMS_TO_TICKS(10));
} }
if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) { if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) {
lv_obj_add_flag(game_over_label, LV_OBJ_FLAG_HIDDEN); lv_obj_add_flag(game_over_label, LV_OBJ_FLAG_HIDDEN);
hide_board();
xSemaphoreGive(xGuiSemaphore); xSemaphoreGive(xGuiSemaphore);
} }
} }
static void fail() { static void fail(void) {
if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) { if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) {
lv_label_set_text(game_over_label, "Game Over\nPress any button to continue"); lv_label_set_text(game_over_label, "Game Over\nPress any button to continue");
lv_obj_clear_flag(game_over_label, LV_OBJ_FLAG_HIDDEN); lv_obj_clear_flag(game_over_label, LV_OBJ_FLAG_HIDDEN);
reveal_board();
xSemaphoreGive(xGuiSemaphore); xSemaphoreGive(xGuiSemaphore);
} }
vTaskDelay(pdMS_TO_TICKS(2000)); vTaskDelay(pdMS_TO_TICKS(500));
while (get_button_pressed(nullptr)); while (get_pressed_button(nullptr));
while (1) { while (1) {
if (get_button_pressed(nullptr)) break; if (get_pressed_button(nullptr)) break;
vTaskDelay(pdMS_TO_TICKS(10)); vTaskDelay(pdMS_TO_TICKS(10));
} }
if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) { if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) {
lv_obj_add_flag(game_over_label, LV_OBJ_FLAG_HIDDEN); lv_obj_add_flag(game_over_label, LV_OBJ_FLAG_HIDDEN);
hide_board();
xSemaphoreGive(xGuiSemaphore); xSemaphoreGive(xGuiSemaphore);
} }
} }
void step4() { void step4(void) {
// TODO: extract to helper function StarCodeHandler star_code = {
SemaphoreHandle_t continue_sem = xSemaphoreCreateBinary(); .code = "*3850",
if (continue_sem == nullptr) {
ESP_LOGE(TAG, "could not create semaphore");
}
StarCodeEntry start_code = {
.code = "3850",
.display_text = "Starting...", .display_text = "Starting...",
.delay_us = 2'000'000, .should_exit = true,
.callback = nullptr, .callback = nullptr,
.triggered_sem = continue_sem,
}; };
do_star_codes(&star_code, 1);
add_star_code(start_code);
xSemaphoreTake(continue_sem, portMAX_DELAY);
rm_star_code(start_code.code);
vSemaphoreDelete(continue_sem);
init_screen(); init_screen();
while (!play_game(4*60*1000, 2)) fail(); while (!play_game(4*60*1000, 2)) fail();
// TODO: create constants for common assets, and put them in a folder.
play_clip_wav(MOUNT_POINT "/partdone.wav", true, false, 0, 0);
complete(); complete();
while (!play_game(4*60*1000, 4)) fail(); while (!play_game(4*60*1000, 4)) fail();
play_clip_wav(MOUNT_POINT "/partdone.wav", true, false, 0, 0);
complete(); complete();
while (!play_game(7*60*1000, 8)) fail(); while (!play_game(6*60*1000, 8)) fail();
play_clip_wav(MOUNT_POINT "/stepdone.wav", true, false, 1, 0);
complete(); complete();
// vTaskDelay(pdMS_TO_TICKS(3000));
deinit_screen(); deinit_screen();
} }
static void show_board() { static void show_board(void) {
for (int h = 0; h < height; h++) { for (int h = 0; h < height; h++) {
for (int w = 0; w < width; w++) { for (int w = 0; w < width; w++) {
if (board[h][w] == 9) { if (board[h][w] == 9) {
@ -429,6 +364,16 @@ static void show_board() {
board[p[0]][p[1]] = 9; board[p[0]][p[1]] = 9;
} }
if (text_output) {
for (int h = height-1; h >= 0; h--) {
for (int w = 0; w < width; w++) {
printf("|%c", board[h][w] == 9 ? 'X' : (invisible_blocks ? '0' : ('0' + board[h][w])));
}
printf("|\n");
}
printf("\n");
}
if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) { if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) {
for (int i = 0; i < sizeof(piece_nodes)/sizeof(piece_nodes[0]); i++) { for (int i = 0; i < sizeof(piece_nodes)/sizeof(piece_nodes[0]); i++) {
int* p = piece_nodes[i]; int* p = piece_nodes[i];
@ -439,7 +384,7 @@ static void show_board() {
} }
} }
static void generate_block() { static void generate_block(void) {
int new_piece = piece_dist(gen); int new_piece = piece_dist(gen);
if (new_piece == piece) { if (new_piece == piece) {
new_piece = 1; new_piece = 1;
@ -474,7 +419,7 @@ static void generate_block() {
} }
} }
static void rotate_block() { static void rotate_block(void) {
piece_rotation++; piece_rotation++;
if (piece_rotation > 3) { if (piece_rotation > 3) {
piece_rotation = 0; piece_rotation = 0;
@ -552,7 +497,7 @@ static void rotate_block() {
} }
// Check if nodes are outside of map or interposed onto placed nodes // Check if nodes are outside of map or interposed onto placed nodes
static bool check_overlap() { static bool check_overlap(void) {
for (int i = 0; i < sizeof(piece_nodes)/sizeof(piece_nodes[0]); i++) { for (int i = 0; i < sizeof(piece_nodes)/sizeof(piece_nodes[0]); i++) {
int* p = piece_nodes[i]; int* p = piece_nodes[i];
if (p[0] < 0 || p[1] < 0 || p[1] >= width) { if (p[0] < 0 || p[1] < 0 || p[1] >= width) {
@ -564,7 +509,7 @@ static bool check_overlap() {
return false; return false;
} }
static void move_left() { static void move_left(void) {
for (int i = 0; i < sizeof(piece_nodes)/sizeof(piece_nodes[0]); i++) { for (int i = 0; i < sizeof(piece_nodes)/sizeof(piece_nodes[0]); i++) {
int* p = piece_nodes[i]; int* p = piece_nodes[i];
if (p[1] == 0) { if (p[1] == 0) {
@ -578,7 +523,7 @@ static void move_left() {
get_node_locations(); get_node_locations();
} }
static void move_right() { static void move_right(void) {
for (int i = 0; i < sizeof(piece_nodes)/sizeof(piece_nodes[0]); i++) { for (int i = 0; i < sizeof(piece_nodes)/sizeof(piece_nodes[0]); i++) {
int* p = piece_nodes[i]; int* p = piece_nodes[i];
if (p[1] == width-1) { if (p[1] == width-1) {
@ -591,7 +536,7 @@ static void move_right() {
get_node_locations(); get_node_locations();
} }
static void drop() { static void drop(void) {
for (int i = 0; i < sizeof(piece_nodes)/sizeof(piece_nodes[0]); i++) { for (int i = 0; i < sizeof(piece_nodes)/sizeof(piece_nodes[0]); i++) {
int* p = piece_nodes[i]; int* p = piece_nodes[i];
if (p[0] == 0) { if (p[0] == 0) {
@ -611,7 +556,7 @@ static void drop() {
get_node_locations(); get_node_locations();
} }
static void place_piece() { static void place_piece(void) {
for (int h = 0; h < height; h++) { for (int h = 0; h < height; h++) {
for (int w = 0; w < width; w++) { for (int w = 0; w < width; w++) {
if (board[h][w] == 9) { if (board[h][w] == 9) {
@ -621,6 +566,7 @@ static void place_piece() {
} }
if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) { if (xSemaphoreTake(xGuiSemaphore, portMAX_DELAY) == pdTRUE) {
for (int i = 0; i < sizeof(piece_nodes)/sizeof(piece_nodes[0]); i++) { for (int i = 0; i < sizeof(piece_nodes)/sizeof(piece_nodes[0]); i++) {
int* p = piece_nodes[i];
lv_obj_align(piece_imgs[i], LV_ALIGN_BOTTOM_LEFT, 159, -(height*16)); lv_obj_align(piece_imgs[i], LV_ALIGN_BOTTOM_LEFT, 159, -(height*16));
} }
xSemaphoreGive(xGuiSemaphore); xSemaphoreGive(xGuiSemaphore);
@ -700,7 +646,7 @@ static void get_node_locations() {
} }
} }
static void check_line_clears() { static void check_line_clears(void) {
for (int h = height-2; h >= 0; h--) { for (int h = height-2; h >= 0; h--) {
for (int w = 0; w < width; w++) { for (int w = 0; w < width; w++) {
if (board[h][w] != 0 && board[h][w] != 9) { if (board[h][w] != 0 && board[h][w] != 9) {
@ -714,11 +660,12 @@ static void check_line_clears() {
} }
} }
static void update_score() { static void update_score(void) {
char buff[16] = {}; char buff[16] = {};
sprintf(buff, "%d/%d", score, target_score); sprintf(buff, "%d/%d", score, target_score);
lcd_clear(); lcd_clear(&lcd);
lcd_print(1, 1, buff); lcd_set_cursor(&lcd, 1, 1);
lcd_print(&lcd, buff);
} }
static void line_clear(int hi) { static void line_clear(int hi) {
@ -751,7 +698,7 @@ static void line_clear(int hi) {
} }
} }
void clear_board() { void clear_board(void) {
for (int h = 0; h < height; h++) { for (int h = 0; h < height; h++) {
for (int w = 0; w < width; w++) { for (int w = 0; w < width; w++) {
board[h][w] = 0; board[h][w] = 0;

17
main/steps/step4.h
View File

@ -2,12 +2,21 @@
#define STEP_4_H #define STEP_4_H
#include <random> #include <random>
#include "../drivers/all.h" #include "../drivers/tft.h"
#include "../drivers/speaker.h"
#include "../drivers/bottom_half.h"
#include "../drivers/game_timer.h"
#include "../drivers/wires.h"
#include "../drivers/char_lcd.h"
#include "../helper.h" #include "../helper.h"
#include "esp_log.h"
#define TETRIS_USE_FLASH_IMG // TODO:
#define TETRIS_USE_FLASH_BG_IMG // - [ ] set up real game loop
// - [ ] stop music
// - [ ] set up strike on falure
// - [ ] set up module timer
void step4(void); void step4(void);

301
main/steps/step5.cpp
View File

@ -1,16 +1,5 @@
#include "step5.h" #include "step5.h"
#define TIME_CLEAR 30'000
#define TIME_PLANK 40'000
#define TIME_EMPTY 40'000
#define TIME_NOTHING 25'000
#define TIME_BLINK 35'000
#define TIME_UMMM 35'000
#define TIME_BLANK 40'000
#define TIME_WHAT 60'000
#define TIME_PLINK 40'000
__attribute__((unused))
static const char *TAG = "step5"; static const char *TAG = "step5";
static const int TIMES_TO_SOLVE = 9; static const int TIMES_TO_SOLVE = 9;
@ -21,23 +10,23 @@ static std::uniform_int_distribution<> puzzle_dist(0, 7);
static std::uniform_int_distribution<> led_picker_dist(0, 20); static std::uniform_int_distribution<> led_picker_dist(0, 20);
static std::uniform_int_distribution<> led_color_dist(0, 5); static std::uniform_int_distribution<> led_color_dist(0, 5);
void set_unique_leds(std::vector<int>& input_options, const int num, const uint32_t color) { void set_unique_leds(std::vector<int>& input_options, const int num, const int r, const int g, const int b) {
for (int i = 0; i < num; i++) { for (int i = 0; i < num; i++) {
std::uniform_int_distribution<> led_option_dist(0, input_options.size() - 1); std::uniform_int_distribution<> led_option_dist(0, input_options.size() - 1);
int led = led_option_dist(gen); int led = led_option_dist(gen);
led_set(input_options[led], color); ESP_ERROR_CHECK(led_strip_set_pixel(leds, input_options[led], r, g, b));
input_options.erase(input_options.begin() + led); input_options.erase(input_options.begin() + led);
} }
} }
void set_unique_leds_random_color(std::vector<int>& input_options, const int num, const uint32_t* COLORS, size_t COLORS_len) { void set_unique_leds_random_color(std::vector<int>& input_options, const int num, const int* r, const int* g, const int* b) {
for (int i = 0; i < num; i++) { for (int i = 0; i < num; i++) {
std::uniform_int_distribution<> led_option_dist(0, input_options.size() - 1); std::uniform_int_distribution<> led_option_dist(0, input_options.size() - 1);
int led = led_option_dist(gen); int led = led_option_dist(gen);
std::uniform_int_distribution<> led_color_dist(0, COLORS_len - 1); std::uniform_int_distribution<> led_color_dist(0, sizeof(r) - 1);
int color = led_color_dist(gen); int color = led_color_dist(gen);
led_set(input_options[led], COLORS[color]); ESP_ERROR_CHECK(led_strip_set_pixel(leds, input_options[led], r[color], g[color], b[color]));
input_options.erase(input_options.begin() + led); input_options.erase(input_options.begin() + led);
} }
} }
@ -179,23 +168,16 @@ bool submit_6(bool* buttons_cycling, bool button_turned_on, int led_off) {
} }
void step5(void) { void step5(void) {
SemaphoreHandle_t continue_sem = xSemaphoreCreateBinary(); StarCodeHandler star_codes[] = {
if (continue_sem == nullptr) { {
ESP_LOGE(TAG, "could not create semaphore"); .code = "*2648",
} .display_text = "Starting...",
.should_exit = true,
StarCodeEntry start_code = { .callback = nullptr,
.code = "2648", },
.display_text = "Starting...",
.delay_us = 2'000'000,
.callback = nullptr,
.triggered_sem = continue_sem,
}; };
int len = sizeof(star_codes)/sizeof(StarCodeHandler);
add_star_code(start_code); do_star_codes(star_codes, len);
xSemaphoreTake(continue_sem, portMAX_DELAY);
rm_star_code(start_code.code);
vSemaphoreDelete(continue_sem);
std::vector<int> all_leds; std::vector<int> all_leds;
@ -203,14 +185,9 @@ void step5(void) {
all_leds.push_back(i); all_leds.push_back(i);
} }
const uint32_t COLORS[] = { const int INDICATOR_RED[6] = {20, 0, 0, 10, 10, 5};
LEDColor::LED_COLOR_RED, const int INDICATOR_GREEN[6] = {0, 0, 10, 5, 0, 7};
LEDColor::LED_COLOR_BLUE, const int INDICATOR_BLUE[6] = {0, 10, 0, 0, 5, 5};
LEDColor::LED_COLOR_GREEN,
LEDColor::LED_COLOR_YELLOW,
LEDColor::LED_COLOR_PINK,
LEDColor::LED_COLOR_WHITE,
};
static std::uniform_int_distribution<> led_number_dist(0, 21); static std::uniform_int_distribution<> led_number_dist(0, 21);
int last_cycle_tick = xTaskGetTickCount(); int last_cycle_tick = xTaskGetTickCount();
@ -219,8 +196,8 @@ void step5(void) {
if ((xTaskGetTickCount() - last_cycle_tick) > pdMS_TO_TICKS(100)) { if ((xTaskGetTickCount() - last_cycle_tick) > pdMS_TO_TICKS(100)) {
clean_bomb(); clean_bomb();
std::vector<int> led_options = all_leds; std::vector<int> led_options = all_leds;
set_unique_leds_random_color(led_options, led_number_dist(gen), COLORS, sizeof(COLORS)/sizeof(COLORS[0])); set_unique_leds_random_color(led_options, led_number_dist(gen), INDICATOR_RED, INDICATOR_GREEN, INDICATOR_BLUE);
leds_flush(); ESP_ERROR_CHECK(led_strip_refresh(leds));
last_cycle_tick = xTaskGetTickCount(); last_cycle_tick = xTaskGetTickCount();
scrambled_times++; scrambled_times++;
} }
@ -229,14 +206,16 @@ void step5(void) {
clean_bomb(); clean_bomb();
int solved_puzzles = 0; int solved_puzzles = 0;
while (solved_puzzles < TIMES_TO_SOLVE) { while (solved_puzzles < TIMES_TO_SOLVE) {
lcd_set_cursor(&lcd, 1, 1);
bool solved_correctly = false; bool solved_correctly = false;
int puzzle = puzzle_dist(gen); int puzzle = puzzle_dist(gen);
// int puzzle = 2;
switch (puzzle) { switch (puzzle) {
case 0: { case 0: {
lcd_print(1, 1, "Clear"); lcd_print(&lcd, "Clear");
set_module_time(TIME_CLEAR); set_module_time(30000);
start_module_timer(); start_module_timer();
std::vector<int> indicator_options = all_leds; std::vector<int> indicator_options = all_leds;
@ -244,23 +223,21 @@ void step5(void) {
// set green // set green
std::uniform_int_distribution<> green_indicators_dist(1, 15); std::uniform_int_distribution<> green_indicators_dist(1, 15);
uint8_t green_indicators = green_indicators_dist(gen); uint8_t green_indicators = green_indicators_dist(gen);
set_unique_leds(indicator_options, green_indicators, LEDColor::LED_COLOR_GREEN); set_unique_leds(indicator_options, green_indicators, 0, 10, 0);
// set non-green // set non-green
const uint32_t NON_GREEN_COLORS[] = { const int NON_GREEN_INDICATOR_RED[3] = {20, 0, 10};
LEDColor::LED_COLOR_RED, const int NON_GREEN_INDICATOR_GREEN[3] = {0, 0, 0};
LEDColor::LED_COLOR_BLUE, const int NON_GREEN_INDICATOR_BLUE[3] = {0, 10, 5};
LEDColor::LED_COLOR_PINK,
};
std::uniform_int_distribution<> non_green_indicators_dist(0, (20 - green_indicators)); std::uniform_int_distribution<> non_green_indicators_dist(0, (20 - green_indicators));
set_unique_leds_random_color(indicator_options, non_green_indicators_dist(gen), NON_GREEN_COLORS, sizeof(NON_GREEN_COLORS)/sizeof(NON_GREEN_COLORS[0])); set_unique_leds_random_color(indicator_options, non_green_indicators_dist(gen), NON_GREEN_INDICATOR_RED, NON_GREEN_INDICATOR_GREEN, NON_GREEN_INDICATOR_BLUE);
leds_flush(); ESP_ERROR_CHECK(led_strip_refresh(leds));
// wait for submit // wait for submit
KeypadKey key; KeypadKey key;
while (1) { while (1) {
if (get_module_time() <= 0 || (get_keypad_pressed(&key) && (char_of_keypad_key(key) == '#'))) { if (get_module_time() <= 0 || (get_pressed_keypad(&key) && (char_of_keypad_key(key) == '#'))) {
solved_correctly = submit_0(green_indicators); solved_correctly = submit_0(green_indicators);
break; break;
} }
@ -270,24 +247,27 @@ void step5(void) {
break; break;
} }
case 1: { case 1: {
lcd_print(1, 1, "Blank"); lcd_print(&lcd, "Blank");
set_module_time(TIME_BLANK); set_module_time(40000);
start_module_timer(); start_module_timer();
std::uniform_int_distribution<> on_indicators_dist(16, 21); std::uniform_int_distribution<> on_indicators_dist(16, 21);
uint8_t indicators_num = on_indicators_dist(gen); uint8_t indicators_num = on_indicators_dist(gen);
std::vector<int> indicator_options = all_leds; std::vector<int> indicator_options = all_leds;
const int INDICATOR_RED[6] = {20, 0, 0, 10, 10, 5};
const int INDICATOR_GREEN[6] = {0, 0, 10, 5, 0, 7};
const int INDICATOR_BLUE[6] = {0, 10, 0, 0, 5, 5};
set_unique_leds_random_color(indicator_options, indicators_num, COLORS, sizeof(COLORS)/sizeof(COLORS[0])); set_unique_leds_random_color(indicator_options, indicators_num, INDICATOR_RED, INDICATOR_BLUE, INDICATOR_GREEN);
leds_flush(); ESP_ERROR_CHECK(led_strip_refresh(leds));
uint8_t starting_switch_state = get_switch_state(); uint8_t starting_switch_state = get_switch_state();
std::string pressed_keys; std::string pressed_keys;
KeypadKey key; KeypadKey key;
while (1) { while (1) {
if (get_keypad_pressed(&key)) { if (get_pressed_keypad(&key)) {
char keypad_char = char_of_keypad_key(key); char keypad_char = char_of_keypad_key(key);
if (keypad_char == '#') { if (keypad_char == '#') {
solved_correctly = submit_1(indicators_num, pressed_keys, starting_switch_state); solved_correctly = submit_1(indicators_num, pressed_keys, starting_switch_state);
@ -305,7 +285,7 @@ void step5(void) {
break; break;
} }
case 2: { case 2: {
set_module_time(TIME_EMPTY); set_module_time(40000);
start_module_timer(); start_module_timer();
std::map<int, int> idx_to_led_map = { std::map<int, int> idx_to_led_map = {
@ -324,10 +304,10 @@ void step5(void) {
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
if (lit_leds[i]) { if (lit_leds[i]) {
int color = led_color_dist(gen); int color = led_color_dist(gen);
led_set(idx_to_led_map[i], COLORS[color]); ESP_ERROR_CHECK(led_strip_set_pixel(leds, idx_to_led_map[i], INDICATOR_RED[color], INDICATOR_GREEN[color], INDICATOR_BLUE[color]));
} }
} }
leds_flush(); ESP_ERROR_CHECK(led_strip_refresh(leds));
int green_button_pressed = 0; int green_button_pressed = 0;
int blue_button_pressed = 0; int blue_button_pressed = 0;
@ -338,7 +318,7 @@ void step5(void) {
ButtonKey button; ButtonKey button;
while (1) { while (1) {
if (get_button_pressed(&button)) { if (get_pressed_button(&button)) {
uint8_t button_state = get_button_state(); uint8_t button_state = get_button_state();
if ((button_state & 0b1) == 0b1) { if ((button_state & 0b1) == 0b1) {
@ -364,7 +344,7 @@ void step5(void) {
break; break;
} }
} }
if (get_keypad_pressed(&key)) { if (get_pressed_keypad(&key)) {
char keypad_char = char_of_keypad_key(key); char keypad_char = char_of_keypad_key(key);
if (keypad_char == '#') { if (keypad_char == '#') {
solved_correctly = submit_2(lit_leds, green_button_pressed, blue_button_pressed, fingerprint_sensor_pressed, keypad_string); solved_correctly = submit_2(lit_leds, green_button_pressed, blue_button_pressed, fingerprint_sensor_pressed, keypad_string);
@ -384,16 +364,13 @@ void step5(void) {
break; break;
} }
case 3: { case 3: {
lcd_print(1, 1, "Nothing"); lcd_print(&lcd, "Nothing");
set_module_time(TIME_NOTHING); set_module_time(25000);
start_module_timer(); start_module_timer();
const uint32_t COLORS[] = { const int COLOR_RED[5] = {0, 20, 10, 0};
LEDColor::LED_COLOR_GREEN, const int COLOR_GREEN[5] = {20, 0, 10, 0};
LEDColor::LED_COLOR_RED, const int COLOR_BLUE[5] = {0, 0, 0, 20};
LEDColor::LED_COLOR_YELLOW,
LEDColor::LED_COLOR_BLUE,
};
static std::uniform_int_distribution<> color_dist(0, 3); static std::uniform_int_distribution<> color_dist(0, 3);
@ -401,16 +378,18 @@ void step5(void) {
int speaker_color = color_dist(gen); int speaker_color = color_dist(gen);
int s3_color = color_dist(gen); int s3_color = color_dist(gen);
led_set(IndicatorLED::LED_TFT, COLORS[tft_color]); ESP_ERROR_CHECK(led_strip_set_pixel(leds, 6, COLOR_RED[tft_color], COLOR_GREEN[tft_color], COLOR_BLUE[tft_color]));
led_set(IndicatorLED::LED_SPEAKER, COLORS[speaker_color]); ESP_ERROR_CHECK(led_strip_set_pixel(leds, 9, COLOR_RED[speaker_color], COLOR_GREEN[speaker_color], COLOR_BLUE[speaker_color]));
led_set(IndicatorLED::LED_S3, COLORS[s3_color]); ESP_ERROR_CHECK(led_strip_set_pixel(leds, 14, COLOR_RED[s3_color], COLOR_GREEN[s3_color], COLOR_BLUE[s3_color]));
leds_flush(); ESP_ERROR_CHECK(led_strip_refresh(leds));
int buttons_pressed = 0; int buttons_pressed = 0;
ButtonKey button; ButtonKey button;
KeypadKey key;
while (1) { while (1) {
if (get_button_pressed(&button)) { if (get_pressed_button(&button)) {
buttons_pressed++; buttons_pressed++;
uint8_t button_state = get_button_state(); uint8_t button_state = get_button_state();
@ -443,48 +422,42 @@ void step5(void) {
break; break;
} }
case 4: { case 4: {
lcd_print(1, 1, "Blink"); lcd_print(&lcd, "Blink");
set_module_time(TIME_BLINK); set_module_time(35000);
start_module_timer(); start_module_timer();
// buttons // buttons
const uint32_t BUTTON_COLORS[] = { const int BUTTON_COLOR_RED[4] = {0, 20, 10, 0};
LEDColor::LED_COLOR_GREEN, const int BUTTON_COLOR_GREEN[4] = {10, 0, 5, 0};
LEDColor::LED_COLOR_RED, const int BUTTON_COLOR_BLUE[4] = {0, 0, 0, 10};
LEDColor::LED_COLOR_YELLOW,
LEDColor::LED_COLOR_BLUE,
};
static std::uniform_int_distribution<> button_color_dist(0, 3); static std::uniform_int_distribution<> button_color_dist(0, 3);
int button_colors[4] = {button_color_dist(gen), button_color_dist(gen), button_color_dist(gen), button_color_dist(gen)}; int button_colors[4] = {button_color_dist(gen), button_color_dist(gen), button_color_dist(gen), button_color_dist(gen)};
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
led_set(IndicatorLED::LED_B1 - i, BUTTON_COLORS[button_colors[i]]); ESP_ERROR_CHECK(led_strip_set_pixel(leds, (20 - i), BUTTON_COLOR_RED[button_colors[i]], BUTTON_COLOR_GREEN[button_colors[i]], BUTTON_COLOR_BLUE[button_colors[i]]));
} }
// switches // switches
const uint32_t SWITCH_COLOR[] = { const int SWITCH_COLOR_RED[3] = {20, 0, 10};
LEDColor::LED_COLOR_RED, const int SWITCH_COLOR_GREEN[3] = {0, 10, 5};
LEDColor::LED_COLOR_GREEN,
LEDColor::LED_COLOR_YELLOW,
};
static std::uniform_int_distribution<> switch_color_dist(0, 2); static std::uniform_int_distribution<> switch_color_dist(0, 2);
int switch_colors[4] = {switch_color_dist(gen), switch_color_dist(gen), switch_color_dist(gen), switch_color_dist(gen)}; int switch_colors[4] = {switch_color_dist(gen), switch_color_dist(gen), switch_color_dist(gen), switch_color_dist(gen)};
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
led_set(IndicatorLED::LED_S1 - i, SWITCH_COLOR[switch_colors[i]]); ESP_ERROR_CHECK(led_strip_set_pixel(leds, (16 - i), SWITCH_COLOR_RED[switch_colors[i]], SWITCH_COLOR_GREEN[switch_colors[i]], 0));
} }
leds_flush(); ESP_ERROR_CHECK(led_strip_refresh(leds));
ButtonKey button; ButtonKey button;
KeypadKey key; KeypadKey key;
uint8_t starting_switch_state = get_switch_state(); uint8_t starting_switch_state = get_switch_state();
while (1) { while (1) {
if (get_button_pressed(&button)) { if (get_pressed_button(&button)) {
uint8_t button_state = get_button_state(); uint8_t button_state = get_button_state();
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
@ -493,12 +466,13 @@ void step5(void) {
if (button_colors[i] > 3) { if (button_colors[i] > 3) {
button_colors[i] = 0; button_colors[i] = 0;
} }
led_set(IndicatorLED::LED_B1 - i, BUTTON_COLORS[button_colors[i]]); ESP_ERROR_CHECK(led_strip_set_pixel(leds, (20 - i), BUTTON_COLOR_RED[button_colors[i]], BUTTON_COLOR_GREEN[button_colors[i]], BUTTON_COLOR_BLUE[button_colors[i]]));
} }
} }
leds_flush(); ESP_ERROR_CHECK(led_strip_refresh(leds));
} }
if (get_module_time() <= 0 || (get_keypad_pressed(&key) && (char_of_keypad_key(key) == '#'))) { if (get_module_time() <= 0 || (get_pressed_keypad(&key) && (char_of_keypad_key(key) == '#'))) {
solved_correctly = submit_4(button_colors, switch_colors, starting_switch_state); solved_correctly = submit_4(button_colors, switch_colors, starting_switch_state);
break; break;
} }
@ -507,34 +481,31 @@ void step5(void) {
break; break;
} }
case 5: { case 5: {
lcd_print(1, 1, "Ummm"); lcd_print(&lcd, "Ummm");
set_module_time(TIME_UMMM); set_module_time(35000);
start_module_timer(); start_module_timer();
std::uniform_int_distribution<> indicator_number_dist(0, 5); std::uniform_int_distribution<> indicator_number_dist(0, 5);
const uint32_t COLORS[] = { const int INDICATOR_RED[4] = {0, 20, 10, 0};
LEDColor::LED_COLOR_GREEN, const int INDICATOR_GREEN[4] = {10, 0, 5, 0};
LEDColor::LED_COLOR_RED, const int INDICATOR_BLUE[4] = {0, 0, 0, 10};
LEDColor::LED_COLOR_YELLOW,
LEDColor::LED_COLOR_BLUE,
};
// green, red, yellow, blue // green, red, yellow, blue
std::array<int, 4> indicator_numbers = {indicator_number_dist(gen), indicator_number_dist(gen), indicator_number_dist(gen), indicator_number_dist(gen)}; std::array<int, 4> indicator_numbers = {indicator_number_dist(gen), indicator_number_dist(gen), indicator_number_dist(gen), indicator_number_dist(gen)};
std::vector<int> indicator_options = all_leds; std::vector<int> indicator_options = all_leds;
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
set_unique_leds(indicator_options, indicator_numbers[i], COLORS[i]); set_unique_leds(indicator_options, indicator_numbers[i], INDICATOR_RED[i], INDICATOR_GREEN[i], INDICATOR_BLUE[i]);
} }
leds_flush(); ESP_ERROR_CHECK(led_strip_refresh(leds));
std::array<int, 4> buttons_pressed = {0, 0, 0, 0}; std::array<int, 4> buttons_pressed = {0, 0, 0, 0};
ButtonKey button; ButtonKey button;
KeypadKey key; KeypadKey key;
while (1) { while (1) {
if (get_button_pressed(&button)) { if (get_pressed_button(&button)) {
uint8_t button_state = get_button_state(); uint8_t button_state = get_button_state();
bool failed = false; bool failed = false;
@ -552,7 +523,7 @@ void step5(void) {
break; break;
} }
} }
if (get_module_time() <= 0 || (get_keypad_pressed(&key) && (char_of_keypad_key(key) == '#'))) { if (get_module_time() <= 0 || (get_pressed_keypad(&key) && (char_of_keypad_key(key) == '#'))) {
ESP_LOGI(TAG, "Keypad Char: %c, time: %lu", char_of_keypad_key(key), get_module_time()); ESP_LOGI(TAG, "Keypad Char: %c, time: %lu", char_of_keypad_key(key), get_module_time());
solved_correctly = submit_5(indicator_numbers, buttons_pressed); solved_correctly = submit_5(indicator_numbers, buttons_pressed);
break; break;
@ -563,21 +534,17 @@ void step5(void) {
break; break;
} }
case 6: { case 6: {
lcd_print(1, 1, "Plank"); lcd_print(&lcd, "Plank");
set_module_time(TIME_PLANK); set_module_time(40000);
start_module_timer(); start_module_timer();
std::uniform_int_distribution<> led_color_dist(0, 5); std::uniform_int_distribution<> led_color_dist(0, 5);
std::uniform_int_distribution<> led_off_dist(-1, 3); std::uniform_int_distribution<> led_off_dist(-1, 3);
const uint32_t COLORS[] = { // red, purple, blue, white, green, yellow
LEDColor::LED_COLOR_RED, const uint8_t COLORS_RED[6] = {20, 10, 0, 5, 0, 10};
LEDColor::LED_COLOR_PINK, const uint8_t COLORS_GREEN[6] = {0, 0, 0, 7, 10, 5};
LEDColor::LED_COLOR_BLUE, const uint8_t COLORS_BLUE[6] = {0, 10, 10, 5, 0, 0};
LEDColor::LED_COLOR_WHITE,
LEDColor::LED_COLOR_GREEN,
LEDColor::LED_COLOR_YELLOW,
};
int button_colors[4]; int button_colors[4];
bool buttons_cycling[4]; bool buttons_cycling[4];
@ -586,14 +553,14 @@ void step5(void) {
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
if (led_off != i) { if (led_off != i) {
button_colors[i] = led_color_dist(gen); button_colors[i] = led_color_dist(gen);
led_set(IndicatorLED::LED_B1 - i, COLORS[button_colors[i]]); ESP_ERROR_CHECK(led_strip_set_pixel(leds, (20 - i), COLORS_RED[button_colors[i]], COLORS_GREEN[button_colors[i]], COLORS_BLUE[button_colors[i]]));
buttons_cycling[i] = true; buttons_cycling[i] = true;
} else { } else {
button_colors[i] = -1; button_colors[i] = -1;
buttons_cycling[i] = false; buttons_cycling[i] = false;
} }
} }
leds_flush(); ESP_ERROR_CHECK(led_strip_refresh(leds));
const uint8_t CORRECT_COLORS[4] = {4, 0, 5, 2}; const uint8_t CORRECT_COLORS[4] = {4, 0, 5, 2};
TickType_t lastCycleTime = xTaskGetTickCount(); TickType_t lastCycleTime = xTaskGetTickCount();
@ -604,7 +571,7 @@ void step5(void) {
std::uniform_int_distribution<> led_turn_on_dist(0, 3); std::uniform_int_distribution<> led_turn_on_dist(0, 3);
while (1) { while (1) {
if (get_button_pressed(&button)) { if (get_pressed_button(&button)) {
uint8_t button_state = get_button_state(); uint8_t button_state = get_button_state();
bool failed = false; bool failed = false;
@ -617,8 +584,8 @@ void step5(void) {
break; break;
} else if (led_turn_on_dist(gen) == 0) { } else if (led_turn_on_dist(gen) == 0) {
button_turned_on = true; button_turned_on = true;
led_set(IndicatorLED::LED_B1 - i, COLORS[CORRECT_COLORS[i]]); led_strip_set_pixel(leds, (20 - i), COLORS_RED[CORRECT_COLORS[i]], COLORS_GREEN[CORRECT_COLORS[i]], COLORS_BLUE[CORRECT_COLORS[i]]);
leds_flush(); led_strip_refresh(leds);
} }
} else if (button_colors[i] != CORRECT_COLORS[i]) { } else if (button_colors[i] != CORRECT_COLORS[i]) {
strike("Wrong time!"); strike("Wrong time!");
@ -634,20 +601,21 @@ void step5(void) {
} }
} }
if ((xTaskGetTickCount() - lastCycleTime) >= pdMS_TO_TICKS(500)) { if ((xTaskGetTickCount() - lastCycleTime) >= pdMS_TO_TICKS(500)) {
for (uint32_t i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
if (buttons_cycling[i]) { if (buttons_cycling[i]) {
button_colors[i]++; button_colors[i]++;
if (button_colors[i] > 5) { if (button_colors[i] > 5) {
button_colors[i] = 0; button_colors[i] = 0;
} }
led_set(IndicatorLED::LED_B1 - i, COLORS[button_colors[i]]); ESP_ERROR_CHECK(led_strip_set_pixel(leds, (20 - i), COLORS_RED[button_colors[i]], COLORS_GREEN[button_colors[i]], COLORS_BLUE[button_colors[i]]));
} }
} }
leds_flush(); ESP_ERROR_CHECK(led_strip_refresh(leds));
lastCycleTime = xTaskGetTickCount(); lastCycleTime = xTaskGetTickCount();
} }
if (get_module_time() <= 0 || (get_keypad_pressed(&key) && (char_of_keypad_key(key) == '#'))) { get_pressed_keypad(&key);
if (get_module_time() <= 0 || (get_pressed_keypad(&key) && (char_of_keypad_key(key) == '#'))) {
solved_correctly = submit_6(buttons_cycling, button_turned_on, led_off); solved_correctly = submit_6(buttons_cycling, button_turned_on, led_off);
break; break;
} }
@ -656,8 +624,8 @@ void step5(void) {
break; break;
} }
case 7: { case 7: {
lcd_print(1, 1, "What"); lcd_print(&lcd, "What");
set_module_time(TIME_WHAT); set_module_time(55000);
start_module_timer(); start_module_timer();
std::uniform_int_distribution<> math_number_dist(1, 9); std::uniform_int_distribution<> math_number_dist(1, 9);
@ -729,15 +697,15 @@ void step5(void) {
} }
// display expression // display expression
lcd_print(2, 1, display_expression.c_str()); lcd_set_cursor(&lcd, 1, 2);
lcd_print(&lcd, display_expression.c_str());
// set LEDs // set LEDs
const uint32_t COLORS[] = {
LEDColor::LED_COLOR_BLUE, // blue, red, green, yellow
LEDColor::LED_COLOR_RED, const int INDICATOR_RED[4] = {0, 20, 0, 10};
LEDColor::LED_COLOR_GREEN, const int INDICATOR_GREEN[4] = {0, 0, 10, 5};
LEDColor::LED_COLOR_YELLOW, const int INDICATOR_BLUE[4] = {10, 0, 0, 0};
};
std::uniform_int_distribution<> add_sub_indicator_dist(1, 6); std::uniform_int_distribution<> add_sub_indicator_dist(1, 6);
std::uniform_int_distribution<> mult_div_indicator_dist(1, 3); std::uniform_int_distribution<> mult_div_indicator_dist(1, 3);
@ -759,10 +727,10 @@ void step5(void) {
std::vector<int> led_options = all_leds; std::vector<int> led_options = all_leds;
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
set_unique_leds(led_options, modifier_indicators[i], COLORS[i]); set_unique_leds(led_options, modifier_indicators[i], INDICATOR_RED[i], INDICATOR_GREEN[i], INDICATOR_BLUE[i]);
} }
leds_flush(); ESP_ERROR_CHECK(led_strip_refresh(leds));
std::string answer_string = std::to_string(expression_answer); std::string answer_string = std::to_string(expression_answer);
std::string entered_string = ""; std::string entered_string = "";
@ -772,7 +740,7 @@ void step5(void) {
KeypadKey key; KeypadKey key;
while (1) { while (1) {
if (get_keypad_pressed(&key)) { if (get_pressed_keypad(&key)) {
if (key == KeypadKey::star) { if (key == KeypadKey::star) {
// clear // clear
entered_string = ""; entered_string = "";
@ -780,6 +748,7 @@ void step5(void) {
// submit // submit
if (entered_string != answer_string) { if (entered_string != answer_string) {
strike("Incorrect answer!"); strike("Incorrect answer!");
break;
} else { } else {
solved_correctly = true; solved_correctly = true;
} }
@ -788,37 +757,38 @@ void step5(void) {
entered_string += char_of_keypad_key(key); entered_string += char_of_keypad_key(key);
} }
lcd_clear(); lcd_clear(&lcd);
lcd_print(1, 1, "What"); lcd_set_cursor(&lcd, 1, 1);
lcd_print(2, 1, display_expression.c_str()); lcd_print(&lcd, "What");
lcd_print(3, 1, entered_string.c_str()); lcd_set_cursor(&lcd, 1, 2);
lcd_print(&lcd, display_expression.c_str());
lcd_set_cursor(&lcd, 1, 3);
lcd_print(&lcd, entered_string.c_str());
} }
if (get_module_time() <= 0) { if (get_module_time() <= 0) {
strike("Ran out of time!"); strike("Ran out of time!");
break; break;
} }
vTaskDelay(pdMS_TO_TICKS(10)); vTaskDelay(pdMS_TO_TICKS(10));
} }
break; break;
} }
case 8: { case 8: {
lcd_print(1, 1, "Plink"); lcd_print(&lcd, "Plink");
set_module_time(TIME_PLINK); set_module_time(40000);
start_module_timer(); start_module_timer();
std::uniform_int_distribution<> indicator_number_dist(0, 4); std::uniform_int_distribution<> indicator_number_dist(0, 4);
// ESP_LOGI(TAG, "Green: %i, Red: %i, Yellow: %i, Blue: %i", green_indicators, red_indicators, yellow_indicators, blue_indicators); // ESP_LOGI(TAG, "Green: %i, Red: %i, Yellow: %i, Blue: %i", green_indicators, red_indicators, yellow_indicators, blue_indicators);
const uint32_t COLORS[] = { // green, red, yellow, blue, purple
LEDColor::LED_COLOR_GREEN, const int INDICATOR_RED[5] = {0, 20, 10, 0, 10};
LEDColor::LED_COLOR_RED, const int INDICATOR_GREEN[5] = {10, 0, 5, 0, 0};
LEDColor::LED_COLOR_YELLOW, const int INDICATOR_BLUE[5] = {0, 0, 0, 10, 5};
LEDColor::LED_COLOR_BLUE,
LEDColor::LED_COLOR_PINK,
};
int solved_times = 0; int solved_times = 0;
bool failed = false; bool failed = false;
@ -827,10 +797,11 @@ void step5(void) {
std::vector<int> led_options = all_leds; std::vector<int> led_options = all_leds;
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
set_unique_leds(led_options, indicator_numbers[i], COLORS[i]); set_unique_leds(led_options, indicator_numbers[i], INDICATOR_RED[i], INDICATOR_GREEN[i], INDICATOR_BLUE[i]);
} }
leds_flush();
ESP_ERROR_CHECK(led_strip_refresh(leds));
std::uniform_int_distribution<> answer_color_dist(0, 4); std::uniform_int_distribution<> answer_color_dist(0, 4);
@ -839,7 +810,7 @@ void step5(void) {
{1, "Red"}, {1, "Red"},
{2, "Yellow"}, {2, "Yellow"},
{3, "Blue"}, {3, "Blue"},
{4, "Pink"}, {4, "Purple"},
}; };
int answer_color = answer_color_dist(gen); int answer_color = answer_color_dist(gen);
@ -849,13 +820,14 @@ void step5(void) {
// ESP_LOGI(TAG, "color string: %s", color_string.c_str()); // ESP_LOGI(TAG, "color string: %s", color_string.c_str());
lcd_print(2, 1, color_string.c_str()); lcd_set_cursor(&lcd, 1, 2);
lcd_print(&lcd, color_string.c_str());
std::string entered_string; std::string entered_string;
KeypadKey key; KeypadKey key;
while (1) { while (1) {
if (get_keypad_pressed(&key)) { if (get_pressed_keypad(&key)) {
bool failed = false; bool failed = false;
if (key == KeypadKey::star) { if (key == KeypadKey::star) {
@ -878,10 +850,13 @@ void step5(void) {
break; break;
} }
lcd_clear(); lcd_clear(&lcd);
lcd_print(1, 1, "Plink"); lcd_set_cursor(&lcd, 1, 1);
lcd_print(2, 1, color_string.c_str()); lcd_print(&lcd, "Plink");
lcd_print(3, 1, entered_string.c_str()); lcd_set_cursor(&lcd, 1, 2);
lcd_print(&lcd, color_string.c_str());
lcd_set_cursor(&lcd, 1, 3);
lcd_print(&lcd, entered_string.c_str());
} }
if (get_module_time() <= 0) { if (get_module_time() <= 0) {
strike("Ran out of time!"); strike("Ran out of time!");
@ -905,13 +880,13 @@ void step5(void) {
stop_module_timer(); stop_module_timer();
if (solved_correctly) { if (solved_correctly) {
solved_puzzles++; solved_puzzles++;
play_clip_wav(MOUNT_POINT "/partdone.wav", true, false, 0, 0); play_raw(MOUNT_POINT "/correct.pcm");
vTaskDelay(pdMS_TO_TICKS(500)); vTaskDelay(pdMS_TO_TICKS(500));
solved_correctly = false; solved_correctly = false;
} else { } else {
vTaskDelay(pdMS_TO_TICKS(3000)); vTaskDelay(pdMS_TO_TICKS(3000));
} }
play_clip_wav(MOUNT_POINT "/stepdone.wav", true, false, 1, 0); clear_all_pressed_released();
clean_bomb(); clean_bomb();
} }
} }

6
main/steps/step5.h
View File

@ -1,7 +1,11 @@
#ifndef STEP_5_H #ifndef STEP_5_H
#define STEP_5_H #define STEP_5_H
#include "../drivers/all.h" #include "../drivers/bottom_half.h"
#include "../drivers/game_timer.h"
#include "../drivers/char_lcd.h"
#include "../drivers/leds.h"
#include "../drivers/wires.h"
#include "../helper.h" #include "../helper.h"
#include <random> #include <random>
#include <iostream> #include <iostream>

4
main/steps/step6.cpp
View File

@ -1,6 +1,5 @@
#include "step6.h" #include "step6.h"
__attribute__((unused))
static const char *TAG = "step6"; static const char *TAG = "step6";
static uint8_t cut_wires = 0; static uint8_t cut_wires = 0;
@ -15,6 +14,7 @@ void step6(void) {
solve_wires(wires, solution); solve_wires(wires, solution);
while (1) { while (1) {
uint8_t new_cut_wires = get_cut_wires(); uint8_t new_cut_wires = get_cut_wires();
uint8_t just_cut_wires = new_cut_wires & ~cut_wires; uint8_t just_cut_wires = new_cut_wires & ~cut_wires;
cut_wires |= new_cut_wires; cut_wires |= new_cut_wires;
@ -22,7 +22,7 @@ void step6(void) {
for (int i = 0; i < NUM_WIRES; i++) { for (int i = 0; i < NUM_WIRES; i++) {
if (just_cut_wires & (1<<i)) { if (just_cut_wires & (1<<i)) {
if (solution[i]) { if (solution[i]) {
play_clip_wav(MOUNT_POINT "/correct.wav", true, false, 3, 0); play_raw(MOUNT_POINT "/correct.pcm");
} else { } else {
strike("Cut wrong wire"); strike("Cut wrong wire");
} }

6
main/steps/step6.h
View File

@ -2,8 +2,10 @@
#define STEP_6_H #define STEP_6_H
#include "wires_puzzle.h" #include "wires_puzzle.h"
#include "../drivers/all.h" #include "drivers/wires.h"
#include "../helper.h" #include "drivers/bottom_half.h"
#include "drivers/sd.h"
#include "drivers/speaker.h"
void step6(void); void step6(void);

13
main/steps/tetris_resources/CMakeLists.txt
View File

@ -1,13 +0,0 @@
set(SOURCES
"bg.c"
"clear.c"
"db.c"
"green.c"
"lb.c"
"orange.c"
"purple.c"
"red.c"
"yellow.c"
)
target_sources(${COMPONENT_LIB} PRIVATE ${SOURCES})

677
main/steps/tetris_resources/bg.c
View File

File diff suppressed because one or more lines are too long

69
main/steps/tetris_resources/clear.c
View File

@ -1,69 +0,0 @@
#ifdef __has_include
#if __has_include("lvgl.h")
#ifndef LV_LVGL_H_INCLUDE_SIMPLE
#define LV_LVGL_H_INCLUDE_SIMPLE
#endif
#endif
#endif
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#ifndef LV_ATTRIBUTE_MEM_ALIGN
#define LV_ATTRIBUTE_MEM_ALIGN
#endif
#ifndef LV_ATTRIBUTE_IMG_CLEAR
#define LV_ATTRIBUTE_IMG_CLEAR
#endif
const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_LARGE_CONST LV_ATTRIBUTE_IMG_CLEAR uint8_t clear_map[] = {
0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00,
0xbb, 0xde, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde,
0xbb, 0xde, 0x75, 0xad, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0x75, 0xad, 0xbb, 0xde,
0xbb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0x5d, 0xef, 0x7d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0xba, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0x5d, 0xef, 0x7d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0xba, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0x5d, 0xef, 0x7d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0xba, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0x5d, 0xef, 0x7d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0xba, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0x5d, 0xef, 0x7d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0xba, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0x5d, 0xef, 0x7d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0xba, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0x5d, 0xef, 0x7d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0xba, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0x5d, 0xef, 0x7d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0xba, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0x5d, 0xef, 0x7d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0xba, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xbb, 0xde, 0x5d, 0xef, 0x7d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0xba, 0xd6, 0x75, 0xad, 0xbb, 0xde,
0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0x5d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xef, 0xb7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0x5d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xef, 0xb7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0x5d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xef, 0xb7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0x5d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xef, 0xb7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0x5d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xef, 0xb7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0x5d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xef, 0xb7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0x5d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xef, 0xb7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0x5d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xef, 0xb7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0x5d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xef, 0xb7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0x5d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xef, 0xb7, 0xbd, 0x75, 0xad, 0xbb, 0xde,
0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0xf8, 0xc5, 0x38, 0xc6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x18, 0xc6, 0xd7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0xf8, 0xc5, 0x38, 0xc6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x18, 0xc6, 0xd7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0xf8, 0xc5, 0x38, 0xc6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x18, 0xc6, 0xd7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0xf8, 0xc5, 0x38, 0xc6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x18, 0xc6, 0xd7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0xf8, 0xc5, 0x38, 0xc6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x18, 0xc6, 0xd7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0xf8, 0xc5, 0x38, 0xc6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x18, 0xc6, 0xd7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0xf8, 0xc5, 0x38, 0xc6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x18, 0xc6, 0xd7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0xf8, 0xc5, 0x38, 0xc6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x18, 0xc6, 0xd7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0xf8, 0xc5, 0x38, 0xc6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x18, 0xc6, 0xd7, 0xbd, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xb7, 0xbd, 0xf8, 0xc5, 0x38, 0xc6, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x18, 0xc6, 0xd7, 0xbd, 0x75, 0xad, 0xbb, 0xde,
0xbb, 0xde, 0x75, 0xad, 0xf7, 0xbd, 0x38, 0xc6, 0x79, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xba, 0xd6, 0xba, 0xd6, 0x9a, 0xd6, 0x9a, 0xd6, 0x7a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf7, 0xbd, 0x38, 0xc6, 0x79, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xba, 0xd6, 0xba, 0xd6, 0x9a, 0xd6, 0x9a, 0xd6, 0x7a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf7, 0xbd, 0x38, 0xc6, 0x79, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xba, 0xd6, 0xba, 0xd6, 0x9a, 0xd6, 0x9a, 0xd6, 0x7a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf7, 0xbd, 0x38, 0xc6, 0x79, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xba, 0xd6, 0xba, 0xd6, 0x9a, 0xd6, 0x9a, 0xd6, 0x7a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf7, 0xbd, 0x38, 0xc6, 0x79, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xba, 0xd6, 0xba, 0xd6, 0x9a, 0xd6, 0x9a, 0xd6, 0x7a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf7, 0xbd, 0x38, 0xc6, 0x79, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xba, 0xd6, 0xba, 0xd6, 0x9a, 0xd6, 0x9a, 0xd6, 0x7a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf7, 0xbd, 0x38, 0xc6, 0x79, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xba, 0xd6, 0xba, 0xd6, 0x9a, 0xd6, 0x9a, 0xd6, 0x7a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf7, 0xbd, 0x38, 0xc6, 0x79, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xba, 0xd6, 0xba, 0xd6, 0x9a, 0xd6, 0x9a, 0xd6, 0x7a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf7, 0xbd, 0x38, 0xc6, 0x79, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xba, 0xd6, 0xba, 0xd6, 0x9a, 0xd6, 0x9a, 0xd6, 0x7a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf7, 0xbd, 0x38, 0xc6, 0x79, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xba, 0xd6, 0xba, 0xd6, 0x9a, 0xd6, 0x9a, 0xd6, 0x7a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde,
0xbb, 0xde, 0x75, 0xad, 0xf8, 0xc5, 0x59, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x9a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf8, 0xc5, 0x59, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x9a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf8, 0xc5, 0x59, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x9a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf8, 0xc5, 0x59, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x9a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf8, 0xc5, 0x59, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x9a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf8, 0xc5, 0x59, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x9a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf8, 0xc5, 0x59, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x9a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf8, 0xc5, 0x59, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x9a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf8, 0xc5, 0x59, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x9a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0xf8, 0xc5, 0x59, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0x9a, 0xd6, 0x59, 0xce, 0x18, 0xc6, 0x75, 0xad, 0xbb, 0xde,
0xbb, 0xde, 0x75, 0xad, 0x18, 0xc6, 0x79, 0xce, 0x9a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xdb, 0xde, 0xbb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x18, 0xc6, 0x79, 0xce, 0x9a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xdb, 0xde, 0xbb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x18, 0xc6, 0x79, 0xce, 0x9a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xdb, 0xde, 0xbb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x18, 0xc6, 0x79, 0xce, 0x9a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xdb, 0xde, 0xbb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x18, 0xc6, 0x79, 0xce, 0x9a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xdb, 0xde, 0xbb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x18, 0xc6, 0x79, 0xce, 0x9a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xdb, 0xde, 0xbb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x18, 0xc6, 0x79, 0xce, 0x9a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xdb, 0xde, 0xbb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x18, 0xc6, 0x79, 0xce, 0x9a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xdb, 0xde, 0xbb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x18, 0xc6, 0x79, 0xce, 0x9a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xdb, 0xde, 0xbb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x18, 0xc6, 0x79, 0xce, 0x9a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xfb, 0xde, 0xdb, 0xde, 0xbb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xbb, 0xde,
0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x7a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0xfc, 0xe6, 0xdb, 0xde, 0xdb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x7a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0xfc, 0xe6, 0xdb, 0xde, 0xdb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x7a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0xfc, 0xe6, 0xdb, 0xde, 0xdb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x7a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0xfc, 0xe6, 0xdb, 0xde, 0xdb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x7a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0xfc, 0xe6, 0xdb, 0xde, 0xdb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x7a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0xfc, 0xe6, 0xdb, 0xde, 0xdb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x7a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0xfc, 0xe6, 0xdb, 0xde, 0xdb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x7a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0xfc, 0xe6, 0xdb, 0xde, 0xdb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x7a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0xfc, 0xe6, 0xdb, 0xde, 0xdb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x7a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0xfc, 0xe6, 0xdb, 0xde, 0xdb, 0xde, 0x9a, 0xd6, 0x59, 0xce, 0x75, 0xad, 0xba, 0xd6,
0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x9a, 0xd6, 0xdb, 0xde, 0xfb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x3c, 0xe7, 0x1c, 0xe7, 0xfc, 0xe6, 0xfb, 0xde, 0xba, 0xd6, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x9a, 0xd6, 0xdb, 0xde, 0xfb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x3c, 0xe7, 0x1c, 0xe7, 0xfc, 0xe6, 0xfb, 0xde, 0xba, 0xd6, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x9a, 0xd6, 0xdb, 0xde, 0xfb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x3c, 0xe7, 0x1c, 0xe7, 0xfc, 0xe6, 0xfb, 0xde, 0xba, 0xd6, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x9a, 0xd6, 0xdb, 0xde, 0xfb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x3c, 0xe7, 0x1c, 0xe7, 0xfc, 0xe6, 0xfb, 0xde, 0xba, 0xd6, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x9a, 0xd6, 0xdb, 0xde, 0xfb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x3c, 0xe7, 0x1c, 0xe7, 0xfc, 0xe6, 0xfb, 0xde, 0xba, 0xd6, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x9a, 0xd6, 0xdb, 0xde, 0xfb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x3c, 0xe7, 0x1c, 0xe7, 0xfc, 0xe6, 0xfb, 0xde, 0xba, 0xd6, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x9a, 0xd6, 0xdb, 0xde, 0xfb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x3c, 0xe7, 0x1c, 0xe7, 0xfc, 0xe6, 0xfb, 0xde, 0xba, 0xd6, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x9a, 0xd6, 0xdb, 0xde, 0xfb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x3c, 0xe7, 0x1c, 0xe7, 0xfc, 0xe6, 0xfb, 0xde, 0xba, 0xd6, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x9a, 0xd6, 0xdb, 0xde, 0xfb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x3c, 0xe7, 0x1c, 0xe7, 0xfc, 0xe6, 0xfb, 0xde, 0xba, 0xd6, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x39, 0xce, 0x9a, 0xd6, 0xdb, 0xde, 0xfb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x3c, 0xe7, 0x1c, 0xe7, 0xfc, 0xe6, 0xfb, 0xde, 0xba, 0xd6, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6,
0xbb, 0xde, 0x75, 0xad, 0x59, 0xce, 0x9a, 0xd6, 0xfb, 0xde, 0xfc, 0xe6, 0x3c, 0xe7, 0x3d, 0xef, 0x3d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xfc, 0xe6, 0xbb, 0xde, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x59, 0xce, 0x9a, 0xd6, 0xfb, 0xde, 0xfc, 0xe6, 0x3c, 0xe7, 0x3d, 0xef, 0x3d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xfc, 0xe6, 0xbb, 0xde, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x59, 0xce, 0x9a, 0xd6, 0xfb, 0xde, 0xfc, 0xe6, 0x3c, 0xe7, 0x3d, 0xef, 0x3d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xfc, 0xe6, 0xbb, 0xde, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x59, 0xce, 0x9a, 0xd6, 0xfb, 0xde, 0xfc, 0xe6, 0x3c, 0xe7, 0x3d, 0xef, 0x3d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xfc, 0xe6, 0xbb, 0xde, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x59, 0xce, 0x9a, 0xd6, 0xfb, 0xde, 0xfc, 0xe6, 0x3c, 0xe7, 0x3d, 0xef, 0x3d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xfc, 0xe6, 0xbb, 0xde, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x59, 0xce, 0x9a, 0xd6, 0xfb, 0xde, 0xfc, 0xe6, 0x3c, 0xe7, 0x3d, 0xef, 0x3d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xfc, 0xe6, 0xbb, 0xde, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x59, 0xce, 0x9a, 0xd6, 0xfb, 0xde, 0xfc, 0xe6, 0x3c, 0xe7, 0x3d, 0xef, 0x3d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xfc, 0xe6, 0xbb, 0xde, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x59, 0xce, 0x9a, 0xd6, 0xfb, 0xde, 0xfc, 0xe6, 0x3c, 0xe7, 0x3d, 0xef, 0x3d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xfc, 0xe6, 0xbb, 0xde, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x59, 0xce, 0x9a, 0xd6, 0xfb, 0xde, 0xfc, 0xe6, 0x3c, 0xe7, 0x3d, 0xef, 0x3d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xfc, 0xe6, 0xbb, 0xde, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6, 0xbb, 0xde, 0x75, 0xad, 0x59, 0xce, 0x9a, 0xd6, 0xfb, 0xde, 0xfc, 0xe6, 0x3c, 0xe7, 0x3d, 0xef, 0x3d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xfc, 0xe6, 0xbb, 0xde, 0x7a, 0xd6, 0x75, 0xad, 0xba, 0xd6,
0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x3c, 0xe7, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x3c, 0xe7, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x3c, 0xe7, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x3c, 0xe7, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x3c, 0xe7, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x3c, 0xe7, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x3c, 0xe7, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x3c, 0xe7, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x3c, 0xe7, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x3c, 0xe7, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde,
0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x5d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x5d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x5d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x5d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x5d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x5d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x5d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x5d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x5d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde, 0xbb, 0xde, 0x75, 0xad, 0x79, 0xce, 0xbb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x5d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xdb, 0xde, 0x9a, 0xd6, 0x75, 0xad, 0xbb, 0xde,
0xba, 0xd6, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xba, 0xd6, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xba, 0xd6, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xba, 0xd6, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xba, 0xd6, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xba, 0xd6, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xba, 0xd6, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xba, 0xd6, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xba, 0xd6, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde, 0xba, 0xd6, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0x75, 0xad, 0xbb, 0xde,
0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xbb, 0xde, 0xba, 0xd6, 0xbb, 0xde, 0xba, 0xd6, 0x00, 0x00,
/*alpha channel*/
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
};
const lv_img_dsc_t clear = {
.header.cf = LV_IMG_CF_RGB565A8,
.header.always_zero = 0,
.header.reserved = 0,
.header.w = 160,
.header.h = 16,
.data_size = 7680,
.data = clear_map,
};

69
main/steps/tetris_resources/db.c
View File

@ -1,69 +0,0 @@
#ifdef __has_include
#if __has_include("lvgl.h")
#ifndef LV_LVGL_H_INCLUDE_SIMPLE
#define LV_LVGL_H_INCLUDE_SIMPLE
#endif
#endif
#endif
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#ifndef LV_ATTRIBUTE_MEM_ALIGN
#define LV_ATTRIBUTE_MEM_ALIGN
#endif
#ifndef LV_ATTRIBUTE_IMG_DB
#define LV_ATTRIBUTE_IMG_DB
#endif
const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_LARGE_CONST LV_ATTRIBUTE_IMG_DB uint8_t db_map[] = {
0x00, 0x00, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x00, 0x00,
0x13, 0x33, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0x13, 0x33,
0x13, 0x33, 0xaf, 0x01, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x34, 0x33, 0x54, 0x33, 0x54, 0x33, 0x54, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0xaf, 0x01, 0x13, 0x33,
0x13, 0x33, 0xaf, 0x01, 0x13, 0x33, 0xb5, 0x4b, 0xd5, 0x4b, 0xf6, 0x4b, 0xf7, 0x4b, 0x17, 0x4c, 0x17, 0x4c, 0x17, 0x4c, 0xf6, 0x4b, 0xf6, 0x4b, 0xb5, 0x4b, 0x13, 0x33, 0xaf, 0x01, 0x13, 0x33,
0x13, 0x33, 0xaf, 0x01, 0xf1, 0x01, 0xd5, 0x4b, 0xdd, 0xce, 0xbb, 0x9d, 0xb9, 0x64, 0xb9, 0x64, 0xb9, 0x64, 0xb9, 0x64, 0xb9, 0x64, 0x98, 0x64, 0xf6, 0x4b, 0xf1, 0x01, 0xaf, 0x01, 0x13, 0x33,
0x13, 0x33, 0xaf, 0x01, 0xf1, 0x01, 0x53, 0x02, 0x95, 0x02, 0x58, 0x54, 0x7b, 0x85, 0x1a, 0x6d, 0x1a, 0x6d, 0x1a, 0x6d, 0x79, 0x54, 0xb5, 0x02, 0x74, 0x02, 0x32, 0x02, 0xaf, 0x01, 0x13, 0x33,
0x13, 0x33, 0xaf, 0x01, 0x32, 0x02, 0x95, 0x02, 0xd6, 0x02, 0xf7, 0x02, 0x38, 0x03, 0x38, 0x03, 0x59, 0x03, 0x38, 0x03, 0x18, 0x03, 0xf7, 0x02, 0xb5, 0x02, 0x53, 0x02, 0xaf, 0x01, 0x13, 0x33,
0x13, 0x33, 0xaf, 0x01, 0x53, 0x02, 0xb5, 0x02, 0xf7, 0x02, 0x18, 0x03, 0x59, 0x03, 0x59, 0x03, 0x59, 0x03, 0x59, 0x03, 0x38, 0x03, 0x18, 0x03, 0xd6, 0x02, 0x74, 0x02, 0xaf, 0x01, 0x13, 0x33,
0x13, 0x33, 0xaf, 0x01, 0x74, 0x02, 0xd6, 0x02, 0x38, 0x03, 0x59, 0x03, 0x7a, 0x03, 0x9a, 0x03, 0xbb, 0x03, 0x9a, 0x03, 0x7a, 0x03, 0x59, 0x03, 0x17, 0x03, 0xb5, 0x02, 0xaf, 0x01, 0x13, 0x33,
0x13, 0x33, 0xaf, 0x01, 0x95, 0x02, 0xf7, 0x02, 0x59, 0x03, 0x5a, 0x03, 0xbb, 0x03, 0xbb, 0x03, 0xbb, 0x03, 0xbb, 0x03, 0x9a, 0x03, 0x59, 0x03, 0x38, 0x03, 0xb6, 0x02, 0xaf, 0x01, 0x13, 0x33,
0x13, 0x33, 0xaf, 0x01, 0xb5, 0x02, 0x18, 0x03, 0x7a, 0x03, 0xbb, 0x03, 0xfc, 0x03, 0xfc, 0x03, 0x1d, 0x04, 0xfc, 0x03, 0xbb, 0x03, 0x9b, 0x03, 0x59, 0x03, 0xd7, 0x02, 0xaf, 0x01, 0x13, 0x33,
0x13, 0x33, 0xaf, 0x01, 0xb6, 0x02, 0x38, 0x03, 0x9a, 0x03, 0xbb, 0x03, 0xfc, 0x03, 0x1d, 0x04, 0x1d, 0x04, 0x1d, 0x04, 0xfc, 0x03, 0xbb, 0x03, 0x59, 0x03, 0xf7, 0x02, 0xaf, 0x01, 0x13, 0x33,
0x13, 0x33, 0xaf, 0x01, 0xd6, 0x02, 0x59, 0x03, 0xbb, 0x03, 0xfc, 0x03, 0x3d, 0x04, 0x5e, 0x04, 0x7e, 0x04, 0x5e, 0x04, 0x1d, 0x04, 0xfc, 0x03, 0x7a, 0x03, 0x18, 0x03, 0xaf, 0x01, 0x13, 0x33,
0x13, 0x33, 0xaf, 0x01, 0xd7, 0x02, 0x59, 0x03, 0xbb, 0x03, 0xfc, 0x03, 0x5e, 0x04, 0x9f, 0x04, 0xbf, 0x04, 0x7f, 0x04, 0x1d, 0x04, 0xfc, 0x03, 0x9a, 0x03, 0x18, 0x03, 0xaf, 0x01, 0x13, 0x33,
0x13, 0x33, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0xaf, 0x01, 0x13, 0x33,
0x00, 0x00, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x13, 0x33, 0x00, 0x00,
/*alpha channel*/
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
};
const lv_img_dsc_t db = {
.header.cf = LV_IMG_CF_RGB565A8,
.header.always_zero = 0,
.header.reserved = 0,
.header.w = 16,
.header.h = 16,
.data_size = 768,
.data = db_map,
};

69
main/steps/tetris_resources/green.c
View File

@ -1,69 +0,0 @@
#ifdef __has_include
#if __has_include("lvgl.h")
#ifndef LV_LVGL_H_INCLUDE_SIMPLE
#define LV_LVGL_H_INCLUDE_SIMPLE
#endif
#endif
#endif
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#ifndef LV_ATTRIBUTE_MEM_ALIGN
#define LV_ATTRIBUTE_MEM_ALIGN
#endif
#ifndef LV_ATTRIBUTE_IMG_GREEN
#define LV_ATTRIBUTE_IMG_GREEN
#endif
const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_LARGE_CONST LV_ATTRIBUTE_IMG_GREEN uint8_t green_map[] = {
0x00, 0x00, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0x00, 0x00,
0xa9, 0x34, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa9, 0x34,
0xa9, 0x34, 0xa3, 0x03, 0xe9, 0x34, 0xe9, 0x34, 0xe9, 0x34, 0xe9, 0x34, 0x09, 0x35, 0x09, 0x35, 0x09, 0x35, 0x09, 0x35, 0xe9, 0x34, 0xe9, 0x34, 0xe9, 0x34, 0xe9, 0x34, 0xa3, 0x03, 0xa9, 0x34,
0xa9, 0x34, 0xa3, 0x03, 0xe9, 0x34, 0x2c, 0x4d, 0x6c, 0x4d, 0x8c, 0x4d, 0xac, 0x4d, 0xcc, 0x4d, 0xcc, 0x4d, 0xcc, 0x4d, 0x8c, 0x4d, 0x8c, 0x4d, 0x2c, 0x4d, 0xc9, 0x34, 0xa3, 0x03, 0xa9, 0x34,
0xa9, 0x34, 0xa3, 0x03, 0x44, 0x04, 0x6c, 0x4d, 0x7a, 0xcf, 0xb5, 0x9e, 0x4f, 0x66, 0x4f, 0x66, 0x4f, 0x66, 0x4f, 0x66, 0x2f, 0x66, 0x0f, 0x66, 0x8c, 0x4d, 0x44, 0x04, 0xa3, 0x03, 0xa9, 0x34,
0xa9, 0x34, 0xa3, 0x03, 0x44, 0x04, 0xc4, 0x04, 0x25, 0x05, 0x0e, 0x56, 0xd3, 0x86, 0x91, 0x6e, 0x91, 0x6e, 0x91, 0x6e, 0x2e, 0x56, 0x65, 0x05, 0x05, 0x05, 0x84, 0x04, 0xa3, 0x03, 0xa9, 0x34,
0xa9, 0x34, 0xa3, 0x03, 0xa4, 0x04, 0x25, 0x05, 0xa5, 0x05, 0xc6, 0x05, 0x06, 0x06, 0x26, 0x06, 0x26, 0x06, 0x06, 0x06, 0x06, 0x06, 0xc6, 0x05, 0x65, 0x05, 0xe5, 0x04, 0xa3, 0x03, 0xa9, 0x34,
0xa9, 0x34, 0xa3, 0x03, 0xc4, 0x04, 0x65, 0x05, 0xc6, 0x05, 0xe6, 0x05, 0x46, 0x06, 0x47, 0x06, 0x47, 0x06, 0x47, 0x06, 0x26, 0x06, 0x06, 0x06, 0x85, 0x05, 0x05, 0x05, 0xa3, 0x03, 0xa9, 0x34,
0xa9, 0x34, 0xa3, 0x03, 0x05, 0x05, 0xa5, 0x05, 0x06, 0x06, 0x47, 0x06, 0x87, 0x06, 0xa7, 0x06, 0xa7, 0x06, 0xa7, 0x06, 0x67, 0x06, 0x46, 0x06, 0xe6, 0x05, 0x65, 0x05, 0xa3, 0x03, 0xa9, 0x34,
0xa9, 0x34, 0xa3, 0x03, 0x45, 0x05, 0xc6, 0x05, 0x46, 0x06, 0x67, 0x06, 0xa7, 0x06, 0xc8, 0x06, 0xe8, 0x06, 0xc8, 0x06, 0x87, 0x06, 0x67, 0x06, 0x06, 0x06, 0x85, 0x05, 0xa3, 0x03, 0xa9, 0x34,
0xa9, 0x34, 0xa3, 0x03, 0x65, 0x05, 0x06, 0x06, 0x87, 0x06, 0xa7, 0x06, 0x08, 0x07, 0x08, 0x07, 0x28, 0x07, 0x28, 0x07, 0xe8, 0x06, 0xa7, 0x06, 0x46, 0x06, 0xc6, 0x05, 0xa3, 0x03, 0xa9, 0x34,
0xa9, 0x34, 0xa3, 0x03, 0x65, 0x05, 0x06, 0x06, 0xa7, 0x06, 0xc7, 0x06, 0x28, 0x07, 0x48, 0x07, 0x48, 0x07, 0x48, 0x07, 0x08, 0x07, 0xc7, 0x06, 0x47, 0x06, 0xc6, 0x05, 0xa3, 0x03, 0xa9, 0x34,
0xa9, 0x34, 0xa3, 0x03, 0xa5, 0x05, 0x46, 0x06, 0xc7, 0x06, 0x08, 0x07, 0x69, 0x07, 0x89, 0x07, 0xa9, 0x07, 0x89, 0x07, 0x28, 0x07, 0x08, 0x07, 0x87, 0x06, 0xe6, 0x05, 0xa3, 0x03, 0xa9, 0x34,
0xa9, 0x34, 0xa3, 0x03, 0xa5, 0x05, 0x47, 0x06, 0xe8, 0x06, 0x08, 0x07, 0x89, 0x07, 0xc9, 0x07, 0xea, 0x07, 0xa9, 0x07, 0x48, 0x07, 0x08, 0x07, 0x87, 0x06, 0x06, 0x06, 0xa3, 0x03, 0xa9, 0x34,
0xa9, 0x34, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa3, 0x03, 0xa9, 0x34,
0x00, 0x00, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0xa9, 0x34, 0x00, 0x00,
/*alpha channel*/
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
};
const lv_img_dsc_t green = {
.header.cf = LV_IMG_CF_RGB565A8,
.header.always_zero = 0,
.header.reserved = 0,
.header.w = 16,
.header.h = 16,
.data_size = 768,
.data = green_map,
};

69
main/steps/tetris_resources/lb.c
View File

@ -1,69 +0,0 @@
#ifdef __has_include
#if __has_include("lvgl.h")
#ifndef LV_LVGL_H_INCLUDE_SIMPLE
#define LV_LVGL_H_INCLUDE_SIMPLE
#endif
#endif
#endif
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#ifndef LV_ATTRIBUTE_MEM_ALIGN
#define LV_ATTRIBUTE_MEM_ALIGN
#endif
#ifndef LV_ATTRIBUTE_IMG_LB
#define LV_ATTRIBUTE_IMG_LB
#endif
const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_LARGE_CONST LV_ATTRIBUTE_IMG_LB uint8_t lb_map[] = {
0x00, 0x00, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x00, 0x00,
0x53, 0x34, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x53, 0x34,
0x53, 0x34, 0x2f, 0x03, 0x73, 0x34, 0x73, 0x34, 0x73, 0x34, 0x73, 0x34, 0x94, 0x34, 0x94, 0x34, 0x94, 0x34, 0x94, 0x34, 0x73, 0x34, 0x73, 0x34, 0x73, 0x34, 0x73, 0x34, 0x2f, 0x03, 0x53, 0x34,
0x53, 0x34, 0x2f, 0x03, 0x73, 0x34, 0xd5, 0x4c, 0x15, 0x4d, 0x36, 0x4d, 0x37, 0x4d, 0x57, 0x4d, 0x57, 0x4d, 0x57, 0x4d, 0x36, 0x4d, 0x16, 0x4d, 0xf5, 0x4c, 0x53, 0x34, 0x2f, 0x03, 0x53, 0x34,
0x53, 0x34, 0x2f, 0x03, 0xb1, 0x03, 0x15, 0x4d, 0x3d, 0xcf, 0x7b, 0x9e, 0xd9, 0x65, 0xd9, 0x65, 0xf9, 0x65, 0xf9, 0x65, 0xd9, 0x65, 0xd8, 0x65, 0x36, 0x4d, 0xb1, 0x03, 0x2f, 0x03, 0x53, 0x34,
0x53, 0x34, 0x2f, 0x03, 0xb1, 0x03, 0x33, 0x04, 0x95, 0x04, 0xb8, 0x55, 0x7b, 0x86, 0x3a, 0x6e, 0x3a, 0x6e, 0x3a, 0x6e, 0xd9, 0x55, 0xd5, 0x04, 0x54, 0x04, 0xf2, 0x03, 0x2f, 0x03, 0x53, 0x34,
0x53, 0x34, 0x2f, 0x03, 0x12, 0x04, 0x95, 0x04, 0x16, 0x05, 0x37, 0x05, 0x78, 0x05, 0x78, 0x05, 0x99, 0x05, 0x78, 0x05, 0x58, 0x05, 0x37, 0x05, 0xd5, 0x04, 0x53, 0x04, 0x2f, 0x03, 0x53, 0x34,
0x53, 0x34, 0x2f, 0x03, 0x33, 0x04, 0xb5, 0x04, 0x37, 0x05, 0x58, 0x05, 0x99, 0x05, 0xb9, 0x05, 0xb9, 0x05, 0xb9, 0x05, 0x78, 0x05, 0x58, 0x05, 0xf6, 0x04, 0x74, 0x04, 0x2f, 0x03, 0x53, 0x34,
0x53, 0x34, 0x2f, 0x03, 0x74, 0x04, 0x16, 0x05, 0x78, 0x05, 0xb9, 0x05, 0xda, 0x05, 0xfa, 0x05, 0x1b, 0x06, 0xfa, 0x05, 0xda, 0x05, 0x99, 0x05, 0x37, 0x05, 0xb5, 0x04, 0x2f, 0x03, 0x53, 0x34,
0x53, 0x34, 0x2f, 0x03, 0xb5, 0x04, 0x37, 0x05, 0x99, 0x05, 0xda, 0x05, 0x1b, 0x06, 0x3b, 0x06, 0x3b, 0x06, 0x3b, 0x06, 0xfa, 0x05, 0xd9, 0x05, 0x78, 0x05, 0xd6, 0x04, 0x2f, 0x03, 0x53, 0x34,
0x53, 0x34, 0x2f, 0x03, 0xb5, 0x04, 0x58, 0x05, 0xda, 0x05, 0x1b, 0x06, 0x5c, 0x06, 0x7c, 0x06, 0x7d, 0x06, 0x7c, 0x06, 0x3b, 0x06, 0xfb, 0x05, 0x99, 0x05, 0x17, 0x05, 0x2f, 0x03, 0x53, 0x34,
0x53, 0x34, 0x2f, 0x03, 0xd6, 0x04, 0x78, 0x05, 0xfa, 0x05, 0x1b, 0x06, 0x7c, 0x06, 0x9d, 0x06, 0x9d, 0x06, 0x9d, 0x06, 0x5c, 0x06, 0x1b, 0x06, 0xb9, 0x05, 0x37, 0x05, 0x2f, 0x03, 0x53, 0x34,
0x53, 0x34, 0x2f, 0x03, 0x16, 0x05, 0x99, 0x05, 0x1b, 0x06, 0x5c, 0x06, 0xbd, 0x06, 0xde, 0x06, 0xfe, 0x06, 0xde, 0x06, 0x9d, 0x06, 0x5c, 0x06, 0xda, 0x05, 0x58, 0x05, 0x2f, 0x03, 0x53, 0x34,
0x53, 0x34, 0x2f, 0x03, 0x17, 0x05, 0xb9, 0x05, 0x3b, 0x06, 0x7c, 0x06, 0xde, 0x06, 0x1f, 0x07, 0x3f, 0x07, 0x1f, 0x07, 0x9d, 0x06, 0x7c, 0x06, 0xfa, 0x05, 0x58, 0x05, 0x2f, 0x03, 0x53, 0x34,
0x53, 0x34, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x2f, 0x03, 0x53, 0x34,
0x00, 0x00, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x53, 0x34, 0x00, 0x00,
/*alpha channel*/
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
};
const lv_img_dsc_t lb = {
.header.cf = LV_IMG_CF_RGB565A8,
.header.always_zero = 0,
.header.reserved = 0,
.header.w = 16,
.header.h = 16,
.data_size = 768,
.data = lb_map,
};

69
main/steps/tetris_resources/orange.c
View File

@ -1,69 +0,0 @@
#ifdef __has_include
#if __has_include("lvgl.h")
#ifndef LV_LVGL_H_INCLUDE_SIMPLE
#define LV_LVGL_H_INCLUDE_SIMPLE
#endif
#endif
#endif
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#ifndef LV_ATTRIBUTE_MEM_ALIGN
#define LV_ATTRIBUTE_MEM_ALIGN
#endif
#ifndef LV_ATTRIBUTE_IMG_ORANGE
#define LV_ATTRIBUTE_IMG_ORANGE
#endif
const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_LARGE_CONST LV_ATTRIBUTE_IMG_ORANGE uint8_t orange_map[] = {
0x00, 0x00, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x00, 0x00,
0x66, 0x9b, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x66, 0x9b,
0x66, 0x9b, 0x20, 0x7a, 0x86, 0x9b, 0x86, 0x9b, 0x86, 0x9b, 0x86, 0x9b, 0xa6, 0xa3, 0xa6, 0xa3, 0xa6, 0xa3, 0xa6, 0xa3, 0x86, 0x9b, 0x86, 0x9b, 0x86, 0x9b, 0x86, 0x9b, 0x20, 0x7a, 0x66, 0x9b,
0x66, 0x9b, 0x20, 0x7a, 0x86, 0x9b, 0x09, 0xac, 0x49, 0xac, 0x49, 0xb4, 0x69, 0xbc, 0x69, 0xbc, 0x89, 0xbc, 0x69, 0xbc, 0x49, 0xb4, 0x49, 0xb4, 0x09, 0xac, 0x86, 0x9b, 0x20, 0x7a, 0x66, 0x9b,
0x66, 0x9b, 0x20, 0x7a, 0x80, 0x8a, 0x29, 0xac, 0xf9, 0xee, 0xf3, 0xdd, 0x0c, 0xcd, 0x0c, 0xcd, 0x2c, 0xcd, 0x0c, 0xcd, 0x0c, 0xcd, 0xec, 0xc4, 0x49, 0xb4, 0x80, 0x8a, 0x20, 0x7a, 0x66, 0x9b,
0x66, 0x9b, 0x20, 0x7a, 0x80, 0x8a, 0xe0, 0x9a, 0x40, 0xab, 0xca, 0xc4, 0xd0, 0xdd, 0x6d, 0xd5, 0x6d, 0xd5, 0x6d, 0xd5, 0xea, 0xcc, 0x60, 0xab, 0x00, 0xa3, 0xc0, 0x92, 0x20, 0x7a, 0x66, 0x9b,
0x66, 0x9b, 0x20, 0x7a, 0xc0, 0x92, 0x40, 0xab, 0x80, 0xb3, 0xa0, 0xbb, 0xe0, 0xc3, 0xe0, 0xc3, 0x00, 0xcc, 0xe0, 0xc3, 0xe0, 0xc3, 0xa0, 0xbb, 0x60, 0xab, 0xe0, 0x9a, 0x20, 0x7a, 0x66, 0x9b,
0x66, 0x9b, 0x20, 0x7a, 0xe0, 0x9a, 0x40, 0xab, 0xa0, 0xbb, 0xe0, 0xc3, 0x00, 0xcc, 0x20, 0xcc, 0x20, 0xcc, 0x20, 0xcc, 0xe0, 0xc3, 0xe0, 0xc3, 0x80, 0xb3, 0x20, 0xa3, 0x20, 0x7a, 0x66, 0x9b,
0x66, 0x9b, 0x20, 0x7a, 0x20, 0xa3, 0x80, 0xb3, 0xe0, 0xc3, 0x20, 0xcc, 0x40, 0xd4, 0x60, 0xd4, 0x80, 0xdc, 0x60, 0xd4, 0x40, 0xd4, 0x20, 0xcc, 0xc0, 0xbb, 0x40, 0xab, 0x20, 0x7a, 0x66, 0x9b,
0x66, 0x9b, 0x20, 0x7a, 0x40, 0xab, 0xa0, 0xbb, 0x00, 0xcc, 0x40, 0xd4, 0x80, 0xdc, 0xa0, 0xdc, 0xa0, 0xdc, 0xa0, 0xdc, 0x60, 0xd4, 0x40, 0xcc, 0xe0, 0xc3, 0x60, 0xb3, 0x20, 0x7a, 0x66, 0x9b,
0x66, 0x9b, 0x20, 0x7a, 0x40, 0xab, 0xe0, 0xc3, 0x40, 0xd4, 0x80, 0xdc, 0xc0, 0xe4, 0xe0, 0xe4, 0xe0, 0xec, 0xe0, 0xe4, 0xa0, 0xdc, 0x80, 0xdc, 0x00, 0xcc, 0xa0, 0xbb, 0x20, 0x7a, 0x66, 0x9b,
0x66, 0x9b, 0x20, 0x7a, 0x60, 0xb3, 0xe0, 0xc3, 0x60, 0xd4, 0x80, 0xdc, 0xe0, 0xe4, 0x00, 0xed, 0x00, 0xed, 0x00, 0xed, 0xc0, 0xe4, 0x80, 0xdc, 0x20, 0xcc, 0xa0, 0xbb, 0x20, 0x7a, 0x66, 0x9b,
0x66, 0x9b, 0x20, 0x7a, 0x80, 0xb3, 0x20, 0xcc, 0x80, 0xdc, 0xc0, 0xe4, 0x20, 0xed, 0x40, 0xf5, 0x40, 0xf5, 0x40, 0xf5, 0x00, 0xed, 0xc0, 0xe4, 0x40, 0xd4, 0xc0, 0xc3, 0x20, 0x7a, 0x66, 0x9b,
0x66, 0x9b, 0x20, 0x7a, 0xa0, 0xbb, 0x20, 0xcc, 0xa0, 0xdc, 0xe0, 0xe4, 0x40, 0xf5, 0x60, 0xfd, 0x80, 0xfd, 0x60, 0xfd, 0x00, 0xed, 0xe0, 0xe4, 0x60, 0xd4, 0xe0, 0xc3, 0x20, 0x7a, 0x66, 0x9b,
0x66, 0x9b, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x20, 0x7a, 0x66, 0x9b,
0x00, 0x00, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x66, 0x9b, 0x00, 0x00,
/*alpha channel*/
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
};
const lv_img_dsc_t orange = {
.header.cf = LV_IMG_CF_RGB565A8,
.header.always_zero = 0,
.header.reserved = 0,
.header.w = 16,
.header.h = 16,
.data_size = 768,
.data = orange_map,
};

69
main/steps/tetris_resources/purple.c
View File

@ -1,69 +0,0 @@
#ifdef __has_include
#if __has_include("lvgl.h")
#ifndef LV_LVGL_H_INCLUDE_SIMPLE
#define LV_LVGL_H_INCLUDE_SIMPLE
#endif
#endif
#endif
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#ifndef LV_ATTRIBUTE_MEM_ALIGN
#define LV_ATTRIBUTE_MEM_ALIGN
#endif
#ifndef LV_ATTRIBUTE_IMG_PURPLE
#define LV_ATTRIBUTE_IMG_PURPLE
#endif
const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_LARGE_CONST LV_ATTRIBUTE_IMG_PURPLE uint8_t purple_map[] = {
0x00, 0x00, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0x00, 0x00,
0xb3, 0x81, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0xb3, 0x81,
0xb3, 0x81, 0x0f, 0x58, 0x93, 0x89, 0x93, 0x89, 0x93, 0x89, 0x93, 0x89, 0x94, 0x89, 0x94, 0x89, 0x94, 0x89, 0x94, 0x89, 0x93, 0x89, 0x93, 0x89, 0x93, 0x89, 0x93, 0x89, 0x0f, 0x58, 0xb3, 0x81,
0xb3, 0x81, 0x0f, 0x58, 0x73, 0x81, 0x55, 0x92, 0x55, 0x9a, 0x56, 0x9a, 0x57, 0xa2, 0x57, 0xa2, 0x57, 0xa2, 0x57, 0xa2, 0x56, 0x9a, 0x56, 0x9a, 0x55, 0x92, 0x73, 0x81, 0x0f, 0x58, 0xb3, 0x81,
0xb3, 0x81, 0x0f, 0x58, 0x11, 0x68, 0x35, 0x9a, 0x5d, 0xe6, 0xdb, 0xcc, 0x19, 0xb3, 0x19, 0xb3, 0x19, 0xb3, 0x19, 0xb3, 0x19, 0xb3, 0x18, 0xb3, 0x56, 0x9a, 0x11, 0x68, 0x0f, 0x58, 0xb3, 0x81,
0xb3, 0x81, 0x0f, 0x58, 0x11, 0x68, 0x13, 0x78, 0x15, 0x80, 0x98, 0xaa, 0x1b, 0xcc, 0x5a, 0xbb, 0x5a, 0xc3, 0x5a, 0xbb, 0x99, 0xb2, 0x15, 0x88, 0x14, 0x80, 0x12, 0x70, 0x0f, 0x58, 0xb3, 0x81,
0xb3, 0x81, 0x0f, 0x58, 0x12, 0x78, 0x15, 0x80, 0x16, 0x90, 0x17, 0x98, 0x18, 0xa0, 0x18, 0xa0, 0x19, 0xa0, 0x18, 0xa0, 0x18, 0x98, 0x17, 0x98, 0x15, 0x88, 0x13, 0x78, 0x0f, 0x58, 0xb3, 0x81,
0xb3, 0x81, 0x0f, 0x58, 0x13, 0x78, 0x15, 0x88, 0x17, 0x98, 0x18, 0x98, 0x19, 0xa0, 0x19, 0xa8, 0x19, 0xa8, 0x19, 0xa8, 0x18, 0xa0, 0x18, 0x98, 0x16, 0x90, 0x14, 0x80, 0x0f, 0x58, 0xb3, 0x81,
0xb3, 0x81, 0x0f, 0x58, 0x14, 0x80, 0x16, 0x90, 0x18, 0xa0, 0x19, 0xa8, 0x1a, 0xa8, 0x1a, 0xb0, 0x1b, 0xb0, 0x1a, 0xb0, 0x1a, 0xa8, 0x19, 0xa0, 0x17, 0x98, 0x15, 0x88, 0x0f, 0x58, 0xb3, 0x81,
0xb3, 0x81, 0x0f, 0x58, 0x15, 0x88, 0x17, 0x98, 0x19, 0xa0, 0x1a, 0xa8, 0x1b, 0xb0, 0x1b, 0xb8, 0x1b, 0xb8, 0x1b, 0xb8, 0x1a, 0xb0, 0x19, 0xa8, 0x18, 0xa0, 0x16, 0x88, 0x0f, 0x58, 0xb3, 0x81,
0xb3, 0x81, 0x0f, 0x58, 0x15, 0x88, 0x18, 0x98, 0x1a, 0xa8, 0x1b, 0xb0, 0x1c, 0xb8, 0x1c, 0xc0, 0x1d, 0xc0, 0x1c, 0xc0, 0x1b, 0xb8, 0x1b, 0xb0, 0x19, 0xa0, 0x17, 0x90, 0x0f, 0x58, 0xb3, 0x81,
0xb3, 0x81, 0x0f, 0x58, 0x16, 0x88, 0x18, 0xa0, 0x1a, 0xb0, 0x1b, 0xb0, 0x1c, 0xc0, 0x1d, 0xc0, 0x1d, 0xc0, 0x1d, 0xc0, 0x1c, 0xb8, 0x1b, 0xb0, 0x19, 0xa8, 0x17, 0x98, 0x0f, 0x58, 0xb3, 0x81,
0xb3, 0x81, 0x0f, 0x58, 0x16, 0x90, 0x19, 0xa0, 0x1b, 0xb0, 0x1c, 0xb8, 0x1d, 0xc8, 0x1e, 0xc8, 0x1e, 0xd0, 0x1e, 0xc8, 0x1d, 0xc0, 0x1c, 0xb8, 0x1a, 0xa8, 0x18, 0x98, 0x0f, 0x58, 0xb3, 0x81,
0xb3, 0x81, 0x0f, 0x58, 0x17, 0x90, 0x19, 0xa8, 0x1b, 0xb8, 0x1c, 0xc0, 0x1e, 0xc8, 0x1f, 0xd0, 0x1f, 0xd8, 0x1f, 0xd0, 0x1d, 0xc0, 0x1c, 0xc0, 0x1a, 0xb0, 0x18, 0x98, 0x0f, 0x58, 0xb3, 0x81,
0xb3, 0x81, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0x0f, 0x58, 0xb3, 0x81,
0x00, 0x00, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0xb3, 0x81, 0x00, 0x00,
/*alpha channel*/
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
};
const lv_img_dsc_t purple = {
.header.cf = LV_IMG_CF_RGB565A8,
.header.always_zero = 0,
.header.reserved = 0,
.header.w = 16,
.header.h = 16,
.data_size = 768,
.data = purple_map,
};

69
main/steps/tetris_resources/red.c
View File

@ -1,69 +0,0 @@
#ifdef __has_include
#if __has_include("lvgl.h")
#ifndef LV_LVGL_H_INCLUDE_SIMPLE
#define LV_LVGL_H_INCLUDE_SIMPLE
#endif
#endif
#endif
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#ifndef LV_ATTRIBUTE_MEM_ALIGN
#define LV_ATTRIBUTE_MEM_ALIGN
#endif
#ifndef LV_ATTRIBUTE_IMG_RED
#define LV_ATTRIBUTE_IMG_RED
#endif
const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_LARGE_CONST LV_ATTRIBUTE_IMG_RED uint8_t red_map[] = {
0x00, 0x00, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0x00, 0x00,
0xa6, 0x99, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0xa6, 0x99,
0xa6, 0x99, 0x00, 0x78, 0x86, 0x99, 0x86, 0x99, 0x86, 0x99, 0x86, 0x99, 0x86, 0xa1, 0x86, 0xa1, 0x86, 0xa1, 0x86, 0xa1, 0x86, 0x99, 0x86, 0x99, 0x86, 0x99, 0x86, 0x99, 0x00, 0x78, 0xa6, 0x99,
0xa6, 0x99, 0x00, 0x78, 0x66, 0x99, 0x49, 0xaa, 0x49, 0xaa, 0x49, 0xb2, 0x49, 0xba, 0x49, 0xba, 0x49, 0xba, 0x49, 0xba, 0x49, 0xb2, 0x49, 0xb2, 0x49, 0xaa, 0x66, 0x99, 0x00, 0x78, 0xa6, 0x99,
0xa6, 0x99, 0x00, 0x78, 0x00, 0x88, 0x29, 0xaa, 0x59, 0xee, 0xd3, 0xdc, 0x0c, 0xcb, 0x0c, 0xcb, 0x0c, 0xcb, 0x0c, 0xcb, 0x0c, 0xcb, 0x0c, 0xc3, 0x49, 0xb2, 0x00, 0x88, 0x00, 0x78, 0xa6, 0x99,
0xa6, 0x99, 0x00, 0x78, 0x00, 0x88, 0x00, 0x98, 0x00, 0xa8, 0x8a, 0xc2, 0x10, 0xdc, 0x4d, 0xd3, 0x4d, 0xd3, 0x4d, 0xd3, 0x8a, 0xca, 0x00, 0xa8, 0x00, 0xa0, 0x00, 0x90, 0x00, 0x78, 0xa6, 0x99,
0xa6, 0x99, 0x00, 0x78, 0x00, 0x90, 0x00, 0xa8, 0x00, 0xb0, 0x00, 0xb8, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc8, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xb8, 0x00, 0xa8, 0x00, 0x98, 0x00, 0x78, 0xa6, 0x99,
0xa6, 0x99, 0x00, 0x78, 0x00, 0x98, 0x00, 0xa8, 0x00, 0xb8, 0x00, 0xc0, 0x00, 0xc8, 0x00, 0xc8, 0x00, 0xc8, 0x00, 0xc8, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xb0, 0x00, 0xa0, 0x00, 0x78, 0xa6, 0x99,
0xa6, 0x99, 0x00, 0x78, 0x00, 0xa0, 0x00, 0xb0, 0x00, 0xc0, 0x00, 0xc8, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xd8, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0xc8, 0x00, 0xb8, 0x00, 0xa8, 0x00, 0x78, 0xa6, 0x99,
0xa6, 0x99, 0x00, 0x78, 0x00, 0xa8, 0x00, 0xb8, 0x00, 0xc8, 0x00, 0xd0, 0x00, 0xd8, 0x00, 0xd8, 0x00, 0xd8, 0x00, 0xd8, 0x00, 0xd0, 0x00, 0xc8, 0x00, 0xc0, 0x00, 0xb0, 0x00, 0x78, 0xa6, 0x99,
0xa6, 0x99, 0x00, 0x78, 0x00, 0xa8, 0x00, 0xc0, 0x00, 0xd0, 0x00, 0xd8, 0x00, 0xe0, 0x00, 0xe0, 0x00, 0xe8, 0x00, 0xe0, 0x00, 0xd8, 0x00, 0xd8, 0x00, 0xc8, 0x00, 0xb8, 0x00, 0x78, 0xa6, 0x99,
0xa6, 0x99, 0x00, 0x78, 0x00, 0xb0, 0x00, 0xc0, 0x00, 0xd0, 0x00, 0xd8, 0x00, 0xe0, 0x00, 0xe8, 0x00, 0xe8, 0x00, 0xe8, 0x00, 0xe0, 0x00, 0xd8, 0x00, 0xc8, 0x00, 0xb8, 0x00, 0x78, 0xa6, 0x99,
0xa6, 0x99, 0x00, 0x78, 0x00, 0xb0, 0x00, 0xc8, 0x00, 0xd8, 0x00, 0xe0, 0x00, 0xe8, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xe8, 0x00, 0xe0, 0x00, 0xd0, 0x00, 0xc0, 0x00, 0x78, 0xa6, 0x99,
0xa6, 0x99, 0x00, 0x78, 0x00, 0xb8, 0x00, 0xc8, 0x00, 0xd8, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xf8, 0x00, 0xf8, 0x00, 0xf8, 0x00, 0xe8, 0x00, 0xe0, 0x00, 0xd0, 0x00, 0xc0, 0x00, 0x78, 0xa6, 0x99,
0xa6, 0x99, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0xa6, 0x99,
0x00, 0x00, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0xa6, 0x99, 0x00, 0x00,
/*alpha channel*/
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
};
const lv_img_dsc_t red = {
.header.cf = LV_IMG_CF_RGB565A8,
.header.always_zero = 0,
.header.reserved = 0,
.header.w = 16,
.header.h = 16,
.data_size = 768,
.data = red_map,
};

69
main/steps/tetris_resources/yellow.c
View File

@ -1,69 +0,0 @@
#ifdef __has_include
#if __has_include("lvgl.h")
#ifndef LV_LVGL_H_INCLUDE_SIMPLE
#define LV_LVGL_H_INCLUDE_SIMPLE
#endif
#endif
#endif
#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#ifndef LV_ATTRIBUTE_MEM_ALIGN
#define LV_ATTRIBUTE_MEM_ALIGN
#endif
#ifndef LV_ATTRIBUTE_IMG_YELLOW
#define LV_ATTRIBUTE_IMG_YELLOW
#endif
const LV_ATTRIBUTE_MEM_ALIGN LV_ATTRIBUTE_LARGE_CONST LV_ATTRIBUTE_IMG_YELLOW uint8_t yellow_map[] = {
0x00, 0x00, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x00, 0x00,
0x88, 0x9c, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0x88, 0x9c,
0x88, 0x9c, 0xa0, 0x83, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0xa8, 0x9c, 0xa8, 0xa4, 0xa8, 0xa4, 0xa8, 0xa4, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0xa0, 0x83, 0x88, 0x9c,
0x88, 0x9c, 0xa0, 0x83, 0x88, 0x9c, 0xcb, 0xa4, 0xeb, 0xac, 0x0b, 0xad, 0x2b, 0xb5, 0x2b, 0xb5, 0x2b, 0xb5, 0x2b, 0xb5, 0x0b, 0xad, 0x0b, 0xad, 0xcb, 0xa4, 0x88, 0x9c, 0xa0, 0x83, 0x88, 0x9c,
0x88, 0x9c, 0xa0, 0x83, 0x20, 0x94, 0xeb, 0xac, 0x18, 0xef, 0x33, 0xce, 0xae, 0xc5, 0xae, 0xc5, 0xae, 0xc5, 0xae, 0xc5, 0x8e, 0xbd, 0x8e, 0xbd, 0x0b, 0xad, 0x20, 0x94, 0xa0, 0x83, 0x88, 0x9c,
0x88, 0x9c, 0xa0, 0x83, 0x20, 0x94, 0x60, 0x9c, 0xa0, 0xa4, 0x8c, 0xbd, 0x31, 0xd6, 0xef, 0xcd, 0xef, 0xcd, 0xef, 0xcd, 0x8c, 0xbd, 0xc0, 0xac, 0x80, 0xa4, 0x40, 0x94, 0xa0, 0x83, 0x88, 0x9c,
0x88, 0x9c, 0xa0, 0x83, 0x40, 0x9c, 0xa0, 0xa4, 0x00, 0xad, 0x20, 0xb5, 0x40, 0xbd, 0x40, 0xbd, 0x60, 0xbd, 0x40, 0xbd, 0x40, 0xbd, 0x20, 0xb5, 0xc0, 0xac, 0x80, 0x9c, 0xa0, 0x83, 0x88, 0x9c,
0x88, 0x9c, 0xa0, 0x83, 0x60, 0x9c, 0xc0, 0xac, 0x20, 0xb5, 0x20, 0xb5, 0x60, 0xbd, 0x80, 0xc5, 0x80, 0xc5, 0x80, 0xc5, 0x40, 0xbd, 0x40, 0xbd, 0xe0, 0xac, 0x80, 0xa4, 0xa0, 0x83, 0x88, 0x9c,
0x88, 0x9c, 0xa0, 0x83, 0x80, 0xa4, 0x00, 0xad, 0x40, 0xbd, 0x80, 0xc5, 0xa0, 0xcd, 0xc0, 0xcd, 0xc0, 0xcd, 0xc0, 0xcd, 0xa0, 0xc5, 0x60, 0xc5, 0x20, 0xb5, 0xc0, 0xac, 0xa0, 0x83, 0x88, 0x9c,
0x88, 0x9c, 0xa0, 0x83, 0xc0, 0xa4, 0x20, 0xb5, 0x60, 0xbd, 0x80, 0xc5, 0xc0, 0xcd, 0xe0, 0xd5, 0x00, 0xd6, 0xe0, 0xd5, 0xc0, 0xcd, 0x80, 0xc5, 0x40, 0xbd, 0xe0, 0xac, 0xa0, 0x83, 0x88, 0x9c,
0x88, 0x9c, 0xa0, 0x83, 0xc0, 0xac, 0x40, 0xbd, 0xa0, 0xcd, 0xc0, 0xcd, 0x20, 0xde, 0x20, 0xde, 0x40, 0xe6, 0x40, 0xde, 0x00, 0xd6, 0xc0, 0xcd, 0x60, 0xbd, 0x00, 0xb5, 0xa0, 0x83, 0x88, 0x9c,
0x88, 0x9c, 0xa0, 0x83, 0xe0, 0xac, 0x40, 0xbd, 0xc0, 0xcd, 0xe0, 0xd5, 0x40, 0xde, 0x60, 0xe6, 0x60, 0xe6, 0x60, 0xe6, 0x20, 0xde, 0xe0, 0xd5, 0x80, 0xc5, 0x20, 0xb5, 0xa0, 0x83, 0x88, 0x9c,
0x88, 0x9c, 0xa0, 0x83, 0x00, 0xad, 0x60, 0xc5, 0xe0, 0xd5, 0x20, 0xde, 0x80, 0xee, 0xa0, 0xee, 0xc0, 0xf6, 0xa0, 0xee, 0x40, 0xe6, 0x20, 0xde, 0xa0, 0xcd, 0x20, 0xb5, 0xa0, 0x83, 0x88, 0x9c,
0x88, 0x9c, 0xa0, 0x83, 0x00, 0xb5, 0x80, 0xc5, 0x00, 0xd6, 0x20, 0xde, 0xa0, 0xee, 0xe0, 0xf6, 0x00, 0xff, 0xe0, 0xf6, 0x60, 0xe6, 0x20, 0xde, 0xc0, 0xcd, 0x40, 0xbd, 0xa0, 0x83, 0x88, 0x9c,
0x88, 0x9c, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0xa0, 0x83, 0x88, 0x9c,
0x00, 0x00, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x88, 0x9c, 0x00, 0x00,
/*alpha channel*/
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
};
const lv_img_dsc_t yellow = {
.header.cf = LV_IMG_CF_RGB565A8,
.header.always_zero = 0,
.header.reserved = 0,
.header.w = 16,
.header.h = 16,
.data_size = 768,
.data = yellow_map,
};

168
main/steps/wires_puzzle.cpp
View File

@ -1,6 +1,6 @@
#include "wires_puzzle.h" #include "wires_puzzle.h"
const static char* WIRES_FILE_PATH = MOUNT_POINT "/wires.txt"; const static char* WIRES_FILE_PATH = "/sdcard/wires.txt";
const static char* TAG = "wires_puzzle"; const static char* TAG = "wires_puzzle";
static int color_name_len[NUM_COLORS] = { static int color_name_len[NUM_COLORS] = {
@ -17,22 +17,22 @@ static int max(int n0, int n1, int n2, int n3, int n4, int n5);
void wires_to_string(WireColor* wires, char* out_wires_string) { void wires_to_string(WireColor* wires, char* out_wires_string) {
for (int i = 0; i < NUM_WIRES; i++) { for (int i = 0; i < NUM_WIRES; i++) {
switch (wires[i]) { switch (wires[i]) {
case WireColor::wire_red: case WireColor::red:
out_wires_string[i] = 'r'; out_wires_string[i] = 'r';
break; break;
case WireColor::wire_yellow: case WireColor::yellow:
out_wires_string[i] = 'y'; out_wires_string[i] = 'y';
break; break;
case WireColor::wire_green: case WireColor::green:
out_wires_string[i] = 'g'; out_wires_string[i] = 'g';
break; break;
case WireColor::wire_blue: case WireColor::blue:
out_wires_string[i] = 'b'; out_wires_string[i] = 'b';
break; break;
case WireColor::wire_black: case WireColor::black:
out_wires_string[i] = 'k'; out_wires_string[i] = 'k';
break; break;
case WireColor::wire_white: case WireColor::white:
out_wires_string[i] = 'w'; out_wires_string[i] = 'w';
break; break;
} }
@ -52,22 +52,22 @@ void string_to_wires(char* wires_string, WireColor* out_wires) {
for (int i = 0; i < NUM_WIRES; i++) { for (int i = 0; i < NUM_WIRES; i++) {
switch (wires_string[i]) { switch (wires_string[i]) {
case 'r': case 'r':
out_wires[i] = WireColor::wire_red; out_wires[i] = WireColor::red;
break; break;
case 'y': case 'y':
out_wires[i] = WireColor::wire_yellow; out_wires[i] = WireColor::yellow;
break; break;
case 'g': case 'g':
out_wires[i] = WireColor::wire_green; out_wires[i] = WireColor::green;
break; break;
case 'b': case 'b':
out_wires[i] = WireColor::wire_blue; out_wires[i] = WireColor::blue;
break; break;
case 'k': case 'k':
out_wires[i] = WireColor::wire_black; out_wires[i] = WireColor::black;
break; break;
case 'w': case 'w':
out_wires[i] = WireColor::wire_white; out_wires[i] = WireColor::white;
break; break;
} }
} }
@ -122,8 +122,6 @@ void generate_new_wires(WireColor* wires) {
} }
void solve_wires(WireColor* wires, bool* out_cut) { void solve_wires(WireColor* wires, bool* out_cut) {
bool debug = false;
// by default, don't cut any wires // by default, don't cut any wires
for (int i = 0; i < NUM_WIRES; i++) { for (int i = 0; i < NUM_WIRES; i++) {
out_cut[i] = false; out_cut[i] = false;
@ -144,17 +142,17 @@ void solve_wires(WireColor* wires, bool* out_cut) {
int white_pos_len = 0; int white_pos_len = 0;
for (int i = 0; i < NUM_WIRES; i++) { for (int i = 0; i < NUM_WIRES; i++) {
if (wires[i] == WireColor::wire_red) { if (wires[i] == WireColor::red) {
red_pos[red_pos_len++] = i; red_pos[red_pos_len++] = i;
} else if (wires[i] == WireColor::wire_yellow) { } else if (wires[i] == WireColor::yellow) {
yellow_pos[yellow_pos_len++] = i; yellow_pos[yellow_pos_len++] = i;
} else if (wires[i] == WireColor::wire_green) { } else if (wires[i] == WireColor::green) {
green_pos[green_pos_len++] = i; green_pos[green_pos_len++] = i;
} else if (wires[i] == WireColor::wire_blue) { } else if (wires[i] == WireColor::blue) {
blue_pos[blue_pos_len++] = i; blue_pos[blue_pos_len++] = i;
} else if (wires[i] == WireColor::wire_black) { } else if (wires[i] == WireColor::black) {
black_pos[black_pos_len++] = i; black_pos[black_pos_len++] = i;
} else if (wires[i] == WireColor::wire_white) { } else if (wires[i] == WireColor::white) {
white_pos[white_pos_len++] = i; white_pos[white_pos_len++] = i;
} }
} }
@ -185,42 +183,34 @@ void solve_wires(WireColor* wires, bool* out_cut) {
if (list_pos_len[i] == max_len) { if (list_pos_len[i] == max_len) {
int idx = list_pos[i][1]; int idx = list_pos[i][1];
out_cut[idx] = true; out_cut[idx] = true;
if (debug) { // ESP_LOGI(TAG, "1. cutting %d", idx);
printf("C1. cutting %d\n", idx);
}
} }
} }
} }
// 2. cut the first wire if it is green or white // 2. cut the first wire if it is green or white
if (wires[0] == WireColor::wire_green || wires[0] == WireColor::wire_white) { if (wires[0] == WireColor::green || wires[0] == WireColor::white) {
out_cut[0] = true; out_cut[0] = true;
if (debug) { // ESP_LOGI(TAG, "2. cutting %d", 0);
printf("C2. cutting %d\n", 0);
}
} }
// 3. cut blue wires in even positions (odd indexes) // 3. cut blue wires in even positions (odd indexes)
for (int i = 1; i < NUM_WIRES; i += 2) { for (int i = 1; i < NUM_WIRES; i += 2) {
if (wires[i] == WireColor::wire_blue) { if (wires[i] == WireColor::blue) {
out_cut[i] = true; out_cut[i] = true;
if (debug) { // ESP_LOGI(TAG, "3. cutting %d", i);
printf("C3. cutting %d\n", i);
}
} }
} }
// 4. cut black and yellow wires next to black and yellow wires // 4. cut black and yellow wires next to black and yellow wires
for (int i = 0; i < NUM_WIRES-1; i++) { for (int i = 0; i < NUM_WIRES-1; i++) {
if ( if (
(wires[i] == WireColor::wire_yellow || wires[i] == WireColor::wire_black) && (wires[i] == WireColor::yellow || wires[i] == WireColor::black) &&
(wires[i+1] == WireColor::wire_yellow || wires[i+1] == WireColor::wire_black) (wires[i+1] == WireColor::yellow || wires[i+1] == WireColor::black)
) { ) {
out_cut[i] = true; out_cut[i] = true;
out_cut[i+1] = true; out_cut[i+1] = true;
if (debug) { // ESP_LOGI(TAG, "4. cutting %d, %d", i, i+1);
printf("C4. cutting %d, %d\n", i, i+1);
}
} }
} }
@ -228,35 +218,29 @@ void solve_wires(WireColor* wires, bool* out_cut) {
for (int green_idx = green_pos_len-1; green_idx >= 0; green_idx--) { for (int green_idx = green_pos_len-1; green_idx >= 0; green_idx--) {
int pos = green_pos[green_idx]; int pos = green_pos[green_idx];
if ( if (
wires[pos-1] == WireColor::wire_yellow || wires[pos-1] == WireColor::yellow ||
wires[pos-1] == WireColor::wire_white || wires[pos-1] == WireColor::white ||
wires[pos+1] == WireColor::wire_yellow || wires[pos+1] == WireColor::yellow ||
wires[pos+1] == WireColor::wire_white wires[pos+1] == WireColor::white
) { ) {
out_cut[pos] = true; out_cut[pos] = true;
if (debug) { // ESP_LOGI(TAG, "5. cutting %d", pos);
printf("C5. cutting %d\n", pos);
}
break; break;
} }
} }
// 6. cut all white wires if there is a red wire in the 5th position // 6. cut all white wires if there is a red wire in the 5th position
if (wires[4] == WireColor::wire_red) { if (wires[4] == WireColor::red) {
for (int white_idx = 0; white_idx < white_pos_len; white_idx++) { for (int white_idx = 0; white_idx < white_pos_len; white_idx++) {
out_cut[white_pos[white_idx]] = true; out_cut[white_pos[white_idx]] = true;
if (debug) { // ESP_LOGI(TAG, "6. cutting %d", white_pos[white_idx]);
printf("C6. cutting %d\n", white_pos[white_idx]);
}
} }
} }
// 7. cut the first black wire if there are more white wires than green wires // 7. cut the first black wire if there are more white wires than green wires
if (white_pos_len > green_pos_len && black_pos_len > 0) { if (white_pos_len > green_pos_len && black_pos_len > 0) {
out_cut[black_pos[0]] = true; out_cut[black_pos[0]] = true;
if (debug) { // ESP_LOGI(TAG, "7. cutting %d", black_pos[0]);
printf("C7. cutting %d\n", black_pos[0]);
}
} }
// 8. cut all wires in an alternating pattern of 2 colors at least 4 wires long // 8. cut all wires in an alternating pattern of 2 colors at least 4 wires long
@ -270,9 +254,7 @@ void solve_wires(WireColor* wires, bool* out_cut) {
out_cut[i+1] = true; out_cut[i+1] = true;
out_cut[i+2] = true; out_cut[i+2] = true;
out_cut[i+3] = true; out_cut[i+3] = true;
if (debug) { // ESP_LOGI(TAG, "8. cutting %d, %d, %d, %d", i, i+1, i+2, i+3);
printf("C8. cutting %d, %d, %d, %d\n", i, i+1, i+2, i+3);
}
} }
} }
@ -280,9 +262,7 @@ void solve_wires(WireColor* wires, bool* out_cut) {
for (int i = 0; i < NUM_WIRES; i++) { for (int i = 0; i < NUM_WIRES; i++) {
if (color_name_len[wires[i]] == i+1) { if (color_name_len[wires[i]] == i+1) {
out_cut[i] = true; out_cut[i] = true;
if (debug) { // ESP_LOGI(TAG, "9. cutting %d", i);
printf("C9. cutting %d\n", i);
}
} }
} }
@ -290,119 +270,83 @@ void solve_wires(WireColor* wires, bool* out_cut) {
if (max_len <= 2) { if (max_len <= 2) {
for (int i = 0; i < red_pos_len; i++) { for (int i = 0; i < red_pos_len; i++) {
out_cut[red_pos[i]] = true; out_cut[red_pos[i]] = true;
if (debug) { // ESP_LOGI(TAG, "10. cutting %d", red_pos[i]);
printf("C10. cutting %d\n", red_pos[i]);
}
} }
} }
// 11. cut the last wire if it is the same color as the first wire // 11. cut the last wire if it is the same color as the first wire
if (wires[0] == wires[NUM_WIRES-1]) { if (wires[0] == wires[NUM_WIRES-1]) {
out_cut[NUM_WIRES-1] = true; out_cut[NUM_WIRES-1] = true;
if (debug) { // ESP_LOGI(TAG, "11. cutting %d", NUM_WIRES-1);
printf("C11. cutting %d\n", NUM_WIRES-1);
}
} }
// 12. cut any wire adjacent to both a yellow and blue wire // 12. cut any wire adjacent to both a yellow and blue wire
for (int i = 0; i < NUM_WIRES-2; i++) { for (int i = 0; i < NUM_WIRES-2; i++) {
if ( if (
(wires[i] == WireColor::wire_yellow && wires[i+2] == WireColor::wire_blue) || (wires[i] == WireColor::yellow && wires[i+2] == WireColor::blue) ||
(wires[i] == WireColor::wire_blue && wires[i+2] == WireColor::wire_yellow) (wires[i] == WireColor::blue && wires[i+2] == WireColor::white)
) { ) {
out_cut[i+1] = true; out_cut[i+1] = true;
if (debug) { // ESP_LOGI(TAG, "12. cutting %d", i+1);
printf("C12. cutting %d\n", i+1);
}
} }
} }
// NEVER CUT // NEVER CUT
// 1. never cut blue wires next to red or green wires // never cut blue wires next to red or green wires
for (int i = 0; i < blue_pos_len; i++) { for (int i = 0; i < blue_pos_len; i++) {
int pos = blue_pos[i]; int pos = blue_pos[i];
if ( if (
wires[pos-1] == WireColor::wire_red || wires[pos-1] == WireColor::red ||
wires[pos-1] == WireColor::wire_green || wires[pos-1] == WireColor::green ||
wires[pos+1] == WireColor::wire_red || wires[pos+1] == WireColor::red ||
wires[pos+1] == WireColor::wire_green wires[pos+1] == WireColor::green
) { ) {
out_cut[pos] = false; out_cut[pos] = false;
if (debug) {
printf("N1. Never cutting %d\n", pos);
}
} }
} }
// 2. never cut white wires if there is at least one red, black and green wire // never cut white wires if there is at least one red, black and green wire
if (red_pos_len > 0 && green_pos_len > 0 && black_pos_len > 0) { if (red_pos_len > 0 && green_pos_len > 0 && black_pos_len > 0) {
for (int i = 0; i < white_pos_len; i++) { for (int i = 0; i < white_pos_len; i++) {
out_cut[white_pos[i]] = false; out_cut[white_pos[i]] = false;
if (debug) {
printf("N2. Never cutting %d\n", white_pos[i]);
}
} }
} }
// 3. never cut red or black wires in the 4th or 7th positions // never cut red or black wires in the 4th or 7th positions
if (wires[3] == WireColor::wire_red || wires[3] == WireColor::wire_black) { if (wires[3] == WireColor::red || wires[3] == WireColor::black) {
out_cut[3] = false; out_cut[3] = false;
if (debug) {
printf("N3. Never cutting %d\n", 3);
}
} }
if (wires[6] == WireColor::wire_red || wires[6] == WireColor::wire_black) { if (wires[6] == WireColor::red || wires[6] == WireColor::black) {
out_cut[6] = false; out_cut[6] = false;
if (debug) {
printf("N3. Never cutting %d\n", 6);
}
} }
// 4. never cut wires that have the same color on both sides of it // never cut wires that have the same color on both sides of it
for (int i = 0; i < NUM_WIRES-2; i++) { for (int i = 0; i < NUM_WIRES-2; i++) {
if (wires[i] == wires[i+2]) { if (wires[i] == wires[i+2]) {
out_cut[i+1] = false; out_cut[i+1] = false;
if (debug) {
printf("N4. Never cutting %d\n", i+1);
}
} }
} }
// 5. never cut a wire in the 1st, 2nd, or 3rd position if it is the same color as the wire in the 4th position. // never cut a wire in the 1st, 2nd, or 3rd position if it is the same color as the wire in the 4th position.
if (wires[0] == wires[3]) { if (wires[0] == wires[3]) {
out_cut[0] = false; out_cut[0] = false;
if (debug) {
printf("N5. Never cutting %d\n", 0);
}
} }
if (wires[1] == wires[3]) { if (wires[1] == wires[3]) {
out_cut[1] = false; out_cut[1] = false;
if (debug) {
printf("N5. Never cutting %d\n", 1);
}
} }
if (wires[2] == wires[3]) { if (wires[2] == wires[3]) {
out_cut[2] = false; out_cut[2] = false;
if (debug) {
printf("N5. Never cutting %d\n", 2);
}
} }
// 6. never cut a blue or green wire in the 8th postion // never cut a blue or green wire in the 8th postion
if (wires[7] == WireColor::wire_blue || wires[7] == WireColor::wire_green) { if (wires[7] == WireColor::blue || wires[7] == WireColor::green) {
out_cut[7] = false; out_cut[7] = false;
if (debug) {
printf("N6. Never cutting %d\n", 7);
}
} }
// 7. never cut a wire in the 5th position if there are no yellow wires // never cut a wire in the 5th position if there are no yellow wires
if (yellow_pos_len == 0) { if (yellow_pos_len == 0) {
out_cut[4] = false; out_cut[4] = false;
if (debug) {
printf("N7 Never cutting %d\n", 4);
}
} }
} }

15
main/steps/wires_puzzle.h
View File

@ -3,18 +3,19 @@
#include <stdint.h> #include <stdint.h>
#include <esp_random.h> #include <esp_random.h>
#include "drivers/sd.h" #include <string.h>
#include "esp_vfs_fat.h"
#define NUM_COLORS 6 #define NUM_COLORS 6
#define NUM_WIRES 8 #define NUM_WIRES 8
typedef enum { typedef enum {
wire_red = 0, red = 0,
wire_yellow = 1, yellow = 1,
wire_green = 2, green = 2,
wire_blue = 3, blue = 3,
wire_black = 4, black = 4,
wire_white = 5, white = 5,
} WireColor; } WireColor;
void solve_wires(WireColor* wires, bool* out_cut); void solve_wires(WireColor* wires, bool* out_cut);

8
partitions.csv
View File

@ -1,8 +0,0 @@
# ESP-IDF Partition Table
# Name, Type, SubType, Offset, Size, Flags
nvs,data,nvs,0x9000,0x6000,,
phy_init,data,phy,0xf000,0x1000,,
ota,data,ota,0x10000,0x2000,,
factory,app,factory,0x20000,2M,,
ota0,app,ota_0,0x220000,2M,,
ota1,app,ota_1,0x420000,2M,,
1 # ESP-IDF Partition Table
2 # Name, Type, SubType, Offset, Size, Flags
3 nvs,data,nvs,0x9000,0x6000,,
4 phy_init,data,phy,0xf000,0x1000,,
5 ota,data,ota,0x10000,0x2000,,
6 factory,app,factory,0x20000,2M,,
7 ota0,app,ota_0,0x220000,2M,,
8 ota1,app,ota_1,0x420000,2M,,

BIN
resources/background.bin Normal file
View File

Binary file not shown.

1
resources/corr.pcm Normal file
View File

File diff suppressed because one or more lines are too long

BIN
resources/corr.wav
View File

Binary file not shown.

27
resources/correct.pcm Normal file
View File

File diff suppressed because one or more lines are too long

BIN
resources/correct.wav
View File

Binary file not shown.

BIN
resources/dark_blue.bin Normal file
View File

Binary file not shown.

BIN
resources/diffuse.wav
View File

Binary file not shown.

1
resources/diffused.pcm Normal file
View File

File diff suppressed because one or more lines are too long

BIN
resources/flash.wav
View File

Binary file not shown.

BIN
resources/high-1.pcm Normal file
View File

Binary file not shown.

BIN
resources/high-1.wav
View File

Binary file not shown.

BIN
resources/high-3.pcm Normal file
View File

Binary file not shown.

BIN
resources/high-3.wav
View File

Binary file not shown.

BIN
resources/high-6.pcm Normal file
View File

Binary file not shown.

BIN
resources/high-6.wav
View File

Binary file not shown.

1
resources/incorrect.pcm Normal file
View File

File diff suppressed because one or more lines are too long

BIN
resources/incorrect.wav
View File

Binary file not shown.

BIN
resources/low-1.pcm Normal file
View File

Binary file not shown.

Some files were not shown because too many files have changed in this diff Show More