private void PrintControlWord(Socket s)
{
ControlWord cw = new ControlWord();
cw.Read(s);
var bitArray19 = new BitArray(new bool[8] {
cw.Bit00, cw.Bit01, cw.Bit02, cw.Bit03, cw.Bit04, cw.Bit05, cw.Bit06, cw.Bit07
});
var bitArray20 = new BitArray(new bool[8] {
cw.Bit08, cw.Bit09, cw.Bit10, cw.Bit11, cw.Bit12, cw.Bit13, cw.Bit14, cw.Bit15
});
byte[] byte19 = new byte[1];
bitArray19.CopyTo(byte19, 0);
byte[] byte20 = new byte[1];
bitArray20.CopyTo(byte20, 0);
Debug.WriteLine("");
Debug.WriteLine("ControlWord");
Debug.WriteLine($"Byte 19: {byte19[0]}");
Debug.WriteLine($"0: {cw.Bit00}, 1: {cw.Bit01}, 2: {cw.Bit02}, 3: {cw.Bit03}, 4: {cw.Bit04}, 5: {cw.Bit05}, 6: {cw.Bit06}, 7: {cw.Bit07}");
Debug.WriteLine($"Byte 20: {byte20[0]}");
Debug.WriteLine($"8: {cw.Bit08}, 9: {cw.Bit09}, 10: {cw.Bit10}, 11: {cw.Bit11}, 12: {cw.Bit12}, 13: {cw.Bit13}, 14: {cw.Bit14}, 15: {cw.Bit15}");
Debug.WriteLine("");
}
public bool Homing(string hostIp, int port)
{
Socket s = ModbusSocket.GetConnection(hostIp, port);
ModesOfOperation modesOfOperation = new ModesOfOperation();
modesOfOperation.Write(s, ModesOfOperation.ModesEnum.Homing);
while (modesOfOperation.ReadDisplay(s) != ModesOfOperation.ModesEnum.Homing)
{
Thread.Sleep(100);
}
ControlWord controlWord = new ControlWord();
// Byte 19: 31
controlWord.Bit00 = true; // 1
controlWord.Bit01 = true; // 2
controlWord.Bit02 = true; // 4
controlWord.Bit03 = true; // 8
controlWord.Bit04 = true; // 16
controlWord.Write(s);
StatusWord statusWord = new StatusWord();
while (!(statusWord.Bit00 && statusWord.Bit01 && statusWord.Bit02 && statusWord.Bit05 && // 39
statusWord.Bit09 && statusWord.Bit10 && statusWord.Bit12)) // 22
{
statusWord.Read(s);
Thread.Sleep(100);
}
return(true);
}
public ControlWord GetControlWord(string hostIp, int port)
{
Socket s = ModbusSocket.GetConnection(hostIp, port);
ControlWord controlWord = new ControlWord();
controlWord.Read(s);
return(controlWord);
}
/// <summary>
/// Program the onboard filters to capture data and reduce it to a baseband signal with the given spectral width.
/// This function will automatically set the filter parameters and decimation factors.
/// For greater control over the filtering process, the filters can be specified manually by using the pb_setup_cic() and pb_setup_fir() functions.
/// </summary>
/// <param name="spectralWidth">Desired spectral width (in MHz) of the stored baseband data.
/// The decimation factor used is the return value of this function, so that can be checked to determine the exact spectral width used. If the FIR filter is used, this value must be the ADC clock divided by a multiple of 8.
/// The value will be rounded appropriately if this condition is not met.</param>
/// <param name="scanRepetition">Number of scans intended to be performed. This number is used only for internal rounding purposes.
/// The actual number of scans performed is determined entirely by how many times the scan_trigger control line is enabled in the pulse program. However, if more scans are performed than specified here, there is a chance that the values stored in RAM will overflow.</param>
/// <param name="cmd">This paramater provides additional options for this function. Multiple options can be sent by ORing them together. If you do not wish to invoke any of the available options, use the number zero for this field. Valid options are:
/// <list>
/// <item >BYPASS_FIR - Incoming data will not pass through the FIR filter. This eliminates the need to decimate by a multiple of 8. This is useful to obtain large spetral widths, or in circumstances where the FIR is deemed unecessary. Please see the RadioProcessor manual for more information about this option.</item>
/// <item >NARROW_BW - Configure the CIC filter so that it will have a narrower bandwidth (the CIC filter will be configured to have three stages rather than the default of one). Please see your board's product manual for more specific information on this feature.</item>
/// </list>
/// </param>
/// <returns></returns>
public int SetupFilters(double spectralWidth, int scanRepetition, ControlWord cmd)
{
lock (this)
{
int ret = NativeMethods.pb_setup_filters(spectralWidth, scanRepetition, (int)cmd);
if (ret < 0)
{
throw new SpinAPIException(Error);
}
return(ret);
}
}
private string GetColorByCommandWord(ControlWord cw, string parameter)
{
foreach (var rule in Rules)
{
if (rule.Address == cw.Address &&
rule.Direction == cw.Direction &&
rule.Subaddress == cw.Subaddress &&
rule.Length == cw.Length)
{
return((parameter == "Color") ? rule.Color : rule.Name);
}
}
return((parameter == "Color") ? "Black" : "Unknown");
}
private void ShutDown(Socket s)
{
ControlWord controlWord = new ControlWord();
// Byte 19: 6
controlWord.Bit01 = true; // 2
controlWord.Bit02 = true; // 4
controlWord.Write(s);
StatusWord statusWord = new StatusWord();
while (!(statusWord.Bit00 && statusWord.Bit05 && // 33
statusWord.Bit09)) // 2
{
statusWord.Read(s);
Thread.Sleep(100);
}
}
private void EnableOperation(Socket s)
{
ControlWord controlWord = new ControlWord();
// Byte 19: 15
controlWord.Bit00 = true; // 1
controlWord.Bit01 = true; // 2
controlWord.Bit02 = true; // 4
controlWord.Bit03 = true; // 8
controlWord.Write(s);
StatusWord statusWord = new StatusWord();
while (!(statusWord.Bit00 && statusWord.Bit01 && statusWord.Bit02 && statusWord.Bit05 && // 39
statusWord.Bit09)) // 2
{
statusWord.Read(s);
Thread.Sleep(100);
}
}
private DataRecord ParseLine(string line, int index)
{
var parts = line.Split(CommentDelimiter)[0].Split(TabDelimiter);
if (parts.Length == 42)
{
var cw1 = new ControlWord(Word(parts, Control1));
DataRecordBuilder builder = new DataRecordBuilder(
index: index,
monitorTime: BuildTime(int.Parse(parts[TimeLo]), int.Parse(parts[TimeHi])),
channel: (BusChannel)int.Parse(parts[BusChannel]),
error: StatusToError(Word(parts, Errors), Word(parts, Response1)),
cw1: cw1,
cw2: new ControlWord(Word(parts, Control2)),
rw1: new ResponseWord(Word(parts, Response1)),
rw2: new ResponseWord(Word(parts, Response2))
);
if (cw1.IsCommand)
{
if (cw1.CommandCode.HasDataWord())
{
builder.Data(Word(parts, DataStart));
}
}
else
{
builder.Data(Enumerable.Range(0, cw1.Length).Select(x => Word(parts, DataStart + x)));
}
return(builder.GetRecord());
}
else
{
return(null);
}
}
public void SetControlWord(string hostIp, int port, [FromBody] ControlWord controlWord)
{
Socket s = ModbusSocket.GetConnection(hostIp, port);
controlWord.Write(s);
}
public void CheckNotACommand()
{
var cw = new ControlWord(1, DataDirection.R, 1, 5);
Assert.ThrowsException <InvalidOperationException>(() => cw.CommandCode);
}
public async Task <bool> MoveToTarget(string ip, int port)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
var controlWordEP = new ControlWordController();
var statusWordEP = new StatusWordController();
var motorEP = new MotorController();
uint acceleration = Convert.ToUInt32(Acceleration * Precision);
uint deceleration = Convert.ToUInt32(Deceleration * Precision);
uint velocity = Convert.ToUInt32(TargetVelocity * Precision);
int targetPosition = Convert.ToInt32(TargetPosition * Precision);
// Set operation mode
motorEP.SetOperationMode(ip, port, 1);
Stopwatch operationMode = new Stopwatch();
operationMode.Start();
while (motorEP.GetOperationModeDisplay(ip, port) != 1)
{
Debug.WriteLine("OPM wrong");
await Delay(10);
}
operationMode.Stop();
Debug.WriteLine($"OperationMode Set: {operationMode.ElapsedMilliseconds}");
// Check if start is reseted
ControlWord controlWord = new ControlWord();
controlWord = controlWordEP.GetControlWord(ip, port);
if (controlWord.Bit04)
{
Debug.WriteLine("Reset bit 4, Z190");
controlWord.Bit04 = false;
controlWordEP.SetControlWord(ip, port, controlWord);
}
// Set relative positioning
if (RelativePosition)
{
if (!controlWord.Bit06)
{
controlWord.Bit06 = true;
controlWordEP.SetControlWord(ip, port, controlWord);
// Check relative positioning is set (Bit 6)
controlWord = controlWordEP.GetControlWord(ip, port);
if (controlWord.Bit06 != RelativePosition)
{
return(false);
}
}
}
else
{
if (controlWord.Bit06)
{
controlWord.Bit06 = false;
controlWordEP.SetControlWord(ip, port, controlWord);
// Check relative positioning is set (Bit 6)
controlWord = controlWordEP.GetControlWord(ip, port);
if (controlWord.Bit06 != RelativePosition)
{
return(false);
}
}
}
int positionWindow = motorEP.GetPositionWindow(ip, port);
// Set acceleration
motorEP.SetProfileAcceleration(ip, port, acceleration);
if (acceleration != motorEP.GetProfileAcceleration(ip, port))
{
return(false);
}
// Set deceleration
motorEP.SetProfileDeceleration(ip, port, deceleration);
if (deceleration != motorEP.GetProfileDeceleration(ip, port))
{
return(false);
}
// Set velocity
motorEP.SetProfileVelocity(ip, port, velocity);
if (velocity != motorEP.GetProfileVelocity(ip, port))
{
return(false);
}
// Set target position
motorEP.SetTargetPosition(ip, port, targetPosition);
if (targetPosition != motorEP.GetTargetPosition(ip, port))
{
return(false);
}
// Check controlWord bit 4 (Start)
controlWord = controlWordEP.GetControlWord(ip, port);
if (controlWord.Bit04)
{
Debug.WriteLine("Reset bit 4 Z243");
controlWord.Bit04 = false;
controlWordEP.SetControlWord(ip, port, controlWord);
await Delay(50);
}
////////////////// Debug
stopwatch.Stop();
Debug.WriteLine($"Instruction Time: {stopwatch.ElapsedMilliseconds}");
stopwatch = new Stopwatch();
stopwatch.Start();
//////////////////
// Start
controlWord.Bit04 = true;
controlWordEP.SetControlWord(ip, port, controlWord);
await Delay(50);
// Check statusWord bit 12
while (!NewTargetSet(statusWordEP.GetStatusWord(ip, port)))
{
Debug.WriteLine("Check bit 12");
await Delay(50);
}
// Reset start
controlWord.Bit04 = false;
controlWordEP.SetControlWord(ip, port, controlWord);
while (!TargetReached(statusWordEP.GetStatusWord(ip, port)) && !InPositionWindow(targetPosition, motorEP.GetActualPosition(ip, port), positionWindow))
{
Stopwatch targetReached = new Stopwatch();
targetReached.Start();
if (TargetReached(statusWordEP.GetStatusWord(ip, port)) && !InPositionWindow(targetPosition, motorEP.GetActualPosition(ip, port), positionWindow))
{
Debug.WriteLine("--------------------------");
Debug.WriteLine("-----------Error----------");
Debug.WriteLine("--------------------------");
}
targetReached.Stop();
Debug.WriteLine($"Target check time: {targetReached.ElapsedMilliseconds}");
await Delay(50);
}
stopwatch.Stop();
Debug.WriteLine($"Movement Time: {stopwatch.ElapsedMilliseconds}");
return(true);
}
