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 __init__( self, *, host='127.0.0.1', bit_adr=0, bit_num=1, word_adr=0, word_num=1, timeout=1, name='Modbus Server', ): """Init server.""" self.port = mdb.PORT self.host = host self.bit_adr = bit_adr self.bit_num = bit_num self.word_adr = word_adr self.word_num = word_num self.timeout = timeout self.name = name self.connection = None try: self.connection = ModbusServer( host=self.host, port=self.port, no_block=True, ) self.connection.start() except Exception as err: raise ServerError('Error with server', err)
def escreveModbus(self, contador): self.server = ModbusServer("127.0.0.1", int(self.portaTCP), no_block=True) self.server.start() DataBank.set_words(0, [int(contador)])
def setUp(self): # modbus server self.server = ModbusServer(port=TestClientServer.port, no_block=True) self.server.start() # modbus client self.client = ModbusClient(port=TestClientServer.port) self.client.open() # to prevent address taken errors TestClientServer.port += 1
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)
def server_stop(host, port): # parse args #parser = argparse.ArgumentParser() #parser.add_argument('-H', '--host', type=str, default='localhost', help='Host') #parser.add_argument('-p', '--port', type=int, default=502, help='TCP port') #args = parser.parse_args() # start modbus server #print("humo") server = ModbusServer(host, int(port), no_block=False) server.stop()
def run_modbus_server(host, port): print('starting modbus server at %s:%d' % (host, port)) server = ModbusServer(host=host, port=port, no_block=True) server.start() DataBank.set_words(0, [0] * 100) while True: DataBank.set_words(0x39, [random.randint(1, 10), 0]) DataBank.set_words(0x41, [random.randint(1, 10), 0]) DataBank.set_words(0x4b, [random.randint(1, 10), 0]) DataBank.set_words(0x50, [random.randint(1, 10), 0]) time.sleep(1)
class ModbusInstance: def __init__(self, host: str = '0.0.0.0', port: int = 502): self.port = port self.host = host self.server = None def run(self, run_async: bool = True): self.server = ModbusServer(host=self.host, port=self.port, no_block=run_async) self.server.start() @staticmethod def write_str(index: int, string: str): parsed_text = [ord(c) for c in string] ModbusInstance.write(index, parsed_text) @staticmethod def write_int(index: int, value: int): value = int(round(value)) ModbusInstance.write(index, [value]) @staticmethod def write_float(index: int, value: float): val = str(value).split('.') prefix = val[0] suffix = val[1] suffix = suffix + '0' if len(suffix) == 1 else suffix ModbusInstance.write(index, [int('%s%s' % (prefix, suffix))]) @staticmethod def write_bit(index: int, value: int): DataBank.set_bits(index, [value]) log('Wrote %s to index %s' % (value, index + 10001)) @staticmethod def write(index: int, value: any): index = index - 40001 if index > 40000 else index DataBank.set_words(index, value) value = value[0] if isinstance(value, list) else value index += 40001 log('Wrote %s to index %s' % (value, index))
def main(): ip, port = load_serve_config('server_info.json') server = ModbusServer(ip, port) print('PAI TA ÔN') print(f'IP: {ip} port {port}') try: server.start() except Exception as e: print(f'shutdown server with exception: {e}') server.stop() print('server is offline')
def run_server(): server = ModbusServer(host="", port=502, no_block=True) try: server.start() logging.info("Modbus server started") #Initialize 500 registers from address 0 DataBank.set_words(0, [0x0000] * 500) while True: continue #Stop server if interrupted except: server.close()
def main(): """ Main method to run the pyModbusTCP server for the test modbus endpoint. """ try: print('modbus main start') # Set holding register data to their address. # Set coils to address % 3 == 0. for i in range(0x4000): print('Setting word {} to {}'.format(i, i)) print('Setting bits {} to {}'.format(i, i % 3 == 0)) DataBank.set_words(i, [i]) DataBank.set_bits(i, [i % 3 == 0]) server = ModbusServer(host='', port=1502, no_block=True) server.start() print('started modbus server') global STOP_SERVER while not STOP_SERVER: time.sleep(.01) server.stop() print('stopped modbus server') except Exception: traceback.print_exc()
import time from pyModbusTCP.server import ModbusServer, DataBank # need https://github.com/dbader/schedule import schedule # word @0 = second since 00:00 divide by 10 to avoid 16 bits overflow def alive_word_job(): DataBank.set_words(0, [int(time.time()) % (24*3600) // 10]) if __name__ == "__main__": # parse args parser = argparse.ArgumentParser() parser.add_argument("-H", "--host", type=str, default="localhost", help="Host") parser.add_argument("-p", "--port", type=int, default=502, help="TCP port") args = parser.parse_args() # init modbus server and start it server = ModbusServer(host=args.host, port=args.port, no_block=True) server.start() # init scheduler # schedule a daily downtime (from 18:00 to 06:00) schedule.every().day.at("18:00").do(server.stop) schedule.every().day.at("06:00").do(server.start) # update life word at @0 schedule.every(10).seconds.do(alive_word_job) # main loop while True: schedule.run_pending() time.sleep(1)
class Thread(QThread): changePixmap = pyqtSignal(QImage) changePixmap2 = pyqtSignal(QImage) contTotal = pyqtSignal(str) width = 150 height = 400 #eggCount = 0 exitCounter = 0 #OffsetRefLines = 100 # Adjust ths value according to your usage ReferenceFrame = None distance_tresh = 400 #radius_min = 0 #radius_max = 0 #area_min = 750 #area_max = 1100 def __init__(self, modbusHab, areaMAx, areaMin, contorno, radiusMin, radiusMax, of7Linhas, portaTCP, porcEsc, contagemParou, diaAtual): super(Thread, self).__init__() self.area_max = areaMAx self.area_min = areaMin self.contornoValue = contorno self.radiusMin = radiusMin self.radiusMax = radiusMax self.of7Linhas = of7Linhas self.eggCount = int(contagemParou) self.portaTCP = portaTCP self.modbusHab = modbusHab self.cont = 0 self.porcEsc = porcEsc self.diaAtual = diaAtual #self.modbus=TCP def stop(self): self.coreActive = False self.quit() def lerModbus(self): zera = DataBank.get_words(1) if int(zera[0]) == 1: self.eggCount = 0 zera[0] = 0 DataBank.set_words(1, [0]) def escreveModbus(self, contador): self.server = ModbusServer("127.0.0.1", int(self.portaTCP), no_block=True) self.server.start() DataBank.set_words(0, [int(contador)]) def run(self): self.coreActive = True cap = cv2.VideoCapture('13.mp4') #cap = cv2.VideoCapture(0) fgbg = cv2.createBackgroundSubtractorMOG2() # for mask tempoini = time.time() while (self.coreActive): data = time.localtime() dia = data.tm_mday if (int(dia) != int(self.diaAtual)): self.eggCount = 0 (grabbed, frame) = cap.read() frame = cv2.rotate(frame, cv2.ROTATE_90_COUNTERCLOCKWISE) if not grabbed: print('Egg count: ' + str(self.eggCount)) print('\n End of the video file...') break # get Settings radius/area values #radius_min=10 #radius_max = 20 #area_min=500 #area_max = 1000 borderSize = self.contornoValue if self.radiusMin == '': self.radiusMin = 0 if self.radiusMax == '': self.radiusMax = 0 if self.area_min == '': self.area_min = 0 if self.area_max == '': self.area_max = 0 percent = int(self.porcEsc) width = int(frame.shape[1] * percent // 100) height = int(frame.shape[0] * percent // 100) dim = (width, height) frame40 = cv2.resize(frame, dim, interpolation=cv2.INTER_AREA) height = np.size(frame40, 0) width = np.size(frame40, 1) fgmask = fgbg.apply(frame40) hsv = cv2.cvtColor(frame40, cv2.COLOR_BGR2HSV) th, bw = cv2.threshold(hsv[:, :, 2], 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU) kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)) morph = cv2.morphologyEx(bw, cv2.MORPH_CLOSE, kernel) dist = cv2.distanceTransform(morph, cv2.DIST_L2, cv2.DIST_MASK_PRECISE) distborder = cv2.copyMakeBorder( dist, borderSize, borderSize, borderSize, borderSize, cv2.BORDER_CONSTANT | cv2.BORDER_ISOLATED, 0) gap = 10 kernel2 = cv2.getStructuringElement( cv2.MORPH_ELLIPSE, (2 * (borderSize - gap) + 1, 2 * (borderSize - gap) + 1)) kernel2 = cv2.copyMakeBorder( kernel2, gap, gap, gap, gap, cv2.BORDER_CONSTANT | cv2.BORDER_ISOLATED, 0) distTempl = cv2.distanceTransform(kernel2, cv2.DIST_L2, cv2.DIST_MASK_PRECISE) nxcor = cv2.matchTemplate(distborder, distTempl, cv2.TM_CCOEFF_NORMED) mn, mx, _, _ = cv2.minMaxLoc(nxcor) th, peaks = cv2.threshold(nxcor, mx * 0.5, 255, cv2.THRESH_BINARY) peaks8u = cv2.convertScaleAbs(peaks) # fgmask = self.fgbg.apply(peaks8u) #_, contours, hierarchy = cv2.findContours(peaks8u, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) contours, hierarchy = cv2.findContours(peaks8u, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) peaks8u = cv2.convertScaleAbs(peaks) # to use as mask # plot reference lines (entrance and exit lines) coordYEntranceLine = (height // 2) + int(self.of7Linhas) coordYMiddleLine = (height // 2) coordYExitLine = (height // 2) - int(self.of7Linhas) cv2.line(frame40, (0, coordYEntranceLine), (width, coordYEntranceLine), (255, 0, 0), 2) cv2.line(frame40, (0, coordYMiddleLine), (width, coordYMiddleLine), (0, 255, 0), 6) cv2.line(frame40, (0, coordYExitLine), (width, coordYExitLine), (255, 0, 0), 2) flag = False egg_list = [] egg_index = 0 for i in range(len(contours)): contour = contours[i] (x, y), radius = cv2.minEnclosingCircle(contour) radius = int(radius) (x, y, w, h) = cv2.boundingRect(contour) egg_index = i egg_list.append([x, y, flag]) if len(contour) >= 5: if (radius <= int(self.radiusMax) and radius >= int(self.radiusMin)): # print("radius: ", radius) # pprint.pprint(hierarchy) ellipse = cv2.fitEllipse(contour) # (x, y, w, h) = cv2.boundingRect(contour) (center, axis, angle) = ellipse try: coordXContour, coordYContour = int(center[0]), int( center[1]) except: coordXContour, coordYContour = 0, 0 coordXCentroid = (2 * coordXContour + w) // 2 coordYCentroid = (2 * coordYContour + h) // 2 try: ax1, ax2 = int(axis[0]) - 2, int(axis[1]) - 2 except: ax1, ax2 = 2, 2 orientation = float(angle) area = cv2.contourArea(contour) if area >= float(self.area_min) and area <= float( self.area_max): #print('egg list: ' + str(egg_list) + ' index: ' + str(egg_index)) if ((coordYContour <= coordYEntranceLine) and (coordYContour >= coordYExitLine)): cv2.ellipse(frame40, (coordXContour, coordYContour), (ax1, ax2), orientation, 0, 360, (255, 0, 0), 2) # blue cv2.circle(frame40, (coordXContour, coordYContour), 1, (0, 255, 0), 15) # green cv2.putText(frame40, str(int(area)), (coordXContour, coordYContour), cv2.FONT_HERSHEY_SIMPLEX, 0.5, 0, 1, cv2.LINE_AA) for k in range(len(egg_list)): egg_new_X = x egg_new_Y = y dist = abs(egg_new_Y - egg_list[k][1]) if dist > self.distance_tresh: # distance_tresh = 200 egg_list.append([egg_new_X, egg_new_Y, flag]) absDistance = abs(coordYContour - coordYEntranceLine) if ((coordYContour >= coordYEntranceLine) and (absDistance <= 3)): self.eggCount += 1 egg_list.remove([egg_new_X, egg_new_Y, flag]) #salva imagem a cada 2 segundos tempofinal = time.time() if (tempofinal - tempoini > 2): cv2.imwrite('frame.jpg', frame40) tempoini = time.time() #escreve e ler modbus a cada 2 segundos if (self.modbusHab == 1): self.escreveModbus(self.eggCount) self.lerModbus() self.rgbImage = cv2.cvtColor(frame40, cv2.COLOR_BGR2RGB) h, w, ch = self.rgbImage.shape bytesPerLine = ch * w convertToQtFormat = QImage(self.rgbImage.data, w, h, bytesPerLine, QImage.Format_RGB888) p = convertToQtFormat.scaled(640, 480, Qt.KeepAspectRatio) self.changePixmap.emit(p) rgbImage2 = cv2.cvtColor(peaks8u, cv2.COLOR_BGR2RGB) h, w, ch = rgbImage2.shape bytesPerLine = ch * w convertToQtFormat = QImage(rgbImage2.data, w, h, bytesPerLine, QImage.Format_RGB888) p = convertToQtFormat.scaled(640, 480, Qt.KeepAspectRatio) self.changePixmap2.emit(p) self.contTotal.emit(str(self.eggCount)) # cleanup the camera and close any open windows cap.release()
Script cliente: from pyModbusTCP.client import ModbusClient from time import sleep SERVER_HOST="192.168.0.12" SERVER_PORT=502 c=ModbusClient(host=SERVER_HOST,port=SERVER_PORT,auto_open=True) c.open() while True: if c.is_open(): regs=c.read_input_registers(reg_addr=10,reg_nb=1) print(regs) sleep(3) else: print("can't connect") sleep(3) Script servidor: from pyModbusTCP.server import ModbusServer , DataBank DataBank.set_words(address=10,word_list=[15]) server=ModbusServer(host="192.168.0.12",port=502,no_block=True) server.start() while True: pass
def run(self, run_async: bool = True): self.server = ModbusServer(host=self.host, port=self.port, no_block=run_async) self.server.start()
import time from pyModbusTCP.server import ModbusServer, DataBank from time import sleep server = ModbusServer("172.17.115.225", 502, no_block=True) try: while True: print("Iniciando servidor...") server.start() print("Servidor iniciado") while True: DataBank.get_words(0) DataBank.get_words(1) DataBank.get_words(2) sleep(1) except: print("Desligando servidor...") server.stop() print("Servidor desligado")
write_l = [Tags.PV, Tags.SP, Tags.OUT, Tags.KP, Tags.KI, Tags.KD] DB.set_floats(0, write_l) # wait next loop time.sleep(0.5) # main program if __name__ == "__main__": # init and start modbus data manager tp = Thread(target=mbus_data_thread) # set daemon: polling thread will exit if main thread exit tp.daemon = True tp.start() # init and start modbus server(remain this after modbus data manager init) server = ModbusServer(host="0.0.0.0", port=502, no_block=True) server.start() # init serial port s = ArduinoCommandSerial("/dev/ttyATH0", baudrate=9600, timeout=2.0) # init PID board # s.send_cmd("auto", echo=True) # main loop while True: # process pending command while not Tags.cmd_q.empty(): cmd = Tags.cmd_q.get() s.send_cmd(cmd, echo=True) # read process values
class AsyncModbusServer(object): """Asynchronous Modbus TCP Server.""" def __init__( self, *, host='127.0.0.1', bit_adr=0, bit_num=1, word_adr=0, word_num=1, timeout=1, name='Modbus Server', ): """Init server.""" self.port = mdb.PORT self.host = host self.bit_adr = bit_adr self.bit_num = bit_num self.word_adr = word_adr self.word_num = word_num self.timeout = timeout self.name = name self.connection = None try: self.connection = ModbusServer( host=self.host, port=self.port, no_block=True, ) self.connection.start() except Exception as err: raise ServerError('Error with server', err) async def run_task(self): """Run asyncio server.""" executor = concurrent.futures.ThreadPoolExecutor(max_workers=3, ) task = asyncio.create_task(self._awaitable(executor)) await task def stop(self): """Stop server.""" self.connection.stop() def _setup(self): cryptogen = SystemRandom() while True: bits_value = [ bool(cryptogen.randrange(2)) for indx in range(self.bit_num) ] words_value = [ cryptogen.randrange(10) for _ in range(self.word_num) ] try: DataBank.set_bits(self.bit_adr, bits_value) DataBank.set_words(self.word_adr, words_value) except Exception as err: raise ServerError('Error with writing', err) async def _awaitable(self, executor): loop = asyncio.get_event_loop() while True: await loop.run_in_executor( executor, self._setup(), ) await asyncio.sleep(self.timeout)
class TestClientServer(unittest.TestCase): port = 5020 def setUp(self): # modbus server self.server = ModbusServer(port=TestClientServer.port, no_block=True) self.server.start() # modbus client self.client = ModbusClient(port=TestClientServer.port) self.client.open() # to prevent address taken errors TestClientServer.port += 1 def tearDown(self): self.client.close() @repeat def test_word_init(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') @repeat def test_word_single(self): # single read/write self.assertEqual(self.client.write_single_register(0, 0xffff), True) self.assertEqual(self.client.read_input_registers(0), [0xffff]) @repeat def test_word_multi(self): # 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) @repeat def test_word_oversize(self): # write over sized words_l = [randint(0, 0xffff)] * 0x7c self.assertEqual(self.client.write_multiple_registers(0, words_l), None) @repeat def test_bit_init(self): # 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') @repeat def test_bit_single(self): # 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]) @repeat def test_bit_multi_min(self): # 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) @repeat def test_bit_multi_max(self): # 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) @repeat def test_bit_multi_oversize(self): # multi-write over sized bits_l = [getrandbits(1)] * 0x7b1 self.assertEqual(self.client.write_multiple_coils(0, bits_l), None)
#!/usr/bin/env python3 """ Example Modbus Server: run 60 seconds Reference: https://youtu.be/FYPQgnQE9fk Author: Zihan Date: 2021-07-10 """ from pyModbusTCP.server import ModbusServer, DataBank import time try: server = ModbusServer(host='localhost', port=1234, no_block=True) server.start() state = 10 t0 = time.time() while True: DataBank.set_words(0, [1, 2, 3]) if state != DataBank.get_words(10, 1)[0]: state = DataBank.get_words(10, 1)[0] print('state changed to {}'.format(state)) time.sleep(0.05) if time.time() - t0 > 60: break server.stop() except: print('Failed to create a server')
from pyModbusTCP.server import ModbusServer if __name__ == '__main__': server = ModbusServer(host='localhost', port=502) server.start()
# Modbus/TCP server from pyModbusTCP.server import ModbusServer if __name__ == '__main__': server = ModbusServer(host='0.0.0.0', port=5020) server.start()
#!/usr/bin/env python3 # -*- coding: utf-8 -*- # Modbus/TCP server import argparse from pyModbusTCP.server import ModbusServer if __name__ == '__main__': # parse args parser = argparse.ArgumentParser() parser.add_argument('-H', '--host', type=str, default='localhost', help='Host') parser.add_argument('-p', '--port', type=int, default=502, help='TCP port') args = parser.parse_args() # start modbus server server = ModbusServer(host=args.host, port=args.port) print("Server ModbusTCP started with param host="+args.host+" port="+str(args.port)) server.start() # Print commandes entrantes et etat des registre?
from pyModbusTCP.server import ModbusServer # This script is used during debugging to set up a modbus server server = ModbusServer("192.168.68.113", 502) print(server.host) try: server.start() while True: pass except: print("Shutdown server ...") server.stop() print("Server is offline")
words.append(random.randrange(0, 10000)) words.append(random.randrange(220, 240)) words.append(random.randrange(0, 800)) print(words) DataBank.set_words(0, [words[0]]) # power DataBank.set_words(1, [words[1]]) # ac voltage DataBank.set_words(2, [words[2]]) # dc voltage if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument("-H", "--host", type=str, default="0.0.0.0", help="host") parser.add_argument("-p", "--port", type=int, default=502, help="port") args = parser.parse_args() modbus_server = ModbusServer(host=args.host, port=args.port, no_block=True) modbus_server.start() scheduler = BackgroundScheduler() scheduler.add_job(set_databank_words, trigger="cron", second="*/20") scheduler.start() print('server started on {0}:{1}!'.format(args.host, args.port)) while True: time.sleep(1)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- # Modbus/TCP server import socket import errno import time from pyModbusTCP.server import ModbusServer, DataBank if __name__ == "__main__": # init server server = ModbusServer(host='localhost', port=502, no_block=True) server.start() # main loop arr = [1] a = 1 while True: a += 1 arr[0] = a DataBank.set_words(0, arr) time.sleep(1)
print("Setting PLC port to DOWN: ", end="", flush=True) cmds = [ "config switch physical-port", "edit port3", "set status down", "end" ] exec_ssh_cmds(cmds) print(f"[{Fore.GREEN}DONE{Style.RESET_ALL}]") # Set IP to PLC's IP print("Setting local IP to PLC IP: ", end="", flush=True) set_ip(interface, targetaddr, targetsubnet, targetgateway) print(f"[{Fore.GREEN}DONE{Style.RESET_ALL}]") print("Waiting for IP to kick in: ", end="", flush=True) time.sleep(2) print(f"[{Fore.GREEN}DONE{Style.RESET_ALL}]") # Run modbus server print("Starting modbus server: ", end="", flush=True) server = ModbusServer(host="0.0.0.0", port=502) DataBank.set_bits(0, [1, 1, 1, 1, 1, 1, 1, 1, 1]) DataBank.set_words(0, [2**15-1, 2**15-1, 2**15-1, 2**15-1, 2**15-1, 2**15-1, 2**15-1, 2**15-1, 2**15-1, 2**15-1]) print(f"[{Fore.GREEN}DONE{Style.RESET_ALL}]") print("Press Ctrl+C to safely stop server") server.start()
from time import sleep import pygame pygame.init() pygame.joystick.init() t = pygame.joystick.get_count() controller = pygame.joystick.Joystick(0) controller.init() axis_data = {0: 0.0, 2: 0.0, 3: 0.9, 4: 0, 1: 0.0} button_data = {0: False, 1: False, 2: False, 3: False, 9: False, 10: False} x = 0 y = 0 # Create an instance of ModbusServer #server = ModbusServer("158.38.140.10", 502, no_block=True) server = ModbusServer("10.0.1.92", 502, no_block=True) print("Start server...") server.start() print("Server is online") state = [0] while True: for event in pygame.event.get(): if event.type == pygame.JOYAXISMOTION: axis_data[event.axis] = round(event.value * 100, 1) x = axis_data[0] y = axis_data[1] * -1 elif event.type == pygame.JOYBUTTONDOWN: button_data[event.button] = True elif event.type == pygame.JOYBUTTONUP: button_data[event.button] = False buzzer = button_data[0] # Square button
from pyModbusTCP.server import ModbusServer, DataBank from time import sleep import random SERVER_HOST_IP = "localhost" SERVER_PORT = 502 # Create an instance of ModbusServer server = ModbusServer(SERVER_HOST_IP, SERVER_PORT, no_block=True) if __name__ == '__main__': try: print("Starting server...") server.start() print("Server online") # Server enable DataBank.set_bits(9901, [1]) # Sample Rate (Hz) DataBank.set_words(39901, [2]) # Fake sensor configuration (LANE 00) # Lane_Enable DataBank.set_bits(0, [1]) # Sensor value DataBank.set_words(30001, [0]) # Raw voltage value (0.1 mV) DataBank.set_words(30002, [0]) # Sensor type DataBank.set_words(40001, [0])
#!/bin/python from pyModbusTCP.server import ModbusServer, DataBank from time import sleep from random import uniform # Create an instance of ModbusServer server = ModbusServer("127.0.0.1", 502, no_block=True) try: print("Start server...") server.start() print("Server is online") state = [0] while True: DataBank.set_words(0, [int(uniform(0, 100))]) if state != DataBank.get_words(1): state = DataBank.get_words(1) print("Value of Register 1 has changed to " + str(state)) sleep(0.5) except: print("Shutdown server ...") server.stop() print("Server is offline")
from pyModbusTCP.server import ModbusServer, DataBank from time import sleep #Criando uma instancia de ModbusServer server = ModbusServer("localHost", 502, no_block=True) try: print("Start server ...") server.start() print("Server is online") state = [0] while True: if state != DataBank.get_words(1): state = DataBank.get_words(1) print("Value has changed to " +str(state)) sleep(0.5) except: print("Shutdown server ...") server.stop() print("Server is offiline")