/// <summary> /// Set state relay by index /// </summary> /// <param name="master">modbus transport</param> /// <param name="index">aim index relay</param> /// <param name="value">aim value relay</param> public void SetRelayState(IModbusMaster master, int index, bool value) { var answer = master.ReadHoldingRegisters(_address, RegisterStartRelays, CountRegistersRelays); Thread.Sleep(10); var state = SetBitToUShortArray(answer, index, value); master.WriteMultipleRegisters(_address, RegisterStartRelays, state); //answer = master.ReadHoldingRegisters(_address, RegisterStartRelays, CountRegistersRelays); //if (state != answer) // throw new Exception(string.Format("Relay not setted(must by {0} but now {1})", state, answer)); }
public static void ReadRegisters(IModbusMaster master) { var result = master.ReadHoldingRegisters(1, 0, 5); for (int i = 0; i < 5; i++) { if (result[i] != i + 1) throw new Exception(); } }
/// <summary> /// Set state multiply relay by index /// </summary> /// <param name="master">modbus transport</param> /// <param name="values">aim values relays</param> public void SetRelayState(IModbusMaster master, IDictionary<int, bool> values) { var answer = master.ReadHoldingRegisters(_address, RegisterStartRelays, CountRegistersRelays); var state = answer; Thread.Sleep(10); foreach (var value in values) { state = SetBitToUShortArray(answer, value.Key, value.Value); } master.WriteMultipleRegisters(_address, RegisterStartRelays, state); _relays = state; //Thread.Sleep(50); //answer = master.ReadHoldingRegisters(_address, RegisterStartRelays, CountRegistersRelays); //if (state != answer) // throw new Exception(string.Format("Relay not setted(must by {0} but now {1})", state, answer)); }
/// <summary> /// Возвращает состояние дискретного выхода /// </summary> /// <param name="registerAddress">Адрес дискретного выхода</param> public bool ReadHoldingRegister(ushort registerAddress) { if (!_connectionEstablished) { throw new InvalidOperationException(_connectionErrorMessage); } try { _logger.Trace($"Controller: {_controllerId}|ReadHoldingRegister ({registerAddress})"); var value = _client.ReadHoldingRegisters(_slaveAddress, (ushort)(registerAddress), 1)[0] == 1; _logger.Trace($"Controller: {_controllerId}|{registerAddress} == {value}"); return(value); } catch { _connectionEstablished = false; throw; } }
/// <summary> /// Read state all state relay /// </summary> /// <param name="master">Транспорт</param> /// <returns>Список изменившихся входов</returns> public void UpdateAllStateRelay(IModbusMaster master) { _relays = master.ReadHoldingRegisters(_address, RegisterStartRelays, CountRegistersRelays); }
private bool ModbusUpdate() { try { lock (m_syncObject) { switch (state) { case State.Read: try { rdBuf = m_mbMaster.ReadHoldingRegisters(slaveaddr, read_start_addr, read_regs_number); state = State.New; Array.Copy(rdBuf, date_ind, date_regs, 0, 3); //++ Array.Copy(rdBuf, id_ind, ID, 0, 6); //++ Array.Copy(rdBuf, src_ind, src_num_regs, 0, 2); //++ Array.Copy(rdBuf, md5_ind, md5_regs, 0, 8); //++ Read_reg = rdBuf[19]; //++ ver_reg = rdBuf[39]; //++ Status_lbl.Invoke((MethodInvoker) delegate { Status_lbl.Text = "Подключен"; }); mb_ok++; is_connected = true; if (mb_ok > mb_tresh) { mb_ok = 0; error_cnt = 0; } } catch (Exception ex) { string strcgc = ex.Message; m_lastError = "Ошибка чтения"; error_cnt++; Status_lbl.Invoke((MethodInvoker) delegate { Status_lbl.Text = m_lastError + " " + error_cnt.ToString(); }); if (error_cnt > mb_tresh) { is_connected = false; } state = State.New; return(false); } break; case State.Write: try { state = State.Set; } catch (Exception ex) { return(false); } break; case State.New: break; case State.Set: state = State.Read; break; } } return(true); } catch (Exception ex) { m_lastError = ex.Message; return(false); } }
public ushort Read_reg(byte addr, ushort reg_addr, ushort num, string str, bool need = true) { ushort one_reg = 0xFF; ushort[] buf; try { switch (str) { case "input": buf = master.ReadInputRegisters(addr, reg_addr, num); one_reg = buf[0]; if (need == true) { for (int i = 0; i < buf.Length; i++) { output += (addr).ToString("D3") + ":" + (reg_addr + i).ToString("D3") + " " + str + ": " + buf[i].ToString("D5") + "\n"; } } break; case "holding": buf = master.ReadHoldingRegisters(addr, reg_addr, num); one_reg = buf[0]; if (need == true) { for (int i = 0; i < buf.Length; i++) { output += (addr).ToString("D3") + ":" + (reg_addr + i).ToString("D3") + " " + str + ": " + buf[i].ToString("D5") + "\n"; } } break; default: reg_addr = 31; num = 1; buf = master.ReadInputRegisters(addr, reg_addr, num); one_reg = buf[0]; buf = master.ReadInputRegisters(addr, (ushort)(reg_addr + 1), (ushort)(one_reg * 8)); if (need == true) { for (int i = 0; i < buf.Length; i++) { if (i % 8 == 0) { output += "\n"; } if (i % 8 < 4) { output += ((byte)buf[i]).ToString("X2") + ((byte)(buf[i] >> 8)).ToString("X2"); } if (i % 8 == 4) { output += " " + ((double)buf[i] / 10).ToString("F1") + " "; } if (i % 8 > 4) { output += buf[i].ToString() + " "; } } output += "\n"; } break; } } catch { output += (addr).ToString("D3") + " " + str + ":" + "Time out\n"; } RaisePropertyChanged("Terminal"); return(one_reg); }
private void Connect_check() { COM1.BaudRate = br_enum[Baudrate.SelectedIndex]; switch (Databits.SelectedIndex) { case 0: COM1.DataBits = 8; break; case 1: COM1.DataBits = 9; break; } switch (Parity.SelectedIndex) { case 0: COM1.Parity = System.IO.Ports.Parity.None; break; case 1: COM1.Parity = System.IO.Ports.Parity.Odd; break; case 2: COM1.Parity = System.IO.Ports.Parity.Even; break; default: COM1.Parity = System.IO.Ports.Parity.None; break; } switch (Stopbit.SelectedIndex) { case 0: COM1.StopBits = System.IO.Ports.StopBits.One; break; case 1: COM1.StopBits = System.IO.Ports.StopBits.Two; break; case 2: COM1.StopBits = System.IO.Ports.StopBits.OnePointFive; break; default: COM1.StopBits = System.IO.Ports.StopBits.None; break; } status_line.Text = null; checkBox1.CheckState = CheckState.Unchecked; try { if (!COM1.IsOpen) { COM1.Open(); } //Thread read = //m_mbMaster = ModbusSerialMaster.CreateRtu(COM1); //m_mbMaster.Transport.ReadTimeout = 1000; //m_state = WorkState.Update; ushort[] tBuf = m_mbMaster.ReadHoldingRegisters(0, 90, 10); if ((tBuf[0] == 0x0102) && (tBuf[9] == 0x01)) { status_line.Text = " Подключен "; IsConnected = true; checkBox1.CheckState = CheckState.Checked; baudrate_label.BackColor = Color.Green; baudrate_label.Text = "Set"; databits_label.BackColor = Color.Green; databits_label.Text = "Set"; parity_label.BackColor = Color.Green; parity_label.Text = "Set"; stopbit_label.BackColor = Color.Green; stopbit_label.Text = "Set"; addr_label.BackColor = Color.Green; addr_label.Text = "Set"; } } catch (Exception ex) { status_line.Text = " Ошибка подключения"; checkBox1.CheckState = CheckState.Unchecked; MessageBox.Show(ex.Message, "Ошибка !!!", MessageBoxButtons.OK, MessageBoxIcon.Error); } //if(!COM1.IsOpen) //{ // COM1.Open(); // m_mbMaster = ModbusSerialMaster.CreateRtu(COM1); //} // rxBuf = m_mbMaster.ReadHoldingRegisters(0, 20, 1); }
/// <summary> /// Метод для считывния содержимого с регистров выхода (AO - на модуле, сигнал от модуля ) /// Read holding registers value /// </summary> /// <param name="slaveID">Address of device to read values from</param> /// <param name="startAddress">Address to begin reading.</param> /// <param name="numOfPoints">Number of holding registers to read</param> /// <returns> ushort[] </returns> public ushort[] ReadHoldingRegistr(byte slaveID, ushort startAddress, ushort numOfPoints) // функциональный код 03 { return(NetworkIsOk ? master.ReadHoldingRegisters(slaveID, startAddress, numOfPoints) : null); }
protected void ReadBuffer(ModbusBaseClientStation self, IModbusMaster master, ModbusBuffer buf) { try { ushort[] registers; byte[] adr; bool[] inputs; if (buf.pauseCounter == 0) { ushort startAddress = buf.startAddress; ushort numInputs = buf.numInputs; switch (buf.ModbusDataType) { case ModbusDataTypeEx.InputRegister: case ModbusDataTypeEx.HoldingRegister: if (buf.ModbusDataType == ModbusDataTypeEx.InputRegister) { registers = master.ReadInputRegisters(buf.slaveId, startAddress, numInputs); } else { registers = master.ReadHoldingRegisters(buf.slaveId, startAddress, numInputs); } DateTime dt = DateTime.Now; int iresult = 0; uint uresult = 0; double fresult = 0.0; foreach (ModbusChannelImp ch in buf.channels) { switch (ch.DeviceDataType) { case ModbusDeviceDataType.Int: adr = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress]); switch (ch.ConversionType) { case ModbusConversionType.SwapBytes: byte tmp = adr[0]; adr[0] = adr[1]; adr[1] = tmp; iresult = BitConverter.ToInt16(adr, 0); break; default: iresult = BitConverter.ToInt16(adr, 0); break; } if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Int32) { ch.DoUpdate(iresult, dt, ChannelStatusFlags.Good); } else if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Double) { ch.DoUpdate((double)(ch.K * iresult + ch.D), dt, ChannelStatusFlags.Good); } else if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert, self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString())); } break; case ModbusDeviceDataType.UInt: adr = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress]); switch (ch.ConversionType) { case ModbusConversionType.SwapBytes: byte tmp = adr[0]; adr[0] = adr[1]; adr[1] = tmp; uresult = BitConverter.ToUInt16(adr, 0); break; default: uresult = BitConverter.ToUInt16(adr, 0); break; } if (ch.ModbusFs2InternalType == ModbusFs2InternalType.UInt32) { ch.DoUpdate(uresult, dt, ChannelStatusFlags.Good); } else if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Double) { ch.DoUpdate((double)(ch.K * uresult + ch.D), dt, ChannelStatusFlags.Good); } else if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert, self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString())); } break; case ModbusDeviceDataType.DInt: byte[] adr0 = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress]); byte[] adr1 = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress + 1]); byte[] res = new byte[4]; res = self.SwapBytesIn(adr0, adr1, ch.ConversionType); iresult = BitConverter.ToInt32(res, 0); if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Int32) { ch.DoUpdate(iresult, dt, ChannelStatusFlags.Good); } else if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Double) { ch.DoUpdate((double)(ch.K * iresult + ch.D), dt, ChannelStatusFlags.Good); } else if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert, self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString())); } break; case ModbusDeviceDataType.DUInt: adr0 = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress]); adr1 = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress + 1]); res = self.SwapBytesIn(adr0, adr1, ch.ConversionType); uresult = BitConverter.ToUInt32(res, 0); if (ch.ModbusFs2InternalType == ModbusFs2InternalType.UInt32) { ch.DoUpdate(uresult, dt, ChannelStatusFlags.Good); } else if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Double) { ch.DoUpdate((double)(ch.K * uresult + ch.D), dt, ChannelStatusFlags.Good); } else if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert, self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString())); } break; case ModbusDeviceDataType.Float: adr0 = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress]); adr1 = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress + 1]); res = self.SwapBytesIn(adr0, adr1, ch.ConversionType); fresult = BitConverter.ToSingle(res, 0); if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Double) { ch.DoUpdate((double)(ch.K * fresult + ch.D), dt, ChannelStatusFlags.Good); } else if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert, self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString())); } break; case ModbusDeviceDataType.Bool: bool bit = (registers[ch.ModbusDataAddress - buf.startAddress] & (0x01 << ch.BitIndex)) > 0; if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Boolean) { ch.DoUpdate(bit, dt, ChannelStatusFlags.Good); } else if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert, self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString())); } break; case ModbusDeviceDataType.String: byte[] str = new byte[2 * ch.DeviceDataLen]; Decoder ascii = (new ASCIIEncoding()).GetDecoder(); int bytesUsed = 0; int charsUsed = 0; bool completed = false; int j = 0; // Conversion strategy: FIRST NONPRINTABLE CHARACTER (ORD < 32) BREAKS CONVERSION, string consists of printables converted before for (int i = 0; i < ch.DeviceDataLen; i++) { byte[] word = BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress + i]); if (ch.ConversionType == ModbusConversionType.SwapBytes) { if (word[1] < 32) { break; // nonprintable character } str[j++] = word[1]; if (word[0] < 32) { break; // nonprintable character } str[j++] = word[0]; } else { if (word[0] < 32) { break; // nonprintable character } str[j++] = word[0]; if (word[1] < 32) { break; // nonprintable character } str[j++] = word[1]; //Array.Copy(BitConverter.GetBytes(registers[ch.ModbusDataAddress - buf.startAddress + i]), 0, str, 2 * i, 2); } } string sresult; if (j > 0) { char[] chars = new char[j]; ascii.Convert(str, 0, j, chars, 0, j, true, out bytesUsed, out charsUsed, out completed); sresult = new String(chars); } else { sresult = ""; } if (ch.ModbusFs2InternalType == ModbusFs2InternalType.String) { ch.DoUpdate(sresult, dt, ChannelStatusFlags.Good); } else if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert, self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString())); } break; } } break; case ModbusDataTypeEx.Coil: case ModbusDataTypeEx.Input: if (buf.ModbusDataType == ModbusDataTypeEx.Coil) { inputs = master.ReadCoils(buf.slaveId, startAddress, numInputs); } else { inputs = master.ReadInputs(buf.slaveId, startAddress, numInputs); } dt = DateTime.Now; foreach (ModbusChannelImp ch in buf.channels) { if (ch.ModbusFs2InternalType == ModbusFs2InternalType.UInt32) { uint val = (uint)(inputs[ch.ModbusDataAddress - buf.startAddress] ? 1 : 0); ch.DoUpdate(val, dt, ChannelStatusFlags.Good); } else if (ch.ModbusFs2InternalType == ModbusFs2InternalType.Boolean) { bool val = inputs[ch.ModbusDataAddress - buf.startAddress]; ch.DoUpdate(val, dt, ChannelStatusFlags.Good); } else if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrConvert, self.Name, ch.Name, ch.DeviceDataType.ToString(), ch.ModbusFs2InternalType.ToString())); } } break; } // Case if (self.failures.ContainsKey(buf.slaveId)) { // failure signal defined self.failures[buf.slaveId].Value = false; } } // If else { buf.pauseCounter--; } } // Try catch (Modbus.SlaveException e) { buf.pauseCounter = self.FailedCount; if (self.failures.ContainsKey(buf.slaveId)) { // failure signal defined self.failures[buf.slaveId].Value = true; } foreach (ModbusChannelImp ch in buf.channels) { ch.StatusFlags = ChannelStatusFlags.Bad; } if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrReceive, self.Name, buf.slaveId, buf.ModbusDataType.ToString(), buf.startAddress, buf.numInputs, e.Message)); } } catch (TimeoutException e) { buf.pauseCounter = self.FailedCount; if (self.failures.ContainsKey(buf.slaveId)) { // failure signal defined self.failures[buf.slaveId].Value = true; } foreach (ModbusChannelImp ch in buf.channels) { ch.StatusFlags = ChannelStatusFlags.Bad; } if (self.LoggingLevel >= ModbusLog.logWarnings) { Env.Current.Logger.LogWarning(string.Format(StringConstants.ErrReceive, self.Name, buf.slaveId, buf.ModbusDataType.ToString(), buf.startAddress, buf.numInputs, e.Message)); } } }
public IEnumerable<KeyValuePair<Tag, object>> Update(IModbusMaster master) { Parse(storage, master.ReadHoldingRegisters(addr, 0, nregs)); return storage.ToList(); }
private void SendPackage(IModbusMaster modbus, Device dv, DataBlock db) { try { SendDone.WaitOne(-1); switch (db.DataType) { case "Bit": byte[] bitArys = null; switch (db.TypeOfRead) { case "ReadCoilStatus": bitArys = modbus.ReadCoilStatus((byte)dv.SlaveId, $"{db.StartAddress}", db.Length); break; case "ReadInputStatus": bitArys = modbus.ReadInputStatus((byte)dv.SlaveId, $"{db.StartAddress}", db.Length); break; default: break; } var BitRs = Bit.ToArray(bitArys); if (bitArys.Length > db.Tags.Count) { return; } for (var j = 0; j < db.Tags.Count; j++) { db.Tags[j].Value = BitRs[j]; db.Tags[j].Checked = BitRs[j]; db.Tags[j].Enabled = BitRs[j]; db.Tags[j].Visible = BitRs[j]; db.Tags[j].ValueSelect1 = BitRs[j]; db.Tags[j].ValueSelect2 = BitRs[j]; db.Tags[j].Timestamp = DateTime.Now; } break; case "Int": var IntArys = modbus.ReadHoldingRegisters((byte)dv.SlaveId, $"{db.StartAddress}", db.Length); var IntRs = Int.ToArray(IntArys); if (IntRs.Length > db.Tags.Count) { return; } for (var j = 0; j < IntRs.Length; j++) { db.Tags[j].Value = IntRs[j]; db.Tags[j].Timestamp = DateTime.Now; } break; case "DInt": var DIntArys = modbus.ReadHoldingRegisters((byte)dv.SlaveId, $"{db.StartAddress}", db.Length); var DIntRs = Int.ToArray(DIntArys); if (DIntRs.Length > db.Tags.Count) { return; } for (var j = 0; j < DIntRs.Length; j++) { db.Tags[j].Value = DIntRs[j]; db.Tags[j].Timestamp = DateTime.Now; } break; case "Word": byte[] wdArys = null; switch (db.TypeOfRead) { case "ReadHoldingRegisters": wdArys = modbus.ReadHoldingRegisters((byte)dv.SlaveId, $"{db.StartAddress}", db.Length); break; case "ReadInputRegisters": wdArys = modbus.ReadInputRegisters((byte)dv.SlaveId, $"{db.StartAddress}", db.Length); break; default: break; } var wdRs = Word.ToArray(wdArys); if (wdRs.Length > db.Tags.Count) { return; } for (var j = 0; j < wdRs.Length; j++) { db.Tags[j].Value = wdRs[j]; db.Tags[j].Timestamp = DateTime.Now; } break; case "DWord": var dwArys = modbus.ReadHoldingRegisters((byte)dv.SlaveId, $"{db.StartAddress}", db.Length); var dwRs = DWord.ToArray(dwArys); for (var j = 0; j < dwRs.Length; j++) { db.Tags[j].Value = dwRs[j]; db.Tags[j].Timestamp = DateTime.Now; } break; case "Real": var rl1Arys = modbus.ReadHoldingRegisters((byte)dv.SlaveId, $"{db.StartAddress}", db.Length); var rl1Rs = Real.ToArray(rl1Arys); for (var j = 0; j < rl1Rs.Length; j++) { db.Tags[j].Value = rl1Rs[j]; db.Tags[j].Timestamp = DateTime.Now; } break; } } catch (Exception ex) { IsConnected = false; EventscadaException?.Invoke(this.GetType().Name + " XModbus.SendPackage", ex.Message); } }
public void OnButtonMbusExecuteClicked(object sender, RoutedEventArgs e) { if (mbus_client.Connected) { ushort offset = ushort.Parse(boxRegOffset.Text); ushort quantity = ushort.Parse(boxRegNumber.Text); byte slave = 0x00; ushort val = ushort.Parse(boxModbusWriteValue.Text); switch (boxModbusOp.Text) { case "Чтение дискретных входов": bool[] discrete_output; try { discrete_output = mbus_master.ReadInputs(slave, offset, quantity); } catch (IOException) { Console.WriteLine("Ошибка соединения. Соединение сброшено"); mbus_client.Close(); discrete_output = new bool[0]; } catch (InvalidModbusRequestException) { Console.WriteLine("Что-то пошло не так..."); discrete_output = new bool[0]; } foreach (bool b in discrete_output) { if (b) { Console.Write("1 "); } else { Console.Write("0 "); } } Console.Write('\n'); break; case "Чтение дискретных выходов": bool[] coil_output; try { coil_output = mbus_master.ReadCoils(slave, offset, quantity); } catch (IOException) { Console.WriteLine("Ошибка соединения. Соединение сброшено"); mbus_client.Close(); coil_output = new bool[0]; } catch (InvalidModbusRequestException) { Console.WriteLine("Что-то пошло не так..."); coil_output = new bool[0]; } foreach (bool b in coil_output) { if (b) { Console.Write("1 "); } else { Console.Write("0 "); } } Console.Write('\n'); break; case "Чтение выходных регистров": ushort[] holding_output; try { holding_output = mbus_master.ReadHoldingRegisters(slave, offset, quantity); } catch (IOException) { Console.WriteLine("Ошибка соединения. Соединение сброшено"); mbus_client.Close(); holding_output = new ushort[0]; } catch (InvalidModbusRequestException) { Console.WriteLine("Что-то пошло не так..."); holding_output = new ushort[0]; } foreach (int i in holding_output) { Console.Write(i.ToString() + " "); } Console.WriteLine(""); break; case "Чтение входных регистров": ushort[] inreg_output; try { inreg_output = mbus_master.ReadInputRegisters(slave, offset, quantity); } catch (IOException) { Console.WriteLine("Ошибка соединения. Соединение сброшено"); mbus_client.Close(); inreg_output = new ushort[0]; } catch (InvalidModbusRequestException) { Console.WriteLine("Что-то пошло не так..."); inreg_output = new ushort[0]; } foreach (int i in inreg_output) { Console.Write(i.ToString() + " "); } Console.WriteLine(""); break; case "Запись в дискретный выход": bool coil = val > 0 ? true : false; try { mbus_master.WriteSingleCoil(slave, offset, coil); Console.WriteLine("ЗАП OK"); } catch (IOException) { Console.WriteLine("Ошибка соединения. Соединение сброшено"); mbus_client.Close(); } catch (InvalidModbusRequestException) { Console.WriteLine("Что-то пошло не так..."); } break; case "Запись в регистр": try { mbus_master.WriteSingleRegister(slave, offset, val); Console.WriteLine("ЗАП OK"); } catch (IOException) { Console.WriteLine("Ошибка соединения. Соединение сброшено"); mbus_client.Close(); } catch (InvalidModbusRequestException) { Console.WriteLine("Что-то пошло не так..."); } break; case "Запись в несколько дискретных выходов": bool[] coil_input = new bool[quantity]; for (int i = 0; i < quantity; i++) { coil_input[i] = val > 0 ? true : false; } try { mbus_master.WriteMultipleCoils(slave, offset, coil_input); Console.WriteLine("ЗАП OK"); } catch (IOException) { Console.WriteLine("Ошибка соединения. Соединение сброшено"); mbus_client.Close(); } catch (InvalidModbusRequestException) { Console.WriteLine("Что-то пошло не так..."); } break; case "Запись в несколько регистров": ushort[] reg_out = new ushort[quantity]; for (int i = 0; i < quantity; i++) { reg_out[0] = val; } try { mbus_master.WriteMultipleRegisters(slave, offset, reg_out); Console.WriteLine("ЗАП OK"); } catch (IOException) { Console.WriteLine("Ошибка соединения. Соединение сброшено"); mbus_client.Close(); } catch (InvalidModbusRequestException) { Console.WriteLine("Что-то пошло не так..."); } break; case "Чтение/Запись в несколько регистров": ushort[] reg_write = new ushort[quantity]; ushort[] reg_read; ushort offset_write = ushort.Parse(boxRegOffsetWr.Text); for (int i = 0; i < quantity; i++) { reg_write[i] = val; } try { reg_read = mbus_master.ReadWriteMultipleRegisters(slave, offset, quantity, offset_write, reg_write); Console.WriteLine("ЧТЕН OK"); foreach (int i in reg_read) { Console.Write(i + " "); } Console.WriteLine("\nЗАП OK"); } catch (IOException) { Console.WriteLine("Ошибка соединения. Соединение сброшено"); mbus_client.Close(); } catch (InvalidModbusRequestException ex) { Console.WriteLine("Что-то пошло не так..."); } break; } } }
private void ProcessDataUpdateTick(object info) { if ((_client != null) && _client.Connected) { ScaleStatus = ""; _processDataTimer.Change(Timeout.Infinite, Timeout.Infinite); try { ushort[] _data = _master.ReadHoldingRegisters(MODBUS_SLAVE_ADDRESS, (CANOPEN_SLAVE_ADDRESS * 10), WTX_REGISTER_DATAWORD_COUNT); if (_data.Length > 4) { if ((_data[3] & 0x0080) > 0) { Weight = "--------"; ScaleStatus = "OVFL"; } else { Weight = UIntToWeight(_data[1] + (uint)(_data[2] << 16)); ScaleStatus = ""; } FillingResult = UIntToWeight(_data[4] + (uint)(_data[5] << 16)); if ((_data[3] & 0x0001) > 0) { CoarseFlow = "COARSE"; } else { CoarseFlow = ""; } if ((_data[3] & 0x0002) > 0) { _fineFlow = "FINE"; } else { _fineFlow = ""; } if ((_data[3] & 0x0004) > 0) { ScaleStatus = "READY"; } else { ScaleStatus = ""; } if ((_data[3] & 0x0040) > 0) { ScaleStatus = "ALARM"; } else { ScaleStatus = ""; } } else { Weight = "Communication error"; } } catch (Exception ex) { Weight = ex.Message; } finally { _processDataTimer.Change(200, 200); } } }
private async void ExecuteFunction() { try { //每次操作是要开启串口 操作完成后需要关闭串口 //目的是为了slave更换连接是不报错 if (port.IsOpen == false) { port.Open(); } //根据功能码写操作方法 if (functionCode != null) { switch (functionCode) { case "01 Read Coils": //读取单个线圈 SetReadParameters(); coilsBuffer = master.ReadCoils(slaveAddress, startAddress, numberOfPoints); for (int i = 0; i < coilsBuffer.Length; i++) { SetMsg(coilsBuffer[i] + " "); } SetMsg("\r\n"); break; case "02 Read DisCrete Inputs": //读取输入线圈/离散量线圈 SetReadParameters(); coilsBuffer = master.ReadInputs(slaveAddress, startAddress, numberOfPoints); for (int i = 0; i < coilsBuffer.Length; i++) { SetMsg(coilsBuffer[i] + " "); } SetMsg("\r\n"); break; case "03 Read Holding Registers": //读取保持寄存器 SetReadParameters(); registerBuffer = master.ReadHoldingRegisters(slaveAddress, startAddress, numberOfPoints); for (int i = 0; i < registerBuffer.Length; i++) { SetMsg(registerBuffer[i] + " "); } SetMsg("\r\n"); break; case "04 Read Input Registers": //读取输入寄存器 SetReadParameters(); registerBuffer = master.ReadInputRegisters(slaveAddress, startAddress, numberOfPoints); for (int i = 0; i < registerBuffer.Length; i++) { SetMsg(registerBuffer[i] + " "); } SetMsg("\r\n"); break; case "05 Write Single Coil": //写单个线圈 SetWriteParametes(); await master.WriteSingleCoilAsync(slaveAddress, startAddress, coilsBuffer[0]); break; case "06 Write Single Registers": //写单个输入线圈/离散量线圈 SetWriteParametes(); await master.WriteSingleRegisterAsync(slaveAddress, startAddress, registerBuffer[0]); break; case "0F Write Multiple Coils": //写一组线圈 SetWriteParametes(); await master.WriteMultipleCoilsAsync(slaveAddress, startAddress, coilsBuffer); break; case "10 Write Multiple Registers": //写一组保持寄存器 SetWriteParametes(); await master.WriteMultipleRegistersAsync(slaveAddress, startAddress, registerBuffer); break; default: break; } } else { MessageBox.Show("请选择功能码!"); } //关闭串口 port.Close(); } catch (Exception ex) { MessageBox.Show(ex.Message); } }
private void Scanner_Tick(object sender, EventArgs e) { try { ///////////////////////////////////////////////////////////////////////////// byte[] bytes = MMaster.ReadHoldingRegisters(1, 3829, 1); //خواندن خط کش txtSpacingRead.Text = string.Empty; // clear text. if (bytes != null) { short[] result = Int.ToArray(bytes); //3200 txtSpacingRead.Text = string.Format("{0}", result[1] * 0.02); // محاسبه عدد خط کش SpacingValue = (int)(result[1] * 0.02); // trackMM.Value = SpacingValue; } //////////////////////////////////////////////////////////////////////// if (StartTest && SpacingValue > ((int)txtSpacing.Value) - 1) // توقف تست { MMaster.WriteSingleCoil(1, 2048, false); // StartTest = false; watch.Stop(); } ///////////////////////////////////////////////////////////////////////// byte[] Loadcell = MMaster.ReadHoldingRegisters(2, 231, 4);// ترانسمیتر for (int i = 0, j = 1; i < Loadcell.Length;) { byte TempA = Loadcell[j]; // B Loadcell[j] = Loadcell[i]; // B <= A Loadcell[i] = TempA; // A<= B i += 2; j += 2; } valueff1 = BitConverter.ToSingle(Loadcell, 0); //لودسل سمت جک valueff2 = BitConverter.ToSingle(Loadcell, 4); // لودسل سمت فنر int x1 = (int)valueff1; int x2 = (int)valueff2; // Eff = (valueff2 / valueff1) * 100; txtForceSpring.Text = x2.ToString(); txtForceHand.Text = x1.ToString(); ///////////////////////////////////////////////////////////////////////// if (x2 > 1 && x1 > 1) { txtEffective.Text = (Eff + 5).ToString(); } //if (x2 > (Convert.ToDouble(Properties.Settings.Default.SpringForce))) //{ // MMaster.WriteSingleCoil(1, 2048, false);// توقف تست // watch.Stop(); //} if (true) { txtTime.Text = watch.Elapsed.ToString(); } if (x2 < 1) { MMaster.WriteSingleCoil(1, 2049, false);// توقف در نقطه صفر } } } catch { MessageBox.Show("Errorr Reaaaad"); } }
/// <summary> /// Get state relay by index /// </summary> /// <param name="master">modbus transport</param> /// <param name="index">aim index</param> /// <returns>state relay</returns> public bool GetRelayState(IModbusMaster master, int index) { var answer = master.ReadHoldingRegisters(_address, RegisterStartRelays, CountRegistersRelays); return GetBitFromUShortArray(answer, index); }
private ushort[] ReadHoldingRegisters(ushort startAddress, ushort pointCount) { return(m_modbusConnection.ReadHoldingRegisters(m_unitID, startAddress, pointCount)); }
public ushort[] ReadPoints(ushort startAddress, ushort numberOfPoints) { return(_master.ReadHoldingRegisters(_unitId, startAddress, numberOfPoints)); }
/// <summary> /// Проверка наличия измененеий в состоянии входов /// </summary> /// <param name="master">Транспорт</param> /// <returns>Список изменившихся входов</returns> public IEnumerable<int> UpdateAllInputState(IModbusMaster master) { var res = new List<int>(); var answer = master.ReadHoldingRegisters(_address, RegisterStartInputs, CountRegistersInputs); if (_lastState == null) { _lastState = answer; for (int i = 0; i < (_lastState.Length * 16); i++) res.Add(i); } else { for(int i = 0; i< answer.Length; i++) { if(answer[i]==_lastState[i]) continue; for(int bit = 0; bit<16; bit++) if (GetBitFromUShortArray(_lastState, (i * 16 + bit)) != GetBitFromUShortArray(answer, (i * 16 + bit))) res.Add(i * 16 + bit); } _lastState = answer; } _lastStateTimestamp = DateTime.Now; return res; }
bool ModbusUpdate() { try { lock (m_syncObject) { //for (int i = 0; i < 1281; i += 125) //{ ///*rdBuf*/ = m_mbMaster.ReadHoldingRegisters(m_slaveAddr, m_startAddr, m_count); //for (int j = 0; j < 126; j++) //{ // if (i + j < 1281) // { // //MyClass.rxData[i + j] = rdBuf[j]; // } //} int count = RegistersCountMax; ushort addr = m_startAddr; int rdLen; int index = 0; if (rdBuf == null) { rdBuf = new ushort[RegistersCountMax]; } while (count > 0) { rdLen = count; if (rdLen > IOCountMax) { rdLen = IOCountMax; } ushort[] tBuf = m_mbMaster.ReadHoldingRegisters(m_slaveAddr, (ushort)index, (ushort)rdLen); // ushort[] tBuf = m_mbMaster.ReadHoldingRegisters(1, 1, 5); Array.Copy(tBuf, 0, rdBuf, index, rdLen); index += rdLen; addr += (ushort)rdLen; count -= rdLen; // ushort[] buf = ValueUtil.StructToBuff<ushort, RegistersData.MbRegisters>(USM_Reg); //GetVals(tBuf); } USM_Reg = ValueUtil.BufToStruct <common.devices.USM.MbUsmRegisters, ushort>(rdBuf); //} //rdBuf[280] = 1; } return(true); } catch (Exception ex) { m_lastError = ex.Message; return(false); } }
//////////////////////////////////////////////////////////////\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ private void ModbusScan_Tick(object sender, EventArgs e) { watch.Start(); mmstart = true; if (c == Course) { ModbusScan.Stop(); if (TestStep == 1) { PublicVar.TestEnd1 = true; db.Database.ExecuteSqlCommandAsync("UPDATE CTest.dbo.ProgramMain SET Counter1 =" + c + " ,TestEnd1 = 1 WHERE id =" + PublicVar.ProgramID); Stop(); MessageBox.Show("The test was completed with course" + PublicVar.Course1 + "and tensile strength of" + PublicVar.Force1 + "kg", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information); Close(); } else if (TestStep == 2) { db.Database.ExecuteSqlCommand("UPDATE CTest.dbo.ProgramMain SET Counter2 =" + c + ",TestEnd2 = 1 WHERE id =" + PublicVar.ProgramID); db.Database.ExecuteSqlCommand("UPDATE CTest.dbo.ProgramMain SET TestEnd1 = 0 WHERE id =" + PublicVar.ProgramID); Stop(); MessageBox.Show("The test was completed with course" + PublicVar.Course2 + "and tensile strength of" + PublicVar.Force2 + "kg", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information); PublicVar.TestEnd2 = true; MessageBox.Show("The settings for the second test step apply to change the spring", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information); Close(); } else if (TestStep == 3) { db.Database.ExecuteSqlCommand("UPDATE CTest.dbo.ProgramMain SET Counter1 =" + c + ",TestEnd1 = 1 WHERE id =" + PublicVar.ProgramID); Stop(); MessageBox.Show("The test was completed with course" + PublicVar.Course2 + "and tensile strength of" + PublicVar.Force2 + "kg", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information); Close(); } } try { byte[] bytes = MMaster.ReadHoldingRegisters(2, 231, 4); for (int i = 0, j = 1; i < bytes.Length;) { byte TempA = bytes[j]; // B bytes[j] = bytes[i]; // B <= A bytes[i] = TempA; // A<= B i += 2; j += 2; } float valueff2 = BitConverter.ToSingle(bytes, 4); // لودسل سمت فنر int x2 = (int)valueff2; // txtLoadcell1.Text = string.Format("{0}, ", valueff2); if (Enumerable.Range(105, 105).Contains(x2))// && x2 > Convert.ToInt32(PublicVar.Force2) + 10) { watch.Stop(); txtTime.Text = watch.Elapsed.ToString(); watch.Reset(); c++; PrcLoadCell(valueff2); Thread.Sleep(1000); } } catch (Exception ex) { MessageBox.Show(this, ex.Message, "Error ModBusScan", MessageBoxButtons.OK, MessageBoxIcon.Error); ModbusScan.Stop(); } }
/// <summary> /// Perform read registers command /// </summary> /// <param name="master"></param> /// <returns></returns> internal static double CalculateAverage(IModbusMaster master) { ushort startAddress = 5; ushort numRegisters = 5; // JIT compile the IL master.ReadHoldingRegisters(SlaveAddress, startAddress, numRegisters); Stopwatch stopwatch = new Stopwatch(); long sum = 0; double numberOfReads = 50; for (int i = 0; i < numberOfReads; i++) { stopwatch.Reset(); stopwatch.Start(); master.ReadHoldingRegisters(SlaveAddress, startAddress, numRegisters); stopwatch.Stop(); log.DebugFormat("CalculateAverage read {0}", i + 1); checked { sum += stopwatch.ElapsedMilliseconds; } } return sum / numberOfReads; }
private async void ExecuteFunction() { try { //重新实例化是为了 modbus slave更换连接时不报错 master = modbusFactory.CreateMaster(new TcpClient("127.0.0.1", 502)); if (functionCode != null) { switch (functionCode) { case "01 Read Coils": //读取单个线圈 SetReadParameters(); coilsBuffer = master.ReadCoils(slaveAddress, startAddress, numberOfPoints); for (int i = 0; i < coilsBuffer.Length; i++) { SetMsg(coilsBuffer[i] + " "); } SetMsg("\r\n"); break; case "02 Read DisCrete Inputs": //读取输入线圈/离散量线圈 SetReadParameters(); coilsBuffer = master.ReadInputs(slaveAddress, startAddress, numberOfPoints); for (int i = 0; i < coilsBuffer.Length; i++) { SetMsg(coilsBuffer[i] + " "); } SetMsg("\r\n"); break; case "03 Read Holding Registers": //读取保持寄存器 SetReadParameters(); registerBuffer = master.ReadHoldingRegisters(slaveAddress, startAddress, numberOfPoints); for (int i = 0; i < registerBuffer.Length; i++) { SetMsg(registerBuffer[i] + " "); } SetMsg("\r\n"); break; case "04 Read Input Registers": //读取输入寄存器 SetReadParameters(); registerBuffer = master.ReadInputRegisters(slaveAddress, startAddress, numberOfPoints); for (int i = 0; i < registerBuffer.Length; i++) { SetMsg(registerBuffer[i] + " "); } SetMsg("\r\n"); break; case "05 Write Single Coil": //写单个线圈 SetWriteParametes(); await master.WriteSingleCoilAsync(slaveAddress, startAddress, coilsBuffer[0]); break; case "06 Write Single Registers": //写单个输入线圈/离散量线圈 SetWriteParametes(); await master.WriteSingleRegisterAsync(slaveAddress, startAddress, registerBuffer[0]); break; case "0F Write Multiple Coils": //写一组线圈 SetWriteParametes(); await master.WriteMultipleCoilsAsync(slaveAddress, startAddress, coilsBuffer); break; case "10 Write Multiple Registers": //写一组保持寄存器 SetWriteParametes(); await master.WriteMultipleRegistersAsync(slaveAddress, startAddress, registerBuffer); break; default: break; } } else { MessageBox.Show("请选择功能码!"); } master.Dispose(); } catch (Exception ex) { MessageBox.Show(ex.Message); } }
internal ushort[] ReadHoldingRegisters(ushort address, ushort num) { return(PLC.ReadHoldingRegisters(1, address, num)); }
public JObject ReadModbusToJson(int siteId, int DeviceIndex, GroupPoint slaves, out HashEntry[] hashEntries) { JObject datarow = new JObject(); List <HashEntry> entries = new List <HashEntry>(); hashEntries = entries.ToArray(); try { if (master == null) { return(datarow); } ushort startAddr = slaves.StartAddress; ushort pointCnt = (ushort)slaves.AiMaps.Sum(x => x.DataType.Size); ushort[] datas = null; lock (lockerObj) { switch ((modbus_io)slaves.IoType) { case modbus_io.ANALOG_INPUT: datas = master.ReadInputRegisters(_config.SlaveId, startAddr, pointCnt); break; case modbus_io.HOLDING_REGISTER: datas = master.ReadHoldingRegisters(_config.SlaveId, startAddr, pointCnt); break; } } DateTime timeStamp = DateTime.Now; datarow.Add("groupid", slaves.GroupId); datarow.Add("groupname", slaves.GroupName); datarow.Add("deviceId", _config.DeviceName); datarow.Add("siteId", siteId); string normalizedeviceid = slaves.GroupId == 1 ? "PCS" : "BMS"; datarow.Add("normalizedeviceid", normalizedeviceid + DeviceIndex.ToString()); entries.Add(new HashEntry("timestamp", timeStamp.ToString())); datarow.Add("timestamp", DateTime.Now.ToString("yyyyMMddHHmmss")); int bitIdx = 0; foreach (AiMap register in slaves.AiMaps) { if (register.Disable == 1) { continue; } //Console.WriteLine("READ REGISTER: " + register.Name); byte[] buffer = GetReadBytes(register.DataType, bitIdx, datas); bitIdx += register.DataType.Size; dynamic value = 0f; switch ((modbus_type)register.DataType.TypeCode) { case modbus_type.DT_BOOLEAN: value = BitConverter.ToBoolean(buffer); break; case modbus_type.DT_INT32: value = BitConverter.ToInt32(buffer); break; case modbus_type.DT_INT16: value = BitConverter.ToInt16(buffer); break; case modbus_type.DT_UINT32: value = BitConverter.ToUInt32(buffer); break; case modbus_type.DT_UINT16: value = BitConverter.ToUInt16(buffer); break; case modbus_type.DT_FLOAT: value = BitConverter.ToSingle(buffer); break; } value = register.ConvertValue(value); entries.Add(new HashEntry(register.Name, value.ToString())); datarow.Add(register.Name, value.ToString()); //registers.Add(register.ConvertRegister(Convert.ToSingle(value))); } hashEntries = entries.ToArray(); return(datarow); } catch (Exception ex) { logger.LogError(ex, ex.Message); return(null); } }
protected override ushort[] ReadCore(IModbusMaster modbusMaster, byte slaveId, ushort startAddress, ushort numberOfPoints) { return(modbusMaster.ReadHoldingRegisters(slaveId, startAddress, numberOfPoints)); }
/// <summary> /// Обновить состояние панели /// </summary> /// <param name="master">Транспорт</param> /// <returns>Список изменившихся входов</returns> public void UpdatePannelState(IModbusMaster master) { var res = new List<int>(); var answer = master.ReadHoldingRegisters(_address, RegisterStar, CountRegisters); ParceFromUShortArray(answer); _lastStateTimestamp = DateTime.Now; }
private ushort[] ReadModbusRegisters() { AllData = _master.ReadHoldingRegisters(WTX_SLAVE_ADDRESS, WTX_REGISTER_START_ADDRESS, WTX_REGISTER_DATAWORD_COUNT); CommunicationLog?.Invoke(this, new LogEventArgs("Read all: " + string.Join(",", AllData.Select(x => x.ToString("X")).ToArray()))); return(AllData); }
void ModbusUpdate() { float gas_v; float pump; float steam_v; float water_lvl; float pressure; ushort alrm; bool torch; while (client_connected == 2) { Thread.Sleep(500); if (update_task_ctoken.IsCancellationRequested) { return; } gas_v = UshortToFloat(mbus_client.ReadHoldingRegisters(0x00, 0, 2)); pump = UshortToFloat(mbus_client.ReadHoldingRegisters(0x00, 2, 2)); steam_v = UshortToFloat(mbus_client.ReadHoldingRegisters(0x00, 4, 2)); water_lvl = UshortToFloat(mbus_client.ReadHoldingRegisters(0x00, 6, 2)); pressure = UshortToFloat(mbus_client.ReadHoldingRegisters(0x00, 8, 2)); alrm = mbus_client.ReadHoldingRegisters(0x00, 10, 1)[0]; torch = mbus_client.ReadCoils(0x00, 5, 1)[0]; Dispatcher.Invoke(() => { valve2_label.Content = String.Format("КЛ2: {0:F1}%", gas_v * 100); pump_label.Content = String.Format("НАС: {0:F1}%", pump * 100); valve1_label.Content = String.Format("КЛ1: {0:F1}%", steam_v * 100); waterlvl_label.Content = String.Format("{0:F1}%", water_lvl * 100); waterlvl_progressbar.Value = water_lvl; pressure_label.Content = String.Format("{0:F1}%", pressure * 100); pressure_progressbar.Value = pressure; if (torch) { heater_status_ellipse.Fill = new SolidColorBrush(Colors.Green); } else { heater_status_ellipse.Fill = new SolidColorBrush(Colors.Red); } if (alrm == 1) { alarm_presshigh.IsEnabled = true; } else if (alrm == 2) { alarm_pressdang.IsEnabled = true; } else if (alrm == 3) { alarm_watrlow.IsEnabled = true; } else if (alrm == 4) { alarm_watrhigh.IsEnabled = true; } else if (alrm == 0) { alarm_pressdang.IsEnabled = false; alarm_presshigh.IsEnabled = false; alarm_watrhigh.IsEnabled = false; alarm_watrlow.IsEnabled = false; } }); if (auto_mode) { } } }