基于CAN总线的汽车诊断协议UDS(上位机开发网络层及错误代码解析)

     UDS协议栈的开发和测试对于刚刚接触UDS协议的开发人员来说,不但需要阅读大量的标准文档,短时间内很难理解透彻,标准协议栈代码的编写更加困难,刚入门又没有快捷简单的测试工具帮助加快理解和验证,使得UDS诊断开发对于一般的初创公司或者小型企业来说,是一个比较难跨越的门槛。一般的企业通过购买专业的软件工具和专业的培训服务来获取UDS诊断开发和测试的技术。本文的目的是通过简单快捷的UDS上位机软件测试界面,有助于帮助开发者加快UDS协议栈的理解和开发测试,能够帮助开发者快速的掌握UDS开发和测试的一般过程和方法。

         

首先贴出网络层协议源码:

namespace Uds

{

    public class uds_trans

    {

        public enum AddressingModes

        {

            Physical_Addressing,

            Functional_Addressing,

        }

 

        private int id;

        /// <summary>

        /// UDS默认填充字节

        /// </summary>

        public byte fill_byte = 0x55;

 

        public int tx_id;

        public int rx_id;

        public int test_id;

        /*

        ** Frame types arranged in numericalorder for efficient switch statement

        ** jump tables.

        */

        private enum FrameType

        {

            TX_SF = 0, /* Single Frame */

            TX_FF = 1, /* First Frame */

            TX_CF = 2, /* Consecutive Frame */

            TX_FC = 3  /* Flow Control Frame */

        };

 

        /*

        ** Masks for the PCI(Protcol ControlInformation) byte.

        ** The MS bit contains the frame type.

        ** The LS bit is mapped differently,depending on frame type, as follows:

        ** SF: DL (number of diagnostic bytes NOT including the PCI byte; only the

        **      3 LS bits are used).

        ** FF: XDL (extended data length; always be 0.)

        ** CF: Sequence number,4 bits, max value:15.

        ** FC: Flow Status. The value of FS shall be set to zero that means that

        **     the tester is ready to receive a maximum number of CF.

        */

        private enum PCI /* Don't change thesevalues, these must be  */

        {

            /* MS bits -  Frame Type */

            FRAME_TYPE_MASK = 0xF0,

            SF_TPDU = 0x00,             /* Single frame                 */

            FF_TPDU = 0x10,             /* First frame                  */

            CF_TPDU = 0x20,             /* Consecutive frame            */

            FC_TPDU = 0x30,             /* Flow control frame           */

            FC_OVFL_PDU = 0x32,         /* Flow control frame           */

 

            /* LS bits - SF_DL */

            SF_DL_MAX_BYTES = 0x07,     /* SF Max Data Length */

            SF_DL_MASK = 0x07,          /* number diagnostic data bytes */

            SF_DL_MASK_LONG = 0x0F,     /* change to check the 4 bits for testing,number diagnostic data bytes */

 

            /* LS bits - FF_DL */

            FF_EX_DL_MASK = 0x0F,       /*Extended data length         */

 

            /* LS bits - CF_SN */

            CF_SN_MASK = 0x0F,          /* Sequence number mask         */

            CF_SN_MAX_VALUE = 0x0F,     /* Max value of sequence number */

 

            /* LS bits - FC Saatus */

            FC_STATUS_CONTINUE = 0x00,  /* Flow control frame, CONTINUE */

            FC_STATUS_WAIT = 0x01,      /* Flow control frame, WAIT */

            FC_STATUS_OVERFLOW = 0x02,  /* Flow control frame, OVERFLOW */

            FC_STATUS_MASK = 0x0F,

        };

 

        private int N_As = 25;

        private int N_Ar = 25;

 

        private int N_Bs = 75;

        private int N_Br;

 

        private int N_Cr = 150;

        private int N_Cs;

 

        private int FC_BS_MAX_VALUE = 0;

        private int FC_ST_MIN_VALUE = 5;

 

        private int CF_SN_MAX_VALUE = 15;

        private int SF_DL_MAX_BYTES = 7;

 

