Exemplo n.º 1
0
        private static string getROWORequestsPropertiesString(ReadWriteRequest readWriteRequest)
        {
            string result = String.Empty;

            // The string results format is:
            // RequestType:OperandType-StartAddress-NumberOfOperands.  where
            // ':' - is the delimitator for the requestType
            // '-' - is the delimitator between request properties.
            // '.' - used to mark the end of the request properties.
            // Example: RO:MI-1-10. means Read 10 MI from address 1.

            if (readWriteRequest is ReadOperands)
            {
                ReadOperands ro = readWriteRequest as ReadOperands;

                result += "RO:" + ro.OperandType.ToString() +
                          "-" + ro.StartAddress.ToString() +
                          "-" + ro.NumberOfOperands.ToString() +
                          ".";
            }
            else
            {
                WriteOperands wo = readWriteRequest as WriteOperands;
                result += "WO" + wo.OperandType.ToString() +
                          "-" + wo.StartAddress.ToString() +
                          "-" + wo.NumberOfOperands.ToString() +
                          ".";
            }

            return(result);
        }
Exemplo n.º 2
0
        private bool receiveMessageSizeFitsThePLCBuffer(ReadWriteRequest operand)
        {
            ReadOperands readOperands       = operand as ReadOperands;
            int          operandSize        = Utils.GetOperandSizeByCommandCode(readOperands.OperandType.ToString());
            int          receiveDataSize    = readOperands.NumberOfOperands * operandSize;
            int          receiveMessageSize = Utils.Lengths.LENGTH_ASCII_RECEIVE_MESSAGE + receiveDataSize;

            return(receiveMessageSize <= PLCVersion.PlcBuffer && readOperands.NumberOfOperands <= 255);
        }
Exemplo n.º 3
0
        private void ReadWriteReadOperand(ReadWriteRequest operand, string parentID, bool suppressEthernetHeader)
        {
            ReadOperands readOperands = operand as ReadOperands;
            GuidClass    guid         = new GuidClass();

            pcomA.BuildAsciiCommand(UnitId,
                                    Utils.ASCIIOperandTypes[Enum.GetName(typeof(OperandTypes), readOperands.OperandType)]
                                    .CommandCodeForRead,
                                    (operand as ReadOperands).StartAddress, readOperands.NumberOfOperands, null,
                                    readOperands.TimerValueFormat);

            string readMessage = pcomA.MessageToPLC as string;

            if (this.BreakFlag)
            {
                throw new ComDriveExceptions("Request aborted by user",
                                             ComDriveExceptions.ComDriveException.AbortedByUser);
            }

            lock (guid)
            {
                Channel.Send(readMessage, ReceiveString, guid, parentID, "ASCII Protocol - Read Operands", PlcGuid,
                             suppressEthernetHeader);
                Monitor.Wait(guid);
            }

            if (this.BreakFlag)
            {
                throw new ComDriveExceptions("Request aborted by user",
                                             ComDriveExceptions.ComDriveException.AbortedByUser);
            }

            PlcResponseMessage plcResponseMessage;

            {
                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);
            }

            pcomA.DisAssembleAsciiResult(plcResponseMessage.response, UnitId,
                                         Utils.ASCIIOperandTypes[Enum.GetName(typeof(OperandTypes), readOperands.OperandType)]
                                         .CommandCodeForRead,
                                         (operand as ReadOperands).StartAddress, readOperands.NumberOfOperands, null,
                                         readOperands.TimerValueFormat);
            if (pcomA.MessageFromPLC != null)
            {
                operand.ResponseValues = (pcomA.MessageFromPLC as AbstractASCIIMessage).ArrayValues; //Values;
            }
        }
