protected override byte[] CreateActionDatagram(KnxAddress destinationAddress, byte[] data)
{
lock (KnxConnectionTunneling.SequenceNumberLock)
{
try
{
var dataLength = KnxHelper.GetDataLength(data);
// HEADER
var datagram = new byte[10];
datagram[00] = 0x06;
datagram[01] = 0x10;
datagram[02] = 0x04;
datagram[03] = 0x20;
var totalLength = BitConverter.GetBytes(dataLength + 20);
datagram[04] = totalLength[1];
datagram[05] = totalLength[0];
datagram[06] = 0x04;
datagram[07] = KnxConnectionTunneling.ChannelId;
datagram[08] = KnxConnectionTunneling.GenerateSequenceNumber();
datagram[09] = 0x00;
return(CreateActionDatagramCommon(destinationAddress, data, datagram));
}
catch
{
KnxConnectionTunneling.RevertSingleSequenceNumber();
return(null);
}
}
}
protected override byte[] CreateRequestStatusDatagram(KnxAddress destinationAddress)
{
lock (KnxConnectionTunneling.SequenceNumberLock)
{
try
{
// HEADER
var datagram = new byte[21];
datagram[00] = 0x06;
datagram[01] = 0x10;
datagram[02] = 0x04;
datagram[03] = 0x20;
datagram[04] = 0x00;
datagram[05] = 0x15;
datagram[06] = 0x04;
datagram[07] = KnxConnectionTunneling.ChannelId;
datagram[08] = KnxConnectionTunneling.GenerateSequenceNumber();
datagram[09] = 0x00;
return(CreateRequestStatusDatagramCommon(destinationAddress, datagram, 10));
}
catch
{
KnxConnectionTunneling.RevertSingleSequenceNumber();
return(null);
}
}
}
/// <summary>
/// Send an int value as data to specified address
/// </summary>
/// <param name="address">KNX Address</param>
/// <param name="data">Int value</param>
/// <exception cref="InvalidKnxDataException"></exception>
public void Action(KnxAddress address, int data)
{
var val = new byte[2];
if (data <= 255)
{
val[0] = 0x00;
val[1] = (byte)data;
}
else if (data <= 65535)
{
val[0] = (byte)data;
val[1] = (byte)(data >> 8);
}
else
{
// allowing only positive integers less than 65535 (2 bytes), maybe it is incorrect...???
throw new InvalidKnxDataException(data.ToString());
}
if (val == null)
{
throw new InvalidKnxDataException(data.ToString());
}
Action(address, val);
}
internal KnxControlField2(KnxAddress address)
{
if (address is KnxGroupAddress)
{
DestinationAddressType = KnxDestinationAddressType.Group;
HopCount = DEFAULT_HOP_COUNT_GROUP;
}
}
internal KnxStatusArgs(
KnxAddress sourceAddress,
KnxAddress destinationAddress,
KnxControlField1 controlField1,
KnxControlField2 controlField2,
byte[] state) : base(sourceAddress, destinationAddress, controlField1, controlField2, state)
{
}
/// <summary>
/// Send a request to KNX asking for specified address current status
/// </summary>
/// <param name="address"></param>
public void RequestStatus(KnxAddress address)
{
Logger.Debug(ClassName, "Sending request status to {0}.", address);
_lockManager.PerformLockedOperation(() => KnxSender.RequestStatus(address));
Logger.Debug(ClassName, "Sent request status to {0}.", address);
}
public void SetValue_InputValue_ExpectedBusDeviceSet(byte[] input, int expected)
{
KnxAddress addr = new KnxAddress()
{
Value = input
};
Assert.Equal(expected, addr.BusDevice);
}
public void SetValue_InputValue_ExpectedAreaSet(byte[] input, int expected)
{
KnxAddress addr = new KnxAddress()
{
Value = input
};
Assert.Equal(expected, addr.Area);
}
public DIBDeviceInfo(byte descriptionType, KnxMedium knxMedium, DeviceStatus deviceStatus, KnxAddress knxAddress, ProjectInstallationIdentifier projectInstallationIdentifier, sbyte[] knxNetIpDeviceSerialNumber, IPAddress knxNetIpDeviceMulticastAddress, MACAddress knxNetIpDeviceMacAddress, sbyte[] deviceFriendlyName)
{
DescriptionType = descriptionType;
KnxMedium = knxMedium;
DeviceStatus = deviceStatus;
KnxAddress = knxAddress;
ProjectInstallationIdentifier = projectInstallationIdentifier;
KnxNetIpDeviceSerialNumber = knxNetIpDeviceSerialNumber;
KnxNetIpDeviceMulticastAddress = knxNetIpDeviceMulticastAddress;
KnxNetIpDeviceMacAddress = knxNetIpDeviceMacAddress;
DeviceFriendlyName = deviceFriendlyName;
}
internal KnxEventArgs(
KnxAddress sourceAddress,
KnxAddress destinationAddress,
KnxControlField1 controlField1,
KnxControlField2 controlField2,
byte[] state)
{
SourceAddress = sourceAddress;
DestinationAddress = destinationAddress;
ControlField1 = controlField1;
ControlField2 = controlField2;
State = state;
}
public KnxNetIpConnectionString(string connectionString) : this()
{
try
{
var str = connectionString.Trim('{', '}');
var kvpairs = str.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var kv in kvpairs)
{
if (kv.Contains("InternalUrl"))
{
InternalAddress = kv.Split('=')[1];
}
if (kv.Contains("ExternalUrl"))
{
ExternalAddress = kv.Split('=')[1];
}
if (kv.Contains("InternalProtocol"))
{
Enum.TryParse(kv.Split('=')[1], true, out _internalProtocol);
}
if (kv.Contains("ExternalProtocol"))
{
Enum.TryParse(kv.Split('=')[1], true, out _externalProtocol);
}
if (kv.Contains("InternalConnectionReleaseDelay"))
{
Enum.TryParse(kv.Split('=')[1], true, out _internalConnectionReleaseDelay);
}
if (kv.Contains("ExternalConnectionReleaseDelay"))
{
Enum.TryParse(kv.Split('=')[1], true, out _externalConnectionReleaseDelay);
}
if (kv.Contains("InternalMulticastUrl"))
{
InternalMulticastUrl = kv.Split('=')[1];
}
if (kv.Contains("DeviceAddress"))
{
var da = KnxAddress.ParseDevice(kv.Split('=')[1]);
DeviceMain = da.Area;
DeviceMiddle = da.Line;
DeviceSub = da.Device;
}
}
}
catch (Exception exception)
{
throw new ArgumentException("ConnectionString is not formated correctly.", exception);
}
}
public CEMIFrameData(bool repeated, CEMIPriority priority, bool acknowledgeRequested, bool errorFlag, KnxAddress sourceAddress, sbyte[] destinationAddress, bool groupAddress, byte hopCount, byte dataLength, TPCI tcpi, byte counter, APCI apci, sbyte dataFirstByte, sbyte[] data, byte crc)
: base(repeated, priority, acknowledgeRequested, errorFlag)
{
SourceAddress = sourceAddress;
DestinationAddress = destinationAddress;
GroupAddress = groupAddress;
HopCount = hopCount;
DataLength = dataLength;
Tcpi = tcpi;
Counter = counter;
Apci = apci;
DataFirstByte = dataFirstByte;
Data = data;
Crc = crc;
}
protected override byte[] CreateRequestStatusDatagram(KnxAddress destinationAddress)
{
// TODO: Test this
// HEADER
var datagram = new byte[17];
datagram[00] = 0x06;
datagram[01] = 0x10;
datagram[02] = 0x05;
datagram[03] = 0x30;
datagram[04] = 0x00;
datagram[05] = 0x11;
return(CreateRequestStatusDatagramCommon(destinationAddress, datagram, 6));
}
/// <summary>
/// Send a byte array value as data to specified address
/// </summary>
/// <param name="address">KNX Address</param>
/// <param name="data">Byte array value</param>
/// <param name="addTruncateByte">adds extra byte to chop off for payload</param>
public void Action(KnxAddress address, byte[] data, bool addTruncateByte = true)
{
if (addTruncateByte)
{
// reverse bytes temporary to add byte in front
Array.Reverse(data);
Array.Resize(ref data, data.Length + 1);
data[data.Length - 1] = 0x00;
Array.Reverse(data);
}
Logger.Debug(ClassName, "Sending 0x{0} to {1}.", BitConverter.ToString(data), address);
_lockManager.PerformLockedOperation(() => KnxSender.Action(address, data));
Logger.Debug(ClassName, "Sent 0x{0} to {1}.", BitConverter.ToString(data), address);
}
protected override byte[] CreateActionDatagram(KnxAddress destinationAddress, byte[] data)
{
var dataLength = KnxHelper.GetDataLength(data);
// HEADER
var datagram = new byte[6];
datagram[0] = 0x06;
datagram[1] = 0x10;
datagram[2] = 0x05;
datagram[3] = 0x30;
var totalLength = BitConverter.GetBytes(dataLength + 16);
datagram[4] = totalLength[1];
datagram[5] = totalLength[0];
return(CreateActionDatagramCommon(destinationAddress, data, datagram));
}
/// <summary>
/// Send a string value as data to specified address
/// </summary>
/// <param name="address">KNX Address</param>
/// <param name="data">String value</param>
/// <exception cref="InvalidKnxDataException"></exception>
public void Action(KnxAddress address, string data)
{
byte[] val;
try
{
val = Encoding.ASCII.GetBytes(data);
}
catch
{
throw new InvalidKnxDataException(data);
}
if (val == null)
{
throw new InvalidKnxDataException(data);
}
Action(address, val);
}
/// <summary>
/// Send a bit value as data to specified address
/// </summary>
/// <param name="address">KNX Address</param>
/// <param name="data">Bit value</param>
/// <exception cref="InvalidKnxDataException"></exception>
public void Action(KnxAddress address, bool data)
{
byte[] val;
try
{
val = new[] { Convert.ToByte(data) };
}
catch
{
throw new InvalidKnxDataException(data.ToString());
}
if (val == null)
{
throw new InvalidKnxDataException(data.ToString());
}
Action(address, val, addTruncateByte: false);
}
public void ParseAddressTest()
{
var address = KnxAddress.ParseLogical("1/2/3");
Assert.IsNotNull(address);
address = KnxAddress.ParseLogical("15-7/3");
Assert.IsNotNull(address);
address = KnxAddress.ParseLogical("15-7-255");
Assert.IsNotNull(address);
try
{
address = KnxAddress.ParseLogical("hello world");
Assert.Fail("Exception should be trown.");
}
catch (FormatException)
{
}
}
public CEMIDataFrame(bool standardFrame, bool polling, bool notRepeated, bool notAckFrame, CEMIPriority priority, bool acknowledgeRequested, bool errorFlag, bool groupDestinationAddress, byte hopCount, byte extendedFrameFormat, KnxAddress sourceAddress, sbyte[] destinationAddress, byte dataLength, TPCI tcpi, byte counter, APCI apci, sbyte dataFirstByte, sbyte[] data)
{
StandardFrame = standardFrame;
Polling = polling;
NotRepeated = notRepeated;
NotAckFrame = notAckFrame;
Priority = priority;
AcknowledgeRequested = acknowledgeRequested;
ErrorFlag = errorFlag;
GroupDestinationAddress = groupDestinationAddress;
HopCount = hopCount;
ExtendedFrameFormat = extendedFrameFormat;
SourceAddress = sourceAddress;
DestinationAddress = destinationAddress;
DataLength = dataLength;
Tcpi = tcpi;
Counter = counter;
Apci = apci;
DataFirstByte = dataFirstByte;
Data = data;
}
private static void Status(KnxConnection connection, KnxAddress address, byte[] state) => Print(connection, address, state);
/// <summary>
/// Send a byte value as data to specified address
/// </summary>
/// <param name="address">KNX Address</param>
/// <param name="data">byte value</param>
public void Action(KnxAddress address, byte data)
{
Action(address, new byte[] { 0x00, data });
}
public ConnectionResponseDataBlockTunnelConnection(KnxAddress knxAddress)
{
KnxAddress = knxAddress;
}
public async Task SendKnxMessage()
{
var target = new KnxNetIpTunnelingClient(new IPEndPoint(IPAddress.Parse("10.10.10.11"), 3671), KnxAddress.Device(1, 1, 2));
try
{
await target.Connect();
var message = new KnxMessage
{
MessageType = MessageType.Write,
MessageCode = MessageCode.Request,
Priority = MessagePriority.Auto,
SourceAddress = new KnxDeviceAddress(1, 1, 2),
DestinationAddress = new KnxLogicalAddress(1, 1, 28),
TransportLayerControlInfo = TransportLayerControlInfo.UnnumberedDataPacket,
DataPacketCount = 0,
Payload = new DptBoolean(false).Payload
};
await target.SendMessage(message);
// test for simpler SendMessage calls
//target.Write(KnxAddress.Logical(9, 3, 0), (new DptTime(new TimeSpan(13, 36, 00), DayOfWeek.Monday)));
}
finally
{
target.Dispose();
}
}
public async Task ConnectTest()
{
using (var target = new KnxNetIpTunnelingClient(new IPEndPoint(IPAddress.Parse("10.10.10.11"), 3671), KnxAddress.Device(1, 1, 2)))
{
await target.Connect();
}
}
private static void Print(KnxConnection connection, KnxAddress knxAddress, byte[] state)
{
const int categoryWidth = 15;
const int descriptionWidth = -60;
var address = knxAddress.ToString();
if (Switches.TryGetValue(address, out var description))
{
var functionalToggle = Category1_SingleBit.parseSingleBit(state[0]);
Console.WriteLine($"{"[ON/OFF]", categoryWidth} {description, descriptionWidth} ({(functionalToggle.Exists() ? functionalToggle.Value.Text : "N/A")})");
}
else if (Toggles.TryGetValue(address, out description))
{
var functionalToggle = Category1_SingleBit.parseSingleBit(state[0]);
Console.WriteLine($"{"[TRUE/FALSE]", categoryWidth} {description, descriptionWidth} ({(functionalToggle.Exists() ? functionalToggle.Value.Text : "N/A")})");
}
else if (Percentages.TryGetValue(address, out description))
{
var functionalPercentage = Category5_Scaling.parseScaling(0, 100, state[0]);
Console.WriteLine($"{"[PERCENTAGE]", categoryWidth} {description, descriptionWidth} ({functionalPercentage} %)");
}
else if (Duration.TryGetValue(address, out description))
{
var functionalDuration = Category7_2ByteUnsignedValue.parseTwoByteUnsigned(1, state[0], state[1]);
Console.WriteLine($"{"[DURATION]", categoryWidth} {description, descriptionWidth} ({functionalDuration} h)");
}
else if (Current.TryGetValue(address, out description))
{
var functionalCurrent = Category7_2ByteUnsignedValue.parseTwoByteUnsigned(1, state[0], state[1]);
Console.WriteLine($"{"[ENERGY]", categoryWidth} {description, descriptionWidth} ({functionalCurrent} mA)");
}
else if (Temperatures.TryGetValue(address, out description))
{
var temp = connection.FromDataPoint("9.001", state); // (decimal)
var functionalTemp = Category9_2ByteFloatValue.parseTwoByteFloat(state[0], state[1]);
Console.WriteLine($"{"[TEMP]", categoryWidth} {description, descriptionWidth} (C#: {temp} °C) (F#: {functionalTemp} °C)");
}
else if (LightStrength.TryGetValue(address, out description))
{
var functionalLightStrength = Category9_2ByteFloatValue.parseTwoByteFloat(state[0], state[1]);
Console.WriteLine($"{"[LUX]", categoryWidth} {description, descriptionWidth} ({functionalLightStrength} Lux)");
}
else if (Times.TryGetValue(address, out description))
{
var functionalTime = Category10_Time.parseTime(state[0], state[1], state[2]);
Console.WriteLine($"{"[TIME]", categoryWidth} {description, descriptionWidth} ({(functionalTime.Item1.Exists() ? functionalTime.Item1.Value.Text : string.Empty)}, {functionalTime.Item2:c})");
}
else if (EnergyWattHour.TryGetValue(address, out description))
{
var wattHour = connection.FromDataPoint("13.010", state); // (int)
var functionalWattHour = Category13_4ByteSignedValue.parseFourByteSigned(state[0], state[1], state[2], state[3]);
Console.WriteLine($"{"[ENERGY]", categoryWidth} {description, descriptionWidth} (C#: {wattHour} Wh) (F#: {functionalWattHour} Wh)");
}
else if (Dates.TryGetValue(address, out description))
{
var date = (DateTime)connection.FromDataPoint("11.001", state); // (DateTime)
var functionalDate = Category11_Date.parseDate(state[0], state[1], state[2]);
Console.WriteLine($"{"[DATE]", categoryWidth} {description, descriptionWidth} (C#: {date:dd/MM/yyyy}) (F#: {functionalDate:dd/MM/yyyy})");
}
else if (Speed.TryGetValue(address, out description))
{
var speed = connection.FromDataPoint("9.005", state); // (decimal)
var functionalSpeed = Category9_2ByteFloatValue.parseTwoByteFloat(state[0], state[1]);
Console.WriteLine($"{"[SPEED]",categoryWidth} {description, descriptionWidth} (C#: {speed} m/s) (F#: {functionalSpeed} m/s)");
}
else
{
_logFile.WriteLine("{0} - {1}", address, BitConverter.ToString(state));
}
}
