Exemplo n.º 1
0
        public void readMessages()
        {
            CANMessage canMessage = new CANMessage();
            byte[] receiveBuffer = new byte[1024]; // circular buffer for reception of data
            string receiveString = string.Empty;

            Console.WriteLine("readMessages started");
            while (true)
            {
                lock (m_synchObject)
                {
                    if (m_endThread)
                    {
                        Console.WriteLine("readMessages ended");
                        return;
                    }
                }
                if (m_serialPort.IsOpen)
                {
                    if (m_serialPort.BytesToRead > 0)
                    {
                        receiveString += m_serialPort.ReadExisting();
                        //Console.WriteLine("BUF1: " + receiveString);
                        receiveString = receiveString.Replace(">", ""); // remove prompt characters... we don't need that stuff
                        receiveString = receiveString.Replace("NO DATA", ""); // remove prompt characters... we don't need that stuff
                        while (receiveString.StartsWith("\n") || receiveString.StartsWith("\r"))
                        {
                            receiveString = receiveString.Substring(1, receiveString.Length - 1);
                        }

                        while (receiveString.Contains('\r'))
                        {
                            // process the line
                            int idx = receiveString.IndexOf('\r');
                            string rxMessage = receiveString.Substring(0, idx);
                            receiveString = receiveString.Substring(idx + 1, receiveString.Length - idx - 1);
                            while (receiveString.StartsWith("\n") || receiveString.StartsWith("\r"))
                            {
                                receiveString = receiveString.Substring(1, receiveString.Length - 1);
                            }
                            //Console.WriteLine("BUF2: " + receiveString);
                            // is it a valid line
                            if (rxMessage.Length >= 6)
                            {
                                try
                                {
                                    uint id = Convert.ToUInt32(rxMessage.Substring(0, 3), 16);
                                    if (MessageContainsInformationForRealtime(id))
                                    {
                                        canMessage.setID(id);
                                        canMessage.setLength(8); // TODO: alter to match data
                                        canMessage.setData(0x0000000000000000); // reset message content
                                        byte b1 = Convert.ToByte(rxMessage.Substring(4, 2), 16);
                                        if (b1 < 7)
                                        {
                                            canMessage.setCanData(b1, 0);
                                            //Console.WriteLine("Byte 1: " + Convert.ToByte(rxMessage.Substring(4, 2), 16).ToString("X2"));
                                            if (b1 >= 1) canMessage.setCanData(Convert.ToByte(rxMessage.Substring(7, 2), 16), 1);
                                            if (b1 >= 2) canMessage.setCanData(Convert.ToByte(rxMessage.Substring(10, 2), 16), 2);
                                            if (b1 >= 3) canMessage.setCanData(Convert.ToByte(rxMessage.Substring(13, 2), 16), 3);
                                            if (b1 >= 4) canMessage.setCanData(Convert.ToByte(rxMessage.Substring(16, 2), 16), 4);
                                            if (b1 >= 5) canMessage.setCanData(Convert.ToByte(rxMessage.Substring(19, 2), 16), 5);
                                            if (b1 >= 6) canMessage.setCanData(Convert.ToByte(rxMessage.Substring(22, 2), 16), 6);
                                            if (b1 >= 7) canMessage.setCanData(Convert.ToByte(rxMessage.Substring(25, 2), 16), 7);
                                        }
                                        else
                                        {
                                            canMessage.setCanData(b1, 0);
                                            //Console.WriteLine("Byte 1: " + Convert.ToByte(rxMessage.Substring(4, 2), 16).ToString("X2"));
                                            canMessage.setCanData(Convert.ToByte(rxMessage.Substring(7, 2), 16), 1);
                                            canMessage.setCanData(Convert.ToByte(rxMessage.Substring(10, 2), 16), 2);
                                            canMessage.setCanData(Convert.ToByte(rxMessage.Substring(13, 2), 16), 3);
                                            canMessage.setCanData(Convert.ToByte(rxMessage.Substring(16, 2), 16), 4);
                                            canMessage.setCanData(Convert.ToByte(rxMessage.Substring(19, 2), 16), 5);
                                            canMessage.setCanData(Convert.ToByte(rxMessage.Substring(22, 2), 16), 6);
                                            canMessage.setCanData(Convert.ToByte(rxMessage.Substring(25, 2), 16), 7);
                                        }

                                        lock (m_listeners)
                                        {
                                            AddToCanTrace("RX: " + canMessage.getData().ToString("X16"));
                                            //Console.WriteLine("MSG: " + rxMessage);
                                            foreach (ICANListener listener in m_listeners)
                                            {
                                                listener.handleMessage(canMessage);
                                            }
                                        }
                                    }

                                }
                                catch (Exception)
                                {
                                    Console.WriteLine("MSG: " + rxMessage);
                                }
                            }
                        }
                    }
                    else
                    {
                        Thread.Sleep(1); // give others some air
                    }
                }

            }
            // parse the receive string

            /*int readResult = 0;
            LAWICEL.CANMsg r_canMsg = new LAWICEL.CANMsg();
            CANMessage canMessage = new CANMessage();
            Console.WriteLine("readMessages started");
            while (true)
            {
                lock (m_synchObject)
                {
                    if (m_endThread)
                    {
                        Console.WriteLine("readMessages ended");
                        return;
                    }
                }
                readResult = LAWICEL.canusb_Read(m_deviceHandle, out r_canMsg);
                if (readResult == LAWICEL.ERROR_CANUSB_OK)
                {
                    //Console.WriteLine(r_canMsg.id.ToString("X3") + " " + r_canMsg.data.ToString("X8"));
                    if (MessageContainsInformationForRealtime(r_canMsg.id))
                    {
                        canMessage.setID(r_canMsg.id);
                        canMessage.setLength(r_canMsg.len);
                        canMessage.setTimeStamp(r_canMsg.timestamp);
                        canMessage.setFlags(r_canMsg.flags);
                        canMessage.setData(r_canMsg.data);
                        lock (m_listeners)
                        {
                            AddToCanTrace("RX: " + r_canMsg.data.ToString("X16"));
                            foreach (ICANListener listener in m_listeners)
                            {
                                //while (listener.messagePending()) ; // dirty, make this better
                                listener.handleMessage(canMessage);
                            }
                            //CastInformationEvent(canMessage); // <GS-05042011> re-activated this function
                        }
                        //Thread.Sleep(1);
                    }

                    // cast event to application to process message
                    //if (MessageContainsInformationForRealtime(r_canMsg.id))
                    //{
                    //TODO: process all other known msg id's into the realtime view
                    //  CastInformationEvent(canMessage); // <GS-05042011> re-activated this function
                    //}
                }
                else if (readResult == LAWICEL.ERROR_CANUSB_NO_MESSAGE)
                {
                    Thread.Sleep(1);
                }
            }
            */
        }
