glitchrain/eye_trainer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added manual mode and time mode settings.

Browse Source
This commit is contained in:
Author glitchrain
2024-12-15 01:07:28 -08:00
committed by s.aydarov
parent 7861a6d207
commit 031a19b107
6 changed files with 154 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
DisplayHelper.h
View File

@@ -50,6 +50,7 @@ public:
void setup() void setup()
{ {
display.setBrightness(0x0f); display.setBrightness(0x0f);
m_DrawTitle = true;
} }
void buttonsTest() void buttonsTest()
@@ -187,15 +188,15 @@ public:
display.setSegments(WORD_DONE); display.setSegments(WORD_DONE);
} }
void DrawRunInfo(bool _Title, bool _Run) void DrawRunInfo(bool _Run)
{ {
if(_Title) if(m_DrawTitle)
{ {
display.setSegments(WORD_RUN); display.setSegments(WORD_RUN);
} }
else if(_Run) else if(_Run)
{ {
display.setSegments((const uint8_t[]) {P, L, A, NONE}); display.setSegments((const uint8_t[]) {P, L, A, Y});
} }
else else
{ {
@@ -203,9 +204,9 @@ public:
} }
} }
void DrawSettingsRunModeInfo(bool _Title, RunMode _RunMode) void DrawSettingsRunModeInfo(RunMode _RunMode)
{ {
if(_Title) if(m_DrawTitle)
{ {
display.setSegments(WORD_MODE); display.setSegments(WORD_MODE);
} }
@@ -213,29 +214,46 @@ public:
{ {
switch(_RunMode) switch(_RunMode)
{ {
case RunMode::FORWARD: display.setSegments((const uint8_t[]) {F, W, R, D}); break; case RunMode::FORWARD: display.setSegments((const uint8_t[]) { F, W, R, D }); break;
case RunMode::BACKWARD: display.setSegments((const uint8_t[]) {B, A, C, K}); break; case RunMode::BACKWARD: display.setSegments((const uint8_t[]) { B, A, C, K }); break;
case RunMode::BOTH: display.setSegments((const uint8_t[]) {B, O, T, H}); break; case RunMode::BOTH: display.setSegments((const uint8_t[]) { B, O, T, H }); break;
case RunMode::RANDOM: display.setSegments((const uint8_t[]) {R, N, D, NONE}); break; case RunMode::RANDOM: display.setSegments((const uint8_t[]) { R, N, D, NONE }); break;
} }
} }
} }
void DrawSettingsTimeInfo(bool _Title, int _SwitchTime) void DrawSettingsTimeSwitchInfo(int _SwitchTime)
{ {
if(_Title) if(m_DrawTitle)
{ {
display.setSegments(WORD_TIME); display.setSegments(WORD_TIME_SWITCH);
} }
else else
{ {
display.showNumberDec(_SwitchTime, false); display.showNumberDec(_SwitchTime, false);
} }
} }
void DrawSettingsBrightnessInfo(bool _Title, int _Brightness) void DrawSettingsTimeModeInfo(TimeMode _TimeMode)
{ {
if(_Title) if(m_DrawTitle)
{
display.setSegments(WORD_TIME_MODE);
}
else
{
switch(_TimeMode)
{
case TimeMode::CONST: display.setSegments((const uint8_t[]) { C, N, S, T }); break;
case TimeMode::MANUAL: display.setSegments((const uint8_t[]) { M, A, N, L }); break;
case TimeMode::DECREASING: display.setSegments((const uint8_t[]) { D, E, C, R }); break;
}
}
}
void DrawSettingsBrightnessInfo(int _Brightness)
{
if(m_DrawTitle)
{ {
display.setSegments(WORD_BRIGHTNESS); display.setSegments(WORD_BRIGHTNESS);
} }
@@ -245,29 +263,20 @@ public:
} }
} }
void DrawTestInfo(bool _Title) void DrawTestInfo()
{ {
display.setSegments(WORD_TEST); display.setSegments(WORD_TEST);
} }
//DOES NOT WORK! void setDrawTitle(bool _Value)
// uint8_t* encodeNumber(uint8_t _Num) {
// { m_DrawTitle = _Value;
// uint8_t data[] = { 0xff, 0xff, 0xff, 0xff }; }
// // data[3] = display.encodeDigit(_Num % 10);
// // _Num = _Num / 10;
// // data[2] = display.encodeDigit(_Num % 10);
// // _Num = _Num / 10;
// // data[1] = display.encodeDigit(_Num % 10);
// // _Num = _Num / 10;
// // data[0] = display.encodeDigit(_Num % 10);
// data[3] = display.encodeDigit(1); void getDrawTitle()
// data[2] = display.encodeDigit(2); {
// data[1] = display.encodeDigit(3); return m_DrawTitle;
// data[0] = display.encodeDigit(4); }
// return data;
// }
private: private:
TM1637Display display = TM1637Display::TM1637Display(PIN_DISPLAY_CLK, PIN_DISPLAY_DIO); TM1637Display display = TM1637Display::TM1637Display(PIN_DISPLAY_CLK, PIN_DISPLAY_DIO);
@@ -278,13 +287,16 @@ private:
//seg B = upper right //seg B = upper right
//seg C = lower right //seg C = lower right
uint8_t WORD_DONE[4] = { D, O, N, E }; uint8_t WORD_DONE[4] = { D, O, N, E };
uint8_t WORD_RUN[4] = { R, U, N, NONE }; uint8_t WORD_RUN[4] = { R, U, N, NONE };
uint8_t WORD_MODE[4] = { M, O, D, E }; uint8_t WORD_MODE[4] = { R, M, O, D };
uint8_t WORD_TIME[4] = { T, I, M, E }; uint8_t WORD_TIME_SWITCH[4] = { T, I, M, E };
uint8_t WORD_BRIGHTNESS[4] = { B, R, G, H }; uint8_t WORD_TIME_MODE[4] = { T, M, O, D };
uint8_t WORD_TEST[4] = { T, E, S, T }; uint8_t WORD_BRIGHTNESS[4] = { B, R, G, H };
uint8_t WORD_[4] = { SEG_G, SEG_G, SEG_G, SEG_G }; uint8_t WORD_TEST[4] = { T, E, S, T };
uint8_t WORD_[4] = { SEG_G, SEG_G, SEG_G, SEG_G };
bool m_DrawTitle = true;
}; };
#endif #endif