        /*

        ** Time to wait for the tester to senda FC frame in response

        ** to a FF(wait for flow control frametime out).

        ** N_As + N_Bs = 25 +75 = 100ms

        */

        private int FC_WAIT_TIMEOUT;//N_As +N_Bs + 50;

 

        /*

        ** wait for Consecutive frame time out

        ** N_Cr < 150ms

        */

        private int CF_WAIT_TIMEOUT;//N_Cr; //(N_Cr- 10))

 

        private int RX_MAX_TP_BYTES = 0xFFF;

 

 

        public uds_trans()

        {

            can_rx_info.frame = new byte[8];

            can_tx_info.frame = new byte[8];

 

            FC_WAIT_TIMEOUT = N_As + N_Bs + 50;/* N_As + N_Bs + 50 */

            CF_WAIT_TIMEOUT = N_Cr;             /* (N_Cr - 10)) */

        }

 

        private readonly intbeginning_seq_number = 1;

        private readonly int TPCI_Byte = 0;

        private readonly int DL_Byte = 1;

        private readonly int BS_Byte = 1;

        private readonly int STminByte = 2;

 

        private class tx_info

        {

            public bool tx_rx_idle = false;

            public bool tx_fc_tpdu = false;

            public bool tx_last_frame_error = false;

            public bool tx_wait_fc = false;

            public bool tx_in_progress = false;

 

            public int tx_block_size = 0;           /* BS(Block Size) in a flow ControlFrame */

            public int tx_stmin_time = 20;

            public int tx_cf_stmin_wait_time =20;   /* STmin Time in Flow Control Frame*/

            public int tx_fc_wait_time =0;         /* Wait for FC when has sentFF */

 

            public int lenght;

            public int offset;

            public int next_seq_num;

            public byte[] buffer;

            public byte[] frame;

        }

 

        private class rx_info

        {

            public bool rx_in_progress = false;

 

            public bool rx_msg_rcvd =false;        /* if the message has neverbeen received to be used by application level software */

            public bool tx_aborted = false;

 

            public int rx_cf_wait_time = 0;

            public boolrx_fc_wait_timeout_disable = false;

            public bool rx_overflow = false;

 

            public int lenght;

            public int offset;

            public int next_seq_num;

            public byte[] buffer;

            public byte[] frame;

        }

 

        private tx_info can_tx_info = newtx_info();

        private rx_info can_rx_info = newrx_info();

 

        #region Event

 

        public class FarmsEventArgs : EventArgs

        {

            public int id = 0;

            public int dlc = 0;

            public byte[] dat = new byte[8];

            public long time = 0;

            public override string ToString()

            {

                time %= 1000000;

                returnid.ToString("X3") + " "

                           +dlc.ToString("X1") + " "

                           + dat.HexToStrings("") + " "

                           + (time /1000).ToString() + "." + (time % 1000).ToString("d3");

            }

        }

 

        public class RxMsgEventArgs : EventArgs

        {

            public int id = 0;

            public byte[] dat;

            public long time = 0;

            public RxMsgEventArgs(int lenght)

            {

                dat = new byte[lenght];

            }

            public override string ToString()

            {

                time %= 1000000;

                returnid.ToString("X3") + " "

                           +dat.HexToStrings(" ") + " "

                           + (time /1000).ToString() + "." + (time % 1000).ToString("d3");

            }

        }

 

        public class ErrorEventArgs : EventArgs

        {

            public string error;

 

            public override string ToString()

            {

                return error;

            }

        }

 

        /// <summary>

        /// UDS 传输层发送一帧事件

        /// </summary>

        public event EventHandler EventTxFarms;

        /// <summary>

        /// UDS 传输层接收一帧事件

        /// </summary>

        public event EventHandler EventRxFarms;

        /// <summary>

        /// UDS 传输层接收完成事件

        /// </summary>

        public event EventHandler EventRxMsgs;

        /// <summary>

        /// UDS 传输层错误事件

        /// </summary>

        public event EventHandler EventError;

 

        private void TxFarmsEvent(int id,byte[] dat, int dlc, long time)

