class Koyo:
def __init__(self, ip_address):
self.ip_address = ip_address
self._koyo = ModbusClient(ip_address)
print("Connected:", self._koyo.connect())
if self._koyo.connect():
self._getversions()
self._get_device_info()
def _getversions(self):
data = self._koyo.read_input_registers(17500, 6)
self.os_version = '.'.join(map(str, data.registers[0:3]))
self.boot_version = '.'.join(map(str, data.registers[3:6]))
def _get_device_info(self):
data = self._koyo.read_input_registers(17510, 19)
self.device_version = data.registers[0]
self.family = data.registers[1]
def disconnect(self):
self._koyo.close()
def read_register(self, x):
read = self._koyo.read_holding_registers(x, count=1, unit=1)
return read.registers[0]
def main():
ur_ctrl = rtde_control.RTDEControlInterface(rsd_conf.UR_IP)
ur_ctrl.moveJ(q.IDLE)
ur_modbus_client = ModbusTcpClient(rsd_conf.UR_IP)
ur_modbus_client.write_coil(16 + rsd_conf.IO_GRIPPER, False)
pi_modbus_client = ModbusTcpClient(rsd_conf.PI_IP, rsd_conf.PI_MODBUS_PORT)
def gripper_grasp(grasp_q, pre_post_q):
ur_ctrl.moveJ(pre_post_q)
ur_ctrl.moveJ(grasp_q)
ur_modbus_client.write_coil(16 + rsd_conf.IO_GRIPPER, True)
ur_ctrl.moveJ(pre_post_q)
def gripper_release():
ur_modbus_client.write_coil(16 + rsd_conf.IO_GRIPPER, False)
order = {"blue": 0, "red": 0, "yellow": 20}
for brick_color_id in range(len(rsd_conf.BRICK_COLORS)):
brick_color = rsd_conf.BRICK_COLORS[brick_color_id]
q_grasp_brick, q_above_brick = q.GRASP_BRICKS[
brick_color_id], q.ABOVE_BRICKS[brick_color_id]
count = order[brick_color]
for _ in range(count):
gripper_grasp(q_grasp_brick, q_above_brick)
ur_ctrl.moveJ(q.ABOVE_CAMERA)
pi_modbus_client.read_input_registers(0, 1)
ur_ctrl.moveJ(q.BRICK_DROP_ORDER_BOX)
gripper_release()
ur_ctrl.moveJ(q.IDLE)
def upmu(upmu, sw_value):
IP = '131.243.41.14'
PORT = 503
id = 2
if upmu == '123p':
register = int(2)
if upmu == '4':
register = int(3)
client = ModbusClient(IP, port=PORT)
try:
client.write_registers(register, int(sw_value), unit=id)
print(f'uPMU{upmu} to {sw_value} ~~ time:',
client.read_input_registers(1, count=1, unit=id).registers[0])
print('epoch:', time.time())
print(dt.datetime.fromtimestamp(time.time()))
print('All Done.',
client.read_input_registers(1, count=1, unit=id).registers[0])
except Exception as e:
print(e)
finally:
client.close()
print('client closed [uPMU]')
return
class Koyo:
def __init__(self, ip_address):
self.ip_address = ip_address
self._koyo = ModbusClient(ip_address)
print self._koyo.connect()
if self._koyo.connect():
self._getversions()
self._get_device_info()
def _getversions(self):
data = self._koyo.read_input_registers(17500, 6)
self.os_version = '.'.join(map(str, data.registers[0:3]))
self.boot_version = '.'.join(map(str, data.registers[3:6]))
def _get_device_info(self):
data = self._koyo.read_input_registers(17510, 19)
self.device_version = data.registers[0]
self.family = data.registers[1]
def outputs(self, max=16):
pass
def write_output(self, output, value):
pass
def inputs(self, max=24):
pass
def memory_bits(self, bit):
pass
def disconnect(self):
self._koyo.close()
def update(seradd: str, sdmid: int):
client = ModbusTcpClient(seradd, port=8899)
with client:
resp = client.read_input_registers(0x0006, 2, unit=sdmid)
al1 = struct.unpack('>f', struct.pack('>HH', *resp.registers))
al1 = float("%.3f" % al1[0])
f = open("/var/www/html/openWB/ramdisk/pva1", 'w')
f.write(str(al1))
f.close()
resp = client.read_input_registers(0x000C, 2, unit=sdmid)
watt = struct.unpack('>f', struct.pack('>HH', *resp.registers))
watt = int(watt[0])
f = open("/var/www/html/openWB/ramdisk/pvwatt", 'w')
f.write(str(watt))
f.close()
resp = client.read_input_registers(0x004a, 2, unit=sdmid)
vwh = struct.unpack('>f', struct.pack('>HH', *resp.registers))
vwh1 = float("%.3f" % vwh[0])
vwhk = str(vwh1)
f = open("/var/www/html/openWB/ramdisk/pvkwhk", 'w')
f.write(str(vwhk))
f.close()
vwh2 = float(vwh1) * int(1000)
vwh3 = str(vwh2)
f = open("/var/www/html/openWB/ramdisk/pvkwh", 'w')
f.write(str(vwh3))
f.close()
def get_b100_readings(address, port):
global modbus_client
if modbus_client is None:
try:
modbus_client = ModbusClient(address, port=port, framer=ModbusFramer)
except:
raise ValueError
ltc_tank_temp = None
top_oil_temp = None
# read LTC Tank Temperature
try:
ltc_tank_temp_read = modbus_client.read_input_registers(LTC_TANK_TEMP_REGISTER,2,unit=1)
ltc_tank_temp_raw = ltc_tank_temp_read.registers[0]
ltc_tank_temp = convert_to_scaled_signedint(val,1000)
except Exception as ex:
ltc_tank_temp = f'error: {ex}'
try:
top_oil_temp_read = modbus_client.read_input_registers(TOP_OIL_TEMP_REGISTER,2,unit=1)
top_oil_temp_raw = top_oil_temp_read.registers[0]
top_oil_temp = convert_to_scaled_signedint(ltc_tank_temp_raw,1000)
except Exception as ex:
top_oil_temp = f'error: {ex}'
readings = {
'ltc_tank_temp': ltc_tank_temp,
'top_oil_temp': top_oil_temp
}
return readings
class ComModbusTcp:
def __init__(self):
self.client = None
self.lock = threading.Lock()
def connectToDevice(self, address):
"""
Connection to the client - the method takes the IP address (as a string, e.g. '192.168.1.11') as an argument.
"""
self.client = ModbusTcpClient(address)
def disconnectFromDevice(self):
"""Close connection"""
self.client.close()
def sendCommand(self, data):
"""
Send a command to the Gripper - the method takes a list of int as an argument.
The meaning of each variable depends on the Gripper model
"""
if (len(data) == 6):
message = []
for i in range(0, len(data)):
message.append(data[i])
with self.lock:
self.client.write_register(52, message[0])
self.client.write_register(53, message[1])
self.client.write_register(54, message[2])
self.client.write_register(3006, message[3])
self.client.write_register(3007, message[4])
self.client.write_register(3008, message[5])
def getStatus(self, numRegs):
"""
Sends a request to read, wait for the response and returns the Gripper status.
The method gets the number of bytes to read as an argument
"""
# TODO: Implement try/except
# Get status from the device
with self.lock:
response1 = self.client.read_input_registers(51, numRegs)
response2 = self.client.read_input_registers(3012, numRegs)
# Instantiate output1 output2 as an empty list
output1 = []
output2 = []
# Fill the output with the bytes in the appropriate order
for i in range(0, numRegs):
output1.append(response1.getRegister(i))
output2.append(response2.getRegister(i))
for i in range(0, numRegs):
output1.append(output2[i])
# Output the result
return output1
class communication:
def __init__(self):
self.client = None
def connectToDevice(self, address):
"""Connection to the client - the method takes the IP address (as a string, e.g. '192.168.1.11') as an argument."""
self.client = ModbusTcpClient(address)
def disconnectFromDevice(self):
"""Close connection"""
self.client.close()
def sendCommand(self, data):
"""Send a command to the Gripper - the method takes a list of uint8 as an argument. The meaning of each variable depends on the Gripper model (see support.robotiq.com for more details)"""
#make sure data has an even number of elements
if (len(data) % 2 == 1):
data.append(0)
#Initiate message as an empty list
message = []
#Fill message by combining two bytes in one register
for i in range(0, int(len(data) / 2)):
message.append((data[2 * i] << 8) + data[2 * i + 1])
#To do!: Implement try/except
self.client.write_registers(0, message)
def getStatus(self, numBytes):
"""Sends a request to read, wait for the response and returns the Gripper status. The method gets the number of bytes to read as an argument"""
numRegs = int(ceil(numBytes / 2.0))
#To do!: Improve try/except to be more robust
#Get status from the device
response = self.client.read_input_registers(0, numRegs)
connection_exception = False
while isinstance(response, ModbusIOException) or connection_exception:
try:
response = self.client.read_input_registers(0, numRegs)
connection_exception = False
except ConnectionException:
connection_exception = True
print('WARNING: comModbusTCP.py ConnectionException, retrying')
time.sleep(0.1)
#Instantiate output as an empty list
output = []
#Fill the output with the bytes in the appropriate order
for i in range(0, numRegs):
output.append((response.getRegister(i) & 0xFF00) >> 8)
output.append(response.getRegister(i) & 0x00FF)
#Output the result
return output
class ChargeController():
def __init__(self, address):
self.host,self.port = address
self.device_name = '<unknown>'
self.serial_number = '<unknown>'
self.update_serial_number_and_device_name()
self.readable_values = {}
self.coil_register_indices = range(1, NUM_COIL_REGISTERS + 1)
def update_serial_number_and_device_name(self):
try:
self.measure_eeprom()
serial_number_bytes = [('%04x' % self.eeprom_measurement[k])[::-1] for k in range(57536, 57540)]
self.serial_number = ''.join(serial_number_bytes)[::2]
device_model = self.eeprom_measurement[0xE0CC]
if device_model:
self.device_name = 'TriStar-MPPT-60'
else:
self.device_name = 'TriStar-MPPT-45'
except Exception:
logger.exception("Could not get serial number or device name for %s:%d" % (self.host,self.port))
def measure(self):
self.client = ModbusTcpClient(host=self.host, port=self.port)
measurement = OrderedDict(epoch=time.time())
result = self.client.read_input_registers(0, NUM_REGISTERS, unit=0x01,)
try:
measurement.update(zip(range(NUM_REGISTERS), result.registers))
except AttributeError as e:
print e, result
raise
self.measurement = measurement
self.client.close()
return self.measurement
def measure_eeprom(self):
self.client = ModbusTcpClient(host=self.host, port=self.port)
self.eeprom_measurement = OrderedDict(epoch=time.time())
eeprom_measurement = self.client.read_input_registers(EEPROM_BATCH_1[0], EEPROM_BATCH_1[1] - EEPROM_BATCH_1[0],
unit=0x01).registers
eeprom_measurement += self.client.read_input_registers(EEPROM_BATCH_2[0], EEPROM_BATCH_2[1] - EEPROM_BATCH_2[0],
unit=0x01).registers
eeprom_measurement += self.client.read_input_registers(EEPROM_BATCH_3[0], EEPROM_BATCH_3[1] - EEPROM_BATCH_3[0],
unit=0x01).registers
self.eeprom_measurement.update(zip(EEPROM_REGISTER_INDICES, eeprom_measurement))
self.client.close()
return self.eeprom_measurement
def measure_coils(self):
self.coil_measurement = OrderedDict(epoch=time.time())
self.coil_measurement.update(
zip(range(NUM_COIL_REGISTERS), self.client.read_coils(0, NUM_COIL_REGISTERS, unit=0x01).bits))
return self.coil_measurement
def readMBinputregisters(clientIP, register, number=1):
from pymodbus.client.sync import ModbusTcpClient, ConnectionException
values = []
client = ModbusTcpClient(clientIP)
try:
rawresult = client.read_input_registers(register, number)
except ConnectionException:
# print('we were unable to connect to the host')
statuscode = 7
else:
# print(rawresult)
try:
resultregisters = rawresult.registers
except AttributeError:
statuscode = rawresult.exception_code
else:
statuscode = 0
values = resultregisters
client.close()
result = {
'message': messagefrommbstatuscode(statuscode),
'statuscode': statuscode,
'values': values
}
return result
def read_input_registers(self, command):
parser = argument_parser()
command = 'read_input_register ' + command
spec = parser.parse_args(command.split())
response = _ModbusClient.read_input_registers(
self, spec.address, spec.count, unit=spec.unit_id)
return response
class VentboxClient(AbstractClient):
def __init__(self) -> None:
super().__init__()
self.client = ModbusClient('192.168.1.92', port=502)
self.client.connect()
print("Connected")
def getInputRegister(self, index) -> float:
reg = self.client.read_input_registers(index, 2)
s = struct.pack('<HH', reg.registers[0], reg.registers[1])
return struct.unpack('f', s)[0]
def getTempExtIn(self) -> float:
return self.getInputRegister(0)
def getHeater(self) -> float:
return self.getInputRegister(16)
def getEngine1(self) -> float:
return self.getInputRegister(12)
def getEngine2(self) -> float:
return self.getInputRegister(14)
def setPower(self, power: int) -> None:
self.power = power
s = struct.pack('>f', power)
i1, i2 = struct.unpack('>HH', s)
self.client.write_register(6, i2)
self.client.write_register(6 + 1, i1)
def closeReku(self):
self.client.close()
def wren_gw_modbus_read(config):
''' read a value from the peer.
@param config the configuration in the key/value type.
'''
try:
m = ModbusTcpClient(host=config['node'], port=config['port'])
m.connect()
unit = 0xff
if config.has_key('unit_id'):
unit = config['unit_id']
# sed data
value = None
if config['table'] == 'InputRegister':
result = m.read_input_registers(config['address'], 1, unit=unit)
if result:
value = result.registers[config['address']]
if config['table'] == 'HoldingRegister':
result = m.read_holding_registers(config['address'], 1, unit=unit)
if result:
value = result.registers[config['address']]
# close it.
m.close()
return {"status":True, "value":str(value)};
except Exception as e:
return {"status":False, "value":str(e)};
class ModbusDevice:
def __init__(self, ip: str, port: int = 502):
self.client = ModbusTcpClient(ip, port=502)
def read(self, reg: Enum, count=2) -> List[int]:
return self.client.read_input_registers(reg.value, count,
unit=3).registers
def write(self, reg: Enum, value: int) -> None:
self.client.write_registers(reg.value, (value // 65536, value % 65536),
unit=3)
@staticmethod
def decode_s32(value: List[int]) -> int:
if value[0] == 32768 and value[1] == 0:
return 0
# To enforce signed decoding, there seems to be no better way.
return struct.unpack(
'>i',
bytes.fromhex(format(value[0], '04x') +
format(value[1], '04x')))[0]
@staticmethod
def decode_u32(value: List[int]) -> int:
if value[0] == 32768 and value[1] == 0:
return 0
return int(format(value[0], '04x') + format(value[1], '04x'), 16)
class VisionClient:
def __init__(self):
self.modbus_conn = ModbusTcpClient(conf.PI_IP, conf.PI_MODBUS_PORT)
def get_color_id(self):
values = self.modbus_conn.read_input_registers(0, 1)
return values.registers[0]
def get_device_class(host, port, modbusid):
client = ModbusClient(host=host, port=port)
try:
client.connect()
except:
print('Modbus Connection Error',
'could not connect to target. Check your settings, please.')
return None
try:
received = client.read_input_registers(address=30051, count=2, unit=3)
except:
thisdate = str(datetime.datetime.now()).partition('.')[0]
thiserrormessage = thisdate + ': Connection not possible. Check settings or connection.'
print(thiserrormessage)
return None
message = BinaryPayloadDecoder.fromRegisters(received.registers,
byteorder=Endian.Big,
wordorder=Endian.Big)
interpreted = message.decode_32bit_uint()
dclass = pvenums["DeviceClass"].get(interpreted)
client.close()
return dclass
def main():
### setup the client ###
ipaddr = '192.168.201.21'
port = 502
print 'Connecting to', (ipaddr, port)
client = ModbusTcpClient(ipaddr, port=port)
### fetch data ###
try:
reg = client.read_input_registers(0, 8) # data request
vlt = raw2volt(reg.registers) # convert bit to voltage (-10 -- 10[V])
except:
print 'Data fetch error. Finishing...'
client.close()
return
### convert voltage to engineering values ###
meas = vlt # TODO: CHANGE THIS
### show data ###
print 'Raw measurement:', vlt
print 'Engineering value:', meas
### finalizing ###
client.close()
def run(self, measured_instrument):
while self.running:
c = ModbusTcpClient(measured_instrument.ip)
start = time.time()
while not c.connect():
log.debug("Can't connect, retry in 0.5s")
self.measurements.append((time.time(), measured_instrument.ip,
measured_instrument.name,
((time.time() - start) * 1000), -2))
time.sleep(0.5)
if measured_instrument.type == "input_register":
response = c.read_input_registers(
measured_instrument.address,
1,
unit=measured_instrument.unit)
measured_instrument.setData(response.registers[0])
if measured_instrument.type == "coil":
response = c.read_coils(measured_instrument.address,
1,
unit=measured_instrument.unit)
measured_instrument.setData(response.bits[0])
c.close()
self.measurements.append(
(time.time(), measured_instrument.ip, measured_instrument.name,
((time.time() - start) * 1000), 1))
log.debug("Tick: {}".format(self.tick))
time.sleep(self.tick)
class ModbusConnection(object):
_max_retries_read = 10
_max_retries_write = 3
@property
def max_retries_read(self):
return self._max_retries_read
@property
def max_retries_write(self):
return self._max_retries_write
@property
def client_address(self):
return self.client.host
@property
def client_port(self):
return str(self.client.port)
def __init__(self, client_address, client_port):
self.client = ModbusClient(host = client_address, port = int(client_port))
self.connect_to_client()
def __del__(self):
self.disconnect_from_client()
def connect_to_client(self):
self.client.connect()
def disconnect_from_client(self):
self.client.close()
def read_input_registers(self, address, count, unit):
k = 0
while k < self.max_retries_read:
try:
return self.client.read_input_registers(address = address, count = count, unit = unit).registers
except:
k += 1
sleep(1.5)
def read_holding_registers(self, address, count, unit):
k = 0
while k < self.max_retries_read:
try:
return self.client.read_holding_registers(address = address, count = count, unit = unit).registers
except:
k += 1
sleep(1.5)
def write_register(self, address, unit, value):
k = 0
while k < self.max_retries_write:
try:
return self.client.write_register(address = address, unit = unit, value = value)
except:
k += 1
sleep(1.5)
class P4AModBusDriver():
def __init__(self, server, port=502, Startup=True):
self.client = MBC(server, port)
if Startup:
self.client.connect()
def close(self):
self.client.close()
def get_ieee754_float(self, address):
return int_to_floating_bin(
self.client.read_input_registers(address).registers[0])
def get_integer(self, address):
return self.client.read_input_registers(address).registers[0]
def write_output(self, address, value):
self.client.write_register(address, value)
class Client:
def __init__(self):
self.client = None
self.handle = None
self.ip = '127.0.0.1'
self.port = 502
def setup(self, config):
self.handle = config
self.ip = config['ipv4']['value']
self.port = config['port']['value']
self.client = ModbusTcpClient(self.ip, self.port)
def execute(self, fc, addr, length=1, values=None):
result = None
if fc == 1:
temp = self.client.read_coils(addr, length)
result = []
for i in range(temp.byte_count):
t2 = temp.bits[i * 16:(i + 1) * 16]
result.append(''.join([str(int(x)) for x in t2]))
elif fc == 2:
temp = self.client.read_discrete_inputs(addr, length)
result = []
for i in range(temp.byte_count):
t2 = temp.bits[i * 16:(i + 1) * 16]
result.append(''.join([str(int(x)) for x in t2]))
elif fc == 3:
temp = self.client.read_holding_registers(addr, length).registers
result = ['{0:016b}'.format(x) for x in temp]
elif fc == 4:
temp = self.client.read_input_registers(addr, length).registers
result = ['{0:016b}'.format(x) for x in temp]
elif fc == 5:
if values:
self.client.write_coil(addr, values[0])
elif fc == 6:
if values:
self.client.write_register(addr, values[0])
elif fc == 15:
if values:
self.client.write_coils(addr, values)
elif fc == 16:
if values:
self.client.write_registers(addr, values)
return result
def update_config(self, conf):
self.ip = conf['ipv4']['value']
self.port = conf['port']['value']
self.client = ModbusTcpClient(self.ip, self.port)
self.handle = conf
def connect(self):
return self.client.connect()
def post(self):
query = self.reqparse.parse_args()
client = ModbusClient(query['ip'], query['port'])
client.connect()
data = None
start_address = query['start_address']
count = query['count']
if query['type_prefix'] == ModbusTypePrefix.DISCRETE_INPUT.value:
data = client.read_discrete_inputs(start_address, count, unit=1)
elif query['type_prefix'] == ModbusTypePrefix.COIL.value:
data = client.read_coils(start_address, count, unit=1)
elif query['type_prefix'] == ModbusTypePrefix.INPUT_REGISTER.value:
data = client.read_input_registers(start_address, count, unit=1)
elif query['type_prefix'] == ModbusTypePrefix.HOLDING_REGISTER.value:
data = client.read_holding_registers(start_address, count, unit=1)
client.close()
result = []
print(data.registers)
# if hasattr(data, 'bits'):
# d = data.bits
# else:
# d = data.registers
decoder = BinaryPayloadDecoder.fromRegisters(data.registers,
byteorder=Endian.Big,
wordorder=Endian.Big)
# decoder.reset()
# decoded = {
# 'string': decoder.decode_string(8),
# 'float': decoder.decode_32bit_float(),
# '16uint': decoder.decode_16bit_uint(),
# 'ignored': decoder.skip_bytes(2),
# '8int': decoder.decode_8bit_int(),
# 'bits': decoder.decode_bits(),
# }
e = decoder.decode_16bit_int()
i = 0
while e is not False:
try:
print e
result.append({'address': i + start_address, 'value': e})
i += 1
e = decoder.decode_16bit_int()
except:
e = False
# for i, v in enumerate(d):
# result.append({'address': i+start_address, 'value': v})
reg_fields = {'address': fields.Integer, 'value': fields.Integer}
return {'registers': [marshal(reg, reg_fields) for reg in result]}
def load_test_client(client: ModbusTcpClient, name: str):
results_dict = {}
config_thermocouple(client, name, AIN='AIN0')
while True:
results_dict[60000] = client.read_input_registers(60000, 2)
results_dict[2800] = client.read_input_registers(2800, 2)
results_dict[0] = client.read_input_registers(0, 2)
resp = results_dict[60000]
data = _convert_to_32_float(resp.registers[0], resp.registers[1])
print('{}: "read version id" trans: {}, unit: {}, registers: {}'
.format(name, resp.transaction_id, resp.unit_id, data))
resp = results_dict[2800]
data = hex(resp.registers[0]) + hex(resp.registers[1])[2:]
print('{}: "DIO" trans: {}, unit: {}, registers: {}'
.format(name, resp.transaction_id, resp.unit_id, data))
resp = results_dict[0]
data = _convert_to_32_float(resp.registers[0], resp.registers[1])
print('{}: "read AIN0" trans: {}, unit: {}, registers: {}'
.format(name, resp.transaction_id, resp.unit_id, data))
sleep(.500)
def run_sync_client():
client = ModbusClient('192.168.1.92', port=502)
client.connect()
print("Connected")
# Reku
for i in range(0, 4):
print("Reading reg ", i)
reg = client.read_input_registers(2 * i, 2)
s = struct.pack('<HH', reg.registers[0], reg.registers[1])
print(i, ' ', struct.unpack('f', s))
def get_b100_readings(address, port):
global modbus_client
if modbus_client is None:
try:
modbus_client = ModbusClient(address,
port=port,
framer=ModbusFramer)
except:
raise ValueError
ltc_tank_temp = None
top_oil_temp = None
LTC_TANK_TEMP_REG = 216
TOP_OIL_TEMP_REG = 268
UNIT = 1
NUM_REGISTERS_TO_READ = 2
SCALING_VALUE = 1000
# read LTC Tank Temperature
try:
ltc_tank_temp_read = modbus_client.read_input_registers(
LTC_TANK_TEMP_REG, NUM_REGISTERS_TO_READ, unit=UNIT)
ltc_tank_temp = decode_and_scale_registers(
ltc_tank_temp_read.registers, SCALING_VALUE)
except Exception as ex:
print(ex)
ltc_tank_temp = 'error'
try:
top_oil_temp_read = modbus_client.read_input_registers(
TOP_OIL_TEMP_REG, NUM_REGISTERS_TO_READ, unit=UNIT)
top_oil_temp = decode_and_scale_registers(top_oil_temp_read.registers,
SCALING_VALUE)
except:
top_oil_temp = 'error'
readings = {'ltc_tank_temp': ltc_tank_temp, 'top_oil_temp': top_oil_temp}
return readings
def sim_start_pause_stop(sim_length_min):
IP = '131.243.41.14'
PORT = 503
id = 2
# Connect to client
client = ModbusClient(IP, port=PORT)
try:
# Read simulaiton time
sim_start = client.read_input_registers(1, count=1,
unit=id).registers[0]
print('simulation start time:', sim_start)
# start recording data (sim flag on)
client.write_registers(int(1), int(1), unit=id)
client.write_registers(int(1), int(3),
unit=id) #sets simulation flag to 1 (ON)
w = 1
while w > 0:
sim_cur = client.read_input_registers(1, count=1,
unit=id).registers[0]
if sim_cur - sim_start >= sim_length_min * 60:
break
print('simulation end time', sim_cur)
client.write_registers(int(1), int(0), unit=id)
print('All Done.',
client.read_input_registers(1, count=1, unit=id).registers[0])
except Exception as e:
print(e)
finally:
client.close()
print('client closed')
return
class Gripper:
def __init__(self, address):
self.client = ModbusTcpClient(address)
self.lock = threading.Lock()
def disconnect(self):
self.client.close()
def activate(self):
self.send_cmd(self.gripper_cmd(1, 0, 0, 0, 0, 0))
sleep(5)
def open(self):
self.send_cmd(self.gripper_cmd(1, 1, 0, 0xFF, 0xFF, 0xFF))
def close(self):
self.send_cmd(self.gripper_cmd(1, 1, 0, 0x00, 0xFF, 0xFF))
@staticmethod
def gripper_cmd(ract, rgto, ratr, rpr, rsp, rfr):
cmd = [0, 0, 0, 0, 0, 0]
cmd[0] = (ract & 0x1) | ((rgto << 0x3) & 0x8) | ((ratr << 0x4) & 0x10)
cmd[3] = rpr
cmd[4] = rsp
cmd[5] = rfr
# for i in cmd: print(hex(i))
return cmd
def send_cmd(self, data):
if len(data) % 2 == 1:
data.append(0)
message = []
for i in range(0, int(len(data) / 2)):
message.append((data[2 * i] << 8) + data[2 * i + 1])
with self.lock:
self.client.write_registers(0, message)
def get_status(self, nbytes):
nregs = int(ceil(nbytes / 2.0))
with self.lock:
response = self.client.read_input_registers(0, nregs)
output = []
for i in range(0, nregs):
output.append((response.getRegister(i) & 0xFF00) >> 8)
output.append(response.getRegister(i) & 0x00FF)
return output
def sim_stop():
IP = '131.243.41.14'
PORT = 503
id = 2
client = ModbusClient(IP, port=PORT)
try:
client.write_registers(int(1), int(0), unit=id)
print('simulation stop time:',client.read_input_registers(1, count=1, unit=id).registers[0])
print('epoch:',time.time())
print(dt.datetime.fromtimestamp(time.time()))
print('All Done.',client.read_input_registers(1, count=1, unit=id).registers[0])
except Exception as e:
print(e)
finally:
client.close()
print('client closed [stop]')
return
def read_device_map(slave, map_address):
try:
client = ModbusClient(MODBUS_TCP_IP, port=MODBUS_PORT)
client.connect()
gems_value = client.read_input_registers(map_address,
slave,
unit=UNIT)
client.close()
return gems_value.registers[0]
except Exception as e:
client.close()
class ComModbusTcp:
def __init__(self):
self.client = None
self.lock = threading.Lock()
def connectToDevice(self, address):
"""
Connection to the client - the method takes the IP address (as a string, e.g. '192.168.1.11') as an argument.
"""
self.client = ModbusTcpClient(address)
def disconnectFromDevice(self):
"""Close connection"""
self.client.close()
def sendCommand(self, data):
"""
Send a command to the Gripper - the method takes a list of uint8 as an argument.
The meaning of each variable depends on the Gripper model
"""
# make sure data has an even number of elements
if (len(data) % 2 == 1):
data.append(0)
# Initiate message as an empty list
message = []
# Fill message by combining two bytes in one register
for i in range(0, len(data) / 2):
message.append((data[2 * i] << 8) + data[2 * i + 1])
# TODO: Implement try/except
with self.lock:
self.client.write_registers(0, message)
def getStatus(self, numBytes):
"""
Sends a request to read, wait for the response and returns the Gripper status.
The method gets the number of bytes to read as an argument
"""
numRegs = int(ceil(numBytes / 2.0))
# TODO: Implement try/except
# Get status from the device
with self.lock:
response = self.client.read_input_registers(0, numRegs)
# Instantiate output as an empty list
output = []
# Fill the output with the bytes in the appropriate order
for i in range(0, numRegs):
output.append((response.getRegister(i) & 0xFF00) >> 8)
output.append(response.getRegister(i) & 0x00FF)
# Output the result
return output
def update(ipaddress: str):
client = ModbusTcpClient(ipaddress, port=502)
with client:
# print "SoC batt"
resp = client.read_input_registers(1056, 2, unit=25)
value1 = resp.registers[0]
value2 = resp.registers[1]
all = format(value1, '04x') + format(value2, '04x')
final = int(struct.unpack('>i', all.decode('hex'))[0]) / 10
f = open('/var/www/html/openWB/ramdisk/speichersoc', 'w')
f.write(str(final))
f.close()
# print "be-entladen watt"
resp = client.read_input_registers(1012, 2, unit=25)
value1 = resp.registers[0]
value2 = resp.registers[1]
all = format(value1, '04x') + format(value2, '04x')
ladung = int(struct.unpack('>i', all.decode('hex'))[0]) * -1
f = open('/var/www/html/openWB/ramdisk/speicherleistung', 'w')
f.write(str(ladung))
f.close()
class communication:
def __init__(self):
self.client = None
self.lock = threading.Lock()
def connectToDevice(self, address):
"""Connection to the client - the method takes the IP address (as a string, e.g. '192.168.1.11') as an argument."""
self.client = ModbusTcpClient(address)
def disconnectFromDevice(self):
"""Close connection"""
self.client.close()
def sendCommand(self, data):
"""Send a command to the Gripper - the method takes a list of uint8 as an argument. The meaning of each variable depends on the Gripper model (see support.robotiq.com for more details)"""
# make sure data has an even number of elements
if len(data) % 2 == 1:
data.append(0)
# Initiate message as an empty list
message = []
# Fill message by combining two bytes in one register
for i in range(0, len(data) / 2):
message.append((data[2 * i] << 8) + data[2 * i + 1])
# To do!: Implement try/except
with self.lock:
self.client.write_registers(0, message)
def getStatus(self, numBytes):
"""Sends a request to read, wait for the response and returns the Gripper status. The method gets the number of bytes to read as an argument"""
numRegs = int(ceil(numBytes / 2.0))
# To do!: Implement try/except
# Get status from the device
with self.lock:
response = self.client.read_input_registers(0, numRegs)
# Instantiate output as an empty list
output = []
# Fill the output with the bytes in the appropriate order
for i in range(0, numRegs):
output.append((response.getRegister(i) & 0xFF00) >> 8)
output.append(response.getRegister(i) & 0x00FF)
# Output the result
return output
class AnalogChattySensor():
def __init__(self, BIT_NUMBER=0, THRESHOLD=100, RESOLUTION=3):
self.BIT_NUMBER = BIT_NUMBER
self.THRESHOLD = THRESHOLD
self.client = ModbusTcpClient('127.0.0.1')
self.encoded_message = []
self.last_value = ''
self.delayed_time = 0
self.data = ''
self.index = 0
self.RESOLUTION = RESOLUTION
def get_data(self):
return self.data
def next_bit(self):
self.index = self.index + 1
self.index = self.index % len(COVERT_MESSAGE)
def get_measure(self):
result = self.client.read_input_registers(self.BIT_NUMBER, 1)
current_value = result.registers[0] < self.THRESHOLD
if self.last_value != '' and self.last_value == True and current_value == False:
current_time = int(
str(time.time()).split('.')[1][:self.RESOLUTION])
if int(COVERT_MESSAGE[self.index]) == current_time % 2:
delta_time = int(str(
time.time()).split('.')[1][:3]) - self.delayed_time
self.data = "\t".join([
"Chatty Sensor:",
str(time.time()).split('.')[1][:self.RESOLUTION],
COVERT_MESSAGE[self.index],
str(delta_time)
])
self.encoded_message.append(
str(time.time()).split('.')[1][:self.RESOLUTION])
self.last_value = current_value
else:
current_value = self.last_value
self.delayed_time = int(str(time.time()).split('.')[1][:3])
else:
self.delayed_time = int(str(time.time()).split('.')[1][:3])
self.last_value = current_value
return current_value
def __del__(self):
self.client.close()
def modbus_poller(id, stop_event, config):
log = logging.getLogger("worker-" + str(id))
log.setLevel(logging.DEBUG)
client = ModbusClient(host=config["address"], port=config["port"])
client.connect()
log.info("Worker started")
t_max = -1
while not stop_event.is_set():
log.info("Poller turn")
t0 = time()
address = 0
for i in poll_range(config["num_controls"], config["chunk_size"]):
result = client.read_input_registers(address=address, count=i, unit=1)
address += i
if result is not None:
if result.function_code >= 0x80 and result.function_code != 132:
log.warn("Server returned error!")
print result
stop_event.set()
break
elif result.function_code == 132:
print "Server fault: " + str(result)
sleep(1)
break
t = time() - t0
log.info("Request took " + str(t) + " s")
if t > t_max:
t_max = t
sleep(config["thread"]["interval"])
log.info("Worker shutting down")
log.info("Max worker process time: " + str(t_max))
client.close()
def readMBinputregisters(clientIP, register, number=1):
from pymodbus.client.sync import ModbusTcpClient, ConnectionException
values = []
client = ModbusTcpClient(clientIP)
try:
rawresult = client.read_input_registers(register, number)
except ConnectionException:
# print('we were unable to connect to the host')
statuscode = 7
else:
# print(rawresult)
try:
resultregisters = rawresult.registers
except AttributeError:
statuscode = rawresult.exception_code
else:
statuscode = 0
values = resultregisters
client.close()
result = {'message': messagefrommbstatuscode(statuscode), 'statuscode': statuscode, 'values':values}
return result
def get_pv_data(config):
host = config.get('inv_host')
port = config.get('inv_port', 502)
modbusid = config.get('inv_modbus', 3)
manufacturer = config.get('inv_modbus', 'Default')
registers = eval(config.get('registers'))
client = ModbusClient(host=host, port=port)
try:
client.connect()
except:
print('Modbus Connection Error', 'could not connect to target. Check your settings, please.')
return None
data = {} ## empty data store for current values
for myreg in registers:
## if the connection is somehow not possible (e.g. target not responding)
# show a error message instead of excepting and stopping
try:
received = client.read_input_registers(address=int(myreg[0]),
count=modbusdatatype[myreg[1]],
unit=modbusid)
except:
thisdate = str(datetime.datetime.now()).partition('.')[0]
thiserrormessage = thisdate + ': Connection not possible. Check settings or connection.'
print(thiserrormessage)
return None ## prevent further execution of this function
name = myreg[3]
message = BinaryPayloadDecoder.fromRegisters(received.registers, byteorder=Endian.Big, wordorder=Endian.Big)
## provide the correct result depending on the defined datatype
if myreg[1] == 'S32':
interpreted = message.decode_32bit_int()
elif myreg[1] == 'U32':
interpreted = message.decode_32bit_uint()
elif myreg[1] == 'U64':
interpreted = message.decode_64bit_uint()
elif myreg[1] == 'STR32':
interpreted = message.decode_string(32)
elif myreg[1] == 'S16':
interpreted = message.decode_16bit_int()
elif myreg[1] == 'U16':
interpreted = message.decode_16bit_uint()
else: ## if no data type is defined do raw interpretation of the delivered data
interpreted = message.decode_16bit_uint()
## check for "None" data before doing anything else
if ((interpreted == MIN_SIGNED) or (interpreted == MAX_UNSIGNED)):
value = None
else:
## put the data with correct formatting into the data table
if myreg[2] == 'FIX3':
value = float(interpreted) / 1000
elif myreg[2] == 'FIX2':
value = float(interpreted) / 100
elif myreg[2] == 'FIX1':
value = float(interpreted) / 10
elif myreg[2] == 'UTF8':
value = str(interpreted,'UTF-8').rstrip("\x00")
elif myreg[2] == 'ENUM':
e=pvenums.get(name,{})
value = e.get(interpreted,str(interpreted))
else:
value = interpreted
data[name] = value
client.close()
return data
def discover(type):
responses=list()
result = []
valid_iphead = False
try:
infile = None
# infile = open(os.path.expanduser("~")+"/workspace/bemoss_os/machine_ip.txt","r") ####
infile = open("machine_ip.txt", "r") ####
for line in infile:
# line= "192.168.1.2" ####
own_ip = line.rstrip()
own_ip_parts = own_ip.split('.')
if len(own_ip_parts) == 4:
print( "Found own IP: "+own_ip)
iphead = own_ip_parts[0]+'.'+own_ip_parts[1]+'.'+own_ip_parts[2]+'.'
valid_iphead = True
break
infile.close()
except:
if infile is not None:
infile.close()
valid_iphead = False
# print("reached half way ")
if valid_iphead:
# print("inside ip head")
start_ip=2
end_ip=254
print ("Looking for Modbus Devices in the IP range: "+iphead+str(start_ip)+" to "+iphead+str(end_ip))
_Timeout=0.2
ip_index=start_ip
iprange=list()
# print("start ip index")
while ip_index<=end_ip:
iprange.append(iphead+str(ip_index))
# print("ipindex: ",ip_index)
ip_index=ip_index+1
print("********************")
#print iprange
counter = 1 ####
for ip in iprange:
counter += 1 ####
if (counter != 99): ####
continue ####
print("checking in the ip range: ",ip)
try:
#print ip
_socket = None ####
# _socket = socket.socket()
try:
_socket = socket.create_connection((ip, 502), _Timeout)
print("Connection successful: ",ip, "socket: ",_socket)
except socket.error:
if _socket: ####
_socket.close() ####
print("socket error") ####
_socket = None
if _socket is not None:
_socket.close() ####
Defaults.Timeout = 10 ####
client = ModbusTcpClient(ip)
print("ModbusTcpClient: ", client)
# client.bind(("192.168.1.2",0))
print(client.connect())
if type == 'Prolon_VAV':
possible_slave_ids = [1, 2, 7, 16]
elif type == 'Prolon_RTU':
possible_slave_ids = [15, 20]
else:
possible_slave_ids = []
print("possible slave ids: ",possible_slave_ids)
for slave_id in possible_slave_ids:
print("slave: ",slave_id)
print("result b4: ",result)
result = client.read_input_registers(0,unit=slave_id)
print("slave_id: ",slave_id," result: ",result)
if result is not None:
responses.append(ip+':'+str(slave_id))
print("end of loop ",slave_id)
client.close()
print("client closed")
break ####
except Exception as e:
print("error: ",e)
pass
if (ip == 99):
break
print("End of outer for loop.")
else:
print ("Modbus discovery failed: Couldn't find IP subnet of network!")
print("responses: ",responses)
return responses
class clientthreads(threading.Thread):
def __init__(self, vnic, ipaddr, port):
threading.Thread.__init__(self)
self.ipaddr = ipaddr # ip address
self.port = port # port address
self.vnic = vnic # virtual nic
self.mode = "" # server or client
self.state = "" # up or down
self.dest = "" # destination address for client
self.clientstop = threading.Event()
self.server = ""
self.client = ""
self.framer = ""
self.vnicm = ""
self.runtime= 0
self.delayr = random.uniform(0,5)
self.delayw = random.uniform(0,60)
self.firstdelay = 0
self.pstart= ""
def run(self):
self.client = ModbusTcpClient(self.dest, self.port, source_address=(self.ipaddr, 0), retries=1, retry_on_empty=True)
if(self.mode=="read"):
self.clientintr()
elif(self.mode=="write"):
self.clientintw()
else:
print "wrong mode specified"
def clientintr(self): # instantiate server stuff
while(not self.clientstop.is_set()):
if(time.time() - self.pstart > self.runtime):
print "stopping"
break
if(self.firstdelay < 1):
print "Start RDelay is: " + str(self.delayr)
time.sleep(self.delayr)
self.firstdelay = 1
print "Starting Reads"
self.clientreads()
print "\n\r-----read-----\n\r"
print self.dest
print time.time() - self.pstart
print "------------------\n\r"
def clientintw(self): # instantiate server stuff
while(not self.clientstop.is_set()):
if(time.time() - self.pstart > self.runtime):
print "stopping"
break
if(self.firstdelay < 1):
print "Start WDelay is: " + str(self.delayw)
time.sleep(self.delayw)
self.firstdelay = 1
print "Starting Writes"
self.clientwrites()
print "\n\r-----write----\n\r"
print self.dest
print time.time() - self.pstart
print "------------------\n\r"
def clientreads(self):
self.client.read_coils(1, 10)
self.client.read_discrete_inputs(1, 10)
self.client.read_holding_registers(1, 10)
self.client.read_input_registers(1, 10)
time.sleep(5)
def clientwrites(self):
self.client.write_coil(1, True)
self.client.write_register(1, 3)
self.client.write_coils(1, [True]*10)
self.client.write_registers(1, [3]*10)
time.sleep(60)
def alloc(self): # Allocate ip address
if (validateIP(self.ipaddr, self.vnicm)):
cmdargs = [self.vnic, self.ipaddr]
subprocess.call(["ifconfig"] + cmdargs)
else:
return 0
def dealloc(self): # De-allocate ip address
cmdargs = [self.vnic]
subprocess.call(["ifconfig"] + cmdargs + ["down"])
def stop(self):
self.clientstop.set()
return
"Thermal/AmbientTemp",
"Thermal/AmbientTemp/1hAvg",
"Thermal/AmbientHumidity",
"Thermal/AmbientHumidity/1hAvg",
"Thermal/TopOilTemp",
"Thermal/TopOilTemp/1hAvg",
"Thermal/BottomOilTemp",
"Thermal/BottomOilTemp/1hAvg",
"Thermal/TapChangerTemp",
"Thermal/TapChangerTemp/1hAvg"
]
numInputs = 10
startAddress = 1000
slaveID = 1
result = client.read_input_registers(startAddress, numInputs, slaveID)
for i in range(0, len(totusTemps)):
print totusTemps[i] + " = " + str(result.getRegister(i)/10.0) + "\xb0C"# scaling is 10
# read alarms
totusAlarms = [
"ALARM/System/HL/State",
"ALARM/System/HHLL/State"
]
numInputs = 2
startAddress = 100
slaveID = 1
from pymodbus.constants import Endian
from pymodbus.payload import BinaryPayloadDecoder
from pymodbus.client.sync import ModbusTcpClient as ModbusClient
import logging
logging.basicConfig()
log = logging.getLogger()
log.setLevel(logging.DEBUG)
client = ModbusClient(host='193.196.78.187', port=501)
print client.connect()
result = client.read_input_registers(address=16, count=2, unit=65)
print result.registers
decoder = BinaryPayloadDecoder.fromRegisters(result.registers, endian=Endian.Little)
decoded = decoder.decode_32bit_float()
print decoded
client.close()
#time.sleep(0.5)
# print('result',str(result.registers))
class Connection():
def __init__(self, indicator_list, coil_on_list, coil_off_list, command_list, coil_list, port,
method="rtu", timeout=0.1, unit=0x01):
self.unit = unit
self.indicator_list = indicator_list
self.coil_on_list = coil_on_list
self.coil_off_list = coil_off_list
self.coil_list = coil_list
self.command_list = command_list
self.lock = threading.Lock()
if method == "rtu":
self.client = ModbusSerialClient(method=method, port=port, baudrate=19200, stopbits=1, bytesize=8,
timeout=timeout)
elif method == "tcp":
self.client = ModbusTcpClient(host=port)
def translate(self, command):
self.lock.acquire()
self.client.connect()
print self.client.connect()
# input registers
if command.split("_")[0] == "IReg":
rr = self.client.read_input_registers(self.indicator_list[command.split()[0]], 1, unit=self.unit)
self.client.close()
self.lock.release()
return rr.getRegister(0)
# coils
elif command.split("_")[0] == "Coil":
if command.split()[0] in self.coil_on_list:
wr = self.client.write_coil(self.coil_on_list[command.split()[0]], 1, unit=self.unit)
rr = self.client.read_coils(self.coil_on_list[command.split()[0]], 1, unit=self.unit)
elif command.split()[0] in self.coil_off_list:
wr = self.client.write_coil(self.coil_off_list[command.split()[0]], 0, unit=self.unit)
rr = self.client.read_coils(self.coil_off_list[command.split()[0]], 1, unit=self.unit)
elif command.split()[0] in self.coil_list and len(command.split()) > 1 and \
command.split()[1].isdigit():
wr = self.client.write_coil(self.coil_list[command.split()[0]], int(command.split()[1]),
unit=self.unit)
rr = self.client.read_coils(self.coil_list[command.split()[0]], 1, unit=self.unit)
self.client.close()
self.lock.release()
return rr.getBit(0)
# holding registers
elif command.split("_")[0] == "HReg":
if len(command.split()) > 1 and command.split()[1].isdigit():
wr = self.client.write_registers(self.command_list[command.split()[0]], [int(command.split()[1])],
unit=self.unit)
rr = self.client.read_holding_registers(self.command_list[command.split()[0]], 1, unit=self.unit)
self.client.close()
self.lock.release()
return rr.getRegister(0)
else:
print "Not correct command"
self.lock.release()
return "Not correct command"
assert(rq.function_code < 0x80) # test that we are not an error
log.debug("Write to a holding register and read back")
rq = client.write_register(1, 10, unit=1)
rr = client.read_holding_registers(1, 1, unit=1)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.registers[0] == 10) # test the expected value
log.debug("Write to multiple holding registers and read back")
rq = client.write_registers(1, [10]*8, unit=1)
rr = client.read_holding_registers(1, 8, unit=1)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.registers == [10]*8) # test the expected value
log.debug("Read input registers")
rr = client.read_input_registers(1, 8, unit=1)
assert(rq.function_code < 0x80) # test that we are not an error
arguments = {
'read_address': 1,
'read_count': 8,
'write_address': 1,
'write_registers': [20]*8,
}
log.debug("Read write registeres simulataneously")
rq = client.readwrite_registers(unit=1, **arguments)
rr = client.read_holding_registers(1, 8, unit=1)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rq.registers == [20]*8) # test the expected value
assert(rr.registers == [20]*8) # test the expected value
except:
print("Error creating the data file!")
# Write the column names
df.write("sn,sta1_delay,sta2_delay,sta3_delay,sta4_delay,sta6_delay,sta1_to_sta2_delay,sta2_to_sta3_delay,sta3_to_sta4_delay,sta6_to_sta1_delay,inspection_result\n")
print("[DONE]")
print("Exporting data..."),
# Maximum parts the PLC can track is currently 512; iterate through all
for part in range(1,512):
# Inform the PLC task which index we want to read
request = client.write_register(0x800B, part)
# PLC needs time to update before we read the data
time.sleep(0.02)
# Read the data
rd = client.read_input_registers(0x800A, 11)
# Part SN's (the first element) are updated as parts are presented
# to Station 6, and are sequential. So, if the first element value
# does not match the expected one, there is no more data to be exported.
if rd.registers[0] != part:
break
else:
#print (rd.registers)
sdata = ""
# Iterate through each element and add it to the CSV string
for word in rd.registers:
if sdata != "":
sdata = sdata + ","
sdata = sdata + str(word)
# Write the data to the file, and add a new line
df.write(sdata + "\n")
rr = client.read_input_registers(8009,1)
print rr
'''
'''
rr = client.read_input_registers(8000,1)
print rr.registers
rr = client.read_input_registers(8001,1)
print rr.registers
rr = client.read_holding_registers(8001, 1)
print rr.registers
'''
i=1
uptime = time.time()
while True:
rq = client.write_registers(8001, [i]*1)
print i
rr = client.read_input_registers(8000, 1)
print rr.registers
if i < 7:
i = i * 2
print time.time() - uptime
else:
i=1
os.system("cls")
time.sleep(1)
#---------------------------------------------------------------------------#
# close the client
#---------------------------------------------------------------------------#
client.close()
def discover(type):
responses=list()
valid_iphead = False
try:
infile = None
infile = open(os.path.expanduser("~")+"/workspace/bemoss_os/machine_ip.txt","r")
for line in infile:
own_ip = line.rstrip()
own_ip_parts = own_ip.split('.')
if len(own_ip_parts) == 4:
print "Found own IP: "+own_ip
iphead = own_ip_parts[0]+'.'+own_ip_parts[1]+'.'+own_ip_parts[2]+'.'
valid_iphead = True
break
infile.close()
except:
if infile is not None:
infile.close()
valid_iphead = False
if valid_iphead:
start_ip=2
end_ip=254
print "Looking for Modbus Devices in the IP range: "+iphead+str(start_ip)+" to "+iphead+str(end_ip)
_Timeout=0.2
ip_index=start_ip
iprange=list()
while ip_index<=end_ip:
iprange.append(iphead+str(ip_index))
ip_index=ip_index+1
#print iprange
for ip in iprange:
try:
#print ip
_socket = None
try:
_socket = socket.create_connection((ip, 502), _Timeout)
except socket.error:
if _socket:
_socket.close()
_socket = None
if _socket is not None:
_socket.close()
client = ModbusTcpClient(ip,port=502)
client.connect()
if type == 'Prolon_VAV':
possible_slave_ids = [1,2,7]
elif type == 'Prolon_RTU':
possible_slave_ids = [15,20]
else:
possible_slave_ids = []
for slave_id in possible_slave_ids:
result = client.read_input_registers(0,unit=slave_id)
if result is not None:
responses.append(ip+':'+str(slave_id))
client.close()
except:
pass
else:
print "Modbus discovery failed: Couldn't find IP subnet of network!"
return responses
def getDeviceStatus(self):
getDeviceStatusResult = True
try:
client = ModbusTcpClient(self.get_variable('address'),port=502)
client.connect()
if (self.get_variable('model')=='VC1000'):
result = client.read_input_registers(0,8,unit=self.get_variable('slave_id'))
if int(result.registers[0])==32767:
self.set_variable('temperature',None)
else:
self.set_variable('temperature',float('%.1f' % self.cel2far(float(int(result.registers[0]))/100.0)))
self.set_variable('heat_setpoint',float('%.1f' % self.cel2far(float(int(result.registers[1]))/100.0)))
self.set_variable('cool_setpoint',float('%.1f' % self.cel2far(float(int(result.registers[2]))/100.0)))
if int(result.registers[7])==32767:
self.set_variable('supply_temperature',None)
else:
self.set_variable('supply_temperature',float('%.1f' % self.cel2far(float(int(result.registers[7]))/100.0)))
result = client.read_holding_registers(159,2,unit=self.get_variable('slave_id'))
if (int(result.registers[0])==1):
self.set_variable('flap_override','ON')
else:
self.set_variable('flap_override','OFF')
self.set_variable('flap_position',int(result.registers[1]))
elif (self.get_variable('model')=='M1000'):
result = client.read_input_registers(0,26,unit=self.get_variable('slave_id'))
if int(result.registers[18])==32767:
self.set_variable('temperature',None)
else:
self.set_variable('temperature',float('%.1f' % self.cel2far(float(int(result.registers[18]))/100.0)))
self.set_variable('heat_setpoint',float('%.1f' % self.cel2far(float(int(result.registers[19]))/100.0)))
self.set_variable('cool_setpoint',float('%.1f' % self.cel2far(float(int(result.registers[20]))/100.0)))
if int(result.registers[0])==32767:
self.set_variable('supply_temperature',None)
else:
self.set_variable('supply_temperature',float('%.1f' % self.cel2far(float(int(result.registers[0]))/100.0)))
if int(result.registers[1])==32767:
self.set_variable('return_temperature',None)
else:
self.set_variable('return_temperature',float('%.1f' % self.cel2far(float(int(result.registers[1]))/100.0)))
if int(result.registers[2])==32767:
self.set_variable('outside_temperature',None)
else:
self.set_variable('outside_temperature',float('%.1f' % self.cel2far(float(int(result.registers[2]))/100.0)))
self.set_variable('pressure',float(int(result.registers[22]))/100.0)
self.set_variable('outside_damper_position',int(result.registers[17]))
self.set_variable('bypass_damper_position',int(result.registers[25]))
cool1=int(result.registers[4])
cool2=int(result.registers[12])
cool3=int(result.registers[13])
cool4=int(result.registers[14])
if (int(result.registers[15])==1):
self.set_variable('fan_status','ON')
else:
self.set_variable('fan_status','OFF')
result = client.read_holding_registers(129,1,unit=self.get_variable('slave_id'))
if int(result.registers[0]) > 100:
self.set_variable('heating',0)
else:
self.set_variable('heating',int(result.registers[0]))
result = client.read_holding_registers(10,1,unit=self.get_variable('slave_id'))
if int(result.registers[0]) == 0:
self.set_variable('cooling_mode','None')
self.set_variable('cooling_status','OFF')
elif int(result.registers[0]) == 1:
self.set_variable('cooling_mode','STG1')
if cool1 == 0:
self.set_variable('cooling_status','OFF')
else:
self.set_variable('cooling_status','ON')
elif int(result.registers[0]) == 2:
self.set_variable('cooling_mode','STG2')
if cool2 == 0:
self.set_variable('cooling_status','OFF')
else:
self.set_variable('cooling_status','ON')
elif int(result.registers[0]) == 3:
self.set_variable('cooling_mode','STG3')
if cool3 == 0:
self.set_variable('cooling_status','OFF')
else:
self.set_variable('cooling_status','ON')
elif int(result.registers[0]) == 4:
self.set_variable('cooling_mode','STG4')
if cool4 == 0:
self.set_variable('cooling_status','OFF')
else:
self.set_variable('cooling_status','ON')
client.close()
except Exception as er:
print "classAPI_vav_rtu: ERROR: Reading Modbus registers at getDeviceStatus:"
print er
getDeviceStatusResult = False
if getDeviceStatusResult==True:
self.set_variable('offline_count',0)
else:
self.set_variable('offline_count',self.get_variable('offline_count')+1)
rr = client.read_coils(1,8)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.bits == [True]*8) # test the expected value
rq = client.write_coils(1, [False]*8)
rr = client.read_discrete_inputs(1,8)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.bits == [True]*8) # test the expected value
rq = client.write_register(1, 10)
rr = client.read_holding_registers(1,1)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.registers[0] == 10) # test the expected value
rq = client.write_registers(1, [10]*8)
rr = client.read_input_registers(1,8)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.registers == [17]*8) # test the expected value
arguments = {
'read_address': 1,
'read_count': 8,
'write_address': 1,
'write_registers': [20]*8,
}
rq = client.readwrite_registers(**arguments)
rr = client.read_input_registers(1,8)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rq.registers == [20]*8) # test the expected value
assert(rr.registers == [17]*8) # test the expected value
def run_sync_client():
# ------------------------------------------------------------------------#
# choose the client you want
# ------------------------------------------------------------------------#
# make sure to start an implementation to hit against. For this
# you can use an existing device, the reference implementation in the tools
# directory, or start a pymodbus server.
#
# If you use the UDP or TCP clients, you can override the framer being used
# to use a custom implementation (say RTU over TCP). By default they use
# the socket framer::
#
# client = ModbusClient('localhost', port=5020, framer=ModbusRtuFramer)
#
# It should be noted that you can supply an ipv4 or an ipv6 host address
# for both the UDP and TCP clients.
#
# There are also other options that can be set on the client that controls
# how transactions are performed. The current ones are:
#
# * retries - Specify how many retries to allow per transaction (default=3)
# * retry_on_empty - Is an empty response a retry (default = False)
# * source_address - Specifies the TCP source address to bind to
#
# Here is an example of using these options::
#
# client = ModbusClient('localhost', retries=3, retry_on_empty=True)
# ------------------------------------------------------------------------#
client = ModbusClient('localhost', port=5020)
# client = ModbusClient(method='ascii', port='/dev/pts/2', timeout=1)
# client = ModbusClient(method='rtu', port='/dev/ttyp0', timeout=1)
client.connect()
# ------------------------------------------------------------------------#
# specify slave to query
# ------------------------------------------------------------------------#
# The slave to query is specified in an optional parameter for each
# individual request. This can be done by specifying the `unit` parameter
# which defaults to `0x00`
# ----------------------------------------------------------------------- #
log.debug("Reading Coils")
rr = client.read_coils(1, 1, unit=0x01)
print(rr)
# ----------------------------------------------------------------------- #
# example requests
# ----------------------------------------------------------------------- #
# simply call the methods that you would like to use. An example session
# is displayed below along with some assert checks. Note that some modbus
# implementations differentiate holding/input discrete/coils and as such
# you will not be able to write to these, therefore the starting values
# are not known to these tests. Furthermore, some use the same memory
# blocks for the two sets, so a change to one is a change to the other.
# Keep both of these cases in mind when testing as the following will
# _only_ pass with the supplied async modbus server (script supplied).
# ----------------------------------------------------------------------- #
log.debug("Write to a Coil and read back")
rq = client.write_coil(0, True, unit=UNIT)
rr = client.read_coils(0, 1, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.bits[0] == True) # test the expected value
log.debug("Write to multiple coils and read back- test 1")
rq = client.write_coils(1, [True]*8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
rr = client.read_coils(1, 21, unit=UNIT)
assert(rr.function_code < 0x80) # test that we are not an error
resp = [True]*21
# If the returned output quantity is not a multiple of eight,
# the remaining bits in the final data byte will be padded with zeros
# (toward the high order end of the byte).
resp.extend([False]*3)
assert(rr.bits == resp) # test the expected value
log.debug("Write to multiple coils and read back - test 2")
rq = client.write_coils(1, [False]*8, unit=UNIT)
rr = client.read_coils(1, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.bits == [False]*8) # test the expected value
log.debug("Read discrete inputs")
rr = client.read_discrete_inputs(0, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
log.debug("Write to a holding register and read back")
rq = client.write_register(1, 10, unit=UNIT)
rr = client.read_holding_registers(1, 1, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.registers[0] == 10) # test the expected value
log.debug("Write to multiple holding registers and read back")
rq = client.write_registers(1, [10]*8, unit=UNIT)
rr = client.read_holding_registers(1, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.registers == [10]*8) # test the expected value
log.debug("Read input registers")
rr = client.read_input_registers(1, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
arguments = {
'read_address': 1,
'read_count': 8,
'write_address': 1,
'write_registers': [20]*8,
}
log.debug("Read write registeres simulataneously")
rq = client.readwrite_registers(unit=UNIT, **arguments)
rr = client.read_holding_registers(1, 8, unit=UNIT)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rq.registers == [20]*8) # test the expected value
assert(rr.registers == [20]*8) # test the expected value
# ----------------------------------------------------------------------- #
# close the client
# ----------------------------------------------------------------------- #
client.close()
cos_write = client.write_coils(args.offset, coils)
assert(cos_write.function_code < 0x80)
elif args.mode == 'r':
# NOTE: read_holding_registers
if args.type == 'HR':
hr_read = client.read_holding_registers(args.offset,
count=args.count)
assert(hr_read.function_code < 0x80)
print(hr_read.registers[0:args.count])
# NOTE: read_holding_registers
elif args.type == 'IR':
ir_read = client.read_input_registers(args.offset,
count=args.count)
assert(ir_read.function_code < 0x80)
print(ir_read.registers[0:args.count])
# NOTE: read_discrete_inputs
elif args.type == 'DI':
di_read = client.read_discrete_inputs(args.offset,
count=args.count)
assert(di_read.function_code < 0x80)
print(di_read.bits)
# NOTE: read_discrete_inputs
elif args.type == 'CO':
co_read = client.read_coils(args.offset,
count=args.count)
assert(co_read.function_code < 0x80)
# ---------------------------------------------------------------------------#
# If you need to decode a collection of registers in a weird layout, the
# payload decoder can help you as well.
#
# Here we demonstrate decoding a random register layout, unpacked it looks
# like the following:
#
# - a 8 byte string 'abcdefgh'
# - a 32 bit float 22.34
# - a 16 bit unsigned int 0x1234
# - an 8 bit int 0x12
# - an 8 bit bitstring [0,1,0,1,1,0,1,0]
# ---------------------------------------------------------------------------#
address = 0x01
count = 8
result = client.read_input_registers(address, count)
decoder = BinaryPayloadDecoder.fromRegisters(result.registers, endian=Endian.Little)
decoded = {
"string": decoder.decode_string(8),
"float": decoder.decode_32bit_float(),
"16uint": decoder.decode_16bit_uint(),
"8int": decoder.decode_8bit_int(),
"bits": decoder.decode_bits(),
}
print "-" * 60
print "Decoded Data"
print "-" * 60
for name, value in decoded.iteritems():
print ("%s\t" % name), value
class ModbusTest(object):
"""
Modbus Test Basisklasse
"""
def __init__(self, host=None, slave_id=1, function_code=None, register_addr=None, data_type=None, endian='big'):
self.client = None
self.host = host
self.slave_id = slave_id
self.function_code = function_code
self.register_addr = register_addr
self.data_type = data_type
if endian == 'big':
self.endian = Endian.Big
else:
self.endian = Endian.Little
def connect(self):
_logger.debug('connect {}'.format(self.host))
self.client = ModbusClient(self.host, port=502)
self.client.connect()
def run(self):
self.connect()
try:
while True:
try:
value = self.read()
except IOError as e:
print e
else:
self.print_value(value)
time.sleep(2)
except KeyboardInterrupt:
self.client.close()
pass
def read(self):
count = COUNTS.get(self.data_type)
if not count:
raise ValueError('Unsupported data type {}'.format(self.data_type))
_logger.debug('read register: {}, count: {}, slave: {}, function: {}'.format(self.register_addr, count, self.slave_id, self.function_code))
if self.function_code == 3:
result = self.client.read_holding_registers(self.register_addr, count, unit=self.slave_id)
elif self.function_code == 4:
result = self.client.read_input_registers(self.register_addr, count, unit=self.slave_id)
else:
raise ValueError('Unsupported function code {}'.format(self.function_code))
if result is None:
raise IOError('No modbus reponse')
if isinstance(result, ExceptionResponse):
raise IOError(str(result))
d = BinaryPayloadDecoder.fromRegisters(result.registers, endian=self.endian)
if self.data_type == '16bit_int':
value = d.decode_16bit_int()
elif self.data_type == '16bit_uint':
value = d.decode_16bit_uint()
elif self.data_type == '32bit_int':
value = d.decode_32bit_int()
elif self.data_type == '32bit_uint':
value = d.decode_32bit_uint()
elif self.data_type == '32bit_float':
value = d.decode_32bit_float()
elif self.data_type == '64bit_float':
value = d.decode_64bit_float()
else:
raise ValueError('Unsupported data type {}'.format(self.data_type))
return value
def print_value(self, value):
"""
Methode zur Ausgabe des Messwertes muss von der erbenden Klasse implementiert werden.
"""
raise NotImplementedError
