/// <summary>
/// This function enables synchonizing two motors.
/// Synchonization should be used when motors should run as synchrone as possible,
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="layer">Specify chain layer number [0 - 3]</param>
/// <param name="ports">Output bit field [0x00 – 0x0F]</param>
/// <param name="speed">Speed level, [-100 – 100]</param>
/// <param name="turnRatio">Turn ratio, [-200 - 200]
/// 0 : Motor will run with same power
/// 100 : One motor will run with specified power while the other will be close to zero
/// 200: One motor will run with specified power forward while the other will run in the opposite direction at the same power level.
/// </param>
/// <param name="time">Time in milliseconds, 0 = Infinite</param>
/// <param name="brake">Specify break level, [0: Float, 1: Break]</param>
/// <remarks>
/// Instruction opOutput_Time_Sync (LAYER, NOS, SPEED, TURN, STEP, BRAKE)
/// Opcode 0xB1
/// Arguments (Data8) LAYER – Specify chain layer number [0 - 3]
/// (Data8) NOS – Output bit field [0x00 – 0x0F]
/// (Data8) SPEED – Power level, [-100 – 100]
/// (Data16) TURN – Turn ratio, [-200 - 200], see documentation below
/// (Data32) TIME – Time in milliseconds, 0 = Infinite
/// (Data8) BRAKE - Specify break level [0: Float, 1: Break]
/// Dispatch status Unchanged
/// Description This function enables synchonizing two motors. Synchonization should be used when motors should run as synchrone as possible,
/// </remarks>
public static async Task TimeSync(ISocket socket, ChainLayer layer, OutputPortFlag ports, int speed, int turnRatio, int time, Brake brake = Brake.Float, bool requireReply = true)
{
if (time < 0)
{
throw new ArgumentOutOfRangeException(nameof(time), ">=0");
}
if (speed < -100 || speed > 100)
{
throw new ArgumentOutOfRangeException(nameof(speed), "[-100,100]");
}
if (turnRatio < -200 || turnRatio > 200)
{
throw new ArgumentOutOfRangeException(nameof(turnRatio), "[-200,200]");
}
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(requireReply ? CommandType.DIRECT_COMMAND_REPLY : CommandType.DIRECT_COMMAND_NO_REPLY))
{
cb.OpCode(OP.opOUTPUT_TIME_SYNC);
cb.SHORT((int)layer);
cb.SHORT((int)ports);
cb.PAR8(speed);
cb.PAR16(turnRatio);
cb.PAR32(time);
cb.PAR8((byte)brake);
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
/// <summary>
/// This function enables specifying a full motor power cycle in tacho counts.
/// The system will automatically adjust the power level to the motor to keep the specified output speed.
/// RampDown specifies the power ramp up periode in tacho count,
/// ContinuesRun specifies the constant power period in tacho counts,
/// RampUp specifies the power down period in tacho counts.
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="layer">Specify chain layer number [0 - 3]</param>
/// <param name="ports">Output bit field [0x00 – 0x0F]</param>
/// <param name="speed">Specify output speed [-100 – 100]</param>
/// <param name="tachoPulsesRampUp">Tacho pulses during ramp up</param>
/// <param name="tachoPulsesContinuesRun">Tacho pulses during continues run</param>
/// <param name="tachoPulsesRampDown">Tacho pulses during ramp down</param>
/// <param name="brake">Specify break level, [0: Float, 1: Break]</param>
/// <remarks>
/// Instruction opOutput_Step_Speed (LAYER, NOS, SPEED, STEP1, STEP2, STEP3, BRAKE)
/// Opcode 0xAE
/// Arguments (Data8) LAYER – Specify chain layer number, [0 - 3]
/// (Data8) NOS – Output bit field, [0x00 – 0x0F]
/// (Data8) SPEED – Power level, [-100 - 100]
/// (Data32) STEP1 – Tacho pulses during ramp up
/// (Data32) STEP2 – Tacho pulses during continues run
/// (Data32) STEP3 – Tacho pulses during ramp down
/// (Data8) BRAKE - Specify break level, [0: Float, 1: Break]
/// Dispatch status Unchanged
/// Description This function enables specifying a full motor power cycle in tacho counts. The system will automatically adjust the power level to the motor to keep the specified output speed. Step1 specifies the power ramp up periode in tacho count, Step2 specifies the constant power period in tacho counts, Step 3 specifies the power down period in tacho counts.
/// </remarks>
public static async Task StepSpeed(ISocket socket, ChainLayer layer, OutputPortFlag ports, int speed, int tachoPulsesRampUp, int tachoPulsesContinuesRun, int tachoPulsesRampDown, Brake brake = Brake.Float, bool requireReply = true)
{
if (speed < -100 || speed > 100)
{
throw new ArgumentOutOfRangeException(nameof(speed), "[-100,100]");
}
if (tachoPulsesContinuesRun < 0)
{
throw new ArgumentOutOfRangeException(nameof(tachoPulsesContinuesRun), ">=0");
}
if (tachoPulsesRampUp < 0)
{
throw new ArgumentOutOfRangeException(nameof(tachoPulsesRampUp), ">=0");
}
if (tachoPulsesRampDown < 0)
{
throw new ArgumentOutOfRangeException(nameof(tachoPulsesRampDown), ">=0");
}
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(requireReply ? CommandType.DIRECT_COMMAND_REPLY : CommandType.DIRECT_COMMAND_NO_REPLY))
{
cb.OpCode(OP.opOUTPUT_STEP_SPEED);
cb.PAR8((int)layer);
cb.PAR8((int)ports);
cb.PAR8(speed);
cb.PAR32((uint)tachoPulsesRampUp);
cb.PAR32((uint)tachoPulsesContinuesRun);
cb.PAR32((uint)tachoPulsesRampDown);
cb.PAR8((byte)brake);
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
/// <summary>
/// Read information about external device
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="port">Port number [0-31]</param>
/// <returns>Format</returns>
/// <remarks>
/// Instruction opInput_Device (CMD, …)
/// Opcode 0x99
/// CMD: GET_FORMAT = 0x02
/// Arguments
/// (Data8) LAYER – Specify chain layer number [0-3]
/// (Data8) NO – Port number
/// Returns
/// (Data8) Datasets – Number of data sets
/// (Data8) FORMAT – Format [0-3], (0: 8-bit, 1: 16-bit, 2: 32-bit, 3: Float point)
/// (Data8) MODES – Number of modes [1-8]
/// (Data8) VIEW – Number of modes visible within port view app [1-8]
/// </remarks>
internal static async Task <Format> GetFormat(ISocket socket, ChainLayer layer, int port)
{
if (port < 0 || port > 31)
{
throw new ArgumentException("Number of port must be between 0 and 31", nameof(port));
}
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_REPLY, 4, 0))
{
cb.OpCode(OP.opINPUT_DEVICE);
cb.Raw((byte)INPUT_DEVICE_SUBCODE.GET_FORMAT);
cb.PAR8((byte)layer);
cb.PAR8((byte)port);
cb.GlobalIndex(0);
cb.GlobalIndex(1);
cb.GlobalIndex(2);
cb.GlobalIndex(3);
cmd = cb.ToCommand();
}
Response response = await socket.Execute(cmd);
byte[] data = response.PayLoad;
return(new Format(data[0], (DataType)data[1], data[2], data[3]));
}
/// <summary>
/// Gets the connection type for the given port
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="port">Port number [0 - 31]</param>
/// <returns></returns>
/// <remarks>
/// Instruction opInput_Device (CMD, …)
/// Opcode 0x99
/// CMD: GET_CONNECTION = 0x0C
/// Arguments
/// (Data8) LAYER – Specify chain layer number [0-3]
/// (Data8) NO – Port number
/// Returns
/// (Data8) CONN – Connection type
/// </remarks>
internal static async Task <ConnectionType> GetConnection(ISocket socket, int port)
{
if (port < 0 || port > 31)
{
throw new ArgumentException("Number of port must be between 0 and 31", "port");
}
ChainLayer layer = GetLayer(port);
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_REPLY, 1, 0))
{
cb.OpCode(OP.opINPUT_DEVICE);
cb.Raw((byte)INPUT_DEVICE_SUBCODE.GET_CONNECTION);
cb.PAR8((byte)layer);
cb.PAR8((ushort)port);
cb.GlobalIndex(0);
cmd = cb.ToCommand();
}
Response response = await socket.Execute(cmd);
ConnectionType type = ConnectionType.CONN_UNKNOW;
if (response.Type == ResponseType.OK)
{
byte[] data = response.PayLoad;
if (data.Length > 0)
{
type = (ConnectionType)data[0];
}
}
return(type);
}
/// <summary>
/// Reads the type and mode of the connected device
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="port">Port [0-31]</param>
/// <returns>TypeMode</returns>
/// <remarks>
/// Instruction opInput_Device (CMD, …)
/// Opcode 0x99
/// CMD: GET_TYPEMODE = 0x05
/// Arguments
/// (Data8) LAYER – Specify chain layer number [0-3]
/// (Data8) NO – Port number
/// Returns
/// (Data8) TYPE – See device type list (Please reference section 0)
/// (Data8) MODE – Device mode [0-7]
/// </remarks>
internal static async Task <DeviceTypeMode> GetTypeMode(ISocket socket, int port)
{
if (port < 0 || port > 31)
{
throw new ArgumentException("Number of port must be between 0 and 31", nameof(port));
}
ChainLayer layer = GetLayer(port);
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_REPLY, 2, 0))
{
cb.OpCode(OP.opINPUT_DEVICE);
cb.Raw((byte)INPUT_DEVICE_SUBCODE.GET_TYPEMODE);
cb.PAR8((byte)layer);
cb.PAR8((byte)port);
cb.GlobalIndex(0);
cb.GlobalIndex(1);
cmd = cb.ToCommand();
}
Response response = await socket.Execute(cmd);
byte[] data = response.PayLoad;
return(new DeviceTypeMode((DeviceType)data[0], (DeviceMode)data[1]));
}
/// <summary>
/// This function enables specifying a full motor power cycle in time.
/// RampUp specifies the power ramp up periode in milliseconds,
/// ContinuesRun specifies the constant power period in milliseconds,
/// RampDown specifies the power down period in milliseconds.
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="layer">Specify chain layer number [0 - 3]</param>
/// <param name="ports">Output bit field [0x00 – 0x0F]</param>
/// <param name="power">Specify output power [-100 – 100]</param>
/// <param name="timeRampUp">Time in milliseconds for ramp up</param>
/// <param name="timeContinuesRun">Time in milliseconds for continues run</param>
/// <param name="timeRampDown">Time in milliseconds for ramp down</param>
/// <param name="brake">Specify break level, [0: Float, 1: Break]</param>
/// <remarks>
/// Instruction opOutput_Time_Power (LAYER, NOS, POWER, STEP1, STEP2, STEP3, BRAKE)
/// Opcode 0xAD
/// Arguments (Data8) LAYER – Specify chain layer number [0 - 3]
/// (Data8) NOS – Output bit field [0x00 – 0x0F]
/// (Data8) POWER – Power level, [-100 – 100]
/// (Data32) STEP1 – Time in milliseconds for ramp up
/// (Data32) STEP2 – Time in milliseconds for continues run
/// (Data32) STEP3 – Time in milliseconds for ramp down
/// (Data8) BRAKE - Specify break level [0: Float, 1: Break]
/// Dispatch status Unchanged
/// Description This function enables specifying a full motor power cycle in time. Step1 specifies the power ramp up periode in milliseconds, Step2 specifies the constant power period in milliseconds, Step 3 specifies the power down period in milliseconds.
/// </remarks>
public static async Task TimePower(ISocket socket, ChainLayer layer, OutputPortFlag ports, int power, int timeRampUp, int timeContinuesRun, int timeRampDown, Brake brake = Brake.Float, bool requireReply = true)
{
if (power < -100 || power > 100)
{
throw new ArgumentOutOfRangeException(nameof(power), "[-100,100]");
}
if (timeContinuesRun < 0)
{
throw new ArgumentOutOfRangeException(nameof(timeContinuesRun), ">=0");
}
if (timeRampUp < 0)
{
throw new ArgumentOutOfRangeException(nameof(timeRampUp), ">=0");
}
if (timeRampDown < 0)
{
throw new ArgumentOutOfRangeException(nameof(timeRampDown), ">=0");
}
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(requireReply ? CommandType.DIRECT_COMMAND_REPLY : CommandType.DIRECT_COMMAND_NO_REPLY))
{
cb.OpCode(OP.opOUTPUT_TIME_POWER);
cb.SHORT((int)layer);
cb.SHORT((int)ports);
cb.PAR8(power);
cb.PAR32(timeRampUp);
cb.PAR32(timeContinuesRun);
cb.PAR32(timeRampDown);
cb.PAR8((byte)brake);
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
/// <summary>
/// This function sets the polarity of the specified output port(s).
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="layer">Specify chain layer number [0 - 3]</param>
/// <param name="ports">Output bit field [0x00 – 0x0F]</param>
/// <param name="polarity">Polarity -1 : backward 0 : opposite direction 1 : forward</param>
/// <remarks>
/// Instruction opOutput_Polarity (LAYER, NOS, POL)
/// Opcode 0xA7
/// Arguments (Data8) LAYER – Specify chain layer number, [0 - 3]
/// (Data8) NOS – Output bit field, [0x00 – 0x0F]
/// (Data8) POL – Polarity [-1, 0, 1], see documentation below
/// Dispatch status Unchanged
/// Description This function enables starting the specified output port.
/// </remarks>
public static async Task SetPolarity(ISocket socket, ChainLayer layer, OutputPortFlag ports, Polarity polarity, bool requireReply = true)
{
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(requireReply ? CommandType.DIRECT_COMMAND_REPLY : CommandType.DIRECT_COMMAND_NO_REPLY))
{
cb.OpCode(OP.opOUTPUT_POLARITY);
cb.PAR8((int)layer);
cb.PAR8((int)ports);
cb.PAR8((byte)polarity);
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
/// <summary>
/// Apply the default minimum and maximum raw value for device type to be used in scaling PCT and SI value
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="type">Device type</param>
/// <param name="mode">Device mode [0-7]</param>
/// <returns></returns>
/// <remarks>
/// Instruction opInput_Device (CMD, …)
/// Opcode 0x99
/// CMD: CAL_DEFAULT = 0x04
/// Arguments
/// (Data8) TYPE – Device type (Please reference section 0)
/// (Data8) MODE – Device mode [0-7]
/// Description
/// Apply the default minimum and maximum raw value for device type to be used in scaling PCT and SI value
/// </remarks>
internal static async Task SetDefaultMinMax(ISocket socket, DeviceType type, DeviceMode mode)
{
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_NO_REPLY))
{
cb.OpCode(OP.opINPUT_DEVICE);
cb.Raw((byte)INPUT_DEVICE_SUBCODE.CAL_DEFAULT);
cb.PAR8((byte)type);
cb.PAR8((byte)mode);
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
///// <summary>
///// This function enables reading current motor speed and tacho count level.
///// </summary>
///// <param name="socket">socket for executing command to brick</param>
///// <param name="layer">Specify chain layer number [0 - 3]</param>
///// <param name="port">Port number [0 - 3]</param>
///// <remarks>
///// Instruction opOutput_Read (LAYER, NO, *SPEED, *TACHO)
///// Opcode 0xA8
///// Arguments (Data8) LAYER – Specify chain layer number [0 - 3]
///// (Data8) NO – Port number [0 - 3]
///// (Data8) *SPEED – Output speed level detected, [-100 - 100]
///// (Data32) *TACHO – Current output tacho count
///// Dispatch status Unchanged
///// Description This function enables reading current motor speed and tacho count level.
///// </remarks>
//public static async Task Read(ISocket socket, ChainLayer layer, OutputPortName port)
//{
// Command cmd = null;
// using (CommandBuilder cb = new CommandBuilder(DIRECT_COMMAND_TYPE.DIRECT_COMMAND_NO_REPLY,0,2))
// {
// cb.OpCode(OpCode.opOutput_Read);
// cb.Argument((byte)layer);
// cb.Argument((byte)port);
// cb.LocalIndex(0);
// cb.LocalIndex32(1);
// cmd = cb.ToCommand();
// }
// await socket.Execute(cmd);
// CommandReply reply = cmd.Reply;
//}
/// <summary>
/// This function enables the program to test if a output port is busy.
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="layer">Specify chain layer number [0 - 3]</param>
/// <param name="ports">Output bit field [0x00 – 0x0F]</param>
/// <remarks>
/// Instruction opOutput_Test (LAYER, NOS, BUSY)
/// Opcode 0xA9
/// Arguments (Data8) LAYER – Specify chain layer number [0 - 3]
/// (Data8) NOS – Output bit field [0x00 – 0x0F]
/// Return (Data8) BUSY – Output busy flag, [0 = Ready, 1 = Busy]
/// Dispatch status Unchanged
/// Description This function enables the program to test if a output port is busy.
/// </remarks>
public static async Task <bool> IsBusy(ISocket socket, ChainLayer layer, OutputPortFlag ports)
{
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_REPLY, 1, 0))
{
cb.OpCode(OP.opOUTPUT_TEST);
cb.PAR8((int)layer);
cb.PAR8((int)ports);
cb.GlobalIndex(0);
cmd = cb.ToCommand();
}
Response response = await socket.Execute(cmd);
return(BitConverter.ToBoolean(response.PayLoad, 0));
}
/// <summary>
/// Plays a tone based on frequency for given duration and at a given volume.
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="volume">Specify volume for playback, [0 - 100]</param>
/// <param name="frequency">Specify frequency, [250 - 10000]</param>
/// <param name="duration">Specify duration in milliseconds [1 - n]</param>
/// <exception cref="ArgumentOutOfRangeException"></exception>
/// <remarks>
/// Instruction opSound (CMD, …)
/// Opcode 0x94
/// Arguments (Data8) CMD => Specific command parameter documented below
/// Dispatch status Unchanged
/// Description Sound control entry
/// CMD: TONE = 0x01
/// Arguments
/// (Data8) VOLUME – Specify volume for playback, [0 - 100]
/// (Data16) FREQUENCY – Specify frequency, [250 - 10000]
/// (Data16) DURATION – Specify duration in millisecond
/// </remarks>
internal static async Task Tone(ISocket socket, int volume, int frequency, int duration)
{
if (volume < 0 || volume > 100)
{
throw new ArgumentOutOfRangeException("Volume must be between 0 and 100", "volume");
}
if (frequency < 250 || frequency > 10000)
{
throw new ArgumentOutOfRangeException("Frequency must be between 250 and 10000", "frequency");
}
if (duration < 1)
{
throw new ArgumentOutOfRangeException("Duration must be longer than 0", "duration");
}
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_NO_REPLY))
{
cb.OpCode(OP.opSOUND);
cb.Raw((byte)SOUND_SUBCODE.TONE);
cb.PAR8(volume);
cb.PAR16(frequency);
cb.PAR16(duration);
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
/// <summary>
/// This function enables the program to read the tacho count as sensor input.
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="layer">Specify chain layer number [0 - 3]</param>
/// <param name="ports">Output bit field [0x00 – 0x0F]</param>
/// <remarks>
/// Instruction opOutput_Get_Count (LAYER, NOS, *TACHO)
/// Opcode 0xB3
/// Arguments (Data8) LAYER – Specify chain layer number [0 - 3]
/// (Data8) NOS – Output bit field [0x00 – 0x0F]
/// (Data32) *TACHO – Tacho count as sensor value
/// Dispatch status Unchanged
/// Description This function enables the program to read the tacho count as sensor input.
/// </remarks>
public static async Task <int> GetTachoCount(ISocket socket, ChainLayer layer, OutputPortName port)
{
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_REPLY, 4, 0))
{
cb.OpCode(OP.opOUTPUT_GET_COUNT);
cb.PAR8((byte)layer);
cb.PAR8((byte)port);
cb.VARIABLE_PAR32(0, PARAMETER_VARIABLE_SCOPE.GLOBAL);
cmd = cb.ToCommand();
}
Response response = await socket.Execute(cmd);
return(BitConverter.ToInt32(response.PayLoad, 0));
}
/// <summary>
/// Clear changes and bumps
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="port">Port number [0 - 31]</param>
/// <returns></returns>
/// <remarks>
/// Instruction opInput_Device (CMD, …)
/// Opcode 0x99
/// CMD: CLR_CHANGES = 0x1A
/// Arguments
/// (Data8) LAYER – Specify chain layer number [0-3]
/// (Data8) NO – Port number
/// Description
/// Clear changes and bumps
/// </remarks>
internal static async Task ClearChanges(ISocket socket, int port)
{
if (port < 0 || port > 31)
{
throw new ArgumentException("Number of port must be between 0 and 31", "port");
}
ChainLayer layer = GetLayer(port);
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_NO_REPLY))
{
cb.OpCode(OP.opINPUT_DEVICE);
cb.Raw((byte)INPUT_DEVICE_SUBCODE.CLR_CHANGES);
cb.PAR8((byte)layer);
cb.PAR8((ushort)port);
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
/// <summary>
/// Set Led mode
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="ledMode">Pattern of the led</param>
public static async Task Led(ISocket socket, LedMode ledMode, bool requireReply = false)
{
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(requireReply ? CommandType.DIRECT_COMMAND_REPLY : CommandType.DIRECT_COMMAND_NO_REPLY))
{
cb.OpCode(OP.opUI_WRITE);
cb.Raw((byte)UI_WRITE_SUBCODE.LED);
cb.PAR8((byte)ledMode);
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
/// <summary>
/// Stop all input devices
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="layer">Specify chain layer number [0 - 3]</param>
/// <returns></returns>
/// <remarks>
/// Instruction opInput_Device (CMD, …)
/// Opcode 0x99
/// CMD: STOP_ALL= 0x0D (Stop all devices)
/// Arguments
/// (Data8) LAYER – Specify chain layer number [0-3] (-1 = All)
/// </remarks>
internal static async Task Stop(ISocket socket, ChainLayer layer)
{
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_NO_REPLY))
{
cb.OpCode(OP.opINPUT_DEVICE);
cb.Raw((byte)INPUT_DEVICE_SUBCODE.STOP_ALL);
cb.PAR8((byte)layer);
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
/// <summary>
/// This function enables specifying the output device type
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="layer">Specify chain layer number [0 - 3]</param>
/// <param name="port">Port number [0 - 3]</param>
/// <param name="type">Output device type, (0x07: Large motor, Medium motor = 0x08)</param>
/// <param name="requireReply">indicate if the brick should respond OK on method call</param>
/// <remarks>
/// Instruction opOutput_Set_Type (LAYER, NO, TYPE)
/// Opcode 0xA1
/// Arguments (Data8) LAYER – Specify chain layer number [0 - 3]
/// (Data8) NO – Port number [0 - 3]
/// (Data8) TYPE – Output device type, (0x07: Large motor, Medium motor = 0x08)
/// Dispatch status Unchanged
/// Description This function enables specifying the output device type
/// </remarks>
public static async Task SetType(ISocket socket, ChainLayer layer, OutputPortName port, DeviceType type, bool requireReply = true)
{
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(requireReply ? CommandType.DIRECT_COMMAND_REPLY : CommandType.DIRECT_COMMAND_NO_REPLY))
{
cb.OpCode(OP.opOUTPUT_SET_TYPE);
cb.SHORT((int)layer);
cb.SHORT((int)port);
cb.PAR8((byte)type);
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
/// <summary>
/// Clear all device counters and values on all layers
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <returns></returns>
/// <remarks>
/// Instruction opInput_Device (CMD, …)
/// Opcode 0x99
/// CMD: CLR_ALL = 0x0A
/// Arguments
/// (Data8) LAYER – Specify chain layer number [0-3] (-1 = All)
/// Description
/// Clear all device counters and values
/// </remarks>
internal static async Task Reset(ISocket socket)
{
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_NO_REPLY))
{
int all = -1;
cb.OpCode(OP.opINPUT_DEVICE);
cb.Raw((byte)INPUT_DEVICE_SUBCODE.CLR_ALL);
cb.PAR8((byte)all);
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
/// <summary>
/// This function sends stop to all individual output ports
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="layer">Specify chain layer number [0 - 3]</param>
/// <param name="ports">Output bit field [0x00 – 0x0F]</param>
/// <param name="brake">Specify break level [0: Float, 1: Break]</param>
/// <remarks>
/// Instruction opOutput_Stop (LAYER, NOS, BRAKE)
/// Opcode 0xA3
/// Arguments (Data8) LAYER – Specify chain layer number [0 - 3]
/// (Data8) NOS – Output bit field [0x00 – 0x0F]
/// (Data8) BRAKE – Specify break level [0: Float, 1: Break]
/// Dispatch status Unchanged
/// Description This function enables restting the tacho count for the individual output ports
/// </remarks>
public static async Task Stop(ISocket socket, ChainLayer layer, OutputPortFlag ports, Brake brake = Brake.Float, bool requireReply = true)
{
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(requireReply ? CommandType.DIRECT_COMMAND_REPLY : CommandType.DIRECT_COMMAND_NO_REPLY))
{
cb.OpCode(OP.opOUTPUT_STOP);
cb.SHORT((int)layer);
cb.SHORT((int)ports);
cb.PAR8((byte)brake);
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
//CMD: BMPFILE = 0x1C
//Arguments
//(DATA8) Color – Specify either black or white, [0: White, 1: Black]
//(Data16) X0 – Specify X start point, [0 - 177]
//(Data16) Y0 – Specify Y start point, [0 - 127]
//(Data8) NAME – First character in filename(Character string)
//Description
//Enable displaying BMP file from icon file within running project.
internal static async Task BMPFile(ISocket socket, string path, int x = 0, int y = 0, UIColor color = UIColor.Black)
{
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_NO_REPLY))
{
cb.OpCode(OP.opUI_DRAW);
cb.Raw((byte)UI_DRAW_SUBCODE.BMPFILE);
cb.PAR8((int)color);
cb.PAR16(x);
cb.PAR16(y);
cb.PARS(path);
cb.OpCode(OP.opUI_DRAW);
cb.Raw((byte)UI_DRAW_SUBCODE.UPDATE);
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
/// <summary>
/// This function enables setting the output percentage speed on the output ports.
/// This automatically enables speed control, which means the system will automatically adjust the power to keep the specified speed.
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="layer">Specify chain layer number [0 - 3]</param>
/// <param name="ports">Output bit field [0x00 – 0x0F]</param>
/// <param name="speed">Specify output speed [-100 – 100 %]</param>
/// <remarks>
/// Instruction opOutput_Speed (LAYER, NOS, SPEED)
/// Opcode 0xA5
/// Arguments (Data8) LAYER – Specify chain layer number [0 - 3]
/// (Data8) NOS – Output bit field [0x00 – 0x0F]
/// (Data8) SPEED – Specify output speed [-100 – 100 %]
/// Dispatch status Unchanged
/// Description This function enables setting the output percentage speed on the output ports. This modes automatically enables speed control, which means the system will automa-tically adjust the power to keep the specified speed.
/// </remarks>
public static async Task SetSpeed(ISocket socket, ChainLayer layer, OutputPortFlag ports, int speed, bool requireReply = true)
{
if (speed < -100 || speed > 100)
{
throw new ArgumentException(nameof(speed), "[-100 and 100]");
}
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(requireReply ? CommandType.DIRECT_COMMAND_REPLY : CommandType.DIRECT_COMMAND_NO_REPLY))
{
cb.OpCode(OP.opOUTPUT_SPEED);
cb.SHORT((int)layer);
cb.SHORT((int)ports);
cb.PAR8(speed);
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
/// <summary>
/// Repeats playing a sound file on the brick at a given volume.
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="volume">Specify volume for playback, [0 - 100]</param>
/// <param name="filePath">FilePath to sound file: ../prjs/myproject/file.rsf</param>
/// <remarks>
/// Instruction opSound (CMD, …)
/// Opcode 0x94
/// Arguments (Data8) CMD => Specific command parameter documented below
/// Dispatch status Unchanged
/// Description Sound control entry
/// CMD: REPEAT = 0x03
/// Arguments
/// (Data8) VOLUME – Specify volume for playback, [0 - 100]
/// (Data8) NAME – First character in filename (Character string)
/// </remarks>
internal static async Task Repeat(ISocket socket, int volume, string filePath)
{
if (volume < 0 || volume > 100)
{
throw new ArgumentOutOfRangeException("Volume must be between 0 and 100", "volume");
}
//soundfiles will not play when extension in path
filePath = Path.ChangeExtension(filePath, null);
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_NO_REPLY))
{
cb.OpCode(OP.opSOUND);
cb.Raw((byte)SOUND_SUBCODE.REPEAT);
cb.PAR8(volume); // (Data8) VOLUME
cb.PARS(filePath); // (Data8) NAME – First character in filename (Character string) ?
cmd = cb.ToCommand();
}
await socket.Execute(cmd);
}
/// <summary>
/// Enables a program to read all available devices on input chain
/// </summary>
/// <param name="socket">socket for executing command to brick</param>
/// <param name="maximum">Maximum number of devices types (Normally 32)</param>
/// <returns>List of devices on chain and ports</returns>
/// <remarks>
/// Instruction opInput_Device_List (LENGTH, ARRAY, CHANGED)
/// Opcode 0x98
/// Arguments (Data8) LENGTH – Maximum number of devices types (Normally 32)
/// Return (Data8) ARRAY – First element of data8 array of types (Normally 32)
/// (Data8) CHANGED – Changed status
/// Dispatch status Unchanged
/// Description Enables a program to read all available devices on input chain
/// </remarks>
internal static async Task <IEnumerable <PortInfo> > PortScan(ISocket socket, ushort maximum = 32)
{
if (maximum < 1 || maximum > 32)
{
throw new ArgumentException("Maximum number of devices must be between 1 and 32", nameof(maximum));
}
Command cmd = null;
using (CommandBuilder cb = new CommandBuilder(CommandType.DIRECT_COMMAND_REPLY, maximum, 0))
{
cb.OpCode(OP.opINPUT_DEVICE_LIST);
cb.PAR8(maximum);
cb.GlobalIndex(0);
cb.GlobalIndex(1);
cmd = cb.ToCommand();
}
Response response = await socket.Execute(cmd);
List <PortInfo> list = new List <PortInfo>();
byte[] data = response.PayLoad;
for (int i = 0; i < maximum; i++) //32 = 4 bricks * 8 ports.
{
int d = data[i];
if (data[i] <= 120 && Enum.IsDefined(typeof(DeviceType), d))
{
list.Add(new PortInfo(i, (DeviceType)d));
}
else
{
list.Add(new PortInfo(i, d));
}
}
//TODO full return includes change status
//(Data8) ARRAY – First element of data8 array of types (Normally 32) (Data8) CHANGED – Changed status
return(list);
}
