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

Fixed probleb with copy assignment of settings in LEDRunner and DisplayHelper classes. Cleaned code up a bit.

Browse Source
This commit is contained in:
Author glitchrain
2024-12-15 03:30:30 -08:00
committed by s.aydarov
parent 031a19b107
commit 11b4909f39
8 changed files with 246 additions and 294 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Defines.h
View File

@@ -21,4 +21,8 @@
#define LONG_CLICK_TIME_MS 500 #define LONG_CLICK_TIME_MS 500
#define BTN_UP_SHORT_CLICKED 1
#define BTN_DOWN_SHORT_CLICKED -1
#define BTN_DOWN_UP_NO_SHORT_CLICKED 0
#endif #endif

50
DisplayDefines.h Normal file
View File

@@ -0,0 +1,50 @@
#ifndef EYE_TRAINER_DISPLAYDEFINES
#define EYE_TRAINER_DISPLAYDEFINES 0
#include <TM1637Display.h>
//SEG_A - Up
//SEG_B..SEG_F - Clockwise
//SEG_G - middle
#define NONE 0
#define A SEG_A | SEG_B | SEG_C | SEG_E | SEG_F | SEG_G
#define B SEG_F | SEG_C | SEG_D | SEG_E | SEG_G
#define C SEG_A | SEG_F | SEG_E | SEG_D
#define D SEG_B | SEG_C | SEG_D | SEG_E | SEG_G
#define E SEG_A | SEG_D | SEG_E | SEG_F | SEG_G
#define F SEG_A | SEG_F | SEG_G | SEG_E
#define G SEG_A | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G
#define H SEG_F | SEG_C | SEG_E | SEG_G
#define I SEG_B | SEG_C
#define J SEG_B | SEG_C | SEG_D
#define K SEG_A
#define L SEG_F | SEG_E | SEG_D
#define M SEG_C | SEG_G | SEG_E
#define N SEG_C | SEG_G | SEG_E
#define O SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F
#define P SEG_A | SEG_B | SEG_G | SEG_F | SEG_E
#define Q SEG_A | SEG_B | SEG_C | SEG_G | SEG_F
#define R SEG_E | SEG_G
#define S SEG_A | SEG_F | SEG_G | SEG_C | SEG_D
#define T SEG_F | SEG_E | SEG_D | SEG_G
#define U SEG_C | SEG_D | SEG_E
#define V SEG_C | SEG_D | SEG_E | SEG_F | SEG_B
#define W SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G
#define X SEG_B | SEG_C | SEG_E | SEG_F | SEG_G
#define Y SEG_F | SEG_G | SEG_B | SEG_C
#define Z SEG_A | SEG_B | SEG_G | SEG_E | SEG_D
#define WORD(a, b, c, d) (const uint8_t[]) {a, b, c, d}
#define WORD_DONE WORD( D, O, N, E )
#define WORD_RUN WORD( R, U, N, NONE )
#define WORD_MODE WORD( R, M, O, D )
#define WORD_TIME_SWITCH WORD( T, I, M, E )
#define WORD_TIME_MODE WORD( T, M, O, D )
#define WORD_BRIGHTNESS WORD( B, R, G, H )
#define WORD_TEST WORD( T, E, S, T )
#define WORD_ WORD( SEG_G, SEG_G, SEG_G, SEG_G )
#endif

124
DisplayHelper.h
View File

