public static KNXmessage CreateResponse(FaHDevice atHomeDevice, KNXAddress AddressToSendTo)
{
KNXmessage kNXmessage = new KNXmessage(knxControlField.KnxPacketType.KNX_PacketLong);
//kNXmessage.HopCount = 6;
kNXmessage.SourceAddress = atHomeDevice.KnxAddress;
uint payloadSize = __FAHChannelStart + (atHomeDevice.ChannelCount * 2);
kNXmessage.TargetAddress = AddressToSendTo;
kNXmessage.Payload.NewPayload(KNXAdpu.ApduType.DeviceDescriptorResponse, payloadSize);
kNXmessage.Payload.ReadablePayloadPacket = new FAHDeviceDescriptorResponse(kNXmessage.Payload);
FAHDeviceDescriptorResponse newPkg = (FAHDeviceDescriptorResponse)kNXmessage.Payload.ReadablePayloadPacket;
newPkg.UpdatePacketSettings();
newPkg.DescriptorType = 3;
newPkg.__UnknownValue0 = new KNXu16SimpleStruct(0x0E, 0x00); //14 00
newPkg.FahDeviceAddress = atHomeDevice.FaHAddress;
newPkg.fahSystemID = atHomeDevice.SystemID;
newPkg.faHDeviceType = atHomeDevice.DeviceType;
newPkg.ConsistencyValue = atHomeDevice.ConsistancyValue;
//kNXmessage.DestinationAddressType = KNXmessage.DestinationAddressFieldType.Group;
for (int i = 1; i <= atHomeDevice.ChannelCount; i++)
{
KNXu16SimpleStruct addr;
if (atHomeDevice.ReadChannelIndentifier(i, out addr))
{
newPkg.SetDeviceChannel((uint)i, addr);
}
//else NULL
}
return(kNXmessage);
}
public static KNXmessage CreateFAHGroupValueResponse(FaHDevice faHDevice, KNXAddress GroupValueAddress, byte[] Payload)
{
if (Payload == null)
{
throw new InvalidDataException();
}
uint plLen;
if (Payload.Length == 1) //Encoded in second byte
{
plLen = 0;
}
else
{ //Not encoded
plLen = (uint)Payload.Length;
}
KNXmessage kNXmessage = new KNXmessage(knxControlField.KnxPacketType.KNX_PacketShort);
kNXmessage.DestinationAddressType = KNXmessage.DestinationAddressFieldType.Group;
kNXmessage.SourceAddress = faHDevice.KnxAddress;
kNXmessage.TargetAddress = GroupValueAddress;
kNXmessage.HopCount = 6;
kNXmessage.Payload.NewPayload(KNXAdpu.ApduType.GroupValueResponse, 2 + plLen);
kNXmessage.Payload.ReadablePayloadPacket = new FAHGroupValueResponse(kNXmessage.Payload);
FAHGroupValueResponse newPkg = (FAHGroupValueResponse)kNXmessage.Payload.ReadablePayloadPacket;
newPkg.MessageData = Payload;
return(kNXmessage);
}
public void SetAddressInformation(KNXAddress Address, FahSystemID fahSystemID)
{
if (this.KnxAddress != Address || fahSystemID != SystemID)
{
this.KnxAddress = Address;
this.SystemID = fahSystemID;
}
}
public override void RemoveKNXAddressToAck(KNXAddress addr)
{
List <byte> addrRemove = new List <byte>(addr.ToByteArray());
addrRemove.Insert(0, KNXNetworkLayer.KNXNetworkLayerTemplate.ADDR_REMOVEKNXADDRTOACK);
addrRemove.Insert(0, KNXNetworkLayer.KNXNetworkLayerTemplate.ADDR_NETWORK_MSG);
PrepareAndSendDataToServerIfConnected(addrRemove.ToArray());
}
public FaHGroupMonitor(KNXNetworkLayerTemplate kNXUart, KNXAddress GroupToMonitor)
{
knxGroupToMonitor = GroupToMonitor;
this.kNXUart = kNXUart;
this.kNXUart.OnKNXMessage += KNXUart_OnKNXMessage;
this.kNXUart.OnKNXEvent += KNXUart_OnKNXEvent;
GetCurrentGroupValueStatus();
}
public bool ButtonClick(SensorActorInterfaceType ActorSensorIndex, byte value)
{
KNXAddress knxAddress = GetGroupValueForChannelType(ActorSensorIndex, value);
if (knxAddress != null)
{
OnGroupWriteEvent?.Invoke(this, knxAddress, new byte[] { value });
}
return(false);
}
public FAHRPPIndividualSerialNumberWrite(KNXPayload payload)
{
addAccountedBytes(0, 2);
deviceAddress = FreeAtHomeDeviceAddress.FromByteArray(payload.ByteData, 2);
addAccountedBytes(2, 6);
kNXAddress = new KNXAddress(payload.ByteData[9], payload.ByteData[8]);
addAccountedBytes(8, 2);
NetworkID = new FahSystemID(payload.ByteData[10], payload.ByteData[11]); //todo Check byte order!
addAccountedBytes(10, 2);
}
private bool GetGroupValueEntry(KNXAddress GroupValue, ref int ChannelID, ref int PropertyID, ChannelType channeltype)
{
if (Channels != null)
{
int chanID = 0;
foreach (var chan in Channels)
{
if (chan != null)
{
int propID = 0;
foreach (var prop in chan.Properties)
{
if (prop != null && prop.ChannelAdresses != null)
{
if (prop.channelType == channeltype)
{
foreach (var chanaddr in prop.ChannelAdresses)
{
if (chanaddr != null && chanaddr.GroupValueAddress != null)
{
foreach (var knxGroupValueAddresses in chanaddr.GroupValueAddress)
{
if (knxGroupValueAddresses != null)
{
if (GroupValue == knxGroupValueAddresses.GetAsReversed())
{
ChannelID = chanID;
PropertyID = propID;
return(true);
}
}
}
}
}
}
}
propID++;
}
}
chanID++;
}
}
return(false);
}
public void ProccessGroupWrite(KNXAddress GroupValue, byte[] data)
{
try
{
if (GroupValue == FaHSceneGroupValueAddress.GetAsReversed())
{
ProcessSceneGroupWrite(data[0]);
return;
}
else
{
//Console.WriteLine(GroupValue);
int ChannelID = -1;
int PropertyID = -1;
//check if it is GroupValueWrite we have to act upon
if (GetGroupValueEntry(GroupValue, ref ChannelID, ref PropertyID, ChannelType.chanInputActorGroupMessage))
{
if (Channels[ChannelID].Properties[PropertyID].PropertyData[1].data.Length == 2)
{
Channels[ChannelID].Properties[PropertyID].PropertyData[1].data[1] = data[0];
this.AutoSave();
}
var OutChan = Channels[ChannelID].Properties[PropertyID + 1];
if (OutChan != null)
{
if (OutChan.channelType == FaHDeviceProperties.ChannelType.chanOutputActorChangedValue)
{
//WritePropertyValue(ChannelID, PropertyID, 1, data);
OnGroupWriteEvent?.Invoke(this, OutChan.ChannelAdresses[1].GroupValueAddress.ElementAt(0).GetAsReversed(), data);
OnActorChange?.Invoke(this, OutChan.ActorSensorIndex, data[0]);
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine("Cannot parse: " + e);
}
}
public void HandleTCPClient(Object obj)
{
TcpClient client = (TcpClient)obj;
IPAddress clientIP = ((IPEndPoint)(client.Client.RemoteEndPoint)).Address;
try
{
while (client.Connected)
{
while (client.Available > 0)
{
using (StreamReader reader = new StreamReader(client.GetStream(), Encoding.UTF8))
{
string line;
while ((line = reader.ReadLine()) != null)
{
try
{
List <byte> knxmsg = new List <byte>(Convert.FromBase64String(line));
if (knxmsg.Count < 3)
{
continue;
}
//Get Checksum and remove from array.
byte checksum = knxmsg.Last();
knxmsg.RemoveAt(knxmsg.Count - 1);
if (KNXUartModule.KNXUartConnection.CheckChecksum(knxmsg, checksum))
{
if (knxmsg[0] == KNXNetworkLayer.KNXNetworkLayerTemplate.ADDR_NETWORK_MSG)
{
Console.Write("knxLayerCommand ");
if (knxmsg[1] == KNXNetworkLayer.KNXNetworkLayerTemplate.ADDR_ADDKNXADDRTOACK)
{
if (knxmsg.Count == 4)
{
KNXAddress k = new KNXAddress(knxmsg.ToArray(), 2);
Console.WriteLine("KnxAddToAck: {0}", k.knxAddress.ToString());
OnKNXAddressAdd(this, k);
}
else
{
Console.Write("KnxAddToAck lenghtfailed");
}
}
else if (knxmsg[1] == KNXNetworkLayer.KNXNetworkLayerTemplate.ADDR_REMOVEKNXADDRTOACK)
{
if (knxmsg.Count == 4)
{
KNXAddress k = new KNXAddress(knxmsg.ToArray(), 2);
Console.WriteLine("KnxRemoveFromAck: {0}", k.knxAddress.ToString());
OnKNXAddressRemove(this, k);
}
else
{
Console.Write("KnxRemoveFromAck lenghtfailed");
}
}
else if (knxmsg[1] == KNXNetworkLayer.KNXNetworkLayerTemplate.ADDR_NETWORK_KEEPALIVE)
{
//Child still alive (timer???)
}
else
{
Console.Write("Unkown");
}
continue;
}
else
{
KNXBaseTypes.KNXmessage kNXmessage = KNXBaseTypes.KNXmessage.fromByteArray(knxmsg.ToArray(), DateTime.Now);
OnKNXMessage?.Invoke(this, kNXmessage);
Console.Write("OK: ");
Console.WriteLine(kNXmessage.ToHexString());
}
}
else
{
Console.Write("CheckSumMismatch: " + line);
}
}
catch
{
Console.WriteLine("Cannot process Base64: " + line);
}
}
}
}
Thread.Sleep(1);
}
}
catch (Exception e)
{
Console.WriteLine("Client Closed: {0}", e.ToString());
}
Console.WriteLine("Client Closed");
onClientDisconnect?.Invoke(this, clientIP);
if (client != null)
{
if (client.Connected)
{
client.Close();
}
}
lock (tLockClientList)
{
tcpClients.Remove(client);
}
}
public bool RemoveChannelConnection(int ChannelIndex, int propIndex, byte connectionIndex, KNXAddress GroupAdress, out bool moreIndices)
{
moreIndices = false;
try
{
var ChannelAdresses = this.Channels[ChannelIndex].Properties[propIndex].ChannelAdresses[connectionIndex];
if (ChannelAdresses == null)
{
return(false);
}
foreach (var Channel in ChannelAdresses.GroupValueAddress)
{
if (Channel == GroupAdress)
{
ChannelAdresses.GroupValueAddress.Remove(Channel);
moreIndices = (this.Channels[ChannelIndex].Properties.Length > propIndex);
return(true);
}
}
}
catch { }
return(false);
}
public KNXmessage ProcessRebootPackage(FaHDevice atHomeDevice, KNXAddress AddressToSendTo)
{
return(null);
}
static void Main(string[] args)
{
//Can be used to replay log messages to an existing device
//fahDevToReturn = FaHDevice.DeserializeFromFile(@"ABB700C730A9-learn-metvloeren.json", true);
//fahDevToLearn = FaHDevice.DeserializeFromFile(@"ABB700C730A9-learn-metvloeren.json", true);
Console.SetWindowSize(Console.WindowWidth * 2, Console.WindowHeight);
stdOut = new ReadWriteKNXDataLog("Output_" + DateTime.Now.Ticks + ".txt", true);
//stdIn = new ReadWriteKNXDataLog(@"replay_log.txt", false);
FaHTCPClient.TCPknxClient kNXUart = new FaHTCPClient.TCPknxClient("172.16.16.20", 9998);
/*KNXUartModule.KNXUartConnection kNXUart = new KNXUartConnection(AppSettings.Default.ComPort)
* {
* AllowWrite = AppSettings.Default.KNXWriteEnabled
* };*/
kNXUart.OnKNXMessage += KNXUart_OnKNXMessage;
kNXUart.OnKNXEvent += KNXUart_OnKNXEvent;
//kNXUart.ResetAndInit();
/*
* int i = 0;
* while (true)
* {
* KNXmessage k = stdIn.ReadNextMessage();
* if (k == null) break;
* if (i > 0)
* KNXUart_OnKNXMessage(null, k, KNXUartConnection.UartEvents.GotKNXPacket);
*
* i++;
* }*/
while (true)
{
string ret = Console.ReadLine();
if (ret.ToLower() == "exit")
{
Console.WriteLine("Exit Accepted");
return;
}
if (ret.ToLower() == "x")
{
//[0x00 - 0x01] [0x14 - 0xC8] 0x00 0x80 0x66
//[0xEB - 0x01] [0xB5 - 0x50] 0x00[0x80 | 0x09]
//[0x00 - 0x01] [0x14 - 0xC8] 0x00 0x80 0x59
//[0x00 - 0x01] [0x3D - 0x26] 0x00 0x80 0x45 0x1E 0xD1 0x58
FaHDevice nulldev = new FaHDevice();
nulldev.KnxAddress.u16valueHigh = 1;
KNXAddress TargetGroupValue = new KNXAddress(0x14, 0xC8);
byte[] data = new byte[] { 0x66 };
KNXmessage GroupWriteMessage = FAHGroupValueWrite.CreateFAHGroupValueWrite(nulldev, TargetGroupValue, data, false);
KNXUart_OnKNXMessage(null, GroupWriteMessage, KNXNetworkLayerTemplate.KnxPacketEvents.GotKNXPacket);
kNXUart.SendKNXMessage(GroupWriteMessage);
//*************************************************************
KNXAddress TargetGroupValue1 = new KNXAddress(0x3D, 0x26);
byte[] data1 = new byte[] { 0x45, 0x1E, 0xD1, 0x66 };
KNXmessage GroupWriteMessage1 = FAHGroupValueWrite.CreateFAHGroupValueWrite(nulldev, TargetGroupValue1, data1, true);
KNXUart_OnKNXMessage(null, GroupWriteMessage1, KNXNetworkLayerTemplate.KnxPacketEvents.GotKNXPacket);
kNXUart.SendKNXMessage(GroupWriteMessage1);
//**********************************************************************//
}
if (ret.ToLower() == "+")
{
FaHDevice nulldev = new FaHDevice();
KNXAddress TargetGroupValue = new KNXAddress(0xC6, 0x4D);
byte[] data = new byte[] { 0x01 };
KNXmessage GroupWriteMessage = FAHGroupValueWrite.CreateFAHGroupValueWrite(nulldev, TargetGroupValue, data, true);
KNXUart_OnKNXMessage(null, GroupWriteMessage, KNXNetworkLayerTemplate.KnxPacketEvents.GotKNXPacket);
kNXUart.SendKNXMessage(GroupWriteMessage);
//2021 - 10 - 03 11:08:33.826; GroupValueWrite KNX_PRIORITY_HIGH[NoExtdFrame] [0x00 - 0x01] [0x3D - 0x26] 0x00 0x80 0x06 0xB0 0xFF 0x57
}
if (ret.ToLower() == "-")
{
FaHDevice nulldev = new FaHDevice();
KNXAddress TargetGroupValue = new KNXAddress(0xC6, 0x4D);
byte[] data = new byte[] { 0x00 };
KNXmessage GroupWriteMessage = FAHGroupValueWrite.CreateFAHGroupValueWrite(nulldev, TargetGroupValue, data, true);
KNXUart_OnKNXMessage(null, GroupWriteMessage, KNXNetworkLayerTemplate.KnxPacketEvents.GotKNXPacket);
//[0xC6 - 0x4D] 0x00[0x80 | 0x01]
kNXUart.SendKNXMessage(GroupWriteMessage);
//2021 - 10 - 03 11:08:33.826; GroupValueWrite KNX_PRIORITY_HIGH[NoExtdFrame] [0x00 - 0x01] [0x3D - 0x26] 0x00 0x80 0x06 0xB0 0xFF 0x57
}
Console.WriteLine("# " + ret);
stdOut.WriteComment(ret);
}
}
public virtual void RemoveKNXAddressToAck(KNXAddress addr)
{
}
public virtual void AddKNXAddressToAck(KNXAddress addr)
{
}
