Subversion Repositories rio

-------------------------------------------------------------------------------

-- 

-- RapidIO IP Library Core

-- 

-- This file is part of the RapidIO IP library project

-- http://www.opencores.org/cores/rio/

-- 

-- Description

-- Contains automatic simulation test code to verify a RioSerial implementation.

-- 

-- To Do:

-- -

-- 

-- Author(s): 

-- - Magnus Rosenius, magro732@opencores.org 

-- 

-------------------------------------------------------------------------------

-- 

-- Copyright (C) 2013 Authors and OPENCORES.ORG 

-- 

-- This source file may be used and distributed without 

-- restriction provided that this copyright statement is not 

-- removed from the file and that any derivative work contains 

-- the original copyright notice and the associated disclaimer. 

-- 

-- This source file is free software; you can redistribute it 

-- and/or modify it under the terms of the GNU Lesser General 

-- Public License as published by the Free Software Foundation; 

-- either version 2.1 of the License, or (at your option) any 

-- later version. 

-- 

-- This source is distributed in the hope that it will be 

-- useful, but WITHOUT ANY WARRANTY; without even the implied 

-- warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 

-- PURPOSE. See the GNU Lesser General Public License for more 

-- details. 

-- 

-- You should have received a copy of the GNU Lesser General 

-- Public License along with this source; if not, download it 

-- from http://www.opencores.org/lgpl.shtml 

-- 

-------------------------------------------------------------------------------

-------------------------------------------------------------------------------

-- TestRioSerial.

-------------------------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

use ieee.numeric_std.all;

library std;

use std.textio.all;

use work.rio_common.all;

-------------------------------------------------------------------------------

-- Entity for TestRioSerial.

-------------------------------------------------------------------------------

entity TestRioSerial is

end entity;

-------------------------------------------------------------------------------

-- Architecture for TestUart.

-------------------------------------------------------------------------------

