From: Nathael Pajani <nathael.pajani@ed3l.fr>
Date: Fri, 12 Jun 2020 14:38:37 +0000 (+0200)
Subject: Update WS2812FX lib
X-Git-Url: http://git.techno-innov.fr/?a=commitdiff_plain;h=ce2a07f9c250d497732e0a0e601b848aa21f7ccd;p=soft%2Flpc122x%2Fcore

Update WS2812FX lib
---

diff --git a/extdrv/ws2812fx.c b/extdrv/ws2812fx.c
index 2af61e5..f66c023 100644
--- a/extdrv/ws2812fx.c
+++ b/extdrv/ws2812fx.c
@@ -35,6 +35,7 @@
 */
 
 #include "core/systick.h"
+#include "lib/utils.h"
 #include "extdrv/ws2812.h"
 #include "extdrv/ws2812fx.h"
 
@@ -46,31 +47,11 @@ static uint32_t random(uint32_t max)
 	return seed % max;
 }
 
-static uint32_t abs(int32_t val)
-{
-	return val < 0 ? -val : val;
-}
-
-static uint32_t min(uint32_t a, uint32_t b)
-{
-	return a < b ? a : b;
-}
-
-static uint32_t max(uint32_t a, uint32_t b)
-{
-	return a > b ? a : b;
-}
-
 static unsigned long millis(void)
 {
 	return systick_get_tick_count();
 }
 
-static uint32_t constrain(int32_t val, int32_t min, int32_t max)
-{
-	return val < min ? min : val > max ? max : val;
-}
-
 
 /* #####################################################
 #
@@ -81,10 +62,10 @@ static uint32_t constrain(int32_t val, int32_t min, int32_t max)
 /*
  * Turns everything off. Doh.
  */
-static void strip_off(ws2812fx_t *fx)
+static void strip_off(struct ws2812fx* fx)
 {
-	ws2812_clear();
-	ws2812_send_frame(fx->_led_count);
+	ws2812_clear(fx->wsconf);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 }
 
 #define WHITE 0xffffff
@@ -93,20 +74,20 @@ static void strip_off(ws2812fx_t *fx)
 #define BLUE  0x0000ff
 #define BLACK 0x000000
 
-static void set_pixel_rgb_color(uint32_t i, uint8_t r, uint8_t g, uint8_t b)
+static void set_pixel_rgb_color(struct ws2812fx* fx, uint32_t i, uint8_t r, uint8_t g, uint8_t b)
 {
-	ws2812_set_pixel(i, r, g, b);
+	ws2812_set_pixel(fx->wsconf, i, r, g, b);
 }
 
-static void set_pixel_color(uint32_t i, uint32_t color)
+static void set_pixel_color(struct ws2812fx* fx, uint32_t i, uint32_t color)
 {
-	ws2812_set_pixel(i, color >> 16, (color >> 8) & 0xff, color & 0xff);
+	ws2812_set_pixel(fx->wsconf, i, color >> 16, (color >> 8) & 0xff, color & 0xff);
 }
 
-static uint32_t get_pixel_color(uint32_t i)
+static uint32_t get_pixel_color(struct ws2812fx* fx, uint32_t i)
 {
 	uint8_t r, g, b;
-	ws2812_get_pixel(i, &r, &g, &b);
+	ws2812_get_pixel(fx->wsconf, i, &r, &g, &b);
 	return (r << 16) | (g << 8) | b;
 }
 
