def write_coil(self, coil_address, write_value):
        """ Modbus command : write single coil data (function code = 05)

            @Argument :
            coil_address (int16) : Coil address where to write a coil data
            write_value (int)    : write value
        """

        # Generate modbus TCP message
        try:
            message = modbus_tcp.write_single_coil(slave_id=self.device_id,
                                                   address=coil_address,
                                                   value=write_value)
        except Exception as e:
            print("Error during generate modbus message.")

        # Send message via TCP socket
        try:
            self._connect()
            response = modbus_tcp.send_message(message, self.tcp_socket)
            print("response={}".format(response))
            self._disconnect()
        except Exception as e:
            print("Error during send modbus message.")
            print(e)
Beispiel #2
0
def openDoor(ip):
    global Threat_Flags
    try:  #open door
        if not Threat_Flags[0]:
            try:
                sock_modbus = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                sock_modbus.connect(('10.11.13.' + ip, 502))
                str_message = tcp.write_single_coil(slave_id=1,
                                                    address=100,
                                                    value=1)
                list_response = tcp.send_message(str_message, sock_modbus)
            except socket.error as e:
                print('except')
                QMessageBox(QMessageBox.Critical, "Error:\n", str(e)).exec()
            else:
                pygame.mixer.music.load("fb.mp3")
                pygame.mixer.music.play(5)
                createRecord()
                GameThread(ip).start()
                setDoor(0)
                SleepThread(10, setDoor, 1).start()
            finally:
                sock_modbus.close()
    except:  #open door
        answerMessage = '{} >> unenable to start game'.format(
            time.strftime('%H:%M:%S|%y.%m.%d', time.localtime()))
        logging.warning(answerMessage)

    else:  #open door
        answerMessage = '{} >> start game'.format(
            time.strftime('%H:%M:%S|%y.%m.%d', time.localtime()))
        logging.info(answerMessage)
Beispiel #3
0
 def writeBit(self,address,value):
     message = tcp.write_single_coil(self.slaveNbr, address, value)
     response = self.__doRequest(message)
     return response
	def write_off(self):
		message = tcp.write_single_coil(slave_id=1, address=self.address, value=0)
		response = tcp.send_message(message,self.sock)
		print("Wrote Off")