Exemplo n.º 2
0
        public void readMessages()
        {
            CANMessage canMessage = new CANMessage();

            byte[] receiveBuffer = new byte[1024]; // circular buffer for reception of data
            string receiveString = string.Empty;


            Console.WriteLine("readMessages started");
            while (true)
            {
                lock (m_synchObject)
                {
                    if (m_endThread)
                    {
                        Console.WriteLine("readMessages ended");
                        return;
                    }
                }
                if (m_serialPort.IsOpen)
                {
                    if (m_serialPort.BytesToRead > 0)
                    {
                        receiveString += m_serialPort.ReadExisting();
                        //Console.WriteLine("BUF1: " + receiveString);
                        receiveString = receiveString.Replace(">", "");       // remove prompt characters... we don't need that stuff
                        receiveString = receiveString.Replace("NO DATA", ""); // remove prompt characters... we don't need that stuff
                        while (receiveString.StartsWith("\n") || receiveString.StartsWith("\r"))
                        {
                            receiveString = receiveString.Substring(1, receiveString.Length - 1);
                        }

                        while (receiveString.Contains('\r'))
                        {
                            // process the line
                            int    idx       = receiveString.IndexOf('\r');
                            string rxMessage = receiveString.Substring(0, idx);
                            receiveString = receiveString.Substring(idx + 1, receiveString.Length - idx - 1);
                            while (receiveString.StartsWith("\n") || receiveString.StartsWith("\r"))
                            {
                                receiveString = receiveString.Substring(1, receiveString.Length - 1);
                            }
                            //Console.WriteLine("BUF2: " + receiveString);
                            // is it a valid line
                            if (rxMessage.Length >= 6)
                            {
                                try
                                {
                                    uint id = Convert.ToUInt32(rxMessage.Substring(0, 3), 16);
                                    if (MessageContainsInformationForRealtime(id))
                                    {
                                        canMessage.setID(id);
                                        canMessage.setLength(8);                // TODO: alter to match data
                                        canMessage.setData(0x0000000000000000); // reset message content
                                        byte b1 = Convert.ToByte(rxMessage.Substring(4, 2), 16);
                                        if (b1 < 7)
                                        {
                                            canMessage.setCanData(b1, 0);
                                            //Console.WriteLine("Byte 1: " + Convert.ToByte(rxMessage.Substring(4, 2), 16).ToString("X2"));
                                            if (b1 >= 1)
                                            {
                                                canMessage.setCanData(Convert.ToByte(rxMessage.Substring(7, 2), 16), 1);
                                            }
                                            if (b1 >= 2)
                                            {
                                                canMessage.setCanData(Convert.ToByte(rxMessage.Substring(10, 2), 16), 2);
                                            }
                                            if (b1 >= 3)
                                            {
                                                canMessage.setCanData(Convert.ToByte(rxMessage.Substring(13, 2), 16), 3);
                                            }
                                            if (b1 >= 4)
                                            {
                                                canMessage.setCanData(Convert.ToByte(rxMessage.Substring(16, 2), 16), 4);
                                            }
                                            if (b1 >= 5)
                                            {
                                                canMessage.setCanData(Convert.ToByte(rxMessage.Substring(19, 2), 16), 5);
                                            }
                                            if (b1 >= 6)
                                            {
                                                canMessage.setCanData(Convert.ToByte(rxMessage.Substring(22, 2), 16), 6);
                                            }
                                            if (b1 >= 7)
                                            {
                                                canMessage.setCanData(Convert.ToByte(rxMessage.Substring(25, 2), 16), 7);
                                            }
                                        }
                                        else
                                        {
                                            canMessage.setCanData(b1, 0);
                                            //Console.WriteLine("Byte 1: " + Convert.ToByte(rxMessage.Substring(4, 2), 16).ToString("X2"));
                                            canMessage.setCanData(Convert.ToByte(rxMessage.Substring(7, 2), 16), 1);
                                            canMessage.setCanData(Convert.ToByte(rxMessage.Substring(10, 2), 16), 2);
                                            canMessage.setCanData(Convert.ToByte(rxMessage.Substring(13, 2), 16), 3);
                                            canMessage.setCanData(Convert.ToByte(rxMessage.Substring(16, 2), 16), 4);
                                            canMessage.setCanData(Convert.ToByte(rxMessage.Substring(19, 2), 16), 5);
                                            canMessage.setCanData(Convert.ToByte(rxMessage.Substring(22, 2), 16), 6);
                                            canMessage.setCanData(Convert.ToByte(rxMessage.Substring(25, 2), 16), 7);
                                        }

                                        lock (m_listeners)
                                        {
                                            AddToCanTrace("RX: " + canMessage.getData().ToString("X16"));
                                            //Console.WriteLine("MSG: " + rxMessage);
                                            foreach (ICANListener listener in m_listeners)
                                            {
                                                listener.handleMessage(canMessage);
                                            }
                                        }
                                    }
                                }
                                catch (Exception)
                                {
                                    Console.WriteLine("MSG: " + rxMessage);
                                }
                            }
                        }
                    }
                    else
                    {
                        Thread.Sleep(1); // give others some air
                    }
                }
            }
            // parse the receive string


            /*int readResult = 0;
             * LAWICEL.CANMsg r_canMsg = new LAWICEL.CANMsg();
             * CANMessage canMessage = new CANMessage();
             * Console.WriteLine("readMessages started");
             * while (true)
             * {
             *  lock (m_synchObject)
             *  {
             *      if (m_endThread)
             *      {
             *          Console.WriteLine("readMessages ended");
             *          return;
             *      }
             *  }
             *  readResult = LAWICEL.canusb_Read(m_deviceHandle, out r_canMsg);
             *  if (readResult == LAWICEL.ERROR_CANUSB_OK)
             *  {
             *      //Console.WriteLine(r_canMsg.id.ToString("X3") + " " + r_canMsg.data.ToString("X8"));
             *      if (MessageContainsInformationForRealtime(r_canMsg.id))
             *      {
             *          canMessage.setID(r_canMsg.id);
             *          canMessage.setLength(r_canMsg.len);
             *          canMessage.setTimeStamp(r_canMsg.timestamp);
             *          canMessage.setFlags(r_canMsg.flags);
             *          canMessage.setData(r_canMsg.data);
             *          lock (m_listeners)
             *          {
             *              AddToCanTrace("RX: " + r_canMsg.data.ToString("X16"));
             *              foreach (ICANListener listener in m_listeners)
             *              {
             *                  //while (listener.messagePending()) ; // dirty, make this better
             *                  listener.handleMessage(canMessage);
             *              }
             *              //CastInformationEvent(canMessage); // <GS-05042011> re-activated this function
             *          }
             *          //Thread.Sleep(1);
             *      }
             *
             *      // cast event to application to process message
             *      //if (MessageContainsInformationForRealtime(r_canMsg.id))
             *      //{
             *      //TODO: process all other known msg id's into the realtime view
             *      //  CastInformationEvent(canMessage); // <GS-05042011> re-activated this function
             *      //}
             *  }
             *  else if (readResult == LAWICEL.ERROR_CANUSB_NO_MESSAGE)
             *  {
             *      Thread.Sleep(1);
             *  }
             * }
             */
        }