@@ -118,9 +99,9 @@ static uint32_t get_pixel_color(uint32_t i)
 static uint32_t color_wheel(uint8_t pos)
 {
 	pos = 255 - pos;
-	if(pos < 85) {
+	if (pos < 85) {
 		return ((uint32_t)(255 - pos * 3) << 16) | ((uint32_t)(0) << 8) | (pos * 3);
-	} else if(pos < 170) {
+	} else if (pos < 170) {
 		pos -= 85;
 		return ((uint32_t)(0) << 16) | ((uint32_t)(pos * 3) << 8) | (255 - pos * 3);
 	} else {
@@ -140,7 +121,7 @@ static uint8_t get_random_wheel_index(uint8_t pos)
 	uint8_t y = 0;
 	uint8_t d = 0;
 
-	while(d < 42) {
+	while (d < 42) {
 		r = random(256);
 		x = abs(pos - r);
 		y = 255 - x;
@@ -154,12 +135,12 @@ static uint8_t get_random_wheel_index(uint8_t pos)
 /*
  * No blinking. Just plain old static light.
  */
-static void mode_static(ws2812fx_t *fx)
+static void mode_static(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, fx->_color);
+	for (uint16_t i = 0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, fx->_color);
 	}
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_mode_delay = 50;
 }
@@ -168,13 +149,13 @@ static void mode_static(ws2812fx_t *fx)
 /*
  * Normal blinking. 50% on/off time.
  */
-static void mode_blink(ws2812fx_t *fx)
+static void mode_blink(struct ws2812fx* fx)
 {
-	if(fx->_counter_mode_call % 2 == 1) {
-		for(uint16_t i=0; i < fx->_led_count; i++) {
-			set_pixel_color(i, fx->_color);
+	if (fx->_counter_mode_call % 2 == 1) {
+		for (uint16_t i=0; i < fx->_led_count; i++) {
+			set_pixel_color(fx, i, fx->_color);
 		}
-		ws2812_send_frame(fx->_led_count);
+		ws2812_send_frame(fx->wsconf, fx->_led_count);
 	} else {
 		strip_off(fx);
 	}
@@ -187,14 +168,14 @@ static void mode_blink(ws2812fx_t *fx)
  * Lights all LEDs after each other up. Then turns them in
  * that order off. Repeat.
  */
-static void mode_color_wipe(ws2812fx_t *fx)
+static void mode_color_wipe(struct ws2812fx* fx)
 {
-	if(fx->_counter_mode_step < fx->_led_count) {
-		set_pixel_color(fx->_counter_mode_step, fx->_color);
+	if (fx->_counter_mode_step < fx->_led_count) {
+		set_pixel_color(fx, fx->_counter_mode_step, fx->_color);
 	} else {
-		set_pixel_color(fx->_counter_mode_step - fx->_led_count, 0);
+		set_pixel_color(fx, fx->_counter_mode_step - fx->_led_count, 0);
 	}
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % (fx->_led_count * 2);
 
@@ -206,14 +187,14 @@ static void mode_color_wipe(ws2812fx_t *fx)
  * Turns all LEDs after each other to a random color.
  * Then starts over with another color.
  */
-static void mode_color_wipe_random(ws2812fx_t *fx)
+static void mode_color_wipe_random(struct ws2812fx* fx)
 {
-	if(fx->_counter_mode_step == 0) {
+	if (fx->_counter_mode_step == 0) {
 		fx->_mode_color = get_random_wheel_index(fx->_mode_color);
 	}
 
-	set_pixel_color(fx->_counter_mode_step, color_wheel(fx->_mode_color));
-	ws2812_send_frame(fx->_led_count);
+	set_pixel_color(fx, fx->_counter_mode_step, color_wheel(fx->_mode_color));
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % fx->_led_count;
 
@@ -225,15 +206,15 @@ static void mode_color_wipe_random(ws2812fx_t *fx)
  * Lights all LEDs in one random color up. Then switches them
  * to the next random color.
  */
-static void mode_random_color(ws2812fx_t *fx)
+static void mode_random_color(struct ws2812fx* fx)
 {
 	fx->_mode_color = get_random_wheel_index(fx->_mode_color);
 
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, color_wheel(fx->_mode_color));
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, color_wheel(fx->_mode_color));
 	}
 
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 	fx->_mode_delay = 100 + ((5000 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
 }
 
@@ -242,16 +223,16 @@ static void mode_random_color(ws2812fx_t *fx)
  * Lights every LED in a random color. Changes one random LED after the other
  * to another random color.
  */
-static void mode_single_dynamic(ws2812fx_t *fx)
+static void mode_single_dynamic(struct ws2812fx* fx)
 {
-	if(fx->_counter_mode_call == 0) {
-		for(uint16_t i=0; i < fx->_led_count; i++) {
-			set_pixel_color(i, color_wheel(random(256)));
+	if (fx->_counter_mode_call == 0) {
+		for (uint16_t i=0; i < fx->_led_count; i++) {
+			set_pixel_color(fx, i, color_wheel(random(256)));
 		}
 	}
 
-	set_pixel_color(random(fx->_led_count), color_wheel(random(256)));
-	ws2812_send_frame(fx->_led_count);
+	set_pixel_color(fx, random(fx->_led_count), color_wheel(random(256)));
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 	fx->_mode_delay = 10 + ((5000 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
 }
 
@@ -260,12 +241,12 @@ static void mode_single_dynamic(ws2812fx_t *fx)
  * Lights every LED in a random color. Changes all LED at the same time
  * to new random colors.
  */
-static void mode_multi_dynamic(ws2812fx_t *fx)
+static void mode_multi_dynamic(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, color_wheel(random(256)));
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, color_wheel(random(256)));
 	}
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 	fx->_mode_delay = 100 + ((5000 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
 }
 
@@ -274,35 +255,35 @@ static void mode_multi_dynamic(ws2812fx_t *fx)
  * Does the "standby-breathing" of well known i-Devices. Fixed Speed.
  * Use mode "fade" if you like to have something similar with a different speed.
  */
-static void mode_breath(ws2812fx_t *fx)
+static void mode_breath(struct ws2812fx* fx)
 {
 	//                                      0    1    2   3   4   5   6    7   8   9  10  11   12   13   14   15   16    // step
 	uint16_t breath_delay_steps[] =     {   7,   9,  13, 15, 16, 17, 18, 930, 19, 18, 15, 13,   9,   7,   4,   5,  10 }; // magic numbers for breathing LED
 	uint8_t breath_brightness_steps[] = { 150, 125, 100, 75, 50, 25, 16,  15, 16, 25, 50, 75, 100, 125, 150, 220, 255 }; // even more magic numbers!
 
-	if(fx->_counter_mode_call == 0) {
+	if (fx->_counter_mode_call == 0) {
 		fx->_mode_color = breath_brightness_steps[0] + 1;
 	}
 
 	uint32_t breath_brightness = fx->_mode_color; // we use fx->_mode_color to store the brightness
 
-	if(fx->_counter_mode_step < 8) {
+	if (fx->_counter_mode_step < 8) {
 		breath_brightness--;
 	} else {
 		breath_brightness++;
 	}
 
 	// update index of current delay when target brightness is reached, start over after the last step
-	if(breath_brightness == breath_brightness_steps[fx->_counter_mode_step]) {
+	if (breath_brightness == breath_brightness_steps[fx->_counter_mode_step]) {
 		fx->_counter_mode_step = (fx->_counter_mode_step + 1) % (sizeof(breath_brightness_steps)/sizeof(uint8_t));
 	}
 
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, fx->_color);           // set all LEDs to selected color
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, fx->_color);           // set all LEDs to selected color
 	}
 	int b = (breath_brightness * (fx->_brightness + 1)) >> 8;  // keep brightness below brightness set by user
-	ws2812_set_brightness(b);
-	ws2812_send_frame(fx->_led_count);
+	ws2812_set_brightness(fx->wsconf, b);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_mode_color = breath_brightness;                         // we use fx->_mode_color to store the brightness
 	fx->_mode_delay = breath_delay_steps[fx->_counter_mode_step];
@@ -312,17 +293,17 @@ static void mode_breath(ws2812fx_t *fx)
 /*
  * Fades the LEDs on and (almost) off again.
  */
-static void mode_fade(ws2812fx_t *fx)
+static void mode_fade(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, fx->_color);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, fx->_color);
 	}
 
 	int b = fx->_counter_mode_step - 127;
 	b = 255 - (abs(b) * 2);
 	b = (b * (min(20, fx->_brightness) + 1)) >> 8;
-	ws2812_set_brightness(b);
-	ws2812_send_frame(fx->_led_count);
+	ws2812_set_brightness(fx->wsconf, b);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % 255;
 	fx->_mode_delay = 5 + ((15 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
@@ -332,9 +313,9 @@ static void mode_fade(ws2812fx_t *fx)
 /*
  * Runs a single pixel back and forth.
  */
-static void mode_scan(ws2812fx_t *fx)
+static void mode_scan(struct ws2812fx* fx)
 {
-	if(fx->_counter_mode_step > (fx->_led_count*2) - 2) {
+	if (fx->_counter_mode_step > (fx->_led_count*2) - 2) {
 		fx->_counter_mode_step = 0;
 	}
 	fx->_counter_mode_step++;
@@ -342,9 +323,9 @@ static void mode_scan(ws2812fx_t *fx)
 	int i = fx->_counter_mode_step - (fx->_led_count - 1);
 	i = abs(i);
 
-	ws2812_clear();
-	set_pixel_color(abs(i), fx->_color);
-	ws2812_send_frame(fx->_led_count);
+	ws2812_clear(fx->wsconf);
+	set_pixel_color(fx, abs(i), fx->_color);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_mode_delay = 10 + ((30 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
 }
@@ -353,9 +334,9 @@ static void mode_scan(ws2812fx_t *fx)
 /*
  * Runs two pixel back and forth in opposite directions.
  */
-static void mode_dual_scan(ws2812fx_t *fx)
+static void mode_dual_scan(struct ws2812fx* fx)
 {
-	if(fx->_counter_mode_step > (fx->_led_count*2) - 2) {
+	if (fx->_counter_mode_step > (fx->_led_count*2) - 2) {
 		fx->_counter_mode_step = 0;
 	}
 	fx->_counter_mode_step++;
@@ -363,10 +344,10 @@ static void mode_dual_scan(ws2812fx_t *fx)
 	int i = fx->_counter_mode_step - (fx->_led_count - 1);
 	i = abs(i);
 
-	ws2812_clear();
-	set_pixel_color(i, fx->_color);
-	set_pixel_color(fx->_led_count - (i+1), fx->_color);
-	ws2812_send_frame(fx->_led_count);
+	ws2812_clear(fx->wsconf);
+	set_pixel_color(fx, i, fx->_color);
+	set_pixel_color(fx, fx->_led_count - (i+1), fx->_color);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_mode_delay = 10 + ((30 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
 }
@@ -375,13 +356,13 @@ static void mode_dual_scan(ws2812fx_t *fx)
 /*
  * Cycles all LEDs at once through a rainbow.
  */
-static void mode_rainbow(ws2812fx_t *fx)
+static void mode_rainbow(struct ws2812fx* fx)
 {
 	uint32_t color = color_wheel(fx->_counter_mode_step);
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, color);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, color);
 	}
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % 256;
 
@@ -392,12 +373,12 @@ static void mode_rainbow(ws2812fx_t *fx)
 /*
  * Cycles a rainbow over the entire string of LEDs.
  */
-static void mode_rainbow_cycle(ws2812fx_t *fx)
+static void mode_rainbow_cycle(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, color_wheel(((i * 256 / fx->_led_count) + fx->_counter_mode_step) % 256));
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, color_wheel(((i * 256 / fx->_led_count) + fx->_counter_mode_step) % 256));
 	}
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % 256;
 
@@ -409,18 +390,18 @@ static void mode_rainbow_cycle(ws2812fx_t *fx)
  * Theatre-style crawling lights.
  * Inspired by the Adafruit examples.
  */
-static void mode_theater_chase(ws2812fx_t *fx)
+static void mode_theater_chase(struct ws2812fx* fx)
 {
 	uint8_t j = fx->_counter_mode_call % 6;
-	if(j % 2 == 0) {
-		for(uint16_t i=0; i < fx->_led_count; i=i+3) {
-			set_pixel_color(i+(j/2), fx->_color);
+	if (j % 2 == 0) {
+		for (uint16_t i=0; i < fx->_led_count; i=i+3) {
+			set_pixel_color(fx, i+(j/2), fx->_color);
 		}
-		ws2812_send_frame(fx->_led_count);
+		ws2812_send_frame(fx->wsconf, fx->_led_count);
 		fx->_mode_delay = 50 + ((500 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
 	} else {
-		for(uint16_t i=0; i < fx->_led_count; i=i+3) {
-			set_pixel_color(i+(j/2), 0);
+		for (uint16_t i=0; i < fx->_led_count; i=i+3) {
+			set_pixel_color(fx, i+(j/2), 0);
 		}
 		fx->_mode_delay = 1;
 	}
@@ -431,18 +412,18 @@ static void mode_theater_chase(ws2812fx_t *fx)
  * Theatre-style crawling lights with rainbow effect.
  * Inspired by the Adafruit examples.
  */
-static void mode_theater_chase_rainbow(ws2812fx_t *fx)
+static void mode_theater_chase_rainbow(struct ws2812fx* fx)
 {
 	uint8_t j = fx->_counter_mode_call % 6;
-	if(j % 2 == 0) {
-		for(uint16_t i=0; i < fx->_led_count; i=i+3) {
-			set_pixel_color(i+(j/2), color_wheel((i+fx->_counter_mode_step) % 256));
+	if (j % 2 == 0) {
+		for (uint16_t i=0; i < fx->_led_count; i=i+3) {
+			set_pixel_color(fx, i+(j/2), color_wheel((i+fx->_counter_mode_step) % 256));
 		}
-		ws2812_send_frame(fx->_led_count);
+		ws2812_send_frame(fx->wsconf, fx->_led_count);
 		fx->_mode_delay = 50 + ((500 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
 	} else {
-		for(uint16_t i=0; i < fx->_led_count; i=i+3) {
-			set_pixel_color(i+(j/2), 0);
+		for (uint16_t i=0; i < fx->_led_count; i=i+3) {
+			set_pixel_color(fx, i+(j/2), 0);
 		}
 		fx->_mode_delay = 1;
 	}
@@ -454,18 +435,18 @@ static void mode_theater_chase_rainbow(ws2812fx_t *fx)
 /*
  * Running lights effect with smooth sine transition.
  */
-static void mode_running_lights(ws2812fx_t *fx)
+static void mode_running_lights(struct ws2812fx* fx)
 {
 	uint8_t r = ((fx->_color >> 16) & 0xFF);
 	uint8_t g = ((fx->_color >> 8) & 0xFF);
 	uint8_t b = (fx->_color & 0xFF);
 
-	for(uint16_t i=0; i < fx->_led_count; i++) {
+	for (uint16_t i=0; i < fx->_led_count; i++) {
 		int s = (sin(i+fx->_counter_mode_call) * 127) + 128;
-		set_pixel_rgb_color(i, (((uint32_t)(r * s)) / 255), (((uint32_t)(g * s)) / 255), (((uint32_t)(b * s)) / 255));
+		set_pixel_rgb_color(fx, i, (((uint32_t)(r * s)) / 255), (((uint32_t)(g * s)) / 255), (((uint32_t)(b * s)) / 255));
 	}
 
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_mode_delay = 35 + ((350 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
 }
@@ -476,17 +457,17 @@ static void mode_running_lights(ws2812fx_t *fx)
  * Blink several LEDs on, reset, repeat.
  * Inspired by www.tweaking4all.com/hardware/arduino/adruino-led-strip-effects/
  */
-static void mode_twinkle(ws2812fx_t *fx)
+static void mode_twinkle(struct ws2812fx* fx)
 {
-	if(fx->_counter_mode_step == 0) {
+	if (fx->_counter_mode_step == 0) {
 		strip_off(fx);
 		uint16_t min_leds = max(1, fx->_led_count/5); // make sure, at least one LED is on
 		uint16_t max_leds = max(1, fx->_led_count/2); // make sure, at least one LED is on
 		fx->_counter_mode_step = min_leds + random(max_leds - min_leds);
 	}
 
-	set_pixel_color(random(fx->_led_count), fx->_mode_color);
-	ws2812_send_frame(fx->_led_count);
+	set_pixel_color(fx, random(fx->_led_count), fx->_mode_color);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step--;
 	fx->_mode_delay = 50 + ((1986 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
@@ -497,7 +478,7 @@ static void mode_twinkle(ws2812fx_t *fx)
  * Blink several LEDs in random colors on, reset, repeat.
  * Inspired by www.tweaking4all.com/hardware/arduino/adruino-led-strip-effects/
  */
-static void mode_twinkle_random(ws2812fx_t *fx)
+static void mode_twinkle_random(struct ws2812fx* fx)
 {
 	fx->_mode_color = color_wheel(random(256));
 	mode_twinkle(fx);
@@ -507,10 +488,10 @@ static void mode_twinkle_random(ws2812fx_t *fx)
 /*
  * Blink several LEDs on, fading out.
  */
-static void mode_twinkle_fade(ws2812fx_t *fx)
+static void mode_twinkle_fade(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		uint32_t px_rgb = get_pixel_color(i);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		uint32_t px_rgb = get_pixel_color(fx, i);
 
 		uint8_t px_r = (px_rgb & 0x00FF0000) >> 16;
 		uint8_t px_g = (px_rgb & 0x0000FF00) >>  8;
@@ -521,14 +502,14 @@ static void mode_twinkle_fade(ws2812fx_t *fx)
 		px_g = px_g >> 1;
 		px_b = px_b >> 1;
 
-		set_pixel_rgb_color(i, px_r, px_g, px_b);
+		set_pixel_rgb_color(fx, i, px_r, px_g, px_b);
 	}
 
-	if(random(3) == 0) {
-		set_pixel_color(random(fx->_led_count), fx->_mode_color);
+	if (random(3) == 0) {
+		set_pixel_color(fx, random(fx->_led_count), fx->_mode_color);
 	}
 
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_mode_delay = 100 + ((100 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
 }
@@ -537,7 +518,7 @@ static void mode_twinkle_fade(ws2812fx_t *fx)
 /*
  * Blink several LEDs in random colors on, fading out.
  */
-static void mode_twinkle_fade_random(ws2812fx_t *fx)
+static void mode_twinkle_fade_random(struct ws2812fx* fx)
 {
 	fx->_mode_color = color_wheel(random(256));
 	mode_twinkle_fade(fx);
@@ -548,11 +529,11 @@ static void mode_twinkle_fade_random(ws2812fx_t *fx)
  * Blinks one LED at a time.
  * Inspired by www.tweaking4all.com/hardware/arduino/adruino-led-strip-effects/
  */
-static void mode_sparkle(ws2812fx_t *fx)
+static void mode_sparkle(struct ws2812fx* fx)
 {
-	ws2812_clear();
-	set_pixel_color(random(fx->_led_count),fx->_color);
-	ws2812_send_frame(fx->_led_count);
+	ws2812_clear(fx->wsconf);
+	set_pixel_color(fx, random(fx->_led_count),fx->_color);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 	fx->_mode_delay = 10 + ((200 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
 }
 
@@ -561,20 +542,20 @@ static void mode_sparkle(ws2812fx_t *fx)
  * Lights all LEDs in the fx->_color. Flashes single white pixels randomly.
  * Inspired by www.tweaking4all.com/hardware/arduino/adruino-led-strip-effects/
  */
-static void mode_flash_sparkle(ws2812fx_t *fx)
+static void mode_flash_sparkle(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, fx->_color);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, fx->_color);
 	}
 
-	if(random(10) == 7) {
-		set_pixel_color(random(fx->_led_count), WHITE);
+	if (random(10) == 7) {
+		set_pixel_color(fx, random(fx->_led_count), WHITE);
 		fx->_mode_delay = 20;
 	} else {
 		fx->_mode_delay = 20 + ((200 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
 	}
 
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 }
 
 
@@ -582,58 +563,58 @@ static void mode_flash_sparkle(ws2812fx_t *fx)
  * Like flash sparkle. With more flash.
  * Inspired by www.tweaking4all.com/hardware/arduino/adruino-led-strip-effects/
  */
-static void mode_hyper_sparkle(ws2812fx_t *fx)
+static void mode_hyper_sparkle(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, fx->_color);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, fx->_color);
 	}
 
-	if(random(10) < 4) {
-		for(uint16_t i=0; i < max(1, fx->_led_count/3); i++) {
-			set_pixel_color(random(fx->_led_count), WHITE);
+	if (random(10) < 4) {
+		for (uint16_t i=0; i < max(1, fx->_led_count/3); i++) {
+			set_pixel_color(fx, random(fx->_led_count), WHITE);
 		}
 		fx->_mode_delay = 20;
 	} else {
 		fx->_mode_delay = 15 + ((120 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
 	}
 
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 }
 
 
 /*
  * Classic Strobe effect.
  */
-static void mode_strobe(ws2812fx_t *fx)
+static void mode_strobe(struct ws2812fx* fx)
 {
-	if(fx->_counter_mode_call % 2 == 0) {
-		for(uint16_t i=0; i < fx->_led_count; i++) {
-			set_pixel_color(i, fx->_color);
+	if (fx->_counter_mode_call % 2 == 0) {
+		for (uint16_t i=0; i < fx->_led_count; i++) {
+			set_pixel_color(fx, i, fx->_color);
 		}
 		fx->_mode_delay = 20;
 	} else {
-		for(uint16_t i=0; i < fx->_led_count; i++) {
-			set_pixel_color(i, 0);
+		for (uint16_t i=0; i < fx->_led_count; i++) {
+			set_pixel_color(fx, i, 0);
 		}
 		fx->_mode_delay = 50 + ((1986 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
 	}
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 }
 
 
 /*
  * Strobe effect with different strobe count and pause, controled by fx->_speed.
  */
-static void mode_multi_strobe(ws2812fx_t *fx)
+static void mode_multi_strobe(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, 0);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, 0);
 	}
 
-	if(fx->_counter_mode_step < (2 * ((fx->_speed / 10) + 1))) {
-		if(fx->_counter_mode_step % 2 == 0) {
-			for(uint16_t i=0; i < fx->_led_count; i++) {
-				set_pixel_color(i, fx->_color);
+	if (fx->_counter_mode_step < (2 * ((fx->_speed / 10) + 1))) {
+		if (fx->_counter_mode_step % 2 == 0) {
+			for (uint16_t i=0; i < fx->_led_count; i++) {
+				set_pixel_color(fx, i, fx->_color);
 			}
 			fx->_mode_delay = 20;
 		} else {
@@ -644,7 +625,7 @@ static void mode_multi_strobe(ws2812fx_t *fx)
 		fx->_mode_delay = 100 + ((9 - (fx->_speed % 10)) * 125);
 	}
 
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % ((2 * ((fx->_speed / 10) + 1)) + 1);
 }
 
@@ -652,33 +633,33 @@ static void mode_multi_strobe(ws2812fx_t *fx)
 /*
  * Classic Strobe effect. Cycling through the rainbow.
  */
-static void mode_strobe_rainbow(ws2812fx_t *fx)
+static void mode_strobe_rainbow(struct ws2812fx* fx)
 {
-	if(fx->_counter_mode_call % 2 == 0) {
-		for(uint16_t i=0; i < fx->_led_count; i++) {
-			set_pixel_color(i, color_wheel(fx->_counter_mode_call % 256));
+	if (fx->_counter_mode_call % 2 == 0) {
+		for (uint16_t i=0; i < fx->_led_count; i++) {
+			set_pixel_color(fx, i, color_wheel(fx->_counter_mode_call % 256));
 		}
 		fx->_mode_delay = 20;
 	} else {
-		for(uint16_t i=0; i < fx->_led_count; i++) {
-			set_pixel_color(i, 0);
+		for (uint16_t i=0; i < fx->_led_count; i++) {
+			set_pixel_color(fx, i, 0);
 		}
 		fx->_mode_delay = 50 + ((1986 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
 	}
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 }
 
 
 /*
  * Classic Blink effect. Cycling through the rainbow.
  */
-static void mode_blink_rainbow(ws2812fx_t *fx)
+static void mode_blink_rainbow(struct ws2812fx* fx)
 {
-	if(fx->_counter_mode_call % 2 == 1) {
-		for(uint16_t i=0; i < fx->_led_count; i++) {
-			set_pixel_color(i, color_wheel(fx->_counter_mode_call % 256));
+	if (fx->_counter_mode_call % 2 == 1) {
+		for (uint16_t i=0; i < fx->_led_count; i++) {
+			set_pixel_color(fx, i, color_wheel(fx->_counter_mode_call % 256));
 		}
-		ws2812_send_frame(fx->_led_count);
+		ws2812_send_frame(fx->wsconf, fx->_led_count);
 	} else {
 		strip_off(fx);
 	}
@@ -690,17 +671,17 @@ static void mode_blink_rainbow(ws2812fx_t *fx)
 /*
  * fx->_color running on white.
  */
-static void mode_chase_white(ws2812fx_t *fx)
+static void mode_chase_white(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, WHITE);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, WHITE);
 	}
 
 	uint16_t n = fx->_counter_mode_step;
 	uint16_t m = (fx->_counter_mode_step + 1) % fx->_led_count;
-	set_pixel_color(n, fx->_color);
-	set_pixel_color(m, fx->_color);
-	ws2812_send_frame(fx->_led_count);
+	set_pixel_color(fx, n, fx->_color);
+	set_pixel_color(fx, m, fx->_color);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % fx->_led_count;
 	fx->_mode_delay = 10 + ((30 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
@@ -710,17 +691,17 @@ static void mode_chase_white(ws2812fx_t *fx)
 /*
  * White running on fx->_color.
  */
-static void mode_chase_color(ws2812fx_t *fx)
+static void mode_chase_color(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, fx->_color);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, fx->_color);
 	}
 
 	uint16_t n = fx->_counter_mode_step;
 	uint16_t m = (fx->_counter_mode_step + 1) % fx->_led_count;
-	set_pixel_color(n, WHITE);
-	set_pixel_color(m, WHITE);
-	ws2812_send_frame(fx->_led_count);
+	set_pixel_color(fx, n, WHITE);
+	set_pixel_color(fx, m, WHITE);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % fx->_led_count;
 	fx->_mode_delay = 10 + ((30 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
@@ -730,23 +711,23 @@ static void mode_chase_color(ws2812fx_t *fx)
 /*
  * White running followed by random color.
  */
-static void mode_chase_random(ws2812fx_t *fx)
+static void mode_chase_random(struct ws2812fx* fx)
 {
-	if(fx->_counter_mode_step == 0) {
-		set_pixel_color(fx->_led_count-1, color_wheel(fx->_mode_color));
+	if (fx->_counter_mode_step == 0) {
+		set_pixel_color(fx, fx->_led_count-1, color_wheel(fx->_mode_color));
 		fx->_mode_color = get_random_wheel_index(fx->_mode_color);
 	}
 
-	for(uint16_t i=0; i < fx->_counter_mode_step; i++) {
-		set_pixel_color(i, color_wheel(fx->_mode_color));
+	for (uint16_t i=0; i < fx->_counter_mode_step; i++) {
+		set_pixel_color(fx, i, color_wheel(fx->_mode_color));
 	}
 
 	uint16_t n = fx->_counter_mode_step;
 	uint16_t m = (fx->_counter_mode_step + 1) % fx->_led_count;
-	set_pixel_color(n, WHITE);
-	set_pixel_color(m, WHITE);
+	set_pixel_color(fx, n, WHITE);
+	set_pixel_color(fx, m, WHITE);
 
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % fx->_led_count;
 	fx->_mode_delay = 10 + ((30 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
@@ -756,17 +737,17 @@ static void mode_chase_random(ws2812fx_t *fx)
 /*
  * White running on rainbow.
  */
-static void mode_chase_rainbow(ws2812fx_t *fx)
+static void mode_chase_rainbow(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, color_wheel(((i * 256 / fx->_led_count) + (fx->_counter_mode_call % 256)) % 256));
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, color_wheel(((i * 256 / fx->_led_count) + (fx->_counter_mode_call % 256)) % 256));
 	}
 
 	uint16_t n = fx->_counter_mode_step;
 	uint16_t m = (fx->_counter_mode_step + 1) % fx->_led_count;
-	set_pixel_color(n, WHITE);
-	set_pixel_color(m, WHITE);
-	ws2812_send_frame(fx->_led_count);
+	set_pixel_color(fx, n, WHITE);
+	set_pixel_color(fx, m, WHITE);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % fx->_led_count;
 	fx->_mode_delay = 10 + ((30 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
@@ -776,21 +757,21 @@ static void mode_chase_rainbow(ws2812fx_t *fx)
 /*
  * White flashes running on fx->_color.
  */
-static void mode_chase_flash(ws2812fx_t *fx)
+static void mode_chase_flash(struct ws2812fx* fx)
 {
 	const static uint8_t flash_count = 4;
 	uint8_t flash_step = fx->_counter_mode_call % ((flash_count * 2) + 1);
 
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, fx->_color);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, fx->_color);
 	}
 
-	if(flash_step < (flash_count * 2)) {
-		if(flash_step % 2 == 0) {
+	if (flash_step < (flash_count * 2)) {
+		if (flash_step % 2 == 0) {
 			uint16_t n = fx->_counter_mode_step;
 			uint16_t m = (fx->_counter_mode_step + 1) % fx->_led_count;
-			set_pixel_color(n, WHITE);
-			set_pixel_color(m, WHITE);
+			set_pixel_color(fx, n, WHITE);
+			set_pixel_color(fx, m, WHITE);
 			fx->_mode_delay = 20;
 		} else {
 			fx->_mode_delay = 30;
@@ -800,61 +781,61 @@ static void mode_chase_flash(ws2812fx_t *fx)
 		fx->_mode_delay = 10 + ((30 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
 	}
 
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 }
 
 
 /*
  * White flashes running, followed by random color.
  */
-static void mode_chase_flash_random(ws2812fx_t *fx)
+static void mode_chase_flash_random(struct ws2812fx* fx)
 {
 	const static uint8_t flash_count = 4;
 	uint8_t flash_step = fx->_counter_mode_call % ((flash_count * 2) + 1);
 
-	for(uint16_t i=0; i < fx->_counter_mode_step; i++) {
-		set_pixel_color(i, color_wheel(fx->_mode_color));
+	for (uint16_t i=0; i < fx->_counter_mode_step; i++) {
+		set_pixel_color(fx, i, color_wheel(fx->_mode_color));
 	}
 
-	if(flash_step < (flash_count * 2)) {
+	if (flash_step < (flash_count * 2)) {
 		uint16_t n = fx->_counter_mode_step;
 		uint16_t m = (fx->_counter_mode_step + 1) % fx->_led_count;
-		if(flash_step % 2 == 0) {
-			set_pixel_color(n, WHITE);
-			set_pixel_color(m, WHITE);
+		if (flash_step % 2 == 0) {
+			set_pixel_color(fx, n, WHITE);
+			set_pixel_color(fx, m, WHITE);
 			fx->_mode_delay = 20;
 		} else {
-			set_pixel_color(n, color_wheel(fx->_mode_color));
-			set_pixel_color(m, BLACK);
+			set_pixel_color(fx, n, color_wheel(fx->_mode_color));
+			set_pixel_color(fx, m, BLACK);
 			fx->_mode_delay = 30;
 		}
 	} else {
 		fx->_counter_mode_step = (fx->_counter_mode_step + 1) % fx->_led_count;
 		fx->_mode_delay = 1 + ((10 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
 
-		if(fx->_counter_mode_step == 0) {
+		if (fx->_counter_mode_step == 0) {
 			fx->_mode_color = get_random_wheel_index(fx->_mode_color);
 		}
 	}
 
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 }
 
 
 /*
  * Rainbow running on white.
  */
-static void mode_chase_rainbow_white(ws2812fx_t *fx)
+static void mode_chase_rainbow_white(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, WHITE);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, WHITE);
 	}
 
 	uint16_t n = fx->_counter_mode_step;
 	uint16_t m = (fx->_counter_mode_step + 1) % fx->_led_count;
-	set_pixel_color(n, color_wheel(((n * 256 / fx->_led_count) + (fx->_counter_mode_call % 256)) % 256));
-	set_pixel_color(m, color_wheel(((m * 256 / fx->_led_count) + (fx->_counter_mode_call % 256)) % 256));
-	ws2812_send_frame(fx->_led_count);
+	set_pixel_color(fx, n, color_wheel(((n * 256 / fx->_led_count) + (fx->_counter_mode_call % 256)) % 256));
+	set_pixel_color(fx, m, color_wheel(((m * 256 / fx->_led_count) + (fx->_counter_mode_call % 256)) % 256));
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % fx->_led_count;
 	fx->_mode_delay = 10 + ((30 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
@@ -864,17 +845,17 @@ static void mode_chase_rainbow_white(ws2812fx_t *fx)
 /*
  * Black running on fx->_color.
  */
-static void mode_chase_blackout(ws2812fx_t *fx)
+static void mode_chase_blackout(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, fx->_color);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, fx->_color);
 	}
 
 	uint16_t n = fx->_counter_mode_step;
 	uint16_t m = (fx->_counter_mode_step + 1) % fx->_led_count;
-	set_pixel_color(n, BLACK);
-	set_pixel_color(m, BLACK);
-	ws2812_send_frame(fx->_led_count);
+	set_pixel_color(fx, n, BLACK);
+	set_pixel_color(fx, m, BLACK);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % fx->_led_count;
 	fx->_mode_delay = 10 + ((30 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
@@ -884,17 +865,17 @@ static void mode_chase_blackout(ws2812fx_t *fx)
 /*
  * Black running on rainbow.
  */
-static void mode_chase_blackout_rainbow(ws2812fx_t *fx)
+static void mode_chase_blackout_rainbow(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		set_pixel_color(i, color_wheel(((i * 256 / fx->_led_count) + (fx->_counter_mode_call % 256)) % 256));
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		set_pixel_color(fx, i, color_wheel(((i * 256 / fx->_led_count) + (fx->_counter_mode_call % 256)) % 256));
 	}
 
 	uint16_t n = fx->_counter_mode_step;
 	uint16_t m = (fx->_counter_mode_step + 1) % fx->_led_count;
-	set_pixel_color(n, BLACK);
-	set_pixel_color(m, BLACK);
-	ws2812_send_frame(fx->_led_count);
+	set_pixel_color(fx, n, BLACK);
+	set_pixel_color(fx, m, BLACK);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % fx->_led_count;
 	fx->_mode_delay = 10 + ((30 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
@@ -904,18 +885,18 @@ static void mode_chase_blackout_rainbow(ws2812fx_t *fx)
 /*
  * Random color intruduced alternating from start and end of strip.
  */
-static void mode_color_sweep_random(ws2812fx_t *fx)
+static void mode_color_sweep_random(struct ws2812fx* fx)
 {
-	if(fx->_counter_mode_step == 0 || fx->_counter_mode_step == fx->_led_count) {
+	if (fx->_counter_mode_step == 0 || fx->_counter_mode_step == fx->_led_count) {
 		fx->_mode_color = get_random_wheel_index(fx->_mode_color);
 	}
 
-	if(fx->_counter_mode_step < fx->_led_count) {
-		set_pixel_color(fx->_counter_mode_step, color_wheel(fx->_mode_color));
+	if (fx->_counter_mode_step < fx->_led_count) {
+		set_pixel_color(fx, fx->_counter_mode_step, color_wheel(fx->_mode_color));
 	} else {
-		set_pixel_color((fx->_led_count * 2) - fx->_counter_mode_step - 1, color_wheel(fx->_mode_color));
+		set_pixel_color(fx, (fx->_led_count * 2) - fx->_counter_mode_step - 1, color_wheel(fx->_mode_color));
 	}
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % (fx->_led_count * 2);
 	fx->_mode_delay = 5 + ((50 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
@@ -925,16 +906,16 @@ static void mode_color_sweep_random(ws2812fx_t *fx)
 /*
  * Alternating color/white pixels running.
  */
-static void mode_running_color(ws2812fx_t *fx)
+static void mode_running_color(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		if((i + fx->_counter_mode_step) % 4 < 2) {
-			set_pixel_color(i, fx->_mode_color);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		if ((i + fx->_counter_mode_step) % 4 < 2) {
+			set_pixel_color(fx, i, fx->_mode_color);
 		} else {
-			set_pixel_color(i, WHITE);
+			set_pixel_color(fx, i, WHITE);
 		}
 	}
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % 4;
 	fx->_mode_delay = 10 + ((30 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
@@ -944,16 +925,16 @@ static void mode_running_color(ws2812fx_t *fx)
 /*
  * Alternating red/blue pixels running.
  */
-static void mode_running_red_blue(ws2812fx_t *fx)
+static void mode_running_red_blue(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		if((i + fx->_counter_mode_step) % 4 < 2) {
-			set_pixel_color(i, RED);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		if ((i + fx->_counter_mode_step) % 4 < 2) {
+			set_pixel_color(fx, i, RED);
 		} else {
-			set_pixel_color(i, BLUE);
+			set_pixel_color(fx, i, BLUE);
 		}
 	}
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % 4;
 	fx->_mode_delay = 100 + ((100 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
@@ -963,18 +944,18 @@ static void mode_running_red_blue(ws2812fx_t *fx)
 /*
  * Random colored pixels running.
  */
-static void mode_running_random(ws2812fx_t *fx)
+static void mode_running_random(struct ws2812fx* fx)
 {
-	for(uint16_t i=fx->_led_count-1; i > 0; i--) {
-		set_pixel_color(i, get_pixel_color(i-1));
+	for (uint16_t i=fx->_led_count-1; i > 0; i--) {
+		set_pixel_color(fx, i, get_pixel_color(fx, i-1));
 	}
 
-	if(fx->_counter_mode_step == 0) {
+	if (fx->_counter_mode_step == 0) {
 		fx->_mode_color = get_random_wheel_index(fx->_mode_color);
-		set_pixel_color(0, color_wheel(fx->_mode_color));
+		set_pixel_color(fx, 0, color_wheel(fx->_mode_color));
 	}
 
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % 2;
 
@@ -985,10 +966,10 @@ static void mode_running_random(ws2812fx_t *fx)
 /*
  * K.I.T.T.
  */
-static void mode_larson_scanner(ws2812fx_t *fx)
+static void mode_larson_scanner(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		uint32_t px_rgb = get_pixel_color(i);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		uint32_t px_rgb = get_pixel_color(fx, i);
 
 		uint8_t px_r = (px_rgb & 0x00FF0000) >> 16;
 		uint8_t px_g = (px_rgb & 0x0000FF00) >>  8;
@@ -999,19 +980,19 @@ static void mode_larson_scanner(ws2812fx_t *fx)
 		px_g = px_g >> 1;
 		px_b = px_b >> 1;
 
-		set_pixel_rgb_color(i, px_r, px_g, px_b);
+		set_pixel_rgb_color(fx, i, px_r, px_g, px_b);
 	}
 
 	uint16_t pos = 0;
 
-	if(fx->_counter_mode_step < fx->_led_count) {
+	if (fx->_counter_mode_step < fx->_led_count) {
 		pos = fx->_counter_mode_step;
 	} else {
 		pos = (fx->_led_count * 2) - fx->_counter_mode_step - 2;
 	}
 
-	set_pixel_color(pos, fx->_color);
-	ws2812_send_frame(fx->_led_count);
+	set_pixel_color(fx, pos, fx->_color);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % ((fx->_led_count * 2) - 2);
 	fx->_mode_delay = 10 + ((10 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
@@ -1021,11 +1002,11 @@ static void mode_larson_scanner(ws2812fx_t *fx)
 /*
  * Fireing comets from one end.
  */
-static void mode_comet(ws2812fx_t *fx)
+static void mode_comet(struct ws2812fx* fx)
 {
 
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		uint32_t px_rgb = get_pixel_color(i);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		uint32_t px_rgb = get_pixel_color(fx, i);
 
 		uint8_t px_r = (px_rgb & 0x00FF0000) >> 16;
 		uint8_t px_g = (px_rgb & 0x0000FF00) >>  8;
@@ -1036,11 +1017,11 @@ static void mode_comet(ws2812fx_t *fx)
 		px_g = px_g >> 1;
 		px_b = px_b >> 1;
 
-		set_pixel_rgb_color(i, px_r, px_g, px_b);
+		set_pixel_rgb_color(fx, i, px_r, px_g, px_b);
 	}
 
-	set_pixel_color(fx->_counter_mode_step, fx->_color);
-	ws2812_send_frame(fx->_led_count);
+	set_pixel_color(fx, fx->_counter_mode_step, fx->_color);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % fx->_led_count;
 	fx->_mode_delay = 10 + ((10 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
@@ -1050,15 +1031,15 @@ static void mode_comet(ws2812fx_t *fx)
 /*
  * Firework sparks.
  */
-static void mode_fireworks(ws2812fx_t *fx)
+static void mode_fireworks(struct ws2812fx* fx)
 {
 	uint32_t px_rgb = 0;
 	uint8_t px_r = 0;
 	uint8_t px_g = 0;
 	uint8_t px_b = 0;
 
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		px_rgb = get_pixel_color(i);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		px_rgb = get_pixel_color(fx, i);
 
 		px_r = (px_rgb & 0x00FF0000) >> 16;
 		px_g = (px_rgb & 0x0000FF00) >>  8;
@@ -1069,54 +1050,54 @@ static void mode_fireworks(ws2812fx_t *fx)
 		px_g = px_g >> 1;
 		px_b = px_b >> 1;
 
-		set_pixel_rgb_color(i, px_r, px_g, px_b);
+		set_pixel_rgb_color(fx, i, px_r, px_g, px_b);
 	}
 
 	// first LED has only one neighbour
-	px_r = (((get_pixel_color(1) & 0x00FF0000) >> 16) >> 1) + ((get_pixel_color(0) & 0x00FF0000) >> 16);
-	px_g = (((get_pixel_color(1) & 0x0000FF00) >>  8) >> 1) + ((get_pixel_color(0) & 0x0000FF00) >>  8);
-	px_b = (((get_pixel_color(1) & 0x000000FF) >>  0) >> 1) + ((get_pixel_color(0) & 0x000000FF) >>  0);
-	set_pixel_rgb_color(0, px_r, px_g, px_b);
+	px_r = (((get_pixel_color(fx, 1) & 0x00FF0000) >> 16) >> 1) + ((get_pixel_color(fx, 0) & 0x00FF0000) >> 16);
+	px_g = (((get_pixel_color(fx, 1) & 0x0000FF00) >>  8) >> 1) + ((get_pixel_color(fx, 0) & 0x0000FF00) >>  8);
+	px_b = (((get_pixel_color(fx, 1) & 0x000000FF) >>  0) >> 1) + ((get_pixel_color(fx, 0) & 0x000000FF) >>  0);
+	set_pixel_rgb_color(fx, 0, px_r, px_g, px_b);
 
 	// set brightness(i) = ((brightness(i-1)/2 + brightness(i+1)) / 2) + brightness(i)
-	for(uint16_t i=1; i < fx->_led_count-1; i++) {
+	for (uint16_t i=1; i < fx->_led_count-1; i++) {
 		px_r = ((
-					(((get_pixel_color(i-1) & 0x00FF0000) >> 16) >> 1) +
-					(((get_pixel_color(i+1) & 0x00FF0000) >> 16) >> 0) ) >> 1) +
-			(((get_pixel_color(i  ) & 0x00FF0000) >> 16) >> 0);
+					(((get_pixel_color(fx, i-1) & 0x00FF0000) >> 16) >> 1) +
+					(((get_pixel_color(fx, i+1) & 0x00FF0000) >> 16) >> 0) ) >> 1) +
+			(((get_pixel_color(fx, i  ) & 0x00FF0000) >> 16) >> 0);
 
 		px_g = ((
-					(((get_pixel_color(i-1) & 0x0000FF00) >> 8) >> 1) +
-					(((get_pixel_color(i+1) & 0x0000FF00) >> 8) >> 0) ) >> 1) +
-			(((get_pixel_color(i  ) & 0x0000FF00) >> 8) >> 0);
+					(((get_pixel_color(fx, i-1) & 0x0000FF00) >> 8) >> 1) +
+					(((get_pixel_color(fx, i+1) & 0x0000FF00) >> 8) >> 0) ) >> 1) +
+			(((get_pixel_color(fx, i  ) & 0x0000FF00) >> 8) >> 0);
 
 		px_b = ((
-					(((get_pixel_color(i-1) & 0x000000FF) >> 0) >> 1) +
-					(((get_pixel_color(i+1) & 0x000000FF) >> 0) >> 0) ) >> 1) +
-			(((get_pixel_color(i  ) & 0x000000FF) >> 0) >> 0);
+					(((get_pixel_color(fx, i-1) & 0x000000FF) >> 0) >> 1) +
+					(((get_pixel_color(fx, i+1) & 0x000000FF) >> 0) >> 0) ) >> 1) +
+			(((get_pixel_color(fx, i  ) & 0x000000FF) >> 0) >> 0);
 
-		set_pixel_rgb_color(i, px_r, px_g, px_b);
+		set_pixel_rgb_color(fx, i, px_r, px_g, px_b);
 	}
 
 	// last LED has only one neighbour
-	px_r = (((get_pixel_color(fx->_led_count-2) & 0x00FF0000) >> 16) >> 2) + ((get_pixel_color(fx->_led_count-1) & 0x00FF0000) >> 16);
-	px_g = (((get_pixel_color(fx->_led_count-2) & 0x0000FF00) >>  8) >> 2) + ((get_pixel_color(fx->_led_count-1) & 0x0000FF00) >>  8);
-	px_b = (((get_pixel_color(fx->_led_count-2) & 0x000000FF) >>  0) >> 2) + ((get_pixel_color(fx->_led_count-1) & 0x000000FF) >>  0);
-	set_pixel_rgb_color(fx->_led_count-1, px_r, px_g, px_b);
-
-	if(!fx->_triggered) {
-		for(uint16_t i=0; i<max(1,fx->_led_count/20); i++) {
-			if(random(10) == 0) {
-				set_pixel_color(random(fx->_led_count), fx->_mode_color);
+	px_r = (((get_pixel_color(fx, fx->_led_count-2) & 0x00FF0000) >> 16) >> 2) + ((get_pixel_color(fx, fx->_led_count-1) & 0x00FF0000) >> 16);
+	px_g = (((get_pixel_color(fx, fx->_led_count-2) & 0x0000FF00) >>  8) >> 2) + ((get_pixel_color(fx, fx->_led_count-1) & 0x0000FF00) >>  8);
+	px_b = (((get_pixel_color(fx, fx->_led_count-2) & 0x000000FF) >>  0) >> 2) + ((get_pixel_color(fx, fx->_led_count-1) & 0x000000FF) >>  0);
+	set_pixel_rgb_color(fx, fx->_led_count-1, px_r, px_g, px_b);
+
+	if (!fx->_triggered) {
+		for (uint16_t i=0; i<max(1,fx->_led_count/20); i++) {
+			if (random(10) == 0) {
+				set_pixel_color(fx, random(fx->_led_count), fx->_mode_color);
 			}
 		}
 	} else {
-		for(uint16_t i=0; i<max(1,fx->_led_count/10); i++) {
-			set_pixel_color(random(fx->_led_count), fx->_mode_color);
+		for (uint16_t i=0; i<max(1,fx->_led_count/10); i++) {
+			set_pixel_color(fx, random(fx->_led_count), fx->_mode_color);
 		}
 	}
 
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_mode_delay = 20 + ((20 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
 }
@@ -1125,7 +1106,7 @@ static void mode_fireworks(ws2812fx_t *fx)
 /*
  * Random colored firework sparks.
  */
-static void mode_fireworks_random(ws2812fx_t *fx)
+static void mode_fireworks_random(struct ws2812fx* fx)
 {
 	fx->_mode_color = color_wheel(random(256));
 	mode_fireworks(fx);
@@ -1135,47 +1116,47 @@ static void mode_fireworks_random(ws2812fx_t *fx)
 /*
  * Alternating red/green pixels running.
  */
-static void mode_merry_christmas(ws2812fx_t *fx)
+static void mode_merry_christmas(struct ws2812fx* fx)
 {
-	for(uint16_t i=0; i < fx->_led_count; i++) {
-		if((i + fx->_counter_mode_step) % 4 < 2) {
-			set_pixel_color(i, RED);
+	for (uint16_t i=0; i < fx->_led_count; i++) {
+		if ((i + fx->_counter_mode_step) % 4 < 2) {
+			set_pixel_color(fx, i, RED);
 		} else {
-			set_pixel_color(i, GREEN);
+			set_pixel_color(fx, i, GREEN);
 		}
 	}
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 
 	fx->_counter_mode_step = (fx->_counter_mode_step + 1) % 4;
 	fx->_mode_delay = 100 + ((100 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / fx->_led_count);
 }
 
 
-static void mode_fire_flicker_int(ws2812fx_t *fx, int rev_intensity)
+static void mode_fire_flicker_int(struct ws2812fx* fx, int rev_intensity)
 {
 	uint8_t p_r = (fx->_color & 0x00FF0000) >> 16;
 	uint8_t p_g = (fx->_color & 0x0000FF00) >>  8;
 	uint8_t p_b = (fx->_color & 0x000000FF) >>  0;
 	uint8_t flicker_val = max(p_r,max(p_g, p_b))/rev_intensity;
-	for(uint16_t i=0; i < fx->_led_count; i++)
+	for (uint16_t i=0; i < fx->_led_count; i++)
 	{
 		int flicker = random(flicker_val);
 		int r1 = p_r-flicker;
 		int g1 = p_g-flicker;
 		int b1 = p_b-flicker;
-		if(g1<0) g1=0;
-		if(r1<0) r1=0;
-		if(b1<0) b1=0;
-		set_pixel_rgb_color(i,r1,g1, b1);
+		if (g1<0) g1=0;
+		if (r1<0) r1=0;
+		if (b1<0) b1=0;
+		set_pixel_rgb_color(fx, i, r1, g1, b1);
 	}
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 	fx->_mode_delay = 10 + ((500 * (uint32_t)(FX_SPEED_MAX - fx->_speed)) / FX_SPEED_MAX);
 }
 
 /*
  * Random flickering.
  */
-static void mode_fire_flicker(ws2812fx_t *fx)
+static void mode_fire_flicker(struct ws2812fx* fx)
 {
 	mode_fire_flicker_int(fx, 3);
 }
@@ -1183,13 +1164,13 @@ static void mode_fire_flicker(ws2812fx_t *fx)
 /*
  * Random flickering, less intesity.
  */
-static void mode_fire_flicker_soft(ws2812fx_t *fx)
+static void mode_fire_flicker_soft(struct ws2812fx* fx)
 {
 	mode_fire_flicker_int(fx, 6);
 }
 
 
-typedef void (*mode_ptr)(ws2812fx_t *fx);
+typedef void (*mode_ptr)(struct ws2812fx* fx);
 
 static struct {
 	mode_ptr _fn;
@@ -1248,9 +1229,10 @@ static struct {
 
 #define CALL_MODE(fx, n) (modes[n]._fn)(fx);
 
-void WS2812FX(ws2812fx_t *fx, uint16_t n, const struct pio *pin)
+void WS2812FX(struct ws2812fx* fx, uint16_t n, const struct pio *pin)
 {
-	ws2812_config(pin);
+	fx->wsconf->nb_leds = n;
+	ws2812_config(fx->wsconf, pin);
 
 	fx->_speed = FX_DEFAULT_SPEED;
 	fx->_brightness = FX_DEFAULT_BRIGHTNESS;
@@ -1264,18 +1246,18 @@ void WS2812FX(ws2812fx_t *fx, uint16_t n, const struct pio *pin)
 	fx->_counter_mode_step = 0;
 }
 
-void FX_init(ws2812fx_t *fx)
+void FX_init(struct ws2812fx* fx)
 {
 	FX_setBrightness(fx, fx->_brightness);
-	ws2812_send_frame(fx->_led_count);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 }
 
-void FX_service(ws2812fx_t *fx)
+void FX_service(struct ws2812fx* fx)
 {
-	if(fx->_running || fx->_triggered) {
+	if (fx->_running || fx->_triggered) {
 		unsigned long now = millis();
 
-		if(now - fx->_mode_last_call_time > fx->_mode_delay || fx->_triggered) {
+		if (now - fx->_mode_last_call_time > fx->_mode_delay || fx->_triggered) {
 			CALL_MODE(fx, fx->_mode_index);
 			fx->_counter_mode_call++;
 			fx->_mode_last_call_time = now;
@@ -1284,7 +1266,7 @@ void FX_service(ws2812fx_t *fx)
 	}
 }
 
-void FX_start(ws2812fx_t *fx)
+void FX_start(struct ws2812fx* fx)
 {
 	fx->_counter_mode_call = 0;
 	fx->_counter_mode_step = 0;
@@ -1292,29 +1274,29 @@ void FX_start(ws2812fx_t *fx)
 	fx->_running = 1;
 }
 
-void FX_stop(ws2812fx_t *fx)
+void FX_stop(struct ws2812fx* fx)
 {
 	fx->_running = 0;
 	strip_off(fx);
 }
 
-void FX_trigger(ws2812fx_t *fx)
+void FX_trigger(struct ws2812fx* fx)
 {
 	fx->_triggered = 1;
 }
 
-void FX_setMode(ws2812fx_t *fx, uint8_t m)
+void FX_setMode(struct ws2812fx* fx, uint8_t m)
 {
 	fx->_counter_mode_call = 0;
 	fx->_counter_mode_step = 0;
 	fx->_mode_last_call_time = 0;
 	fx->_mode_index = constrain(m, 0, FX_MODE_COUNT-1);
 	fx->_mode_color = fx->_color;
-	ws2812_set_brightness(fx->_brightness);
+	ws2812_set_brightness(fx->wsconf, fx->_brightness);
 	//strip_off(fx);
 }
 
-void FX_setSpeed(ws2812fx_t *fx, uint8_t s)
+void FX_setSpeed(struct ws2812fx* fx, uint8_t s)
 {
 	fx->_counter_mode_call = 0;
 	fx->_counter_mode_step = 0;
@@ -1323,79 +1305,79 @@ void FX_setSpeed(ws2812fx_t *fx, uint8_t s)
 	//strip_off(fx);
 }
 
-void FX_increaseSpeed(ws2812fx_t *fx, uint8_t s)
+void FX_increaseSpeed(struct ws2812fx* fx, uint8_t s)
 {
 	s = constrain(fx->_speed + s, FX_SPEED_MIN, FX_SPEED_MAX);
 	FX_setSpeed(fx, s);
 }
 
-void FX_decreaseSpeed(ws2812fx_t *fx, uint8_t s)
+void FX_decreaseSpeed(struct ws2812fx* fx, uint8_t s)
 {
 	s = constrain(fx->_speed - s, FX_SPEED_MIN, FX_SPEED_MAX);
 	FX_setSpeed(fx, s);
 }
 
-void FX_setRGBColor(ws2812fx_t *fx, uint8_t r, uint8_t g, uint8_t b)
+void FX_setRGBColor(struct ws2812fx* fx, uint8_t r, uint8_t g, uint8_t b)
 {
 	FX_setColor(fx, ((uint32_t)r << 16) | ((uint32_t)g << 8) | b);
 }
 
-void FX_setColor(ws2812fx_t *fx, uint32_t c)
+void FX_setColor(struct ws2812fx* fx, uint32_t c)
 {
 	fx->_color = c;
 	fx->_counter_mode_call = 0;
 	fx->_counter_mode_step = 0;
 	fx->_mode_last_call_time = 0;
 	fx->_mode_color = fx->_color;
-	ws2812_set_brightness(fx->_brightness);
+	ws2812_set_brightness(fx->wsconf, fx->_brightness);
 	//strip_off(fx);
 }
 
-void FX_setBrightness(ws2812fx_t *fx, uint8_t b)
+void FX_setBrightness(struct ws2812fx* fx, uint8_t b)
 {
 	fx->_brightness = constrain(b, FX_BRIGHTNESS_MIN, FX_BRIGHTNESS_MAX);
-	ws2812_set_brightness(fx->_brightness);
-	ws2812_send_frame(fx->_led_count);
+	ws2812_set_brightness(fx->wsconf, fx->_brightness);
+	ws2812_send_frame(fx->wsconf, fx->_led_count);
 }
 
-void FX_increaseBrightness(ws2812fx_t *fx, uint8_t s)
+void FX_increaseBrightness(struct ws2812fx* fx, uint8_t s)
 {
 	s = constrain(fx->_brightness + s, FX_BRIGHTNESS_MIN, FX_BRIGHTNESS_MAX);
 	FX_setBrightness(fx, s);
 }
 
-void FX_decreaseBrightness(ws2812fx_t *fx, uint8_t s)
+void FX_decreaseBrightness(struct ws2812fx* fx, uint8_t s)
 {
 	s = constrain(fx->_brightness - s, FX_BRIGHTNESS_MIN, FX_BRIGHTNESS_MAX);
 	FX_setBrightness(fx, s);
 }
 
-int FX_isRunning(ws2812fx_t *fx)
+int FX_isRunning(struct ws2812fx* fx)
 {
 	return fx->_running;
 }
 
-uint8_t FX_getMode(ws2812fx_t *fx)
+uint8_t FX_getMode(struct ws2812fx* fx)
 {
 	return fx->_mode_index;
 }
 
-uint8_t FX_getSpeed(ws2812fx_t *fx)
+uint8_t FX_getSpeed(struct ws2812fx* fx)
 {
 	return fx->_speed;
 }
 
-uint8_t FX_getBrightness(ws2812fx_t *fx)
+uint8_t FX_getBrightness(struct ws2812fx* fx)
 {
 	return fx->_brightness;
 }
 
-uint8_t FX_getModeCount(ws2812fx_t *fx)
+uint8_t FX_getModeCount(struct ws2812fx* fx)
 {
 	return FX_MODE_COUNT;
 }
 
-uint32_t FX_getColor(ws2812fx_t *fx)
+uint32_t FX_getColor(struct ws2812fx* fx)
 {
 	return fx->_color;
 }
diff --git a/include/extdrv/ws2812fx.h b/include/extdrv/ws2812fx.h
index 2d88955..df00f2e 100644
--- a/include/extdrv/ws2812fx.h
+++ b/include/extdrv/ws2812fx.h
@@ -38,6 +38,7 @@
 #define WS2812FX_h
 
 #include "core/pio.h"
+#include "extdrv/ws2812.h"
 
 #define FX_DEFAULT_BRIGHTNESS 50
 #define FX_DEFAULT_MODE 0
@@ -103,16 +104,11 @@ enum ModeFX {
 	FX_MODE_COUNT
 };
 
-typedef struct {
+struct ws2812fx {
+	struct ws2812_conf* wsconf;
 	int _running;
 	int _triggered;
 
-	uint8_t _mode_index;
-	uint8_t _speed;
-	uint8_t _brightness;
-
-	uint16_t _led_count;
-
 	uint32_t _color;
 	uint32_t _counter_mode_call;
 	uint32_t _counter_mode_step;
@@ -120,33 +116,39 @@ typedef struct {
 	uint32_t _mode_delay;
 
 	unsigned long _mode_last_call_time;
-} ws2812fx_t;
-
-void WS2812FX(ws2812fx_t *fx, uint16_t n, const struct pio *pin);
-
-void FX_init(ws2812fx_t *fx);
-void FX_service(ws2812fx_t *fx);
-void FX_start(ws2812fx_t *fx);
-void FX_stop(ws2812fx_t *fx);
-void FX_setMode(ws2812fx_t *fx, uint8_t m);
-void FX_setSpeed(ws2812fx_t *fx, uint8_t s);
-void FX_increaseSpeed(ws2812fx_t *fx, uint8_t s);
-void FX_decreaseSpeed(ws2812fx_t *fx, uint8_t s);
-void FX_setRGBColor(ws2812fx_t *fx, uint8_t r, uint8_t g, uint8_t b);
-void FX_setColor(ws2812fx_t *fx, uint32_t c);
-void FX_trigger(ws2812fx_t *fx);
-void FX_setBrightness(ws2812fx_t *fx, uint8_t b);
-void FX_increaseBrightness(ws2812fx_t *fx, uint8_t s);
-void FX_decreaseBrightness(ws2812fx_t *fx, uint8_t s);
-
-int FX_isRunning(ws2812fx_t *fx);
-
-uint8_t FX_getMode(ws2812fx_t *fx);
-uint8_t FX_getSpeed(ws2812fx_t *fx);
-uint8_t FX_getBrightness(ws2812fx_t *fx);
-uint8_t FX_getModeCount(ws2812fx_t *fx);
-
-uint32_t FX_getColor(ws2812fx_t *fx);
+
+	uint16_t _led_count;
+
+	uint8_t _mode_index;
+	uint8_t _speed;
+	uint8_t _brightness;
+};
+
+void WS2812FX(struct ws2812fx* fx, uint16_t n, const struct pio* pin);
+
+void FX_init(struct ws2812fx* fx);
+void FX_service(struct ws2812fx* fx);
+void FX_start(struct ws2812fx* fx);
+void FX_stop(struct ws2812fx* fx);
+void FX_setMode(struct ws2812fx* fx, uint8_t m);
+void FX_setSpeed(struct ws2812fx* fx, uint8_t s);
+void FX_increaseSpeed(struct ws2812fx* fx, uint8_t s);
+void FX_decreaseSpeed(struct ws2812fx* fx, uint8_t s);
+void FX_setRGBColor(struct ws2812fx* fx, uint8_t r, uint8_t g, uint8_t b);
+void FX_setColor(struct ws2812fx* fx, uint32_t c);
+void FX_trigger(struct ws2812fx* fx);
+void FX_setBrightness(struct ws2812fx* fx, uint8_t b);
+void FX_increaseBrightness(struct ws2812fx* fx, uint8_t s);
+void FX_decreaseBrightness(struct ws2812fx* fx, uint8_t s);
+
+int FX_isRunning(struct ws2812fx* fx);
+
+uint8_t FX_getMode(struct ws2812fx* fx);
+uint8_t FX_getSpeed(struct ws2812fx* fx);
+uint8_t FX_getBrightness(struct ws2812fx* fx);
+uint8_t FX_getModeCount(struct ws2812fx* fx);
+
+uint32_t FX_getColor(struct ws2812fx* fx);
 
 const char* FX_getModeName(uint8_t m);