class TestClientServer(unittest.TestCase):
def setUp(self):
# modbus server
self.server = ModbusServer(port=5020, no_block=True)
self.server.start()
# modbus client
self.client = ModbusClient(port=5020)
self.client.open()
def tearDown(self):
self.client.close()
def test_read_and_write(self):
# word space
self.assertEqual(self.client.read_holding_registers(0), [0], 'Default value is 0 when server start')
self.assertEqual(self.client.read_input_registers(0), [0], 'Default value is 0 when server start')
# single read/write
self.assertEqual(self.client.write_single_register(0, 0xffff), True)
self.assertEqual(self.client.read_input_registers(0), [0xffff])
# multi-write at max size
words_l = [randint(0, 0xffff)] * 0x7b
self.assertEqual(self.client.write_multiple_registers(0, words_l), True)
self.assertEqual(self.client.read_holding_registers(0, len(words_l)), words_l)
self.assertEqual(self.client.read_input_registers(0, len(words_l)), words_l)
# write over sized
words_l = [randint(0, 0xffff)] * 0x7c
self.assertEqual(self.client.write_multiple_registers(0, words_l), None)
# bit space
self.assertEqual(self.client.read_coils(0), [False], 'Default value is False when server start')
self.assertEqual(self.client.read_discrete_inputs(0), [False], 'Default value is False when server start')
# single read/write
self.assertEqual(self.client.write_single_coil(0, True), True)
self.assertEqual(self.client.read_coils(0), [True])
self.assertEqual(self.client.read_discrete_inputs(0), [True])
# multi-write at min size
bits_l = [getrandbits(1)] * 0x1
self.assertEqual(self.client.write_multiple_coils(0, bits_l), True)
self.assertEqual(self.client.read_coils(0, len(bits_l)), bits_l)
self.assertEqual(self.client.read_discrete_inputs(0, len(bits_l)), bits_l)
# multi-write at max size
bits_l = [getrandbits(1)] * 0x7b0
self.assertEqual(self.client.write_multiple_coils(0, bits_l), True)
self.assertEqual(self.client.read_coils(0, len(bits_l)), bits_l)
self.assertEqual(self.client.read_discrete_inputs(0, len(bits_l)), bits_l)
# multi-write over sized
bits_l = [getrandbits(1)] * 0x7b1
self.assertEqual(self.client.write_multiple_coils(0, bits_l), None)
help='RTU port (default is %d)' % DEF_MB_PORT)
parser.add_argument('id_str', type=str,
help='ID string')
parser.add_argument('-a', '--id_addr', type=int, default=DEF_ID_ADDR,
help='ID address (default is %d)' % DEF_ID_ADDR)
args = parser.parse_args()
# init modbus client
c = ModbusClient(host=args.ip_rtu, port=args.port_rtu)
# open TCP link
if not c.open():
print("unable to connect to " + args.ip_rtu + ":" + str(args.port_rtu))
sys.exit(1)
# format id list (8 chars max)
id_list = [ord(x) for x in args.id_str.ljust(8)][:8]
# do modbus write
print('write ID %s at @%d' % (id_list, args.id_addr))
regs = c.write_multiple_registers(args.id_addr, id_list)
# print status
if regs:
print('ok')
else:
print('error')
# close TCP link
c.close()
class modBusWriteRead():
def __init__(self,client_host):
self.client_host = client_host
self.client_port = 502
self.err_list = []
self.connect() #buradan bağlantı yapılacak;
def connect(self):
self.modbus_c = ModbusClient()
self.modbus_c.host(self.client_host)
self.modbus_c.port(self.client_port)
if not self.modbus_c.is_open():
if not self.modbus_c.open():
text="unable to connect to " + self.client_host + ":" + str(self.client_port)
print(text)
def write_data_reg(self,address,list):
if self.modbus_c.open():
if len(list)>120:
sent_list = self.hazirla_dizi_to_write(list)
i = 0
hedef_reg_taban = address
for list_to_sent in sent_list:
hedef_reg = hedef_reg_taban + (i * 120)
a = self.modbus_c.write_multiple_registers(hedef_reg, list_to_sent)
if a == None or a == False:
self.err_list.append(False)
i += 1
else:
a = self.modbus_c.write_multiple_registers(address, list)
if a == None or a == False:
self.err_list.append(False)
if len(self.err_list) > 0:
self.err_list = []
pass
# dikkat
# print("data göndermede hata oluştu, tekrar deneyin !")
def hazirla_dizi_to_write(self,d_list):
# eğer gönderilecek değer 120 den büyük ise aşağıdaki fonksiyon 120 lik diziler döndürüyor
r_list = []
g_list = []
i = 0
for index in range(len(d_list)):
g_list.append(d_list[index])
i += 1
if i > 119:
i = 0
r_list.append(g_list)
g_list = []
if (len(d_list) - 1) == index and i < 119:
r_list.append(g_list)
return r_list
def read_data_reg(self,address,reg_count,read_float=False ):
# burada 16 lık ya da float olarak okunabiliyor
if self.modbus_c.is_open():
if read_float == False:
plc_list_int = self.modbus_c.read_holding_registers(address, reg_count)
return plc_list_int
elif read_float == True:
plc_list_f_16=self.modbus_c.read_holding_registers(address,reg_count)
if plc_list_f_16 is not None:
plc_list_float=self.long_to_float(plc_list_f_16)
return plc_list_float
def long_to_float(self,list_16):
list_float=[]
list_16.reverse()
list_long=utils.word_list_to_long(list_16)
for any_long in list_long:
list_float.append(utils.decode_ieee(any_long))
list_float.reverse()
return list_float
if not c.is_open():
if not c.open():
print("unable to connect to " + client_host + ":" + str(client_port))
def int32_to_int8(n):
mask = (1 << 16) - 1
return [(n >> k) & mask for k in range(0, 32, 16)]
var_int = utils.encode_ieee(7.5)
print(var_int)
sonuc=int32_to_int8(var_int)
print(sonuc)
if c.is_open():
# read 10 registers at address 0, store result in regs list
print(var_int)
c.write_single_register(0,5)
c.write_multiple_registers(1,sonuc)
regs = c.read_holding_registers(0,100)
# if success display registers
if regs:
print("reg ad #0 to 9: " , regs)
bits = c.read_discrete_inputs(0, 16)
# if success display registers
if bits:
print("bit ad #0 to 9: " + str(bits))
import serial
import subprocess as sp
from pyModbusTCP.client import ModbusClient
global systems
systems={'modbus':False, 'serial':False,'bluetooth':False}
MODBUS_SERVER_IP="192.168.0.200"
c = ModbusClient(host=MODBUS_SERVER_IP, port=502, auto_open=True)
c.host(MODBUS_SERVER_IP)
c.port(502)
if c.write_multiple_registers(133, [1, 0]):
systems['modbus'] = True
else:
systems['modbus'] = False
if not systems['modbus']:
MODBUS_SERVER_IP="127.0.0.1"
c = ModbusClient(host=MODBUS_SERVER_IP, port=502, auto_open=True)
c.host(MODBUS_SERVER_IP)
c.port(502)
if c.write_multiple_registers(133, [1, 0]):
systems['modbus'] = True
# else:
# import os
# os.system("sudo python3 sync_server.py")
#time.sleep(3)
class roebot():
def __init__(self, threadpool):
self.tp = Thread(target=self.polling_thread)
self.threadpool = threadpool
self.regList = []
self.tp.start()
self.pictureIndex = 0
self.camera = Camera.Camera()
self.imageCv = imageProcessing2.imageProcessing()
self.imageList = []
# self.modbusclient = r_w_float_modbus.FloatModbusClient(ModbusClient)
def poll_command(self):
print("Polling server for commands")
commandpoll = False
# display loop (in main thread)
while not commandpoll:
# print regs list (with thread lock synchronization)
if self.regList:
command = self.regList[0]
if command in range(1, 6):
if self.sendIntModbus(0, 0):
self.switch_case(command)
# Takes picture of tray.
def takePicture(self):
print("Executing take picture")
RoeImage = self.camera.takePicture(330, self.pictureIndex)
self.pictureIndex += 1
self.imageCv.processingQueue.append(RoeImage)
self.switch_case(0)
# modbus polling thread
def polling_thread(self):
self.client = ModbusClient(host=SERVER_HOST, port=SERVER_PORT)
isOpen = False
# polling loop
while True:
# keep TCP open
if not self.client.is_open():
print("unable to connect to " + SERVER_HOST + ":" +
str(SERVER_PORT))
self.client.open()
if self.client.is_open():
if not isOpen:
print("connected to " + SERVER_HOST + ":" +
str(SERVER_PORT))
isOpen = True
# do modbus reading on socket
reg_list = self.client.read_holding_registers(0, 10)
# if read is ok, store result in regs (with thread lock synchronization)
if reg_list:
with regs_lock:
self.regList = list(reg_list)
# 1s before next polling
time.sleep(0.2)
# send int to modbusServer
def sendIntModbus(self, value, address):
return self.client.write_single_register(address, value)
# process images by creating a RoeImage adding them to roeimage Queue
def processImages(self):
if len(self.imageList) == 0:
print("processing images")
imageList1, processing = self.imageCv.processImages()
self.imageList = imageList1
else:
self.imageList = []
self.switch_case(0)
def sendcoord(self, arrayX, arrayY):
sending = False
if self.client.write_multiple_registers(10, arrayX):
print("write ok")
sending = True
else:
print("write error")
sending = False
return sending
# generate coordinate list relative to the robot
def generatecoordinateList(self):
print("generating cordinate list")
coordList = []
for roeImage in self.imageList:
list = roeImage.getRoePositionMillimeter()
if len(list) > 0:
for i in range(len(list)):
coordinate = list[i]
xpos = coordinate.getxCoor() + (
(int(roeImage.getPictureIndex()) + 1) * 300)
ypos = coordinate.getyCoor()
newcoord = Coordinate.coordinate(xpos, ypos)
coordList.append(newcoord)
return coordList
def sendCordToPLC(self):
print("sending to PLC")
arrayX = []
arrayY = []
corrdList = self.generatecoordinateList()
for cord in corrdList:
arrayX.append(cord.getxCoor())
arrayY.append(cord.getyCoor())
print(arrayX)
self.client.write_multiple_registers(10, arrayX)
#sleep so register can be updated
time.sleep(1)
self.imageCv.processingQueue = []
self.imageList = []
self.switch_case(0)
def getImageList(self):
print(len(self.imageList))
time.sleep(1)
self.switch_case(0)
def switch_case(self, command):
switcher = {
0: self.poll_command,
2: self.takePicture,
3: self.processImages,
4: self.sendCordToPLC,
5: self.getImageList
}
# Get the function from switcher dictionary
func = switcher.get(command, lambda: "Invalid command")
# Execute the function
return func()
minimalmodbus.CLOSE_PORT_AFTER_EACH_CALL = True
# TCP auto connect on first modbus request
c = ModbusClient(host="localhost", port=502, auto_open=True)
# TCP auto connect on modbus request, close after it
c = ModbusClient(host="127.0.0.1", auto_open=True, auto_close=True)
c = ModbusClient()
c.host("localhost")
c.port(502)
# managing TCP sessions with call to c.open()/c.close()
c.open()
#Read 2x 16 bits registers at modbus address 0 :
regs = c.read_holding_registers(0, 2)
if regs:
print(regs)
else:
print("read error")
#Write value 44 and 55 to registers at modbus address 10 :
if c.write_multiple_registers(10, [44, 55]):
print("write ok")
else:
print("write error")
data1 = np.zeros(16)
data2 = np.zeros(16)
data3 = np.zeros(8)
d
def modbus_polling_thread():
global DATA_TO_HMI_HOLDING, DATA_FROM_HMI_HOLDING, DATA_FROM_HMI_COIL, DATA_TO_HMI_COIL
global start_addr, test_signal_coil, test_signal_holding
global addr_num
c = ModbusClient(host=MODBUS_SPEC['SERVER_HMI_HOST'],
port=MODBUS_SPEC['SERVER_HMI_PORT'])
# polling loop
while True:
# keep TCP open
if not c.is_open():
c.open()
# read data from hmi(holding & coil)
DATA_FROM_HMI_HOLDING = c.read_holding_registers(
MDS_ADDR_R['addr_start_holding_R'],
MDS_ADDR_R['addr_num_holding_R'])
# if read is ok, store result in regs (with thread lock synchronization)
#time.sleep(0.)
DATA_FROM_HMI_COIL = c.read_coils(MDS_ADDR_R['addr_start_coil_R'],
MDS_ADDR_R['addr_num_coil_R'])
print('Holding %s COil %s', DATA_FROM_HMI_HOLDING, DATA_FROM_HMI_COIL)
print('reading form mds slave')
if DATA_FROM_HMI_HOLDING:
with regs_lock:
print('with regs_lock_holding')
#for demonstrate usage
#DATA_FROM_HMI = list(DATA_FROM_HMI_HOLDING)
###
holding_payload_to_ros = {}
#publish holding register data to ros driver
if mqtt_client is not None:
#insert data from holding register
for x in range(0, MDS_ADDR_R['addr_num_holding_R']):
holding_payload_to_ros[
str(MDS_ADDR_R['addr_start_holding_R'] +
x)] = DATA_FROM_HMI_HOLDING[x]
#transfer dict to string with json.dumps(payload_)
#print('holding payload to ros driver %s',sort_key(holding_payload_to_ros))
input_holding = json.dumps(holding_payload_to_ros)
#transfer string to string with json.loads(input)
mqtt_client.publish(topic='DATA_TO_ROS_DRIVER_HOLDING_R',
payload=input_holding,
qos=2,
retain=False)
time.sleep(0.05)
if DATA_FROM_HMI_COIL:
#insert data from coil register
coil_payload_to_ros = {}
for y in range(0, MDS_ADDR_R['addr_num_coil_R']):
coil_payload_to_ros[str(MDS_ADDR_R['addr_start_coil_R'] +
y)] = DATA_FROM_HMI_COIL[y]
input_coil = json.dumps(coil_payload_to_ros)
#print('coil payload to ros driver %s',sort_key(coil_payload_to_ros))
if mqtt_client is not None:
mqtt_client.publish(topic='DATA_TO_ROS_DRIVER_COIL_R',
payload=input_coil,
qos=2,
retain=False)
else:
print('listenning to holding register fail')
#write data to hmi(holding & coil)
with msg_lock_w:
print('with msg_lock_coiling')
print('DATA_TO_HMI_HOLDING %s', DATA_TO_HMI_HOLDING)
if DATA_TO_HMI_HOLDING is not None and len(
DATA_TO_HMI_HOLDING) is not 0 and len(
DATA_TO_HMI_HOLDING
) == MDS_ADDR_W['addr_num_holding_W']:
print('SDSDASD %s', MDS_ADDR_W['addr_start_holding_W'])
if c.write_multiple_registers(
MDS_ADDR_W['addr_start_holding_W'],
DATA_TO_HMI_HOLDING):
print('write holding ok from addr %s with list %s',
MDS_ADDR_W['addr_start_holding_W'],
DATA_TO_HMI_HOLDING)
else:
print('write holding error from addr %s with list %s',
MDS_ADDR_W['addr_start_holding_W'],
DATA_TO_HMI_HOLDING)
else:
print('holding data missing with %s with desired len %s',
DATA_TO_HMI_HOLDING, MDS_ADDR_W['addr_num_holding_W'])
time.sleep(0.1)
if DATA_TO_HMI_COIL is not None and len(
DATA_TO_HMI_COIL) is not 0 and len(
DATA_TO_HMI_COIL) == MDS_ADDR_W['addr_num_coil_W']:
print(MDS_ADDR_W['addr_start_coil_W'])
is_ok = c.write_multiple_coils(MDS_ADDR_W['addr_start_coil_W'],
DATA_TO_HMI_COIL)
if is_ok:
print('write coil ok from addr %s with list %s',
MDS_ADDR_W['addr_start_coil_W'], DATA_TO_HMI_COIL)
else:
print('write coil error from addr %s with list %s',
MDS_ADDR_W['addr_start_coil_W'], DATA_TO_HMI_COIL)
else:
print('coil data missing with %s with desired len %s',
DATA_TO_HMI_COIL, MDS_ADDR_W['addr_num_coil_W'])
#write something to HMI
time.sleep(0.1)