5
Enums.h
View File

@@ -6,7 +6,8 @@ enum DeviceMode
RUN = 0, RUN = 0,
SETTINGS_MODE, SETTINGS_MODE,
SETTINGS_BRIGHTNESS, SETTINGS_BRIGHTNESS,
SETTINGS_TIME, SETTINGS_TIME_SWITCH,
SETTINGS_TIME_MODE,
TEST TEST
}; };
@@ -22,7 +23,7 @@ enum TimeMode
{ {
CONST = 0, CONST = 0,
MANUAL, MANUAL,
DECREASING DECREASING // not implemented
}; };
#endif #endif

115
EyeTrainerMain.h
View File

@@ -8,23 +8,6 @@
class EyeTrainerMain class EyeTrainerMain
{ {
public: public:
//==============================================================
//state
//==============================================================
enum DeviceMode m_deviceMode = DeviceMode::RUN;
Settings m_Settings = Settings();
LEDRunner m_LEDRunner = LEDRunner(&m_Settings);
DisplayHelper m_DisplayHelper = DisplayHelper(&m_Settings);
InputHelper m_InputHelper = InputHelper();
bool m_DrawTitle = true;
unsigned long m_PrevTime = 0;
//==============================================================
//end of state
//==============================================================
EyeTrainerMain() { } EyeTrainerMain() { }
void setup() void setup()
@@ -39,20 +22,24 @@ public:
void loop() void loop()
{ {
bool inputEvent = m_InputHelper.readInputs(millis()); bool inputEvent = m_InputHelper.readInputs(millis());
switch(m_deviceMode) if(inputEvent)
{ {
case DeviceMode::RUN: ProcessRun(); break; switch(m_deviceMode)
case DeviceMode::SETTINGS_MODE: ProcessSettingsRunMode(); break; {
case DeviceMode::SETTINGS_TIME: ProcessSwitchTime(); break; case DeviceMode::RUN: ProcessRun(); break;
case DeviceMode::SETTINGS_BRIGHTNESS: ProcessBrightness(); break; case DeviceMode::SETTINGS_MODE: ProcessSettingsRunMode(); break;
case DeviceMode::TEST: ProcessTest(); break; case DeviceMode::SETTINGS_TIME_SWITCH: ProcessSwitchTime(); break;
case DeviceMode::SETTINGS_BRIGHTNESS: ProcessBrightness(); break;
case DeviceMode::SETTINGS_TIME_MODE: ProcessTimeMode(); break;
case DeviceMode::TEST: ProcessTest(); break;
}
} }
unsigned long deltaTime = millis() - m_PrevTime; unsigned long deltaTime = millis() - m_PrevTime;
m_PrevTime = millis(); m_PrevTime = millis();
m_LEDRunner.update(deltaTime, m_Settings.SwitchTime, m_Settings.m_RunMode, m_Settings.m_TimeMode); m_LEDRunner.update(deltaTime, m_Settings.SwitchTime, m_Settings.RunModeState, m_Settings.TimeModeState);
} }
void runTest() void runTest()
@@ -62,11 +49,26 @@ public:
} }
private: private:
static const uint8_t BTN_UP_SHORT_CLICKED = 1; static const uint8_t BTN_UP_SHORT_CLICKED = 1;
static const uint8_t BTN_DOWN_SHORT_CLICKED = -1; static const uint8_t BTN_DOWN_SHORT_CLICKED = -1;
static const uint8_t BTN_DOWN_UP_NO_SHORT_CLICKED = 0; static const uint8_t BTN_DOWN_UP_NO_SHORT_CLICKED = 0;
//==============================================================
//state
//==============================================================
enum DeviceMode m_deviceMode = DeviceMode::RUN;
Settings m_Settings = Settings();
LEDRunner m_LEDRunner = LEDRunner(&m_Settings);
DisplayHelper m_DisplayHelper = DisplayHelper(&m_Settings);
InputHelper m_InputHelper = InputHelper();
unsigned long m_PrevTime = 0;
//==============================================================
//end of state
//==============================================================
int wrapInt(int _Num, int _Max) int wrapInt(int _Num, int _Max)
{ {
if(_Num < 0) if(_Num < 0)
@@ -94,8 +96,8 @@ private:
if(!mainButtonShortClicked) if(!mainButtonShortClicked)
return; return;
m_DrawTitle = true; m_DisplayHelper.setDrawTitle(true);
m_deviceMode = static_cast<DeviceMode>(wrapInt(static_cast<int>(m_deviceMode) + 1, 5)); m_deviceMode = static_cast<DeviceMode>(wrapInt(static_cast<int>(m_deviceMode) + 1, 6));
UpdateModeDisplay(); UpdateModeDisplay();
if(m_deviceMode != DeviceMode::RUN) if(m_deviceMode != DeviceMode::RUN)
{ {
@@ -107,18 +109,19 @@ private:
{ {
switch(m_deviceMode) switch(m_deviceMode)
{ {
case DeviceMode::RUN: m_DisplayHelper.DrawRunInfo(m_DrawTitle, m_LEDRunner.getRun()); break; case DeviceMode::RUN: m_DisplayHelper.DrawRunInfo(m_LEDRunner.getRun()); break;
case DeviceMode::SETTINGS_MODE: m_DisplayHelper.DrawSettingsRunModeInfo(m_DrawTitle, m_Settings.m_RunMode); break; case DeviceMode::SETTINGS_MODE: m_DisplayHelper.DrawSettingsRunModeInfo(m_Settings.RunModeState); break;
case DeviceMode::SETTINGS_TIME: m_DisplayHelper.DrawSettingsTimeInfo(m_DrawTitle, m_Settings.SwitchTime / 10); break; case DeviceMode::SETTINGS_BRIGHTNESS: m_DisplayHelper.DrawSettingsBrightnessInfo(m_Settings.Brightness); break;
case DeviceMode::SETTINGS_BRIGHTNESS: m_DisplayHelper.DrawSettingsBrightnessInfo(m_DrawTitle, m_Settings.Brightness); break; case DeviceMode::SETTINGS_TIME_SWITCH: m_DisplayHelper.DrawSettingsTimeSwitchInfo(m_Settings.SwitchTime / 10); break;
case DeviceMode::TEST: m_DisplayHelper.DrawTestInfo(m_DrawTitle); break; case DeviceMode::SETTINGS_TIME_MODE: m_DisplayHelper.DrawSettingsTimeModeInfo(m_Settings.TimeModeState); break;
case DeviceMode::TEST: m_DisplayHelper.DrawTestInfo(); break;
} }
} }
int GetUpDownButtonsShortClicked() int GetUpDownButtonsShortClicked()
{ {
bool upButtonShortClicked = m_InputHelper.getButtonUp().IsNowShortClicked(); bool upButtonShortClicked = m_InputHelper.getButtonUp().IsNowShortClicked();
bool downButtonShortClicked = m_InputHelper.getButtonUp().IsNowShortClicked(); bool downButtonShortClicked = m_InputHelper.getButtonDown().IsNowShortClicked();
if(upButtonShortClicked) if(upButtonShortClicked)
return BTN_UP_SHORT_CLICKED; return BTN_UP_SHORT_CLICKED;
else if(downButtonShortClicked) else if(downButtonShortClicked)
@@ -133,20 +136,28 @@ private:
return (upButtonHold - downButtonHold); return (upButtonHold - downButtonHold);
} }
//TODO: FIX BUG HERE: display is not updated.
void ProcessRun() void ProcessRun()
{ {
ProcessChangeMode(); ProcessChangeMode();
int upDownButtons = GetUpDownButtonsShortClicked(); int upDownButtons = GetUpDownButtonsShortClicked();
if(upDownButtons == BTN_UP_SHORT_CLICKED) if(m_Settings.TimeModeState == TimeMode::MANUAL && upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED)
{ {
m_LEDRunner.setRun(true); m_LEDRunner.manualUpdate(m_Settings.RunModeState, upDownButtons);
UpdateModeDisplay();
} }
if(upDownButtons == BTN_DOWN_SHORT_CLICKED) else
{ {
m_LEDRunner.setRun(false); if(upDownButtons == BTN_UP_SHORT_CLICKED)
UpdateModeDisplay(); {
m_DisplayHelper.setDrawTitle(false);
m_LEDRunner.setRun(true);
UpdateModeDisplay();
}
if(upDownButtons == BTN_DOWN_SHORT_CLICKED)
{
m_DisplayHelper.setDrawTitle(false);
m_LEDRunner.setRun(false);
UpdateModeDisplay();
}
} }
} }
@@ -156,7 +167,7 @@ private:
int upDownButtons = GetUpDownButtonsShortClicked(); int upDownButtons = GetUpDownButtonsShortClicked();
if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED) if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED)
{ {
m_DrawTitle = false; m_DisplayHelper.setDrawTitle(false);
m_Settings.switchRunMode(upDownButtons); m_Settings.switchRunMode(upDownButtons);
UpdateModeDisplay(); UpdateModeDisplay();
} }
@@ -170,13 +181,13 @@ private:
int upDownHoldButtons = GetUpDownButtonsHold(); int upDownHoldButtons = GetUpDownButtonsHold();
if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED) if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED)
{ {
m_DrawTitle = false; m_DisplayHelper.setDrawTitle(false);
m_Settings.setSwitchTime(m_Settings.SwitchTime + upDownButtons * 50); m_Settings.setSwitchTime(m_Settings.SwitchTime + upDownButtons * 50);
UpdateModeDisplay(); UpdateModeDisplay();
} }
if(upDownHoldButtons != 0) if(upDownHoldButtons != 0)
{ {
m_DrawTitle = false; m_DisplayHelper.setDrawTitle(false);
m_Settings.setSwitchTime(m_Settings.SwitchTime + upDownHoldButtons * 50); m_Settings.setSwitchTime(m_Settings.SwitchTime + upDownHoldButtons * 50);
UpdateModeDisplay(); UpdateModeDisplay();
} }
@@ -191,7 +202,7 @@ private:
if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED) if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED)
{ {
m_LEDRunner.setAllHigh(); m_LEDRunner.setAllHigh();
m_DrawTitle = false; m_DisplayHelper.setDrawTitle(false);
m_Settings.setBrightness(m_Settings.Brightness + upDownButtons); m_Settings.setBrightness(m_Settings.Brightness + upDownButtons);
m_LEDRunner.updateBrightness(m_Settings.Brightness); m_LEDRunner.updateBrightness(m_Settings.Brightness);
UpdateModeDisplay(); UpdateModeDisplay();
@@ -200,13 +211,25 @@ private:
if(upDownHoldButtons != 0) if(upDownHoldButtons != 0)
{ {
m_LEDRunner.setAllHigh(); m_LEDRunner.setAllHigh();
m_DrawTitle = false; m_DisplayHelper.setDrawTitle(false);
m_Settings.setBrightness(m_Settings.Brightness + upDownHoldButtons); m_Settings.setBrightness(m_Settings.Brightness + upDownHoldButtons);
m_LEDRunner.updateBrightness(m_Settings.Brightness); m_LEDRunner.updateBrightness(m_Settings.Brightness);
UpdateModeDisplay(); UpdateModeDisplay();
} }
} }
void ProcessTimeMode()
{
ProcessChangeMode();
int upDownButtons = GetUpDownButtonsShortClicked();
if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED)
{
m_DisplayHelper.setDrawTitle(false);
m_Settings.switchTimeMode(upDownButtons);
UpdateModeDisplay();
}
}
void ProcessTest() void ProcessTest()
{ {
ProcessChangeMode(); ProcessChangeMode();

1
EyeTrainer_1.ino
View File

@@ -1,4 +1,3 @@
#include "EyeTrainerMain.h" #include "EyeTrainerMain.h"
EyeTrainerMain m_EyeTrainerMain; EyeTrainerMain m_EyeTrainerMain;

29
LEDRunner.h
View File

@@ -1,3 +1,6 @@
#ifndef EYE_TRAINER_LEDRUNNER
#define EYE_TRAINER_LEDRUNNER 0
/* /*
ShiftRegister74HC595 - Library for simplified control of 74HC595 shift registers. ShiftRegister74HC595 - Library for simplified control of 74HC595 shift registers.
Developed and maintained by Timo Denk and contributers, since Nov 2014. Developed and maintained by Timo Denk and contributers, since Nov 2014.
@@ -11,10 +14,6 @@
class LEDRunner class LEDRunner
{ {
public: public:
// LEDRunner()
// {
// }
LEDRunner(Settings* _Settings) LEDRunner(Settings* _Settings)
{ {
this->m_Settings = _Settings; this->m_Settings = _Settings;
@@ -28,24 +27,30 @@ public:
pinMode(PIN_LED_LATCH, OUTPUT); pinMode(PIN_LED_LATCH, OUTPUT);
} }
void nextLED(RunMode _RunMode) void nextLED(RunMode _RunMode, int _NextLEDIndexIncrement)
{ {
switch(_RunMode) switch(_RunMode)
{ {
case RunMode::FORWARD: m_CurrentLED = wrapInt(m_CurrentLED + 1, MAX_LED_INDEX + 1); break; case RunMode::FORWARD: m_CurrentLED = wrapInt(m_CurrentLED + _NextLEDIndexIncrement, MAX_LED_INDEX + 1); break;
case RunMode::BACKWARD: m_CurrentLED = wrapInt(m_CurrentLED - 1, MAX_LED_INDEX + 1); break; case RunMode::BACKWARD: m_CurrentLED = wrapInt(m_CurrentLED - _NextLEDIndexIncrement, MAX_LED_INDEX + 1); break;
//TODO: ADD PING PONG
case RunMode::BOTH: case RunMode::BOTH:
m_CurrentLEDPingPong = wrapInt(m_CurrentLEDPingPong + 1, (MAX_LED_INDEX + 1) * 2); m_CurrentLEDPingPong = wrapInt(m_CurrentLEDPingPong + _NextLEDIndexIncrement, (MAX_LED_INDEX + 1) * 2);
m_CurrentLED = pingPong(m_CurrentLEDPingPong, MAX_LED_INDEX + 1); m_CurrentLED = pingPong(m_CurrentLEDPingPong, MAX_LED_INDEX + 1);
break; break;
case RunMode::RANDOM: m_CurrentLED = random(0, MAX_LED_INDEX + 1); break; case RunMode::RANDOM: m_CurrentLED = random(0, MAX_LED_INDEX + 1); break;
} }
} }
void manualUpdate(RunMode _RunMode, int _NextLEDIndexIncrement)
{
nextLED(_RunMode, _NextLEDIndexIncrement);
sr.setAllLow();
sr.set(m_CurrentLED, HIGH);
}
void update(unsigned long _DeltaTime, int _SwitchTime, RunMode _RunMode, TimeMode _TimeMode) void update(unsigned long _DeltaTime, int _SwitchTime, RunMode _RunMode, TimeMode _TimeMode)
{ {
if(!m_Run) if(!m_Run || _TimeMode == TimeMode::MANUAL)
return; return;
m_CurrentTime += _DeltaTime; m_CurrentTime += _DeltaTime;
@@ -53,7 +58,7 @@ public:
if(m_CurrentTime > _SwitchTime) if(m_CurrentTime > _SwitchTime)
{ {
m_CurrentTime = 0; m_CurrentTime = 0;
nextLED(_RunMode); nextLED(_RunMode, 1);
sr.setAllLow(); sr.setAllLow();
sr.set(m_CurrentLED, HIGH); sr.set(m_CurrentLED, HIGH);
} }
@@ -239,3 +244,5 @@ public:
return wrapInt(num, max) + _Min; return wrapInt(num, max) + _Min;
} }
}; };
#endif

40
Settings.h
View File

@@ -7,11 +7,10 @@
class Settings class Settings
{ {
public: public:
enum RunMode m_RunMode = RunMode::RANDOM; enum RunMode RunModeState = RunMode::RANDOM;
enum TimeMode m_TimeMode = TimeMode::CONST; enum TimeMode TimeModeState = TimeMode::CONST;
int SwitchTime = 3000; //In milliseconds int SwitchTime = 3000; //In milliseconds
// float Brightness = MAX_BRIGHTNESS; float Brightness = MAX_BRIGHTNESS / 2;
float Brightness = 195;
Settings() Settings()
{ {
@@ -50,38 +49,23 @@ public:
void resetRunMode(RunMode _RunMode) void resetRunMode(RunMode _RunMode)
{ {
m_RunMode = RunMode::FORWARD; RunModeState = RunMode::FORWARD;
} }
void switchRunMode(int _NextOrBack) void switchRunMode(int _ModeIncrement)
{ {
if(m_RunMode == RunMode::FORWARD) RunModeState = static_cast<RunMode>(wrapInt(static_cast<int>(RunModeState) + _ModeIncrement, 4));
{
m_RunMode = RunMode::BACKWARD;
}
else if(m_RunMode == RunMode::BACKWARD)
{
m_RunMode = RunMode::BOTH;
}
else if(m_RunMode == RunMode::BOTH)
{
m_RunMode = RunMode::RANDOM;
}
else if(m_RunMode == RunMode::RANDOM)
{
m_RunMode = RunMode::FORWARD;
}
// RunMode newRunMode = static_cast<RunMode>(wrapInt(static_cast<int>(m_RunMode) + _NextOrBack, 4));
// m_RunMode = newRunMode;
} }
void setTimeMode(enum TimeMode _TimeMode) void setTimeMode(enum TimeMode _TimeMode)
{ {
m_TimeMode = _TimeMode; TimeModeState = _TimeMode;
} }
void switchTimeMode(int _ModeIncrement)
{
TimeModeState = static_cast<TimeMode>(wrapInt(static_cast<int>(TimeModeState) + _ModeIncrement, 3));
}
private: private:
int wrapInt(int _Num, int _Max) int wrapInt(int _Num, int _Max)