Exemplo n.º 4
0
        private void _receiveSizeExceedPLCBUffer(ReadWriteRequest readWriteRequest)
        {
            ReadOperands ro = readWriteRequest as ReadOperands;
            ushort       availableReceiveSize  = (ushort)(plcBuffer - bytesNoToReceive - (Utils.Lengths.LENGTH_WR_DETAILS));
            ushort       availableNoOfOperands = (ushort)(availableReceiveSize / operandSize);

            if (availableNoOfOperands > 255)
            {
                availableReceiveSize -=
                    (ushort)((availableNoOfOperands / 255) * (Utils.Lengths.LENGTH_WR_DETAILS + 1));
                availableReceiveSize -= 1;
                availableReceiveSize -= (ushort)((availableNoOfOperands % 255) % 2);
                availableNoOfOperands = (ushort)(availableReceiveSize / operandSize);
            }

            ushort noOfOperands = 0;
            ushort startAddress = ro.StartAddress;
            int    requestNo    = 0;

            ReadOperands remainingRo = new ReadOperands
            {
                NumberOfOperands = (ushort)(ro.NumberOfOperands - availableNoOfOperands),
                OperandType      = ro.OperandType,
                StartAddress     = (ushort)(ro.StartAddress + availableNoOfOperands),
                TimerValueFormat = ro.TimerValueFormat
            };


            while (availableNoOfOperands > 0)
            {
                if (availableNoOfOperands > 255)
                {
                    noOfOperands           = 255;
                    availableNoOfOperands -= noOfOperands;
                }
                else
                {
                    noOfOperands          = availableNoOfOperands;
                    availableNoOfOperands = 0;
                }

                requestNo++;
                ReadOperands tmpRO = new ReadOperands(noOfOperands, ro.OperandType, startAddress, ro.TimerValueFormat);
                requestsList.Add(tmpRO);
                startAddress += noOfOperands;
                _updateSplitDetailsList();
            }

            ReadWriteRequest[] tmpReq = requestsList.ToArray();
            allRequestsList.Add(tmpReq.ToList());

            _resetRequestsList();
            AddNewRequest(remainingRo, reqPosition, true);
        }
Exemplo n.º 5
0
        public ReadWriteRequest[] init()
        {
            //
            ReadWriteRequest r1 = new ReadOperands
            {
                NumberOfOperands = 8,
                OperandType      = OperandTypes.MI,
                StartAddress     = 0,
            };

            return(new ReadWriteRequest[] { r1 });
        }
Exemplo n.º 6
0
        private void _addRequestsWhenNoOfOperandsExceed255(ReadWriteRequest readWriteRequest)
        {
            ushort startAddress;
            ushort noOfOperands;
            ushort remainingNoOfOperands;

            if (readWriteRequest is ReadOperands)
            {
                ReadOperands ro = readWriteRequest as ReadOperands;
                remainingNoOfOperands = ro.NumberOfOperands;
                startAddress          = ro.StartAddress;
                noOfOperands          = 255;

                while (remainingNoOfOperands > 0)
                {
                    requestsList.Add(new ReadOperands(noOfOperands, ro.OperandType, startAddress, ro.TimerValueFormat));
                    startAddress          += noOfOperands;
                    remainingNoOfOperands -= noOfOperands;

                    if (remainingNoOfOperands <= 255)
                    {
                        noOfOperands = remainingNoOfOperands;
                    }

                    _updateSplitDetailsList();
                }
            }
            else
            {
                WriteOperands wo = readWriteRequest as WriteOperands;
                remainingNoOfOperands = wo.NumberOfOperands;
                startAddress          = wo.StartAddress;
                noOfOperands          = 255;

                while (remainingNoOfOperands > 0)
                {
                    object[] values = new object[noOfOperands];
                    Array.Copy(wo.Values, startAddress - wo.StartAddress, values, 0, noOfOperands);

                    requestsList.Add(new WriteOperands(noOfOperands, wo.OperandType, startAddress, values,
                                                       wo.TimerValueFormat));
                    startAddress          += noOfOperands;
                    remainingNoOfOperands -= noOfOperands;

                    if (remainingNoOfOperands <= 255)
                    {
                        noOfOperands = remainingNoOfOperands;
                    }

                    _updateSplitDetailsList();
                }
            }
        }
