public static byte[] Compress( byte[] buffer )
{
using ( MemoryStream ms = new MemoryStream() )
using ( BinaryWriter writer = new BinaryWriter( ms ) )
{
uint checkSum = 0;
using ( Crc crc = new Crc( CrcParameters.GetParameters( CrcStandard.Crc32Bit ) ) )
{
checkSum = BitConverter.ToUInt32( crc.ComputeHash( buffer ), 0 );
}
byte[] compressed = DeflateBuffer( buffer );
Int32 poslocal = WriteHeader( writer, LocalFileHeader );
WriteLocalFile( writer, "z", checkSum, ( UInt32 )buffer.Length, compressed );
Int32 posCDR = WriteHeader( writer, CentralDirectoryHeader );
UInt32 CDRSize = WriteCentralDirectory( writer, "z", checkSum, ( UInt32 )compressed.Length, ( UInt32 )buffer.Length, poslocal );
Int32 posEOD = WriteHeader( writer, EndOfDirectoryHeader );
WriteEndOfDirectory( writer, 1, CDRSize, posCDR );
return ms.ToArray();
}
}
private static uint CalculateDigest(byte[] data, uint offset, uint size)
{
var crc = new Crc();
// crc.Init();
crc.Update(data, offset, size);
return crc.GetDigest();
}
void ReceiveByteWithEscaping(byte b, MessageCallback framingErrorCallback)
{
if (b == Constants.Bof)
{
if (framingErrorCallback != null)
{
framingErrorCallback("S101: BOF in frame!");
}
_stream.SetLength(0);
_isDataLinkEscaped = false;
_crc = Crc.InitialValue;
if (_outOfFrameByteCount > 0 && framingErrorCallback != null)
{
framingErrorCallback(String.Format("S101: {0} out of frame data bytes!", _outOfFrameByteCount));
}
_outOfFrameByteCount = 0;
return;
}
if (b == Constants.Eof)
{
var length = (int)_stream.Length;
_stream.Write(Constants.Eofs, 0, Constants.Eofs.Length);
if (length >= 3)
{
if (_crc == 0xF0B8)
{
_stream.SetLength(length - 2);
var memory = _stream.ToArray();
OnMessageReceived(new MessageReceivedArgs(memory.Length, memory, false), true);
}
else
{
if (framingErrorCallback != null)
{
framingErrorCallback("S101: CRC error!");
}
}
}
else if (length == 0)
{
if (framingErrorCallback != null)
{
framingErrorCallback("S101: EOF out of frame!");
}
}
_isInFrame = false;
_stream.SetLength(0);
return;
}
if (b == Constants.Ce)
{
_isDataLinkEscaped = true;
return;
}
if (b >= Constants.Invalid)
{
if (framingErrorCallback != null)
{
framingErrorCallback("S101: Invalid character received!");
}
_isInFrame = false;
_stream.SetLength(0);
return;
}
if (_isDataLinkEscaped)
{
_isDataLinkEscaped = false;
b ^= 0x20;
}
_stream.WriteByte(b);
_crc = Crc.CrcCCITT16(_crc, b);
}
private void Idle()
{
try
{
while (true)
{
var buffer = new byte[BUFFER_SIZE];
var readed = socket.Receive(buffer);
if (readed == 0)
{
throw new Exception("пришло 0 байт");
//log.Debug(string.Format("[{0}] пришло 0 байт", GetImei()));
}
else
{
byte[] bytes = buffer.Take(readed).ToArray();
subscriber?.Invoke(bytes);
if (subscriber == null) // 12.03.2019
{
if (bytes.Length < 5)
{
if (bytes.Length == 2 && (bytes[0] + bytes[1] == 0xFF))
{
SendDataToSocket(bytes);
}
else if (bytes.Length == 3 && ((byte)((bytes[1] >> 4) | (bytes[1] << 4)) == bytes[2]))
{
try
{
Guid objectId = GetObjectId(GetImei(), bytes[0]);
ModbusControl.Instance.Request(new Guid[] { objectId }, bytes[1].ToString(), GetImei(), "Abnormal");
}
catch (Exception ex)
{
}
log.Error("событие");
}
log.Error($"количество байтов пришло {bytes.Length} < 5");
}
else if (Crc.Check(bytes, new Crc16Modbus()))
{
SendDataToSocket(ModbusControl.Instance.TeleofisWrx(bytes, GetImei()));
}
else
{
if ((bytes[0] == 0x0A && bytes[1] == 0x0D) || (bytes[bytes.Length - 2] == 0x0A && bytes[bytes.Length - 1] == 0x0D))
{
List <byte> bufferTmp = bytes.ToList();
while (bufferTmp.Count > 5 && (bufferTmp[0] == 0x0A && bufferTmp[1] == 0x0D))
{
bufferTmp.RemoveRange(0, 2);
}
while (bufferTmp.Count > 5 && (bufferTmp[bufferTmp.Count - 2] == 0x0A && bufferTmp[bufferTmp.Count - 1] == 0x0D))
{
bufferTmp.RemoveRange(bufferTmp.Count - 2, 2);
}
bytes = null;
bytes = bufferTmp.ToArray();
if (!Crc.Check(bytes, new Crc16Modbus()))
{
log.Error("контрольная сумма кадра не сошлась");
}
else
{
SendDataToSocket(ModbusControl.Instance.TeleofisWrx(bytes, GetImei()));
}
}
}
}
}
}
}
catch (Exception oex)
{
log.Error(string.Format("[{0}] поток слушающий сокет остановлен", GetImei()), oex);
CloseSocket();
}
}
private dynamic Send(byte[] datasend, int attempts_total = SEND_ATTEMPTS)
{
dynamic answer = new ExpandoObject();
answer.success = false;
answer.error = string.Empty;
answer.errorcode = DeviceError.NO_ERROR;
byte[] buffer = null;
for (var attempts = 0; attempts < attempts_total && answer.success == false; attempts++)
{
buffer = SendSimple(datasend);
if (buffer.Length == 0)
{
answer.error = "Нет ответа";
answer.errorcode = DeviceError.NO_ANSWER;
}
else
{
if (buffer.Length < 4)
{
answer.error = "в кадре ответа не может содержаться менее 4 байт";
answer.errorcode = DeviceError.TOO_SHORT_ANSWER;
}
else if (!Crc.Check(buffer, new Crc16Modbus()))
{
answer.error = "контрольная сумма кадра не сошлась";
answer.errorcode = DeviceError.CRC_ERROR;
}
else
{
answer.success = true;
answer.error = string.Empty;
answer.errorcode = DeviceError.NO_ERROR;
}
}
}
if (answer.success)
{
answer.NetworkAddress = buffer[0];
answer.Body = buffer.Skip(1).Take(buffer.Length - 3).ToArray();
var tmp = buffer.Skip(1).Take(buffer.Length - 3);
/*
* log($"buffer, {string.Join(",", buffer.Select(b => b.ToString("X2")))}");
* log($"Body, {string.Join(",", tmp.Select(b => b.ToString("X2")))}");
*
* List<byte> tmpByte = (tmp.Select(b => b)).ToList();
* log($"tmpByte до удаления, {string.Join(",", tmpByte.Select(b => b.ToString("X2")))}");
* try
* {
* int firstIndexFF = tmpByte.IndexOf(0xFF);
* log($"Индекс1: {firstIndexFF}");
* if (firstIndexFF > 40)
* {
* tmpByte.RemoveAt(firstIndexFF);
* }
* }
* catch
* {
* }
* log($"tmpByte после удаления, {string.Join(",", tmpByte.Select(b => b.ToString("X2")))}");
*/
//answer.Body = tmpByte.ToArray();
//modbus error
if (buffer.Length == 4)
{
answer.success = false;
answer.errorcode = DeviceError.DEVICE_EXCEPTION;
switch (buffer[1] & 0x0F)
{
case 0x00:
answer.success = true;
answer.errorcode = DeviceError.NO_ERROR;
answer.error = "все нормально";
break;
case 0x01:
answer.error = "недопустимая команда или параметр";
break;
case 0x02:
answer.error = "внутренняя ошибка счетчика";
break;
case 0x03:
answer.error = "не достаточен уровень доступа для удовлетворения запроса";
break;
case 0x04:
answer.error = "внутренние часы счетчика уже корректировались в течении текущих суток";
break;
case 0x05:
answer.error = "не открыт канал связи";
break;
case 0x0F:
answer.error = "счётчик не отвечает (коммуникатор)";
break;
default:
answer.error = "неизвестная ошибка";
break;
}
}
}
return(answer);
}
public void Execute()
{
ValidateFacets();
var facetsByName = new Dictionary <string, Dictionary <string, FacetValue> >();
bool isDistinct = IndexQuery.IsDistinct;
if (isDistinct)
{
_fieldsCrc = IndexQuery.FieldsToFetch.Aggregate <string, uint>(0, (current, field) => Crc.Value(field, current));
}
_currentState = Database.IndexStorage.GetCurrentStateHolder(Index);
using (_currentState)
{
var currentIndexSearcher = _currentState.IndexSearcher;
var baseQuery = Database.IndexStorage.GetDocumentQuery(Index, IndexQuery, Database.IndexQueryTriggers);
var returnedReaders = GetQueryMatchingDocuments(currentIndexSearcher, baseQuery);
foreach (var facet in Facets.Values)
{
if (facet.Mode != FacetMode.Default)
{
continue;
}
Dictionary <string, HashSet <IndexSearcherHolder.StringCollectionValue> > distinctItems = null;
HashSet <IndexSearcherHolder.StringCollectionValue> alreadySeen = null;
if (isDistinct)
{
distinctItems = new Dictionary <string, HashSet <IndexSearcherHolder.StringCollectionValue> >();
}
foreach (var readerFacetInfo in returnedReaders)
{
var termsForField = IndexedTerms.GetTermsAndDocumentsFor(readerFacetInfo.Reader, readerFacetInfo.DocBase, facet.Name, Database.Name, Index);
Dictionary <string, FacetValue> facetValues;
if (facetsByName.TryGetValue(facet.DisplayName, out facetValues) == false)
{
facetsByName[facet.DisplayName] = facetValues = new Dictionary <string, FacetValue>();
}
foreach (var kvp in termsForField)
{
if (isDistinct)
{
if (distinctItems.TryGetValue(kvp.Key, out alreadySeen) == false)
{
alreadySeen = new HashSet <IndexSearcherHolder.StringCollectionValue>();
distinctItems[kvp.Key] = alreadySeen;
}
}
var needToApplyAggregation = (facet.Aggregation == FacetAggregation.None || facet.Aggregation == FacetAggregation.Count) == false;
var intersectedDocuments = GetIntersectedDocuments(new ArraySegment <int>(kvp.Value), readerFacetInfo.Results, alreadySeen, needToApplyAggregation);
var intersectCount = intersectedDocuments.Count;
if (intersectCount == 0)
{
continue;
}
FacetValue facetValue;
if (facetValues.TryGetValue(kvp.Key, out facetValue) == false)
{
facetValue = new FacetValue
{
Range = GetRangeName(facet.Name, kvp.Key)
};
facetValues.Add(kvp.Key, facetValue);
}
facetValue.Hits += intersectCount;
facetValue.Count = facetValue.Hits;
if (needToApplyAggregation)
{
var docsInQuery = new ArraySegment <int>(intersectedDocuments.Documents, 0, intersectedDocuments.Count);
ApplyAggregation(facet, facetValue, docsInQuery, readerFacetInfo.Reader, readerFacetInfo.DocBase);
}
}
}
}
foreach (var range in Ranges)
{
var facet = Facets[range.Key];
var needToApplyAggregation = (facet.Aggregation == FacetAggregation.None || facet.Aggregation == FacetAggregation.Count) == false;
Dictionary <string, HashSet <IndexSearcherHolder.StringCollectionValue> > distinctItems = null;
HashSet <IndexSearcherHolder.StringCollectionValue> alreadySeen = null;
if (isDistinct)
{
distinctItems = new Dictionary <string, HashSet <IndexSearcherHolder.StringCollectionValue> >();
}
foreach (var readerFacetInfo in returnedReaders)
{
var termsForField = IndexedTerms.GetTermsAndDocumentsFor(readerFacetInfo.Reader, readerFacetInfo.DocBase, facet.Name, Database.Name, Index);
if (isDistinct)
{
if (distinctItems.TryGetValue(range.Key, out alreadySeen) == false)
{
alreadySeen = new HashSet <IndexSearcherHolder.StringCollectionValue>();
distinctItems[range.Key] = alreadySeen;
}
}
var facetResult = Results.Results[range.Key];
var ranges = range.Value;
foreach (var kvp in termsForField)
{
for (int i = 0; i < ranges.Count; i++)
{
var parsedRange = ranges[i];
if (parsedRange.IsMatch(kvp.Key))
{
var facetValue = facetResult.Values[i];
var intersectedDocuments = GetIntersectedDocuments(new ArraySegment <int>(kvp.Value), readerFacetInfo.Results, alreadySeen, needToApplyAggregation);
var intersectCount = intersectedDocuments.Count;
if (intersectCount == 0)
{
continue;
}
facetValue.Hits += intersectCount;
facetValue.Count = facetValue.Hits;
if (needToApplyAggregation)
{
var docsInQuery = new ArraySegment <int>(intersectedDocuments.Documents, 0, intersectedDocuments.Count);
ApplyAggregation(facet, facetValue, docsInQuery, readerFacetInfo.Reader, readerFacetInfo.DocBase);
IntArraysPool.Instance.FreeArray(intersectedDocuments.Documents);
intersectedDocuments.Documents = null;
}
}
}
}
}
}
UpdateFacetResults(facetsByName);
CompleteFacetCalculationsStage();
foreach (var readerFacetInfo in returnedReaders)
{
IntArraysPool.Instance.FreeArray(readerFacetInfo.Results.Array);
}
}
}
private dynamic Send(byte[] data, int attempts_total = 8) //4
{
if (gate228)
{
dynamic answer = new ExpandoObject();
answer.success = false;
answer.error = string.Empty;
answer.errorcode = DeviceError.NO_ERROR;
byte[] buffer = null;
if (firstStart == 0)
{
byte[] extraBytes1 = new byte[] { 0xDE, 0x65, 0x71, 0x01, 0x00, 0x00, 0x80, 0x7F, 0x20, 0x3F };
byte[] extraBytes2 = new byte[] { 0x27, 0xB7, 0xFC, 0x01, 0x00, 0x04, 0x00, 0x00, 0x01, 0x16, 0x22, 0x04, 0x3C };
SendSimple(extraBytes1);
SendSimple(extraBytes2);
firstStart++;
}
List <byte> dataGate228 = new List <byte>();
dataGate228.Add(01);
dataGate228.Add(00);
if (data.Length > 255)
{
dataGate228.AddRange(BitConverter.GetBytes(data.Length));
}
else
{
dataGate228.Add((byte)(data.Length));
//dataGate228.Add(4);
dataGate228.Add(0);
}
// dataGate228.Add(0);
dataGate228.Add(1);
UInt32 crc24 = Crc24.Compute(dataGate228.ToArray());
dataGate228.InsertRange(0, BitConverter.GetBytes(crc24).Take(3));
byte csLast = (byte)(data.Sum(d => d) - 1);
dataGate228.AddRange(data);
dataGate228.Add(csLast);
for (var attempts = 0; attempts < attempts_total && answer.success == false; attempts++)
{
buffer = SendSimple(dataGate228.ToArray());
buffer = buffer.Skip(8).Take(buffer[5]).ToArray();
log(string.Format("< {0}", string.Join(",", buffer.Select(b => b.ToString("X2")))), level: 3);
if (buffer.Length == 0)
{
answer.error = "Нет ответа";
answer.errorcode = DeviceError.NO_ANSWER;
}
else
{
buffer = buffer.SkipWhile(b => b == 0xff).ToArray();
if (buffer.Length < 4)
{
answer.error = "в кадре ответа не может содежаться менее 4 байт";
answer.errorcode = DeviceError.TOO_SHORT_ANSWER;
}
else
{
UInt32 crc24forcheck = BitConverter.ToUInt32(new byte[] { buffer[0], buffer[1], buffer[2], 0x00 }, 0);
byte cs = (byte)(buffer.Skip(8).Take(buffer.Length - 9).Sum(b => b) - 1);
//if (crc24forcheck != Crc24.Compute(buffer, 3, 5))
//{
// answer.error = "контрольная сумма заголовка не сошлась";
// answer.errorcode = DeviceError.CRC_ERROR;
//}
//else if (cs != buffer[buffer.Length - 1])
//{
// answer.error = "контрольная сумма данных не сошлась";
// answer.errorcode = DeviceError.CRC_ERROR;
//}
answer.success = true;
answer.error = string.Empty;
answer.errorcode = DeviceError.NO_ERROR;
//else
//{
//}
}
}
}
if (answer.success)
{
answer.Body = buffer.Skip(1).ToArray();
//answer.Payload = buffer.Skip(8).Take(buffer.Length - 9).ToArray();
//modbus error
if (buffer.Length == 4)
{
answer.errorcode = DeviceError.DEVICE_EXCEPTION;
answer.exceptioncode = buffer[1];
answer.success = false;
switch (buffer[1])
{
case 0x00:
answer.errorcode = DeviceError.NO_ERROR;
answer.success = true;
answer.error = "все нормально";
break;
case 0x01:
answer.error = "недопустимая команда или параметр";
break;
case 0x02:
answer.error = "внутренняя ошибка счетчика";
break;
case 0x03:
answer.error = "не достаточен уровень доступа для удовлетворения запроса";
break;
case 0x04:
answer.error = "внутренние часы счетчика уже корректировались в течении текущих суток";
break;
case 0x05:
answer.error = "не открыт канал связи";
break;
default:
answer.error = "неизвестная ошибка";
break;
}
}
}
return(answer);
}
else
{
dynamic answer = new ExpandoObject();
answer.success = false;
answer.error = string.Empty;
answer.errorcode = DeviceError.NO_ERROR;
byte[] buffer = null;
for (var attempts = 0; attempts < attempts_total && answer.success == false; attempts++)
{
buffer = SendSimple(data);
if (buffer.Length == 0)
{
answer.error = "Нет ответа";
answer.errorcode = DeviceError.NO_ANSWER;
}
else
{
buffer = buffer.SkipWhile(b => b == 0xff).ToArray();
if (buffer.Length < 4)
{
answer.error = "в кадре ответа не может содежаться менее 4 байт";
answer.errorcode = DeviceError.TOO_SHORT_ANSWER;
}
else if (buffer[0] != NetworkAddress)
{
answer.error = "Несовпадение сетевого адреса";
answer.errorcode = DeviceError.ADDRESS_ERROR;
}
else if (buffer.Length == 4 && buffer[1] == 0x05)
{
answer.error = "Закрыт канал связи";
answer.errorcode = DeviceError.CHANNEL_CLOSED;
}
else if (!Crc.Check(buffer, new Crc16Modbus()))
{
answer.error = "контрольная сумма кадра не сошлась";
answer.errorcode = DeviceError.CRC_ERROR;
for (int i = 0; i < buffer.Length - 1; i++)
{
if ((buffer[i] == 0x0d) && (buffer[i + 1] == 0x0a))
{
for (int j = i + 2; j < buffer.Length - 1; j++)
{
if ((buffer[j] == 0x0d) && (buffer[j + 1] == 0x0a))
{
//var tmp = buffer.Take(i);
//buffer = null;
//buffer = tmp.ToArray();
buffer = buffer.Take(i).ToArray();
if (Crc.Check(buffer, new Crc16Modbus()))
{
answer.success = true;
answer.error = string.Empty;
answer.errorcode = DeviceError.NO_ERROR;
}
}
}
}
}
}
else
{
answer.success = true;
answer.error = string.Empty;
answer.errorcode = DeviceError.NO_ERROR;
}
}
}
if (answer.success)
{
answer.Body = buffer.Skip(1).Take(buffer.Count() - 3).ToArray();
answer.NetworkAddress = buffer[0];
//modbus error
if (buffer.Length == 4)
{
answer.errorcode = DeviceError.DEVICE_EXCEPTION;
answer.exceptioncode = buffer[1];
answer.success = false;
switch (buffer[1])
{
case 0x00:
answer.errorcode = DeviceError.NO_ERROR;
answer.success = true;
answer.error = "все нормально";
break;
case 0x01:
answer.error = "недопустимая команда или параметр";
break;
case 0x02:
answer.error = "внутренняя ошибка счетчика";
break;
case 0x03:
answer.error = "не достаточен уровень доступа для удовлетворения запроса";
break;
case 0x04:
answer.error = "внутренние часы счетчика уже корректировались в течении текущих суток";
break;
case 0x05:
answer.error = "не открыт канал связи";
break;
default:
answer.error = "неизвестная ошибка";
break;
}
}
}
return(answer);
}
}
private dynamic Send(byte[] dataSend)
{
dynamic answer = new ExpandoObject();
answer.success = false;
answer.error = string.Empty;
byte[] data = null;
for (var attempts = 0; attempts < 3 && answer.success == false; attempts++)
{
if (attempts == 0)
{
data = SendSimple(dataSend, 10000, 3);
}
else if (attempts == 1)
{
data = SendSimple(dataSend, 10000, 6);
}
else
{
data = SendSimple(dataSend, 10000, 6);
}
if (data.Length == 0)
{
answer.error = "Нет ответа";
}
else
{
if (data.Length < 5)
{
answer.error = "в кадре ответа не может содежаться менее 5 байт";
}
else if (!Crc.Check(data, new Crc16Modbus()))
{
answer.error = "контрольная сумма кадра не сошлась";
}
else if ((data[1] < 0x80) && (data[1] != dataSend[1]))
{
answer.error = "пришёл ответ на другой запрос";
}
else
{
answer.success = true;
}
}
}
if (answer.success)
{
answer.NetworkAddress = data[0];
answer.Function = data[1];
answer.Length = data[2];
answer.Body = data.Skip(3).Take(data.Length - 5).ToArray();
answer.data = data;
//modbus error
if (answer.Function > 0x80)
{
answer.exceptionCode = (ModbusExceptionCode)data[2];
answer.success = false;
answer.error = string.Format("устройство вернуло ошибку: {0}", answer.exceptionCode);
}
}
return(answer);
}
/// <inheritdoc />
public override string ToString()
{
return string.Format(CultureInfo.InvariantCulture, "Name: '{0}', CRC: 0x{1}", Description, Crc.ToString("X8", CultureInfo.InvariantCulture));
}
public bool ReadOneTransaction(StorageEnvironmentOptions options, bool checkCrc = true)
{
if (_readingPage >= _pager.NumberOfAllocatedPages)
{
return(false);
}
TransactionHeader *current;
if (!TryReadAndValidateHeader(options, out current))
{
return(false);
}
var compressedPages = (current->CompressedSize / AbstractPager.PageSize) + (current->CompressedSize % AbstractPager.PageSize == 0 ? 0 : 1);
if (current->TransactionId <= _lastSyncedTransactionId)
{
LastTransactionHeader = current;
_readingPage += compressedPages;
return(true); // skipping
}
if (checkCrc)
{
uint crc = Crc.Value(_pager.AcquirePagePointer(_readingPage), 0, compressedPages * AbstractPager.PageSize);
if (crc != current->Crc)
{
RequireHeaderUpdate = true;
options.InvokeRecoveryError(this, "Invalid CRC signature for transaction " + current->TransactionId, null);
return(false);
}
}
_recoveryPager.EnsureContinuous(null, _recoveryPage, (current->PageCount + current->OverflowPageCount) + 1);
var dataPage = _recoveryPager.AcquirePagePointer(_recoveryPage);
NativeMethods.memset(dataPage, 0, (current->PageCount + current->OverflowPageCount) * AbstractPager.PageSize);
try
{
LZ4.Decode64(_pager.AcquirePagePointer(_readingPage), current->CompressedSize, dataPage, current->UncompressedSize, true);
}
catch (Exception e)
{
options.InvokeRecoveryError(this, "Could not de-compress, invalid data", e);
RequireHeaderUpdate = true;
return(false);
}
var tempTransactionPageTranslaction = new Dictionary <long, JournalFile.PagePosition>();
for (var i = 0; i < current->PageCount; i++)
{
Debug.Assert(_pager.Disposed == false);
Debug.Assert(_recoveryPager.Disposed == false);
var page = _recoveryPager.Read(_recoveryPage);
tempTransactionPageTranslaction[page.PageNumber] = new JournalFile.PagePosition
{
JournalPos = _recoveryPage,
TransactionId = current->TransactionId
};
if (page.IsOverflow)
{
var numOfPages = _recoveryPager.GetNumberOfOverflowPages(page.OverflowSize);
_recoveryPage += numOfPages;
}
else
{
_recoveryPage++;
}
}
_readingPage += compressedPages;
LastTransactionHeader = current;
foreach (var pagePosition in tempTransactionPageTranslaction)
{
_transactionPageTranslation[pagePosition.Key] = pagePosition.Value;
}
return(true);
}
public bool DecodeFrame(byte[] buffer, int bufferLen)
{
ushort bufferIndex = 0;
if (buffer[bufferIndex] != 0xAA)
{
return(false);
}
bufferIndex += 1;
CmdType = buffer[bufferIndex];
bufferIndex += 1;
CmdByte = buffer[bufferIndex];
bufferIndex += 1;
Array.Copy(buffer, bufferIndex, Pwd, 0, 8);
bufferIndex += 8;
NodeId = Utility.BytesToUint32(buffer, bufferIndex, false);
bufferIndex += 4;
Array.Copy(buffer, bufferIndex, Description, 0, 12);
bufferIndex += 12;
SrcAddr = buffer[bufferIndex];
bufferIndex += 1;
DstAddr = buffer[bufferIndex];
bufferIndex += 1;
DataLen = Utility.BytesToUint16(buffer, bufferIndex, false);
bufferIndex += 2;
Array.Copy(buffer, bufferIndex, Data, 0, DataLen);
bufferIndex += DataLen;
var crc1 = Crc.GetUsmbcrc16(buffer, bufferIndex);
var crc2 = Utility.BytesToUint16(buffer, bufferIndex, false);
bufferIndex += 2;
if (crc1 != crc2)
{
return(false);
}
if (buffer[bufferIndex] != 0xDD)
{
return(false);
}
bufferIndex += 1;
if (bufferLen != bufferIndex)
{
return(false);
}
return(true);
}
//public Guid GetObjectId(byte[] bytesObjectId, string imei, UInt32 networkAddress)
//{
// Guid nullGuid = new Guid();
// Guid objectId = new Guid(bytesObjectId);
// if (objectId == nullGuid || (bytesObjectId[0] == 0xFF && bytesObjectId[1] == 0xFF))
// {
// objectId = GetObjectId(imei, networkAddress);
// }
// return objectId;
//}
private void Idle()
{
try
{
while (true)
{
var buffer = new byte[BUFFER_SIZE];
var readed = socket.Receive(buffer);
if (readed == 0)
{
throw new Exception("пришло 0 байт");
//log.Debug(string.Format("[{0}] пришло 0 байт", GetImei()));
}
else
{
byte[] bytes = buffer.Take(readed).ToArray();
subscriber?.Invoke(bytes);
if (subscriber == null) // 12.03.2019
{
if (bytes.Length < 5)
{
if (bytes.Length == 2 && (bytes[0] + bytes[1] == 0xFF))
{
SendDataToSocket(bytes);
}
else if (bytes.Length == 3 && ((byte)((bytes[1] >> 4) | (bytes[1] << 4)) == bytes[2]))
{
try
{
Guid objectId = GetObjectId <byte>(GetImei(), bytes[0]);
ModbusControl.Instance.Request(new Guid[] { objectId }, bytes[1].ToString(), GetImei(), "Abnormal");
}
catch (Exception ex)
{
}
log.Error("событие");
}
log.Error($"количество байтов пришло {bytes.Length} < 5");
}
else if (Crc.Check(bytes, new Crc16Modbus()))
{
if (bytes[0] == 0xFB) //вместо СА используется CID
{
//if (bytes[13] == 0x60) // не работает еще
//{
// byte[] byteConfig = bytes.Skip(1).Take(bytes.Length - 4).ToArray();
// //tsConfig conf = setBytes(byteConfig);
// EditNode(BitConverter.ToString(byteConfig));
//}
if (bytes[13] == 0x4D) //длинный СА
{
DateTime dt1970 = new DateTime(1970, 1, 1, 0, 0, 0, 0);
byte[] bytesCId = bytes.Skip(1).Take(12).ToArray();
string strCId = BitConverter.ToString(bytesCId).Replace("-", "");
byte func = bytes[13];
byte[] bytesObjectId = bytes.Skip(14).Take(16).ToArray();
UInt32 networkAddress = Helper.ToUInt32(bytes, 30);
//byte networkAddress = bytes[30];
Guid objectId = GetObjectId <UInt32>(bytesObjectId, GetImei(), networkAddress);
byte[] byteTime = bytes.Skip(34).Take(4).ToArray(); //31
UInt32 uInt32Time = (UInt32)(byteTime[3] << 24) | (UInt32)(byteTime[2] << 16) | (UInt32)(byteTime[1] << 8) | byteTime[0];
DateTime dtContollers = dt1970.AddSeconds(uInt32Time);
UInt16 code = Helper.ToUInt16(bytes, 38);
DateTime[] dtEvent = new DateTime[16];
for (int i = 0; i < 16; i++)
{
if (i == 7)
{
byte[] byteTime1 = bytes.Skip(40 + i * 4).Take(4).ToArray(); //31
UInt32 uInt32Time1 = (UInt32)(byteTime1[3] << 24) | (UInt32)(byteTime1[2] << 16) | (UInt32)(byteTime1[1] << 8) | byteTime1[0];
dtEvent[i] = dt1970.AddSeconds(uInt32Time1);
}
else
{
dtEvent[i] = u32ToBytes(bytes.Skip(40 + i * 4).Take(4).ToArray());
}
//byte[] byteTime1 = bytes.Skip(37 + i*4 ).Take(4).ToArray();
//UInt32 uInt32Time1 = (UInt32)(byteTime1[3] << 24) | (UInt32)(byteTime1[2] << 16) | (UInt32)(byteTime1[1] << 8) | byteTime1[0];
//dtEvent[i] = dt1970.AddSeconds(uInt32Time1);
}
byte[] arrParams = new byte[] { 0x01, 0x02, 0x07, 0x08, 0x0A, 0x12, 0x13, 0x00 };
List <dynamic> records = new List <dynamic>();
for (int i = 0; i < arrParams.Length; i++)
{
if (((byte)(code >> i) & 1) == 1 && dtEvent[i] != DateTime.MinValue)
{
records.Add(MakeAbnormalRecord(objectId, ParamName(arrParams[i]), MessageParam(arrParams[i]), dtEvent[i], 1));
}
}
if (records.Any())
{
RecordsAcceptor.Instance.Save(records);
}
}
}
else
{
if (bytes[1] == 0x60)
{
byte[] byteConfig = bytes.Skip(2).Take(bytes.Length - 4).ToArray();
EditNode(BitConverter.ToString(byteConfig));
}
}
//tsConfig conf = setBytes(bytes);
//SendDataToSocket(ModbusControl.Instance.TeleofisWrx(bytes, GetImei()));
}
else
{
if ((bytes[0] == 0x0A && bytes[1] == 0x0D) || (bytes[bytes.Length - 2] == 0x0A && bytes[bytes.Length - 1] == 0x0D))
{
List <byte> bufferTmp = bytes.ToList();
while (bufferTmp.Count > 5 && (bufferTmp[0] == 0x0A && bufferTmp[1] == 0x0D))
{
bufferTmp.RemoveRange(0, 2);
}
while (bufferTmp.Count > 5 && (bufferTmp[bufferTmp.Count - 2] == 0x0A && bufferTmp[bufferTmp.Count - 1] == 0x0D))
{
bufferTmp.RemoveRange(bufferTmp.Count - 2, 2);
}
bytes = null;
bytes = bufferTmp.ToArray();
if (!Crc.Check(bytes, new Crc16Modbus()))
{
log.Error("контрольная сумма кадра не сошлась");
}
else
{
SendDataToSocket(ModbusControl.Instance.TeleofisWrx(bytes, GetImei()));
}
}
}
}
}
}
}
catch (Exception oex)
{
log.Error(string.Format("[{0}] поток слушающий сокет остановлен", GetImei()), oex);
CloseSocket();
}
}
public System.Collections.IEnumerator UnzipProcess(object obj)
{
float step = 0.5f / ResManager.RES_NUM;
for (int i = 0; i < ResManager.RES_NUM; ++i)
{
ResType rt = (ResType)i;
string path = RuntimeInfo.GetResStreamingPath(rt);
string destPath = RuntimeInfo.GetResPersistentPath(rt);
string destPathTemp = destPath + ".temp";
WWW www = new WWW(path);
while (www.isDone == false)
{
yield return(new WaitForEndOfFrame());
}
if (www.bytes == null || www.bytes.Length == 0)
{
m_Error = "资源解压失败:" + path;
LogMgr.Log("解压失败，未找到文件:" + www.error + ", Path:" + path);
yield break;
}
try
{
FileInfo fi = new FileInfo(destPathTemp);
if (fi.Exists)
{
fi.Delete();
}
FileStream fss = fi.Create();
fss.Write(www.bytes, 0, www.bytes.Length);
fss.Flush();
fss.Close();
LZMA.DecompressFile(destPathTemp, destPath);
if (fi.Exists)
{
fi.Delete();
}
m_Progress += step;
}
catch (System.Exception e)
{
m_Error = "资源解压失败:" + path;
ReportException.Instance.AddException("Exception:解压文件失败: " + e.ToString());
yield break;
}
yield return(new WaitForEndOfFrame());
try
{
m_ResVer[i].ResCrc = Crc.Crc32FromFile(destPathTemp);
FileInfo ff = new FileInfo(destPath);
m_ResVer[i].ResSize = (uint)ff.Length;
m_Progress += step;
}
catch (System.Exception e)
{
m_Error = "计算CRC失败:" + path;
ReportException.Instance.AddException("Exception:计算文件CRC失败: " + e.ToString());
yield break;
}
File.Delete(destPathTemp);
yield return(new WaitForEndOfFrame());
}
m_bHasVerFile = true;
m_Progress = 1.0f;
if (!SaveVersion())
{
ReportException.Instance.AddException("Exception:保存版本文件失败:");
}
yield break;
}
public MainWindow()
{
InitializeComponent();
Loaded += new RoutedEventHandler(InitSerialPort); //Serial 받기
Thread thread = new Thread(processMain);
thread.Start();
//Thread thread_uwb = new Thread(process_UWB);
//thread_uwb.Start();
//Thread thread_uwb2 = new Thread(process_UWB_2);
//thread_uwb2.Start();
Thread thread_ui = new Thread(Update_ui);
thread_ui.Start();
timer = new System.Windows.Forms.Timer();
timer.Tick += timer_Tick;
timer.Interval = 100;
timer.Start();
//Box_In_Event.Interval = new TimeSpan(0, 0, 0, 0, 100);
//Box_In_Event.Tick += new EventHandler(Text_box_in);
//Box_In_Event.Start();
// COP_Draw_Event.Interval = new TimeSpan(0, 0, 0, 0, 30);
// COP_Draw_Event.Tick += new EventHandler(COP_Cal);
// COP_Draw_Event.Start();
crc = new CRC.Crc(CRC.CrcStdParams.StandartParameters[CRC.CrcAlgorithms.Crc32Mpeg2]);
//COP 계산 변수
//Left position
posx[0] = -162.35f + 0.25f * w;
posx[1] = -162.35f + 0.25f * w;
posx[2] = -162.35f - 0.25f * w;
posx[3] = -162.35f - 0.25f * w;
posx[4] = -162.35f;
//Right position
posx[5] = 162.35f - 0.25f * w;
posx[6] = 162.35f - 0.25f * w;
posx[7] = 162.35f + 0.25f * w;
posx[8] = 162.35f + 0.25f * w;
posx[9] = 162.35f;
posy[0] = 0.7f * l;
posy[1] = 0.58f * l;
posy[2] = 0.49f * l;
posy[3] = 0.35f * l;
posy[4] = 0f;
posy[5] = 0.7f * l;
posy[6] = 0.58f * l;
posy[7] = 0.49f * l;
posy[8] = 0.35f * l;
posy[9] = 0f;
}
private void CheckConnection(object arg)
{
try
{
Thread.CurrentThread.IsBackground = true;
var socket = arg as Socket;
socket.Send(TELEOFIS_TCP_AUTH_START);
var buffer = new byte[64 * 1024];
var readed = socket.Receive(buffer);
string imei = "";
if (readed == 71 && buffer[0] == 0xC0 && buffer[1] == 0x00 && buffer[2] == 0x07 && buffer[3] == 0x00 && buffer[4] == 0x3F && buffer[70] == 0xC2)
{
byte[] data = buffer.Skip(5).Take(63).ToArray();
byte authCount = data[0];
imei = Encoding.ASCII.GetString(data.Skip(1).Take(15).ToArray());
}
var regex = new Regex(@"[0-9]{15}");
var match = regex.Match(imei);
var remote = socket.RemoteEndPoint.ToString();
//проверяем имей ли это
if (match.Success)
{
socket.Send(TELEOFIS_TCP_AUTH_END);
var terminal = NodeManager.Instance.GetNodes <MatrixTerminalConnectionNode>().FirstOrDefault(m => m.GetImei() == imei);
if (terminal == null)
{
log.Warn(string.Format("контроллер с imei '{0}' не зарегистрирован на сервере, идет сохранение", imei));
var api = UnityManager.Instance.Resolve <IConnector>();
dynamic message = Helper.BuildMessage("edit");
var id = Guid.NewGuid();
dynamic rule1 = new ExpandoObject();
rule1.action = "add";
rule1.target = "node";
rule1.content = new ExpandoObject();
rule1.content.id = id;
rule1.content.type = "MatrixTerminalConnection";
rule1.content.body = new ExpandoObject();
rule1.content.body.id = id;
rule1.content.body.imei = imei;
rule1.content.body.type = "MatrixTerminalConnection";
rule1.content.body.created = DateTime.Now;
dynamic rule2 = new ExpandoObject();
rule2.action = "add";
rule2.target = "relation";
rule2.content = new ExpandoObject();
rule2.content.start = id;
rule2.content.end = GetId();
rule2.content.type = "contains";
rule2.content.body = new ExpandoObject();
message.body.rules = new List <dynamic>();
message.body.rules.Add(rule1);
message.body.rules.Add(rule2);
api.SendMessage(message);
//socket.Close();
return;
}
terminal.OpenSocket(socket);
log.InfoFormat("[{0}] получено соединение контроллера: IMEI={1}, IP={2}", this, imei, remote);
var crc = Crc.Calc(MATRIX_TERMINAL_GET_CONFIG, new Crc16Modbus());
List <byte> byteForSend = new List <byte>();
byteForSend.AddRange(MATRIX_TERMINAL_GET_CONFIG);
byteForSend.Add(crc.CrcData[1]);
byteForSend.Add(crc.CrcData[0]);
Thread.Sleep(1000 * 2);
socket.Send(byteForSend.ToArray());
return;
}
else
{
log.WarnFormat("[{0}] соединение не соответствующее протоколу ({1}); соединение разорвано", this, imei);
socket.Close();
}
}
catch (Exception ex)
{
log.Error(string.Format("[{0}] ошибка при приеме соединения", this), ex);
}
}
public Dictionary <string, string> GetFilterDictionary(List <string> values)
{
Dictionary <string, string> d = new Dictionary <string, string>();
foreach (string s in values)
{
if (d.ContainsKey(s))
{
continue;
}
if (s == "name")
{
d.Add("name", Name);
}
else if (s == "hash")
{
d.Add("hash", Hash.ToString());
}
else if (s == "crc")
{
d.Add("crc", Crc.ToString());
}
else if (s == "type")
{
d.Add("type", Type);
}
else if (s == "matched")
{
d.Add("matched", Matched.ToString());
}
else if (s == "valid")
{
d.Add("valid", Valid.ToString());
}
else if (s == "references")
{
d.Add("references", ReferencesCount.ToString());
}
else if (s == "referenced")
{
d.Add("referenced", ReferencedCount.ToString());
}
else if (s == "file")
{
d.Add("file", Location);
}
else
{
foreach (INIParameter p in parameters)
{
if (p.Name == s)
{
d.Add(s, p[0].Value);
}
}
}
}
return(d);
}
private void EditButton_Click(object sender, EventArgs e)
{
bAddNew = false;
ControlBehaviour(false);
Crc.Focus();
}
static Vfd()
{
crc = new Crc(CrcStdParams.StandartParameters[CrcAlgorithms.Crc16Modbus]);
crc.Initialize();
}
public virtual void Save(System.IO.Stream stream)
{
byte [] name_bytes = System.Text.Encoding.ASCII.GetBytes (Name);
byte [] length_bytes = BitConverter.GetBytes ((uint)data.Length, false);
stream.Write (length_bytes, 0, length_bytes.Length);
Crc crc = new Crc (stream);
crc.Write (name_bytes);
crc.Write (data);
crc.WriteSum ();
}
/// <inheritdoc />
public override int GetHashCode()
{
return Crc.GetHashCode();
}
private bool ReadByte(ReadBuffer readBuffer)
{
var currentByte = readBuffer[readBuffer.Index++];
switch (this.state)
{
case State.BeforeFrame:
if (currentByte == Frame.BeginOfFrame)
{
this.state = State.InFrame;
}
else
{
this.outOfFrameByteReceived(currentByte);
}
break;
case State.InFrame:
if (currentByte < Frame.InvalidStart)
{
this.crc = Crc.AddCrcCcitt(this.crc, currentByte);
this.decodedQueue.Enqueue(currentByte);
}
else
{
switch (currentByte)
{
case Frame.EscapeByte:
this.state = State.InFrameEscaped;
break;
case Frame.BeginOfFrame:
this.decodedQueue.Clear();
this.crc = 0xFFFF;
break;
case Frame.EndOfFrame:
this.state = State.AfterFrame;
if (this.crc != 0xF0B8)
{
this.decodedQueue.Clear();
}
return(false);
default:
this.state = State.AfterFrame;
this.decodedQueue.Clear();
break;
}
}
break;
case State.InFrameEscaped:
if (currentByte >= Frame.InvalidStart)
{
this.state = State.AfterFrame;
this.decodedQueue.Clear();
}
currentByte = (byte)(currentByte ^ Frame.EscapeXor);
this.crc = Crc.AddCrcCcitt(this.crc, currentByte);
this.decodedQueue.Enqueue(currentByte);
this.state = State.InFrame;
break;
}
return(true);
}
public bool CheckCrc(uint value)
{
byte [] name = System.Text.Encoding.ASCII.GetBytes (Name);
Crc crc = new Crc ();
crc.Write (name);
crc.Write (data);
return crc.Value == value;
}
private dynamic Send(byte[] data)
{
dynamic answer = new ExpandoObject();
answer.success = false;
answer.error = string.Empty;
answer.errorcode = DeviceError.NO_ERROR;
answer.code = 0;
byte[] buffer = null;
for (var attempt = 0; attempt < 3 && answer.success == false; attempt++)
{
buffer = SendSimple(data, attempt);
if (buffer.Length == 0)
{
answer.error = "Нет ответа";
answer.errorcode = DeviceError.NO_ANSWER;
}
else
{
if (buffer.Length <= 4)
{
answer.error = "Слишком короткий ответ";
answer.errorcode = DeviceError.TOO_SHORT_ANSWER;
}
else if (!Crc.Check(buffer.ToArray(), new Crc16Modbus()))
{
answer.error = "Не сошлась контрольная сумма";
answer.errorcode = DeviceError.CRC_ERROR;
}
else if (buffer[1] >= 0x80)
{
var code = buffer[2];
answer.errorcode = DeviceError.DEVICE_EXCEPTION;
switch (code)
{
case 2:
answer.error = "Несуществующий тип значений";
break;
case 3:
answer.error = "В архиве отсутствуют данные за эту дату";
break;
case 5:
answer.error = "Зафиксировано изменение схемы измерения";
break;
}
answer.code = code;
}
else
{
answer.success = true;
answer.error = string.Empty;
}
}
}
if (answer.success)
{
answer.code = 0;
answer.NetworkAddress = buffer[0];
answer.Function = buffer[1];
answer.data = buffer;
answer.Body = buffer.Skip(2).Take(buffer.Length - 4).ToArray();
}
return(answer);
}
private dynamic Send(byte[] data)
{
dynamic answer = new ExpandoObject();
answer.success = false;
answer.error = string.Empty;
answer.errorcode = DeviceError.NO_ERROR;
byte[] buffer = null;
//var attempts_total = (packagesSent > 0) ? SEND_ATTEMPTS_COUNT : 1; // непонятный оператор 04.03.2019
var attempts_total = SEND_ATTEMPTS_COUNT;
for (var attempts = 0; (attempts < attempts_total) && (answer.success == false); attempts++)
{
var timeout = TIMEOUT_TIME_MIN * (attempts + 1);
buffer = SendSimple(data, timeout);
if (buffer.Length == 0)
{
answer.error = "Нет ответа";
answer.errorcode = DeviceError.NO_ANSWER;
}
else
{
if (buffer.Length < 5)
{
answer.errorcode = DeviceError.TOO_SHORT_ANSWER;
answer.error = "в кадре ответа не может содержаться менее 5 байт";
}
else if (!Crc.CheckReverse(buffer, new Crc16Modbus()))
{
answer.errorcode = DeviceError.CRC_ERROR;
answer.error = "контрольная сумма кадра не сошлась";
answer = xOAxOD(buffer);
if (answer.success)
{
buffer = answer.buffer;
}
}
else
{
answer.success = true;
answer.error = string.Empty;
answer.errorcode = DeviceError.NO_ERROR;
}
}
}
if (answer.success)
{
var offset = 0;
answer.NetworkAddress = buffer[0];
if (answer.NetworkAddress == 251)
{
offset = 12;
}
answer.Function = buffer.Skip(offset + 1).FirstOrDefault();
answer.Body = buffer.Skip(offset + 2).Take(buffer.Length - (offset + 2 + 2)).ToArray();
//modbus error
if (answer.Function > 0x80)//0xc1)
{
answer.errorcode = DeviceError.DEVICE_EXCEPTION;
answer.success = false;
answer.exceptionCode = buffer.Skip(offset + 2).FirstOrDefault();
string exceptionMessage = deviceExceptionMessage.ContainsKey(answer.exceptionCode) ? deviceExceptionMessage[answer.exceptionCode] : "";
answer.error = $"устройство вернуло ошибку: {answer.exceptionCode} {exceptionMessage}";
}
}
mid++;
return(answer);
}
private dynamic All(string components, List <dynamic> hourRanges, List <dynamic> dayRanges, IEnumerable <int> channels)
{
var rules = new[] {
//0
new { offset = 0x00000000, length = 0x00000002 },
new { offset = 0x00000011, length = 0x00000001 },
new { offset = 0x00000023, length = 0x00000001 },
new { offset = 0x00000028, length = 0x00000002 },
new { offset = 0x00000033, length = 0x00000001 },
new { offset = 0x0000003f, length = 0x00000001 },
new { offset = 0x0000004d, length = 0x00000001 },
new { offset = 0x00000059, length = 0x00000001 },
new { offset = 0x0000006b, length = 0x00000001 },
new { offset = 0x00000079, length = 0x00000001 },
//10
new { offset = 0x00000085, length = 0x00000001 },
new { offset = 0x00000097, length = 0x00000001 },
new { offset = 0x000000a5, length = 0x00000001 },
new { offset = 0x000000b1, length = 0x00000001 },
new { offset = 0x000000c1, length = 0x00000001 },
new { offset = 0x000000cd, length = 0x00000001 },
new { offset = 0x000000db, length = 0x00000001 },
new { offset = 0x000000e7, length = 0x00000001 },
new { offset = 0x000000f9, length = 0x00000001 },
new { offset = 0x00000107, length = 0x00000001 },
//20
new { offset = 0x00000113, length = 0x00000001 },
new { offset = 0x00000125, length = 0x00000001 },
new { offset = 0x00000133, length = 0x00000001 },
new { offset = 0x0000013f, length = 0x00000001 },
new { offset = 0x00000147, length = 0x00000001 },
new { offset = 0x00000200, length = 0x00000002 },
new { offset = 0x00000211, length = 0x00000001 },
new { offset = 0x00000223, length = 0x00000001 },
new { offset = 0x00000228, length = 0x00000002 },
new { offset = 0x00000204, length = 0x00000026 },
//30
new { offset = 0x0000022a, length = 0x00000001 },
new { offset = 0x0000022e, length = 0x00000002 },
new { offset = 0x000002b8, length = 0x00000001 },
new { offset = 0x000002bc, length = 0x00000002 }
};
//var server = ParseReadServerVersionResponse(Send(MakeReadDataRequest()));
int serverVersion = 1;
//if (server.success)
//{
// log(string.Format("Версия сервера: {0}", server.version));
// serverVersion = server.version;
//}
//else
//{
// log(string.Format("Версия сервера не получена: {0}", server.error));
// serverVersion = 0;
//}
var date = DateTime.MinValue;
dynamic info = null;
var constants = new List <dynamic>();
var currents = new List <dynamic>();
info = ParseReadInfoResponse(Send(MakeReadInfoRequest()));
if (!info.success)
{
log(string.Format("Ошибка при считывании текущей даты на вычислителе: {0}", info.error), level: 1);
return(MakeResult(102, info.errorcode, info.error));
}
setContractDay(info.TotalDay);
var curDate = ParseReadCurrentDateResponse(Send(MakeReadCurrentDateRequest()), info.Version);
if (!curDate.success)
{
log(string.Format("Ошибка при считывании текущей даты на вычислителе: {0}", curDate.error), level: 1);
return(MakeResult(102, curDate.errorcode, curDate.error));
}
date = curDate.Date;
setTimeDifference(DateTime.Now - date);
log(string.Format("Дата/время на вычислителе: {0:dd.MM.yy HH:mm:ss}", date));
if (getEndDate == null)
{
getEndDate = (type) => date;
}
if (components.Contains("Constant"))
{
var constant = GetConstants(date, info);
if (!constant.success)
{
log(string.Format("Ошибка при считывании констант: {0}", constant.error));
return(MakeResult(103, constant.errorcode, constant.error));
}
constants = constant.records as List <dynamic>;
byte[] db;
{
List <byte> temp = new List <byte>();
for (int i = 0; i < 8; i++)
{
var writeDb1 = ParseWriteResponse(Send(MakeWriteRequest(0x3ff7, 2, BitConverter.GetBytes((UInt16)(1320 + i)))));
if (!writeDb1.success)
{
log(string.Format("Ошибка при считывании констант: {0}", writeDb1.error));
return(MakeResult(103, writeDb1.errorcode, writeDb1.error));
}
var readDb1 = ParseReadResponse(Send(MakeReadRequest(0x3ff8, 0x80)));
if (!readDb1.success)
{
log(string.Format("Ошибка при считывании констант: {0}", readDb1.error));
return(MakeResult(103, readDb1.errorcode, readDb1.error));
}
temp.AddRange(readDb1.Body as IEnumerable <byte>);
//byte[] data = (readDb1.Body as IEnumerable<byte>).ToArray();
}
db = temp.ToArray();
}
{
byte A = db[0x212];
byte B = db[0x213];
foreach (var r in rules)
{
for (int i = 0; i < r.length; i++)
{
db[r.offset + i] = 0;
}
}
if (info.Version >= 0x22)
{
db[0x212] = A;
db[0x213] = B;
}
}
var crc = Crc.Calc(db, new Crc16Modbus());
constants.Add(MakeConstRecord("КС", $"0x{crc.CrcData[1]:X2}{crc.CrcData[0]:X2}", date));
constants.Add(MakeConstRecord("tх, град. C", (double)BitConverter.ToInt16(db, 18) / 100.0, date));
log(string.Format("Константы прочитаны: всего {0}, отчётный день={1}", constants.Count, constant.TotalDay));
records(constants);
}
//
MOCK_ZONE = true;
var properties = GetProperties(serverVersion);
if (!properties.success)
{
log(string.Format("Ошибка при считывании свойств: {0}", properties.error), level: 1);
return(MakeResult(103, properties.errorcode, properties.error));
}
log(string.Format("Свойства прочитаны: всего - ед. измерений {0}, дробных частей {1}", properties.Units.Count, properties.Fracs.Count), level: 1);
MOCK_ZONE = false;
if (components.Contains("Current"))
{
var current = GetCurrents(properties, date, channels);
if (!current.success)
{
log(string.Format("Ошибка при считывании текущих и констант: {0}", current.error), level: 1);
return(MakeResult(102, current.errorcode, current.error));
}
currents = current.records;
log(string.Format("Текущие на {0} прочитаны: всего {1}", current.date, currents.Count), level: 1);
records(currents);
}
//records(cncs.constants);
List <dynamic> hours = new List <dynamic>();
List <dynamic> days = new List <dynamic>();
List <dynamic> months = new List <dynamic>();
if (components.Contains("Hour"))
{
if (hourRanges != null)
{
foreach (var range in hourRanges)
{
var startH = range.start;
var endH = range.end;
if (startH > date)
{
continue;
}
if (endH > date)
{
endH = date;
}
var hour = GetHours(startH, endH, date, properties, channels);
if (!hour.success)
{
log(string.Format("Ошибка при считывании часовых: {0}", hour.error), level: 1);
return(MakeResult(105, hour.errorcode, hour.error));
}
hours = hour.records;
log(string.Format("Прочитаны часовые с {0:dd.MM.yyyy HH:mm} по {1:dd.MM.yyyy HH:mm}: {2} записей", startH, endH, hours.Count), level: 1);
}
}
else
{
//чтение часовых
var startH = getStartDate("Hour");
var endH = getEndDate("Hour");
var hour = GetHours(startH, endH, date, properties, channels);
if (!hour.success)
{
log(string.Format("Ошибка при считывании часовых: {0}", hour.error), level: 1);
return(MakeResult(105, hour.errorcode, hour.error));
}
hours = hour.records;
log(string.Format("Прочитаны часовые с {0:dd.MM.yyyy HH:mm} по {1:dd.MM.yyyy HH:mm}: {2} записей", startH, endH, hours.Count), level: 1);
}
}
if (components.Contains("Day"))
{
if (dayRanges != null)
{
foreach (var range in dayRanges)
{
var startD = range.start;
var endD = range.end;
if (startD > date)
{
continue;
}
if (endD > date)
{
endD = date;
}
var day = GetDays(startD, endD, date, properties, info.TotalDay, channels);
if (!day.success)
{
log(string.Format("Ошибка при считывании суточных: {0}", day.error), level: 1);
return(MakeResult(104, day.errorcode, day.error));
}
days = day.records;
log(string.Format("Прочитаны суточные с {0:dd.MM.yyyy} по {1:dd.MM.yyyy}: {2} записей", startD, endD, days.Count), level: 1);
}
}
else
{
//чтение суточных
var startD = getStartDate("Day");
var endD = getEndDate("Day");
var day = GetDays(startD, endD, date, properties, info.TotalDay, channels);
if (!day.success)
{
log(string.Format("Ошибка при считывании суточных: {0}", day.error), level: 1);
return(MakeResult(104, day.errorcode, day.error));
}
days = day.records;
log(string.Format("Прочитаны суточные с {0:dd.MM.yyyy} по {1:dd.MM.yyyy}: {2} записей", startD, endD, days.Count), level: 1);
}
}
if (components.Contains("Day") && monthPoll)
{
//чтение ежемесячных
var startM = date.AddMonths(-3);
var endM = date;
var month = GetMonths(startM, endM, date, properties, info.TotalDay);
if (!month.success)
{
log(string.Format("Ошибка при считывании ежемесячных: {0}", month.error), level: 1);
return(MakeResult(104, month.errorcode, month.error));
}
months = month.records;
log(string.Format("Прочитаны ежемесячные с {0:MM.yyyy} по {1:MM.yyyy}: {2} записей", startM, endM, months.Count), level: 1);
}
///// Нештатные ситуации ///
//var lastAbnormal = getLastTime("Abnormal");
//DateTime startAbnormal = lastAbnormal.AddHours(-constant.contractHour).Date;
//DateTime endAbnormal = current.date;
//var abnormal = GetAbnormals(startAbnormal, endAbnormal);
//if (!abnormal.success)
//{
// log(string.Format("ошибка при считывании НС: {0}", abnormal.error));
// return;
//}
//log(string.Format("Успешно прочитано: {0}/{1}/{2}/{3}/{4} записей", constants.Count, currents.Count, days.Count, hours.Count, months.Count));
return(MakeResult(0, DeviceError.NO_ERROR, "опрос успешно завершен"));
}
public void ToFile(StorageEnvironment env, string backupPath, CompressionLevel compression = CompressionLevel.Optimal, Action <string> infoNotify = null,
Action backupStarted = null)
{
if (env.Options.IncrementalBackupEnabled == false)
{
throw new InvalidOperationException("Incremental backup is disabled for this storage");
}
var pageNumberToPageInScratch = new Dictionary <long, long>();
if (infoNotify == null)
{
infoNotify = str => { }
}
;
var toDispose = new List <IDisposable>();
try
{
IncrementalBackupInfo backupInfo;
long lastWrittenLogPage = -1;
long lastWrittenLogFile = -1;
using (var txw = env.NewTransaction(TransactionFlags.ReadWrite))
{
backupInfo = env.HeaderAccessor.Get(ptr => ptr->IncrementalBackup);
if (env.Journal.CurrentFile != null)
{
lastWrittenLogFile = env.Journal.CurrentFile.Number;
lastWrittenLogPage = env.Journal.CurrentFile.WritePagePosition;
}
//txw.Commit(); - intentionally not committing
}
if (backupStarted != null)
{
backupStarted();
}
infoNotify("Voron - reading storage journals for snapshot pages");
var lastBackedUpFile = backupInfo.LastBackedUpJournal;
var lastBackedUpPage = backupInfo.LastBackedUpJournalPage;
var firstJournalToBackup = backupInfo.LastBackedUpJournal;
if (firstJournalToBackup == -1)
{
firstJournalToBackup = 0; // first time that we do incremental backup
}
var lastTransaction = new TransactionHeader {
TransactionId = -1
};
var recoveryPager = env.Options.CreateScratchPager("min-inc-backup.scratch");
toDispose.Add(recoveryPager);
int recoveryPage = 0;
for (var journalNum = firstJournalToBackup; journalNum <= backupInfo.LastCreatedJournal; journalNum++)
{
lastBackedUpFile = journalNum;
var journalFile = IncrementalBackup.GetJournalFile(env, journalNum, backupInfo);
try
{
using (var filePager = env.Options.OpenJournalPager(journalNum))
{
var reader = new JournalReader(filePager, recoveryPager, 0, null, recoveryPage);
reader.MaxPageToRead = lastBackedUpPage = journalFile.JournalWriter.NumberOfAllocatedPages;
if (journalNum == lastWrittenLogFile) // set the last part of the log file we'll be reading
{
reader.MaxPageToRead = lastBackedUpPage = lastWrittenLogPage;
}
if (lastBackedUpPage == journalFile.JournalWriter.NumberOfAllocatedPages) // past the file size
{
// move to the next
lastBackedUpPage = -1;
lastBackedUpFile++;
}
if (journalNum == backupInfo.LastBackedUpJournal) // continue from last backup
{
reader.SetStartPage(backupInfo.LastBackedUpJournalPage);
}
TransactionHeader *lastJournalTxHeader = null;
while (reader.ReadOneTransaction(env.Options))
{
// read all transactions here
lastJournalTxHeader = reader.LastTransactionHeader;
}
if (lastJournalTxHeader != null)
{
lastTransaction = *lastJournalTxHeader;
}
recoveryPage = reader.RecoveryPage;
foreach (var pagePosition in reader.TransactionPageTranslation)
{
var pageInJournal = pagePosition.Value.JournalPos;
var page = recoveryPager.Read(null, pageInJournal);
pageNumberToPageInScratch[pagePosition.Key] = pageInJournal;
if (page.IsOverflow)
{
var numberOfOverflowPages = recoveryPager.GetNumberOfOverflowPages(page.OverflowSize);
for (int i = 1; i < numberOfOverflowPages; i++)
{
pageNumberToPageInScratch.Remove(page.PageNumber + i);
}
}
}
}
}
finally
{
journalFile.Release();
}
}
if (pageNumberToPageInScratch.Count == 0)
{
infoNotify("Voron - no changes since last backup, nothing to do");
return;
}
infoNotify("Voron - started writing snapshot file.");
if (lastTransaction.TransactionId == -1)
{
throw new InvalidOperationException("Could not find any transactions in the journals, but found pages to write? That ain't right.");
}
// it is possible that we merged enough transactions so the _merged_ output is too large for us.
// Voron limit transactions to about 4GB each. That means that we can't just merge all transactions
// blindly, for fear of hitting this limit. So we need to split things.
// We are also limited to about 8 TB of data in general before we literally can't fit the number of pages into
// pageNumberToPageInScratch even theoretically.
// We're fine with saying that you need to run min inc backup before you hit 8 TB in your increment, so that works for now.
// We are also going to use env.Options.MaxScratchBufferSize to set the actual transaction limit here, to avoid issues
// down the road and to limit how big a single transaction can be before the theoretical 4GB limit.
var nextJournalNum = lastBackedUpFile;
using (var file = new FileStream(backupPath, FileMode.Create))
{
using (var package = new ZipArchive(file, ZipArchiveMode.Create, leaveOpen: true))
{
var copier = new DataCopier(AbstractPager.PageSize * 16);
var finalPager = env.Options.CreateScratchPager("min-inc-backup-final.scratch");
toDispose.Add(finalPager);
finalPager.EnsureContinuous(null, 0, 1);//txHeader
foreach (var partition in Partition(pageNumberToPageInScratch.Values, env.Options.MaxNumberOfPagesInMergedTransaction))
{
int totalNumberOfPages = 0;
int overflowPages = 0;
int start = 1;
foreach (var pageNum in partition)
{
var p = recoveryPager.Read(null, pageNum);
var size = 1;
if (p.IsOverflow)
{
size = recoveryPager.GetNumberOfOverflowPages(p.OverflowSize);
overflowPages += (size - 1);
}
totalNumberOfPages += size;
finalPager.EnsureContinuous(null, start, size); //maybe increase size
Memory.Copy(finalPager.AcquirePagePointer(null, start), p.Base, size * AbstractPager.PageSize);
start += size;
}
var txPage = finalPager.AcquirePagePointer(null, 0);
UnmanagedMemory.Set(txPage, 0, AbstractPager.PageSize);
var txHeader = (TransactionHeader *)txPage;
txHeader->HeaderMarker = Constants.TransactionHeaderMarker;
txHeader->FreeSpace = lastTransaction.FreeSpace;
txHeader->Root = lastTransaction.Root;
txHeader->OverflowPageCount = overflowPages;
txHeader->PageCount = totalNumberOfPages - overflowPages;
txHeader->PreviousTransactionCrc = lastTransaction.PreviousTransactionCrc;
txHeader->TransactionId = lastTransaction.TransactionId;
txHeader->NextPageNumber = lastTransaction.NextPageNumber;
txHeader->LastPageNumber = lastTransaction.LastPageNumber;
txHeader->TxMarker = TransactionMarker.Commit | TransactionMarker.Merged;
txHeader->Compressed = false;
txHeader->UncompressedSize = txHeader->CompressedSize = totalNumberOfPages * AbstractPager.PageSize;
txHeader->Crc = Crc.Value(finalPager.AcquirePagePointer(null, 1), 0, totalNumberOfPages * AbstractPager.PageSize);
var entry = package.CreateEntry(string.Format("{0:D19}.merged-journal", nextJournalNum), compression);
nextJournalNum++;
using (var stream = entry.Open())
{
copier.ToStream(finalPager.AcquirePagePointer(null, 0), (totalNumberOfPages + 1) * AbstractPager.PageSize, stream, CancellationToken.None);
}
}
}
file.Flush(true);// make sure we hit the disk and stay there
}
env.HeaderAccessor.Modify(header =>
{
header->IncrementalBackup.LastBackedUpJournal = lastBackedUpFile;
header->IncrementalBackup.LastBackedUpJournalPage = lastBackedUpPage;
});
}
finally
{
foreach (var disposable in toDispose)
{
disposable.Dispose();
}
}
}
/// <summary> /// Gets a hash code for the <see cref="Crc32"/>. /// </summary> /// <returns>The created hash code.</returns> public override int GetHashCode() => Crc.GetHashCode();
/// <summary>
/// Writes a byte to the s101 message, taking care of crc calculation and escaping.
/// </summary>
/// <param name="b">The byte to write</param>
public void WriteByte(byte b)
{
_crc = Crc.CrcCCITT16(_crc, b);
WriteEscapedByte(b);
}
public string GeneratePayload(MerchantPayload payload)
{
var sb = new StringBuilder();
sb.Append(EncodeProperty(nameof(MerchantPayload.PayloadFormatIndicator), payload.PayloadFormatIndicator));
sb.Append(EncodeProperty(nameof(MerchantPayload.PointOfInitializationMethod), payload.PointOfInitializationMethod));
if (null != payload.MerchantAccountInformation)
{
foreach (var merchantAccountInfo in payload.MerchantAccountInformation)
{
var merchantInfoBuilder = new StringBuilder();
merchantInfoBuilder.Append(EncodeProperty(typeof(MerchantAccountInformation).GetProperty("GlobalUniqueIdentifier"), merchantAccountInfo.Value.GlobalUniqueIdentifier));
foreach (var paymentNetworkItem in merchantAccountInfo.Value.PaymentNetworkSpecific)
{
merchantInfoBuilder.Append(EncodeKeyPair(paymentNetworkItem.Key, paymentNetworkItem.Value));
}
sb.AppendFormat("{0:D2}{1:D2}{2}", merchantAccountInfo.Key, merchantInfoBuilder.Length, merchantInfoBuilder);
}
}
sb.Append(EncodeProperty(nameof(MerchantPayload.MerchantCategoryCode), payload.MerchantCategoryCode));
sb.Append(EncodeProperty(nameof(MerchantPayload.CountyCode), payload.CountyCode));
sb.Append(EncodeProperty(nameof(MerchantPayload.MerchantName), payload.MerchantName));
sb.Append(EncodeProperty(nameof(MerchantPayload.MerchantCity), payload.MerchantCity));
sb.Append(EncodeProperty(nameof(MerchantPayload.PostalCode), payload.PostalCode));
if (null != payload.MerchantInformation)
{
var languateTemplateBuilder = new StringBuilder();
languateTemplateBuilder.Append(EncodeProperty(typeof(MerchantInfoLanguageTemplate).GetProperty(nameof(MerchantInfoLanguageTemplate.LanguagePreference)), payload.MerchantInformation.LanguagePreference));
languateTemplateBuilder.Append(EncodeProperty(typeof(MerchantInfoLanguageTemplate).GetProperty(nameof(MerchantInfoLanguageTemplate.MerchantNameAlternateLanguage)), payload.MerchantInformation.MerchantNameAlternateLanguage));
languateTemplateBuilder.Append(EncodeProperty(typeof(MerchantInfoLanguageTemplate).GetProperty(nameof(MerchantInfoLanguageTemplate.MerchantCityAlternateLanguage)), payload.MerchantInformation.MerchantCityAlternateLanguage));
sb.Append(EncodeProperty(nameof(MerchantPayload.MerchantInformation), languateTemplateBuilder.ToString()));
}
sb.Append(EncodeProperty(nameof(MerchantPayload.TransactionAmount), payload.TransactionAmount));
sb.Append(EncodeProperty(nameof(MerchantPayload.TransactionCurrency), payload.TransactionCurrency));
sb.Append(EncodeProperty(nameof(MerchantPayload.TipOrConvenienceIndicator), payload.TipOrConvenienceIndicator));
sb.Append(EncodeProperty(nameof(MerchantPayload.ValueOfConvenienceFeeFixed), payload.ValueOfConvenienceFeeFixed));
sb.Append(EncodeProperty(nameof(MerchantPayload.ValueOfConvenienceFeePercentage), payload.ValueOfConvenienceFeePercentage));
if (null != payload.AdditionalData)
{
var additionalDataBuilder = new StringBuilder();
additionalDataBuilder.Append(EncodeProperty(typeof(MerchantAdditionalData).GetProperty(nameof(MerchantAdditionalData.BillNumber)), payload.AdditionalData.BillNumber));
additionalDataBuilder.Append(EncodeProperty(typeof(MerchantAdditionalData).GetProperty(nameof(MerchantAdditionalData.MobileNumber)), payload.AdditionalData.MobileNumber));
additionalDataBuilder.Append(EncodeProperty(typeof(MerchantAdditionalData).GetProperty(nameof(MerchantAdditionalData.StoreLabel)), payload.AdditionalData.StoreLabel));
additionalDataBuilder.Append(EncodeProperty(typeof(MerchantAdditionalData).GetProperty(nameof(MerchantAdditionalData.LoyaltyNumber)), payload.AdditionalData.LoyaltyNumber));
additionalDataBuilder.Append(EncodeProperty(typeof(MerchantAdditionalData).GetProperty(nameof(MerchantAdditionalData.ReferenceLabel)), payload.AdditionalData.ReferenceLabel));
additionalDataBuilder.Append(EncodeProperty(typeof(MerchantAdditionalData).GetProperty(nameof(MerchantAdditionalData.CustomerLabel)), payload.AdditionalData.CustomerLabel));
additionalDataBuilder.Append(EncodeProperty(typeof(MerchantAdditionalData).GetProperty(nameof(MerchantAdditionalData.TerminalLabel)), payload.AdditionalData.TerminalLabel));
additionalDataBuilder.Append(EncodeProperty(typeof(MerchantAdditionalData).GetProperty(nameof(MerchantAdditionalData.PurposeOfTransaction)), payload.AdditionalData.PurposeOfTransaction));
additionalDataBuilder.Append(EncodeProperty(typeof(MerchantAdditionalData).GetProperty(nameof(MerchantAdditionalData.AdditionalConsumerDataRequest)), payload.AdditionalData.AdditionalConsumerDataRequest));
sb.Append(EncodeProperty(nameof(MerchantPayload.AdditionalData), additionalDataBuilder.ToString()));
}
if (null != payload.UnreservedTemplate)
{
foreach (var unreservedTemplateItem in payload.UnreservedTemplate)
{
var merchantInfoBuilder = new StringBuilder();
merchantInfoBuilder.Append(EncodeProperty(typeof(MerchantAccountInformation).GetProperty("GlobalUniqueIdentifier"), unreservedTemplateItem.Value.GlobalUniqueIdentifier));
foreach (var dataItem in unreservedTemplateItem.Value.ContextSpecificData)
{
merchantInfoBuilder.Append(EncodeKeyPair(dataItem.Key, dataItem.Value));
}
sb.AppendFormat("{0:D2}{1:D2}{2}", unreservedTemplateItem.Key, merchantInfoBuilder.Length, merchantInfoBuilder);
}
}
/*
* Add CRC
*
* The checksum shall be calculated according to [ISO/IEC 13239] using the polynomial '1021' (hex) and initial
* value 'FFFF' (hex). The data over which the checksum is calculated shall cover all data objects, including their
* ID, Length and Value, to be included in the QR Code, in their respective order, as well as the ID and Length of
* the CRC itself (but excluding its Value).
*/
sb.Append("6304"); //// {id:63}{length:04}
var crc16ccittFalseParameters = CrcStdParams.StandartParameters[CrcAlgorithms.Crc16CcittFalse];
var crc = new Crc(crc16ccittFalseParameters).ComputeHash(System.Text.Encoding.UTF8.GetBytes(sb.ToString()));
sb.Append(crc.ToHex(true).GetLast(4));
return(sb.ToString());
}
// Update is called once per frame
void Update()
{
try
{
switch (Step)
{
case 0:
{
if (Timer.Match())
{
// Create TCP client and asynchronously connect to server
Client = new TcpClient();
ConnectTask = Client.ConnectAsync(IPAddress.Parse(address), port);
Debug.Log(string.Format("Connecting on {0} : {1}", address, port));
Step++;
}
break;
}
case 1:
{
if (ConnectTask.Status == TaskStatus.RanToCompletion)
{
Debug.Log("Connected!");
Stream = Client.GetStream();
LastColor = ColorPicker.Color;
Timer.Start(100);
Step++;
}
else if (ConnectTask.Exception != null)
{
throw ConnectTask.Exception.InnerException;
}
break;
}
case 2:
{
if ((LastColor != ColorPicker.Color) && Timer.Match())
{
LastColor = ColorPicker.Color;
Timer.Start(100);
int startLed = 0;
int stopLed = 0;
Color32 color = LastColor;
// Create packet
int n = 0;
Packet[n++] = (byte)Preample;
Packet[n++] = (byte)(Preample >> 8);
Packet[n++] = (byte)(Preample >> 16);
Packet[n++] = (byte)(Preample >> 24);
int packetLen = 8;
Packet[n++] = (byte)packetLen;
Packet[n++] = (byte)(packetLen >> 8);
int dataOffset = n;
Packet[n++] = (byte)Command_t.SET_LEDS;
Packet[n++] = (byte)startLed;
Packet[n++] = (byte)(startLed >> 8);
Packet[n++] = (byte)stopLed;
Packet[n++] = (byte)(stopLed >> 8);
Packet[n++] = color.r;
Packet[n++] = color.g;
Packet[n++] = color.b;
ushort crc = Crc.CRC16(Packet, dataOffset, n - dataOffset, 0);
Packet[n++] = (byte)crc;
Packet[n++] = (byte)(crc >> 8);
// Send packet
Debug.Log(string.Format("Sending color: {0}", color));
SendTask = Stream.WriteAsync(Packet, 0, n);
Step++;
}
break;
}
case 3:
{
if (SendTask.Status == TaskStatus.RanToCompletion)
{
Debug.Log("Sended!");
Step--;
}
else if (SendTask.Exception != null)
{
throw SendTask.Exception.InnerException;
}
break;
}
default:
{
break;
}
}
}
catch (Exception ex)
{
// if something went wrong - close everything and try to connect again
if (Stream != null)
{
Stream.Close();
Stream = null;
}
if (Client != null)
{
Client.Close();
Client = null;
}
Timer.Start(5000);
Step = 0;
Debug.Log(ex.Message);
}
}
private dynamic Send(byte[] data, byte cmd, int attempts = 3)
{
dynamic answer = new ExpandoObject();
answer.success = false;
answer.error = string.Empty;
answer.errorcode = DeviceError.NO_ERROR;
byte[] buffer = null;
for (var attempt = 0; (attempt < attempts) && (answer.success == false); attempt++)
{
buffer = SendSimple(data);
if (buffer.Length == 0)
{
answer.error = "Нет ответа";
answer.errorcode = DeviceError.NO_ANSWER;
}
else
{
//buffer = buffer.SkipWhile(b => b == 0xff).ToArray();
var na = GetNaPacket();
if (buffer.Length < 6)
{
answer.error = "в кадре ответа не может содежаться менее 6 байт";
answer.errorcode = DeviceError.TOO_SHORT_ANSWER;
}
else if ((buffer[0] != data[0]) || (buffer[1] != data[1]) || (buffer[2] != data[2]) || (buffer[3] != data[3]))
{
log("Несовпадение сетевого адреса", level: 1);
answer.error = "Несовпадение сетевого адреса";
answer.errorcode = DeviceError.ADDRESS_ERROR;
}
else if (cmd != data[4])
{
answer.error = "Несовпадение команды";
answer.errorcode = DeviceError.ADDRESS_ERROR;
}
else
{
do
{
if (Crc.Check(buffer, new Crc16Modbus()))
{
break;
}
buffer = buffer.Take(buffer.Length - 1).ToArray();
}while (buffer.Length > 6);
if (!Crc.Check(buffer, new Crc16Modbus()))
{
answer.error = "контрольная сумма кадра не сошлась";
answer.errorcode = DeviceError.CRC_ERROR;
}
else
{
answer.success = true;
answer.error = string.Empty;
answer.errorcode = DeviceError.NO_ERROR;
}
}
}
}
if (answer.success)
{
answer.Body = buffer.Take(buffer.Length - 2).Skip(5).ToArray();
}
return(answer);
}
bool SaveRes(MultiFileOK dd)
{
//验证crc
DownResData drd = dd.Drd;
if (drd.ResSize != dd.Data.Length)
{
LogMgr.Log("Res:" + drd.ResType + " 大小不匹配,localSize:" + dd.Data.Length + ", serverSize:" + drd.ResSize);
return(false);
}
uint crc = Crc.Crc32(dd.Data, 0, dd.Data.Length);
if (crc != drd.ResCrc)
{
LogMgr.Log("Res:" + drd.ResType + "资源检验失败, size:" + dd.Data.Length + ", localCrc:" + crc + ", serverCrc:" + drd.ResCrc);
return(false);
}
System.Random rr = new System.Random();
int name = rr.Next(100, 10000);
string tempFile = RuntimeInfo.GetLocalPath(drd.ResType + name.ToString() + "_temp.dat");
string path = RuntimeInfo.GetResPersistentPath(drd.ResType);
try
{
File.Delete(tempFile);
}
catch
{
}
try
{
File.Delete(path);
}
catch
{
}
try
{
FileStream fsTemp = File.Create(tempFile);
if (fsTemp == null)
{
LogMgr.Log("RES文件创建失败:" + drd.ResType);
return(false);
}
//解压
fsTemp.Write(dd.Data, 0, dd.Data.Length);
fsTemp.Flush();
fsTemp.Close();
fsTemp = null;
LZMA.DecompressFile(tempFile, path);
}
catch (System.Exception e)
{
ReportException.Instance.AddException("文件解压失败:" + e.ToString());
}
try
{
File.Delete(tempFile);
}
catch
{
}
if (File.Exists(path) == false)
{
LogMgr.Log("RES文件解压失败:" + drd.ResType);
return(false);
}
ResManager.Instance.VersionMgr.SetResVersion(drd.ResType, drd.ResCrc, drd.ResUnzipSize);
return(ResManager.Instance.VersionMgr.SaveVersion());
}
public override string ToString()
{
return(Crc.ToString("x2"));
}
/// <summary>
/// Performs CRC32 on an input byte array using the CrcStandard.Crc32Bit parameters
/// </summary>
public static byte[] CRCHash( byte[] input )
{
using ( Crc crc = new Crc( CrcParameters.GetParameters( CrcStandard.Crc32Bit ) ) )
{
byte[] hash = crc.ComputeHash( input );
Array.Reverse( hash );
return hash;
}
}
private dynamic Send(byte[] dataSend)
{
dynamic answer = new ExpandoObject();
answer.success = false;
answer.error = string.Empty;
answer.errorcode = DeviceError.NO_ERROR;
byte[] data = null;
for (var attempts = 0; (attempts < 2) && (answer.success == false); attempts++)
{
//if (attempts == 0)
//{
// data = SendSimple(dataSend, 750, 1);
//}
//if (attempts < 2)
//{
data = SendSimple(dataSend);//, 15000, 6);
//}
//else
//{
// data = SendSimple(dataSend, 10000, 6);
//}
if (data.Length == 0)
{
answer.error = "Нет ответа";
answer.errorcode = DeviceError.NO_ANSWER;
}
else
{
if (data.Length < 5)
{
answer.error = "в кадре ответа не может содежаться менее 5 байт";
answer.errorcode = DeviceError.TOO_SHORT_ANSWER;
}
else if (!Crc.Check(data, new Crc16Modbus()))
{
answer.error = "контрольная сумма кадра не сошлась";
answer.errorcode = DeviceError.CRC_ERROR;
}
else
{
answer.success = true;
}
}
}
if (answer.success)
{
answer.NetworkAddress = data[0];
answer.Function = data[1];
answer.Length = data[3];
answer.Body = data.Skip(3).Take(data.Length - 5).ToArray();
answer.data = data;
//modbus error
if (answer.Function > 0x80)
{
var exceptionCode = (ModbusExceptionCode)data[2];
answer.success = false;
answer.error = string.Format("устройство вернуло ошибку: {0}", exceptionCode);
answer.errorcode = DeviceError.DEVICE_EXCEPTION;
}
}
return(answer);
}