        {

            if (EventTxFarms != null)

            {

                FarmsEventArgs e_args = newFarmsEventArgs();

                e_args.id = id;

                e_args.dlc = dlc;

                e_args.time = time;

                Array.Copy(dat, e_args.dat,dlc);

                EventTxFarms(this, e_args);

            }

        }

 

        private void RxFarmsEvent(int id,byte[] dat, int dlc, long time)

        {

            if (EventRxFarms != null)

            {

                FarmsEventArgs e_args = newFarmsEventArgs();

                e_args.id = id;

                e_args.dlc = dlc;

                e_args.time = time;

                Array.Copy(dat, e_args.dat,dlc);

                EventRxFarms(this, e_args);

            }

        }

 

        private void RxMsgEvent(int id, byte[]dat)

        {

            if (EventRxMsgs != null)

            {

                int lenght = dat.Length;

                RxMsgEventArgs e_rx_msg_args =new RxMsgEventArgs(lenght);

                e_rx_msg_args.id = id;

                Array.Copy(dat,e_rx_msg_args.dat, lenght);

                EventRxMsgs(this,e_rx_msg_args);

            }

        }

 

        private void RrrorEvent(string strings)

        {

            if (EventError != null)

            {

                ErrorEventArgs e_args = newErrorEventArgs();

                e_args.error = strings;

                EventError(this, e_args);

            }

        }

 

        public delegate bool CanWriteData(intid, byte[] dat, int dlc, out long time);

        public delegate bool CanReadData(outint id, ref byte[] dat, out int dlc, out long time);

 

        /// <summary>

        /// 利用委托发送一帧数据

        /// </summary>

        public CanWriteData WriteData;

        /// <summary>

        /// 利用委托接收一帧数据

        /// </summary>

        public CanReadData ReadData;

 

        #endregion

 

        #region Trans Thread

 

        Thread testerPresent_thread;

        private void testerPresent_Thread()

        {

            while (true)

            {

                long time;

                if (WriteData != null&& WriteData(test_id, new byte[] { 0x02, 0x3E, 0x80, 0x00, 0x00, 0x00,0x00, 0x00 }, 8, out time) == true)

                {

                    Thread.Sleep(3000);

                }

            }

        }

        private bool tester = false;

        /// <summary>

        /// 诊断保持

        /// </summary>

        public bool testerPresentCheckd

        {

            set

            {

                tester = value;

                if (tester)

                {

                    testerPresent_thread = newThread(new ThreadStart(testerPresent_Thread));

                   testerPresent_thread.Start();

                }

                else

                {

                    if (testerPresent_thread !=null && testerPresent_thread.IsAlive)

                    {

                       testerPresent_thread.Abort();

                    }

                }

            }

            get

            {

                return tester;

            }

        }

        Thread trans_thread;

        private void CanTrans_Thread()

        {

            long oldTime = DateTime.Now.Ticks;

            while (true)

            {

                long cnt;

                int id;

                int dlc;

                long time;

                byte[] dat = new byte[8];

                while (true)

                {

                    bool rx_frame = false;

                    while (ReadData != null&& ReadData(out id, ref dat, out dlc, out time) == true)

                    {

                        if (id == rx_id&& dlc == 8)

                        {

                            if(can_rx_info.rx_in_progress && dat[0] == 0x02 && dat[1] == 0x7F&& dat[3] == 0x78)

                            {

                                can_rx_info.rx_cf_wait_time = 5000;

                                break;

                            }

                            Array.Copy(dat,can_rx_info.frame, 8);

                            RxFarmsEvent(id,dat, dlc, time);

                            rx_frame = true;

                            break;

                        }

                    }

                    long nowTime =DateTime.Now.Ticks;

                    cnt = nowTime - oldTime;

                    if (cnt > 10000 ||rx_frame)

                    {

                        oldTime = nowTime;

                        break;

                    }

                    else if(!can_tx_info.tx_in_progress && !can_rx_info.rx_in_progress)     //UDS空闲,释放进程

                    {

                        Thread.Sleep(1);

                    }

                }

                CanTrans_Manage((int)(cnt +5000) / 10000);

            }

        }

        /// <summary>

        /// UDS 传输层开启

        /// </summary>

        public void Start()