@@ -5,6 +5,7 @@
#include "Defines.h" #include "Defines.h"
#include "Settings.h" #include "Settings.h"
#include "Enums.h" #include "Enums.h"
#include "DisplayDefines.h"
class DisplayHelper class DisplayHelper
{ {
@@ -13,39 +14,6 @@ class DisplayHelper
public: public:
DisplayHelper() { } DisplayHelper() { }
DisplayHelper(Settings* _Settings)
{
m_Settings = _Settings;
}
static const uint8_t NONE = 0;
static const uint8_t A = SEG_A | SEG_B | SEG_C | SEG_E | SEG_F | SEG_G;
static const uint8_t B = SEG_F | SEG_C | SEG_D | SEG_E | SEG_G;
static const uint8_t C = SEG_A | SEG_F | SEG_E | SEG_D;
static const uint8_t D = SEG_B | SEG_C | SEG_D | SEG_E | SEG_G;
static const uint8_t E = SEG_A | SEG_D | SEG_E | SEG_F | SEG_G;
static const uint8_t F = SEG_A | SEG_F | SEG_G | SEG_E;
static const uint8_t G = SEG_A | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G;
static const uint8_t H = SEG_F | SEG_C | SEG_E | SEG_G;
static const uint8_t I = SEG_B | SEG_C;
static const uint8_t J = SEG_B | SEG_C | SEG_D;
static const uint8_t K = SEG_A;
static const uint8_t L = SEG_F | SEG_E | SEG_D;
static const uint8_t M = SEG_C | SEG_G | SEG_E;
static const uint8_t N = SEG_C | SEG_G | SEG_E;
static const uint8_t O = SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F;
static const uint8_t P = SEG_A | SEG_B | SEG_G | SEG_F | SEG_E;
static const uint8_t Q = SEG_G;
static const uint8_t R = SEG_E | SEG_G;
static const uint8_t S = SEG_A | SEG_F | SEG_G | SEG_C | SEG_D;
static const uint8_t T = SEG_F | SEG_E | SEG_D | SEG_G;
static const uint8_t U = SEG_C | SEG_D | SEG_E;
static const uint8_t V = SEG_C | SEG_D | SEG_E | SEG_F | SEG_B;
static const uint8_t W = SEG_D;
static const uint8_t X = SEG_B | SEG_C | SEG_E | SEG_F | SEG_G;
static const uint8_t Y = SEG_F | SEG_G | SEG_B | SEG_C;
static const uint8_t Z = SEG_A | SEG_B | SEG_G | SEG_E | SEG_D;
void setup() void setup()
{ {
@@ -53,34 +21,6 @@ public:
m_DrawTitle = true; m_DrawTitle = true;
} }
void buttonsTest()
{
bool btnMainState = digitalRead(PIN_BTN_MAIN);
bool btnUpState = digitalRead(PIN_BTN_UP);
bool btnDownState = digitalRead(PIN_BTN_DOWN);
int numChanged = currentTestNum;
if(btnMainState == HIGH)
{
numChanged = 0;
}
else if (btnUpState == HIGH)
{
numChanged++;
}
else if (btnDownState == HIGH)
{
numChanged--;
}
if(numChanged != currentTestNum)
{
currentTestNum = numChanged;
display.clear();
display.showNumberDec(currentTestNum, false);
}
}
void runTest() void runTest()
{ {
int k; int k;
@@ -188,6 +128,19 @@ public:
display.setSegments(WORD_DONE); display.setSegments(WORD_DONE);
} }
void UpdateModeDisplay(bool _RunnerActive, DeviceMode _DeviceMode)
{
switch(_DeviceMode)
{
case DeviceMode::RUN: DrawRunInfo(_RunnerActive); break;
case DeviceMode::SETTINGS_MODE: DrawSettingsRunModeInfo(); break;
case DeviceMode::SETTINGS_BRIGHTNESS: DrawSettingsBrightnessInfo(); break;
case DeviceMode::SETTINGS_TIME_SWITCH: DrawSettingsTimeSwitchInfo(); break;
case DeviceMode::SETTINGS_TIME_MODE: DrawSettingsTimeModeInfo(); break;
case DeviceMode::TEST: DrawTestInfo(); break;
}
}
void DrawRunInfo(bool _Run) void DrawRunInfo(bool _Run)
{ {
if(m_DrawTitle) if(m_DrawTitle)
@@ -196,15 +149,15 @@ public:
} }
else if(_Run) else if(_Run)
{ {
display.setSegments((const uint8_t[]) {P, L, A, Y}); display.setSegments(WORD(P, L, A, Y));
} }
else else
{ {
display.setSegments((const uint8_t[]) {P, A, U, S}); display.setSegments(WORD(P, A, U, S));
} }
} }
void DrawSettingsRunModeInfo(RunMode _RunMode) void DrawSettingsRunModeInfo()
{ {
if(m_DrawTitle) if(m_DrawTitle)
{ {
@@ -212,17 +165,17 @@ public:
} }
else else
{ {
switch(_RunMode) switch(Settings::getInstance().RunModeState)
{ {
case RunMode::FORWARD: display.setSegments((const uint8_t[]) { F, W, R, D }); break; case RunMode::FORWARD: display.setSegments(WORD(F, W, R, D )); break;
case RunMode::BACKWARD: display.setSegments((const uint8_t[]) { B, A, C, K }); break; case RunMode::BACKWARD: display.setSegments(WORD(B, A, C, K )); break;
case RunMode::BOTH: display.setSegments((const uint8_t[]) { B, O, T, H }); break; case RunMode::BOTH: display.setSegments(WORD(B, O, T, H )); break;
case RunMode::RANDOM: display.setSegments((const uint8_t[]) { R, N, D, NONE }); break; case RunMode::RANDOM: display.setSegments(WORD(R, N, D, NONE)); break;
} }
} }
} }
void DrawSettingsTimeSwitchInfo(int _SwitchTime) void DrawSettingsTimeSwitchInfo()
{ {
if(m_DrawTitle) if(m_DrawTitle)
{ {
@@ -230,11 +183,11 @@ public:
} }
else else
{ {
display.showNumberDec(_SwitchTime, false); display.showNumberDec(Settings::getInstance().getDisplaySwitchTime(), false);
} }
} }
void DrawSettingsTimeModeInfo(TimeMode _TimeMode) void DrawSettingsTimeModeInfo()
{ {
if(m_DrawTitle) if(m_DrawTitle)
{ {
@@ -242,16 +195,16 @@ public:
} }
else else
{ {
switch(_TimeMode) switch(Settings::getInstance().TimeModeState)
{ {
case TimeMode::CONST: display.setSegments((const uint8_t[]) { C, N, S, T }); break; case TimeMode::CONST: display.setSegments(WORD(C, N, S, T )); break;
case TimeMode::MANUAL: display.setSegments((const uint8_t[]) { M, A, N, L }); break; case TimeMode::MANUAL: display.setSegments(WORD(M, A, N, L )); break;
case TimeMode::DECREASING: display.setSegments((const uint8_t[]) { D, E, C, R }); break; case TimeMode::DECREASING: display.setSegments(WORD(D, E, C, R )); break;
} }
} }
} }
void DrawSettingsBrightnessInfo(int _Brightness) void DrawSettingsBrightnessInfo()
{ {
if(m_DrawTitle) if(m_DrawTitle)
{ {
@@ -259,7 +212,7 @@ public:
} }
else else
{ {
display.showNumberDec(_Brightness, false); display.showNumberDec(Settings::getInstance().Brightness, false);
} }
} }
@@ -280,22 +233,7 @@ public:
private: private:
TM1637Display display = TM1637Display::TM1637Display(PIN_DISPLAY_CLK, PIN_DISPLAY_DIO); TM1637Display display = TM1637Display::TM1637Display(PIN_DISPLAY_CLK, PIN_DISPLAY_DIO);
Settings* m_Settings;
int currentTestNum = 0; int currentTestNum = 0;
//seg A = upper ground
//seg B = upper right
//seg C = lower right
uint8_t WORD_DONE[4] = { D, O, N, E };
uint8_t WORD_RUN[4] = { R, U, N, NONE };
uint8_t WORD_MODE[4] = { R, M, O, D };
uint8_t WORD_TIME_SWITCH[4] = { T, I, M, E };
uint8_t WORD_TIME_MODE[4] = { T, M, O, D };
uint8_t WORD_BRIGHTNESS[4] = { B, R, G, H };
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; bool m_DrawTitle = true;
}; };