architecture TestRioSerialImpl of TestRioSerial is

  component TestSwitchPort is

    generic(

      NUMBER_WORDS : natural range 1 to 8 := 1);

    port(

      clk : in std_logic;

      areset_n : in std_logic;

      frameValid_i : in std_logic_vector(0 to 63);

      frameWrite_i : in RioFrameArray(0 to 63);

      frameComplete_o : out std_logic_vector(0 to 63);

      frameExpected_i : in std_logic;

      frameRead_i : in RioFrame;

      frameReceived_o : out std_logic;

      readFrameEmpty_o : out std_logic;

      readFrame_i : in std_logic;

      readFrameRestart_i : in std_logic;

      readFrameAborted_o : out std_logic;

      readWindowEmpty_o : out std_logic;

      readWindowReset_i : in std_logic;

      readWindowNext_i : in std_logic;

      readContentEmpty_o : out std_logic;

      readContent_i : in std_logic;

      readContentEnd_o : out std_logic;

      readContentData_o : out std_logic_vector(2+(32*NUMBER_WORDS-1) downto 0);

      writeFrameFull_o : out std_logic;

      writeFrame_i : in std_logic;

      writeFrameAbort_i : in std_logic;

      writeContent_i : in std_logic;

      writeContentData_i : in std_logic_vector(2+(32*NUMBER_WORDS-1) downto 0));

  end component;

  component RioSerial is

    generic(

      TIMEOUT_WIDTH : natural;

      NUMBER_WORDS : natural range 1 to 8 := 1);

    port(

      clk : in std_logic;

      areset_n : in std_logic;

      portLinkTimeout_i : in std_logic_vector(TIMEOUT_WIDTH-1 downto 0);

      linkInitialized_o : out std_logic;

      inputPortEnable_i : in std_logic;

      outputPortEnable_i : in std_logic;

      localAckIdWrite_i : in std_logic;

      clrOutstandingAckId_i : in std_logic;

      inboundAckId_i : in std_logic_vector(4 downto 0);

      outstandingAckId_i : in std_logic_vector(4 downto 0);

      outboundAckId_i : in std_logic_vector(4 downto 0);

      inboundAckId_o : out std_logic_vector(4 downto 0);

      outstandingAckId_o : out std_logic_vector(4 downto 0);

      outboundAckId_o : out std_logic_vector(4 downto 0);

      readFrameEmpty_i : in std_logic;

      readFrame_o : out std_logic;

      readFrameRestart_o : out std_logic;

      readFrameAborted_i : in std_logic;

      readWindowEmpty_i : in std_logic;

      readWindowReset_o : out std_logic;

      readWindowNext_o : out std_logic;

      readContentEmpty_i : in std_logic;

      readContent_o : out std_logic;

      readContentEnd_i : in std_logic;

      readContentData_i : in std_logic_vector(2+(32*NUMBER_WORDS-1) downto 0);

      writeFrameFull_i : in std_logic;

      writeFrame_o : out std_logic;

      writeFrameAbort_o : out std_logic;

      writeContent_o : out std_logic;

      writeContentData_o : out std_logic_vector(2+(32*NUMBER_WORDS-1) downto 0);

      portInitialized_i : in std_logic;

      outboundSymbolEmpty_o : out std_logic;

      outboundSymbolRead_i : in std_logic;

      outboundSymbol_o : out std_logic_vector(2+(32*NUMBER_WORDS-1) downto 0);

      inboundSymbolFull_o : out std_logic;

      inboundSymbolWrite_i : in std_logic;

      inboundSymbol_i : in std_logic_vector(2+(32*NUMBER_WORDS-1) downto 0));

  end component;

  constant NUMBER_WORDS : natural range 1 to 8 := 1;

  signal clk : std_logic;

  signal areset_n : std_logic;

  signal portLinkTimeout : std_logic_vector(10 downto 0);

  signal linkInitialized : std_logic;

  signal inputPortEnable : std_logic;

  signal outputPortEnable : std_logic;

  signal localAckIdWrite : std_logic;

  signal clrOutstandingAckId : std_logic;

  signal inboundAckIdWrite : std_logic_vector(4 downto 0);

  signal outstandingAckIdWrite : std_logic_vector(4 downto 0);

  signal outboundAckIdWrite : std_logic_vector(4 downto 0);

  signal inboundAckIdRead : std_logic_vector(4 downto 0);

  signal outstandingAckIdRead : std_logic_vector(4 downto 0);

  signal outboundAckIdRead : std_logic_vector(4 downto 0);

  signal portInitialized : std_logic;

  signal outboundSymbolEmpty : std_logic;

  signal outboundSymbolRead : std_logic;

  signal outboundSymbol : std_logic_vector(2+(32*NUMBER_WORDS-1) downto 0);

  signal inboundSymbolFull : std_logic;

  signal inboundSymbolWrite : std_logic;

  signal inboundSymbol : std_logic_vector(2+(32*NUMBER_WORDS-1) downto 0);

  signal readFrameEmpty : std_logic;

  signal readFrame : std_logic;

  signal readFrameRestart : std_logic;

  signal readFrameAborted : std_logic;

  signal readWindowEmpty : std_logic;

  signal readWindowReset : std_logic;

  signal readWindowNext : std_logic;

  signal readContentEmpty : std_logic;

  signal readContent : std_logic;

  signal readContentEnd : std_logic;

  signal readContentData : std_logic_vector(2+(32*NUMBER_WORDS-1) downto 0);

  signal writeFrameFull : std_logic;

  signal writeFrame : std_logic;

  signal writeFrameAbort : std_logic;

  signal writeContent : std_logic;

  signal writeContentData : std_logic_vector(2+(32*NUMBER_WORDS-1) downto 0);

  signal frameValid : std_logic_vector(0 to 63);

  signal frameWrite : RioFrameArray(0 to 63);

  signal frameComplete : std_logic_vector(0 to 63);

  signal frameExpected : std_logic;

  signal frameRead : RioFrame;

  signal frameReceived : std_logic;

