def send_to_is(bucket_name, bucket_key, access_key, weather): try: streamer = Streamer(bucket_name, bucket_key, access_key) # Temperature temp = weather.get_temperature(unit='fahrenheit').get('temp') streamer.log('Temperature (F)', temp) # Cloud coverage cloud = str(weather.get_clouds()) + '%' streamer.log('Cloud Coverage', cloud) # Detailed status detail_status = weather.get_detailed_status() streamer.log('Detailed Status', detail_status) # Humidity humidity = str(weather.get_humidity()) + '%' streamer.log('Humidity', humidity) # Visibility distance visibility_distance = weather.get_visibility_distance() streamer.log('Visibility Distance (m)', visibility_distance) # Wind speed wind_speed = weather.get_wind().get('speed') streamer.log('Wind Speed (m/s)', wind_speed) # Wind degree wind_degree = weather.get_wind().get('deg') streamer.log('Wind Degree', wind_degree) finally: streamer.close()
def post_data_to_initialstate(field_name, sensor_value): streamer = Streamer(bucket_name=BUCKET_NAME, bucket_key=BUCKET_KEY, access_key=IS_ACCESS_KEY) # send some data streamer.log(field_name, sensor_value) # flush and close the stream streamer.close()
async def send_data(): stream_data = deepcopy(data.statsDict) stream_data['user_count'] = len(data.userSet) stream_data['server_count'] = len(bot.guilds) stream_data['total_command_count'] = await bot.cogs.get('StatsCog').get_total_helper(data.statsDict) streamer = Streamer(bucket_name="Feyre", bucket_key=bucket_key, access_key=access_key, buffer_size=200) streamer.log_object(stream_data) streamer.flush() streamer.close()
def logToInitialState(self): utcnow = datetime.utcnow() bucketKey = "{0} - coffee_scale_data".format(self.environment) streamer = Streamer(bucket_name="{0} - Coffee Scale Data".format(self.environment), bucket_key=bucketKey, access_key=self.initialStateKey) if self.potIsLifted(): streamer.log("Coffee Pot Lifted", True) streamer.log("Coffee Weight", self._currentWeight) streamer.close()
def main(): streamer = Streamer(bucket_name=args.bucket, access_key=apiKey) try: while True: resultLines = read_temp_raw(args.sensor) save_result(args.sensor, resultLines, streamer) print(INFO,"Cycle finished, sleeping %ss" %(args.delay)) time.sleep(args.delay) except KeyboardInterrupt: streamer.close()
def send_value(t): # Streamer constructor, this will create a bucket called Python Stream Example # you'll be able to see this name in your list of logs on initialstate.com # your access_key is a secret and is specific to you, don't share it! streamer = Streamer(bucket_name="Temperature Perros-Guirec", bucket_key="VFSWQRTVFX56", access_key="TpxF1xIFECwXn4XuGsGYvHHAhLY1kJHU") streamer.log("temp", t) streamer.log("temperature Perros-Guirec", t) # Once you're finished, close the stream to properly dispose streamer.close() return
def main(): streamer = Streamer(bucket_name=args.bucket, access_key=apiKey, bucket_key=args.bucket_key) try: while True: resultLines = read_temp_raw(args.sensor) save_result(args.sensor, resultLines, streamer) print(INFO, "Cycle finished, sleeping %ss" % (args.delay)) time.sleep(args.delay) except KeyboardInterrupt: streamer.close()
def logToInitialState(self): utcnow = datetime.utcnow() bucketKey = "{0} - coffee_scale_data".format(self.environment) streamer = Streamer(bucket_name="{0} - Coffee Scale Data".format( self.environment), bucket_key=bucketKey, access_key=self.initialStateKey) if self.potIsLifted(): streamer.log("Coffee Pot Lifted", True) streamer.log("Coffee Weight", self._currentWeight) streamer.close()
def initialstate_stream_reading(reading): if "initialstate.enabled" not in configs or configs[ "initialstate.enabled"] != 1: return try: from ISStreamer.Streamer import Streamer streamer = Streamer(bucket_name=configs["initialstate.bucket_name"], bucket_key=configs["initialstate.bucket_key"], access_key=configs["initialstate.access_key"]) streamer.log(key=configs["initialstate.item_key"], value=reading) streamer.flush() streamer.close() log.log_restarts("sent initialstate reading") except Exception as ex: log.log_errors("problem streaming reading to initialstate!")
class InitialStateLogObject(TerminatorBlock): """ Initial State block for logging objects """ version = VersionProperty("1.0.0") access_key = StringProperty(title='Access Key', default='[[INITIAL_STATE_ACCESS_KEY]]') bucket_name = StringProperty(title='Bucket Name', default='New Bucket') bucket_key = StringProperty(title='Bucket Key', default='') object = Property(title='Object', default='{{ $.to_dict() }}') buffer_size = IntProperty(title='Buffer Size', default=10) def __init__(self): super().__init__() self._streamer = None def configure(self, context): super().configure(context) try: kwargs = {'access_key': self.access_key()} if self.bucket_name(): kwargs['bucket_name'] = self.bucket_name() if self.bucket_key(): kwargs['bucket_key'] = self.bucket_key() if self.buffer_size(): kwargs['buffer_size'] = self.buffer_size() self._streamer = Streamer(**kwargs) except Exception as e: self.logger.error("Failed to create streamer: {}".format(e)) raise e def process_signals(self, signals): for s in signals: try: self._streamer.log_object(self.object(s)) except Exception as e: self.logger.warning("Failed to log object: {}".format(e)) self._streamer.flush() def stop(self): super().stop() self._streamer.close()
def main(argv): bucket = '' access_key = '' try: opts, args = getopt.getopt(argv,"hb:k:",["bucket_name=", "access_key="]) except getopt.GetoptError: print('example_command_line.py -b <bucket_name> -k <access_key>') for opt, arg in opts: if opt == '-h': print('example_command_line.py -b <bucket_name> -k <access_key>') elif opt in ("-b", "--bucket_name"): bucket = arg elif opt in ("-k", "--access_key"): access_key = arg streamer = Streamer(bucket_name=bucket, access_key=access_key) try: while 1: log = '' try: if (sys.version_info < (2,7,0)): sys.stderr.write("You need at least python 2.7.0 to use the ISStreamer") exit(1) elif (sys.version_info >= (3,0)): log = input() else: log = raw_input() except EOFError: break parts = log.split(',') if len(parts) == 2: streamer.log(parts[0].strip(), parts[1].strip()) else: print("format should be \"key, value\"") except KeyboardInterrupt: streamer.close()
def main(): sensor = W1ThermSensor() pool_streamer = Streamer( bucket_name="Pool Temperature", access_key="PFphNne4eMOAMQ6EiIW5DT0BNWEIunAT", bucket_key="RPSVL4LX8S7H") pi_streamer = Streamer( bucket_name="Pi Temperature", access_key="PFphNne4eMOAMQ6EiIW5DT0BNWEIunAT", bucket_key="8YXAKKXW348W") try: while True: pi_temp = read_pi_temp() send_data_to_InitialState( "Onboard Pi Temperature", pi_temp, pi_streamer ) print( "Pi onboard temperature is %.2f" % ( pi_temp ) ) temp_in_fahrenheit = sensor.get_temperature( W1ThermSensor.DEGREES_F ) send_data_to_InitialState( "Pool Temperature Sensor", temp_in_fahrenheit, pool_streamer ) print( "Sensor %s has temperature %.2f" % ( sensor.id, temp_in_fahrenheit ) ) time.sleep( delay ) except KeyboardInterrupt: pool_streamer.close() pi_streamer.close()
def main(argv): bucket = "" access_key = "" try: opts, args = getopt.getopt(argv, "hb:k:", ["bucket_name=", "access_key="]) except getopt.GetoptError: print("example_command_line.py -b <bucket_name> -k <access_key>") for opt, arg in opts: if opt == "-h": print("example_command_line.py -b <bucket_name> -k <access_key>") elif opt in ("-b", "--bucket_name"): bucket = arg elif opt in ("-k", "--access_key"): access_key = arg streamer = Streamer(bucket_name=bucket, access_key=access_key) try: while 1: log = "" try: if sys.version_info < (2, 7, 0): sys.stderr.write("You need at least python 2.7.0 to use the ISStreamer") exit(1) elif sys.version_info >= (3, 0): log = input() else: log = raw_input() except EOFError: break parts = log.split(",") if len(parts) == 2: streamer.log(parts[0].strip(), parts[1].strip()) else: print('format should be "key, value"') except KeyboardInterrupt: streamer.close()
# ########################################## # This script is an example # of how to hit the stream limit # on a free account, who's cap is set # prorated for when then plan is selected. # ########################################### from math import ceil import time, calendar, datetime from ISStreamer.Streamer import Streamer now = datetime.datetime.now() days_in_month = calendar.monthrange(now.year, now.month)[1] days_left_in_month = float(days_in_month - now.day) unrounded_prorate = (days_left_in_month / days_in_month) # roudn the proration up and multiply it by the current free tier allowance estimated_cap = int((ceil(unrounded_prorate*100) / 100.0) * 25000) print("Estimated Cap: {}".format(estimated_cap)) stream = Streamer(bucket_name="Testing Cap", bucket_key="cap_testing", buffer_size=100, ini_file_location="./isstreamer.ini", debug_level=2) for x in range(1, estimated_cap): # throttle every 100 events if (x%100 == 0): time.sleep(1) stream.log("event", x) stream.close()
sys.stderr = MyLogger(logger, logging.ERROR) CHECK_FREQ = 60 #check temp every 60 secs while True: if DEBUG: string1 = 'PIs internal temperature is: ' string2 = float(open('/sys/class/thermal/thermal_zone0/temp').read()) string2 = string2/1000 string2 = str(string2) string3 = ' Degrees Celsius' endstring = string1 + string2 + string3 logger.info(endstring) slogger.log("PI Internal Temp: ", string2) slogger.close() URLString = 'https://whatever it will be for you.hanatrial.ondemand.com/iotscenario/?action=addsensorvalue&sensorid=1&unit=Celsius&sensorvalue=' + string2 +'&sensorvaluemultiplier=1&sensorvaluecalibration=0' # print(URLString) (I use that for debugging purpose) urllib2.urlopen(URLString).read() else: break time.sleep(CHECK_FREQ)
def main(): city = input( "Enter the name of the City you require the Weather Conditions of:") address = "https://www.google.com/search?rlz=1C1HLDY_enUS874US874&ei=dengXeHcE8qd5wKj4aDIAw&q=" + city + "+coordinates&oq=" + city + "+&gs_l=psy-ab.3.0.0i67i70i251j0j0i67l3j0i131j0i67l3j0i131.10435.11689..12656...0.1..0.165.881.4j4......0....1..gws-wiz.......0i71j0i273.KfscqkpHNeY" web_page = requests.get(address) soup = BeautifulSoup(web_page.content, "html.parser") #Scraping Content from Google Search coords_class = soup.find_all(class_="BNeawe iBp4i AP7Wnd") required_coords = coords_class[0].find_all( class_="BNeawe iBp4i AP7Wnd" ) #Getting coords in a particular class in scraped data latitudes_longitude = [] str_coords = str(required_coords) t = str_coords.replace(">", " ") t = t.replace("<", " ") t = t.replace(",", " ") t = t.replace("°", "") T = t.split(" ") latitudes_longitude.append(T[5]) latitudes_longitude.append(T[6]) latitudes_longitude.append(T[8]) latitudes_longitude.append(T[9]) coords = "" if (latitudes_longitude[1] == "S"): latitudes_longitude[0] = str(-1.0 * float( latitudes_longitude[0])) #Converting Latitude to standard notation if (latitudes_longitude[3] == "W"): latitudes_longitude[2] = str(-1.0 * float( latitudes_longitude[2])) #converting Longitude to standar notation coords = latitudes_longitude[0] + "," + latitudes_longitude[ 2] #Adding Latitudes and Longitudes of a place in "coords" variable coords global GPS_COORDS GPS_COORDS = coords global DARKSKY_API_KEY DARKSKY_API_KEY = "c0974690b3b66a08fe5ea57c4926f420" #Storing API key in DarkSky_API_KEY variable BUCKET_NAME = ":partly_sunny: " + city + " Weather" #Storing Bucket Name BUCKET_KEY = "T57BL7K39XAX" #Storing Buckey Key for Streamer Dashboard ACCESS_KEY = "ist_uOnFF2jMhg7iwAu9R5HqFVAVeTZoQk-q" #Storing Access Key of Streamer Dashboard curr_conditions = get_current_conditions() if ( 'currently' not in curr_conditions ): # Checking for connectivity to API and printing if connection is invalid print( "Error! Dark Sky API call failed, check your GPS coordinates and make sure your Dark Sky API key is valid!\n" ) print(curr_conditions) exit() else: streamer = Streamer(bucket_name=BUCKET_NAME, bucket_key=BUCKET_KEY, access_key=ACCESS_KEY) #Accessing the Streamer while True: curr_conditions = get_current_conditions() if ('currently' not in curr_conditions): print( "Error! Dark Sky API call failed. Skipping a reading then continuing ...\n" ) #Again checking connectivity else: streamer.log(":house: Location", GPS_COORDS) #Streaming the Location on the Dashboard webbrowser.open( 'https://go.init.st/jp3ahqe' ) #Command to automatically open up default webbrowser #Streaming the Humidity on the Dashboard if 'humidity' in curr_conditions['currently'] and isFloat( curr_conditions['currently']['humidity']): streamer.log(":droplet: Humidity(%)", curr_conditions['currently']['humidity'] * 100) #Streaming the Temperature on the Dashboard if 'temperature' in curr_conditions['currently'] and isFloat( curr_conditions['currently']['temperature']): streamer.log("Temperature", curr_conditions['currently']['temperature']) #Streaming the Apparent Temperature on the Dashboard if 'apparentTemperature' in curr_conditions[ 'currently'] and isFloat( curr_conditions['currently']['apparentTemperature']): streamer.log( "Apparent Temperature", curr_conditions['currently']['apparentTemperature']) #Streaming the DewPoint on the Dashboard if 'dewPoint' in curr_conditions['currently'] and isFloat( curr_conditions['currently']['dewPoint']): streamer.log("Dewpoint", curr_conditions['currently']['dewPoint']) #Streaming the WindSpeed on the Dashboard if 'windSpeed' in curr_conditions['currently'] and isFloat( curr_conditions['currently']['windSpeed']): streamer.log(":dash: Wind Speed", curr_conditions['currently']['windSpeed']) #Streaming the Wind_Gust on the Dashboard if 'windGust' in curr_conditions['currently'] and isFloat( curr_conditions['currently']['windGust']): streamer.log(":dash: Wind Gust", curr_conditions['currently']['windGust']) #Streaming the Wind Direction on the Dashboard if 'windBearing' in curr_conditions['currently'] and isFloat( curr_conditions['currently']['windBearing']): streamer.log( ":dash: Wind Direction", wind_dir_icon(curr_conditions['currently']['windBearing'])) #Streaming the Pressure Condition on the Dashboard if 'pressure' in curr_conditions['currently'] and isFloat( curr_conditions['currently']['pressure']): streamer.log("Pressure", curr_conditions['currently']['pressure']) #Streaming the Precipitation Intensity on the Dashboard if 'precipIntensity' in curr_conditions['currently'] and isFloat( curr_conditions['currently']['precipIntensity']): streamer.log(":umbrella: Precipitation Intensity", curr_conditions['currently']['precipIntensity']) #Streaming the Precipitation Probability on the Dashboard if 'precipProbability' in curr_conditions['currently'] and isFloat( curr_conditions['currently']['precipProbability']): streamer.log( ":umbrella: Precipitation Probabiity(%)", curr_conditions['currently']['precipProbability'] * 100) #Streaming the Cloud Cover on the Dashboard if 'cloudCover' in curr_conditions['currently'] and isFloat( curr_conditions['currently']['cloudCover']): streamer.log(":cloud: Cloud Cover(%)", curr_conditions['currently']['cloudCover'] * 100) #Streaming the Ultraviolet Index on the Dashboard if 'uvIndex' in curr_conditions['currently'] and isFloat( curr_conditions['currently']['uvIndex']): streamer.log(":sunny: UV Index:", curr_conditions['currently']['uvIndex']) #Streaming the Visibility on the Dashboard if 'visibility' in curr_conditions['currently'] and isFloat( curr_conditions['currently']['visibility']): streamer.log(":sunny: Visibility:", curr_conditions['currently']['visibility']) #Streaming the Ozone Level on the Dashboard if 'ozone' in curr_conditions['currently'] and isFloat( curr_conditions['currently']['ozone']): streamer.log(":sunny: Ozone Level:", curr_conditions['currently']['ozone']) #Streaming the Weather Summary on the Dashboard if 'summary' in curr_conditions['currently']: streamer.log(":cloud: Weather Summary", curr_conditions['currently']['summary']) #Streaming the Forecast Message for today on the Dashboard if 'hourly' in curr_conditions: streamer.log("Today's Forecast", curr_conditions['hourly']['summary']) #Streaming the Moon Phase and Weather Condition Icon on the Dashboard if 'daily' in curr_conditions: if 'data' in curr_conditions['daily']: if 'moonPhase' in curr_conditions['daily']['data'][0]: moon_phase = curr_conditions['daily']['data'][0][ 'moonPhase'] streamer.log(":crescent_moon: Moon Phase", moon_icon(moon_phase)) streamer.log( ":cloud: Weather Conditions", weather_status_icon( curr_conditions['currently']['icon'], moon_phase)) streamer.flush() #Refreshing the Stream streamer.close() #Closing the Stream break
def identify(image): faceId1 = detect(image) body = str({'faceIds': faceId1, 'personGroupId': 'contacts'}) #Line added to push to Initial State streamer = Streamer(bucket_name="TRAKR", bucket_key="VandyHacks", access_key="02JRVjhxxM9eIwKrvXN44TWnzUotO0aZ") try: conn = http.client.HTTPSConnection('api.projectoxford.ai') conn.request("POST", "/face/v1.0/identify?", body, jsonHeaders) response = conn.getresponse() data = response.read().decode('utf-8') data = json.loads(data) #Code for tracking counter from a local file f = open("counter.txt", "r") counter = int(f.read()) f.close() arrNames = [] for key in data: if key == 'error': pass elif len(key['candidates']) == 0: alert("+12674750425", "+12674607556", "Someone unknown is by the door.\n", image) #Code added to push to Initial State streamer.log("Name:", "Unknown") streamer.log("Status:", "Awaiting") streamer.log("Recognized:", ":thumbsdown:") streamer.log("People at home :house:", counter) else: pId = key['candidates'][0]['personId'] conn.request( "GET", "/face/v1.0/persongroups/contacts/persons/{}?".format(pId), "{null}", jsonHeaders) response = conn.getresponse() data = response.read().decode('utf-8') data = json.loads(data) arrNames.append(data['name']) print(data['name']) streamer.log("Name:", data['name']) streamer.log("Status:", "Inside") streamer.log("Recognized:", ":thumbsup:") now = datetime.now() today7am = now.replace(hour=7, minute=0, second=0, microsecond=0) today8pm = now.replace(hour=20, minute=0, second=0, microsecond=0) if now > today8pm or now < today7am: streamer.log("Time of entry :crescent_moon:", datetime.now().strftime("%H:%M:%S")) else: streamer.log("Time of entry :sunny:", datetime.now().strftime("%H:%M:%S")) counter = counter + 1 streamer.log("People at home :house:", counter) if len(arrNames) == 1: conn.request( "POST", "/face/v1.0/persongroups/contacts/persons/{}/persistedFaces?". format(pId), convert_to_bin(image), headers) train() if len(arrNames) > 0: welcome(arrNames) conn.close() f2 = open("counter.txt", "w") f2.write(str(counter)) f2.close() streamer.close() except Exception as e: print(e) print("[identifyErrno {0}] {1}".format(e.errno, e.strerror))
import time # Streamer constructor, this will create a bucket called Python Stream Example # you'll be able to see this name in your list of logs on initialstate.com # your access_key is a secret and is specific to you, don't share it! streamer = Streamer(bucket_name="Sofie.py", bucket_key="Sofie", access_key="ist_kh_4Iv3IJuAd4mH82Km0H0yHD5CU9QJh") # example data logging for num in range(1, 20): time.sleep(0.1) if num % 1 == 0: streamer.log("Number", "2") if num % 2 == 0: streamer.log("Naam", "Sofie") if num % 3 == 0: streamer.log("Energie", "40") if num % 4 == 0: streamer.log("myNumber", "51.16257, 4.99084") ## This is just an example, try something of your own! ## ideas: ## - solve world hunger, one bug fix at a time ## - create the worlds first widget ## - build an army of bug-free robot kittens # Once you're finished, close the stream to properly dispose streamer.close()
from ISStreamer.Streamer import Streamer import time streamer = Streamer(bucket_name="test", debug_level=2) def stress_test_loop(i, num): while i > 0: streamer.log("iterations_left_{n}".format(n=num), i) time.sleep(0.2) i = i - 1 stress_test_loop(50, 1) streamer.close()
uartlist[3] = int(uartlist[3]) uartlist[4] = int(uartlist[4]) uartlist[5] = int(uartlist[5]) for i in range(1,3): temperature = convert_to_temperature((uartlist[i+3])) vwc = convert_to_vwc((uartlist[i+1]), temperature) uartlist[i+1] = vwc uartlist[i+3] = temperature rssi.log(uartlist[1]) shallowtemp.log(uartlist[2]) shallowvwc.log(uartlist[3]) deeptemp.log(uartlist[4]) deepvwc.log(uartlist[5]) rssi.close() shallowtemp.close() shallowvwc.close() deeptemp.close() deepvwc.close() i=0 for x in gv.hubnames: if ((uartlist[0] == x[1]) and (len(uartlist)==6)): if (len(gv.hubnames[i]))==3: gv.hubnames[i].extend(uartlist[2:6]) elif (len(gv.hubnames[i]))==7: for j in range(3,7): ((gv.hubnames[i])[j]) = uartlist[j-1] i = i + 1
publish_data.log("Vehicle is located at", where_it_is.address) print(where_it_is.address) if raw_data['class'] == 'TPV': if hasattr(raw_data, 'speed'): publish_data.log("Speed of the vehicle", raw_data.speed) print "Vehicle is moving at = " + str(raw_data.speed) + " KPH" if raw_data['class'] == 'TPV': if hasattr(raw_data, 'alt'): publish_data.log("Altitude", raw_data.alt) print "The altitude is = " + str(raw_data.alt) + " m" if raw_data['class'] == 'TPV': if hasattr(raw_data, 'time'): publish_data.log("Time", raw_data.time) print "The curent date and time is = " + str( raw_data.time) + "\n" except GeocoderTimedOut as e: publish_data.log("msg", "Geocoder Timeout") pass except KeyError: pass except (KeyboardInterrupt, SystemExit): publish_data.close() print "\nEnding the current process" gps.running = False exit() quit() except StopIteration: session = None print "No incoming data from the GPS module"
import time from ISStreamer.Streamer import Streamer logger = Streamer(bucket_name="Stream Example", debug_level=2) logger.log("My Messages", "Stream Starting") for num in range(1, 1000): time.sleep(0.001) logger.log("My Numbers", num) if num%2 == 0: logger.log("My Booleans", False) else: logger.log("My Booleans", True) if num%3 == 0: logger.log("My Events", "pop") if num%10 == 0: logger.log("My Messages", "Stream Half Done") logger.log("My Messages", "Stream Done") logger.close()
def main(): streamer = Streamer(bucket_name="FireDash", bucket_key="python_example", access_key="ist_vg7IMJ1kf0T-YjoSjdZG-1Do8VA3tj6i") #Sending Startup Values to dashboard streamer.log("Status", "Online") streamer.log("Temperature", 0) streamer.log("Pressure", 0) streamer.log("Light", 0) streamer.log("FireLevel", 1) streamer.log("FireDetected", "Low") count = 0 temp_sum = 0 pressure_sum = 0 light_sum = 0 risk_rating = { 1: "Low", 2: "Moderate", 3: "High", 4: "Critical", } print("Stream Started") while True: print("Streaming") time.sleep(0.1) count = count + 1 #temperature sensor affected by surrounding residual heat #subtracting raw value from cpu temperature to get accurate results cpu_temp = get_cpu_temperature() raw_temp = weather.temperature() temp_fixed = raw_temp - ((cpu_temp-raw_temp)/1.3) #temperature, light and pressure as totaled for smoothing temp_sum = temp_sum + temp_fixed light_sum = light_sum + light.light() pressure_sum = pressure_sum + weather.pressure(unit = 'hPa') #once allocated samples are taken, the value is averaged to get a more accurate reading if count == SAMPLE_RATE: temp_value = temp_sum/SAMPLE_RATE pressure_value = pressure_sum/SAMPLE_RATE light_value = light_sum/SAMPLE_RATE #smoothed data is sent to dash board for processing streamer.log("Temperature", round(temp_value,2)) streamer.log("Pressure", round(pressure_value,2)) streamer.log("Light", round(light_value,2)) #calculates the risk of a fire present based on recieved data risk_level = calculate_risk(temp_value, pressure_value, light_value) streamer.log("FireLevel", risk_level) streamer.log("FireDetected", risk_rating.get(risk_level)) streamer.flush() count = 0 temp_sum = 0 light_sum = 0 pressure_sum = 0 streamer.close()
import time from ISStreamer.Streamer import Streamer logger = Streamer(bucket_name="Stream Example", debug_level=2, offline=True) logger.log("My Messages", "Stream Starting") for num in range(1, 1000): time.sleep(0.001) logger.log("My Numbers", num) if num % 2 == 0: logger.log("My Booleans", False) else: logger.log("My Booleans", True) if num % 3 == 0: logger.log("My Events", "pop") if num % 10 == 0: logger.log("My Messages", "Stream Half Done") logger.log("My Messages", "Stream Done") logger.close()
except: # try the other serial port on the raspberry pi dbgprint("Failed to open serial port 0. Trying port 1.") ser = serial.Serial(port1, baud_rate, timeout=1) dbgprint("serial port: " + ser.name + ": open=" + str(ser.isOpen())) time.sleep(0.5) try: cloud_streamer = Streamer(bucket_name=credentials.bucket_name, bucket_key=credentials.bucket_key, access_key=credentials.access_key) dbgprint("streamer.BucketName: " + str(cloud_streamer.BucketName)) dbgprint("streamer.AccessKey: " + str(cloud_streamer.AccessKey)) # spawn a thread to continually read Arduino sensors, cache locally, and send to the cloud t1 = threading.Thread(target=check_status, args=()) t2 = threading.Thread(target=analyze_status, args=()) # flag threads as daemons so we exit if the main thread dies t1.daemon = True t2.daemon = True t1.start() t2.start() while ser.isOpen(): time.sleep(5) except: try: ser.close() cloud_streamer.close() finally: dbgprint("\nQuitting")