Skip to content

Commit b288fa2

Browse files
dbambusdbambus
authored
Merge pull request #607 from dbambus/main
Updated Frame handling
2 parents ef1ac0b + e3e1db0 commit b288fa2

File tree

12 files changed

+233
-130
lines changed

12 files changed

+233
-130
lines changed

‎include/Transitiontypes/Transition.h‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -169,7 +169,6 @@ class Transition {
169169
void saveMatrix();
170170
void analyzeColors(RgbfColor **dest, RgbfColor **source,
171171
RgbfColor &foreground, RgbfColor &background);
172-
void setMinute(void);
173172
void copy2Stripe(RgbfColor **source);
174173
void copyMatrix(RgbfColor **dest, RgbfColor **source);
175174
void copyMatrixFlags(RgbfColor **dest, RgbfColor **source);

‎include/Transitiontypes/Transition.hpp‎

Lines changed: 6 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -469,25 +469,6 @@ void Transition::analyzeColors(RgbfColor **dest, RgbfColor **source,
469469
}
470470
}
471471

472-
//------------------------------------------------------------------------------
473-
474-
void Transition::setMinute() {
475-
if (G.minuteVariant != MinuteVariant::Off) {
476-
uint8_t m = lastMinute % 5;
477-
uint16_t minArray[4];
478-
usedUhrType->getMinuteArray(minArray,
479-
clockWork.determineWhichMinuteVariant());
480-
if (G.layoutVariant[ReverseMinDirection]) {
481-
std::reverse(std::begin(minArray), std::end(minArray));
482-
}
483-
for (uint8_t i = 0; i < 4; i++) {
484-
led.setPixel(minArray[i],
485-
HsbColor{m > i ? foregroundMinute : background});
486-
// TODO: fading transition for Minutes
487-
}
488-
}
489-
}
490-
491472
//------------------------------------------------------------------------------
492473
// Overwrite the LEDs with internal matrix
493474

