def create_app(config_object=DockerConfig):
global db
global mqtt
global api
global redis
global recognizer
global app
app = Flask(__name__)
app.config.from_object(config_object)
#print(app.config)
CORS(app)
# Init API
api = Api(app)
# Init MQTT
mqtt = Mqtt(app)
mqtt.subscribe('camera')
# Init DB
db = SQLAlchemy(app)
# Init Redis
redis = red.StrictRedis(host=app.config['REDIS_HOST'],
port=app.config['REDIS_PORT'],
db=1,
charset="utf-8",
decode_responses=True)
# Init Recognizer
from heimdall.recognition.Recognition import Recognizer
recognizer = Recognizer(
shape_predictor_path=app.config['DLIB_SHAPE_PREDICTOR_PATH'],
descriptor_model_path=app.config['DLIB_FACE_RECOGNITION_MODEL_PATH'])
from heimdall.recognition import RecognitionManager
RecognitionManager.init(app, db)
return app
class FlaskMQTTTestCase(unittest.TestCase):
def setUp(self):
self.app = Flask(__name__)
def test_simple_connect(self):
self.mqtt = Mqtt(self.app)
self.mqtt.disconnect()
def test_connect_with_username(self):
self.app.config['MQTT_USERNAME'] = '******'
self.app.config['MQTT_PASSWORD'] = '******'
self.mqtt = Mqtt(self.app)
self.mqtt.disconnect()
def test_subscribe(self):
self.mqtt = Mqtt(self.app)
self.mqtt.subscribe('test')
self.assertEqual('test', self.mqtt.topics[0])
self.assertEqual(1, len(self.mqtt.topics))
self.mqtt.subscribe('test')
self.assertEqual(1, len(self.mqtt.topics))
self.mqtt.unsubscribe('test')
self.assertEqual(0, len(self.mqtt.topics))
self.mqtt.unsubscribe('test')
self.mqtt.subscribe('test1')
self.mqtt.subscribe('test2')
self.assertEqual(2, len(self.mqtt.topics))
self.mqtt.unsubscribe_all()
self.assertEqual(0, len(self.mqtt.topics))
self.mqtt.disconnect()
def test_publish(self):
self.mqtt = Mqtt(self.app)
@self.mqtt.on_message()
def handle_message(client, userdata, message):
print(message)
@self.mqtt.on_topic('test')
def handle_on_topic(*args, **kwargs):
pass
self.mqtt.subscribe('test')
self.mqtt.publish('test', 'hello world')
time.sleep(2)
app.config['SECRET'] = 'my secret key'
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.config['MQTT_BROKER_URL'] = 'big.forcebing.top'
app.config['MQTT_BROKER_PORT'] = 1883
app.config['MQTT_USERNAME'] = ''
app.config['MQTT_PASSWORD'] = ''
app.config['MQTT_KEEPALIVE'] = 60
app.config['MQTT_TLS_ENABLED'] = False
app.config['MQTT_LAST_WILL_TOPIC'] = '/last/will'
app.config['MQTT_LAST_WILL_MESSAGE'] = 'bye'
app.config['MQTT_LAST_WILL_QOS'] = 2
mqtt_ws = Mqtt(app)
socketio = SocketIO(app, cors_allowed_origins="*")
# 只有我们提前写了订阅的消息，才会收到消息
mqtt_ws.subscribe('test')
@app.route('/')
def index():
return 'hello world '
@app.route('/ws')
def wevsocket():
return render_template('websocket_mqtt_demo.html')
@socketio.on('publish', namespace='/test')
def handle_publish(json_str):
# data = json.loads(json_str)
from project import app
from project import db
from project.models import InpData
from datetime import datetime
from flask_mqtt import Mqtt
mqtt = Mqtt(app)
inputs = InpData.query.all()
for inp in inputs:
mqtt.subscribe(inp.topic)
@mqtt.on_message()
def handle_mqtt_message(client, userdata, message):
inp = InpData.query.filter_by(topic=message.topic).first()
if inp is not None:
if message.payload[0] == 0x47 and message.payload[
1] == 0x82: # secret cod
if message.payload[2] == 0x00 and message.payload[
3] == 0x01: # protocol version
head_length = 4
ob = inp.parent_object
discr_count = ob.discr_count
analog_count = ob.analog_count
message_count = ob.message_count
top_data = list()
for i in range(discr_count):
byte_num = i // 8
bit_num = i % 8
if message.payload[byte_num +
from pymongo import MongoClient
import datetime
app = Flask(__name__)
client = MongoClient(
'mongodb://*****:*****@ds133166.mlab.com:33166/pyiot-stackup')
db = client['pyiot-stackup']
app = Flask(__name__)
app.config['MQTT_BROKER_URL'] = 'm12.cloudmqtt.com'
app.config['MQTT_BROKER_PORT'] = 13743
app.config['MQTT_USERNAME'] = '******'
app.config['MQTT_PASSWORD'] = '******'
app.config['MQTT_REFRESH_TIME'] = 1.0 # refresh time in seconds
mqtt = Mqtt(app)
mqtt.subscribe('room/temp')
@mqtt.on_message()
def handle_mqtt_message(client, userdata, message):
data = dict(topic=message.topic, payload=message.payload.decode())
print(data['topic'])
print(data['payload'])
tempValue = {
"value": data['payload'],
"modified-date": datetime.datetime.utcnow()
}
temp = db.temperature
temperValue_id = temp.insert_one(tempValue).inserted_id
app.config['MQTT_BROKER_PORT'] = 1883 # default port for non-tls connection
app.config[
'MQTT_USERNAME'] = '' # set the username here if you need authentication for the broker
app.config[
'MQTT_PASSWORD'] = '' # set the password here if the broker demands authentication
app.config[
'MQTT_KEEPALIVE'] = 5 # set the time interval for sending a ping to the broker to 5 seconds
app.config[
'MQTT_TLS_ENABLED'] = False # set TLS to disabled for testing purposes
time.sleep(2)
mqtt = Mqtt(app)
if (mqtt):
print("[*] MQTT Connected OK!")
mqtt.subscribe('application/11/device/+/rx')
print("[*] MQTT Suscribed to application/11/device/+/rx OK!\n\n")
socketio = SocketIO(app, cors_allowed_origins="*")
#! MQTT Callback Function. When a new message arrives, this
#! data is stored in the database table (public.dustbinData)
@mqtt.on_message()
def handle_mqtt_message(client, userdata, message):
dict_data = json.loads(message.payload)
print(dict_data)
device_eui = str(dict_data['devEUI'])
device_name = str(dict_data['deviceName'])
json_sensor_data = json.dumps(dict_data['object'], indent=4)
mqtt = Mqtt(app)
socketio = SocketIO(app)
NUMBER_CONNEXIONS = 0
PI = {
"sensor":
"pi",
"locations": [
"A532", "A533", "A503", "A507", "A406", "A432", "A433", "A434", "A400",
"A401", "A402", "A403", "A404"
],
"durations": ["5minutes", "hour", "day"]
}
mqtt.subscribe("hepia/pi/meanByLocation/5minutes")
mqtt.subscribe("hepia/pi/meanByLocation/hour")
mqtt.subscribe("hepia/pi/meanByLocation/day")
TI = {
"sensor": "ti",
"locations": ["CC2650"],
"durations": ["5minutes", "hour", "day"]
}
mqtt.subscribe("hepia/ti/values/5minutes")
mqtt.subscribe("hepia/ti/values/hour")
mqtt.subscribe("hepia/ti/values/day")
SENSORS = [PI, TI]
def handle_unsubscribe_all():
mqtt.unsubscribe_all()
@mqtt.on_message()
def handle_mqtt_message(client, userdata, message):
data = dict(
topic=message.topic,
payload=message.payload.decode(),
qos=message.qos,
)
socketio.emit('mqtt_message', data=data)
@mqtt.on_log()
def handle_logging(client, userdata, level, buf):
# print(level, buf)
pass
mqtt.subscribe(topic='stat/smartSurgeOutlet1/POWER')
mqtt.subscribe(topic='stat/smartSurgeOutlet2/POWER')
mqtt.subscribe(topic='stat/smartSurgeOutlet3/POWER')
mqtt.subscribe(topic='stat/smartSurgeOutlet4/POWER')
mqtt.subscribe(topic='stat/columnLED/POWER')
mqtt.subscribe(topic='stat/treeLED/POWER')
if __name__ == '__main__':
socketio.run(app, host='0.0.0.0', port=5000, use_reloader=True, debug=True)
# app.config['MQTT_TLS_INSECURE'] = True
# app.config['MQTT_TLS_CA_CERTS'] = 'ca.crt'
# Parameters for SSL enabled
# app.config['MQTT_BROKER_PORT'] = 8883
# app.config['MQTT_TLS_ENABLED'] = True
# app.config['MQTT_TLS_INSECURE'] = True
# app.config['MQTT_TLS_CA_CERTS'] = 'ca.crt'
mqtt = Mqtt(app)
socketio = SocketIO(app)
bootstrap = Bootstrap(app)
all_data = []
mqtt.subscribe(topic)
@app.route('/api/mqtt/1')
#For now, api v1 returns a huge json with all
#+/devices/+/up topic messages
def index():
all_data_parsed = [{
**d, 'payload': json.loads(d['payload'])
} for d in all_data]
print(all_data_parsed)
return jsonify(all_data_parsed)
#return render_template('index.html')
####### MQTT settings #######
hostName = "192.168.4.1"
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.config['MQTT_BROKER_URL'] = hostName
app.config['MQTT_BROKER_PORT'] = 1883
app.config['MQTT_USERNAME'] = ''
app.config['MQTT_PASSWORD'] = ''
app.config['MQTT_KEEPALIVE'] = 5
app.config['MQTT_TLS_ENABLED'] = False
#Connect to mosquitto broker
mqtt = Mqtt(app)
# Subscribe to sensors topics
mqtt.subscribe("record")
mqtt.subscribe("IMU_data")
mqtt.subscribe("RazorIMU_data")
mqtt.subscribe("CAN_data")
mqtt.subscribe("LoadCell_data")
# Emit over websocket the sensors data. This function fires every time
# a new message is published on a topic.
@mqtt.on_message()
def handle_mqtt_message(client, userdata, message):
msg = json.loads(message.payload)
msg = json.dumps(msg)
websocketio.emit(message.topic,msg, namespace='/sensors')
####### WEB SOCKETS #######
if message.topic == 'Radar/Connections' and m == 'GO':
print('This is working!')
def on_disconnect(client, userdata, flags, rc=0):
m = client.name + "DisConnected flags" + "result code " + str(rc)
print(m)
client.connected_flag = False
connection = {client.name: client.connected_flag}
ConManager.conman.cond.update(connection)
def on_log(client, userdata, level, buf):
print("log: ", buf)
connection_status_topic = mq_connections[:-2] + '/' + mq_client_name
print('Publishing to', connection_status_topic)
mqtt_client.subscribe(mq_connections)
print('Mqtt client Connected to', mq_connections)
mqtt_client.subscribe(mq_expdict)
mqtt_client.subscribe(mq_status)
mqtt_client.subscribe(mq_gpsdos)
temp = {
mq_client_name: {
mq_client_name: {
"name": mq_client_name,
"connection": True,
"ip": "192.168.100"
}
}
}
mqtt_client.publish(connection_status_topic, str(temp), 0, True)
qos=message.qos,
)
print(data['topic'] + ": " + data['payload'])
device = data['topic'].split('/')[1]
command = data['topic'].split('/')[3]
if device in address:
dev_address = address[device]
if (command == "temp"):
temp = data['payload']
logger.info("Change wanted temperature on " + device + ": ", temp)
set_temperature(dev_address, temp)
if (command == "mode"):
mode = data['payload']
logger.info("Change mode on " + device + ": ", mode)
set_mode(dev_address, mode)
else:
logger.error("Unknown device address: " + device)
#@mqtt.on_log()
#def handle_logging(client, userdata, level, buf):
# print(level, buf)
if __name__ == '__main__':
mqtt.subscribe(HR20_TEMP_TOPIC, 2)
mqtt.subscribe(HR20_MODE_TOPIC, 2)
socketio.run(app, host='0.0.0.0', port=5000)
class MqttClient:
def __init__(self):
self.mqtt = Mqtt()
self.mqttclient_pub_topic_list = []
self.mqttclient_sub_topic_list = []
self.recv_msg_buffer = RingBuf(15)
self.is_mqtt_client_connected = False
def add_publish_topic(self, topic):
# check for duplicate topics
for item in self.mqttclient_pub_topic_list:
if topic in item:
return False
# add topic to the list
new_item = (topic, topic)
self.mqttclient_pub_topic_list.append(new_item)
return True
def add_subscription_topic(self, topic):
# check for duplicate topics
for item in self.mqttclient_sub_topic_list:
if topic in item:
return False
# add topic to the list
new_item = (topic, topic)
self.mqttclient_sub_topic_list.append(new_item)
# Subscribe this topic
self.mqtt.subscribe(topic)
return True
def rm_publish_topic(self, topic):
# check for duplicate topics
for item in self.mqttclient_pub_topic_list:
if topic in item:
# add topic to the list
self.mqttclient_pub_topic_list.remove(item)
return True
return False
def rm_subscription_topic(self, topic):
# check for duplicate topics
for item in self.mqttclient_sub_topic_list:
if topic in item:
# add topic to the list
self.mqttclient_sub_topic_list.remove(item)
# unsubscribe this topic
self.mqtt.unsubscribe(topic)
return True
return False
def get_status(self):
return self.is_mqtt_client_connected
def on_message_send(self, topic, message, qos):
if topic != "" and message != "":
[result, b] = self.mqtt.publish(topic, message, int(qos))
if result == MQTT_ERR_SUCCESS:
return True
return False
def on_message_receive(self, topic, data):
message = topic + " : " + data
self.recv_msg_buffer.append(message)
print("added")
def update(self):
if self.recv_msg_buffer.item_list:
output = ""
for item in self.recv_msg_buffer.item_list:
output = output + item + "\n"
return output
return None
'https://southern-iot-box.firebaseio.com')
app = Flask(__name__)
#auto reloading
app.config['SECRET_KEY'] = '39380a3952f0ae125a699fd873560c51'
bcrypt = Bcrypt(app)
login_manager = LoginManager(app)
login_manager.init_app(app)
login_manager.login_view = 'login'
login_manager.login_message_category = 'red lighten-2'
from flask_mqtt import Mqtt
app.config['MQTT_BROKER_URL'] = 'localhost' # use the free broker from HIVEMQ
app.config['MQTT_BROKER_PORT'] = 1883 # default port for non-tls connection
app.config[
'MQTT_USERNAME'] = '' # set the username here if you need authentication for the broker
app.config[
'MQTT_PASSWORD'] = '' # set the password here if the broker demands authentication
app.config[
'MQTT_KEEPALIVE'] = 5 # set the time interval for sending a ping to the broker to 5 seconds
app.config[
'MQTT_TLS_ENABLED'] = False # set TLS to disabled for testing purposes
mqtt = Mqtt(app)
mqtt.subscribe('open_box')
mqtt.subscribe('is_reserved')
mqtt.subscribe('is_free')
mqtt.subscribe('is_opened')
mqtt.subscribe('is_closed')
from app import routes
}
firebase2 = pyrebase.initialize_app(config)
db = firebase2.database()
app = Flask(__name__)
app.config['MQTT_BROKER_URL'] = 'mqtt.bartrug.me'
app.config['MQTT_BROKER_PORT'] = 1883
app.config['MQTT_KEEPALIVE'] = 5
app.config['MQTT_TLS_ENABLED'] = False
mqtt = Mqtt(app)
fs = open("sensors.txt")
sensors = fs.read()
for i in sensors.split('\n'):
mqtt.subscribe('/devices/' + i + '/events')
print(i)
print("subscribed")
@mqtt.on_message()
def handle_mqtt_message(client, userdata, message):
data = dict(topic=message.topic, payload=message.payload.decode())
astring = data['topic']
bstring = astring.split('/')
eventId = uuid.uuid4()
from pytz import timezone
tz = timezone('EST')
date = datetime.datetime.now().strftime("%B%d%Y")
event_date = re.split('(\d+)', date)
time = datetime.datetime.now(tz).strftime("%I:%M%p")
@app.after_request
def add_header(r):
r.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
r.headers["Pragma"] = "no-cache"
r.headers["Expires"] = "0"
r.headers['Cache-Control'] = 'public, max-age=0'
return r
# MQTT on message
@mqtt.on_message()
def handle_mqtt_message(client, userdata, message):
logging.info("handle_mqtt_message called")
logging.info("from topic: %s", message.topic)
# emit a mqtt_message event to the socket containing the message data
socketio.emit('mqtt_message', data=message.payload.decode())
if __name__ == '__main__':
# Subscribe to the "/detect" topic
mqtt.subscribe(MQTT_TOPIC_DETECT)
# important: Do not use reloader because this will create two Flask instances.
# Flask-MQTT only supports running with one instance
socketio.run(app,
host=FLASK_BIND_ADDRESS,
port=FLASK_BIND_PORT,
use_reloader=False,
debug=False)
from flask import Flask
from flask import render_template, request
from flask_mqtt import Mqtt
import sqlite3, json, datetime
app = Flask(__name__)
app.config['SECRET'] = 'my secret key'
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.config['MQTT_BROKER_URL'] = '127.0.0.1'
app.config['MQTT_BROKER_PORT'] = 1883
app.config['MQTT_USERNAME'] = ''
app.config['MQTT_PASSWORD'] = ''
app.config['MQTT_KEEPALIVE'] = 5
app.config['MQTT_TLS_ENABLED'] = False
mqtt = Mqtt(app)
mqtt.subscribe('garden/#')
UI_IP = '127.0.0.1'
UI_PORT = 8180
UI_BASE_URL = 'http://garden.stobi.local/'
IGNORE_PORTS = True
last_read_values = {
'air_temperature': 0,
'air_humidity': 0,
'light': 0,
'soil_moisture': 0,
'watering_sys_stat': 'unknow'
}
DB_FILE = "garden-ui.sqlite"
@socketio.on('publish')
def handle_publish(json_str):
data = json.loads(json_str)
#mqtt.publish(data['topic'], data['message'])
@socketio.on('subscribe')
def handle_subscribe(json_str):
data = json.loads(json_str)
#mqtt.subscribe(data['topic'])
@mqtt.on_message()
def handle_mqtt_message(client, userdata, message):
data = dict(topic=message.topic, payload=message.payload.decode())
print('Server 2: Received message', data['payload'], 'from topic: ',
data['topic'])
socketio.emit('mqtt_message', data=data)
@mqtt.on_log()
def handle_logging(client, userdata, level, buf):
print(level, buf)
if __name__ == '__main__':
#print('Server 2: subscribing to rmpbpp')
#socketio.emit('subscribe', None)
mqtt.subscribe('channel01')
socketio.run(app, host='0.0.0.0', port=5001, use_reloader=True, debug=True)
app.config['MQTT_BROKER_URL'] = '192.168.1.133'
app.config['MQTT_BROKER_PORT'] = 1883
app.config['MQTT_USERNAME'] = ''
app.config['MQTT_PASSWORD'] = ''
app.config['MQTT_KEEPALIVE'] = 5
app.config['MQTT_TLS_ENABLED'] = False
# Parameters for SSL enabled
# app.config['MQTT_BROKER_PORT'] = 8883
# app.config['MQTT_TLS_ENABLED'] = True
# app.config['MQTT_TLS_INSECURE'] = True
# app.config['MQTT_TLS_CA_CERTS'] = 'ca.crt'
mqtt = Mqtt(app)
socketio = SocketIO(app)
mqtt.subscribe('machine_park/machine_1')
mqtt.subscribe('machine_park/machine_1/temp')
@app.route('/')
def index():
return render_template('index.html')
@app.route('/quicksimulation')
def quick_simulation():
return render_template('quick_simulation.html')
@app.route('/realtimesimulation')
def real_time_simulation():
]
api.register(name='alertflag', url='/alertf/')
class AlertFlagView(ResourceView):
resource = AlertFlagResource
methods = [
methods.Create, methods.Update, methods.Fetch, methods.List,
methods.Delete
]
#-------------------------------------------MQTT Methods Handler---------------------------------------------------------
mqtt.subscribe("System/Sensors/#")
@mqtt.on_connect()
def handle_connect(client, userdata, flags, rc):
print('on_connect client : {} userdata :{} flags :{} rc:{}'.format(
client, userdata, flags, rc))
@mqtt.on_disconnect()
def handle_disconnect(client, userdata, rc):
print('on_disconnect client : {} userdata :{} rc :{}'.format(
client, userdata, rc))
@mqtt.on_subscribe()
is_authenticated = check_password_hash(self.pw_hash, password)
@staticmethod
def get_id():
return id
def __repr__(self):
return '<User %r>' % self.username
# Create Test Users
admin = User(username='******', password='******')
db.session.add(admin)
# MQTT Subscriptions (Temporary, try to remove at earliest possibility)
mqtt.subscribe('nodemcu/temp')
mqtt.subscribe('nodemcu/doorlock/pub')
# PIN Device variable (Temporary, try to remove at earliest possibility)
security_pin = 1232
# Home Page
@app.route("/")
def my_home():
return render_template("index.html")
# Login Page
@app.route("/login/", methods=['GET', 'POST'])
def my_login():
@socketio.on('unsubscribe_all')
def handle_unsubscribe_all():
mqtt.unsubscribe_all()
@mqtt.on_message()
def handle_mqtt_message(client, userdata, message):
data = dict(
topic=message.topic,
payload=message.payload.decode(),
qos=message.qos,
)
socketio.emit('mqtt_message', data=data)
@mqtt.on_log()
def handle_logging(client, userdata, level, buf):
# print(level, buf)
pass
mqtt.subscribe(topic='stat/smartSurgeOutlet1/POWER')
mqtt.subscribe(topic='stat/smartSurgeOutlet2/POWER')
mqtt.subscribe(topic='stat/smartSurgeOutlet3/POWER')
mqtt.subscribe(topic='stat/smartSurgeOutlet4/POWER')
if __name__ == '__main__':
socketio.run(app, host='0.0.0.0', port=5000, use_reloader=True, debug=True)
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.config['MQTT_BROKER_URL'] = 'test.mosquitto.org'
app.config['MQTT_BROKER_PORT'] = 1883
app.config['MQTT_USERNAME'] = ''
app.config['MQTT_PASSWORD'] = ''
app.config['MQTT_KEEPALIVE'] = 5
app.config['MQTT_TLS_ENABLED'] = False
mqtt = Mqtt(app)
db = Database()
socketio = SocketIO(app,
cors_allowed_origins="*",
engineio_logger=True,
logger=True)
CORS(app, resources={r"/*": {"origins": "*"}})
mqtt.subscribe('iGarden/values')
# Parameters for SSL enabled
# app.config['MQTT_BROKER_PORT'] = 8883
# app.config['MQTT_TLS_ENABLED'] = True
# app.config['MQTT_TLS_INSECURE'] = True
# app.config['MQTT_TLS_CA_CERTS'] = 'ca.crt'
state = {"humidity": 0, "temperature": 0, "humid": True, "lightness": 0}
@app.route('/state')
def get_state():
print(state)
return jsonify(state)
id = db.Column(db.Integer, unique=True, nullable=False, primary_key=True)
temperature = db.Column(db.Float)
humidity = db.Column(db.Float)
datetime = db.Column(db.String,
default=str(
time.strftime("%A, %d. %B %Y %I:%M:%S %p")))
def __repr__(self):
return "<Record: id={0}, temp={1}, hum= {2}, datetime={3}".format(
self.id, self.temperature, self.humidity, self.datetime)
# _________________________________________________________
mqtt.subscribe('HumidityTemp')
@app.route('/')
def index():
return render_template('index.html')
@socketio.on('client_connected')
def handle_client_connect(json):
print("client connected received: {0}".format(str(json)))
@socketio.on('publishTemp')
def handle_publish_temperature_and_humidity():
humidity, temperature = Adafruit_DHT.read_retry(11, 4)
def mqtt_latest():
data = data_from_mq
return render_template("index.html", data=data)
@mqtt.on_message()
def handle_mqtt_message(client, userdata, message):
data_from_mq = message.payload.decode()
data_dict = json.loads(data_from_mq)
payload_for_influx = '{}/api/v2/write?org={}&bucket={}&precision=s'.format(
influx_cloud_url, org, bucket)
header = "--headers Authorization: Token {}".format(influx_cloud_token)
data = '--data-raw mem,host=host1 temperature={} {}'.format(
data_dict['temperature'], 83)
requests.post(payload_for_influx + header + data)
print(data_dict)
@mqtt.on_log()
def handle_logging(client, userdata, level, buf):
print(level, buf)
if __name__ == '__main__':
mqtt.subscribe("/topic/bettair")
socketio.run(app,
host='0.0.0.0',
port=5000,
use_reloader=False,
debug=True)
app.config['TEMPLATES_AUTO_RELOAD'] = True
#app.config['MQTT_BROKER_URL'] = 'broker.hivemq.com'
app.config['MQTT_BROKER_URL'] = 'test.mosquitto.org'
#app.config['MQTT_BROKER_PORT'] = 1883 # default port for non-tls connection
#app.config['MQTT_USERNAME'] = '' # set the username here if you need authentication for the broker
#app.config['MQTT_PASSWORD'] = '' # set the password here if the broker demands authentication
#app.config['MQTT_KEEPALIVE'] = 5 # set the time interval for sending a ping to the broker to 5 seconds
#app.config['MQTT_TLS_ENABLED'] = False # set TLS to disabled for testing purposes
mqtt = Mqtt(app)
TOPIC_IN = 'upcu/profile/in'
TOPIC_OUT = 'upcu/profile/out'
mqtt.subscribe(TOPIC_IN)
#mqtt.subscribe(TOPIC_OUT)
@mqtt.on_message()
def handle_mqtt_message(client, userdata, message):
data = dict(topic=message.topic, payload=message.payload.decode())
print(data)
payload = json.loads(data['payload'])
action = get_action_from_request(payload)
#print("PAYLOAD: " + str(payload))
print("ACTION: " + action)
if action == 'get':
class FlaskMQTTTestCase(unittest.TestCase):
def setUp(self):
self.app = Flask(__name__)
def test_simple_connect(self):
self.mqtt = Mqtt(self.app)
self.mqtt._disconnect()
def test_connect_with_username(self):
self.app.config['MQTT_USERNAME'] = '******'
self.app.config['MQTT_PASSWORD'] = '******'
self.mqtt = Mqtt(self.app)
self.mqtt._disconnect()
def test_subscribe(self):
self.mqtt = Mqtt(self.app)
self.subscribe_handled = False
self.unsubscribe_handled = False
@self.mqtt.on_subscribe()
def handle_subscribe(client, userdata, mid_, granted_qos):
self.subscribe_handled = True
@self.mqtt.on_unsubscribe()
def handle_unsubscribe(client, userdata, mid_):
self.unsubscribe_handled = True
ret, mid = self.mqtt.subscribe('home/test')
self.assertEqual(ret, MQTT_ERR_SUCCESS)
wait()
ret, mid = self.mqtt.unsubscribe('home/test')
self.assertEqual(ret, MQTT_ERR_SUCCESS)
wait()
self.assertTrue(self.subscribe_handled)
self.assertTrue(self.unsubscribe_handled)
def test_topic_count(self):
self.mqtt = Mqtt(self.app)
ret, mid = self.mqtt.subscribe('test')
self.assertEqual(1, len(self.mqtt.topics))
ret, mid = self.mqtt.subscribe('test')
self.assertEqual(1, len(self.mqtt.topics))
self.mqtt.unsubscribe('test')
self.assertEqual(0, len(self.mqtt.topics))
self.mqtt.unsubscribe('test')
self.assertEqual(0, len(self.mqtt.topics))
ret, mid = self.mqtt.subscribe('test1')
ret, mid = self.mqtt.subscribe('test2')
self.assertEqual(2, len(self.mqtt.topics))
self.mqtt.unsubscribe_all()
self.assertEqual(0, len(self.mqtt.topics))
self.mqtt._disconnect()
def test_publish(self):
self.mqtt = Mqtt(self.app)
self.handled_message = False
self.handled_topic = False
self.handled_publish = False
@self.mqtt.on_message()
def handle_message(client, userdata, message):
self.handled_message = True
@self.mqtt.on_publish()
def handle_publish(client, userdata, mid):
self.handled_publish = True
self.mqtt.subscribe('home/test')
wait()
self.mqtt.publish('home/test', 'hello world')
wait()
self.assertTrue(self.handled_message)
# self.assertTrue(self.handled_topic)
self.assertTrue(self.handled_publish)
def test_on_topic(self):
self.mqtt = Mqtt(self.app)
self.handled_message = False
self.handled_topic = False
@self.mqtt.on_message()
def handle_message(client, userdata, message):
self.handled_message = True
@self.mqtt.on_topic('home/test')
def handle_on_topic(*args, **kwargs):
self.handled_topic = True
self.mqtt.subscribe('home/test')
wait()
self.mqtt.publish('home/test', 'hello world')
wait()
self.assertFalse(self.handled_message)
self.assertTrue(self.handled_topic)
def test_logging(self):
self.mqtt = Mqtt(self.app)
@self.mqtt.on_log()
def handle_logging(client, userdata, level, buf):
self.assertIsNotNone(client)
self.assertIsNotNone(level)
self.assertIsNotNone(buf)
self.mqtt.publish('test', 'hello world')
mqtt.subscribe('heating/2/on')
mqtt.subscribe('heating/2/off')
mqtt.subscribe('heating/2/setTemperature')
def subscribe_fan():
mqtt.subscribe('fan/3/setFanSpeed')
mqtt.subscribe('fan/3/off')
mqtt.subscribe('fan/3/increaseSpeed')
mqtt.subscribe('fan/3/decreaseSpeed')
def subscribe_tv():
mqtt.subscribe('tv/4/on')
mqtt.subscribe('tv/4/off')
#-----------------------------------------------------------------------------------------------------------------------
# subscribe to all available topics of ontology
mqtt.subscribe('light/1/on')
mqtt.subscribe('light/1/off')
mqtt.subscribe('heating/2/on')
mqtt.subscribe('heating/2/off')
mqtt.subscribe('heating/2/setTemperature')
mqtt.subscribe('fan/3/setFanSpeed')
mqtt.subscribe('fan/3/off')
mqtt.subscribe('fan/3/increaseSpeed')
mqtt.subscribe('fan/3/decreaseSpeed')
mqtt.subscribe('tv/4/on')
mqtt.subscribe('tv/4/off')
# @mqtt.on_log()
# def handle_logging(client, userdata, level, buf):
# deserializo el json a mi esquema
json_deseria = schema.loads(json_data, partial=True)
# lo parseo a un obj de mi modelo
obj_json = json_deseria.data
# traigo un sensor
sensor = Sensor.query.get(1)
# cambio el valor del sensor por el valor que me llegó del json
sensor.valor = obj_json.valor
# commiteo los cambios
db.session.commit()
# llamo a la función que le actualiza los datos a los clientes
handle_selectAll()
""" Mqtt Listeners """
mqtt.subscribe("/test") # Sub a /test
@mqtt.on_message()
def handle_mqtt_message(client, userdata, message):
data = dict(topic=message.topic,
payload=message.payload.decode("utf-8", "ignore"))
try:
json_str = data["payload"]
except Exception as e:
print(e)
else:
schema = SensorSchema()
json_deserialized = schema.loads(json_str, many=True, partial=True)
@socketio.on('connect', namespace='/position')
def handle_connect():
clients.append(request.sid)
print("New client connected")
@socketio.on('disconnect', namespace='/position')
def handle_disconnect():
clients.remove(request.sid)
print('Client disconnected')
@mqtt.on_message()
def handle_mqtt_message(client, userdata, message):
if message.topic == 'position':
try:
result = position_handler(message.payload)
except ValueError:
result = None
if result:
floorplan.update_pos((result['pos'], result['theta']))
socketio.emit('json', dumps(result), namespace='/position')
if __name__ == '__main__':
logger.log(logging.INFO, "Connecting to MQTT broker at {}:{}".format(
app.config['MQTT_BROKER_URL'],app.config['MQTT_BROKER_PORT']))
mqtt.init_app(app)
mqtt.subscribe('position')
socketio.run(app, host='0.0.0.0', log_output=True)