begin

  -----------------------------------------------------------------------------

  -- Clock generation.

  -----------------------------------------------------------------------------

  ClockGenerator: process

  begin

    clk <= '0';

    wait for 20 ns;

    clk <= '1';

    wait for 20 ns;

  end process;

  -----------------------------------------------------------------------------

  -- Serial protocol test driver.

  -----------------------------------------------------------------------------

  TestDriver: process

    ---------------------------------------------------------------------------

    -- Procedure to receive a symbol.

    ---------------------------------------------------------------------------

    procedure ReceiveSymbol(

      constant symbolType : in std_logic_vector(1 downto 0);

      constant symbolContent : in std_logic_vector(31 downto 0) := x"00000000") is

    begin

      wait until outboundSymbolEmpty = '0' and clk'event and clk = '1';

      while ((outboundSymbol(33 downto 32) = SYMBOL_IDLE) and

             (symbolType /= SYMBOL_IDLE)) loop

        outboundSymbolRead <= '1';

        wait until clk'event and clk = '1';

        outboundSymbolRead <= '0';

        wait until outboundSymbolEmpty = '0' and clk'event and clk = '1';

      end loop;

      assert symbolType = outboundSymbol(33 downto 32)

        report "Missmatching symbol type:expected=" &

        integer'image(to_integer(unsigned(symbolType))) &

        " got=" &

        integer'image(to_integer(unsigned(outboundSymbol(33 downto 32))))

        severity error;

      if (outboundSymbol(33 downto 32) = SYMBOL_CONTROL) then

        assert symbolContent(31 downto 8) = outboundSymbol(31 downto 8)

          report "Missmatching symbol content:expected=" &

          integer'image(to_integer(unsigned(symbolContent(31 downto 8)))) &

          " got=" &

          integer'image(to_integer(unsigned(outboundSymbol(31 downto 8))))

          severity error;

      elsif (outboundSymbol(33 downto 32) = SYMBOL_DATA) then

        assert symbolContent(31 downto 0) = outboundSymbol(31 downto 0)

          report "Missmatching symbol content:expected=" &

          integer'image(to_integer(unsigned(symbolContent(31 downto 0)))) &

          " got=" &

          integer'image(to_integer(unsigned(outboundSymbol(31 downto 0))))

          severity error;

      end if;

      outboundSymbolRead <= '1';

      wait until clk'event and clk = '1';

      outboundSymbolRead <= '0';

    end procedure;

    ---------------------------------------------------------------------------

    -- Procedure to send a symbol.

    ---------------------------------------------------------------------------

    procedure SendSymbol(

      constant symbolType : in std_logic_vector(1 downto 0);

      constant symbolContent : in std_logic_vector(31 downto 0) := x"00000000") is

    begin

      wait until inboundSymbolFull = '0' and clk'event and clk = '1';

      inboundSymbolWrite <= '1';

      inboundSymbol <= symbolType & symbolContent;

      wait until clk'event and clk = '1';

      inboundSymbolWrite <= '0';

    end procedure;

    ---------------------------------------------------------------------------

    -- Process variables.

    ---------------------------------------------------------------------------

    variable seed1 : positive := 1;

    variable seed2 : positive := 1;

    variable payload : RioPayload;

    variable frame : RioFrame;

  begin

    ---------------------------------------------------------------------------

    -- Test case initialization.

    ---------------------------------------------------------------------------

    frameValid <= (others=>'0');

    frameExpected <= '0';

    portLinkTimeout <= (others=>'1');

    inputPortEnable <= '1';

    outputPortEnable <= '1';

    portInitialized <= '0';

    outboundSymbolRead <= '0';

    inboundSymbolWrite <= '0';

    inboundSymbol <= (others => '0');

    localAckIdWrite <= '0';

    clrOutstandingAckId <= '0';

    inboundAckIdWrite <= (others=>'0');

    outstandingAckIdWrite <= (others=>'0');

    outboundAckIdWrite <= (others=>'0');

    -- Generate a startup reset pulse.

    areset_n <= '0';

    wait until clk'event and clk = '1';

    wait until clk'event and clk = '1';

    areset_n <= '1';

    wait until clk'event and clk = '1';

    wait until clk'event and clk = '1';

    ---------------------------------------------------------------------------

    PrintS("-----------------------------------------------------------------");

    PrintS("TG_RioSerial");

    PrintS("-----------------------------------------------------------------");

    PrintS("TG_RioSerial-TC1");

    PrintS("Description: Test idle-sequence transmission at startup.");

    PrintS("Requirement: XXXXX");

    PrintS("-----------------------------------------------------------------");

    PrintS("Step 1:");

    PrintS("Action: Read transmission port.");

    PrintS("Result: Idle sequence symbols should be read.");

    ---------------------------------------------------------------------------

    PrintR("TG_RioSerial-TC1-Step1");

    ---------------------------------------------------------------------------

    -- Make sure only idle-sequences are transmitted at startup.

    for i in 0 to 1024 loop

      ReceiveSymbol(SYMBOL_IDLE);

    end loop;

    ---------------------------------------------------------------------------

    PrintS("-----------------------------------------------------------------");

    PrintS("TG_RioSerial-TC2");

    PrintS("Description: Test idle-sequence and status symbol transmission");

    PrintS("             when the port has been initialized.");

    PrintS("Requirement: XXXXX");

    PrintS("-----------------------------------------------------------------");

    PrintS("Step 1:");

    PrintS("Action: Set port initialized and read transmission port.");

    PrintS("Result: Idle sequence and status symbols should be read.");

    ---------------------------------------------------------------------------

    PrintR("TG_RioSerial-TC2-Step1");

    ---------------------------------------------------------------------------

    -- Initialize the port to trigger a change of state.

    portInitialized <= '1';

    -- The transmitter should send idle sequences at startup and a status once

    -- in a while.

    for i in 0 to 254 loop

      ReceiveSymbol(SYMBOL_IDLE);

    end loop;

    ReceiveSymbol(SYMBOL_CONTROL,

                  RioControlSymbolCreate(STYPE0_STATUS, "00000", "11111",

                                         STYPE1_NOP, "000"));

    for i in 0 to 254 loop

      ReceiveSymbol(SYMBOL_IDLE);

    end loop;

    ReceiveSymbol(SYMBOL_CONTROL,

                  RioControlSymbolCreate(STYPE0_STATUS, "00000", "11111",

                                         STYPE1_NOP, "000"));

    ---------------------------------------------------------------------------

    PrintS("-----------------------------------------------------------------");

    PrintS("Step 2:");

    PrintS("Action: Toggle port initialized pin and check that no status ");

    PrintS("        symbols are transmitted when uninitialized.");

    PrintS("Result: Only idle sequences should be read when uninitialized.");

    ---------------------------------------------------------------------------

    PrintR("TG_RioSerial-TC2-Step2");

    ---------------------------------------------------------------------------

    -- Deassert the port initialized flag.

    portInitialized <= '0';

    -- Make sure only idle-sequences are transmitted at startup.

    for i in 0 to 1024 loop

      ReceiveSymbol(SYMBOL_IDLE);

    end loop;

    -- Initialize the port to trigger a change of state.

    portInitialized <= '1';

    -- The transmitter should send idle sequences at startup and a status once

    -- in a while.

    for i in 0 to 254 loop

      ReceiveSymbol(SYMBOL_IDLE);

    end loop;

    ReceiveSymbol(SYMBOL_CONTROL,

                  RioControlSymbolCreate(STYPE0_STATUS, "00000", "11111",

                                         STYPE1_NOP, "000"));

    for i in 0 to 254 loop

      ReceiveSymbol(SYMBOL_IDLE);

    end loop;

    ReceiveSymbol(SYMBOL_CONTROL,

                  RioControlSymbolCreate(STYPE0_STATUS, "00000", "11111",

                                         STYPE1_NOP, "000"));

    ---------------------------------------------------------------------------

    PrintS("-----------------------------------------------------------------");

    PrintS("Step 3:");

    PrintS("Action: Send one error free status symbol to trigger the ");

    PrintS("        transmission of status symbols with a higher frequency.");

    PrintS("Result: Idle sequence and status symbols should be read but ");

    PrintS("        status symbols should be recived more often.");

    ---------------------------------------------------------------------------

    PrintR("TG_RioSerial-TC2-Step3");

    ---------------------------------------------------------------------------

    -- A received error-free status triggers transmission of status symbols in

    -- a more rapid past.

    SendSymbol(SYMBOL_CONTROL,

               RioControlSymbolCreate(STYPE0_STATUS, "00000", "11111",

                                      STYPE1_NOP, "000"));

    -- The transmitter should send at least 15 additional statuses after

    -- receiving an error free status.

    for j in 0 to 15 loop

      for i in 0 to 15 loop

        ReceiveSymbol(SYMBOL_IDLE);

      end loop;

      ReceiveSymbol(SYMBOL_CONTROL,

                    RioControlSymbolCreate(STYPE0_STATUS, "00000", "11111",

                                           STYPE1_NOP, "000"));

    end loop;

    ---------------------------------------------------------------------------

    PrintS("-----------------------------------------------------------------");

    PrintS("Step 4:");

    PrintS("Action: Send one errornous status symbol to restart the status ");

    PrintS("        counting.");

    PrintS("Result: Idle sequence and status symbols should be read but ");

    PrintS("        status symbols should still be received more often.");

    ---------------------------------------------------------------------------

    PrintR("TG_RioSerial-TC2-Step4");

    ---------------------------------------------------------------------------

    -- REMARK: Add this...

    PrintR("Not implemented.");

    ---------------------------------------------------------------------------

    PrintS("-----------------------------------------------------------------");

    PrintS("Step 5:");

    PrintS("Action: Send one errornous status symbol to restart the status ");

    PrintS("        counting.");

    PrintS("Result: Idle sequence and status symbols should be read but ");

    PrintS("        status symbols should still be received more often.");

    ---------------------------------------------------------------------------

    PrintR("TG_RioSerial-TC2-Step5");

    ---------------------------------------------------------------------------

    -- Make the link fully initialized by sending 7 additional statuses.

    for i in 0 to 6 loop

      SendSymbol(SYMBOL_CONTROL,

                 RioControlSymbolCreate(STYPE0_STATUS, "00000", "11111",

                                        STYPE1_NOP, "000"));

    end loop;

    ReceiveSymbol(SYMBOL_IDLE);

    ReceiveSymbol(SYMBOL_IDLE);

    wait until linkInitialized = '1';

    ---------------------------------------------------------------------------

    PrintS("-----------------------------------------------------------------");

    PrintS("TG_RioSerial-TC3");

    PrintS("Description: Test port reception.");

    PrintS("Requirement: XXXXX");

    PrintS("-----------------------------------------------------------------");

    PrintS("Step 1:");

    PrintS("Action: Send an inbound frame with pad after the CRC.");

    PrintS("Result: The frame should end up in a frame buffer.");

    ---------------------------------------------------------------------------

    PrintR("TG_RioSerial-TC3-Step1");

    ---------------------------------------------------------------------------

    -- Create the frame.

    CreateRandomPayload(payload.data, seed1, seed2);

    payload.length := 1;

    frame := RioFrameCreate(ackId=>"00000", vc=>'0', crf=>'0', prio=>"00",

                            tt=>"01", ftype=>"0000",

                            sourceId=>x"0000", destId=>x"0000",

                            payload=>payload);

    frameExpected <= '1';

    frameRead <= frame;

    -- Start the reception of a frame.

    SendSymbol(SYMBOL_CONTROL,

               RioControlSymbolCreate(STYPE0_STATUS, "00000", "11111",

                                      STYPE1_START_OF_PACKET, "000"));

    -- Send the data symbols of the frame.

    for i in 0 to frame.length-1 loop

      SendSymbol(SYMBOL_DATA, frame.payload(i));

    end loop;

    -- End the reception of the frame.

    SendSymbol(SYMBOL_CONTROL,

               RioControlSymbolCreate(STYPE0_STATUS, "00000", "11111",

                                      STYPE1_END_OF_PACKET, "000"));

    -- Check that the frame has been received in the frame buffer.

    wait until frameReceived = '1';

    frameExpected <= '0';

    -- Receive an idle symbol left in the FIFO before the ack was generated.

    ReceiveSymbol(SYMBOL_IDLE);

    -- Receive acknowledge for the transmitted frame.

    ReceiveSymbol(SYMBOL_CONTROL,

                  RioControlSymbolCreate(STYPE0_PACKET_ACCEPTED, "00000", "11111",

                                         STYPE1_NOP, "000"));

    ---------------------------------------------------------------------------

    PrintS("-----------------------------------------------------------------");

    PrintS("Step 2:");

    PrintS("Action: Send an inbound frame without a pad after the CRC.");

    PrintS("Result: The frame should end up in a frame buffer.");

    ---------------------------------------------------------------------------

    PrintR("TG_RioSerial-TC3-Step2");

    ---------------------------------------------------------------------------

    -- Create the frame.

    CreateRandomPayload(payload.data, seed1, seed2);

    payload.length := 2;

    frame := RioFrameCreate(ackId=>"00001", vc=>'0', crf=>'0', prio=>"00",

                            tt=>"01", ftype=>"0000",

                            sourceId=>x"0000", destId=>x"0000",

                            payload=>payload);

    frameExpected <= '1';

    frameRead <= frame;

    -- Start the reception of a frame.

    SendSymbol(SYMBOL_CONTROL,

               RioControlSymbolCreate(STYPE0_STATUS, "00000", "11111",

                                      STYPE1_START_OF_PACKET, "000"));

    -- Send the data symbols of the frame.

    for i in 0 to frame.length-1 loop

      SendSymbol(SYMBOL_DATA, frame.payload(i));

    end loop;

    -- End the reception of the frame.

    SendSymbol(SYMBOL_CONTROL,

               RioControlSymbolCreate(STYPE0_STATUS, "00000", "11111",

                                      STYPE1_END_OF_PACKET, "000"));

    -- Check that the frame has been received in the frame buffer.

    wait until frameReceived = '1';

    frameExpected <= '0';

    -- Receive an idle symbol left in the FIFO before the ack was generated.

    ReceiveSymbol(SYMBOL_IDLE);

    -- Receive acknowledge for the transmited frame.

    ReceiveSymbol(SYMBOL_CONTROL,

                  RioControlSymbolCreate(STYPE0_PACKET_ACCEPTED, "00001", "11111",

                                         STYPE1_NOP, "000"));

    ---------------------------------------------------------------------------

    PrintS("-----------------------------------------------------------------");

    PrintS("Step 3:");

    PrintS("Action: Send an inbound frame with maximum size.");

    PrintS("Result: The frame should end up in a frame buffer.");

    ---------------------------------------------------------------------------

    PrintR("TG_RioSerial-TC3-Step3");

    ---------------------------------------------------------------------------

    -- Create the frame.

    CreateRandomPayload(payload.data, seed1, seed2);

    payload.length := 133;

    frame := RioFrameCreate(ackId=>"00010", vc=>'0', crf=>'0', prio=>"00",

                            tt=>"01", ftype=>"0000",

                            sourceId=>x"0000", destId=>x"0000",

                            payload=>payload);

    frameExpected <= '1';

    frameRead <= frame;

    -- Start the reception of a frame.

    SendSymbol(SYMBOL_CONTROL,

               RioControlSymbolCreate(STYPE0_STATUS, "00000", "11111",

                                      STYPE1_START_OF_PACKET, "000"));

    -- Send the data symbols of the frame.

    for i in 0 to frame.length-1 loop

      SendSymbol(SYMBOL_DATA, frame.payload(i));

    end loop;

    -- End the reception of the frame.

    SendSymbol(SYMBOL_CONTROL,

               RioControlSymbolCreate(STYPE0_STATUS, "00000", "11111",

                                      STYPE1_END_OF_PACKET, "000"));

    -- Check that the frame has been received in the frame buffer.

    wait until frameReceived = '1';

    frameExpected <= '0';

    -- Receive an idle symbol left in the FIFO before the ack was generated.

    ReceiveSymbol(SYMBOL_IDLE);

    -- Receive acknowledge for the transmitted frame.

    ReceiveSymbol(SYMBOL_CONTROL,

                  RioControlSymbolCreate(STYPE0_PACKET_ACCEPTED, "00010", "11111",

                                         STYPE1_NOP, "000"));

    ---------------------------------------------------------------------------

    PrintS("-----------------------------------------------------------------");

    PrintS("Step 4:");

    PrintS("Action: Send two packets without end-of-packet in between.");

    PrintS("Result: Both packets should be accepted.");

    ---------------------------------------------------------------------------

    PrintR("TG_RioSerial-TC3-Step4");

    ---------------------------------------------------------------------------

    -- Create the first frame.

    CreateRandomPayload(payload.data, seed1, seed2);

    payload.length := 10;

    frame := RioFrameCreate(ackId=>"00011", vc=>'0', crf=>'0', prio=>"00",

                            tt=>"01", ftype=>"0000",

                            sourceId=>x"0000", destId=>x"0000",

                            payload=>payload);

    frameExpected <= '1';

    frameRead <= frame;

    -- Start the reception of a frame.

    SendSymbol(SYMBOL_CONTROL,

               RioControlSymbolCreate(STYPE0_STATUS, "00000", "11111",

                                      STYPE1_START_OF_PACKET, "000"));