#define FASTLED_ALLOW_INTERRUPTS 0
#include <FastLED.h>
#include "palettes.h"

#define MATRIX  32 //could be 16, 24, 32, 40 and 48
#define DATA_PIN            3
#define NUM_LEDS            ((MATRIX) * (MATRIX))
#define LED_TYPE            WS2811
#define COLOR_ORDER         GRB
int BRIGHTNESS = 180;
CRGB leds[NUM_LEDS];
CRGBPalette16 currentPalette;
#include "functions.h"
void setup()
{
	FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS).setDither(BRIGHTNESS < 255); // cpt-city palettes have different color balance
	FastLED.setBrightness(BRIGHTNESS);
	currentPalette = RainbowColors_p;
	randomSeed(analogRead(A0));
}
void loop()
{
	int random_palette = random(gGradientPaletteCount);
	currentPalette = gGradientPalettes[random_palette];
	int function = random(9);
	switch (function) {
	case 0: pixels_eighth_no_symmetry(); break;
	case 1: pixels_eighth_horizontal_symmetry(); break;
	case 2: pixels_eighth_vertical_symmetry(); break;
	case 3: pixels_eighth_both_symmetry(); break;
	case 4: pixels_quarter_no_symmetry(); break;
	case 5: pixels_quarter_horizontal_symmetry(); break;
	case 6: pixels_quarter_vertical_symmetry(); break;
	case 7: pixels_quarter_both_symmetry(); break;
	case 8: pixels_half_both_symmetry(); break;
	}
	FastLED.show();
	delay(2000);
	fill_solid( leds, NUM_LEDS, CRGB(0,0,0));
}



Square_Tiling.ino

diagram.json

palettes.h


#ifndef FUNCTIONS_H_
#define FUNCTIONS_H_

byte pixels_eighth[MATRIX/8 * MATRIX/8]; //one cell is MATRIX/8 x MATRIX/8 pixel unit
byte pixels_quarter[MATRIX/4 * MATRIX/4];
byte pixels_half[MATRIX/2 * MATRIX/2];

// this finds the right index within a serpentine matrix
int XY( int x, int y) {
	int i;
	i = y * MATRIX  + x;
	return i;
}

void pixels_eighth_init() {
	for (int c = 0; c < (MATRIX/8 * MATRIX/8); c++) {
		pixels_eighth[c] = random(256);
	}
}

void pixels_quarter_init() {
	for (int c = 0; c < (MATRIX/4 * MATRIX/4); c++) {
		pixels_quarter[c] = random(256);
	}
}

void pixels_half_init() {
	for (int c = 0; c < (MATRIX/2 * MATRIX/2); c++) {
		pixels_half[c] = random(256);
	}
}

void pixels_eighth_no_symmetry() {
	pixels_eighth_init();
	int i = 0;
	for (int x = 0; x < MATRIX; x += MATRIX/8) {
		for (int y = 0; y < MATRIX; y += MATRIX/8 ) {
			for (int x1 = 0; x1 < MATRIX/8; x1++) {
				for (int y1 = 0; y1 < MATRIX/8; y1++) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_eighth[i]);
					i++;
				}
			}
			i = 0;
		}
	}
}

void pixels_eighth_horizontal_symmetry() {
	pixels_eighth_init();
	int i = 0;
	for (int x = 0; x < MATRIX; x += (2 * MATRIX/8)) {
		for (int y = 0; y < MATRIX; y += MATRIX/8 ) {
			for (int x1 = 0; x1 < MATRIX/8; x1++) {
				for (int y1 = 0; y1 < MATRIX/8; y1++) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_eighth[i]);
					i++;
				}
			}
			i = 0;
		}
	}
	i = 0;
	for (int x = MATRIX/8; x < MATRIX; x += (2 * MATRIX/8)) {
		for (int y = 0; y < MATRIX; y += MATRIX/8 ) {
			for (int x1 = (MATRIX/8 - 1); x1 >= 0; x1--) {
				for (int y1 = 0; y1 < MATRIX/8; y1++) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_eighth[i]);
					i++;
				}
			}
			i = 0;
		}
	}
}

