/// <summary>
            /// Method that formats the message going to the embedded PTU target. The format of the message
            /// is specific to the type of request made.
            /// </summary>
            /// <param name="targetIsBigEndian">true if the embedded PTU target is a Big Endian machine; false otherwise</param>
            /// <returns>ordered byte array that is to be sent to the embedded PTU target</returns>
            public Byte[] GetByteArray(Boolean targetIsBigEndian)
            {
                DataPacketProlog dpp = new DataPacketProlog();

                if (targetIsBigEndian)
                {
                    this.NewEventLog = Utils.ReverseByteOrder(this.NewEventLog);
                }
                // Even though "ms" is allocated MAX_TX_STREAM_SIZE, the ToArray() returns the size
                // of the array that was populated with data
                MemoryStream ms = new MemoryStream(MAX_TX_STREAM_SIZE);
                BinaryWriter bw = new BinaryWriter(ms);
                bw.Write(this.NewEventLog);
                return dpp.GetByteArray(ms.ToArray(), PACKET_TYPE, RESPONSE_TYPE, targetIsBigEndian);
            }
            /// <summary>
            /// Method that formats the message going to the embedded PTU target. The format of the message
            /// is specific to the type of request made.
            /// </summary>
            /// <param name="targetIsBigEndian">true if the embedded PTU target is a Big Endian machine; false otherwise</param>
            /// <returns>ordered byte array that is to be sent to the embedded PTU target</returns>
            public Byte[] GetByteArray(Boolean targetIsBigEndian)
            {
                DataPacketProlog dpp = new DataPacketProlog();

                if (targetIsBigEndian)
                {
                    this.TaskID = Utils.ReverseByteOrder(this.TaskID);
                    this.FaultID = Utils.ReverseByteOrder(this.FaultID);
                    this.EnableFlag = Utils.ReverseByteOrder(this.EnableFlag);
                    this.DatalogFlag = Utils.ReverseByteOrder(this.DatalogFlag);
                }
                MemoryStream ms = new MemoryStream(MAX_TX_STREAM_SIZE);
                BinaryWriter bw = new BinaryWriter(ms);
                bw.Write(this.TaskID);
                bw.Write(this.FaultID);
                bw.Write(this.EnableFlag);
                bw.Write(this.DatalogFlag);
                return dpp.GetByteArray(ms.ToArray(), PACKET_TYPE, RESPONSE_TYPE, targetIsBigEndian);
            }
            /// <summary>
            /// Method that formats the message going to the embedded PTU target. The format of the message
            /// is specific to the type of request made.
            /// </summary>
            /// <param name="targetIsBigEndian">true if the embedded PTU target is a Big Endian machine; false otherwise</param>
            /// <returns>ordered byte array that is to be sent to the embedded PTU target</returns>
            public Byte[] GetByteArray(Boolean targetIsBigEndian)
            {
                DataPacketProlog dpp = new DataPacketProlog();

                if (targetIsBigEndian)
                {
                    this.TargetState = Utils.ReverseByteOrder(this.TargetState);
                }

                Byte[] payload = { this.TargetState };

                return dpp.GetByteArray(payload, PACKET_TYPE, RESPONSE_TYPE, targetIsBigEndian);
            }
            /// <summary>
            /// Method that formats the message going to the embedded PTU target. The format of the message
            /// is specific to the type of request made.
            /// </summary>
            /// <param name="targetIsBigEndian">true if the embedded PTU target is a Big Endian machine; false otherwise</param>
            /// <returns>ordered byte array that is to be sent to the embedded PTU target</returns>
            public Byte[] GetByteArray(Boolean targetIsBigEndian)
            {
                DataPacketProlog dpp = new DataPacketProlog();

                if (targetIsBigEndian)
                {
                    // Intentionally do nothing since the only item to be converted is a string
                }

                // Convert string to byte array
                Byte[] payload = Encoding.ASCII.GetBytes(this.NewCarId);

                return dpp.GetByteArray(payload, PACKET_TYPE, RESPONSE_TYPE, targetIsBigEndian);
            }
            /// <summary>
            /// Method that formats the message going to the embedded PTU target. The format of the message
            /// is specific to the type of request made.
            /// </summary>
            /// <param name="targetIsBigEndian">true if the embedded PTU target is a Big Endian machine; false otherwise</param>
            /// <returns>ordered byte array that is to be sent to the embedded PTU target</returns>
            public Byte[] GetByteArray(Boolean targetIsBigEndian)
            {
                DataPacketProlog dpp = new DataPacketProlog();

                if (targetIsBigEndian)
                {
                    this.DictionaryIndex = Utils.ReverseByteOrder(this.DictionaryIndex);
                    this.MaxScale = Utils.ReverseByteOrder(this.MaxScale);
                    this.MinScale = Utils.ReverseByteOrder(this.MinScale);
                }
                MemoryStream ms = new MemoryStream(MAX_TX_STREAM_SIZE);
                BinaryWriter bw = new BinaryWriter(ms);
                bw.Write(this.DictionaryIndex);
                bw.Write(this.MaxScale);
                bw.Write(this.MinScale);
                return dpp.GetByteArray(ms.ToArray(), PACKET_TYPE, RESPONSE_TYPE, targetIsBigEndian);
            }
            /// <summary>
            /// Method that formats the message going to the embedded PTU target. The format of the message
            /// is specific to the type of request made.
            /// </summary>
            /// <param name="targetIsBigEndian">true if the embedded PTU target is a Big Endian machine; false otherwise</param>
            /// <returns>ordered byte array that is to be sent to the embedded PTU target</returns>
            public Byte[] GetByteArray(Boolean targetIsBigEndian)
            {
                DataPacketProlog dpp = new DataPacketProlog();

                if (targetIsBigEndian)
                {
                    this.CommandId = Utils.ReverseByteOrder(this.CommandId);
                    this.NumberOfTests = Utils.ReverseByteOrder(this.NumberOfTests);

                    for (UInt16 i = 0; i < this.TestList.Length; i++)
                    {
                        this.TestList[i] = Utils.ReverseByteOrder(this.TestList[i]);
                    }
                }
                MemoryStream ms = new MemoryStream(MAX_TX_STREAM_SIZE);
                BinaryWriter bw = new BinaryWriter(ms);

                bw.Write(this.CommandId);
                bw.Write((Byte)0);
                bw.Write(this.NumberOfTests);

                for (UInt16 i = 0; i < this.TestList.Length; i++)
                {
                    bw.Write(this.TestList[i]);
                }

                return dpp.GetByteArray(ms.ToArray(), PACKET_TYPE, RESPONSE_TYPE, targetIsBigEndian);
            }
            /// <summary>
            /// Method that formats the message going to the embedded PTU target. The format of the message
            /// is specific to the type of request made.
            /// </summary>
            /// <param name="targetIsBigEndian">true if the embedded PTU target is a Big Endian machine; false otherwise</param>
            /// <returns>ordered byte array that is to be sent to the embedded PTU target</returns>
            public Byte[] GetByteArray(Boolean targetIsBigEndian)
            {
                DataPacketProlog dpp = new DataPacketProlog();

                if (targetIsBigEndian)
                {
                    this.CommandId = Utils.ReverseByteOrder(this.CommandId);
                    this.Data = Utils.ReverseByteOrder(this.Data);
                }
                MemoryStream ms = new MemoryStream(MAX_TX_STREAM_SIZE);
                BinaryWriter bw = new BinaryWriter(ms);
                bw.Write(this.CommandId);
                bw.Write(this.TruckId);
                bw.Write(this.Data);

                return dpp.GetByteArray(ms.ToArray(), PACKET_TYPE, RESPONSE_TYPE, targetIsBigEndian);
            }
            /// <summary>
            /// Method that formats the message going to the embedded PTU target. The format of the message
            /// is specific to the type of request made.
            /// </summary>
            /// <param name="targetIsBigEndian">true if the embedded PTU target is a Big Endian machine; false otherwise</param>
            /// <returns>ordered byte array that is to be sent to the embedded PTU target</returns>
            public Byte[] GetByteArray(Boolean targetIsBigEndian)
            {
                DataPacketProlog dpp = new DataPacketProlog();

                Byte[] payload = { this.ForceFullUpdate != 0 ? (Byte)1 : (Byte)0 };

                return dpp.GetByteArray(payload, PACKET_TYPE, RESPONSE_TYPE, targetIsBigEndian);
            }
            /// <summary>
            /// Method that formats the message going to the embedded PTU target. The format of the message
            /// is specific to the type of request made.
            /// </summary>
            /// <param name="targetIsBigEndian">true if the embedded PTU target is a Big Endian machine; false otherwise</param>
            /// <returns>ordered byte array that is to be sent to the embedded PTU target</returns>
            public Byte[] GetByteArray(Boolean targetIsBigEndian)
            {
                DataPacketProlog dpp = new DataPacketProlog();

                if (targetIsBigEndian)
                {
                    this.Hour = Utils.ReverseByteOrder(this.Hour);
                    this.Minute = Utils.ReverseByteOrder(this.Minute);
                    this.Second = Utils.ReverseByteOrder(this.Second);
                    this.Year = Utils.ReverseByteOrder(this.Year);
                    this.Month = Utils.ReverseByteOrder(this.Month);
                    this.Day = Utils.ReverseByteOrder(this.Day);
                }

                MemoryStream ms = new MemoryStream(MAX_TX_STREAM_SIZE);
                BinaryWriter bw = new BinaryWriter(ms);
                bw.Write(this.Hour);
                bw.Write(this.Minute);
                bw.Write(this.Second);
                if (this.fourDigitYear)
                {
                    // Used to fill a word boundary
                    bw.Write((Byte)0x00);
                    bw.Write(this.Year);
                }
                else
                {
                    Byte bYear = (Byte)this.Year;
                    bw.Write(bYear);
                }
                bw.Write(this.Month);
                bw.Write(this.Day);
                return dpp.GetByteArray(ms.ToArray(), PACKET_TYPE, RESPONSE_TYPE, targetIsBigEndian);
            }
            /// <summary>
            /// Method that formats the message going to the embedded PTU target. The format of the message
            /// is specific to the type of request made.
            /// </summary>
            /// <param name="targetIsBigEndian">true if the embedded PTU target is a Big Endian machine; false otherwise</param>
            /// <returns>ordered byte array that is to be sent to the embedded PTU target</returns>
            public Byte[] GetByteArray(Boolean targetIsBigEndian)
            {
                DataPacketProlog dpp = new DataPacketProlog();

                UInt16 numVars = streamInformation.NumberOfVariables;

                if (targetIsBigEndian)
                {
                    streamInformation.NumberOfVariables = Utils.ReverseByteOrder(streamInformation.NumberOfVariables);
                    streamInformation.NumberOfSamples = Utils.ReverseByteOrder(streamInformation.NumberOfSamples);
                    streamInformation.SampleRate = Utils.ReverseByteOrder(streamInformation.SampleRate);

                    for (UInt16 i = 0; i < numVars; i++)
                    {
                        streamInformation.StreamVariableInfo[i].Variable = Utils.ReverseByteOrder(streamInformation.StreamVariableInfo[i].Variable);
                        streamInformation.StreamVariableInfo[i].VariableType = Utils.ReverseByteOrder(streamInformation.StreamVariableInfo[i].VariableType);
                    }
                }

                MemoryStream ms = new MemoryStream(MAX_TX_STREAM_SIZE);
                BinaryWriter bw = new BinaryWriter(ms);
                bw.Write(streamInformation.NumberOfVariables);
                bw.Write(streamInformation.NumberOfSamples);
                bw.Write(streamInformation.SampleRate);
                for (UInt16 i = 0; i < numVars; i++)
                {
                    bw.Write(streamInformation.StreamVariableInfo[i].Variable);
                    bw.Write(streamInformation.StreamVariableInfo[i].VariableType);
                }
                return dpp.GetByteArray(ms.ToArray(), PACKET_TYPE, RESPONSE_TYPE, targetIsBigEndian);
            }