Esempio n. 1
0
        /// <summary>
        /// 按位输出信号
        /// </summary>
        /// <param name="nIndex"></param>
        /// <param name="bBit"></param>
        /// <returns></returns>
        public override bool WriteIoBit(int nIndex, bool bBit)
        {
            if (!m_bOpen)
            {
                return(false);
            }
            int  nAxisNo   = (nIndex & 0xff00) >> 8;
            int  nIoIndex  = nIndex & 0xff;
            byte byteWrite = bBit ? (byte)1 : (byte)0;
            // Motion.mAcm_AxDoSetBit(m_Axishand[nAxisNo], (ushort)nIoIndex, byteWrite);
            byte   slaveAddress = (byte)m_nCardNo;
            ushort coilAddress  = (ushort)(nIoIndex + 80);

            try
            {
                lock (_syncRoot)
                    _master.WriteSingleCoil(slaveAddress, coilAddress, bBit);
                return(true);
            }
            catch (Exception ex)
            {
                if (_serialPort.IsOpen)
                {
                    _serialPort.Close();
                }
                if (!_serialPort.IsOpen)
                {
                    _serialPort.Open();
                }
                _master.Dispose();
                _master = ModbusSerialMaster.CreateRtu(_serialPort);
                _logger.Warn(ex.Message);
                return(false);
            }
        }
Esempio n. 2
0
        private void btn_for_Click(object sender, EventArgs e)
        {
            IModbusSerialMaster master3 = ModbusSerialMaster.CreateRtu(ports);

            if (funct1 == 0)
            {
                funct1            = 1;
                btn_for.Text      = "LIGADO";
                btn_for.BackColor = Color.LightGreen;
                master3.WriteSingleCoil(1, 4, true);
            }
            else if (funct1 == 1)
            {
                funct1            = 0;
                btn_for.Text      = "DESLIGADO";
                btn_for.BackColor = Color.LightCoral;
                master3.WriteSingleCoil(1, 4, false);
            }
        }
 private void btnPosicao4_Click(object sender, EventArgs e)
 {
     try
     {
         SerialPort port = new SerialPort("COM4");
         // configure serial port
         port.BaudRate = 19200;
         port.DataBits = 8;
         port.Parity   = Parity.None;
         port.StopBits = StopBits.One;
         port.Close();
         port.Open();
         IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
         byte slaveId = 1;
         master.WriteSingleCoil(slaveId, 2068, true);
         port.Close();
     }
     catch
     {
         responseData = "";
     }
 }
Esempio n. 4
0
        /// <summary>
        /// 写入操作,针对的数据类型只有 字符串量 计算值 关系数据库值
        /// </summary>
        /// <param name="server"></param>
        /// <param name="comm"></param>
        /// <param name="device"></param>
        /// <param name="para">要写入参数</param>
        /// <param name="value">要写入的值</param>
        /// <returns></returns>
        public Task <bool> ResponseData(string SlaveId, string Address, ModbusFragment para, string value)
        {
            var task = Task.Run <bool>(() => {
                if (para == null)
                {
                    return(false);
                }

                //设备地址不能为空
                if (Address == "")
                {
                    return(false);
                }
                try
                {
                    //获取参数中的
                    if (serialPort != null && serialPort.IsOpen && master != null)
                    {
                        ushort offset = para.StartRegister;
                        switch (para.Code)
                        {
                        case "01":
                            {
                                ///写入单个线圈
                                if (ushort.Parse(value) > 0)
                                {
                                    master.WriteSingleCoil(byte.Parse(Address), offset, true);
                                }
                                else
                                {
                                    master.WriteSingleCoil(byte.Parse(Address), offset, false);
                                }
                            }
                            break;

                        case "02":    //此类型只能查询,不能写入
                            {
                            }
                            break;

                        case "03":
                            {
                                switch (para.DataType)
                                {
                                case "float":        //单精度浮点型
                                    {
                                        ushort[] buff    = new ushort[2];
                                        float WriteValue = float.Parse(value);
                                        ModbusConvert.SetReal(buff, 0, WriteValue);
                                        master.WriteMultipleRegisters(byte.Parse(Address), offset, buff);
                                    }
                                    break;

                                case "double":        //双精度浮点数64位
                                    {
                                        ushort[] buff     = new ushort[4];
                                        double WriteValue = double.Parse(value);
                                        ModbusConvert.SetDouble(buff, 0, WriteValue);
                                        master.WriteMultipleRegisters(byte.Parse(Address), offset, buff);
                                    }
                                    break;

                                case "string":        //字符型
                                    {
                                        ushort[] buff     = new ushort[para.charsize];
                                        string WriteValue = value;
                                        if (value.Length > para.charsize)
                                        {
                                            WriteValue = value.Substring(0, para.charsize);
                                        }
                                        if (value.Length < para.charsize)
                                        {
                                            WriteValue = value.PadRight(para.charsize, ' ');
                                        }
                                        ModbusConvert.SetString(buff, 0, WriteValue);
                                        master.WriteMultipleRegisters(byte.Parse(Address), offset, buff);
                                    }
                                    break;

                                case "byte":        //无符号整数8位:
                                    {
                                        ushort[] buff   = new ushort[1];
                                        byte WriteValue = byte.Parse(value);
                                        ModbusConvert.SetByte(buff, 0, WriteValue, true);
                                        master.WriteSingleRegister(byte.Parse(Address), offset, buff[0]);
                                    }
                                    break;

                                case "sbyte":        //有符号整数8位:
                                    {
                                        ushort[] buff    = new ushort[1];
                                        sbyte WriteValue = sbyte.Parse(value);
                                        ModbusConvert.SetSByte(buff, 0, WriteValue, true);
                                        master.WriteSingleRegister(byte.Parse(Address), offset, buff[0]);
                                    }
                                    break;

                                case "uint16":        //无符号整数16位:
                                    {
                                        ushort WriteValue = ushort.Parse(value);
                                        ushort[] buff     = new ushort[1];
                                        ModbusConvert.SetUShort(buff, 0, WriteValue);
                                        master.WriteSingleRegister(byte.Parse(Address), offset, buff[0]);
                                    }
                                    break;

                                case "int16":        //有符号整数16位:
                                    {
                                        Int16 WriteValue = Int16.Parse(value);
                                        ushort[] buff    = new ushort[1];
                                        ModbusConvert.SetShort(buff, 0, WriteValue);
                                        master.WriteSingleRegister(byte.Parse(Address), offset, buff[0]);
                                    }
                                    break;

                                case "uint32":        //无符号整数32位:
                                    {
                                        uint WriteValue = uint.Parse(value);
                                        ushort[] buff   = new ushort[2];
                                        ModbusConvert.SetUInt(buff, 0, WriteValue);
                                        master.WriteMultipleRegisters(byte.Parse(Address), offset, buff);
                                    }
                                    break;

                                case "int32":        //有符号整数32位:
                                    {
                                        int WriteValue = int.Parse(value);
                                        ushort[] buff  = new ushort[2];
                                        ModbusConvert.SetInt(buff, 0, WriteValue);
                                        master.WriteMultipleRegisters(byte.Parse(Address), offset, buff);
                                    }
                                    break;
                                }
                            }
                            break;
                        }
                    }
                }
                catch
                {
                    return(false);
                }
                return(true);
            });

            return(task);
        }
