class RemotePubNub():
def __init__(self, PUBNUB_PUBLISH_KEY="demo", PUBNUB_SUBSCRIBE_KEY="demo", queue=None):
self.pubnub = Pubnub(publish_key=PUBNUB_PUBLISH_KEY, subscribe_key=PUBNUB_SUBSCRIBE_KEY)
self.queue = queue
def get_queue(self):
return self.queue
def publish(self, channel, message):
self.pubnub.publish(channel, message)
#logging.info("message published")
def subscribe(self, channel):
self.pubnub.subscribe(
channel, callback=self.parse_command, error=self.sub_error,
connect=self.sub_connect, disconnect=self.sub_disconnect)
def parse_command(self, message, channel):
if self.queue is not None:
print message
self.queue.put(message)
def sub_error(message):
logging.ERROR(message)
def sub_connect(self, channel):
message = 'Connected to: %s' % channel
logging.info(message)
def sub_disconnect(self, message):
logging.info(message)
def run(self, channel, latency, bufferSize):
self.mutex = Lock()
self.outqueuebuffers = {}
self.outbuffers = {}
self.senders = {}
self.channels = None
self.channel = channel
self.buffer_size = bufferSize
self.timestamp_buffer = [None] * self.buffer_size
self.debug = False
self.index = 0
self.offset = None
self.latency = latency
self.setupDone = False
self.channel_count = 0
pubnub = Pubnub(
"pub-c-e655613e-f776-4301-9f29-f71edbcd6559",
"sub-c-2eafcf66-c636-11e3-8dcd-02ee2ddab7fe",
"sec-c-ZjUwZDgzMTItYzE2Mi00ZGYyLTg2NGMtNmE5N2Q3MGI0MTli", False)
self.m = MQTT()
broker = config.mqtt['Broker']
print("Connecting to broker: " + broker)
self.m.connect(broker)
while (True):
pubnub.subscribe({
'channel': self.channel,
'callback': self.setData
})
def run(self, channel, latency, bufferSize):
self.mutex = Lock()
self.outqueuebuffers = {}
self.outbuffers = {}
self.senders = {}
self.channels = None
self.channel = channel
self.buffer_size = bufferSize
self.timestamp_buffer = [None] * self.buffer_size
self.debug = False
self.index = 0
self.offset = None
self.latency = latency
self.setupDone = False
self.channel_count = 0
pubnub = Pubnub("pub-c-e655613e-f776-4301-9f29-f71edbcd6559",
"sub-c-2eafcf66-c636-11e3-8dcd-02ee2ddab7fe",
"sec-c-ZjUwZDgzMTItYzE2Mi00ZGYyLTg2NGMtNmE5N2Q3MGI0MTli",
False)
self.m = MQTT()
broker = config.mqtt['Broker']
print("Connecting to broker: " + broker)
self.m.connect(broker)
while(True):
pubnub.subscribe({
'channel': self.channel,
'callback': self.setData
})
def startStockPicker(server, port):
global globalQueueRef
#Step 1 - Initialize MongoDB & PubNub Connection
mongoconn = pymongo.MongoClient(server, port)
db = mongoconn.stockdb
coll = db.stockcollection
#Setup index on time to fetch the latest update
coll.create_index([('time', DESCENDING)])
#YOUR PUBNUB KEYS - Replace the publish_key and subscriber_key below with your own keys
pubnub = Pubnub(publish_key="<your publish key>",
subscribe_key="<your subscribe key>")
#Step 2 - Check and define the metadata ( index names )
metaDataInit(coll)
#Step 3 - Set the parameters , max periodicity , random range
updateTime = 10 #Max ten seconds for every price update
numOfItems = 4 #Four indices to manage
random.seed()
#Step 4 - Setup the Queue and ClientListener Thread
clientQueue = Queue()
clientListener = ClientListenerThread(server, port, clientQueue, pubnub)
clientListener.start()
globalQueueRef = clientQueue
#Step 5 - Setup PubNub Subscription for client requests
pubnub.subscribe("stockhistory", historyCallback, historyError)
#Step 6 - Start the stock picking loop
while True:
#Step 6.1 - Wait for random time
time.sleep(random.randint(1, updateTime))
#Step 6.2 - Wake up and update the stock price for one of the index
newPriceData = getUpdatedPrice(coll)
#Step 6.3 - Update the new price in DB
print "New Price Update " + str(newPriceData)
coll.insert(newPriceData)
#Step 6.4 - Publish over Pubnub , stockdata channel
broadcastData = {
'name': newPriceData['name'],
'value': newPriceData['value'],
'change': newPriceData['change'],
'time': newPriceData['time'],
}
pubnub.publish('stockdata', json.dumps(broadcastData))
def main():
resetAVR()
print("Establishing Connections...")
pubnub = Pubnub(publish_key = 'pub-c-f83b8b34-5dbc-4502-ac34-5073f2382d96',
subscribe_key = 'sub-c-34be47b2-f776-11e4-b559-0619f8945a4f',
uuid = "pi")
channel = 'leap2pi'
GPIO.output(4, False)
def _connect(m):
print("Connected to PubNub!")
GPIO.output(4, True)
def _reconnect(m):
print("Reconnected to PubNub!")
GPIO.output(4, True)
def _disconnect(m):
print("Disconnected from PubNub!")
GPIO.output(4, False)
def _callback(m,n):
left_byte = 0
right_byte = 0
# ==============================Left Hand==============================
left_hand = m.get("left_hand",{})
if left_hand != {}:
left_byte = handleLeft(left_hand)
#print(left_hand)
# ==============================Right Hand=============================
right_hand = m.get("right_hand",{})
if right_hand != {}:
right_byte= handleRight(right_hand)
#print(right_hand)
byte = left_byte | right_byte
#print(byte)
#====send i2c=====#
try:
bus.write_byte(0x47,byte)
except IOError:
print("Error!!!!")
resetAVR()
bus.write_byte(0x47,byte)
#Catch and Print Error
def _error(m):
GPIO.output(4, False)
print(m)
#Subscribe to subchannel, set callback function to _callback and set error fucntion to _error
pubnub.subscribe(channels=channel, callback=_callback, error=_error, connect=_connect, reconnect=_reconnect, disconnect=_disconnect)
def startStockPicker(server,port):
global globalQueueRef
#Step 1 - Initialize MongoDB & PubNub Connection
mongoconn = pymongo.MongoClient(server,port)
db = mongoconn.stockdb
coll = db.stockcollection
#Setup index on time to fetch the latest update
coll.create_index([('time',DESCENDING)])
#YOUR PUBNUB KEYS - Replace the publish_key and subscriber_key below with your own keys
pubnub = Pubnub(publish_key="<your publish key>",subscribe_key="<your subscribe key>")
#Step 2 - Check and define the metadata ( index names )
metaDataInit(coll)
#Step 3 - Set the parameters , max periodicity , random range
updateTime = 10 #Max ten seconds for every price update
numOfItems = 4 #Four indices to manage
random.seed()
#Step 4 - Setup the Queue and ClientListener Thread
clientQueue = Queue()
clientListener = ClientListenerThread(server,port,clientQueue,pubnub)
clientListener.start()
globalQueueRef = clientQueue
#Step 5 - Setup PubNub Subscription for client requests
pubnub.subscribe("stockhistory", historyCallback,historyError)
#Step 6 - Start the stock picking loop
while True:
#Step 6.1 - Wait for random time
time.sleep(random.randint(1,updateTime))
#Step 6.2 - Wake up and update the stock price for one of the index
newPriceData = getUpdatedPrice(coll)
#Step 6.3 - Update the new price in DB
print "New Price Update " + str(newPriceData)
coll.insert(newPriceData)
#Step 6.4 - Publish over Pubnub , stockdata channel
broadcastData = { 'name' : newPriceData['name'],
'value' : newPriceData['value'],
'change' : newPriceData['change'],
'time' : newPriceData['time'],
}
pubnub.publish('stockdata',json.dumps(broadcastData))
def startStockPicker(server,port):
global globalQueueRef
global graph
#Step 1 - Initialize MongoDB & PubNub Connection
# py2neo.set_auth_token('%s:%s' % (NEO_HOST, NEO_PORT), NEO_AUTH_TOKEN)
graph = Graph('%s://%s:%s@%s:%s/db/data/' %
(NEO_PROTOCOL, NEO_USER, NEO_PASSWORD, NEO_HOST, NEO_PORT))
#YOUR PUBNUB KEYS - Replace the publish_key and subscriber_key below with your own keys
pubnub = Pubnub(publish_key="<your pub key>",subscribe_key="<your sub key>")
#Step 2 - Check and define the metadata ( index names )
metaDataInit()
#Step 3 - Set the parameters , max periodicity , random range
updateTime = 10 #Max ten seconds for every price update
numOfItems = 4 #Four indices to manage
random.seed()
#Step 4 - Setup the Queue and ClientListener Thread
clientQueue = Queue()
clientListener = ClientListenerThread(server,port,clientQueue,pubnub)
clientListener.start()
globalQueueRef = clientQueue
#Step 5 - Setup PubNub Subscription for client requests
pubnub.subscribe("stockhistory", historyCallback,historyError)
#Step 6 - Start the stock picking loop
while True:
#Step 6.1 - Wait for random time
time.sleep(random.randint(1,updateTime))
#Step 6.2 - Wake up and update the stock price for one of the index
newPriceData = getUpdatedPrice()
#Step 6.3 - Update the new price in DB
print "New Price Update " + str(newPriceData)
#Step 6.4 - Publish over Pubnub , stockdata channel
broadcastData = { 'name' : newPriceData['name'],
'value' : newPriceData['value'],
'change' : newPriceData['change'],
'time' : newPriceData['time'],
}
pubnub.publish('stockdata',json.dumps(broadcastData))
def main(USERNAME, PASSWORD, SENSOR_ID):
lcd = Adafruit_CharLCD()
lcd.clear()
sessionToken, objectID = LoginUser(USERNAME, PASSWORD)
pubnub = Pubnub(publish_key="pub-c-e6b9a1fd-eed2-441a-8622-a3ef7cc5853a",
subscribe_key="sub-c-7e14a542-b148-11e4-9beb-02ee2ddab7fe")
channel = SENSOR_ID
def _callback(message, channel):
print("Message received from channel: ", message)
data = {'status': None, 'targetTemperature': None}
if message['airconStatus']:
if message['airconStatus'] == 'on':
print "Lets turn on air con now"
lcd.clear()
lcd.message("Aircon On!")
logging.warning("Lets turn on air con now")
else:
print "lets turn off aircon now"
lcd.clear()
lcd.message("Aircon Off!\n Have a good day!")
logging.warning("Lets turn off air con now")
data['status'] = message['airconStatus']
if message['targetTemperature']:
print "Lets turn aircon to : ", message['targetTemperature']
lcd.clear()
lcd.message("Setting temperature\n" +
"Temp={0:0.1f}*C".format(message['targetTemperature']))
logging.warning("Lets turn aircon to : " +
str(message['targetTemperature']))
data['targetTemperature'] = message['targetTemperature']
if message[
'switchOffLCD']: #note that this might happen a few times because current logic is if last activity was more than 3 mins ago, we swtich off
print "Lets switch off LCD"
lcd.clear()
logging.warning("switching off LCD")
needToReLogin = SendDataToParse(data, objectID, sessionToken,
SENSOR_ID)
def _error(message):
print("Error: ", message)
logging.warning("Error: ", message)
pubnub.subscribe(channel, callback=_callback, error=_error)
class iotbridge(object):
def __init__(self, publish_key, subscribe_key, uuid):
self.publish_key = publish_key
self.subscribe_key = subscribe_key
self.uuid = uuid
self.pubnub = Pubnub("demo", "demo", None, False)
self.pubnub.uuid = self.uuid
def send(self, channel, message):
# Sending message on the channel
self.pubnub.publish(channel, message)
def connect(self, channel, callback):
# Listening for messages on the channel
self.pubnub.subscribe(channel, callback=callback)
class iotbridge(object):
def __init__(self, publish_key, subscribe_key, uuid):
self.publish_key = publish_key
self.subscribe_key = subscribe_key
self.uuid = uuid
self.pubnub = Pubnub('demo', 'demo', None, False)
self.pubnub.uuid = self.uuid
def send(self, channel, message):
# Sending message on the channel
self.pubnub.publish(channel, message)
def connect(self, channel, callback):
# Listening for messages on the channel
self.pubnub.subscribe(channel, callback=callback)
def init(func):
global pubnub
global pubnub_freeboard
global message_cb
try:
message_cb = func
log.info("pubnub SUBSCRIBE")
pubnub = Pubnub(publish_key=PUB_KEY, subscribe_key=SUB_KEY, cipher_key=CHIPER_KEY, ssl_on=True)
pubnub.subscribe(CHANNEL, callback=pubnub_message_cb, error=pubnub_error_cb, connect=pubnub_connect_cb, reconnect=pubnub_reconnect_cb, disconnect=pubnub_disconnect_cb)
pubnub_freeboard = Pubnub(publish_key=PUB_KEY, subscribe_key=SUB_KEY, ssl_on=False)
log.info("pubnub SUBSCRIBED")
except:
log.error("Error initializing pubnub...Cannot continue")
raise SystemExit
class Streamteam(object):
def __init__(self, args):
self.channel = args.channel
self.pubnub = Pubnub(
args.publish,
args.subscribe,
None,
False
)
def publish(self, m):
def callback(message):
return message
self.pubnub.publish(
self.channel,
m,
callback=callback,
error=callback
)
def subscribe(self):
def callback(message, channel):
print(message)
def error(message):
print("ERROR : " + str(message))
def connect(message):
print("CONNECTED")
def reconnect(message):
print("RECONNECTED")
def disconnect(message):
print("DISCONNECTED")
self.pubnub.subscribe(
self.channel,
callback=callback,
error=callback,
connect=connect,
reconnect=reconnect,
disconnect=disconnect
)
def main():
print "started"
global t
t = threading.Timer(TEMPO, callback_timer)
t.start()
pubnub = Pubnub(
"pub-e10385fe-9f9f-46a4-b969-f3c8ba11ff59", ## PUBLISH_KEY
"sub-f8f2ff3a-a176-11e1-bbc1-f151a023fb9a", ## SUBSCRIBE_KEY
"sec-OGY5MTk3Y2QtMDY2OS00NThiLTlmZjItNWFkZGM3NDgxMmZi",
False
)
print("subscribing...")
pubnub.subscribe({
'channel' : 'fbhackaton_newquestion',
'callback' : receive
})
class Streamteam(object):
def __init__(self, args):
self.channel = args.channel
self.pubnub = Pubnub(
args.publish,
args.subscribe,
None,
False
)
def publish(self, message):
self.pubnub.publish({
'channel' : self.channel,
'message' : message
})
def subscribe(self):
def receive(message):
# q = ""
s = ""
v = ""
names = "gyroX gyroY AF3 F7 F3 FC5 T7 P7 O1 O2 P8 T8 FC6 F4 F8 AF4".split(" ")
os.system('clear')
for i in names:
# q += str(message['quality'][i]) + " "
v += str(message['values'][i]) + " "
while len(i) < 7:
i += " "
s += i
print("Channel : " + s)
# print("Quality : " + q)
print("Values : " + v)
return True
self.pubnub.subscribe({
'channel' : self.channel,
'callback' : receive
})
class WatchRemote():
"""monitoring remote repository"""
def __init__(self, pid, path, key ):
self.pid = pid
self.path = path
self.pubnub = Pubnub( None, key, None, False )
def receive(self,message) :
notify('GitBox Download', 'receiving new and changed files in %s' % self.path)
cmd = 'git push'
process = subprocess.Popen(cmd.split(' '), cwd=self.path)
process.communicate()
return True
def start(self):
## Initiat Class
self.pubnub.subscribe({'channel' : self.pid, 'callback' : self.receive })
def stop(self):
pass
message['withdrawListSize'] = len(message['withdrawList'])
message['totalCredit'] = message['credit'] + message['cash']
if (message['userName'].isalpha()==False):
message['userName'] = make_english_name(message['userName'])
print(message)
print_receipt_on(printer, message)
def connected():
print('Connected')
## -----------------------------------------------------------------------
## Main
## -----------------------------------------------------------------------
pubnub = Pubnub(publish_key, subscribe_key, secret_key, ssl_on)
pubnub.subscribe({
'channel' : channel_name,
'connect' : connected,
'callback' : message_received
})
## -----------------------------------------------------------------------
## IO Event Loop
## -----------------------------------------------------------------------
try:
pubnub.start()
except:
pass
def speed(): # Speeds up the motor
wiringpi.pwmWrite(18, 900)
adcChannel = 1
spi = spidev.SpiDev()
spi.open(0, 0)
is_warning = False
try:
GPIO.add_event_detect(25,
GPIO.FALLING,
callback=button_callback,
bouncetime=300)
pubnub.subscribe(channels="text", callback=call, error=_error)
while True:
adc_value = (get_adc(adcChannel))
v = cal_voltage(adc_value)
t = cal_temp(v)
if t > 50 and is_warning == False:
message = 'The room temperature is ' + str(int(t)) + ' C'
pubnub.publish("my_channel",
message,
callback=_callback,
error=_error)
runMotor()
is_warning = True
def connect_d(message):
print("CONNECTED " + str(message))
pubnub.unsubscribe(channel='d')
def reconnect(message):
print("RECONNECTED " + str(message))
def disconnect(message):
print("DISCONNECTED " + str(message))
print pubnub.channel_group_add_channel(channel_group='abc', channel="b")
pubnub.subscribe_group(channel_groups='abc',
callback=callback_abc,
error=error,
connect=connect_abc,
reconnect=reconnect,
disconnect=disconnect)
pubnub.subscribe(channels='d',
callback=callback_d,
error=error,
connect=connect_d,
reconnect=reconnect,
disconnect=disconnect)
pubnub.start()
def main():
resetAVR()
print("Establishing Connections...")
pubnub = Pubnub(publish_key='pub-c-f83b8b34-5dbc-4502-ac34-5073f2382d96',
subscribe_key='sub-c-34be47b2-f776-11e4-b559-0619f8945a4f',
uuid="pi")
channel = 'leap2pi'
GPIO.output(4, False)
def checkValue(value):
if (value < SERVO_MIN):
value = SERVO_MIN
elif (value > SERVO_MAX):
value = SERVO_MAX
return value
def invertValue(value):
value = checkValue(value)
return SERVO_MAX - value + SERVO_MIN
def _connect(m):
print("Connected to PubNub!")
GPIO.output(4, True)
def _reconnect(m):
print("Reconnected to PubNub!")
GPIO.output(4, True)
def _disconnect(m):
print("Disconnected from PubNub!")
GPIO.output(4, False)
def _callback(m, n):
left_byte = 0
right_byte = 0
yaw = 0
pitch = 0
byte = 0
# Handle message
left_hand = m.get("left_hand", {})
right_hand = m.get("right_hand", {})
if (servo_mode == MIRROR):
# Leap Motion: Left hand, Servos: Stage Left
if left_hand != {}:
yaw = left_hand["left_yaw"]
yaw = checkValue(yaw)
pitch = left_hand["left_pitch"]
pitch = checkValue(pitch)
left_byte = left_hand["left_byte"]
pwm.setPWM(0, 0, yaw)
pwm.setPWM(1, 1, pitch)
# Leap Motion: Left hand, Servos: Stage Right
if right_hand != {}:
yaw = right_hand["right_yaw"]
yaw = checkValue(yaw)
pitch = right_hand["right_pitch"]
pitch = checkValue(pitch)
right_byte = right_hand["right_byte"] >> 4
pwm.setPWM(2, 2, yaw)
pwm.setPWM(3, 3, pitch)
byte = left_byte | (right_byte << 4)
elif (servo_mode == CLONE):
# Leap Motion: Left hand, Servos: Stage Right
if left_hand != {}:
yaw = left_hand["left_yaw"]
yaw = invertValue(yaw)
pitch = left_hand["left_pitch"]
pitch = invertValue(pitch)
left_byte = left_hand["left_byte"]
pwm.setPWM(2, 2, yaw)
pwm.setPWM(3, 3, pitch)
# Leap Motion: Left hand, Servos: Stage Left
if right_hand != {}:
yaw = right_hand["right_yaw"]
yaw = invertValue(yaw)
pitch = right_hand["right_pitch"]
pitch = invertValue(pitch)
right_byte = right_hand["right_byte"] >> 4
pwm.setPWM(0, 0, yaw)
pwm.setPWM(1, 1, pitch)
byte = (left_byte << 4) | right_byte
else:
byte = -1
#====send i2c=====#
if (byte >= 0):
try:
bus.write_byte(0x47, byte)
except IOError:
print("Error!!!!")
resetAVR()
bus.write_byte(0x47, byte)
#Catch and Print Error
def _error(m):
GPIO.output(4, False)
print(m)
#Subscribe to subchannel, set callback function to _callback and set error fucntion to _error
pubnub.subscribe(channels=channel,
callback=_callback,
error=_error,
connect=_connect,
reconnect=_reconnect,
disconnect=_disconnect)
# Loop here forever
while True:
# Check for switch position
time.sleep(1)
if (GPIO.input(16) == False):
servo_mode = CLONE
elif (GPIO.input(20) == False):
servo_mode = MIRROR
else:
servo_mode = DISABLED
def init(): global pubnub pubnub = Pubnub(publish_key="demo", subscribe_key="demo") pubnub.subscribe(channels=pubnub_responsechannel, callback=_callback, error=_error)
def main():
resetAVR()
print("Establishing Connections...")
pubnub = Pubnub(publish_key = 'pub-c-f83b8b34-5dbc-4502-ac34-5073f2382d96',
subscribe_key = 'sub-c-34be47b2-f776-11e4-b559-0619f8945a4f',
uuid = "pi")
channel = 'leap2pi'
GPIO.output(4, False)
def checkValue(value):
if (value < SERVO_MIN):
value = SERVO_MIN
elif(value > SERVO_MAX):
value = SERVO_MAX
return value
def invertValue(value):
value = checkValue(value)
return SERVO_MAX - value + SERVO_MIN
def _connect(m):
print("Connected to PubNub!")
GPIO.output(4, True)
def _reconnect(m):
print("Reconnected to PubNub!")
GPIO.output(4, True)
def _disconnect(m):
print("Disconnected from PubNub!")
GPIO.output(4, False)
def _callback(m,n):
left_byte = 0
right_byte = 0
yaw = 0
pitch = 0
byte = 0
# Handle message
left_hand = m.get("left_hand",{})
right_hand = m.get("right_hand",{})
if (servo_mode == MIRROR):
# Leap Motion: Left hand, Servos: Stage Left
if left_hand != {}:
yaw = left_hand["left_yaw"]
yaw = checkValue(yaw)
pitch = left_hand["left_pitch"]
pitch = checkValue(pitch)
left_byte = left_hand["left_byte"]
pwm.setPWM(0, 0, yaw)
pwm.setPWM(1, 1, pitch)
# Leap Motion: Left hand, Servos: Stage Right
if right_hand != {}:
yaw = right_hand["right_yaw"]
yaw = checkValue(yaw)
pitch = right_hand["right_pitch"]
pitch = checkValue(pitch)
right_byte = right_hand["right_byte"] >> 4
pwm.setPWM(2, 2, yaw)
pwm.setPWM(3, 3, pitch)
byte = left_byte | (right_byte << 4)
elif (servo_mode == CLONE):
# Leap Motion: Left hand, Servos: Stage Right
if left_hand != {}:
yaw = left_hand["left_yaw"]
yaw = invertValue(yaw)
pitch = left_hand["left_pitch"]
pitch = invertValue(pitch)
left_byte = left_hand["left_byte"]
pwm.setPWM(2, 2, yaw)
pwm.setPWM(3, 3, pitch)
# Leap Motion: Left hand, Servos: Stage Left
if right_hand != {}:
yaw = right_hand["right_yaw"]
yaw = invertValue(yaw)
pitch = right_hand["right_pitch"]
pitch = invertValue(pitch)
right_byte = right_hand["right_byte"] >> 4
pwm.setPWM(0, 0, yaw)
pwm.setPWM(1, 1, pitch)
byte = (left_byte << 4) | right_byte
else:
byte = -1
#====send i2c=====#
if (byte >= 0):
try:
bus.write_byte(0x47,byte)
except IOError:
print("Error!!!!")
resetAVR()
bus.write_byte(0x47,byte)
#Catch and Print Error
def _error(m):
GPIO.output(4, False)
print(m)
#Subscribe to subchannel, set callback function to _callback and set error fucntion to _error
pubnub.subscribe(channels=channel, callback=_callback, error=_error, connect=_connect, reconnect=_reconnect, disconnect=_disconnect)
# Loop here forever
while True:
# Check for switch position
time.sleep(1)
if(GPIO.input(16) == False):
servo_mode = CLONE
elif (GPIO.input(20) == False):
servo_mode = MIRROR
else:
servo_mode = DISABLED
""
) % {
'max' : trips['max'],
'avg' : trips['avg'],
'publishes' : analytics['publishes'],
'received' : analytics['received'],
'successful_publishes' : analytics['successful_publishes'],
'failed_publishes' : analytics['failed_publishes'],
'failed_deliveries' : analytics['failed_deliveries'],
'publishes' : analytics['publishes'],
'deliverability' : analytics['deliverability'],
'queued' : analytics['queued']
} )
pubnub.timeout( show_status, 1 )
def connected():
show_status()
pubnub.timeout( send, 1 )
print( "Connected: %s\n" % origin )
pubnub.subscribe({
'channel' : channel,
'connect' : connected,
'callback' : received
})
## -----------------------------------------------------------------------
## IO Event Loop
## -----------------------------------------------------------------------
pubnub.start()
## -----------------------------------------------------------------------
history = pubnub.history({
'channel' : crazy,
'limit' : 1
})
test(
history[0].encode('utf-8') == crazy,
'History Message: ' + history[0]
)
test( len(history) == 1, 'History Message Count' )
## -----------------------------------------------------------------------
## PubNub Server Time Example
## -----------------------------------------------------------------------
timestamp = pubnub.time()
test( timestamp > 0, 'PubNub Server Time: ' + str(timestamp) )
## -----------------------------------------------------------------------
## Subscribe Example
## -----------------------------------------------------------------------
def receive(message) :
print(message)
return True
pubnub.subscribe({
'channel' : crazy,
'callback' : receive
})
global node_state
global next_call
try:
get_state()
print datetime.datetime.now(), "publish", node_state[node_type]
pubnub.publish(node_type, node_state[node_type])
select_active()
except:
print "unknown error"
next_call = next_call + 10
threading.Timer(next_call - time.time(), state_publish).start()
## -----------------------------------------------------------------------
## Initiate Pubnub State
## -----------------------------------------------------------------------
publish_key = config["pubnub_auth"]["publish_key"]
subscribe_key = config["pubnub_auth"]["subscribe_key"]
secret_key = config["pubnub_auth"]["secret_key"]
cipher_key = config["pubnub_auth"]["cipher_key"]
ssl_on = False
pubnub = Pubnub(
publish_key=publish_key, subscribe_key=subscribe_key, secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on
)
pubnub.subscribe(node_type_other, callback=callback, error=error)
next_call = (int(time.time() / 10)) * 10 + 5
state_publish()
ser = serial.Serial('COM4', 9600)
pubnub = Pubnub(publish_key="pub-c-6a3d5bbe-652b-49a2-bca1-ccb6db8bb50d", subscribe_key="sub-c-5fa82184-f7ba-11e4-8fd2-02ee2ddab7fe")
def _callback(message, channel):
if message["sender"] == "browser":
print(message['setSystemStatus'])
signal.set()
#time.sleep(2)
out_message = {"sender": "bric", "body": "status update"}
pubnub.publish("demo_tutorial", out_message, callback=callback, error=callback)
def _error(message):
print("error")
pubnub.subscribe(channels="demo_tutorial", callback=_callback, error=_error)
def callback(message):
print("callback place holder")
while True:
if not signal.is_set():
s = ser.readline()
out_message = {"sender": "bric", "body": s}
pubnub.publish("demo_tutorial", out_message, callback=callback(out_message), error=callback(out_message))
time.sleep(1)
elif signal.is_set():
print "status configuration"
time.sleep(2)
output = subprocess.check_output('ipconfig')
print("Programming Arduino...done")
## -----------------------------------------------------------------------
## Initiate Pubnub State
## -----------------------------------------------------------------------
pubnub = Pubnub( publish_key=publish_key, subscribe_key=subscribe_key, secret_key=secret_key,cipher_key=cipher_key, ssl_on=ssl_on )
#pubnub = Pubnub( publish_key, subscribe_key, secret_key, ssl_on )
crazy = 'hello_world'
def connect_cb():
print 'Connect'
def subscribe_result(response):
print response
pubnub.subscribe({
'channel' : crazy,
'callback' : subscribe_result,
'connect' : connect_cb
})
## -----------------------------------------------------------------------
## Publish Example
## -----------------------------------------------------------------------
'''
def publish_complete(info):
print(info)
## Publish string
pubnub.publish({
'channel' : crazy,
'message' : 'Hello World!',
'callback' : publish_complete
})
result = json.loads(connection.getresponse().read())
print "Photo Uploaded!"
except:
connection.close()
connection = httplib.HTTPSConnection('api.parse.com', 443)
connection.connect()
print "Error Uploading."
pubnub.publish(channel, imgFile)
lock.release()
else: # Not a person
print "False"
os.remove(imgFile)
sys.exit(0)
try:
pubnub.subscribe(channels=subchannel, callback=_kill, error=_error) ## Change to callback
while True:
previous_state = current_state
current_state = GPIO.input(sensor)
if current_state != previous_state:
new_state = "HIGH" if current_state else "LOW"
if current_state: # Motion is Detected
lock.acquire()
cam.start_preview() # Comment in future
cam.preview_fullscreen = False
cam.preview_window = (10,10, 320,240)
print('Motion Detected')
for i in range(imgCount):
curTime = (time.strftime("%I:%M:%S")) + ".jpg"
from Pubnub import Pubnub
## Initiat Class
pubnub = Pubnub( 'demo', 'demo', None, False )
## Subscribe Example
def receive(message) :
print(message)
return True
print("Listening for messages...")
pubnub.subscribe({
'channel' : 'hello_world',
'callback' : receive
})
test(history[0].encode('utf-8') == crazy, 'History Message: ' + history[0])
test(len(history) == 1, 'History Message Count')
## -----------------------------------------------------------------------
## PubNub Server Time Example
## -----------------------------------------------------------------------
timestamp = pubnub.time()
test(timestamp > 0, 'PubNub Server Time: ' + str(timestamp))
## -----------------------------------------------------------------------
## Channel Analytics Example
## -----------------------------------------------------------------------
analytics = pubnub.analytics({
'channel': 'channel-name-here', ## Leave blank for all channels
'limit': 100, ## aggregation range
'ago': 0, ## minutes ago to look backward
'duratoin': 100 ## minutes offset
})
test(analytics.has_key('results'), 'PubNub Channel Analytics')
## -----------------------------------------------------------------------
## Subscribe Example
## -----------------------------------------------------------------------
def receive(message):
print(message)
return True
pubnub.subscribe({'channel': crazy, 'callback': receive})
try:
get_state()
print datetime.datetime.now(), 'publish', node_state[node_type]
pubnub.publish(node_type, node_state[node_type])
select_active()
except:
print "unknown error"
next_call = next_call + 10
threading.Timer(next_call - time.time(), state_publish).start()
## -----------------------------------------------------------------------
## Initiate Pubnub State
## -----------------------------------------------------------------------
publish_key = config["pubnub_auth"]["publish_key"]
subscribe_key = config["pubnub_auth"]["subscribe_key"]
secret_key = config["pubnub_auth"]["secret_key"]
cipher_key = config["pubnub_auth"]["cipher_key"]
ssl_on = False
pubnub = Pubnub(publish_key=publish_key,
subscribe_key=subscribe_key,
secret_key=secret_key,
cipher_key=cipher_key,
ssl_on=ssl_on)
pubnub.subscribe(node_type_other, callback=callback, error=error)
next_call = (int(time.time() / 10)) * 10 + 5
state_publish()
loopcount = 0
pubnub = Pubnub(publish_key='pub-c-9710b97d-1b82-4e19-8508-ef27b1bf9fde', subscribe_key='sub-c-18528260-3ca5-11e8-a433-9e6b275e7b64')
channel = 'Rangefinder'
GPIO.setmode(GPIO.BCM)
TRIG = 20
ECHO = 26
GPIO.setup(TRIG,GPIO.OUT)
GPIO.setup(ECHO,GPIO.IN)
GPIO.output(TRIG,False)
time.sleep(2)
pubnub.subscribe(channel, callback=callback, error=callback)
def callback(m, channel):
if m['getDistance'] == 'on'
while True:
GPIO.output(TRIG,True)
time.sleep(0.00001)
GPIO.output(TRIG,False)
pulse_start = time.time()
while GPIO.input(ECHO)==0:
pulse_start = time.time()
while GPIO.input(ECHO)==1:
pulse_end = time.time()
pulse_duration = pulse_end - pulse_start
distance = round(distance, 2)
loopcount=+=1
message = {"Distance": distance}
def message_received(message):
message["withdrawListSize"] = len(message["withdrawList"])
message["totalCredit"] = message["credit"] + message["cash"]
if message["userName"].isalpha() == False:
message["userName"] = make_english_name(message["userName"])
print(message)
print_receipt_on(printer, message)
def connected():
print("Connected")
## -----------------------------------------------------------------------
## Main
## -----------------------------------------------------------------------
pubnub = Pubnub(publish_key, subscribe_key, secret_key, ssl_on)
pubnub.subscribe({"channel": channel_name, "connect": connected, "callback": message_received})
## -----------------------------------------------------------------------
## IO Event Loop
## -----------------------------------------------------------------------
try:
pubnub.start()
except:
pass
## -----------------------------------------------------------------------
## function about pubnub
## -----------------------------------------------------------------------
# Asynchronous usage
def callback(message, channel):
print datetime.datetime.now(), 'receive', message
def error(message):
print("ERROR : " + str(message))
## -----------------------------------------------------------------------
## Initiate Pubnub State
## -----------------------------------------------------------------------
publish_key = config["pubnub_auth"]["publish_key"]
subscribe_key = config["pubnub_auth"]["subscribe_key"]
secret_key = config["pubnub_auth"]["secret_key"]
cipher_key = config["pubnub_auth"]["cipher_key"]
ssl_on = False
pubnub = Pubnub(publish_key=publish_key,
subscribe_key=subscribe_key,
secret_key=secret_key,
cipher_key=cipher_key,
ssl_on=ssl_on)
pubnub.subscribe("blockchain_list_blocks", callback=callback, error=error)
pubnub.subscribe("blockchain_list_delegate", callback=callback, error=error)
try:
result = json.loads(connection.getresponse().read())
print result
except:
print "Error Uploading."
pubnub.publish(channel,curTime)
os.remove(curTime)
def _error(m):
print(m)
# def is_person(image):
# det = Detector(image)
# return len(det.face()) or len(det.upper_body()) or len(det.pedestrian())
try:
cam.start_preview()
cam.preview_fullscreen = False
cam.preview_window = (10,10, 320,240)
pubnub.subscribe(channels=channel2, callback=_callback, error=_error)
# Listening for messages on the channel
while True:
time.sleep(10)
except KeyboardInterrupt:
cam.stop_preview()
sys.exit(0)
import threading
from Pubnub import Pubnub
from gntp import notifier
from datetime import datetime
from pnsettings import publish_key as p, subscribe_key as s
channel = 'notify'
pubnub = Pubnub(publish_key=p, subscribe_key=s)
def receive_message(data, channel):
ts = datetime.fromtimestamp(float(data['timestamp']))
notifier.mini(ts.strftime('%H:%M:%S: ' + data['message']))
pubnub.subscribe(channel, callback=receive_message)
import signal, sys
def kill_all_threads():
for thread in threading.enumerate():
if thread.isAlive():
thread._Thread__stop()
def cleanup(signal=None, frame=None):
print "\nCleaning up."
kill_all_threads()
sys.exit(0)
signal.signal(signal.SIGINT, cleanup)
trips['avg'] = (trips['avg'] + trips[last_trip]) / 2
## Increment Trip Counter
trips[current_trip] = trips[current_trip] + 1
## Update Max
if trips[current_trip] > trips['max']:
trips['max'] = trips[current_trip]
print(message)
pubnub.publish({
'channel':
crazy,
'message':
current_trip + " Trip: " + str(trips[current_trip]) + " MAX: " +
str(trips['max']) + "/sec " + " AVG: " + str(trips['avg']) + "/sec"
})
pubnub.subscribe({
'channel': crazy,
'connect': connected,
'callback': received
})
## -----------------------------------------------------------------------
## IO Event Loop
## -----------------------------------------------------------------------
pubnub.start()
class App():
def readKeys(self):
myvars = {}
with open("keys") as myfile:
for line in myfile:
name, var = line.partition("=")[::2]
myvars[name.strip()] = "".join(var.split())
self.publish_key = myvars["publish_key"]
self.subscribe_key = myvars["subscribe_key"]
self.secret_key = myvars["secret_key"]
def __init__(self):
self.stdin_path = '/dev/null'
self.stdout_path = '/dev/tty'
self.stderr_path = '/dev/tty'
self.pidfile_path = '/tmp/eke.pid'
self.channel_sub = 'hello_world'
self.pidfile_timeout = 5
self.df = pd.DataFrame(columns = ['temp'])
self.publish_key = ''
self.subscribe_key = ''
self.secret_key = ''
self.cipher_key = ''
self.ssl_on = False
self.readKeys()
self.pubnub = Pubnub(publish_key=self.publish_key,
subscribe_key=self.subscribe_key,
secret_key=self.secret_key,
cipher_key=self.cipher_key,
ssl_on=self.ssl_on)
def anomaly(self, message):
logger.info(message)
pass
# Asynchronous usage
def callback(self, message, channel):
# load stuff into LS or DBScan
anomalymodel = LS.LSAnomaly(rho=1, sigma=.5)
try:
s = message
logger.info(float(s['temp']))
self.df.loc[self.df.values.size] = float(s['temp'])
if self.df.values.size > 10:
if np.std(self.df['temp'].values) < 1.1:
logger.info("std less than 1.1 for this set")
s = pd.Series(self.df['temp'])
s = s.reshape(s.shape[0],1)
anomalymodel.fit(s)
anomalymodel.predict(s)
self.df['outcome'] = anomalymodel.predict(s)
ano = self.df[self.df['outcome'] != 0]
print ano
print self.df
for i in ano.index:
print ano.ix[i]
self.df = pd.DataFrame(columns = ['temp'])
return
except TypeError:
pass
def error(self, message):
print("ERROR : " + str(message))
def connect(self, message):
print("CONNECTED")
def reconnect(self, message):
print("RECONNECTED")
def disconnect(self, message):
print("DISCONNECTED")
def run(self):
logger.info("Eke server started!")
self.pubnub.subscribe(self.channel_sub,
callback=self.callback,
error=self.callback,
connect=self.connect,
reconnect=self.reconnect,
disconnect=self.disconnect
)
glow = False
respstring = 'off'
else:
glow = True
respstring = 'on'
GPIO.output(16, glow)
respmsg = {"resp": respstring}
pubnub.publish(pubnubChannelName, respmsg)
#PubNub Channel Subscribe Callback
def gpioError(msg):
print 'Error :' + msg
if __name__ == '__main__':
GPIO.setup(16, GPIO.OUT)
pubnub.subscribe(pubnubChannelName, gpioCallback, gpioError)
while True:
time.sleep(5000)
if (GPIO.gpio_function(16)):
#All is over
break
class BasePubNub(object):
secret_key = "sec-c-YjFhY2U3MWUtMDIzZS00MzUxLTkyMjgtMmI5ZDMwNGI4YzNj"
pub_key = "pub-c-07bede4d-e0d6-4f19-bb9b-fb8414505f36"
sub_key = "sub-c-d9e6107e-d34c-11e4-adb1-02ee2ddab7fe"
channel = "base"
str_force = '"query"'
str_on = '"set_on"'
str_off = '"set_off"'
str_auto = '"set_auto"'
def __init__(self, subscribe=True, logcb=None, valuecb=None, swap=False):
self.channel_down = "%s_down" % self.channel
self.channel_up = "%s_up" % self.channel
if swap:
self.channel_down, self.channel_up = self.channel_up, self.channel_down
self.pubnub = Pubnub(publish_key=self.pub_key, subscribe_key=self.sub_key, secret_key=self.secret_key)
if subscribe:
self.pubnub.subscribe(channels=self.channel_up, callback=self._callback, error=self._error_cb)
self.logcb = logcb
self.valuecb = valuecb
def logcb(self, text):
pass
def force(self):
self.pubnub.publish(self.channel_down, self.str_force)
def set_on(self):
self.pubnub.publish(self.channel_down, self.str_on)
def set_off(self):
self.pubnub.publish(self.channel_down, self.str_off)
def set_auto(self):
self.pubnub.publish(self.channel_down, self.str_auto)
def send_value(self, value):
info = {"name": self.channel, "value": value}
self.pubnub.publish(self.channel_down, json.dumps(info))
def _callback(self, message, channel):
if self.logcb:
self.logcb("ch [%s] msg [%s]" % (channel, message))
else:
print "got called back"
print "ch [%s]" % channel
print "msg [%s]" % message
try:
if type(message) == str:
try:
message = json.loads(message)
except:
print "was not a good json"
# m = json.loads(message)
if "value" in message and self.valuecb:
self.valuecb(self.channel, str(message["value"]))
except ValueError, e:
print "json failed"
except Exception, e:
print "nope, that didnt work"
print traceback.format_exc()
})
try:
result = json.loads(connection.getresponse().read())
print result
except:
print "Error Uploading."
pubnub.publish(channel, curTime)
os.remove(curTime)
def _error(m):
print(m)
# def is_person(image):
# det = Detector(image)
# return len(det.face()) or len(det.upper_body()) or len(det.pedestrian())
try:
cam.start_preview()
cam.preview_fullscreen = False
cam.preview_window = (10, 10, 320, 240)
pubnub.subscribe(channels=channel2, callback=_callback, error=_error)
# Listening for messages on the channel
while True:
time.sleep(10)
except KeyboardInterrupt:
cam.stop_preview()
sys.exit(0)
trips[current_trip] = trips[current_trip] + 1
## Update Max
if trips[current_trip] > trips["max"]:
trips["max"] = trips[current_trip]
print(message)
pubnub.publish(
{
"channel": crazy,
"message": current_trip
+ " Trip: "
+ str(trips[current_trip])
+ " MAX: "
+ str(trips["max"])
+ "/sec "
+ " AVG: "
+ str(trips["avg"])
+ "/sec",
}
)
pubnub.subscribe({"channel": crazy, "connect": connected, "callback": received})
## -----------------------------------------------------------------------
## IO Event Loop
## -----------------------------------------------------------------------
tornado.ioloop.IOLoop.instance().start()
# speed 0 - 100
def setSpeed(speed):
if speed > 100:
speed = 100
elif speed < 0:
speed = 0
speedByte = MIN_SPEED_BYTE + (FAST_SPEED_BYTE -
MIN_SPEED_BYTE) * speed / 100
# Forward
output = speedByte << 2
output += 0x01
i2c.write_byte_data(ADDRESS, 0, output)
def subscribeCallback(message, channel):
print('received, ' + channel + ':' + str(message))
if channel == CHANNEL_C_CONTROL:
speed = message['speed']
setSpeed(speed)
def subscribeError(message):
print(str(message))
pubnub.subscribe(SUBSCRIBE_CHANNELS, subscribeCallback, subscribeError)
class PubnubChanListenerFactory():
logging.info('PubnubChannelFactory()')
def __init__(self,
publish_key,
subscribe_key,
secret_key = False,
ssl_on = False,
channelName = '',
callbackMethod = False
):
self.__publish_key = publish_key
self.__subscribe_key = subscribe_key
self.__secret_key = secret_key
self.__ssl_on = ssl_on
self.__channelName = channelName
self.__callbackMethod = callbackMethod if callbackMethod else self.__undefinedCallbackListener
self.__initThreadedListener()
'''
#**
#* PubnubChannelFactory
#*
#* Init PubnubChannelFactory
#*
#* @param string publish_key required key to send messages.
#* @param string subscribe_key required key to receive messages.
#* @param string secret_key required key to sign messages.
#* @param boolean ssl_on required for 2048 bit encrypted messages.
#* @param string origin PUBNUB Server Origin.
#**
## Initiat Class
pubnubConn = PubnubChannelFactory( 'PUBLISH-KEY', 'SUBSCRIBE-KEY', 'SECRET-KEY', Bool, 'CHANNEL-NAME', callbackMethod )
'''
def __undefinedCallbackListener(self, message):
logging.warn('message received, but NO CALLBACK DEFINED', message)
def __initThreadedListener(self):
logging.info('__initThreadedListener')
# call BLOCKING subscribe method in a separate thread
args = {'channel': self.__channelName,
'callback': self.__receiveComm,
'publish_key': self.__publish_key,
'subscribe_key': self.__subscribe_key,
'secret_key': self.__secret_key,
'ssl_on': self.__ssl_on
}
# Channel listening is BLOCKING so we are instantiating in another thread
self.t = background_thread.BackgroundThread(target=self.__doSubscribe, kwargs=args)
self.t.daemon = True
self.t.start()
# Type 2
# self.tid = background_thread.start_new_background_thread(target=self.__doSubscribe, kwargs=args)
def __doSubscribe(self, **kwargs):
self.pubnubConnecor = Pubnub(kwargs['publish_key'],
kwargs['subscribe_key'],
kwargs['secret_key'],
kwargs['ssl_on']
)
if len( kwargs['channel'] ) > 0:
logging.info('subscribing to channel ({})'.format(kwargs['channel']))
self.pubnubConnecor.subscribe({
'channel' : kwargs['channel'],
'callback' : kwargs['callback']
})
else:
logging.info('no channel defined, listening will not begin until one is assigned via switchChannel')
return False
def switchChannel(self, newChannel):
self.__channelName = newChannel;
# kill thread, init new channel
def __receiveComm(self, message):
self.__callbackMethod(message)
return True
'''
The pending BLOCKING request in the pubnub subscribe method
can keep the thread alive when GAE is trying to shut it down
so we just reset the callback so the message is not received twice
'''
def destroy(self):
print('destroy', self, 'setting callback to ignored internal method')
self.__callbackMethod = self.__undefinedCallbackListener
from Pubnub import Pubnub
## Initiat Class
pubnub = Pubnub('demo', 'demo', None, False)
## Subscribe Example
def receive(message):
print(message)
return True
print("Listening for messages...")
pubnub.subscribe({'channel': 'hello_world', 'callback': receive})
class PubnubDataConnection(threading.Thread):
"A connection to a PubNub data hub running on its own thread."
def __init__(self, callback, credentials):
"""
Opens a PubNub connection with a callback and a credentials dict.
:param callback: A callable to be called with two arguments:
message_content and channel_name.
:type callback: A function or object implementing the ``__call__`` method.
:param credentials: A set of key/value pairs to be passed to PubNub.
:type credentials: dict
"""
super(PubnubDataConnection, self).__init__()
self._stop_event = threading.Event()
self.callback = callback
self.credentials = credentials
self.channel = credentials['channel']
self.hub = Pubnub(publish_key=credentials.get('publishKey', None),
subscribe_key=credentials.get('subscribeKey', None),
cipher_key=credentials.get('cipherKey', None),
auth_key=credentials.get('authKey', None),
secret_key=None,
ssl_on=True)
if PY2 and "daemon" in Pubnub.__init__.func_code.co_varnames:
self.hub.daemon = True
elif PY3 and "daemon" in Pubnub.__init__.__code__.co_varnames:
self.hub.daemon = True
self.setDaemon(True)
def run(self):
"""Thread method, called implicitly after starting the thread."""
self.subscribe(self.channel, self.callback)
while not self._stop_event.is_set():
time.sleep(1)
def stop(self):
"""Mark the connection/thread for being stopped."""
self._stop_event.set()
self.unsubscribe(self.channel)
def subscribe(self, channel_name, callback):
"""
Subscribes a callable to a channel with the given name.
:param channel_name: The channel name.
:type channel_name: string
:param callback: The callable to be called with two arguments:
message_content and channel_name.
:type callback: A function or object implementing the ``__call__`` method.
"""
self.hub.subscribe(channel_name, callback)
def unsubscribe(self, channel_name):
"""
Unsubscribes from a channel with given name.
:param channel_name: the channel name
:type channel_name: string
"""
self.hub.unsubscribe(channel_name)
## -----------------------------------------------------------------------
## Publish Example
## -----------------------------------------------------------------------
def publish_complete(info):
print(info)
pubnub.publish({
'channel': crazy,
'message': {
'some_text': 'Hello World!'
},
'callback': publish_complete
})
## -----------------------------------------------------------------------
## Subscribe Example
## -----------------------------------------------------------------------
def message_received(message):
print(message)
pubnub.subscribe({'channel': crazy, 'callback': message_received})
## -----------------------------------------------------------------------
## IO Event Loop
## -----------------------------------------------------------------------
tornado.ioloop.IOLoop.instance().start()
## -----------------------------------------------------------------------
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
channel = 'a'
# Asynchronous usage
def callback(message, channel):
print(message)
def error(message):
print("ERROR : " + str(message))
def connect(message):
print("CONNECTED")
def reconnect(message):
print("RECONNECTED")
def disconnect(message):
print("DISCONNECTED")
pubnub.subscribe(channel, callback=callback, error=callback,
connect=connect, reconnect=reconnect, disconnect=disconnect)
glow = True
respstring = 'on'
GPIO.output(16, glow)
respmsg = {"resp" : respstring }
pubnub.publish(pubnubChannelName, respmsg)
#PubNub Channel Subscribe Callback
def gpioError(msg):
print 'Error :' + msg
if __name__ == '__main__':
GPIO.setup(16, GPIO.OUT)
pubnub.subscribe(pubnubChannelName, gpioCallback, gpioError)
while True:
time.sleep(5000)
if(GPIO.gpio_function(16)):
#All is over
break
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
## -----------------------------------------------------------------------
## Initiate Pubnub State
## -----------------------------------------------------------------------
pubnub = Pubnub( publish_key, subscribe_key, secret_key, cipher_key, ssl_on )
crazy = 'hello_world'
## -----------------------------------------------------------------------
## Subscribe Example
## -----------------------------------------------------------------------
def message_received(message):
print(message)
def connected() :
pubnub.publish({
'channel' : crazy,
'message' : { 'Info' : 'Connected!' }
})
pubnub.subscribe({
'channel' : crazy,
'connect' : connected,
'callback' : message_received
})
## -----------------------------------------------------------------------
## IO Event Loop
## -----------------------------------------------------------------------
reactor.run()
pubnub = Pubnub(PUBLISH_KEY, SUBSCRIBE_KEY)
i2c = smbus.SMBus(1)
# speed 0 - 100
def setSpeed(speed):
if speed > 100:
speed = 100
elif speed < 0:
speed = 0
speedByte = MIN_SPEED_BYTE + (FAST_SPEED_BYTE - MIN_SPEED_BYTE) * speed / 100
# Forward
output = speedByte << 2;
output += 0x01
i2c.write_byte_data(ADDRESS, 0, output)
def subscribeCallback(message, channel):
print('received, ' + channel + ':' + str(message))
if channel == CHANNEL_C_CONTROL:
speed = message['speed']
setSpeed(speed)
def subscribeError(message):
print(str(message))
pubnub.subscribe(SUBSCRIBE_CHANNELS, subscribeCallback, subscribeError)
