def run(self, topic, message=None, qos=0, retain=False):
        if self._username:
            self._auth_payload = {
                'username': self._username,
                'password': self._password,
            }

        if self._ssl:
            if not self._ssl_cacert:
                raise ValueError('Missing "ssl_cacert" config option')

            if not self._ssl_cert:
                raise ValueError('Missing "ssl_cert" config option')

            if not self._ssl_key:
                raise ValueError('Missing "ssl_key" config option')

            self._ssl_payload = {
                'ca_certs': self._ssl_cacert,
                'certfile': self._ssl_cert,
                'keyfile': self._ssl_key,
            }

        publish.single(topic, payload=message, qos=qos, retain=retain,
                       hostname=self._hostname, port=self._port,
                       client_id=self._client_id, keepalive=60,
                       auth=self._auth_payload, tls=self._ssl_payload,
                       protocol=self._protocol)

def checkEvent(onlyEv=False):
	if debug:
		print("[checkEvent]")
	global link_map
	#warte auf mouseup
	try:
		for ev in p.event.get(6):
			#hole coords
			pos = ev.pos
			
			if onlyEv:
				return True
		
			#vergleiche mit linkmap
			for ln in link_map:
			#fuehle ersten treffer aus
				if ln["pos1"][0] <= pos[0] and ln["pos2"][0] >= pos[0] and ln["pos1"][1] <= pos[1] and ln["pos2"][1] >= pos[1]:
					if debug:
						print(pos)
						print(ln)
						#exit()

					if "exec" in ln.keys():
						call('bin/'+ln["exec"])
						
					if "screen" in ln.keys():
						updateScreen(ln["screen"])
						
					if "mqttt" in ln.keys():
						mospub.single(ln["mqttt"], payload=ln["mqttp"], hostname=c.mSERVER)
					#verwerfe rest
					return True
	except:
		pass
	return False

 def publish(self, msg):
     try:
         publish.single(
             topic=self.topic, payload=msg, hostname=self.host, auth=self.auth, tls=self.tls, port=self.port
         )
     except Exception, ex:
         print ex

def sendND():
	try:
		while(True):
			publish.single("testbed/nodeDiscover/command/", 'START', hostname=BROKER_NAME)
			time.sleep(30)
	except:
		print "Publish ND command failed. Trying again in 30 seconds..."

def contingency_plan(contingency):
	global nodeList
	print "in contingency_plan"
	print nodeList
	# For each mac address (appliance)


	for i in nodeList:
		if contingency < 0:
			if nodeList[i] < abs(contingency):
				# Disable everything in the appliance
				countp1 = i.split(',')[1] # get A=X
				countp2 = countp1.split('=')[1] # get X
				j = 0
				while j < int(countp2):
					publish.single("testbed/gateway/mqtt/" + i.split(',')[0], 'AO' + str(j) + '=0', hostname=BROKER_NAME)
					print 'AO' + str(j)
					j = j + 1
					time.sleep(1)
					# Need to wait due to limitation of the arduino

		if contingency > 0:
			if nodeList[i] < abs(contingency):
				# Disable everything in the appliance
				countp1 = i.split(',')[1] # get A=X
				countp2 = countp1.split('=')[1] # get X
				j = 0
				while j < int(countp2):
					publish.single("testbed/gateway/mqtt/" + i.split(',')[0], 'AO' + str(j) + '=1', hostname=BROKER_NAME)
					print 'AO' + str(j)
					j = j + 1
					time.sleep(1)

