diff --git a/wled00/FX_2Dfcn.cpp b/wled00/FX_2Dfcn.cpp
index e4007ed7e..e14b68f4f 100644
--- a/wled00/FX_2Dfcn.cpp
+++ b/wled00/FX_2Dfcn.cpp
@@ -110,11 +110,11 @@ void WS2812FX::setUpMatrix() {
         releaseJSONBufferLock();
       }
 
-      uint16_t x, y, pix=0; //pixel
+      unsigned x, y, pix=0; //pixel
       for (size_t pan = 0; pan < panel.size(); pan++) {
         Panel &p = panel[pan];
-        uint16_t h = p.vertical ? p.height : p.width;
-        uint16_t v = p.vertical ? p.width  : p.height;
+        unsigned h = p.vertical ? p.height : p.width;
+        unsigned v = p.vertical ? p.width  : p.height;
         for (size_t j = 0; j < v; j++){
           for(size_t i = 0; i < h; i++) {
             y = (p.vertical?p.rightStart:p.bottomStart) ? v-j-1 : j;
@@ -163,8 +163,8 @@ void WS2812FX::setUpMatrix() {
 // XY(x,y) - gets pixel index within current segment (often used to reference leds[] array element)
 uint16_t IRAM_ATTR Segment::XY(uint16_t x, uint16_t y)
 {
-  uint16_t width  = virtualWidth();   // segment width in logical pixels (can be 0 if segment is inactive)
-  uint16_t height = virtualHeight();  // segment height in logical pixels (is always >= 1)
+  unsigned width  = virtualWidth();   // segment width in logical pixels (can be 0 if segment is inactive)
+  unsigned height = virtualHeight();  // segment height in logical pixels (is always >= 1)
   return isActive() ? (x%width) + (y%height) * width : 0;
 }
 
@@ -180,7 +180,7 @@ void IRAM_ATTR Segment::setPixelColorXY(int x, int y, uint32_t col)
 
   if (reverse  ) x = virtualWidth()  - x - 1;
   if (reverse_y) y = virtualHeight() - y - 1;
-  if (transpose) { uint16_t t = x; x = y; y = t; } // swap X & Y if segment transposed
+  if (transpose) { unsigned t = x; x = y; y = t; } // swap X & Y if segment transposed
 
   x *= groupLength(); // expand to physical pixels
   y *= groupLength(); // expand to physical pixels
@@ -189,7 +189,7 @@ void IRAM_ATTR Segment::setPixelColorXY(int x, int y, uint32_t col)
   uint32_t tmpCol = col;
   for (int j = 0; j < grouping; j++) {   // groupping vertically
     for (int g = 0; g < grouping; g++) { // groupping horizontally
-      uint16_t xX = (x+g), yY = (y+j);
+      unsigned xX = (x+g), yY = (y+j);
       if (xX >= width() || yY >= height()) continue; // we have reached one dimension's end
 
 #ifndef WLED_DISABLE_MODE_BLEND
@@ -221,16 +221,16 @@ void Segment::setPixelColorXY(float x, float y, uint32_t col, bool aa)
   if (!isActive()) return; // not active
   if (x<0.0f || x>1.0f || y<0.0f || y>1.0f) return; // not normalized
 
-  const uint16_t cols = virtualWidth();
-  const uint16_t rows = virtualHeight();
+  const unsigned cols = virtualWidth();
+  const unsigned rows = virtualHeight();
 
   float fX = x * (cols-1);
   float fY = y * (rows-1);
   if (aa) {
-    uint16_t xL = roundf(fX-0.49f);
-    uint16_t xR = roundf(fX+0.49f);
-    uint16_t yT = roundf(fY-0.49f);
-    uint16_t yB = roundf(fY+0.49f);
+    unsigned xL = roundf(fX-0.49f);
+    unsigned xR = roundf(fX+0.49f);
+    unsigned yT = roundf(fY-0.49f);
+    unsigned yB = roundf(fY+0.49f);
     float    dL = (fX - xL)*(fX - xL);
     float    dR = (xR - fX)*(xR - fX);
     float    dT = (fY - yT)*(fY - yT);
@@ -266,7 +266,7 @@ uint32_t IRAM_ATTR Segment::getPixelColorXY(int x, int y) {
   if (x >= virtualWidth() || y >= virtualHeight() || x<0 || y<0) return 0;  // if pixel would fall out of virtual segment just exit
   if (reverse  ) x = virtualWidth()  - x - 1;
   if (reverse_y) y = virtualHeight() - y - 1;
-  if (transpose) { uint16_t t = x; x = y; y = t; } // swap X & Y if segment transposed
+  if (transpose) { unsigned t = x; x = y; y = t; } // swap X & Y if segment transposed
   x *= groupLength(); // expand to physical pixels
   y *= groupLength(); // expand to physical pixels
   if (x >= width() || y >= height()) return 0;
@@ -276,8 +276,8 @@ uint32_t IRAM_ATTR Segment::getPixelColorXY(int x, int y) {
 // blurRow: perform a blur on a row of a rectangular matrix
 void Segment::blurRow(uint32_t row, fract8 blur_amount, bool smear){
   if (!isActive() || blur_amount == 0) return; // not active
-  const uint_fast16_t cols = virtualWidth();
-  const uint_fast16_t rows = virtualHeight();
+  const unsigned cols = virtualWidth();
+  const unsigned rows = virtualHeight();
 
   if (row >= rows) return;
   // blur one row
@@ -309,8 +309,8 @@ void Segment::blurRow(uint32_t row, fract8 blur_amount, bool smear){
 // blurCol: perform a blur on a column of a rectangular matrix
 void Segment::blurCol(uint32_t col, fract8 blur_amount, bool smear) {
   if (!isActive() || blur_amount == 0) return; // not active
-  const uint_fast16_t cols = virtualWidth();
-  const uint_fast16_t rows = virtualHeight();
+  const unsigned cols = virtualWidth();
+  const unsigned rows = virtualHeight();
 
   if (col >= cols) return;
   // blur one column
@@ -342,34 +342,34 @@ void Segment::blurCol(uint32_t col, fract8 blur_amount, bool smear) {
 // 1D Box blur (with added weight - blur_amount: [0=no blur, 255=max blur])
 void Segment::box_blur(uint16_t i, bool vertical, fract8 blur_amount) {
   if (!isActive() || blur_amount == 0) return; // not active
-  const uint16_t cols = virtualWidth();
-  const uint16_t rows = virtualHeight();
-  const uint16_t dim1 = vertical ? rows : cols;
-  const uint16_t dim2 = vertical ? cols : rows;
+  const unsigned cols = virtualWidth();
+  const unsigned rows = virtualHeight();
+  const unsigned dim1 = vertical ? rows : cols;
+  const unsigned dim2 = vertical ? cols : rows;
   if (i >= dim2) return;
   const float seep = blur_amount/255.f;
   const float keep = 3.f - 2.f*seep;
   // 1D box blur
   CRGB tmp[dim1];
-  for (int j = 0; j < dim1; j++) {
-    uint16_t x = vertical ? i : j;
-    uint16_t y = vertical ? j : i;
-    int16_t xp = vertical ? x : x-1;  // "signed" to prevent underflow
-    int16_t yp = vertical ? y-1 : y;  // "signed" to prevent underflow
-    uint16_t xn = vertical ? x : x+1;
-    uint16_t yn = vertical ? y+1 : y;
+  for (unsigned j = 0; j < dim1; j++) {
+    unsigned x = vertical ? i : j;
+    unsigned y = vertical ? j : i;
+    int xp = vertical ? x : x-1;  // "signed" to prevent underflow
+    int yp = vertical ? y-1 : y;  // "signed" to prevent underflow
+    unsigned xn = vertical ? x : x+1;
+    unsigned yn = vertical ? y+1 : y;
     CRGB curr = getPixelColorXY(x,y);
     CRGB prev = (xp<0 || yp<0) ? CRGB::Black : getPixelColorXY(xp,yp);
     CRGB next = ((vertical && yn>=dim1) || (!vertical && xn>=dim1)) ? CRGB::Black : getPixelColorXY(xn,yn);
-    uint16_t r, g, b;
+    unsigned r, g, b;
     r = (curr.r*keep + (prev.r + next.r)*seep) / 3;
     g = (curr.g*keep + (prev.g + next.g)*seep) / 3;
     b = (curr.b*keep + (prev.b + next.b)*seep) / 3;
     tmp[j] = CRGB(r,g,b);
   }
-  for (int j = 0; j < dim1; j++) {
-    uint16_t x = vertical ? i : j;
-    uint16_t y = vertical ? j : i;
+  for (unsigned j = 0; j < dim1; j++) {
+    unsigned x = vertical ? i : j;
+    unsigned y = vertical ? j : i;
     setPixelColorXY(x, y, tmp[j]);
   }
 }
@@ -389,14 +389,14 @@ void Segment::box_blur(uint16_t i, bool vertical, fract8 blur_amount) {
 //         it can be used to (slowly) clear the LEDs to black.
 
 void Segment::blur1d(fract8 blur_amount) {
-  const uint16_t rows = virtualHeight();
+  const unsigned rows = virtualHeight();
   for (unsigned y = 0; y < rows; y++) blurRow(y, blur_amount);
 }
 
 void Segment::moveX(int8_t delta, bool wrap) {
   if (!isActive()) return; // not active
-  const uint16_t cols = virtualWidth();
-  const uint16_t rows = virtualHeight();
+  const int cols = virtualWidth();
+  const int rows = virtualHeight();
   if (!delta || abs(delta) >= cols) return;
   uint32_t newPxCol[cols];
   for (int y = 0; y < rows; y++) {
@@ -413,8 +413,8 @@ void Segment::moveX(int8_t delta, bool wrap) {
 
 void Segment::moveY(int8_t delta, bool wrap) {
   if (!isActive()) return; // not active
-  const uint16_t cols = virtualWidth();
-  const uint16_t rows = virtualHeight();
+  const int cols = virtualWidth();
+  const int rows = virtualHeight();
   if (!delta || abs(delta) >= rows) return;
   uint32_t newPxCol[rows];
   for (int x = 0; x < cols; x++) {
@@ -474,13 +474,13 @@ void Segment::draw_circle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB col) {
 // by stepko, taken from https://editor.soulmatelights.com/gallery/573-blobs
 void Segment::fill_circle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB col) {
   if (!isActive() || radius == 0) return; // not active
-  const uint16_t cols = virtualWidth();
-  const uint16_t rows = virtualHeight();
-  for (int16_t y = -radius; y <= radius; y++) {
-    for (int16_t x = -radius; x <= radius; x++) {
+  const int cols = virtualWidth();
+  const int rows = virtualHeight();
+  for (int y = -radius; y <= radius; y++) {
+    for (int x = -radius; x <= radius; x++) {
       if (x * x + y * y <= radius * radius &&
-          int16_t(cx)+x>=0 && int16_t(cy)+y>=0 &&
-          int16_t(cx)+x<cols && int16_t(cy)+y<rows)
+          int(cx)+x>=0 && int(cy)+y>=0 &&
+          int(cx)+x<cols && int(cy)+y<rows)
         setPixelColorXY(cx + x, cy + y, col);
     }
   }
@@ -488,9 +488,9 @@ void Segment::fill_circle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB col) {
 
 void Segment::nscale8(uint8_t scale) {
   if (!isActive()) return; // not active
-  const uint16_t cols = virtualWidth();
-  const uint16_t rows = virtualHeight();
-  for (int y = 0; y < rows; y++) for (int x = 0; x < cols; x++) {
+  const unsigned cols = virtualWidth();
+  const unsigned rows = virtualHeight();
+  for (unsigned y = 0; y < rows; y++) for (unsigned x = 0; x < cols; x++) {
     setPixelColorXY(x, y, CRGB(getPixelColorXY(x, y)).nscale8(scale));
   }
 }
@@ -498,12 +498,12 @@ void Segment::nscale8(uint8_t scale) {
 //line function
 void Segment::drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint32_t c) {
   if (!isActive()) return; // not active
-  const uint16_t cols = virtualWidth();
-  const uint16_t rows = virtualHeight();
+  const unsigned cols = virtualWidth();
+  const unsigned rows = virtualHeight();
   if (x0 >= cols || x1 >= cols || y0 >= rows || y1 >= rows) return;
-  const int16_t dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;
-  const int16_t dy = abs(y1-y0), sy = y0<y1 ? 1 : -1;
-  int16_t err = (dx>dy ? dx : -dy)/2, e2;
+  const int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;
+  const int dy = abs(y1-y0), sy = y0<y1 ? 1 : -1;
+  int err = (dx>dy ? dx : -dy)/2, e2;
   for (;;) {
     setPixelColorXY(x0,y0,c);
     if (x0==x1 && y0==y1) break;
@@ -525,8 +525,8 @@ void Segment::drawCharacter(unsigned char chr, int16_t x, int16_t y, uint8_t w,
   if (!isActive()) return; // not active
   if (chr < 32 || chr > 126) return; // only ASCII 32-126 supported
   chr -= 32; // align with font table entries
-  const uint16_t cols = virtualWidth();
-  const uint16_t rows = virtualHeight();
+  const int cols = virtualWidth();
+  const int rows = virtualHeight();
   const int font = w*h;
 
   CRGB col = CRGB(color);
@@ -565,7 +565,7 @@ void Segment::drawCharacter(unsigned char chr, int16_t x, int16_t y, uint8_t w,
 void Segment::wu_pixel(uint32_t x, uint32_t y, CRGB c) {      //awesome wu_pixel procedure by reddit u/sutaburosu
   if (!isActive()) return; // not active
   // extract the fractional parts and derive their inverses
-  uint8_t xx = x & 0xff, yy = y & 0xff, ix = 255 - xx, iy = 255 - yy;
+  unsigned xx = x & 0xff, yy = y & 0xff, ix = 255 - xx, iy = 255 - yy;
   // calculate the intensities for each affected pixel
   uint8_t wu[4] = {WU_WEIGHT(ix, iy), WU_WEIGHT(xx, iy),
                    WU_WEIGHT(ix, yy), WU_WEIGHT(xx, yy)};
diff --git a/wled00/FX_fcn.cpp b/wled00/FX_fcn.cpp
index 5d031e8ce..ce510f16e 100644
--- a/wled00/FX_fcn.cpp
+++ b/wled00/FX_fcn.cpp
@@ -327,7 +327,7 @@ void Segment::stopTransition() {
 }
 
 void Segment::handleTransition() {
-  uint16_t _progress = progress();
+  unsigned _progress = progress();
   if (_progress == 0xFFFFU) stopTransition();
 }
 
@@ -412,9 +412,9 @@ void Segment::restoreSegenv(tmpsegd_t &tmpSeg) {
 #endif
 
 uint8_t IRAM_ATTR Segment::currentBri(bool useCct) {
-  uint32_t prog = progress();
+  unsigned prog = progress();
   if (prog < 0xFFFFU) {
-    uint32_t curBri = (useCct ? cct : (on ? opacity : 0)) * prog;
+    unsigned curBri = (useCct ? cct : (on ? opacity : 0)) * prog;
     curBri += (useCct ? _t->_cctT : _t->_briT) * (0xFFFFU - prog);
     return curBri / 0xFFFFU;
   }
@@ -423,7 +423,7 @@ uint8_t IRAM_ATTR Segment::currentBri(bool useCct) {
 
 uint8_t IRAM_ATTR Segment::currentMode() {
 #ifndef WLED_DISABLE_MODE_BLEND
-  uint16_t prog = progress();
+  unsigned prog = progress();
   if (modeBlending && prog < 0xFFFFU) return _t->_modeT;
 #endif
   return mode;
@@ -440,13 +440,13 @@ uint32_t IRAM_ATTR Segment::currentColor(uint8_t slot) {
 
 CRGBPalette16 IRAM_ATTR &Segment::currentPalette(CRGBPalette16 &targetPalette, uint8_t pal) {
   loadPalette(targetPalette, pal);
-  uint16_t prog = progress();
+  unsigned prog = progress();
   if (strip.paletteFade && prog < 0xFFFFU) {
     // blend palettes
     // there are about 255 blend passes of 48 "blends" to completely blend two palettes (in _dur time)
     // minimum blend time is 100ms maximum is 65535ms
-    uint16_t noOfBlends = ((255U * prog) / 0xFFFFU) - _t->_prevPaletteBlends;
-    for (int i=0; i<noOfBlends; i++, _t->_prevPaletteBlends++) nblendPaletteTowardPalette(_t->_palT, targetPalette, 48);
+    unsigned noOfBlends = ((255U * prog) / 0xFFFFU) - _t->_prevPaletteBlends;
+    for (unsigned i=0; i<noOfBlends; i++, _t->_prevPaletteBlends++) nblendPaletteTowardPalette(_t->_palT, targetPalette, 48);
     targetPalette = _t->_palT; // copy transitioning/temporary palette
   }
   return targetPalette;
@@ -576,7 +576,7 @@ void Segment::setMode(uint8_t fx, bool loadDefaults) {
     mode = fx;
     // load default values from effect string
     if (loadDefaults) {
-      int16_t sOpt;
+      int sOpt;
       sOpt = extractModeDefaults(fx, "sx");  speed     = (sOpt >= 0) ? sOpt : DEFAULT_SPEED;
       sOpt = extractModeDefaults(fx, "ix");  intensity = (sOpt >= 0) ? sOpt : DEFAULT_INTENSITY;
       sOpt = extractModeDefaults(fx, "c1");  custom1   = (sOpt >= 0) ? sOpt : DEFAULT_C1;
@@ -610,21 +610,21 @@ void Segment::setPalette(uint8_t pal) {
 
 // 2D matrix
 uint16_t IRAM_ATTR Segment::virtualWidth() const {
-  uint16_t groupLen = groupLength();
-  uint16_t vWidth = ((transpose ? height() : width()) + groupLen - 1) / groupLen;
+  unsigned groupLen = groupLength();
+  unsigned vWidth = ((transpose ? height() : width()) + groupLen - 1) / groupLen;
   if (mirror) vWidth = (vWidth + 1) /2;  // divide by 2 if mirror, leave at least a single LED
   return vWidth;
 }
 
 uint16_t IRAM_ATTR Segment::virtualHeight() const {
-  uint16_t groupLen = groupLength();
-  uint16_t vHeight = ((transpose ? width() : height()) + groupLen - 1) / groupLen;
+  unsigned groupLen = groupLength();
+  unsigned vHeight = ((transpose ? width() : height()) + groupLen - 1) / groupLen;
   if (mirror_y) vHeight = (vHeight + 1) /2;  // divide by 2 if mirror, leave at least a single LED
   return vHeight;
 }
 
 uint16_t IRAM_ATTR Segment::nrOfVStrips() const {
-  uint16_t vLen = 1;
+  unsigned vLen = 1;
 #ifndef WLED_DISABLE_2D
   if (is2D()) {
     switch (map1D2D) {
@@ -641,9 +641,9 @@ uint16_t IRAM_ATTR Segment::nrOfVStrips() const {
 uint16_t IRAM_ATTR Segment::virtualLength() const {
 #ifndef WLED_DISABLE_2D
   if (is2D()) {
-    uint16_t vW = virtualWidth();
-    uint16_t vH = virtualHeight();
-    uint16_t vLen = vW * vH; // use all pixels from segment
+    unsigned vW = virtualWidth();
+    unsigned vH = virtualHeight();
+    unsigned vLen = vW * vH; // use all pixels from segment
     switch (map1D2D) {
       case M12_pBar:
         vLen = vH;
@@ -656,8 +656,8 @@ uint16_t IRAM_ATTR Segment::virtualLength() const {
     return vLen;
   }
 #endif
-  uint16_t groupLen = groupLength(); // is always >= 1
-  uint16_t vLength = (length() + groupLen - 1) / groupLen;
+  unsigned groupLen = groupLength(); // is always >= 1
+  unsigned vLength = (length() + groupLen - 1) / groupLen;
   if (mirror) vLength = (vLength + 1) /2;  // divide by 2 if mirror, leave at least a single LED
   return vLength;
 }
@@ -674,8 +674,8 @@ void IRAM_ATTR Segment::setPixelColor(int i, uint32_t col)
 
 #ifndef WLED_DISABLE_2D
   if (is2D()) {
-    uint16_t vH = virtualHeight();  // segment height in logical pixels
-    uint16_t vW = virtualWidth();
+    int vH = virtualHeight();  // segment height in logical pixels
+    int vW = virtualWidth();
     switch (map1D2D) {
       case M12_Pixels:
         // use all available pixels as a long strip
@@ -732,7 +732,7 @@ void IRAM_ATTR Segment::setPixelColor(int i, uint32_t col)
   }
 #endif
 
-  uint16_t len = length();
+  unsigned len = length();
   uint8_t _bri_t = currentBri();
   if (_bri_t < 255) {
     col = color_fade(col, _bri_t);
@@ -785,8 +785,8 @@ void Segment::setPixelColor(float i, uint32_t col, bool aa)
 
   float fC = i * (virtualLength()-1);
   if (aa) {
-    uint16_t iL = roundf(fC-0.49f);
-    uint16_t iR = roundf(fC+0.49f);
+    unsigned iL = roundf(fC-0.49f);
+    unsigned iR = roundf(fC+0.49f);
     float    dL = (fC - iL)*(fC - iL);
     float    dR = (iR - fC)*(iR - fC);
     uint32_t cIL = getPixelColor(iL | (vStrip<<16));
@@ -803,7 +803,7 @@ void Segment::setPixelColor(float i, uint32_t col, bool aa)
       setPixelColor(iL | (vStrip<<16), col);
     }
   } else {
-    setPixelColor(uint16_t(roundf(fC)) | (vStrip<<16), col);
+    setPixelColor(int(roundf(fC)) | (vStrip<<16), col);
   }
 }
 #endif
@@ -818,8 +818,8 @@ uint32_t IRAM_ATTR Segment::getPixelColor(int i)
 
 #ifndef WLED_DISABLE_2D
   if (is2D()) {
-    uint16_t vH = virtualHeight();  // segment height in logical pixels
-    uint16_t vW = virtualWidth();
+    unsigned vH = virtualHeight();  // segment height in logical pixels
+    unsigned vW = virtualWidth();
     switch (map1D2D) {
       case M12_Pixels:
         return getPixelColorXY(i % vW, i / vW);
@@ -875,9 +875,9 @@ uint8_t Segment::differs(Segment& b) const {
 }
 
 void Segment::refreshLightCapabilities() {
-  uint8_t capabilities = 0;
-  uint16_t segStartIdx = 0xFFFFU;
-  uint16_t segStopIdx  = 0;
+  unsigned capabilities = 0;
+  unsigned segStartIdx = 0xFFFFU;
+  unsigned segStopIdx  = 0;
 
   if (!isActive()) {
     _capabilities = 0;
@@ -887,7 +887,7 @@ void Segment::refreshLightCapabilities() {
   if (start < Segment::maxWidth * Segment::maxHeight) {
     // we are withing 2D matrix (includes 1D segments)
     for (int y = startY; y < stopY; y++) for (int x = start; x < stop; x++) {
-      uint16_t index = strip.getMappedPixelIndex(x + Segment::maxWidth * y); // convert logical address to physical
+      unsigned index = strip.getMappedPixelIndex(x + Segment::maxWidth * y); // convert logical address to physical
       if (index < 0xFFFFU) {
         if (segStartIdx > index) segStartIdx = index;
         if (segStopIdx  < index) segStopIdx  = index;
@@ -912,7 +912,7 @@ void Segment::refreshLightCapabilities() {
     if (!cctFromRgb && bus->hasCCT())                   capabilities |= SEG_CAPABILITY_CCT;
     if (correctWB && (bus->hasRGB() || bus->hasCCT()))  capabilities |= SEG_CAPABILITY_CCT; //white balance correction (CCT slider)
     if (bus->hasWhite()) {
-      uint8_t aWM = Bus::getGlobalAWMode() == AW_GLOBAL_DISABLED ? bus->getAutoWhiteMode() : Bus::getGlobalAWMode();
+      unsigned aWM = Bus::getGlobalAWMode() == AW_GLOBAL_DISABLED ? bus->getAutoWhiteMode() : Bus::getGlobalAWMode();
       bool whiteSlider = (aWM == RGBW_MODE_DUAL || aWM == RGBW_MODE_MANUAL_ONLY); // white slider allowed
       // if auto white calculation from RGB is active (Accurate/Brighter), force RGB controls even if there are no RGB busses
       if (!whiteSlider) capabilities |= SEG_CAPABILITY_RGB;
@@ -928,8 +928,8 @@ void Segment::refreshLightCapabilities() {
  */
 void Segment::fill(uint32_t c) {
   if (!isActive()) return; // not active
-  const uint16_t cols = is2D() ? virtualWidth() : virtualLength();
-  const uint16_t rows = virtualHeight(); // will be 1 for 1D
+  const int cols = is2D() ? virtualWidth() : virtualLength();
+  const int rows = virtualHeight(); // will be 1 for 1D
   for (int y = 0; y < rows; y++) for (int x = 0; x < cols; x++) {
     if (is2D()) setPixelColorXY(x, y, c);
     else        setPixelColor(x, c);
@@ -941,8 +941,8 @@ void Segment::fill(uint32_t c) {
  */
 void Segment::fade_out(uint8_t rate) {
   if (!isActive()) return; // not active
-  const uint16_t cols = is2D() ? virtualWidth() : virtualLength();
-  const uint16_t rows = virtualHeight(); // will be 1 for 1D
+  const int cols = is2D() ? virtualWidth() : virtualLength();
+  const int rows = virtualHeight(); // will be 1 for 1D
 
   rate = (255-rate) >> 1;
   float mappedRate = float(rate) +1.1f;
@@ -979,8 +979,8 @@ void Segment::fade_out(uint8_t rate) {
 // fades all pixels to black using nscale8()
 void Segment::fadeToBlackBy(uint8_t fadeBy) {
   if (!isActive() || fadeBy == 0) return;   // optimization - no scaling to apply
-  const uint16_t cols = is2D() ? virtualWidth() : virtualLength();
-  const uint16_t rows = virtualHeight(); // will be 1 for 1D
+  const int cols = is2D() ? virtualWidth() : virtualLength();
+  const int rows = virtualHeight(); // will be 1 for 1D
 
   for (int y = 0; y < rows; y++) for (int x = 0; x < cols; x++) {
     if (is2D()) setPixelColorXY(x, y, color_fade(getPixelColorXY(x,y), 255-fadeBy));
@@ -1065,7 +1065,7 @@ uint32_t Segment::color_from_palette(uint16_t i, bool mapping, bool wrap, uint8_
   // default palette or no RGB support on segment
   if ((palette == 0 && mcol < NUM_COLORS) || !_isRGB) return (pbri == 255) ? color : color_fade(color, pbri, true);
 
-  uint8_t paletteIndex = i;
+  unsigned paletteIndex = i;
   if (mapping && virtualLength() > 1) paletteIndex = (i*255)/(virtualLength() -1);
   // paletteBlend: 0 - wrap when moving, 1 - always wrap, 2 - never wrap, 3 - none (undefined)
   if (!wrap && strip.paletteBlend != 3) paletteIndex = scale8(paletteIndex, 240); //cut off blend at palette "end"
@@ -1132,7 +1132,7 @@ void WS2812FX::finalizeInit(void) {
     _hasWhiteChannel |= bus->hasWhite();
     //refresh is required to remain off if at least one of the strips requires the refresh.
     _isOffRefreshRequired |= bus->isOffRefreshRequired();
-    uint16_t busEnd = bus->getStart() + bus->getLength();
+    unsigned busEnd = bus->getStart() + bus->getLength();
     if (busEnd > _length) _length = busEnd;
     #ifdef ESP8266
     if ((!IS_DIGITAL(bus->getType()) || IS_2PIN(bus->getType()))) continue;
@@ -1176,10 +1176,10 @@ void WS2812FX::service() {
     if (nowUp > seg.next_time || _triggered || (doShow && seg.mode == FX_MODE_STATIC))
     {
       doShow = true;
-      uint16_t delay = FRAMETIME;
+      unsigned delay = FRAMETIME;
 
       if (!seg.freeze) { //only run effect function if not frozen
-        int16_t oldCCT = BusManager::getSegmentCCT(); // store original CCT value (actually it is not Segment based)
+        int oldCCT = BusManager::getSegmentCCT(); // store original CCT value (actually it is not Segment based)
         _virtualSegmentLength = seg.virtualLength(); //SEGLEN
         _colors_t[0] = gamma32(seg.currentColor(0));
         _colors_t[1] = gamma32(seg.currentColor(1));
@@ -1203,7 +1203,7 @@ void WS2812FX::service() {
           Segment::modeBlend(true);           // set semaphore
           seg.swapSegenv(_tmpSegData);        // temporarily store new mode state (and swap it with transitional state)
           _virtualSegmentLength = seg.virtualLength(); // update SEGLEN (mapping may have changed)
-          uint16_t d2 = (*_mode[tmpMode])();  // run old mode
+          unsigned d2 = (*_mode[tmpMode])();  // run old mode
           seg.restoreSegenv(_tmpSegData);     // restore mode state (will also update transitional state)
           delay = MIN(delay,d2);              // use shortest delay
           Segment::modeBlend(false);          // unset semaphore
@@ -1378,13 +1378,13 @@ uint8_t WS2812FX::getActiveSegmentsNum(void) {
 }
 
 uint16_t WS2812FX::getLengthTotal(void) {
-  uint16_t len = Segment::maxWidth * Segment::maxHeight; // will be _length for 1D (see finalizeInit()) but should cover whole matrix for 2D
+  unsigned len = Segment::maxWidth * Segment::maxHeight; // will be _length for 1D (see finalizeInit()) but should cover whole matrix for 2D
   if (isMatrix && _length > len) len = _length; // for 2D with trailing strip
   return len;
 }
 
 uint16_t WS2812FX::getLengthPhysical(void) {
-  uint16_t len = 0;
+  unsigned len = 0;
   for (size_t b = 0; b < BusManager::getNumBusses(); b++) {
     Bus *bus = BusManager::getBus(b);
     if (bus->getType() >= TYPE_NET_DDP_RGB) continue; //exclude non-physical network busses
@@ -1461,8 +1461,8 @@ void WS2812FX::resetSegments() {
 
 void WS2812FX::makeAutoSegments(bool forceReset) {
   if (autoSegments) { //make one segment per bus
-    uint16_t segStarts[MAX_NUM_SEGMENTS] = {0};
-    uint16_t segStops [MAX_NUM_SEGMENTS] = {0};
+    unsigned segStarts[MAX_NUM_SEGMENTS] = {0};
+    unsigned segStops [MAX_NUM_SEGMENTS] = {0};
     size_t s = 0;
 
     #ifndef WLED_DISABLE_2D