@@ -1302,9 +1283,13 @@ void Transition::loop(struct tm &tm) {
13021283
transitionColorChange();
13031284
copy2Stripe(work);
13041285
if (!specialEvent) {
1305-
setMinute();
1286+
1287+
if (G.minuteVariant != MinuteVariant::Off) {
1288+
led.setbyMinuteArray(Foreground);
1289+
}
1290+
13061291
if (G.secondVariant != SecondVariant::Off) {
1307-
led.setbySecondArray();
1292+
led.setbySecondArray(Frame);
13081293
// Workaround: setbySecondArray not in 'work'
13091294
}
13101295
}

‎include/Uhrtypes/DE11x11.v3.hpp‎

Lines changed: 32 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,11 +17,42 @@
1717
* 7 | E L F N E U N V I E R
1818
* 8 | W A C H T Z E H N R S
1919
* 9 | B S E C H S F M U H R
20-
* X | E V F X R N Z S L P I
20+
* X | E V * X * N * S * P I
2121
*/
2222

2323
class De11x11V3_t : public De11x11_t {
2424
public:
25+
virtual const void getMinuteArray(uint16_t *returnArr,
26+
uint8_t col) override {
27+
28+
uint16_t numPixelsWordMatrix = rowsWordMatrix() * colsWordMatrix();
29+
30+
if (G.buildTypeDef == BuildTypeDef::DoubleResM1) {
31+
numPixelsWordMatrix = rowsWordMatrix() * (colsWordMatrix() * 2 - 1);
32+
}
33+
34+
for (uint8_t i = 0; i < 4; i++) {
35+
switch (col) {
36+
case 0: // LEDs for "LED4x" minute display
37+
returnArr[i] = 3 + (i * 2); // 3,5,7,9
38+
break;
39+
40+
case 1: // LEDs for "LED7x" minute display
41+
returnArr[i] = 113 + (i * 2); // 3,5,7,9
42+
break;
43+
44+
case 2: // LEDs für "Corners" type minute display
45+
returnArr[i] = numPixelsWordMatrix + i;
46+
break;
47+
48+
default:
49+
break;
50+
}
51+
}
52+
};
53+
54+
//------------------------------------------------------------------------------
55+
2556
void show(FrontWord word) override {
2657
switch (word) {
2758

‎include/Uhrtypes/Uhrtype.hpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -208,6 +208,7 @@ class iUhrType {
208208

209209
virtual const uint16_t getFrontMatrixIndex(uint8_t row, uint8_t col) {
210210

211+
uint16_t returnValue;
211212
uint8_t newColsWordMatrix = colsWordMatrix();
212213
uint16_t numPixelsWordMatrix = rowsWordMatrix() * colsWordMatrix();
213214

@@ -217,7 +218,6 @@ class iUhrType {
217218
col *= 2;
218219
}
219220

220-
uint16_t returnValue;
221221
if (G.layoutVariant[FlipHorzVert] == false) {
222222
if (G.layoutVariant[MeanderRows] && (row % 2 != 0)) {
223223
col = newColsWordMatrix - col - 1;

‎include/clockWork.hpp‎

Lines changed: 5 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1122,7 +1122,7 @@ void ClockWork::loop(struct tm &tm) {
11221122
transition->demoMode(_hour, _minute, _second);
11231123

11241124
//------------------------------------------------
1125-
// Secounds and LDR Routine
1125+
// Seconds and LDR Routine
11261126
//------------------------------------------------
11271127
if (lastSecond != _second) {
11281128

@@ -1146,7 +1146,7 @@ void ClockWork::loop(struct tm &tm) {
11461146
loopAutoBrightLogic();
11471147
}
11481148

1149-
if (G.prog == COMMAND_IDLE && G.conf == 0) {
1149+
if (G.prog == COMMAND_IDLE && G.conf == COMMAND_IDLE) {
11501150
led.clear();
11511151
G.prog = COMMAND_MODE_WORD_CLOCK;
11521152
}
@@ -1373,28 +1373,20 @@ void ClockWork::loop(struct tm &tm) {
13731373
case COMMAND_SET_MINUTE:
13741374
case COMMAND_SET_BRIGHTNESS:
13751375
case COMMAND_SET_AUTO_BRIGHT:
1376-
case COMMAND_SET_LANGUAGE_VARIANT:
13771376
case COMMAND_SET_WHITETYPE:
1378-
case COMMAND_SET_TIME_MANUAL: {
1379-
eeprom::write();
1380-
led.clear();
1381-
memset(frameArray, false, sizeof(frameArray));
1382-
parametersChanged = true;
1383-
break;
1384-
}
1385-
1377+
case COMMAND_SET_TIME_MANUAL:
13861378
case COMMAND_SET_LAYOUT_VARIANT: {
13871379
eeprom::write();
13881380
led.clear();
13891381
memset(frameArray, false, sizeof(frameArray));
1390-
layoutChanged = true;
1382+
parametersChanged = true;
13911383
break;
13921384
}
13931385

1386+
case COMMAND_SET_LANGUAGE_VARIANT:
13941387
case COMMAND_SET_SETTING_SECOND: {
13951388
eeprom::write();
13961389
led.clear();
1397-
memset(frameArray, false, sizeof(frameArray));
13981390
G.progInit = true;
13991391
parametersChanged = true;
14001392
break;

‎include/frame.h‎

Lines changed: 135 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -17,12 +17,24 @@ class SecondsFrame {
1717
private:
1818
void setInitFrameSector();
1919
void frameLogic();
20+
bool checkIfFrameLoopShouldRun() const;
21+
void updateMillisCounters();
22+
bool checkIfFrameInit() const;
23+
bool checkIftoRunFrameLogic() const;
24+
uint16_t calcCurrentSecondFrameVariable();
25+
void handleFrameSectorToggle();
26+
void handleFrameSector();
27+
void toggleFrameSectorUpToCurrent();
28+
bool isFullMinute() const;
29+
void handleFullMinute();
30+
void handleSecondFrameChange();
31+
void updateLedsIfClockworkMode();
2032

2133
public:
2234
SecondsFrame(const uint8_t num);
2335
~SecondsFrame();
2436

25-
void setup();
37+
void initFrame();
2638
void loop();
2739
};
2840

@@ -41,86 +53,167 @@ SecondsFrame::SecondsFrame(const uint8_t num) {
4153
previousMillis = 0;
4254
}
4355

56+
//------------------------------------------------------------------------------
57+
// Helper functions
58+
//------------------------------------------------------------------------------
59+
60+
bool SecondsFrame::checkIfFrameLoopShouldRun() const {
61+
return usedUhrType->numPixelsFrameMatrix() == 0;
62+
}
63+
64+
//------------------------------------------------------------------------------
65+
66+
void SecondsFrame::updateMillisCounters() {
67+
unsigned long currentMillis = millis();
68+
countMillisFrameIntervall += currentMillis - previousMillis;
69+
previousMillis = currentMillis;
70+
}
71+
72+
//------------------------------------------------------------------------------
73+
74+
bool SecondsFrame::checkIfFrameInit() const {
75+
return G.progInit && G.prog == COMMAND_IDLE;
76+
}
77+
78+
//------------------------------------------------------------------------------
79+
80+
bool SecondsFrame::checkIftoRunFrameLogic() const {
81+
return countMillisFrameIntervall >= frameIntervall;
82+
}
83+
84+
//------------------------------------------------------------------------------
85+
86+
uint16_t SecondsFrame::calcCurrentSecondFrameVariable() {
87+
return _second / (60.f / numFramePixels);
88+
}
89+
90+
//------------------------------------------------------------------------------
91+
92+
void SecondsFrame::handleFrameSectorToggle() {
93+
if (_minute % 2 == 1) {
94+
memset(frameArray, true, sizeof(frameArray));
95+
}
96+
toggleFrameSectorUpToCurrent();
97+
}
98+
99+
//------------------------------------------------------------------------------
100+
101+
void SecondsFrame::handleFrameSector() { toggleFrameSectorUpToCurrent(); }
102+
103+
//------------------------------------------------------------------------------
104+
105+
void SecondsFrame::toggleFrameSectorUpToCurrent() {
106+
for (uint8_t i = 0; i <= _secondFrame; i++) {
107+
frameArray[i] = !frameArray[i];
108+
}
109+
}
110+
44111
//------------------------------------------------------------------------------
45112

46113
void SecondsFrame::setInitFrameSector() {
114+
memset(frameArray, false, sizeof(frameArray)); // Clear the frame array
115+
47116
switch (G.secondVariant) {
48117
case SecondVariant::FrameSectorToggle:
49-
if (_minute % 2 == 1) {
50-
memset(frameArray, true, sizeof(numFramePixels));
51-
}
52-
/* intentianally no break */
118+
handleFrameSectorToggle();
119+
break;
53120
case SecondVariant::FrameSector:
54-
for (uint8_t i = 0; i <= _secondFrame; i++) {
55-
frameArray[i] = !frameArray[i];
56-
}
121+
handleFrameSector();
57122
break;
58123
default:
124+
Serial.println("[ERROR] frame.h - Invalid second variant");
59125
break;
60126
}
61127
}
62128

63129
//------------------------------------------------------------------------------
64130

65-
void SecondsFrame::setup() {
131+
void SecondsFrame::initFrame() {
66132
led.clearFrame();
67-
_secondFrame = _second / (60.f / numFramePixels);
133+
_secondFrame = calcCurrentSecondFrameVariable();
68134
setInitFrameSector();
69135
parametersChanged = true;
70136
}
71137

72138
//------------------------------------------------------------------------------
73139

140+
bool SecondsFrame::isFullMinute() const {
141+
return _secondFrame == numFramePixels;
142+
}
143+
144+
//------------------------------------------------------------------------------
145+
146+
void SecondsFrame::handleFullMinute() {
147+
led.clearFrame();
148+
memset(frameArray, false, sizeof(frameArray));
149+
_secondFrame = 0;
150+
setInitFrameSector();
151+
}
152+
153+
//------------------------------------------------------------------------------
154+
155+
void SecondsFrame::handleSecondFrameChange() {
156+
switch (G.secondVariant) {
157+
case SecondVariant::FrameDot:
158+
frameArray[_secondFrame] = true;
159+
if (_secondFrame != 0) {
160+
frameArray[_secondFrame - 1] = false;
161+
}
162+
break;
163+
case SecondVariant::FrameSector:
164+
case SecondVariant::FrameSectorToggle:
165+
frameArray[_secondFrame] = !frameArray[_secondFrame];
166+
break;
167+
default:
168+
break;
169+
}
170+
}
171+
172+
//------------------------------------------------------------------------------
173+
174+
void SecondsFrame::updateLedsIfClockworkMode() {
175+
if (G.prog == COMMAND_IDLE && G.conf == COMMAND_IDLE) {
176+
led.clearFrame();
177+
parametersChanged = true;
178+
G.prog = COMMAND_MODE_WORD_CLOCK;
179+
}
180+
}
181+
182+
//------------------------------------------------------------------------------
183+
74184
void SecondsFrame::frameLogic() {
75185
countMillisFrameIntervall = 0;
76186
_secondFrame++;
77187

78-
/*Every full minute */
79-
if (_secondFrame == numFramePixels) {
80-
led.clearFrame();
81-
memset(frameArray, false, sizeof(frameArray));
82-
setInitFrameSector();
83-
_secondFrame = 0;
188+
if (isFullMinute()) {
189+
handleFullMinute();
84190
}
85191

86-
/*Every (Frame-)Second*/
87192
if (lastSecondFrame != _secondFrame) {
88-
switch (G.secondVariant) {
89-
case SecondVariant::FrameDot:
90-
frameArray[_secondFrame] = true;
91-
if (_secondFrame != 0) {
92-
frameArray[_secondFrame - 1] = false;
93-
}
94-
break;
95-
case SecondVariant::FrameSector:
96-
case SecondVariant::FrameSectorToggle:
97-
frameArray[_secondFrame] = !frameArray[_secondFrame];
98-
break;
99-
default:
100-
break;
101-
}
193+
handleSecondFrameChange();
102194
lastSecondFrame = _secondFrame;
103195
}
104196

105-
/*Update LEDs corrosponding with mode Clockwork*/
106-
if (G.prog == 0 && G.conf == 0) {
107-
led.clear();
108-
G.prog = COMMAND_MODE_WORD_CLOCK;
109-
}
197+
updateLedsIfClockworkMode();
110198
}
111199

200+
//------------------------------------------------------------------------------
201+
// Loop function for SecondsFrame
112202
//------------------------------------------------------------------------------
113203

114204
void SecondsFrame::loop() {
115-
unsigned long currentMillis = millis();
116-
countMillisFrameIntervall += currentMillis - previousMillis;
117-
previousMillis = currentMillis;
205+
if (checkIfFrameLoopShouldRun()) {
206+
return;
207+
}
118208

119-
if (G.progInit && G.prog == 0) {
120-
setup();
209+
updateMillisCounters();
210+
211+
if (checkIfFrameInit()) {
212+
initFrame();
121213
G.progInit = false;
122214
}
123-
if (countMillisFrameIntervall >= frameIntervall) {
215+
216+
if (checkIftoRunFrameLogic()) {
124217
frameLogic();
125218
}
126219
}

0 commit comments

Comments
 (0)