public void SendDmxPacket(ICommand[] outputStates)
{
if (outputStates == null || this._statePacket == null || _serialPort == null)
{
return;
}
var channelValues = new byte[outputStates.Length];
for (int index = 0; index < outputStates.Length; index++)
{
_8BitCommand command = outputStates[index] as _8BitCommand;
if (command == null)
{
// State reset
channelValues[index] = 0;
continue;
}
channelValues[index] = command.CommandValue;
}
if (!this._serialPort.IsOpen)
{
this._serialPort.Open();
}
this._statePacket[0] = 0; // Start code
Array.Copy(channelValues, 0, this._statePacket, 1, Math.Min(512, channelValues.Length));
byte[] packet = this._dmxPacketMessage.Packet;
if (packet != null)
{
this._serialPort.Write(packet, 0, packet.Length);
}
}
public void updateData(ICommand[] outputStates)
{
var channelValues = new byte[outputStates.Length];
//Make sure that editing the output buffer is thread safe
lock (buffer)
{
//copy the lighting commands to the DMX Buffer
for (int i = 0; i < outputStates.Length; i++)
{
_8BitCommand command = outputStates[i] as _8BitCommand;
//Reset the channel if the command is null
if (command == null)
{
// State reset
buffer[i + 1] = 0;
continue;
}
//Copy the new intensity value to the output buffer
buffer[i + 1] = command.CommandValue;
}
}
}
public static ICommand Max(this _8BitCommand command, _8BitCommand commandOther)
{
if (command.CommandValue > commandOther.CommandValue)
{
return(command);
}
return(commandOther);
}
public static ICommand Max(this _8BitCommand command, _8BitCommand commandOther)
{
if (command.CommandValue > commandOther.CommandValue)
{
return command;
}
return commandOther;
}
protected override void _PreRender(CancellationTokenSource tokenSource = null)
{
_elementData = new EffectIntents();
if (_data == null)
{
return;
}
ICommand command = null;
switch (ValueType)
{
case CustomValueType._8Bit:
command = new _8BitCommand(Value8Bit);
break;
case CustomValueType._16Bit:
command = new _16BitCommand(Value16Bit);
break;
case CustomValueType._32Bit:
command = new _32BitCommand(Value32Bit);
break;
case CustomValueType._64Bit:
command = new _64BitCommand(Value64Bit);
break;
case CustomValueType.Color:
command = new ColorCommand(ColorValue);
break;
case CustomValueType.String:
command = new StringCommand(StringValue);
break;
}
CommandValue value = new CommandValue(command);
foreach (ElementNode node in TargetNodes)
{
foreach (var leafNode in node.GetLeafEnumerator())
{
if (tokenSource != null && tokenSource.IsCancellationRequested)
{
return;
}
IIntent intent = new CommandIntent(value, TimeSpan);
_elementData.AddIntentForElement(leafNode.Element.Id, intent, TimeSpan.Zero);
}
}
}
public override void Handle(_8BitCommand obj)
{
if (CombinatorValue == null)
{
CombinatorValue = obj;
}
else
{
CombinatorValue = obj.Max((_8BitCommand)CombinatorValue);
}
}
public override void Handle(_8BitCommand obj)
{
if (CombinatorValue == null)
{
CombinatorValue = obj;
}
else
{
byte value1 = (CombinatorValue as _8BitCommand).CommandValue;
byte value2 = obj.CommandValue;
CombinatorValue = new _8BitCommand(Math.Max(value1, value2));
}
}
public override void Handle(ColorCommand obj)
{
if (CombinatorValue == null)
{
CombinatorValue = new _8BitCommand(RGBValue.GetGrayscaleLevel(obj.CommandValue));
}
else
{
byte value1 = (CombinatorValue as _8BitCommand).CommandValue;
byte value2 = RGBValue.GetGrayscaleLevel(obj.CommandValue);
CombinatorValue = new _8BitCommand(Math.Max(value1, value2));
}
}
public override void Handle(_8BitCommand obj)
{
if (CombinatorValue == null)
{
CombinatorValue = obj;
}
else
{
byte value1 = CombinatorValue.CommandValue;
byte value2 = obj.CommandValue;
CombinatorValue = new _8BitCommand((value1 + value2) >> 1);
}
}
public override void Handle(_16BitCommand obj)
{
if (CombinatorValue == null)
{
CombinatorValue = new _8BitCommand(obj.CommandValue);
}
else
{
byte value1 = CombinatorValue.CommandValue;
byte value2 = (byte)obj.CommandValue;
CombinatorValue = new _8BitCommand(Math.Max(value1, value2));
}
}
public override void Handle(_8BitCommand obj)
{
if (CombinatorValue == null)
{
CombinatorValue = new _16BitCommand(obj.CommandValue);
}
else
{
ushort value1 = CombinatorValue.CommandValue;
ushort value2 = obj.CommandValue;
CombinatorValue = new _16BitCommand(Math.Max(value1, value2));
}
}
public override void Handle(_8BitCommand obj)
{
if (CombinatorValue == null)
{
CombinatorValue = new _32BitCommand(obj.CommandValue);
}
else
{
uint value1 = (CombinatorValue as _32BitCommand).CommandValue;
uint value2 = obj.CommandValue;
CombinatorValue = new _32BitCommand(Math.Max(value1, value2));
}
}
public static byte[] ToChannelValuesAsBytes(this ICommand[] outputStates)
{
if (outputStates == null)
{
return(new byte[0]);
}
var channelValues = new byte[outputStates.Length];
for (int index = 0; index < outputStates.Length; index++)
{
_8BitCommand command = outputStates[index] as _8BitCommand;
if (command == null)
{
// State reset
channelValues[index] = 0;
continue;
}
channelValues[index] = command.CommandValue;
}
return(channelValues);
}
// Handling intents as an evaluator.
public override void Handle(IIntentState<RGBValue> obj)
{
byte byteLevel = (byte)(byte.MaxValue * obj.GetValue().Intensity);
EvaluatorValue = new _8BitCommand(byteLevel);
}
public override void Handle(IIntentState <IntensityValue> obj)
{
EvaluatorValue = new _8BitCommand((byte)(byte.MaxValue * obj.GetValue().Intensity));
}
// Handling intents as an evaluator.
public override void Handle(IIntentState <ColorValue> obj)
{
byte byteLevel = ColorValue.GetGrayscaleLevel(obj.GetValue().Color);
EvaluatorValue = new _8BitCommand(byteLevel);
}
public void Handle(_64BitCommand obj)
{
EvaluatorValue = new _8BitCommand(obj.CommandValue);
}
public override void Handle(IIntentState <LightingValue> obj)
{
EvaluatorValue = new _8BitCommand(obj.GetValue().Intensity *byte.MaxValue);
}
public override void Handle(_8BitCommand obj)
{
Command = new _8BitCommand(_reducer.Reduce(obj.CommandValue, ReductionPercentage));
}
public override void Handle(_8BitCommand obj)
{
Value = (obj.CommandValue > 0) ? (short)1 : (short)0;
}
public virtual void Handle(_8BitCommand obj)
{
}
// Additionally dispatching command intents and handling the command they wrap.
public void Handle(_8BitCommand obj)
{
EvaluatorValue = obj;
}
public override void Handle(IIntentState<LightingValue> obj)
{
EvaluatorValue = new _8BitCommand((byte)(byte.MaxValue * obj.GetValue().Intensity));
}
public void Handle(ColorCommand obj)
{
EvaluatorValue = new _8BitCommand(ColorValue.GetGrayscaleLevel(obj.CommandValue));
}
public override void Handle(IIntentState<PositionValue> obj)
{
EvaluatorValue = new _8BitCommand((byte) (byte.MaxValue*obj.GetValue().Position));
}
public override void Handle(_8BitCommand obj)
{
Value = obj.CommandValue;
}
public override void Handle(_8BitCommand obj)
{
Command = new _8BitCommand(_reducer.Reduce(obj.CommandValue, ReductionPercentage));
}
public override void UpdateState(int chainIndex, ICommand[] outputStates)
{
if (_networkStream == null && !FakingIt())
{
bool success = OpenConnection();
if (!success)
{
Logging.Warn("BlinkyLinky: failed to connect to device, not updating the current state.");
return;
}
}
// build up transmission packet
byte[] data = new byte[1024]; // overkill, but it'll do
int totalPacketLength = 0;
// protocol is: 4 bytes header
// 1 byte command
//
// at the moment, only the 'Set Values' blinky-protocol command is supported.
// Set Values: 1 byte for the stream (ie. 0-2, for which RS485 stream)
// 2 bytes for the length of following data (high byte first) - ie. only the channel/value bytes
// 2 bytes (repeated): channel, value.
data[totalPacketLength++] = HEADER_1;
data[totalPacketLength++] = HEADER_2;
data[totalPacketLength++] = HEADER_3;
data[totalPacketLength++] = HEADER_4;
data[totalPacketLength++] = COMMAND_SET_VALUES;
data[totalPacketLength++] = (byte)_data.Stream;
int lengthPosH = totalPacketLength++;
int lengthPosL = totalPacketLength++;
bool changed = false;
for (int i = 0; i < outputStates.Length; i++)
{
byte newValue = 0;
if (outputStates[i] != null)
{
_8BitCommand command = outputStates[i] as _8BitCommand;
if (command == null)
{
continue;
}
newValue = command.CommandValue;
_nullCommands[i] = 0;
}
else
{
// it was a null command. We should turn it off; however, to avoid some potentially nasty flickering,
// we will keep track of the null commands for this output, and ignore the first one. Any after that will
// actually be sent through.
if (_nullCommands[i] == 0)
{
_nullCommands[i] = 1;
newValue = _lastValues[i];
}
}
if (_lastValues[i] != newValue)
{
changed = true;
data[totalPacketLength++] = (byte)i;
data[totalPacketLength++] = newValue;
_lastValues[i] = newValue;
}
}
int totalData = totalPacketLength - lengthPosL - 1;
data[lengthPosH] = (byte)((totalData >> 8) & 0xFF);
data[lengthPosL] = (byte)(totalData & 0xFF);
// don't bother writing anything if we haven't acutally *changed* any values...
// (also, send at least a 'null' update command every 10 seconds. I think there's a bug in the micro
// firmware; it doesn't seem to close network connections properly. Need to diagnose more, later.)
if (changed || _timeoutStopwatch.ElapsedMilliseconds >= 10000)
{
try {
_timeoutStopwatch.Restart();
if (FakingIt())
{
System.Threading.Thread.Sleep(1);
}
else
{
_networkStream.Write(data, 0, totalPacketLength);
_networkStream.Flush();
}
}
catch (Exception ex) {
Logging.Warn(
"BlinkyLinky: failed to write data to device, this update state may be lost. Closing connection.", ex);
CloseConnection();
}
}
}
public override void Handle(_8BitCommand obj)
{
Value = (obj.CommandValue > 0) ? (short)1 : (short)0;
}
// Handling intents as an evaluator.
public override void Handle(IIntentState <RGBValue> obj)
{
byte byteLevel = (byte)(byte.MaxValue * obj.GetValue().Intensity);
EvaluatorValue = new _8BitCommand(byteLevel);
}
protected override void _PreRender(CancellationTokenSource tokenSource = null)
{
_elementData = new EffectIntents();
if (_data == null)
return;
ICommand command = null;
switch (ValueType) {
case CustomValueType._8Bit:
command = new _8BitCommand(Value8Bit);
break;
case CustomValueType._16Bit:
command = new _16BitCommand(Value16Bit);
break;
case CustomValueType._32Bit:
command = new _32BitCommand(Value32Bit);
break;
case CustomValueType._64Bit:
command = new _64BitCommand(Value64Bit);
break;
case CustomValueType.Color:
command = new ColorCommand(ColorValue);
break;
case CustomValueType.String:
command = new StringCommand(StringValue);
break;
}
CommandValue value = new CommandValue(command);
foreach (ElementNode node in TargetNodes)
{
foreach (var leafNode in node.GetLeafEnumerator())
{
if (tokenSource != null && tokenSource.IsCancellationRequested)
return;
IIntent intent = new CommandIntent(value, TimeSpan);
_elementData.AddIntentForElement(leafNode.Element.Id, intent, TimeSpan.Zero);
}
}
}
public override void Handle(_8BitCommand obj)
{
ByteValue = obj.CommandValue;
}
virtual public void Handle(_8BitCommand obj)
{
}
