private void OnReceive(IBuffer buffer)
{
mBaseNetworkStream.Import(buffer);
if (Packet != null)
{
try
{
Packet.Decode(this, this.Stream);
}
catch (Exception e_)
{
ProcessError(e_, "client packet decoding error!");
}
}
else
{
try
{
mReceiveArgs.Stream = this.Stream;
if (awaitPipeStream.Pending)
{
awaitPipeStream.Success(this.Stream.ToPipeStream());
}
else
{
DataReceive?.Invoke(this, mReceiveArgs);
}
}
catch (Exception e_)
{
ProcessError(e_, "client buffer process error!");
}
}
}
private void button1_Click(object sender, EventArgs e)
{
button1.Enabled = false;
DataReceive dr = new DataReceive(textBox1.Text);
textBox2.Text=dr.getData()+"\n Data Received From this ip"+dr.ipaddress;
button1.Enabled = true;
}
protected DataReceive GetDataRec()
{
DataReceive data = state.buffer;
flagReadyReadData = false;
return(data);
}
/// <summary>
/// 开始读取串口数据
/// </summary>
private void ReadPort()
{
while (m_keepReading)
{
if (m_serialPort.IsOpen)
{
int size = m_serialPort.BytesToRead;
if (size > 0)
{
byte[] buffer = new byte[size];
try
{
Application.DoEvents();
m_serialPort.Read(buffer, 0, size);
DataReceive?.Invoke(buffer);
Thread.Sleep(100);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
}
public void Initialize()
{
robotManagementService = new RobotManagementService(this.mainWindow.map);
doorManagementService = new DoorManagementService();
DataReceive status = new DataReceive();
// Test door
/// doorManagementService.DoorMezzamineUpNew.LampSetStateOn(DoorType.DOOR_FRONT);
//while (true)
//{
// doorManagementService.DoorMezzamineUpNew.LampOn(DoorType.DOOR_FRONT);
// doorManagementService.DoorMezzamineUpNew.LampOff(DoorType.DOOR_FRONT);
// doorManagementService.DoorMezzamineUpNew.OpenPress(DoorType.DOOR_FRONT);
// doorManagementService.DoorMezzamineUpNew.GetStatus(ref status, DoorType.DOOR_FRONT);
// doorManagementService.DoorMezzamineUpNew.ClosePress(DoorType.DOOR_FRONT);
// doorManagementService.DoorMezzamineUpNew.GetStatus(ref status, DoorType.DOOR_FRONT);
// doorManagementService.DoorMezzamineUpNew.OpenPress(DoorType.DOOR_BACK);
// doorManagementService.DoorMezzamineUpNew.GetStatus(ref status, DoorType.DOOR_BACK);
// doorManagementService.DoorMezzamineUpNew.ClosePress(DoorType.DOOR_BACK);
// doorManagementService.DoorMezzamineUpNew.GetStatus(ref status, DoorType.DOOR_BACK);
//}
// End
procedureManagementService = new ProcedureManagementService();
chargerService = new ChargerManagementService();
trafficService = new TrafficManagementService();
deviceRegistrationService = new DeviceRegistrationService(12000);
Global_Object.doorManagementServiceCtrl = doorManagementService;
assigmentTaskService = new AssigmentTaskService();
assigmentTaskService.RegistryService(robotManagementService);
assigmentTaskService.RegistryService(procedureManagementService);
assigmentTaskService.RegistryService(deviceRegistrationService.GetDeviceItemList());
assigmentTaskService.RegistryService(trafficService);
procedureManagementService.RegistryService(trafficService);
procedureManagementService.RegistryService(robotManagementService);
procedureManagementService.RegistryService(doorManagementService);
procedureManagementService.RegistryService(chargerService);
procedureManagementService.RegistryService(deviceRegistrationService);
procedureManagementService.RegistryService(assigmentTaskService);
robotManagementService.Registry(trafficService);
// robotManagementService.TestRobotProceure();
robotManagementService.Initialize();
//robotManagementService.robot2test();
deviceRegistrationService.listen();
deviceRegistrationService.RegistryMainWindow(this.mainWindow);
//assigmentTaskService.Start();
MessageBox.Show("Bấm Start Để Bắt Đầu !");
RobotMoving robotMoving = new RobotMoving(robotManagementService.RobotUnityRegistedList);
robotMoving.Show();
//assigmentTaskService.Start();
}
public ProcedureRobotToCharger(RobotUnity robot, ChargerManagementService charger, ChargerId id) : base(robot)
{
StateRobotToCharge = RobotGoToCharge.ROBCHAR_IDLE;
batLevel = new DataReceive();
statusCharger = new DataReceive();
this.robot = robot;
chargerCtrl = charger.ChargerStationList[id];
procedureCode = ProcedureCode.PROC_CODE_ROBOT_TO_CHARGE;
}
private void DataReceiveCallback(IAsyncResult ar)
{
UdpClient u = (UdpClient)((UdpState)ar.AsyncState).Client;
IPEndPoint e = (IPEndPoint)((UdpState)ar.AsyncState).EndPoint;
byte[] data = u.EndReceive(ar, ref e);
DataReceive.Raise(this, new UdpServerReceiveEventArgs(data, e, ((UdpState)ar.AsyncState)));
u.BeginReceive(new AsyncCallback(DataReceiveCallback), new UdpState(u, new IPEndPoint(IPAddress.Any, Port)));
}
static void Main(string[] args)
{
string ManagerIpAddress="172.16.52.125";
string ManagerPortAddress="10000";
DataReceive dr = new DataReceive("9000");
string ipaddress=dr.ipaddress;
string data = dr.getData();
Console.WriteLine(data);
DataSend ds = new DataSend(ManagerIpAddress,ManagerPortAddress);
ds.sendData(ipaddress);
ds.sendData(data);
}
void WorkThreadFunction()
{
while (true)
{
DataReceive dr = new DataReceive("11000");
string ipaddress = dr.ipaddress;
//Console.WriteLine(ipaddress);
StackIpaddress.ScannerClerkIpAddress.Enqueue(ipaddress);
//Console.WriteLine(StackIpaddress.ScannerClerkIpAddress.Peek() + "enqueued");
}
}
//internal System.Threading.WaitCallback startTread(ListBox ls)
internal System.Threading.ThreadStart startTread(crawler.Employee.EmployeeGUI employeeGUI)
{
while (true)
{
Console.WriteLine("strt");
DataReceive dr = new DataReceive("5210");
String ipaddress = dr.ipaddress;
StackIpaddress.ClerkIpAddress.Enqueue(ipaddress);
Console.WriteLine(ipaddress);
employeeGUI.AddToListBoxClerk(ipaddress);
}
throw new NotImplementedException();
}
static void Main(string[] args)
{
string ManagerIpAddress = "172.16.52.125";
string ManagerPortAddress = "10000";
DataReceive dr = new DataReceive("9000");
string ipaddress = dr.ipaddress;
string data = dr.getData();
Console.WriteLine(data);
DataSend ds = new DataSend(ManagerIpAddress, ManagerPortAddress);
ds.sendData(ipaddress);
ds.sendData(data);
}
private void _serialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
if (_serialPort.BytesToRead == 0)
{
return;
}
var length = _serialPort.BytesToRead;
var datas = new byte[length];
_serialPort.Read(datas, 0, length);
var code = Encoding.UTF8.GetString(datas);
_buffer.Read(code)?.ForEach(p => DataReceive?.Invoke(this, new DataReceiveEventArgs(p)));
}
internal System.Threading.ThreadStart Monitor(string port)
{
//throw new NotImplementedException();
while (true)
{
DataReceive dr = new DataReceive(port);
string ipaddress = dr.ipaddress;
//Console.WriteLine("ipaddress"+ipaddress);
//Console.WriteLine("enqueueing");
StackIpaddress.ScannerClerkIpAddress.Enqueue(ipaddress);
//Console.WriteLine(StackIpaddress.ScannerClerkIpAddress.Peek()+"enqueued");
}
}
protected bool Tranfer(byte[] dataSend)
{
DataReceive data = new DataReceive();
bool onTranfer = false;
try
{
onTranfer = Tranfer(dataSend, ref data);
}
catch
{
}
return(onTranfer);
}
protected virtual void OnDataReceive(WSReceiveArgs e)
{
try
{
DataReceive?.Invoke(this, e);
}
catch (Exception e_)
{
try
{
e.Error = new BXException($"ws client receive error {e_.Message}", e_);
DataReceive?.Invoke(this, e);
}
catch { }
}
}
public SocketServer()
{
Server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Server.Bind(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1111));
Server.Listen(10);
var task = new Task(() =>
{
try
{
while (true)
{
var client = Server.Accept();
var ip = ((IPEndPoint)client.RemoteEndPoint).ToString();
if (!DicClient.Keys.Contains(ip))
{
DicClient.Add(ip, client);
}
else
{
DicClient[ip].TryDispose();
DicClient[ip] = client;
}
var t = new Task(() =>
{
try
{
var data = new byte[65535];
var length = client.Receive(data);
data = data.Take(length).ToArray();
DataReceive?.Invoke(client, data);
}
catch (Exception ex)
{
}
});
t.Start();
}
}
catch (Exception ex)
{
}
});
task.Start();
}
public override IActivity toActivity(string pCmd, object[] pArgs)
{
string _name = ToolObjectName.getName(pCmd);
string _type = ToolObjectName.getType(pCmd);
switch (_name)
{
case "tool.data.import":
return(DataReceive.createDataReceive());
case "tool.data.export":
return(DataSend.createDataSend());
}
return(base.toActivity(pCmd, pArgs));
}
//internal System.Threading.WaitCallback startTread(ListBox ls)
internal System.Threading.ThreadStart startTread(clerk.ClerkGUI c)
{
while (true)
{
n = c;
//Requesting for Sending Data //
c.AddToTextBox("Data Send to : "+c.getIp());
DataSend ds = new DataSend(c.getIp(), "5210");
ds.sendData("Free");
//Requesting For
c.AddToTextBox("\nData Successfully Sent to : " + c.getIp());
DataReceive dr = new DataReceive("5211");
c.AddToTextBox("\nData Received"+dr.getData()+"from ip-address"+dr.ipaddress);
computeIt(dr.getData());
}
throw new NotImplementedException();
}
private void DataReceiveControl(string A_0)
{
try
{
if (this.u.InvokeRequired)
{
DataReceive method = new DataReceive(this.DataReceiveControl);
base.Invoke(method, new object[] { A_0 });
}
else
{
this.u.Text = A_0;
}
}
catch
{
}
}
public ErrorCodeCharger GetBatteryLevel(ref DataReceive data)
{
ErrorCodeCharger ret = ErrorCodeCharger.TRUE;
byte[] dataSend = new byte[6];
dataSend[0] = 0xFA;
dataSend[1] = 0x55;
dataSend[2] = (byte)CmdCtrlMcu.CMD_GET_BAT_LEVEL;
dataSend[3] = 0x04;
dataSend[4] = 0x00;
dataSend[5] = CalChecksum(dataSend, 3);
bool result = this.Tranfer(dataSend, ref data);
if (result == false)
{
ret = ErrorCodeCharger.ERROR_CONNECT;
}
return(ret);
}
void ScannerClerk()
{
while (true)
{
new SendIdleMessage(ipaddress, port);
//Console.WriteLine("IDLE");
DataReceive dr = new DataReceive("10001");
string ip = dr.getData();
string path = dr.getData();
//Console.WriteLine(ip);
//Console.WriteLine(path);
ScanThread st = new ScanThread(@"C:\Program Files\ClamWin\bin\");
string temp = path;
//Console.WriteLine("file Path" + temp);
st.Working = true;
st.SetWork(temp);
while (st.Working == true) ;
//Console.ReadLine();
}
}
private void OnReceive()
{
var error = mSslStream?.SyncDataError;
if (SSL && error != null)
{
ProcessError(error, $"sync SslStream data error {error.Message}@{error.StackTrace}");
DisConnect();
return;
}
if (Packet != null)
{
try
{
Packet.Decode(this, this.Stream);
}
catch (Exception e_)
{
ProcessError(e_, "client packet decoding error!");
}
}
else
{
try
{
mReceiveArgs.Stream = this.Stream;
if (awaitPipeStream.Pending)
{
awaitPipeStream.Success(this.Stream.ToPipeStream());
}
else
{
DataReceive?.Invoke(this, mReceiveArgs);
}
}
catch (Exception e_)
{
ProcessError(e_, "client buffer process error!");
}
}
}
private void OnReceive(IBuffer buffer)
{
mBaseNetworkStream.Import(buffer);
if (SSL && mSslStream.SyncDataError != null)
{
ProcessError(mSslStream.SyncDataError, $"sync SslStream data error {mSslStream.SyncDataError.Message}");
DisConnect();
return;
}
if (Packet != null)
{
try
{
Packet.Decode(this, this.Stream);
}
catch (Exception e_)
{
ProcessError(e_, "client packet decoding error!");
}
}
else
{
try
{
mReceiveArgs.Stream = this.Stream;
if (awaitPipeStream.Pending)
{
awaitPipeStream.Success(this.Stream.ToPipeStream());
}
else
{
DataReceive?.Invoke(this, mReceiveArgs);
}
}
catch (Exception e_)
{
ProcessError(e_, "client buffer process error!");
}
}
}
private void OnClientError(IClient c, ClientErrorArgs e)
{
if (OnWSConnected)
{
if (e.Error is BXException)
{
OnWSConnected = false;
}
try
{
WSReceiveArgs wse = new WSReceiveArgs();
wse.Client = this;
wse.Error = e.Error;
DataReceive?.Invoke(this, wse);
}
catch { }
}
else
{
OnConnectResponse(e.Error, null);
}
}
private void OnClientError(IClient c, ClientErrorArgs e)
{
if (OnWSConnected)
{
if (e.Error is BXException)
{
OnWSConnected = false;
}
lock (mLockReceive)
{
if (mReceiveCompletionSource != null)
{
var completed = mReceiveCompletionSource;
mReceiveCompletionSource = null;
Task.Run(() =>
{
completed.Error(e.Error);
});
return;
}
}
if (DataReceive != null)
{
try
{
WSReceiveArgs wse = new WSReceiveArgs();
wse.Client = this;
wse.Error = e.Error;
DataReceive?.Invoke(this, wse);
}
catch { }
}
}
else
{
OnConnectResponse(e.Error, null);
}
}
private void stringReceived(string A_0)
{
try
{
if (this.textBox1.InvokeRequired)
{
DataReceive method = new DataReceive(this.stringReceived);
base.Invoke(method, new object[] { A_0 });
}
else
{
this.textBox1.SuspendLayout();
if ((A_0.Length == 1) && (A_0[0] == '\b'))
{
if (this.textBox1.Text.Length > 0)
{
this.textBox1.SelectionStart = this.textBox1.Text.Length - 1;
this.textBox1.SelectionLength = 1;
this.textBox1.SelectedText = "";
}
}
else
{
this.textBox1.AppendText(A_0);
decimal testvalue;
/// MessageAnalysis(this.textBox1.Text,out testvalue);
//// this.textBox1.AppendText(testvalue.ToString());
}
if (this.textBox1.Text.Length > 0x186a0)
{
this.textBox1.Text = this.textBox1.Text.Substring(0xc350, this.textBox1.Text.Length - 0xc350);
}
this.textBox1.ResumeLayout(false);
}
}
catch
{
}
}
// Start is called before the first frame update
void Start()
{
//find instance of network manager
dataReceive = GameObject.Find("Manager").GetComponent <DataReceive>();
//listen for value change in the slider and record the value
fanSpeedInput.onValueChanged.AddListener(speedChange);
//on button click, send the previewed fan speed
btn.onClick.AddListener(sendSpeed);
//disable the temperature warning image
tempWarning.enabled = false;
serverTime = GameObject.Find("serverTime").GetComponent <Text>();
autoText = GameObject.Find("setAuto").GetComponentInChildren <Text>();
setAuto = GameObject.Find("setAuto").GetComponent <Button>();
setAuto.onClick.AddListener(autoPress);
#region speech
keywords.Add("full", () =>
{
//toggle preview mode
isPreview = true;
//set the fan speed to full
speed = 100;
//show the previewed speed on the slider
fanSpeedInput.value = speed;
//show previewed fan speed as a string
speedDisp_Preview.text = "Previewed speed: " + speed.ToString() + "%";
});
keywords.Add("max", () =>
{
//toggle preview mode
isPreview = true;
//set the fan speed to full
speed = 100;
//show the previewed speed on the slider
fanSpeedInput.value = speed;
//show previewed fan speed as a string
speedDisp_Preview.text = "Previewed speed: " + speed.ToString() + "%";
});
keywords.Add("confirm", () =>
{
//send the new speed
dataReceive.SendMsg("0+" + speed.ToString());
//toggle preview mode
isPreview = false;
});
keywords.Add("ok", () =>
{
//send the new speed
dataReceive.SendMsg("0+" + speed.ToString());
//toggle preview mode
isPreview = false;
});
keywords.Add("off", () =>
{
//toggle preview mode
isPreview = true;
//set the fan speed to zero
speed = 0;
//show the previewed speed on the slider
fanSpeedInput.value = speed;
//show previewed fan speed as a string
speedDisp_Preview.text = "Previewed speed: " + speed.ToString() + "%";
});
keywords.Add("disable", () =>
{
//toggle preview mode
isPreview = true;
//set the fan speed to zero
speed = 0;
//show the previewed speed on the slider
fanSpeedInput.value = speed;
//show previewed fan speed as a string
speedDisp_Preview.text = "Previewed speed: " + speed.ToString() + "%";
});
keywords.Add("mid", () =>
{
//toggle preview mode
isPreview = true;
//set the fan speed to medium
speed = 50;
//show the previewed speed on the slider
fanSpeedInput.value = speed;
//show previewed fan speed as a string
speedDisp_Preview.text = "Previewed speed: " + speed.ToString() + "%";
});
keywordRecogniser = new KeywordRecognizer(keywords.Keys.ToArray());
keywordRecogniser.OnPhraseRecognized += KeywordRecogniser_OnPhraseRecognised;
keywordRecogniser.Start();
#endregion
}
private void menuReceive_Click(object sender, EventArgs e)
{
DataReceive r = new DataReceive(environment);
r.done();
}
private void Start()
{
//find instance of network manager
dataReceive = GameObject.Find("Manager").GetComponent <DataReceive>();
}
protected bool Tranfer(byte[] dataSend, ref DataReceive dataRec)
{
bool flagGetRespone = true;
bool result = false;
//this.StartClient(); // open socket
numResent = 0;
//Console.WriteLine("len send {0}", dataSend.Length);
while (true == flagGetRespone)
{
numResent++;
if (numResent >= 100)
{
return(false);
}
if (this.rb != null)
{
if (numResent > 1)
{
this.rb.ShowText("try sent socket : " + numResent);
}
}
Console.WriteLine("try sent socket ------------------ {0} ----------------", numResent);
this.Close();
if (this.StartClient())// open socket
{
if (false == SendCMD(dataSend))
{
this.Close();
Thread.Sleep(50);
continue;
}
}
else
{
Thread.Sleep(50);
continue;
}
if (this.WaitForReadyRead(TIME_OUT_WAIT_RESPONSE))
{
try
{
//Console.WriteLine("have data receive");
DataReceive dataRx = GetDataRec();
byte[] data = new byte[dataRx.length];
Buffer.BlockCopy(dataRx.data, 0, data, 0, dataRx.length);
ResPacket resPaket = new ResPacket();
resPaket.header = (UInt16)((data[1] << 8) | data[0]);
resPaket.command = data[2];
resPaket.length = (UInt16)((data[4] << 8) | data[3]);
resPaket.ack = data[5];
UInt16 len = (UInt16)(resPaket.length - 4);
resPaket.data = new byte[len];
Buffer.BlockCopy(data, 6, resPaket.data, 0, len);
if (resPaket.header == 0x55FA)
{
//Console.WriteLine("check header ok");
if (resPaket.data[len - 1] == CalChecksum(data, (UInt32)(data.Length - 3)))
{
//Console.WriteLine("calChecksum ok");
if (resPaket.ack == ACK)
{
if (resPaket.command == (byte)(dataSend[2] + 1))
{
if (len > 1)
{
dataRec.length = len - 1;
dataRec.data = new byte[dataRec.length];
Buffer.BlockCopy(resPaket.data, 0, dataRec.data, 0, len - 1);
}
result = true;
flagGetRespone = false;
// Console.WriteLine(DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss tt")+"Send data success");
numResent = 0;
this.Close();
return(true);
}
}
}
}
}
catch (System.Exception e)
{
Console.WriteLine(e.ToString());
this.Close();
result = false;
flagGetRespone = false;
}
}
else
{
this.Close();
result = false;
flagGetRespone = false;
}
}
this.Close();
return(result);
}
protected virtual void OnDataReceive(UdpDataReceiveEventArgs e)
{
DataReceive?.Invoke(this, e);
}
