private IMessage ReceiveMessage(PComB pComB, List <List <byte> > readDataTablesDataRequestBytes, string parentID) { if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } GuidClass guid = new GuidClass(); lock (guid) { Channel.Send(pComB.MessageToPLC as byte[], ReceiveBytes, guid, parentID, "Binary Protocol - Read/Write Data Tables", PlcGuid); Monitor.Wait(guid); } if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } PlcResponseMessage plcResponseMessage; lock (_lockObj) { plcResponseMessage = m_responseMessageQueue[guid]; m_responseMessageQueue.Remove(guid); } if (plcResponseMessage.comException == CommunicationException.Timeout) { throw new ComDriveExceptions("Cannot communicate with the PLC with the specified UnitID!", ComDriveExceptions.ComDriveException.CommunicationTimeout); } pComB.DisAssembleBinaryResult(plcResponseMessage.responseBytesMessage, null); return(pComB.MessageFromPLC); }
private void SplitAndSendBinaryData(ReadWriteRequest binaryRequest, string parentID) { BinaryRequest binRequest = binaryRequest as BinaryRequest; PComB pComB = new PComB(); int offsetInBuffer = 0; int chunkSize = 0; int outgoingBufferSize = 0; int currentAddress = binRequest.Address; int messageKey = binRequest.MessageKey; const int MIN_TIME_BETWEEN_CHUNKS_WRITE = 20; GuidClass guid; PlcResponseMessage plcResponseMessage; byte[] outgoingChunk; if (binRequest.OutgoingBuffer != null) { outgoingBufferSize = binRequest.OutgoingBuffer.Length; } switch (binRequest.CommandCode) { case 0x1: case 0x41: case 75: case 5: if ((binRequest.OutgoingBuffer == null) || (outgoingBufferSize == 0)) { binRequest.RaiseProgressEvent(0, binRequest.ElementsCount, RequestProgress.en_NotificationType.SetMinMax, 0, ""); binRequest.RaiseProgressEvent(0, binRequest.ElementsCount, RequestProgress.en_NotificationType.ProgressChanged, 0, ""); if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } if (binRequest.WaitForIdle) { WaitForFlashIdle((byte)UnitId, parentID); } byte[] arrivedData = new byte[binRequest.ElementsCount]; while (offsetInBuffer < binRequest.ElementsCount) { int sizeOfDataToCopy; if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } chunkSize = binRequest.ElementsCount - offsetInBuffer; sizeOfDataToCopy = chunkSize; if (chunkSize > PLCVersion.PlcBuffer - Utils.Lengths.LENGTH_HEADER_AND_FOOTER) { chunkSize = PLCVersion.PlcBuffer - Utils.Lengths.LENGTH_HEADER_AND_FOOTER; } if (binRequest.ChunkSizeAlignment != 0) { // Chop the end of the chunk to fit into aligment chunkSize -= (chunkSize % binRequest.ChunkSizeAlignment); } if (binRequest.FlashBankSize != 0) { // Chop the end of the chunk so the burned data will not be written on 2 different flash banks if (((currentAddress + chunkSize) / binRequest.FlashBankSize) != (currentAddress / binRequest.FlashBankSize)) { chunkSize -= ((currentAddress + chunkSize) % binRequest.FlashBankSize); } } if (chunkSize == 0) { chunkSize = binRequest.ChunkSizeAlignment; } else { sizeOfDataToCopy = chunkSize; } pComB.BuildBinaryCommand((byte)UnitId, messageKey, binRequest.CommandCode, binRequest.SubCommand, currentAddress, chunkSize, 0, new byte[0]); guid = new GuidClass(); lock (guid) { Channel.Send(pComB.MessageToPLC as byte[], ReceiveBytes, guid, parentID, "Binary Protocol - Binary Request (" + binRequest.CommandCode.ToString() + ")", PlcGuid); Monitor.Wait(guid); } if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } lock (_lockObj) { plcResponseMessage = m_responseMessageQueue[guid]; m_responseMessageQueue.Remove(guid); } if (plcResponseMessage.comException == CommunicationException.Timeout) { throw new ComDriveExceptions( "Cannot communicate with the PLC with the specified UnitID!", ComDriveExceptions.ComDriveException.CommunicationTimeout); } binRequest.IncomingBuffer = new byte[plcResponseMessage.responseBytesMessage.Length - Utils.Lengths.LENGTH_HEADER_AND_FOOTER]; if (binRequest.IncomingBuffer.Length > 0) { Array.Copy(plcResponseMessage.responseBytesMessage, Utils.Lengths.LENGTH_HEADER, binRequest.IncomingBuffer, 0, binRequest.IncomingBuffer.Length); } Array.Copy(binRequest.IncomingBuffer, 0, arrivedData, offsetInBuffer, sizeOfDataToCopy); if (plcResponseMessage.responseBytesMessage[12] == 0xFF) { binRequest.PlcReceiveResult = (BinaryRequest.ePlcReceiveResult)plcResponseMessage.responseBytesMessage[13]; } else if (plcResponseMessage.responseBytesMessage[12] == binRequest.CommandCode + 0x80) { binRequest.PlcReceiveResult = BinaryRequest.ePlcReceiveResult.Sucsess; } else { binRequest.PlcReceiveResult = BinaryRequest.ePlcReceiveResult.Unknown; } offsetInBuffer += sizeOfDataToCopy; currentAddress += sizeOfDataToCopy; messageKey++; // Message Key is % 256. The BuildBinaryCommand takes care of that binRequest.MessageKey = messageKey; binRequest.MessageKey = binRequest.MessageKey % 256; if (binRequest.MessageKey == 0) { messageKey = binRequest.CycledMessageKey; binRequest.MessageKey = messageKey; } if (binRequest.WaitForIdle) { WaitForFlashIdle((byte)UnitId, parentID); } binRequest.RaiseProgressEvent(0, binRequest.ElementsCount, RequestProgress.en_NotificationType.ProgressChanged, offsetInBuffer, ""); } binRequest.IncomingBuffer = arrivedData; binRequest.RaiseProgressEvent(0, binRequest.ElementsCount, RequestProgress.en_NotificationType.Completed, binRequest.ElementsCount, ""); } else { if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } if (binRequest.WaitForIdle) { WaitForFlashIdle((byte)UnitId, parentID); } binRequest.RaiseProgressEvent(0, outgoingBufferSize, RequestProgress.en_NotificationType.SetMinMax, 0, ""); binRequest.RaiseProgressEvent(0, outgoingBufferSize, RequestProgress.en_NotificationType.ProgressChanged, 0, ""); //if (binRequest.SubCommand == (int)MemoryType.InternalFlash && binRequest.CommandCode == 0x41) //{ // if ((binRequest.OutgoingBuffer.Length % 8) != 0) // { // byte[] binDataToBurn = new byte[binRequest.OutgoingBuffer.Length + 8 - binRequest.OutgoingBuffer.Length % 8]; // for (int i = binRequest.OutgoingBuffer.Length; i < binDataToBurn.Length; i++) // { // binDataToBurn[i] = 0xFF; // } // Array.Copy(binRequest.OutgoingBuffer, 0, binDataToBurn, 0, binRequest.OutgoingBuffer.Length); // binRequest.OutgoingBuffer = binDataToBurn; // outgoingBufferSize = binRequest.OutgoingBuffer.Length; // } //} Stopwatch sw = new Stopwatch(); sw.Start(); long lastTime = 0; while (offsetInBuffer < outgoingBufferSize) { if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } chunkSize = outgoingBufferSize - offsetInBuffer; if (chunkSize > PLCVersion.PlcBuffer - Utils.Lengths.LENGTH_HEADER_AND_FOOTER) { chunkSize = PLCVersion.PlcBuffer - Utils.Lengths.LENGTH_HEADER_AND_FOOTER; } if (binRequest.ChunkSizeAlignment != 0) { // Chop the end of the chunk to fit into aligment chunkSize -= (chunkSize % binRequest.ChunkSizeAlignment); } if (binRequest.FlashBankSize != 0) { // Chop the end of the chunk so the burned data will not be written on 2 different flash banks if (((currentAddress + chunkSize) / binRequest.FlashBankSize) != (currentAddress / binRequest.FlashBankSize)) { chunkSize -= ((currentAddress + chunkSize) % binRequest.FlashBankSize); } } //if (binRequest.SubCommand == (int)MemoryType.InternalFlash && binRequest.CommandCode == 0x41) //{ // if ((chunkSize % 8) != 0) // chunkSize -= chunkSize % 8; //} outgoingChunk = new byte[chunkSize]; Array.Copy(binRequest.OutgoingBuffer, offsetInBuffer, outgoingChunk, 0, chunkSize); // Programming command (0x41) // We want to put it on PLC even if the chunk is full with 0xff (Because it is not a flash memory) if ((binRequest.CommandCode == 0x41 && binRequest.SubCommand == (int)MemoryType.SRAM) || IsValidChunkBufferData(outgoingChunk, binRequest.DecodeValue)) { if (sw.ElapsedMilliseconds - lastTime < MIN_TIME_BETWEEN_CHUNKS_WRITE) { Thread.Sleep((int)(MIN_TIME_BETWEEN_CHUNKS_WRITE - (sw.ElapsedMilliseconds - lastTime))); } pComB.BuildBinaryCommand((byte)UnitId, messageKey, binRequest.CommandCode, binRequest.SubCommand, currentAddress, chunkSize, (ushort)chunkSize, outgoingChunk); lastTime = sw.ElapsedMilliseconds; messageKey++; // Message Key is % 256. The BuildBinaryCommand takes care of that binRequest.MessageKey = messageKey; binRequest.MessageKey = binRequest.MessageKey % 256; if (binRequest.MessageKey == 0) { messageKey = binRequest.CycledMessageKey; binRequest.MessageKey = messageKey; } guid = new GuidClass(); lock (guid) { Channel.Send(pComB.MessageToPLC as byte[], ReceiveBytes, guid, parentID, "Binary Protocol - Binary Request (" + binRequest.CommandCode.ToString() + ")", PlcGuid); Monitor.Wait(guid); } if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } lock (_lockObj) { plcResponseMessage = m_responseMessageQueue[guid]; m_responseMessageQueue.Remove(guid); } if (plcResponseMessage.comException == CommunicationException.Timeout) { throw new ComDriveExceptions( "Cannot communicate with the PLC with the specified UnitID!", ComDriveExceptions.ComDriveException.CommunicationTimeout); } binRequest.IncomingBuffer = new byte[plcResponseMessage.responseBytesMessage.Length - Utils.Lengths.LENGTH_HEADER_AND_FOOTER]; if (binRequest.IncomingBuffer.Length > 0) { Array.Copy(plcResponseMessage.responseBytesMessage, Utils.Lengths.LENGTH_HEADER, binRequest.IncomingBuffer, 0, binRequest.IncomingBuffer.Length); } if (plcResponseMessage.responseBytesMessage[12] == 0xFF) { binRequest.PlcReceiveResult = (BinaryRequest.ePlcReceiveResult)plcResponseMessage.responseBytesMessage[13]; } else if (plcResponseMessage.responseBytesMessage[12] == binRequest.CommandCode + 0x80) { binRequest.PlcReceiveResult = BinaryRequest.ePlcReceiveResult.Sucsess; } else { binRequest.PlcReceiveResult = BinaryRequest.ePlcReceiveResult.Unknown; } if (binRequest.PlcReceiveResult != BinaryRequest.ePlcReceiveResult.Sucsess) { return; } if (binRequest.WaitForIdle) { WaitForFlashIdle((byte)UnitId, parentID); } else { if (binRequest.CommandCode == 0x41) { Thread.Sleep(25); } } } else { Debug.Print("Not Valid"); } offsetInBuffer += chunkSize; currentAddress += chunkSize; binRequest.RaiseProgressEvent(0, outgoingBufferSize, RequestProgress.en_NotificationType.ProgressChanged, offsetInBuffer, ""); } binRequest.RaiseProgressEvent(0, outgoingBufferSize, RequestProgress.en_NotificationType.Completed, outgoingBufferSize, ""); } break; default: binRequest.RaiseProgressEvent(0, 100, RequestProgress.en_NotificationType.SetMinMax, 0, ""); binRequest.RaiseProgressEvent(0, 100, RequestProgress.en_NotificationType.ProgressChanged, 0, ""); pComB.BuildBinaryCommand((byte)UnitId, messageKey, binRequest.CommandCode, binRequest.SubCommand, currentAddress, binRequest.ElementsCount, (ushort)outgoingBufferSize, binRequest.OutgoingBuffer); if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } if (binRequest.WaitForIdle) { WaitForFlashIdle((byte)UnitId, parentID); } guid = new GuidClass(); lock (guid) { Channel.Send(pComB.MessageToPLC as byte[], ReceiveBytes, guid, parentID, "Binary Protocol - Binary Request (" + binRequest.CommandCode.ToString() + ")", PlcGuid); Monitor.Wait(guid); } if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } lock (_lockObj) { plcResponseMessage = m_responseMessageQueue[guid]; m_responseMessageQueue.Remove(guid); } if (plcResponseMessage.comException == CommunicationException.Timeout) { throw new ComDriveExceptions("Cannot communicate with the PLC with the specified UnitID!", ComDriveExceptions.ComDriveException.CommunicationTimeout); } binRequest.IncomingBuffer = new byte[plcResponseMessage.responseBytesMessage.Length - Utils.Lengths.LENGTH_HEADER_AND_FOOTER]; if (binRequest.IncomingBuffer.Length > 0) { Array.Copy(plcResponseMessage.responseBytesMessage, Utils.Lengths.LENGTH_HEADER, binRequest.IncomingBuffer, 0, binRequest.IncomingBuffer.Length); } if (plcResponseMessage.responseBytesMessage[12] == 0xFF) { binRequest.PlcReceiveResult = (BinaryRequest.ePlcReceiveResult)plcResponseMessage.responseBytesMessage[13]; } else if (plcResponseMessage.responseBytesMessage[12] == binRequest.CommandCode + 0x80) { binRequest.PlcReceiveResult = BinaryRequest.ePlcReceiveResult.Sucsess; } else { binRequest.PlcReceiveResult = BinaryRequest.ePlcReceiveResult.Unknown; } if (binRequest.WaitForIdle) { WaitForFlashIdle((byte)UnitId, parentID); } binRequest.RaiseProgressEvent(0, 100, RequestProgress.en_NotificationType.Completed, 100, ""); break; } }
private void WaitForFlashIdle(byte unitID, string parentID) { int idleCount = 0; const int READ_STATUS_COMMAND = 7; const int TOTAL_TIME_OUT = 300; byte[] incomingBuffer; FlashStatus flashStatus; DateTime dateTime = DateTime.Now; PComB pComB = new PComB(); pComB.BuildBinaryCommand(unitID, 0, READ_STATUS_COMMAND, 0, 0, 106, 0, new byte[0]); if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } while ((DateTime.Now - dateTime).Seconds <= TOTAL_TIME_OUT) { GuidClass guid = new GuidClass(); lock (guid) { Channel.Send(pComB.MessageToPLC as byte[], ReceiveBytes, guid, parentID, "Binary Protocol - Binary Request (" + READ_STATUS_COMMAND + ")", PlcGuid); Monitor.Wait(guid); } if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } PlcResponseMessage plcResponseMessage; lock (_lockObj) { plcResponseMessage = m_responseMessageQueue[guid]; m_responseMessageQueue.Remove(guid); } if (plcResponseMessage.comException == CommunicationException.Timeout) { throw new ComDriveExceptions("Cannot communicate with the PLC with the specified UnitID!", ComDriveExceptions.ComDriveException.CommunicationTimeout); } incomingBuffer = new byte[plcResponseMessage.responseBytesMessage.Length - Utils.Lengths.LENGTH_HEADER_AND_FOOTER]; if (incomingBuffer.Length > 0) { Array.Copy(plcResponseMessage.responseBytesMessage, Utils.Lengths.LENGTH_HEADER, incomingBuffer, 0, incomingBuffer.Length); } flashStatus = GetFlashStatus(incomingBuffer); if ((flashStatus.MemoryStatus != (MemoryStatus)'I') || (flashStatus.eFlashStatus != eFlashStatus.Idle)) { Thread.Sleep(20); } else { idleCount++; if (idleCount > 1) { return; } } } }
private void ReadWriteOperandsCommand(ref ReadWriteRequest[] values, string parentID, byte messageEnumerator) { PComB pComB = new PComB(); List <List <byte> > dataRequestsBytes = new List <List <byte> >(); #region Group Requests by type. List <ReadOperands> operandReads = new List <ReadOperands>(); List <WriteOperands> operandWrites = new List <WriteOperands>(); for (int i = 0; i < values.Length; i++) { if (values[i] is ReadOperands) { operandReads.Add(values[i] as ReadOperands); } if (values[i] is WriteOperands) { operandWrites.Add(values[i] as WriteOperands); } } #endregion #region Detail Area Header int totalNumberOfReads = 0; int totalNumberOfWrites = 0; foreach (ReadWriteRequest operand in values) { if (operand is ReadOperands) { totalNumberOfReads += (operand as ReadOperands).NumberOfOperands; dataRequestsBytes.Add(GetDataRequestsBytesForReadOperands(operand as ReadOperands)); } if (operand is WriteOperands) { totalNumberOfWrites += (operand as WriteOperands).NumberOfOperands; dataRequestsBytes.Add(GetDataRequestsBytesForWriteOperands(operand as WriteOperands)); } } byte[] command_detailes = new byte[4]; byte[] NoOfReads = BitConverter.GetBytes(totalNumberOfReads); byte[] NoOfWrites = BitConverter.GetBytes(totalNumberOfWrites); command_detailes[0] = NoOfReads[0]; command_detailes[1] = NoOfReads[1]; command_detailes[2] = NoOfWrites[0]; command_detailes[3] = NoOfWrites[1]; #endregion if (operandReads.Count > 0 || operandWrites.Count > 0) { pComB.BuildBinaryCommand((byte)UnitId, BinaryCommand.ReadWrite, command_detailes, values.ToList(), dataRequestsBytes); if (Channel != null) { if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } GuidClass guid = new GuidClass(); lock (guid) { Channel.Send(pComB.MessageToPLC as byte[], ReceiveBytes, guid, parentID, "Binary Protocol - Read/Write Operands (80)", PlcGuid, messageEnumerator); Monitor.Wait(guid); } if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } PlcResponseMessage plcResponseMessage; lock (_lockObj) { plcResponseMessage = m_responseMessageQueue[guid]; m_responseMessageQueue.Remove(guid); } if (plcResponseMessage.comException == CommunicationException.Timeout) { throw new ComDriveExceptions("Cannot communicate with the PLC with the specified UnitID!", ComDriveExceptions.ComDriveException.CommunicationTimeout); } // receivedMessage[13] shows if there was occured an error. if (plcResponseMessage.responseBytesMessage[13] == 0) { pComB.DisAssembleBinaryResult(plcResponseMessage.responseBytesMessage, dataRequestsBytes); } } } else { //System.Diagnostics.Debug.Assert(false); } }
private void ReadOperations(ref List <ReadWriteRequest> pdataRequestsForRead, string parentID) { List <ReadWriteRequest> dataRequestsForRead = null; dataRequestsForRead = pdataRequestsForRead.OrderBy(dr => GetOperandSize(dr)).ToList(); List <List <byte> > dataRequestBytes = new List <List <byte> >(); for (int i = 0; i < dataRequestsForRead.Count; i++) { if (dataRequestsForRead[i] is ReadOperands) { dataRequestBytes.Add(GetDataRequestBytes(dataRequestsForRead[i] as ReadOperands)); } } //set number of read requests in position 4 and 5 of command_details which in header will be 18 and 19 byte[] command_detailes = new byte[6]; byte[] count = BitConverter.GetBytes(dataRequestsForRead.Count); command_detailes[4] = count[0]; command_detailes[5] = count[1]; PComB pComB = new PComB(); pComB.BuildBinaryCommand((byte)UnitId, BinaryCommand.ReadOperands, command_detailes, dataRequestsForRead, dataRequestBytes); if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } GuidClass guid = new GuidClass(); lock (guid) { Channel.Send(pComB.MessageToPLC as byte[], ReceiveBytes, guid, parentID, "Binary Protocol - Read Operands (77)", PlcGuid); Monitor.Wait(guid); } if (this.BreakFlag) { throw new ComDriveExceptions("Request aborted by user", ComDriveExceptions.ComDriveException.AbortedByUser); } PlcResponseMessage plcResponseMessage; lock (_lockObj) { plcResponseMessage = m_responseMessageQueue[guid]; m_responseMessageQueue.Remove(guid); } if (plcResponseMessage.comException == CommunicationException.Timeout) { throw new ComDriveExceptions("Cannot communicate with the PLC with the specified UnitID!", ComDriveExceptions.ComDriveException.CommunicationTimeout); } pComB.DisAssembleBinaryResult(plcResponseMessage.responseBytesMessage, dataRequestBytes); }
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, ""); } } }