Esempio n. 5
0
 /// <summary>
 /// 根据从站ID和地址写线圈状态
 /// </summary>
 /// <param name="master"></param>
 /// <param name="slaveid"></param>
 /// <param name="addr"></param>
 /// <param name="value"></param>
 public static void WriteValue(IModbusSerialMaster master, byte slaveid, ushort addr, bool value)
 {
     master.WriteSingleCoil(slaveid, addr, value);
 }
Esempio n. 6
0
        private void ComunicaçãoCLP()
        {
            try
            {
                SerialPort port = new SerialPort("COM3");
                // configure serial port
                port.BaudRate = 19200;
                port.DataBits = 8;
                port.Parity   = Parity.None;
                port.StopBits = StopBits.One;
                port.Close();
                port.Open();
                IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
                byte   slaveId             = 1;
                ushort startAddress        = 4096;
                ushort numRegisters        = 10;
                if (btnRejeito.BackColor == Color.Red)
                {
                    master.WriteSingleCoil(slaveId, 2070, false);
                }
                else
                {
                    master.WriteSingleCoil(slaveId, 2070, true);
                }
                if (reset1 == true)
                {
                    master.WriteSingleCoil(slaveId, 2068, true);
                    reset1 = false;
                }
                if (reset2 == true)
                {
                    master.WriteSingleCoil(slaveId, 2069, true);
                    reset2 = false;
                }



                ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, numRegisters);
                //bool[] coil = master.ReadCoils(slaveId, 2068, 5);

                //Resultados na Camera esquerda

                bom_esq       = (registers[1] * 65536) + registers[0];
                bom_dir       = (registers[3] * 65536) + registers[2];
                total_esq     = (registers[5] * 65536) + registers[4];
                total_dir     = (registers[7] * 65536) + registers[6];
                txtBons.Text  = Convert.ToString(bom_esq);
                ruim_esq      = total_esq - bom_esq;
                txtRuins.Text = Convert.ToString(ruim_esq);
                txtTotal.Text = Convert.ToString(total_esq);
                if (ruim_esq > 0)
                {
                    txtPorcentagemRuins.Text = Convert.ToString((ruim_esq / total_esq) * 100);
                }
                if (bom_esq > 0)
                {
                    txtPorcentagemBons.Text = Convert.ToString((bom_esq / total_esq) * 100);
                }

                //Resultados na Camera direita
                txtBons1.Text  = Convert.ToString(bom_dir);
                ruim_dir       = total_dir - bom_dir;
                txtRuins1.Text = Convert.ToString(ruim_dir);
                txtTotal1.Text = Convert.ToString(total_dir);
                if (ruim_dir > 0)
                {
                    txtPorcentagemRuins1.Text = Convert.ToString((ruim_dir / total_dir) * 100);
                }
                if (bom_dir > 0)
                {
                    txtPorcentagemBons1.Text = Convert.ToString((bom_dir / total_dir) * 100);
                }
                port.Close();
            }
            catch
            {
                responseData = "";
            }
        }