feedc0de/NeoPixelBus
1
0
Fork 0
forked from Makuna/NeoPixelBus
Code Pull Requests Activity

Sm16825e (#742)

Browse Source 
* Neo5WordFeature

* rgbww80color

* expose Rgbwc and Rgbcw feature
This commit is contained in:
Michael Miller
2023-11-06 11:32:59 -08:00
committed by GitHub
parent 9a42d3e7aa
commit 7e84f7b759
11 changed files with 1013 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/internal/NeoColorFeatures.h
View File

@@ -42,6 +42,7 @@ License along with NeoPixel. If not, see
#include "features/Neo6xxByteFeature.h"
#include "features/Neo3WordFeature.h"
#include "features/Neo4WordFeature.h"
#include "features/Neo5WordFeature.h"
// NeoPixel Features
//
@@ -52,7 +53,9 @@ License along with NeoPixel. If not, see
#include "features/NeoRgbwxxFeatures.h"
#include "features/NeoRgbcwxFeatures.h"
#include "features/NeoSm168xxFeatures.h"
#include "features/NeoSm168x3Features.h"
#include "features/NeoSm168x4Features.h"
#include "features/NeoSm168x5Features.h"
#include "features/NeoTm1814Features.h"
#include "features/NeoTm1914Features.h"

1
src/internal/NeoColors.h
View File

@@ -43,6 +43,7 @@ License along with NeoPixel. If not, see
#include "colors/Rgbw64Color.h"
#include "colors/RgbwwColor.h"
#include "colors/Rgbww80Color.h"
#include "colors/SegmentDigit.h"

3
src/internal/colors/RgbColorIndexes.h
View File

@@ -32,4 +32,5 @@ const uint8_t ColorIndexG = 1;
const uint8_t ColorIndexB = 2;
const uint8_t ColorIndexW = 3;
const uint8_t ColorIndexWW = 3; // warmer white
const uint8_t ColorIndexCW = 4; // cooler white
const uint8_t ColorIndexCW = 4; // cooler white
const uint8_t ColorIndexY = 4;

220
src/internal/colors/Rgbww80Color.cpp Normal file
View File

@@ -0,0 +1,220 @@
/*-------------------------------------------------------------------------
Rgbww80Color provides a color object that can be directly consumed by NeoPixelBus
Written by Michael C. Miller.
I invest time and resources providing this open source code,
please support me by dontating (see https://github.com/Makuna/NeoPixelBus)
-------------------------------------------------------------------------
This file is part of the Makuna/NeoPixelBus library.
NeoPixelBus is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
NeoPixelBus is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with NeoPixel. If not, see
<http://www.gnu.org/licenses/>.
-------------------------------------------------------------------------*/
#include <Arduino.h>
#include "../NeoSettings.h"
#include "RgbColorBase.h"
#include "RgbColor.h"
#include "RgbwColor.h"
#include "Rgb48Color.h"
#include "Rgbw64Color.h"
#include "HslColor.h"
#include "HsbColor.h"
#include "HtmlColor.h"
#include "Rgbww80Color.h"
Rgbww80Color::Rgbww80Color(const RgbwColor& color)
{
*this = Rgbw64Color(color);
};
Rgbww80Color::Rgbww80Color(const Rgbw64Color& color) :
R(color.R),
G(color.G),
B(color.B),
WW(color.W),
CW(color.W)
{
};
uint16_t Rgbww80Color::CalculateBrightness() const
{
uint16_t colorB = static_cast<uint16_t>((static_cast<uint32_t>(R) + static_cast<uint32_t>(G) + static_cast<uint32_t>(B)) / 3);
uint16_t whiteB = static_cast<uint16_t>((static_cast<uint32_t>(WW) + static_cast<uint32_t>(CW)) / 2);
return (whiteB > colorB) ? whiteB : colorB;
}
Rgbww80Color Rgbww80Color::Dim(uint16_t ratio) const
{
// specifically avoids float math
return Rgbww80Color(_elementDim(R, ratio),
_elementDim(G, ratio),
_elementDim(B, ratio),
_elementDim(WW, ratio),
_elementDim(CW, ratio));
}
Rgbww80Color Rgbww80Color::Brighten(uint16_t ratio) const
{
// specifically avoids float math
return Rgbww80Color(_elementBrighten(R, ratio),
_elementBrighten(G, ratio),
_elementBrighten(B, ratio),
_elementBrighten(WW, ratio),
_elementBrighten(CW, ratio));
}
void Rgbww80Color::Darken(uint16_t delta)
{
if (R > delta)
{
R -= delta;
}
else
{
R = 0;
}
if (G > delta)
{
G -= delta;
}
else
{
G = 0;
}
if (B > delta)
{
B -= delta;
}
else
{
B = 0;
}
if (WW > delta)
{
WW -= delta;
}
else
{
WW = 0;
}
if (CW > delta)
{
CW -= delta;
}
else
{
CW = 0;
}
}
void Rgbww80Color::Lighten(uint16_t delta)
{
if (IsColorLess())
{
if (WW < Max - delta)
{
WW += delta;
}
else
{
WW = Max;
}
if (CW < Max - delta)
{
CW += delta;
}
else
{
CW = Max;
}
}
else
{
if (R < Max - delta)
{
R += delta;
}
else
{
R = Max;
}
if (G < Max - delta)
{
G += delta;
}
else
{
G = Max;
}
if (B < Max - delta)
{
B += delta;
}
else
{
B = Max;
}
}
}
Rgbww80Color Rgbww80Color::LinearBlend(const Rgbww80Color& left, const Rgbww80Color& right, float progress)
{
return Rgbww80Color( left.R + ((static_cast<int32_t>(right.R) - left.R) * progress),
left.G + ((static_cast<int32_t>(right.G) - left.G) * progress),
left.B + ((static_cast<int32_t>(right.B) - left.B) * progress),
left.WW + ((static_cast<int32_t>(right.WW) - left.WW) * progress),
left.CW + ((static_cast<int32_t>(right.CW) - left.CW) * progress));
}
Rgbww80Color Rgbww80Color::LinearBlend(const Rgbww80Color& left, const Rgbww80Color& right, uint8_t progress)
{
return Rgbww80Color(left.R + (((static_cast<int64_t>(right.R) - left.R) * static_cast<int64_t>(progress) + 1) >> 8),
left.G + (((static_cast<int64_t>(right.G) - left.G) * static_cast<int64_t>(progress) + 1) >> 8),
left.B + (((static_cast<int64_t>(right.B) - left.B) * static_cast<int64_t>(progress) + 1) >> 8),
left.WW + (((static_cast<int64_t>(right.WW) - left.WW) * static_cast<int64_t>(progress) + 1) >> 8),
left.CW + (((static_cast<int64_t>(right.CW) - left.CW) * static_cast<int64_t>(progress) + 1) >> 8));
}
Rgbww80Color Rgbww80Color::BilinearBlend(const Rgbww80Color& c00,
const Rgbww80Color& c01,
const Rgbww80Color& c10,
const Rgbww80Color& c11,
float x,
float y)
{
float v00 = (1.0f - x) * (1.0f - y);
float v10 = x * (1.0f - y);
float v01 = (1.0f - x) * y;
float v11 = x * y;
return Rgbww80Color(
c00.R * v00 + c10.R * v10 + c01.R * v01 + c11.R * v11,
c00.G * v00 + c10.G * v10 + c01.G * v01 + c11.G * v11,
c00.B * v00 + c10.B * v10 + c01.B * v01 + c11.B * v11,
c00.WW * v00 + c10.WW * v10 + c01.WW * v01 + c11.WW * v11,
c00.CW * v00 + c10.CW * v10 + c01.CW * v01 + c11.CW * v11);
}

364
src/internal/colors/Rgbww80Color.h Normal file
View File

@@ -0,0 +1,364 @@
/*-------------------------------------------------------------------------
Rgbww80Color provides a color object that can be directly consumed by NeoPixelBus
Written by Michael C. Miller.
I invest time and resources providing this open source code,
please support me by dontating (see https://github.com/Makuna/NeoPixelBus)
-------------------------------------------------------------------------
This file is part of the Makuna/NeoPixelBus library.
NeoPixelBus is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
NeoPixelBus is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with NeoPixel. If not, see
<http://www.gnu.org/licenses/>.
-------------------------------------------------------------------------*/
#pragma once
struct RgbColor;
struct HslColor;
struct HsbColor;
// ------------------------------------------------------------------------
// Rgbww80Color represents a color object that is represented by Red, Green, Blue
// component values and two extra White components.
// While the white components are labeled as WW (warm) and CW (cool), they can be
// considered as the "warmer" and "cooler" whites of your LEDs; so that if yours
// have Nuetral and Cool, you could consider the WW as your nuetral.
// It contains helpful color routines to manipulate the color.
// ------------------------------------------------------------------------
struct Rgbww80Color : RgbColorBase
{
typedef NeoRgbwwCurrentSettings SettingsObject;
// ------------------------------------------------------------------------
// Construct a Rgbww80Color using R, G, B, WW, CW values (0-65535)
// ------------------------------------------------------------------------
Rgbww80Color(uint16_t r, uint16_t g, uint16_t b, uint16_t warmW = 0, uint16_t coolW = 0) :
R(r), G(g), B(b), WW(warmW), CW(coolW)
{
};
// ------------------------------------------------------------------------
// Construct a Rgbww80Color using a single brightness value (0-65535)
// This works well for creating gray tone colors
// (0) = black, (65535) = white, (128) = gray
// ------------------------------------------------------------------------
Rgbww80Color(uint16_t brightness) :
R(0), G(0), B(0), WW(brightness), CW(brightness)
{
};
// ------------------------------------------------------------------------
// Construct a Rgbww80Color using RgbColor
// ------------------------------------------------------------------------
Rgbww80Color(const RgbColor& color)
{
*this = Rgb48Color(color);
};
// ------------------------------------------------------------------------
// Construct a Rgbw80Color using Rgb48Color
// ------------------------------------------------------------------------
Rgbww80Color(const Rgb48Color& color) :
R(color.R),
G(color.G),
B(color.B),
WW(0),
CW(0)
{
};
// ------------------------------------------------------------------------
// Construct a Rgbww80Color using RgbwColor
// ------------------------------------------------------------------------
Rgbww80Color(const RgbwColor& color);
// ------------------------------------------------------------------------
// Construct a Rgbw64Color using Rgb48Color
// ------------------------------------------------------------------------
Rgbww80Color(const Rgbw64Color& color);
// ------------------------------------------------------------------------
// Construct a Rgbww80Color using HtmlColor
// ------------------------------------------------------------------------
Rgbww80Color(const HtmlColor& color)
{
*this = RgbwColor(color);
}
// ------------------------------------------------------------------------
// Construct a Rgbww80Color using HslColor
// ------------------------------------------------------------------------
Rgbww80Color(const HslColor& color)
{
*this = Rgb48Color(color);
}
// ------------------------------------------------------------------------
// Construct a Rgbww80Color using HsbColor
// ------------------------------------------------------------------------
Rgbww80Color(const HsbColor& color)
{
*this = Rgb48Color(color);
}
// ------------------------------------------------------------------------
// Construct a Rgbww80Color that will have its values set in latter operations
// CAUTION: The R,G,B, WW, CW members are not initialized and may not be consistent
// ------------------------------------------------------------------------
Rgbww80Color()
{
};
// ------------------------------------------------------------------------
// Comparison operators
// ------------------------------------------------------------------------
bool operator==(const Rgbww80Color& other) const
{
return (R == other.R && G == other.G && B == other.B && WW == other.WW && CW == other.CW);
};
bool operator!=(const Rgbww80Color& other) const
{
return !(*this == other);
};
// ------------------------------------------------------------------------
// CompareTo method
// compares against another color with the given epsilon (delta allowed)
// returns the greatest difference of a set of elements,
// 0 = equal within epsilon delta
// negative - this is less than other
// positive - this is greater than other
// ------------------------------------------------------------------------
int32_t CompareTo(const Rgbww80Color& other, uint16_t epsilon = 256)
{
return _Compare<Rgbww80Color, int32_t>(*this, other, epsilon);
}
// ------------------------------------------------------------------------
// Compare method
// compares two colors with the given epsilon (delta allowed)
// returns the greatest difference of a set of elements,
// 0 = equal within epsilon delta
// negative - left is less than right
// positive - left is greater than right
// ------------------------------------------------------------------------
static int32_t Compare(const Rgbww80Color& left, const Rgbww80Color& right, uint16_t epsilon = 256)
{
return _Compare<Rgbww80Color, int32_t>(left, right, epsilon);
}
// ------------------------------------------------------------------------
// operator [] - readonly
// access elements in order by index rather than R,G,B,WW,CW
// see static Count for the number of elements
// ------------------------------------------------------------------------
uint16_t operator[](size_t idx) const
{
switch (idx)
{
case 0:
return R;
case 1:
return G;
case 2:
return B;
case 3:
return WW;
default:
return CW;
}
}
// ------------------------------------------------------------------------
// operator [] - read write
// access elements in order by index rather than R,G,B,WW,CW
// see static Count for the number of elements
// ------------------------------------------------------------------------
uint16_t& operator[](size_t idx)
{
switch (idx)
{
case 0:
return R;
case 1:
return G;
case 2:
return B;
case 3:
return WW;
default:
return CW;
}
}
// ------------------------------------------------------------------------
// Returns if the color is grey, all values are equal other than whites
// ------------------------------------------------------------------------
bool IsMonotone() const
{
return (R == B && R == G);
};
// ------------------------------------------------------------------------
// Returns if the color components are all zero, the white components maybe
// anything
// ------------------------------------------------------------------------
bool IsColorLess() const
{
return (R == 0 && B == 0 && G == 0);
};
// ------------------------------------------------------------------------
// CalculateBrightness will calculate the overall brightness
// NOTE: This is a simple linear brightness
// ------------------------------------------------------------------------
uint16_t CalculateBrightness() const;
// ------------------------------------------------------------------------
// Dim will return a new color that is blended to black with the given ratio
// ratio - (0-65535) where 65535 will return the original color and 0 will return black
//
// NOTE: This is a simple linear blend
// ------------------------------------------------------------------------
Rgbww80Color Dim(uint16_t ratio) const;
// ------------------------------------------------------------------------
// Dim will return a new color that is blended to black with the given ratio
// ratio - (0-255) where 255 will return the original color and 0 will return black
//
// NOTE: This is a simple linear blend
// ------------------------------------------------------------------------
Rgbww80Color Dim(uint8_t ratio) const
{
uint16_t expanded = ratio << 8;
return Dim(expanded);
}
// ------------------------------------------------------------------------
// Brighten will return a new color that is blended to white with the given ratio
// ratio - (0-65535) where 65535 will return the original color and 0 will return white
//
// NOTE: This is a simple linear blend
// ------------------------------------------------------------------------
Rgbww80Color Brighten(uint16_t ratio) const;
// ------------------------------------------------------------------------
// Brighten will return a new color that is blended to white with the given ratio
// ratio - (0-255) where 255 will return the original color and 0 will return white
//
// NOTE: This is a simple linear blend
// ------------------------------------------------------------------------
Rgbww80Color Brighten(uint8_t ratio) const
{
uint16_t expanded = ratio << 8;
return Brighten(expanded);
}
// ------------------------------------------------------------------------
// Darken will adjust the color by the given delta toward black
// NOTE: This is a simple linear change
// delta - (0-65535) the amount to dim the color
// ------------------------------------------------------------------------
void Darken(uint16_t delta);
// ------------------------------------------------------------------------
// Lighten will adjust the color by the given delta toward white
// NOTE: This is a simple linear change
// delta - (0-65535) the amount to lighten the color
// ------------------------------------------------------------------------
void Lighten(uint16_t delta);
// ------------------------------------------------------------------------
// LinearBlend between two colors by the amount defined by progress variable
// left - the color to start the blend at
// right - the color to end the blend at
// progress - (0.0 - 1.0) value where 0 will return left and 1.0 will return right
// and a value between will blend the color weighted linearly between them
// ------------------------------------------------------------------------
static Rgbww80Color LinearBlend(const Rgbww80Color& left, const Rgbww80Color& right, float progress);
// progress - (0 - 255) value where 0 will return left and 255 will return right
// and a value between will blend the color weighted linearly between them
// ------------------------------------------------------------------------
static Rgbww80Color LinearBlend(const Rgbww80Color& left, const Rgbww80Color& right, uint8_t progress);
// ------------------------------------------------------------------------
// BilinearBlend between four colors by the amount defined by 2d variable
// c00 - upper left quadrant color
// c01 - upper right quadrant color
// c10 - lower left quadrant color
// c11 - lower right quadrant color
// x - unit value (0.0 - 1.0) that defines the blend progress in horizontal space
// y - unit value (0.0 - 1.0) that defines the blend progress in vertical space
// ------------------------------------------------------------------------
static Rgbww80Color BilinearBlend(const Rgbww80Color& c00,
const Rgbww80Color& c01,
const Rgbww80Color& c10,
const Rgbww80Color& c11,
float x,
float y);
uint16_t CalcTotalTenthMilliAmpere(const SettingsObject& settings)
{
auto total = 0;
total += R * settings.RedTenthMilliAmpere / Max;
total += G * settings.GreenTenthMilliAmpere / Max;
total += B * settings.BlueTenthMilliAmpere / Max;
total += WW * settings.WarmWhiteTenthMilliAmpere / Max;
total += CW * settings.CoolWhiteTenthMilliAmpere / Max;
return total;
}
// ------------------------------------------------------------------------
// Red, Green, Blue, Warm White, Cool White color members (0-65535) where
// (0,0,0,0,0) is black and
// (65535,65535,65535, 0, 0) is a white
// (0,0,0,65535,0) is warm white and
// (0,0,0,0,65535) is cool white and
// Note (65535,65535,65535,65535,65535) is extreme bright white
// ------------------------------------------------------------------------
uint16_t R;
uint16_t G;
uint16_t B;
uint16_t WW;
uint16_t CW;
const static uint16_t Max = 65535;
const static size_t Count = 5; // five elements in []
private:
inline static uint16_t _elementDim(uint16_t value, uint16_t ratio)
{
return (static_cast<uint32_t>(value) * (static_cast<uint32_t>(ratio) + 1)) >> 16;
}
inline static uint16_t _elementBrighten(uint16_t value, uint16_t ratio)
{
uint32_t element = ((static_cast<uint32_t>(value) + 1) << 16) / (static_cast<uint32_t>(ratio) + 1);
if (element > Max)
{
element = Max;
}
else
{
element -= 1;
}
return element;
}
};

20
src/internal/colors/RgbwwColor.cpp
View File

@@ -141,51 +141,51 @@ void RgbwwColor::Lighten(uint8_t delta)
{
if (IsColorLess())
{
if (WW < 255 - delta)
if (WW < Max - delta)
{
WW += delta;
}
else
{
WW = 255;
WW = Max;
}
if (CW < 255 - delta)
if (CW < Max - delta)
{
CW += delta;
}
else
{
CW = 255;
CW = Max;
}
}
else
{
if (R < 255 - delta)
if (R < Max - delta)
{
R += delta;
}
else
{
R = 255;
R = Max;
}
if (G < 255 - delta)
if (G < Max - delta)
{
G += delta;
}
else
{
G = 255;
G = Max;
}
if (B < 255 - delta)
if (B < Max - delta)
{
B += delta;
}
else
{
B = 255;
B = Max;
}
}
}

2
src/internal/colors/RgbwwColor.h
View File

@@ -299,7 +299,7 @@ struct RgbwwColor : RgbColorBase
uint8_t CW;
const static uint8_t Max = 255;
const static size_t Count = 5; // four elements in []
const static size_t Count = 5; // five elements in []
private:
inline static uint8_t _elementDim(uint8_t value, uint8_t ratio)

87
src/internal/features/Neo5WordFeature.h Normal file
View File

@@ -0,0 +1,87 @@
/*-------------------------------------------------------------------------
Neo5WordFeature provides feature base class to describe color order for
5 Word features
Written by Michael C. Miller.
I invest time and resources providing this open source code,
please support me by dontating (see https://github.com/Makuna/NeoPixelBus)
-------------------------------------------------------------------------
This file is part of the Makuna/NeoPixelBus library.
NeoPixelBus is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
NeoPixelBus is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with NeoPixel. If not, see
<http://www.gnu.org/licenses/>.
-------------------------------------------------------------------------*/
#pragma once
template <uint8_t V_IC_1, uint8_t V_IC_2, uint8_t V_IC_3, uint8_t V_IC_4, uint8_t V_IC_5>
class Neo5WordFeature :
public NeoWordElements<10, Rgbww80Color, uint16_t>
{
public:
static void applyPixelColor(uint8_t* pPixels, uint16_t indexPixel, ColorObject color)
{
uint8_t* p = getPixelAddress(pPixels, indexPixel);
// due to endianness the byte order must be copied to output
*p++ = color[V_IC_1] >> 8;
*p++ = color[V_IC_1] & 0xff;
*p++ = color[V_IC_2] >> 8;
*p++ = color[V_IC_2] & 0xff;
*p++ = color[V_IC_3] >> 8;
*p++ = color[V_IC_3] & 0xff;
*p++ = color[V_IC_4] >> 8;
*p++ = color[V_IC_4] & 0xff;
*p++ = color[V_IC_5] >> 8;
*p = color[V_IC_5] & 0xff;
}
static ColorObject retrievePixelColor(const uint8_t* pPixels, uint16_t indexPixel)
{
ColorObject color;
const uint8_t* p = getPixelAddress(pPixels, indexPixel);
// due to endianness the byte order must be copied to output
color[V_IC_1] = (static_cast<uint16_t>(*p++) << 8);
color[V_IC_1] |= *p++;
color[V_IC_2] = (static_cast<uint16_t>(*p++) << 8);
color[V_IC_2] |= *p++;
color[V_IC_3] = (static_cast<uint16_t>(*p++) << 8);
color[V_IC_3] |= *p++;
color[V_IC_4] = (static_cast<uint16_t>(*p++) << 8);
color[V_IC_4] |= *p++;
color[V_IC_5] = (static_cast<uint16_t>(*p++) << 8);
color[V_IC_5] |= *p;
return color;
}
static ColorObject retrievePixelColor_P(PGM_VOID_P pPixels, uint16_t indexPixel)
{
ColorObject color;
const uint16_t* p = reinterpret_cast<const uint16_t*>(getPixelAddress(reinterpret_cast<const uint8_t*>(pPixels), indexPixel));
// PROGMEM unit of storage expected to be the same size as color element
// so no endianness issues to worry about
color[V_IC_1] = pgm_read_word(p++);
color[V_IC_2] = pgm_read_word(p++);
color[V_IC_3] = pgm_read_word(p++);
color[V_IC_4] = pgm_read_word(p++);
color[V_IC_5] = pgm_read_word(p);
return color;
}
};

161
src/internal/features/NeoSm168x3Features.h Normal file
View File

@@ -0,0 +1,161 @@
/*-------------------------------------------------------------------------
NeoSm168x3Features provides feature classes to describe color order and
color depth for NeoPixelBus template class specific to the SM168x3 chips/leds
Written by Michael C. Miller.
I invest time and resources providing this open source code,
please support me by dontating (see https://github.com/Makuna/NeoPixelBus)
-------------------------------------------------------------------------
This file is part of the Makuna/NeoPixelBus library.
NeoPixelBus is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
NeoPixelBus is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with NeoPixel. If not, see
<http://www.gnu.org/licenses/>.
-------------------------------------------------------------------------*/
#pragma once
/*
3 channel RGB
SM16803P 1.8~60mA << need spec sheet to get accurate implementation
SM16813PB 1.8~19mA
SM16823E 60~350mA
*/
class NeoSm168x3SettingsBase : public NeoRgbCurrentSettings
{
public:
NeoSm168x3SettingsBase(uint8_t redGain,
uint8_t greenGain,
uint8_t blueGain,
uint16_t redCurrent,
uint16_t greenCurrent,
uint16_t blueCurrent) :
NeoRgbCurrentSettings(redCurrent, greenCurrent, blueCurrent),
RedGain(redGain & 0x0f),
GreenGain(greenGain & 0x0f),
BlueGain(blueGain & 0x0f) {}
// ------------------------------------------------------------------------
// operator [] - readonly
// access elements in order by index rather than member name
// ------------------------------------------------------------------------
uint8_t operator[](size_t idx) const
{
switch (idx)
{
case 0:
return RedGain;
case 1:
return GreenGain;
default:
return BlueGain;
}
}
const uint8_t RedGain : 4;
const uint8_t GreenGain : 4;
const uint8_t BlueGain : 4;
};
template <uint8_t V_IC_1, uint8_t V_IC_2, uint8_t V_IC_3>
class NeoSm16803pbSettings : public NeoSm168x3SettingsBase
{
public:
NeoSm16803pbSettings(uint8_t redGain, uint8_t greenGain, uint8_t blueGain) :
NeoSm168x3SettingsBase(redGain,
greenGain,
blueGain,
CurrentLookup[redGain],
CurrentLookup[greenGain],
CurrentLookup[blueGain])
{
}
void Encode(uint8_t* encoded) const
{
// 0RGB 4 bits each
*encoded++ = operator[](V_IC_1);
*encoded = operator[](V_IC_2) << 4 | operator[](V_IC_3);
}
protected:
static constexpr uint8_t CurrentLookup[16] = {
18, 30, 41, 53, 64, 76, 87, 99,
110, 133, 145, 156, 168, 179, 190};
};
template <uint8_t V_IC_1, uint8_t V_IC_2, uint8_t V_IC_3>
class NeoSm16823eSettings : public NeoSm168x3SettingsBase
{
public:
NeoSm16823eSettings(uint8_t redGain, uint8_t greenGain, uint8_t blueGain, uint16_t resisterOhms) :
NeoSm168x3SettingsBase(redGain,
greenGain,
blueGain,
calcCurrent(resisterOhms, redGain),
calcCurrent(resisterOhms, greenGain),
calcCurrent(resisterOhms, blueGain)),
extROhms(resisterOhms)
{
}
void Encode(uint8_t* encoded) const
{
// RGB0 4 bits each
*encoded++ = operator[](V_IC_1) << 4 | operator[](V_IC_2);
*encoded = operator[](V_IC_3) << 4;
}
protected:
const uint16_t extROhms;
static uint16_t calcCurrent(const uint16_t ohms, const uint8_t gain)
{
uint16_t mA = (967 * (240 + (gain * 32)) / ohms); // from spec sheet, gain 0-15 instead
return mA * 10; // return tenths of mA
}
};
// CAUTION: Make sure ColorIndex order for Neo3ByteFeature matches T_SETTINGS
template<typename T_SETTINGS> class NeoRgbSm168x3Elements :
public Neo3ByteFeature<ColorIndexR, ColorIndexG, ColorIndexB>
{
public:
typedef T_SETTINGS SettingsObject;
static const size_t SettingsSize = 2;
static void applySettings([[maybe_unused]] uint8_t* pData, [[maybe_unused]] size_t sizeData, [[maybe_unused]] const SettingsObject& settings)
{
// settings are at the end of the data stream
uint8_t* pDest = pData + sizeData - SettingsSize;
settings.Encode(pDest);
}
static uint8_t* pixels([[maybe_unused]] uint8_t* pData, [[maybe_unused]] size_t sizeData)
{
return pData;
}
static const uint8_t* pixels([[maybe_unused]] const uint8_t* pData, [[maybe_unused]] size_t sizeData)
{
return pData;
}
};
typedef NeoRgbSm168x3Elements<NeoSm16803pbSettings<ColorIndexR, ColorIndexG, ColorIndexB>> NeoRgbSm16803pbFeature;
typedef NeoRgbSm168x3Elements<NeoSm16823eSettings<ColorIndexR, ColorIndexG, ColorIndexB>> NeoRgbSm16823eFeature;

132
src/internal/features/NeoSm168xxFeatures.h → src/internal/features/NeoSm168x4Features.h
View File

@@ -1,6 +1,6 @@
/*-------------------------------------------------------------------------
NeoSm168xxFeatures provides feature classes to describe color order and
color depth for NeoPixelBus template class specific to the SM168xx chips/leds
NeoSm168x4Features provides feature classes to describe color order and
color depth for NeoPixelBus template class specific to the SM168x4 chips/leds
Written by Michael C. Miller.
@@ -26,111 +26,12 @@ License along with NeoPixel. If not, see
-------------------------------------------------------------------------*/
#pragma once
/*
3 channel RGB
SM16803P 1.8~60mA << need spec sheet to get accurate implementation
SM16813PB 1.8~19mA
SM16823E 60~350mA
4 channel RGBW
SM16804PB 1.5~60mA << need spec sheet to get accurate implementation
SM16804EB 1.8~19mA
SM16824E 60~350mA
*/
class NeoSm168x3SettingsBase : public NeoRgbCurrentSettings
{
public:
NeoSm168x3SettingsBase(uint8_t redGain,
uint8_t greenGain,
uint8_t blueGain,
uint16_t redCurrent,
uint16_t greenCurrent,
uint16_t blueCurrent) :
NeoRgbCurrentSettings(redCurrent, greenCurrent, blueCurrent),
RedGain(redGain & 0x0f),
GreenGain(greenGain & 0x0f),
BlueGain(blueGain & 0x0f) {}
// ------------------------------------------------------------------------
// operator [] - readonly
// access elements in order by index rather than member name
// ------------------------------------------------------------------------
uint8_t operator[](size_t idx) const
{
switch (idx)
{
case 0:
return RedGain;
case 1:
return GreenGain;
default:
return BlueGain;
}
}
const uint8_t RedGain : 4;
const uint8_t GreenGain : 4;
const uint8_t BlueGain : 4;
};
template <uint8_t V_IC_1, uint8_t V_IC_2, uint8_t V_IC_3>
class NeoSm16803pbSettings : public NeoSm168x3SettingsBase
{
public:
NeoSm16803pbSettings(uint8_t redGain, uint8_t greenGain, uint8_t blueGain) :
NeoSm168x3SettingsBase(redGain,
greenGain,
blueGain,
CurrentLookup[redGain],
CurrentLookup[greenGain],
CurrentLookup[blueGain])
{
}
void Encode(uint8_t* encoded) const
{
// 0RGB 4 bits each
*encoded++ = operator[](V_IC_1);
*encoded = operator[](V_IC_2) << 4 | operator[](V_IC_3);
}
protected:
static constexpr uint8_t CurrentLookup[16] = {
18, 30, 41, 53, 64, 76, 87, 99,
110, 133, 145, 156, 168, 179, 190};
};
template <uint8_t V_IC_1, uint8_t V_IC_2, uint8_t V_IC_3>
class NeoSm16823eSettings : public NeoSm168x3SettingsBase
{
public:
NeoSm16823eSettings(uint8_t redGain, uint8_t greenGain, uint8_t blueGain, uint16_t resisterOhms) :
NeoSm168x3SettingsBase(redGain,
greenGain,
blueGain,
calcCurrent(resisterOhms, redGain),
calcCurrent(resisterOhms, greenGain),
calcCurrent(resisterOhms, blueGain)),
extROhms(resisterOhms)
{
}
void Encode(uint8_t* encoded) const
{
// RGB0 4 bits each
*encoded++ = operator[](V_IC_1) << 4 | operator[](V_IC_2);
*encoded = operator[](V_IC_3) << 4;
}
protected:
const uint16_t extROhms;
static uint16_t calcCurrent(const uint16_t ohms, const uint8_t gain)
{
uint16_t mA = (967 * (240 + (gain * 32)) / ohms); // from spec sheet, gain 0-15 instead
return mA * 10; // return tenths of mA
}
};
// RGBW versions
class NeoSm168x4SettingsBase : public NeoRgbwCurrentSettings
@@ -267,35 +168,6 @@ public:
}
};
// CAUTION: Make sure ColorIndex order for Neo3ByteFeature matches T_SETTINGS
template<typename T_SETTINGS> class NeoRgbSm168x3Elements :
public Neo3ByteFeature<ColorIndexR, ColorIndexG, ColorIndexB>
{
public:
typedef T_SETTINGS SettingsObject;
static const size_t SettingsSize = 2;
static void applySettings([[maybe_unused]] uint8_t* pData, [[maybe_unused]] size_t sizeData, [[maybe_unused]] const SettingsObject& settings)
{
// settings are at the end of the data stream
uint8_t* pDest = pData + sizeData - SettingsSize;
settings.Encode(pDest);
}
static uint8_t* pixels([[maybe_unused]] uint8_t* pData, [[maybe_unused]] size_t sizeData)
{
return pData;
}
static const uint8_t* pixels([[maybe_unused]] const uint8_t* pData, [[maybe_unused]] size_t sizeData)
{
return pData;
}
};
typedef NeoRgbSm168x3Elements<NeoSm16803pbSettings<ColorIndexR, ColorIndexG, ColorIndexB>> NeoRgbSm16803pbFeature;
typedef NeoRgbSm168x3Elements<NeoSm16823eSettings<ColorIndexR, ColorIndexG, ColorIndexB>> NeoRgbSm16823eFeature;
typedef NeoRgbwSm168x4Elements<NeoSm16804ebSettings<ColorIndexR, ColorIndexG, ColorIndexB, ColorIndexW>> NeoRgbwSm16804ebFeature;
typedef NeoRgbwSm168x4Elements<NeoSm16824eSettings<ColorIndexR, ColorIndexG, ColorIndexB, ColorIndexW>> NeoRgbwSm16824eFeature;

