public override int GetTypeAttr(IntPtr ppTypeAttr)
{
var hr = _target_ITypeInfo.GetTypeAttr(ppTypeAttr);
if (ComHelper.HRESULT_FAILED(hr))
{
return(HandleBadHRESULT(hr));
}
var pTypeAttr = StructHelper.ReadStructureUnsafe <IntPtr>(ppTypeAttr);
var typeAttr = StructHelper.ReadStructureUnsafe <ComTypes.TYPEATTR>(pTypeAttr);
typeAttr.typekind = PatchTypeKind((TYPEKIND_VBE)typeAttr.typekind);
// A proper type library would not have any variables defined in the modules.
// However, a VBA module can have those and that can trip up CLR's parser. To
// work around this, we lie to any ComTypes.ITypeInfo consumer that there's no
// variables. If we need for VBA-specific work, we need to consult
// ITypeInfoWrapper.Vars instead.
if (typeAttr.typekind == ComTypes.TYPEKIND.TKIND_MODULE && typeAttr.cVars > 0)
{
typeAttr.cVars = (short)Consts.Count;
}
RdMarshal.StructureToPtr <ComTypes.TYPEATTR>(typeAttr, pTypeAttr, true);
return(hr);
}
private static void Test()
{
try
{
ProductStruct product = new ProductStruct();
product.No = 1;
product.UID = "PNo123456".GetFixLengthChar(14);
product.Current = 0.567;
product.Pass = 0;
var b = StructHelper.StuctToByte(product);
Console.WriteLine("Struct length:" + b.Length);
Console.WriteLine("Hex: " + ByteToHexString(b, ' '));
var s = StructHelper.ByteToStuct <ProductStruct>(b);
Console.WriteLine("No: " + s.No.ToString());
Console.WriteLine("UID: " + s.UID.GetString());
Console.WriteLine("Current: " + s.Current.ToString());
Console.WriteLine("Pass: " + s.Pass.ToString());
//Test1();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
//byte[] buffer = new byte[1024];
//Array.Copy(test, 0, buffer, 0, test.Length);
//Analysis(buffer, test);
}
//------------------------------------------------------
//
// Public Methods
//
//------------------------------------------------------
#region Public Methods
public override void Go()
{
string generatedPath =
Path.Combine(
_resourceModel.OutputDirectory,
"src\\Graphics\\Include\\Generated"
);
FileCodeSink cppFile = new FileCodeSink(generatedPath, "wgx_render_types_generated.h");;
Helpers.Style.WriteFileHeader(cppFile);
foreach (McgEnum e in _resourceModel.Enums)
{
if (_resourceModel.ShouldGenerate(CodeSections.NativeMilRenderTypes, e))
{
cppFile.WriteBlock(EnumHelper.FormatNativeEnum(e));
}
}
foreach (McgResource r in _resourceModel.Resources)
{
if (_resourceModel.ShouldGenerate(CodeSections.NativeMilRenderTypes, r))
{
cppFile.WriteBlock(StructHelper.FormatNativeStructure(r));
}
}
//
// MilCompoundStyle is a special case
//
McgEnum milCompoundStyleEnum = (McgEnum)_resourceModel.FindType("MilCompoundStyle");
cppFile.WriteBlock(
void doLogicGetData(Connector socketConnector)
{
socketConnector.Send(Encoding.ASCII.GetBytes("\n"));
socketConnector.Receive(ref frameInfo);
if (frameInfo != null) // size of the empty buffer
{
Debug.Log("I started deserialization for" + index);
this.feature = MessagePackSerializer.Deserialize<Dictionary<string, Dictionary<string, ushort[][]>>>(frameInfo);
Debug.Log("I finished deserialization for" + index);
structHelper = featureMapCreator.updateFeatures(feature);
try
{
var convPixelsFifthBatch = getConvPixels(structHelper.featureMapList);
var lastLayersPixels = getLastLayersPixels(); // make sure it is not reused
var time = DateTime.Now.ToString("HH:mm:ss");
main.updateFeatureMapPixels(convPixelsFifthBatch, lastLayersPixels, time);
}
catch
{
}
}
}
public ActionResult UserLookUp()
{
StructHelper structHelper = new StructHelper();
ViewBag.StructTree = structHelper.GetStructTree(true);
return(View());
}
void Start()
{
TeachIp = new IPEndPoint(IPAddress.Parse(File.ReadAllText("ip.txt")), 16000);
this.clientTeach = new UdpClient(12000);
ip = new IPEndPoint(IPAddress.Any, 0);
angle = DefaultAngle;
lastAngle = DefaultAngle;
otherAngle = DefaultAngle;
command = default(TeachingCommand);
angleWithLocation = default(AngleWithLocation);
otherAngleWithLocation = default(AngleWithLocation);
SendThreading = new Thread(new ThreadStart(SendRotation));
SendThreading.Start();
SendThreading.Name = "SendEvent" + base.transform.name;
RecieveThread = new Thread(new ThreadStart(RecieveData));
RecieveThread.Start();
RecieveThread.Name = "RecieveEvent";
RecieveFromTeachThread = new Thread(new ThreadStart(RecieveDataFromTeach));
RecieveFromTeachThread.Start();
RecieveFromTeachThread.Name = "RecieveFromTeachEvent";
//UdpPlatform.Instance.SendString("Udp Start");
Task.Run(() =>
{
while (true)
{
//var ipRe = new IPEndPoint(IPAddress.Parse("192.168.0.135"), 16000);
//var bytes = this.clientTeach.Receive(ref ipRe);
var bytes = this.clientTeach.Receive(ref TeachIp);
var length = bytes.Length;
if (length == StructHelper.GetStructSize <TeachingCommand>())
{
command = StructHelper.BytesToStruct <TeachingCommand>(bytes);
this.IsSendFromTeachingPlatform = command.IsStart == 1;
}
}
});
Task.Run(() =>
{
while (true)
{
UdpPlatform.Instance.SendData(this.angleWithLocation, new IPEndPoint(IPAddress.Broadcast, 16000));
Thread.Sleep(20);
}
});
if (this.MemDB.Init(this.memName) == 0 || this.MemDB.Init("GAME_SHARED_MEM_0000") == 0)
{
Debug.Log("Run");
}
else
{
Debug.Log("no Run");
Time.timeScale = 0f;
}
}
protected static byte[] ControlChangeMessage(Channel channel, int control, int value)
=> new[]
{
StructHelper.StatusByte(Midi.Status.ControlChangeBitmask, channel),
StructHelper.DataByte(control),
StructHelper.DataByte(value)
};
public static void SetOverdriveCounter(int charIndex, int odIndex, int odCount)
{
var odOffset = StructHelper.GetFieldOffset <PartyMember>("OverdriveWarrior",
_offsetParty + Marshal.SizeOf <PartyMember>() * charIndex + OverdriveModes[odIndex].BitIndex * 2);
GameMemory.Write(odOffset, BitConverter.GetBytes((ushort)odCount), false);
}
protected static byte[] PolyphonicKeyPressureMessage(Channel channel, Key key = Key.Key0, int pressure = 0)
=> new[]
{
StructHelper.StatusByte(Midi.Status.PolyphonicKeyPressureBitmask, channel),
StructHelper.DataByte(key),
StructHelper.DataByte(pressure)
};
protected static byte[] NoteOnMessage(Channel channel, Key key = Key.Key0, int velocity = 0)
=> new[]
{
StructHelper.StatusByte(Midi.Status.NoteOnBitmask, channel),
StructHelper.DataByte(key),
StructHelper.DataByte(velocity)
};
//------------------------------------------------------
//
// Public Methods
//
//------------------------------------------------------
#region Public Methods
public override void Go()
{
string generatedPath =
Path.Combine(
_resourceModel.OutputDirectory,
"src\\Graphics\\Include\\Generated"
);
FileCodeSink cppFile = new FileCodeSink(generatedPath, "wincodec_private_generated.h");;
Helpers.Style.WriteFileHeader(cppFile);
foreach (McgEnum e in _resourceModel.Enums)
{
if (_resourceModel.ShouldGenerate(CodeSections.NativeWincodecPrivate, e))
{
cppFile.WriteBlock(EnumHelper.FormatNativeEnum(e));
}
}
foreach (McgResource r in _resourceModel.Resources)
{
if (_resourceModel.ShouldGenerate(CodeSections.NativeWincodecPrivate, r))
{
cppFile.WriteBlock(StructHelper.FormatNativeStructure(r));
}
}
cppFile.Dispose();
}
void Start()
{
featureMapCreator = new FeatureMapCreator();
sceneLoader = GameObject.Find("SceneLoader").GetComponent <SceneLoader>();
socketConnector = new Connector();
socketConnector.establishConnection(60000); // 60000
model = getModelNameAndSize(sceneLoader.modelPicker.ToString()); // get model type
visualisationMode = sceneLoader.mode;
inputImageSizeValue = sceneLoader.inputImageSizeValue;
if (model.Equals("17"))
{
modelPath = sceneLoader.pathModel;
}
else
{
modelPath = "None";
}
if (inputImageSizeValue != 0)
{
model += " " + inputImageSizeValue.ToString();
}
if (visualisationMode == 1)
{
videoPath = sceneLoader.pathVideo;
}
else
{
videoPath = "None";
}
recordTime = sceneLoader.loadingTime; /// get loading time
frameRate = 1 / sceneLoader.framesPerSecond; // get framerate update
numThreads = sceneLoader.threads; // get number of threads
HashSet <string> .Enumerator layers = sceneLoader.layersToGet.GetEnumerator(); /// get layers to see
while (layers.MoveNext())
{
layersToSee = layersToSee + " " + layers.Current;
}
byte[] start_server = Encoding.ASCII.GetBytes("start " + numThreads + " " + model + " " + modelPath + " " + visualisationMode + " " + videoPath + " " + sceneLoader.framesPerSecond + " " + layersToSee + "\n");
var z = socketConnector.SendAndReceive(start_server);
Debug.Log("I started deserialization");
feature = MessagePackSerializer.Deserialize <Dictionary <string, Dictionary <string, ushort[][]> > >(z);
Debug.Log("I finished deserialization");
featureMapsObjects = featureMapCreator.makeFeature(featuresTemplate, featuresPredictionsTemplate, feature);
for (int x = 1; x <= numThreads; x++)
{
new ThreadComponent(x, this, featureMapCreator).init();
Thread.Sleep(1000);
}
}
/// <summary>
/// Gets the control <see cref="ComTypes.ITypeInfo"/> by looking for the
/// corresponding getter on the form interface and returning its retval type
/// </summary>
/// <param name="controlName">the name of the control</param>
/// <returns>
/// <see cref="ITypeInfoWrapper"/> representing the type of control,
/// typically the coclass, but this is host dependent
/// </returns>
public static ITypeInfoWrapper GetControlTypeFromInterface(ITypeInfoWrapper rootInterface, string controlName)
{
// TODO should encapsulate handling of raw datatypes
foreach (var func in rootInterface.Funcs)
{
using (func)
{
// Controls are exposed as getters on the interface.
// can either be ControlType* get_ControlName()
// or HRESULT get_ControlName(ControlType** Out)
if ((func.Name == controlName) &&
(func.ProcKind == PROCKIND.PROCKIND_GET) &&
(func.ParamCount == 0) &&
(func.FuncDesc.elemdescFunc.tdesc.vt == (short)VarEnum.VT_PTR))
{
var retValElement = StructHelper.ReadStructureUnsafe <ComTypes.ELEMDESC>(func.FuncDesc.elemdescFunc.tdesc.lpValue);
if (retValElement.tdesc.vt == (short)VarEnum.VT_USERDEFINED)
{
var hr = rootInterface.GetSafeRefTypeInfo((int)retValElement.tdesc.lpValue, out var retVal);
if (ComHelper.HRESULT_FAILED(hr))
{
throw RdMarshal.GetExceptionForHR(hr);
}
return(retVal);
}
}
else if ((func.Name == controlName) &&
(func.ProcKind == PROCKIND.PROCKIND_GET) &&
(func.ParamCount == 1) &&
(func.FuncDesc.elemdescFunc.tdesc.vt == (short)VarEnum.VT_HRESULT))
{
// Get details of the first argument
var retValElementOuterPtr = StructHelper.ReadStructureUnsafe <ComTypes.ELEMDESC>(func.FuncDesc.lprgelemdescParam);
if (retValElementOuterPtr.tdesc.vt == (short)VarEnum.VT_PTR)
{
var retValElementInnerPtr = StructHelper.ReadStructureUnsafe <ComTypes.ELEMDESC>(retValElementOuterPtr.tdesc.lpValue);
if (retValElementInnerPtr.tdesc.vt == (short)VarEnum.VT_PTR)
{
var retValElement = StructHelper.ReadStructureUnsafe <ComTypes.ELEMDESC>(retValElementInnerPtr.tdesc.lpValue);
if (retValElement.tdesc.vt == (short)VarEnum.VT_USERDEFINED)
{
var hr = rootInterface.GetSafeRefTypeInfo((int)retValElement.tdesc.lpValue, out var retVal);
if (ComHelper.HRESULT_FAILED(hr))
{
throw RdMarshal.GetExceptionForHR(hr);
}
return(retVal);
}
}
}
}
}
}
throw new ArgumentException($"TypeInfoWrapper::GetControlType failed. '{controlName}' control not found.");
}
internal static ITypeLibWrapper FromVBProject(IVBProject vbProject)
{
using (var references = vbProject.References)
{
// Now we've got the references object, we can read the internal object structure to grab the ITypeLib
var internalReferencesObj = StructHelper.ReadComObjectStructure <VBEReferencesObj>(references.Target);
return(TypeApiFactory.GetTypeLibWrapper(internalReferencesObj._typeLib, addRef: true));
}
}
public void Reset() // walk back to the first project in the chain
{
while (_currentTypeLibStruct.Prev != IntPtr.Zero)
{
_currentTypeLibPtr = _currentTypeLibStruct.Prev;
_currentTypeLibStruct = StructHelper.ReadStructureSafe <VBETypeLibObj>(_currentTypeLibPtr);
}
_isStart = true;
}
public ActionResult AssignUser(string roleId)
{
ViewBag.RoleId = roleId;
StructHelper helper = new StructHelper();
ViewBag.StructTree = helper.GetStructTree(true);
return(View());
}
public static Header FromArray(byte[] header)
{
if (header.Length < SIZE)
{
throw new ArgumentException("Header length too small");
}
return(StructHelper.GetStruct <Header>(header, 0, SIZE));
}
public static Question FromArray(byte[] message, int offset, out int endOffset)
{
Domain domain = Domain.FromArray(message, offset, out offset);
Tail tail = StructHelper.GetStruct <Tail>(message, offset, Tail.SIZE);
endOffset = offset + Tail.SIZE;
return(new Question(domain, tail.Type, tail.Class));
}
public static void MaxSphereLevels()
{
var partyOffset = OffsetScanner.GetOffset(GameOffset.FFX_PartyStatBase);
for (var i = 0; i < 8; i++)
{
int characterOffset = partyOffset + 0x94 * i;
LegacyMemoryReader.WriteByte(StructHelper.GetFieldOffset <PartyMember>("SphereLevelCurrent", characterOffset), 255);
}
}
public byte[] ToArray()
{
ByteStream result = new ByteStream(Size);
result
.Append(domain.ToArray())
.Append(StructHelper.GetBytes(new Tail {
Type = Type, Class = Class
}));
return(result.ToArray());
}
public TypeInfoVariable(ComTypes.ITypeInfo typeInfo, int index)
{
_typeInfo = typeInfo;
_typeInfo.GetVarDesc(index, out _varDescPtr);
_varDesc = StructHelper.ReadStructureUnsafe <ComTypes.VARDESC>(_varDescPtr);
var names = new string[1];
typeInfo.GetNames(_varDesc.memid, names, 1, out var actualCount);
Name = actualCount >= 1 ? names[0] : "[unnamed]";
}
public void Pack()
{
var outputStream = File.Open(_outFile, FileMode.OpenOrCreate, FileAccess.ReadWrite);
_packHeader.Signature = new byte[] { 0x50, 0x41, 0x43, 0x4B, 0x02, 0x01, 0x00, 0x00 };
_packHeader.D1 = 1;
_packHeader.Sum = (uint)_packList.Count;
_packHeader.DataPath = "data\\";
_packHeader.FileTime1 = DateTime.UtcNow.ToFileTimeUtc();
_packHeader.FileTime2 = DateTime.UtcNow.ToFileTimeUtc();
_packHeader.FileCount = (uint)_packList.Count;
_packHeader.HeaderLength = 0;
_packHeader.DataLength = (uint)_bodyStream.Position;
_packHeader.BlankLength = 0;
_packHeader.Zero = new byte[16];
var infos = new List <Tuple <byte[], PackageItemInfo> >();
foreach (var entry in _packList)
{
var info = new PackageItemInfo
{
CompressedSize = (int)entry.CompressedSize,
DecompressedSize = (int)entry.DecompressedSize,
IsCompressed = entry.IsCompressed,
DataOffset = entry.DataOffset,
Seed = (int)entry.Seed,
FileTime1 = entry.FileTime1,
FileTime3 = entry.FileTime3,
FileTime5 = entry.FileTime5
};
var bytes = EncodeName(entry.FullName);
infos.Add(Tuple.Create(bytes, info));
_packHeader.HeaderLength += (uint)(bytes.Length + StructHelper.SizeOf <PackageItemInfo>());
}
_packHeader.WriteToStream(outputStream);
foreach (var packInfo in infos)
{
outputStream.Write(packInfo.Item1, 0, packInfo.Item1.Length);
packInfo.Item2.WriteToStream(outputStream);
}
_bodyStream.Position = 0;
_bodyStream.CopyTo(outputStream);
outputStream.Flush();
outputStream.Close();
outputStream.Dispose();
}
public TypeInfoFunc(TypeInfoWrapper typeInfo, int funcIndex)
{
_typeInfo = typeInfo;
((ComTypes.ITypeInfo)_typeInfo).GetFuncDesc(funcIndex, out _funcDescPtr);
FuncDesc = StructHelper.ReadStructureUnsafe <ComTypes.FUNCDESC>(_funcDescPtr);
((ComTypes.ITypeInfo)_typeInfo).GetNames(FuncDesc.memid, _names, _names.Length, out _cNames);
if (_cNames == 0)
{
_names[0] = "[unnamed]";
}
}
public void FillStructReport(T_TBS_BG tbs, StructReport structReport)
{
StructHelper.FillCommonResult(tbs, structReport);
// if (!string.IsNullOrEmpty(tbs.F_TBS_WSW1.Trim()))
// structReport.UnStructItems.Add(new UNStructItem
// {
// ItemName = "HER2基因扩增",
// Result = tbs.F_TBS_WSW1
// });
//连续计数浸润性癌 30 个肿瘤细胞
if (!string.IsNullOrEmpty(tbs.F_TBS_WSW2.Trim()))
{
structReport.StructItems.Add(new StructItem
{
ItemName = "连续计数浸润性癌",
Result = T_TBS_BG.SubStringBetween(tbs.F_TBS_WSW2, "连续计数浸润性癌", "个肿瘤细胞").Trim(),
ResultUnit = "个"
});
}
//平均HER2基因拷贝数/细胞=3.52
if (!string.IsNullOrEmpty(tbs.F_TBS_WSW3.Trim()))
{
structReport.StructItems.Add(new StructItem
{
ItemName = "平均HER2基因拷贝数",
Result = tbs.F_TBS_WSW3.Replace("平均HER2基因拷贝数/细胞=", "").Trim(),
ResultUnit = "拷贝数/细胞"
});
}
//平均CEP17拷贝数/细胞=2.02
if (!string.IsNullOrEmpty(tbs.F_TBS_WSW4.Trim()))
{
structReport.StructItems.Add(new StructItem
{
ItemName = "平均CEP17拷贝数",
Result = tbs.F_TBS_WSW4.Replace("平均CEP17拷贝数/细胞=", "").Trim(),
ResultUnit = "拷贝数/细胞"
});
}
//HER2/CEP17比值=1.06
if (!string.IsNullOrEmpty(tbs.F_TBS_WSW5.Trim()))
{
structReport.StructItems.Add(new StructItem
{
ItemName = "HER2/CEP17比值",
Result = tbs.F_TBS_WSW5.Replace("HER2/CEP17比值=", "").Trim(),
ResultUnit = ""
});
}
}
public StartOfAuthorityResourceRecord(IResourceRecord record, byte[] message, int dataOffset)
: base(record)
{
MasterDomainName = Domain.FromArray(message, dataOffset, out dataOffset);
ResponsibleDomainName = Domain.FromArray(message, dataOffset, out dataOffset);
Options tail = StructHelper.GetStruct <Options>(message, dataOffset, Options.SIZE);
SerialNumber = tail.SerialNumber;
RefreshInterval = tail.RefreshInterval;
RetryInterval = tail.RetryInterval;
ExpireInterval = tail.ExpireInterval;
MinimumTimeToLive = tail.MinimumTimeToLive;
}
public static ResourceRecord FromArray(byte[] message, int offset, out int endOffset)
{
Domain domain = Domain.FromArray(message, offset, out offset);
Tail tail = StructHelper.GetStruct <Tail>(message, offset, Tail.SIZE);
byte[] data = new byte[tail.DataLength];
offset += Tail.SIZE;
Array.Copy(message, offset, data, 0, data.Length);
endOffset = offset + data.Length;
return(new ResourceRecord(domain, data, tail.Type, tail.Class, tail.TimeToLive));
}
static void UdpTask()
{
Task.Run(() =>
{
try
{
while (true)
{
// 从WswTHUSim接收飞行模拟器姿态和经纬度坐标
var ipEndPoint = new IPEndPoint(IPAddress.Any, 0);
var recieveBytes = udpClient.Receive(ref ipEndPoint);
var ip = ipEndPoint.Address.ToString();
var length = recieveBytes.Length;
if (length == StructHelper.GetStructSize <AngleWithLocation>() &&
(ip.StartsWith(comConfig.SelfIp) == true || ip.StartsWith("127.0.0.1")))
{
// 地球坐标系坐标 x y z roll pitch yaw
var angleWithLocation = StructHelper.BytesToStruct <AngleWithLocation>(recieveBytes);
var lon = PositionHelper.XYZToLon(angleWithLocation.X, angleWithLocation.Y, angleWithLocation.Z);
var lat = PositionHelper.XYZToLat(angleWithLocation.X, angleWithLocation.Y, angleWithLocation.Z);
var height = PositionHelper.XYZToHeight(angleWithLocation.X, angleWithLocation.Y, angleWithLocation.Z);
var rolldeg = (angleWithLocation.Roll);
var pitchdeg = (angleWithLocation.Pitch);
var yawdeg = (angleWithLocation.Yaw);
var kind = WswHelper.GetFlightKindFromIp(ip);
if (kind == WswModelKind.EH101)
{
rolldeg = -rolldeg; pitchdeg = -pitchdeg; yawdeg = -yawdeg;
}
udpCount++;
isRevcUdp = true;
lock (lockobj)
{
packetBuilder.SetAngles(rolldeg, pitchdeg, yawdeg)
.SetPositions(lon, lat, height)
.SetStatus(true, false, true, 80)
.SetFlightSimulatorKind(kind);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("udp error as follows:");
Console.WriteLine(ex.ToString());
isUdpError = true;
}
});
}
public void FillStructReport(T_TBS_BG tbs, StructReport structReport)
{
StructHelper.FillCommonResult(tbs, structReport);
// //2.63E+05 copy/mL
// if (!string.IsNullOrEmpty(tbs.F_TBS_XBXM1.Trim()))
// structReport.StructItems.Add(new StructItem
// {
// ItemName = tbs.F_FZ_JCXM,
// Result = tbs.F_TBS_XBXM1.Replace("IU/mL","").Trim(),
// ResultUnit = "IU/mL",
// Reference = tbs.F_TBS_XBXM2.Replace("IU/mL", "").Trim(),
// RefernceUnit = "IU/mL",
// });
}
public static void ToggleOverdriveMode(int charIndex, int overdriveId)
{
var odOffset = StructHelper.GetFieldOffset <PartyMember>("OverdriveModes",
_offsetParty + Marshal.SizeOf <PartyMember>() * charIndex);
var odBytes = GameMemory.Read <byte>(odOffset, 3, false);
var odMode = OverdriveModes.First(od => od.ID == overdriveId);
var bitIndex = odMode.BitIndex % 8;
var byteIndex = odMode.BitIndex / 8;
odBytes[byteIndex] = BitHelper.ToggleBit(odBytes[byteIndex], bitIndex);
GameMemory.Write(odOffset, odBytes, false);
}
private void RecieveDataFromTeach()
{
while (true)
{
var ipRe = new IPEndPoint(IPAddress.Parse("192.168.0.135"), 16000);
var bytes = this.clientTeach.Receive(ref ipRe);
//var bytes = this.clientTeach.Receive(ref TeachIp);
var length = bytes.Length;
if (length == StructHelper.GetStructSize <TeachingCommand>())
{
command = StructHelper.BytesToStruct <TeachingCommand>(bytes);
this.IsSendFromTeachingPlatform = command.IsStart == 1;
}
}
}