145
EyeTrainerMain.h
View File

@@ -4,6 +4,7 @@
#include "LEDRunner.h" #include "LEDRunner.h"
#include "InputHelper.h" #include "InputHelper.h"
#include "Enums.h" #include "Enums.h"
#include "WrapHelper.h"
class EyeTrainerMain class EyeTrainerMain
{ {
@@ -25,21 +26,23 @@ public:
if(inputEvent) if(inputEvent)
{ {
ProcessChangeMode();
int upDownButtonsShortClickState = m_InputHelper.GetUpDownButtonsShortClicked();
int upDownButtonsHoldState = m_InputHelper.GetUpDownButtonsHold();
switch(m_deviceMode) switch(m_deviceMode)
{ {
case DeviceMode::RUN: ProcessRun(); break; case DeviceMode::RUN: ProcessRun(upDownButtonsShortClickState, upDownButtonsHoldState); break;
case DeviceMode::SETTINGS_MODE: ProcessSettingsRunMode(); break; case DeviceMode::SETTINGS_MODE: ProcessSettingsRunMode(upDownButtonsShortClickState, upDownButtonsHoldState); break;
case DeviceMode::SETTINGS_TIME_SWITCH: ProcessSwitchTime(); break; case DeviceMode::SETTINGS_TIME_SWITCH: ProcessSwitchTime(upDownButtonsShortClickState, upDownButtonsHoldState); break;
case DeviceMode::SETTINGS_BRIGHTNESS: ProcessBrightness(); break; case DeviceMode::SETTINGS_BRIGHTNESS: ProcessBrightness(upDownButtonsShortClickState, upDownButtonsHoldState); break;
case DeviceMode::SETTINGS_TIME_MODE: ProcessTimeMode(); break; case DeviceMode::SETTINGS_TIME_MODE: ProcessTimeMode(upDownButtonsShortClickState, upDownButtonsHoldState); break;
case DeviceMode::TEST: ProcessTest(); break; case DeviceMode::TEST: ProcessTest(upDownButtonsShortClickState, upDownButtonsHoldState); break;
} }
} }
unsigned long currentTime = millis();
unsigned long deltaTime = millis() - m_PrevTime; unsigned long deltaTime = currentTime - m_PrevTime;
m_PrevTime = millis(); m_PrevTime = currentTime;
m_LEDRunner.update(deltaTime);
m_LEDRunner.update(deltaTime, m_Settings.SwitchTime, m_Settings.RunModeState, m_Settings.TimeModeState);
} }
void runTest() void runTest()
@@ -49,45 +52,16 @@ public:
} }
private: private:
static const uint8_t BTN_UP_SHORT_CLICKED = 1;
static const uint8_t BTN_DOWN_SHORT_CLICKED = -1;
static const uint8_t BTN_DOWN_UP_NO_SHORT_CLICKED = 0;
//==============================================================
//state
//==============================================================
enum DeviceMode m_deviceMode = DeviceMode::RUN; enum DeviceMode m_deviceMode = DeviceMode::RUN;
Settings m_Settings = Settings(); LEDRunner m_LEDRunner = LEDRunner();
LEDRunner m_LEDRunner = LEDRunner(&m_Settings); DisplayHelper m_DisplayHelper = DisplayHelper();
DisplayHelper m_DisplayHelper = DisplayHelper(&m_Settings);
InputHelper m_InputHelper = InputHelper(); InputHelper m_InputHelper = InputHelper();
unsigned long m_PrevTime = 0; unsigned long m_PrevTime = 0;
//============================================================== void UpdateModeDisplay()
//end of state
//==============================================================
int wrapInt(int _Num, int _Max)
{ {
if(_Num < 0) m_DisplayHelper.UpdateModeDisplay(m_LEDRunner.getRun(), m_deviceMode);
{
return (_Max + _Num % _Max);
}
if(_Num >= _Max)
{
return _Num % _Max;
}
return _Num;
}
int wrapInt(int _Num, int _Min, int _Max)
{
int num = _Num - _Min;
int max = _Max - _Min;
return wrapInt(num, max) + _Min;
} }
void ProcessChangeMode() void ProcessChangeMode()
@@ -105,44 +79,11 @@ private:
} }
} }
void UpdateModeDisplay() void ProcessRun(int upDownButtons, int upDownButtonsHold)
{ {
switch(m_deviceMode) if(Settings::getInstance().TimeModeState == TimeMode::MANUAL && upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED)
{ {
case DeviceMode::RUN: m_DisplayHelper.DrawRunInfo(m_LEDRunner.getRun()); break; m_LEDRunner.manualUpdate(Settings::getInstance().RunModeState, upDownButtons);
case DeviceMode::SETTINGS_MODE: m_DisplayHelper.DrawSettingsRunModeInfo(m_Settings.RunModeState); break;
case DeviceMode::SETTINGS_BRIGHTNESS: m_DisplayHelper.DrawSettingsBrightnessInfo(m_Settings.Brightness); break;
case DeviceMode::SETTINGS_TIME_SWITCH: m_DisplayHelper.DrawSettingsTimeSwitchInfo(m_Settings.SwitchTime / 10); break;
case DeviceMode::SETTINGS_TIME_MODE: m_DisplayHelper.DrawSettingsTimeModeInfo(m_Settings.TimeModeState); break;
case DeviceMode::TEST: m_DisplayHelper.DrawTestInfo(); break;
}
}
int GetUpDownButtonsShortClicked()
{
bool upButtonShortClicked = m_InputHelper.getButtonUp().IsNowShortClicked();
bool downButtonShortClicked = m_InputHelper.getButtonDown().IsNowShortClicked();
if(upButtonShortClicked)
return BTN_UP_SHORT_CLICKED;
else if(downButtonShortClicked)
return BTN_DOWN_SHORT_CLICKED;
return BTN_DOWN_UP_NO_SHORT_CLICKED;
}
int GetUpDownButtonsHold()
{
bool upButtonHold = m_InputHelper.getButtonUp().IsHolded();
bool downButtonHold = m_InputHelper.getButtonDown().IsHolded();
return (upButtonHold - downButtonHold);
}
void ProcessRun()
{
ProcessChangeMode();
int upDownButtons = GetUpDownButtonsShortClicked();
if(m_Settings.TimeModeState == TimeMode::MANUAL && upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED)
{
m_LEDRunner.manualUpdate(m_Settings.RunModeState, upDownButtons);
} }
else else
{ {
@@ -161,79 +102,65 @@ private:
} }
} }
void ProcessSettingsRunMode() void ProcessSettingsRunMode(int upDownButtons, int upDownButtonsHold)
{ {
ProcessChangeMode();
int upDownButtons = GetUpDownButtonsShortClicked();
if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED) if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED)
{ {
m_DisplayHelper.setDrawTitle(false); m_DisplayHelper.setDrawTitle(false);
m_Settings.switchRunMode(upDownButtons); Settings::getInstance().switchRunMode(upDownButtons);
UpdateModeDisplay(); UpdateModeDisplay();
} }
} }
void ProcessSwitchTime() void ProcessSwitchTime(int upDownButtons, int upDownButtonsHold)
{ {
ProcessChangeMode();
int upDownButtons = GetUpDownButtonsShortClicked();
int upDownHoldButtons = GetUpDownButtonsHold();
if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED) if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED)
{ {
m_DisplayHelper.setDrawTitle(false); m_DisplayHelper.setDrawTitle(false);
m_Settings.setSwitchTime(m_Settings.SwitchTime + upDownButtons * 50); Settings::getInstance().setSwitchTime(Settings::getInstance().SwitchTime + upDownButtons * 50);
UpdateModeDisplay(); UpdateModeDisplay();
} }
if(upDownHoldButtons != 0) if(upDownButtonsHold != 0)
{ {
m_DisplayHelper.setDrawTitle(false); m_DisplayHelper.setDrawTitle(false);
m_Settings.setSwitchTime(m_Settings.SwitchTime + upDownHoldButtons * 50); Settings::getInstance().setSwitchTime(Settings::getInstance().SwitchTime + upDownButtonsHold * 50);
UpdateModeDisplay(); UpdateModeDisplay();
} }
} }
void ProcessBrightness() void ProcessBrightness(int upDownButtons, int upDownButtonsHold)
{ {
ProcessChangeMode();
int upDownButtons = GetUpDownButtonsShortClicked();
int upDownHoldButtons = GetUpDownButtonsHold();
if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED) if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED)
{ {
m_LEDRunner.setAllHigh(); m_LEDRunner.setAllHigh();
m_DisplayHelper.setDrawTitle(false); m_DisplayHelper.setDrawTitle(false);
m_Settings.setBrightness(m_Settings.Brightness + upDownButtons); Settings::getInstance().setBrightness(Settings::getInstance().Brightness + upDownButtons);
m_LEDRunner.updateBrightness(m_Settings.Brightness); m_LEDRunner.updateBrightness(Settings::getInstance().Brightness);
UpdateModeDisplay(); UpdateModeDisplay();
} }
if(upDownHoldButtons != 0) if(upDownButtonsHold != 0)
{ {
m_LEDRunner.setAllHigh(); m_LEDRunner.setAllHigh();
m_DisplayHelper.setDrawTitle(false); m_DisplayHelper.setDrawTitle(false);
m_Settings.setBrightness(m_Settings.Brightness + upDownHoldButtons); Settings::getInstance().setBrightness(Settings::getInstance().Brightness + upDownButtonsHold);
m_LEDRunner.updateBrightness(m_Settings.Brightness); m_LEDRunner.updateBrightness(Settings::getInstance().Brightness);
UpdateModeDisplay(); UpdateModeDisplay();
} }
} }
void ProcessTimeMode() void ProcessTimeMode(int upDownButtons, int upDownButtonsHold)
{ {
ProcessChangeMode();
int upDownButtons = GetUpDownButtonsShortClicked();
if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED) if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED)
{ {
m_DisplayHelper.setDrawTitle(false); m_DisplayHelper.setDrawTitle(false);
m_Settings.switchTimeMode(upDownButtons); Settings::getInstance().switchTimeMode(upDownButtons);
UpdateModeDisplay(); UpdateModeDisplay();
} }
} }
void ProcessTest() void ProcessTest(int upDownButtons, int upDownButtonsHold)
{ {
ProcessChangeMode();
int upDownButtons = GetUpDownButtonsShortClicked();
if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED) if(upDownButtons != BTN_DOWN_UP_NO_SHORT_CLICKED)
{ {
runTest(); runTest();

20
InputHelper.h
View File

@@ -42,11 +42,29 @@ public:
return m_DownButton; return m_DownButton;
} }
int GetUpDownButtonsShortClicked()
{
bool upButtonShortClicked = m_UpButton.IsNowShortClicked();
bool downButtonShortClicked = m_DownButton.IsNowShortClicked();
if(upButtonShortClicked)
return BTN_UP_SHORT_CLICKED;
else if(downButtonShortClicked)
return BTN_DOWN_SHORT_CLICKED;
return BTN_DOWN_UP_NO_SHORT_CLICKED;
}
int GetUpDownButtonsHold()
{
bool upButtonHold = m_UpButton.IsHolded();
bool downButtonHold = m_DownButton.IsHolded();
return (upButtonHold - downButtonHold);
}
private: private:
bool m_InputEvent; bool m_InputEvent;
SimpleButton m_MainButton = SimpleButton(PIN_BTN_MAIN, LONG_CLICK_TIME_MS); SimpleButton m_MainButton = SimpleButton(PIN_BTN_MAIN, LONG_CLICK_TIME_MS);
SimpleButton m_UpButton = SimpleButton(PIN_BTN_UP, LONG_CLICK_TIME_MS); SimpleButton m_UpButton = SimpleButton(PIN_BTN_UP, LONG_CLICK_TIME_MS);
SimpleButton m_DownButton = SimpleButton(PIN_BTN_DOWN, LONG_CLICK_TIME_MS); SimpleButton m_DownButton = SimpleButton(PIN_BTN_DOWN, LONG_CLICK_TIME_MS);
}; };