void pixels_eighth_vertical_symmetry() {
	pixels_eighth_init();
	int i = 0;
	for (int x = 0; x < MATRIX; x += MATRIX/8) {
		for (int y = 0; y < MATRIX; y += (2 * MATRIX/8)) {
			for (int x1 = 0; x1 < MATRIX/8; x1++) {
				for (int y1 = 0; y1 < MATRIX/8; y1++) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_eighth[i]);
					i++;
				}
			}
			i = 0;
		}
	}
	i = 0;
	for (int x = 0; x < MATRIX; x += MATRIX/8) {
		for (int y = MATRIX/8; y < MATRIX; y += (2 * MATRIX/8)) {
			for (int x1 = 0; x1 < MATRIX/8; x1++) {
				for (int y1 = (MATRIX/8 -1); y1 >= 0; y1--) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_eighth[i]);
					i++;
				}
			}
			i = 0;
		}
	}
}

void pixels_eighth_both_symmetry() {
	pixels_eighth_init();
	int i = 0;
	for (int x = 0; x < MATRIX; x += (2 * MATRIX/8)) {
		for (int y = 0; y < MATRIX; y += (2 * MATRIX/8)) {
			for (int x1 = 0; x1 < MATRIX/8; x1++) {
				for (int y1 = 0; y1 < MATRIX/8; y1++) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_eighth[i]);
					i++;
				}
			}
			i = 0;
		}
	}
	i = 0;
	for (int x = MATRIX/8; x < MATRIX; x += (2 * MATRIX/8)) {
		for (int y = 0; y < MATRIX; y += (2 * MATRIX/8)) {
			for (int x1 = (MATRIX/8 -1); x1 >= 0; x1--) {
				for (int y1 = 0; y1 < MATRIX/8 ; y1++) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_eighth[i]);
					i++;
				}
			}
			i = 0;
		}
	}
	i = 0;
	for (int x = 0; x < MATRIX; x += (2 * MATRIX/8)) {
		for (int y = MATRIX/8; y < MATRIX; y += (2 * MATRIX/8)) {
			for (int x1 = 0; x1 < MATRIX/8; x1++) {
				for (int y1 = (MATRIX/8 -1); y1 >= 0; y1--) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_eighth[i]);
					i++;
				}
			}
			i = 0;
		}
	}
	i = 0;
	for (int x = MATRIX/8; x < MATRIX; x += (2 * MATRIX/8)) {
		for (int y = MATRIX/8; y < MATRIX; y += (2 * MATRIX/8)) {
			for (int x1 = (MATRIX/8 - 1); x1 >= 0; x1--)  {
				for (int y1 = (MATRIX/8 - 1); y1 >= 0; y1--) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_eighth[i]);
					i++;
				}
			}
			i = 0;
		}
	}
}

void pixels_quarter_no_symmetry() {
	pixels_quarter_init();
	int i = 0;
	for (int x = 0; x < MATRIX; x += MATRIX/4) {
		for (int y = 0; y < MATRIX; y += MATRIX/4) {
			for (int x1 = 0; x1 < MATRIX/4; x1++) {
				for (int y1 = 0; y1 < MATRIX/4; y1++) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_quarter[i]);
					i++;
				}
			}
			i = 0;
		}
	}
}

void pixels_quarter_horizontal_symmetry() {
	pixels_quarter_init();
	int i = 0;
	for (int x = 0; x < MATRIX; x += (2 * MATRIX/4)) {
		for (int y = 0; y < MATRIX; y += MATRIX/4) {
			for (int x1 = 0; x1 < MATRIX/4; x1++) {
				for (int y1 = 0; y1 < MATRIX/4; y1++) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_quarter[i]);
					i++;
				}
			}
			i = 0;
		}
	}
	i = 0;
	for (int x = MATRIX/4; x < MATRIX; x += (2 * MATRIX/4)) {
		for (int y = 0; y < MATRIX; y += MATRIX/4) {
			for (int x1 = (MATRIX/4 - 1); x1 >= 0; x1--) {
				for (int y1 = 0; y1 < MATRIX/4; y1++) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_quarter[i]);
					i++;
				}
			}
			i = 0;
		}
	}
}

