Example #1
0
 public TPM(Axle _axelLoc, string _StemID, string _PSI, Esys.IO.TypeOfStem _StemType)
 {
     axelLoc = _axelLoc;
     StemID = _StemID;
     PSI = _PSI;
     StemType = _StemType;
 }
Example #2
0
 private void ReadTag(string tagname, Esys.IO.DataType dataType, Esys.IO.TagDirection direction)
 {
     //Adds the tag if it does not already exist in the INGEAR driver
     AddTag(tagname, dataType, direction);
     string error = "";
     object tagvalue = null;
     bool success = mPLC.ReadTagByName(tagname, ref tagvalue, ref error);
     if (TagRead != null && tagvalue != null)
     {
         TagRead(this, new TagChangedEventArgs(tagname, tagvalue.ToString()));
     }
     if (success == false)
     {
         throw new Exception(error);
     }
 }
Example #3
0
 void mPLC_StatusChanged(object sender, Esys.IO.DeviceStatusEventArgs e)
 {
     OnNewMessage(e.Message);
 }
Example #4
0
        /// <summary>
        /// Checks if a tag exists in teh InGear dictionary, if it doesn't, then add it.
        /// </summary>
        /// <param name="tagname"></param>
        /// <param name="datatype"></param>
        /// <param name="direction"></param>
        private void AddTag(string tagname, Esys.IO.DataType datatype, Esys.IO.TagDirection direction)
        {
            if (mPLC.TagExists(tagname) == true) return; //already exists

            Esys.IO.Tag tag = new Esys.IO.Tag(tagname, datatype, direction, false);
            mPLC.AddTag(tag);
        }
        public bool PFCSSendSolData(Esys.IO.PFCS.MessageType msgType, string data, string _MachineID)
        {
            try
            {

                if (this.PortType != PORT_TYPE.Soliciated)
                {
                    if (StateChanged != null) StateChanged(this, new StateChangeEventArgs(StateChange.ErrorHappened, "Can only send data (PFCSSendSolData) on Solicated Port."));
                    return false;
                }
                if (!(msgType == MessageType.SendingTestResults || msgType == MessageType.SendingDataRequestOnSolPort))
                {
                    if (StateChanged != null) StateChanged(this, new StateChangeEventArgs(StateChange.ErrorHappened, "Can only send message types of SendingDataRequestOnSolPort and SendingTestResults (PFCSSendSolData)."));
                    return false;
                }

                if (data.Length > 1024)
                {
                    if (StateChanged != null) StateChanged(this, new StateChangeEventArgs(StateChange.ErrorHappened, "data to send must be 1024 bytes or less. (PFCSSendSolData)"));
                    return false;
                }

                Message_Upload msg = new Message_Upload();
                msg.MachineID = _MachineID;
                msg.SequenceNum = 1; //Send Routine will automatically set the correct sequence number
                msg.PortType  = PORT_TYPE.Soliciated;
                msg.MsgType = msgType;
                msg.ResponseType = MessageResponseType.DataMessage;
                msg.Data = data;
                Send(msg);
                return true;
            }
            catch (Exception ex)
            {
                if (StateChanged != null) StateChanged(this, new StateChangeEventArgs(StateChange.ErrorHappened, ex.ToString()));
                return false;
            }
        }
 public bool PFCSSendNAK(Esys.IO.PFCS.Message_Upload msgToRespondTo, Esys.IO.PFCS.MessageErrors NAK_Error)
 {
     try
     {
         Message_Upload ack = new Message_Upload(msgToRespondTo.MsgType);
         ack.MachineID = MachID;
         ack.SequenceNum = msgToRespondTo.SequenceNum;
         ack.MsgType = msgToRespondTo.MsgType;
         ack.Error = NAK_Error;
         ack.ResponseType = MessageResponseType.NAK;
         Send(ack);
         return true;
     }
     catch (Exception ex)
     {
         if (StateChanged != null) StateChanged(this, new StateChangeEventArgs(StateChange.ErrorHappened, ex.ToString()));
         return false;
     }
 }
 /// <summary>
 /// Send an ACK message to PFCS from a message to respond to
 /// </summary>
 /// <param name="msgToRespondTo"></param>
 /// <param name="msgError"></param>
 /// <returns></returns>
 public bool PFCSSendACK(Esys.IO.PFCS.Message_Upload msgToRespondTo, Esys.IO.PFCS.MessageErrors msgError)
 {
     Message_Upload ack = PFCSCreateACK(msgToRespondTo, msgError);
     if (ack == null)
     {
         return false;
     }
     else
     {
         Send(ack);
         return true; ;
     }
 }
        /// <summary>
        /// Creates an ACK message from a message to respond to
        /// </summary>
        /// <param name="msgToRespondTo"></param>
        /// <param name="msgError"></param>
        /// <returns></returns>
        public Message_Upload PFCSCreateACK(Esys.IO.PFCS.Message_Upload msgToRespondTo, Esys.IO.PFCS.MessageErrors msgError)
        {
            try
            {

                Message_Upload ack = new Message_Upload(msgToRespondTo.MsgType);
                ack.MachineID = MachID;
                ack.SequenceNum = msgToRespondTo.SequenceNum;
                ack.MsgType = msgToRespondTo.MsgType;
                ack.Error = msgError;
                ack.ResponseType = MessageResponseType.ACK;
                //Send(ack);
                return ack;
            }
            catch (Exception ex)
            {
                if (StateChanged != null) StateChanged(this, new StateChangeEventArgs(StateChange.ErrorHappened, ex.ToString()));
                return null;
            }
        }
        //return
        public bool CAN_SetSessionToExtendedDiagnostic(ref string ErrorDesc, Esys.IO.TypeOfStem StemType)
        {
            mLog.Write("CAN_SetSessionToExtendedDiagnostic");
            mLog.Write("Stem Type = " + StemType.ToString());
            if (mPort == null) { ErrorDesc = "Port Not Initialized"; return false; }
            if (mPort.IsOpen == false) { ErrorDesc = "Port Not Opened"; return false; }
            if (mSendAddr == null) { ErrorDesc = "Send Address not initialized"; return false; }
            if (Connected == false) { ErrorDesc = "CAN ODBII cable not connected"; return false; }
            try {
                lock (mSyncLock) {

                    string dataToSend;
                    string expectedResponse;

                    if(StemType == TypeOfStem.Continental || StemType == TypeOfStem.Continental_Japan){
                        dataToSend = ":S" + mSendAddr + "N" + "0210030000000000;";
                        expectedResponse = ":S" + mRecvAddrFilter + "N" + "0250030000000000;";
                    }else{
                        dataToSend = ":S" + mSendAddr + "N" + "0210030000000000;";
                        expectedResponse = ":S" + mRecvAddrFilter + "N" + "0650030096177055;";
                    }
                    int timeout = 2000;//ms
                    //clear the buffer
                    string buffer = CANReadExisting();
                    mPort.ReadTimeout = 100;
                    CANWrite(dataToSend);

                    if (StemType == TypeOfStem.Continental || StemType == TypeOfStem.Continental_Japan)
                    {
                        Thread.Sleep(1000);
                    }

                    DateTime StartTime = DateTime.Now;
                    while (DateTime.Now.Subtract(StartTime).TotalMilliseconds < timeout) {
                        try {
                            buffer = CANReadLine();
                        } catch (TimeoutException e) {//ignore this error.  It just means that data is not on the line.
                        } catch (Exception ex) { ErrorDesc = ex.ToString(); }
                        if (buffer.Contains(expectedResponse)) {
                            //IT DID IT!!!!
                            return true;
                        }
                        Thread.Sleep(10);
                    }
                }
            } catch (Exception ex) {
                ErrorDesc = ex.ToString();
            }

            if (ErrorDesc.Length == 0) ErrorDesc = "Vehicle is not responding. Check ACC Power Rail.";
            return false;
        }
        //return
        public bool CAN_ReadSensorIDs(ref string ErrorDesc, Esys.IO.TypeOfStem StemType, ref string SensorID1, ref string SensorID2, ref string SensorID3, ref string SensorID4)
        {
            mLog.Write("CAN_ReadSensorIDs");
            if (mPort == null) { ErrorDesc = "Port Not Initialized"; return false; }
            if (mPort.IsOpen == false) { ErrorDesc = "Port Not Opened"; return false; }
            if (mSendAddr == null) { ErrorDesc = "Send Address not initialized"; return false; }
            if (Connected == false) { ErrorDesc = "CAN ODBII cable not connected"; return false; }
            try {
                lock (mSyncLock) {

                    string dataToSend ;
                    string Respone_1stMsg;
                    string expectedResponse_1stMsg;
                    string expectedResponse_2ndMsg;
                    string expectedResponse_3rdMsg;

                    if (StemType == TypeOfStem.Continental || StemType == TypeOfStem.Continental_Japan)
                    {
                        dataToSend = ":S" + mSendAddr + "N" + "0322F09400000000;";
                        Respone_1stMsg = ":S" + mSendAddr + "N" + "30000A0000000000;";
                        expectedResponse_1stMsg = ":S" + mRecvAddrFilter + "N" + "101362F094";
                        expectedResponse_2ndMsg = ":S" + mRecvAddrFilter + "N" + "21";
                        expectedResponse_3rdMsg = ":S" + mRecvAddrFilter + "N" + "22";
                    }
                    else
                    {
                        dataToSend = ":S" + mSendAddr + "N" + "0322F09000000000;";
                        Respone_1stMsg = ":S" + mSendAddr + "N" + "30000A0000000000;";
                        expectedResponse_1stMsg = ":S" + mRecvAddrFilter + "N" + "101362F090";
                        expectedResponse_2ndMsg = ":S" + mRecvAddrFilter + "N" + "21";
                        expectedResponse_3rdMsg = ":S" + mRecvAddrFilter + "N" + "22";
                    }
                    SensorID1="";
                    SensorID2="";
                    SensorID3="";
                    SensorID4="";

                    int timeout = 2000;//ms
                    //clear the buffer
                    string buffer = CANReadExisting();
                    mPort.ReadTimeout = 100;
                    CANWrite(dataToSend);
                    DateTime StartTime = DateTime.Now;
                    while (DateTime.Now.Subtract(StartTime).TotalMilliseconds < timeout) {
                        try {
                            buffer = CANReadLine();
                        } catch (TimeoutException e) {//ignore this error.  It just means that data is not on the line.
                        } catch (Exception ex) { ErrorDesc = ex.ToString(); }
                        if (buffer.Contains(expectedResponse_1stMsg)) {
                            int StartPos = buffer.IndexOf(expectedResponse_1stMsg, 0);
                            SensorID1 = buffer.Substring(StartPos + 16, 6);
                            CANWrite(Respone_1stMsg);
                        }
                        if (buffer.Contains(expectedResponse_2ndMsg)) {
                            int StartPos = buffer.IndexOf(expectedResponse_2ndMsg, 0);
                            SensorID1 += buffer.Substring(StartPos + 8, 2);
                            SensorID2 = buffer.Substring(StartPos + 10, 8);
                            SensorID3 = buffer.Substring(StartPos + 18, 4);
                        }
                        if (buffer.Contains(expectedResponse_3rdMsg)) {
                            int StartPos = buffer.IndexOf(expectedResponse_3rdMsg, 0);
                            SensorID3 += buffer.Substring(StartPos + 8, 4);
                            SensorID4 = buffer.Substring(StartPos + 12, 8);
                            break;
                        }
                        Thread.Sleep(10);
                    }
                    mLog.Write("SensorID1=" + SensorID1 + "; SensorID2=" + SensorID2 + "; SensorID3=" + SensorID3 + "; SensorID4=" + SensorID4);
                    if (SensorID1.Length == 8 && SensorID2.Length == 8 && SensorID3.Length == 8 && SensorID4.Length == 8) {
                        return true;
                    }else{
                        if (SensorID1.Length == 0) {ErrorDesc = "Did not receive 1st sensor ID";}
                        else if (SensorID2.Length == 0) {ErrorDesc = "Did not receive 2nd sensor ID";}
                        else if (SensorID4.Length == 0) {ErrorDesc = "Did not receive 4th sensor ID";}
                        else { ErrorDesc = "Error with recieving Read Sensor ID's"; };
                        return false;
                    }
                }
            } catch (Exception ex) {
                ErrorDesc = ex.ToString();
            }

            if (ErrorDesc.Length == 0) ErrorDesc = "Vehicle is not responding to Read ID's.";
            return false;
        }
        void mClient_DataReceived(object sender, Esys.Sockets.DataReceivedEventArgs e)
        {
            lock (mSyncRxData) {
                mDataRxBuffer += ASCIIEncoding.UTF8.GetString(e.Data);

                int startPos = 0;
                int endPos = 0;
                int normIdentifier = 0;
                string canID;
                string canData;

                while (startPos < mDataRxBuffer.Length) {
                    startPos = mDataRxBuffer.IndexOf((char)58, startPos);
                    if (startPos < 0) return;
                    endPos = mDataRxBuffer.IndexOf((char)59, startPos);
                    if (endPos < 0 || endPos <= startPos) return;
                    normIdentifier = mDataRxBuffer.IndexOf("N");
                    if (normIdentifier < 0) return;
                    canID = mDataRxBuffer.Substring(startPos + 2, normIdentifier - 2);
                    canData = mDataRxBuffer.Substring(normIdentifier + 1, endPos - normIdentifier - 1);

                    mLastMessageRx = DateTime.Now;
                    if (WaitForRx) {
                        if ((mRecvAddrFilter != null) && (mDataRxBuffer.Contains(mRecvAddrFilter))) {

                            //if (CANMsgReceived != null) CANMsgReceived(this, new CANMsgReceivedEventArgs(canID, canData));
                            //lock (mSyncRxLock) {
                            byte lsn = byte.Parse(canData.Substring(1, 1), NumberStyles.HexNumber); //least significant nibble is the length
                            switch (canData.Substring(0, 1)) {                      //most significant nibble is the frame type
                                case "0":       //single frame
                                    if ((canData.Substring(2, 2) == "7F") && (canData.Substring(6, 2) == "78")) {
                                        //this is the 1st response to flow control timing change... ignore
                                        break;
                                    } else {
                                        mRxBuffer = canData.Substring(2, lsn * 2);
                                        mRxBufferLen = (byte)(lsn * 2);
                                        mRxBufferPos = (lsn * 2);
                                        RxComplete = true;
                                        WaitForRx = false;
                                        break;
                                    }
                                case "1":       //1st of multiple frames
                                    mRxBuffer = canData.Substring(4, 12);
                                    mRxBufferLen = (byte)(byte.Parse(canData.Substring(2, 2), NumberStyles.HexNumber) * 2);
                                    mRxBufferPos = 12;
                                    break;
                                case "3":       //flow control...
                                    mClrToSend = true;
                                    break;
                                default:        //consecutive frame
                                    int bytesToRead = mRxBufferLen - mRxBufferPos;
                                    if (bytesToRead >= 14) {
                                        mRxBuffer += canData.Substring(2, 14);
                                        mRxBufferPos += 14;

                                    } else {
                                        mRxBuffer += canData.Substring(2, bytesToRead);
                                        mRxBufferPos += bytesToRead;
                                    }
                                    if (mRxBufferPos >= mRxBufferLen) {
                                        RxComplete = true;
                                        WaitForRx = false;
                                    }
                                    break;
                            }

                        } else if ((mRecvAddrFilter == null) || (mRecvAddrFilter == "")) {
                            //if (CANMsgReceived != null) CANMsgReceived(this, new CANMsgReceivedEventArgs(canID, canData));
                        }
                    }
                    startPos = 0;//endPos + 2;
                    mDataRxBuffer = mDataRxBuffer.Substring(endPos, mDataRxBuffer.Length - endPos);
                }
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="ErrorDesc"></param>
        /// <param name="SensorID1"></param>
        /// <param name="SensorID2"></param>
        /// <param name="SensorID3"></param>
        /// <param name="SensorID4"></param>
        /// <returns></returns>
        public bool CAN_WriteSensorIDs(ref string ErrorDesc, Esys.IO.TypeOfStem StemType, string SensorID1, string SensorID2, string SensorID3, string SensorID4)
        {
            mLog.Write("CAN_WriteSensorIDs SensorID1="+ SensorID1 + "; SensorID2=" + SensorID2 + "; SensorID3=" + SensorID3 + "; SensorID4=" + SensorID4);
            if (mPort == null) { ErrorDesc = "Port Not Initialized"; return false; }
            if (mPort.IsOpen == false) { ErrorDesc = "Port Not Opened"; return false; }
            if (mSendAddr == null) { ErrorDesc = "Send Address not initialized"; return false; }
            if (Connected == false) { ErrorDesc = "CAN ODBII cable not connected"; return false; }
            if (SensorID1.Length != 8) { ErrorDesc = "Sensor ID 1 must be 8 characters.  Cannot Write Sensor ID."; return false; }
            if (SensorID2.Length != 8) { ErrorDesc = "Sensor ID 2 must be 8 characters.  Cannot Write Sensor ID."; return false; }
            if (SensorID3.Length != 8) { ErrorDesc = "Sensor ID 3 must be 8 characters.  Cannot Write Sensor ID."; return false; }
            if (SensorID4.Length != 8) { ErrorDesc = "Sensor ID 4 must be 8 characters.  Cannot Write Sensor ID."; return false; }
            try {
                lock (mSyncLock) {

                    string dataToSend_1stMsg;
                    string dataToSend_2ndMsg;
                    string dataToSend_3rdMsg;
                    string Response_1stMsg;

                    if(StemType == TypeOfStem.Continental || StemType == TypeOfStem.Continental_Japan)
                    {
                        dataToSend_1stMsg = ":S" + mSendAddr + "N" + "10132EF094" + SensorID1.Substring(0,6) + ";";
                        dataToSend_2ndMsg = ":S" + mSendAddr + "N" + "21" + SensorID1.Substring(6, 2) + SensorID2.Substring(0, 8) + SensorID3.Substring(0, 4) + ";";
                        dataToSend_3rdMsg = ":S" + mSendAddr + "N" + "22" + SensorID3.Substring(4, 4) + SensorID4 + "00;";
                        Response_1stMsg = ":S" + mRecvAddrFilter + "N" + "30010E";
                    }
                    else
                    {
                        dataToSend_1stMsg = ":S" + mSendAddr + "N" + "10132EF090" + SensorID1.Substring(0,6) + ";";
                        dataToSend_2ndMsg = ":S" + mSendAddr + "N" + "21" + SensorID1.Substring(6, 2) + SensorID2 + SensorID3.Substring(0, 4) + ";";
                        dataToSend_3rdMsg = ":S" + mSendAddr + "N" + "22" + SensorID3.Substring(4, 4) + SensorID4 + "00;";
                        Response_1stMsg = ":S" + mRecvAddrFilter + "N" + "300314";
                    }

                    int timeout = 2000;//ms
                    //clear the buffer
                    string buffer = CANReadExisting();
                    mPort.ReadTimeout = 100;
                    CANWrite(dataToSend_1stMsg);
                    DateTime StartTime = DateTime.Now;
                    while (DateTime.Now.Subtract(StartTime).TotalMilliseconds < timeout) {
                        try {
                            buffer = CANReadLine();
                            int i = 99;
                        } catch (TimeoutException e) {//ignore this error.  It just means that data is not on the line.
                        } catch (Exception ex) { ErrorDesc = ex.ToString(); }
                        if (buffer.Contains(Response_1stMsg)) {
                            CANWrite(dataToSend_2ndMsg);
                            CANWrite(dataToSend_3rdMsg);

                            //buffer = CANReadExisting();

                            return true;
                        }
                        Thread.Sleep(10);
                    }
                    ErrorDesc = "Response not received for Write Sensor Thresholds.";
                    return false;
                }
            } catch (Exception ex) {
                ErrorDesc = ex.ToString();
            }

            if (ErrorDesc.Length == 0) ErrorDesc = "Vehicle is not responding to Write IDs.";
            return false;
        }