        {

            trans_thread = new Thread(newThreadStart(CanTrans_Thread));

            trans_thread.Priority =ThreadPriority.Highest;

            trans_thread.Start();

        }

 

        /// <summary>

        /// UDS 传输层关闭

        /// </summary>

        public void Stop()

        {

            if (trans_thread != null &&trans_thread.IsAlive)

            {

                trans_thread.Abort();

            }

            testerPresentCheckd = false;

        }

 

        #endregion

 

        private byte[] tx_msg = new byte[0];

 

        /// <summary>

        /// 发送信息

        /// </summary>

        /// <paramname="mode"></param>

        /// <paramname="msg"></param>

        /// <returns></returns>

        public bool CanTrans_TxMsg(AddressingModesmode, byte[] msg)

        {

            if (msg.Length == 0)

            {

                RrrorEvent("-->Error:Tx Msg Length Is Zero");

                return false;

            }

            if (msg.Length > RX_MAX_TP_BYTES- 2)

            {

                RrrorEvent("-->Error:Tx Msg Length > RX_MAX_TP_BYTES");

                return false;

            }

            if (tx_msg.Length != 0)

            {

                RrrorEvent("-->Error:Tx Msg ing");

                return false;

            }

            if (mode ==AddressingModes.Physical_Addressing)

            {

                id = tx_id;

            }

            else

            {

                id = test_id;

            }

            tx_msg = msg;

            tx_msg = new byte[msg.Length];

            Array.Copy(msg, tx_msg,msg.Length);

            return true;

        }

 

        /// <summary>

        /// 发送信息

        /// </summary>

        /// <paramname="mode"></param>

        /// <paramname="strings"></param>

        /// <returns></returns>

        public boolCanTrans_TxMsg(AddressingModes mode, string strings)

        {

            return CanTrans_TxMsg(mode,strings.StringToHex());

        }

 

        private void CanTrans_TxMsg()

        {

            if (tx_msg.Length == 0)

            {

                return;

            }

            /*

            ** Set the tx_in_progress bit...itwill be cleared when TX is done.

            */

            can_tx_info.tx_in_progress = true;

            can_tx_info.tx_last_frame_error =false;

 

            /*

            ** Assign fields in the controlstructure to initiate TX, then TX the

            ** appropriate frame type.

            */

            can_tx_info.offset = 0;

            can_tx_info.lenght = tx_msg.Length;

            can_tx_info.buffer = newbyte[tx_msg.Length];

            Array.Copy(tx_msg,can_tx_info.buffer, can_tx_info.lenght);

            can_tx_info.offset = 0;

            tx_msg = new byte[0];

 

            if (can_tx_info.lenght <= SF_DL_MAX_BYTES)

            {

               CanTrans_TxFrame(FrameType.TX_SF);

            }

            else

            {

               CanTrans_TxFrame(FrameType.TX_FF);

            }

        }

 

        private void CanTrans_TxFrame(FrameTypeframe_type)