Exemplo n.º 3
0
 /// <summary>
 /// waitForMessage waits for a specific CAN message give by a CAN id.
 /// </summary>
 /// <param name="a_canID">The CAN id to listen for</param>
 /// <param name="timeout">Listen timeout</param>
 /// <param name="r_canMsg">The CAN message with a_canID that we where listening for.</param>
 /// <returns>The CAN id for the message we where listening for, otherwise 0.</returns>
 public override uint waitForMessage(uint a_canID, uint timeout, out CANMessage canMsg)
 {
     /*
     int readResult = 0;
     int nrOfWait = 0;
     while (nrOfWait < timeout)
     {
         LAWICEL.CANMsg r_canMsg = new LAWICEL.CANMsg();
         canMsg = new CANMessage();
         readResult = LAWICEL.canusb_Read(m_deviceHandle, out r_canMsg);
         if (readResult == LAWICEL.ERROR_CANUSB_OK)
         {
             //Console.WriteLine("rx id: 0x" + r_canMsg.id.ToString("X4"));
             if (r_canMsg.id != a_canID)
             {
                 nrOfWait++;
                 continue;
             }
             else
             {
                 canMsg.setID(r_canMsg.id);
                 canMsg.setData(r_canMsg.data);
                 canMsg.setFlags(r_canMsg.flags);
                 return (uint)r_canMsg.id;
             }
         }
         else if (readResult == LAWICEL.ERROR_CANUSB_NO_MESSAGE)
         {
             Thread.Sleep(1);
             nrOfWait++;
         }
     }
     canMsg = new CANMessage();
     return 0;*/
     LAWICEL.CANMsg r_canMsg;
     canMsg = new CANMessage();
     int readResult = 0;
     int nrOfWait = 0;
     while (nrOfWait < timeout)
     {
         r_canMsg = new LAWICEL.CANMsg();
         readResult = LAWICEL.canusb_Read(m_deviceHandle, out r_canMsg);
         if (readResult == LAWICEL.ERROR_CANUSB_OK)
         {
             Thread.Sleep(1);
             AddToCanTrace("rx: 0x" + r_canMsg.id.ToString("X4") + r_canMsg.data.ToString("X16"));
             if (r_canMsg.id == 0x00)
             {
                 nrOfWait++;
             }
             else if (r_canMsg.id != a_canID)
                 continue;
             canMsg.setData(r_canMsg.data);
             canMsg.setID(r_canMsg.id);
             canMsg.setLength(r_canMsg.len);
             return (uint)r_canMsg.id;
         }
         else if (readResult == LAWICEL.ERROR_CANUSB_NO_MESSAGE)
         {
             Thread.Sleep(1);
             nrOfWait++;
         }
     }
     r_canMsg = new LAWICEL.CANMsg();
     return 0;
 }
