def test_get_latest_dweet_for(self):
"""`get_latest_dweet_for` should return a valid response.
"""
dweepy.dweet_for(self.my_thing_id, test_data)
dweets = dweepy.get_latest_dweet_for(self.my_thing_id)
check_valid_get_response(self, dweets)
def dataRotary(mqttclient):
knob = grove.GroveRotary(3)
myLcd = lcd.Jhd1313m1(0, 0x3E, 0x62)
twythonid = twitterHandler()
while True:
abs = knob.abs_value()
myLcd.setCursor(0,0)
myLcd.write('Health System')
myLcd.setColor(0, 128, 0)
myLcd.setCursor(1,0)
myLcd.write('Heart Rate %s' % abs)
while (abs > 950):
myLcd.setColor(255, 0, 0)
id = str(randint(0,1000))
status = "0x" + id + " #IoTLab Health System Heart Rate Warning " + str(abs)
mqttclient.publish("IoTPy/Buzzer", "None")
twythonid.update_status(status=status)
data = {}
data['alive'] = "1"
data['warning'] = "1"
data['message'] = status
dweepy.dweet_for('IoTHealthSystem', data)
time.sleep(1.5)
data['warning'] = "0"
data['message'] = ""
dweepy.dweet_for('IoTHealthSystem', data)
break
time.sleep(0.25)
def send_controller_dweet(self, is_launch, drone_id, latitude, longitude, country, is_real, is_game):
# If the dweet says that it is a launch, start a new drone
is_real_boolean = bool(is_real)
is_game_boolean = bool(is_game)
if is_launch:
drone_name = self.start_drone(drone_id, latitude, longitude, country, is_real_boolean, is_game_boolean)
dweet_to_app = {
'content': "Drone Launched",
'droneID': drone_id,
'drone_name': drone_name,
'is_launch': True,
'country': country,
'is_real': is_real_boolean,
'is_game_boolean': is_game_boolean
}
dweepy.dweet_for(self.controller_dweet_name, dweet_to_app)
logging.debug("Drone launched!")
self.drone_id_to_name[drone_id] = drone_name
# If the dweet says that it is not a launch, disable the drone with the dweeted UUID
else:
self.stop_drone(drone_id)
dweet_to_app = {
'content': "Drone disabled",
'droneID': drone_id,
'drone_name': self.drone_id_to_name[drone_id],
'is_launch': False,
'country': "N/A",
'is_real': is_real_boolean
}
dweepy.dweet_for(self.controller_dweet_name, dweet_to_app)
logging.debug("Drone stopped!")
def push_score( thing, score, text ):
dweepy.dweet_for(
'%s-score' % thing, {
'score': score,
'text': text
}
)
def send_data(name, msg):
"""Send the collected data to Dweet.io."""
import dweepy
try:
dweepy.dweet_for(name, msg)
except dweepy.DweepyError:
_LOGGER.error("Error saving data '%s' to Dweet.io", msg)
def exitHandler():
print "Exiting"
time.sleep(2)
dweetiodatasource['alive'] = "0"
dweetiodatasource['luxes'] = 0
dweetiodatasource['message'] = "None"
dweepy.dweet_for(dweetiothingname, dweetiodatasource)
sys.exit(0)
def functionServicesDweet():
while True:
time.sleep(5)
dweepy.dweet_for('InternetOfThings101Dweet', {'Status':'1'})
print dweepy.get_latest_dweet_for('InternetOfThings101Dweet')
time.sleep(5)
dweepy.dweet_for('InternetOfThings101Dweet', {'Status':'0'})
print dweepy.get_latest_dweet_for('InternetOfThings101Dweet')
def dataDweetHandler(): # Freeboard
light = grove.GroveLight(0)
data = {}
while True:
data['alive'] = "1"
data['network'] = dataNetwork()
data['light'] = light.value()
dweepy.dweet_for('InternetOfThings101x00', data)
time.sleep(5)
def functionDataSensor():
# netdata = psutil.net_io_counters()
# data = netdata.packets_sent + netdata.packets_recv
temp = sensTH.readTemperature()
hum = sensTH.readHumidity()
lig = sensL.value()
dweepy.dweet_for('IoT'+DeviceID, {'Temp':str(temp), \
'Hum':str(hum),'Lig':str(lig)})
print dweepy.get_latest_dweet_for('IoT'+DeviceID)
def test_dweet_for_with_an_invalid_key(self):
"""`dweet_for` with an invalid key should raise an exception.
"""
try:
dweepy.dweet_for(self.my_thing_id, test_data, key='badkey')
except dweepy.DweepyError as e:
self.assertEqual(e.args[0], 'the key you provided doesn\'t work with this thing')
else:
self.fail("shouldn't ever get called")
def test_dweet_for_without_a_key(self):
"""`dweet_for` without a key should raise an exception.
"""
try:
dweepy.dweet_for(self.my_thing_id, test_data)
except dweepy.DweepyError as e:
self.assertEqual(e.args[0], 'this thing is locked and requires a key')
else:
self.fail("shouldn't ever get called")
def report(thing, key, data):
"""
Publish a dweet for a thing.
key is used to create an hmac
"""
mac = calc_mac(key, json.dumps(data))
packet = {'data': data, 'sig': mac}
print('dweeting for {}!'.format(thing))
dweepy.dweet_for(thing, packet)
def try_read_data(carriots_client):
if radio.available():
len = radio.getDynamicPayloadSize()
receive_payload = radio.read(len)
print('Got payload size={} value="{}"'.format(len, receive_payload.decode('utf-8')))
values = receive_payload.split('|')
dweet = {'temp1': float(values[0].decode()), 'temp2': float(values[1].decode()), 'pressure': float(values[2].decode()), 'humidity': float(values[3].decode())}
print(dweet)
dweepy.dweet_for(thing_name, dweet)
msg_dict = {'protocol': 'v2', 'device': '*****@*****.**', 'at': 'now'}
msg_dict['data'] = dweet
carriots_client.publish(dumps(msg_dict))
def report_dweet(tempF):
timestamp = create_timestamp()
# print "At: {} it is {} degrees".format(timestamp,tempF)
try:
dweepy.dweet_for('orangemoose-moosetemp',{
'sensor': "Mooseometer",
'value': tempF,
'unit': "degrees F",
'time': timestamp,
});
except Exception, e:
print e
def test_dweet_for_alert(self):
"""`dweet_for` should not raise an exception no matter what alert condition is used
"""
dweepy.set_alert(
self.my_thing_id,
['*****@*****.**', '*****@*****.**'],
test_alert_condition,
test_key,
)
dweet = dweepy.dweet_for(self.my_thing_id, {'alertValue': 11}, key=test_key)
check_valid_dweet_response(self, dweet, skip_content=True)
dweet = dweepy.dweet_for(self.my_thing_id, {'alertValue': 5}, key=test_key)
check_valid_dweet_response(self, dweet, skip_content=True)
dweet = dweepy.dweet_for(self.my_thing_id, {'alertValue': 10}, key=test_key)
check_valid_dweet_response(self, dweet, skip_content=True)
def exitHandler():
global gServo, gTemp, myLcd, light, relay
threadlcd.do_run = False
threadlcd.join()
print "Exiting"
time.sleep(2)
datafreeboard['alive'] = "0"
datafreeboard['luxes'] = "0"
datafreeboard['Temp'] = "0"
datafreeboard['message'] = "System off"
dweepy.dweet_for('domotics', datafreeboard)
relay.off()
gServo.setAngle(0)
del gServo, gTemp, myLcd, light, relay
os._exit(0)
def send(args):
"""write the message to the queue"""
msgList = (' '.join(args.message)).split(";")
payLoad = []
for msg in msgList:
logger.debug('Message: ' + msg)
payLoad.append(msg)
logger.debug('Payload: ' + json.dumps(payLoad))
jsonPayLoad = {'message': payLoad}
logger.info('Dweeting to ' + args.queue)
try:
dweepy.dweet_for(args.queue, jsonPayLoad)
except dweepy.DweepyError as e:
logger.exception('Failed dweeting')
sys.exit(1)
def dweet():
if (DWEET_ENABLED):
dweetData = {}
dweetData['countTotal'] = len(Device.allDevices)
dweetData['countInHouse'] = len(Device.devicesInHouse)
for device in Device.allDevices:
dweetData[device.name] = {}
dweetData[device.name]['visible'] = device.visible
dweetData[device.name]['inHouse'] = device.inHouse
dweetData[device.name]['secondsSinceLastLeave'] = round(device.secondsSinceLastLeave(), 0)
dweetData[device.name]['secondsSinceLastJoin'] = round(device.secondsSinceLastJoin(), 0)
dweetData[device.name]['secondsSinceLastVisible'] = round(device.secondsSinceLastVisible(), 0)
dweepy.dweet_for(DWEET_THING_NAME, dweetData)
def test_valid_dweet_for(self):
"""`dweet_for` should return a valid response.
"""
my_thing_id = str(uuid.uuid4())
dweet = dweepy.dweet_for(my_thing_id, test_data)
check_valid_dweet_response(self, dweet)
self.assertEqual(dweet['thing'], my_thing_id)
def publish_status(self, target, temp, heater_percent, cooler_percent):
if (datetime.now() - self._last_published).seconds < self._frequency:
# Don't Dweet until the defined frequency has passed.
return
try:
response = dweepy.dweet_for(
self._thing_name,
{
'temperature': temp,
'target': target,
'heater': heater_percent,
'cooler': cooler_percent,
}
)
except Exception as err:
raise OutputError(
'Error publishing to Dweet API: {0}'.format(err))
if response['this'] != 'succeeded':
print response
raise OutputError(
'Error publishing to Dweet API: {0}'.format(response['this']))
else:
self._last_published = datetime.now()
def dumpToDweet(data):
# dweetUrl = 'http://dweet.io:80/dweet/for/decisive-train/'
info = {
"user": "******",
"genericName": data["product"]["generic_name"],
"code": data["code"],
"calories": data["product"]["nutriments"]["energy"],
}
dweepy.dweet_for("decisive-train", info)
# resp = requests.post(dweetUrl, data=json.dumps(info), headers=headers)
# print resp
return {
"user": "******",
"genericName": data["product"]["generic_name"],
"code": data["code"],
"calories": data["product"]["nutriments"]["energy"],
}
def send(args):
"""write the message to the queue"""
msgList = (' '.join(args.message)).split(";")
payLoad = []
for msg in msgList:
logger.debug('Message: ' + msg)
payLoad.append(msg)
logger.debug('Payload: ' + json.dumps(payLoad))
jsonPayLoad = {'message': payLoad}
logger.info('Dweeting to ' + args.queue)
try:
dweepy.dweet_for(args.queue, jsonPayLoad)
# except dweepy.DweepyError as e:
except dweepy.DweepyError:
logger.exception('Failed dweeting')
# FIXME Where does this exit come from?
# Perhaps should be imported from sys?
exit(1)
def send(self, data):
# send data to dweet
try:
response = dweepy.dweet_for(self.dweet_name, data)
except Exception as exception:
response = {'error': exception.message}
return response
def uploadDweet():
time_d = time.time()
while(True):
if(time.time()-time_d > 5):
print "Sending data, " + str(time.time())
time_d = time.time()
while (redis_q.llen('queue') > 0):
print "Queue len: %s" % redis_q.llen('queue')
message = redis_q.blpop('queue')
message_d = cPickle.loads(message[1])
thing = message_d[0]
data = message_d[1]
try:
#pass
dweepy.dweet_for(thing, data)
except:
print "Error dweepy"
print "cleared queue"
def dataNetworkHandler():
i=0
a=0
b=15
mqttclient = paho.Client()
mqttclient.on_publish = on_publish
mqttclient.connect("test.mosquitto.org", 1883, 60)
while True:
dataWeatherHandler()
LcdShow=" "
print bar0
print "Hello Internet of Things 101"
idDevice=GetMACAdress()
myLcd.setColor(53, 39, 249)
packets = dataNetwork()
message = idDevice + " " + str(packets)
print "dataNetworkHandler " + message
print "MQTT dataNetworkHandler " + message
pass0={'network':packets}
dweepy.dweet_for('hvelazquezs',pass0)
mqttmsg="IoT101/"+idDevice+"/Network"
mqttclient.publish(mqttmsg,message)
LcdShow=('MAC: '+ idDevice)
myLcd.setCursor(1,8)
myLcd.write(' CPU%'+str(psutil.cpu_percent()))
myLcd.setCursor(0,0)
myLcd.write(LcdShow[a:b])
myLcd.setCursor(1,0)
myLcd.write('Pk:' + str(packets))
data[i]=message
a=a+1
b=b+1
i=i+1
if (b>=23):
a=0
b=15
if (i==16):
i=0
time.sleep(2)
def dataNetworkHandler():
global idDevice
idDevice = GetMACAddress() # Make this a global variable
mqttclient = paho.Client()
mqttclient.on_publish = on_publish
adaclient = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY)
mqttclient.connect("test.mosquitto.org", 1883, 60)
adaclient.connect()
#adaclient.loop_background()
while True:
packets = dataNetwork()
global message
message = idDevice + " " + str(packets)
#pdb.set_trace()
print "dataNetworkHandler " + message
mqttclient.publish("IoT101/"+idDevice+"/Network", message)
adaclient.publish("IoT101/"+idDevice+"/Network", message)
json = {'id':idDevice,'packets':int(packets)}
dweepy.dweet_for('DataReportingSystem',json)
time.sleep(3)
def dumpToDweet(data, aggrData, user):
alert = isProhibited(data, user)
info = getDefaultInfo(user)
aggrData = getDefaultAggrDoc(aggrData)
info = {
"user": user,
"genericName": data["product"]["product_name"],
"code": data["code"],
"calories": data["product"]["nutriments"]["energy"],
"caloriesForToday": aggrData["caloriesForToday"],
"carbsForToday": aggrData["carbsForToday"],
"fatForToday": aggrData["fatForToday"],
"proteinsForToday": aggrData["proteinsForToday"],
"weekly_calories": "10,2,3,5,6,7,8",
"alert": alert,
}
dweepy.dweet_for("decisive-train", info)
return info
def sendTemperature(id, t, ws):
value = {}
update = {}
temperature = {}
sensorID = {}
connectionType = {}
device = {}
# Generate an ISO 8601 timestamp for the data packet
lognow = time.gmtime(time.time())
timestamp = ( '{0}-{1:02d}-{2:02d}T{3:02d}:{4:02d}:{5:02d}Z'.
format(lognow.tm_year,lognow.tm_mon,lognow.tm_mday,
lognow.tm_hour,lognow.tm_min,lognow.tm_sec) )
value["value"] = t
value["unit"] = "degrees F"
value["time"] = timestamp
value["name"] = id
update[".update"] = value
temperature["temperature"] = update
sensorID[id] = temperature
connectionType["IP"] = sensorID
device["device"] = connectionType
# DEBUG: print "sending msg: ", json.dumps(device, indent=4)
# Output what we sent (for logging purposes)
# print "{0},{1:.3f}".format(timestamp,t)
logstring(timestamp + "," + str(t) + "\n")
# Send the value to the server via our websocket
ws.send(json.dumps(device))
# Oh, and dweet the data while we're at it (for fun)
dweepy.dweet_for('orangemoose-thingy', {
'sensor': id,
'value': t,
'unit': "degrees F",
'time': timestamp,
});
def post(dic):
thing = 'LauraPi'
print(dweepy.dweet_for(thing, dic))
import psutil
import signal
import sys
import time
from flask import Flask, jsonify
app = Flask(__name__)
def ThingDataSensors():
netdata = psutil.net_io_counters()
return netdata.packets_sent + netdata.packets_recv
def ThingDataActuators():
return "Thing Data Actuators"
def SignalHandler(signal, frame):
sys.exit(0)
if __name__ == '__main__':
signal.signal(signal.SIGINT, SignalHandler)
while True:
dweepy.dweet_for('DweetThingDataSensors', {'Sensors': ThingDataSensors()})
dweepy.dweet_for('DweetThingDataActuators', {'Actuators': ThingDataActuators()})
time.sleep(5)
# End of File
def post(dic):
thing = 'ultra-rpi'
print dweepy.dweet_for(thing, dic)
# #
# You should have received a copy of the GNU General Public License #
# along with this program. If not, see <http://www.gnu.org/licenses/>. #
################################################################################
import dweepy
import Adafruit_MCP3008
import time
## Software SPI setup
CLK = 11
MISO = 9
MOSI = 10
CS = 8
mcp = Adafruit_MCP3008.MCP3008(clk=CLK, cs=CS, miso=MISO, mosi=MOSI)
## Convert 10-bit ADC output to RGB friendly 0-255, store as variables
## NewValue = (((OldValue - OldMin) * (NewMax - NewMin) / (OldMax - OldMin)) + $
while True:
red = (((mcp.read_adc(0) - 0) * (255 - 0)) / (1023 - 0)) + 0
blue = (((mcp.read_adc(2) - 0) * (255 - 0)) / (1023 - 0)) + 0
green = (((mcp.read_adc(1) - 0) * (255 - 0)) / (1023 - 0)) + 0
dweepy.dweet_for('pot-one', {'red': red})
time.sleep(0.1)
dweepy.dweet_for('pot-two', {'blue': blue})
time.sleep(0.1)
dweepy.dweet_for('pot-three', {'green': green})
time.sleep(0.2)
#else:
# print_id = 0
text += "(" + str(print_id+1) + "/" + str(no_of_sensors) + ")"
#text += sensor_names[print_id] + ": " + str(sensor_values[print_id])
setText(text)
if not data_available:
setRGB(50, 50, 50)
data_available = True
#Try to dweet it
try:
dweepy.dweet_for('OpenData',
{'Sound': sound_level,
'Light': light_intensity,
'Temperature': temp,
'Humidity': hum,
'WindDirection': wind_direction,
'Distance': distance,
'Switch' : switch})
dweepy.dweet_for('OpenData2',
{'Sound': sound_level+randint(0,50),
'Light': light_intensity+randint(0,100),
'Temperature': temp + +randint(0,5),
'Humidity': hum +randint(0,20),
'WindDirection': wind_direction + randint(0,25),
'Distance': distance + randint(0,5),
'Switch' : switch + +randint(0,1)})
except:
print " Dweetio exception"
def post(dict):
thing = 'mike_ca'
print dweepy.dweet_for(thing, dict)
pass
}
}
}
mqttc.publish("$aws/things/TARC/shadow/update", json.dumps(payload), qos=1)
#publish for dynamodb
payload = {
"datetime": str(datetime.datetime.now()),
"temperature": str(temp_value),
"ldr": str(ldr_value)
}
mqttc.publish("TARC/sensors", json.dumps(payload), qos=1)
#registro em arquivo
arq.write(str(x)+" -> temp = "+str(temp_value)+", ldr = "+str(ldr_value))
arq.write("\n")
x = x + 1
dweepy.dweet_for(
'tarc',
{
'datetime': time,
'temperature': temp_value,
'ldr': ldr_value,
'terremoto': terremoto,
'enchente': enchente,
'tempestade': tempestade,
'latitude': -23.581497,
'longitude': -47.526555,
})
# Configuracion del puerto GPIO al cual esta conectado (GPIO 23)
pin = 23
# Intenta ejecutar las siguientes instrucciones, si falla va a la instruccion except
try:
# Ciclo principal infinito
while True:
# Obtiene la humedad y la temperatura desde el sensor
humedad, temperatura = Adafruit_DHT.read_retry(sensor, pin)
# Imprime en la consola las variables temperatura y humedad con un decimal
print('Temperatura={0:0.1f}* Humedad={1:0.1f}%'.format(
temperatura, humedad))
dweepy.dweet_for('sensor', {'temp': temperatura, 'humedad': humedad})
{
u'content': {
u'temp': temperatura,
'humedad': humedad
},
u'created': u'2019-03-18',
u'thing': u'dht11'
}
# Duerme 10 segundos
time.sleep(10)
# Se ejecuta en caso de que falle alguna instruccion dentro del try
except Exception as e:
# Imprime en pantalla el error e
def post(dic):
thing = 'get_your_own_thing'
print dweepy.dweet_for(thing, dic)
def post(readings):
thing = config.thing
print dweepy.dweet_for(thing, readings)
def publish_dweepy(inverter):
try:
result = dweepy.dweet_for(config.dweepy_uuid,inverter)
print("[INFO] Sent to dweet.io")
except:
result = None
def post(dic):
thing='therapeutic-caption'
#dweet.io
print dweepy.dweet_for(thing, dic)
def send_update(metric,
value): #method for sending updates about metrics as needed.
logger.debug("Sending update for {}: {}".format(metric, value))
dweepy.dweet_for(configstuff['dweet_thing'], {metric: value})
try:
curs.execute("INSERT INTO temppi (batchname, tempc, tempf, tstamp) VALUES(?, ?, ?, ?);", (batch, temp_c, temp_f, datetime.datetime.now() ) )
conn.commit()
last_temp[batch] = '{:0.4f}'.format(temp_c)
print (" Logged temp in DB", end="")
except sqlite3.Error as er:
print (" Couldn't log temp into database: " + er.message, end="")
if broadcast == 'true':
dweet_packet[probecnt] = {'temp_f':'{:0.4f}'.format(temp_f), 'temp_c':'{:0.4f}'.format(temp_c), 'localtime':datetime.datetime.now().isoformat(), 'batch-id' : batch }
print ("")
# End of active if statement
if len(dweet_packet.keys()):
try:
dweet_key = get_key( find_dotenv(), 'DWEETY-KEY' ).lower()
if dweet_key != '':
dweepy.dweet_for( dweet_key, dweet_packet )
print (" Dweeted", end="")
except:
print (" Couldn't log temp to dweetly",sys.exc_info()[0], end="")
print ("")
freq = get_key( find_dotenv(), 'POLL-FREQ' )
freq = int(freq) or int(15)
time.sleep(freq)
if retries == 9:
return (0)
# Split the text with new lines (\n) and select the second line.
secondline = text.split("\n")[1]
# Split the line into words, referring to the spaces, and select the 10th word (counting from 0).
temperaturedata = secondline.split(" ")[9]
# The first two characters are "t=", so get rid of those and convert the temperature from a string to a number.
temperature = float(temperaturedata[2:])
# Put the decimal point in the right place and display it.
temperature = temperature / 1000
temp = float(temperature)
return (temp)
def get_ip():
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
ip = s.getsockname()[0]
s.close()
return (ip)
while 1:
reading = GetTemperature()
ip = get_ip()
# values = (time.strftime('%d/%m/%Y %H:%M:%S'), reading)
values = {"timestamp": time.time(), "temp": reading, "IP address": ip}
dweepy.dweet_for("rpi_klima2", values)
print values
time.sleep(interval)
def print_image():
if wireless.current() == printer_ssid:
os.system("instax-print Intruder.jpeg -i 1111")
else:
switch_to_printer_network()
switch_to_robot_network()
try:
response = dweepy.get_latest_dweet_for('misty')
old_status = str(response[0]["created"])
print("START:", old_status)
except:
dweepy.dweet_for('misty', {'status': 'script_start'})
time.sleep(2)
while True:
try:
time.sleep(1.5)
response = dweepy.get_latest_dweet_for('misty')
new_status = str(response[0]["created"])
print("NOW: ", new_status)
if new_status != old_status:
old_status = new_status
print("Trigger Alarm")
print("Preparing Image")
prepare_image()
print("Connecting to printer network")
x = switch_to_printer_network()
def interruptHandler(signal, frame):
sys.exit(0)
if __name__ == '__main__':
signal.signal(signal.SIGINT, interruptHandler)
touch = ttp223.TTP223(6)
myLcd = lcd.Jhd1313m1(0, 0x3E, 0x62)
button = grove.GroveButton(8)
count = 0
myLcd.setColor(0, 0, 255)
# Read the input and print, waiting 1/2 second between readings
while 1:
contador = {}
if button.value():
count = count + 1
if touch.isPressed():
count = count - 1
myLcd.setCursor(0, 0)
myLcd.write('%6d' % count)
contador["conteo"] = count
dweepy.dweet_for("Legalileo_racso1290", contador)
time.sleep(0.5)
del button
del touch
GPIO.output(buzzer, GPIO.HIGH)
while True:
GPIO.output(redLED, GPIO.HIGH)
time.sleep(0.1)
GPIO.output(redLED, GPIO.HIGH)
else:
GPIO.output(buzzer, GPIO.LOW)
while True:
GPIO.output(greenLED, GPIO.HIGH)
time.sleep(1)
GPIO.output(greenLED, GPIO.HIGH)
print('Distance = '), d, ('cm')
buzzerStatus = GPIO.input(17)
if buzzerStatus == True:
buzzerSignal = True
else:
buzzerSignal = False
iot_data = {
'Distance': d,
'systemName': 'Front Gate Detection System',
'Buzzer': buzzerSignal
}
dweepy.dweet_for('distance_mark10', iot_data)
time.sleep(0.1)
GPIO.cleanup()
'Vertical Speed' : truncate(vessel.vessel_vertical_speed),
}
'Orbit':{
'Vessel Periapsis' : vessel_periapsis,
'Vessel Apoapsis' : vessel_apoapsis,
'Time To Periapsis' : vessel_time_to_periapsis,
'Time To Apoapsis' : vessel_time_to_apoapsis,
}
'Resources':{
'EletricCharge Current' : truncate(vessel.resource_ec_current),
'EletricCharge Max' : truncate(vessel.resource_ec_max),
'Oxidizer Current' : truncate(vessel.resource_ox_current),
'Oxidizer Max' : truncate(vessel.resource_ox_max),
'MonoPropellant Current' : truncate(vessel.resource_mp_current),
'MonoPropellant Max' : truncate(vessel.resource_mp_max),
'LiquidFuel Current' : truncate(vessel.resource_lf_current),
'LiquidFuel Max' : truncate(vessel.resource_lf_max),
'SolidFuel Current' : truncate(vessel.resource_sf_current),
'SolidFuel Max' : truncate(vessel.resource_sf_max),
}
}
dweepy.dweet_for(thingId,myDweet)
i += 1
print ('\r'+'Still working alright, '+ str(i) + ' packets sent', end ='')
def SIGINTHandler(signum, frame):
raise SystemExit
def exitHandler():
print "Exiting"
time.sleep(2)
dweetiodatasource['alive'] = "0"
dweetiodatasource['luxes'] = 0
dweetiodatasource['message'] = "None"
dweepy.dweet_for(dweetiothingname, dweetiodatasource)
sys.exit(0)
atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler)
if __name__ == '__main__':
message = "Hello Xpuhil!"
while True:
luxes = light.value()
dweetiodatasource['alive'] = "1"
dweetiodatasource['luxes'] = luxes
dweetiodatasource['message'] = message
dweepy.dweet_for(dweetiothingname, dweetiodatasource)
time.sleep(2)
def SIGINTHandler(signum, frame):
raise SystemExit
def exitHandler():
print "Exiting"
time.sleep(2)
datafreeboard['alive'] = "0"
datafreeboard['luxes'] = 0
datafreeboard['message'] = "None"
dweepy.dweet_for(datadweet, datafreeboard)
sys.exit(0)
atexit.register(exitHandler)
signal.signal(signal.SIGINT, SIGINTHandler)
if __name__ == '__main__':
message = "Hola Cacerola! I'm Xpuhil!"
while True:
luxes = light.value()
datafreeboard['alive'] = "1"
datafreeboard['luxes'] = luxes
datafreeboard['message'] = message
dweepy.dweet_for(datadweet, datafreeboard)
time.sleep(1)
global gpsd
while gpsp.running:
gpsd.next()
if __name__ == '__main__':
gpsp = GPSMain()
try:
gpsp.start()
while True:
os.system('clear')
myDweet['latitude'] = gpsd.fix.latitude
myDweet['longitude'] = gpsd.fix.longitude
print
print ' GPS Statistics'
print '----------------------------------------'
print 'latitude ', gpsd.fix.latitude
print 'longitude ', gpsd.fix.longitude
print 'time utc ', gpsd.utc, ' + ', gpsd.fix.time
print 'altitude (m)', gpsd.fix.altitude
print 'speed (m/s) ', gpsd.fix.speed
print '----------------------------------------'
dweepy.dweet_for(sender, myDweet)
time.sleep(3) #set to whatever
except (KeyboardInterrupt, SystemExit): #when you press ctrl+c
gpsp.running = False
gpsp.join() # wait for the thread to finish what it's doing
print "Done.\nExiting."
def send_update(metric, value): #method for sending updates about metrics as needed.
logger.debug("Sending update for {}: {}".format(metric, value))
dweepy.dweet_for(configstuff['dweet_thing'], {metric: value})
def post(result): #posts to dweet
thing = get_file()
print dweepy.dweet_for(thing, result)
def listener(publisher_thread):
print "listener thread..."
for dweet in dweepy.listen_for_dweets_from('canary30_iot'):
global lights_state #declaring global variable for sensor and actuator states
global motion_state
global Pan_state
global Tilt_state
print "Got the dweet things"
my_dweet = dweet #creating a new variable my_dweet
content = my_dweet["content"] #my_dweet contains "content" which has the JSON dweet values
lights_state = content["lights"] #String lights is declared to lights_state
Pan_state = content["pan"] #String pan is declared to Pan_state
Tilt_state = content ["tilt"] #String tilt is declared to Tilt_state
print "Contents opened"
# Lights
if lights_state == "true": #This if statement turns on lights if lights equals to true
LEDRight.write(1)
LEDLeft.write(1)
print "Right light is ON"
lights_state = "On"
elif lights_state == "false": #This if statement turns off lights if lights equals to false
print "<<<Turn off Right Light>>>"
LEDRight.write(0)
LEDLeft.write(0)
print "<<<Right light is OFF>>>"
lights_state = "Off"
# Pan Right
if Pan_state == "true": # This if statement turns the camera right if equals to true
servoPan.enable(False);
servoPan.pulsewidth_us(500)
servoPan.enable(True);
time.sleep(1)
servoPan.enable(False);
print "Pan turnned right"
Pan_state = "right"
# Pan Center
elif Pan_state == "false": # This if statement turns the camera facing forward if equals to false
servoPan.enable(False);
servoPan.pulsewidth_us(1200)
servoPan.enable(True);
time.sleep(1)
servoPan.enable(False);
print "Pan is looking forward"
Pan_state = "center"
# Pan left
if Pan_state == "left":
servoPan.enable(False);
servoPan.pulsewidth_us(2000)
servoPan.enable(True);
LEDLeft.write(1)
time.sleep(1)
servoPan.enable(False);
print "Pan turned left"
Pan_state = "left"
elif Tilt_state == "down":
servoTilt.enable(False);
servoTilt.pulsewidth_us(1050)
servoTilt.enable(True);
time.sleep(1)
servoTilt.enable(False);
print "Tilted DOWN"
Tilt_state = "up"
# Tilt camera Up
if Tilt_state == "true":
servoTilt.enable(False);
servoTilt.pulsewidth_us(650)
servoTilt.enable(True);
time.sleep(1)
servoTilt.enable(False);
print "Tilted UP"
Tilt_state = "up"
# Straighten camera
elif Tilt_state == "false":
servoTilt.enable(False);
servoTilt.pulsewidth_us(850)
servoTilt.enable(True);
time.sleep(1)
servoTilt.enable(False);
print "Camera Level"
Tilt_state = "straight"
# PIR Motion Sensor
if pir.value(): #The Motion sensor sends its values to canary30_iot
print "***Motion is ON***"
result = dweepy.dweet_for('canary30_pir', {'pir': "true"})
print result
dict= pir.value()
# saves data to a local file (Canary_Backup_Data.txt) only when motion was detected
backupFile = open('Canary_Backup_Data.txt', 'a')
stringToWrite = str(dict)
timeToWrite = datetime.datetime.now().strftime(dateString)
backupFile.write(timeToWrite + " " + stringToWrite + '\n')
backupFile.close()
else:
print "<<<Moton is OFF>>>"
result = dweepy.dweet_for('canary30_pir', {'pir': "false"})
print result
time.sleep(2)
if publisher_thread.is_alive(): # Activate or continue publisher
print "Yes it is alive"
else:
publisher_thread.start()
def interruptHandler(signal, frame):
sys.exit(0)
if __name__ == '__main__':
signal.signal(signal.SIGINT, interruptHandler)
touch = ttp223.TTP223(6)
myLcd = lcd.Jhd1313m1(0, 0x3E, 0x62)
button = grove.GroveButton(8)
count = 0
myLcd.setColor(0, 0, 255)
# Read the input and print, waiting 1/2 second betweenreadings
while 1:
if button.value():
count = count + 1
if touch.isPressed():
count = count - 1
myLcd.setCursor(0, 0)
myLcd.write('%6d' % count)
time.sleep(0.5)
dic = {}
dic["cont"] = count
dweepy.dweet_for("Aracelis", dic)
time.sleep(1)
del button
del touch