def publish_msg(args):
    print 'publish >>> topic:', args.topic, 'payload:', args.payload
    if args.username and args.password:
        auth = {'username':args.username, 'password':args.password}
    else:
        auth = None
    publish.single(args.topic, args.payload, hostname=args.host, port=args.port, auth=auth)

    def publish_single(self, topic, payload=None, qos=0, retain=False,
            hostname="localhost", port=1883, client_id="", keepalive=60,
            will=None, auth=None, tls=None, protocol=mqtt.MQTTv31):

        """ Publish a single message and disconnect. This keyword uses the
        [http://eclipse.org/paho/clients/python/docs/#single|single]
        function of publish module.
        `topic` topic to which the message will be published
        `payload` message payload to publish (default None)
        `qos` qos of the message (default 0)
        `retain` retain flag (True or False, default False)
        `hostname` MQTT broker host (default localhost)
        `port` broker port (default 1883)
        `client_id` if not specified, a random id is generated
        `keepalive` keepalive timeout value for client
        `will` a dict containing will parameters for client:
            will = {'topic': "<topic>", 'payload':"<payload">, 'qos':<qos>,
                'retain':<retain>}
        `auth` a dict containing authentication parameters for the client:
            auth = {'username':"<username>", 'password':"<password>"}
        `tls` a dict containing TLS configuration parameters for the client:
            dict = {'ca_certs':"<ca_certs>", 'certfile':"<certfile>",
                'keyfile':"<keyfile>", 'tls_version':"<tls_version>",
                'ciphers':"<ciphers">}
        `protocol` MQTT protocol version (MQTTv31 or MQTTv311)
        Example:
        Publish a message on specified topic and disconnect:
        | Publish Single | topic=t/mqtt | payload=test | hostname=127.0.0.1 |
        """
        logger.info('Publishing to: %s:%s, topic: %s, payload: %s, qos: %s' %
                    (hostname, port, topic, payload, qos))
        publish.single(topic, payload, qos, retain, hostname, port,
                        client_id, keepalive, will, auth, tls, protocol)

def sales_forecast():
    #forecast
    s = requests.Session()
    r = s.get("https://login.salesforce.com/?un={}&pw={}".format(sf_id, sf_pw))

    #forecast
    r = s.get("https://na3.salesforce.com/00O50000003OCM5?view=d&snip&export=1&enc=UTF-8&xf=csv")
    
    content = r.content.decode('UTF-8')
    sf_data = csv.reader(StringIO(content))

    sf_data = [row for row in sf_data if len(row)>10]
    if not sf_data:
        return
    sf_data.pop(0)

    forecast = sum(map(float, [row[11] for row in sf_data]))
    forecast = "${:,d}".format(round(forecast))
    print("forecast =", forecast)

    #closed
    closed = sum(map(float, [row[10] for row in sf_data]))
    closed = "${:,d}".format(round(closed))
    print("closed =", closed)

    data = {"header":"Forecast", "text":["forecast: {}".format(forecast), "closed: {}".format(closed)], "pos":5} #expects a list
    mqtt_publish.single('esp_tft', json.dumps(data), hostname=aws_host, retain=False, port=1883, keepalive=60)

def main(args):
    
    if args.https:
        conn = http.client.HTTPSConnection("data.jkoolcloud.com", timeout=10)
        conn.connect()
        
        msg = "<access-request><token>" + args.https + "</token></access-request>"
        headers = {"Content-Type": "text/plain"}
        conn.request("POST", "", msg, headers)
        response = conn.getresponse()
        data = response.read()
        
        headers = {"Content-Type":"application/json"}
        msg = {"operation":"tnt4py", "type":"EVENT", "msg-text":args.msg}
        msg = json.dumps(msg)
        conn.request("POST", "", msg, headers)
        response = conn.getresponse()
        data = response.read()
        print(response.status, response.reason)
        conn.close()
        
    if args.mqtt:
        topic = "tnt4py"
        if args.topic:
            topic = args.topic
        publish.single(topic, args.msg, hostname=args.mqtt[0], auth={"username":args.mqtt[1], "password":args.mqtt[2]})  

