private void Channel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
logger?.LogDebug($"Slave channel '{e.ChannelId}' with Id = '{slave.UnitId}' received message.");
byte[] msg = mapper.MapOut(e.Message);
OnReceive?.Invoke(this, new ChannelReceivedEventArgs(e.ChannelId, msg));
lastMessage = null;
}
private void Input_OnReceive(object sender, ChannelReceivedEventArgs e)
{
byte[] message = e.Message;
byte[] msg = message;
try
{
MbapHeader header = MbapHeader.Decode(message);
if (header == null)
{
return;
}
Slave slave = config.Slaves.Where(s => s.UnitId == header.UnitId).FirstOrDefault();
byte? alias = slave?.Alias.Value;
foreach (var filter in InputFilters)
{
msg = filter.Execute(message, alias);
msg ??= message;
logger?.LogDebug("Filter executed.");
}
OutputChannel.SendAsync(msg).GetAwaiter();
logger?.LogDebug("Message sent to output channel.");
}
catch (Exception ex)
{
logger?.LogError(ex, "Fault input channel receive.");
}
}
private static async void Channel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
Console.WriteLine("Message received");
await channel.SendAsync(e.Message);
Console.WriteLine("Message sent");
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
try
{
MbapHeader header = MbapHeader.Decode(e.Message);
if (!unitId.HasValue)
{
unitId = header.UnitId;
}
if (unitId.HasValue && header.UnitId == unitId.Value)
{
RtuPiSystem piSystem = map.GetItem((ushort)unitId.Value);
if (piSystem == null)
{
throw new Exception($"PI-System not found for unit id - {unitId.Value}");
}
else
{
client.SubscribeAsync(piSystem.RtuOutputEvent, QualityOfServiceLevelType.AtLeastOnce, ReceiveOutput).GetAwaiter();
client.PublishAsync(QualityOfServiceLevelType.AtLeastOnce, piSystem.RtuInputEvent, contentType, e.Message).GetAwaiter();
}
}
else
{
throw new Exception("Unit Id missing from SCADA client message.");
}
}
catch (Exception ex)
{
OnError?.Invoke(this, new AdapterErrorEventArgs(Id, ex));
}
}
private void Input_OnReceive(object sender, ChannelReceivedEventArgs e)
{
MbapHeader header = MbapHeader.Decode(e.Message);
if (header == null)
{
logger?.LogWarning("MBAP Header returned null");
return; //assume keep alive
}
if (!map.HasItem(header.UnitId))
{
byte[] errorMsg = ModbusErrorMessage.Create(e.Message, ErrorCode.GatewayPathsNotAvailable);
this.InputChannel.SendAsync(errorMsg).GetAwaiter();
return;
}
if (!map.GetItem(header.UnitId).Authorize(e.Message))
{
byte[] errorMsg = ModbusErrorMessage.Create(e.Message, ErrorCode.IllegalAddress);
this.InputChannel.SendAsync(errorMsg).GetAwaiter();
return;
}
byte[] message = e.Message;
byte[] msg = null;
foreach (var filter in InputFilters)
{
msg = filter.Execute(message);
msg ??= message;
}
OutputChannel.SendAsync(msg).GetAwaiter();
}
private void OnChannelReceivedEvent(ChannelReceivedEventArgs e)
{
ChannelReceivedEventHandler handler = ChannelReceivedEvent;
if (handler != null)
{
handler(this, e);
}
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs args)
{
CoapMessage message = CoapMessage.DecodeMessage(args.Message);
CoapMessageHandler handler = CoapMessageHandler.Create(session, message, dispatcher);
Task task = ReceiveAsync(handler);
Task.WhenAll(task);
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
var metadata = graphManager.GetPiSystemMetadataAsync(resource).GetAwaiter().GetResult();
EventMessage msg = new EventMessage(contentType, resource, ProtocolType.WSN, e.Message, DateTime.UtcNow, metadata.Audit)
{
CacheKey = cacheKey
};
adapter.PublishAsync(msg, indexes).GetAwaiter();
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs args)
{
MqttMessage msg = MqttMessage.DecodeMessage(args.Message);
MqttMessageHandler handler = MqttMessageHandler.Create(session, msg);
MqttMessage response = handler.ProcessAsync().GetAwaiter().GetResult();
if (response != null)
{
channel.SendAsync(response.Encode()).GetAwaiter();
}
}
private void Output_OnReceive(object sender, ChannelReceivedEventArgs e)
{
byte[] message = e.Message;
byte[] msg = null;
foreach (var filter in OutputFilters)
{
msg = filter.Execute(message);
msg ??= message;
}
InputChannel.SendAsync(msg);
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
try
{
MqttMessage msg = MqttMessage.DecodeMessage(e.Message);
OnObserve?.Invoke(this, new ChannelObserverEventArgs(Channel.Id, null, null, e.Message));
if (!session.IsAuthenticated)
{
if (!(msg is ConnectMessage message))
{
throw new SecurityException("Connect message not first message");
}
if (session.Authenticate(message.Username, message.Password))
{
IdentityDecoder decoder = new IdentityDecoder(session.Config.IdentityClaimType, context,
session.Config.Indexes);
session.Identity = decoder.Id;
session.Indexes = decoder.Indexes;
adapter.Identity = decoder.Id;
UserAuditRecord record = new UserAuditRecord(Channel.Id, session.Identity,
session.Config.IdentityClaimType, Channel.TypeId, "MQTT", "Granted", DateTime.UtcNow);
userAuditor?.WriteAuditRecordAsync(record).Ignore();
}
else
{
throw new SecurityException("Session could not be authenticated.");
}
}
else if (forcePerReceiveAuthn)
{
if (!session.Authenticate())
{
throw new SecurityException("Per receive authentication failed.");
}
}
ProcessMessageAsync(msg).GetAwaiter();
}
catch (Exception ex)
{
logger?.LogErrorAsync(ex, $"MQTT adapter Channel_OnReceive error on channel '{Channel.Id}'.")
.GetAwaiter();
OnError?.Invoke(this, new ProtocolAdapterErrorEventArgs(Channel.Id, ex));
}
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs args)
{
MqttMessage msg = MqttMessage.DecodeMessage(args.Message);
MqttMessageHandler handler = MqttMessageHandler.Create(session, msg, dispatcher);
try
{
MqttMessage message = handler.ProcessAsync().GetAwaiter().GetResult();
if (message != null)
{
channel.SendAsync(message.Encode()).GetAwaiter();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Trace.TraceError(ex.Message);
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(channel.Id, ex));
}
//Task task = Task.Factory.StartNew(async () =>
//{
// try
// {
// MqttMessage message = await handler.ProcessAsync();
// if (message != null)
// {
// await channel.SendAsync(message.Encode());
// }
// }
// catch(Exception ex)
// {
// Console.WriteLine(ex.Message);
// Trace.TraceError(ex.Message);
// }
//});
//Task.WaitAll(task);
//if (task.Exception != null)
//{
// OnChannelError?.Invoke(this, new ChannelErrorEventArgs(channel.Id, task.Exception.InnerException));
//}
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs args)
{
MqttMessage msg = MqttMessage.DecodeMessage(args.Message);
MqttMessageHandler handler = MqttMessageHandler.Create(session, msg, dispatcher);
try
{
MqttMessage message = handler.ProcessAsync().GetAwaiter().GetResult();
if (message != null)
{
Channel.SendAsync(message.Encode()).GetAwaiter();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Trace.TraceError(ex.Message);
OnChannelError?.Invoke(this, new ChannelErrorEventArgs(Channel.Id, ex));
}
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
try
{
CoapMessage message = CoapMessage.DecodeMessage(e.Message);
if (!session.IsAuthenticated || forcePerReceiveAuthn)
{
session.EnsureAuthentication(message, forcePerReceiveAuthn);
UserAuditRecord record = new UserAuditRecord(Channel.Id, session.Identity,
session.Config.IdentityClaimType, Channel.TypeId, "COAP", "Granted", DateTime.UtcNow);
userAuditor?.WriteAuditRecordAsync(record).Ignore();
}
OnObserve?.Invoke(this,
new ChannelObserverEventArgs(Channel.Id, message.ResourceUri.ToString(),
MediaTypeConverter.ConvertFromMediaType(message.ContentType), message.Payload));
Task task = Task.Factory.StartNew(async() =>
{
CoapMessageHandler handler = CoapMessageHandler.Create(session, message, dispatcher);
CoapMessage msg = await handler.ProcessAsync();
if (msg != null)
{
byte[] payload = msg.Encode();
await Channel.SendAsync(payload);
}
});
task.LogExceptions();
}
catch (Exception ex)
{
logger?.LogErrorAsync(ex, $"CoAP adapter receiveing on channel '{Channel.Id}'.").GetAwaiter();
OnError?.Invoke(this, new ProtocolAdapterErrorEventArgs(Channel.Id, ex));
Channel.CloseAsync().Ignore();
}
}
private void ChannelOSCReceived(object sender, ChannelReceivedEventArgs e)
{
string[] subs = e.subAddress.Split('/');
switch (subs[1])
{
case "mix":
switch (subs[2])
{
case "fader":
X32Level level = new X32Level(0, 1024);
level.RawLevel = (float)e.value;
List <float> faderLevels = view.FaderValues as List <float>;
switch (view.Bank.getEnum())
{
case Constants.FADER_GROUP.CHANNEL_1_8:
faderLevels[e.channel - 1] = level.DbFSLevel;
break;
case Constants.FADER_GROUP.CHANNEL_9_16:
faderLevels[e.channel - 9] = level.DbFSLevel;
break;
case Constants.FADER_GROUP.CHANNEL_17_24:
faderLevels[e.channel - 17] = level.DbFSLevel;
break;
case Constants.FADER_GROUP.CHANNEL_25_32:
faderLevels[e.channel - 25] = level.DbFSLevel;
break;
}
break;
}
break;
default:
//do nothing
break;
}
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs args)
{
CoapMessage message = CoapMessage.DecodeMessage(args.Message);
CoapMessageHandler handler = CoapMessageHandler.Create(session, message, dispatcher);
Task task = ReceiveAsync(handler);
Task.WhenAll(task);
//Task task = Task.Factory.StartNew(async () =>
//{
// CoapMessage msg = await handler.ProcessAsync();
// if (msg != null && pingId.Contains(msg.MessageId))
// {
// pingId.Remove(msg.MessageId);
// //ping complete
// OnPingResponse?.Invoke(this, new CoapMessageEventArgs(msg));
// }
//});
//Task.WaitAll(task);
}
private async void Channel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
logger?.LogDebug("SCADA client channel starting receive.");
try
{
MbapHeader header = MbapHeader.Decode(e.Message);
RtuPiSystem piSystem = map.GetItem(header.UnitId);
if (piSystem == null)
{
logger?.LogWarning("SCADA client receive cannot find RTU pi-system.");
throw new InvalidOperationException("RTU pi-system was not found.");
}
if (!subscribed.Contains(header.UnitId))
{
//subscribe to pi-system for unit id
await connection.AddSubscriptionAsync(piSystem.RtuOutputEvent.ToLowerInvariant(), ReceiveOutput);
subscribed.Add(header.UnitId);
}
byte[] msg = mapper.MapIn(e.Message);
await connection.SendAsync(piSystem.RtuInputEvent.ToLowerInvariant(), CONTENT_TYPE, msg);
MbapHeader mheader = MbapHeader.Decode(msg);
//await connection.Monitor.SendInAsync(ModuleType.VRTU.ToString(), e.Message, mheader.TransactionId);
}
catch (Exception ex)
{
logger?.LogError($"SCADA client receive error - {ex.Message}");
OnError?.Invoke(this, new AdapterErrorEventArgs(Id, ex));
}
}
public override async Task ReceiveAsync()
{
try
{
while (!token.IsCancellationRequested && IsConnected)
{
ChannelReceivedEventArgs args = null;
WebSocketMessage message = await WebSocketMessageReader.ReadMessageAsync(client, new byte[config.ReceiveLoopBufferSize], config.MaxIncomingMessageSize, token);
if (message.Data != null)
{
if (message.MessageType == WebSocketMessageType.Binary)
{
args = new ChannelReceivedEventArgs(Id, message.Data as byte[]);
}
else if (message.MessageType == WebSocketMessageType.Text)
{
args = new ChannelReceivedEventArgs(Id, Encoding.UTF8.GetBytes(message.Data as string));
}
else
{
State = ChannelState.ClosedReceived;
break;
}
OnReceive?.Invoke(this, args);
}
}
}
catch (Exception ex)
{
Trace.TraceError("Web socket client channel {0} error {1}", Id, ex.Message);
}
await CloseAsync();
}
private void Dispatch_ChannelReceivedEvent(object sender, ChannelReceivedEventArgs e)
{
string[] subs = e.subAddress.Split('/');
//the first substring will be a null character because the format of the 'subaddress
//string is '/<parameter>/....'
switch (subs[1])
{
case "config":
case "mix":
Channels[e.channel - 1].SetValuesFromOSC(subs, e.value);
break;
case "delay":
break;
case "preamp":
Channels[e.channel - 1].m_PreAmp.SetValuesFromOSC(subs, e.value);
break;
case "gate":
Channels[e.channel - 1].m_Gate.SetValuesFromOSC(subs, e.value);
break;
case "dyn":
Channels[e.channel - 1].m_Dynamic.SetValuesFromOSC(subs, e.value);
break;
case "eq":
Channels[e.channel - 1].m_Eq.SetValuesFromOSC(subs, e.value);
break;
case "grp":
break;
}
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
OnMessage?.Invoke(this, new TcpReceivedEventArgs(e.ChannelId, e.Message));
}
public void UpdateFromUI(Constants.COMPONENT_TYPE type, int channel, object newValue, string address)
{
switch (type)
{
case Constants.COMPONENT_TYPE.CHANNEL:
ChannelReceivedEventArgs args = new ChannelReceivedEventArgs();
args.channel = channel;
args.value = newValue;
args.subAddress = address;
args.fromLocal = true;
OnChannelReceivedEvent(args);
break;
case Constants.COMPONENT_TYPE.AUX_INPUT:
AuxinReceivedEventArgs auxArgs = new AuxinReceivedEventArgs();
auxArgs.channel = channel;
auxArgs.value = newValue;
auxArgs.subAddress = address;
auxArgs.fromLocal = true;
OnAuxinReceivedEvent(auxArgs);
break;
case Constants.COMPONENT_TYPE.FXRETURN:
FXReturnReceivedEventArgs fxArgs = new FXReturnReceivedEventArgs();
fxArgs.channel = channel;
fxArgs.value = newValue;
fxArgs.subAddress = address;
fxArgs.fromLocal = true;
OnFXReturnReceivedEvent(fxArgs);
break;
case Constants.COMPONENT_TYPE.MIX_BUS:
BusReceivedEventArgs busArgs = new BusReceivedEventArgs();
busArgs.bus = channel;
busArgs.value = newValue;
busArgs.subAddress = address;
busArgs.fromLocal = true;
OnBusReceivedEvent(busArgs);
break;
case Constants.COMPONENT_TYPE.MATRIX:
MatrixReceivedEventArgs matrixArgs = new MatrixReceivedEventArgs();
matrixArgs.matrix = channel;
matrixArgs.value = newValue;
matrixArgs.subAddress = address;
matrixArgs.fromLocal = true;
OnMatrixReceivedEvent(matrixArgs);
break;
case Constants.COMPONENT_TYPE.MAIN:
MainOutReceivedEventArgs mainArgs = new MainOutReceivedEventArgs();
mainArgs.mainout = channel;
mainArgs.value = newValue;
mainArgs.subAddress = address;
mainArgs.fromLocal = true;
OnMainOutReceivedEvent(mainArgs);
break;
case Constants.COMPONENT_TYPE.DCA:
DCAReceivedEventArgs dcaArgs = new DCAReceivedEventArgs();
dcaArgs.dca = channel;
dcaArgs.value = newValue;
dcaArgs.subAddress = address;
dcaArgs.fromLocal = true;
OnDCAReceivedEvent(dcaArgs);
break;
default:
break;
}
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
Exception error = null;
if (method == "POST" && string.IsNullOrEmpty(resource))
{
error = new Exception("REST adapter cannot send message without resource.");
}
if (method == "POST" && string.IsNullOrEmpty(contentType))
{
error = new Exception("REST adapter cannot send message without content-type.");
}
if (method == "POST" && (e.Message == null || e.Message.Length == 0))
{
error = new Exception("REST adapter cannot send empty message.");
}
if (method == "GET" && (subscriptions == null || subscriptions.Count() == 0))
{
error = new Exception("REST adapter cannot subscribe to '0' subscriptions.");
}
if (error != null)
{
logger?.LogWarningAsync(error.Message).GetAwaiter();
OnError?.Invoke(this, new ProtocolAdapterErrorEventArgs(channel.Id, error));
return;
}
try
{
if (method == "POST")
{
EventMessage message = new EventMessage(contentType, resource, protocolType, e.Message);
if (!string.IsNullOrEmpty(messageUri.CacheKey))
{
message.CacheKey = messageUri.CacheKey;
}
adapter.PublishAsync(message, indexes).GetAwaiter();
logger?.LogDebugAsync("REST adapter published message");
MessageAuditRecord record = new MessageAuditRecord(message.MessageId, identity, channel.TypeId, protocolType.ToString(), e.Message.Length, MessageDirectionType.In, true, DateTime.UtcNow);
messageAuditor?.WriteAuditRecordAsync(record).Ignore();
OnClose?.Invoke(this, new ProtocolAdapterCloseEventArgs(Channel.Id));
}
if (method == "GET")
{
foreach (var subscription in subscriptions)
{
SubscriptionMetadata metadata = new SubscriptionMetadata()
{
Identity = identity,
Indexes = indexes,
IsEphemeral = true
};
adapter.SubscribeAsync(subscription, metadata).GetAwaiter();
}
}
}
catch (Exception ex)
{
logger?.LogErrorAsync($"REST adapter processing error on receive - {ex.Message}");
OnError?.Invoke(this, new ProtocolAdapterErrorEventArgs(channel.Id, ex));
}
}
public void receivedOscMessage(Object sender, OSCPacketReceivedEventArgs e)
{
if (!goodPacket(e.packet))
{
return;
}
if (e.packet.Address.Substring(0, 7) == "/meters")
{
MetersReceivedEventArgs args = new MetersReceivedEventArgs();
switch (e.packet.Address)
{
case "/meters/0":
args.type = Constants.METER_TYPE.HOME;
break;
case "/meters/1":
args.type = Constants.METER_TYPE.CHANNEL_PAGE;
break;
case "/meters/2":
args.type = Constants.METER_TYPE.MIX_BUS;
break;
case "/meters/3":
args.type = Constants.METER_TYPE.AUX_FX;
break;
case "/meters/4":
args.type = Constants.METER_TYPE.IN_OUT;
break;
case "/meters/5":
args.type = Constants.METER_TYPE.SURFACE;
break;
case "/meters/6":
args.type = Constants.METER_TYPE.CHANNEL_DETAIL;
break;
case "/meters/7":
args.type = Constants.METER_TYPE.BUS_SEND;
break;
case "/meters/8":
args.type = Constants.METER_TYPE.MATRIX_SEND;
break;
case "/meters/9":
args.type = Constants.METER_TYPE.EFFECTS;
break;
default:
break;
}
Stream str = (Stream)e.packet.Values[0].getValue();
args.data = new byte[str.Length];
try
{
int i = 0;
str.Position = 0;
while (str.Position < str.Length)
{
args.data[i] = (byte)str.ReadByte();
i++;
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
throw;
} OnMetersReceivedEvent(args);
}
else if (e.packet.Address.Substring(0, 7) == "/config")
{
ConfigReceivedEventArgs args = new ConfigReceivedEventArgs();
args.subAddress = e.packet.Address.Substring(7);
args.value = e.packet.Values[0].getValue();
OnConfigReceivedEvent(args);
}
else if (e.packet.Address.Substring(0, 3) == "/ch")
{
ChannelReceivedEventArgs args = new ChannelReceivedEventArgs();
string tempChannel = e.packet.Address.Substring(4, 2);
args.channel = Convert.ToInt32(tempChannel);
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(6);
OnChannelReceivedEvent(args);
}
else if (e.packet.Address.Substring(0, 6) == "/auxin")
{
AuxinReceivedEventArgs args = new AuxinReceivedEventArgs();
string tempChannel = e.packet.Address.Substring(7, 2);
args.channel = Convert.ToInt32(tempChannel);
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(9);
OnAuxinReceivedEvent(args);
}
else if (e.packet.Address.Substring(0, 6) == "/fxrtn")
{
FXReturnReceivedEventArgs args = new FXReturnReceivedEventArgs();
string tempChannel = e.packet.Address.Substring(7, 2);
args.channel = Convert.ToInt32(tempChannel);
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(9);
OnFXReturnReceivedEvent(args);
}
else if (e.packet.Address.Substring(0, 4) == "/bus")
{
BusReceivedEventArgs args = new BusReceivedEventArgs();
string tempBus = e.packet.Address.Substring(5, 2);
args.bus = Convert.ToInt32(tempBus);
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(7);
OnBusReceivedEvent(args);
}
else if (e.packet.Address.Substring(0, 4) == "/mtx")
{
MatrixReceivedEventArgs args = new MatrixReceivedEventArgs();
string tempMatrix = e.packet.Address.Substring(5, 2);
args.matrix = Convert.ToInt32(tempMatrix);
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(7);
OnMatrixReceivedEvent(args);
}
else if (e.packet.Address.Substring(0, 4) == "/main/st")
{
MainReceivedEventArgs args = new MainReceivedEventArgs();
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(8);
OnMainReceivedEvent(args);
}
else if (e.packet.Address.Substring(0, 4) == "/mono/st")
{
MonoReceivedEventArgs args = new MonoReceivedEventArgs();
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(8);
OnMonoReceivedEvent(args);
}
else if (e.packet.Address.Substring(0, 4) == "/dca")
{
DCAReceivedEventArgs args = new DCAReceivedEventArgs();
string tempDCA = e.packet.Address.Substring(5, 1);
args.dca = Convert.ToInt32(tempDCA);
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(6);
OnDCAReceivedEvent(args);
}
else if (e.packet.Address.Substring(0, 3) == "/fx")
{
EffectReceivedEventArgs args = new EffectReceivedEventArgs();
string tempEffect = e.packet.Address.Substring(4, 1);
args.effect = Convert.ToInt32(tempEffect);
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(5);
OnEffectReceivedEvent(args);
}
else if (e.packet.Address.Substring(0, 8) == "/outputs")
{
if (e.packet.Address.Substring(8, 5) == "/main")
{
MainOutReceivedEventArgs args = new MainOutReceivedEventArgs();
string tempMainOut = e.packet.Address.Substring(13, 2);
args.mainout = Convert.ToInt32(tempMainOut);
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(15);
OnMainOutReceivedEvent(args);
}
else if (e.packet.Address.Substring(8, 4) == "/aux")
{
AuxOutReceivedEventArgs args = new AuxOutReceivedEventArgs();
string tempAuxOut = e.packet.Address.Substring(12, 2);
args.auxout = Convert.ToInt32(tempAuxOut);
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(14);
OnAuxOutReceivedEvent(args);
}
else if (e.packet.Address.Substring(8, 4) == "/p16")
{
P16OutReceivedEventArgs args = new P16OutReceivedEventArgs();
string tempP16Out = e.packet.Address.Substring(12, 2);
args.p16out = Convert.ToInt32(tempP16Out);
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(14);
OnP16OutReceivedEvent(args);
}
else if (e.packet.Address.Substring(8, 4) == "/aes")
{
AESOutReceivedEventArgs args = new AESOutReceivedEventArgs();
string tempAESOut = e.packet.Address.Substring(12, 2);
args.aesout = Convert.ToInt32(tempAESOut);
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(14);
OnAESOutReceivedEvent(args);
}
else if (e.packet.Address.Substring(8, 4) == "/rec")
{
RecordOutReceivedEventArgs args = new RecordOutReceivedEventArgs();
string tempRecordOut = e.packet.Address.Substring(12, 2);
args.recordout = Convert.ToInt32(tempRecordOut);
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(14);
OnRecordOutReceivedEvent(args);
}
}
else if (e.packet.Address.Substring(0, 8) == "/headamp")
{
HeadampReceivedEventArgs args = new HeadampReceivedEventArgs();
string tempHeadamp = e.packet.Address.Substring(9, 3);
args.headamp = Convert.ToInt32(tempHeadamp);
args.value = e.packet.Values[0].getValue();
args.subAddress = e.packet.Address.Substring(12);
OnHeadampReceivedEvent(args);
}
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
}
private static void Channel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
Console.WriteLine($"Received message length {e.Message.Length}");
}
private void SlaveChannel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
OnReceive?.Invoke(this, e);
}
private void Channel_OnReceive(object sender, ChannelReceivedEventArgs e)
{
OnReceived?.Invoke(this, new TcpReceivedEventArgs(this.id, e.Message));
logger?.LogDebug($"Channel '{e.ChannelId}' received message.");
}
