public void ProcessCommand(Queue <String> arguments)
{
string command = arguments.Dequeue().ToLower();
switch (command)
{
case "reset":
_bus.Reset();
break;
case "rescan":
_bus.Rescan();
break;
case "start":
_bus.StartPolling();
break;
case "stop":
_bus.StopPolling();
break;
case "device":
byte address = byte.Parse(arguments.Dequeue());
EosDevice device = _bus.Devices.GetByAddress(address);
if (device != null)
{
ProcessDeviceCommand(device, arguments);
}
break;
}
}
internal EosLed(EosDevice device, byte id)
: base(device, id)
{
_powerPacket = new EosPacket(device.Address, EosBusCommands.LED_POWER);
_powerPacket.Add((byte)id);
_powerPacket.Add((byte)0);
_powerPacket.IsSent = true;
_levelPacket = new EosPacket(device.Address, EosBusCommands.LED_LEVEL);
_levelPacket.Add((byte)id);
_levelPacket.Add((byte)0);
_levelPacket.IsSent = true;
}
public void ProcessCoilCommand(EosDevice device, Queue <String> arguments)
{
byte coil = byte.Parse(arguments.Dequeue());
string coilCommand = arguments.Dequeue().ToLower();
switch (coilCommand)
{
case "position":
int position = int.Parse(arguments.Dequeue());
device.SetCoilPosition(coil, position);
break;
}
}
public void ProcessStepperCommand(EosDevice device, Queue <String> arguments)
{
byte stepper = byte.Parse(arguments.Dequeue());
string stepperCommand = arguments.Dequeue().ToLower();
switch (stepperCommand)
{
case "target":
long target = long.Parse(arguments.Dequeue());
device.SetStepperTargetPosition(stepper, target);
break;
case "zero":
device.ZeroStepperPosition(stepper);
break;
}
}
public void ProcessLedCommand(EosDevice device, Queue <String> arguments, byte?ledId)
{
string ledCommand = arguments.Dequeue().ToLower();
switch (ledCommand)
{
case "level":
byte level = byte.Parse(arguments.Dequeue());
if (ledId == null)
{
device.SetBacklightLevel(level);
}
else
{
device.SetLedLevel((byte)ledId, level);
}
break;
case "on":
if (ledId == null)
{
device.SetBacklightPower(true);
}
else
{
device.SetLedPower((byte)ledId, true);
}
break;
case "off":
if (ledId == null)
{
device.SetBacklightPower(false);
}
else
{
device.SetLedPower((byte)ledId, false);
}
break;
}
}
public void ProcessSetCommand(EosDevice device, Queue <string> arguments)
{
string setCommand = arguments.Dequeue().ToLower();
switch (setCommand)
{
case "address":
byte newAddress = byte.Parse(arguments.Dequeue());
device.SetNodeAddress(newAddress);
break;
case "group":
byte newGroup = byte.Parse(arguments.Dequeue());
device.SetGroup(newGroup);
break;
case "name":
device.SetName(arguments.Dequeue());
break;
}
}
public void ProcessDeviceCommand(EosDevice device, Queue <String> arguments)
{
string deviceCommand = arguments.Dequeue().ToLower();
switch (deviceCommand)
{
case "set":
ProcessSetCommand(device, arguments);
break;
case "stepper":
ProcessStepperCommand(device, arguments);
break;
case "servo":
ProcessServoCommand(device, arguments);
break;
case "backlight":
ProcessLedCommand(device, arguments, null);
break;
case "led":
byte led = byte.Parse(arguments.Dequeue());
ProcessLedCommand(device, arguments, led);
break;
case "text":
ProcessTextCommand(device, arguments);
break;
case "coil":
ProcessCoilCommand(device, arguments);
break;
}
}
public void ProcessServoCommand(EosDevice device, Queue <String> arguments)
{
byte servo = byte.Parse(arguments.Dequeue());
string servoCommand = arguments.Dequeue().ToLower();
switch (servoCommand)
{
case "value":
int target = int.Parse(arguments.Dequeue());
device.SetServoValue(servo, target);
break;
case "set":
int minValue = int.Parse(arguments.Dequeue());
int maxValue = int.Parse(arguments.Dequeue());
int defaultValue = int.Parse(arguments.Dequeue());
device.SetServoConfig(servo, minValue, maxValue, defaultValue);
break;
case "get":
device.GetServoConfig(servo);
break;
}
}
protected void OnDeviceUpdated(EosDevice device)
{
OnDeviceUpdated(new EosDeviceEventArgs(device));
}
/// <summary>
/// Creates an output for a device and it's unique id.
/// </summary>
/// <param name="device">Device this output belongs to.</param>
/// <param name="id">Unique id by type for this output.</param>
internal EosOutput(EosDevice device, byte id)
{
_id = id;
_device = device;
}
private void Parser_PacketReady(object sender, EosPacketEventArgs e)
{
lock (this)
{
//Console.WriteLine("Packet Received (masterState {0}, responseAddress {1})", _masterState, _resposneAddress);
OnPacketReceived(e.Packet);
// Check to see if we got the response before we checked for done transmitting
if (_masterState == BusMasterState.TRANSMITTING && _resposneAddress != 0xff && !IsWriting)
{
_masterState = BusMasterState.WAITINGRESPONSE;
switch (State)
{
case EosBusState.TRANSMITTING:
State = EosBusState.WAITING_RESPONSE;
break;
case EosBusState.POLLING:
case EosBusState.IDLE:
State = _polling ? EosBusState.POLLING : EosBusState.IDLE;
break;
}
}
if (_masterState == BusMasterState.WAITINGRESPONSE && e.Packet.Source == _resposneAddress)
{
_busTimer.Stop();
_masterState = BusMasterState.IDLE;
switch (State)
{
case EosBusState.POLLING:
//Console.WriteLine("Polling Received");
if (e.Packet.Data.Count > 0)
{
EosDevice device = Devices.GetByAddress(e.Packet.Source);
device.UpdateState(e.Packet);
OnDeviceUpdated(device);
}
_busTimer.Interval = POLL_INTERVAL;
_busTimer.Start();
break;
case EosBusState.SCANNING:
// Scan found a valid response
_devices.Add(new EosDevice(this, e.Packet.Source, e.Packet.Data));
NextScan();
break;
case EosBusState.WAITING_RESPONSE:
//Console.WriteLine("Response sent");
OnResponseReceived(e.Packet);
if (_polling)
{
State = EosBusState.POLLING;
_busTimer.Interval = POLL_INTERVAL;
_busTimer.Start();
}
else
{
State = EosBusState.IDLE;
}
break;
}
}
else if (_masterState == BusMasterState.CLEARINGSCAN)
{
_masterState = BusMasterState.IDLE;
Rescan();
}
else if (_masterState == BusMasterState.CLEARINGRESET)
{
_masterState = BusMasterState.IDLE;
Reset();
}
else
{
// Received errored packet when we are not waiting on one.
_stats.Collisions++;
}
}
}
public void ProcessTextCommand(EosDevice device, Queue <String> arguments)
{
byte display = byte.Parse(arguments.Dequeue());
device.SetDisplayText(display, arguments.Dequeue());
}
public override void ProcessData(byte[] buffer, int offset, int length)
{
for (int i = 0; i < length; i++)
{
byte data = buffer[offset + i];
switch (_parseState)
{
case ParseStates.COMMAND:
ProcessCommand(data);
break;
case ParseStates.MODE:
ProcessMode(data);
break;
case ParseStates.PACKET:
_parseBuffer[_parseBufferCount++] = data;
if ((_parseBufferCount == 4 && _parseBuffer[3] == 0) ||
(_parseBufferCount > 4 && _parseBufferCount == (4 + _parseBuffer[3])))
{
EosPacket packet = new EosPacket();
packet.Destination = _parseBuffer[0];
packet.Source = _parseBuffer[1];
packet.Command = _parseBuffer[2];
for (int j = 0; j < _parseBuffer[3]; j++)
{
packet.Add(_parseBuffer[4 + j]);
}
OnPacketReceived(packet);
if (State == EosBusState.WAITING_RESPONSE)
{
OnResponseReceived(packet);
}
if (packet.Command == 127 && packet.Data.Count > 0)
{
EosDevice device = Devices.GetByAddress(packet.Source);
device.UpdateState(packet);
OnDeviceUpdated(device);
}
_parseState = ParseStates.COMMAND;
//Console.WriteLine();
}
break;
case ParseStates.ENUMERATIONCOUNT:
if (data > 0)
{
_parseBuffer[0] = data;
_parseState = ParseStates.ENUMERATION;
}
else
{
_parseState = ParseStates.COMMAND;
}
break;
case ParseStates.ENUMERATION:
_parseBuffer[1 + _parseBufferCount++] = data;
if (_parseBufferCount == 21)
{
List <byte> deviceData = new List <byte>(20);
for (int j = 0; j < 20; j++)
{
deviceData.Add(_parseBuffer[2 + j]);
}
_devices.Add(new EosDevice(this, _parseBuffer[1], deviceData));
_parseBuffer[0]--;
_parseBufferCount = 0;
if (_parseBuffer[0] == 0)
{
_parseState = ParseStates.COMMAND;
OnBusReset();
//Console.WriteLine();
}
}
break;
default:
if (data == 58)
{
ProcessCommandData();
//Console.WriteLine();
}
else
{
_parseBuffer[_parseBufferCount++] = data;
}
break;
}
}
}
public EosDeviceEventArgs(EosDevice device)
{
_device = device;
}
