public void ParseConfigPacket(EosPacket packet)
{
if (packet.Source == Board.Address && packet.Command == (byte)EosBusCommands.SERVO_GET_CONFIG_RESPONSE)
{
byte servo = packet.Data[0];
if (servo == Number)
{
int _lastMin = _minValue;
int _lastMax = _maxValue;
int _lastDefault = _defaultValue;
_minValue = ReadInt(packet.Data, 1);
_maxValue = ReadInt(packet.Data, 3);
_defaultValue = ReadInt(packet.Data, 5);
if (_lastMin != _minValue)
{
OnPropertyChanged("MinimumValue", _lastMin, _minValue, true);
}
if (_lastMax != _maxValue)
{
OnPropertyChanged("MaximumValue", _lastMax, _maxValue, true);
}
if (_lastDefault != _defaultValue)
{
OnPropertyChanged("DefaultValue", _lastDefault, _defaultValue, true);
}
}
}
}
public void Notify(EosPacket packet)
{
foreach (var o in _observers)
{
o.Update(packet);
}
}
public void ParseConfigPacket(EosPacket packet)
{
if (packet.Source == Board.Address && packet.Command == (byte)EosBusCommands.STEPPER_GET_CONFIG_RESPONSE)
{
byte stepper = packet.Data[0];
if (stepper == Number)
{
uint _lastMaxSpeed = _maxSpeed;
ulong _lastIdleSleep = _idleSleep;
_maxSpeed = ReadInt(packet.Data, 1);
_idleSleep = ReadLong(packet.Data, 3);
if (_lastMaxSpeed != _maxSpeed)
{
OnPropertyChanged("MaxSpeed", _lastMaxSpeed, _maxSpeed, true);
}
if (_lastIdleSleep != _idleSleep)
{
OnPropertyChanged("IdleSleep", _lastIdleSleep, _idleSleep, true);
}
}
}
}
public EosPacket CreatePacket()
{
EosPacket p = new EosPacket();
p.Type = EosPacketType.Message;
p.Data.Add(Encoding.Unicode.GetBytes(Message));
return(p);
}
public void SendPushShutdown(ReactorVirtualClient c)
{
EosPacket p = new EosPacket();
p.Sender = ReactorServer.Id;
p.Type = EosPacketType.Shutdown;
byte[] toSend = Encryption.AES_Encrypt(p.ToBytes(), c.Key, c.Salt);
EosSignal.SendNotification(c.Address, SignalPort, toSend);
}
protected virtual void SendPushRegistration(ReactorVirtualClient c)
{
EosPacket p = new EosPacket();
p.Sender = ReactorServer.Id;
p.Type = EosPacketType.Registered;
p.Data.Add(Encoding.Unicode.GetBytes(TimeToLive.ToString()));
c.SendPacket(p.ToBytes());
}
/// <summary>
/// Request the registration on the messaging server.
/// </summary>
protected void RequestRegistration()
{
EosPacket p = new EosPacket();
p.Sender = Id;
p.Type = EosPacketType.RequstRegistration;
p.Data.Add(Encoding.Unicode.GetBytes(AccessKey));
p.Data.Add(Encoding.Unicode.GetBytes(Username));
base.SendPacket(p.ToBytes());
}
/// <summary>
/// Send a push notification to a client with the specified username
/// </summary>
/// <param name="username"></param>
/// <param name="p"></param>
public void SendPushMessage(string username, EosPacket p)
{
var entry = (
from c in TtlClients where Encoding.Unicode.GetString((byte[])c.Key.Tag) == username select c)
.SingleOrDefault();
var client = entry.Key;
p.Type = EosPacketType.Message;
byte[] toSend = Encryption.AES_Encrypt(p.ToBytes(), client.Key, client.Salt);
EosSignal.SendNotification(client.Address, SignalPort, toSend);
}
/// <summary>
/// Handle a Packet.
/// </summary>
/// <param name="p"></param>
protected virtual void HandlePacket(EosPacket p)
{
switch (p.Type)
{
case EosPacketType.Registered:
// Start the Receiver
Receiver = new EosReceiver(PortReceiver);
Receiver.ReceivedPacketEvent += ReceiverOnReceivedPacketEvent;
Receiver.StartListening();
SendTerminate();
break;
}
}
/// <summary>
/// ReactorClient packet receiver
/// </summary>
/// <param name="data"></param>
public virtual void ReceiverOnReceivedPacketEvent(byte[] data)
{
byte[] d = Encryption.AES_Decrypt(data, Key, Salt);
EosPacket p = new EosPacket(d);
if (p.Type == EosPacketType.Message)
{
HandlePushMessage(p);
}
else if (p.Type == EosPacketType.Shutdown)
{
HandleServerShutdown();
}
}
private void UpdateServo(EosPacket packet)
{
EosDirectSerial bus = Interface as EosDirectSerial;
foreach (EosBoard board in bus.Boards)
{
foreach (EosServo servo in board.ServoOutputs)
{
servo.ParseConfigPacket(packet);
}
foreach (EosStepper stepper in board.StepperOutputs)
{
stepper.ParseConfigPacket(packet);
}
}
}
private void UpdateServo(EosPacket packet)
{
EosDirectSerial bus = Interface as EosDirectSerial;
foreach (EosBoard board in bus.Boards)
{
foreach (EosServo servo in board.ServoOutputs)
{
servo.ParseConfigPacket(packet);
}
foreach (EosStepper stepper in board.StepperOutputs)
{
stepper.ParseConfigPacket(packet);
}
}
}
public void HandleReactorPacket(ReactorVirtualClient c, EosPacket p)
{
switch (p.Type)
{
case EosPacketType.RequstRegistration:
byte[] accesskey = p.Data[0];
string username = Encoding.Unicode.GetString(p.Data[1]);
if (!ValidateAccessKey(accesskey))
{
break;
}
c.Tag = Encoding.Unicode.GetBytes(username);
// register
TtlClients.Add(c, Environment.TickCount); // Current Time in Ticks
SendPushRegistration(c);
break;
}
}
public void ParseConfigPacket(EosPacket packet)
{
if (packet.Source == Board.Address && packet.Command == (byte)EosBusCommands.STEPPER_GET_CONFIG_RESPONSE)
{
byte stepper = packet.Data[0];
if (stepper == Number)
{
uint _lastMaxSpeed = _maxSpeed;
ulong _lastIdleSleep = _idleSleep;
_maxSpeed = ReadInt(packet.Data, 1);
_idleSleep = ReadLong(packet.Data, 3);
if (_lastMaxSpeed != _maxSpeed)
{
OnPropertyChanged("MaxSpeed", _lastMaxSpeed, _maxSpeed, true);
}
if (_lastIdleSleep != _idleSleep)
{
OnPropertyChanged("IdleSleep", _lastIdleSleep, _idleSleep, true);
}
}
}
}
public void SendPacket(EosPacket packet, Server server, string username)
{
server.SendPushMessage(username, packet);
}
private void ReactorServerOnClientPacketReceivedEvent(ReactorVirtualClient c, byte[] data)
{
EosPacket p = new EosPacket(data);
HandleReactorPacket(c, p);
}
public void Update(EosPacket packet)
{
cmdManager.AddMessage(Encoding.Unicode.GetString(packet.Data[0]));
}
public void ParseConfigPacket(EosPacket packet)
{
if (packet.Source == Board.Address && packet.Command == (byte)EosBusCommands.SERVO_GET_CONFIG_RESPONSE)
{
byte servo = packet.Data[0];
if (servo == Number)
{
int _lastMin = _minValue;
int _lastMax = _maxValue;
int _lastDefault = _defaultValue;
_minValue = ReadInt(packet.Data, 1);
_maxValue = ReadInt(packet.Data, 3);
_defaultValue = ReadInt(packet.Data, 5);
if (_lastMin != _minValue)
{
OnPropertyChanged("MinimumValue", _lastMin, _minValue, true);
}
if (_lastMax != _maxValue)
{
OnPropertyChanged("MaximumValue", _lastMax, _maxValue, true);
}
if (_lastDefault != _defaultValue)
{
OnPropertyChanged("DefaultValue", _lastDefault, _defaultValue, true);
}
}
}
}
/// <summary>
/// Overwrite this to handle the PushMessage. The parameter is passed by the
/// receiver.
/// </summary>
/// <param name="p"></param>
protected virtual void HandlePushMessage(EosPacket p)
{
// OVERWRITE
}
protected override void HandlePushMessage(EosPacket p)
{
Notify(p);
Console.WriteLine(DateTime.Now.ToString() + "> Client | Received Push Message: " + Encoding.Unicode.GetString(p.Data[0]));
base.HandlePushMessage(p);
}
/// <summary>
/// called when bytes are received. Casted to a EosPacket.
/// </summary>
/// <param name="data"></param>
public virtual void OnPacketReceivedEvent(byte[] data)
{
EosPacket p = new EosPacket(data);
HandlePacket(p);
}
