public async void SendSensorMessagesToPC(string message, string pcsIPAddress) //send the light sensor's data to PC
{
if (IoTBrightnessSender == null || pcsIPAddress != pcsOriginalIPAddress)
{
pcsOriginalIPAddress = pcsIPAddress;
try
{
HostName hostname = new HostName(pcsOriginalIPAddress);
IoTBrightnessSender = new DatagramSocket();
await IoTBrightnessSender.ConnectAsync(hostname, "2214");
IoTBrightnessDataWriter = new DataWriter(IoTBrightnessSender.OutputStream);
}
catch (Exception)
{
return;
}
}
try
{
IoTBrightnessDataWriter.WriteString(message);
await IoTBrightnessDataWriter.StoreAsync();
}
catch (Exception)
{
return;
}
}
public static async Task Init()
{
ClearPrevious();
try
{
if (App.isRPi)
{
await InitCamera(1, IMAGE_QUALITY_PERCENT, VIDEO_SUBTYP, VIDEO_RES);
socket = new DatagramSocket();
socket.MessageReceived += MessageReceived;
HostName hn = new HostName(hostName);
await socket.ConnectAsync(hn, hostPort).AsTask();
Debug.WriteLine("Connected to remote camera " + hn + ":" + hostPort);
socketIsConnected = true;
}
else
{
listener = new DatagramSocket();
listener.MessageReceived += MessageReceived;
await listener.BindServiceNameAsync(hostPort).AsTask();
Debug.WriteLine("Remote camera listening on port " + hostPort);
listenerHasStarted = true;
}
}
catch (Exception ex)
{
Debug.WriteLine("Error initializing camera: " + ex.Message);
}
}
async void RunPollerTask()
{
var pollPacket = Packet.PacketBuilder.GetPollPacket();
using (var udpSocket = new DatagramSocket())
{
udpSocket.Control.QualityOfService = SocketQualityOfService.LowLatency;
await udpSocket.ConnectAsync(new HostName("255.255.255.255"), $"{SimpleArtNetEngine.ArtNetUDPPort}");
using (var writer = new DataWriter(udpSocket.OutputStream))
{
try
{
while (true)
{
cancelTokenSource.Token.ThrowIfCancellationRequested();
if (!_pause)
{
writer.WriteBytes(pollPacket);
await writer.StoreAsync();
}
await Task.Delay(DelayBetweenPoll);
}
}
catch (Exception ex)
{
Debug.WriteLine($"EXCEPTION : ArtNetPoller.RunPollerTask() : {ex.ToString()}");
}
}
}
}
public static async Task WakeAsync(HostName endPoint, int port, byte[] macAddress)
{
var packet = new List <byte>();
for (var i = 0; i < 6; i++) // Trailer of 6 FF packets
{
packet.Add(0xFF);
}
for (var i = 0; i < 16; i++) // Repeat 16 times the MAC address
{
packet.AddRange(macAddress);
}
using (var socket = new DatagramSocket())
{
await socket.ConnectAsync(endPoint, port.ToString());
var stream = socket.OutputStream;
using (var writer = new DataWriter(stream))
{
writer.WriteBytes(packet.ToArray());
await writer.StoreAsync();
}
}
}
public async void SendMessagesToRasp(string message, string ipAddress) //send command from PC or phone to RasPi
{
if (sender == null || ipAddress != raspberrysOriginalIPAddress)
{
raspberrysOriginalIPAddress = ipAddress;
try
{
HostName hostname = new HostName(ipAddress);
sender = new DatagramSocket();
await sender.ConnectAsync(hostname, "2000");
dataWriter = new DataWriter(sender.OutputStream);
}
catch (Exception)
{
return;
}
}
try
{
dataWriter.WriteString(message);
await dataWriter.StoreAsync();
}
catch (Exception)
{
return;
}
}
async void Start()
{
#if !UNITY_EDITOR
m_sStatus = "Waiting for a connection...";
socket = new DatagramSocket();
socket.MessageReceived += Socket_MessageReceived;
try
{
await socket.ConnectAsync(new EndpointPair(new HostName(m_sIPLocal), m_sPortLocal, new HostName(m_sIPRemote), m_sPortRemote));
m_output = new DataWriter(socket.OutputStream);
Debug.Log("exit start");
m_sStatus = "UDP connection initialization ok";
}
catch (Exception e)
{
Debug.Log(e.ToString());
Debug.Log(SocketError.GetStatus(e.HResult).ToString());
m_sStatus = "Error - UDP connection initialization ";
return;
}
#endif
m_vExecuteRotation.x = 0;
m_vExecuteRotation.y = 0;
m_vExecuteRotation.z = 0;
m_vCylinderOriginalPosition = m_directionalObject.transform.position;
m_idebugStatus = 0;
}
public override async void Start()
{
if (_Started)
{
return;
}
_SequenceNumber = 1;
// Connect To Drone
udpClient = new DatagramSocket();
await udpClient.BindServiceNameAsync(_ServiceName);
await udpClient.ConnectAsync(new HostName(DroneClient.Host), _ServiceName);
udpWriter = new DataWriter(udpClient.OutputStream);
//string path = string.Format("AR.Drone-CommandHistory_{0:yyyy-MM-dd-HH-mm}.txt", DateTime.Now);
//commandHistoryFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(path, CreationCollisionOption.ReplaceExisting);
// Write first message
//byte[] firstMessage = BitConverter.GetBytes(1);
//WriteString(firstMessage.ToString());
udpWriter.WriteByte(1);
await udpWriter.StoreAsync();
_Timer = ThreadPoolTimer.CreatePeriodicTimer(new TimerElapsedHandler(timerElapsedHandler), TimeSpan.FromMilliseconds(25));
_Started = true;
}
private async void sendUdpMessage(string message)
{
Debug.WriteLine("[Playback::sendUdpMessage] Try to send message: " + message);
try
{
m_output.WriteString(message);
await m_output.StoreAsync();
await Task.Run(() =>
{
Task.Yield();
Logger.m_logger.addLog("Message sent - " + message);
});
}
catch (Exception exception)
{
Debug.WriteLine("[Playback::sendUdpMessage] Send failed with error: " + exception.Message);
Debug.WriteLine("[Playback::sendUdpMessage] Trying to reconnect");
try
{
await m_dsUdpSocket.ConnectAsync(new EndpointPair(new HostName(Settings.m_sIPLocalUDP), Settings.m_sPortLocalUDP, new HostName(Settings.m_sIPRemoteUDP), Settings.m_sPortRemoteUDP));
m_output = new DataWriter(m_dsUdpSocket.OutputStream);
Debug.WriteLine("[Playback::start] UDP connection initialization ok");
}
catch (Exception e)
{
Debug.WriteLine("[Playback::start] Error - UDP connection initialization ");
return;
}
}
}
public async Task SendDataAsync(byte[] data)
{
if (socket == null)
{
lock (commandLock)
{
if (socket == null)
{
socket = new DatagramSocket();
}
}
await socket.ConnectAsync(new HostName(outHost), outPort);
if (isAdmin)
{
socket.MessageReceived += socket_MessageReceived;
}
dataWriter = new DataWriter(socket.OutputStream);
}
dataWriter.WriteBytes(data);
await dataWriter.StoreAsync();
await DelayAsync();
}
private async Task ConnectAsync()
{
var connectMessage = new ConnectMessage();
var port = Uri.IsDefaultPort ? 80 : Uri.Port;
await _tracker.ConnectAsync(new HostName(Uri.Host), port.ToString());
var responseBytes = await SendAndReceiveAsync(connectMessage);
var msg = Receive(connectMessage, responseBytes);
if (msg == null)
{
throw new Exception(FailureMessage);
}
var rsp = msg as ConnectResponseMessage;
if (rsp == null)
{
FailureMessage = ((ErrorMessage)msg).Error;
throw new Exception(FailureMessage);
}
_connectionId = rsp.ConnectionId;
_hasConnected = true;
}
public async void ConnectUDP(NetworkConnectionEndpoint remoteNetworkConnectionEndpoint)
{
if (!IsUDPSetup)
{
InitUDP();
}
if (IsUDPConnected)
{
ResetUDP(); InitUDP();
}
try
{
Debug.WriteLine("Binding UDPPort");
await m_datagramSocket.BindServiceNameAsync(remoteNetworkConnectionEndpoint.Port);
Debug.WriteLine("Connecting UDPSocket");
await m_datagramSocket.ConnectAsync(remoteNetworkConnectionEndpoint.HostName, remoteNetworkConnectionEndpoint.Port);
Debug.WriteLine("Creating UDPDataWriter");
m_udpDataWriter = new DataWriter(m_datagramSocket.OutputStream);
Debug.WriteLine("Completed UDP");
UDPNetworkConnectionEndpoint = remoteNetworkConnectionEndpoint;
IsUDPConnected = true;
Debug.WriteLine("UDP Connected: " + UDPNetworkConnectionEndpoint.ToString());
}
catch (Exception ex) { Debug.WriteLine(DebugTools.PrintOutException("ConnectUDP", ex)); }
}
public async void SendLampBrightnessToPC(string message, string pcsIPAddress)//Send lamp's brightness info to pc
{
if (IoTSender == null || pcsIPAddress != pcsOriginalIPAddress)
{
pcsOriginalIPAddress = pcsIPAddress;
try
{
HostName hostname = new HostName(pcsOriginalIPAddress);
IoTSender = new DatagramSocket();
await IoTSender.ConnectAsync(hostname, "2213");
IoTDataWriter = new DataWriter(IoTSender.OutputStream);
}
catch (Exception)
{
throw;
}
}
try
{
IoTDataWriter.WriteString(message);
await IoTDataWriter.StoreAsync();
}
catch (Exception)
{
return;
}
}
private async Task ScanTask(string ip, string port)
{
scanNow++;
try
{
using (DatagramSocket socket = new DatagramSocket())
{
socket.MessageReceived += client_MessageReceived;
await socket.ConnectAsync(new HostName(ip), port);
Stream stream = socket.OutputStream.AsStreamForWrite();
stream.Write(clientPINGPacket, 0, clientPINGPacket.Length);
stream.Flush();
await Task.Delay(50);
scanned++;
if (ScanProgressUpdated != null)
{
ScanProgressUpdated(this, new ScanProgressEventArgs()
{
Scanned = scanned, LastIP = ip
});
}
Logger.Write("Pinged to " + ip);
}
}
catch (Exception) { }
scanNow--;
}
/// <summary>
/// Gets accurate time using the NTP protocol with default timeout of 45 seconds.
/// </summary>
/// <param name="timeout">Operation timeout.</param>
/// <returns>Network accurate <see cref="DateTime"/> value.</returns>
public async Task <DateTime> GetNetworkTimeAsync(TimeSpan timeout)
{
using (var socket = new DatagramSocket())
using (var ct = new CancellationTokenSource(timeout))
{
ct.Token.Register(() => _resultCompletionSource.TrySetCanceled());
socket.MessageReceived += OnSocketMessageReceived;
//The UDP port number assigned to NTP is 123
await socket.ConnectAsync(new HostName("pool.ntp.org"), "123");
using (var writer = new DataWriter(socket.OutputStream))
{
// NTP message size is 16 bytes of the digest (RFC 2030)
var ntpBuffer = new byte[48];
// Setting the Leap Indicator,
// Version Number and Mode values
// LI = 0 (no warning)
// VN = 3 (IPv4 only)
// Mode = 3 (Client Mode)
ntpBuffer[0] = 0x1B;
writer.WriteBytes(ntpBuffer);
await writer.StoreAsync();
var result = await _resultCompletionSource.Task;
return(result);
}
}
}
async void start()
{
Debug.WriteLine("[Playback::start] Waiting for a connection...");
m_dsUdpSocket = new DatagramSocket();
m_dsUdpSocket.MessageReceived += Socket_MessageReceived;
// Initialization UDP communication
try
{
m_sIPLocalUDP = "192.168.137.1";
m_sPortLocalUDP = "62503";
m_sIPRemoteUDP = "192.168.137.161";
m_sPortRemoteUDP = "63777";
await m_dsUdpSocket.ConnectAsync(new EndpointPair(new HostName(m_sIPLocalUDP), m_sPortLocalUDP, new HostName(m_sIPRemoteUDP), m_sPortRemoteUDP));
m_output = new DataWriter(m_dsUdpSocket.OutputStream);
Debug.WriteLine("[Playback::start] UDP connection initialization ok");
}
catch (Exception e)
{
Debug.WriteLine("[Playback::start] Error - UDP connection initialization ");
return;
}
// Initialization video communication
m_sIPRemoteVideo = m_sIPRemoteUDP;
m_sPortRemoteVideo = "27772";
videoPlayer.Visibility = Visibility.Collapsed;
}
public override async void Start()
{
if (_Started)
{
return;
}
_SequenceNumber = 1;
try
{
// Connect to the Drone
udpClient = new DatagramSocket();
await udpClient.BindServiceNameAsync(_ServiceName);
await udpClient.ConnectAsync(new HostName(DroneClient.Host), _ServiceName);
udpWriter = new DataWriter(udpClient.OutputStream);
udpWriter.WriteByte(1);
await udpWriter.StoreAsync();
_Timer = ThreadPoolTimer.CreatePeriodicTimer(new TimerElapsedHandler(timerElapsedHandler), TimeSpan.FromMilliseconds(25));
_Started = true;
}
catch (Exception)
{
Stop();
}
}
private async void sendUdpMessage(string message)
{
Debug.WriteLine("[Playback::sendUdpMessage] Try to send message: " + message);
m_output.WriteString(message);
try
{
await m_output.StoreAsync();
}
catch (Exception exception)
{
Debug.WriteLine("[Playback::sendUdpMessage] Send failed with error: " + exception.Message);
Debug.WriteLine("[Playback::sendUdpMessage] Trying to reconnect");
try
{
m_sIPLocalUDP = "192.168.137.1";
m_sPortLocalUDP = "62503";
m_sIPRemoteUDP = "192.168.137.161";
m_sPortRemoteUDP = "63777";
await m_dsUdpSocket.ConnectAsync(new EndpointPair(new HostName(m_sIPLocalUDP), m_sPortLocalUDP, new HostName(m_sIPRemoteUDP), m_sPortRemoteUDP));
m_output = new DataWriter(m_dsUdpSocket.OutputStream);
Debug.WriteLine("[Playback::start] UDP connection initialization ok");
}
catch (Exception e)
{
Debug.WriteLine("[Playback::start] Error - UDP connection initialization ");
return;
}
}
}
public async Task SendStringData(HostName hostName, string port, string data)
{
try
{
using (var datagramSocket = new DatagramSocket())
{
await datagramSocket.ConnectAsync(hostName, port);
using (Stream outputStream = datagramSocket.OutputStream.AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(data);
await streamWriter.FlushAsync();
}
}
datagramSocket.Dispose();
}
}
catch (Exception ex)
{
SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult);
}
}
public static async Task ConnectAsync(string hostName = HOST_NAME, string port = REMOTE_PORT)
{
if (!StubMode)
{
#if WINDOWS_APP || WINDOWS_PHONE_APP
// Set up the UDP connection.
var droneIP = new HostName(hostName);
udpSocket = new DatagramSocket();
await udpSocket.BindServiceNameAsync(port);
await udpSocket.ConnectAsync(droneIP, port);
udpWriter = new DataWriter(udpSocket.OutputStream);
udpWriter.WriteByte(1);
await udpWriter.StoreAsync();
#else
udpSocket = new UdpClient();
udpSocket.Connect(hostName, int.Parse(port));
byte[] datagram = new byte[1] {
1
};
await udpSocket.SendAsync(datagram, datagram.Length);
#endif
}
var loop = Task.Run(() => DroneLoop());
}
// Connect
public async void Connect(HostName remoteHostName, string remoteServiceNameOrPort)
{
await _socket.ConnectAsync(remoteHostName, remoteServiceNameOrPort).AsTask().ContinueWith(task =>
{
IsConnected = true;
});
}
private async Task DataSender()
{
try {
DatagramSocket udpSocket = new DatagramSocket();
await udpSocket.ConnectAsync(new HostName(_asapIP), _sendPort.ToString());
DataWriter udpWriter = new DataWriter(udpSocket.OutputStream);
while (!_listening)
{
await Task.Delay(100);
}
while (_running)
{
string nextPacket = "";
lock (_sendQueueLock) {
if (_sendQueue.Count > 0)
{
nextPacket = _sendQueue.Dequeue();
}
}
if (nextPacket.Length != 0)
{
udpWriter.WriteString(nextPacket);
await udpWriter.StoreAsync();
}
await Task.Delay(1);
}
} catch (Exception e) {
Debug.Log("DATA SENDER EXCEPTION: " + e.ToString());
Debug.Log(SocketError.GetStatus(e.HResult).ToString());
return;
}
}
//-------------------------------------------------------------------------------------------------
//--- Get the UTC time from a public NTP server
//-------------------------------------------------------------------------------------------------
public DateTime GetNTPTime()
{
const string myNTPServer = "pool.ntp.org";
DateTime TheNetworkTime;
// NTP message size - 16 bytes of the digest (RFC 2030)
var myNTPDataArray = new byte[48];
//Setting the Leap Indicator, Version Number and Mode values
myNTPDataArray[0] = 0x1B; //LI = 0 (no warning), VN = 3 (IPv4 only), Mode = 3 (Client Mode)
try
{
#if WINDOWS_UWP
using (var mySocket = new DatagramSocket())
using (var ct = new CancellationTokenSource(3000))
{
ct.Token.Register(() => myResultCompletionSource.TrySetCanceled());
mySocket.MessageReceived += OnSocketMessageReceived;
//The UDP port number assigned to NTP is 123
await mySocket.ConnectAsync(new HostName(myNTPServer), "123");
using (var writer = new DataWriter(mySocket.OutputStream))
{
writer.WriteBytes(myNTPDataArray);
await writer.StoreAsync();
TheNetworkTime = await myResultCompletionSource.Task;
}
}
#else
var myAddresses = Dns.GetHostEntry(myNTPServer).AddressList;
//The UDP port number assigned to NTP is 123
var myIPEndPoint = new IPEndPoint(myAddresses[0], 123);
//NTP uses UDP
using (var mySocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
{
mySocket.Connect(myIPEndPoint);
//Stops code hang if NTP is blocked
mySocket.ReceiveTimeout = 3000;
mySocket.Send(myNTPDataArray);
mySocket.Receive(myNTPDataArray);
mySocket.Close();
}
#endif
TheNetworkTime = ParseNetworkTime(myNTPDataArray);
}
catch
{
TheNetworkTime = DateTime.UtcNow;
}
return(TheNetworkTime);
}
public void Init()
{
s = new DatagramSocket();
s.MessageReceived += S_MessageReceived;
s.BindEndpointAsync(new HostName("127.0.0.1"), port).AsTask().Wait();
s.ConnectAsync(new HostName("127.0.0.1"), "9007").AsTask().Wait();
tun?.Init();
}
private async Task ConnectAsync()
{
try {
await client.ConnectAsync(endPoint);
} catch (Exception e) {
System.Diagnostics.Debug.WriteLine(e);
}
}
public async Task <Guid> ConnectAsync(HostName hostName, string port)
{
if (nameResponse != null)
{
throw new InvalidOperationException("The client is connecting to another server");
}
nameResponse = new TaskCompletionSource <HClientResponseWithNameAndIP>();
// Connect to the server
DatagramSocket socket = new DatagramSocket();
socket.Control.QualityOfService = SocketQualityOfService.LowLatency;
socket.MessageReceived += client_MessageReceived;
await socket.ConnectAsync(hostName, port);
// Create new information
HServerInformation serverInf = new HServerInformation();
serverInf.Socket = socket;
serverInf.Converter = new ShortStreamConverter(socket.OutputStream.AsStreamForWrite());
// Ping the server
serverInf.Converter.Write(clientCONNHeader);
serverInf.Converter.Write(Encoding.UTF8.GetBytes(clientName));
serverInf.Converter.Flush();
// Wait for ping (or timeout)
Task.WhenAny(nameResponse.Task, Task.Delay(CONNECT_TIMEOUT)).Wait();
if (!nameResponse.Task.IsCompleted)
{
nameResponse.TrySetCanceled();
socket.Dispose();
Log(serverInf.Guid, "Connection timeout");
nameResponse = null;
return(default(Guid));
}
// Add new entry
serverInf.Guid = nameResponse.Task.Result.GUID;
serverInf.Name = nameResponse.Task.Result.Name;
serverInf.IP = nameResponse.Task.Result.IP;
Log(serverInf.Guid, "Profile added");
serverList.Add(serverInf);
nameResponse = null;
// Fire event
if (Connected != null)
{
Connected(this, serverInf.Guid);
}
return(serverInf.Guid);
}
public void Init(string port)
{
s = new DatagramSocket();
s.MessageReceived += S_MessageReceived;
s.BindEndpointAsync(new HostName("127.0.0.1"), "9008").AsTask().Wait();
s.ConnectAsync(new HostName("127.0.0.1"), "9007").AsTask().Wait();
tun.Init();
tun.PacketPoped += Tun_PacketPoped;
}
private static async void CheckSocketConnectAsync()
{
try
{
DatagramSocket socket = new DatagramSocket();
await socket.ConnectAsync(new HostName("pubsub.pubnub.com"), "80");
}
catch { }
}
private static async void CheckSocketConnectAsync()
{
try
{
DatagramSocket socket = new DatagramSocket();
await socket.ConnectAsync(new HostName(Origin), "80");
}
catch { }
}
public void Connect(VpnChannel channel)
{
State = VpnPluginState.Connecting;
LogLine("Connecting", channel);
try
{
DatagramSocket transport = new DatagramSocket();
channel.AssociateTransport(transport, null);
VpnContext context = null;
if (channel.PlugInContext == null)
{
// create and Initialize context
LogLine("Initializing new context", channel);
channel.PlugInContext = context = new VpnContext();
context.InitTun2Socks(TUN_SERVICE_NAME, VPN_ADDR, VPN_NETMASK, (int)VPN_MTU, "192.168.1.107:60000", "aes-256-cfb", "SSTest");
context.Init();
}
else
{
LogLine("Context exists", channel);
context = (VpnContext)channel.PlugInContext;
}
transport.ConnectAsync(new HostName("127.0.0.1"), TUN_SERVICE_NAME).AsTask().ContinueWith(t =>
{
LogLine("r Connected", channel);
}).Wait();
var now = DateTime.Now;
LogLine("Starting transport", channel);
channel.StartWithMainTransport(
new[] { VPN_HOST },
null,
null,
context.routeScope,
null,
VPN_MTU,
VPN_MAX_FRAME,
false,
transport
);
var delta = DateTime.Now - now;
LogLine($"Finished starting transport in {delta.TotalMilliseconds} ms.", channel);
LogLine("Connected", channel);
State = VpnPluginState.Connected;
}
catch (Exception ex)
{
LogLine("Error connecting", channel);
LogLine(ex.Message, channel);
LogLine(ex.StackTrace, channel);
State = VpnPluginState.Disconnected;
}
}
public void Start()
{
_socket = new DatagramSocket();
_socket.Control.DontFragment = true;
_socket.ConnectAsync(new HostName("255.255.255.255"), "19227").AsTask().Wait();
_outputStream = _socket.OutputStream.AsStreamForWrite();
_timer.Change(0, Timeout.Infinite);
}
