def connect(self):
while 1:
config.np = nyamuk.Nyamuk(
(config.client_pub + str(random.randint(1000, 10000))),
server=config.server)
config.ns = nyamuk.Nyamuk(
(config.client_sub + str(random.randint(1000, 10000))),
server=config.server)
rs = config.ns.connect()
rp = config.np.connect()
if (rs != NC.ERR_SUCCESS) or (rp != NC.ERR_SUCCESS):
print "Can't connect"
time.sleep(30)
else:
print "Connection successful"
return
def start_nyamuk(server = 'localhost', port = 1883, client_id = None, topic = None, username = None,
password = None, version = 3, **kwargs):
ny = nyamuk.Nyamuk(client_id, username, password, server=server, port=port)
rc = ny.connect(version=version)
if rc != NC.ERR_SUCCESS:
print "Connection failed : can't connect to the broker"
sys.exit(-1)
# queued after CONNECT
rc = ny.subscribe(topic, kwargs.get('qos',0))
while rc == NC.ERR_SUCCESS:
rc = ny.loop()
if rc == NC.ERR_CONN_LOST:
ny.logger.fatal("Connection to server closed"); break
ev = ny.pop_event()
if ev is None:
continue
if ev.type == NC.CMD_CONNACK:
handle_connack(ev)
elif ev.type == NC.CMD_PUBLISH:
handle_publish(ev, ny)
elif ev.type == NC.CMD_SUBACK:
handle_suback(ev, ny)
elif ev.type == NC.CMD_PUBREL:
handle_pubrel(ev, ny)
elif ev.type == event.EV_NET_ERR:
print "Network Error. Msg = ", ev.msg
sys.exit(-1)
ny.logger.info("subscriber exited")
def start_nyamuk(server, client_id, topic, username = None, password = None):
ny = nyamuk.Nyamuk(client_id, username, password, server)
rc = ny.connect()
if rc != NC.ERR_SUCCESS:
print "Can't connect"
sys.exit(-1)
rc = ny.subscribe(topic, 0)
while rc == NC.ERR_SUCCESS:
ev = ny.pop_event()
if ev != None:
if ev.type == NC.CMD_CONNACK:
handle_connack(ev)
elif ev.type == NC.CMD_PUBLISH:
handle_publish(ev)
elif ev.type == NC.CMD_SUBACK:
handle_suback(ev)
elif ev.type == EV_NET_ERR:
print "Network Error. Msg = ", ev.msg
sys.exit(-1)
rc = ny.loop()
if rc == NC.ERR_CONN_LOST:
ny.logger.fatal("Connection to server closed")
ny.logger.info("subscriber exited")
def __init__(self,
client_id="testsuite:{seq}",
connect=False,
raw_connect=False,
**kwargs):
loglevel = logging.DEBUG
logfile = None
DEBUG = os.environ.get('DEBUG', '0')
if DEBUG == '0':
loglevel = logging.WARNING
elif DEBUG != '1':
logfile = DEBUG
clean_session = kwargs.pop('clean_session', 1)
self._connack = None
read_connack = kwargs.pop('read_connack', True)
server = 'localhost'
self.client_id = client_id.format(zero=zero_generator.next(),
seq=seq_generator.next(),
rand=rand_generator.next())
#print "clientid=", self.client_id
self._c = nyamuk.Nyamuk(self.client_id,
server=server,
log_level=loglevel,
log_file=logfile,
**kwargs)
# MQTT connection
#
# connect takes protocol version (3 or 4) or is True (set version to 3)
if connect is not False:
version = connect if isinstance(connect, int) else 3
self._c.connect(version=version, clean_session=clean_session)
if read_connack:
self._connack = self.recv()
return
# open TCP connection
#
port = 1883
if raw_connect:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect((server, port))
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
sock.setblocking(1)
#sock.settimeout(.5)
except Exception as e:
raise e
self._c.sock = sock
def db_connect(self):
while 1:
MQTT.database = nyamuk.Nyamuk((MQTT.client_dblib + str(random.randint(1000, 10000))), None, None, MQTT.server)
rdb = MQTT.database.connect()
if (rdb != NC.ERR_SUCCESS):
logger.error('Cant connect to subscribe')
print "Can't connect"
time.sleep(30)
else:
logger.info("Connection successful for subscription")
print "Connection successful"
return
def start_nyamuk(server='localhost',
port=1883,
client_id=None,
topic=None,
msg=None,
username=None,
password=None,
version=3,
**kwargs):
ny = nyamuk.Nyamuk(client_id, username, password, server=server, port=port)
rc = ny.connect(version=version)
if rc != NC.ERR_SUCCESS:
print "Connection failed : can't connect to the broker"
sys.exit(-1)
qos = kwargs.get('qos', 0)
while rc == NC.ERR_SUCCESS:
rc = ny.loop()
if rc == NC.ERR_CONN_LOST:
ny.logger.fatal("Connection to server closed")
break
ev = ny.pop_event()
if ev is None:
continue
if ev.type == NC.CMD_CONNACK:
ret_code = handle_connack(ev)
if ret_code == NC.CONNECT_ACCEPTED:
print "publishing payload"
ny.publish(topic, msg, qos=qos)
if qos == 0:
break
# QoS = 1
elif ev.type == NC.CMD_PUBACK:
handle_puback(ev, ny)
break
# QoS = 2
elif ev.type == NC.CMD_PUBREC:
if not handle_pubrec(ev, ny):
break
elif ev.type == NC.CMD_PUBCOMP:
handle_pubcomp(ev, ny)
break
ny.disconnect()
def start_nyamuk(server, client_id, topic, payload):
ny = nyamuk.Nyamuk(client_id, server=server)
rc = ny.connect()
if rc != NC.ERR_SUCCESS:
print "Can't connect"
sys.exit(-1)
index = 0
while rc == NC.ERR_SUCCESS:
ev = ny.pop_event()
if ev != None:
if ev.type == NC.CMD_CONNACK:
ret_code = handle_connack(ev)
if ret_code == NC.CONNECT_ACCEPTED:
print "publishing payload"
ny.publish(topic, payload)
rc = ny.loop()
def connect():
while 1:
MQTT.threed_pub = nyamuk.Nyamuk((MQTT.client_3bpub + str(random.randint(1000, 10000)), None, None, MQTT.server)
rcpub = MQTT.threed_pub.connect()
if (rcpub != NC.ERR_SUCCESS):
print "Can't connect"
time.sleep(30)
else:
print "Publish Connection successful"
return
def start_nyamuk(server, client_id, topic, username = None, password = None):
connect()
while 1:
threed = nyamuk.Nyamuk(client_id, username, password, server)
rc = threed.connect()
if rc != NC.ERR_SUCCESS:
print "Can't connect"
sys.exit(-1)
rc = threed.subscribe(topic, 0)
while rc == NC.ERR_SUCCESS:
ev = threed.pop_event()
if ev != None:
if ev.type == NC.CMD_PUBLISH:
handle_payload(ev)
elif ev.type == 1000:
print "Network Error. Msg = ", ev.msg
break
rc = threed.loop()
if rc == NC.ERR_CONN_LOST:
threed.logger.info("subscriber reconnecting in 30sec")
time.sleep(30)
break
if __name__ == '__main__':
start_nyamuk(MQTT.server, (MQTT.client_3d + str(random.randint(1000, 10000)), MQTT.topic_temp)
def start_nyamuk(server, topic, name, username, password):
ny = nyamuk.Nyamuk(name, logging.DEBUG)
ny.on_message = on_message
ny.on_connect = on_connect
ny.on_subscribe = on_subscribe
ny.keep_alive = 10
the_topic = topic
#rc = ny.connect(server, username = "******", password = "******")
#rc = ny.connect(server)
rc = ny.connect(server, username=username, password=make_sha(password))
if rc != NC.ERR_SUCCESS:
print "Can't connect"
sys.exit(-1)
index = 0
while rc == NC.ERR_SUCCESS:
rc = ny.loop()
index += 1
if index == 3:
rc = ny.subscribe(topic, 0)
def start_nyamuk(server, client_id, topic, username=None, password=None):
while 1:
ts = nyamuk.Nyamuk(client_id, username, password, server)
rc = ts.connect()
if rc != NC.ERR_SUCCESS:
print "Can't connect"
sys.exit(-1)
rc = ts.subscribe(topic, 0)
while rc == NC.ERR_SUCCESS:
ev = ts.pop_event()
if ev != None:
if ev.type == NC.CMD_PUBLISH:
handle_payload(ev)
elif ev.type == 1000:
print "Network Error. Msg = ", ev.msg
break
rc = ts.loop()
if rc == NC.ERR_CONN_LOST:
ts.logger.info("subscriber reconnecting in 30sec")
time.sleep(30)
break
print "Waiting: Card Removal"
time.sleep(interval)
def get_time():
""" Returns a string with the time and date """
return time.strftime("%a, %d %b %Y %H:%M:%S + 0000", time.gmtime())
ny_server = "test.mosquitto.org"
ny_client = "RFID-Reader"
ny_topic = "/nyamuk/test"
# Open the card reader
card = open_reader()
card_info = card.info('cardselect v0.1m')
# Connect to the MQTT Server
ny = nyamuk.Nyamuk(ny_client, server = ny_server)
print "Connecting..."
rc = ny.connect()
# Check for a successfull connection
if rc != NC.ERR_SUCCESS:
print "Can't connect"
sys.exit(-1)
print "Connected!"
# Main loop
while 1:
card_id = listen(card, 0.1)
listen_remove(card, 0.1, card_id)
Handle signal received
"""
swap_manager.stop()
sys.exit(0)
if __name__ == '__main__':
MQTT.pi_id = sys.argv[1]
settings = os.path.join(os.path.dirname(sys.argv[0]), "config",
"settings.xml")
# Catch possible SIGINT signals
signal.signal(signal.SIGINT, signal_handler)
# if no sigint
MQTT.ny = nyamuk.Nyamuk((MQTT.client + str(random.randint(1000, 10000))),
server=MQTT.server)
rc = MQTT.ny.connect()
if rc != NC.ERR_SUCCESS:
print "Can't connect"
sys.exit(-1)
# index = 0
print "Connected to MQTT"
try:
# SWAP manager
swap_manager = SwapManager(settings)
except SwapException as ex:
sys.exit(1)
ex.display()
ex.log()
signal.pause()
def registerValueChanged(self, register):
"""
Register value changed
@param register: register object having changed
**********************
not sure what this does, think it returns the temperature
"""
# Skip config registers
if register.isConfig():
return
if self._print_swap == True:
print "Register addr= " + str(register.getAddress()) + " id=" + str(register.id) + " changed to " + register.value.toAsciiHex()
status = []
# For every endpoint contained in this register
for endp in register.parameters:
strval = endp.getValueInAscii()
if endp.valueChanged:
if self._print_swap:
if endp.unit is not None:
strval += " " + endp.unit.name
print endp.name + " in address " + str(endp.getRegAddress()) + " changed to " + strval
if endp.display:
endp_data = endp.dumps()
if endp_data is not None:
status.append(endp_data)
if len(status) > 0:
# publish data onto the server LIB/level4/climate_raw
data = json.dumps(status)
L = len(data)
data = data[1:L-1]
# print data
# if (endp.name == "Temperature" || endp.name == "Voltage"):
print "updating list"
logger.info('Connecting and subscribing to the mote filtering database')
self.db_connect()
database_data = self.db_subscribe()
database_data = str(database_data)
try:
pilist = json.loads(database_data)
pis = pilist["pi"]
for i in pis:
if str(i['id']) == MQTT.pi_id:
motes = i['mote']
for j in motes:
if str(j['id']) == str(endp.id):
MQTT.ny = nyamuk.Nyamuk(MQTT.client, server = MQTT.server)
MQTT.rc = MQTT.ny.connect()
if(MQTT.ny.publish(MQTT.topic_temp, data, retain = True) == 0,):
logger.info('Published data')
print "published = " + data
else:
logger.error('Failed to publish data')
print "publish failed"
MQTT.ny.loop()
except ValueError:
print "Error"
logger.error('Error reading json string')