def button(func, state):

	state = not state
	ret_word = ""
	ret_state = False

	conf.SIGNED_VALUES = True
	plc_ip = '192.168.10.35'
	port_id = 502
	sl_id = 0
	writing_value = 1

	# socket
	sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
	# 502 is the port  
	sock.connect((plc_ip, port_id))

	if (func == 0):
		message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
		response = tcp.send_message(message, sock)

		if (response[0]):
			message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
			response = tcp.send_message(message, sock)
			ret_word = "Failed to flush all"
			return ret_state,ret_word
		else:
			row_Entry_message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1)
			row_Entry_response = tcp.send_message(row_Entry_message, sock)
			row_Entry_state = row_Entry_response[0]
			if (row_Entry_state):
				message = tcp.write_single_coil(slave_id = 1, address = func, value = 1)
				response = tcp.send_message(message, sock)

				message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
				response = tcp.send_message(message, sock)
				if(response[0]):
					ret_word = "Flush all once"
					ret_state = True
					time.sleep(1)
					message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
					response = tcp.send_message(message, sock)
					return ret_state,ret_word
				else:
					ret_word = "Failed to flush all once"
					return ret_state,ret_word
			else:
				ret_word = "Harvester not on row_Entry state"
				return ret_state,ret_word

	elif (func == 1):

		# Make sure it is not shutdown
		message = tcp.read_holding_registers(slave_id=1, starting_address=0, quantity=1)
		response = tcp.send_message(message, sock)
		if(response[0]):
			# Make sure row_Out state is 0
			message = tcp.write_single_coil(slave_id = 1, address = 2, value = 0)
			response = tcp.send_message(message, sock)
			message = tcp.read_coils(slave_id = 1, starting_address = 2, quantity = 1)
			response = tcp.send_message(message, sock)

			if (not response[0]):
				# Make sure clean state is 0
				message = tcp.write_single_coil(slave_id = 1, address = 3, value = 0)
				response = tcp.send_message(message, sock)

				message = tcp.write_single_coil(slave_id = 1, address = func, value = 1)
				response = tcp.send_message(message, sock)
		
				message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
				response = tcp.send_message(message, sock)

				if(response[0]):
					ret_state = True
					ret_word = "Standby/row_entry on"
					return ret_state,ret_word
				else:
					ret_word = "Failed to standby"
					return ret_state,ret_word
		
		else:
			ret_word = "You are in shutdown mode"
			return ret_state, ret_word

	elif (func == 2):

		message = tcp.read_holding_registers(slave_id=1, starting_address=0, quantity=1)
		response = tcp.send_message(message, sock)
		if(response[0]):
			# Make sure row_Entry state is 0
			message = tcp.write_single_coil(slave_id = 1, address = 1, value = 0)
			response = tcp.send_message(message, sock)
			message = tcp.read_coils(slave_id = 1, starting_address = 2, quantity = 1)
			response = tcp.send_message(message, sock)
			if (not response[0]):
				message = tcp.write_single_coil(slave_id = 1, address = func, value = 1)
				response = tcp.send_message(message, sock)
				
				message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
				response = tcp.send_message(message, sock)
				if(response[0]):
					ret_state = True
					ret_word = "Navigation/Row_Out on"
					return ret_state,ret_word
				else:
					ret_word = "Failed to set Navigation/Row_Out mode"
					return ret_state,ret_word
		else:
			ret_word = "You are in shutdown mode"
			return ret_state, ret_word		

	elif (func == 3):
		message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
		response = tcp.send_message(message, sock)
		if (response[0]):
			message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
			response = tcp.send_message(message, sock)
		else:
			message = tcp.read_coils(slave_id = 1, starting_address = 2, quantity = 1)
			response = tcp.send_message(message, sock)
			if (response[0] != 1):
				ret_word = "row_Out is not on, make sure row_Out is on first"
				return ret_state,ret_word

			else:
				message = tcp.write_single_coil(slave_id = 1, address = func, value = 1)
				response = tcp.send_message(message, sock)

				message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
				response = tcp.send_message(message, sock)
				if(response[0]):
					ret_state = True
					ret_word = "clean on"
					return ret_state,ret_word
				else:
					ret_word = "failed to set clean on"
					return ret_state,ret_word
		
	elif (func == 4):
		message = tcp.write_single_register(slave_id = 1, address = 0, value = 16)
		response = tcp.send_message(message, sock)

		message = tcp.read_holding_registers(slave_id=1, starting_address=0, quantity=1)
		response = tcp.send_message(message, sock)

		if response[0] == 16:
			ret_word = "Startup"
			ret_state = True
			return ret_state,ret_word
		else:
			ret_word = "Unable to startup"
			return ret_state,ret_word

	elif (func == 5):
		message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1)
		response = tcp.send_message(message, sock)
		if response[0]:
			message = tcp.write_single_coil(slave_id=1, address=func,value=1)
			response = tcp.send_message(message,sock)
			time.sleep(1)
			message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
			response = tcp.send_message(message, sock)
			ret_word = "Trough 1 flush once"
			return ret_state,ret_word

		else:
			ret_word = "Not in Standby/Row_Entry state"
			return ret_state, ret_word

	elif (func == 6):
		message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1)
		response = tcp.send_message(message, sock)
		if response[0]:
			message = tcp.write_single_coil(slave_id=1, address=func,value=1)
			response = tcp.send_message(message,sock)
			time.sleep(1)
			message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
			response = tcp.send_message(message, sock)
			ret_word = "Trough 2 flush once"
			return ret_state,ret_word

		else:
			ret_word = "Not in Standby/Row_Entry state"
			return ret_state, ret_word

	elif (func == 7):
		message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1)
		response = tcp.send_message(message, sock)
		if response[0]:
			message = tcp.write_single_coil(slave_id=1, address=func,value=1)
			response = tcp.send_message(message,sock)
			time.sleep(1)
			message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
			response = tcp.send_message(message, sock)
			ret_word = "Trough 3 flush once"
			return ret_state,ret_word

		else:
			ret_word = "Not in Standby/Row_Entry state"
			return ret_state, ret_word

	elif (func == 8):
		message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1)
		response = tcp.send_message(message, sock)
		if response[0]:
			message = tcp.write_single_coil(slave_id=1, address=func,value=1)
			response = tcp.send_message(message,sock)
			time.sleep(1)
			message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
			response = tcp.send_message(message, sock)
			ret_word = "Trough 4 flush once"
			return ret_state,ret_word

		else:
			ret_word = "Not in Standby/Row_Entry state"
			return ret_state, ret_word

	elif (func == 9):
		message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1)
		response = tcp.send_message(message, sock)
		if response[0]:
			message = tcp.write_single_coil(slave_id=1, address=func,value=1)
			response = tcp.send_message(message,sock)
			time.sleep(1)
			message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
			response = tcp.send_message(message, sock)
			ret_word = "Trough 5 flush once"
			return ret_state,ret_word

		else:
			ret_word = "Not in Standby/Row_Entry state"
			return ret_state, ret_word

	if (func == 10):
		message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
		response = tcp.send_message(message, sock)

		if (response[0]):
			message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
			response = tcp.send_message(message, sock)
		else:
			row_Entry_message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1)
			row_Entry_response = tcp.send_message(row_Entry_message, sock)
			row_Entry_state = row_Entry_response[0]
			if (row_Entry_state):
				message = tcp.write_single_coil(slave_id = 1, address = func, value = 1)
				response = tcp.send_message(message, sock)

				message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
				response = tcp.send_message(message, sock)
				if(response[0]):
					ret_state = True
					ret_word = "Flush_with_delay once"
					time.sleep(1)
					message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
					response = tcp.send_message(message, sock)
					return ret_state,ret_word
				else:
					ret_word = "Failed to delay flush once"
					return ret_state,ret_word
			else:
				ret_word = "Harvester not on Standby/Row_Entry state"
				return ret_state,ret_word


	elif (func == -1):
		message = tcp.write_single_register(slave_id = 1, address = 0, value = 0)
		response = tcp.send_message(message, sock) 

		message = tcp.read_holding_registers(slave_id=1, starting_address=0, quantity=1)
		response = tcp.send_message(message, sock)
		if response[0] == 0:
			ret_state = True
			ret_word = "Close all"
			return ret_state,ret_word

	return ret_state,ret_word
	sock.close()
 def write_coil(self, address, value):
     with self.__lock:
         message = tcp.write_single_coil(slave_id=1,
                                         address=address - 1,
                                         value=value)
         self.__send_modbus_message(message)
