public byte GetMinByteSize() => 33; // of byte sized of fields (exclude extended)
public void Deserialize(ref ReadOnlySpan <byte> buffer, int payloadSize)
{
var index = 0;
var endIndex = payloadSize;
var arraySize = 0;
arraySize = /*ArrayLength*/ 4 - Math.Max(0, ((/*PayloadByteSize*/ 33 - payloadSize - /*ExtendedFieldsLength*/ 0) / 4 /*FieldTypeByteSize*/));
ArU32 = new uint[arraySize];
for (var i = 0; i < arraySize; i++)
{
ArU32[i] = BinSerialize.ReadUInt(ref buffer); index += 4;
}
arraySize = 4;
for (var i = 0; i < arraySize; i++)
{
ArU16[i] = BinSerialize.ReadUShort(ref buffer); index += 2;
}
V1 = (byte)BinSerialize.ReadByte(ref buffer); index += 1;
arraySize = 4;
for (var i = 0; i < arraySize; i++)
{
ArI8[i] = (sbyte)BinSerialize.ReadByte(ref buffer); index += 1;
}
arraySize = 4;
for (var i = 0; i < arraySize; i++)
{
ArU8[i] = (byte)BinSerialize.ReadByte(ref buffer); index += 1;
}
}
public static void WriteHeader(ref Span <byte> span, ushort methodInterfaceId, ushort methodMethodId,
byte requestId)
{
BinSerialize.WriteByte(ref span, requestId);
BinSerialize.WritePackedUnsignedInteger(ref span, methodInterfaceId);
BinSerialize.WritePackedUnsignedInteger(ref span, methodMethodId);
}
public void Serialize(ref Span <byte> buffer)
{
BinSerialize.WritePackedUnsignedInteger(ref buffer, Index);
BinSerialize.WritePackedUnsignedInteger(ref buffer, (uint)Type.TypeEnum);
var typeSize = Type.GetByteSize();
var valueSize = int.MaxValue; // if value == null, we wouldn't serialize it
if (Value != null)
{
valueSize = Value.GetByteSize();
}
if (Value == null || typeSize + valueSize + 1 > PayloadV2Helper.MaxMessageSize)
{
// send only type
BinSerialize.WriteBool(ref buffer, false);
Type.Serialize(ref buffer);
}
else
{
// send type + value
BinSerialize.WriteBool(ref buffer, true);
Type.Serialize(ref buffer);
Value.Serialize(ref buffer);
}
}
public void Deserialize(ref ReadOnlySpan <byte> buffer)
{
var type = (Pv2ParamTypeEnum)BinSerialize.ReadPackedUnsignedInteger(ref buffer);
Value = Pv2ParamInterface.CreateValue(type);
Value.Deserialize(ref buffer);
}
public void Deserialize(ref ReadOnlySpan <byte> buffer)
{
Comment = BinSerialize.ReadString(ref buffer);
Version = BinSerialize.ReadByte(ref buffer);
Hash = BinSerialize.ReadUInt(ref buffer);
ItemsCount = BinSerialize.ReadInt(ref buffer);
}
public void Serialize(ref Span <byte> buffer)
{
SessionId.Serialize(ref buffer);
BinSerialize.WritePackedUnsignedInteger(ref buffer, FieldId);
BinSerialize.WritePackedUnsignedInteger(ref buffer, StartIndex);
BinSerialize.WritePackedUnsignedInteger(ref buffer, Take);
}
public void Serialize(ref Span <byte> buffer)
{
BinSerialize.WriteString(ref buffer, Comment);
BinSerialize.WriteByte(ref buffer, Version);
BinSerialize.WriteUInt(ref buffer, Hash);
BinSerialize.WriteInt(ref buffer, ItemsCount);
}
public int Serialize(ref Span <byte> buffer)
{
var index = 0;
for (var i = 0; i < Aileron.Length; i++)
{
BinSerialize.WriteUShort(ref buffer, Aileron[i]); index += 2;
}
for (var i = 0; i < Elevator.Length; i++)
{
BinSerialize.WriteUShort(ref buffer, Elevator[i]); index += 2;
}
for (var i = 0; i < Rudder.Length; i++)
{
BinSerialize.WriteUShort(ref buffer, Rudder[i]); index += 2;
}
for (var i = 0; i < Gyro.Length; i++)
{
BinSerialize.WriteUShort(ref buffer, Gyro[i]); index += 2;
}
for (var i = 0; i < Pitch.Length; i++)
{
BinSerialize.WriteUShort(ref buffer, Pitch[i]); index += 2;
}
for (var i = 0; i < Throttle.Length; i++)
{
BinSerialize.WriteUShort(ref buffer, Throttle[i]); index += 2;
}
return(index); // /*PayloadByteSize*/42;
}
public int GetByteSize()
{
return(SessionId.GetByteSize() +
BinSerialize.GetSizeForPackedUnsignedInteger(FieldId) +
BinSerialize.GetSizeForPackedUnsignedInteger(StartIndex) +
BinSerialize.GetSizeForPackedUnsignedInteger(Take));
}
public void Deserialize(ref ReadOnlySpan <byte> buffer)
{
Count = BinSerialize.ReadPackedUnsignedInteger(ref buffer);
var arraySize = BinSerialize.ReadPackedUnsignedInteger(ref buffer);
Data = BinSerialize.ReadBlock(ref buffer, (int)arraySize);
}
public override void Deserialize(ref ReadOnlySpan <byte> buffer)
{
UavIdFilterEnabled = BinSerialize.ReadBool(ref buffer);
UavSystemId = BinSerialize.ReadByte(ref buffer);
UavComponentId = BinSerialize.ReadByte(ref buffer);
WpIndex = BinSerialize.ReadUShort(ref buffer);
}
public int Serialize(ref Span <byte> buffer)
{
var index = 0;
BinSerialize.WriteByte(ref buffer, (byte)Rfhealth); index += 1;
return(index); // /*PayloadByteSize*/1;
}
public void Serialize(ref Span <byte> buffer)
{
var fillBuffer = buffer.Slice(0);
var payloadBuffer = buffer.Slice(10);
var payloadSize = Payload.Serialize(ref payloadBuffer);
Debug.Assert(payloadSize <= byte.MaxValue, $"Wrong payload serialize size (must be {byte.MaxValue} size)");
BinSerialize.WriteByte(ref fillBuffer, PacketV2Helper.MagicMarkerV2);
BinSerialize.WriteByte(ref fillBuffer, (byte)payloadSize);
BinSerialize.WriteByte(ref fillBuffer, IncompatFlags);
BinSerialize.WriteByte(ref fillBuffer, CompatFlags);
BinSerialize.WriteByte(ref fillBuffer, Sequence);
BinSerialize.WriteByte(ref fillBuffer, SystemId);
BinSerialize.WriteByte(ref fillBuffer, ComponenId);
BinSerialize.WriteByte(ref fillBuffer, (byte)((MessageId) & 0xFF));
BinSerialize.WriteByte(ref fillBuffer, (byte)((MessageId >> 8) & 0xFF));
BinSerialize.WriteByte(ref fillBuffer, (byte)((MessageId >> 16) & 0xFF));
var crcBuff = buffer.Slice(1, 9);
var crc = X25Crc.Accumulate(ref crcBuff, X25Crc.CrcSeed);
crcBuff = buffer.Slice(10, payloadSize);
crc = X25Crc.Accumulate(ref crcBuff, crc);
crc = X25Crc.Accumulate(GetCrcEtra(), crc);
fillBuffer = fillBuffer.Slice(payloadSize);
BinSerialize.WriteUShort(ref fillBuffer, crc);
if (Signature.IsPresent)
{
Signature.Serialize(ref fillBuffer);
}
// Debug.Assert((payloadSize + Signature.ByteSize + PacketV2Helper.PacketV2FrameSize) == (buffer.Length - fillBuffer.Length));
buffer = fillBuffer;
}
public byte GetMinByteSize() => 20; // of byte sized of fields (exclude extended)
public void Deserialize(ref ReadOnlySpan <byte> buffer, int payloadSize)
{
var index = 0;
var endIndex = payloadSize;
var arraySize = 0;
Icao = BinSerialize.ReadUInt(ref buffer); index += 4;
Stallspeed = BinSerialize.ReadUShort(ref buffer); index += 2;
arraySize = /*ArrayLength*/ 9 - Math.Max(0, ((/*PayloadByteSize*/ 20 - payloadSize - /*ExtendedFieldsLength*/ 0) / 1 /*FieldTypeByteSize*/));
Callsign = new char[arraySize];
unsafe
{
fixed(byte *bytePointer = buffer)
fixed(char *charPointer = Callsign)
{
Encoding.ASCII.GetChars(bytePointer, arraySize, charPointer, Callsign.Length);
}
}
buffer = buffer.Slice(arraySize);
index += arraySize;
Emittertype = (AdsbEmitterType)BinSerialize.ReadByte(ref buffer); index += 1;
Aircraftsize = (UavionixAdsbOutCfgAircraftSize)BinSerialize.ReadByte(ref buffer); index += 1;
Gpsoffsetlat = (UavionixAdsbOutCfgGpsOffsetLat)BinSerialize.ReadByte(ref buffer); index += 1;
Gpsoffsetlon = (UavionixAdsbOutCfgGpsOffsetLon)BinSerialize.ReadByte(ref buffer); index += 1;
Rfselect = (UavionixAdsbOutRfSelect)BinSerialize.ReadByte(ref buffer); index += 1;
}
public override void Serialize(ref Span <byte> buffer)
{
BinSerialize.WriteBool(ref buffer, UavIdFilterEnabled);
BinSerialize.WriteByte(ref buffer, UavSystemId);
BinSerialize.WriteByte(ref buffer, UavComponentId);
BinSerialize.WriteUShort(ref buffer, WpIndex);
}
public byte GetMinByteSize() => 84; // of byte sized of fields (exclude extended)
public void Deserialize(ref ReadOnlySpan <byte> buffer, int payloadSize)
{
var index = 0;
var endIndex = payloadSize;
var arraySize = 0;
arraySize = 2;
for (var i = 0; i < arraySize; i++)
{
ArD[i] = BinSerialize.ReadDouble(ref buffer); index += 8;
}
arraySize = 2;
for (var i = 0; i < arraySize; i++)
{
ArF[i] = BinSerialize.ReadFloat(ref buffer); index += 4;
}
arraySize = 2;
for (var i = 0; i < arraySize; i++)
{
ArU32[i] = BinSerialize.ReadUInt(ref buffer); index += 4;
}
arraySize = 2;
for (var i = 0; i < arraySize; i++)
{
ArI32[i] = BinSerialize.ReadInt(ref buffer); index += 4;
}
arraySize = 2;
for (var i = 0; i < arraySize; i++)
{
ArU16[i] = BinSerialize.ReadUShort(ref buffer); index += 2;
}
arraySize = 2;
for (var i = 0; i < arraySize; i++)
{
ArI16[i] = BinSerialize.ReadShort(ref buffer); index += 2;
}
arraySize = 2;
for (var i = 0; i < arraySize; i++)
{
ArU8[i] = (byte)BinSerialize.ReadByte(ref buffer); index += 1;
}
arraySize = 2;
for (var i = 0; i < arraySize; i++)
{
ArI8[i] = (sbyte)BinSerialize.ReadByte(ref buffer); index += 1;
}
arraySize = /*ArrayLength*/ 32 - Math.Max(0, ((/*PayloadByteSize*/ 84 - payloadSize - /*ExtendedFieldsLength*/ 0) / 1 /*FieldTypeByteSize*/));
ArC = new char[arraySize];
unsafe
{
fixed(byte *bytePointer = buffer)
fixed(char *charPointer = ArC)
{
Encoding.ASCII.GetChars(bytePointer, arraySize, charPointer, ArC.Length);
}
}
buffer = buffer.Slice(arraySize);
index += arraySize;
}
public byte GetMinByteSize() => 1; // of byte sized of fields (exclude extended)
public void Deserialize(ref ReadOnlySpan <byte> buffer, int payloadSize)
{
var index = 0;
var endIndex = payloadSize;
var arraySize = 0;
Rfhealth = (UavionixAdsbRfHealth)BinSerialize.ReadByte(ref buffer); index += 1;
}
public void Serialize(ref Span <byte> buffer)
{
BinSerialize.WriteBool(ref buffer, IsEnabled);
if (IsEnabled && Session != null)
{
Session.Serialize(ref buffer);
}
}
public int Serialize(ref Span <byte> buffer)
{
var index = 0;
BinSerialize.WriteUInt(ref buffer, Checksum); index += 4;
BinSerialize.WriteByte(ref buffer, (byte)MissionType); index += 1;
return(index); // /*PayloadByteSize*/5;
}
public int GetByteSize()
{
return(SessionId.GetByteSize() +
BinSerialize.GetSizeForPackedUnsignedInteger(Counter) +
sizeof(byte) /* Flags */ +
sizeof(byte) /* Count */ +
(Groups?.Count * sizeof(ushort) ?? 0));
}
public byte GetMinByteSize() => 1; // of byte sized of fields (exclude extended)
public void Deserialize(ref ReadOnlySpan <byte> buffer, int payloadSize)
{
var index = 0;
var endIndex = payloadSize;
var arraySize = 0;
Status = (IcarousFmsState)BinSerialize.ReadByte(ref buffer); index += 1;
}
public void Deserialize(ref ReadOnlySpan <byte> buffer)
{
SessionId ??= new SessionId();
SessionId.Deserialize(ref buffer);
FieldId = BinSerialize.ReadPackedUnsignedInteger(ref buffer);
StartIndex = BinSerialize.ReadPackedUnsignedInteger(ref buffer);
Take = BinSerialize.ReadPackedUnsignedInteger(ref buffer);
}
public override void Serialize(ref Span <byte> buffer)
{
base.Serialize(ref buffer);
BinSerialize.WritePackedUnsignedInteger(ref buffer, (uint)_list.Count);
foreach (var t in Items)
{
BinSerialize.WriteString(ref buffer, t);
}
}
public byte GetMinByteSize() => 5; // of byte sized of fields (exclude extended)
public void Deserialize(ref ReadOnlySpan <byte> buffer, int payloadSize)
{
var index = 0;
var endIndex = payloadSize;
var arraySize = 0;
Checksum = BinSerialize.ReadUInt(ref buffer); index += 4;
MissionType = (MavMissionType)BinSerialize.ReadByte(ref buffer); index += 1;
}
public int Serialize(ref Span <byte> buffer)
{
var index = 0;
BinSerialize.WriteByte(ref buffer, (byte)Mode); index += 1;
BinSerialize.WriteByte(ref buffer, (byte)NavMode); index += 1;
BinSerialize.WriteByte(ref buffer, (byte)Pilot); index += 1;
return(index); // /*PayloadByteSize*/3;
}
public void Serialize(ref Span <byte> buffer)
{
BinSerialize.WritePackedUnsignedInteger(ref buffer, (uint)Items.Count);
foreach (var item in Items)
{
Debug.Assert(item != null, nameof(item) + " != null");
item.Serialize(ref buffer);
}
}
public byte GetMinByteSize() => 3; // of byte sized of fields (exclude extended)
public void Deserialize(ref ReadOnlySpan <byte> buffer, int payloadSize)
{
var index = 0;
var endIndex = payloadSize;
var arraySize = 0;
Mode = (byte)BinSerialize.ReadByte(ref buffer); index += 1;
NavMode = (byte)BinSerialize.ReadByte(ref buffer); index += 1;
Pilot = (byte)BinSerialize.ReadByte(ref buffer); index += 1;
}
public int Serialize(ref Span <byte> buffer)
{
var index = 0;
for (var i = 0; i < ArU32.Length; i++)
{
BinSerialize.WriteUInt(ref buffer, ArU32[i]); index += 4;
}
return(index); // /*PayloadByteSize*/16;
}
public void Deserialize(ref ReadOnlySpan <byte> buffer)
{
IsEnabled = BinSerialize.ReadBool(ref buffer);
if (!IsEnabled)
{
return;
}
Session = new SessionMetadata();
Session.Deserialize(ref buffer);
}
public void Deserialize(ref ReadOnlySpan <byte> buffer)
{
var count = BinSerialize.ReadPackedUnsignedInteger(ref buffer);
for (var i = 0; i < count; i++)
{
var item = new Pv2ParamValueItem();
item.Deserialize(ref buffer);
Items.Add(item);
}
}
