public HttpResponseMessage Service()
{
//将当前请求对象转换为传统HttpRequestBase对象
HttpRequestBase requ = this.GetRequest();
//初始化数据传递对象
TransmitData transmitData = new TransmitData();
//将请求附带参数赋值给TransmitData对象
transmitData.SetRequestPara(requ);
//获取当前回调的事件名
string eventType = transmitData.requestPara["EventType"].ToString();
string responseJSON = new Handles(transmitData).Handle(eventType);
//当没有找到EventType对应Handle方法时
if (string.IsNullOrEmpty(responseJSON))
{
throw new Exception("未找到“" + eventType + "”方法！");
}
return(new HttpResponseMessage {
Content = new StringContent(responseJSON, System.Text.Encoding.UTF8, "application/json")
});
}
public EditFormulaForm(TransmitData transmitData)
{
InitializeComponent();
this.transmitData = transmitData;
loadGlobalChineseCharacters = LoadGlobalChineseCharacters.GetInstance();
initUI();
}
public TransmitData getCurrentSelected(MaskType mt)
{
TransmitData sdRtn = new TransmitData();
sdRtn.data = new CANData();
TreeNode tnSelected = MessageTreeView.SelectedNode;
CANMessage cMsg;
if (typeof(CANMessage).Equals(tnSelected.Tag.GetType()))
{
cMsg = tnSelected.Tag as CANMessage;
sdRtn.data.ID = cMsg.ID;
sdRtn.data.SetData(cMsg.BuildMessage(mt));
sdRtn.cycle = cMsg.TxPeriod;
}
else if (typeof(CANSignal).Equals(tnSelected.Tag.GetType()))
{
cMsg = tnSelected.Parent.Tag as CANMessage;
CANSignal cSignal = tnSelected.Tag as CANSignal;
sdRtn.data.ID = cMsg.ID;
sdRtn.data.SetData(cSignal.encode(mt));
sdRtn.cycle = cMsg.TxPeriod;
}
else
{
sdRtn = null;
}
return(sdRtn);
}
/// <summary>
/// 直接从这里提取一个要发送的主体字节集数据;已经加密完成
/// </summary>
/// <param name="state">StateBase</param>
/// <returns>字节集</returns>
private static byte[] FileGetSendDate(TransmitData state)
{
int Date_Max = state.BufferSize - 24;
if (state.SendFile.FileDateAll == null)
{
return(null);//说明文件已经发完了
}
int FileDateAllLenth = state.SendFile.FileDateAll.Length;
if (FileDateAllLenth <= Date_Max)
{
state.SendFile.SendDate = SendSubjectEncryption(state.SendFile.FileDateAll, state.SendFile.FileLabel);
state.SendFile.FileDateAll = null;
}
else
{
//现在送出去
byte[] dateS = new byte[Date_Max];
//剩下的数据
byte[] dateL = new byte[FileDateAllLenth - Date_Max];
Array.Copy(state.SendFile.FileDateAll, 0, dateS, 0, Date_Max);
Array.Copy(state.SendFile.FileDateAll, Date_Max, dateL, 0, FileDateAllLenth - Date_Max);
state.SendFile.FileDateAll = dateL;
//在这里加入主体暗号_fileSubjectCode;
state.SendFile.SendDate = SendSubjectEncryption(dateS, state.SendFile.FileLabel);
}
return(state.SendFile.SendDate);
}
public void Transmit(TransmitData data)
{
if (!IsOpen)
{
return;
}
Task.Factory.StartNew(() =>
{
if (!DoesItPassFilter(data))
{
return;
}
List <string> udpStrings = ConvertCANPackageToInfluxdbUDPPackage(data);
RaiseReceivedData(new ReceivedData()
{
Time = _watch.ElapsedMilliseconds / 1000.0,
CanId = data.CanId,
DLC = data.DLC,
IsExtId = data.IsExtId,
Payload = data.Payload
});
foreach (var el in udpStrings)
{
SendToInfluxDB(el);
}
});
}
private List <string> ConvertCANPackageToInfluxdbUDPPackage(TransmitData data)
{
List <string> result = new List <string>();
foreach (var filter in _config.Filters.Where(x =>
(x.Header.IsExtId == data.IsExtId) &&
(x.Header.DLC == data.DLC) &&
(x.Header.Id == data.CanId) &&
(data.Payload.BinaryAnd(x.Header.MaskBytes).IsEquals(x.Header.ValueBytes))))
{
foreach (var insert in filter.Inserts)
{
string exp = insert.Field.Value;
for (int i = 0; i < data.Payload.Length; i++)
{
exp = exp.Replace($"data{i}", data.Payload[i].ToString());
}
try
{
result.Add($"{insert.Measurement},{insert.Tag.Name}={insert.Tag.Value} {insert.Field.Name}={new DataTable().Compute(exp, null).ToString().Replace(",", ".")}");
}
catch { }
}
}
return(result);
}
/// <summary>
/// 文件数据分析处理中心；如果是发送方发过来的数据让接收方去处理
/// </summary>
/// <param name="fileDate">文件数据</param>
/// <param name="stateOne">StateBase</param>
/// <returns>处理以后的数据</returns>
internal static byte[] ReceiveDateTO(byte[] fileDate, TransmitData stateOne)
{
if (fileDate.Length < 7)
{
return(null);
}
byte[] haveDate = null;
byte code = fileDate[1];
if (code == CipherCode._receiveUser)
{
if (fileSend == null)//这里没有开启；直接让对方取消
{
haveDate = EncDecFile.FileSevenEncryption(CipherCode._sendUser, CipherCode._fileCancel, ByteToDate.ByteToInt(3, fileDate));
}
else
{
haveDate = fileSend.ReceiveDateTO(fileDate, stateOne);
}
}
else if (code == CipherCode._sendUser)
{
if (fileReceive == null)//这里没有开启；直接让对方取消
{
haveDate = EncDecFile.FileSevenEncryption(CipherCode._receiveUser, CipherCode._fileCancel, ByteToDate.ByteToInt(3, fileDate));
}
else
{
haveDate = fileReceive.ReceiveDateTO(fileDate, stateOne);
}
}
return(haveDate);
}
/// <summary>
/// 通过StateBase中断所有的文件；服务器用到的
/// </summary>
/// <param name="stateOne">StateBase</param>
internal static void FileStopITxBase(TransmitData stateOne)
{
if (fileSend != null)
{
foreach (FileState state in fileSend.FS)
{
if (state.StateOne == stateOne)
{
state.StateFile = 2;
fileSend.SendMust.FileBreak(state.FileLabel, "对方下线或断线");
}
}
}
else if (fileReceive != null)
{
foreach (FileState state in fileReceive.FS)
{
if (state.StateOne == stateOne)
{
state.StateFile = 2;
fileReceive.ReceiveMust.FileBreak(state.FileLabel, "对方下线或断线");
}
}
}
}
public async Task Run(TransmitData transmitData)
{
try
{
using var dbContext = new EFContext();
DateTime NowTime = DateTime.Now;
NbCommand nbCommand = new NbCommand
{
CmdCode = transmitData.CommandCode,
MessageID = transmitData.MesssageID,
CmdData = DataHelper.BytesToHexStr(transmitData.Data),
CmdId = transmitData.UUID.ToString().ToUpper(),
EventTime = NowTime,
Timestamp = NowTime,
Topic = transmitData.Topic,
TopicType = "light",
Account = "System"
};
await dbContext.NbCommands.AddAsync(nbCommand); //先插入发送命令表中
await dbContext.SaveChangesAsync(); //保证数据库中存在值
var res = await Send(transmitData.Topic, nbCommand.CmdData);
}
catch (Exception ex)
{
}
}
private void ShotCommand_Execute()
{
TransmitData data = new TransmitData()
{
CanId = (int)this.CanId,
IsExtId = this.IsExtId,
DLC = (int)this.DLC,
Payload = this.Payload.ToArray()
};
var results = new List <ValidationResult>();
if (!Validator.TryValidateObject(data, new ValidationContext(data), results, true))
{
foreach (var error in results)
{
MessageBox.Show(error.ErrorMessage, (string)Manager <LanguageCultureInfo> .StaticInstance.GetResource("#WarningMsgBoxTitle"), MessageBoxButton.OK, MessageBoxImage.Error);
}
if (Status == TransmitState.Transmiting)
{
RunCommand.Execute();
}
return;
}
Task.Run(() => { TransmitToSelectedChannels?.Invoke(data); });
}
public ChooseColumnForm(TransmitData transmitData)
{
this.transmitData = transmitData;
loadGlobalChineseCharacters = LoadGlobalChineseCharacters.GetInstance();
InitializeComponent();
initUI();
addColumnCheckBox(transmitData.columnsNameList, transmitData.columnTypeDict);
clearNotNeedData(transmitData);
}
public void Transmit(TransmitData data)
{
SendDataToProxy(data);
string response = _process.StandardOutput.ReadLine();
var match = Regex.Match(response,
@"([0-1]{1});" +
@"([0-9a-fA-F]{8});" +
@"([0-9a-fA-F]{1});" +
@"([0-9a-fA-F])+;" +
@"([0-9a-fA-F]{4});");
if (!match.Success)
{
return;
}
ReceivedData result = new ReceivedData();
try
{
result.DLC = Convert.ToInt32(match.Groups[3].Value, 16);
}
catch { return; }
match = Regex.Match(response,
@"([0-1]{1});" +
@"([0-9a-fA-F]{8});" +
@"([0-9a-fA-F]{1});" +
@"([0-9a-fA-F]{" + (result.DLC * 2) + "});" +
@"([0-9a-fA-F]{4});");
if (!match.Success)
{
return;
}
try
{
result.IsExtId = Convert.ToInt32(match.Groups[1].Value, 16) == 0 ? false : true;
result.CanId = Convert.ToInt32(match.Groups[2].Value, 16);
result.Time = Convert.ToInt32(match.Groups[5].Value, 16) / 1000.0;
result.Payload = new byte[result.DLC];
for (int i = 0; i < result.DLC; i++)
{
result.Payload[i] = Convert.ToByte(match.Groups[4].Value.Substring(i * 2, 2), 16);
}
}
catch { return; }
RaiseReceivedData(result);
}
private bool DoesItPassFilter(TransmitData data)
{
InfuxDBFilter a = _config.Filters.FirstOrDefault(x =>
(x.Header.IsExtId == data.IsExtId) &&
(x.Header.DLC == data.DLC) &&
(x.Header.Id == data.CanId) &&
(data.Payload.BinaryAnd(x.Header.MaskBytes).IsEquals(x.Header.ValueBytes)));
return(a == null ? false : true);
}
public static void GetAasx(IHttpContext context)
{
string ret = "ERROR";
if (context.Request.PathParameters.Count == 3)
{
string path = context.Request.PathInfo;
string[] split = path.Split('/');
string node = split[2];
string aasIndex = split[3];
TransmitData td = new TransmitData();
td.source = sourceName;
td.destination = node;
td.type = "getaasx";
td.extensions = aasIndex;
// publishRequest.Add(td);
if (parentDomain != "GLOBALROOT")
{
publishRequest.Add(td);
}
else
{
for (int i = 0; i < publishResponse.Length; i++)
{
if (publishResponse[i] == null)
{
publishResponse[i] = new List <TransmitData> {
};
publishResponse[i].Add(td);
if (childs.Count != 0)
{
publishResponseChilds[i] = new List <string> {
};
foreach (string value in childs)
{
publishResponseChilds[i].Add(value);
}
}
break;
}
}
}
ret = "Downloaded .AASX from node " + node + " at index " + aasIndex + " will be stored in user download directory!";
}
context.Response.ContentType = ContentType.TEXT;
context.Response.ContentEncoding = Encoding.UTF8;
context.Response.ContentLength64 = ret.Length;
context.Response.SendResponse(ret);
}
/// <summary>
/// 发送方的文件进行续传;如果回复是null;说明不存在
/// </summary>
/// <param name="fileLable">文件标签</param>
/// <param name="stateOne">StateBase</param>
/// <returns>byte[]</returns>
internal byte[] FileContinue(int fileLable, TransmitData stateOne)
{
byte[] haveDate = null;
FileState state = FileLabelToState(fileLable);
if (state != null && state.StateFile == 2)
{
haveDate = EncDecFile.FileSevenEncryption(CipherCode._sendUser, CipherCode._fileContinue, fileLable);
state.StateOne = stateOne;//可以续传；用新的stateOne代替旧的
}
return(haveDate);
}
public static async void ThreadLoop()
{
while (true)
{
// Test data to publish
string testPublish = "";
if (testRequest == "")
{
testPublish = "{ \"source\" : \"" + sourceName + "\" , \"count\" : \"" + count + "\" }";
count++;
}
else
{
testPublish = await getTestData(testRequest);
}
TransmitData td = new TransmitData();
td.source = sourceName; // must be a unique name in the overall node network
td.type = "test"; // AASX Server publishes type "submodel"
td.publish.Add(testPublish);
TransmitFrame tf = new TransmitFrame();
tf.source = sourceName;
tf.data.Add(td);
string publish = JsonConvert.SerializeObject(tf, Formatting.Indented);
Console.WriteLine("Publish data:\n" + publish + "\n");
var handler = new HttpClientHandler();
handler.DefaultProxyCredentials = CredentialCache.DefaultCredentials;
var client = new HttpClient(handler);
string content = "";
try
{
var contentJson = new StringContent(publish, System.Text.Encoding.UTF8, "application/json");
var result = client.PostAsync(connectDomain + "/publish", contentJson).Result;
content = ContentToString(result.Content);
}
catch
{
Console.WriteLine("ERROR: Publish Timeout!\n");
}
if (content != "")
{
// Received JSON content as TransmitFrame
Console.WriteLine("Received Subscribe Data:\n" + content + "\n");
}
Thread.Sleep(3000);
}
}
/// <summary>
/// 接收方的文件进行续传;如果回复是null;说明不存在
/// </summary>
/// <param name="fileLable">文件标签</param>
/// <param name="stateOne">StateBase</param>
/// <returns>byte[]</returns>
internal byte[] FileContinue(int fileLable, TransmitData stateOne)
{
byte[] haveDate = null;
FileState state = FileLabelToState(fileLable);
if (state != null && state.StateFile == 2)
{
haveDate = EncDecFile.ReceiveContingueEncryption(CipherCode._fileContinue, state);
ExpandBuffer(state, stateOne);
}
return(haveDate);
}
/// <summary>
/// 扩充因要接收文件而增大的缓冲区
/// </summary>
/// <param name="state">FileState</param>
/// <param name="stateOne">stateOne</param>
private void ExpandBuffer(FileState state, TransmitData stateOne)
{
if (state.StateOne != stateOne)
{
if (stateOne.Buffer.Length != BufferSize)
{
stateOne.BufferBackup = stateOne.Buffer;
stateOne.Buffer = new byte[BufferSize];
}
state.StateOne = stateOne;
}
}
/// <summary>
/// Trasmit data to CAN channel.
/// </summary>
/// <param name="data">Data to be transmited.</param>
public void Transmit(TransmitData data)
{
if (_port == null)
{
return;
}
if (!_port.IsOpen)
{
Owner.Disconnect();
}
var validatorResults = new List <ValidationResult>();
if (!Validator.TryValidateObject(data, new ValidationContext(data), validatorResults, true))
{
string errors = "";
foreach (var el in validatorResults)
{
errors += $"{el.ErrorMessage}\r\n";
}
throw new ArgumentException($"Transmit data is invalid:\r\n{errors}");
}
if (!IsOpen || IsListenOnly)
{
return;
}
string transmit = "";
string payloadstr = "";
for (int i = 0; i < data.DLC; i++)
{
payloadstr += data.Payload[i].ToString("X2");
}
if (data.IsExtId)
{
transmit = $"T{data.CanId.ToString("X8")}{data.DLC.ToString("X1")}{payloadstr}\r";
}
else
{
transmit = $"t{data.CanId.ToString("X3")}{data.DLC.ToString("X1")}{payloadstr}\r";
}
lock (_port)
{
_port.Write(transmit);
}
}
/// <summary>
/// 对文件进行续传；只要一个文件标签，会自动分析是发送方还是接收方的文件标签；
/// </summary>
/// <param name="fileLable">文件标签</param>
/// <param name="stateOne">StateBase</param>
/// <returns></returns>
internal static byte[] FileContinue(int fileLable, TransmitData stateOne)
{
byte[] haveDate = null;
if (fileSend != null)
{
haveDate = fileSend.FileContinue(fileLable, stateOne);
}
else if (haveDate == null && fileReceive != null)
{
haveDate = fileReceive.FileContinue(fileLable, stateOne);
}
return(haveDate);
}
public SetDateTypeParameterForm(TransmitData transmitData)
{
this.transmitData = transmitData;
InitializeComponent();
loadGlobalChineseCharacters = LoadGlobalChineseCharacters.GetInstance();
this.selectColumnList = transmitData.selectedColumn;
this.columnTypeDict = transmitData.columnTypeDict;
this.selectedColumnVariableDict = transmitData.selectedColumnVariableDict;
tmpTwoDateColumnRelationContainer = new TwoDateColumnRelationContainer <string>();
//relationContainerList = new List<TwoDateColumnRelationContainer<string>>();
excelHandle = new ExcelHandle();
relationContainerList = excelHandle.getExistRelationFormExistExcel();
initUI();
}
public AssignmentForm(TransmitData transmitData)
{
this.transmitData = transmitData;
selectedColumnList = transmitData.selectedColumn;
InitializeComponent();
loadGlobalChineseCharacters = LoadGlobalChineseCharacters.GetInstance();
this.selectedColumnVariableDict = assignVariableName();
this.weightRelation = new Dictionary <int, int>();
this.weightAndColumnNameRelation = new Dictionary <int, string>();
initUI();
initDataGridView();
clearNotNeedData(transmitData);
transmitData.selectedColumnVariableDict = this.selectedColumnVariableDict;
}
/// <summary>
/// 对数据加入暗号与数据标签
/// </summary>
/// <param name="date">要加密的数据</param>
/// <param name="textCode">数据模型的暗号</param>
/// <param name="state">StateBase</param>
/// <returns>加密之后的数据（1暗号+1暗号+4数据标签+date）</returns>
private static byte[] encryptionTemporary(byte[] date, byte textCode, TransmitData state)
{
if (date.Length > state.BufferSize - 20)
{
//超出通过文件大数据包处理发送
return(EncDecSeparateDate.SendHeadEncryption(date, textCode, state));
}
//给发送的数据进行编号
state.SendDateLabel = RandomPublic.RandomNumber(16787);
//编号并加密 （加密
byte[] dateOverall = ByteToDate.OffsetEncryption(date, state.SendDateLabel, 2);
dateOverall[0] = CipherCode._commonCode;
dateOverall[1] = textCode;
return(dateOverall);
}
/// <summary>
/// 返回分包数据11位的数据包包头（暗号类型1+暗号1+原暗号+数据标签+长度）
/// </summary>
/// <param name="date">数据</param>
/// <param name="textCode">原暗号，什么文件</param>
/// <param name="state">StateBase</param>
/// <returns>加密之后的包头</returns>
internal static byte[] SendHeadEncryption(byte[] date, byte textCode, TransmitData state)
{
state.SendFile = new TransmitFile(date);
state.SendFile.FileLabel = RandomPublic.RandomNumber(14562);
byte[] headDate = new byte[11];
//写入暗号
headDate[0] = CipherCode._bigDateCode;
headDate[1] = CipherCode._fileHeadCode;
headDate[2] = textCode;
//写入数据标签
ByteToDate.IntToByte(state.SendFile.FileLabel, 3, headDate);
//写入数据长度
ByteToDate.IntToByte(date.Length, 7, headDate);
return(headDate);
}
/// <summary>
/// 对文本和图片数据进行解密;
/// </summary>
/// <param name="date">接收到的数据</param>
/// <param name="state">StateBase</param>
/// <returns>返回一个图片</returns>
internal static DataModel deciphering(byte[] date, TransmitData state)
{
DataModel stateCode = null;
//小于6，是说：暗号类型1位+暗号1位+数据标签4位
if (date.Length < 6)
{
return(stateCode);//收到的数据不正确
}
byte headDate = date[1];
//当是图片与文本时
if (headDate == CipherCode._textCode || headDate == CipherCode._photographCode)
{
int SendDateLabel = 0;
//取得数据，并取得数据标签
byte[] dateAll = ByteToDate.OffsetDecrypt(date, out SendDateLabel, 2);
//回复此数据标签的数据是成功收到了
byte[] ReplyDate = ByteToDate.CombinationTwo(CipherCode._commonCode, CipherCode._dateSuccess, SendDateLabel);
//判断是否文本
if (headDate == CipherCode._textCode)
{
//文本
string str = Encoding.UTF8.GetString(dateAll);
stateCode = new DataModel(CipherCode._textCode, str, ReplyDate);//解析出来是文本数据
}
else
{
//图片
stateCode = new DataModel(CipherCode._photographCode, dateAll, ReplyDate);//解释出来是图片数据
}
}
else if (headDate == CipherCode._dateSuccess)//数据成功或重发
{
//找出已发数据的标签
int SendDateLabel = ByteToDate.ByteToInt(2, date);
if (headDate == CipherCode._dateSuccess)
{
stateCode = new DataModel(headDate);//生成一个成功信息的数据模型
if (SendDateLabel == state.SendDateLabel)
{
state.SendDate = null;
} //已经成功对已发数据进行删除
}
}
return(stateCode);
}
private void SendDataToProxy(TransmitData data)
{
string payload = "";
for (int i = 0; i < data.DLC; i++)
{
payload += data.Payload[i].ToString("X2");
}
string response = $"{(data.IsExtId ? "1" : "0")};" +
$"{data.CanId.ToString("X8")};" +
$"{data.DLC.ToString("X1")};" +
$"{payload};" +
$"{((int)(0)).ToString("X4")};";
_process.StandardInput.WriteLine(response);
}
/// <summary>
/// 读取缓冲区数据，并清空
/// </summary>
/// <param name="stateOne">StateBase</param>
/// <param name="insert">数据实际长度</param>
/// <returns>需要的数据</returns>
internal static byte[] DateOneManage(TransmitData stateOne, int insert)
{
byte[] receiveByte = null;
if (stateOne.Buffer[0] == 0 && stateOne.BufferBackup != null && stateOne.BufferBackup.Length >= insert)
{
receiveByte = stateOne.BufferBackup;
//清空备用缓冲区
stateOne.BufferBackup = null;
}//主要用于缓冲区有扩大缩小
else
{
receiveByte = stateOne.Buffer;
}
byte[] haveDate = ByteToDate.ByteToByte(receiveByte, insert, 0);
Array.Clear(stateOne.Buffer, 0, stateOne.Buffer.Length);
return(haveDate);
}
/// <summary>
/// 对文本和图片数据进行加密;如果长度超过限制，直接抛给文件处理中心
/// </summary>
/// <param name="stateCode">StateCode</param>
/// <param name="state">StateBase</param>
/// <returns>要发送的数据</returns>
internal static byte[] encryption(DataModel stateCode, TransmitData state)
{
byte[] returnByte = null;
//表示字符暗号
if (stateCode.State == CipherCode._textCode)
{
//取得文本数据
byte[] date = Encoding.UTF8.GetBytes(stateCode.Datestring);
//对数据主体部分进行加密,加密之后的数据（1暗号+1暗号+4数据标签+date）
returnByte = encryptionTemporary(date, stateCode.State, state);
}
else if (stateCode.State == CipherCode._photographCode)
{
//对数据主体部分进行加密,加密之后的数据（1暗号+1暗号+4数据标签+date）
returnByte = encryptionTemporary(stateCode.DateByte, stateCode.State, state);
}
return(returnByte);
}
/// <summary>
/// 发送文件
/// </summary>
/// <param name="fileLable">文件标签</param>
/// <param name="fileName">文件地址</param>
/// <param name="stateOne">StateBase</param>
/// <returns>形成之后的数据</returns>
internal byte[] Send(ref int fileLable, string fileName, TransmitData stateOne)
{
int fileLenth = 0;
FileStream fs;
try
{
fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
fileLenth = (int)fs.Length;
}
catch (Exception Ex) { throw new Exception(Ex.Message); }
fileLable = RandomPublic.RandomNumber(16787);
FileState fileState = new FileState(fileLable, fileLenth, fileName, fs);
fileState.StateOne = stateOne;
FS.Add(fileState);
byte[] haveByte = EncDecFile.FileHeadEncryption(fileState);
return(haveByte);
}
public async Task Execute(IJobExecutionContext context)
{
logger.Info("执行时间同步任务..................");
try
{
using var dbContext = new EFContext();
await dbContext.TNL_TunnelLights.ForEachAsync(async l =>
{
var IMEI = l.IMEI;
Guid guid = Guid.NewGuid();
DateTime NowTime = DateTime.Now;
var year = NowTime.Year.ToString("X4");
var month = NowTime.Month.ToString("X2");
var day = NowTime.Day.ToString("X2");
var week = ((int)NowTime.DayOfWeek).ToString("X2");
var hour = NowTime.Hour.ToString("X2");
var minute = NowTime.Minute.ToString("X2");
var second = NowTime.Second.ToString("X2");
var RTCHex = year + month + day + week + hour + minute + second;
var RTCBytes = HexFormatHelper.StringConvertHexBytes(RTCHex);
var RTCTransmitHex = TransmitHelper.SendNBComand(guid.ToByteArray(), RTCBytes, (byte)NBCommondCode.DateSync);
var RTCtransmitData = new TransmitData
{
Topic = AppSetting.LightTopicBefore + IMEI,
CommandCode = DataHelper.BytesToHexStr(new byte[] { (byte)NBCommondCode.DateSync }),
MesssageID = 0,
Data = RTCTransmitHex,
UUID = guid
};
await TransmitContext.GetInstance().GetTransmitSchedule().Run(RTCtransmitData);
await Task.Delay(100);
});
}
catch (Exception ex)
{
logger.Error(ex.ToString());
}
logger.Info("执行时间同步任务完成..................");
}