Razvalyaev/Lamps
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Еще больше рефакторинга

Browse Source 
- Выделение меню в отдельную группу
- Добавление отдельных модулей для функционала игр и для функционала часов
- Переход на 5 компилятор, чтобы прошивка меньше весила (не влезает в C6)
- Фикс варнингов для 5 компилятора
This commit is contained in:
Razvalyaev
2026-04-22 10:05:39 +03:00
parent 71fc59d34d
commit 357d4e5454
20 changed files with 1326 additions and 925 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Core/Clock/clock_manager.h
View File

@@ -23,4 +23,4 @@ void ClockManager_SetDuty(uint8_t value);
// Сброс времени на 00:00:00
void ClockManager_ResetTime(void);
#endif
#endif

2
Core/Clock/melody.c
View File

@@ -104,4 +104,4 @@ void Melody_Update(MelodyHandle* mh) {
uint8_t Melody_IsPlaying(MelodyHandle* mh) {
return mh->is_playing;
}
}

2
Core/Clock/melody.h
View File

@@ -24,4 +24,4 @@ void Melody_Stop(MelodyHandle* mh);
void Melody_Update(MelodyHandle* mh);
uint8_t Melody_IsPlaying(MelodyHandle* mh);
#endif
#endif

195
Core/Clock/menu.c
View File

@@ -1,195 +0,0 @@
#include "menu.h"
#include "segment.h"
#include <string.h>
#include <stdio.h>
#define LONG_PRESS_MS 500
MenuContext g_ctx;
uint8_t g_sound_enabled = 1;
extern bool ReadButton(Button_Type btn);
extern MenuNode* Menu_GetRootMenu(void);
void Menu_Init(MenuNode* startNode) {
g_ctx.currentNode = startNode;
g_ctx.needsRedraw = true;
g_ctx.lastTick = 0;
if (startNode && startNode->onEnter) {
startNode->onEnter();
}
}
// НОВАЯ ФУНКЦИЯ - открыть меню
void Menu_OpenMenu(MenuNode* menu) {
if (!menu) return;
g_ctx.currentNode = menu;
g_ctx.needsRedraw = true;
if (menu->onEnter) {
menu->onEnter();
}
}
void Menu_HandleButton(Button_Type btn, bool longPress) {
if (!g_ctx.currentNode) return;
// Длинное нажатие SELECT на корневом уровне (часы) - вход в меню
if (longPress && btn == BUTTON_SELECT && g_ctx.currentNode->parent == NULL) {
SOUND_DOUBLE;
MenuNode* rootMenu = Menu_GetRootMenu();
if (rootMenu) {
Menu_OpenMenu(rootMenu);
}
return;
}
if (g_ctx.currentNode->onButton) {
if(btn == BUTTON_SELECT)
{
SOUND_DOUBLE;
}
else
{
SOUND_CLICK;
}
g_ctx.currentNode->onButton(btn, longPress);
return;
}
if (g_ctx.currentNode->parent != NULL) {
switch (btn) {
case BUTTON_UP:
SOUND_CLICK;
if (g_ctx.currentNode->selectedChild > 0) {
g_ctx.currentNode->selectedChild--;
g_ctx.needsRedraw = true;
}
break;
case BUTTON_DOWN:
SOUND_CLICK;
if (g_ctx.currentNode->selectedChild < g_ctx.currentNode->childCount - 1) {
g_ctx.currentNode->selectedChild++;
g_ctx.needsRedraw = true;
}
break;
case BUTTON_SELECT: {
SOUND_DOUBLE;
if (g_ctx.currentNode->children) {
MenuNode* selected = g_ctx.currentNode->children[g_ctx.currentNode->selectedChild];
if (selected) {
g_ctx.currentNode = selected;
g_ctx.needsRedraw = true;
if (selected->onEnter) {
selected->onEnter();
}
}
}
break;
}
case BUTTON_BACK:
SOUND_CLICK;
Menu_GoBack();
break;
default:
break;
}
}
}
void Menu_Process(void) {
uint32_t tick = HAL_GetTick();
// ОБРАБОТКА КНОПОК С ДЕБАУНСОМ
for (int i = 0; i < BUTTON_COUNT; i++) {
bool reading = ReadButton((Button_Type)i);
if (reading != g_ctx.lastButtonState[i]) {
g_ctx.lastDebounceTime[i] = tick;
}
if ((tick - g_ctx.lastDebounceTime[i]) > 30) { // DEBOUNCE_MS = 30
if (reading != g_ctx.buttonState[i]) {
g_ctx.buttonState[i] = reading;
if (g_ctx.buttonState[i]) {
g_ctx.pressStartTime[i] = tick;
g_ctx.longPressTriggered[i] = false;
} else {
if (!g_ctx.longPressTriggered[i]) {
Menu_HandleButton((Button_Type)i, false);
}
}
}
}
if (g_ctx.buttonState[i] && !g_ctx.longPressTriggered[i]) {
if ((tick - g_ctx.pressStartTime[i]) >= LONG_PRESS_MS) {
g_ctx.longPressTriggered[i] = true;
Menu_HandleButton((Button_Type)i, true);
}
}
g_ctx.lastButtonState[i] = reading;
}
if (g_ctx.currentNode && g_ctx.currentNode->onUpdate) {
g_ctx.currentNode->onUpdate();
}
if (tick - g_ctx.lastTick >= 200) {
g_ctx.lastTick = tick;
g_ctx.needsRedraw = true;
}
if ((g_ctx.needsRedraw && g_ctx.currentNode && g_ctx.currentNode->display) ||
(g_ctx.currentNode && g_ctx.currentNode->display && g_ctx.currentNode->needsRedraw)) {
g_ctx.currentNode->display();
g_ctx.needsRedraw = false;
}
}
void Menu_GoBack(void) {
if (g_ctx.currentNode && g_ctx.currentNode->parent) {
g_ctx.currentNode = g_ctx.currentNode->parent;
g_ctx.needsRedraw = true;
if (g_ctx.currentNode->onEnter) {
g_ctx.currentNode->onEnter();
}
}
}
void Menu_Refresh(void) {
g_ctx.needsRedraw = true;
}
MenuNode* Menu_GetCurrentNode(void) {
return g_ctx.currentNode;
}
void Menu_Sound_On(void) {
g_sound_enabled = 1;
SOUND_SUCCESS;
}
void Menu_Sound_Off(void) {
g_sound_enabled = 0;
}
void Menu_Sound_Toggle(void) {
if (g_sound_enabled) {
Menu_Sound_Off();
} else {
Menu_Sound_On();
}
}
uint8_t Menu_Sound_IsEnabled(void) {
return g_sound_enabled;
}