        {

            int tx_farme_index = 0;

            int tx_data_bytes = 0;

 

            if (can_tx_info.tx_last_frame_error== false)

            {

                can_tx_info.frame = new byte[8]{ fill_byte, fill_byte, fill_byte, fill_byte, fill_byte, fill_byte, fill_byte,fill_byte };

 

                /*

                ** Place control bytes into theframe.

                */

                switch (frame_type)

                {

                    case FrameType.TX_SF: /*single frame */

                       can_tx_info.frame[TPCI_Byte] = (byte)((byte)PCI.SF_TPDU |can_tx_info.lenght);

                        tx_data_bytes =can_tx_info.lenght;

                        tx_farme_index = 1;

                        break;

 

                    case FrameType.TX_FF: /* first frame */

                       can_tx_info.frame[TPCI_Byte] = (byte)((byte)PCI.FF_TPDU |(can_tx_info.lenght >> 8) & 0x0F);

                       can_tx_info.frame[DL_Byte] = (byte)(can_tx_info.lenght & 0xFF);

                        tx_data_bytes = SF_DL_MAX_BYTES- 1;

                        tx_farme_index = 2;

                       can_tx_info.next_seq_num = beginning_seq_number;

                       can_rx_info.rx_fc_wait_timeout_disable = false;

                        break;

 

                    case FrameType.TX_CF: /*conscutive frame */

                       can_tx_info.frame[TPCI_Byte] = (byte)((byte)PCI.CF_TPDU |can_tx_info.next_seq_num);

                        tx_farme_index = 1;

                        tx_data_bytes = (can_tx_info.lenght -can_tx_info.offset);

                        if (tx_data_bytes >SF_DL_MAX_BYTES)

                        {

                            tx_data_bytes =SF_DL_MAX_BYTES;

                        }

                       can_tx_info.next_seq_num = (can_tx_info.next_seq_num + 1) %(CF_SN_MAX_VALUE + 1);

 

                        break;

 

                    case FrameType.TX_FC: /*single frame */

                        if(can_rx_info.rx_overflow == true)

                        {

                           can_tx_info.frame[TPCI_Byte] = (byte)PCI.FC_OVFL_PDU;

                        }

                        else

                        {

                           can_tx_info.frame[TPCI_Byte] = (byte)PCI.FC_TPDU;

                        }

                       can_tx_info.frame[BS_Byte] = (byte)FC_BS_MAX_VALUE;

                       can_tx_info.frame[STminByte] = (byte)FC_ST_MIN_VALUE;

                        tx_data_bytes = 0;

                        break;

 

                    default:

                        return;

                }

 

                while (tx_data_bytes != 0)

                {

                   can_tx_info.frame[tx_farme_index++] =can_tx_info.buffer[can_tx_info.offset++];

                    tx_data_bytes--;

                }

 

            }

            long time;

            if (WriteData != null &&WriteData(id, can_tx_info.frame, 8, out time) == true)

            {

                TxFarmsEvent(id,can_tx_info.frame, 8, time);

                can_tx_info.tx_last_frame_error= false;

                can_rx_info.frame[TPCI_Byte] =0;

                /*

                ** Verify if the data has beencompletely transfered. If not, set flag to

                ** transfer CF frames. (For FCframes, s_cantp_tx_info is not used and there

                ** should not be a CF frameafter a FC frame.)

                */

                if (can_tx_info.lenght >can_tx_info.offset && frame_type != FrameType.TX_FC)

                {

                    can_tx_info.tx_in_progress =true;

 

                    if (frame_type ==FrameType.TX_FF)

                    {

                        can_tx_info.tx_wait_fc= true;

                       can_tx_info.tx_fc_wait_time = FC_WAIT_TIMEOUT; /* start flow controlwait timer */

                    }

                }

                else

                {

                    can_tx_info.tx_in_progress= false;

                }

            }

            else

            {

                /* user specific action incasetransmission request is not successful */

                can_tx_info.tx_last_frame_error= true;

            }

        }

 

        private void CanTrans_Manage(int tick)

