1140 lines
35 KiB
C#
1140 lines
35 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using DTS.Common.Enums.DASFactory;
|
|
using DTS.Common.ICommunication;
|
|
|
|
namespace DTS.DASLib.Command.SLICEDB
|
|
{
|
|
public abstract class GPIOCommands : CommandBase
|
|
{
|
|
public enum SDBInputRegister
|
|
{
|
|
On3V = (1 << 0),
|
|
Charged3V = (1 << 1),
|
|
Start3V = (1 << 2),
|
|
RecordStatus3V = (1 << 3),
|
|
OMAPPowerGood = (1 << 4),
|
|
}
|
|
|
|
public enum ZeroRegister
|
|
{
|
|
On = (1 << 0),
|
|
Enable5V = (1 << 1),
|
|
nEnableBattery = (1 << 2),
|
|
RecordStatus = (1 << 3),
|
|
OMAPPowerGood = (1 << 4),
|
|
EnableOneWire = (1 << 5),
|
|
EnableBatteryCharge = (1 << 6),
|
|
SliceRun = (1 << 7),
|
|
}
|
|
|
|
public enum OneRegister
|
|
{
|
|
GreenLED = (1 << 0),
|
|
BlueLED = (1 << 1),
|
|
RedLED = (1 << 2),
|
|
}
|
|
|
|
public enum DirectionRegister
|
|
{
|
|
On3V = (1 << 0),
|
|
Charged3V = (1 << 1),
|
|
Start3V = (1 << 2),
|
|
RecordStatus3V = (1 << 3),
|
|
OMAPPowerGood = (1 << 4),
|
|
}
|
|
|
|
protected enum Commands
|
|
{
|
|
Reserved = 0x00,
|
|
|
|
ReadInputRegister = 0x01,
|
|
|
|
WriteSet0Register = 0x02,
|
|
WriteClear0Register = 0x03,
|
|
WriteToggle0Register = 0x04,
|
|
ReadDat0Register = 0x05,
|
|
WriteDat0Register = 0x06,
|
|
|
|
WriteSet1Register = 0x07,
|
|
WriteClear1Register = 0x08,
|
|
WriteToggle1Register = 0x09,
|
|
ReadDat1Register = 0x0A,
|
|
WriteDat1Register = 0x0B,
|
|
|
|
ReadDirRegister = 0x0C,
|
|
WriteDirRegister = 0x0D,
|
|
|
|
ReadHubConfigRegister = 0x0E,
|
|
WriteHubConfigRegister = 0x0F,
|
|
QueryStatusLED = 0x10,
|
|
SetStatusLED = 0x11,
|
|
|
|
StopStatusLEDServer = 0x12,
|
|
StartStatusLEDServer = 0x13,
|
|
|
|
QueryOMAPEventMon = 0x14,
|
|
QueryOMAPExtStatMon = 0x15,
|
|
QueryOMAPnStartMon = 0x16,
|
|
QueryOMAPnStatusMon = 0x17,
|
|
|
|
QueryOMAPEventLow = 0x18,
|
|
SetOMAPEventLow = 0x19,
|
|
QueryOMAPStartLow = 0x1A,
|
|
SetOMAPStartLow = 0x1B,
|
|
QueryOMAPStatusLow = 0x1C,
|
|
SetOMAPStatusLow = 0x1D,
|
|
QueryOMAPRecStatExt = 0x1E,
|
|
SetOMAPRecStatExt = 0x1F,
|
|
|
|
QueryAllGPIO = 0x20,
|
|
};
|
|
|
|
protected abstract Commands _Command { get; }
|
|
protected GPIOCommands(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
command.Type = CommandPacket.CommandType.GPIO;
|
|
command.SetCommand((byte)_Command, _Command.ToString());
|
|
}
|
|
|
|
protected GPIOCommands(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
command.Type = CommandPacket.CommandType.GPIO;
|
|
command.SetCommand((byte)_Command, _Command.ToString());
|
|
}
|
|
//public const int SDB_GPIO_PROTO_VERISON = 4;
|
|
}
|
|
#region MSP GPIO Registors
|
|
public class ReadInputRegister : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.ReadInputRegister; }
|
|
}
|
|
public ReadInputRegister(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public ReadInputRegister(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
|
|
private byte _val;
|
|
|
|
/// <summary>
|
|
/// The current value of the 8-bit input register
|
|
/// </summary>
|
|
public byte InputRegister
|
|
{
|
|
get { return _val; }
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
_val = 0;
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
byte bVal;
|
|
response.GetParameter(0, out bVal);
|
|
_val = bVal;
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
string.Format("InputRegister: {0}",InputRegister)
|
|
});
|
|
}
|
|
}
|
|
|
|
public class ReadDat0Register : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.ReadDat0Register; }
|
|
}
|
|
public ReadDat0Register(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public ReadDat0Register(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
|
|
private byte _value;
|
|
|
|
/// <summary>
|
|
/// The current value of the 8-bit input register
|
|
/// </summary>
|
|
public byte Value
|
|
{
|
|
get { return _value; }
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
_value = 0;
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
byte bVal;
|
|
response.GetParameter(0, out bVal);
|
|
_value = bVal;
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
string.Format("Value: {0}",Value)
|
|
});
|
|
}
|
|
}
|
|
|
|
public class ReadDat1Register : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.ReadDat1Register; }
|
|
}
|
|
public ReadDat1Register(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public ReadDat1Register(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
|
|
private byte _value;
|
|
|
|
/// <summary>
|
|
/// The current value of the 8-bit input register
|
|
/// </summary>
|
|
public byte Value
|
|
{
|
|
get { return _value; }
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
_value = 0;
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
byte bVal;
|
|
response.GetParameter(0, out bVal);
|
|
_value = bVal;
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
string.Format("Value: {0}",Value)
|
|
});
|
|
}
|
|
}
|
|
|
|
public class WriteDat0Register : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.WriteDat0Register; }
|
|
}
|
|
public WriteDat0Register(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public WriteDat0Register(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
|
|
private byte _val;
|
|
|
|
/// <summary>
|
|
/// The current Dat0 reg of the SLICE DB
|
|
/// </summary>
|
|
public byte Value
|
|
{
|
|
get { return _val; }
|
|
set
|
|
{
|
|
_val = value;
|
|
command.Parameter = new byte[sizeof(byte)];
|
|
command.SetParameter(0, _val);
|
|
}
|
|
}
|
|
|
|
public override void CommandToString(ref List<List<string>> lines)
|
|
{
|
|
base.CommandToString(ref lines);
|
|
lines.Add(new List<string>() { string.Format("Value: {0}", Value) });
|
|
}
|
|
}
|
|
|
|
public class WriteDat1Register : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.WriteDat1Register; }
|
|
}
|
|
public WriteDat1Register(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public WriteDat1Register(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
|
|
private byte _val;
|
|
|
|
/// <summary>
|
|
/// The current Dat0 reg of the SLICE DB
|
|
/// </summary>
|
|
public byte Value
|
|
{
|
|
get { return _val; }
|
|
set
|
|
{
|
|
_val = value;
|
|
command.Parameter = new byte[sizeof(byte)];
|
|
command.SetParameter(0, _val);
|
|
}
|
|
}
|
|
|
|
public override void CommandToString(ref List<List<string>> lines)
|
|
{
|
|
base.CommandToString(ref lines);
|
|
lines.Add(new List<string>() { string.Format("Value: {0}", Value) });
|
|
}
|
|
}
|
|
|
|
public class WriteToggle0Register : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.WriteToggle0Register; }
|
|
}
|
|
public WriteToggle0Register(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public WriteToggle0Register(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
|
|
private byte _val;
|
|
|
|
/// <summary>
|
|
/// The current Dat0 reg of the SLICE DB
|
|
/// </summary>
|
|
public byte Value
|
|
{
|
|
get { return _val; }
|
|
set
|
|
{
|
|
_val = value;
|
|
command.Parameter = new byte[sizeof(byte)];
|
|
command.SetParameter(0, _val);
|
|
}
|
|
}
|
|
|
|
public override void CommandToString(ref List<List<string>> lines)
|
|
{
|
|
base.CommandToString(ref lines);
|
|
lines.Add(new List<string>() { string.Format("Value: {0}", Value) });
|
|
}
|
|
}
|
|
|
|
public class WriteSet0Register : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.WriteSet0Register; }
|
|
}
|
|
public WriteSet0Register(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public WriteSet0Register(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
|
|
private byte _val;
|
|
|
|
/// <summary>
|
|
/// The current Dat0 reg of the SLICE DB
|
|
/// </summary>
|
|
public byte Value
|
|
{
|
|
get { return _val; }
|
|
set
|
|
{
|
|
_val = value;
|
|
command.Parameter = new byte[sizeof(byte)];
|
|
command.SetParameter(0, _val);
|
|
}
|
|
}
|
|
|
|
public override void CommandToString(ref List<List<string>> lines)
|
|
{
|
|
base.CommandToString(ref lines);
|
|
lines.Add(new List<string>() { string.Format("Value: {0}", Value) });
|
|
}
|
|
}
|
|
|
|
public class WriteClear0Register : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.WriteClear0Register; }
|
|
}
|
|
public WriteClear0Register(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public WriteClear0Register(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
|
|
private byte _val;
|
|
|
|
/// <summary>
|
|
/// The current Dat0 reg of the SLICE DB
|
|
/// </summary>
|
|
public byte Value
|
|
{
|
|
get { return _val; }
|
|
set
|
|
{
|
|
_val = value;
|
|
command.Parameter = new byte[sizeof(byte)];
|
|
command.SetParameter(0, _val);
|
|
}
|
|
}
|
|
|
|
public override void CommandToString(ref List<List<string>> lines)
|
|
{
|
|
base.CommandToString(ref lines);
|
|
lines.Add(new List<string>() { string.Format("Value: {0}", Value) });
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Status LED
|
|
public class QueryStatusLED : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.QueryStatusLED; }
|
|
}
|
|
public QueryStatusLED(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public QueryStatusLED(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private byte _value;
|
|
|
|
/// <summary>
|
|
/// The current value of the 8-bit input register
|
|
/// </summary>
|
|
public byte Value
|
|
{
|
|
get { return _value; }
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
_value = 0;
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
byte bVal;
|
|
response.GetParameter(0, out bVal);
|
|
_value = bVal;
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
string.Format("Value: {0}",Value)
|
|
});
|
|
}
|
|
}
|
|
|
|
public class SetStatusLED : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.SetStatusLED; }
|
|
}
|
|
public SetStatusLED(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public SetStatusLED(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private byte _val;
|
|
|
|
/// <summary>
|
|
/// The current StatusLED reg of the SLICE DB
|
|
/// </summary>
|
|
public byte Value
|
|
{
|
|
get { return _val; }
|
|
set
|
|
{
|
|
_val = value;
|
|
command.Parameter = new byte[sizeof(byte)];
|
|
command.SetParameter(0, _val);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region OMAP GPIO Reg Monitors
|
|
|
|
public class QueryOMAPEventMon : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.QueryOMAPEventMon; }
|
|
}
|
|
public QueryOMAPEventMon(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public QueryOMAPEventMon(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private byte _value;
|
|
|
|
/// <summary>
|
|
/// The current value of the event mon reg
|
|
/// </summary>
|
|
public bool Value
|
|
{
|
|
get { return Convert.ToBoolean(_value); }
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
_value = 0;
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
byte bVal;
|
|
response.GetParameter(0, out bVal);
|
|
_value = bVal;
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
string.Format("Value: {0}",Value)
|
|
});
|
|
}
|
|
}
|
|
|
|
public class QueryOMAPExtStatMon : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.QueryOMAPExtStatMon; }
|
|
}
|
|
public QueryOMAPExtStatMon(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public QueryOMAPExtStatMon(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private byte _value;
|
|
|
|
/// <summary>
|
|
/// The current value of the event mon reg
|
|
/// </summary>
|
|
public bool Value
|
|
{
|
|
get { return Convert.ToBoolean(_value); }
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
_value = 0;
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
byte bVal;
|
|
response.GetParameter(0, out bVal);
|
|
_value = bVal;
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
string.Format("Value: {0}",Value)
|
|
});
|
|
}
|
|
}
|
|
|
|
public class QueryOMAPnStartMon : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.QueryOMAPnStartMon; }
|
|
}
|
|
public QueryOMAPnStartMon(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public QueryOMAPnStartMon(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private byte _value;
|
|
|
|
/// <summary>
|
|
/// The current value of the event mon reg
|
|
/// </summary>
|
|
public bool Value
|
|
{
|
|
get { return Convert.ToBoolean(_value); }
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
_value = 0;
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
byte bVal;
|
|
response.GetParameter(0, out bVal);
|
|
_value = bVal;
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
string.Format("Value: {0}",Value)
|
|
});
|
|
}
|
|
}
|
|
|
|
public class QueryOMAPnStatusMon : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.QueryOMAPnStatusMon; }
|
|
}
|
|
public QueryOMAPnStatusMon(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public QueryOMAPnStatusMon(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private byte _value;
|
|
|
|
/// <summary>
|
|
/// The current value of the event mon reg
|
|
/// </summary>
|
|
public bool Value
|
|
{
|
|
get { return Convert.ToBoolean(_value); }
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
_value = 0;
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
byte bVal;
|
|
response.GetParameter(0, out bVal);
|
|
_value = bVal;
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
string.Format("Value: {0}",Value)
|
|
});
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region OMAP GPIO Reg Read/Writes
|
|
|
|
public class QueryOMAPEventLow : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.QueryOMAPEventLow; }
|
|
}
|
|
public QueryOMAPEventLow(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public QueryOMAPEventLow(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private byte _value;
|
|
|
|
/// <summary>
|
|
/// The current value of the event mon reg
|
|
/// </summary>
|
|
public bool Value
|
|
{
|
|
get { return Convert.ToBoolean(_value); }
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
_value = 0;
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
byte bVal;
|
|
response.GetParameter(0, out bVal);
|
|
_value = bVal;
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
string.Format("Value: {0}",Value)
|
|
});
|
|
}
|
|
}
|
|
|
|
public class SetOMAPEventLow : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.SetOMAPEventLow; }
|
|
}
|
|
public SetOMAPEventLow(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public SetOMAPEventLow(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private byte _val;
|
|
|
|
/// <summary>
|
|
/// The current StatusLED reg of the SLICE DB
|
|
/// </summary>
|
|
public bool Value
|
|
{
|
|
get { return Convert.ToBoolean(_val); }
|
|
set
|
|
{
|
|
_val = Convert.ToByte(value);
|
|
command.Parameter = new byte[sizeof(byte)];
|
|
command.SetParameter(0, _val);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class QueryOMAPStartLow : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.QueryOMAPStartLow; }
|
|
}
|
|
public QueryOMAPStartLow(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public QueryOMAPStartLow(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private byte _value;
|
|
|
|
/// <summary>
|
|
/// The current value of the event mon reg
|
|
/// </summary>
|
|
public bool Value
|
|
{
|
|
get { return Convert.ToBoolean(_value); }
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
_value = 0;
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
byte bVal;
|
|
response.GetParameter(0, out bVal);
|
|
_value = bVal;
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
string.Format("Value: {0}",Value)
|
|
});
|
|
}
|
|
}
|
|
|
|
public class SetOMAPStartLow : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.SetOMAPStartLow; }
|
|
}
|
|
public SetOMAPStartLow(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public SetOMAPStartLow(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private byte _val;
|
|
|
|
/// <summary>
|
|
/// The current StatusLED reg of the SLICE DB
|
|
/// </summary>
|
|
public bool Value
|
|
{
|
|
get { return Convert.ToBoolean(_val); }
|
|
set
|
|
{
|
|
_val = Convert.ToByte(value);
|
|
command.Parameter = new byte[sizeof(byte)];
|
|
command.SetParameter(0, _val);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class QueryOMAPStatusLow : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.QueryOMAPStatusLow; }
|
|
}
|
|
public QueryOMAPStatusLow(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public QueryOMAPStatusLow(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private byte _value;
|
|
|
|
/// <summary>
|
|
/// The current value of the event mon reg
|
|
/// </summary>
|
|
public bool Value
|
|
{
|
|
get { return Convert.ToBoolean(_value); }
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
_value = 0;
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
byte bVal;
|
|
response.GetParameter(0, out bVal);
|
|
_value = bVal;
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
string.Format("Value: {0}",Value)
|
|
});
|
|
}
|
|
}
|
|
|
|
public class SetOMAPStatusLow : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.SetOMAPStatusLow; }
|
|
}
|
|
public SetOMAPStatusLow(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public SetOMAPStatusLow(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private byte _val;
|
|
|
|
/// <summary>
|
|
/// The current StatusLED reg of the SLICE DB
|
|
/// </summary>
|
|
public bool Value
|
|
{
|
|
get { return Convert.ToBoolean(_val); }
|
|
set
|
|
{
|
|
_val = Convert.ToByte(value);
|
|
command.Parameter = new byte[sizeof(byte)];
|
|
command.SetParameter(0, _val);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class QueryOMAPRecStatExt : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.QueryOMAPRecStatExt; }
|
|
}
|
|
public QueryOMAPRecStatExt(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public QueryOMAPRecStatExt(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private byte _value;
|
|
|
|
/// <summary>
|
|
/// The current value of the event mon reg
|
|
/// </summary>
|
|
public bool Value
|
|
{
|
|
get { return Convert.ToBoolean(_value); }
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
_value = 0;
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
byte bVal;
|
|
response.GetParameter(0, out bVal);
|
|
_value = bVal;
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
string.Format("Value: {0}",Value)
|
|
});
|
|
}
|
|
}
|
|
|
|
public class SetOMAPRecStatExt : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.SetOMAPRecStatExt; }
|
|
}
|
|
public SetOMAPRecStatExt(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public SetOMAPRecStatExt(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private byte _val;
|
|
|
|
/// <summary>
|
|
/// The current StatusLED reg of the SLICE DB
|
|
/// </summary>
|
|
public bool Value
|
|
{
|
|
get { return Convert.ToBoolean(_val); }
|
|
set
|
|
{
|
|
_val = Convert.ToByte(value);
|
|
command.Parameter = new byte[sizeof(byte)];
|
|
command.SetParameter(0, _val);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class QueryAllGPIO : GPIOCommands
|
|
{
|
|
protected override GPIOCommands.Commands _Command
|
|
{
|
|
get { return Commands.QueryAllGPIO; }
|
|
}
|
|
|
|
public QueryAllGPIO(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
public QueryAllGPIO(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.OMAP_GPIO);
|
|
}
|
|
|
|
private UInt32[] _val;
|
|
|
|
/// <summary>
|
|
/// The slice bus voltage in millivolts
|
|
/// </summary>
|
|
public UInt32[] GPIOReg
|
|
{
|
|
get { return _val; }
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
_val = new uint[7];
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
UInt32 uVal;
|
|
for (byte i = 0; i < _val.Length; i++)
|
|
{
|
|
response.GetParameter(i * 4, out uVal);
|
|
_val[i] = uVal;
|
|
}
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
string.Format("SLICE Bus voltage (mV): {0}",GPIOReg)
|
|
});
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|