You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

793 lines
25 KiB

using JiLinApp.Docking.VibrateAlarm;
using System.Collections.Concurrent;
using System.Net;
using System.Timers;
using Timer = System.Timers.Timer;
namespace JiLinApp.Docking.FenceAlarm;
public class UdpManager
{
#region Fields
private UdpServer Server { get; set; }
private UdpManagerConfig Config { get; set; }
private Timer PtzCheckTimer { get; } = new();
private ConcurrentDictionary<int, UdpAlarmHost> DeviceDict { get; } = new();
#region Event
public delegate void FenceUdpDeviceStateEvent(UdpAlarmHost device);
public delegate void FenceUdpSectorStateEvent(SectorState sector);
public delegate void FenceUdpAlarmEvent(UdpAlarmHostMessage msg);
public event FenceUdpDeviceStateEvent? OnFenceUdpDeviceState;
public event FenceUdpSectorStateEvent? OnFenceUdpSectorState;
public event FenceUdpAlarmEvent? OnFenceUdpAlarm;
#endregion Event
#endregion Fields
public UdpManager()
{
}
#region Server
public void Start(UdpManagerConfig config)
{
if (IsRunning()) return;
Server = new(config.ServerPort);
Server.DatagramReceived += Server_DatagramReceived;
Server.Start();
PtzCheckTimer.Interval = 3000;//3s
PtzCheckTimer.Elapsed += PTZCheckTimer_Elapsed;
PtzCheckTimer.Enabled = true;
Config = config;
}
public void Stop()
{
if (!IsRunning()) return;
try
{
Server.Stop();
}
finally
{
Server.DatagramReceived -= Server_DatagramReceived;
Server = null;
DeviceDict.Clear();
PtzCheckTimer.Stop();
PtzCheckTimer.Elapsed -= PTZCheckTimer_Elapsed;
}
}
public bool IsRunning()
{
return Server != null && Server.IsRunning();
}
#endregion Server
#region Events
/// <summary>
/// 计时判断设备是否在线,若超过规定时间没有新消息发来,则设备离线
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void PTZCheckTimer_Elapsed(object? sender, ElapsedEventArgs e)
{
foreach (var key in DeviceDict.Keys)
{
UdpAlarmHost device = DeviceDict[key];
if (device.KeepLive > 0) device.KeepLive--;
else ProcessDeviceStateEvent(ref device, 0, device.DefenceState);
}
}
private void Server_DatagramReceived(object? sender, UdpDatagramReceivedEventArgs<byte[]> e)
{
IPEndPoint ipep = e.Ipep;
//解码
//byte[] msg = e.Datagram;
byte[] msg = AlarmEncode.DecodeMessage(e.Datagram);
bool vaild = msg.Length >= 8 && msg[2] == AlarmEncode.Head[0] && msg[3] == AlarmEncode.Head[1];
Console.WriteLine("Recv from {0}:{1} => {2}, {3}, {4}", ipep.Address.ToString(), ipep.Port, DataMessage.ToHexString(e.Datagram), DataMessage.ToHexString(msg), vaild);
if (!vaild) return;
//解析
DeviceCmd deviceCmd = (DeviceCmd)msg[4];
switch (deviceCmd)
{
case DeviceCmd.HeartBeatCmd://心跳信息
AnalysisHeartMessage(ipep, msg);
break;
case DeviceCmd.AlarmCmd://报警信息
AnalysisAlarmMessage(ipep, msg);
break;
case DeviceCmd.AllSectorStateCmd://防区信息
AnalysisAllSectorMessage(ipep, msg);
break;
case DeviceCmd.RtSectorStateCmd://张力防区信息
AnalysisSectorMessage(ipep, msg);
break;
case DeviceCmd.MaxSectorTotalCmd://最大防区信息
AnalysisMaxSectorMessage(ipep, msg);
break;
case DeviceCmd.BackSettingsCmd://返回报警主机设置参数回服务器,无需解析
break;
default:
break;
}
SendOk(ipep);
}
#endregion Events
#region Analysis
private void AnalysisHeartMessage(IPEndPoint ipep, byte[] msg)
{
string ip = ipep.Address.ToString();
int deviceId = ByteToInt(msg, 5);
if (!TryGetDevice(deviceId, out UdpAlarmHost device))
{
device = new()
{
DeviceId = deviceId,
Ip = ip,
Port = ipep.Port,
GroupId = ByteToInt(msg, 9),
UserId = ByteToInt(msg, 13),
OnlineState = 1,
KeepLive = Config.DeviceHeartKeep
};
AddDevice(deviceId, ref device);
}
byte defenceState = msg[17];
//在线状态
device.KeepLive = Config.DeviceHeartKeep;
ProcessDeviceStateEvent(ref device, 1, defenceState);
device.WorkState = msg[18];
//设备状态1
device.CellState = GetBit(msg[19], 0);
device.ElectricityState = GetBit(msg[19], 1);
device.FuseState = GetBit(msg[19], 2);
device.SectorState = GetBit(msg[19], 3);
device.CellTestState = GetBit(msg[19], 4);
device.DeviceElectricityState = GetBit(msg[19], 5);
device.SoundState = GetBit(msg[19], 6);
device.TestState = GetBit(msg[19], 7);
//设备状态2
device.CriticalAlarmState = GetBit(msg[20], 0);
device.FireAlarmState = GetBit(msg[20], 1);
device.StealAlarmState = GetBit(msg[20], 2);
device.DeviceFireAlarmState = GetBit(msg[20], 3);
device.DeviceAlarmState = GetBit(msg[20], 4);
device.DeviceBywayState = GetBit(msg[20], 5);
device.BusOfflineState = GetBit(msg[20], 6);
device.NetOfflineState = GetBit(msg[20], 7);
//设备状态3,4暂不使用
device.DevideType = msg[23];
device.SignalIntensity = msg[24];
device.SectorTotal = msg[25];
}
private void AnalysisAlarmMessage(IPEndPoint ipep, byte[] msg)
{
string ip = ipep.Address.ToString();
int deviceId = ByteToInt(msg, 5);
if (!TryGetDevice(deviceId, out _))
{
UdpAlarmHost device = new()
{
DeviceId = deviceId,
Ip = ip,
Port = ipep.Port,
GroupId = ByteToInt(msg, 9),
UserId = ByteToInt(msg, 13),
OnlineState = 1,
KeepLive = Config.DeviceHeartKeep
};
AddDevice(deviceId, ref device);
}
string alarmTime = $"20{GetBCD(msg[17])}-{GetBCD(msg[18])}-{GetBCD(msg[19])} " +
$"{GetBCD(msg[20])}:{GetBCD(msg[21])}:{GetBCD(msg[22])}";
string CID = GetCID(msg[23]) + GetCID(msg[24]) + GetCID(msg[25]) + GetCID(msg[26]);
int sectorId = msg[29] + msg[30] * 256;
UdpAlarmHostMessage alarm = new()
{
DeviceId = deviceId,
Ip = ip,
GroupId = ByteToInt(msg, 9),
UserId = ByteToInt(msg, 13),
AlarmTime = alarmTime,
//CID暂定
CID = CID,
LinkOut = msg[27] + msg[28] * 256,
SectorId = sectorId,
SubSectorId = msg[31] + msg[32] * 256,
ExtendArgs = msg[33].ToString("X2") + " " + msg[34].ToString("X2") + " " + msg[35].ToString("X2"),
};
ReportAlarm(alarm);
}
private void AnalysisAllSectorMessage(IPEndPoint ipep, byte[] msg)
{
string ip = ipep.Address.ToString();
int deviceId = ByteToInt(msg, 5);
if (!TryGetDevice(deviceId, out UdpAlarmHost device))
{
device = new()
{
DeviceId = deviceId,
Ip = ip,
Port = ipep.Port,
GroupId = ByteToInt(msg, 9),
UserId = ByteToInt(msg, 13),
OnlineState = 1,
KeepLive = Config.DeviceHeartKeep
};
AddDevice(deviceId, ref device);
}
device.SectorTotal = msg[17] * 256 + msg[18];
int sectorNum = msg[19], startIndex = msg[20];
for (int i = 0; i < sectorNum; i++)
{
int sectorId = i + startIndex;//防区序号
int pos = 21 + i;//防区信息所在byte数组未知
SectorState curSector = new(device.DeviceId, sectorId, msg[pos]);
if (device.SectorDict.TryGetValue(sectorId, out SectorState? sector))
{
ProcessSectorStateEvent(ref sector, curSector.State);
}
else
{
sector = curSector;
device.SectorDict[sector.Id] = sector;
//ProcessSectorStateEvent(ref sector);
}
}
}
private void AnalysisSectorMessage(IPEndPoint ipep, byte[] msg)
{
//东北没有张力防区,暂不解析
string ip = ipep.Address.ToString();
int deviceId = ByteToInt(msg, 5);
if (!TryGetDevice(deviceId, out UdpAlarmHost device))
{
device = new()
{
DeviceId = deviceId,
Ip = ip,
Port = ipep.Port,
GroupId = ByteToInt(msg, 9),
UserId = ByteToInt(msg, 13),
OnlineState = 1,
KeepLive = Config.DeviceHeartKeep
};
AddDevice(deviceId, ref device);
}
}
private void AnalysisMaxSectorMessage(IPEndPoint ipep, byte[] msg)
{
string ip = ipep.Address.ToString();
int deviceId = ByteToInt(msg, 5);
if (!TryGetDevice(deviceId, out UdpAlarmHost device))
{
device = new()
{
DeviceId = deviceId,
Ip = ip,
Port = ipep.Port,
GroupId = ByteToInt(msg, 9),
UserId = ByteToInt(msg, 13),
OnlineState = 1,
KeepLive = Config.DeviceHeartKeep
};
AddDevice(deviceId, ref device);
}
device.SectorTotal = msg[17] * 256 + msg[18];
}
private void ProcessDeviceStateEvent(ref UdpAlarmHost device, int onlineState, int defenceState)
{
bool reportFlag = false;
if (device.OnlineState != onlineState)
{
if (onlineState == 0 && device.KeepLive < 0)
{
reportFlag = true;
device.OnlineState = onlineState;
}
else if (onlineState == 1 && device.KeepLive >= 0)
{
reportFlag = true;
device.OnlineState = onlineState;
}
}
if (device.DefenceState != defenceState)
{
reportFlag = true;
device.DefenceState = defenceState;
}
if (reportFlag) ReportDeviceState(device);
}
private void ProcessSectorStateEvent(ref SectorState sector, int state)
{
if (sector.State != state)
{
sector.State = state;
ReportSectorState(sector);
}
}
private void ReportDeviceState(UdpAlarmHost device)
{
OnFenceUdpDeviceState?.Invoke(device);
}
private void ReportSectorState(SectorState sector)
{
OnFenceUdpSectorState?.Invoke(sector);
}
private void ReportAlarm(UdpAlarmHostMessage msg)
{
OnFenceUdpAlarm?.Invoke(msg);
}
#endregion Analysis
#region Send
/// <summary>
/// 应答
/// </summary>
/// <param name="ipep"></param>
/// <returns></returns>
private bool SendOk(IPEndPoint ipep)
{
if (!IsRunning()) return false;
byte[] bytes = new byte[] { 0x08, 0x12, 0xF0, 0xFA, 0x8F, 0x06, 0x6B, 0x0D };
////byte[] bytes = AlarmEncode.GetSendMessage(0x8F, Array.Empty<byte>());
return Server.SendMessage(ipep.Address.ToString(), ipep.Port, AlarmEncode.EncodeMessage(bytes));
//Console.WriteLine();
//byte[] bytes = new byte[] {
// 0x24, 0x12, 0xF0, 0xFA,
// 0x02,
// 0x77, 0x35, 0x94, 0x01,
// 0x07, 0x5B, 0xCD, 0x15,
// 0x00, 0x01, 0xE2, 0x40,
// 0x23, 0x05, 0x18, 0x17, 0x12, 0x34,
// 0x01, 0x00, 0x00, 0x01,
// 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
// 0x0F, 0x41, 0x0D };
//Console.WriteLine(DataMessage.ToHexString(AlarmEncode.EncodeMessage(bytes))); bytes = new byte[] {
// 0x24, 0x12, 0xF0, 0xFA,
// 0x02,
// 0x77, 0x35, 0x94, 0x01,
// 0x07, 0x5B, 0xCD, 0x15,
// 0x00, 0x01, 0xE2, 0x40,
// 0x23, 0x05, 0x18, 0x17, 0x12, 0x34,
// 0x01, 0x00, 0x00, 0x02,
// 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
// 0x3C, 0x05, 0x0D };
//Console.WriteLine(DataMessage.ToHexString(AlarmEncode.EncodeMessage(bytes))); bytes = new byte[] {
// 0x24, 0x12, 0xF0, 0xFA,
// 0x02,
// 0x77, 0x35, 0x94, 0x01,
// 0x07, 0x5B, 0xCD, 0x15,
// 0x00, 0x01, 0xE2, 0x40,
// 0x23, 0x05, 0x18, 0x17, 0x12, 0x34,
// 0x01, 0x00, 0x00, 0x01,
// 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
// 0x0E, 0x35, 0x0D };
//Console.WriteLine(DataMessage.ToHexString(AlarmEncode.EncodeMessage(bytes))); bytes = new byte[] {
// 0x24, 0x12, 0xF0, 0xFA,
// 0x02,
// 0x77, 0x35, 0x94, 0x01,
// 0x07, 0x5B, 0xCD, 0x15,
// 0x00, 0x01, 0xE2, 0x40,
// 0x23, 0x05, 0x18, 0x17, 0x12, 0x34,
// 0x01, 0x00, 0x00, 0x02,
// 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
// 0x3C, 0xC9, 0x0D };
//Console.WriteLine(DataMessage.ToHexString(AlarmEncode.EncodeMessage(bytes)));
//Server.SendMessage(ipep.Address.ToString(), ipep.Port, AlarmEncode.EncodeMessage(bytes));
//return true;
}
/// <summary>
/// 外出布防或者布防
/// </summary>
/// <param name="deviceId"></param>
/// <returns></returns>
public bool SetDeviceDefence(int deviceId)
{
UdpAlarmHost device = GetDevice(deviceId);
if (CheckDevice(device))
{
byte[] bytes = AlarmEncode.GetSendMessage(0x80, new byte[] { 0x60 });
return Server.SendMessage(device.Ip, device.Port, AlarmEncode.EncodeMessage(bytes));
}
return false;
}
/// <summary>
/// 撤防
/// </summary>
/// <param name="deviceId"></param>
/// <returns></returns>
public bool WithdrawDeviceDefence(int deviceId)
{
UdpAlarmHost device = GetDevice(deviceId);
if (CheckDevice(device))
{
byte[] bytes = AlarmEncode.GetSendMessage(0x80, new byte[] { 0x61 });
return Server.SendMessage(device.Ip, device.Port, AlarmEncode.EncodeMessage(bytes));
}
return false;
}
/// <summary>
/// 立即布防
/// </summary>
/// <param name="deviceId"></param>
/// <returns></returns>
public bool SetDeviceDefenceImmediately(int deviceId)
{
UdpAlarmHost device = GetDevice(deviceId);
if (CheckDevice(device))
{
byte[] bytes = AlarmEncode.GetSendMessage(0x80, new byte[] { 0x62 });
return Server.SendMessage(device.Ip, device.Port, AlarmEncode.EncodeMessage(bytes));
}
return false;
}
/// <summary>
/// 在家布防留守布防
/// </summary>
/// <param name="deviceId"></param>
/// <returns></returns>
public bool SetDeviceDefenceHome(int deviceId)
{
UdpAlarmHost device = GetDevice(deviceId);
if (CheckDevice(device))
{
byte[] bytes = AlarmEncode.GetSendMessage(0x80, new byte[] { 0x63 });
return Server.SendMessage(device.Ip, device.Port, AlarmEncode.EncodeMessage(bytes));
}
return false;
}
/// <summary>
/// 即时留守布防
/// </summary>
/// <param name="deviceId"></param>
/// <returns></returns>
public bool SetDeviceDefenceHomeImmediately(int deviceId)
{
UdpAlarmHost device = GetDevice(deviceId);
if (CheckDevice(device))
{
byte[] bytes = AlarmEncode.GetSendMessage(0x80, new byte[] { 0x64 });
return Server.SendMessage(device.Ip, device.Port, AlarmEncode.EncodeMessage(bytes));
}
return false;
}
/// <summary>
/// 清除报警记忆(复位)
/// </summary>
/// <param name="deviceId"></param>
/// <returns></returns>
public bool ClearDeviceDefence(int deviceId)
{
UdpAlarmHost device = GetDevice(deviceId);
if (CheckDevice(device))
{
byte[] bytes = AlarmEncode.GetSendMessage(0x80, new byte[] { 0x65 });
return Server.SendMessage(device.Ip, device.Port, AlarmEncode.EncodeMessage(bytes));
}
return false;
}
/// <summary>
/// 校对系统时间
/// </summary>
/// <param name="deviceId"></param>
/// <param name="time"></param>
/// <returns></returns>
public bool SetDeviceTime(int deviceId)
{
UdpAlarmHost device = GetDevice(deviceId);
if (CheckDevice(device))
{
byte[] content = GetBCDTime(DateTime.Now);
byte[] bytes = AlarmEncode.GetSendMessage(0x8D, content);
return Server.SendMessage(device.Ip, device.Port, AlarmEncode.EncodeMessage(bytes));
}
return false;
}
/// <summary>
/// 设备重启
/// </summary>
/// <param name="deviceId"></param>
/// <returns></returns>
public bool RebootDevice(int deviceId)
{
UdpAlarmHost device = GetDevice(deviceId);
if (CheckDevice(device))
{
byte[] bytes = AlarmEncode.GetSendMessage(0xA0, Array.Empty<byte>());
return Server.SendMessage(device.Ip, device.Port, AlarmEncode.EncodeMessage(bytes));
}
return false;
}
/// <summary>
/// 单防区布防
/// </summary>
/// <param name="deviceId"></param>
/// <param name="sectorId"></param>
/// <returns></returns>
public bool SetSectorefence(int deviceId, int sectorId)
{
UdpAlarmHost device = GetDevice(deviceId);
if (CheckDevice(device))
{
byte[] bytes = AlarmEncode.GetSendMessage(0xC0, new byte[] { (byte)(sectorId / 256), (byte)(sectorId % 256) });
return Server.SendMessage(device.Ip, device.Port, AlarmEncode.EncodeMessage(bytes));
}
return false;
}
/// <summary>
/// 单防区撤防
/// </summary>
/// <param name="deviceId"></param>
/// <param name="sectorId"></param>
/// <returns></returns>
public bool WithdrawSectorDefence(int deviceId, int sectorId)
{
UdpAlarmHost device = GetDevice(deviceId);
if (CheckDevice(device))
{
byte[] bytes = AlarmEncode.GetSendMessage(0xC1, new byte[] { (byte)(sectorId / 256), (byte)(sectorId % 256) });
return Server.SendMessage(device.Ip, device.Port, AlarmEncode.EncodeMessage(bytes));
}
return false;
}
/// <summary>
/// 单防区旁路
/// </summary>
/// <param name="deviceId"></param>
/// <param name="sectorId"></param>
/// <returns></returns>
public bool SetSectorByway(int deviceId, int sectorId)
{
UdpAlarmHost device = GetDevice(deviceId);
if (CheckDevice(device))
{
byte[] bytes = AlarmEncode.GetSendMessage(0xC2, new byte[] { (byte)(sectorId / 256), (byte)(sectorId % 256) });
return Server.SendMessage(device.Ip, device.Port, AlarmEncode.EncodeMessage(bytes));
}
return false;
}
/// <summary>
/// 单防区旁路恢复
/// </summary>
/// <param name="deviceId"></param>
/// <param name="sectorId"></param>
/// <returns></returns>
public bool WithdrawSectorByway(int deviceId, int sectorId)
{
UdpAlarmHost device = GetDevice(deviceId);
if (CheckDevice(device))
{
byte[] bytes = AlarmEncode.GetSendMessage(0xC3, new byte[] { (byte)(sectorId / 256), (byte)(sectorId % 256) });
return Server.SendMessage(device.Ip, device.Port, AlarmEncode.EncodeMessage(bytes));
}
return false;
}
/// <summary>
/// 查询防区状态
/// </summary>
/// <param name="deviceId"></param>
/// <param name="sectorId"></param>
/// <returns></returns>
public bool SearchSectorState(int deviceId, int sectorId)
{
UdpAlarmHost device = GetDevice(deviceId);
if (CheckDevice(device))
{
byte[] bytes = AlarmEncode.GetSendMessage(0x85, new byte[] { (byte)(sectorId / 256), (byte)(sectorId % 256) });
return Server.SendMessage(device.Ip, device.Port, AlarmEncode.EncodeMessage(bytes));
}
return false;
}
/// <summary>
/// 查询所有防区状态
/// </summary>
/// <param name="deviceId"></param>
/// <returns></returns>
public bool SearchAllSectorState(int deviceId)
{
UdpAlarmHost device = GetDevice(deviceId);
if (CheckDevice(device))
{
int sectorId = 0x00;
byte[] bytes = AlarmEncode.GetSendMessage(0x85, new byte[] { (byte)(sectorId / 256), (byte)(sectorId % 256) });
return Server.SendMessage(device.Ip, device.Port, AlarmEncode.EncodeMessage(bytes));
}
return false;
}
#endregion Send
#region DeviceDict
public bool ContainsDevice(int deviceId)
{
return DeviceDict.ContainsKey(deviceId);
}
public UdpAlarmHost GetDevice(int deviceId)
{
return DeviceDict[deviceId];
}
public bool TryGetDevice(int deviceId, out UdpAlarmHost device)
{
return DeviceDict.TryGetValue(deviceId, out device);
}
private bool AddDevice(int deviceId, ref UdpAlarmHost device)
{
if (ContainsDevice(deviceId)) return false;
DeviceDict[deviceId] = device;
UdpAlarmHost innerDevice = DeviceDict[deviceId];
if (innerDevice.SectorsEmpty && innerDevice.SectorsLock.TryEnterWriteLock(1000))
{
Task.Run(() =>
{
innerDevice = DeviceDict[deviceId];
while (innerDevice.SectorsEmpty)
{
SearchAllSectorState(innerDevice.DeviceId);
Thread.Sleep(1000);
}
innerDevice.SectorsLock.ExitWriteLock();
});
}
return true;
}
private void SetDevice(int deviceId, UdpAlarmHost device)
{
DeviceDict[deviceId] = device;
}
private bool RemoveDevice(int deviceId)
{
return DeviceDict.Remove(deviceId, out _);
}
public List<UdpAlarmHost> GetDeviceList()
{
return DeviceDict.Values.ToList();
}
private bool CheckDevice(UdpAlarmHost device)
{
if (!IsRunning()) return false;
if (device == null) return false;
if (device.OnlineState == 0) return false;
return true;
}
#endregion DeviceDict
#region Util
private int GetBit(byte bytes, int index)
{
return index switch
{
0 => bytes & 0x01,
1 => (bytes & 0x02) >> 1,
2 => (bytes & 0x04) >> 2,
3 => (bytes & 0x08) >> 3,
4 => (bytes & 0x10) >> 4,
5 => (bytes & 0x20) >> 5,
6 => (bytes & 0x40) >> 6,
7 => (bytes & 0x80) >> 7,
_ => 0,
};
}
private int ByteToInt(byte[] msg, int start)
{
byte[] bytes = new byte[] { msg[start + 3], msg[start + 2], msg[start + 1], msg[start] };
return BitConverter.ToInt32(bytes, 0);
}
private byte[] IntToByte(int num)
{
byte[] bytes = BitConverter.GetBytes(num);
return new byte[] { bytes[3], bytes[2], bytes[1], bytes[0] };
}
private string GetCID(byte bytes)
{
return bytes switch
{
0x00 => "0",
0x01 => "1",
0x02 => "2",
0x03 => "3",
0x04 => "4",
0x05 => "5",
0x06 => "6",
0x07 => "7",
0x08 => "8",
0x09 => "9",
0x0A => "A",
0x0B => "B",
0x0C => "C",
0x0D => "D",
0x0E => "E",
0x0F => "F",
_ => "0",
};
}
private string GetBCD(byte bytes)
{
int num = (bytes >> 4) * 10 + (bytes & 0x0F);
return num.ToString();
}
private byte GetBCDByte(int num)
{
if (num >= 100) num %= 100;
int hex = num / 10;
int lex = num % 10;
return (byte)(hex * 16 + lex);
}
private byte[] GetBCDTime(DateTime time)
{
return new byte[] { GetBCDByte(time.Year),GetBCDByte((int)time.DayOfWeek),GetBCDByte(time.Month),GetBCDByte(time.Day),
GetBCDByte(time.Hour),GetBCDByte(time.Minute),GetBCDByte(time.Second) };
}
#endregion Util
}