        {

            CanTrans_TxMsg();

 

            CanTrans_Counter(tick);

 

            /*

            ** If new message has beenreceived, process it.

            */

            if (can_rx_info.frame[TPCI_Byte] !=0)

            {

                CanTrans_RxStateAnalyse();

                /*clear first rx frame byte tocheck a new frame next time*/

                can_rx_info.frame[TPCI_Byte] =0;

            }

 

            if (can_tx_info.tx_in_progress

                &&!can_tx_info.tx_wait_fc

                )

            {

                if (0x00 ==can_tx_info.tx_block_size)

                {

                    /* st_min time, receivedfrom tester*/

                    if (0x00 ==can_tx_info.tx_stmin_time)

                    {

                        CanTrans_TxFrame(FrameType.TX_CF);

                    }

                    else

                    {

                        /* st_min time,received from tester is not 0 */

                        if (0x00 ==can_tx_info.tx_cf_stmin_wait_time)

                        {

                           CanTrans_TxFrame(FrameType.TX_CF);

                           can_tx_info.tx_cf_stmin_wait_time = can_tx_info.tx_stmin_time;

                        }

                    }

                }

                else if (can_tx_info.tx_block_size> 1)

                {

                    if (0x00 ==can_tx_info.tx_stmin_time)

                    {

                       CanTrans_TxFrame(FrameType.TX_CF);

                        if(!can_tx_info.tx_last_frame_error)

                        {

                           can_tx_info.tx_block_size--;

                        }

                    }

                    else

                    {

                        if (0x00 ==can_tx_info.tx_cf_stmin_wait_time)

                        {

                           CanTrans_TxFrame(FrameType.TX_CF);

                            if(!can_tx_info.tx_last_frame_error)

                            {

                               can_tx_info.tx_block_size--;

                            }

 

                            /* start stmintime,interval of consecutive frame */

                           can_tx_info.tx_cf_stmin_wait_time = can_tx_info.tx_stmin_time;

                        }

                    }

 

                    if(can_tx_info.tx_block_size <= 1)

                    {

                        can_tx_info.tx_wait_fc= true;

 

                        /* start flow controlwait timer */

                       can_tx_info.tx_fc_wait_time = FC_WAIT_TIMEOUT;

                    }

                }

            }

            else if (can_tx_info.tx_fc_tpdu)

            {

               CanTrans_TxFrame(FrameType.TX_FC);

                can_tx_info.tx_fc_tpdu = false;

 

                /*start to counter the CF waittime*/

                can_rx_info.rx_cf_wait_time =CF_WAIT_TIMEOUT;

            }

 

            if (can_tx_info.tx_in_progress

                &&can_tx_info.tx_wait_fc

                )

            {

                /* wait for flow control frametime out! */

               if (can_tx_info.tx_fc_wait_time == 0)

                {

                    can_tx_info.tx_in_progress= false;

                    can_tx_info.tx_wait_fc =false;

                   can_tx_info.tx_last_frame_error = false;

                    RrrorEvent("-->Error: Wait For FlowControl Frame Time Out");

                }

            }

            if (can_rx_info.rx_in_progress ==true

                &&!can_tx_info.tx_fc_tpdu

              )

            {

                if (0x00 == can_rx_info.rx_cf_wait_time)

                {

                    can_rx_info.tx_aborted =true;

                    /*

                    ** wait for consecutiveframe Time out,abort Rx.

                    */

                    can_rx_info.rx_in_progress= false;

 

                    /*

                    ** When Time out occurs,ECU has to send negative

                    ** resp(71) for the firstframe.First frame is already copied in to

                    ** g_cantp_can_rx_info.msgbuffer but message length is not yet copied.

                    ** So assign data length asFirst Frame length and set RX_MSG_RCVD

                    ** flag.This flag indicatesto a new message has come.

                    */

                    can_rx_info.lenght =SF_DL_MAX_BYTES - 1;

                    can_rx_info.rx_msg_rcvd =true;

 

                   RrrorEvent("-->Error: Ecu Tx Aborted");

                }

            }

 

            if (can_rx_info.rx_msg_rcvd ==true)

            {

                can_rx_info.rx_msg_rcvd =false;

                if (can_rx_info.tx_aborted ==false)

                {

                    RxMsgEvent(rx_id,can_rx_info.buffer);

                }

                can_rx_info.tx_aborted = false;

            }

        }

 

        private void CanTrans_Counter(int tick)

        {

            /* interval of consecutive frame,STmin = 10ms, separation time */

            if(can_tx_info.tx_cf_stmin_wait_time > 0)

            {

                if(can_tx_info.tx_cf_stmin_wait_time > tick)

                {

                   can_tx_info.tx_cf_stmin_wait_time -= tick;

                }

                else

                {

                   can_tx_info.tx_cf_stmin_wait_time = 0;

                }

            }

 

            /* N_Bs, flow control frame waittime out, 75ms*/

            if (can_tx_info.tx_fc_wait_time> 0)

            {

                if (can_tx_info.tx_fc_wait_time> tick)

                {

                    can_tx_info.tx_fc_wait_time-= tick;

                }

                else

                {

                    can_tx_info.tx_fc_wait_time= 0;

                   can_rx_info.rx_fc_wait_timeout_disable = true;

                }

            }

 

            /* N_Cr,consecutive frame wait timeout, 75ms*/

            if (can_rx_info.rx_cf_wait_time> tick)

            {

                can_rx_info.rx_cf_wait_time -=tick;

            }

            else

            {

                can_rx_info.rx_cf_wait_time =0;

            }

        }

 

