diff --git a/docs/web-ui.md b/docs/web-ui.md index a1e055b..527d18f 100644 --- a/docs/web-ui.md +++ b/docs/web-ui.md @@ -140,7 +140,8 @@ The display schedule (on/off, when the display is on, when it switches off); slo (also a Home Assistant switch: the display only changes every 1-60 minutes, on the clock, and is switched off in between, for less noise); the "No WiFi" screen; the flip time, the pause after each pulse, pulses per dot and the refresh effect (instant, sparkle, wipe, rain, from the middle out, -diagonal, spiral, flip all then reveal, push, random; optionally only for small changes +diagonal, spiral, flip all then reveal, push, Matrix (yellow streaks fall down the columns +that change and leave the new image behind them), random; optionally only for small changes like the clock's minutes; pages can choose their own effect); how often every dot is flipped again ("Dot refresh", default 2 min) and how often the whole image is sent again ("Image resync", default 10 min; 0 switches either off); test patterns; the status LED. diff --git a/lib/BROSE9323/BROSE9323.cpp b/lib/BROSE9323/BROSE9323.cpp index c951840..f6e9224 100644 --- a/lib/BROSE9323/BROSE9323.cpp +++ b/lib/BROSE9323/BROSE9323.cpp @@ -15,6 +15,9 @@ BROSE9323::BROSE9323(uint8_t w, uint8_t h, uint8_t pw, uint16_t ft) : Adafruit_G _old_buffer = (uint8_t *)calloc(_buffer_size, sizeof(uint8_t)); #endif _new_buffer = (uint8_t *)calloc(_buffer_size, sizeof(uint8_t)); +#ifndef ESPSERIAL + _changed_columns = (uint8_t *)calloc(_buffer_width, sizeof(uint8_t)); +#endif } #ifdef ESPSERIAL @@ -424,9 +427,14 @@ void BROSE9323::_startEffect(bool all, bool instant) { uint16_t total = width() * height(); uint16_t changed = 0; + memset(_changed_columns, 0, _buffer_width); for (uint8_t y = 0; y < height(); y++) for (uint8_t x = 0; x < width(); x++) - changed += _changed(x, y); + if (_changed(x, y)) + { + changed++; + _changed_columns[x >> 3] |= 1 << (x & 7); + } if (changed == 0 && !all) { _animating = false; @@ -438,7 +446,7 @@ void BROSE9323::_startEffect(bool all, bool instant) if (effect != EFFECT_INSTANT && (_effect_flags & EFFECT_FLAG_SMALL_ONLY) && (all || changed > total / 10)) effect = EFFECT_INSTANT; if (effect == EFFECT_RANDOM) - effect = 1 + micros() % (EFFECT_RANDOM - 1); + effect = randomEffect(micros()); // Pushing needs to know what is shown; after boot that is unknown if (all && effect == EFFECT_PUSH) effect = EFFECT_WIPE; @@ -462,6 +470,15 @@ void BROSE9323::_startEffect(bool all, bool instant) _push_pos = 0; steps = width(); } + else if (effect == EFFECT_MATRIX) + { + _push_shift = 0; + _push_pos = 0; + _matrix_seed = micros() >> 2; + if (all) + memset(_changed_columns, 0xFF, _buffer_width); + steps = matrixTicks(height()); + } else { _sequence.begin(effect == EFFECT_FLAP ? EFFECT_WIPE : effect, width(), height(), (uint16_t)micros()); @@ -517,6 +534,48 @@ bool BROSE9323::_pushDot(void) return ++_push_shift <= w; } +// The next flip of the current matrix tick. _push_pos walks over two places per column: the +// streak's head (turns the dot yellow), then its tail (the new image). Only the changed +// columns have a streak. Only a dot's final flip gets all pulses, so the head gives a dot +// that ends up black just one: a full screen change takes much less time. False when all +// ticks are done. +bool BROSE9323::_matrixStep(void) +{ + uint8_t w = width(), h = height(); + uint8_t spread = matrixStartSpread(h); + while (true) + { + uint8_t x = _push_pos >> 1; + bool tail = _push_pos & 1; + bool flipped = false; + if (_changed_columns[x >> 3] & (1 << (x & 7))) + { + int16_t row = (int16_t)_push_shift - matrixStartTick(x, _matrix_seed, spread); + if (tail) + row -= MATRIX_STREAK; + if (row >= 0 && row < h) + { + bool wanted = _wanted(x, row); + bool target = tail ? wanted : true; + bool changed = _shown(x, row) != target; + if (changed || _animate_all) + { + _flipTo(x, row, target, changed && (tail || wanted) ? _pulses : 1); + flipped = true; + } + } + } + if (++_push_pos >= (uint16_t)w * 2) + { + _push_pos = 0; + _next_step += _step_time; + return ++_push_shift < matrixTicks(h); + } + if (flipped) + return true; + } +} + bool BROSE9323::busy(void) const { return _animating && !_drawing; @@ -548,6 +607,15 @@ bool BROSE9323::update(void) } continue; } + if (_running_effect == EFFECT_MATRIX) + { + if (!_matrixStep()) + { + _animating = false; + break; + } + continue; + } uint8_t x, y; if (!_sequence.next(x, y)) diff --git a/lib/BROSE9323/BROSE9323.h b/lib/BROSE9323/BROSE9323.h index a87e8cb..3f3bf9a 100644 --- a/lib/BROSE9323/BROSE9323.h +++ b/lib/BROSE9323/BROSE9323.h @@ -44,8 +44,10 @@ private: bool _animating = false; uint8_t _running_effect = EFFECT_INSTANT; // _effect, or the one chosen for EFFECT_RANDOM uint8_t _phase = 0; // EFFECT_FLAP: 0 = to yellow, 1 = the new image - uint8_t _push_shift = 0; // EFFECT_PUSH: column shift 1..width - uint16_t _push_pos = 0; // EFFECT_PUSH: dot within the shift + uint8_t _push_shift = 0; // EFFECT_PUSH: column shift 1..width; EFFECT_MATRIX: tick + uint16_t _push_pos = 0; // EFFECT_PUSH: dot within the shift; EFFECT_MATRIX: see _matrixStep() + uint8_t *_changed_columns = NULL; // a bit per column, set by _startEffect() (EFFECT_MATRIX) + uint8_t _matrix_seed = 0; // EFFECT_MATRIX: different start ticks for each frame bool _animate_all = false; // flip every dot, not only the changed ones bool _drawing = false; // the buffer changed since the last display(): pause uint32_t _step_time = 0; // us per step @@ -106,6 +108,7 @@ private: void _flipTo(uint8_t x, uint8_t y, bool on, uint8_t pulses); void _flipDot(uint8_t x, uint8_t y, uint8_t pulses); bool _pushDot(void); + bool _matrixStep(void); void _startEffect(bool all, bool instant); void _refreshStep(uint32_t start); #endif @@ -138,8 +141,8 @@ public: // Pulses for each changed dot (a second pulse catches dots that didn't flip). Full // redraws use one pulse per dot. void setPulses(uint8_t); - // How display() shows a new frame (RefreshEffect), how long it takes in ms (pushing - // can take longer: it flips many dots per step) and EFFECT_FLAG_... flags. + // How display() shows a new frame (RefreshEffect), how long it takes in ms (push and + // matrix can take longer: they flip many dots) and EFFECT_FLAG_... flags. // Effects run in steps from update(), so call that often (every loop). void setEffect(uint8_t effect, uint16_t time_ms, uint8_t flags = 0); #ifndef ESPSERIAL diff --git a/lib/BROSE9323/dot_sequence.h b/lib/BROSE9323/dot_sequence.h index 45321a6..6919a55 100644 --- a/lib/BROSE9323/dot_sequence.h +++ b/lib/BROSE9323/dot_sequence.h @@ -16,10 +16,39 @@ enum RefreshEffect : uint8_t // The ones below are run by BROSE9323 itself (DotSequence uses column order for them) EFFECT_FLAP = 7, // every dot to yellow (wipe), then the new image (wipe) EFFECT_PUSH = 8, // the new image slides in from the right, pushing the old one out - EFFECT_RANDOM = 9, // one of the effects 1-8, chosen for each frame - EFFECT_COUNT = 10, + EFFECT_RANDOM = 9, // one of the effects 1-8 or 10, chosen for each frame + EFFECT_MATRIX = 10, // yellow streaks fall down the changed columns, the new image behind them + EFFECT_COUNT = 11, }; +// The effect for EFFECT_RANDOM. now: micros(), which only gives multiples of 4 on a 16 MHz +// Nano, so its lowest bits say nothing. +inline uint8_t randomEffect(uint32_t now) +{ + uint8_t pick = 1 + (now >> 2) % 9; + return pick == EFFECT_RANDOM ? (uint8_t)EFFECT_MATRIX : pick; +} + +// EFFECT_MATRIX runs in ticks: per tick every streak moves one row down. A streak's head +// starts at the top in the column's start tick and turns dots yellow; MATRIX_STREAK rows +// behind it, its tail shows the new image. +const uint8_t MATRIX_STREAK = 4; +// Columns start in the first 2/3 of the ticks, the last 1/3 is the last streak falling +inline uint8_t matrixTicks(uint8_t h) { return 3 * (h + MATRIX_STREAK); } +inline uint8_t matrixStartSpread(uint8_t h) { return 2 * (h + MATRIX_STREAK); } + +// The start tick of a column, a mixed hash so that no pattern shows between the columns +// (and no RAM per column). Fast on the AVR: only 8 bit steps and one 8 x 8 multiplication. +inline uint8_t matrixStartTick(uint8_t column, uint8_t seed, uint8_t spread) +{ + uint8_t v = (uint8_t)(column * 167) ^ seed; + v *= 29; + v ^= v >> 3; + v *= 113; + v ^= v >> 4; + return ((uint16_t)v * spread) >> 8; +} + // Flags for BROSE9323::setEffect() const uint8_t EFFECT_FLAG_SMALL_ONLY = 1; // big changes (> 1/10 of the dots) are instant // E command only: use the effect until the next E command or power cycle, without storing diff --git a/src/esp32/config.h b/src/esp32/config.h index 854246f..7908b1d 100644 --- a/src/esp32/config.h +++ b/src/esp32/config.h @@ -118,7 +118,7 @@ const uint32_t SETUP_AP_DELAY = 20000; // open the AP when WiFi fails thi const uint32_t WIFI_CONNECT_TIMEOUT = 30000; const uint32_t WIFI_RESTART_TIME = 10UL * 60 * 1000; -#define FIRMWARE_VERSION "2.20.0" +#define FIRMWARE_VERSION "2.21.0" // Home Assistant device id (do not change: Home Assistant's entities are linked to it) const uint8_t HA_DEVICE_ID[] = {0x34, 0x86, 0x5d, 0x3a, 0x08, 0x28}; diff --git a/src/esp32/logic/page.h b/src/esp32/logic/page.h index 3aa840c..b4a7f37 100644 --- a/src/esp32/logic/page.h +++ b/src/esp32/logic/page.h @@ -26,7 +26,7 @@ const int ELEMENT_MAP_SIZE = 64; const char DEGREE_SIGN = 127; // DynamicPage::effect: the refresh effect of the Hardware settings const uint8_t PAGE_EFFECT_DEFAULT = 255; -const uint8_t PAGE_EFFECT_COUNT = 10; // DRIVE_EFFECT_COUNT (checked in logic/settings.cpp) +const uint8_t PAGE_EFFECT_COUNT = 11; // DRIVE_EFFECT_COUNT (checked in logic/settings.cpp) enum class ElementType : uint8_t { diff --git a/src/esp32/logic/settings.cpp b/src/esp32/logic/settings.cpp index 818fbeb..bf9941f 100644 --- a/src/esp32/logic/settings.cpp +++ b/src/esp32/logic/settings.cpp @@ -69,6 +69,8 @@ uint32_t effectTime(const DriveSettings &drive) return 0; if (drive.effect == DRIVE_EFFECT_PUSH || drive.effect == DRIVE_EFFECT_RANDOM) return drive.effect_time + DRIVE_PUSH_EXTRA_TIME; + if (drive.effect == DRIVE_EFFECT_MATRIX) + return drive.effect_time + DRIVE_MATRIX_EXTRA_TIME; return drive.effect_time; } diff --git a/src/esp32/logic/settings.h b/src/esp32/logic/settings.h index 5e63408..edc7061 100644 --- a/src/esp32/logic/settings.h +++ b/src/esp32/logic/settings.h @@ -51,9 +51,12 @@ struct HomeAssistantSettings const uint8_t DRIVE_EFFECT_INSTANT = 0; // numbers: RefreshEffect in lib/BROSE9323/dot_sequence.h const uint8_t DRIVE_EFFECT_PUSH = 8; const uint8_t DRIVE_EFFECT_RANDOM = 9; -const uint8_t DRIVE_EFFECT_COUNT = 10; +const uint8_t DRIVE_EFFECT_MATRIX = 10; +const uint8_t DRIVE_EFFECT_COUNT = 11; // Pushing flips many dots per column step, so it can take much longer than effect_time const uint32_t DRIVE_PUSH_EXTRA_TIME = 20000; +// The matrix streaks flip most dots of a changed column twice, also more than effect_time +const uint32_t DRIVE_MATRIX_EXTRA_TIME = 5000; struct DriveSettings { diff --git a/src/esp32/web/web_page.h b/src/esp32/web/web_page.h index 4b3e5c2..f5be15e 100644 --- a/src/esp32/web/web_page.h +++ b/src/esp32/web/web_page.h @@ -171,9 +171,9 @@ details{margin-top:10px}summary{cursor:pointer;color:var(--dim);font-size:13px;m + - + diff --git a/src/nano/README.md b/src/nano/README.md index 71e8a52..a6a463b 100644 --- a/src/nano/README.md +++ b/src/nano/README.md @@ -38,9 +38,10 @@ Arduino core, EEPROM and the display driver are replaced by fakes in so the coil supply can recover. - **Refresh effect** (`E`): with `0` (default) a frame appears column by column as fast as possible. The other effects (sparkle, wipe, rain, from the middle out, diagonal, - spiral, flip all then reveal, push, random) spread the flips over the effect time. - Push shifts the whole picture one column per step, so it flips many dots and can take - longer than the effect time. With flag 1 only small changes (at most 1/10 of the dots, + spiral, flip all then reveal, push, matrix, random) spread the flips over the effect + time. Push shifts the whole picture one column per step, so it flips many dots and can + take longer than the effect time. Matrix drops a yellow streak down each column that + changed, so it flips those columns' dots up to twice and can also take longer. With flag 1 only small changes (at most 1/10 of the dots, like the clock's minutes) get the effect. After boot the dot state is unknown, so push falls back to a wipe. They run in small steps from `loop()`, so serial data keeps being read; while a new frame is being drawn into the buffer the effect pauses, and the @@ -90,7 +91,7 @@ skipped and the next line starts clean. Coordinates are 2-digit **hex**. Color i | `N` | `Nn` | Pulses for each changed dot (1–3), stored in EEPROM | | `I` | `Innn` | Minutes between full redraws (decimal, 0–1440, 0 = never), stored in EEPROM | | `C` | `C` | Reply `C xxxx`: checksum of the image received so far (CRC-16/CCITT of the buffer, only the dots, `lib/BROSE9323/buffer_crc.h`), 4 hex digits | -| `E` | `Ee,nnnn[,f]` | Refresh effect `e` (0 instant, 1 sparkle, 2 wipe, 3 rain, 4 from the middle out, 5 diagonal, 6 spiral, 7 flip all then reveal, 8 push, 9 random), its time in ms (100–10000) and flags `f` (1 = only small changes, default 0), stored in EEPROM | +| `E` | `Ee,nnnn[,f]` | Refresh effect `e` (0 instant, 1 sparkle, 2 wipe, 3 rain, 4 from the middle out, 5 diagonal, 6 spiral, 7 flip all then reveal, 8 push, 9 random, 10 matrix), its time in ms (100–10000) and flags `f` (1 = only small changes, default 0), stored in EEPROM | Replies on the Nano's TX pin: diff --git a/test/test_driver/test_main.cpp b/test/test_driver/test_main.cpp index faace78..528b426 100644 --- a/test/test_driver/test_main.cpp +++ b/test/test_driver/test_main.cpp @@ -124,6 +124,147 @@ void test_effects_end_with_the_right_image() } } +// Stricter than assertPanelShows(): shownPixel() would also agree with a leftover streak +static void assertPanelHasPattern(int seed) +{ + for (int x = 0; x < W; x++) + for (int y = 0; y < H; y++) + if (panel.dot[x][y] != (((x * 7 + y * 3 + seed) % 5) == 0)) + { + char msg[64]; + snprintf(msg, sizeof(msg), "dot %d,%d is wrong", x, y); + TEST_FAIL_MESSAGE(msg); + } +} + +void test_matrix_ends_with_the_right_image_and_reaches_every_dot_after_boot() +{ + BROSE9323 *d = make(); + d->setEffect(EFFECT_MATRIX, 500); + drawPattern(*d, 0); + d->display(); + finish(*d); + TEST_ASSERT_EQUAL(W * H, dotsFlippedAtLeast(1)); + assertPanelHasPattern(0); + drawPattern(*d, 2); + d->display(); + finish(*d); + assertPanelHasPattern(2); + delete d; +} + +void test_matrix_flips_only_changed_columns_with_the_right_pulses() +{ + BROSE9323 *d = make(); + d->setEffect(EFFECT_MATRIX, 500); + d->fillScreen(0); + d->drawPixel(40, 3, 1); // stays yellow + d->drawPixel(40, 9, 1); // yellow to black + d->display(); + finish(*d); + panel.clearCounts(); + + d->drawPixel(40, 9, 0); + d->drawPixel(40, 12, 1); // black to yellow + d->display(); + finish(*d); + for (int x = 0; x < W; x++) + for (int y = 0; y < H; y++) + { + int expected = x != 40 ? 0 : y == 3 ? 0 : y == 9 ? 3 : y == 12 ? 3 : 1 + 3; + if (panel.flips[x][y] != expected) + { + char msg[64]; + snprintf(msg, sizeof(msg), "dot %d,%d: %d pulses, not %d", x, y, panel.flips[x][y], expected); + TEST_FAIL_MESSAGE(msg); + } + } + TEST_ASSERT_TRUE(panel.dot[40][3]); + TEST_ASSERT_FALSE(panel.dot[40][9]); + TEST_ASSERT_TRUE(panel.dot[40][12]); + delete d; +} + +void test_matrix_streak_falls_from_the_top_and_takes_the_effect_time() +{ + BROSE9323 *d = make(); + d->setEffect(EFFECT_MATRIX, 1000); + d->fillScreen(0); + d->display(); + finish(*d); + + d->drawPixel(40, 18, 1); + uint32_t start = fake_micros; + d->display(); + int highest = -1, longest = 0; + while (d->busy()) + { + d->update(); + int lit = 0, bottom = -1; + for (int y = 0; y < H; y++) + if (panel.dot[40][y]) + { + lit++; + bottom = y; + } + TEST_ASSERT_LESS_OR_EQUAL(highest + 1, bottom); // one row at a time, never upwards + if (bottom > highest) + highest = bottom; + if (lit > longest) + longest = lit; + } + TEST_ASSERT_EQUAL(H - 1, highest); + TEST_ASSERT_EQUAL(MATRIX_STREAK + 1, longest); // the tail goes after the head moved + uint32_t took = fake_micros - start; + TEST_ASSERT_UINT32_WITHIN(100000, 1000000, took); + delete d; +} + +void test_matrix_full_screen_change_never_blocks_and_finishes_soon_enough() +{ + BROSE9323 *d = make(); + d->setEffect(EFFECT_MATRIX, 1500); + drawPattern(*d, 0); + d->display(); + finish(*d); + drawPattern(*d, 1); + uint32_t start = fake_micros; + d->display(); + finish(*d); + assertPanelHasPattern(1); + uint32_t took = fake_micros - start; + // DRIVE_MATRIX_EXTRA_TIME on the ESP32 keeps the power on for this much longer + TEST_ASSERT_LESS_THAN(1500000 + 5000000, took); + delete d; +} + +void test_matrix_interrupted_by_a_new_frame_leaves_no_streaks() +{ + BROSE9323 *d = make(); + d->setEffect(EFFECT_MATRIX, 1000); + drawPattern(*d, 0); + d->display(); + finish(*d); + drawPattern(*d, 1); + d->display(); + // Until streaks are visible: dots yellow that are in neither image + int streak_dots = 0; + while (d->busy() && streak_dots < 10) + { + d->update(); + streak_dots = 0; + for (int x = 0; x < W; x++) + for (int y = 0; y < H; y++) + streak_dots += panel.dot[x][y] && ((x * 7 + y * 3) % 5) != 0 && ((x * 7 + y * 3 + 1) % 5) != 0; + } + TEST_ASSERT_TRUE(d->busy()); + drawPattern(*d, 2); + d->display(false, true); // a moving page: instant + finish(*d); + assertPanelHasPattern(2); + delete d; +} + void test_refresh_flips_every_dot_once_without_blocking() { BROSE9323 *d = make(); @@ -264,6 +405,11 @@ int main() RUN_TEST(test_first_frame_flips_every_dot_without_blocking); RUN_TEST(test_instant_frame_flips_only_the_changed_dots_with_all_pulses); RUN_TEST(test_effects_end_with_the_right_image); + RUN_TEST(test_matrix_ends_with_the_right_image_and_reaches_every_dot_after_boot); + RUN_TEST(test_matrix_flips_only_changed_columns_with_the_right_pulses); + RUN_TEST(test_matrix_streak_falls_from_the_top_and_takes_the_effect_time); + RUN_TEST(test_matrix_full_screen_change_never_blocks_and_finishes_soon_enough); + RUN_TEST(test_matrix_interrupted_by_a_new_frame_leaves_no_streaks); RUN_TEST(test_refresh_flips_every_dot_once_without_blocking); RUN_TEST(test_refresh_pauses_while_a_frame_arrives_and_then_finishes); RUN_TEST(test_refresh_waits_for_a_running_effect); diff --git a/test/test_esp32/test_main.cpp b/test/test_esp32/test_main.cpp index 8d7a6cd..7e47026 100644 --- a/test/test_esp32/test_main.cpp +++ b/test/test_esp32/test_main.cpp @@ -756,6 +756,11 @@ void test_effect_time_is_zero_when_instant() TEST_ASSERT_EQUAL(2500 + (int)DRIVE_PUSH_EXTRA_TIME, (int)effectTime(d)); d.effect = DRIVE_EFFECT_RANDOM; // can be a push TEST_ASSERT_EQUAL(2500 + (int)DRIVE_PUSH_EXTRA_TIME, (int)effectTime(d)); + d.effect = DRIVE_EFFECT_MATRIX; // flips most dots of a changed column twice + TEST_ASSERT_EQUAL(2500 + (int)DRIVE_MATRIX_EXTRA_TIME, (int)effectTime(d)); + Settings s; + s.drive.effect = DRIVE_EFFECT_MATRIX; + TEST_ASSERT_NULL(validateSettings(s)); } void test_settings_off_page_blank_or_bitmap_name() diff --git a/test/test_nano/test_main.cpp b/test/test_nano/test_main.cpp index 1fe2843..1396471 100644 --- a/test/test_nano/test_main.cpp +++ b/test/test_nano/test_main.cpp @@ -478,7 +478,7 @@ void test_effect_without_saving() void test_invalid_effect_is_rejected() { - send("E10,1500\n"); // unknown effect + send("E11,1500\n"); // unknown effect send("E1,1500,4\n"); // unknown flag send("E1,50\n"); // too fast send("E1\n"); // no duration @@ -486,6 +486,18 @@ void test_invalid_effect_is_rejected() TEST_ASSERT_TRUE(replied("ERR")); } +void test_matrix_effect_is_accepted_and_stored() +{ + send("E10,2000\n"); + TEST_ASSERT_EQUAL(EFFECT_MATRIX, display.last("effect")->a); + TEST_ASSERT_FALSE(replied("ERR")); + display.calls.clear(); + setup(); + TEST_ASSERT_EQUAL(EFFECT_MATRIX, display.last("effect")->a); + TEST_ASSERT_EQUAL(2000, display.last("effect")->b); + send("E0,1500,0\n"); +} + // Every effect order visits each dot exactly once static void checkSequence(uint8_t effect, uint8_t w, uint8_t h, uint16_t seed) { @@ -574,6 +586,59 @@ void test_sparkle_order_is_scrambled() TEST_ASSERT_LESS_THAN(n / 20, neighbours); } +void test_random_effect_reaches_all_effects_with_nano_micros() +{ + // micros() on the Nano: multiples of 4. Taking the modulo of that directly only ever + // gave sparkle and diagonal. + int seen[EFFECT_COUNT] = {}; + for (uint32_t now = 0; now < 4000; now += 4) + { + uint8_t effect = randomEffect(now); + TEST_ASSERT_LESS_THAN(EFFECT_COUNT, effect); + seen[effect]++; + } + TEST_ASSERT_EQUAL(0, seen[EFFECT_INSTANT]); + TEST_ASSERT_EQUAL(0, seen[EFFECT_RANDOM]); + for (uint8_t effect = EFFECT_SPARKLE; effect < EFFECT_COUNT; effect++) + if (effect != EFFECT_RANDOM) + TEST_ASSERT_GREATER_THAN(100, seen[effect]); +} + +void test_matrix_start_ticks_are_spread_without_a_pattern() +{ + const uint8_t spread = matrixStartSpread(19); + TEST_ASSERT_EQUAL(matrixTicks(19), spread + 19 + MATRIX_STREAK); + for (int seed = 0; seed < 256; seed++) + { + int starts[46] = {}; + int steps[46] = {}; + int close = 0, previous = 0; + for (int x = 0; x < 84; x++) + { + int start = matrixStartTick(x, seed, spread); + TEST_ASSERT_LESS_THAN(spread, start); + starts[start]++; + if (x) + { + close += abs(start - previous) <= 1; + steps[(start - previous + spread) % spread]++; + } + previous = start; + } + for (int i = 0; i < spread; i++) + { + TEST_ASSERT_LESS_THAN(9, starts[i]); // no walls of streaks + TEST_ASSERT_LESS_THAN(15, steps[i]); // no diagonal lines + } + TEST_ASSERT_LESS_THAN(20, close); // no wide bands + } + // A new frame gets other columns first + int same = 0; + for (int x = 0; x < 84; x++) + same += matrixStartTick(x, 1, spread) == matrixStartTick(x, 2, spread); + TEST_ASSERT_LESS_THAN(20, same); +} + // --------------------------------------------------------------------------- // Periodic full redraw // --------------------------------------------------------------------------- @@ -750,9 +815,12 @@ int main() RUN_TEST(test_effect_is_applied_and_stored); RUN_TEST(test_effect_without_saving); RUN_TEST(test_invalid_effect_is_rejected); + RUN_TEST(test_matrix_effect_is_accepted_and_stored); RUN_TEST(test_every_effect_visits_each_dot_once); RUN_TEST(test_wipe_goes_left_to_right_and_center_starts_in_the_middle); RUN_TEST(test_sparkle_order_is_scrambled); + RUN_TEST(test_random_effect_reaches_all_effects_with_nano_micros); + RUN_TEST(test_matrix_start_ticks_are_spread_without_a_pattern); RUN_TEST(test_refresh_when_due); RUN_TEST(test_refresh_only_once_per_interval);