/// <summary>
/// 获取服务器时间
/// </summary>
/// <returns></returns>
public string UP0012(string cp_code, string cb_code, string bodyData)
{
string sendData = "";
Dictionary <string, object> tcpClientDic = Config.g_tcpClientDic[cp_code];
Listener_ChargePile_Data_AC data = (Listener_ChargePile_Data_AC)tcpClientDic["data"];
string checkbody = "DW0012[" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "]";
sendData =
tcpClientDic["version"].ToString() +
data.cs_id +
cp_code +
cb_code +
CRC16.GetString(checkbody) +
checkbody;
return(sendData);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override byte[] MakeCommand()
{
byte[] r = new byte[9];
r[0] = 0x21; //!
r[1] = 0x58; //X
r[2] = 0x44; //D
r[3] = (byte)Station.Address; //dev adr
r[4] = 0xA0; //dev type
r[5] = 0x1E; // func code
r[6] = 00; // inner data len
byte hi, lo;
CRC16.CalculateCRC(r, 7, out hi, out lo);
r[7] = lo;
r[8] = hi;
return(r);
}
/// <summary>
/// 线圈写入
/// </summary>
/// <param name="address"></param>
/// <param name="value"></param>
/// <param name="stationNumber"></param>
/// <param name="functionCode"></param>
public Result Write(string address, bool value, byte stationNumber = 1, byte functionCode = 5)
{
if (isAutoOpen)
{
Connect();
}
var result = new Result();
try
{
var command = GetWriteCoilCommand(address, value, stationNumber, functionCode);
var commandCRC16 = CRC16.GetCRC16(command);
result.Requst = string.Join(" ", commandCRC16.Select(t => t.ToString("X2")));
//发送命令并获取响应报文
var responsePackage = SendPackage(commandCRC16);
if (!responsePackage.Any())
{
result.IsSucceed = false;
result.Err = "响应结果为空";
return(result);
}
else if (!CRC16.CheckCRC16(responsePackage))
{
result.IsSucceed = false;
result.Err = "响应结果CRC16验证失败";
//return result;
}
byte[] resultBuffer = new byte[responsePackage.Length - 2];
Buffer.BlockCopy(responsePackage, 0, resultBuffer, 0, resultBuffer.Length);
result.Response = string.Join(" ", responsePackage.Select(t => t.ToString("X2")));
}
catch (Exception ex)
{
result.IsSucceed = false;
result.Err = ex.Message;
result.ErrList.Add(ex.Message);
}
finally
{
if (isAutoOpen)
{
Dispose();
}
}
return(result);
}
/// <summary>
/// Upload to a remote device
/// </summary>
/// <param name="serialPort">Serial port</param>
/// <param name="fileaName">Full file name</param>
/// <returns></returns>
private bool Upload(string filename, byte[] data, DateTimeOffset lastWriteTimeUtc)
{
var hasUploadedSuccessfully = default(bool);
var sw = new Stopwatch();
sw.Start();
var crc16 = new CRC16();
var crc32 = new CRC32();
// Close serial port if already open.
CloseSerialPortIfOpen();
// Initiate session
var hasExecutedCommandSuccessfully = SendZRQINITFrame(crc16);
if (hasExecutedCommandSuccessfully)
{
// Send ZFILE header with filename.
hasUploadedSuccessfully = hasExecutedCommandSuccessfully = SendZFILEHeaderCommand(filename, data.Length, lastWriteTimeUtc, crc32);
}
if (hasExecutedCommandSuccessfully)
{
// Send binary data wrapped into ZDATA header.
SendZDATAPackets(data, 0, ChunkSize, crc32);
}
if (hasExecutedCommandSuccessfully)
{
// Send EOF command
hasUploadedSuccessfully = hasExecutedCommandSuccessfully = SendEOFCommand(data.Length, crc16);
}
// Send ZFIN to finish the session
hasExecutedCommandSuccessfully = SendFinishSession(crc16);
// Send over and out
SendCommand("OO");
sw.Stop();
Console.WriteLine($"Took: {sw.ElapsedMilliseconds}ms");
return(hasUploadedSuccessfully);
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public override CommResultState ProcessReceived(byte[] data)
{
if (data == null || data.Length == 0)
{
return(CommResultState.NullData);
}
if (data.Length != 9 + 0x0A)
{
return(CommResultState.LengthError);
}
if (data[4] != 0xA0 || data[5] != 0x14)
{
return(CommResultState.DataError);
}
if (data[6] != 0x0A)
{
return(CommResultState.DataError);
}
byte cachi, caclo;
CRC16.CalculateCRC(data, data.Length - 2, out cachi, out caclo);
byte hi = data[data.Length - 1];
byte lo = data[data.Length - 2];
if (cachi != hi || caclo != lo)
{
return(CommResultState.CheckError);
}
byte[] innerData = GRCommandMaker.GetReceivedInnerData(data);
if (innerData[0] != GRDef.MC_GIVETEMP_MODE)
{
return(CommResultState.DataError);
}
_giveTempMode = GetGiveTempMode(innerData[1]);
_giveTempValue = BitConverter.ToSingle(innerData, 2);
return(CommResultState.Correct);
}
/// <summary>
///
/// </summary>
/// <param name="address"></param>
/// <param name="deviceType"></param>
/// <param name="functionCode"></param>
/// <param name="datas"></param>
/// <returns></returns>
public static CommResultState CheckReceivedData(int address, int deviceType,
int functionCode, byte[] datas)
{
if (datas == null || datas.Length < XGDefinition.ZERO_DATA_CMD_LENGTH)
{
return(CommResultState.LengthError);
}
int innerDataLen = datas[XGDefinition.INNER_DATA_LENGTH_POS];
if (innerDataLen != XGDefinition.GetInnerDataLen(functionCode))
{
return(CommResultState.LengthError);
}
if (datas.Length != XGDefinition.ZERO_DATA_CMD_LENGTH + innerDataLen)
{
return(CommResultState.LengthError);
}
byte calcHi, calcLo;
CRC16.CalculateCRC(datas, datas.Length - 2, out calcHi, out calcLo);
byte lo = datas[datas.Length - 2];
byte hi = datas[datas.Length - 1];
if (hi != calcHi || lo != calcLo)
{
return(CommResultState.CheckError);
}
int rAddress = datas[XGDefinition.ADDRESS_POS];
int rDeviceType = datas [XGDefinition.DEVICE_TYPE_POS];
int rFC = datas[XGDefinition.FUNCTION_CODE_POS];
if (rAddress != address ||
rDeviceType != deviceType ||
rFC != functionCode)
{
return(CommResultState.DataError);
}
return(CommResultState.Correct);
}
public string CreateQRString(QRInfo qrData)
{
var EMVCo = "000201";
var applicationID = "0016A000000677010112";
var BillerID = $"{qrData.TaxID}{qrData.Suffix}";
var defaultBiller = "00000000000001";
var billPaymentBillerID = !String.IsNullOrEmpty(BillerID) ? $"01{fieldIsNull(BillerID)}" : $"01{fieldIsNull(defaultBiller)}";
var reference1 = $"02{fieldIsNull(qrData.Ref1)}";
var reference2 = $"03{fieldIsNull(qrData.Ref2)}";
var transactionAmount = "";
if (!String.IsNullOrEmpty(qrData.Amount))
{
var amount = String.Format("{0:0.00}", Convert.ToDouble(qrData.Amount));
transactionAmount = $"54{len(amount)}{amount}";
}
else
{
transactionAmount = "";
}
var transactionCurrency = !String.IsNullOrEmpty(qrData.Currency) ? $"5303{qrData.Currency}" : $"5303764";
var countryCode = !String.IsNullOrEmpty(qrData.CountryCode) ? $"5802{(qrData.CountryCode).ToUpper()}" : "5802TH";
var merchantName = !String.IsNullOrEmpty(qrData.MerchantName) ? $"59{fieldIsNull(qrData.MerchantName)}" : "";
var terminalNumber = !String.IsNullOrEmpty(qrData.TerminalNo) ? $"62{fieldIsNull(qrData.TerminalNo)}" : "";
var qrUse = qrData.PointOfInherite == "No" ? "010212" : "010211";
var billPayment = $"{applicationID}{billPaymentBillerID}{reference1}{reference2}";
var billPaymentInfo = $"30{fieldIsNull(billPayment)}";
var qrcode = new StringBuilder();
qrcode.Append(EMVCo)
.Append(qrUse)
.Append(billPaymentInfo)
.Append(transactionCurrency)
.Append(transactionAmount)
.Append(countryCode)
.Append(merchantName)
.Append(terminalNumber)
.Append("6304");
var payload = qrcode.ToString().Select(x => Convert.ToByte(x)).ToArray();
var crc = new CRC16().ComputeCheckSum(payload);
var crc16 = crc.ToString("X").PadLeft(4, '0');
qrcode.Append(crc16);
return(qrcode.ToString());
}
protected void BuildPayload(byte command, byte[] data)
{
ResponseCode = (byte)(command + 0x80);
var dataLength = (ushort)data.Length;
var payloadLength = 8 + dataLength + 2; //preamble + data + crc
if (command > 0x80)
{
/* this case is actually a response, but since it is
* used only for Pong, we threat it as a special case
* instead of creating a full ResponseBuildPayload
*/
payloadLength += 1; // RET
}
/* NOTE: in the original specification, the payload must be less than 400 bytes
* However, issue #45 found that Facepass devices use much bigger payloads
*
* if (dataLength > 400)
* {
* throw new Exception("Payload too big");
* }
*/
var i = 0;
Payload = new byte[payloadLength];
Payload[i++] = 0xA5;
Payload[i++] = (byte)((DeviceId >> 24) % 256);
Payload[i++] = (byte)((DeviceId >> 16) % 256);
Payload[i++] = (byte)((DeviceId >> 8) % 256);
Payload[i++] = (byte)(DeviceId % 256);
Payload[i++] = command;
if (command > 0x80)
{
Payload[i++] = 0; // RET
}
Payload[i++] = (byte)(dataLength >> 8);
Payload[i++] = (byte)(dataLength % 256);
data.CopyTo(Payload, i);
i += data.Length;
var crc = CRC16.Compute(Payload, Payload.Length - 2); //last 2 bytes = crc
Payload[i++] = (byte)(crc % 256);
Payload[i++] = (byte)((crc >> 8) % 256);
}
/// <summary>
/// Sends a request to a module and then polls the module to get the response.
/// </summary>
/// <param name="addr">Module address.</param>
/// <param name="buffer">I2C data to be sent, I2C data received after method returns.</param>
/// <returns>Status of communication. True if response is valid, false otherwise.</returns>
protected virtual bool RequestToModuleFromBuffer(int addr, ref byte[] buffer)
{
var m = new I2CManager();
CRC16.PutCRC(ref buffer);
LogBuffer(buffer, "I2C data sent");
int fd = GetFDFromAddress(addr);
int l = m.I2CWriteBlock(fd, ref buffer);
for (int i = 0; i < ICCConstants.PACKETSIZE; i++)
{
buffer[i] = 0;
}
return(PollModuleForResponse(addr, ref buffer));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override byte[] MakeCommand()
{
byte[] r = new byte[10];
r[0] = 0x21; //!
r[1] = 0x58; //X
r[2] = 0x44; //D
r[3] = (byte)Station.Address;
r[4] = 0xA0; //dev type
r[5] = GRDef.FC_READ_SETTINGS; // func code
r[6] = 01; // inner data len
r[7] = GRDef.MC_GIVETEMP_MODE;
byte hi, lo;
CRC16.CalculateCRC(r, 7, out hi, out lo);
r[8] = lo;
r[9] = hi;
return(r);
}
private bool SendEOFCommand(int dataLength, CRC16 crcCalculator)
{
var result = default(bool);
Utils.GenerateZModemFileOffset(dataLength, out int p0, out int p1, out int p2, out int p3);
var zeofCommand = Utils.BuildCommonHexHeader(HeaderType.ZEOF, p0, p1, p2, p3, crcCalculator);
// Send command
var response = SendCommand(zeofCommand, true, HeaderType.ZRINIT);
if (response?.ZHeader == HeaderType.ZRINIT)
{
result = true;
}
return(result);
}
private void GenerateCommand()
{
command = new byte[7];
byte[] commandCache = new byte[command.Length - 2];
byte[] CRCCode;
commandCache[0] = commandType;
commandCache[1] = 0x00;
commandCache[2] = 0x00;
commandCache[3] = addrType;
commandCache[4] = startLowAddr;
CRCCode = CRC16.GetCRC(commandCache);
for (int i = 0; i < commandCache.Length; i++)
{
command[i] = commandCache[i];
}
command[5] = CRCCode[0];
command[6] = CRCCode[1];
}
/// <summary>
/// 写入TCP
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void but_tcpIn_Click(object sender, RoutedEventArgs e)
{
string checkbody = "DW0255" +
"[" + text_version.Text + "]" +
"[" + text_cs_id.Text + "]" +
"[" + text_cp_code.Text + "]";
string sendData = "(" +
text_version.Text +
text_cs_id.Text +
text_cp_code.Text +
"00000000000000000000000000000000" +
CRC16.GetString(checkbody) +
checkbody +
")";
m_socket.Send(Encoding.UTF8.GetBytes(sendData));
text_content.AppendText("TCP数据已发送。\r\n");
}
//--------
//-------- ScratchPad methods
//--------
/// <summary>
/// Read the scratchpad page of memory from a NVRAM device
/// This method reads and returns the entire scratchpad after the byte
/// offset regardless of the actual ending offset
/// </summary>
/// <param name="readBuf"> byte array to place read data into
/// length of array is always pageLength. </param>
/// <param name="offset"> offset into readBuf to pug data </param>
/// <param name="len"> length in bytes to read </param>
/// <param name="extraInfo"> byte array to put extra info read into
/// (TA1, TA2, e/s byte)
/// length of array is always extraInfoLength.
/// Can be 'null' if extra info is not needed.
/// </param>
/// <exception cref="OneWireIOException"> </exception>
/// <exception cref="OneWireException"> </exception>
public override void readScratchpad(byte[] readBuf, int offset, int len, byte[] extraInfo)
{
// select the device
if (!ib.adapter.select(ib.address))
{
forceVerify();
throw new OneWireIOException("Device select failed");
}
// build block
byte[] raw_buf = new byte[extraInfoLength + pageLength + 3];
raw_buf[0] = READ_SCRATCHPAD_COMMAND;
Array.Copy(ffBlock, 0, raw_buf, 1, raw_buf.Length - 1);
// send block, command + (extra) + page data + CRC
ib.adapter.dataBlock(raw_buf, 0, raw_buf.Length);
// get the starting offset to see when the crc will show up
int addr = raw_buf[1];
addr = (addr | ((raw_buf[2] << 8) & 0xFF00)) & 0xFFFF;
int num_crc = 35 - (addr & 0x001F) + extraInfoLength;
// check crc of entire block
if (CRC16.compute(raw_buf, 0, num_crc, 0) != 0x0000B001)
{
forceVerify();
throw new OneWireIOException("Invalid CRC16 read from device");
}
// optionally extract the extra info
if (extraInfo != null)
{
Array.Copy(raw_buf, 1, extraInfo, 0, extraInfoLength);
}
// extract the page data
Array.Copy(raw_buf, extraInfoLength + 1, readBuf, 0, pageLength);
}
public IActionResult Index()
{
var builder = new StringBuilder();
builder.Append("00020101021229370016A0000006770101110113006691493165953037645802TH6304");
var payload = builder.ToString().Select(x => Convert.ToByte(x)).ToArray();
var crc = new CRC16().ComputeCheckSum(payload);
builder.Append(crc.ToString("X").PadLeft(4, '0'));
var str = builder.ToString();
MessagingToolkit.QRCode.Codec.QRCodeEncoder encoder = new MessagingToolkit.QRCode.Codec.QRCodeEncoder();
encoder.QRCodeScale = 8;
Bitmap bmp = encoder.Encode(str);
return(View());
}
//--------
//-------- ScratchPad methods
//--------
/// <summary>
/// Write to the scratchpad page of memory a NVRAM device.
/// </summary>
/// <param name="startAddr"> starting address </param>
/// <param name="writeBuf"> byte array containing data to write </param>
/// <param name="offset"> offset into readBuf to place data </param>
/// <param name="len"> length in bytes to write
/// </param>
/// <exception cref="OneWireIOException"> </exception>
/// <exception cref="OneWireException"> </exception>
public override void writeScratchpad(int startAddr, byte[] writeBuf, int offset, int len)
{
bool calcCRC = false;
// select the device
if (!ib.adapter.select(ib.address))
{
forceVerify();
throw new OneWireIOException("Device select failed");
}
// build block to send
byte[] raw_buf = new byte[37];
raw_buf[0] = WRITE_SCRATCHPAD_COMMAND;
raw_buf[1] = (byte)(startAddr & 0xFF);
raw_buf[2] = (byte)(((int)((uint)(startAddr & 0xFFFF) >> 8)) & 0xFF);
Array.Copy(writeBuf, offset, raw_buf, 3, len);
// check if full page (can utilize CRC)
if (((startAddr + len) % pageLength) == 0)
{
Array.Copy(ffBlock, 0, raw_buf, len + 3, 2);
calcCRC = true;
}
// send block, return result
ib.adapter.dataBlock(raw_buf, 0, len + 3 + ((calcCRC) ? 2 : 0));
// check crc
if (calcCRC)
{
if (CRC16.compute(raw_buf, 0, len + 5, 0) != 0x0000B001)
{
forceVerify();
throw new OneWireIOException("Invalid CRC16 read from device");
}
}
}
/// <summary>
/// 写入
/// </summary>
/// <param name="address"></param>
/// <param name="values"></param>
/// <param name="stationNumber"></param>
/// <param name="functionCode"></param>
/// <returns></returns>
public Result Write(string address, byte[] values, byte stationNumber = 1, byte functionCode = 16)
{
if (isAutoOpen)
{
Connect();
}
var result = new Result();
try
{
var command = GetWriteCommand(address, values, stationNumber, functionCode);
var commandCRC16 = CRC16.GetCRC16(command);
serialPort.Write(commandCRC16, 0, commandCRC16.Length);
result.Requst = string.Join(" ", commandCRC16.Select(t => t.ToString("X2")));
//3 获取响应报文
var responsePackage = SerialPortRead(serialPort);
if (!CRC16.CheckCRC16(responsePackage))
{
result.IsSucceed = false;
result.Err = "响应结果CRC16验证失败";
return(result);
}
byte[] resultBuffer = new byte[responsePackage.Length - 2];
Array.Copy(responsePackage, 0, resultBuffer, 0, resultBuffer.Length);
result.Response = string.Join(" ", responsePackage.Select(t => t.ToString("X2")));
}
catch (Exception ex)
{
result.IsSucceed = false;
result.Err = ex.Message;
result.ErrList.Add(ex.Message);
}
finally
{
if (isAutoOpen)
{
Dispose();
}
}
return(result);
}
private void AlarmButton_Click(object sender, EventArgs e)
{
Task.Run(() =>
{
//发送120次报警信号跳变,
for (int i = 0; i < 120; i++)
{
Thread.Sleep(20);
GPIO.SetHigh();
Thread.Sleep(20);
GPIO.SetLow();
}
});
portString = textBox.Text;
comboboxString = selectCombobox.Text;
uint portNum = Convert.ToUInt32(portString);
IntPtr comHandle = InitPort(portNum, 9600, 'N', 8, 1, false);
readData = ReadDataCallBackFunc;
CommSetCallBack(readData);
CommStartR();
byte param = Convert.ToByte(comboboxString);
Random random = new Random();
byte x = (byte)(0x50 + random.Next(0, 100));
byte y = (byte)(0x50 + random.Next(0, 100));
byte[] command = { 0x86, x, y, param, 0x00, 0x0a };
byte[] crc = CRC16.crc_16(command);
byte[] sendData = new byte[command.Length + 2];
command.CopyTo(sendData, 0);
sendData[sendData.Length - 2] = crc[1];
sendData[sendData.Length - 1] = crc[0];
bool isWriteSuccessful = CommSendDataFunction(sendData, 8);
ClosePort();
}
public HBFCard()
{
Reset();
// CRC calculator init
m_crc_generator = new CRC16(0x1021, 0xffff);
// reserve memory
m_card_ram = new byte[CardRAMSize];
m_card_rom = new byte[CardROMSize];
// create disk drives
m_disk_drives = new DiskDrive[NumberOfDrives];
for (int i = 0; i < NumberOfDrives; i++)
{
m_disk_drives[i] = new DiskDrive();
}
//m_disk_drives[0] = new DiskDrive();
m_disk_drives[0].Geometry.NumberOfTracks = 80;
m_disk_drives[0].Geometry.NumberOfSides = 2;
m_disk_drives[0].Geometry.SectorPerTrack = 9;
//m_disk_drives[0].OpenDiskImageFile(@"d:\Projects\Retro\YATE\disk\mralex.dsk");
//m_disk_drives[0].OpenDiskImageFile(@"d:\Projects\Retro\YATE\disk\IKPLUS_TVC.dsk");
//m_disk_drives[0].OpenDiskImageFile(@"d:\Projects\Retro\YATE\disk\test.dsk");
//m_disk_drives[0].OpenDiskImageFile(@"d:\Projects\Retro\YATE\disk\UPM_TEST.dsk");
//m_disk_drives[0].OpenDiskImageFile(@"d:\Projects\Retro\YATE\disk\UPM_test1.xdi");
//m_disk_drives[0].OpenDiskImageFile(@"d:\Projects\Retro\YATE\disk\nautilus.dsk");
m_disk_drives[0].OpenDiskImageFile(@"d:\Projects\Retro\YATE\disk\upmlemez.img");
//m_disk_drives[1] = new DiskDrive();
m_disk_drives[1].Geometry.NumberOfTracks = 40;
m_disk_drives[1].Geometry.NumberOfSides = 2;
m_disk_drives[1].Geometry.SectorPerTrack = 9;
//m_disk_drives[0].OpenDiskImageFile(@"d:\Projects\Retro\YATE\disk\mralex.dsk");
//m_disk_drives[0].OpenDiskImageFile(@"d:\Projects\Retro\YATE\disk\IKPLUS_TVC.dsk");
m_disk_drives[1].OpenDiskImageFile(@"d:\Projects\Retro\YATE\disk\test.dsk");
//m_disk_drives[0].OpenDiskImageFile(@"d:\Projects\Retro\YATE\disk\UPM_TEST.dsk");
//m_disk_drives[0].OpenDiskImageFile(@"d:\Projects\Retro\YATE\disk\UPM_test1.xdi");
//m_disk_drives[0].OpenDiskImageFile(@"d:\Projects\Retro\YATE\disk\nautilus.dsk");
}
static void Main(string[] args)
{
byte[] data = Encoding.ASCII.GetBytes("123456789");
Crc16 crc16 = new Crc16(Crc16.IBM, true);
Console.WriteLine("CRC-16 = {0:X4}", crc16.Compute(data));
HashAlgorithm hash16 = new CRC16();
Console.WriteLine("Nito CRC-16 = {0:X4}", BitConverter.ToUInt16(hash16.ComputeHash(data), 0));
Crc16 crc16ccitt = new Crc16(Crc16.CCITT, false, 0xFFFF, 0);
Console.WriteLine("CRC-16-CCITT = {0:X4}", crc16ccitt.Compute(data));
HashAlgorithm hash16ccitt = new CRC16(CRC16.Definition.CcittFalse);
Console.WriteLine("Nito CRC-16-CCITT = {0:X4}", BitConverter.ToUInt16(hash16ccitt.ComputeHash(data), 0));
Crc32 crc32 = new Crc32(Crc32.IEEE, 0xFFFFFFFF, 0xFFFFFFFF);
Console.WriteLine("CRC-32 = {0:X8}", crc32.Compute(data));
HashAlgorithm hash32 = new CRC32();
Console.WriteLine("Nito CRC-32 = {0:X8}", BitConverter.ToUInt32(hash32.ComputeHash(data), 0));
XorHash32To16 xor1632 = new XorHash32To16(new Crc32(Crc32.IEEE));
Console.WriteLine("Xor32To16 CRC-32 IEEE = {0:X4}", xor1632.Compute(data));
CRC32.Definition crcdef = new CRC32.Definition();
crcdef.FinalXorValue = 0x0;
crcdef.Initializer = 0x0;
crcdef.ReverseDataBytes = CRC32.Definition.Default.ReverseDataBytes;
crcdef.ReverseResultBeforeFinalXor = CRC32.Definition.Default.ReverseResultBeforeFinalXor;
crcdef.TruncatedPolynomial = CRC32.Definition.Default.TruncatedPolynomial;
HashAlgorithm hashXor = new Xor32To16Algorithm(crcdef.Create());
Console.WriteLine("Nito Xor32To16 CRC-32 = {0:X4}", BitConverter.ToUInt16(hashXor.ComputeHash(data), 0));
#if DEBUG
Console.WriteLine("---> Program finished.");
Console.ReadKey();
#endif
}
private void ReceiveBody(int BodyLength, bool PreserveBuffer, int SourceOffset)
{
var receivedBody = false;
var timeout = Environment.TickCount + m_TimeoutSync;
while (Environment.TickCount < timeout || IGNORE_TIMEOUTS)
{
lock (m_ReadSync)
{
if (m_RawReadBufferLength >= BodyLength * 2)
{
Utils.DeserializeBytesToUShortArray(m_RawReadBuffer, BodyLength * 2, m_ReadBuffer, SourceOffset);
if (!PreserveBuffer)
{
m_RawReadBufferLength -= BodyLength * 2 + SourceOffset;
}
receivedBody = true;
}
}
if (receivedBody)
{
var crcComp = CRC16.ComputeCRC(m_ReadBuffer, BodyLength - 1);
var crcRec = m_ReadBuffer[BodyLength - 1];
if (crcComp != crcRec)
{
throw new ProtocolBadCRCException(String.Format(Resources.SCCIMasterAdapter_Parser_error_bad_CRC, crcRec, crcComp), crcRec, crcComp);
}
break;
}
m_DataReceivedEvent.WaitOne((timeout - Environment.TickCount < 0) ? 0 : timeout - Environment.TickCount);
}
if (!receivedBody)
{
throw new ProtocolTimeoutException(Resources.SCCIMasterAdapter_General_error_timeout_while_reading_frame_body);
}
}
protected void BuildPayload(byte command, byte[] data)
{
ushort dataLength = (ushort)data.Length;
ushort crc = 0x0000;
byte[] commandBytes = new byte[8 + dataLength];
commandBytes[0] = 0xA5;
commandBytes[1] = (byte)((deviceId >> 24) % 256);
commandBytes[2] = (byte)((deviceId >> 16) % 256);
commandBytes[3] = (byte)((deviceId >> 8) % 256);
commandBytes[4] = (byte)(deviceId % 256);
commandBytes[5] = command;
commandBytes[6] = (byte)(dataLength >> 8);
commandBytes[7] = (byte)(dataLength % 256);
data.CopyTo(commandBytes, 8);
crc = CRC16.Compute(commandBytes);
payload = new byte[commandBytes.Length + 2];
commandBytes.CopyTo(payload, 0);
payload[9 + dataLength] = (byte)((crc >> 8) % 256);
payload[8 + dataLength] = (byte)(crc % 256);
}
public static int RequestToModuleFromBuffer(int addr, ref byte[] buffer)
{
var m = new I2CManager();
CRC16.PutCRC(ref buffer);
int fd = GetFDFromAddress(addr);
Console.WriteLine(string.Format("RequestToModuleFromBuffer : File descriptor : {0}", fd));
int l = m.I2CWriteBlock(fd, ref buffer);
//int l = m.I2CWriteBlockAddr(addr, ref buffer);
PrintBuffer(buffer, "RequestToModuleFromBuffer");
for (int i = 0; i < ICCConstants.PACKETSIZE; i++)
{
buffer[i] = 0;
}
return(PollModuleForResponse(addr, ref buffer));
}
/// <summary>
/// Test for SHT85
/// </summary>
public void TestWrite()
{
ResetOneWireAndMatchDeviceRomAddress();
Master.EnableStrongPullup();
//byte deviceCommand = (byte)DS28E17_Commands.WriteDataWithStop;
byte deviceCommand = (byte)DS28E17.DeviceCommand.WriteDataWithStop;
//deviceCommand = 0x1F;
byte i2cSlaveAddress = 0x44; //0x44 SHT85 address
var sht85cmd = BitConverter.GetBytes((UInt16)0x2416).Reverse().ToArray();
//var sht85cmd = BitConverter.GetBytes((UInt16)0x2416).ToArray();
var i2cCommand = new List <byte>();
i2cCommand.Add(deviceCommand);
i2cCommand.Add((byte)(i2cSlaveAddress << 1)); //7 bit for address, bit[0] = 0 (i2c write)
i2cCommand.Add((byte)sht85cmd.Length);
i2cCommand.AddRange(sht85cmd);
var crc16 = CRC16.Compute(i2cCommand.ToArray());
crc16 = ~crc16;
foreach (byte b in i2cCommand)
{
Master.OneWireWriteByte(b);
SpinWait.SpinUntil(() => false, 10);
}
Master.OneWireWriteByte((byte)(crc16 & 0xFF)); // Least significant byte of 16 bit CRC
Master.OneWireWriteByte((byte)(crc16 >> 8)); // Most significant byte of 16 bit CRC
SpinWait.SpinUntil(() => false, 10);
var status = Master.OneWireReadByte();
var writeStatus = Master.OneWireReadByte();
TestRead();
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public override CommResultState ProcessReceived(byte[] data)
{
if (data == null || data.Length == 0)
{
return(CommResultState.NullData);
}
if (data.Length != 113)
{
return(CommResultState.LengthError);
}
if (data[4] != 0xA0 || data[5] != 0x1E)
{
return(CommResultState.DataError);
}
byte cachi, caclo;
CRC16.CalculateCRC(data, 113 - 2, out cachi, out caclo);
byte hi = data[113 - 1];
byte lo = data[113 - 2];
if (cachi != hi || caclo != lo)
{
return(CommResultState.CheckError);
}
byte[] innerData = GetReceivedInnerData(data);
int address = data[GRDef.ADDRESS_POS];
GRRealData rd = GRRealData.Parse(innerData, address);
_realData = rd;
//Singles.S.OutSideTemperature = _realData.OutSideTemp;
//Utilities.frmPropertiesGrid f = new frmPropertiesGrid();
//f.ShowMe( rd,"");
return(CommResultState.Correct);
}
private void ReceiveDataStream(int DataCount, bool UseCRC, ushort CRC, int SourceBufferOffset)
{
var received = false;
var timeout = Environment.TickCount + m_TimeoutSyncStream;
var streamLength = (DataCount / DATA_STREAM_QUANTA + ((DataCount % DATA_STREAM_QUANTA != 0) ? 1 : 0)) * DATA_STREAM_QUANTA;
while ((Environment.TickCount < timeout) || IGNORE_TIMEOUTS)
{
lock (m_ReadSync)
{
if (m_RawReadBufferLength >= (streamLength * 2 + SourceBufferOffset))
{
Utils.DeserializeBytesToUShortArray(m_RawReadBuffer, streamLength * 2, m_ReadBuffer, SourceBufferOffset);
m_RawReadBufferLength -= streamLength * 2;
received = true;
break;
}
}
var tout = timeout - Environment.TickCount;
tout = (tout < 0) ? 0 : tout;
m_DataReceivedEvent.WaitOne(tout);
}
if (received && UseCRC)
{
var crcComp = CRC16.ComputeCRC(m_ReadBuffer, DataCount);
if (crcComp != CRC)
{
throw new ProtocolBadCRCException(
String.Format(Resources.SCCIMasterAdapter_Parser_error_bad_CRC, CRC, crcComp), CRC, crcComp);
}
}
if (!received)
{
throw new ProtocolTimeoutException(Resources.SCCIMasterAdapter_General_error_timeout_while_reading_data_stream);
}
}
/// <summary>
/// 心跳
/// </summary>
/// <returns></returns>
public string UP0001(string cp_code, string cb_code, string bodyData)
{
string sendData = "";
Dictionary <string, object> tcpClientDic = Config.g_tcpClientDic[cp_code];
Listener_ChargePile_Data_AC data = (Listener_ChargePile_Data_AC)tcpClientDic["data"];
//解析包文体
MatchCollection arr = Regex.Matches(bodyData, @"(?<=\[)[^\]]*(?=\])");
string UP_0 = arr[0].Value; //是否在充电
string UP_1 = arr[1].Value; //枪编号
string[] UP_2 = arr[2].Value.Split('|'); //电压
string[] UP_3 = arr[3].Value.Split('|'); //电流
string UP_4 = arr[4].Value; //有功功率
string UP_5 = arr[5].Value; //无功功率
string UP_6 = arr[6].Value; //功率因数
string UP_7 = double.Parse(arr[7].Value).ToString(); //电度
string UP_8 = arr[8].Value; //充电剩余时间
string UP_9 = arr[9].Value; //用户名
//枪编号大于0才执行
if (int.Parse(UP_1) > 0)
{
if (int.Parse(UP_0) == 1)
{
data.gundata[int.Parse(UP_1)].cb_code = cb_code;
m_incTCPSend002.DW0010(cp_code, cb_code, long.Parse(UP_9));
}
}
string checkbody = "DW0001";
sendData =
tcpClientDic["version"].ToString() +
data.cs_id +
cp_code +
cb_code +
CRC16.GetString(checkbody) +
checkbody;
return(sendData);
}
/// <summary>
/// 组织完整的数据帧
/// 注意：这里组织默认的都是小端方式
/// </summary>
/// <param name="data">数据部分</param>
/// <returns>完整的数据帧</returns>
public static byte[] MergeMsg(ref PrepareData.Msg_Bus _frame, byte [] data)
{
byte[] sender;
ushort CRC;
_frame.data = new byte[PrepareData.BUS_FRAME_IN_DATALEN];
//数据域小于8，在帧内组织
if (data.Length <= 8)
{
//帧内拷贝
Array.Copy(data, _frame.data, data.Length);
_frame.crc16 = 0x0000;
sender = ByteStruct.StructToBytes(_frame);
CRC = CRC16.CalculateCrc16(sender, 0, sender.Length - 2);
sender[sender.Length - 1] = (byte)(CRC >> 8);
sender[sender.Length - 2] = (byte)CRC;
}
//数据帧过长需要帧外组织
else
{
_frame.crc16 = 0x0000;
//帧外的CRC校验
CRC = CRC16.CalculateCrc16(data);
byte [] temp = ByteStruct.StructToBytes(_frame);
//帧内数据的CRC校验码
ushort crctemp = CRC16.CalculateCrc16(temp, 0, temp.Length - 2);
temp[temp.Length - 1] = (byte)(crctemp >> 8);
temp[temp.Length - 2] = (byte)crctemp;
//整体数据组织
sender = new byte[PrepareData.BUS_FRAME_MINLEN + data.Length + 2];
//帧内数据
temp.CopyTo(sender, 0);
//帧外数据
Array.Copy(data, 0, sender, PrepareData.BUS_FRAME_MINLEN, data.Length);
//帧外CRC
sender[sender.Length - 1] = (byte)(CRC >> 8);
sender[sender.Length - 2] = (byte)CRC;
}
return(sender);
}
/// <summary>
/// 响应获取充电状态请求
/// </summary>
/// <returns></returns>
public string UP0010(string cp_code, string cb_code, string bodyData)
{
string sendData = "";
Dictionary <string, object> tcpClientDic = Config.g_tcpClientDic[cp_code];
Listener_ChargePile_Data_AC data = (Listener_ChargePile_Data_AC)tcpClientDic["data"];
MatchCollection arr = Regex.Matches(bodyData, @"(?<=\[)[^\]]*(?=\])");
string UP_0 = arr[0].Value; //枪编号
string UP_1 = arr[1].Value; //用户名
string UP_2 = arr[2].Value; //已充电量
string UP_3 = arr[3].Value; //剩余时间
string UP_4 = arr[4].Value; //单价，元/度
string UP_5 = arr[5].Value; //充电模式，1按时间、2按金额、3按电量、4自动充满
string UP_6 = arr[6].Value; //数值（当2为4时，此值为0）
if (int.Parse(UP_0) > 0)
{
//更新充电桩状态
data.condition = 2;
data.gundata[int.Parse(UP_0)].useruname = long.Parse(UP_1);
data.gundata[int.Parse(UP_0)].kwh = double.Parse(UP_2);
data.gundata[int.Parse(UP_0)].timeleft = TimeSpan.FromSeconds(double.Parse(UP_3));
data.unitmoney = decimal.Parse(UP_4);
data.gundata[int.Parse(UP_0)].chargemod = int.Parse(UP_5);
data.gundata[int.Parse(UP_0)].chargemodcontent = long.Parse(UP_6);
data.gundata[int.Parse(UP_0)].guncondition = true;
}
string checkbody = "DW0011[1]";
sendData =
tcpClientDic["version"].ToString() +
data.cs_id +
cp_code +
cb_code +
CRC16.GetString(checkbody) +
checkbody;
return(sendData);
}
public static byte[] Pack(object msg, out int length)
{
byte[] data = new byte[4096];
using (MemoryStream s = new MemoryStream(data))
{
//content
formatter.Serialize(s, msg);
//length
UInt16 l = (UInt16)s.Position;
//crc
UInt16 crc16 = CRC16.CalculateCrc16(data, 0, l);
s.WriteByte((byte)(crc16 >> 8));
s.WriteByte((byte)(crc16 & 0xff));
s.Flush();
s.Close();
length = l + 2; //content crc
return(data);
}
}
// static constructor
static CRC16()
{
_crc16TablesCache = Hashtable.Synchronized(new Hashtable());
_defaultCRC = new CRC16();
}