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, ""); } } }