def execute_func():
sensor_no = ModbusClient(host="192.40.50.107",
port=10010,
unit_id=1,
auto_open=True)
sensor_no.open()
regs = sensor_no.read_holding_registers(0, 100)
if regs:
print(regs)
else:
print("read error")
n = 0
data_count = 0
for n in range(50):
data_count = n * 2
regs[data_count], regs[data_count + 1] = regs[data_count +
1], regs[data_count]
dec_array = regs
data_bytes = np.array(dec_array, dtype=np.uint16)
data_as_float = data_bytes.view(dtype=np.float32)
time_data = datetime.datetime.now()
print(time_data)
start = 1
start_range = 50
value = [[num for num in range(start, start + start_range)],
[num for num in range(start, start + start_range)], data_as_float]
data = np.array(value).T.tolist()
# print(data)
products = data
arr = []
for product in products:
vals = {}
vals["Sensor No"] = str(int(product[1]))
vals["Temp"] = str(product[2])
vals["Time"] = str(time_data)
arr.append(vals)
myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["Modbus_Database"]
mycol = mydb["collection1"]
record_data = arr
mycol.insert_many(record_data)
global documents
documents = list(mycol.find({}, {'_id': 0}))
print(documents)
# myclient.drop_database('Modbus_Database')
mycol.delete_many({})
time.sleep(60)
async def async_setup(hass, config):
"""Set up the SolarEdge component."""
conf = config.get(DOMAIN)
_LOGGER.debug("creating modbus client begin")
host = conf[CONF_HOST]
port = conf["port"]
client = ModbusClient(host, port=port, unit_id=1, auto_open=True)
hass.data[DOMAIN] = client
_LOGGER.debug("creating modbus client done")
for component in ["sensor"]:
# BEGIN 15/12/2020-16/12/2020: new battery meter
# discovery.load_platform(hass, component, DOMAIN, {CONF_NAME: DOMAIN, CONF_SCAN_INTERVAL: conf[CONF_SCAN_INTERVAL], "read_meter1": conf["read_meter1"]}, config)
# discovery.load_platform(hass, component, DOMAIN, {CONF_NAME: DOMAIN, CONF_SCAN_INTERVAL: conf[CONF_SCAN_INTERVAL], "read_meter1": conf["read_meter1"], "read_meter2": conf["read_meter2"]}, config)
discovery.load_platform(
hass, component, DOMAIN, {
CONF_NAME: DOMAIN,
CONF_SCAN_INTERVAL: conf[CONF_SCAN_INTERVAL],
"read_meter1": conf["read_meter1"],
"read_meter2": conf["read_meter2"],
"read_battery": conf["read_battery"]
}, config)
# END 15/12/2020-16/12/2020
return True
def read(ip):
# Initialize modbus
c = ModbusClient(host=ip, port=502, auto_open=True, timeout=0.1)
# Read the outputs (Returns None if timeout)
return(c.read_coils(16, 6))
def __init__(self, c=ModbusClient(), com=""):
self.rwm = RWM.ReadWriteMethod(c)
self.COM = com
QtWidgets.QMainWindow.__init__(self)
Ui_SecondWindow.__init__(self)
self.setupUi(self)
self.setWindowIcon(QtGui.QIcon(path + os.sep + 'MeVb.png'))
self.lcd_volt.setDigitCount(5)
mainMenu = self.menuBar()
fileMenu = mainMenu.addMenu('File')
exitButton = QAction('Exit', self)
exitButton.setShortcut('Ctrl+Q')
exitButton.setStatusTip('Exit application')
exitButton.triggered.connect(self.close)
fileMenu.addAction(exitButton)
fileMenu = mainMenu.addMenu('Edit')
autoButton = QAction('Auto_Mode', self)
autoButton.setShortcut('Ctrl+A')
autoButton.setStatusTip('Auto application')
autoButton.triggered.connect(self.auto_mode)
fileMenu.addAction(autoButton)
self.lcd_volt.setMode(QLCDNumber.Dec)
self.lcd_volt.setStyleSheet(
"border: 2px solid black; color: red; background: silver;")
self.initUI()
def _read_config(self):
self._ip = self._config.get('modbus_server_ip')
self._port = self._config.get(
'modbus_port', ModbusTCPSensor.default_config['modbus_port'])
self._debug = self._config.get('debug', 0) == 1
self._sample_rate = self._config.get(
'sample_rate', ModbusTCPSensor.default_config['sample_rate'])
self._sensors = []
# Load Sensors
for sensor in self._config.get('sensors', []):
if 0 <= sensor['sensor_id'] < 32:
self._sensors.append(sensor)
# Load Validation bits
self._validation_bits = []
for validation_bit in self._config.get('bits', []):
if 0 <= validation_bit['validation_bit_id'] < 256:
self._validation_bits.append(validation_bit)
self._enabled = len(self._sensors) > 0
try:
from pyModbusTCP.client import ModbusClient
self._client = ModbusClient(self._ip,
self._port,
auto_open=True,
auto_close=True)
self._client.open()
self._enabled = self._enabled & True
except Exception as ex:
self.logger('Error connecting to Modbus server: {0}'.format(ex))
self.logger('ModbusTCPSensor is {0}'.format(
'enabled' if self._enabled else 'disabled'))
def VICTRON_modbus_power():
debug = debugVICTRON
Modbus_Device_IP = "192.168.1.190"
Modbus_Device_ID = "100"
Modbus_Device_Port = 502
modbus_read_address = 842
debug = False
value = 0.0
try:
c = ModbusClient(host=Modbus_Device_IP,
unit_id=Modbus_Device_ID,
port=Modbus_Device_Port,
debug=debug)
c.open()
collected = c.read_input_registers(modbus_read_address, 1)
value = utils.get_2comp(collected[0],
16) #utils.get_list_2comp to convert a list
c.close()
if debug:
print("Modbus IP=", Modbus_Device_IP, "Modbus ID=",
Modbus_Device_ID, "Modbus address=", modbus_read_address,
"Value=", value, "Collected=", collected)
except:
print("Could not read power from Victron modbus")
return value
def onStart():
Domoticz.Log("Domoticz SMA Inverter Modbus plugin start")
if 1 not in Devices:
Domoticz.Device(Name="Solar Yield", Unit=1, TypeName="kWh",
Used=0).Create()
if 2 not in Devices:
Domoticz.Device(Name="DC Power A", Unit=2, TypeName="Usage",
Used=0).Create()
if 3 not in Devices:
Domoticz.Device(Name="DC Power B", Unit=3, TypeName="Usage",
Used=0).Create()
if 4 not in Devices:
Domoticz.Device(Name="AC Power", Unit=4, TypeName="Usage",
Used=0).Create()
if 5 not in Devices:
Domoticz.Device(Name="Temperature",
Unit=5,
TypeName="Temperature",
Used=0).Create()
global client
client = ModbusClient(host=Parameters["Address"],
port=Parameters["Port"],
unit_id=Parameters["Mode1"])
client.open()
Domoticz.Heartbeat(int(Parameters["Mode2"]))
def doWrite(goToPos):
c = ModbusClient(host="192.168.1.1", auto_open=True, auto_close=True)
if c.write_single_register(1, goToPos):
print("write ok")
else:
print("write error")
def __init__(self):
self.__client = ModbusClient(host="192.168.1.200", port=502, auto_open=True)
self.__address = 0
self.__register = 2
self.__hex_str_list = []
self.__hex_data = []
self.float_list = []
def __init__(
self,
maxpower=3300,
addr_command=63245,
addr_time=63243,
addr_disPower=63248,
addr_chaPower=63246,
timeBatt=36000,
SERVER_HOST="192.168.0.51",
SERVER_PORT=502,
PWRNET_API_BASE_URL='http://pwrnet-158117.appspot.com/api/v1/'):
self.maxPower = maxpower
self.addr_command = addr_command
self.addr_time = addr_time
self.addr_disPower = addr_disPower
self.addr_chaPower = addr_chaPower
self.timeBatt = timeBatt # How long to (dis)charge [s]: uint32
self.SERVER_HOST = SERVER_HOST
self.SERVER_PORT = SERVER_PORT
self.tcpClient = ModbusClient(host=self.SERVER_HOST,
port=self.SERVER_PORT,
unit_id=247,
timeout=2,
auto_open=True)
self.PWRNET_API_BASE_URL = PWRNET_API_BASE_URL
self.logger = logging.getLogger(__name__)
self.logger.setLevel(logging.DEBUG)
self.handler = RotatingFileHandler('my_log.log',
maxBytes=2000,
backupCount=10)
self.logger.addHandler(self.handler)
self.logger.info('Storage class called')
def __init__(self, machine, name):
builder.SetDeviceName(name)
self.com = ModbusClient(host=machine, port=4000, auto_open=True) #4000
self.com.mode(constants.MODBUS_RTU)
stat = self.com.open()
self.pv_stat = builder.aIn("stat")
self.pv_stat.PREC = 1
self.pv_stat.LOPR = 0
self.pv_stat.HOPR = 100
self.pv_temp = builder.aIn("temp")
self.pv_temp.PREC = 1
self.pv_temp.LOPR = 0
self.pv_temp.HOPR = 100
self.pv_humi = builder.aIn("humidity")
self.pv_humi.PREC = 1
self.pv_humi.LOPR = 0
self.pv_humi.HOPR = 100
self.pv_humi.HSV = "MINOR"
self.pv_humi.HHSV = "MAJOR"
self.pv_humi.HIGH = 45
self.pv_humi.HIHI = 50
self.pv_flow = builder.aIn("flow")
self.pv_flow.PREC = 0
self.pv_flow.LOPR = 0
self.pv_flow.HOPR = 600
self.pv_flow.LOLO = 250
self.pv_flow.LOW = 300
self.pv_flow.HIGH = 480
self.pv_flow.HIHI = 520
self.pv_flow.LSV = "MINOR"
self.pv_flow.LLSV = "MAJOR"
self.pv_flow.HSV = "MINOR"
self.pv_flow.HHSV = "MAJOR"
self.stat_pv = builder.boolIn("status",
ZNAM="off",
ONAM="on",
DESC=name)
self.stat_pv.ZSV = "MAJOR"
self.pv_on = builder.boolOut("on",
ZNAM="0",
ONAM="1",
HIGH=0.1,
on_update=self.turnOn)
self.pv_off = builder.boolOut("off",
ZNAM="0",
ONAM="1",
HIGH=0.1,
on_update=self.turnOff)
self.busy = False
self.pv_act = builder.boolOut("activity", ZNAM="0", ONAM="1", HIGH=1)
self.pv_was_on = builder.boolOut("was_on",
ZNAM="0",
ONAM="1",
HIGH=1.5)
self.pv_was_off = builder.boolOut("was_off",
ZNAM="0",
ONAM="1",
HIGH=1.5)
self.id_temp = 0
self.id_stat = 1
def post(self, uid):
'''
POST to control module coil output states
(Make the blinkey lights go blinkey)
'''
# Parse the form data
parser = reqparse.RequestParser()
parser.add_argument("type")
parser.add_argument("output")
parser.add_argument("state")
parser.add_argument("ips", action='append')
args = parser.parse_args()
outputs = ['all_clear', 'emergency', 'lightning', 'a', 'b', 'c']
# Iterate over the outputs and send the state for each one
# True = On, False = Off
for idx, output in enumerate(outputs):
if output == args['output']:
for ip in args['ips']:
c = ModbusClient(host=ip,
port=502,
auto_open=True,
timeout=1)
coil = idx + 16
c.write_single_coil(coil, args['state'])
return (200)
def onStart(self):
Domoticz.Heartbeat(5)
if Parameters["Mode2"] == "Debug":
Domoticz.Debugging(1)
else:
Domoticz.Debugging(0)
# 从Domoticz重新加载硬件和设备信息
self.reloadFromDomoticz()
debug = False
if Parameters["Mode2"] == "Debug":
debug = True
if self.client and self.client.is_open():
self.client.close()
self.client = ModbusClient(host=Parameters["Address"],
port=Parameters["Port"],
auto_open=True,
auto_close=False,
timeout=1)
self.messageThread.start()
self.client.mode(2)
self.messageQueue.put({
"Type": "Log",
"Text": "Heartbeat test message"
})
def modbus_devices(register, value):
c = ModbusClient(host="164.8.11.147", port=502, auto_open=True)
# regs=c.read_holding_registers(33)
# print(regs)
regs = c.write_single_register(register, value)
regs1 = c.read_holding_registers(register)
print(regs1)
def __init__(self, *, queue=None, host='127.0.0.1', timeout=1):
"""
Set up client.
::host:: str - By default client runs on localhost.
::port:: int - Port 502 is constant for ModdbusTCP.
"""
self.queue = queue
self.host = host
self.port = 502
self.timeout = timeout
self.client = ModbusClient(host=self.host, port=self.port)
self.func_read_dict = {
'hr': self.client.read_holding_registers,
'c': self.client.read_coils,
'di': self.client.read_discrete_inputs,
'ir': self.client.read_input_registers,
}
self.func_write_dict = {
'hr': self.client.write_multiple_registers,
'c': self.client.write_multiple_coils,
}
self.registers_dict = {}
self.reg_current_value = {}
self.name_stack = []
def modbus_com(SERVER_HOST, SERVER_PORT, function_code, start_register,
amount_of_registers):
c = ModbusClient()
c.host(SERVER_HOST)
c.port(SERVER_PORT)
cnt = 0
while True:
# open or reconnect TCP to server
if not c.is_open():
if not c.open():
print("unable to connect to " + SERVER_HOST + ":" +
str(SERVER_PORT))
# if open() is ok, read register (modbus function 0x03)
if c.is_open():
if function_code == "3":
# Read the amount_of_registers from start_register
regs = c.read_holding_registers(int(start_register),
int(amount_of_registers))
# if success display registers
if regs:
print("reg address" + str(start_register) + "to" + str(
int(start_register) + int(amount_of_registers) - 1) +
":" + str(regs))
elif function_code == "16":
#Future support
pass
cnt += 1
if cnt >= 2:
print("クライアント通信終了")
c.close()
break
# sleep 1s before next polling
time.sleep(1)
def VICTRON_modbus(Modbus_Device_ID, Modbus_read_address, factor):
debug = debugVICTRON
Modbus_Device_IP = "192.168.1.190"
Modbus_Device_Port = 502
value = 0.0
collected = [0]
collected_array = [0]
collected_array.pop()
if debug:
print("Victron Modbus collecting from ID", Modbus_Device_ID,
"register", Modbus_read_address)
try:
c = ModbusClient(host=Modbus_Device_IP,
unit_id=Modbus_Device_ID,
port=Modbus_Device_Port,
debug=debug)
c.open()
collected = c.read_input_registers(Modbus_read_address, 1)
if debug: print("VICTRON collected from modbus=", collected)
value = collected[0]
value = value / factor
if debug:
print("Modbus IP=", Modbus_Device_IP, "Modbus ID=",
Modbus_Device_ID, "Modbus address=", Modbus_read_address,
"Value=", value)
c.close()
except:
print("could not read from SMA Modbus IP=", Modbus_Device_IP,
"Modbus ID=", Modbus_Device_ID, "Modbus address=",
Modbus_read_address)
return value
def test_unit_id(self):
# test valid/invalid cases for debug()
c = ModbusClient()
self.assertEqual(c.unit_id(), 1, 'default unit_id is 1')
self.assertEqual(c.unit_id(42), 42)
self.assertEqual(c.unit_id(0), 0)
self.assertEqual(c.unit_id(420), None)
def __init__(self, modbus_address):
self.areTopicsAlive = {}
faultTime = rospy.get_time()
#Initialise communication with ModbusClient
adam = ModbusClient(host="192.168.1.3",
port=502,
auto_open=True,
auto_close=False)
rospy.Subscriber("/1/failures", TopicState, self.callback)
rospy.Subscriber("/2/failures", TopicState, self.callback)
#While System has not been shutdown
while not rospy.is_shutdown():
#If for some reason the watchdogs or subscription fail tell PLCs
if len(self.areTopicsAlive.keys()) == 0:
adam.write_single_coil(int(modbus_address), False)
#If watch dogs are functioning
else:
#Check current state of every topic
for key in self.areTopicsAlive.keys():
#If there is a failure in one of the topics
if self.areTopicsAlive[key] == 0:
#Set pin to LOW
adam.write_single_coil(int(modbus_address), False)
faultTime = rospy.get_time()
rospy.logerr(
"System is not working. Topic %s has failed", key)
#If there has been no fault for 2 secs set pin back to HIGH
if rospy.get_time() - faultTime >= 2:
adam.write_single_coil(int(modbus_address), True)
sleep(0.2)
def Collect_Modbus(Collect_Array):
#todo: add try
try:
c = ModbusClient(host=Modbus_Device_IP,
unit_id=Modbus_Device_ID,
port=Modbus_Device_Port,
debug=False)
c.open()
for x in range(len(Collect_Array)):
collected_array = [0]
collected_array.pop()
collected = c.read_input_registers(Collect_Array[x][0],
Collect_Array[x][1])
collected_merged = struct.pack('>HH', collected[0], collected[1])
collected_array.append(struct.unpack('>i', collected_merged)[0])
#store_url format : (sensor, description, value, metric, timestamp)
if collected_array[0] < 100000 and collected_array[0] > -100000:
store_url("SMA", Collect_Array[x][3], collected_array,
Collect_Array[x][2], datetime.now())
print("SMA", Collect_Array[x][3], collected_array[0],
Collect_Array[x][2], datetime.now())
else:
store_url("SMA", Collect_Array[x][3], 0, Collect_Array[x][2],
datetime.now())
print("unrealistic value detected set value to 0")
c.close()
except:
print("Could not read from modbus")
def __init__(self):
ip = rospy.get_param("/robot_ip")
self.c = ModbusClient(host=ip,
auto_open=True,
auto_close=False,
port=502,
debug=False,
unit_id=2)
rospy.init_node("joint_pos_pub")
self.p = rospy.Publisher('/joint_states', JointState, queue_size=1)
name = getpass.getuser()
f = open(
'/home/%s/catkin_ws/src/delta/arm_driver/yaml/joint_limits.yaml' %
name, 'r')
d = yaml.load(f)
f.close()
self.dP = d["PUU_limits"]
self.dA = d["Angle_limits"]
self.joint_states = JointState()
self.joint_states.name = [
'shoulder', 'elbow', 'wrist1', 'wrist2', 'wrist3', 'wrist4'
]
def connect(self, ip=None):
"""
Verbinde dich mit einer Heliotherm Wärmepumpe (mit RCG2). Gib dazu die IP-Adresse/den Hostnamen an. Wenn die IP-Adresse schonmal konfiguriert wurde, lasse das Feld einfach leer.
"""
if ip != None and ip != '' and type(ip) is str:
self.IP_Adresse = ip
self.savePersistentVariable('IP_Adresse', self.IP_Adresse)
self.info('Connecting with {}'.format(self.IP_Adresse))
if not self._connected:
try:
self.setPerpetualTimer(self._readModbusRegisters, samplerate=self.samplerate)
self._c = ModbusClient(host=self.IP_Adresse, port=self.Port, auto_open=True, auto_close=True)
if self._c is None:
self.error('Could not connect with {}'.format(self.IP_Adresse))
self.status = 'Could not connect with {}'.format(self.IP_Adresse)
return False
self._c.timeout(10)
self.status = 'Trying to connect...'
self.start()
self._connected = True
return True
except Exception as e:
self.error('Could not connect with {}:\n{}'.format(self.IP_Adresse, e))
self.status = 'Could not connect with {}:\n{}'.format(self.IP_Adresse, e)
return False
else:
self.status = 'Already connected. Disconnect first'
return False
def modbus_request(self, progress_callback):
c = ModbusClient(host="localhost", auto_open=False)
connection_ok = c.open()
if connection_ok:
try:
self.holding_registers = c.read_holding_registers(0, 3)
print(self.holding_registers)
regs = [
int(10 * self.tcurrinsp.value()),
int(10 * self.tcurrexp.value()),
int(10 * self.currpress.value())
]
c.write_multiple_registers(3, regs)
print(regs)
c.close()
except:
print("modbus exception")
pass
else:
print("other")
pass
finally:
#print("passed")
pass
else:
print("could not open")
pass
def read_all_tags(self):
try:
c = ModbusClient(host="192.168.2.11", port=502, debug=False)
c.open()
for name, tag in self.tag_db.items():
mb0 = tag['modbus_start'] -1
mb1 = tag['modbus_stop'] -1
size = 1+mb1-mb0
#print(name, mb0, mb1, size)
#print(tag)
if 0 <= mb0 < 100000:
val = c.read_coils(mb0)[0]
elif 100000 <= mb0 < 200000:
val = c.read_discrete_inputs(mb0-100000)[0]
elif 300000 <= mb0 < 400000:
val = c.read_input_registers(mb0-300000, size)
if size == 1: val = val[0]
elif size == 2:
val = utils.word_list_to_long(val, big_endian=False)[0]
elif 400000 <= mb0 < 500000:
val = c.read_holding_registers(mb0-400000, size )
if size == 1: val = val[0]
elif size == 2:
val = utils.word_list_to_long(val, big_endian=False)[0]
if tag['dtype'] == 'float32':
val = utils.decode_ieee(val)
#print(name, val)
self.settings[name] = val
except Exception as err:
print("Error in read_all_tags", err)
c.close()
def __init__(self, address, port):
c = ModbusClient()
c.host(address)
c.port(port)
c.unit_id(1)
c.open()
data = c.read_holding_registers(130, 12)
self.data=data
c.close()
if data:
self.LowT1Start = format(data[0], 'x')
self.LowT1Stop = format(data[1], 'x')
self.LowT2Start = format(data[2], 'x')
self.LowT2Stop = format(data[3], 'x')
self.NormT1Start = format(data[4], 'x')
self.NormT1Stop = format(data[5], 'x')
self.NormT2Start = format(data[6], 'x')
self.NormT2Stop = format(data[7], 'x')
self.PeakT1Start = format(data[8], 'x')
self.PeakT1Stop = format(data[9], 'x')
self.PeakT2Start = format(data[10], 'x')
self.PeakT2Stop = format(data[11], 'x')
else:
print("Read Volt And Amper ERROR")
def baglan(self):
self.c = ModbusClient(host=self.host,
unit_id=1,
timeout=self.timeout,
auto_open=True,
auto_close=True,
port=self.port)
def __init__(self):
# self.host = input("请输入IP地址：")
# self.port = int(input("请输入端口号："))
# self.username = input("请输入用户名：")
# self.password = input("请输入密码：")
self.host = "192.168.1.30"
self.port = 2121
self.username = "******"
self.password = "******"
self.remote_path = "/data/mgrid/sampler/modbus_map.xml"
self.__file = "./modbus_map.xml"
self.__old_str = "&"
self.__new_str = "-"
self.equipid_list = []
self.sigid_list = []
self.reg_addr_list = []
self.name_list = []
self.__client = ModbusClient(host=self.host,
port=502,
debug=True,
auto_open=True)
self.__address = 0
self.__register = 50
self.i = 0
self.__conn = connect(host='localhost',
port=3306,
database="MOTTA_data",
user="******",
password="******",
charset="utf8")
self.__cur = self.__conn.cursor()
self.float_data = [] # 检测获取到的数据
def connect_to_UR():
global modbus_conn
modbus_conn = ModbusClient(host="192.168.153.136",
port=502,
auto_open=True)
# modbus_conn = ModbusClient(host="192.168.1.19", port=502, auto_open=True)
print("connected to UR modbus")
def __init__(self, host):
self.client = ModbusClient(host=host, auto_open=True, auto_close=False)
#self.client.debug(True)
logger.info("Connecting to %s", self.client.host())
status = self.check_status()
if status & 1<<15:
# Watchdog ellapsed, try to reset
logger.info("Resetting watchdog")
self.client.write_single_register(0x1121, 0xbecf)
self.client.write_single_register(0x1121, 0xaffe)
# Disable the watchdog, if enabled
watchdog_timeout = self.client.read_holding_registers(0x1120)[0]
if watchdog_timeout > 0:
logger.debug("Watchdog timeout: %d", watchdog_timeout)
logger.info("Disabling watchdog")
self.client.write_single_register(0x1120, 0)
(self.num_outputs, self.num_inputs) = self.client.read_holding_registers(0x1012, 2)
logger.info("Number of outputs: %d", self.num_outputs)
logger.info("Number of inputs: %d", self.num_inputs)
self.client.close()
# We use auto close for all subsequent calls after initialization
self.client.auto_close(True)
def routineLoop():
global ac, dados, off
for i in ip: #Entra na lista de ip's
for x in add[ip.index(i)]: #entra na lista de endereços
ac = ModbusClient(host=i, auto_open=True, unit_id=x)
readTemp = ac.read_input_registers(
0) #Leitura da temperatura lida pelo ac
dados = ac.read_holding_registers(2, 26)
if bool(readTemp
) == False: #Se o valor for falso pula para o próximo ac
break
if dados[0] == 0: off = 1
else: off = 0
resposta = connect(
off, int(readTemp[0]), str(i), str(x), str(dados[1]),
str(dados[3]),
str(dados[2])) #Envia os dados para API e recebe a resposta
resposta = json.loads(resposta)
print('Recebido: ' + str(resposta))
decisao = decision(dados, resposta)
d = datetime.now()
print(decisao + " | " + str(d.hour) + ":" + str(d.minute) + ":" +
str(d.second))
ac.close()