70
Core/Clock/menu.h
View File

@@ -1,70 +0,0 @@
#ifndef MENU_H
#define MENU_H
#include <stdint.h>
#include <stdbool.h>
#include "main.h"
#include "melody.h"
// Макросы звуковых эффектов
#define SFX_BPM 480
#define SOUND_CLICK if(g_sound_enabled) Melody_Play(&melody, &SFX_Click, SFX_BPM)
#define SOUND_DOUBLE if(g_sound_enabled) Melody_Play(&melody, &SFX_DoubleBeep, SFX_BPM)
#define SOUND_ERROR if(g_sound_enabled) Melody_Play(&melody, &SFX_Error, SFX_BPM)
#define SOUND_SUCCESS if(g_sound_enabled) Melody_Play(&melody, &SFX_Success, SFX_BPM)
typedef enum {
BUTTON_UP,
BUTTON_DOWN,
BUTTON_SELECT,
BUTTON_BACK,
BUTTON_COUNT
} Button_Type;
typedef struct MenuNode {
const char* name;
struct MenuNode* parent;
struct MenuNode** children;
uint8_t childCount;
uint8_t selectedChild;
uint8_t needsRedraw;
void (*display)(void);
void (*onEnter)(void);
void (*onUpdate)(void);
void (*onButton)(Button_Type btn, bool longPress);
void* data;
} MenuNode;
typedef struct {
MenuNode* currentNode;
uint32_t lastTick;
bool needsRedraw;
uint32_t lastDebounceTime[BUTTON_COUNT];
uint8_t lastButtonState[BUTTON_COUNT];
uint8_t buttonState[BUTTON_COUNT];
uint32_t pressStartTime[BUTTON_COUNT];
uint8_t longPressTriggered[BUTTON_COUNT];
} MenuContext;
// Глобальные переменные
extern uint8_t g_sound_enabled;
extern MenuContext g_ctx;
// Функции
void Menu_Init(MenuNode* startNode);
void Menu_Process(void);
void Menu_HandleButton(Button_Type btn, bool longPress);
void Menu_GoBack(void);
void Menu_Refresh(void);
MenuNode* Menu_GetCurrentNode(void);
void Menu_OpenMenu(MenuNode* menu);
void Menu_Sound_On(void);
void Menu_Sound_Off(void);
void Menu_Sound_Toggle(void);
uint8_t Menu_Sound_IsEnabled(void);
#endif