Exemplo n.º 4
0
        /// <summary>
        /// readMessages is the "run" method of this class. It reads all incomming messages
        /// and publishes them to registered ICANListeners.
        /// </summary>
        public void readMessages()
        {
            int readResult = 0;
            LAWICEL.CANMsg r_canMsg = new LAWICEL.CANMsg();
            CANMessage canMessage = new CANMessage();
            Console.WriteLine("readMessages started");
            while (true)
            {
                lock (m_synchObject)
                {
                    if (m_endThread)
                    {
                        Console.WriteLine("readMessages ended");
                        return;
                    }
                }
                readResult = LAWICEL.canusb_Read(m_deviceHandle, out r_canMsg);
                if (readResult == LAWICEL.ERROR_CANUSB_OK)
                {
                    //Console.WriteLine(r_canMsg.id.ToString("X6") + " " + r_canMsg.data.ToString("X16"));
                    //if (MessageContainsInformationForRealtime(r_canMsg.id))
                    {
                        canMessage.setID(r_canMsg.id);
                        canMessage.setLength(r_canMsg.len);
                        canMessage.setTimeStamp(r_canMsg.timestamp);
                        canMessage.setFlags(r_canMsg.flags);
                        canMessage.setData(r_canMsg.data);
                        lock (m_listeners)
                        {
                            bitsPerSecond += 109;
                            AddToCanTrace("RX: " + r_canMsg.id.ToString("X6") + " " + r_canMsg.data.ToString("X16"));
                            rxCount++;
                            foreach (ICANListener listener in m_listeners)
                            {
                                //while (listener.messagePending()) ; // dirty, make this better
                                listener.handleMessage(canMessage);
                            }
                            CastInformationEvent("", rxCount, txCount, errCount); // <GS-05042011> re-activated this function
                        }
                        //Thread.Sleep(1);
                    }

                    // cast event to application to process message
                    //if (MessageContainsInformationForRealtime(r_canMsg.id))
                    //{
                        //TODO: process all other known msg id's into the realtime view
                      //  CastInformationEvent(canMessage); // <GS-05042011> re-activated this function
                    //}
                }
                else if (readResult == LAWICEL.ERROR_CANUSB_NO_MESSAGE)
                {
                   // Console.WriteLine("No message");
                    Thread.Sleep(1);
                }
                else
                {
                    Console.WriteLine("Result: " + readResult.ToString("X8"));
                }
                /*int stat = LAWICEL.canusb_Status(m_deviceHandle);
                if (stat != 0)
                {
                    Console.WriteLine("status: " + stat.ToString("X4"));
                }*/
            }
        }