161
src/internal/features/NeoSm168x5Features.h Normal file
View File

@@ -0,0 +1,161 @@
/*-------------------------------------------------------------------------
NeoSm168x5Features provides feature classes to describe color order and
color depth for NeoPixelBus template class specific to the SM168x5 chips/leds
Written by Michael C. Miller.
I invest time and resources providing this open source code,
please support me by dontating (see https://github.com/Makuna/NeoPixelBus)
-------------------------------------------------------------------------
This file is part of the Makuna/NeoPixelBus library.
NeoPixelBus is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
NeoPixelBus is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with NeoPixel. If not, see
<http://www.gnu.org/licenses/>.
-------------------------------------------------------------------------*/
#pragma once
/*
5 channel RGBWY
SM16825E 10.2~310.0mA
*/
class NeoSm168x5SettingsBase : public NeoRgbwwCurrentSettings
{
public:
NeoSm168x5SettingsBase(uint8_t redGain,
uint8_t greenGain,
uint8_t blueGain,
uint8_t whiteGain,
uint8_t otherGain,
uint16_t redCurrent,
uint16_t greenCurrent,
uint16_t blueCurrent,
uint16_t whiteCurrent,
uint16_t otherCurrent) :
NeoRgbwwCurrentSettings(redCurrent, greenCurrent, blueCurrent, whiteCurrent, otherCurrent),
RedGain(redGain & 0x1f),
GreenGain(greenGain & 0x1f),
BlueGain(blueGain & 0x1f),
WhiteGain(whiteGain & 0x1f),
OtherGain(otherGain & 0x1f) {}
// ------------------------------------------------------------------------
// operator [] - readonly
// access elements in order by index rather than member name
// ------------------------------------------------------------------------
uint8_t operator[](size_t idx) const
{
switch (idx)
{
case 0:
return RedGain;
case 1:
return GreenGain;
case 2:
return BlueGain;
case 3:
return WhiteGain;
default:
return OtherGain;
}
}
const uint8_t RedGain : 5;
const uint8_t GreenGain : 5;
const uint8_t BlueGain : 5;
const uint8_t WhiteGain : 5;
const uint8_t OtherGain : 5;
};
template <uint8_t V_IC_1, uint8_t V_IC_2, uint8_t V_IC_3, uint8_t V_IC_4, uint8_t V_IC_5>
class NeoSm16825eSettings : public NeoSm168x5SettingsBase
{
public:
NeoSm16825eSettings(uint8_t redGain, uint8_t greenGain, uint8_t blueGain, uint8_t whiteGain, uint8_t otherGain ) :
NeoSm168x5SettingsBase(redGain,
greenGain,
blueGain,
whiteGain,
otherGain,
CurrentLookup[redGain],
CurrentLookup[greenGain],
CurrentLookup[blueGain],
CurrentLookup[whiteGain],
CurrentLookup[otherGain])
{
}
void Encode(uint8_t* encoded) const
{
// RGBWY 5 bits each
*encoded++ = operator[](V_IC_1) << 3 | operator[](V_IC_2) >> 2; // 0b11111222
*encoded++ = operator[](V_IC_2) << 6 | operator[](V_IC_3) << 1 | operator[](V_IC_4) >> 4; // 0b22333334
*encoded++ = operator[](V_IC_4) << 4 | operator[](V_IC_5) >> 1; // 0b44445555
*encoded = operator[](V_IC_5) << 7 | 0b00011111; // 0b50011111 00 (action, not standby) 11111 (reserved)
}
protected:
static constexpr uint16_t CurrentLookup[32] = {
102, 203, 304, 405, 506, 607, 708, 809,
910, 1011, 1112, 1213, 1307, 1406, 1505, 1602,
1700, 1790, 1885, 1980, 2078, 2168, 2264, 2358,
2450, 2544, 2636, 2728, 2820, 2910, 3000, 3100}; // in tenth mA
/* not to spec, switched to table
constexpr uint16_t MinCmA = 1020; // 100th of a mA
constexpr uint16_t MaxCmA = 31000;
constexpr uint16_t DeltaCmA = MaxCmA - MinCmA;
constexpr uint16_t IncCmA = DeltaCmA / 31;
static uint16_t calcCurrent(const uint8_t gain)
{
uint16_t CmA = MinCmA + (gain * IncCmA);
return CmA / 10; // return tenths of mA
}
*/
};
// CAUTION: Make sure ColorIndex order for Neo5ByteFeature matches T_SETTINGS
template<uint8_t V_IC_1, uint8_t V_IC_2, uint8_t V_IC_3, uint8_t V_IC_4, uint8_t V_IC_5>
class NeoRgbwcSm168x5Elements :
public Neo5WordFeature<V_IC_1, V_IC_2, V_IC_3, V_IC_4, V_IC_5>
{
public:
typedef NeoSm16825eSettings<V_IC_1, V_IC_2, V_IC_3, V_IC_4, V_IC_5> SettingsObject;
static const size_t SettingsSize = 4;
static void applySettings([[maybe_unused]] uint8_t* pData, [[maybe_unused]] size_t sizeData, [[maybe_unused]] const SettingsObject& settings)
{
// settings are at the end of the data stream
uint8_t* pDest = pData + sizeData - SettingsSize;
settings.Encode(pDest);
}
static uint8_t* pixels([[maybe_unused]] uint8_t* pData, [[maybe_unused]] size_t sizeData)
{
return pData;
}
static const uint8_t* pixels([[maybe_unused]] const uint8_t* pData, [[maybe_unused]] size_t sizeData)
{
return pData;
}
};
typedef NeoRgbwcSm168x5Elements<ColorIndexR, ColorIndexG, ColorIndexB, ColorIndexWW, ColorIndexCW> NeoRgbwcSm16825eFeature;
typedef NeoRgbwcSm168x5Elements<ColorIndexR, ColorIndexG, ColorIndexB, ColorIndexCW, ColorIndexWW> NeoRgbcwSm16825eFeature;