695
Core/Clock/menu_items.c
View File

@@ -1,695 +0,0 @@
#include "menu_items.h"
#include "segment.h"
#include "clock_manager.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
static MenuNode g_rootMenu;
// Сначала объявляем узлы активностей
MenuNode g_clockNode;
MenuNode g_timerNode;
MenuNode g_stopwatchNode;
MenuNode g_ZeroMillisNode;
MenuNode g_ReactionTimeNode;
MenuNode g_ClickerTimeNode;
// Потом объявляем узлы меню
MenuNode g_gamesNode;
MenuNode g_settingsNode;
MenuNode g_timeEditNode;
MenuNode g_dutyEditNode;
MenuNode g_LEDEditNode;
MenuNode g_MenuSoundNode;
MenuNode g_PowerOnSongNode;
MenuNode g_SongNode;
MenuNode g_resetNode;
// ==================== Данные ====================
typedef struct {
time_t editTime;
uint8_t editStep;
bool blinkState;
uint32_t lastBlink;
} TimeEditData;
typedef struct {
uint32_t startTime;
uint32_t pressTime;
bool celebrating;
bool result;
int32_t diff_ms;
uint8_t state;
} Game1SecData;
typedef struct {
uint32_t waitStart;
uint32_t ledOnTime;
uint32_t reactionTime;
uint8_t state;
} GameReactionData;
typedef struct {
uint32_t endTime;
uint16_t clicks;
bool active;
bool finished;
} GameClickerData;
static TimeEditData g_timeData;
static uint8_t g_originalDuty;
static uint8_t g_editDuty;
static Game1SecData g_game1sec;
static GameReactionData g_gameReaction;
static GameClickerData g_gameClicker;
// Текущая активность в корне
static MenuNode* g_currentActivity = NULL;
// ==================== Функции отображения активностей ====================
static void Display_Clock(void) {
time_t now = ClockManager_GetTime(1);
char buf[7];
sprintf(buf, "%02d%02d%02d", now.hour, now.min, now.sec);
Segment_SetString(buf);
}
static void Display_Timer(void) {
Segment_SetString("TIMER ");
}
static void Display_Stopwatch(void) {
Segment_SetString("SECOND ");
}
static void Display_ZeroMillis(void) {
char buf[7];
switch (g_game1sec.state) {
case 0:
g_game1sec.celebrating = 0;
sprintf(buf, "START"); break;
case 1:
g_game1sec.diff_ms = (HAL_GetTick() - g_game1sec.startTime);
case 2:
sprintf(buf, " %4d", g_game1sec.diff_ms/10);
break;
default: sprintf(buf, "ERROR"); break;
}
if(g_game1sec.state == 2)
{
if((g_game1sec.diff_ms/10)%100 == 0)
{
if(!g_game1sec.celebrating)
{
g_game1sec.celebrating = 1;
Melody_Play(&melody, &Polyphia_PlayingGod, 134);
}
}
}
Segment_SetString(buf);
}
static void Display_Reaction(void) {
char buf[7];
switch (g_gameReaction.state) {
case 0: sprintf(buf, "START"); break;
case 1: sprintf(buf, " "); break;
case 2: sprintf(buf, "888888"); break;
case 3: sprintf(buf, "%6d", g_gameReaction.reactionTime); break;
default: sprintf(buf, "ERROR"); break;
}
Segment_SetString(buf);
}
static void Display_Clicker(void) {
char buf[7];
if (!g_gameClicker.active && !g_gameClicker.finished) {
sprintf(buf, "START");
} else if (g_gameClicker.active) {
uint32_t remaining = (g_gameClicker.endTime - HAL_GetTick()) / 1000;
sprintf(buf, "%2d %3d", remaining, g_gameClicker.clicks);
} else {
sprintf(buf, " %3d", g_gameClicker.clicks);
}
Segment_SetString(buf);
}
static void Display_MenuItem(void) {
MenuNode* current = Menu_GetCurrentNode();
if (current && current->selectedChild < current->childCount) {
const char* name = current->children[current->selectedChild]->name;
char buf[7];
sprintf(buf, "%-6.6s", name);
Segment_SetString(buf);
}
}
static void Display_TimeEdit(void) {
char buf[7];
sprintf(buf, "%02d%02d%02d",
g_timeData.editTime.hour,
g_timeData.editTime.min,
g_timeData.editTime.sec);
if (g_timeData.blinkState && g_timeData.editStep < 6) {
buf[g_timeData.editStep] = ' ';
}
Segment_SetString(buf);
}
static void Display_DutyEdit(void) {
char buf[7] = "DUTY ";
if (g_editDuty == 10) {
buf[4] = '1';
buf[5] = '0';
} else {
buf[5] = '0' + g_editDuty;
}
Segment_SetString(buf);
}
static void Display_Reset(void) {
Segment_SetString("RESET ");
}
// ==================== Вход в активности ====================
static void OnEnter_Clock(void) {
g_currentActivity = &g_clockNode;
g_rootMenu.parent = &g_clockNode;
}
static void OnEnter_Timer(void) {
g_currentActivity = &g_timerNode;
g_rootMenu.parent = &g_timerNode;
}
static void OnEnter_Stopwatch(void) {
g_currentActivity = &g_stopwatchNode;
g_rootMenu.parent = &g_stopwatchNode;
}
static void OnEnter_ZeroMillis(void) {
g_game1sec.state = 0;
Menu_Refresh();
}
static void OnEnter_Reaction(void) {
g_gameReaction.state = 0;
Menu_Refresh();
}
static void OnEnter_Clicker(void) {
g_gameClicker.active = false;
g_gameClicker.finished = false;
g_gameClicker.clicks = 0;
Menu_Refresh();
}
static void OnEnter_TimeEdit(void) {
g_timeData.editTime = ClockManager_GetTime(0);
g_timeData.editStep = 0;
g_timeData.blinkState = true;
g_timeData.lastBlink = HAL_GetTick();
}
static void OnEnter_DutyEdit(void) {
g_originalDuty = ClockManager_GetDuty();
g_editDuty = g_originalDuty;
Segment_SetBrightness(g_editDuty * 10);
}
static void OnEnter_Reset(void) {}
// ==================== Обновления ====================
static void OnUpdate_TimeEdit(void) {
uint32_t tick = HAL_GetTick();
if (tick - g_timeData.lastBlink >= 500) {
g_timeData.lastBlink = tick;
g_timeData.blinkState = !g_timeData.blinkState;
Menu_Refresh();
}
}
static void OnUpdate_Reaction(void) {
uint32_t tick = HAL_GetTick();
if (g_gameReaction.state == 1) {
if (tick - g_gameReaction.waitStart >= g_gameReaction.ledOnTime) {
g_gameReaction.state = 2;
g_gameReaction.waitStart = tick;
Menu_Refresh();
}
}
else if (g_gameReaction.state == 2) {
if (tick - g_gameReaction.waitStart >= 2000) {
g_gameReaction.state = 3;
g_gameReaction.reactionTime = 999;
Menu_Refresh();
}
}
}
static void OnUpdate_Clicker(void) {
if (g_gameClicker.active && HAL_GetTick() >= g_gameClicker.endTime) {
g_gameClicker.active = false;
g_gameClicker.finished = true;
Menu_Refresh();
}
}
// ==================== Обработчики кнопок активностей ====================
static void Clock_OnButton(Button_Type btn, bool longPress) {
if (longPress && btn == BUTTON_SELECT) {
Menu_OpenMenu(&g_rootMenu);
}
}
static void Timer_OnButton(Button_Type btn, bool longPress) {
if (longPress && btn == BUTTON_SELECT) {
Menu_OpenMenu(&g_rootMenu);
}
}
static void Stopwatch_OnButton(Button_Type btn, bool longPress) {
if (longPress && btn == BUTTON_SELECT) {
Menu_OpenMenu(&g_rootMenu);
}
}
static void ZeroMillis_OnButton(Button_Type btn, bool longPress) {
if (longPress && btn == BUTTON_SELECT) {
Menu_OpenMenu(&g_rootMenu);
return;
}
if (btn == BUTTON_BACK) {
Menu_GoBack();
}
uint32_t tick = HAL_GetTick();
if (g_game1sec.state == 0 && btn == BUTTON_SELECT) {
g_game1sec.state = 1;
g_game1sec.startTime = tick;
Menu_Refresh();
}
else if ((btn == BUTTON_SELECT) && (g_game1sec.state == 1)) {
g_game1sec.state = 2;
g_game1sec.pressTime = HAL_GetTick();
g_game1sec.diff_ms = (g_game1sec.pressTime - g_game1sec.startTime);
if (g_game1sec.diff_ms < 0) g_game1sec.diff_ms = -g_game1sec.diff_ms;
Menu_Refresh();
}
else if ((g_game1sec.state == 2) && (btn == BUTTON_SELECT))
{
g_game1sec.state = 0;
}
}
static void Reaction_OnButton(Button_Type btn, bool longPress) {
if (longPress && btn == BUTTON_SELECT) {
Menu_OpenMenu(&g_rootMenu);
return;
}
if (btn == BUTTON_BACK) {
Menu_GoBack();
}
uint32_t tick = HAL_GetTick();
if (g_gameReaction.state == 0 && btn == BUTTON_SELECT) {
g_gameReaction.state = 1;
g_gameReaction.waitStart = tick;
g_gameReaction.ledOnTime = 1000 + (rand() % 4000);
Menu_Refresh();
}
else if (g_gameReaction.state == 2 && btn == BUTTON_SELECT) {
g_gameReaction.reactionTime = tick - g_gameReaction.waitStart;
g_gameReaction.state = 3;
Menu_Refresh();
}
else if ((g_gameReaction.state == 3) && (btn == BUTTON_SELECT))
{
g_gameReaction.state = 0;
}
}
static void Clicker_OnButton(Button_Type btn, bool longPress) {
if (longPress && btn == BUTTON_SELECT) {
Menu_OpenMenu(&g_rootMenu);
return;
}
if (btn == BUTTON_BACK) {
Menu_GoBack();
}
if (!g_gameClicker.active && !g_gameClicker.finished && btn == BUTTON_SELECT) {
g_gameClicker.active = true;
g_gameClicker.endTime = HAL_GetTick() + 10000;
g_gameClicker.clicks = 0;
Menu_Refresh();
}
else if (g_gameClicker.active && btn == BUTTON_UP) {
g_gameClicker.clicks++;
Menu_Refresh();
}
else if (g_gameClicker.finished && (btn == BUTTON_SELECT))
{
g_gameClicker.finished = 0;
g_gameClicker.active = 0;
}
}
static void TimeEdit_OnButton(Button_Type btn, bool longPress) {
(void)longPress;
switch (btn) {
case BUTTON_UP: {
uint8_t tens, units;
switch (g_timeData.editStep) {
case 0:
tens = g_timeData.editTime.hour / 10;
units = g_timeData.editTime.hour % 10;
tens = (tens + 1) % 3;
g_timeData.editTime.hour = tens * 10 + units;
break;
case 1:
tens = g_timeData.editTime.hour / 10;
units = (g_timeData.editTime.hour % 10 + 1) % 10;
if (tens == 2 && units > 3) units = 0;
g_timeData.editTime.hour = tens * 10 + units;
break;
case 2:
tens = (g_timeData.editTime.min / 10 + 1) % 6;
g_timeData.editTime.min = tens * 10 + (g_timeData.editTime.min % 10);
break;
case 3:
units = (g_timeData.editTime.min % 10 + 1) % 10;
g_timeData.editTime.min = (g_timeData.editTime.min / 10) * 10 + units;
break;
case 4:
tens = (g_timeData.editTime.sec / 10 + 1) % 6;
g_timeData.editTime.sec = tens * 10 + (g_timeData.editTime.sec % 10);
break;
case 5:
units = (g_timeData.editTime.sec % 10 + 1) % 10;
g_timeData.editTime.sec = (g_timeData.editTime.sec / 10) * 10 + units;
break;
}
Menu_Refresh();
break;
}
case BUTTON_DOWN: {
uint8_t tens, units;
switch (g_timeData.editStep) {
case 0:
tens = g_timeData.editTime.hour / 10;
units = g_timeData.editTime.hour % 10;
tens = (tens == 0) ? 2 : tens - 1;
g_timeData.editTime.hour = tens * 10 + units;
break;
case 1:
tens = g_timeData.editTime.hour / 10;
units = g_timeData.editTime.hour % 10;
if (units == 0) units = (tens == 2) ? 3 : 9;
else units--;
g_timeData.editTime.hour = tens * 10 + units;
break;
case 2:
tens = g_timeData.editTime.min / 10;
tens = (tens == 0) ? 5 : tens - 1;
g_timeData.editTime.min = tens * 10 + (g_timeData.editTime.min % 10);
break;
case 3:
units = g_timeData.editTime.min % 10;
units = (units == 0) ? 9 : units - 1;
g_timeData.editTime.min = (g_timeData.editTime.min / 10) * 10 + units;
break;
case 4:
tens = g_timeData.editTime.sec / 10;
tens = (tens == 0) ? 5 : tens - 1;
g_timeData.editTime.sec = tens * 10 + (g_timeData.editTime.sec % 10);
break;
case 5:
units = g_timeData.editTime.sec % 10;
units = (units == 0) ? 9 : units - 1;
g_timeData.editTime.sec = (g_timeData.editTime.sec / 10) * 10 + units;
break;
}
Menu_Refresh();
break;
}
case BUTTON_SELECT:
g_timeData.editStep++;
if (g_timeData.editStep >= 6) {
ClockManager_SetTime(g_timeData.editTime.hour,
g_timeData.editTime.min,
g_timeData.editTime.sec);
Menu_GoBack();
}
Menu_Refresh();
break;
case BUTTON_BACK:
Menu_GoBack();
default:
break;
}
}
static void DutyEdit_OnButton(Button_Type btn, bool longPress) {
(void)longPress;
switch (btn) {
case BUTTON_UP:
if (g_editDuty < 10) {
g_editDuty++;
Segment_SetBrightness(g_editDuty * 10);
Menu_Refresh();
}
break;
case BUTTON_DOWN:
if (g_editDuty > 0) {
g_editDuty--;
Segment_SetBrightness(g_editDuty * 10);
Menu_Refresh();
}
break;
case BUTTON_SELECT:
ClockManager_SetDuty(g_editDuty);
Menu_GoBack();
break;
case BUTTON_BACK:
ClockManager_SetDuty(g_originalDuty);
Menu_GoBack();
default:
break;
}
}
static void Reset_OnButton(Button_Type btn, bool longPress) {
if ((btn == BUTTON_SELECT) && longPress) {
ClockManager_ResetTime();
ClockManager_SetDuty(5);
Menu_GoBack();
}
}
// ==================== Узлы активностей (корень) ====================
MenuNode g_clockNode = {
.name = "CLOC",
.parent = NULL,
.children = NULL,
.childCount = 0,
.selectedChild = 0,
.display = Display_Clock,
.onEnter = OnEnter_Clock,
.onUpdate = NULL,
.onButton = Clock_OnButton,
.data = NULL
};
MenuNode g_timerNode = {
.name = "TIMER",
.parent = NULL,
.children = NULL,
.childCount = 0,
.selectedChild = 0,
.display = Display_Timer,
.onEnter = OnEnter_Timer,
.onUpdate = NULL,
.onButton = Timer_OnButton,
.data = NULL
};
MenuNode g_stopwatchNode = {
.name = "SECOND",
.parent = NULL,
.children = NULL,
.childCount = 0,
.selectedChild = 0,
.display = Display_Stopwatch,
.onEnter = OnEnter_Stopwatch,
.onUpdate = NULL,
.onButton = Stopwatch_OnButton,
.data = NULL
};
MenuNode g_ZeroMillisNode = {
.name = "00 SEC",
.parent = &g_gamesNode,
.children = NULL,
.childCount = 0,
.selectedChild = 0,
.needsRedraw = 1,
.display = Display_ZeroMillis,
.onEnter = OnEnter_ZeroMillis,
.onUpdate = NULL,
.onButton = ZeroMillis_OnButton,
.data = &g_game1sec
};
MenuNode g_ReactionTimeNode = {
.name = "CSTEST",
.parent = &g_gamesNode,
.children = NULL,
.childCount = 0,
.selectedChild = 0,
.display = Display_Reaction,
.onEnter = OnEnter_Reaction,
.onUpdate = OnUpdate_Reaction,
.onButton = Reaction_OnButton,
.data = &g_gameReaction
};
MenuNode g_ClickerTimeNode = {
.name = "CLICER",
.parent = &g_gamesNode,
.children = NULL,
.childCount = 0,
.selectedChild = 0,
.display = Display_Clicker,
.onEnter = OnEnter_Clicker,
.onUpdate = OnUpdate_Clicker,
.onButton = Clicker_OnButton,
.data = &g_gameClicker
};
// ==================== Узлы меню ====================
MenuNode g_gamesNode;
MenuNode g_settingsNode;
MenuNode g_timeEditNode;
MenuNode g_dutyEditNode;
MenuNode g_LEDEditNode;
MenuNode g_MenuSoundNode;
MenuNode g_PowerOnSongNode;
MenuNode g_SongNode;
MenuNode g_resetNode;
static MenuNode* g_gamesChildren[] = {
&g_ZeroMillisNode,
&g_ReactionTimeNode,
&g_ClickerTimeNode
};
static MenuNode* g_settingsChildren[] = {
&g_timeEditNode,
&g_dutyEditNode,
&g_LEDEditNode,
&g_MenuSoundNode,
&g_PowerOnSongNode,
&g_SongNode,
&g_resetNode
};
static MenuNode* g_mainMenuChildren[] = {
&g_clockNode,
&g_timerNode,
&g_stopwatchNode,
&g_gamesNode,
&g_settingsNode
};
static MenuNode g_rootMenu = {
.name = "MAIN",
.parent = NULL,
.children = g_mainMenuChildren,
.childCount = 5,
.selectedChild = 0,
.display = Display_MenuItem,
.onEnter = NULL,
.onUpdate = NULL,
.onButton = NULL,
.data = NULL
};
void MenuItems_Init(void) {
g_gamesNode = (MenuNode){
.name = "PLAY",
.parent = &g_rootMenu,
.children = g_gamesChildren,
.childCount = 3,
.selectedChild = 0,
.display = Display_MenuItem,
.onEnter = NULL,
.onUpdate = NULL,
.onButton = NULL,
.data = NULL
};
g_settingsNode = (MenuNode){
.name = "SETUP",
.parent = &g_rootMenu,
.children = g_settingsChildren,
.childCount = 7,
.selectedChild = 0,
.display = Display_MenuItem,
.onEnter = NULL,
.onUpdate = NULL,
.onButton = NULL,
.data = NULL
};
g_timeEditNode = (MenuNode){
.name = "SET T",
.parent = &g_settingsNode,
.children = NULL,
.childCount = 0,
.selectedChild = 0,
.display = Display_TimeEdit,
.onEnter = OnEnter_TimeEdit,
.onUpdate = OnUpdate_TimeEdit,
.onButton = TimeEdit_OnButton,
.data = &g_timeData
};
g_dutyEditNode = (MenuNode){
.name = "SET D",
.parent = &g_settingsNode,
.children = NULL,
.childCount = 0,
.selectedChild = 0,
.display = Display_DutyEdit,
.onEnter = OnEnter_DutyEdit,
.onUpdate = NULL,
.onButton = DutyEdit_OnButton,
.data = &g_editDuty
};
g_resetNode = (MenuNode){
.name = "RESET",
.parent = &g_settingsNode,
.children = NULL,
.childCount = 0,
.selectedChild = 0,
.display = Display_Reset,
.onEnter = OnEnter_Reset,
.onUpdate = NULL,
.onButton = Reset_OnButton,
.data = NULL
};
}
MenuNode* Menu_GetRootMenu(void) {
return &g_rootMenu;
}
MenuNode* Menu_GetCurrentActivity(void) {
return g_currentActivity;
}