Beispiel #7
0
def button(func, state):

	state = not state
	ret_word = ""
	ret_state = False

	conf.SIGNED_VALUES = True
	plc_ip = '192.168.10.35'
	port_id = 502
	sl_id = 0
	writing_value = 1

	# socket
	sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
	# 502 is the port  
	sock.connect((plc_ip, port_id))

	if (func == 0):
		message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
		response = tcp.send_message(message, sock)

		if (response[0]):
			message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
			response = tcp.send_message(message, sock)
			ret_word = "Failed to flush all"
			return ret_state,ret_word
		else:
			row_Entry_message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1)
			row_Entry_response = tcp.send_message(row_Entry_message, sock)
			row_Entry_state = row_Entry_response[0]
			if (row_Entry_state):
				message = tcp.write_single_coil(slave_id = 1, address = func, value = 1)
				response = tcp.send_message(message, sock)

				message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
				response = tcp.send_message(message, sock)
				if(response[0]):
					ret_word = "flush for 1 sec"
					ret_state = True
					time.sleep(1)
					message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
					response = tcp.send_message(message, sock)
					return ret_state,ret_word
				else:
					ret_word = "failed to set flush on"
					return ret_state,ret_word
			else:
				ret_word = "Harvester not on row_Entry state, make sure it is on row_Entry state first to flush"
				return ret_state,ret_word

	elif (func == 1):
		# Make sure row_Out state is 0
		message = tcp.write_single_coil(slave_id = 1, address = 2, value = 0)
		response = tcp.send_message(message, sock)

		# Make sure clean state is 0
		message = tcp.write_single_coil(slave_id = 1, address = 3, value = 0)
		response = tcp.send_message(message, sock)

		message = tcp.write_single_coil(slave_id = 1, address = func, value = 1)
		response = tcp.send_message(message, sock)
		
		message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
		response = tcp.send_message(message, sock)
		if(response[0]):
			ret_state = True
			ret_word = "row_Entry on"
			return ret_state,ret_word
		else:
			ret_word = "failed to set row_Entry on"
			return ret_state,ret_word

	elif (func == 2):
		# Make sure row_Entry state is 0
		message = tcp.write_single_coil(slave_id = 1, address = 1, value = 0)
		response = tcp.send_message(message, sock)

		#Make sure flush state is 0
		message = tcp.write_single_coil(slave_id = 1, address = 0, value = 0)
		response = tcp.send_message(message, sock)

		message = tcp.write_single_coil(slave_id = 1, address = func, value = 1)
		response = tcp.send_message(message, sock)
		
		message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
		response = tcp.send_message(message, sock)
		if(response[0]):
			ret_state = True
			ret_word = "row_Out on"
			return ret_state,ret_word
		else:
			ret_word = "failed to set row_Out on"
			return ret_state,ret_word

	elif (func == 3):
		message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
		response = tcp.send_message(message, sock)
		if (response[0]):
			message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
			response = tcp.send_message(message, sock)
		else:
			message = tcp.read_coils(slave_id = 1, starting_address = 2, quantity = 1)
			response = tcp.send_message(message, sock)
			if (response[0] != 1):
				ret_word = "row_Out is not on, make sure row_Out is on first"
				return ret_state,ret_word

			else:
				message = tcp.write_single_coil(slave_id = 1, address = func, value = 1)
				response = tcp.send_message(message, sock)

				message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
				response = tcp.send_message(message, sock)
				if(response[0]):
					ret_state = True
					ret_word = "clean on"
					return ret_state,ret_word
				else:
					ret_word = "failed to set clean on"
					return ret_state,ret_word
		
	elif (func == 4):
		message = tcp.write_single_register(slave_id = 1, address = 0, value = 16)
		response = tcp.send_message(message, sock)

	elif (func == 5):
		message = tcp.write_single_coil(slave_id=1, address=func,value=1)
		response = tcp.send_message(message,sock)
		time.sleep(1)
		message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
		response = tcp.send_message(message, sock)
		ret_word = "trough 1"
		return ret_state,ret_word

	elif (func == 6):
		message = tcp.write_single_coil(slave_id=1, address=func,value=1)
		response = tcp.send_message(message,sock)
		time.sleep(1)
		message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
		response = tcp.send_message(message, sock)
		ret_word = "trough 2"
		return ret_state,ret_word

	elif (func == 7):
		message = tcp.write_single_coil(slave_id=1, address=func,value=1)
		response = tcp.send_message(message,sock)
		time.sleep(1)
		message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
		response = tcp.send_message(message, sock)
		ret_word = "trough 3"
		return ret_state,ret_word

	elif (func == 8):
		message = tcp.write_single_coil(slave_id=1, address=func,value=1)
		response = tcp.send_message(message,sock)
		time.sleep(1)
		message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
		response = tcp.send_message(message, sock)
		ret_word = "trough 4"
		return ret_state,ret_word

	elif (func == 9):
		message = tcp.write_single_coil(slave_id=1, address=func,value=1)
		response = tcp.send_message(message,sock)
		time.sleep(1)
		message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
		response = tcp.send_message(message, sock)
		ret_word = "trough 5"
		return ret_state,ret_word

	if (func == 10):
		message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
		response = tcp.send_message(message, sock)

		if (response[0]):
			message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
			response = tcp.send_message(message, sock)
		else:
			row_Entry_message = tcp.read_coils(slave_id = 1, starting_address = 1, quantity = 1)
			row_Entry_response = tcp.send_message(row_Entry_message, sock)
			row_Entry_state = row_Entry_response[0]
			if (row_Entry_state):
				message = tcp.write_single_coil(slave_id = 1, address = func, value = 1)
				response = tcp.send_message(message, sock)

				message = tcp.read_coils(slave_id = 1, starting_address = func, quantity = 1)
				response = tcp.send_message(message, sock)
				if(response[0]):
					ret_state = True
					ret_word = "flush_with_delay on"
					time.sleep(1)
					message = tcp.write_single_coil(slave_id = 1, address = func, value = 0)
					response = tcp.send_message(message, sock)
					return ret_state,ret_word
				else:
					ret_word = "failed to set flush on"
					return ret_state,ret_word
			else:
				ret_word = "Harvester not on row_Entry state, make sure it is on row_Entry state first to flush"
				return ret_state,ret_word


	elif (func == -1):
		message = tcp.write_single_register(slave_id = 1, address = 0, value = 0)
		response = tcp.send_message(message, sock) 
		ret_state = True
		ret_word = "Close all"
		return ret_state,ret_word

	return ret_state,ret_word
	sock.close()
