Exemple #1
0
 public ReadedParams ReadParams()
 {
     try
     {
         Modbus.READ_INPUT_REGS_RESP resp = _modbus.ReadInputRegisters(0, 4);
         return(new ReadedParams()
         {
             F = resp.GetInpRegsFLOAT(0),
             U = resp.GetInpRegsFLOAT(2)
         });
     }
     catch (TimeoutException)
     {
         return(null);
     }
 }
Exemple #2
0
        private void backgroundReader_DoWork(object sender, DoWorkEventArgs e)
        {
            ReaderParams param = (ReaderParams)e.Argument;
            SerialPort   port  = null;

            try
            {
                port = new SerialPort(param.Port, param.Baudrate, Parity.None, 8, StopBits.One);
                port.WriteTimeout = port.ReadTimeout = 250;
                port.Open();

                Modbus modbus = new Modbus(port, param.ModbusID);

                modbus.WriteSingleRegister(34, 123);
                modbus.WriteSingleRegister(35, (ushort)(param.Type == AnalogSensorType.TypeAnalog ? 0 : 1));

                while (!backgroundReader.CancellationPending)
                {
                    try
                    {
                        Modbus.READ_INPUT_REGS_RESP resp = modbus.ReadInputRegisters(0, 6);

                        float val = 0.0f;
                        if (param.Type == AnalogSensorType.TypeAnalog)
                        {
                            val = resp.GetInpRegsFLOAT(2);
                        }
                        else
                        {
                            val = resp.GetInpRegsFLOAT(0);
                        }

                        float curr = resp.GetInpRegsFLOAT(4) * 1000;

                        Invoke(new Action <string>(a => lbValue.Text   = a), string.Format("{0:0.00}", val));
                        Invoke(new Action <string>(a => lbCurrent.Text = a), ((int)(curr)).ToString());
                        connectStatus = ConnectionStatus.ConnectionOn;

                        Thread.Sleep(400);
                    }
                    catch (TimeoutException)
                    {
                        //выходим

                        /*e.Result = new ReaderResult()
                         * {
                         *  Status = ReaderResult.ReaderStatus.ReaderError,
                         *  Message = currentTranslation.modbusNoAnswerError
                         * };
                         *
                         * return;*/

                        Invoke(new Action <string>(a => lbValue.Text   = a), string.Format("{0:0.00}", 0.0f));
                        Invoke(new Action <string>(a => lbCurrent.Text = a), "0");
                        connectStatus = ConnectionStatus.ConnectionOff;
                    }
                    catch (Modbus.ModbusException ex)
                    {
                        string message = ex.Message;

                        switch (ex.Reason)
                        {
                        case Modbus.ModbusException.ExceptionReason.IllegalAddrException:
                        case Modbus.ModbusException.ExceptionReason.IllegalFuncException:
                        case Modbus.ModbusException.ExceptionReason.IllegalValueException:
                            message = currentTranslation.modbusIllegalError;
                            break;

                        case Modbus.ModbusException.ExceptionReason.CRCException:
                            message = currentTranslation.modbusCRCError;
                            break;

                        case Modbus.ModbusException.ExceptionReason.IDException:
                            message = currentTranslation.modbusHostIDError;
                            break;

                        case Modbus.ModbusException.ExceptionReason.LengthException:
                            message = currentTranslation.modbusBufferLenError;
                            break;

                        case Modbus.ModbusException.ExceptionReason.UnknownException:
                            message = currentTranslation.modbusUnknownError;
                            break;
                        }

                        e.Result = new ReaderResult()
                        {
                            Status  = ReaderResult.ReaderStatus.ReaderError,
                            Message = message
                        };
                        return;
                    }
                }

                e.Result = new ReaderResult()
                {
                    Status = ReaderResult.ReaderStatus.ReaderCancel
                };
                return;
            }
            catch (Exception ex)
            {
                e.Result = new ReaderResult()
                {
                    Status  = ReaderResult.ReaderStatus.ReaderError,
                    Message = ex.Message
                };
                return;
            }
            finally
            {
                if (port != null)
                {
                    if (port.IsOpen)
                    {
                        port.Close();
                    }
                }
            }
        }