class DoorAlarm(object):
def __init__(self):
self.config = None
self.p0 = machine.Pin(2, machine.Pin.OUT)
def load_config(self):
with open('cfg.json', 'r') as cfg:
self.config = ujson.load(cfg)
def connect_wifi(self):
ap_if = network.WLAN(network.AP_IF)
ap_if.active(False)
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
if sta_if.isconnected():
sta_if.disconnect()
sta_if.connect(self.config['ssid'], self.config['passwd'])
for _ in range(20):
time.sleep(1)
if sta_if.isconnected():
return
print('Unable to connect to AP: {}'.format(ssid))
sys.exit(1)
def mqtt_callback(self, topic, msg):
self.p0.value(not self.p0.value())
def mqtt_subscribe(self):
client_id = b'tom_' + ubinascii.hexlify(machine.unique_id())
self.mqtt = MQTTClient(client_id, self.config['host'],
port=int(self.config['port']))
self.mqtt.set_callback(self.mqtt_callback)
self.mqtt.connect()
self.mqtt.subscribe(self.config['topic'])
import time
from umqtt.robust import MQTTClient
def sub_cb(topic, msg):
print((topic, msg))
c = MQTTClient("umqtt_client", "localhost")
# Print diagnostic messages when retries/reconnects happens
c.DEBUG = True
c.set_callback(sub_cb)
# Connect to server, requesting not to clean session for this
# client. If there was no existing session (False return value
# from connect() method), we perform the initial setup of client
# session - subscribe to needed topics. Afterwards, these
# subscriptions will be stored server-side, and will be persistent,
# (as we use clean_session=False).
#
# There can be a problem when a session for a given client exists,
# but doesn't have subscriptions a particular application expects.
# In this case, a session needs to be cleaned first. See
# example_reset_session.py for an obvious way how to do that.
#
# In an actual application, it's up to its developer how to
# manage these issues. One extreme is to have external "provisioning"
# phase, where initial session setup, and any further management of
# a session, is done by external tools. This allows to save resources
# on a small embedded device. Another extreme is to have an application
# to perform auto-setup (e.g., clean session, then re-create session
# on each restart). This example shows mid-line between these 2
# logtime=time.localtime()
# log.write("{}.{}.{} {}:{}:{} - {}\n".format(logtime[2],logtime[1],logtime[0],logtime[3]+TZ,logtime[4],logtime[5],logentry))
# Configure MQTT
logentry = "Configuring MQTT."
logtime = time.localtime()
log.write("{}.{}.{} {}:{}:{} - {}\n".format(logtime[2], logtime[1], logtime[0],
logtime[3] + TZ, logtime[4],
logtime[5], logentry))
c = MQTTClient(client_id=mqtt_config['mqtt_client'],
server=mqtt_config['mqtt_broker'],
user=mqtt_config['mqtt_user'],
password=mqtt_config['mqtt_pwd'],
port=mqtt_config['mqtt_port'])
c.DEBUG = True
c.set_callback(sub_cb)
wdt.feed()
c.connect()
wdt.feed()
print(gw_config['gw_topic'] + '/' + gw_config['gw_id'])
# LoRaMQTTGateway is subscribed to topic gw_topic/gw_id and its subtopics
c.subscribe(gw_config['gw_topic'] + '/' + gw_config['gw_id'])
c.subscribe(gw_config['gw_topic'] + '/' + gw_config['gw_id'] + '/#')
print("MQTT broker {} connected!".format(mqtt_config['mqtt_broker']))
logentry = "MQTT broker {} connected!".format(mqtt_config['mqtt_broker'])
logtime = time.localtime()
log.write("{}.{}.{} {}:{}:{} - {}\n".format(logtime[2], logtime[1], logtime[0],
logtime[3] + TZ, logtime[4],
logtime[5], logentry))
topic = TOPIC_BASE + 'cmd/%d' % channel
print("Subscribing to topic %s, please wait 5 s" % topic)
time.sleep(0.5)
c.subscribe(topic)
print("Subscribe sent")
# switch the LED off, it is too bright!
neoPixel[0] = (red, green, blue)
neoPixel.write()
connectWifi(SSID, PASSWORD)
server = SERVER
print("Connecting to myDevices MQTT broker")
c = MQTTClient(CLIENT_ID, server, 0, username, password)
print("Registering callback")
c.set_callback(ledUpdate)
if not c.connect(clean_session=False):
print("New session being set up")
subscribeCayenne(2)
subscribeCayenne(3)
subscribeCayenne(4)
while True:
try:
print("Wait for mgs")
c.wait_msg()
except OSError:
pass
def send_state():
client = MQTTClient('state', SERVER)
client.connect()
client.set_callback(on_message)
client.publish(state, '2')
freeHeap = float(str(msg,'utf-8'))
print("free heap size = {} bytes".format(freeHeap))
randomNum = int.from_bytes(os.urandom(3), 'little')
myMqttClient = bytes("client"+str(randomNum), 'utf-8')
THINGSPEAK_URL = b"mqtt.thingspeak.com"
THINGSPEAK_USER_ID = b'ID_CANAL'
THINGSPEAK_MQTT_API_KEY = b'CHAVE_API_MQTT'
client = MQTTClient(client_id=myMqttClient,
server=THINGSPEAK_URL,
user=THINGSPEAK_USER_ID,
password=THINGSPEAK_MQTT_API_KEY,
ssl=False)
client.set_callback(cb)
try:
client.connect()
except Exception as e:
print('could not connect to MQTT server {}{}'.format(type(e).__name__, e))
sys.exit()
THINGSPEAK_CHANNEL_ID = b'ID_DO_CANAL'
THINGSPEAK_CHANNEL_WRITE_API_KEY = b'CHAVE_WRITE_DO_CANAL'
subscribeTopic = bytes("channels/{:s}/subscribe/fields/field1/{:s}".format(THINGSPEAK_CHANNEL_ID, THINGSPEAK_CHANNEL_READ_API_KEY), 'utf-8')
client.subscribe(subscribeTopic)
while True:
try:
client.wait_msg()
except KeyboardInterrupt:
# Define a namespace for all messages
MQTT_Topic_Status = 'JorgePe/Status'
MQTT_Topic_Motor = 'JorgePe/Motor'
# callback message to process any new message appearing at the subscribed
# topics
def getmessages(topic, msg):
if topic == MQTT_Topic_Status.encode():
brick.display.text(str(msg.decode()))
elif topic == MQTT_Topic_Motor.encode():
brick.display.text(str(msg.decode()))
motor.run_target(180, int(msg.decode()))
motor.reset_angle(0)
client = MQTTClient(MQTT_ClientID, MQTT_Broker)
client.connect()
client.publish(MQTT_Topic_Status, MQTT_ClientID + ' Started')
client.set_callback(getmessages)
client.subscribe(MQTT_Topic_Status)
client.subscribe(MQTT_Topic_Motor)
client.publish(MQTT_Topic_Status, MQTT_ClientID + ' Listening')
while True:
client.check_msg()
time.sleep(0.1)
iw.oled.show()
# Connect to MQTT broker
iw.oled.text("MQTT connecting",0,10)
iw.oled.show()
mqtt = MQTTClient("clientId-XXXXXXXXXXXXXXXXXXXXXXX","broker.mqttdashboard.com")
mqtt.connect()
iw.oled.text("MQTT connected",0,10)
iw.oled.show()
def sub_cb(topic,msg):
if topic == b"krujeen/data/temp":
iw.oled.fill(0)
iw.oled.text(msg,0,0)
iw.oled.show()
mqtt.set_callback(sub_cb)
mqtt.subscribe("krujeen/data/#")
# Config BLYNK
BLYNK_AUTH = 'XXXXXXXXXXXXXXXXXXXXXXX'
blynk = BlynkLib.Blynk(BLYNK_AUTH)
def on_connect():
print("connected")
blynk.on_connect(on_connect)
def on_disconnect():
print("disconnected")
blynk.on_disconnect(on_disconnect)
class MQTT:
def __init__(self, ssid, pswd):
self.WIFI_SSID = ssid
self.WIFI_PSWD = pswd
self.subLoopRunning = False
# create a random MQTT clientID
random_num = int.from_bytes(os.urandom(3), 'little')
self.mqtt_client_id = bytes('client_' + str(random_num), 'utf-8')
#email = [email protected] password db4password
self.ADAFRUIT_IO_URL = b'io.adafruit.com'
self.ADAFRUIT_USERNAME = b'db4g5'
self.ADAFRUIT_IO_KEY = Key()
self.connect()
def __del__(self):
self.subLoopRunning = False
def connect(self):
# turn off the WiFi Access Point
ap_if = network.WLAN(network.AP_IF)
ap_if.active(False)
# connect the device to the WiFi network
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.connect(self.WIFI_SSID, self.WIFI_PSWD)
attempt_count = 0
while not wifi.isconnected() and attempt_count < 20:
attempt_count += 1
time.sleep(1)
if attempt_count == 20:
print('could not connect to the WiFi network')
sys.exit()
self.client = MQTTClient(client_id=self.mqtt_client_id,
server=self.ADAFRUIT_IO_URL,
user=self.ADAFRUIT_USERNAME,
password=self.ADAFRUIT_IO_KEY,
ssl=False)
try:
self.client.connect()
except Exception as e:
print('could not connect to MQTT server {}{}'.format(
type(e).__name__, e))
sys.exit()
# used to publish new data to a certain topic
def publish(self, topic, value):
mqtt_feedname = bytes(
'{:s}/feeds/{:s}'.format(self.ADAFRUIT_USERNAME, topic), 'utf-8')
try:
self.client.publish(mqtt_feedname,
bytes(str(value), 'utf-8'),
qos=0)
except Exception:
self.connect()
# used to poll client subscriptions
def __sub_loop(self):
while self.subLoopRunning:
try:
self.client.check_msg()
time.sleep(2)
except Exception:
self.connect()
# run only once with custom function func(topic, msg)
def setCallback(self, cb):
self.client.set_callback(cb)
# add a subscription
def subscribe(self, topic):
mqtt_feedname = bytes(
'{:s}/feeds/{:s}'.format(self.ADAFRUIT_USERNAME, topic), 'utf-8')
self.client.subscribe(mqtt_feedname)
if self.subLoopRunning == False:
self.subLoopRunning = True
_thread.start_new_thread(self.__sub_loop, ())
certf = f.read()
print(certf)
with open(key, 'rb') as f:
keyf = f.read()
print(keyf)
with open(root, 'rb') as f:
rootf = f.read()
print(rootf)
time.sleep(1)
conn = MQTTClient(client_id=TOPIC,
server=HOST,
port=8883,
ssl=True,
ssl_params={
"cert": certf,
"key": keyf
})
conn.set_callback(cb)
conn.connect()
conn.subscribe(TOPIC)
msg = 'mensaje'
while True:
connection.publish(topic=TOPIC, msg=msg, qos=0)
sleep(2)
client.publish(b'SessionID', ca.sessionID)
except OSError as e:
restart_and_reconnect()
# Main Function
do_connect()
ca = CryptAes()
client = MQTTClient(client_id=client_id,
server=mqtt_server,
port=port,
user=username,
password=password)
client.set_callback(sub_cb)
client.connect()
client.subscribe(b'Sensor_Data')
print("Connected to MQTT Broker")
#hard_timer1.init(period=1000, mode=machine.Timer.PERIODIC, callback=hard_handleInterrupt1)
client.publish(b'SessionID', ca.sessionID)
print("published message")
ticks_1 = utime.ticks_ms()
while True:
new_message = client.check_msg()
time.sleep_us(1000)
if mail_flag == 1:
mail_flag = 0
result = ca.verify_hmac(json_message)
print('unknown command')
return
if payload['type'] == 'pinstatus':
send_pin_status()
elif payload['type'] == 'changepin':
if 'data' in payload and type(payload['data']) == dict:
pins_changed = 0
for pin in payload['data']:
if type(pin) == str and not str.isdigit(pin): continue
ipin = int(pin)
if ipin < len(digital_out_pins):
pin_val = int(payload['data'][pin])
machine.Pin(digital_out_pins[ipin],
machine.Pin.OUT).value(pin_val)
pins_changed += 1
if pins_changed: send_pin_status()
send_pin_status()
client.set_callback(on_mqtt_msg)
channel = '{}/{}'.format('/hydroots/server', machineid)
client.subscribe(channel)
print('subscribed', channel)
if __name__ == '__main__':
while True:
print('looping')
check_data_send()
client.check_msg()
time.sleep(1)
def onMessage_local(topic, msg):
m=loads(msg)
print(m)
config["config_sync"] = m["config_sync"]
config["time_interval"] = m["time_interval"]*60
config["local"] = m["local"]
config["cloud"] = m["cloud"]
config["buzzer"] = m["buzzer"]
config["msg_alert"] = m["msg_alert"]
config["powersave"] = m["powersave"]
config["auto_freq"] = m["auto_freq"]
config["max_freq"] = m["max_freq"]
mqtt_local.set_callback(onMessage_local)
mqtt_cloud.set_callback(onMessage_cloud)
try:
mqtt_local.subscribe("smartgiger",qos=0)
print("waiting for msg...")
led.color(500, 700)
mqtt_local.check_msg()
except:
print("local subscribe faild")
led.color(r=1023,g=0)
timer = ticks_ms()
async def geiger_count():