Exemplo n.º 7
0
        private List <byte> GetDataRequestBytes(ReadOperands readOperandsExecuter)
        {
            bool        isVectorial = true;
            List <byte> results     = new List <byte>();

            results.AddRange(BitConverter.GetBytes(readOperandsExecuter.NumberOfOperands));
            OperandType operandType = Enum.GetName(typeof(OperandTypes), readOperandsExecuter.OperandType)
                                      .GetOperandTypeByName();

            results.Add(isVectorial ? operandType.VectorialValue : operandType.ByteValue);
            results.Add(255);

            results.AddRange(BitConverter.GetBytes(readOperandsExecuter.StartAddress));

            return(results);
        }
        private List <byte> GetDataRequestsBytesForReadOperands(ReadOperands readOperandsExecuter)
        {
            List <byte> results = new List <byte>();

            results.AddRange(
                BitConverter.GetBytes((readOperandsExecuter.NumberOfOperands > 0) ? (UInt16)1 : (UInt16)0));
            results.AddRange(BitConverter.GetBytes((UInt16)0));

            if (readOperandsExecuter.NumberOfOperands > 0)
            {
                results.AddRange(UpdateReadDataRequest(
                                     readOperandsExecuter.OperandType.ToString().GetOperandIdByNameForFullBinary(),
                                     readOperandsExecuter.NumberOfOperands, readOperandsExecuter.StartAddress));
            }

            return(results);
        }
Exemplo n.º 9
0
        private int GetReadOperandReceiveSize(ReadWriteRequest readWriteRequest)
        {
            ReadOperands readOperands = readWriteRequest as ReadOperands;
            int          operandSize  = readOperands.OperandType.GetOperandSizeByOperandTypeForFullBinarry();
            int          result       = 0;

            if (operandSize == 1)
            {
                result = (readOperands.NumberOfOperands / 8);
                if (readOperands.NumberOfOperands % 8 != 0)
                {
                    result++;
                }
            }
            else
            {
                result = operandSize * readOperands.NumberOfOperands;
            }

            return(result);
        }
Exemplo n.º 10
0
        private List <ReadOperands> GetSplitedReadOperands(ReadWriteRequest operand)
        {
            ReadOperands        readOpearnd = operand as ReadOperands;
            List <ReadOperands> results     = new List <ReadOperands>();
            int    operandSize           = Utils.GetOperandSizeByCommandCode(readOpearnd.OperandType.ToString());
            ushort startAddress          = readOpearnd.StartAddress;
            ushort remainingNoOfOperands = readOpearnd.NumberOfOperands;
            int    splitMaxDataSize      = PLCVersion.PlcBuffer - Utils.Lengths.LENGTH_ASCII_RECEIVE_MESSAGE;
            ushort splitMaxNoOfOperands  = (ushort)(splitMaxDataSize / operandSize);

            if (splitMaxNoOfOperands > 255)
            {
                splitMaxNoOfOperands = 255;
            }

            bool bDone = false;

            while (!bDone)
            {
                if (remainingNoOfOperands <= splitMaxNoOfOperands)
                {
                    results.Add(new ReadOperands(remainingNoOfOperands, readOpearnd.OperandType, startAddress,
                                                 readOpearnd.TimerValueFormat));
                    bDone = true;
                }
                else
                {
                    results.Add(new ReadOperands(splitMaxNoOfOperands, readOpearnd.OperandType, startAddress,
                                                 readOpearnd.TimerValueFormat));
                    startAddress          += splitMaxNoOfOperands;
                    remainingNoOfOperands -= splitMaxNoOfOperands;
                }
            }

            return(results);
        }
