from pubnub import Pubnub
from gpiozero import LED
from time import sleep
import subprocess
pubnub = Pubnub(publish_key="pub-c-5b4ed4d3-8921-45cb-8151-d48aaebb2467",
subscribe_key="sub-c-f7b16a98-a291-11e6-a1b1-0619f8945a4f")
led = LED(17)
channel = "manage"
def callback(message, channel):
print('[' + channel + ']: ' + str(message))
if message == 'install':
print('install')
subprocess.call('./install.sh')
elif message == 'reboot':
print('reboot')
subprocess.call('./reboot.sh')
elif message == 'ledon':
print('ledon')
led.on()
sleep(5)
led.off()
pubnub.subscribe(channel, callback=callback)
def wrapper(self, *args, **kwargs):
if not hasattr(self, 'pubnub'):
pubnub_key = self.config.get_all()['pubnub']
self.pubnub = Pubnub(publish_key=pubnub_key['publish_key'],
subscribe_key=pubnub_key['subscribe_key'])
return func(self, *args, **kwargs)
## Web-controlled LED
import RPi.GPIO as GPIO
import time
import sys
from pubnub import Pubnub
GPIO.setmode (GPIO.BCM)
LED_PIN = 4
GPIO.setup(LED_PIN,GPIO.OUT)
pubnub = Pubnub(publish_key='demo', subscribe_key='demo')
channel = 'disco'
def _callback(m, channel):
print(m)
if m['led'] == 1:
for i in range(6):
GPIO.output(LED_PIN,True)
time.sleep(0.5)
GPIO.output(LED_PIN,False)
time.sleep(0.5)
print('blink')
def _error(m):
print(m)
GPIO.output(22,0)
GPIO.output(23,1)
def stop():
GPIO.output(17,0)
GPIO.output(18,0)
GPIO.output(22,0)
GPIO.output(23,0)
def lightOn():
GPIO.output(21, True)
GPIO.output(20, True)
def lightOff():
GPIO.output(21, False)
GPIO.output(20, False)
pubnub = Pubnub(publish_key=keys.PUBLISH, subscribe_key=keys.SUBSCRIBE)
def callback(message, channel):
print((message['move']))
if message['move'] == 'forwards':
forwards()
elif message['move'] == 'backwards':
backwards()
elif message['move'] == 'left':
left()
elif message['move'] == 'right':
right()
elif message['move'] == 'nudge-left':
left()
time.sleep(0.1)
stop()
from pubnub import Pubnub
import json
import time
pubnub = Pubnub(publish_key='pub-c-52dfaf38-9202-447f-a5c4-4fffdd0fdeac',
subscribe_key='sub-c-09f86e3c-2e1e-11e7-97de-0619f8945a4f')
#Initialize
NoOfMsgs = 0
NoOfDevices = 0
start_time = time.time()
#Subscribe Channels
StatusChannel = "StatusReport"
#Publish Channels
StatusReportChannel = "Checker"
def GetStatusCallback(message, channel):
time.sleep(7)
pubnub.publish(channel=StatusReportChannel, message="Check")
pubnub.subscribe(StatusChannel, callback=GetStatusCallback)
import os
from pubnub import Pubnub
import RPi.GPIO as GPIO
import time
pubnub = Pubnub(
publish_key=os.environ["PUBNUB_GT_PUBLISH"],
subscribe_key=os.environ["PUBNUB_GT_SUBSCRIBE"])
CHANNEL = "GitTreats"
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
pinMotorForwards = 10
GPIO.setup(pinMotorForwards, GPIO.OUT)
GPIO.output(pinMotorForwards, 0)
def turn_motor(duration):
GPIO.output(pinMotorForwards, 1)
time.sleep(duration)
GPIO.output(pinMotorAForwards, 0)
def callback(message, channel):
if message == "Give \'em a treat":
turn_motor(3)
def main():
pubnub.subscribe(channels=CHANNEL, callback=callback)
from pubnub import Pubnub
from os import system
txPin = 0 #wiringPi pin
pubnub = Pubnub(publish_key="YOU-PUB-KEY", subscribe_key="YOUR-SUB-KEY")
codes = {
'switch1': { #the name of the switch
'on': 4216115, #the code to turn the switch on
'off': 4216124, #the code to turn the switch off
'len': 187, #the length of the codes
},
'switch2': {
'on': 4216259,
'off': 4216268,
'len': 187,
},
'switch3': {
'on': 4216579,
'off': 4216588,
'len': 187,
},
'switch4': {
'on': 4218115,
'off': 4218124,
'len': 187,
},
'switch5': {
'on': 4224259,
'off': 4224268,
import sys
from pubnub import Pubnub
pubnub = Pubnub(publish_key='pub-c-df137065-b5ca-4b1d-841a-3f547ec9b6f0',
subscribe_key='sub-c-875a6a50-d26d-11e5-b684-02ee2ddab7fe')
channel = 'hello'
data = {'username': '******', 'message': 'Hello World from Pi!'}
def callback(m):
print(m)
pubnub.publish(channel, data, callback=callback, error=callback)
sensor = 4
GPIO.setmode(GPIO.BCM)
GPIO.setup(sensor, GPIO.IN, GPIO.PUD_DOWN)
previous_state = False
current_state = False
connection = http.client.HTTPSConnection('api.parse.com', 443)
connection.connect()
pubnub = Pubnub(publish_key = 'pub-c-f83b8b34-5dbc-4502-ac34-5073f2382d96',
subscribe_key = 'sub-c-34be47b2-f776-11e4-b559-0619f8945a4f',
uuid='pi')
cam = picamera.PiCamera()
lock = threading.Lock()
channel = 'iotchannel'
subchannel = 'liveCamStatus'
## Camera Settings
imgCount = 3
frameSleep = 0.5 # Seconds between burst-snaps
camSleep = 5 # Seconds between Detections
def _error(m):
print(m)
# Get PubNub settings from ENV
pnpubkey = os.environ['PN_PUBKEY']
pnsubkey = os.environ['PN_SUBKEY']
pnaction = os.environ['PN_ACTION']
pnstatus = os.environ['PN_STATUS']
# Get InfluxDB settings from ENV
idbhost = os.environ['IDB_HOST']
idbport = os.environ['IDB_PORT']
idbuser = os.environ['IDB_USER']
idbpass = os.environ['IDB_PASS']
idbusedb = os.environ['IDB_USEDB']
# PubNub Client Connection
pubnub = Pubnub(publish_key=pnpubkey, subscribe_key=pnsubkey)
# InfluxDB Client Connection
client = InfluxDBClient(idbhost, idbport, idbuser, idbpass, idbusedb)
# Publish readSensors action to imp on the action channel
def readSensors():
pubnub.publish(channel=pnaction, message='{"imp":"readSensors"}')
threading.Timer(300, readSensors).start()
# Unsubscribe from the status channel
def pnUnsubscribe():
pubnub.unsubscribe(channel=pnstatus)
def _callback(message, channel):
if 'measurement' in message:
from pubnub import Pubnub pubnub = Pubnub(publish_key="your pub key", subscribe_key="your sub key") print(pubnub.publish(channel='your channel name', message='your msg'))
import sys
from pubnub import Pubnub
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'pam'
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'pam'
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'pam'
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
# -----------------------------------------------------------------------
# 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,
auth_key="abcd")
channel = 'hello_world'
def callback(message):
print(message)
print(pubnub.revoke(channel_group='dev:abcd', auth_key="abcd"))
print(pubnub.audit(channel_group="dev:abcd"))
print(
pubnub.grant(channel_group='dev:abcd',
read=True,
write=True,
import RPi.GPIO as GPIO
import time
import os
import sys
from pubnub import Pubnub
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(17, GPIO.IN, pull_up_down = GPIO.PUD_UP)
GPIO.setup(22, GPIO.IN, pull_up_down = GPIO.PUD_UP)
GPIO.setup(7, GPIO.OUT)
pubnub = Pubnub(publish_key='pub-c-dc523a3b-b81c-430d-9eb6-37ffa0c9053c', subscribe_key='sub-c-2e3bb45c-1f8e-11e5-9dff-0619f8945a4f')
monitor = 'iot_garage_monitor'
def reset():
pubnub.publish(channel=monitor, message='RedBlkBtn.py GIPIO Reset Ready to Go')
reset()
def Shutdown(channel):
pubnub.publish(channel=monitor, message='RedBlkBtn.py Requested to Shutdown')
# os.system("sudo shutdown -h now")
def FireRelay(channel):
GPIO.output(7,False)
time.sleep(0.9)
GPIO.output(7,True)
pubnub.publish(channel=monitor, message='RedBlkBtn.py Relay Fired')
import RPi.GPIO as GPIO
import time
import sys
import Tkinter as tk
from pubnub import Pubnub
import json
pubnub = Pubnub(publish_key='pub-c-371bafb0-b1dc-4175-9bc0-6e68b7d512e2',
subscribe_key='sub-c-a11f9ed6-dc88-11e5-8905-02ee2ddab7fe')
channel = 'Channel-car'
# Enable GPIO pins DECLERATION (H-Bridge 1)
H1_enable_a = 23
H1_enable_b = 24
# Enable GPIO pins DECLERATION (H-Bridge 2)
H2_enable_a = 13
H2_enable_b = 26
# IN(1-4) GPIO pins DECLERATION (H-Bridge 1)
H1_IN1 = 4
H1_IN2 = 17
H1_IN3 = 27
H1_IN4 = 22
# IN(1-4) GPIO pins DECLERATION (H-Bridge 2)
H2_IN1 = 5
H2_IN2 = 6
H2_IN3 = 12
H2_IN4 = 16
####
#### Send the episode details via PubNub
####
from pubnub import Pubnub
import json
import time
import sys
from time import strftime
# Initialise PubNub
pubnub = Pubnub(publish_key='pub-c-92b5e647-0c49-49a1-ab2a-4753777f53b9', subscribe_key='sub-c-02de9d80-9a93-11e5-9a49-02ee2ddab7fe',
secret_key='sec-c-YTM5ZDM5ZmMtOTRmMS00Yzg2LThhYzQtYWI0Zjk2Yzg5M2U3')
channel = 'episodes'
# Organise message details
Videomessage = json.dumps({'level': 0, 'duration': sys.argv[1], 'start' : (strftime("%Y-%m-%d %H:%M"))})
# Send via PubNub
pubnub.publish(
channel = channel,
message = Videomessage)
from pubnub import PubnubTwisted as Pubnub
## =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
## Configuration
## =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
publish_key = 'pub-c-f6a20151-db8d-45af-ba42-def0edaa459f'
subscribe_key = 'sub-c-b5ff3208-7f64-11e4-b601-02ee2ddab7fe'
secret_key = 'demo'
server_channel = 'echo-server'
client_channel = 'echo-channel'
## =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
## Create PubNub Instance
## =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
pubnub = Pubnub(publish_key=publish_key,
subscribe_key=subscribe_key,
secret_key=secret_key,
ssl_on=True)
## =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
## Error Log
## =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
def error_log(data):
print(data)
## =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
## Access Log
## =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
def access_log(data):
print(data)
#!/usr/bin/python2.7
import os
import sys
from pubnub import Pubnub
pubnub = Pubnub(
publish_key='pub-c-xxxxxxxxxxxxxxxxxxxxxxxxxxxx3',
subscribe_key='sub-c-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx1')
channel = "Rcv-data"
def callback(m):
print m
def main():
while True:
os.system("clear")
print "1. Bulb on"
print "2. Bulb off"
print "3. Fan/Ac on"
print "4. Fan/Ac off"
print "5. Motor on"
print "6. Motor off"
choice = input("choice? : ")
if choice == 1:
data = {"bulb": 1}
pubnub.publish(channel, data, callback=callback, error=callback)
elif choice == 2:
data = {"bulb": 0}
import os
import time
import sys
from pubnub import Pubnub
import Adafruit_DHT as dht
pubnub = Pubnub(publish_key='pub-c-156a6d5f-22bd-4a13-848d-b5b4d4b36695',
subscribe_key='sub-c-f762fb78-2724-11e4-a4df-02ee2ddab7fe')
channel = 'tempeon'
def callback(message):
print(message)
#published in this fashion to comply with Eon
while True:
h, t = dht.read_retry(dht.DHT22, 4)
print 'Temp={0:0.1f}*C Humidity={1:0.1f}%'.format(t, h)
pubnub.publish(
'tempeon',
{'columns': [['x', time.time()], ['temperature_celcius', t]]})
pubnub.publish('humeon', {'columns': [['humidity', h]]})
def main():
global pn
pn = Pubnub(publish_key="demo", subscribe_key="demo", ssl_on=False)
loop()
from pubnub import Pubnub pubnub = Pubnub(publish_key="publish_key", subscribe_key="subscribe_key") print(pubnub.publish(channel='my_channel', message="on"))
import keys
from pubnub import Pubnub
pubnub = Pubnub(publish_key=keys.PUB_KEY, subscribe_key=keys.SUB_KEY)
def callback(message):
print(message)
pubnub.publish('my_channel_sf23',
'Hello from PubNub Python SDK!',
callback=callback,
error=callback)
while True:
pubnub.publish('my_channel_sf23',
raw_input(),
callback=callback,
error=callback)
from pubnub import Pubnub
from accounts.models import User
pub_nub = Pubnub(publish_key="pub-c-e89f7f1c-cf77-42e6-9f90-6f7f09413d4d",
subscribe_key="sub-c-82e403c8-0f8a-11e6-8c3e-0619f8945a4f")
def callback(message, channel):
if channel.startswith('agent'):
update_agent_location(message, channel)
def error(message):
print("ERROR : " + str(message))
def connect(message):
print("CONNECTED")
def reconnect(message):
print("RECONNECTED")
def disconnect(message):
print("DISCONNECTED")
def subscribe_global():
pass
def _error(message):
print(message)
def storeData(data):
client = MongoClient(url)
database = client['XChangeRate']
name = re.sub(r'USD/', '', data['name'])
collection = database[name]
collection.find_one_and_update(
{'time': data['time']},
{'$set': {
'price': data['price'],
'time': data['time']
}},
upsert=True)
if __name__ == '__main__':
msg_buffer = []
pubnub = Pubnub(publish_key="demo", subscribe_key=sub_key)
pubnub.subscribe(channels="xChangeRate", callback=_callback, error=_error)
while True:
if len(msg_buffer) > 0:
for msg in msg_buffer:
storeData(msg)
msg_buffer.pop(0)
def init(ch):
pubnub = Pubnub(publish_key='pub-c-xxxxxxxxxxxxxxxxxxxxxxxxxxx3',
subscribe_key='sub-c-xxxxxxxxxxxxxxxxxxxxxxxxx1')
channel = ch
return (pubnub, channel)
pubnub.subscribe_group(channel_groups=[channel_group],
callback=callback_group,
error=error,
connect=connect_group)
def _error(message):
test(False, "Channel Group Creation failed")
pubnub.channel_group_add_channel(channel_group=channel_group,
channel=channel_g,
callback=_callback,
error=_error)
pubnub = Pubnub(publish_key="ds",
subscribe_key="ds",
secret_key="ds",
ssl_on=False)
pubnub2 = Pubnub(publish_key="ds",
subscribe_key="ds",
secret_key="ds",
ssl_on=False)
pubnub_ssl = Pubnub(publish_key="ds",
subscribe_key="ds",
secret_key="ds",
ssl_on=True)
pubnub_ssl_2 = Pubnub(publish_key="ds",
subscribe_key="ds",
secret_key="ds",
import RPi.GPIO as GPIO
import sys
import time
import random
from pubnub import Pubnub
pubKey = 'pub-c-1b5f6f38-34c4-45a8-81c7-7ef4c45fd608'
subKey = 'sub-c-a3cf770a-2c3d-11e6-8b91-02ee2ddab7fe'
pubnub = Pubnub(publish_key=pubKey, subscribe_key=subKey)
channel = 'Olaf'
GPIO.setmode(GPIO.BCM) #board??
LIGHT = 2
GPIO.setup(LIGHT, GPIO.OUT)
redGpioMain = 9 #gpio9 = red
greenGpioMain = 6
blueGpioMain = 8
plainGpio = 2
GPIO.setup(redGpioMain, GPIO.OUT)
GPIO.setup(greenGpioMain, GPIO.OUT)
GPIO.setup(blueGpioMain, GPIO.OUT)
GPIO.setup(plainGpio, GPIO.OUT)
Freq = 100 #Hz
# Asynchronous usage
def callback(message, channel):
dictOfTwitterUNames = dict()
for key in message:
## http://www.pubnub.com/
import sys
from pubnub import Pubnub
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
## -----------------------------------------------------------------------
## 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, daemon=True)
channel = 'a'
# Asynchronous usage
def callback(message, channel):
print(message)
def error(message):
print("ERROR : " + str(message))
def connect(message):
print("CONNECTED")
import time
from pubnub import PubnubTornado as Pubnub
subkey = "sub-c-9aeec0d4-cdf4-11e5-bcee-0619f8945a4f"
pubkey = "pub-c-b3fdf8fc-4516-4ab2-8836-6fb22ba7870d"
secretkey = "sec-c-ZDQwNTUwMDctZDViYi00MzhlLTg2NTctYjViZDcwNTA5Zjhj"
pubnub = Pubnub(pubkey, subkey)
pubnub_pam = Pubnub(pubkey, subkey, secretkey)
# Grant permission read true, write true, on channel ( Async Mode )
def test_1():
def _callback(resp, ch=None):
assert resp == {
'message': 'Success',
'payload': {
'auths': {
'abcd': {
'r': 1,
'w': 1,
'm': 0
}
},
'subscribe_key': subkey,
'level': 'user',
'channel': 'abcd',
'ttl': 1
}
}
import os
import time
import sys
from pubnub import Pubnub
import Adafruit_DHT as dht
pubnub = Pubnub( publish_key = 'pub-c-3cfe4559-c152-42d9-9185-710fe1215e65',
subscribe_key = 'sub-c-828e2f18-4106-11e6-bfbb-02ee2ddab7fe')
# name : MD Hasib, MD_hz1994
channel = 'tempeon'
#channel = 'humeon'
def callback(message):
print(message)
while True:
h,t = dht.read_retry(dht.DHT11,4)
print 'Temp = {0:0.1f}*C Humidity = {1:0.1f}%'.format(t,h)
pubnub.publish('tempeon' , {
'columns': [
['x',time.time()],
['temperature_celcius',t]
]
})
pubnub.publish('humeon' , {
import RPi.GPIO as GPIO
import time
import sys
from pubnub import Pubnub
GPIO.setmode(GPIO.BOARD)
GPIO.setup(21, GPIO.OUT)
PIN_SERVO = 21
FREQ = 50
servo = GPIO.PWM(PIN_SERVO, FREQ)
servo.start(7.5)
pubnub = Pubnub(publish_key='pub-c-21d3cb4c-7809-43f5-938e-2c6139510cc9',
subscribe_key='sub-c-108945de-0ffa-11e6-a5b5-0619f8945a4f')
channel = 'door'
def _callback(m, channel):
print(m)
if m['item'] == 'door':
if m['open'] == True:
time.sleep(0.9)
servo.ChangeDutyCycle(4.5)
elif m['open'] == False:
time.sleep(1.65)
servo.ChangeDutyCycle(7.5)
def _error(m):
print(m)