Exemplo n.º 5
0
        public int query_data(byte unit, byte data_id, out byte[] answer)
        {
            byte[] data = new byte[8];
            byte length= 0;
            byte i = 0;
            answer = new byte[8]; // test <GS-11012011>
            int rcv_length;
            byte[] query = new byte[8] { 0x40, 0x00, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00 };
            byte[] ack = new byte[8] { 0x40, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00 };
            //ulong query_long = 0x0000000021020040;
            //ulong ack_long = 0x00000000003F0040;
            query[1] = unit;
            ack[1] = unit;
            // If data_id is zero, decrease length field
            if (data_id != 0x00) query[4] = data_id;
            else query[2] = 0x01;

            data[0] = 0x00;
            rcv_length = 0;

            //for (int i = 0; i < 5; i++)
            {

                CANMessage msg = new CANMessage(0x240, 0, 8);
                //msg.setData(query_long);
                msg.setCanData(query[0], 0);
                msg.setCanData(query[1], 1);
                msg.setCanData(query[2], 2);
                msg.setCanData(query[3], 3);
                msg.setCanData(query[4], 4);
                msg.setCanData(query[5], 5);
                msg.setCanData(query[6], 6);
                msg.setCanData(query[7], 7);
                msg.setID(0x240);
                AddToCanTrace("Sending: 0x" + msg.getData().ToString("X16") + " id: 0x" + msg.getID().ToString("X4"));

                if (!sendMessage(msg))
                {
                    return -1;
                }
                uint reply_unit = GetReplyforUnit(unit);
                reply_unit = 0x258; // for testing purposes
                while (data[0] != 0x80 && data[0] != 0xC0)
                {
                    CANMessage replyMessage = new CANMessage();
                    AddToCanTrace("Waiting for ID: 0x" + reply_unit.ToString("X4"));
                    if (waitForMessage(reply_unit, 1000, out replyMessage) == reply_unit)
                    {
                        AddToCanTrace("Rx data: " + replyMessage.getData().ToString("X16"));
                        data[0] = replyMessage.getCanData(0);
                        data[1] = replyMessage.getCanData(1);
                        data[2] = replyMessage.getCanData(2);
                        data[3] = replyMessage.getCanData(3);
                        data[4] = replyMessage.getCanData(4);
                        data[5] = replyMessage.getCanData(5);
                        data[6] = replyMessage.getCanData(6);
                        data[7] = replyMessage.getCanData(7);
                        int idx = 0;
                        if ((data[0] & 0x40) > 0)
                        {
                            if (data[2] > 0x02)
                            {
                                length = data[2];   // subtract two non-payload bytes
                                length -= 2;
                                answer = new byte[length];
                            }
                            else length = 0;

                            if (--length > 0)
                            {
                                answer[idx++] = data[5];
                                rcv_length++;
                            }
                            if (--length > 0)
                            {
                                answer[idx++] = data[6];
                                rcv_length++;
                            }
                            if (--length > 0)
                            {
                                answer[idx++] = data[7];
                                rcv_length++;
                            }
                        }
                        else
                        {
                            for (i = 0; i < 6; i++)
                            {
                                answer[idx++] = data[2 + i];
                                length--;
                                rcv_length++;
                                if (length == 0) i = 6;
                            }
                        }
                        // Send acknowledgement
                        ack[3] = Convert.ToByte(data[0] & 0xBF);
                        CANMessage ackMessage = new CANMessage();
                        //ackMessage.setData(ack_long);
                        ackMessage.setCanData(ack[0], 0);
                        ackMessage.setCanData(ack[1], 1);
                        ackMessage.setCanData(ack[2], 2);
                        ackMessage.setCanData(ack[3], 3);
                        ackMessage.setCanData(ack[4], 4);
                        ackMessage.setCanData(ack[5], 5);
                        ackMessage.setCanData(ack[6], 6);
                        ackMessage.setCanData(ack[7], 7);

                        ackMessage.setID(0x266);
                        sendMessage(ackMessage);
                    }
                    else
                    {
                        // Timeout
                        AddToCanTrace("Timeout waiting for 0x" + reply_unit.ToString("X3"));
                        return -1;
                    }
                }
            }
            return rcv_length;
        }
