コード例 #1
0
        public void iniciarThreadConexao()
        {
            // Iniciando/Reiniciando travas.
            transmissionSemaphore = new Semaphore(1, 1);

            string enderecoModBus = modbusRegistry.obterModBusEndereco();
            int    portaModBus    = modbusRegistry.obterModBusPorta();

            ThreadConexao = new Thread(() =>
            {
                bool conectado = false;

                databaseCheckerShouldRun = true;

                while (conectado == false && DatabaseCheckerShouldRun)
                {
                    try
                    {
                        modbusClient = new ModbusClient(enderecoModBus, portaModBus);    //Ip-Address and Port of Modbus-TCP-Server
                        modbusClient.Connect();                                          //Connect to Server
                        conectado = true;
                        ProcessIcon.ChangeIcon((int)ProcessIcon.ICONS.Normal);
                    }
                    catch (Exception ex)
                    {
                        logger.Error("Erro ao conectar ao servidor: " + ex.Message);
                        logger.Warn("Tentando novamente em 3 segundos...");
                        Thread.Sleep(3000);
                    }
                }

                iniciarThreadPrincipal();
                iniciarThreadHeartBeat();
                ThreadConexao.Join();
            });
            ThreadConexao.Name = "Conexão";
            ThreadConexao.Start();
        }
コード例 #2
0
        public void pararThreads()
        {
            DatabaseCheckerShouldRun = false;
            logger.Warn("**** Interrompendo threads de produção/reconexão ****");
            Thread.Sleep(2000);

            // Limpa o Thread de Conexao
            if (ThreadConexao != null)
            {
                try
                {
                    if (ThreadConexao.IsAlive)
                    {
                        ThreadConexao.Abort();
                        //ThreadConexao = null;
                        logger.Fatal(ThreadConexao.Name + " exterminada de forma forçada");
                    }
                    else
                    {
                        ThreadConexao.Join();
                        //ThreadConexao = null;
                        logger.Info(ThreadConexao.Name + " terminada normalmente.");
                    }
                }
                catch (Exception ex)
                {
                    logger.Error("Erro ao interromper o thread " + ThreadConexao.Name + ": " + ex.Message);
                }
            }

            // Derruba a conexão se tiver...
            if (modbusClient != null)
            {
                try
                {
                    modbusClient.Disconnect();
                }
                catch (Exception ex)
                {
                    logger.Error("Erro ao desconectar do servidor: " + ex.Message);
                }
            }

            // Derruba o Thread Principal se estiver rodando...
            if (ThreadPrincipal != null)
            {
                try
                {
                    // Tenta parar a thread por bem.
                    if (ThreadPrincipal.IsAlive)
                    {// Senão para por mal...
                        ThreadPrincipal.Abort();
                        //ThreadPrincipal = null;
                        logger.Fatal(ThreadPrincipal.Name + " exterminada de forma forçada");
                    }
                    else
                    {
                        ThreadPrincipal.Join();
                        //ThreadPrincipal = null;
                        logger.Info(ThreadPrincipal.Name + " terminada normalmente.");
                    }
                }
                catch (Exception ex)
                {
                    logger.Error("Erro ao interromper o thread " + ThreadPrincipal.Name + ": " + ex.Message);
                }
            }

            // Derruba o Thread de Heartbeat se estiver rodando...
            if (ThreadHeartBeat != null)
            {
                try
                {
                    if (ThreadHeartBeat.IsAlive)
                    {
                        ThreadHeartBeat.Abort();
                        //ThreadHeartBeat = null;
                        logger.Fatal(ThreadHeartBeat.Name + " exterminada de forma forçada");
                    }
                    else
                    {
                        ThreadHeartBeat.Join();
                        //ThreadHeartBeat = null;
                        logger.Info(ThreadHeartBeat.Name + " terminada normalmente.");
                    }
                }
                catch (Exception ex)
                {
                    logger.Error("Erro ao interromper o thread " + ThreadHeartBeat.Name + ": " + ex.Message);
                }
            }
        }