def iterateNodes(xbee, runningNodes, uniqueDict):
    # while True:
    print "in iterator nodes"
    for key in runningNodes:
        # InfoIdConv just sets the info_id as the destination address
        status = None
        t = 9999
        #defaults to temperature sensor

        try:
            xbee.tx(frame_id='2', dest_addr=key, data='\x54\x3F\x0A')
            # xbee.tx(frame_id='2', dest_addr=key, data='\x4C\x3F\x0A')
            print '[WAITING ON DATA]'
            status=xbee.wait_read_frame(timeout=1)
            # if status['sdz']:
            #     print "hi"
            print status
            print 'RECEIVED DATA]'
            status=xbee.wait_read_frame(timeout=1)
            print status
            t=status['rf_data'].split('/r/n')[0]
            t=t.split('\n')[0]
            t=t.split('=')[1]
            print 'RECEIVED RF DATA: ' + t
            mqttUploadString = ('testbed/' + key.encode('hex'))
            print "Sending message to broker on topic: " + mqttUploadString
            publish.single(mqttUploadString, t, hostname=BROKER_NAME)
        except:
            print "EXCEPTION IN ITERATE NODES"

def sendmessage(request):
    Topic = request.REQUEST.get('topic','')
    Message = request.REQUEST.get('message','')
    if Topic =='' or Message =='':
        return HttpResponse(returnCode(1004))#"{'error':1004,'message':'missing some part'}")
    publish.single(Topic, Message,qos=2, hostname=Hostname,port=Port)
    return HttpResponse(returnCode(2000))#"{'error':2000,'message':'Success!'}")

def process(csv):
    """ Split the CSV, transform to OwnTracks JSON and publish via MQTT"""

    try:
        tst, lat, lon, soc, interval = csv.split(",")
        if int(tst) < 1:
            print "Ignoring zeroed results:", result
        payload = {
            "_type": "location",
            "tst": int(tst),
            "lat": float(lat),
            "lon": float(lon),
            "tid": device_id[-2:],
            "batt": float(soc),  # State of Charge in %
            "_interval": int(interval),
        }

        mqtt.single(
            topic,
            json.dumps(payload),
            qos=2,
            retain=True,
            hostname=hostname,
            port=int(port),
            client_id=clientid,
            auth=auth,
            will=will,
            tls=tls,
            protocol=int(protocol),
        )

    except Exception, e:
        print str(e)

def lo():
    """ The program turns on LED
    """

    # Set up logging
    syslog.syslog('Lo Starting')
    logging.basicConfig(filename='ha-conn.log',level=logging.DEBUG)
    logging.info('Lo starting')

    # set up the MQTT environment
    client = mqtt.Client()
    client.on_connect = on_connect
    client.on_message = on_message

    client.connect("127.0.0.1", 1883, 60)

    topic = "homeassistant/2/101/1/P"
    msgDict = {}
    msgDict['action'] = "P"
    msgDict['result'] = 0
    msgDict['req_ID'] = 4
    msgDict['deviceID'] = 101
    msgDict['instance'] = 1
    msgDict['float1'] = 300 

    msg = json.dumps(msgDict) 
    print(topic + " " + msg)

    logging.info(topic + " " + msg)
    publish.single(topic, msg, hostname="127.0.0.1")

def balance_thread():
    if not os.path.isfile("mqtt_config.txt"):
        raise Exception("MQTT is not configured. "
                        "Create mqtt_config.txt with first line mqtt server IP address and "
                        "second line with user name and"
                        "third line with your password and"
                        "forth line with your topic for account balance.")

    with open("mqtt_config.txt") as fp:
        ip = fp.readline().strip()
        user = fp.readline().strip()
        password = fp.readline().strip()
        topic = fp.readline().strip()

    while True:
        balance = exchange.get_balance()
        publish.single(topic,
                       payload="{0}".format(sum([coin['usdtValue'] for coin in balance])),
                       qos=0,
                       retain=True,
                       hostname=ip,
                       port=1883,
                       client_id="",
                       keepalive=60,
                       will=None,
                       auth={'username': user, 'password': password},
                       tls=None)

        time.sleep(20)

