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());
}
}
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();
}
}
protected byte[] MakeAIQueryCommand()
{
var result = new byte[8];
result[0] = address;
result[1] = Convert.ToByte(0x04);
result[3] = 0;
result[5] = Convert.ToByte(this.AnalogInputCount);
var checkSum = crc.ComputeHash(result, 0, 6);
result[6] = checkSum[checkSum.Length - 1];
result[7] = checkSum[checkSum.Length - 2];
return(result);
}
private static void SendResponse(MessageInput input, long id)
{
string head = $"{0:X4}";
string body = $"4CBF{id:X8}{0:X4}";
string checksum = Crc.ComputeHash(HexUtil.ConvertHexStringToByteArray(body), CrcAlgorithm.Crc16CcittFalse);
string response = $"{head}{body}{checksum}";
input.NetworkStream.Write(HexUtil.ConvertHexStringToByteArray(response));
}
private static void TestCRC()
{
// Sender side
// ============================================================================================
BitPacker bufferSender = new BitPacker();
bufferSender.WriteValue(0x39, 6);
bufferSender.WriteValue(0x2B, 6);
Console.WriteLine("Data envoyées sans CRC :" + bufferSender.ToString());
Parameters parameters = CrcStdParams.StandartParameters[CrcAlgorithms.Crc32];
Crc crcSender = new Crc(parameters);
crcSender.ComputeHash(bufferSender.GetByteBuffer());
uint value = (uint)CrcHelper.FromBigEndian(crcSender.Hash, crcSender.HashSize);
bufferSender.AlignToNextWriteByte();
bufferSender.WriteValue(value, 32);
/*
* Console.WriteLine("Data envoyées avec CRC :" + bufferSender.ToString());
*
* // Trucage des données pour test du CRC
* bufferSender = new BitPacking();
* bufferSender.WriteValue(0x39, BitsRequired(0, 63));
* bufferSender.WriteValue(0x2B, BitsRequired(0, 63));
*
* bufferSender.AlignToNextByte();
* bufferSender.WriteValue(value, (uint)crcSender.HashSize);
* bufferSender.PushTempInBuffer();
* // Console.WriteLine("Valeur du CRC :" + Convert.ToString(value, toBase: 16));
*
* Console.WriteLine("=================================================================");
*/
// Receiver side
// ============================================================================================
BitPacker bufferReceiver = BitPacker.FromArray(bufferSender.GetByteBuffer());
//Console.WriteLine("Réception data avec CRC :" + bufferReceiver.ToString());
Crc crcReceiver = new Crc(parameters);
uint crcValue = bufferReceiver.ReadValue(crcReceiver.HashSize, true, bufferReceiver.BitLength - 32);
Console.WriteLine("Réception data sans CRC :" + bufferReceiver.ToString());
parameters.Check = crcValue;
if (crcReceiver.IsRight(bufferReceiver.GetByteBuffer()))
{
Console.WriteLine("Paquet accepté !");
}
else
{
Console.WriteLine("Refused packet !");
}
}
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);
}
}
public void Crc32Test()
{
var bytes = Encoding.ASCII.GetBytes("AA0199BB");
var crc = new Crc(CrcStdParams.StandartParameters[CrcAlgorithms.Crc32]);
var hash = crc.ComputeHash(bytes);
var value = Convert.ToString(BitConverter.ToInt32(hash), 16);
value.HexFormat().Should().Be("06 56 91 43");
}
private static void SendResponse(MessageInput input)
{
// ReSharper disable once PossiblyMistakenUseOfInterpolatedStringInsert
string packetLength = $"{2:X4}";
const string command = "64";
const string ack = "01";
string checksum = Crc.ComputeHash(HexUtil.ConvertHexStringToByteArray($"{command}{ack}"),
CrcAlgorithm.Crc16Kermit);
string fullReply = $"{packetLength}{command}{ack}{checksum}";
input.NetworkStream.Write(HexUtil.ConvertHexStringToByteArray(fullReply));
}
public void SaveNewMaterial()
{
matData.ReplaceRange(BitConverter.GetBytes(matData.Count - 28), 8, 4); //write new material data size to material chunks's header
matData.ReplaceRange(BitConverter.GetBytes(valueDataSize), 24, 4); //write new material "valueData" size to materials chunk's header
Crc crc32 = new Crc(CrcStdParams.StandartParameters[CrcAlgorithms.Crc32]);
byte[] b32 = crc32.ComputeHash(matData.ToArray(), 28, matData.Count - 28); //calc material data crc32
matData.ReplaceRange(b32, 4, 4); //write material data crc32
Crc crc8 = new Crc(CrcStdParams.StandartParameters[CrcAlgorithms.Crc16Genibus]);
byte[] tempHeader = matData.GetRange(0, 28).ToArray(); tempHeader[2] = 0x00; //temp material header without crc8
byte[] b8 = crc8.ComputeHash(tempHeader, 0, 28); //calc material header crc16, gets trunicated to 8 bits
matData.ReplaceRange(b8, 2, 1); //write material header crc8
}
/// <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;
}
}
public static byte[] ComputeChecksum(byte[] bytes) => crc.ComputeHash(bytes);
public void processMain()
{
for (;;)
{
if (RecvDataList.Count < 70)
{
continue;
}
if (!(RecvDataList[0] == 0xFF && RecvDataList[1] == 0xFF)) //FF, FF 확인
{
RecvDataList.RemoveRange(0, 1); //FF, FF전 데이터삭제
continue;
}
else if (RecvDataList[0] == 0xFF && RecvDataList[1] == 0xFF)
{
if (RecvDataList[bufferlength - 2] == 0xFF && RecvDataList[bufferlength - 1] == 0xFE) //FF, FE 확인
{
RecvDataList.CopyTo(0, Rec_Check, 0, bufferlength);
byte[] crc_cal = new byte[bufferlength - 6];
Array.Copy(Rec_Check, 2, crc_cal, 0, bufferlength - 6);
Crc = crc.ComputeHash(crc_cal);
if (Crc[Crc.Length - 2] != Rec_Check[66] || Crc[Crc.Length - 1] != Rec_Check[67])
{
RecvDataList.RemoveRange(0, bufferlength - 1);
continue;
}
//data parse :
for (int i = 0; i < 11; i++)
{
int k = 2 * i;
Tempo_FSR[i] = (Rec_Check[2 + k] << 8) + Rec_Check[3 + k]; // TMR + FSR
if (flag_save == true)
{
try
{
file.Write("{0}", Tempo_FSR[i]);
file.Write(",");
}
catch {}
}
}
//uwb hex to short
// uwb 1 : range , power + uwb 2 : range , power
for (int i = 0; i < 12; i++)
{
int k = 2 * i;
Tempo_UWB[i] = (short)((Rec_Check[24 + k] << 8) + Rec_Check[25 + k]); // UWB
if (flag_save == true)
{
try
{
file.Write("{0}", Tempo_UWB[i]);
file.Write(",");
}
catch { }
}
}
//Imu data int
// uwb 1 : range , power + uwb 2 : range , power
for (int i = 0; i < 9; i++)
{
int k = 2 * i;
Tempo_IMU[i] = (Rec_Check[48 + k] << 8) + Rec_Check[49 + k]; // IMU
if (flag_save == true)
{
try
{
file.Write("{0}", Tempo_IMU[i]);
if (i == 8)
{
//file.Write(";");
file.Write("\n");
}
else
{
file.Write(",");
}
}
catch { }
}
}
try
{
RecvDataList.RemoveRange(0, bufferlength - 1);
}
catch { }
}
else
{
RecvDataList.RemoveRange(0, bufferlength - 1); // 데이터 모두삭제
continue;
}
}
}
}