예제 #1
0
 public cFlowTEX()
 {
     TheSerialPort = new SerialPort();
     RequestMState = eRequestMState.eFLOW;
     bActive       = false;
     RequestStatus = eRequestStatus.eSTANDBY;
     SerialMode    = eSerialMode.eCLOSED;
     flow          = 0;
     temperature   = 0;
 }
예제 #2
0
        public void connect()
        {
            bDisconnect = false;

            if (bActive)
            {
                SerialMode    = eSerialMode.eSETUP;
                portOpenRetry = 3;
            }
        }
예제 #3
0
        public void disconnect()
        {
            if (bActive)
            {
                if (TheSerialPort.IsOpen)
                {
                    TheSerialPort.Close();
                }
            }

            bDisconnect = true;
            SerialMode  = eSerialMode.eCLOSED;
        }
예제 #4
0
        void poll()
        {
            int data = -1;

            try
            {
                if (TheSerialPort.IsOpen)
                {
                    do
                    {
                        try
                        {
                            if (TheSerialPort.BytesToRead > 0)
                            {
                                data = TheSerialPort.ReadByte();
                            }
                            else
                            {
                                data = -1;
                            }
                        }
                        catch
                        {
                            data = -1;
                        }
                        finally
                        {
                            TexNET.messagePoll(data);
                            TexNET.process();
                            byte[] bufferTX = TexNET.getDataToSend();
                            if ((bufferTX != null) && (bufferTX.Length > 0))
                            {
                                TheSerialPort.Write(bufferTX, 0, bufferTX.Length);
                                TexNET.dataSent();
                            }
                        }
                    }while((data >= 0) && (TheSerialPort.IsOpen));
                }
            }
            catch
            {
            }

            if ((bError) && (RequestStatus == eRequestStatus.eNEW_REQUEST))
            {
                RequestStatus = eRequestStatus.eFAIL;
            }

            if (TheSerialPort.IsOpen)
            {
                switch (RequestMState)
                {
                default:
                case eRequestMState.eFLOW:
                {
                    TexNET.sendRequest(cMTDOpcodes.OPC_READ_FLOW, null);
                    RequestMState = eRequestMState.eFLOW_ANSWER;
                    break;
                }

                case eRequestMState.eFLOW_ANSWER:
                {
                    if (!TexNET.isWaitingAnswer())
                    {
                        if (TexNET.getAnswer(out byte opcode, out byte[] msg, out int length))
                        {
                            if ((opcode == cMTDOpcodes.OPC_READ_FLOW) && (length >= 8))
                            {
                                flow        = BitConverter.ToSingle(msg, 0);
                                temperature = BitConverter.ToSingle(msg, 4);
                                bError      = false;
                            }
                        }
                        else
                        {
                            if (SerialMode != eSerialMode.eCLOSED)
                            {
                                portOpenRetry = 3;
                                SerialMode    = eSerialMode.eSETUP;
                                bError        = true;
                            }
                        }

                        if (RequestStatus == eRequestStatus.eNEW_REQUEST)
                        {
                            RequestMState = eRequestMState.eUSER_REQUEST;
                        }
                        else
                        {
                            RequestMState = eRequestMState.eFLOW;
                        }
                    }
                    break;
                }

                case eRequestMState.eUSER_REQUEST:
                {
                    TexNET.sendRequest(NewRequest.Opcode, NewRequest.Msg);
                    RequestStatus = eRequestStatus.eWAITTING;
                    RequestMState = eRequestMState.eUSER_ANSWER;
                    break;
                }

                case eRequestMState.eUSER_ANSWER:
                {
                    if (!TexNET.isWaitingAnswer())
                    {
                        if (TexNET.getAnswer(out byte opcode, out byte[] msg, out int length))
                        {
                            if (opcode == NewRequest.Opcode)
                            {
                                NewRequest.Opcode = opcode;
                                NewRequest.Msg    = msg;
                                NewRequest.Length = (byte)length;
                                RequestStatus     = eRequestStatus.eSUCCESS;
                                bError            = false;
                            }
                            else
                            {
                                RequestStatus = eRequestStatus.eFAIL;
                                if (SerialMode != eSerialMode.eCLOSED)
                                {
                                    portOpenRetry = 3;
                                    SerialMode    = eSerialMode.eSETUP;
                                    bError        = true;
                                }
                            }
                        }
                        else
                        {
                            RequestStatus = eRequestStatus.eFAIL;
                            if (SerialMode != eSerialMode.eCLOSED)
                            {
                                portOpenRetry = 3;
                                SerialMode    = eSerialMode.eSETUP;
                                bError        = true;
                            }
                        }

                        RequestMState = eRequestMState.eFLOW;
                    }
                    break;
                }
                }
            }
        }
예제 #5
0
        void task()
        {
            while (!TaskEnd)
            {
                if (bDisconnect)
                {
                    SerialMode = eSerialMode.eCLOSED;
                }

                switch (SerialMode)
                {
                case eSerialMode.eCLOSED:
                {
                    if (TheSerialPort.IsOpen)
                    {
                        TheSerialPort.Close();
                    }
                    bError      = true;
                    bDisconnect = false;

                    if ((RequestStatus == eRequestStatus.eNEW_REQUEST) || (RequestStatus == eRequestStatus.eWAITTING))
                    {
                        RequestStatus = eRequestStatus.eFAIL;
                    }
                    break;
                }

                case eSerialMode.eSETUP:
                {
                    if (TheSerialPort.IsOpen)
                    {
                        TheSerialPort.Close();
                    }

                    if (AutoDetectPort)
                    {
                        try
                        {
                            List <string> Ports = new List <string>(System.IO.Ports.SerialPort.GetPortNames());

                            if (Ports.Count > 0)
                            {
                                Ports.Sort();

                                if (portIdx < 0)
                                {
                                    portIdx = 0;
                                }
                                else
                                {
                                    portIdx++;
                                }

                                if (portIdx >= Ports.Count)
                                {
                                    portIdx = 0;
                                }

                                TheSerialPort.PortName = Ports[portIdx];
                            }
                            else
                            {
                                portIdx = -1;
                            }
                        }
                        catch
                        {
                            portIdx = -1;
                        }
                    }

                    SerialMode = eSerialMode.eOPEN;
                    break;
                }

                case eSerialMode.eOPEN:
                {
                    if (!TheSerialPort.IsOpen)
                    {
                        try
                        {
                            TheSerialPort.BaudRate = 115200;
                            TheSerialPort.Open();
                        }
                        catch
                        {
                            bError = true;

                            if (portOpenRetry == 0)
                            {
                                portOpenRetry = 3;
                                SerialMode    = eSerialMode.eSETUP;
                            }
                            else
                            {
                                portOpenRetry--;
                            }
                        }
                    }
                    else
                    {
                        TheSerialPort.Close();
                    }

                    if (TheSerialPort.IsOpen)
                    {
                        SerialMode = eSerialMode.eTEXNET;
                        bError     = false;
                    }
                    break;
                }

                case eSerialMode.eTEXNET:
                {
                    if (!TheSerialPort.IsOpen)
                    {
                        portOpenRetry = 3;
                        SerialMode    = eSerialMode.eSETUP;
                        bError        = true;
                    }
                    else
                    {
                        poll();
                    }
                    break;
                }
                }

                Thread.Sleep(10);
            }
        }