private List <byte> GetDataRequestBytesForWriteDataTables(WriteDataTables wdt)
{
List <byte> result = new List <byte>();
result.AddRange(BitConverter.GetBytes(wdt.NumberOfBytesToWriteInRow));
result.AddRange(BitConverter.GetBytes(wdt.NumberOfRowsToWrite));
result.AddRange(BitConverter.GetBytes(Convert.ToUInt32(wdt.RowSizeInBytes)));
result.AddRange(new byte[24]);
try
{
if (wdt.NumberOfBytesToWriteInRow * wdt.NumberOfRowsToWrite == wdt.Values.Count)
{
result.AddRange(wdt.Values);
}
else
{
throw new Exception();
}
}
catch
{
throw new ComDriveExceptions("Invalid write values",
ComDriveExceptions.ComDriveException.UserInputException);
}
return(result);
}
private void SplitAndWriteDataTableRowSizeExceedPLCBuffer(ref List <ReadWriteRequest> joinRequests,
ushort maximumAvailableBytesNo, string parentID)
{
WriteDataTables wdt = joinRequests[0] as WriteDataTables;
List <ReadWriteRequest> splitWDTList = new List <ReadWriteRequest>();
ushort remainingRowsNo = wdt.NumberOfRowsToWrite;
ushort maxAvailableWriteRowBytesNo = maximumAvailableBytesNo;
ushort remainingWriteRowByteNo = (ushort)wdt.NumberOfBytesToWriteInRow;
uint startAddress = wdt.StartAddress;
int sourceIndex = 0;
wdt.RaiseProgressEvent(0, wdt.NumberOfRowsToWrite * wdt.NumberOfBytesToWriteInRow,
RequestProgress.en_NotificationType.SetMinMax, 0, "");
wdt.RaiseProgressEvent(0, wdt.NumberOfRowsToWrite * wdt.NumberOfBytesToWriteInRow,
RequestProgress.en_NotificationType.ProgressChanged, 0, "");
while (remainingRowsNo > 0)
{
while (remainingWriteRowByteNo > 0)
{
byte[] values = new byte[maxAvailableWriteRowBytesNo];
Array.Copy(wdt.Values.ToArray(), sourceIndex, values, 0, maxAvailableWriteRowBytesNo);
sourceIndex += maxAvailableWriteRowBytesNo;
WriteDataTables tmpWDT = new WriteDataTables(startAddress, maxAvailableWriteRowBytesNo, 1,
(ushort)wdt.RowSizeInBytes, values.ToList(), wdt.SubCommand);
splitWDTList.Add(tmpWDT);
ReadWriteDataTable(ref splitWDTList, parentID);
splitWDTList.Clear();
startAddress += maxAvailableWriteRowBytesNo;
remainingWriteRowByteNo -= maxAvailableWriteRowBytesNo;
if (remainingWriteRowByteNo < maxAvailableWriteRowBytesNo && remainingWriteRowByteNo > 0)
{
maxAvailableWriteRowBytesNo = remainingWriteRowByteNo;
}
}
remainingRowsNo--;
maxAvailableWriteRowBytesNo = maximumAvailableBytesNo;
remainingWriteRowByteNo = (ushort)wdt.NumberOfBytesToWriteInRow;
startAddress =
(uint)(wdt.StartAddress + (wdt.NumberOfRowsToWrite - remainingRowsNo) * wdt.RowSizeInBytes);
wdt.RaiseProgressEvent(0, wdt.NumberOfRowsToWrite * wdt.NumberOfBytesToWriteInRow,
RequestProgress.en_NotificationType.ProgressChanged,
(wdt.NumberOfRowsToWrite - remainingRowsNo) * wdt.NumberOfBytesToWriteInRow, "");
}
wdt.RaiseProgressEvent(0, wdt.NumberOfRowsToWrite * wdt.NumberOfBytesToWriteInRow,
RequestProgress.en_NotificationType.Completed, wdt.NumberOfRowsToWrite * wdt.NumberOfBytesToWriteInRow,
"");
joinRequests[0].ResponseValues = String.Empty;
}
private bool WriteDataTableFitsThePlcBuffer(ReadWriteRequest readWriteRequest)
{
WriteDataTables wdt = readWriteRequest as WriteDataTables;
int wdtRequestSize = Utils.Lengths.LENGTH_HEADER_AND_FOOTER +
Utils.Lengths.LENGTH_WRITE_DATA_TABLE_DETAILS +
wdt.NumberOfBytesToWriteInRow * wdt.NumberOfRowsToWrite;
return(wdtRequestSize <= PLCVersion.PlcBuffer);
}
private void SplitAndWriteDataTableRows(ref List <ReadWriteRequest> joinRequests, ushort maximumAvailableBytesNo,
string parentID)
{
WriteDataTables wdt = joinRequests[0] as WriteDataTables;
List <ReadWriteRequest> splitWDTList = new List <ReadWriteRequest>();
int sourceIndex = 0;
int length = 0;
ushort availableRowsNo = (ushort)(maximumAvailableBytesNo / wdt.NumberOfBytesToWriteInRow);
int remainingRowsNo = wdt.NumberOfRowsToWrite;
uint startAddress = wdt.StartAddress;
wdt.RaiseProgressEvent(0, wdt.NumberOfRowsToWrite * wdt.NumberOfBytesToWriteInRow,
RequestProgress.en_NotificationType.SetMinMax, 0, "");
wdt.RaiseProgressEvent(0, wdt.NumberOfRowsToWrite * wdt.NumberOfBytesToWriteInRow,
RequestProgress.en_NotificationType.ProgressChanged, 0, "");
while (remainingRowsNo > 0)
{
length = wdt.NumberOfBytesToWriteInRow * availableRowsNo;
byte[] writeValues = new byte[length];
Array.Copy(wdt.Values.ToArray(), sourceIndex, writeValues, 0, length);
sourceIndex += length;
WriteDataTables tmpWDT = new WriteDataTables(startAddress, wdt.NumberOfBytesToWriteInRow,
availableRowsNo, (ushort)(wdt.RowSizeInBytes), writeValues.ToList(), wdt.SubCommand);
splitWDTList.Add(tmpWDT);
ReadWriteDataTable(ref splitWDTList, parentID);
splitWDTList.Clear();
startAddress += (uint)(availableRowsNo * wdt.RowSizeInBytes);
remainingRowsNo -= availableRowsNo;
if (remainingRowsNo < availableRowsNo && remainingRowsNo > 0)
{
availableRowsNo = (ushort)remainingRowsNo;
}
wdt.RaiseProgressEvent(0, wdt.NumberOfRowsToWrite * wdt.NumberOfBytesToWriteInRow,
RequestProgress.en_NotificationType.ProgressChanged,
(wdt.NumberOfRowsToWrite - remainingRowsNo) * wdt.NumberOfBytesToWriteInRow, "");
}
wdt.RaiseProgressEvent(0, wdt.NumberOfRowsToWrite * wdt.NumberOfBytesToWriteInRow,
RequestProgress.en_NotificationType.Completed, wdt.NumberOfRowsToWrite * wdt.NumberOfBytesToWriteInRow,
"");
joinRequests[0].ResponseValues = String.Empty;
}
private void SplitAndWriteDataTable(ref List <ReadWriteRequest> joinRequests, string parentID)
{
WriteDataTables wdt = joinRequests[0] as WriteDataTables;
ushort maximumAvailableBytesNo = (ushort)(PLCVersion.PlcBuffer - Utils.Lengths.LENGTH_HEADER_AND_FOOTER -
Utils.Lengths.LENGTH_WRITE_DATA_TABLE_DETAILS);
//Test if the no of bytes in one write Row doesn't exceed the plcBuffer
if (wdt.NumberOfBytesToWriteInRow > maximumAvailableBytesNo)
{
SplitAndWriteDataTableRowSizeExceedPLCBuffer(ref joinRequests, maximumAvailableBytesNo, parentID);
}
else //We can write atleast 1 complete row
{
SplitAndWriteDataTableRows(ref joinRequests, maximumAvailableBytesNo, parentID);
}
}
private static string getRDTorWDTRequestsPropertiesString(ReadWriteRequest readWriteRequest)
{
string result = String.Empty;
// The string results format is:
// RequestType:StartAddress-NumberOfRowsToRead/Write-RowSizeInBytes-NumberOfBytesToRead/WriteInRow.
// ':' - is the delimitator for the requestType
// '-' - is the delimitator between request properties.
// '.' - used to mark the end of the request properties.
// Example: RDT:1-10-20-10.
if (readWriteRequest is ReadDataTables)
{
ReadDataTables rdt = readWriteRequest as ReadDataTables;
result += "RDT:" + rdt.StartAddress.ToString() +
"-" + rdt.NumberOfRowsToRead.ToString() +
"-" + rdt.RowSizeInBytes.ToString() +
"-" + rdt.NumberOfBytesToReadInRow.ToString() +
"-" + rdt.PartOfProject.ToString() +
"-" + rdt.SubCommand.ToString() +
".";
}
else
{
WriteDataTables wdt = readWriteRequest as WriteDataTables;
result += "WDT" + wdt.StartAddress.ToString() +
"-" + wdt.NumberOfRowsToWrite.ToString() +
"-" + wdt.RowSizeInBytes.ToString() +
"-" + wdt.NumberOfBytesToWriteInRow.ToString() +
"-" + wdt.SubCommand.ToString() +
".";
}
return(result);
}
internal void CheckReadWriteRequests(ReadWriteRequest[] values)
{
foreach (ReadWriteRequest rw in values)
{
if (rw is ReadOperands)
{
ReadOperands ro = rw as ReadOperands;
if (ro == null)
{
throw new ComDriveExceptions("Read Operand Request cannot be Null",
ComDriveExceptions.ComDriveException.UserInputException);
}
if (ro.NumberOfOperands <= 0)
{
throw new ComDriveExceptions("The number of Operands to read cannot be less than 1",
ComDriveExceptions.ComDriveException.UserInputException);
}
if ((ro.StartAddress < 0) ||
(ro.StartAddress + ro.NumberOfOperands > m_plcVersion.OperandCount(ro.OperandType)))
{
throw new ComDriveExceptions(
"Operand start address and end must be non-negative and less than the operand count on the PLC",
ComDriveExceptions.ComDriveException.OperandAddressOutOfRange);
}
}
else if (rw is WriteOperands)
{
WriteOperands wo = rw as WriteOperands;
if (wo == null)
{
throw new ComDriveExceptions("Write Operand Request cannot be Null",
ComDriveExceptions.ComDriveException.UserInputException);
}
if (wo.NumberOfOperands <= 0)
{
throw new ComDriveExceptions("The number of Operands to write cannot be less than 1",
ComDriveExceptions.ComDriveException.UserInputException);
}
if (wo.Values == null)
{
throw new ComDriveExceptions("Values cannot be Null in a Write Operands request",
ComDriveExceptions.ComDriveException.UserInputException);
}
if (wo.NumberOfOperands > wo.Values.Length)
{
throw new ComDriveExceptions(
"The number of Operands to write is larger than the number of values that were entered",
ComDriveExceptions.ComDriveException.UserInputException);
}
if ((wo.StartAddress < 0) ||
(wo.StartAddress + wo.NumberOfOperands > m_plcVersion.OperandCount(wo.OperandType)))
{
throw new ComDriveExceptions(
"Operand start address and end must be non-negative and less than the operand count on the PLC",
ComDriveExceptions.ComDriveException.OperandAddressOutOfRange);
}
}
else if (rw is ReadDataTables)
{
ReadDataTables rdt = rw as ReadDataTables;
if (rdt == null)
{
throw new ComDriveExceptions("Read DataTables Request cannot be Null",
ComDriveExceptions.ComDriveException.UserInputException);
}
if ((rdt.NumberOfBytesToReadInRow <= 0) && (rdt.NumberOfRowsToRead <= 0) &&
(rdt.RowSizeInBytes <= 0) && (rdt.StartAddress < 0))
{
throw new ComDriveExceptions("Invalid request parameters in Read DataTables Request",
ComDriveExceptions.ComDriveException.UserInputException);
}
}
else if (rw is WriteDataTables)
{
WriteDataTables wdt = rw as WriteDataTables;
if (wdt == null)
{
throw new ComDriveExceptions("Write DataTables Request cannot be Null",
ComDriveExceptions.ComDriveException.UserInputException);
}
if ((wdt.NumberOfBytesToWriteInRow <= 0) && (wdt.NumberOfRowsToWrite <= 0) &&
(wdt.RowSizeInBytes <= 0) && (wdt.StartAddress < 0))
{
throw new ComDriveExceptions("Invalid request parameters in Read DataTables Request",
ComDriveExceptions.ComDriveException.UserInputException);
}
}
else if (rw == null)
{
throw new ComDriveExceptions("One or more ReadWriteRequest object are Null",
ComDriveExceptions.ComDriveException.UserInputException);
}
else if (rw is BinaryRequest)
{
// Nothing specific to check
}
else
{
throw new ComDriveExceptions("Unsupported request",
ComDriveExceptions.ComDriveException.UnsupportedCommand);
}
}
}
private void ReadWriteDataTable(ref List <ReadWriteRequest> dataTableDRs, string parentID)
{
PComB pComB = new PComB();
BinaryCommand binaryCommand;
ReadDataTables rdt = null;
WriteDataTables wdt = null;
if (this.BreakFlag)
{
throw new ComDriveExceptions("Request aborted by user",
ComDriveExceptions.ComDriveException.AbortedByUser);
}
foreach (ReadWriteRequest rwr in dataTableDRs)
{
if (this.BreakFlag)
{
throw new ComDriveExceptions("Request aborted by user",
ComDriveExceptions.ComDriveException.AbortedByUser);
}
if (rwr is ReadDataTables)
{
binaryCommand = BinaryCommand.ReadDataTables;
rdt = rwr as ReadDataTables;
rdt.RaiseProgressEvent(0, rdt.NumberOfBytesToReadInRow * rdt.NumberOfRowsToRead,
RequestProgress.en_NotificationType.SetMinMax, 0, "");
rdt.RaiseProgressEvent(0, rdt.NumberOfBytesToReadInRow * rdt.NumberOfRowsToRead,
RequestProgress.en_NotificationType.ProgressChanged, 0, "");
if (rdt.PartOfProject)
{
binaryCommand = BinaryCommand.ReadPartOfProjectDataTables;
}
List <List <byte> > readDataTablesDataRequestBytes = new List <List <byte> >();
readDataTablesDataRequestBytes.Add(GetDataRequestBytesForReadDataTables(rdt));
if (rdt != null)
{
byte[] cmdDetails = new byte[6];
Array.Copy(BitConverter.GetBytes(rdt.StartAddress), cmdDetails, 4);
pComB.BuildBinaryCommand((byte)UnitId, binaryCommand, cmdDetails, dataTableDRs,
readDataTablesDataRequestBytes, (byte)rdt.SubCommand);
BinaryMessage receivedMessage =
ReceiveMessage(pComB, readDataTablesDataRequestBytes, parentID) as BinaryMessage;
}
rdt.RaiseProgressEvent(0, rdt.NumberOfBytesToReadInRow * rdt.NumberOfRowsToRead,
RequestProgress.en_NotificationType.Completed,
rdt.NumberOfBytesToReadInRow * rdt.NumberOfRowsToRead, "");
}
if (rwr is WriteDataTables)
{
binaryCommand = BinaryCommand.WriteDataTables;
wdt = rwr as WriteDataTables;
wdt.RaiseProgressEvent(0, wdt.NumberOfBytesToWriteInRow * wdt.NumberOfRowsToWrite,
RequestProgress.en_NotificationType.SetMinMax, 0, "");
wdt.RaiseProgressEvent(0, wdt.NumberOfBytesToWriteInRow * wdt.NumberOfRowsToWrite,
RequestProgress.en_NotificationType.ProgressChanged, 0, "");
List <List <byte> > writeDataTablesDataRequestBytes = new List <List <byte> >();
writeDataTablesDataRequestBytes.Add(GetDataRequestBytesForWriteDataTables(wdt));
if (wdt != null)
{
byte[] cmdDetails = new byte[6];
Array.Copy(BitConverter.GetBytes(wdt.StartAddress), cmdDetails, 4);
pComB.BuildBinaryCommand((byte)UnitId, binaryCommand, cmdDetails, dataTableDRs,
writeDataTablesDataRequestBytes, (byte)wdt.SubCommand);
BinaryMessage receivedMessage = ReceiveMessage(pComB, null, parentID) as BinaryMessage;
}
wdt.RaiseProgressEvent(0, wdt.NumberOfBytesToWriteInRow * wdt.NumberOfRowsToWrite,
RequestProgress.en_NotificationType.ProgressChanged,
wdt.NumberOfBytesToWriteInRow * wdt.NumberOfRowsToWrite, "");
}
}
}