132
LEDRunner.h
View File

@@ -10,14 +10,12 @@
#include "Defines.h" #include "Defines.h"
#include <ShiftRegister74HC595.h> #include <ShiftRegister74HC595.h>
#include "Settings.h" #include "Settings.h"
#include "WrapHelper.h"
class LEDRunner class LEDRunner
{ {
public: public:
LEDRunner(Settings* _Settings) LEDRunner() { }
{
this->m_Settings = _Settings;
}
void setup() void setup()
{ {
@@ -44,23 +42,23 @@ public:
void manualUpdate(RunMode _RunMode, int _NextLEDIndexIncrement) void manualUpdate(RunMode _RunMode, int _NextLEDIndexIncrement)
{ {
nextLED(_RunMode, _NextLEDIndexIncrement); nextLED(_RunMode, _NextLEDIndexIncrement);
sr.setAllLow(); m_LEDs.setAllLow();
sr.set(m_CurrentLED, HIGH); m_LEDs.set(m_CurrentLED, HIGH);
} }
void update(unsigned long _DeltaTime, int _SwitchTime, RunMode _RunMode, TimeMode _TimeMode) void update(unsigned long _DeltaTime)
{ {
if(!m_Run || _TimeMode == TimeMode::MANUAL) if(!m_Run || Settings::getInstance().TimeModeState == TimeMode::MANUAL)
return; return;
m_CurrentTime += _DeltaTime; m_CurrentTime += _DeltaTime;
if(m_CurrentTime > _SwitchTime) if(m_CurrentTime > Settings::getInstance().SwitchTime)
{ {
m_CurrentTime = 0; m_CurrentTime = 0;
nextLED(_RunMode, 1); nextLED(Settings::getInstance().RunModeState, 1);
sr.setAllLow(); m_LEDs.setAllLow();
sr.set(m_CurrentLED, HIGH); m_LEDs.set(m_CurrentLED, HIGH);
} }
} }
@@ -81,10 +79,6 @@ public:
void runTest() void runTest()
{ {
// // setting all pins at the same time to either HIGH or LOW
// sr.setAllHigh(); // set all pins HIGH
// delay(500);
analogWrite(PIN_LED_GND_BUS, 120); analogWrite(PIN_LED_GND_BUS, 120);
for(int i = 0; i < 4; i++) for(int i = 0; i < 4; i++)
@@ -95,13 +89,13 @@ public:
delay(250); // wait for a second delay(250); // wait for a second
} }
sr.setAllHigh(); m_LEDs.setAllHigh();
delay(500); delay(500);
sr.setAllLow(); m_LEDs.setAllLow();
delay(500); delay(500);
sr.setAllHigh(); m_LEDs.setAllHigh();
delay(500); delay(500);
sr.setAllLow(); m_LEDs.setAllLow();
delay(500); delay(500);
for(int i = 0; i < 4; i++) for(int i = 0; i < 4; i++)
@@ -117,29 +111,29 @@ public:
// setting single pins // setting single pins
for (int i = 0; i < MAX_LED_INDEX; i++) for (int i = 0; i < MAX_LED_INDEX; i++)
{ {
sr.set(i, HIGH); m_LEDs.set(i, HIGH);
delay(25); delay(25);
sr.set(i, LOW); m_LEDs.set(i, LOW);
} }
// setting single pins // setting single pins
for (int i = MAX_LED_INDEX; i > 0; i--) for (int i = MAX_LED_INDEX; i > 0; i--)
{ {
sr.set(i, HIGH); m_LEDs.set(i, HIGH);
delay(25); delay(25);
sr.set(i, LOW); m_LEDs.set(i, LOW);
} }
} }
sr.set(0, HIGH); m_LEDs.set(0, HIGH);
delay(50); delay(50);
for (int i = 0; i < MAX_LED_INDEX / 2; i++) for (int i = 0; i < MAX_LED_INDEX / 2; i++)
{ {
sr.set(i, HIGH); m_LEDs.set(i, HIGH);
sr.set(MAX_LED_INDEX - i, HIGH); m_LEDs.set(MAX_LED_INDEX - i, HIGH);
delay(150); delay(150);
sr.set(i, LOW); m_LEDs.set(i, LOW);
sr.set(MAX_LED_INDEX - i, LOW); m_LEDs.set(MAX_LED_INDEX - i, LOW);
} }
@@ -147,15 +141,15 @@ public:
{ {
for (int i = MAX_LED_INDEX / 2; i >= 0; i--) for (int i = MAX_LED_INDEX / 2; i >= 0; i--)
{ {
sr.set(i, HIGH); m_LEDs.set(i, HIGH);
sr.set(MAX_LED_INDEX - i, HIGH); m_LEDs.set(MAX_LED_INDEX - i, HIGH);
delay(50); delay(50);
sr.set(i, LOW); m_LEDs.set(i, LOW);
sr.set(MAX_LED_INDEX - i, LOW); m_LEDs.set(MAX_LED_INDEX - i, LOW);
} }
} }
sr.setAllHigh(); // set all pins HIGH m_LEDs.setAllHigh(); // set all pins HIGH
for(int i = 10; i > 0; i--) for(int i = 10; i > 0; i--)
{ {
@@ -168,81 +162,39 @@ public:
void blink(const uint8_t _LedIndex, unsigned long _Time) void blink(const uint8_t _LedIndex, unsigned long _Time)
{ {
sr.setAllLow(); m_LEDs.setAllLow();
sr.set(_LedIndex, HIGH); m_LEDs.set(_LedIndex, HIGH);
delay(_Time); delay(_Time);
sr.setAllLow(); m_LEDs.setAllLow();
} }
void setAndClearOthers(const uint8_t _LedIndex, const uint8_t _Value) void setAndClearOthers(const uint8_t _LedIndex, const uint8_t _Value)
{ {
sr.setAllLow(); m_LEDs.setAllLow();
sr.set(_LedIndex, _Value); m_LEDs.set(_LedIndex, _Value);
} }
void set(const uint8_t _LedIndex, const uint8_t _Value) void set(const uint8_t _LedIndex, const uint8_t _Value)
{ {
sr.set(_LedIndex, _Value); m_LEDs.set(_LedIndex, _Value);
} }
void setAllHigh() void setAllHigh()
{ {
sr.setAllHigh(); m_LEDs.setAllHigh();
} }
void setAllLow() void setAllLow()
{ {
sr.setAllLow(); m_LEDs.setAllLow();
} }
private: private:
Settings* m_Settings; bool m_Run = false;
bool m_Run = false; unsigned long m_CurrentTime = 0;
unsigned long m_CurrentTime = 0; int m_CurrentLED = 0;
int m_CurrentLED = 0; int m_CurrentLEDPingPong = 0;
int m_CurrentLEDPingPong = 0; ShiftRegister74HC595<REGISTER_SIZE> m_LEDs = ShiftRegister74HC595<REGISTER_SIZE>::ShiftRegister74HC595(PIN_LED_DATA, PIN_LED_CLOCK, PIN_LED_LATCH);
ShiftRegister74HC595<REGISTER_SIZE> sr = ShiftRegister74HC595<REGISTER_SIZE>::ShiftRegister74HC595(PIN_LED_DATA, PIN_LED_CLOCK, PIN_LED_LATCH);
int wrapInt(int _Num, int _Max)
{
if(_Num < 0)
{
return (_Max + _Num % _Max);
}
if(_Num >= _Max)
{
return _Num % _Max;
}
return _Num;
}
//Fix upper bounce (all LEDs are off)
int pingPong(int _Num, int _Max)
{
if(_Num < 0)
{
return (_Max + _Num % _Max);
}
if(_Num > _Max * 2)
{
return _Num % _Max;
}
if(_Num > _Max)
{
return _Max - _Num % _Max;
}
return _Num;
}
int wrapInt(int _Num, int _Min, int _Max)
{
int num = _Num - _Min;
int max = _Max - _Min;
return wrapInt(num, max) + _Min;
}
}; };
#endif #endif

21
Settings.h
View File

@@ -12,10 +12,24 @@ public:
int SwitchTime = 3000; //In milliseconds int SwitchTime = 3000; //In milliseconds
float Brightness = MAX_BRIGHTNESS / 2; float Brightness = MAX_BRIGHTNESS / 2;
Settings() //=======================================
//Singleton. AVOID COPY ASSIGNMENTS
//=======================================
static Settings& getInstance()
{ {
static Settings instance; // Guaranteed to be destroyed. Instantiated on first use.
return instance;
} }
Settings() {}
Settings(Settings const&) = delete;
void operator = (Settings const&) = delete;
//=======================================
//Singleton. AVOID COPY ASSIGNMENTS
//=======================================
void setSwitchTime(int _SwitchTime) void setSwitchTime(int _SwitchTime)
{ {
if(_SwitchTime > 15000) if(_SwitchTime > 15000)
@@ -67,6 +81,11 @@ public:
TimeModeState = static_cast<TimeMode>(wrapInt(static_cast<int>(TimeModeState) + _ModeIncrement, 3)); TimeModeState = static_cast<TimeMode>(wrapInt(static_cast<int>(TimeModeState) + _ModeIncrement, 3));
} }
int getDisplaySwitchTime()
{
return SwitchTime / 10;
}
private: private:
int wrapInt(int _Num, int _Max) int wrapInt(int _Num, int _Max)
{ {

44
WrapHelper.h Normal file
View File

@@ -0,0 +1,44 @@
#ifndef EYE_TRAINER_WRAPHELPER
#define EYE_TRAINER_WRAPHELPER 0
int wrapInt(int _Num, int _Max)
{
if(_Num < 0)
{
return (_Max + _Num % _Max);
}
if(_Num >= _Max)
{
return _Num % _Max;
}
return _Num;
}
//Fix upper bounce (all LEDs are off)
int pingPong(int _Num, int _Max)
{
if(_Num < 0)
{
return (_Max + _Num % _Max);
}
if(_Num > _Max * 2)
{
return _Num % _Max;
}
if(_Num > _Max)
{
return _Max - _Num % _Max;
}
return _Num;
}
int wrapInt(int _Num, int _Min, int _Max)
{
int num = _Num - _Min;
int max = _Max - _Min;
return wrapInt(num, max) + _Min;
}
#endif