void pixels_quarter_vertical_symmetry() {
	pixels_quarter_init();
	int i = 0;
	for (int x = 0; x < MATRIX; x += MATRIX/4) {
		for (int y = 0; y < MATRIX; y += (2 * MATRIX/4)) {
			for (int x1 = 0; x1 < MATRIX/4; x1++) {
				for (int y1 = 0; y1 < MATRIX/4; y1++) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_quarter[i]);
					i++;
				}
			}
			i = 0;
		}
	}
	i = 0;
	for (int x = 0; x < MATRIX; x += MATRIX/4) {
		for (int y = MATRIX/4; y < MATRIX; y += (2 * MATRIX/4)) {
			for (int x1 = 0; x1 < MATRIX/4; x1++) {
				for (int y1 = (MATRIX/4 - 1); y1 >= 0; y1--) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_quarter[i]);
					i++;
				}
			}
			i = 0;
		}
	}
}

void pixels_quarter_both_symmetry() {
	pixels_quarter_init();
	int i = 0;
	for (int x = 0; x < MATRIX; x += (2 * MATRIX/4)) {
		for (int y = 0; y < MATRIX; y += (2 * MATRIX/4)) {
			for (int x1 = 0; x1 < MATRIX/4; x1++) {
				for (int y1 = 0; y1 < MATRIX/4; y1++) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_quarter[i]);
					i++;
				}
			}
			i = 0;
		}
	}
	i = 0;
	for (int x = MATRIX/4; x < MATRIX; x += (2 * MATRIX/4)) {
		for (int y = 0; y < MATRIX; y += (2 * MATRIX/4)) {
			for (int x1 = (MATRIX/4 - 1); x1 >= 0; x1--) {
				for (int y1 = 0; y1 < MATRIX/4; y1++) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_quarter[i]);
					i++;
				}
			}
			i = 0;
		}
	}
	i = 0;
	for (int x = 0; x < MATRIX; x += (2 * MATRIX/4)) {
		for (int y = MATRIX/4; y < MATRIX; y += (2 * MATRIX/4)) {
			for (int x1 = 0; x1 < MATRIX/4; x1++) {
				for (int y1 = (MATRIX/4 - 1); y1 >= 0; y1--) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_quarter[i]);
					i++;
				}
			}
			i = 0;
		}
	}
	i = 0;
	for (int x = MATRIX/4; x < MATRIX; x += (2 * MATRIX/4)) {
		for (int y = MATRIX/4; y < MATRIX; y += (2 * MATRIX/4)) {
			for (int x1 = (MATRIX/4 - 1); x1 >= 0; x1--) {
				for (int y1 = (MATRIX/4 - 1); y1 >= 0; y1--) {
					leds[XY(x + x1, y + y1)] = ColorFromPalette( currentPalette, pixels_quarter[i]);
					i++;
				}
			}
			i = 0;
		}
	}
}

void pixels_half_both_symmetry() {
	pixels_half_init();
	int i = 0;
	for (int x = 0; x < MATRIX/2 ; x++) {
		for (int y = 0; y < MATRIX/2 ; y++) {
			leds[XY(x, y)] = ColorFromPalette( currentPalette, pixels_half[i]);
			i++;
		}
	}
	i = 0;
	for (int x = MATRIX - 1; x >= MATRIX/2; x--) {
		for (int y = 0; y < MATRIX/2; y++) {
			leds[XY(x, y)] = ColorFromPalette( currentPalette, pixels_half[i]);
			i++;
		}
	}
	i = 0;
	for (int x = 0; x < MATRIX/2; x++) {
		for (int y = MATRIX - 1; y >= MATRIX/2; y--) {
			leds[XY(x, y)] = ColorFromPalette( currentPalette, pixels_half[i]);
			i++;
		}
	}
	i = 0;
	for (int x = MATRIX-1; x >= MATRIX/2; x--) {
		for (int y = MATRIX - 1; y >= MATRIX/2; y--) {
			leds[XY(x, y)] = ColorFromPalette( currentPalette, pixels_half[i]);
			i++;
		}
	}
}

#endif /* FUNCTIONS_H_ */


functions.h

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

# Automatically added based on includes:
FastLED
# ---
