public override IDictionary <PortIdentifier, List <LedColor> > GenerateColors(List <PortIdentifier> ports, ICacheProvider cache)
{
_fill += Config.FillStep;
if (_fill >= 1)
{
_fill = 0;
_lastHue = _currentHue;
_currentHue = ((_currentHue + Config.HueStep) % 360 + 360) % 360;
}
var lastColor = LedColor.FromHsv(_lastHue, Config.Saturation, Config.Brightness);
var currentColor = LedColor.FromHsv(_currentHue, Config.Saturation, Config.Brightness);
if (Config.ColorGenerationMethod == ColorGenerationMethod.PerPort)
{
return(EffectUtils.GenerateColorsPerPort(ports, cache, (port, ledCount) => GenerateColors(ledCount, currentColor, lastColor)));
}
else if (Config.ColorGenerationMethod == ColorGenerationMethod.SpanPorts)
{
var totalLedCount = ports.Select(p => cache.GetDeviceConfig(p).LedCount).Sum();
var colors = GenerateColors(totalLedCount, currentColor, lastColor);
return(EffectUtils.SplitColorsPerPort(colors, ports, cache));
}
return(null);
}
public override IDictionary <PortIdentifier, List <LedColor> > GenerateColors(List <PortIdentifier> ports, ICacheProvider cache)
{
_fill += Config.FillStep;
if (_fill >= 1)
{
_fill = 0;
_lastHue = _currentHue;
_currentHue = (_currentHue + Config.HueStep) % 360;
}
var result = new Dictionary <PortIdentifier, List <LedColor> >();
foreach (var port in ports)
{
var config = cache.GetPortConfig(port);
if (config == null)
{
continue;
}
var lastColor = LedColor.FromHsv(_lastHue, Config.Saturation, Config.Brightness);
var currentColor = LedColor.FromHsv(_currentHue, Config.Saturation, Config.Brightness);
var colors = Enumerable.Range(0, config.LedCount).Select(x => lastColor).ToList();
for (var i = 0; i < (int)Math.Round(config.LedCount * _fill); i++)
{
colors[i] = currentColor;
}
result.Add(port, colors);
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="ReaderLedControl"/> class.
/// </summary>
/// <param name="readerNumber">The reader number starting at 0.</param>
/// <param name="ledNumber">The LED number.</param>
/// <param name="temporaryMode">The temporary mode.</param>
/// <param name="temporaryOnTime">The temporary on time in units of 100ms.</param>
/// <param name="temporaryOffTime">The temporary off time in units of 100ms.</param>
/// <param name="temporaryOnColor">Color of the temporary on.</param>
/// <param name="temporaryOffColor">Color of the temporary off.</param>
/// <param name="temporaryTimer">The temporary timer in units of 100ms.</param>
/// <param name="permanentMode">The permanent mode.</param>
/// <param name="permanentOnTime">The permanent on time in units of 100ms.</param>
/// <param name="permanentOffTime">The permanent off time in units of 100ms.</param>
/// <param name="permanentOnColor">Color of the permanent on.</param>
/// <param name="permanentOffColor">Color of the permanent off.</param>
public ReaderLedControl(
byte readerNumber,
byte ledNumber,
TemporaryReaderControlCode temporaryMode,
byte temporaryOnTime,
byte temporaryOffTime,
LedColor temporaryOnColor,
LedColor temporaryOffColor,
ushort temporaryTimer,
PermanentReaderControlCode permanentMode,
byte permanentOnTime,
byte permanentOffTime,
LedColor permanentOnColor,
LedColor permanentOffColor)
{
ReaderNumber = readerNumber;
LedNumber = ledNumber;
TemporaryMode = temporaryMode;
TemporaryOnTime = temporaryOnTime;
TemporaryOffTime = temporaryOffTime;
TemporaryOnColor = temporaryOnColor;
TemporaryOffColor = temporaryOffColor;
TemporaryTimer = temporaryTimer;
PermanentMode = permanentMode;
PermanentOnTime = permanentOnTime;
PermanentOffTime = permanentOffTime;
PermanentOnColor = permanentOnColor;
PermanentOffColor = permanentOffColor;
}
public Led(LedColor color, LedPosition position) : base($"leds/ev3:{position.ToString().ToLower()}:{color.ToString().ToLower()}:ev3dev")
{
Color = color;
Position = position;
brightness = new ClassProperty(Folder, "brightness");
}
public void SetRgb([FromBody] LedColor ledColor)
{
var color = Color.FromArgb(ledColor.r, ledColor.b, ledColor.g);
Program.KillAllThreads();
Program.ClearLeds();
Program.SetAllLeds(color);
}
private void OnColorUpdate(object sender, RzBroadcastColorChangedEventArgs e)
{
Logger.Trace("Razer broadcast colors updated");
for (var i = 0; i < _colors.Length; i++)
{
_colors[i] = LedColor.Unpack(e.Colors[i]);
}
}
/// <summary>
/// Sets the Color of one of the system leds
/// </summary>
/// <param name="led">Led to set</param>
/// <param name="col">Color to set</param>
public void SetLedColor(SystemLed led, LedColor col)
{
var data = new byte[1];
data = _control.Read(_byteAddr, 1);
data[0] = (byte)((data[0] & ~(0x03 << (int)led)) | ((byte)col << (int)led));
_control.Write(_byteAddr, data, 1);
}
public void LedPattern(LedColor color, LedEffect effect)
{
int pattern = (int)color + (int)effect;
byte[] cmd = new byte[2];
cmd [0] = (byte)('0' + pattern);
dev.Write(cmd);
}
/// <summary>
/// Sets state of an LED
/// </summary>
/// <param name="ledIndex">Index of the Led - use 0 for standard Movesense sensor</param>
/// <param name="ledOn">Set on or off</param>
/// <param name="ledColor">[optional]value from LedColor enumeration - default is LedColor.Red</param>
public async Task SetLedStateAsync(int ledIndex, bool ledOn, LedColor ledColor = LedColor.Red)
{
string datapath = String.Format(LED_PATH, ledIndex);
string led_On_Body = $"{{ \"LedState\": {{ \"IsOn\": true, \"LedColor\": {(int)ledColor}}} }}";
string led_Off_Body = @"{ ""LedState"": { ""IsOn"": false, ""LedColor"": 0} }";
var op = new ApiCallAsync <LedState>(this, MdsOp.PUT, datapath, ledOn ? led_On_Body : led_Off_Body);
await op.CallAsync();
}
public void SetColor(LedColor color)
{
switch (color)
{
case LedColor.White:
R = 100; G = 255; B = 95;
break;
case LedColor.Red:
R = 255; G = 0; B = 0;
break;
case LedColor.Blue:
R = 0; G = 0; B = 255;
break;
case LedColor.Green:
R = 0; G = 255; B = 0;
break;
case LedColor.Yellow:
R = 132; G = 255; B = 0;
break;
case LedColor.Orange:
R = 180; G = 255; B = 0;
break;
case LedColor.Pink:
R = 255; G = 100; B = 50;
break;
case LedColor.IceBlue:
R = 0; G = 160; B = 255;
break;
case LedColor.IceGreen:
R = 18; G = 255; B = 18;
break;
case LedColor.Off:
R = 0; G = 0; B = 0;
break;
case LedColor.Active:
R = 0; G = 32; B = 16;
break;
case LedColor.InActive:
R = 9; G = 24; B = 9;
break;
default:
break;
}
mInterface.WriteMessage(new SerialMessage(Command.LED_ACT, (byte)mBoardId, 0));
}
public AuroraEffect(AuroraEffectConfig config) : base(config)
{
if (Config.Gradient == null)
{
var colors = Enumerable.Range(0, Config.Length)
.Select(x => LedColor.FromHsv(x / (Config.Length - 1f) * 360, Config.Saturation, Config.Brightness));
Config.Gradient = new LedColorGradient(colors);
}
}
public override IDictionary <PortIdentifier, List <LedColor> > GenerateColors(List <PortIdentifier> ports, ICacheProvider cache)
{
_hue = (_hue + Config.HueStep) % 360;
var color = LedColor.FromHsv(_hue, Config.Saturation, Config.Brightness);
return(ports.ToDictionary(p => p, _ => new List <LedColor>()
{
color
}));
}
public PulseEffect(PulseEffectConfig config) : base(config)
{
_direction = -1;
_t = 1d;
_maxBrightness = config.Colors.Select(c =>
{
var(h, s, v) = LedColor.ToHsv(c);
return(v);
}).ToArray();
}
public RippleEffect(RippleEffectConfig config) : base(config)
{
_tick = Config.TickInterval;
_rippleColors = new LedColor[Config.Length];
var(hue, saturation, value) = LedColor.ToHsv(Config.Color);
for (var i = 0; i < Config.Length; i++)
{
_rippleColors[i] = LedColor.FromHsv(hue, saturation, value * (Config.Length - i - 1) / (Config.Length - 1));
}
}
public void Led(LedColor color, LedMode mode)
{
WebRequest cidpsid = WebRequest.Create("http://" + ip + "/led.ps3mapi?color=" + color + "&mode=" + mode);
WebResponse rsp = cidpsid.GetResponse();
using (Stream dataStream = rsp.GetResponseStream())
{
StreamReader rd = new StreamReader(dataStream);
rd.ReadToEnd();
}
rsp.Close();
}
private List <LedColor> GenerateColors(int ledCount, LedColor currentColor, LedColor lastColor)
{
var fillIndex = (int)Math.Round(ledCount * _fill);
var colors = new List <LedColor>();
for (var i = 0; i < ledCount; i++)
{
colors.Add((i < fillIndex) ? currentColor : lastColor);
}
return(colors);
}
public void SetColor(LedColor color)
{
switch (color)
{
case LedColor.Black:
redPin.TurnOff();
greenPin.TurnOff();
bluePin.TurnOff();
break;
case LedColor.Red:
redPin.TurnOn();
greenPin.TurnOff();
bluePin.TurnOff();
break;
case LedColor.Green:
redPin.TurnOff();
greenPin.TurnOn();
bluePin.TurnOff();
break;
case LedColor.Blue:
redPin.TurnOff();
greenPin.TurnOff();
bluePin.TurnOn();
break;
case LedColor.Violet:
redPin.TurnOn();
greenPin.TurnOff();
bluePin.TurnOn();
break;
case LedColor.Yellow:
redPin.TurnOn();
greenPin.TurnOn();
bluePin.TurnOff();
break;
case LedColor.Purple:
redPin.TurnOff();
greenPin.TurnOn();
bluePin.TurnOn();
break;
case LedColor.White:
redPin.TurnOn();
greenPin.TurnOn();
bluePin.TurnOn();
break;
}
}
public void SetColor(LedColor color)
{
switch(color)
{
case LedColor.Black:
redPin.TurnOff();
greenPin.TurnOff();
bluePin.TurnOff();
break;
case LedColor.Red:
redPin.TurnOn();
greenPin.TurnOff();
bluePin.TurnOff();
break;
case LedColor.Green:
redPin.TurnOff();
greenPin.TurnOn();
bluePin.TurnOff();
break;
case LedColor.Blue:
redPin.TurnOff();
greenPin.TurnOff();
bluePin.TurnOn();
break;
case LedColor.Violet:
redPin.TurnOn();
greenPin.TurnOff();
bluePin.TurnOn();
break;
case LedColor.Yellow:
redPin.TurnOn();
greenPin.TurnOn();
bluePin.TurnOff();
break;
case LedColor.Purple:
redPin.TurnOff();
greenPin.TurnOn();
bluePin.TurnOn();
break;
case LedColor.White:
redPin.TurnOn();
greenPin.TurnOn();
bluePin.TurnOn();
break;
}
}
public Led(LedColor color)
{
_controller = GpioControllerFactory.GetController();
_pinNumber = color switch
{
LedColor.Red => Constants.PIN_LEDRED,
LedColor.Green => Constants.PIN_LEDGREEN,
LedColor.Blue => Constants.PIN_LEDBLUE,
_ => throw new NotImplementedException(),
};
_controller.OpenPin(_pinNumber, PinMode.Output);
}
public override IDictionary <PortIdentifier, List <LedColor> > GenerateColors(List <PortIdentifier> ports, ICacheProvider cache)
{
var temperatures = Config.Sensors.Select(cache.GetTemperature);
var temperature = float.NaN;
if (Config.SensorMixFunction == SensorMixFunction.Average)
{
temperature = temperatures.Average();
}
else if (Config.SensorMixFunction == SensorMixFunction.Minimum)
{
temperature = temperatures.Min();
}
else if (Config.SensorMixFunction == SensorMixFunction.Maximum)
{
temperature = temperatures.Max();
}
if (temperature < _minTemperature)
{
temperature = _minTemperature;
}
if (temperature > _maxTemperature)
{
temperature = _maxTemperature;
}
if (float.IsNaN(temperature))
{
_r = Config.ColorGradient.Start.Color.R;
_g = Config.ColorGradient.Start.Color.G;
_b = Config.ColorGradient.Start.Color.B;
}
else
{
var(rr, gg, bb) = Config.ColorGradient.ColorAtDeconstruct(temperature);
var t = 0.05f;
_r = _r * (1 - t) + rr * t;
_g = _g * (1 - t) + gg * t;
_b = _b * (1 - t) + bb * t;
}
var color = new LedColor((byte)_r, (byte)_g, (byte)_b);
return(ports.ToDictionary(p => p, p => new List <LedColor> {
color
}));
}
private List <LedColor> GenerateColors(int ledCount, double portStart, double portEnd, double radius = 0.95, bool oddDivide = true)
{
var colors = Enumerable.Range(0, ledCount).Select(_ => new LedColor()).ToList();
var tBottom = _t - Config.Height / 2;
var tTop = _t + Config.Height / 2;
var localStart = (tBottom - portStart) / (portEnd - portStart);
var localEnd = (tTop - portStart) / (portEnd - portStart);
var isOdd = ledCount % 2 != 0;
var halfCount = ledCount / 2 + (oddDivide || isOdd ? 0 : -1);
for (var j = 0; j <= halfCount; j++)
{
var a = (0.5 + j / (double)halfCount) * Math.PI;
var x = -Math.Cos(a) / 2 * radius;
var y = 1 - (1 + Math.Sin(a) * radius) / 2;
if (x > Config.Width / 2)
{
continue;
}
if (y >= localStart && y <= localEnd)
{
var color = Config.ColorGradient.GetColor(portStart + (portEnd - portStart) * y);
if (Config.EnableSmoothing)
{
var dist = Math.Abs(Math.Min(y - localStart, localEnd - y));
var falloff = (2 * dist) / (localEnd - localStart);
var(h, s, v) = LedColor.ToHsv(color);
color = LedColor.FromHsv(h, s, v * falloff);
}
colors[j] = color;
if (!oddDivide && !isOdd)
{
colors[ledCount - j - 1] = color;
}
else if (j != 0 && (j != ledCount / 2 || isOdd))
{
colors[ledCount - j] = color;
}
}
}
return(colors);
}
public override List <LedColor> GenerateColors(int count, ICacheProvider cache)
{
var lastColor = LedColor.FromHsv(_lastHue, Config.Saturation, Config.Brightness);
var currentColor = LedColor.FromHsv(_currentHue, Config.Saturation, Config.Brightness);
var fillIndex = (int)Math.Round(count * _fill);
var colors = new List <LedColor>();
for (var i = 0; i < count; i++)
{
colors.Add((i < fillIndex) ? currentColor : lastColor);
}
return(colors);
}
public override IDictionary <PortIdentifier, List <LedColor> > GenerateColors(List <PortIdentifier> ports, ICacheProvider cache)
{
var values = Config.Sensors.Select(cache.GetSensorValue);
var value = float.NaN;
if (Config.SensorMixFunction == SensorMixFunction.Average)
{
value = values.Average();
}
else if (Config.SensorMixFunction == SensorMixFunction.Minimum)
{
value = values.Min();
}
else if (Config.SensorMixFunction == SensorMixFunction.Maximum)
{
value = values.Max();
}
if (value < _minValue)
{
value = _minValue;
}
if (value > _maxValue)
{
value = _maxValue;
}
if (float.IsNaN(value))
{
_r = Config.ColorGradient.Start.Color.R;
_g = Config.ColorGradient.Start.Color.G;
_b = Config.ColorGradient.Start.Color.B;
}
else
{
var(rr, gg, bb) = Config.ColorGradient.ColorAtDeconstruct(value);
const float t = 0.05f;
_r = _r * (1 - t) + rr * t;
_g = _g * (1 - t) + gg * t;
_b = _b * (1 - t) + bb * t;
}
var color = new LedColor((byte)_r, (byte)_g, (byte)_b);
return(ports.ToDictionary(p => p, p => Enumerable.Repeat(color, cache.GetPortConfig(p).LedCount).ToList()));
}
protected override void WriteLed(AnalysisResult result)
{
var theme = Theme;
if (theme == null)
{
return;
}
var colors = new LedColor[_controller.LEDCount];
foreach (var colorRange in theme.ColorRanges)
{
ConfigureColors(result, colors, colorRange);
}
for (var i = 0; i < colors.Length; i++)
{
var color = colors[i] * Brightness;
color.Red = Limit(color.Red);
color.Green = Limit(color.Green);
color.Blue = Limit(color.Blue);
colors[i] = color;
var col = color.AsColor();
_controller.SetLED(i, col);
}
var log = Log;
if (log != null && _lastColors != null)
{
int index = 0;
foreach (var colorPair in colors.Zip(_lastColors))
{
if (colorPair.First != colorPair.Second)
{
var col = colorPair.First.AsColor();
log.Verbose($"[{index.ToString("000")}] R:{col.R} G:{col.G} B:{col.B}");
}
index++;
}
}
_lastColors = colors;
_device.Render();
}
public override IDictionary <PortIdentifier, List <LedColor> > GenerateColors(List <PortIdentifier> ports, ICacheProvider cache)
{
var values = Config.Sensors.Select(cache.GetSensorValue);
var value = float.NaN;
if (Config.SensorMixFunction == SensorMixFunction.Average)
{
value = values.Average();
}
else if (Config.SensorMixFunction == SensorMixFunction.Minimum)
{
value = values.Min();
}
else if (Config.SensorMixFunction == SensorMixFunction.Maximum)
{
value = values.Max();
}
if (value < _minValue)
{
value = _minValue;
}
if (value > _maxValue)
{
value = _maxValue;
}
if (float.IsNaN(value))
{
_r = Config.ColorGradient.Start.Color.R;
_g = Config.ColorGradient.Start.Color.G;
_b = Config.ColorGradient.Start.Color.B;
}
else
{
var(rr, gg, bb) = Config.ColorGradient.GetColorSmooth(value);
_r = _r * (1 - Config.SmoothingFactor) + rr * Config.SmoothingFactor;
_g = _g * (1 - Config.SmoothingFactor) + gg * Config.SmoothingFactor;
_b = _b * (1 - Config.SmoothingFactor) + bb * Config.SmoothingFactor;
}
var color = new LedColor((byte)_r, (byte)_g, (byte)_b);
return(EffectUtils.GenerateColorsPerPort(ports, cache, (port, ledCount) => Enumerable.Repeat(color, ledCount).ToList()));
}
public override IDictionary <PortIdentifier, List <LedColor> > GenerateColors(List <PortIdentifier> ports, ICacheProvider cache)
{
_t += Config.BrightnessStep * _direction;
if (_t < 0)
{
_direction = 1;
_t = 0;
}
else if (_t > 1)
{
_direction = -1;
_t = 1;
}
for (var i = 0; i < Config.Colors.Count; i++)
{
var(h, s, v) = LedColor.ToHsv(Config.Colors[i]);
_colors[i] = LedColor.FromHsv(h, s, v * _t);
}
if (Config.ColorGenerationMethod == ColorGenerationMethod.PerPort)
{
return(ports.ToDictionary(p => p, _ => _colors.ToList()));
}
else if (Config.ColorGenerationMethod == ColorGenerationMethod.SpanPorts)
{
var result = new Dictionary <PortIdentifier, List <LedColor> >();
var offset = 0;
foreach (var port in ports)
{
var config = cache.GetPortConfig(port);
if (config == null)
{
continue;
}
result.Add(port, _colors.Skip(offset).Take(config.LedCount).ToList());
offset += config.LedCount;
}
return(result);
}
return(null);
}
public override List <LedColor> GenerateColors(int count, ICacheProvider cache)
{
var current = Config.Sequence[_sequenceIndex];
if (_state == SequenceState.Hold)
{
return(current.Color.Get(count).ToList());
}
else if (_state == SequenceState.Transition)
{
int Wrap(int a, int b) => (a % b + b) % b;
var prev = Config.Sequence[Wrap(_sequenceIndex - 1, Config.Sequence.Count)];
var t = (Environment.TickCount - _stateStart) / (float)current.TransitionTime;
return(LedColor.Lerp(t, prev.Color.Get(count), current.Color.Get(count)).ToList());
}
return(null);
}
public static Color ToUnityColor(this LedColor ledColor)
{
switch (ledColor)
{
case LedColor.Yellow:
return(YellowColor);
case LedColor.Orange:
return(OrangeColor);
case LedColor.Red:
return(RedColor);
case LedColor.Green:
return(GreenColor);
default:
throw new ArgumentOutOfRangeException(ledColor.ToString());
}
}
public override IDictionary <PortIdentifier, List <LedColor> > GenerateColors(List <PortIdentifier> ports, ICacheProvider cache)
{
int Wrap(int a, int b) => (a % b + b) % b;
if (_tick++ >= Config.TickInterval)
{
_tick = 0;
_rotation++;
}
var result = new Dictionary <PortIdentifier, List <LedColor> >();
foreach (var port in ports)
{
var config = cache.GetPortConfig(port);
if (config == null)
{
continue;
}
var off = new LedColor(0, 0, 0);
var colors = Enumerable.Range(0, config.LedCount).Select(_ => off).ToList();
var(hue, saturation, value) = LedColor.ToHsv(Config.Color);
var length = Config.Length == 0 ? config.LedCount : Config.Length;
for (var i = 0; i < length; i++)
{
var idx = Wrap(_rotation - i, config.LedCount);
colors[idx] = LedColor.FromHsv(hue, saturation, value * (length - i) / length);
}
result.Add(port, colors);
}
return(result);
}
public override IDictionary <PortIdentifier, List <LedColor> > GenerateColors(List <PortIdentifier> ports, ICacheProvider cache)
{
_t += Config.BrightnessStep * _direction;
if (_t < 0 || _t > 1)
{
_direction = -_direction;
}
if (Config.ColorGenerationMethod == ColorGenerationMethod.PerPort)
{
return(EffectUtils.GenerateColorsPerPort(ports, cache,
(port, ledCount) => Config.Color.Get(ledCount).Select(c => LedColor.ChangeValue(c, c.GetValue() * _t)).ToList()
));
}
if (Config.ColorGenerationMethod == ColorGenerationMethod.SpanPorts)
{
var totalLedCount = ports.Sum(p => cache.GetDeviceConfig(p).LedCount);
var colors = Config.Color.Get(totalLedCount).Select(c => LedColor.ChangeValue(c, c.GetValue() * _t)).ToList();
return(EffectUtils.SplitColorsPerPort(colors, ports, cache));
}
return(null);
}
public override IDictionary <PortIdentifier, List <LedColor> > GenerateColors(List <PortIdentifier> ports, ICacheProvider cache)
{
_t += Config.BrightnessStep * _direction;
if (_t < 0)
{
_direction = 1;
_t = 0;
}
else if (_t > 1)
{
_direction = -1;
_t = 1;
}
var colors = new List <LedColor>();
for (var i = 0; i < Config.Colors.Count; i++)
{
var(h, s, v) = LedColor.ToHsv(Config.Colors[i]);
colors.Add(LedColor.FromHsv(h, s, _maxBrightness[i] * _t));
}
return(ports.ToDictionary(p => p, p => colors.ToList()));
}