        private void CanTrans_RxStateAnalyse()

        {

            PCI flow_control_sts;

            int data_length = 0x00;

 

            /* single frame */

            if ((can_rx_info.frame[TPCI_Byte]& (byte)PCI.FRAME_TYPE_MASK) == (byte)PCI.SF_TPDU)

            {

                /* As per 15765-2 network layerspec when SF_DL is 0 or greater

                ** than 7, just ignore it.

                */

                data_length =(can_rx_info.frame[TPCI_Byte] & (byte)PCI.SF_DL_MASK_LONG);

 

                can_tx_info.tx_in_progress = false;

                can_tx_info.tx_wait_fc = false;

                can_rx_info.rx_in_progress =false;

                can_tx_info.tx_last_frame_error= false;

 

                if ((data_length == 0)

                 || (data_length > SF_DL_MAX_BYTES)

                  )

                {

                    return;

                }

                can_rx_info.lenght =data_length;

                can_rx_info.buffer = newbyte[can_rx_info.lenght];

                /*

                ** Copy the frame to the RXbuffer. Clear the RX_IN_PROGRESS bit

                ** (SF frame) will abortmulti-frame transfer.

                */

                Array.Copy(can_rx_info.frame,1, can_rx_info.buffer, 0, can_rx_info.lenght);

 

                can_rx_info.rx_msg_rcvd = true;

            }

            /* first frame */

            else if((can_rx_info.frame[TPCI_Byte] & (byte)PCI.FRAME_TYPE_MASK) ==(byte)PCI.FF_TPDU)

            {

                data_length = ((int)(can_rx_info.frame[TPCI_Byte]& (byte)PCI.FF_EX_DL_MASK) << 8)

                                         +can_rx_info.frame[DL_Byte];

 

               can_rx_info.rx_fc_wait_timeout_disable = false;

                can_rx_info.lenght =data_length;

                can_rx_info.buffer = newbyte[can_rx_info.lenght];

 

                /*

                ** Clear the RX buffer, copyfirst frame to RX buffer and initiate RX.

                */

                Array.Copy(can_rx_info.frame,2, can_rx_info.buffer, 0, SF_DL_MAX_BYTES - 1);

                can_rx_info.next_seq_num =beginning_seq_number;

                can_rx_info.offset =SF_DL_MAX_BYTES - 1;

 

                can_tx_info.tx_in_progress =false;

                can_tx_info.tx_wait_fc = false;

                can_rx_info.rx_in_progress =true;

 

                /* set flag to send flowcontrol frame */

                can_tx_info.tx_fc_tpdu = true;

            }

            /* Consecutive Frame */

            else if((((can_rx_info.frame[TPCI_Byte] & (byte)PCI.FRAME_TYPE_MASK) ==(byte)PCI.CF_TPDU)

                /* Don't accept consecutiveframe until flow control frame sent by ECU */

                &&(!can_tx_info.tx_fc_tpdu)

                /* Don't accept consecutiveframe if we are sending CF*/

                &&(!can_tx_info.tx_in_progress))

                )

            {

                /*

                ** Ignore frame unless RX inprogress.

                */

                if (can_rx_info.rx_in_progress)

                {

                    /*

                    ** Verify the sequencenumber is as expected.

                    */

                    if((can_rx_info.frame[TPCI_Byte] & (byte)PCI.CF_SN_MASK) ==can_rx_info.next_seq_num)

                    {

                        data_length =can_rx_info.lenght - can_rx_info.offset;

                        /*

                        **  Last frame in message?

                        */

                        if (data_length <=SF_DL_MAX_BYTES)

                        {

                            Array.Copy(can_rx_info.frame, 1,can_rx_info.buffer, can_rx_info.offset, data_length);

 

                           can_rx_info.rx_in_progress = false;

                           can_rx_info.rx_msg_rcvd = true;

                        }

                        else

                        {

                            /*

                            ** not the lastframe,copy bytes to RX buffer and

                            ** continue RXing.

                            */

                           Array.Copy(can_rx_info.frame, 1, can_rx_info.buffer, can_rx_info.offset,SF_DL_MAX_BYTES);

 

                           can_rx_info.next_seq_num = (can_rx_info.next_seq_num + 1) %(CF_SN_MAX_VALUE + 1);

                            can_rx_info.offset += SF_DL_MAX_BYTES;

                           can_rx_info.rx_cf_wait_time = CF_WAIT_TIMEOUT;

                        }

                    }

                    else

                    {

                        /*

                        ** Invalid sequence number...abort Rx.Asa diagnostic measure,

                        ** consideration wasgiven to send an FC frame here, but not done.

                        */

                       can_rx_info.rx_in_progress = false;

                        /*

                        ** When Invalidsequence number is received, ECU has to send

                        ** negative resp forthe first frame.so set RX_MSG_RCVD flag.

                        ** This flag indicatesto DiagManager as new message has come.

                        */

                        can_rx_info.tx_aborted= true;

                        can_rx_info.rx_msg_rcvd= true;

                       RrrorEvent("-->Error: Ecu Invalid Sequence Number");

                    }

                }

            }

            /* flow control frame */

            else if((can_rx_info.frame[TPCI_Byte] & (byte)PCI.FRAME_TYPE_MASK) ==(byte)PCI.FC_TPDU)

            {

                if (can_tx_info.tx_wait_fc)

                {

                    /*

                       ** Receive Flow Status(FS) forTransmiting the CF Frames.

                       ** The value of FS shall be setto zero that means that the

                       ** tester is ready to receive amaximum number of CF.

                       */

                    flow_control_sts =PCI.FC_STATUS_CONTINUE;

                    if((can_rx_info.frame[TPCI_Byte] & (byte)PCI.FC_STATUS_MASK) != 0x00)

                    {

                        /* Flow Status(FS)

                           ** 0: Continue to send(CTS)

                           ** 1: wait(WT)

                           ** 2: Overflow(OVFLW)

                           */

 

                        flow_control_sts =(PCI)(can_rx_info.frame[TPCI_Byte] & (byte)PCI.FC_STATUS_MASK);

                    }

 

                    /*

                    ** Receive the BS and STmin time for Transmiting the CF Frames.

                    */

                    if(can_rx_info.frame[BS_Byte] != 0x00)

                    {

                        can_tx_info.tx_block_size= can_rx_info.frame[BS_Byte] + 1;

                    }

                    else

                    {

                       can_tx_info.tx_block_size = 0x00;

                    }

 

                    if ((can_rx_info.frame[STminByte]& 0x7F) != 0x00)

                    {

                        /*

                        ** Valid Range forSTMin timeout is 0 - 127ms.

                        */

                       can_tx_info.tx_stmin_time = (can_rx_info.frame[STminByte] & 0x7F) +5;   /* extend the delay time */

                    }

                    else

                    {

                       can_tx_info.tx_stmin_time = 20;

                    }

 

                    if ((flow_control_sts ==PCI.FC_STATUS_CONTINUE)

                     &&(can_rx_info.rx_fc_wait_timeout_disable == false)

                      )

                    {

                        can_tx_info.tx_wait_fc= false;

                       can_tx_info.tx_fc_wait_time = 0;

                    }

                    else if (flow_control_sts== PCI.FC_STATUS_WAIT)

                    {

                       can_tx_info.tx_fc_wait_time = FC_WAIT_TIMEOUT;  /* if wait, we will wait another time */

                    }

                    else if (flow_control_sts ==PCI.FC_STATUS_OVERFLOW)

                    {

                        /* do nothing here, ifover flow, we will stop sending

                           any message until wegot new cmd */

                        can_tx_info.tx_fc_wait_time= 1;   /* exit after 10ms */

                       RrrorEvent("-->Error: Ecu Buff Over Flow");

                    }

                    else

                    {

                        /* do nothing here, ifover flow, we will stop sending

                           any message until wegot new cmd */

                       can_tx_info.tx_fc_wait_time = 1;  /* exit after 10ms */

                    }

                }

            }

        }

    }

}

 

©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页

打赏作者

weixin_38239523

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值