Exemple #1
0
        public MmProtocol(IMmStream mmStream, int sourceId = 0, int transactionLabel = 0)
        {
            this.mmStream = mmStream;

            // Optional parameter. If you are running two or more applications simultaneously, you can give
            // each application a different ID in this parameter. If an error occurs, you can read the
            // Source address in the memory map Status area to find out which application caused the error.
            // Range 0x0000-0xffff (16bit)
            var si = sourceId & 0xffff;

            if (si != sourceId)
            {
                Thrower.Throw("Source id {0:X} out of range (0x0000 to 0xFFFF)", sourceId);
            }
            this.sourceId = sourceId;

            // A label specified by the requester and identifying this transaction.
            // Range 0x00-0x3F (8bit). This value is returned in the response packet.
            var tl = (transactionLabel << 2) & 0xff;

            if (tl >> 2 != transactionLabel)
            {
                Thrower.Throw(
                    "Transaction label {0:X} out of range (0x00 to 0x3F)", transactionLabel);
            }
            this.transactionLabel = tl;
        }
Exemple #2
0
 private void checkBlockLength(int length)
 {
     if (length != (length & 0xffff))
     {
         Thrower.Throw(
             "Invalid length {0:X}, range is 0x0000 to 0xffff",
             length);
     }
 }
        public void Read(byte[] data)
        {
            var count = socket.GetStream().Read(data, 0, data.Length);

            if (count != data.Length)
            {
                Thrower.Throw("Read count mismatch requested:{0} available:{1}", data.Length, count);
            }
        }
Exemple #4
0
        private void checkBlockLength(byte[] response, int length)
        {
            var _length = response[12] << 8 | response[13];

            if (_length != length)
            {
                Thrower.Throw(
                    "Invalid block length, expected {0} but received {1}",
                    length, _length);
            }
        }
Exemple #5
0
        private void checkDestinationOffset(long destinationOffset)
        {
            var _destinationOffset = (destinationOffset & 0xffffffffffffL);

            if (destinationOffset != _destinationOffset)
            {
                Thrower.Throw(
                    "Invalid destinationOffset {0:X}, range is 0x000000000000 to 0xffffffffffff",
                    destinationOffset);
            }
        }
Exemple #6
0
 private void checkData(byte[] data, int length)
 {
     if (data == null)
     {
         Thrower.Throw("data is null");
     }
     if (length >= 0 && data.Length != length)               // do not test if length<0
     {
         Thrower.Throw(
             "Invalid data length, expected {0} but received {1}",
             length, data.Length);
     }
 }
        public SocketMmStream(string host, int port, int timeout)
        {
            this.socket = new TcpClient();
            var result = socket.BeginConnect(host, port, null, null);

            if (!result.AsyncWaitHandle.WaitOne(timeout, true))
            {
                Thrower.Throw("Timeout connecting to {0}:{1}", host, port);
            }
            socket.EndConnect(result);
            socket.ReceiveTimeout = timeout;
            socket.SendTimeout    = timeout;
        }
Exemple #8
0
        private void checkResponse(byte[] response, TransactionCode transactionCode)
        {
            // 40h returned for required powerup clear
            // 50h returned for invalid address
            var _resultCode = response.Length >= 7 ? response[6] : (byte)0;

            if (_resultCode != 0)
            {
                throw new NakException(_resultCode);
            }

            // check source id matches
            var _sourceId = 0xffff & response[4] << 8 | response[5];

            if (_sourceId != sourceId)
            {
                Thrower.Throw(
                    "Invalid source id, expected {0:X} but received {1:X}",
                    sourceId, _sourceId);
            }

            // check transaction label matches
            var _transactionLabel = response[2] & 0xff;

            if (_transactionLabel != transactionLabel)
            {
                Thrower.Throw(
                    "Invalid transaction label, expected {0:X} but received {1:X}",
                    transactionLabel, _transactionLabel);
            }

            // check transaction code matches
            var _transactionCode = response[3] & 0xff;

            if (!Enum.IsDefined(typeof(TransactionCode), _transactionCode) ||
                (TransactionCode)_transactionCode != transactionCode)
            {
                Thrower.Throw(
                    "Invalid transaction code, expected {0:X} but received {1:X}",
                    transactionCode, _transactionCode);
            }
        }