From c3201fe3aa8a3b71d4d5ab9446ef3d16502e9518 Mon Sep 17 00:00:00 2001 From: MightyPork Date: Wed, 24 Dec 2014 01:53:59 +0100 Subject: [PATCH] macros for rendering array in WS strip, ADC lib, testing radnom --- devel/gamepad-test/main.c | 145 --- devel/lib/adc.h | 39 + devel/lib/calc.h | 6 + devel/lib/colors.h | 34 +- devel/lib/ws2812.h | 33 +- devel/{gamepad-test => memorygame}/Makefile | 0 devel/{gamepad-test => memorygame}/lib | 0 devel/memorygame/main.c | 185 ++++ devel/memorygame/main.pre | 973 ++++++++++++++++++++ 9 files changed, 1259 insertions(+), 156 deletions(-) delete mode 100644 devel/gamepad-test/main.c create mode 100644 devel/lib/adc.h rename devel/{gamepad-test => memorygame}/Makefile (100%) rename devel/{gamepad-test => memorygame}/lib (100%) create mode 100644 devel/memorygame/main.c create mode 100644 devel/memorygame/main.pre diff --git a/devel/gamepad-test/main.c b/devel/gamepad-test/main.c deleted file mode 100644 index cdca085..0000000 --- a/devel/gamepad-test/main.c +++ /dev/null @@ -1,145 +0,0 @@ -#include -#include -#include -// #include -#include - -#include "lib/meta.h" -#include "lib/arduino_pins.h" -#include "lib/calc.h" -#include "lib/colors.h" -#include "lib/ws2812.h" - -#define DEBO_CHANNELS 11 -#define DEBO_TICKS 1 // 0.01s - -#include "lib/debounce.h" - -#define WS1 D10 - -#define BTN_LEFT D2 -#define BTN_RIGHT D3 -#define BTN_UP D4 -#define BTN_DOWN D5 -#define BTN_A D6 -#define BTN_B D7 -#define BTN_AA D8 -#define BTN_BB D9 -#define BTN_SLOW D14 -#define BTN_START D15 -#define BTN_SELECT D16 - -void render(); - -void SECTION(".init8") init_io() -{ - // led strip data - as_output(WS1); - - // gamepad buttons - as_input_pu(BTN_LEFT); - as_input_pu(BTN_RIGHT); - as_input_pu(BTN_UP); - as_input_pu(BTN_DOWN); - - as_input_pu(BTN_A); - as_input_pu(BTN_B); - as_input_pu(BTN_AA); - as_input_pu(BTN_BB); - - as_input_pu(BTN_SLOW); - as_input_pu(BTN_START); - as_input_pu(BTN_SELECT); - - // set up debouncers - #define BTN_LEFT_D 0 - debo_add_rev(BTN_LEFT); - - #define BTN_RIGHT_D 1 - debo_add_rev(BTN_RIGHT); - - #define BTN_UP_D 2 - debo_add_rev(BTN_UP); - - #define BTN_DOWN_D 3 - debo_add_rev(BTN_DOWN); - - #define BTN_A_D 4 - debo_add_rev(BTN_A); - - #define BTN_B_D 5 - debo_add_rev(BTN_B); - - #define BTN_AA_D 6 - debo_add_rev(BTN_AA); - - #define BTN_BB_D 7 - debo_add_rev(BTN_BB); - - #define BTN_SLOW_D 8 - debo_add_rev(BTN_SLOW); - - #define BTN_START_D 9 - debo_add_rev(BTN_START); - - #define BTN_SELECT_D 10 - debo_add_rev(BTN_SELECT); - - - // setup timer 10 ms - TCCR0A = _BV(WGM01); // CTC - TCCR0B = _BV(CS02) | _BV(CS00); // prescaler 512 - OCR0A = 156; // interrupt every 10 ms - sbi(TIMSK0, OCIE0A); - sei(); -} - -/** timer 0 interrupt vector */ -ISR(TIMER0_COMPA_vect) -{ - debo_tick(); // poll debouncer - render(); -} - - -void render() -{ - const rgb24_t PINK = 0x970078; - const rgb24_t BLUE = 0x005397; - const rgb24_t RED = 0xFF0000; - const rgb24_t YELLOW = 0xFFFF00; - const rgb24_t BLACK = 0x000000; - - static rgb24_t table[12]; - - table[0] = debo_get_pin(BTN_LEFT_D) ? PINK : BLACK; - table[1] = debo_get_pin(BTN_RIGHT_D) ? PINK : BLACK; - table[2] = debo_get_pin(BTN_UP_D) ? PINK : BLACK; - table[3] = debo_get_pin(BTN_DOWN_D) ? PINK : BLACK; - table[4] = debo_get_pin(BTN_A_D) ? BLUE : BLACK; - table[5] = debo_get_pin(BTN_B_D) ? BLUE : BLACK; - table[6] = debo_get_pin(BTN_AA_D) ? BLUE : BLACK; - table[7] = debo_get_pin(BTN_BB_D) ? BLUE : BLACK; - table[8] = debo_get_pin(BTN_SELECT_D) ? RED : BLACK; - table[9] = debo_get_pin(BTN_START_D) ? RED : BLACK; - table[10] = debo_get_pin(BTN_SLOW_D) ? RED : BLACK; - table[11] = YELLOW; - - rgb24_t c; - for (uint8_t i=0; i<30; i++) { - - if (i < 12) - c = table[i]; - else - c = BLACK; - - ws_send_rgb24(WS1, c); - } -} - - -void main() -{ - // render(); - while(1) {} -} diff --git a/devel/lib/adc.h b/devel/lib/adc.h new file mode 100644 index 0000000..41e855c --- /dev/null +++ b/devel/lib/adc.h @@ -0,0 +1,39 @@ +#pragma once + +#include +#include +#include "calc.h" + +/** Initialize the ADC */ +void adc_init() +{ + ADCSRA |= _BV(ADPS2) | _BV(ADPS1) | _BV(ADPS0); // 128 prescaler -> 125 kHz + ADMUX |= _BV(REFS0); // Voltage reference + sbi(ADCSRA, ADEN); // Enable ADC +} + + +/** Sample analog pin with 8-bit precision */ +uint8_t adc_read_byte(uint8_t channel) +{ + write_low_nibble(ADMUX, channel); // Select channel to sample + sbi(ADMUX, ADLAR); // Align result to left + sbi(ADCSRA, ADSC); // Start conversion + + while(bit_is_high(ADCSRA, ADSC)); // Wait for it... + + return ADCH; // The upper 8 bits of ADC result +} + + +/** Sample analog pin with 10-bit precision */ +uint16_t adc_read_word(uint8_t channel) +{ + write_low_nibble(ADMUX, channel); // Select channel to sample + cbi(ADMUX, ADLAR); // Align result to right + sbi(ADCSRA, ADSC); // Start conversion + + while(get_bit(ADCSRA, ADSC)); // Wait for it... + + return ADCW; // The whole ADC word (10 bits) +} diff --git a/devel/lib/calc.h b/devel/lib/calc.h index df04dac..b4011e8 100644 --- a/devel/lib/calc.h +++ b/devel/lib/calc.h @@ -16,6 +16,9 @@ #define read_bit(reg, bit) ((((uint8_t)(reg)) >> (uint8_t)(bit)) & 0x1) #define get_bit(reg, bit) read_bit(reg, bit) +#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 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) @@ -32,6 +35,9 @@ #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 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) + // 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))) diff --git a/devel/lib/colors.h b/devel/lib/colors.h index fe3a7ec..cc1280c 100644 --- a/devel/lib/colors.h +++ b/devel/lib/colors.h @@ -2,6 +2,13 @@ /* Some useful utilities for RGB color manipulation + + The XXXc macros don't use cast, so they can be used in array initializers. + + xrgb ... 3-byte true-color RGB (8 bits per component) + rgbXX ... XX-bit color value, with equal nr of bits per component + + XX_r (_g, _b) ... extract component from the color, and convert it to 0..255 */ typedef struct { @@ -16,7 +23,9 @@ typedef uint16_t rgb12_t; typedef uint8_t rgb6_t; -#define xrgb(rr, gg, bb) ((xrgb_t) { .r = ((uint8_t)(rr)), .g = ((uint8_t)(gg)), .b = ((uint8_t)(bb)) }) +#define xrgb(rr, gg, bb) ((xrgb_t)xrgbc(rr, gg, bb)) +// xrgb for constant array declarations +#define xrgbc(rr, gg, bb) { .r = ((uint8_t)(rr)), .g = ((uint8_t)(gg)), .b = ((uint8_t)(bb)) } #define xrgb_r(c) ((uint8_t)(c.r)) #define xrgb_g(c) ((uint8_t)(c.g)) #define xrgb_b(c) ((uint8_t)(c.b)) @@ -26,34 +35,49 @@ typedef uint8_t rgb6_t; #define xrgb_rgb6(c) (((((rgb6_t)c.r) & 0xC0) >> 2) | ((((rgb6_t)c.g) & 0xC0) >> 4) | ((((rgb6_t)c.b) & 0xC0) >> 6)) -#define rgb24(r,g,b) ((rgb24_t) (((((rgb24_t)r) & 0xFF) << 16) | ((((rgb24_t)g) & 0xFF) << 8) | (((rgb24_t)b) & 0xFF))) +#define rgb24(r,g,b) (((((rgb24_t)r) & 0xFF) << 16) | ((((rgb24_t)g) & 0xFF) << 8) | (((rgb24_t)b) & 0xFF)) +#define rgb24c(r,g,b) ((rgb24_t) rgb24(r,g,b)) + #define rgb24_r(c) ((((rgb24_t) (c)) >> 16) & 0xFF) #define rgb24_g(c) ((((rgb24_t) (c)) >> 8) & 0xFF) #define rgb24_b(c) ((((rgb24_t) (c)) >> 0) & 0xFF) #define rgb24_xrgb(c) xrgb(rgb24_r(c), rgb24_g(c), rgb24_b(c)) +#define rgb24_xrgbc(c) xrgbc(rgb24_r(c), rgb24_g(c), rgb24_b(c)) -#define rgb15(r,g,b) ((rgb16_t) (((r & 0x1F) << 10) | ((g & 0x1F) << 5) | (b & 0x1F))) +#define rgb15(r,g,b) ((rgb16_t) rgb15c(r,g,b)) +#define rgb15c(r,g,b) (((r & 0x1F) << 10) | ((g & 0x1F) << 5) | (b & 0x1F)) + #define rgb15_r(c) ((((rgb15_t) (c)) & 0x7C00) >> 7) #define rgb15_g(c) ((((rgb15_t) (c)) & 0x3E0) >> 2) #define rgb15_b(c) ((((rgb15_t) (c)) & 0x1F) << 3) #define rgb15_xrgb(c) xrgb(rgb15_r(c), rgb15_g(c), rgb15_b(c)) #define rgb15_rgb24(c) rgb24(rgb15_r(c), rgb15_g(c), rgb15_b(c)) +#define rgb15_rgb24c(c) rgb24c(rgb15_r(c), rgb15_g(c), rgb15_b(c)) + +#define rgb12(r,g,b) ((rgb12_t) rgb12c(r,g,b)) +#define rgb12c(r,g,b) (((r & 0xF) << 8) | ((g & 0xF) << 4) | (b & 0xF)) -#define rgb12(r,g,b) ((rgb12_t) (((r & 0xF) << 8) | ((g & 0xF) << 4) | (b & 0xF))) #define rgb12_r(c) ((((rgb12_t) (c)) & 0xF00) >> 4) #define rgb12_g(c) (((rgb12_t) (c)) & 0xF0) #define rgb12_b(c) (((r(rgb12_t) (c)gb) & 0x0F) << 4) #define rgb12_xrgb(c) xrgb(rgb12_r(c), rgb12_g(c), rgb12_b(c)) +#define rgb12_xrgbc(c) xrgbc(rgb12_r(c), rgb12_g(c), rgb12_b(c)) #define rgb12_rgb24(c) rgb24(rgb12_r(c), rgb12_g(c), rgb12_b(c)) +#define rgb12_rgb24c(c) rgb24c(rgb12_r(c), rgb12_g(c), rgb12_b(c)) -#define rgb6(r,g,b) ((rgb6_t) (((r & 3) << 4) | ((g & 3) << 2) | (b & 3))) +#define rgb6(r,g,b) ((rgb6_t) rgb6c(r,g,b)) +#define rgb6c(r,g,b) (((r & 3) << 4) | ((g & 3) << 2) | (b & 3)) + #define rgb6_r(c) ((((rgb6_t) (c)) & 0x30) << 2) #define rgb6_g(c) ((((rgb6_t) (c)) & 0xC) << 4) #define rgb6_b(c) ((((rgb6_t) (c)) & 0x3) << 6) #define rgb6_xrgb(c) xrgb(rgb6_r(c), rgb6_g(c), rgb6_b(c)) +#define rgb6_xrgbc(c) xrgbc(rgb6_r(c), rgb6_g(c), rgb6_b(c)) #define rgb6_rgb24(c) rgb24(rgb6_r(c), rgb6_g(c), rgb6_b(c)) +#define rgb6_rgb24c(c) rgb24c(rgb6_r(c), rgb6_g(c), rgb6_b(c)) + #define add_xrgb(x, y) ((xrgb_t) { (((y).r > (255 - (x).r)) ? 255 : ((x).r + (y).r)), (((y).g > (255 - (x).g)) ? 255 : ((x).g + (y).g)), (((y).b > 255 - (x).b) ? 255 : ((x).b + (y).b)) }) diff --git a/devel/lib/ws2812.h b/devel/lib/ws2812.h index 815d250..3d6e0d6 100644 --- a/devel/lib/ws2812.h +++ b/devel/lib/ws2812.h @@ -4,11 +4,17 @@ Utils for driving a WS2812 (WS2812B) RGB LED strips. It's implemented as macros to avoid overhead when passing values, and to - enable driving multiple strips at once. There is over 1us of free time between - the colors, which can be used for some processing or color computation. + enable driving multiple strips at once. - To avoid bloating your code, try to reduce the nuýmber of invocations - + To avoid bloating your code, try to reduce the number of invocations - compute color and then send it. + + [IMPORTANT] + + Some seemingly random influences can ruin the communication. + If you have enough memory, consider preparing the colors in array, + and sending this array using one of the "ws_send_XXX_array" macros. + */ #include @@ -43,13 +49,13 @@ /** Wait long enough for the colors to show */ -#define ws_show() do { delay_ns_c(WS_T_LATCH, 0); } while(0) +#define ws_show() do {delay_ns_c(WS_T_LATCH, 0); } while(0) /** Send one byte to the RGB strip */ #define ws_send_byte(io, bb) do { \ - for (volatile int8_t __wsba_i = 7; __wsba_i >= 0; --__wsba_i) { \ - if ((bb) & (1 << __wsba_i)) { \ + for (volatile int8_t __ws_tmp = 7; __ws_tmp >= 0; --__ws_tmp) { \ + if ((bb) & (1 << __ws_tmp)) { \ pin_high(io_pack(io)); delay_ns_c(WS_T_1H, -2); \ pin_low(io_pack(io)); delay_ns_c(WS_T_1L, -10); \ } else { \ @@ -75,3 +81,18 @@ #define ws_send_rgb15(io, rgb) ws_send_rgb(io_pack(io), rgb15_r(rgb), rgb15_g(rgb), rgb15_b(rgb)) #define ws_send_rgb12(io, rgb) ws_send_rgb(io_pack(io), rgb12_r(rgb), rgb12_g(rgb), rgb12_b(rgb)) #define ws_send_rgb6(io, rgb) ws_send_rgb(io_pack(io), rgb6_r(rgb), rgb6_g(rgb), rgb6_b(rgb)) + +/** Send array of colors */ +#define ws_send_xrgb_array(io, rgbs, length) __ws_send_array_proto(io_pack(io), (rgbs), (length), xrgb) +#define ws_send_rgb24_array(io, rgbs, length) __ws_send_array_proto(io_pack(io), (rgbs), (length), rgb24) +#define ws_send_rgb15_array(io, rgbs, length) __ws_send_array_proto(io_pack(io), (rgbs), (length), rgb15) +#define ws_send_rgb12_array(io, rgbs, length) __ws_send_array_proto(io_pack(io), (rgbs), (length), rgb12) +#define ws_send_rgb6_array(io, rgbs, length) __ws_send_array_proto(io_pack(io), (rgbs), (length), rgb6) + +// prototype for sending array. it's ugly, sorry. +#define __ws_send_array_proto(io, rgbs, length, style) do { \ + for (uint8_t __ws_tmp_sap_i = 0; __ws_tmp_sap_i < length; __ws_tmp_sap_i++) { \ + style ## _t __ws_tmp_sap2 = (rgbs)[__ws_tmp_sap_i]; \ + ws_send_ ## style(io_pack(io), __ws_tmp_sap2); \ + } \ +} while(0) diff --git a/devel/gamepad-test/Makefile b/devel/memorygame/Makefile similarity index 100% rename from devel/gamepad-test/Makefile rename to devel/memorygame/Makefile diff --git a/devel/gamepad-test/lib b/devel/memorygame/lib similarity index 100% rename from devel/gamepad-test/lib rename to devel/memorygame/lib diff --git a/devel/memorygame/main.c b/devel/memorygame/main.c new file mode 100644 index 0000000..dff57cf --- /dev/null +++ b/devel/memorygame/main.c @@ -0,0 +1,185 @@ +#include +#include +#include +// #include +#include +#include + +#include "lib/meta.h" +#include "lib/arduino_pins.h" +#include "lib/calc.h" +#include "lib/colors.h" +#include "lib/ws2812.h" +#include "lib/adc.h" + +#define DEBO_CHANNELS 6 +#define DEBO_TICKS 1 // in 0.01s + +#include "lib/debounce.h" + + +#define BOARD_WIDTH 6 +#define BOARD_HEIGHT 5 +#define BOARD_LEN (BOARD_WIDTH * BOARD_HEIGHT) +#define TILE_COUNT (BOARD_LEN / 2) + +const xrgb_t COLORS[] = { + rgb24_xrgbc(0xB14835), // brick red + rgb24_xrgbc(0x4C1661), // indigo + rgb24_xrgbc(0xA3268E), // royal purple + rgb24_xrgbc(0x009ADA), // cobalt blue + rgb24_xrgbc(0x007D8F), // teal + rgb24_xrgbc(0x002E5A), // navy blue + rgb24_xrgbc(0x56BCC1), // turquoise + rgb24_xrgbc(0x01654D), // emerald dark + rgb24_xrgbc(0xF5864F), // papaya orange + rgb24_xrgbc(0xED1B24), // firetruck red + rgb24_xrgbc(0xFDAF17), // tangerine orange + rgb24_xrgbc(0xF58F83), // coral + rgb24_xrgbc(0xED008C), // magenta + rgb24_xrgbc(0xFEF200), // sunshine yellow + rgb24_xrgbc(0x6D9346), // treetop green +}; + + +// assert valid board size +#if BOARD_LEN % 2 == 1 +# error "Board size is not even!" +#endif + + +#define WS1 D10 + +#define BTN_LEFT D2 +#define BTN_RIGHT D3 +#define BTN_UP D4 +#define BTN_DOWN D5 +#define BTN_SELECT D6 +#define BTN_RESTART D7 + +// Debouncer channels for buttons +// (Must be added in this order to debouncer) +#define D_LEFT 0 +#define D_RIGHT 1 +#define D_UP 2 +#define D_DOWN 3 +#define D_SELECT 4 +#define D_RESTART 5 + +// Pin A0 not connected to anything, used to get +// entropy for random number generator + +// Prototypes +void render(); +void update(); + + +void SECTION(".init8") init() +{ + adc_init(); // Initialize ADC + srand(adc_read_word(0)); // Randomize RNG + + // led strip data + as_output(WS1); + + // gamepad buttons + as_input_pu(BTN_LEFT); + as_input_pu(BTN_RIGHT); + as_input_pu(BTN_UP); + as_input_pu(BTN_DOWN); + as_input_pu(BTN_SELECT); + as_input_pu(BTN_RESTART); + + // add buttons to debouncer + debo_add_rev(BTN_LEFT); + debo_add_rev(BTN_RIGHT); + debo_add_rev(BTN_UP); + debo_add_rev(BTN_DOWN); + debo_add_rev(BTN_SELECT); + debo_add_rev(BTN_RESTART); + + // setup timer + TCCR0A = _BV(WGM01); // CTC + TCCR0B = _BV(CS02) | _BV(CS00); // prescaler 1024 + OCR0A = 156; // interrupt every 10 ms + sbi(TIMSK0, OCIE0A); + + + sei(); +} + + +/** timer 0 interrupt vector */ +ISR(TIMER0_COMPA_vect) +{ + //debo_tick(); // poll debouncer + update(); // update game state + render(); +} + + +void main() +{ + while(1); // Timer does everything +} + + +/** Tile state enum */ +typedef enum { + SECRET, + REVEALED, + GONE +} tilestate_t; + + +/** Tile struct */ +typedef struct { + uint8_t color; // color index from COLORS[] + tilestate_t state; // state of the tile (used for render) +} tile_t; + + +// board tiles +tile_t board[BOARD_LEN]; + +// player cursor position +uint8_t cursor = 0; + +uint8_t noise = 0; +uint8_t xxx = 0; + +/** Update game */ +void update() +{ + if(xxx++ >= 10) { + noise = rand(); + xxx = 0; + } +} + + +// colors to be displayed +rgb24_t screen[BOARD_LEN]; + +/** Update screen[] and send to display */ +void render() +{ + #define BLUE 0x005397 + #define RED 0xFF0000 + #define YELLOW 0xFFFF00 + #define BLACK 0x000000 + + for (uint8_t i = 0; i < BOARD_LEN; i++) { + if (i < 8) { + screen[i] = get_bit(noise, i) ? RED : BLUE; + } else { + screen[i] = YELLOW; + } + } + + // debo_get_pin(BTN_LEFT_D) ? PINK : BLACK; + + ws_send_rgb24_array(WS1, screen, BOARD_LEN); + ws_show(); +} + diff --git a/devel/memorygame/main.pre b/devel/memorygame/main.pre new file mode 100644 index 0000000..21d77c1 --- /dev/null +++ b/devel/memorygame/main.pre @@ -0,0 +1,973 @@ +# 1 "main.c" +# 1 "/home/ondra/git/avr-projects/devel/memorygame//" +# 1 "" +# 1 "" +# 1 "main.c" +# 1 "/usr/avr/include/avr/io.h" 1 3 +# 99 "/usr/avr/include/avr/io.h" 3 +# 1 "/usr/avr/include/avr/sfr_defs.h" 1 3 +# 126 "/usr/avr/include/avr/sfr_defs.h" 3 +# 1 "/usr/avr/include/inttypes.h" 1 3 +# 37 "/usr/avr/include/inttypes.h" 3 +# 1 "/usr/lib/gcc/avr/4.9.2/include/stdint.h" 1 3 4 +# 9 "/usr/lib/gcc/avr/4.9.2/include/stdint.h" 3 4 +# 1 "/usr/avr/include/stdint.h" 1 3 4 +# 122 "/usr/avr/include/stdint.h" 3 4 +typedef signed int int8_t __attribute__((__mode__(__QI__))); +typedef unsigned int uint8_t __attribute__((__mode__(__QI__))); +typedef signed int int16_t __attribute__ ((__mode__ (__HI__))); +typedef unsigned int uint16_t __attribute__ ((__mode__ (__HI__))); +typedef signed int int32_t __attribute__ ((__mode__ (__SI__))); +typedef unsigned int uint32_t __attribute__ ((__mode__ (__SI__))); + +typedef signed int int64_t __attribute__((__mode__(__DI__))); +typedef unsigned int uint64_t __attribute__((__mode__(__DI__))); +# 143 "/usr/avr/include/stdint.h" 3 4 +typedef int16_t intptr_t; + + + + +typedef uint16_t uintptr_t; +# 160 "/usr/avr/include/stdint.h" 3 4 +typedef int8_t int_least8_t; + + + + +typedef uint8_t uint_least8_t; + + + + +typedef int16_t int_least16_t; + + + + +typedef uint16_t uint_least16_t; + + + + +typedef int32_t int_least32_t; + + + + +typedef uint32_t uint_least32_t; + + + + + + + +typedef int64_t int_least64_t; + + + + + + +typedef uint64_t uint_least64_t; +# 214 "/usr/avr/include/stdint.h" 3 4 +typedef int8_t int_fast8_t; + + + + +typedef uint8_t uint_fast8_t; + + + + +typedef int16_t int_fast16_t; + + + + +typedef uint16_t uint_fast16_t; + + + + +typedef int32_t int_fast32_t; + + + + +typedef uint32_t uint_fast32_t; + + + + + + + +typedef int64_t int_fast64_t; + + + + + + +typedef uint64_t uint_fast64_t; +# 274 "/usr/avr/include/stdint.h" 3 4 +typedef int64_t intmax_t; + + + + +typedef uint64_t uintmax_t; +# 10 "/usr/lib/gcc/avr/4.9.2/include/stdint.h" 2 3 4 +# 38 "/usr/avr/include/inttypes.h" 2 3 +# 77 "/usr/avr/include/inttypes.h" 3 +typedef int32_t int_farptr_t; + + + +typedef uint32_t uint_farptr_t; +# 127 "/usr/avr/include/avr/sfr_defs.h" 2 3 +# 100 "/usr/avr/include/avr/io.h" 2 3 +# 248 "/usr/avr/include/avr/io.h" 3 +# 1 "/usr/avr/include/avr/iom328p.h" 1 3 +# 249 "/usr/avr/include/avr/io.h" 2 3 +# 534 "/usr/avr/include/avr/io.h" 3 +# 1 "/usr/avr/include/avr/portpins.h" 1 3 +# 535 "/usr/avr/include/avr/io.h" 2 3 + +# 1 "/usr/avr/include/avr/common.h" 1 3 +# 537 "/usr/avr/include/avr/io.h" 2 3 + +# 1 "/usr/avr/include/avr/version.h" 1 3 +# 539 "/usr/avr/include/avr/io.h" 2 3 + + + + + + +# 1 "/usr/avr/include/avr/fuse.h" 1 3 +# 239 "/usr/avr/include/avr/fuse.h" 3 +typedef struct +{ + unsigned char low; + unsigned char high; + unsigned char extended; +} __fuse_t; +# 546 "/usr/avr/include/avr/io.h" 2 3 + + +# 1 "/usr/avr/include/avr/lock.h" 1 3 +# 549 "/usr/avr/include/avr/io.h" 2 3 +# 2 "main.c" 2 +# 1 "/usr/avr/include/avr/interrupt.h" 1 3 +# 3 "main.c" 2 +# 1 "/usr/avr/include/util/delay.h" 1 3 +# 43 "/usr/avr/include/util/delay.h" 3 +# 1 "/usr/avr/include/util/delay_basic.h" 1 3 +# 40 "/usr/avr/include/util/delay_basic.h" 3 +static inline void _delay_loop_1(uint8_t __count) __attribute__((always_inline)); +static inline void _delay_loop_2(uint16_t __count) __attribute__((always_inline)); +# 80 "/usr/avr/include/util/delay_basic.h" 3 +void +_delay_loop_1(uint8_t __count) +{ + __asm__ volatile ( + "1: dec %0" "\n\t" + "brne 1b" + : "=r" (__count) + : "0" (__count) + ); +} +# 102 "/usr/avr/include/util/delay_basic.h" 3 +void +_delay_loop_2(uint16_t __count) +{ + __asm__ volatile ( + "1: sbiw %0,1" "\n\t" + "brne 1b" + : "=w" (__count) + : "0" (__count) + ); +} +# 44 "/usr/avr/include/util/delay.h" 2 3 +# 1 "/usr/avr/include/math.h" 1 3 +# 127 "/usr/avr/include/math.h" 3 +extern double cos(double __x) __attribute__((__const__)); + + + + + +extern double sin(double __x) __attribute__((__const__)); + + + + + +extern double tan(double __x) __attribute__((__const__)); + + + + + + +extern double fabs(double __x) __attribute__((__const__)); + + + + + + +extern double fmod(double __x, double __y) __attribute__((__const__)); +# 168 "/usr/avr/include/math.h" 3 +extern double modf(double __x, double *__iptr); + + + +extern float modff (float __x, float *__iptr); + + + + +extern double sqrt(double __x) __attribute__((__const__)); +extern float sqrtf (float) __attribute__((__const__)); + + + + +extern double cbrt(double __x) __attribute__((__const__)); +# 194 "/usr/avr/include/math.h" 3 +extern double hypot (double __x, double __y) __attribute__((__const__)); + + + + + + + +extern double square(double __x) __attribute__((__const__)); + + + + + + +extern double floor(double __x) __attribute__((__const__)); + + + + + + +extern double ceil(double __x) __attribute__((__const__)); +# 234 "/usr/avr/include/math.h" 3 +extern double frexp(double __x, int *__pexp); + + + + + + + +extern double ldexp(double __x, int __exp) __attribute__((__const__)); + + + + + +extern double exp(double __x) __attribute__((__const__)); + + + + + +extern double cosh(double __x) __attribute__((__const__)); + + + + + +extern double sinh(double __x) __attribute__((__const__)); + + + + + +extern double tanh(double __x) __attribute__((__const__)); + + + + + + + +extern double acos(double __x) __attribute__((__const__)); + + + + + + + +extern double asin(double __x) __attribute__((__const__)); + + + + + + +extern double atan(double __x) __attribute__((__const__)); +# 298 "/usr/avr/include/math.h" 3 +extern double atan2(double __y, double __x) __attribute__((__const__)); + + + + + +extern double log(double __x) __attribute__((__const__)); + + + + + +extern double log10(double __x) __attribute__((__const__)); + + + + + +extern double pow(double __x, double __y) __attribute__((__const__)); + + + + + + +extern int isnan(double __x) __attribute__((__const__)); +# 333 "/usr/avr/include/math.h" 3 +extern int isinf(double __x) __attribute__((__const__)); + + + + + + +__attribute__((__const__)) static inline int isfinite (double __x) +{ + unsigned char __exp; + __asm__ ( + "mov %0, %C1 \n\t" + "lsl %0 \n\t" + "mov %0, %D1 \n\t" + "rol %0 " + : "=r" (__exp) + : "r" (__x) ); + return __exp != 0xff; +} + + + + + + +__attribute__((__const__)) static inline double copysign (double __x, double __y) +{ + __asm__ ( + "bst %D2, 7 \n\t" + "bld %D0, 7 " + : "=r" (__x) + : "0" (__x), "r" (__y) ); + return __x; +} +# 376 "/usr/avr/include/math.h" 3 +extern int signbit (double __x) __attribute__((__const__)); + + + + + + +extern double fdim (double __x, double __y) __attribute__((__const__)); +# 392 "/usr/avr/include/math.h" 3 +extern double fma (double __x, double __y, double __z) __attribute__((__const__)); + + + + + + + +extern double fmax (double __x, double __y) __attribute__((__const__)); + + + + + + + +extern double fmin (double __x, double __y) __attribute__((__const__)); + + + + + + +extern double trunc (double __x) __attribute__((__const__)); +# 426 "/usr/avr/include/math.h" 3 +extern double round (double __x) __attribute__((__const__)); +# 439 "/usr/avr/include/math.h" 3 +extern long lround (double __x) __attribute__((__const__)); +# 453 "/usr/avr/include/math.h" 3 +extern long lrint (double __x) __attribute__((__const__)); +# 45 "/usr/avr/include/util/delay.h" 2 3 +# 84 "/usr/avr/include/util/delay.h" 3 +static inline void _delay_us(double __us) __attribute__((always_inline)); +static inline void _delay_ms(double __ms) __attribute__((always_inline)); +# 141 "/usr/avr/include/util/delay.h" 3 +void +_delay_ms(double __ms) +{ + double __tmp ; +# 166 "/usr/avr/include/util/delay.h" 3 + uint16_t __ticks; + __tmp = ((16000000UL) / 4e3) * __ms; + if (__tmp < 1.0) + __ticks = 1; + else if (__tmp > 65535) + { + + __ticks = (uint16_t) (__ms * 10.0); + while(__ticks) + { + + _delay_loop_2(((16000000UL) / 4e3) / 10); + __ticks --; + } + return; + } + else + __ticks = (uint16_t)__tmp; + _delay_loop_2(__ticks); + +} +# 223 "/usr/avr/include/util/delay.h" 3 +void +_delay_us(double __us) +{ + double __tmp ; +# 248 "/usr/avr/include/util/delay.h" 3 + uint8_t __ticks; + double __tmp2 ; + __tmp = ((16000000UL) / 3e6) * __us; + __tmp2 = ((16000000UL) / 4e6) * __us; + if (__tmp < 1.0) + __ticks = 1; + else if (__tmp2 > 65535) + { + _delay_ms(__us / 1000.0); + } + else if (__tmp > 255) + { + uint16_t __ticks=(uint16_t)__tmp2; + _delay_loop_2(__ticks); + return; + } + else + __ticks = (uint8_t)__tmp; + _delay_loop_1(__ticks); + +} +# 4 "main.c" 2 + + +# 1 "/usr/avr/include/stdlib.h" 1 3 +# 47 "/usr/avr/include/stdlib.h" 3 +# 1 "/usr/lib/gcc/avr/4.9.2/include/stddef.h" 1 3 4 +# 212 "/usr/lib/gcc/avr/4.9.2/include/stddef.h" 3 4 +typedef unsigned int size_t; +# 324 "/usr/lib/gcc/avr/4.9.2/include/stddef.h" 3 4 +typedef int wchar_t; +# 48 "/usr/avr/include/stdlib.h" 2 3 +# 68 "/usr/avr/include/stdlib.h" 3 +typedef struct { + int quot; + int rem; +} div_t; + + +typedef struct { + long quot; + long rem; +} ldiv_t; + + +typedef int (*__compar_fn_t)(const void *, const void *); +# 114 "/usr/avr/include/stdlib.h" 3 +extern void abort(void) __attribute__((__noreturn__)); + + + + +extern int abs(int __i) __attribute__((__const__)); +# 128 "/usr/avr/include/stdlib.h" 3 +extern long labs(long __i) __attribute__((__const__)); +# 151 "/usr/avr/include/stdlib.h" 3 +extern void *bsearch(const void *__key, const void *__base, size_t __nmemb, + size_t __size, int (*__compar)(const void *, const void *)); + + + + + + + +extern div_t div(int __num, int __denom) __asm__("__divmodhi4") __attribute__((__const__)); + + + + + +extern ldiv_t ldiv(long __num, long __denom) __asm__("__divmodsi4") __attribute__((__const__)); +# 183 "/usr/avr/include/stdlib.h" 3 +extern void qsort(void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar); +# 216 "/usr/avr/include/stdlib.h" 3 +extern long strtol(const char *__nptr, char **__endptr, int __base); +# 250 "/usr/avr/include/stdlib.h" 3 +extern unsigned long strtoul(const char *__nptr, char **__endptr, int __base); +# 262 "/usr/avr/include/stdlib.h" 3 +extern long atol(const char *__s) __attribute__((__pure__)); +# 274 "/usr/avr/include/stdlib.h" 3 +extern int atoi(const char *__s) __attribute__((__pure__)); +# 286 "/usr/avr/include/stdlib.h" 3 +extern void exit(int __status) __attribute__((__noreturn__)); +# 298 "/usr/avr/include/stdlib.h" 3 +extern void *malloc(size_t __size) __attribute__((__malloc__)); + + + + + + +extern void free(void *__ptr); + + + + +extern size_t __malloc_margin; + + + + +extern char *__malloc_heap_start; + + + + +extern char *__malloc_heap_end; + + + + + + +extern void *calloc(size_t __nele, size_t __size) __attribute__((__malloc__)); +# 346 "/usr/avr/include/stdlib.h" 3 +extern void *realloc(void *__ptr, size_t __size) __attribute__((__malloc__)); + +extern double strtod(const char *__nptr, char **__endptr); + +extern double atof(const char *__nptr); +# 372 "/usr/avr/include/stdlib.h" 3 +extern int rand(void); + + + +extern void srand(unsigned int __seed); + + + + + + +extern int rand_r(unsigned long *__ctx); +# 417 "/usr/avr/include/stdlib.h" 3 +extern __inline__ __attribute__((__gnu_inline__)) +char *itoa (int __val, char *__s, int __radix) +{ + if (!__builtin_constant_p (__radix)) { + extern char *__itoa (int, char *, int); + return __itoa (__val, __s, __radix); + } else if (__radix < 2 || __radix > 36) { + *__s = 0; + return __s; + } else { + extern char *__itoa_ncheck (int, char *, unsigned char); + return __itoa_ncheck (__val, __s, __radix); + } +} +# 462 "/usr/avr/include/stdlib.h" 3 +extern __inline__ __attribute__((__gnu_inline__)) +char *ltoa (long __val, char *__s, int __radix) +{ + if (!__builtin_constant_p (__radix)) { + extern char *__ltoa (long, char *, int); + return __ltoa (__val, __s, __radix); + } else if (__radix < 2 || __radix > 36) { + *__s = 0; + return __s; + } else { + extern char *__ltoa_ncheck (long, char *, unsigned char); + return __ltoa_ncheck (__val, __s, __radix); + } +} +# 505 "/usr/avr/include/stdlib.h" 3 +extern __inline__ __attribute__((__gnu_inline__)) +char *utoa (unsigned int __val, char *__s, int __radix) +{ + if (!__builtin_constant_p (__radix)) { + extern char *__utoa (unsigned int, char *, int); + return __utoa (__val, __s, __radix); + } else if (__radix < 2 || __radix > 36) { + *__s = 0; + return __s; + } else { + extern char *__utoa_ncheck (unsigned int, char *, unsigned char); + return __utoa_ncheck (__val, __s, __radix); + } +} +# 547 "/usr/avr/include/stdlib.h" 3 +extern __inline__ __attribute__((__gnu_inline__)) +char *ultoa (unsigned long __val, char *__s, int __radix) +{ + if (!__builtin_constant_p (__radix)) { + extern char *__ultoa (unsigned long, char *, int); + return __ultoa (__val, __s, __radix); + } else if (__radix < 2 || __radix > 36) { + *__s = 0; + return __s; + } else { + extern char *__ultoa_ncheck (unsigned long, char *, unsigned char); + return __ultoa_ncheck (__val, __s, __radix); + } +} +# 579 "/usr/avr/include/stdlib.h" 3 +extern long random(void); + + + + +extern void srandom(unsigned long __seed); + + + + + + + +extern long random_r(unsigned long *__ctx); +# 638 "/usr/avr/include/stdlib.h" 3 +extern char *dtostre(double __val, char *__s, unsigned char __prec, + unsigned char __flags); +# 655 "/usr/avr/include/stdlib.h" 3 +extern char *dtostrf(double __val, signed char __width, + unsigned char __prec, char *__s); +# 672 "/usr/avr/include/stdlib.h" 3 +extern int atexit(void (*)(void)); +extern int system (const char *); +extern char *getenv (const char *); +# 7 "main.c" 2 + +# 1 "lib/meta.h" 1 + +# 9 "main.c" 2 +# 1 "lib/arduino_pins.h" 1 + + + + + + +# 1 "lib/pins.h" 1 + +# 30 "lib/pins.h" +# 1 "lib/calc.h" 1 + +# 31 "lib/pins.h" 2 +# 51 "lib/pins.h" +typedef volatile uint8_t* PORT_P; + +typedef uint8_t BIT_N; +# 8 "lib/arduino_pins.h" 2 +# 10 "main.c" 2 + +# 1 "lib/colors.h" 1 + + + + + + +typedef struct { + uint8_t r; + uint8_t g; + uint8_t b; +} xrgb_t; + +typedef uint32_t rgb24_t; +typedef uint16_t rgb16_t; +typedef uint16_t rgb12_t; +typedef uint8_t rgb6_t; +# 12 "main.c" 2 +# 1 "lib/ws2812.h" 1 + +# 15 "lib/ws2812.h" +# 1 "/usr/avr/include/avr/cpufunc.h" 1 3 +# 16 "lib/ws2812.h" 2 + + +# 1 "lib/nsdelay.h" 1 + +# 19 "lib/ws2812.h" 2 +# 13 "main.c" 2 +# 1 "lib/adc.h" 1 + + + +# 1 "/usr/lib/gcc/avr/4.9.2/include/stdbool.h" 1 3 4 +# 5 "lib/adc.h" 2 + + + +void adc_init() +{ + (*(volatile uint8_t *)(0x7A)) |= (1 << (2)) | (1 << (1)) | (1 << (0)); + (*(volatile uint8_t *)(0x7C)) |= (1 << (6)); + do { ((*(volatile uint8_t *)(0x7A))) |= (1 << (uint8_t)(7)); } while(0); +} + + + +uint8_t adc_read_byte(uint8_t channel) +{ + do { ((*(volatile uint8_t *)(0x7C))) = (((*(volatile uint8_t *)(0x7C))) & 0xF0) | ((uint8_t)(channel) & 0xF); } while(0); + do { ((*(volatile uint8_t *)(0x7C))) |= (1 << (uint8_t)(5)); } while(0); + do { ((*(volatile uint8_t *)(0x7A))) |= (1 << (uint8_t)(6)); } while(0); + + while(((((uint8_t)((*(volatile uint8_t *)(0x7A)))) >> (uint8_t)(6)) & 0x1)); + + return (*(volatile uint8_t *)(0x79)); +} + + + +uint16_t adc_read_word(uint8_t channel) +{ + do { ((*(volatile uint8_t *)(0x7C))) = (((*(volatile uint8_t *)(0x7C))) & 0xF0) | ((uint8_t)(channel) & 0xF); } while(0); + do { ((*(volatile uint8_t *)(0x7C))) &= ~(1 << (uint8_t)(5)); } while(0); + do { ((*(volatile uint8_t *)(0x7A))) |= (1 << (uint8_t)(6)); } while(0); + + while(((((uint8_t)((*(volatile uint8_t *)(0x7A)))) >> (uint8_t)(6)) & 0x1)); + + return (*(volatile uint16_t *)(0x78)); +} +# 14 "main.c" 2 + + + + +# 1 "lib/debounce.h" 1 + +# 51 "lib/debounce.h" +typedef struct { + PORT_P reg; + uint8_t bit; + uint8_t count; +} debo_slot_t; + + +debo_slot_t debo_slots[6]; +uint8_t debo_next_slot = 0; + + + + + + +uint8_t debo_register(PORT_P reg, uint8_t bit, _Bool invert) +{ + debo_slots[debo_next_slot] = (debo_slot_t){ + .reg = reg, + .bit = bit | ((invert & 1) << 7) | (((*(reg) >> (uint8_t)(bit)) & 0x1) << 6), + .count = 0, + }; + + return debo_next_slot++; +} + + + +void debo_tick() +{ + for (uint8_t i = 0; i < debo_next_slot; i++) { + + _Bool value = ((*(debo_slots[i].reg) >> (uint8_t)(debo_slots[i].bit & 0x7)) & 0x1); + + if (value != ((((uint8_t)(debo_slots[i].bit)) >> (uint8_t)(6)) & 0x1)) { + + + if (debo_slots[i].count < 1) { + debo_slots[i].count++; + } else { + + do { (debo_slots[i].bit) = ((debo_slots[i].bit) & ~(1 << (uint8_t)(6))) | (((uint8_t)(value) & 0x1) << (uint8_t)(6)); } while(0); + debo_slots[i].count = 0; + } + } else { + debo_slots[i].count = 0; + } + } +} +# 19 "main.c" 2 + + + + + + + +const xrgb_t COLORS[] = { + { .r = ((uint8_t)(((((rgb24_t) (0xB14835)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0xB14835)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0xB14835)) >> 0) & 0xFF))) }, + { .r = ((uint8_t)(((((rgb24_t) (0x4C1661)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0x4C1661)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0x4C1661)) >> 0) & 0xFF))) }, + { .r = ((uint8_t)(((((rgb24_t) (0xA3268E)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0xA3268E)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0xA3268E)) >> 0) & 0xFF))) }, + { .r = ((uint8_t)(((((rgb24_t) (0x009ADA)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0x009ADA)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0x009ADA)) >> 0) & 0xFF))) }, + { .r = ((uint8_t)(((((rgb24_t) (0x007D8F)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0x007D8F)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0x007D8F)) >> 0) & 0xFF))) }, + { .r = ((uint8_t)(((((rgb24_t) (0x002E5A)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0x002E5A)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0x002E5A)) >> 0) & 0xFF))) }, + { .r = ((uint8_t)(((((rgb24_t) (0x56BCC1)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0x56BCC1)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0x56BCC1)) >> 0) & 0xFF))) }, + { .r = ((uint8_t)(((((rgb24_t) (0x01654D)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0x01654D)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0x01654D)) >> 0) & 0xFF))) }, + { .r = ((uint8_t)(((((rgb24_t) (0xF5864F)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0xF5864F)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0xF5864F)) >> 0) & 0xFF))) }, + { .r = ((uint8_t)(((((rgb24_t) (0xED1B24)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0xED1B24)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0xED1B24)) >> 0) & 0xFF))) }, + { .r = ((uint8_t)(((((rgb24_t) (0xFDAF17)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0xFDAF17)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0xFDAF17)) >> 0) & 0xFF))) }, + { .r = ((uint8_t)(((((rgb24_t) (0xF58F83)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0xF58F83)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0xF58F83)) >> 0) & 0xFF))) }, + { .r = ((uint8_t)(((((rgb24_t) (0xED008C)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0xED008C)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0xED008C)) >> 0) & 0xFF))) }, + { .r = ((uint8_t)(((((rgb24_t) (0xFEF200)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0xFEF200)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0xFEF200)) >> 0) & 0xFF))) }, + { .r = ((uint8_t)(((((rgb24_t) (0x6D9346)) >> 16) & 0xFF))), .g = ((uint8_t)(((((rgb24_t) (0x6D9346)) >> 8) & 0xFF))), .b = ((uint8_t)(((((rgb24_t) (0x6D9346)) >> 0) & 0xFF))) }, +}; +# 73 "main.c" +void render(); +void update(); + + +void __attribute__((naked, used, section(".init8"))) init() +{ + + + + + do { ((*(volatile uint8_t *)((0x04) + 0x20))) |= (1 << (uint8_t)((2))); } while(0); + + + do { do { ((*(volatile uint8_t *)((0x0A) + 0x20))) &= ~(1 << (uint8_t)((2))); } while(0); do { ((*(volatile uint8_t *)((0x0B) + 0x20))) |= (1 << (uint8_t)((2))); } while(0); } while(0); + do { do { ((*(volatile uint8_t *)((0x0A) + 0x20))) &= ~(1 << (uint8_t)((3))); } while(0); do { ((*(volatile uint8_t *)((0x0B) + 0x20))) |= (1 << (uint8_t)((3))); } while(0); } while(0); + do { do { ((*(volatile uint8_t *)((0x0A) + 0x20))) &= ~(1 << (uint8_t)((4))); } while(0); do { ((*(volatile uint8_t *)((0x0B) + 0x20))) |= (1 << (uint8_t)((4))); } while(0); } while(0); + do { do { ((*(volatile uint8_t *)((0x0A) + 0x20))) &= ~(1 << (uint8_t)((5))); } while(0); do { ((*(volatile uint8_t *)((0x0B) + 0x20))) |= (1 << (uint8_t)((5))); } while(0); } while(0); + do { do { ((*(volatile uint8_t *)((0x0A) + 0x20))) &= ~(1 << (uint8_t)((6))); } while(0); do { ((*(volatile uint8_t *)((0x0B) + 0x20))) |= (1 << (uint8_t)((6))); } while(0); } while(0); + do { do { ((*(volatile uint8_t *)((0x0A) + 0x20))) &= ~(1 << (uint8_t)((7))); } while(0); do { ((*(volatile uint8_t *)((0x0B) + 0x20))) |= (1 << (uint8_t)((7))); } while(0); } while(0); + + + debo_register(&(*(volatile uint8_t *)((0x09) + 0x20)), 2, 1); + debo_register(&(*(volatile uint8_t *)((0x09) + 0x20)), 3, 1); + debo_register(&(*(volatile uint8_t *)((0x09) + 0x20)), 4, 1); + debo_register(&(*(volatile uint8_t *)((0x09) + 0x20)), 5, 1); + debo_register(&(*(volatile uint8_t *)((0x09) + 0x20)), 6, 1); + debo_register(&(*(volatile uint8_t *)((0x09) + 0x20)), 7, 1); + + + (*(volatile uint8_t *)((0x24) + 0x20)) = (1 << (1)); + (*(volatile uint8_t *)((0x25) + 0x20)) = (1 << (2)) | (1 << (0)); + (*(volatile uint8_t *)((0x27) + 0x20)) = 156; + do { ((*(volatile uint8_t *)(0x6E))) |= (1 << (uint8_t)(1)); } while(0); + + + __asm__ __volatile__ ("sei" ::: "memory"); +} + + + +void __vector_14 (void) __attribute__ ((signal,used, externally_visible)) ; void __vector_14 (void) +{ + + update(); + render(); +} + + +void main() +{ + while(1); +} + + + +typedef enum { + SECRET, + REVEALED, + GONE +} tilestate_t; + + + +typedef struct { + uint8_t color; + tilestate_t state; +} tile_t; + + + +tile_t board[(6 * 5)]; + + +uint8_t cursor = 0; + +volatile uint8_t noise = 0; +uint16_t xxx = 0; + +void update() +{ + if(xxx++ >= 100) { + noise = adc_read_byte(0); + xxx = 0; + } +} + + + +xrgb_t screen[(6 * 5)]; + + +void render() +{ + const rgb24_t BLUE = 0x005397; + const rgb24_t RED = 0xFF0000; + const rgb24_t YELLOW = 0xFFFF00; + const rgb24_t BLACK = 0x000000; + + + + rgb24_t c; + for (uint8_t i = 0; i < (6 * 5); i++) { + + c = YELLOW; + + if (i < 8) { + c = ((((uint8_t)(noise)) >> (uint8_t)(i)) & 0x1) ? RED : BLUE; + } + + do { do { for (volatile int8_t __wsba_i = 7; __wsba_i >= 0; --__wsba_i) { if ((((((rgb24_t) (c)) >> 8) & 0xFF)) & (1 << __wsba_i)) { __asm__ __volatile__("":::"memory"); do { ((*(volatile uint8_t *)((0x05) + 0x20))) |= (1 << (uint8_t)((2))); } while(0); (((( (700) / (1000000000L / (signed long) 16000000UL) ) + (-2)) > 0) ? __builtin_avr_delay_cycles(( (700) / (1000000000L / (signed long) 16000000UL) ) + (-2)) : __builtin_avr_delay_cycles(0)); __asm__ __volatile__("":::"memory"); do { ((*(volatile uint8_t *)((0x05) + 0x20))) &= ~(1 << (uint8_t)((2))); } while(0); (((( (150) / (1000000000L / (signed long) 16000000UL) ) + (-10)) > 0) ? __builtin_avr_delay_cycles(( (150) / (1000000000L / (signed long) 16000000UL) ) + (-10)) : __builtin_avr_delay_cycles(0)); } else { __asm__ __volatile__("":::"memory"); do { ((*(volatile uint8_t *)((0x05) + 0x20))) |= (1 << (uint8_t)((2))); } while(0); (((( (150) / (1000000000L / (signed long) 16000000UL) ) + (-2)) > 0) ? __builtin_avr_delay_cycles(( (150) / (1000000000L / (signed long) 16000000UL) ) + (-2)) : __builtin_avr_delay_cycles(0)); __asm__ __volatile__("":::"memory"); do { ((*(volatile uint8_t *)((0x05) + 0x20))) &= ~(1 << (uint8_t)((2))); } while(0); (((( (700) / (1000000000L / (signed long) 16000000UL) ) + (-10)) > 0) ? __builtin_avr_delay_cycles(( (700) / (1000000000L / (signed long) 16000000UL) ) + (-10)) : __builtin_avr_delay_cycles(0)); } } } while(0); do { for (volatile int8_t __wsba_i = 7; __wsba_i >= 0; --__wsba_i) { if ((((((rgb24_t) (c)) >> 16) & 0xFF)) & (1 << __wsba_i)) { __asm__ __volatile__("":::"memory"); do { ((*(volatile uint8_t *)((0x05) + 0x20))) |= (1 << (uint8_t)((2))); } while(0); (((( (700) / (1000000000L / (signed long) 16000000UL) ) + (-2)) > 0) ? __builtin_avr_delay_cycles(( (700) / (1000000000L / (signed long) 16000000UL) ) + (-2)) : __builtin_avr_delay_cycles(0)); __asm__ __volatile__("":::"memory"); do { ((*(volatile uint8_t *)((0x05) + 0x20))) &= ~(1 << (uint8_t)((2))); } while(0); (((( (150) / (1000000000L / (signed long) 16000000UL) ) + (-10)) > 0) ? __builtin_avr_delay_cycles(( (150) / (1000000000L / (signed long) 16000000UL) ) + (-10)) : __builtin_avr_delay_cycles(0)); } else { __asm__ __volatile__("":::"memory"); do { ((*(volatile uint8_t *)((0x05) + 0x20))) |= (1 << (uint8_t)((2))); } while(0); (((( (150) / (1000000000L / (signed long) 16000000UL) ) + (-2)) > 0) ? __builtin_avr_delay_cycles(( (150) / (1000000000L / (signed long) 16000000UL) ) + (-2)) : __builtin_avr_delay_cycles(0)); __asm__ __volatile__("":::"memory"); do { ((*(volatile uint8_t *)((0x05) + 0x20))) &= ~(1 << (uint8_t)((2))); } while(0); (((( (700) / (1000000000L / (signed long) 16000000UL) ) + (-10)) > 0) ? __builtin_avr_delay_cycles(( (700) / (1000000000L / (signed long) 16000000UL) ) + (-10)) : __builtin_avr_delay_cycles(0)); } } } while(0); do { for (volatile int8_t __wsba_i = 7; __wsba_i >= 0; --__wsba_i) { if ((((((rgb24_t) (c)) >> 0) & 0xFF)) & (1 << __wsba_i)) { __asm__ __volatile__("":::"memory"); do { ((*(volatile uint8_t *)((0x05) + 0x20))) |= (1 << (uint8_t)((2))); } while(0); (((( (700) / (1000000000L / (signed long) 16000000UL) ) + (-2)) > 0) ? __builtin_avr_delay_cycles(( (700) / (1000000000L / (signed long) 16000000UL) ) + (-2)) : __builtin_avr_delay_cycles(0)); __asm__ __volatile__("":::"memory"); do { ((*(volatile uint8_t *)((0x05) + 0x20))) &= ~(1 << (uint8_t)((2))); } while(0); (((( (150) / (1000000000L / (signed long) 16000000UL) ) + (-10)) > 0) ? __builtin_avr_delay_cycles(( (150) / (1000000000L / (signed long) 16000000UL) ) + (-10)) : __builtin_avr_delay_cycles(0)); } else { __asm__ __volatile__("":::"memory"); do { ((*(volatile uint8_t *)((0x05) + 0x20))) |= (1 << (uint8_t)((2))); } while(0); (((( (150) / (1000000000L / (signed long) 16000000UL) ) + (-2)) > 0) ? __builtin_avr_delay_cycles(( (150) / (1000000000L / (signed long) 16000000UL) ) + (-2)) : __builtin_avr_delay_cycles(0)); __asm__ __volatile__("":::"memory"); do { ((*(volatile uint8_t *)((0x05) + 0x20))) &= ~(1 << (uint8_t)((2))); } while(0); (((( (700) / (1000000000L / (signed long) 16000000UL) ) + (-10)) > 0) ? __builtin_avr_delay_cycles(( (700) / (1000000000L / (signed long) 16000000UL) ) + (-10)) : __builtin_avr_delay_cycles(0)); } } } while(0); } while(0); + } + + do { __asm__ __volatile__("":::"memory"); (((( (7000) / (1000000000L / (signed long) 16000000UL) ) + (0)) > 0) ? __builtin_avr_delay_cycles(( (7000) / (1000000000L / (signed long) 16000000UL) ) + (0)) : __builtin_avr_delay_cycles(0)); } while(0); +}