Exemplo n.º 11
0
        private void _getRequestBytesSize(ReadWriteRequest readWriteRequest)
        {
            ushort noOfOperands;
            int    noOf255Splits, noOfSplits;

            if (readWriteRequest is WriteOperands)
            {
                WriteOperands wo = readWriteRequest as WriteOperands;
                noOfOperands = wo.NumberOfOperands;
                operandSize  = wo.OperandType.GetOperandSizeByOperandTypeForFullBinarry();

                noOf255Splits = noOfOperands / 255;
                noOfSplits    = noOfOperands % 255;

                if (noOfOperands > 255)
                {
                    requestBytesNoToSend =
                        (ushort)(noOf255Splits * Utils.Lengths.LENGTH_WR_DETAILS + noOf255Splits * 255 * operandSize);
                    requestBytesNoToSend += (ushort)((operandSize % 2) * (noOf255Splits + noOfSplits % 2));

                    if (noOfSplits > 0)
                    {
                        requestBytesNoToSend += (ushort)(Utils.Lengths.LENGTH_WR_DETAILS + noOfSplits * operandSize);
                    }
                }
                else
                {
                    requestBytesNoToSend  = (ushort)(operandSize * noOfOperands + Utils.Lengths.LENGTH_WR_DETAILS);
                    requestBytesNoToSend += (ushort)(requestBytesNoToSend % 2);
                }

                requestBytesNoToReceive = 0;
            }
            else
            {
                ReadOperands ro = readWriteRequest as ReadOperands;
                noOfOperands = ro.NumberOfOperands;
                operandSize  = ro.OperandType.GetOperandSizeByOperandTypeForFullBinarry();

                if (noOfOperands > 255)
                {
                    noOf255Splits = (noOfOperands / 255);
                    noOfSplits    = (noOfOperands % 255);

                    requestBytesNoToSend    = (ushort)(noOf255Splits * Utils.Lengths.LENGTH_WR_DETAILS);
                    requestBytesNoToReceive =
                        (ushort)(noOf255Splits * Utils.Lengths.LENGTH_WR_DETAILS + noOf255Splits * 255 * operandSize);
                    requestBytesNoToReceive += (ushort)((operandSize % 2) * (noOf255Splits + noOfSplits % 2));

                    if (noOfSplits != 0)
                    {
                        requestBytesNoToSend    += Utils.Lengths.LENGTH_WR_DETAILS;
                        requestBytesNoToReceive +=
                            (ushort)(Utils.Lengths.LENGTH_WR_DETAILS + noOfSplits * operandSize);
                    }
                }
                else
                {
                    requestBytesNoToReceive  = (ushort)(operandSize * noOfOperands + Utils.Lengths.LENGTH_WR_DETAILS);
                    requestBytesNoToReceive += (ushort)(requestBytesNoToReceive % 2);
                    requestBytesNoToSend     = Utils.Lengths.LENGTH_WR_DETAILS;
                }
            }
        }
Exemplo n.º 12
0
        //Staticly type for needed Application
        public ReadWriteRequest[] init()
        {
            //Unusedwl ser
            ReadWriteRequest r1 = new ReadOperands
            {
                NumberOfOperands = 1,
                OperandType      = OperandTypes.MI,
                StartAddress     = 1501,
            }; ReadWriteRequest r2 = new ReadOperands

            {
                NumberOfOperands = 1,
                OperandType      = OperandTypes.MI,
                StartAddress     = 56,
            };
            //Hydr Vorlauf+Rück % Kom Vor+Rück --> Spliten
            ReadWriteRequest r3 = new ReadOperands
            {
                NumberOfOperands = 4,
                OperandType      = OperandTypes.MI,
                StartAddress     = 1631,
            };
            //Hydr. --> Spliten
            ReadWriteRequest r4 = new ReadOperands
            {
                NumberOfOperands = 2,
                OperandType      = OperandTypes.MI,
                StartAddress     = 29,
            };
            //Aussentemp
            ReadWriteRequest r5 = new ReadOperands
            {
                NumberOfOperands = 1,
                OperandType      = OperandTypes.MI,
                StartAddress     = 1523,
            };
            //Fehler
            ReadWriteRequest r6 = new ReadOperands
            {
                NumberOfOperands = 1,
                OperandType      = OperandTypes.MB,
                StartAddress     = 2300,
            };
            //Daten Kühlung aktiv
            ReadWriteRequest r7 = new ReadOperands
            {
                NumberOfOperands = 1,
                OperandType      = OperandTypes.SB,
                StartAddress     = 3,
            };
            //Luft MO
            ReadWriteRequest r8 = new ReadOperands
            {
                NumberOfOperands = 1,
                OperandType      = OperandTypes.MB,
                StartAddress     = 1807,
            };
            //Luft SP1
            ReadWriteRequest r9 = new ReadOperands
            {
                NumberOfOperands = 1,
                OperandType      = OperandTypes.MB,
                StartAddress     = 1805,
            };
            //Luft SC
            ReadWriteRequest r10 = new ReadOperands
            {
                NumberOfOperands = 1,
                OperandType      = OperandTypes.MB,
                StartAddress     = 1801,
            };
            //Luft Versorgung
            ReadWriteRequest r11 = new ReadOperands
            {
                NumberOfOperands = 1,
                OperandType      = OperandTypes.MB,
                StartAddress     = 1811,
            };
            //Luft SP2
            ReadWriteRequest r12 = new ReadOperands
            {
                NumberOfOperands = 1,
                OperandType      = OperandTypes.MB,
                StartAddress     = 1803,
            };
            //Luft FB
            ReadWriteRequest r13 = new ReadOperands
            {
                NumberOfOperands = 1,
                OperandType      = OperandTypes.MB,
                StartAddress     = 1809,
            };
            //Temp Klebeplatz
            ReadWriteRequest r14 = new ReadOperands
            {
                NumberOfOperands = 1,
                OperandType      = OperandTypes.MI,
                StartAddress     = 1561,
            };

            return(new ReadWriteRequest[] { r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14 });
        }
        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);
                }
            }
        }