Exemplo n.º 6
0
        public int query_data(byte unit, byte data_id, out byte[] answer)
        {
            byte[] data   = new byte[8];
            byte   length = 0;
            byte   i      = 0;

            answer = new byte[8]; // test <GS-11012011>
            int rcv_length;

            byte[] query = new byte[8] {
                0x40, 0x00, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00
            };
            byte[] ack = new byte[8] {
                0x40, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00
            };
            //ulong query_long = 0x0000000021020040;
            //ulong ack_long = 0x00000000003F0040;
            query[1] = unit;
            ack[1]   = unit;
            // If data_id is zero, decrease length field
            if (data_id != 0x00)
            {
                query[4] = data_id;
            }
            else
            {
                query[2] = 0x01;
            }

            data[0]    = 0x00;
            rcv_length = 0;

            //for (int i = 0; i < 5; i++)
            {
                CANMessage msg = new CANMessage(0x240, 0, 8);
                //msg.setData(query_long);
                msg.setCanData(query[0], 0);
                msg.setCanData(query[1], 1);
                msg.setCanData(query[2], 2);
                msg.setCanData(query[3], 3);
                msg.setCanData(query[4], 4);
                msg.setCanData(query[5], 5);
                msg.setCanData(query[6], 6);
                msg.setCanData(query[7], 7);
                msg.setID(0x240);
                AddToCanTrace("Sending: 0x" + msg.getData().ToString("X16") + " id: 0x" + msg.getID().ToString("X4"));

                if (!sendMessage(msg))
                {
                    return(-1);
                }
                uint reply_unit = GetReplyforUnit(unit);
                reply_unit = 0x258; // for testing purposes
                while (data[0] != 0x80 && data[0] != 0xC0)
                {
                    CANMessage replyMessage = new CANMessage();
                    AddToCanTrace("Waiting for ID: 0x" + reply_unit.ToString("X4"));
                    if (waitForMessage(reply_unit, 1000, out replyMessage) == reply_unit)
                    {
                        AddToCanTrace("Rx data: " + replyMessage.getData().ToString("X16"));
                        data[0] = replyMessage.getCanData(0);
                        data[1] = replyMessage.getCanData(1);
                        data[2] = replyMessage.getCanData(2);
                        data[3] = replyMessage.getCanData(3);
                        data[4] = replyMessage.getCanData(4);
                        data[5] = replyMessage.getCanData(5);
                        data[6] = replyMessage.getCanData(6);
                        data[7] = replyMessage.getCanData(7);
                        int idx = 0;
                        if ((data[0] & 0x40) > 0)
                        {
                            if (data[2] > 0x02)
                            {
                                length  = data[2];  // subtract two non-payload bytes
                                length -= 2;
                                answer  = new byte[length];
                            }
                            else
                            {
                                length = 0;
                            }

                            if (--length > 0)
                            {
                                answer[idx++] = data[5];
                                rcv_length++;
                            }
                            if (--length > 0)
                            {
                                answer[idx++] = data[6];
                                rcv_length++;
                            }
                            if (--length > 0)
                            {
                                answer[idx++] = data[7];
                                rcv_length++;
                            }
                        }
                        else
                        {
                            for (i = 0; i < 6; i++)
                            {
                                answer[idx++] = data[2 + i];
                                length--;
                                rcv_length++;
                                if (length == 0)
                                {
                                    i = 6;
                                }
                            }
                        }
                        // Send acknowledgement
                        ack[3] = Convert.ToByte(data[0] & 0xBF);
                        CANMessage ackMessage = new CANMessage();
                        //ackMessage.setData(ack_long);
                        ackMessage.setCanData(ack[0], 0);
                        ackMessage.setCanData(ack[1], 1);
                        ackMessage.setCanData(ack[2], 2);
                        ackMessage.setCanData(ack[3], 3);
                        ackMessage.setCanData(ack[4], 4);
                        ackMessage.setCanData(ack[5], 5);
                        ackMessage.setCanData(ack[6], 6);
                        ackMessage.setCanData(ack[7], 7);

                        ackMessage.setID(0x266);
                        sendMessage(ackMessage);
                    }
                    else
                    {
                        // Timeout
                        AddToCanTrace("Timeout waiting for 0x" + reply_unit.ToString("X3"));
                        return(-1);
                    }
                }
            }
            return(rcv_length);
        }
Exemplo n.º 7
0
        //-------------------------------------------------------------------------
        /**
        Waits for arrival of a specific CAN message or any message if ID = 0.

        @param      a_canID     message ID
        @param      timeout     timeout, ms
        @param      canMsg      message

        @return                 message ID
        */
        public override uint waitForMessage(uint a_canID, uint timeout,
        out CANMessage canMsg)
        {
            canMsg = new CANMessage();
            Debug.Assert(canMsg != null);
            canMsg.setID(0);

            caCombiAdapter.caCANFrame frame = new caCombiAdapter.caCANFrame();
            if (this.combi.CAN_GetMessage(ref frame, timeout) &&
            (frame.id == a_canID || a_canID == 0))
            {
            // message received
            canMsg.setID(frame.id);
            canMsg.setLength(frame.length);
            canMsg.setData(frame.data);

            return frame.id;
            }

            // timed out
            return 0;
        }