From a18e9d38a1377421eb8b7ccaec539b6b7800bf36 Mon Sep 17 00:00:00 2001 From: MightyPork Date: Fri, 26 Dec 2014 01:08:09 +0100 Subject: [PATCH] added unit tests for calc.h --- devel/cstruct.h | 5 + devel/lib/README.md | 8 +- devel/lib/calc.h | 87 +++++-- devel/lib/debounce.h | 7 +- devel/lib/loops.h | 25 ++ devel/lib_tests/lib | 1 + devel/lib_tests/run_tests.sh | 8 + devel/lib_tests/test_calc.c | 356 ++++++++++++++++++++++++++ devel/lib_tests/test_loops_visual.c | 26 ++ projects/color-memory-game/lib/calc.h | 16 +- projects/color-memory-game/main.c | 168 +++++++----- 11 files changed, 602 insertions(+), 105 deletions(-) create mode 100644 devel/cstruct.h create mode 100644 devel/lib/loops.h create mode 120000 devel/lib_tests/lib create mode 100755 devel/lib_tests/run_tests.sh create mode 100644 devel/lib_tests/test_calc.c create mode 100644 devel/lib_tests/test_loops_visual.c diff --git a/devel/cstruct.h b/devel/cstruct.h new file mode 100644 index 0000000..845bd8c --- /dev/null +++ b/devel/cstruct.h @@ -0,0 +1,5 @@ +#pragma once + +#define loop(varname, count) for(uint8_t varname = 0; varname < (count); varname++) +#define repeat(count) for(uint8_t _repeat_i = 0; _repeat_i < (count); _repeat_i++) +#define until(cond) while(!(cond)) diff --git a/devel/lib/README.md b/devel/lib/README.md index ae3661a..7ac9922 100644 --- a/devel/lib/README.md +++ b/devel/lib/README.md @@ -1,6 +1,8 @@ -MightyPorsk's AVR utils library -=============================== +AVR utils library +================= -This is my ever-evolving library. When I'm done with a project, I copy the current library to the project, so it doesn't break when I do further improvements. +This is my ever-evolving library (not only) for AVR programming. + +When I'm done with a project, I copy the current library to the project, so it doesn't break when I do further improvements. Each library file contains a large comment block explaining it's function. diff --git a/devel/lib/calc.h b/devel/lib/calc.h index b4011e8..750e173 100644 --- a/devel/lib/calc.h +++ b/devel/lib/calc.h @@ -1,46 +1,89 @@ #pragma once /** - General purpose calculation and bit manipulation utilities. + Bit and byte manipulation utilities */ -// if max, go to zero. Else increment. -#define inc_wrap(var, min, max) do { if ((var) >= (max)) { (var)=min; } else { (var)++; } } while(0) -// If zero, go to max. Else decrement, -#define dec_wrap(var, min, max) do { if ((var) > min) { (var)--; } else { (var)=(max); } } while(0) +// --- Increment in range --- +// when overflown, wraps within range. Lower bound < upper bound. +// ..., upper bound excluded +#define inc_wrap(var, min, max) do { if ((var) >= (max - 1)) { (var) = (min); } else { (var)++; } } while(0) +// ..., upper bound included +#define inc_wrapi(var, min, max) inc_wrap((var), (min), (max) + 1) -// === general bit manipulation with register === -#define sbi(reg, bit) do { (reg) |= (1 << (uint8_t)(bit)); } while(0) + +// --- Decrement in range --- +// when underflown, wraps within range. Lower bound < upper bound. +// ..., upper bound excluded +#define dec_wrap(var, min, max) do { if ((var) <= (min)) { (var) = (max) - 1; } else { (var)--; } } while(0) +// ..., upper bound included +#define dec_wrapi(var, min, max) dec_wrap((var), (min), (max) + 1) + + +// --- Bit manipulation -- + +// Set bit +#define sbi(reg, bit) do { (reg) |= (1 << (uint8_t)(bit)); } while(0) + +// Clear bit #define cbi(reg, bit) do { (reg) &= ~(1 << (uint8_t)(bit)); } while(0) -#define read_bit(reg, bit) ((((uint8_t)(reg)) >> (uint8_t)(bit)) & 0x1) -#define get_bit(reg, bit) read_bit(reg, bit) +// Get n-th bit +#define read_bit(reg, bit) (((reg) >> (uint8_t)(bit)) & 0x1) +#define get_bit(reg, bit) read_bit(reg, bit) + +// Test n-th bit (Can't use bit_is_set, as it's redefined in sfr_def.h) #define bit_is_high(reg, bit) read_bit(reg, bit) -#define bit_is_low(reg, bit) !read_bit(reg, bit) -// Can't use bit_is_set, as it's redefined in sfr_def.h +#define bit_is_low(reg, bit) (!read_bit(reg, bit)) +// Write value to n-th bit #define write_bit(reg, bit, value) do { (reg) = ((reg) & ~(1 << (uint8_t)(bit))) | (((uint8_t)(value) & 0x1) << (uint8_t)(bit)); } while(0) -#define set_bit(reg, bit, value) write_bit(reg, bit, value) -#define toggle_bit(reg, bit) do { (reg) ^= (1 << (uint8_t)(bit)); } while(0) +#define set_bit(reg, bit, value) write_bit(reg, bit, value) + +// Invert n-th bit +#define toggle_bit(reg, bit) do { (reg) ^= (1 << (uint8_t)(bit)); } while(0) -// general pin manipulation - with pointer to register -#define sbi_p(reg_p, bit) do { (*(reg_p)) |= (1 << (uint8_t)(bit)); } while(0) + +// --- Bit manipulation with pointer to variable --- + +// Set n-th bit in pointee +#define sbi_p(reg_p, bit) do { (*(reg_p)) |= (1 << (uint8_t)(bit)); } while(0) +// Clear n-th bit in pointee #define cbi_p(reg_p, bit) do { (*(reg_p)) &= ~(1 << (uint8_t)(bit)); } while(0) +// Get n-th bit in pointee #define read_bit_p(reg_p, bit) ((*(reg_p) >> (uint8_t)(bit)) & 0x1) -#define get_bit_p(reg_p, bit) read_bit_p(reg_p, bit) +#define get_bit_p(reg_p, bit) read_bit_p(reg_p, bit) +// Test n-th bit in pointee (Can't use bit_is_set, as it's redefined in sfr_def.h) +#define bit_is_high_p(reg_p, bit) read_bit_p(reg_p, bit) +#define bit_is_low_p(reg_p, bit) (!read_bit_p(reg_p, bit)) + +// Write value to a bit in pointee #define write_bit_p(reg_p, bit, value) do { *(reg_p) = (*(reg_p) & ~(1 << ((uint8_t)(bit) & 0x1))) | (((uint8_t)(value) & 0x1) << (uint8_t)(bit)); } while(0) -#define set_bit_p(reg, bit, value) write_bit_p(reg_p, bit, value) -#define toggle_bit_p(reg_p, bit) do { *(reg_p) ^= (1 << (uint8_t)(bit)); } while(0) +#define set_bit_p(reg_p, bit, value) write_bit_p(reg_p, bit, value) +#define toggle_bit_p(reg_p, bit) do { *(reg_p) ^= (1 << (uint8_t)(bit)); } while(0) + +// --- Nibble manipulation --- + +// Replace nibble in a byte #define write_low_nibble(reg, value) do { (reg) = ((reg) & 0xF0) | ((uint8_t)(value) & 0xF); } while(0) #define write_high_nibble(reg, value) do { (reg) = ((reg) & 0x0F) | (((uint8_t)(value) & 0xF) << 4); } while(0) +#define write_low_nibble_p(reg_p, value) do { *(reg_p) = (*(reg_p) & 0xF0) | ((uint8_t)(value) & 0xF); } while(0) +#define write_high_nibble_p(reg_p, value) do { *(reg_p) = (*(reg_p) & 0x0F) | (((uint8_t)(value) & 0xF) << 4); } while(0) + + +// --- Range tests --- -// Check if value is in range A..B or B..A -#define in_range(x, low, high) (((low) < (high)) && ((x) > (low) && (x) < (high))) || (((low) > (high)) && ((x) < (low) || (x) > (high))) +// Test if X is within low..high, regardless of bounds order +#define in_range(x, low, high) ((((low) < (high)) && ((x) >= (low) && (x) < (high))) || (((low) > (high)) && ((x) >= (high) && (x) < (low)))) +// ..., include greater bound +#define in_rangei(x, low, high) ((((low) <= (high)) && ((x) >= (low) && (x) <= (high))) || (((low) > (high)) && ((x) >= (high) && (x) <= (low)))) -// Check if value is in range A..B. If B < A, matches all outside B..A -#define in_range_wrap(x, low, high) (((low) < (high)) && ((x) > (low) && (x) < (high))) || (((low) > (high)) && ((x) > (low) || (x) < (high))) +// Test if X in low..high, wrap around ends if needed. +#define in_range_wrap(x, low, high) ((((low) < (high)) && ((x) >= (low) && (x) < (high))) || (((low) > (high)) && ((x) >= (low) || (x) < (high)))) +// ..., include upper bound +#define in_range_wrapi(x, low, high) ((((low) <= (high)) && ((x) >= (low) && (x) <= (high))) || (((low) > (high)) && ((x) >= (low) || (x) <= (high)))) diff --git a/devel/lib/debounce.h b/devel/lib/debounce.h index eaf233c..00c0587 100644 --- a/devel/lib/debounce.h +++ b/devel/lib/debounce.h @@ -49,9 +49,9 @@ /* Internal deboucer entry */ typedef struct { - PORT_P reg; - uint8_t bit; - uint8_t count; + PORT_P reg; // pointer to IO register + uint8_t bit; // bits 6 and 7 of this hold "state" & "invert" flag + uint8_t count; // number of ticks this was in the new state } debo_slot_t; /** Debounce data array */ @@ -101,4 +101,3 @@ void debo_tick() /** Get a value of debounced pin */ #define debo_get_pin(i) (get_bit(debo_slots[i].bit, 6) ^ get_bit(debo_slots[i].bit, 7)) -//(get_bit(debo_slots[i].bit, 6) ^ get_bit(debo_slots[i].bit, 7)) diff --git a/devel/lib/loops.h b/devel/lib/loops.h new file mode 100644 index 0000000..401c249 --- /dev/null +++ b/devel/lib/loops.h @@ -0,0 +1,25 @@ +#pragma once + +/** + Custom loops +*/ + +// Repeat code n times (uint8_t counter) +#define repeat(count) repeat_aux(count, _repeat_##__COUNTER__) +#define repeat_aux(count, cntvar) for (uint8_t cntvar = 0; cntvar < (count); cntvar++) + +// Repeat code n times (uint16_t counter) +#define repeatx(count) repeatx_aux(count, _repeatx_##__COUNTER__) +#define repeatx_aux(count, cntvar) for (uint16_t cntvar = 0; cntvar < (count); cntvar++) + +// Repeat with custom counter name (uint8_t) +#define loop(var, count) repeat_aux(count, var) +// ..., uint16_t +#define loopx(var, count) repeatx_aux(count, var) + +// Do until condition is met +#define until(what) while(!(what)) + +// Because why the hell not +#define whilst(what) while((what)) + diff --git a/devel/lib_tests/lib b/devel/lib_tests/lib new file mode 120000 index 0000000..62f3b3d --- /dev/null +++ b/devel/lib_tests/lib @@ -0,0 +1 @@ +/home/ondra/devel/avr/avr-projects/devel/lib \ No newline at end of file diff --git a/devel/lib_tests/run_tests.sh b/devel/lib_tests/run_tests.sh new file mode 100755 index 0000000..589f263 --- /dev/null +++ b/devel/lib_tests/run_tests.sh @@ -0,0 +1,8 @@ +#!/bin/bash + +dir=/tmp/avrclib_unittest + +[ -d "$dir" ] || mkdir "$dir" + +gcc test_calc.c -o "$dir/test_calc" && "$dir/test_calc" + diff --git a/devel/lib_tests/test_calc.c b/devel/lib_tests/test_calc.c new file mode 100644 index 0000000..595e528 --- /dev/null +++ b/devel/lib_tests/test_calc.c @@ -0,0 +1,356 @@ +#include +#include +#include +#include + +#include "lib/calc.h" + +void main() +{ + printf("== calc.h ==\n"); + + int i; + int a; + + printf("fn: inc_wrap()\n"); + { + // normal operation + a = 1; + inc_wrap(a, 0, 15); + assert(a == 2); + + // overflow + a = 14; + inc_wrap(a, 0, 15); + assert(a == 0); + } + + + printf("fn: inc_wrapi()\n"); + { + // normal operation + a = 1; + inc_wrapi(a, 0, 15); + assert(a == 2); + + // not overflow yet + a = 14; + inc_wrapi(a, 0, 15); + assert(a == 15); + + // overflow + a = 15; + inc_wrap(a, 0, 15); + assert(a == 0); + } + + + printf("fn: dec_wrap()\n"); + { + // normal operation + a = 5; + dec_wrap(a, 0, 15); + assert(a == 4); + + // underflow + a = 0; + dec_wrap(a, 0, 15); + assert(a == 14); + } + + + printf("fn: dec_wrapi()\n"); + { + // normal operation + a = 5; + dec_wrapi(a, 0, 15); + assert(a == 4); + + // underflow + a = 0; + dec_wrapi(a, 0, 15); + assert(a == 15); + } + + + printf("fn: sbi()\n"); + { + a = 0; + sbi(a, 2); + assert(a == 0b100); + } + + + printf("fn: cbi()\n"); + { + a = 0b11111; + cbi(a, 2); + assert(a == 0b11011); + } + + + printf("fn: read_bit()\n"); + { + a = 0b101; + assert(read_bit(a, 0) == 1); + assert(read_bit(a, 1) == 0); + assert(read_bit(a, 2) == 1); + } + + + printf("fn: bit_is_high()\n"); + { + a = 0b101; + assert(bit_is_high(a, 0) == 1); + assert(bit_is_high(a, 1) == 0); + assert(bit_is_high(a, 2) == 1); + } + + + printf("fn: bit_is_low()\n"); + { + a = 0b101; + assert(bit_is_low(a, 0) == 0); + assert(bit_is_low(a, 1) == 1); + assert(bit_is_low(a, 2) == 0); + } + + + printf("fn: toggle_bit()\n"); + { + a = 0; + toggle_bit(a, 2); + assert(a == 0b00100); + toggle_bit(a, 4); + assert(a == 0b10100); + toggle_bit(a, 4); + assert(a == 0b00100); + } + + // pointer variants + + int* b = &a; + + printf("fn: sbi_p()\n"); + { + *b = 0; + sbi_p(b, 2); + assert(*b == 0b100); + } + + + printf("fn: cbi_p()\n"); + { + *b = 0b11111; + cbi_p(b, 2); + assert(*b == 0b11011); + } + + + printf("fn: read_bit_p()\n"); + { + *b = 0b101; + assert(read_bit_p(b, 0) == 1); + assert(read_bit_p(b, 1) == 0); + assert(read_bit_p(b, 2) == 1); + } + + + printf("fn: bit_is_high_p()\n"); + { + *b = 0b101; + assert(bit_is_high_p(b, 0) == 1); + assert(bit_is_high_p(b, 1) == 0); + assert(bit_is_high_p(b, 2) == 1); + } + + + printf("fn: bit_is_low_p()\n"); + { + *b = 0b101; + assert(bit_is_low_p(b, 0) == 0); + assert(bit_is_low_p(b, 1) == 1); + assert(bit_is_low_p(b, 2) == 0); + } + + + printf("fn: toggle_bit_p()\n"); + { + *b = 0; + toggle_bit_p(b, 2); + assert(*b == 0b00100); + toggle_bit_p(b, 4); + assert(*b == 0b10100); + toggle_bit_p(b, 4); + assert(*b == 0b00100); + } + + + // -- nibbles -- + + printf("fn: write_low_nibble()\n"); + { + a = 0xAC; + write_low_nibble(a, 0x5); // shifted 4 left + assert(a == 0xA5); + + a = 0xAB; + write_low_nibble(a, 0x65); // shifted 4 left, extra ignored + assert(a == 0xA5); + } + + + printf("fn: write_high_nibble()\n"); + { + a = 0xAC; + write_high_nibble(a, 0x5); // shifted 4 left + assert(a == 0x5C); + + a = 0xAB; + write_high_nibble(a, 0x65); // shifted 4 left, extra ignored + assert(a == 0x5B); + } + + + printf("fn: write_low_nibble_p()\n"); + { + *b = 0xAC; + write_low_nibble_p(b, 0x5); // shifted 4 left + assert(*b == 0xA5); + + *b = 0xAB; + write_low_nibble_p(b, 0x65); // shifted 4 left, extra ignored + assert(*b == 0xA5); + } + + + printf("fn: write_high_nibble_p()\n"); + { + *b = 0xAC; + write_high_nibble_p(b, 0x5); // shifted 4 left + assert(*b == 0x5C); + + *b = 0xAB; + write_high_nibble_p(b, 0x65); // shifted 4 left, extra ignored + assert(*b == 0x5B); + } + + + printf("fn: in_range()\n"); + { + // regular + assert(in_range(10, 10, 15)); + assert(in_range(14, 10, 15)); + assert(in_range(13, 10, 15)); + // under + assert(!in_range(9, 10, 15)); + assert(!in_range(0, 10, 15)); + // above + assert(!in_range(15, 10, 15)); + assert(!in_range(99, 10, 15)); + + // swapped bounds + + // regular + assert(in_range(10, 15, 10)); + assert(in_range(14, 15, 10)); + assert(in_range(13, 15, 10)); + // under + assert(!in_range(9, 15, 10)); + assert(!in_range(0, 15, 10)); + // above + assert(!in_range(15, 15, 10)); + assert(!in_range(99, 15, 10)); + } + + + printf("fn: in_rangei()\n"); + { + // regular + assert(in_rangei(10, 10, 15)); + assert(in_rangei(15, 10, 15)); + assert(in_rangei(13, 10, 15)); + // under + assert(!in_rangei(9, 10, 15)); + assert(!in_rangei(0, 10, 15)); + // above + assert(!in_rangei(16, 10, 15)); + assert(!in_rangei(99, 10, 15)); + + // -- swapped bounds -- + + // regular + assert(in_rangei(10, 15, 10)); + assert(in_rangei(15, 15, 10)); + assert(in_rangei(13, 15, 10)); + // under + assert(!in_rangei(9, 15, 10)); + assert(!in_rangei(0, 15, 10)); + // above + assert(!in_rangei(16, 15, 10)); + assert(!in_rangei(99, 15, 10)); + } + + + printf("fn: in_range_wrap()\n"); + { + // as regular range + + // regular + assert(in_range_wrap(10, 10, 15)); + assert(in_range_wrap(14, 10, 15)); + assert(in_range_wrap(13, 10, 15)); + // under + assert(!in_range_wrap(9, 10, 15)); + assert(!in_range_wrap(0, 10, 15)); + // above + assert(!in_range_wrap(15, 10, 15)); + assert(!in_range_wrap(16, 10, 15)); + assert(!in_range_wrap(99, 10, 15)); + + // with wrap (>= 15, < 10) + + // regular + assert(!in_range_wrap(10, 15, 10)); + assert(!in_range_wrap(14, 15, 10)); + assert(!in_range_wrap(13, 15, 10)); + // under + assert(in_range_wrap(9, 15, 10)); + assert(in_range_wrap(0, 15, 10)); + // above + assert(in_range_wrap(16, 15, 10)); + assert(in_range_wrap(99, 15, 10)); + } + + + printf("fn: in_range_wrapi()\n"); + { + // as regular range + + // regular + assert(in_range_wrapi(10, 10, 15)); + assert(in_range_wrapi(15, 10, 15)); + assert(in_range_wrapi(13, 10, 15)); + // under + assert(!in_range_wrapi(9, 10, 15)); + assert(!in_range_wrapi(0, 10, 15)); + // above + assert(!in_range_wrapi(16, 10, 15)); + assert(!in_range_wrapi(99, 10, 15)); + + // with wrap (>= 15, < 10) + + // regular + assert(in_range_wrapi(10, 15, 10)); + assert(!in_range_wrapi(14, 15, 10)); + assert(!in_range_wrapi(13, 15, 10)); + // under + assert(in_range_wrapi(10, 15, 10)); + assert(in_range_wrapi(0, 15, 10)); + // above + assert(in_range_wrapi(16, 15, 10)); + assert(in_range_wrapi(99, 15, 10)); + } + + printf("== PASSED ==\n"); +} diff --git a/devel/lib_tests/test_loops_visual.c b/devel/lib_tests/test_loops_visual.c new file mode 100644 index 0000000..d604d56 --- /dev/null +++ b/devel/lib_tests/test_loops_visual.c @@ -0,0 +1,26 @@ +#include +#include +#include +#include + +#include "lib/loops.h" + +void main() +{ + repeat(5) printf("Five times!\n"); + repeatx(500) printf("."); + printf("\n"); + int i = 0; + until (i == 100) i++; + + whilst (i > 0) { + i--; + printf("i = %d\n", i); + } + + printf("\n"); + + loop(moo, 7) { + printf("moo = %d\n", moo); + } +} \ No newline at end of file diff --git a/projects/color-memory-game/lib/calc.h b/projects/color-memory-game/lib/calc.h index b4011e8..68ec190 100644 --- a/projects/color-memory-game/lib/calc.h +++ b/projects/color-memory-game/lib/calc.h @@ -4,11 +4,13 @@ General purpose calculation and bit manipulation utilities. */ -// if max, go to zero. Else increment. -#define inc_wrap(var, min, max) do { if ((var) >= (max)) { (var)=min; } else { (var)++; } } while(0) +// if max, go to zero. Else increment. wrape = wrap exclusive +#define inc_wrap(var, min, max) do { if ((var) >= (max - 1)) { (var) = (min); } else { (var)++; } } while(0) +#define inc_wrapi(var, min, max) inc_wrap((var), (min), (max) + 1) -// If zero, go to max. Else decrement, -#define dec_wrap(var, min, max) do { if ((var) > min) { (var)--; } else { (var)=(max); } } while(0) +// If zero, go to max. Else decrement. wrape = wrap exclusive +#define dec_wrap(var, min, max) do { if ((var) > (min)) { (var)--; } else { (var) = (max) - 1; } } while(0) +#define dec_wrapi(var, min, max) dec_wrap((var), (min), (max) + 1) // === general bit manipulation with register === #define sbi(reg, bit) do { (reg) |= (1 << (uint8_t)(bit)); } while(0) @@ -40,7 +42,9 @@ // Check if value is in range A..B or B..A -#define in_range(x, low, high) (((low) < (high)) && ((x) > (low) && (x) < (high))) || (((low) > (high)) && ((x) < (low) || (x) > (high))) +#define in_range(x, low, high) ((((low) < (high)) && ((x) >= (low) && (x) < (high))) || (((low) > (high)) && ((x) < (low) && (x) >= (high)))) +#define in_rangei(x, low, high) ((((low) <= (high)) && ((x) >= (low) && (x) <= (high))) || (((low) > (high)) && ((x) <= (low) && (x) >= (high)))) // Check if value is in range A..B. If B < A, matches all outside B..A -#define in_range_wrap(x, low, high) (((low) < (high)) && ((x) > (low) && (x) < (high))) || (((low) > (high)) && ((x) > (low) || (x) < (high))) +#define in_range_wrap(x, low, high) ((((low) < (high)) && ((x) >= (low) && (x) < (high))) || (((low) > (high)) && ((x) >= (low) || (x) < (high)))) +#define in_range_wrapi(x, low, high) ((((low) <= (high)) && ((x) >= (low) && (x) <= (high))) || (((low) > (high)) && ((x) >= (low) || (x) <= (high)))) diff --git a/projects/color-memory-game/main.c b/projects/color-memory-game/main.c index 9176b4b..ca743ba 100644 --- a/projects/color-memory-game/main.c +++ b/projects/color-memory-game/main.c @@ -17,48 +17,17 @@ #include "lib/debounce.h" - -// #define BOARD_WIDTH 6 -// #define BOARD_HEIGHT 5 -#define BOARD_WIDTH 6 -#define BOARD_HEIGHT 5 +#define WIDTH 6 +#define HEIGHT 5 // number of cards -#define CARD_COUNT (BOARD_WIDTH * BOARD_HEIGHT) - -// number of pairs -#define PAIR_COUNT (CARD_COUNT / 2) +#define CARD_COUNT (WIDTH * HEIGHT) // when the "small" pin is DOWN, only this many cards are dealt - on the same board size -#define CARD_COUNT_SMALL 12 +#define CARD_COUNT_SMALL WIDTH * 2 -// color palette -const xrgb_t COLORS[] = { - rgb24_xrgbc(0x00FF99), // emerald - rgb24_xrgbc(0x0000CC), // full blue - rgb24_xrgbc(0xFF00FF), // magenta - rgb24_xrgbc(0xFF0000), // red - rgb24_xrgbc(0xFF2B00), // orange - rgb24_xrgbc(0xFFFF00), // yellow - rgb24_xrgbc(0x0BEE00), // green - rgb24_xrgbc(0xFF6D00), // tangerine yellow/orange - rgb24_xrgbc(0x00CCCC), // cyan - rgb24_xrgbc(0x4400FF), // blue-purple - rgb24_xrgbc(0x5FBA00), // yellow-green - rgb24_xrgbc(0xD70053), // wine - rgb24_xrgbc(0xCD2B64), // brick - rgb24_xrgbc(0xED1B24), // firetruck red - rgb24_xrgbc(0xFF6D55), // salmon? -}; - - -// assert valid board size -#if CARD_COUNT % 2 == 1 -# error "Board size is not even!" -#endif - -// Pin assignments (see pins.h) +// --- Pin assignments (see pins.h) --- // RGB LED strip data line #define WS1 D10 @@ -71,7 +40,7 @@ const xrgb_t COLORS[] = { #define BTN_SELECT D6 #define BTN_RESTART D7 -// connect this pin to ground to get smaller board size (for kids ^^) +// Connect to GROUND to get small board size (for kids ^_^) #define FLAG_SMALL D12 // Debouncer channels for buttons @@ -88,10 +57,44 @@ const xrgb_t COLORS[] = { // entropy for the random number generator + +// number of pairs +#define PAIR_COUNT (CARD_COUNT / 2) + +// assert valid board size +#if CARD_COUNT % 2 == 1 +# error "CARD_COUNT is not even!" +#endif + +#if CARD_COUNT_SMALL % 2 == 1 +# error "CARD_COUNT_SMALL is not even!" +#endif + +// color palette +const xrgb_t COLORS[] = { + rgb24_xrgbc(0x0000CC), // full blue + rgb24_xrgbc(0x0BEE00), // green + rgb24_xrgbc(0xFFFF00), // yellow + rgb24_xrgbc(0xFF0000), // red + rgb24_xrgbc(0x00CCFF), // cyan + rgb24_xrgbc(0xFF3300), // orange + rgb24_xrgbc(0xFF00FF), // magenta + rgb24_xrgbc(0x00FF88), // emerald + rgb24_xrgbc(0x5FBA00), // yellow-green + rgb24_xrgbc(0xFF7700), // tangerine yellow/orange + rgb24_xrgbc(0x4400FF), // blue-purple + rgb24_xrgbc(0xD70053), // wine + rgb24_xrgbc(0xED1B24), // firetruck red + rgb24_xrgbc(0xFF6D55), // salmon? + rgb24_xrgbc(0xFF4C4C), // skin pink +}; + + // Prototypes void render(); void update(); void deal_cards(); +void safe_press_arrow_key(uint8_t n); /** Program initialization */ @@ -194,7 +197,10 @@ ISR(TIMER0_COMPA_vect) // player cursor position -uint8_t cursor = 0; +uint8_t pos_x = 0; +uint8_t pos_y = 0; +#define Cursor (pos_y * WIDTH + pos_x) + uint8_t animframe = 0; bool hide_timeout_match; @@ -220,46 +226,36 @@ void button_click(uint8_t n) { switch (n) { case D_UP: - if (cursor < BOARD_WIDTH) // first row - cursor += (CARD_COUNT - BOARD_WIDTH); - else - cursor -= BOARD_WIDTH; + dec_wrap(pos_y, 0, HEIGHT); break; case D_DOWN: - if (cursor >= (CARD_COUNT - BOARD_WIDTH)) // last row - cursor -= (CARD_COUNT - BOARD_WIDTH); - else - cursor += BOARD_WIDTH; + inc_wrap(pos_y, 0, HEIGHT); break; case D_LEFT: - if (cursor > 0) // last row - cursor--; - else - cursor = (CARD_COUNT - 1); + if (pos_x == 0) dec_wrap(pos_y, 0, HEIGHT); // go to previous row + dec_wrap(pos_x, 0, WIDTH); break; case D_RIGHT: - if (cursor < (CARD_COUNT - 1)) // last row - cursor++; - else - cursor = 0; + if (pos_x == WIDTH - 1) inc_wrap(pos_y, 0, HEIGHT); // go to next row + inc_wrap(pos_x, 0, WIDTH); break; case D_SELECT: if (tiles_revealed == 2) break; // two already shown - if (board[cursor].state != SECRET) break; // selected tile not secret + if (board[Cursor].state != SECRET) break; // selected tile not secret // reveal a tile if (tiles_revealed < 2) { - board[cursor].state = REVEALED; + board[Cursor].state = REVEALED; tiles_revealed++; if(tiles_revealed == 1) { - tile1 = cursor; + tile1 = Cursor; } else { - tile2 = cursor; + tile2 = Cursor; } } @@ -273,6 +269,9 @@ void button_click(uint8_t n) case D_RESTART: deal_cards(); + if (board[Cursor].state == GONE) + safe_press_arrow_key(D_RIGHT); + break; } } @@ -281,20 +280,49 @@ void button_click(uint8_t n) /** Press arrow key, skip empty tiles */ void safe_press_arrow_key(uint8_t n) { - // attempt to arrive at some secret tile - for (uint8_t j = 0; j < BOARD_HEIGHT; j++) { + // preserve old position + const uint8_t x1 = pos_x; + const uint8_t y1 = pos_y; + + if (n == D_LEFT || n == D_RIGHT) { - for (uint8_t k = 0; k < BOARD_WIDTH; k++) { + // traverse all buttons + for (uint8_t i = 0; i < CARD_COUNT; i++) { button_click(n); - if (board[cursor].state != GONE) break; + + if (board[Cursor].state != GONE) return; } - if (board[cursor].state != GONE) break; + } else { + + for (uint8_t i = 0; i < HEIGHT; i++) { + + // Go up/down + button_click(n); + if (board[Cursor].state != GONE) return; - // traverse right since current column is empty - // - button_click(D_RIGHT); + for (int8_t x = 0; x < WIDTH; x++) { + + if ((int8_t) pos_x - x >= 0) { + if (board[Cursor - x].state != GONE) { + pos_x -= x; + return; + } + } + + if ((int8_t) pos_x + x < WIDTH) { + if (board[Cursor + x].state != GONE) { + pos_x += x; + return; + } + } + } + } } + + // restore original position + pos_x = x1; + pos_y = y1; } @@ -331,10 +359,10 @@ void update() board[tile1].state = GONE; board[tile2].state = GONE; - if (board[cursor].state == GONE) { + if (board[Cursor].state == GONE) { // move to some other tile // try not to change row if possible - if ((cursor % BOARD_WIDTH) == (BOARD_WIDTH - 1)) + if ((Cursor % WIDTH) == (WIDTH - 1)) safe_press_arrow_key(D_LEFT); else safe_press_arrow_key(D_RIGHT); @@ -350,7 +378,7 @@ void update() } // Animation for pulsing the active color - inc_wrap(animframe, 0, F_ANIM_LEN * 2); + inc_wrapi(animframe, 0, F_ANIM_LEN * 2); } // LED off @@ -384,7 +412,7 @@ void render() } // pulse active tile - if (i == cursor) { + if (i == Cursor) { uint16_t mult; if (animframe < F_ANIM_LEN) {