Exemplo n.º 14
0
        private void SplitAndReadReadOperands(ref List <ReadWriteRequest> readWriteRequest, string parentID)
        {
            if (this.BreakFlag)
            {
                throw new ComDriveExceptions("Request aborted by user",
                                             ComDriveExceptions.ComDriveException.AbortedByUser);
            }

            if (readWriteRequest.Count == 1) //only 1 request that exceed the plcBuffer
            {
                ReadOperands            readOperands   = readWriteRequest[0] as ReadOperands;
                List <ReadWriteRequest> splitRequests  = new List <ReadWriteRequest>();
                List <object>           responseValues = new List <object>();

                int operandSize = readOperands.OperandType.GetOperandSizeByOperandTypeForFullBinarry();

                ushort maxNoOfOperands =
                    (ushort)((PLCVersion.PlcBuffer - Utils.Lengths.LENGTH_HEADER_AND_FOOTER) / operandSize);
                ushort startAddress = (readWriteRequest[0] as ReadOperands).StartAddress;

                ushort remainingNoOfOperands = (ushort)(readOperands.NumberOfOperands);
                ushort remainingStartAddress = startAddress;

                while (remainingNoOfOperands > maxNoOfOperands)
                {
                    if (this.BreakFlag)
                    {
                        throw new ComDriveExceptions("Request aborted by user",
                                                     ComDriveExceptions.ComDriveException.AbortedByUser);
                    }

                    splitRequests.Add(new ReadOperands(maxNoOfOperands, readOperands.OperandType, remainingStartAddress,
                                                       readOperands.TimerValueFormat));

                    ReadOperations(ref splitRequests, parentID);

                    if (this.BreakFlag)
                    {
                        throw new ComDriveExceptions("Request aborted by user",
                                                     ComDriveExceptions.ComDriveException.AbortedByUser);
                    }

                    responseValues.AddRange((splitRequests[0].ResponseValues) as object[]);

                    splitRequests.Clear();
                    remainingNoOfOperands -= maxNoOfOperands;
                    remainingStartAddress += maxNoOfOperands;
                }

                if (remainingNoOfOperands > 0)
                {
                    if (this.BreakFlag)
                    {
                        throw new ComDriveExceptions("Request aborted by user",
                                                     ComDriveExceptions.ComDriveException.AbortedByUser);
                    }

                    splitRequests.Add(new ReadOperands(remainingNoOfOperands, readOperands.OperandType,
                                                       remainingStartAddress, readOperands.TimerValueFormat));

                    ReadOperations(ref splitRequests, parentID);

                    responseValues.AddRange((splitRequests[0].ResponseValues) as object[]);
                }

                readWriteRequest[0].ResponseValues = responseValues.ToArray();
            }
            else
            {
                //this is called only at the end of userRequests and when
                //joinRequests contains more than 1 requests

                if (this.BreakFlag)
                {
                    throw new ComDriveExceptions("Request aborted by user",
                                                 ComDriveExceptions.ComDriveException.AbortedByUser);
                }

                ReadOperations(ref readWriteRequest, parentID);
            }
        }