def mqtt_monitor():
    """ The main program that links the gateway Moteino to the MQTT system
    """
    global reqList

    # set up the MQTT environment
    client = mqtt.Client()
    client.on_connect = on_connect
    client.on_message = on_message

    client.connect("127.0.0.1", 1883, 60)
    client.loop_start()

    req_Ref = 1              # a unique reference number to include in each request
    reqList = []            # a list to hold outstanding requests
    inpString = ''
    myReq = remoteRequest("")       # create an empty request object
    myReq.topic = 'homeassistant/jim'
    myReq.node=1
    myReq.device=1
    myReq.instance=1
    myReq.action='Z'
    myReq.result=12
    myReq.float1=13
    myReq.float2=14
    myReq.req_ID=15
    myReq.Topic()                     # Create the topic & message to send to mqtt
    myReq.Msg()
    
    while True:
      time.sleep(5)
      #publish.single(myReq.topic, myReq.msg, hostname="127.0.0.1")  # send to mqtt  # send to mqtt
      publish.single("Jim/topic", "Test", hostname="127.0.0.1")  # send to mqtt  # send to mqtt

def publish_mqtt(payload):
    topic = "/plc1"
    try:
        publish.single(topic, payload, hostname="broker_ip_address", port=1883, retain=False, qos=0)
    except Exception as err:
        print "Couldn't publish :" + str(err)
        pass

def send(uid, addr, req, token):
    broker = get_broker(addr)
    buf = codec.encode(req, token, uid)
    if QOS >= 0:
        publish.single(addr, buf, hostname=broker, port=SIGNALING_PORT, qos=QOS)
    else:
        publish.single(addr, buf, hostname=broker, port=SIGNALING_PORT)

	def publish(self, msg):
		try:
			publish.single(topic=self.topic, payload=msg, hostname=self.host, auth=self.auth, tls=self.tls, port=self.port)
			#print "MQTT message published:", self.topic, msg, self.host, self.auth, self.tls, self.port
			logging.info( "MQTT message published: " + msg)
		except Exception, ex:
			logging.error(ex)

def analyzer(response):
    result = {}
    res = [hex(i) for i in response]
    print len(res)
    result['header'] = header_analyser(res)
    result['command'] = command_analyzer(res)
    result['parameters'] = paramaters_analyzer(res)
    timestamp = datetime.now().time()
    print 'header: ' + str(antenna_code)
    print 'command: ' + result['command']
    if len(res)>50:
        print '-'.join(res[26:42])
        print 'Antenna: ' + str(antenna_code) #'-'.join(res[24:25])
        print 'Tag: '+ '-'.join(res[26:42])
        msg = json.dumps({'tag': '-'.join(res[26:42]), 'antenna': str(antenna_code) , 'timestamp': str(timestamp) }, sort_keys=True,indent=4, separators=(',', ': '))
        try:
            publish.single("input/" + get_antenna_code(), msg , hostname="localhost", port=1883, client_id="", keepalive=60, will=None, auth=None, tls=None)
            print "LED ON"
        except:
            print "LED OFF"
            pass
    else:
        print '-'.join(result['parameters'])
    print ''
    return result

def handle(text, mic, profile):
    """
        Responds to user-input, typically speech text, by sending a
        mosquitto publish event
        Arguments:
        text -- user-input, typically transcribed speech
        mic -- used to interact with the user (for both input and output)
        profile -- contains information related to the user (e.g., phone
                   number)
    """
    words = text.split(' ')
    if words[0] not in DEVICES:
        return mic.say(words[0]+" not found in the list of devices")
    if words[1] not in NUMBERS:
        return mic.say(words[1]+" not found in the list of valid indexes")
    if words[2] not in PAYLOADS:
        return mic.say(words[2]+" is not found in the list of valid payloads")
    topic = '/'.join(['hal9000']+words[0:2])
    payload = words[2]
    if payload == 'OF':
        payload = 'OFF'
    if 'protocol' in profile['mqtt'] and profile['mqtt']['protocol'] == 'MQTTv311':
        protocol = mqtt.MQTTv311
    else:
        protocol = mqtt.MQTTv31
    publish.single(topic.lower(), payload=payload.lower(), client_id='hal9000',
                   hostname=profile['mqtt']['hostname'], port=profile['mqtt']['port'],
                   protocol=protocol)