Beispiel #8
0
from umodbus.client import tcp
from time import sleep

SCADAIP = '192.168.0.12'

# Enable values to be signed (default is False).
conf.SIGNED_VALUES = True

# open connection
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((SCADAIP, 502))

#loop to blink light (range value is 2x the number of 'on' blinks
for loop in range(20):

    # start with 'on' command (1)
    # make sure range value is even if you want to end with light off
    onoff = 1 if (loop % 2 == 0) else 0

    # set message to write to coil (DO4)
    message = tcp.write_single_coil(slave_id=1, address=4, value=onoff)

    # send message
    response = tcp.send_message(message, sock)

    # wait 0.5 second before looping
    sleep(0.5)

#close connection
sock.close()
Beispiel #9
0
    def run(self):
        sock = socket.socket()
        sock.bind(("", 2017))
        sock.listen(1)
        try:  #fire socket
            while True:
                conn, addr = sock.accept()
                if addr[0] != self.server_address:
                    print('wrong server')
                    conn.send("connection error. wrong server".encode("utf-8"))
                    conn.close()
                    continue
                data = ''
                try:  #recive data
                    data = conn.recv(1024)
                except socket.error as e:  #recive data
                    answerMessage = '{} >> socket connection error {}'.format(
                        time.strftime('%H:%M:%S|%y.%m.%d', time.localtime()),
                        e.args[0])
                    logging.warning(answerMessage)
                else:  #recive data
                    if data == b'FIRE':  #data parse
                        print('FIRE')
                        global door_pin, player_pin, gpio_lock
                        gpio_lock.acquire()
                        try:  #anlock door
                            self.flag_link[0] = 1
                            pygame.mixer.music.stop()
                            GPIO.setmode(GPIO.BCM)
                            GPIO.setup((door_pin), GPIO.OUT)
                            self.previos_pin_stat = GPIO.input(door_pin)
                            GPIO.output((door_pin), GPIO.LOW)
                            sock_modbus = socket.socket(
                                socket.AF_INET, socket.SOCK_STREAM)
                            sock_modbus.connect(('10.11.13.104', 502))
                            str_message = tcp.write_single_coil(slave_id=1,
                                                                address=100,
                                                                value=4)
                            list_response = tcp.send_message(
                                str_message, sock_modbus)

                        except:  #anlock door
                            conn.send(
                                "Error while unblock doors".encode("utf-8"))
                            answerMessage = '{} >> Error while unblock doors'.format(
                                time.strftime('%H:%M:%S|%y.%m.%d',
                                              time.localtime()))
                            logging.warning(answerMessage)
                        else:  #anlock door
                            conn.send("Unblock doors".encode("utf-8"))
                            answerMessage = '{} >> Unblock door by fire alarm'.format(
                                time.strftime('%H:%M:%S|%y.%m.%d',
                                              time.localtime()))
                            logging.info(answerMessage)
                        finally:  #anlock door
                            gpio_lock.release()
                            sock_modbus.close()
                    elif data == b'ALLOW':  #data parse
                        print('ALLOW')
                        global door_pin, player_pin, gpio_lock
                        gpio_lock.acquire()
                        try:  #allow blocking
                            self.flag_link[0] = 0
                            GPIO.setmode(GPIO.BCM)
                            GPIO.setup((door_pin), GPIO.OUT)
                            GPIO.output((door_pin), self.previos_pin_stat)
                        except:  #allow blocking
                            conn.send("Error while unlock AC".encode("utf-8"))
                            answerMessage = '{} >> Error while unlock AC'.format(
                                time.strftime('%H:%M:%S|%y.%m.%d',
                                              time.localtime()))
                            logging.warning(answerMessage)
                        else:  #allow blocking
                            conn.send("Unlock AC".encode("utf-8"))
                            answerMessage = '{} >> Anlock AC after fire alarm'.format(
                                time.strftime('%H:%M:%S|%y.%m.%d',
                                              time.localtime()))
                            logging.info(answerMessage)
                        finally:  #allow blocking
                            gpio_lock.release()
                    else:  #data parse
                        conn.send("error: unknown command: ".encode("utf-8"),
                                  data)
                        answerMessage = '{} >> Error: unknown command: {}'.format(
                            time.strftime('%H:%M:%S|%y.%m.%d',
                                          time.localtime()),
                            data.decode("utf-8"))
                        logging.warning(answerMessage)
                finally:
                    conn.close()
        finally:  #fire socket
            sock.close()