19
Core/Clock/menu_items.h
View File

@@ -1,19 +0,0 @@
#ifndef MENU_ITEMS_H
#define MENU_ITEMS_H
#include "menu.h"
// Глобальные узлы меню (для доступа из main.c)
extern MenuNode g_clockNode;
extern MenuNode g_timerNode;
extern MenuNode g_stopwatchNode;
extern MenuNode g_gamesNode;
extern MenuNode g_settingsNode;
extern MenuNode g_timeEditNode;
extern MenuNode g_dutyEditNode;
extern MenuNode g_resetNode;
// Инициализация всех пунктов меню
void MenuItems_Init(void);
#endif

2
Core/Clock/notes.h
View File

@@ -158,4 +158,4 @@ typedef struct {
#define NOTE_REST 0
#endif
#endif

14
Core/Clock/segment.c
View File

@@ -13,13 +13,13 @@ volatile uint8_t GLOBAL_BRIGHTNESS = 100; // Глобальная ярко
#define SWAP_BIT5_BIT6(x) (((x) & 0x9F) | (((x) & 0x20) << 1) | (((x) & 0x40) >> 1))
// Макросы для быстрой работы с пинами (вместо HAL_GPIO_WritePin)
#define SET_SEGMENT_A(val) SEGMENT_A_GPIO_Port->BSRR = (SEGMENT_A_Pin << 16) | ((val) ? 0 : SEGMENT_A_Pin)
#define SET_SEGMENT_B(val) SEGMENT_B_GPIO_Port->BSRR = (SEGMENT_B_Pin << 16) | ((val) ? 0 : SEGMENT_B_Pin)
#define SET_SEGMENT_C(val) SEGMENT_C_GPIO_Port->BSRR = (SEGMENT_C_Pin << 16) | ((val) ? 0 : SEGMENT_C_Pin)
#define SET_SEGMENT_D(val) SEGMENT_D_GPIO_Port->BSRR = (SEGMENT_D_Pin << 16) | ((val) ? 0 : SEGMENT_D_Pin)
#define SET_SEGMENT_E(val) SEGMENT_E_GPIO_Port->BSRR = (SEGMENT_E_Pin << 16) | ((val) ? 0 : SEGMENT_E_Pin)
#define SET_SEGMENT_F(val) SEGMENT_F_GPIO_Port->BSRR = (SEGMENT_F_Pin << 16) | ((val) ? 0 : SEGMENT_F_Pin)
#define SET_SEGMENT_G(val) SEGMENT_G_GPIO_Port->BSRR = (SEGMENT_G_Pin << 16) | ((val) ? 0 : SEGMENT_G_Pin)
#define SET_SEGMENT_A(val) SEGMENT_A_GPIO_Port->BSRR = ((uint32_t)SEGMENT_A_Pin << 16) | ((val) ? 0 : SEGMENT_A_Pin)
#define SET_SEGMENT_B(val) SEGMENT_B_GPIO_Port->BSRR = ((uint32_t)SEGMENT_B_Pin << 16) | ((val) ? 0 : SEGMENT_B_Pin)
#define SET_SEGMENT_C(val) SEGMENT_C_GPIO_Port->BSRR = ((uint32_t)SEGMENT_C_Pin << 16) | ((val) ? 0 : SEGMENT_C_Pin)
#define SET_SEGMENT_D(val) SEGMENT_D_GPIO_Port->BSRR = ((uint32_t)SEGMENT_D_Pin << 16) | ((val) ? 0 : SEGMENT_D_Pin)
#define SET_SEGMENT_E(val) SEGMENT_E_GPIO_Port->BSRR = ((uint32_t)SEGMENT_E_Pin << 16) | ((val) ? 0 : SEGMENT_E_Pin)
#define SET_SEGMENT_F(val) SEGMENT_F_GPIO_Port->BSRR = ((uint32_t)SEGMENT_F_Pin << 16) | ((val) ? 0 : SEGMENT_F_Pin)
#define SET_SEGMENT_G(val) SEGMENT_G_GPIO_Port->BSRR = ((uint32_t)SEGMENT_G_Pin << 16) | ((val) ? 0 : SEGMENT_G_Pin)
// ==================== Таблица символов ====================
// Для общего анода: 0 - сегмент горит, 1 - сегмент не горит

2
Core/Clock/segment.h
View File

@@ -31,4 +31,4 @@ void Segment_SetBrightness(uint8_t percent);
// Вызывается каждые PROCESS_INTERVAL_US микросекунд или из таймера
void Segment_Process(void);
#endif
#endif

2
Core/Clock/songs.h
View File

@@ -123,4 +123,4 @@ static const Note_t Polyphia_PlayingGod_Notes[] = {
{SI2, NOTE_SIXTEENTH},
{MI3, NOTE_SIXTEENTH},
};
static Melody_t Polyphia_PlayingGod = {song_length(Polyphia_PlayingGod_Notes), Polyphia_PlayingGod_Notes};
static Melody_t Polyphia_PlayingGod = {song_length(Polyphia_PlayingGod_Notes), Polyphia_PlayingGod_Notes};

2
Core/Clock/sounds.h
View File

@@ -51,4 +51,4 @@ static const Note_t SFX_Alarm_Notes[] = {
{NOTE_REST, NOTE_EIGHTH},
{LA4, NOTE_EIGHTH}
};
static Melody_t SFX_Alarm = {song_length(SFX_Alarm_Notes), SFX_Alarm_Notes};
static Melody_t SFX_Alarm = {song_length(SFX_Alarm_Notes), SFX_Alarm_Notes};