sem/Proftaak-RH-B4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'develop' into dokter

Browse Source
This commit is contained in:
fabjuuuh
2020-10-09 10:56:48 +02:00
parent fc0e70403f 143f7e4d88
commit a043cdc723
33 changed files with 1732 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
Client/Client.cs
View File

@@ -31,22 +31,46 @@ namespace Client
client.BeginConnect(adress, port, new AsyncCallback(OnConnect), null);
}
/// <summary>
/// initializes the VR engine and sets the callbacks
/// </summary>
private void initEngine()
{
engineConnection = EngineConnection.INSTANCE;
engineConnection.OnNoTunnelId = retryEngineConnection;
engineConnection.OnSuccessFullConnection = engineConnected;
if (!engineConnection.Connected) engineConnection.Connect();
}
/// <summary>
/// retries to connect to the VR engine if no tunnel id was found
/// </summary>
private void retryEngineConnection()
{
Console.WriteLine("-- Could not connect to the VR engine. Please make sure you are running the simulation!");
Console.WriteLine("-- Press any key to retry connecting to the VR engine.");
Console.ReadKey();
engineConnection.CreateConnection();
Console.WriteLine("-- Press ENTER to retry connecting to the VR engine.");
Console.WriteLine("-- Press 'q' and then ENTER to not connect to the VR engine");
string input = Console.ReadLine();
if (input == string.Empty) engineConnection.CreateConnection();
else
{
Console.WriteLine("Skipping connecting to VR engine...");
engineConnection.Stop();
}
}
private void engineConnected()
{
Console.WriteLine("successfully connected to VR engine");
engineConnection.initScene();
if (engineConnection.Connected && sessionRunning && !engineConnection.FollowingRoute) engineConnection.StartRouteFollow();
}
/// <summary>
/// callback method for when the TCP client is connected
/// </summary>
/// <param name="ar">the result of the async read</param>
private void OnConnect(IAsyncResult ar)
{
this.client.EndConnect(ar);
@@ -60,6 +84,10 @@ namespace Client
this.stream.BeginRead(this.buffer, 0, this.buffer.Length, new AsyncCallback(OnRead), null);
}
/// <summary>
/// callback method for when there is a message read
/// </summary>
/// <param name="ar">the result of the async read</param>
private void OnRead(IAsyncResult ar)
{
int receivedBytes = this.stream.EndRead(ar);
@@ -93,6 +121,7 @@ namespace Client
string responseStatus = DataParser.getResponseStatus(payloadbytes);
if (responseStatus == "OK")
{
Console.WriteLine("Username and password correct!");
this.connected = true;
//initEngine();
}
@@ -103,14 +132,18 @@ namespace Client
}
break;
case DataParser.START_SESSION:
Console.WriteLine("Session started!");
this.sessionRunning = true;
if (engineConnection.Connected && !engineConnection.FollowingRoute) engineConnection.StartRouteFollow();
sendMessage(DataParser.getStartSessionJson());
break;
case DataParser.STOP_SESSION:
Console.WriteLine("Stop session identifier");
this.sessionRunning = false;
sendMessage(DataParser.getStopSessionJson());
break;
case DataParser.SET_RESISTANCE:
Console.WriteLine("Set resistance identifier");
if (this.handler == null)
{
Console.WriteLine("handler is null");
@@ -140,11 +173,19 @@ namespace Client
}
/// <summary>
/// starts sending a message to the server
/// </summary>
/// <param name="message">the message to send</param>
private void sendMessage(byte[] message)
{
stream.BeginWrite(message, 0, message.Length, new AsyncCallback(OnWrite), null);
}
/// <summary>
/// callback method for when a message is fully written to the server
/// </summary>
/// <param name="ar">the async result representing the asynchronous call</param>
private void OnWrite(IAsyncResult ar)
{
this.stream.EndWrite(ar);
@@ -152,6 +193,10 @@ namespace Client
#region interface
//maybe move this to other place
/// <summary>
/// bpm method for receiving the BPM value from the bluetooth bike or the simulation
/// </summary>
/// <param name="bytes">the message</param>
public void BPM(byte[] bytes)
{
if (!sessionRunning)
@@ -163,9 +208,21 @@ namespace Client
throw new ArgumentNullException("no bytes");
}
byte[] message = DataParser.GetRawDataMessage(bytes);
if (engineConnection.Connected && engineConnection.FollowingRoute)
{
engineConnection.BikeBPM = bytes[1];
engineConnection.UpdateInfoPanel();
}
this.stream.BeginWrite(message, 0, message.Length, new AsyncCallback(OnWrite), null);
}
/// <summary>
/// method for receiving the bike message from the bluetooth bike or the simulation
/// </summary>
/// <param name="bytes">the message</param>
public void Bike(byte[] bytes)
{
if (!sessionRunning)
@@ -177,15 +234,35 @@ namespace Client
throw new ArgumentNullException("no bytes");
}
byte[] message = DataParser.GetRawDataMessage(bytes);
switch (bytes[0])
{
case 0x10:
engineConnection.BikeSpeed = (bytes[4] | (bytes[5] << 8)) * 0.01f;
break;
case 0x19:
engineConnection.BikePower = (bytes[5]) | (bytes[6] & 0b00001111) << 8;
break;
}
if (engineConnection.Connected && engineConnection.FollowingRoute)
engineConnection.UpdateInfoPanel();
this.stream.BeginWrite(message, 0, message.Length, new AsyncCallback(OnWrite), null);
}
#endregion
/// <summary>
/// wether or not the client stream is connected
/// </summary>
/// <returns>true if it's connected, false if not</returns>
public bool IsConnected()
{
return this.connected;
}
/// <summary>
/// tries to log in to the server by asking for a username and password
/// </summary>
private void tryLogin()
{
//TODO File in lezen
@@ -203,17 +280,10 @@ namespace Client
this.stream.BeginWrite(message, 0, message.Length, new AsyncCallback(OnWrite), null);
}
public void tryLoginDoctor(string username, string password)
{
string hashUser = Hashing.Hasher.HashString(username);
string hashPassword = Hashing.Hasher.HashString(password);
byte[] message = DataParser.getJsonMessage(DataParser.GetLoginJson(hashUser, hashPassword));
stream.BeginWrite(message, 0, message.Length, new AsyncCallback(OnWrite), null);
}
/// <summary>
/// sets the handler for the client, so either the bike simulator or the bluetooth bike handler
/// </summary>
/// <param name="handler"></param>
public void setHandler(IHandler handler)
{
this.handler = handler;

173
Client/EngineConnection.cs
View File

@@ -8,12 +8,14 @@ namespace Client
{
public delegate void HandleSerial(string message);
public delegate void HandleNoTunnelId();
public delegate void OnSuccessfullConnection();
public sealed class EngineConnection
{
private static EngineConnection instance = null;
private static readonly object padlock = new object();
public HandleNoTunnelId OnNoTunnelId;
public OnSuccessfullConnection OnSuccessFullConnection;
private static PC[] PCs = {
@@ -29,9 +31,18 @@ namespace Client
private static ServerResponseReader serverResponseReader;
private static string sessionId = string.Empty;
private static string tunnelId = string.Empty;
private static string cameraId = string.Empty;
private static string routeId = string.Empty;
private static string panelId = string.Empty;
private static string bikeId = string.Empty;
private static string headId = string.Empty;
public float BikeSpeed { get; set; }
public float BikePower { get; set; }
public float BikeBPM { get; set; }
public float BikeResistance { get; set; }
public bool FollowingRoute = false;
private static NetworkStream stream;
@@ -42,9 +53,15 @@ namespace Client
EngineConnection()
{
BikeSpeed = 0;
BikePower = 0;
BikeBPM = 0;
BikeResistance = 50;
}
/// <summary>
/// Singleton constructor
/// </summary>
public static EngineConnection INSTANCE
{
get
@@ -60,6 +77,11 @@ namespace Client
}
}
/// <summary>
/// connects to the vr engine and initalizes the serverResponseReader
/// </summary>
public void Connect()
{
TcpClient client = new TcpClient("145.48.6.10", 6666);
@@ -68,6 +90,18 @@ namespace Client
CreateConnection();
}
/// <summary>
/// initializes and starts the reading of the responses from the vr server
/// </summary>
/// <param name="stream">the networkstream</param>
private void initReader()
{
serverResponseReader = new ServerResponseReader(stream);
serverResponseReader.callback = HandleResponse;
serverResponseReader.StartRead();
}
#region VR Message traffic
/// <summary>
/// connects to the server and creates the tunnel
/// </summary>
@@ -84,26 +118,8 @@ namespace Client
WriteTextMessage(tunnelCreate);
// wait until we have a tunnel id
while (tunnelId == string.Empty) { }
if (tunnelId != null)
{
Write("got tunnel id! " + tunnelId);
}
mainCommand = new Command(tunnelId);
}
/// <summary>
/// initializes and starts the reading of the responses from the vr server
/// </summary>
/// <param name="stream">the networkstream</param>
private void initReader()
{
serverResponseReader = new ServerResponseReader(stream);
serverResponseReader.callback = HandleResponse;
serverResponseReader.StartRead();
Connected = true;
}
/// <summary>
/// callback method that handles responses from the server
@@ -121,12 +137,19 @@ namespace Client
else if (id == "tunnel/create")
{
tunnelId = JSONParser.GetTunnelID(message);
Console.WriteLine("set tunnel id to " + tunnelId);
if (tunnelId == null)
{
Write("could not find a valid tunnel id!");
OnNoTunnelId?.Invoke();
Connected = false;
FollowingRoute = false;
return;
} else
{
Write("got tunnel id! " + tunnelId);
Connected = true;
OnSuccessFullConnection?.Invoke();
}
}
@@ -139,6 +162,102 @@ namespace Client
}
}
public void initScene()
{
Write("initializing scene...");
mainCommand = new Command(tunnelId);
// reset the scene
WriteTextMessage(mainCommand.ResetScene());
//Get sceneinfo and set the id's
SendMessageAndOnResponse(mainCommand.GetSceneInfoCommand("sceneinfo"), "sceneinfo",
(message) =>
{
//Console.WriteLine("\r\n\r\n\r\nscene info" + message);
cameraId = JSONParser.GetIdSceneInfoChild(message, "Camera");
string headId = JSONParser.GetIdSceneInfoChild(message, "Head");
string handLeftId = JSONParser.GetIdSceneInfoChild(message, "LeftHand");
string handRightId = JSONParser.GetIdSceneInfoChild(message, "RightHand");
//Force(stream, mainCommand.DeleteNode(handLeftId, "deleteHandL"), "deleteHandL", (message) => Console.WriteLine("Left hand deleted"));
//Force(stream, mainCommand.DeleteNode(handRightId, "deleteHandR"), "deleteHandR", (message) => Console.WriteLine("Right hand deleted"));
});
// add the route and set the route id
SendMessageAndOnResponse(mainCommand.RouteCommand("routeID"), "routeID", (message) => routeId = JSONParser.GetResponseUuid(message));
}
internal void StartRouteFollow()
{
Write("Starting route follow...");
FollowingRoute = true;
SendMessageAndOnResponse(mainCommand.AddBikeModel("bikeID"), "bikeID",
(message) =>
{
bikeId = JSONParser.GetResponseUuid(message);
SendMessageAndOnResponse(mainCommand.addPanel("panelAdd", bikeId), "panelAdd",
(message) =>
{
panelId = JSONParser.getPanelID(message);
WriteTextMessage(mainCommand.ColorPanel(panelId));
UpdateInfoPanel();
while (cameraId == string.Empty) { }
SetFollowSpeed(5.0f);
});
});
}
public void UpdateInfoPanel()
{
ShowPanel(BikeSpeed, (int)BikeBPM, (int)BikePower, (int)BikeResistance);
WriteTextMessage(mainCommand.RouteSpeed(BikeSpeed, bikeId));
WriteTextMessage(mainCommand.RouteSpeed(BikeSpeed, cameraId));
}
public void ShowPanel(double bikeSpeed, int bpm, int power, int resistance)
{
WriteTextMessage(mainCommand.ClearPanel(panelId));
SendMessageAndOnResponse(mainCommand.showBikespeed(panelId, "bikeSpeed", bikeSpeed), "bikeSpeed",
(message) =>
{
// TODO check if is drawn
});
SendMessageAndOnResponse(mainCommand.showHeartrate(panelId, "bpm", bpm), "bpm",
(message) =>
{
// TODO check if is drawn
});
SendMessageAndOnResponse(mainCommand.showPower(panelId, "power", power), "power",
(message) =>
{
// TODO check if is drawn
});
SendMessageAndOnResponse(mainCommand.showResistance(panelId, "resistance", resistance), "resistance",
(message) =>
{
// TODO check if is drawn
});
// Check if every text is drawn!
WriteTextMessage(mainCommand.SwapPanel(panelId));
}
private void SetFollowSpeed(float speed)
{
WriteTextMessage(mainCommand.RouteFollow(routeId, bikeId, speed, new float[] { 0, -(float)Math.PI / 2f, 0 }, new float[] { 0, 0, 0 }));
WriteTextMessage(mainCommand.RouteFollow(routeId, cameraId, speed));
}
#endregion
#region message send/receive
/// <summary>
/// method that sends the speciefied message with the specified serial, and executes the given action upon receivind a reply from the server with this serial.
/// </summary>
@@ -148,7 +267,13 @@ namespace Client
/// <param name="action">the code to be executed upon reveiving a reply from the server with the specified serial</param>
public void SendMessageAndOnResponse(string message, string serial, HandleSerial action)
{
serialResponses.Add(serial, action);
if (serialResponses.ContainsKey(serial))
{
serialResponses[serial] = action;
} else
{
serialResponses.Add(serial, action);
}
WriteTextMessage(message);
}
@@ -169,6 +294,14 @@ namespace Client
//Write("sent message " + message);
}
#endregion
public void Stop()
{
serverResponseReader.Stop();
}
public void Write(string msg)
{
Console.WriteLine( "[ENGINECONNECT] " + msg);

14
Client/Program.cs
View File

@@ -12,7 +12,7 @@ namespace Client
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
Console.WriteLine("// Connecting... //");
//connect fiets?
Thread.Sleep(20000);
@@ -23,18 +23,18 @@ namespace Client
{
}
BLEHandler bLEHandler = new BLEHandler(client);
//BLEHandler bLEHandler = new BLEHandler(client);
bLEHandler.Connect();
//bLEHandler.Connect();
client.setHandler(bLEHandler);
//client.setHandler(bLEHandler);
//BikeSimulator bikeSimulator = new BikeSimulator(client);
BikeSimulator bikeSimulator = new BikeSimulator(client);
//bikeSimulator.StartSimulation();
bikeSimulator.StartSimulation();
//client.setHandler(bikeSimulator);
client.setHandler(bikeSimulator);
while (true)
{