def publish_streamer_solar(self):
try:
streamer = Streamer(
bucket_name="srisaengtham",
bucket_key="WSARH9FBXEBX",
access_key="4YM0GM6ZNUAZtHT8LYWxQSAdrqaxTipw")
streamer.log(
self._agent_id + '_daily_energy' + '_solarimportbill',
round(self.solar_bill_today, 4))
streamer.log(
self._agent_id + '_daily_energy' + '_solarimportenergy',
round(self.solar_energy_today, 4))
streamer.log(
self._agent_id + '_monthly_energy' + '_solarimportbill',
round(self.solar_bill_this_month, 4))
streamer.log(
self._agent_id + '_monthly_energy' + '_solarimportenergy',
round(self.solar_energy_this_month, 4))
streamer.log(
self._agent_id + '_annual_energy' + '_solarimportbill',
round(self.solar_bill_annual, 4))
streamer.log(
self._agent_id + '_annual_energy' + '_solarimportenergy',
round(self.solar_energy_annual, 4))
except Exception as er:
print "update data base error: {}".format(er)
def main():
curr_conditions = get_current_conditions()
if ('data' not in curr_conditions):
print "Error! AirQual API call failed, check your GPS coordinates and make sure your AirQual API key is valid!\n"
print curr_conditions
exit()
else:
streamer = Streamer(bucket_name=BUCKET_NAME, bucket_key=BUCKET_KEY, access_key=ACCESS_KEY)
while True:
curr_conditions = get_current_conditions()
if ('data' not in curr_conditions):
print "Error! AirQual API call failed. Skipping a reading then continuing ...\n"
print curr_conditions
else:
streamer.log(":house: Location", LATITUDE + "," + LONGITUDE)
if 'aqius' in curr_conditions['data']['current']['pollution'] and isFloat(curr_conditions['data']['current']['pollution']['aqius']):
streamer.log("AQIUS",curr_conditions['data']['current']['pollution']['aqius'])
if 'mainus' in curr_conditions['data']['current']['pollution']:
streamer.log("MAINUS",curr_conditions['data']['current']['pollution']['mainus'])
streamer.flush()
time.sleep(60*MINUTES_BETWEEN_READS)
def main(): if len(sys.argv) != 2: print "Usage: " + sys.argv[0] + " <pid>" exit() pid = sys.argv[1] streamer = Streamer(bucket_name=BUCKET_NAME, bucket_key=BUCKET_KEY, access_key=ACCESS_KEY) if psutil.pid_exists(int(pid)) == False: print "Error: That process doesn't exist! Exiting ..." exit() else: streamer.log(PROCESS_NAME,"Running") streamer.flush() while True: if psutil.pid_exists(int(pid)) == False: streamer.log(PROCESS_NAME,"Exited") streamer.flush() exit() else: streamer.log(PROCESS_NAME,"Running") process = Popen(['hostname', '-I'], stdout=PIPE) output, _error = process.communicate() streamer.log(PROCESS_NAME + " IP Address", output.rstrip()) streamer.flush() time.sleep(60*MINUTES_BETWEEN_READS)
def monitor_tilt():
streamer = Streamer(bucket_name="Boiling",
bucket_key="HG9YAAUM5DX4",
access_key="ist_QX41bivamY4BhpNUbQwSIfuePaW23bGb")
temperature_buffer = []
gravity_buffer = []
while True:
beacons = distinct(blescan.parse_events(sock, 100))
for beacon in beacons:
print(temperature_buffer)
print(gravity_buffer)
if beacon['uuid'] in TILTS.keys():
temperature_buffer.append(beacon['major'])
gravity_buffer.append(beacon['minor'])
if len(temperature_buffer) >= 1:
print("f")
temperature_average = round(
float(sum(temperature_buffer)) /
float(len(temperature_buffer)), 3)
gravity_average = round(
float(sum(gravity_buffer)) / 1000 *
float(len(gravity_buffer)), 3)
print("Temp Avg:")
print(temperature_average)
print("Gravity Avg:")
print(gravity_average)
streamer.log("Temperature", temperature_average)
streamer.log("Gravity", gravity_average)
del temperature_buffer[:]
del gravity_buffer[:]
time.sleep(1)
def main():
gpio.setmode(gpio.BCM)
gpio.setup(4, gpio.IN)
gpio.setup(19, gpio.OUT)
gpio.setup(16, gpio.OUT)
gpio.add_event_detect(4, gpio.RISING, callback=shutdown, bouncetime=200)
mcp = setupSystem()
streamer = Streamer(bucket_name="MoogTest",
bucket_key="5LRM9UG8CASH",
access_key="NCbUQzFnRPMVoXDSjUL40Paxs0ICSV0Q")
while int(time.strftime("%H")) <= 23:
avg, maxVal, stdDev, timeElapsed = dataCollect(len(arr), mcp)
if avg == 0 and maxVal == 0 and stdDev == 0:
gpio.output(16, gpio.HIGH)
else:
gpio.output(16, gpio.LOW)
printInfo(avg, maxVal, stdDev, timeElapsed)
#saveData()
try:
r = sendToGoogleScript(avg, maxVal, stdDev, timeElapsed)
sendToIS(streamer, avg, maxVal, stdDev, timeElapsed)
except ConnectionError as e:
r = "No response."
print("Connection error. Check network settings.")
gpio.output(16, gpio.HIGH)
if r != "No response.":
gpio.output(16, gpio.LOW)
def main_without_pppd():
# Initialize the Initial State streamer
# Start the program by opening the cellular connection and creating a bucket for our data
print("Starting streamer...")
streamer = Streamer(bucket_name=BUCKET_NAME,
bucket_key=BUCKET_KEY,
access_key=ACCESS_KEY,
buffer_size=20)
# Wait long enough for the request to complete
sleep(5)
while True:
# Make sure there's a GPS fix
if checkForFix():
# Get lat and long
if getCoord():
latitude, longitude = getCoord()
coord = "movv lat:" + str(latitude) + "," + "movv lgt:" + str(
longitude)
print coord
# Buffer the coordinates to be streamed
streamer.log("Coordinates", coord)
sleep(SECONDS_BETWEEN_READS)
print "streaming location to Initial State"
# Flush the streaming queue and send the data
streamer.flush()
print "streaming complete"
def main():
streamer = Streamer(bucket_name=BUCKET_NAME,
bucket_key=BUCKET_KEY,
access_key=ACCESS_KEY)
# Start temperature stream thread
try:
thread.start_new_thread(stream_temp, (streamer, ))
except:
print "Error: unable to start temperature streamer thread"
# Door sensor
door_status = 1
while True:
## if the switch is open
if (io.input(door_pin) == True and door_status != 0):
streamer.log(":door: Door", "Open")
print "Door Open"
streamer.flush()
door_status = 0
## if the switch is closed
if (io.input(door_pin) == False and door_status != 1):
streamer.log(":door: Door", "Close")
print "Door Closed"
streamer.flush()
door_status = 1
time.sleep(2)
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 run(self):
self.logger.write("readingsThread started")
try:
streamer = Streamer(bucket_name="HandheldPi Stream",
access_key="y8ZCpNZ5ZYQQLfU5zKqdZrSEyizKFc17")
con = sqlite.connect('/home/pi/handheldPi/handheldPi.db')
while True:
cur = con.cursor()
humidity, temperature = Adafruit_DHT.read_retry(11, 23)
cur.execute(
"INSERT INTO readings (reading_date, reading_time, reading_type, value) VALUES (date('now'), time('now'), 'temperature', ?)",
(temperature, ))
cur.execute(
"INSERT INTO readings (reading_date, reading_time, reading_type, value) VALUES (date('now'), time('now'), 'humidity', ?)",
(humidity, ))
con.commit()
streamer.log("Temperature", temperature)
streamer.log("Humidity", humidity)
time.sleep(5)
except sqlite.Error, e:
if con:
con.rollback()
print("Error %s:" % e.args[0])
self.logger.write("Error %s:" % e.args[0])
con.close()
exit(1)
def main():
if len(sys.argv) != 2:
print("Usage: " + sys.argv[0] + " <pid>")
exit()
pid = sys.argv[1]
streamer = Streamer(bucket_name=BUCKET_NAME,
bucket_key=BUCKET_KEY,
access_key=ACCESS_KEY)
if not psutil.pid_exists(int(pid)):
print("Error: That process doesn't exist! Exiting ...")
exit()
else:
streamer.log(PROCESS_NAME, "Running")
streamer.flush()
while True:
if not psutil.pid_exists(int(pid)):
streamer.log(PROCESS_NAME, "Exited")
streamer.flush()
exit()
else:
streamer.log(PROCESS_NAME, "Running")
streamer.flush()
time.sleep(60 * MINUTES_BETWEEN_READS)
def initial_report(temp, humi, config):
from ISStreamer.Streamer import Streamer
streamer = Streamer(bucket_name=config["bucket_name"],
bucket_key=config["bucket_key"],
access_key=config["access_key"])
streamer.log("Temperature", round(temp, 1))
streamer.log("Humidity", round(humi, 1))
print("Initial State Committed")
def main():
streamer = Streamer(bucket_name=BUCKET_NAME,
bucket_key=BUCKET_KEY,
access_key=ACCESS_KEY)
while True:
cpu_temperature = get_cpu_temperature()
if METRIC_UNITS:
streamer.log("CPU Temperature(C)", cpu_temperature)
else:
cpu_temperature = cpu_temperature * 9.0 / 5.0 + 32.0
streamer.log("CPU Temperature(F)",
str("{0:.2f}".format(cpu_temperature)))
cpu_percents = psutil.cpu_percent(percpu=True)
streamer.log_object(cpu_percents, key_prefix="cpu")
cpu_percent = psutil.cpu_percent(percpu=False)
streamer.log("CPU Usage", cpu_percent)
disk = psutil.disk_usage('/')
disk_total = disk.total / 2**30
streamer.log("Disk Total(GB)", str("{0:.2f}".format(disk_total)))
disk_used = disk.used / 2**30
streamer.log("Disk Used(GB)", str("{0:.2f}".format(disk_used)))
disk_free = disk.free / 2**30
streamer.log("Disk Free(GB)", str("{0:.2f}".format(disk_free)))
disk_percent_used = disk.percent
streamer.log("Disk Used(%)", str("{0:.2f}".format(disk_percent_used)))
mem = psutil.virtual_memory()
mem_total = mem.total / 2**20
streamer.log("Memory Total(MB)", str("{0:.2f}".format(mem_total)))
mem_avail = mem.available / 2**20
streamer.log("Memory Available(MB)", str("{0:.2f}".format(mem_avail)))
mem_percent_used = mem.percent
streamer.log("Memory Used(%)", str("{0:.2f}".format(mem_percent_used)))
mem_used = mem.used / 2**20
streamer.log("Memory Used(MB)", str("{0:.2f}".format(mem_used)))
mem_free = mem.free / 2**20
streamer.log("Memory Free(MB)", str("{0:.2f}".format(mem_free)))
net = psutil.net_io_counters()
net_bytes_sent = net.bytes_sent / 2**20
streamer.log("Network MB Sent", str("{0:.2f}".format(net_bytes_sent)))
net_bytes_recv = net.bytes_recv / 2**20
streamer.log("Network MB Received",
str("{0:.2f}".format(net_bytes_recv)))
net_errin = net.errin
streamer.log("Network Errors Receiving", str(net_errin))
net_errout = net.errout
streamer.log("Network Errors Sending", str(net_errout))
net_dropin = net.dropin
streamer.log("Incoming Packets Dropped", str(net_dropin))
net_dropout = net.dropout
streamer.log("Outgoing Packets Dropped", str(net_dropout))
streamer.flush()
time.sleep(60 * MINUTES_BETWEEN_READS)
def __init__(self):
self._measured = False
self.done = False
self._measureCnt = 0
self._events = list(range(WEIGHT_SAMPLES))
self.bottles = 0
self._bottlesPrev = -1
self._doorStatus = False
self._takeMeasurement = False
self.streamer = Streamer(bucket_name=BUCKET_NAME,bucket_key=BUCKET_KEY,access_key=ACCESS_KEY)
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 connectInitialState(self):
try:
self.iss = Streamer(
bucket_name=self._config.get("INITIALSTATE", "bucketName"),
bucket_key=self._config.get("INITIALSTATE", "bucketKey"),
access_key=self._config.get("INITIALSTATE", "accessKey"),
buffer_size=20)
self.iss.log("Uplink", "Initial Connect")
self.iss.flush()
except:
print "Error sending initial state. Sleep for one hour."
time.sleep(60 * 60) # one hour
def __init__(self):
self._measured = False
self.done = False
self._measureCnt = 0
self._events = range(WEIGHT_SAMPLES)
self._lastMeasurement = 0
self._lastWeightSent = 0
self._changeDetected = False
self._weightDiff = 0
self.streamer = Streamer(bucket_name=BUCKET_NAME,
bucket_key=BUCKET_KEY,
access_key=ACCESS_KEY)
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,
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 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 streamTemp():
streamer = Streamer(bucket_name=BUCKET_NAME,bucket_key=BUCKET_KEY,access_key=ACCESS_KEY)
while True:
tempC = readTemp()
tempF = tempC * 9.0 / 5.0 + 32.0
if tempF > TEMPERATURE_TOO_HIGH_F:
streamer.log("Status", ":fire: :exclamation:")
if tempF < TEMPERATURE_TOO_LOW_F:
streamer.log("Status", ":snowflake: :exclamation:")
streamer.log("Temperature(F)", tempF)
streamer.flush()
print("Temperature: " + str(tempF) + " F")
time.sleep(TEMPERATURE_DELAY)
def __init__(self):
self._measured = False
self.done = False
self._measureCnt = 0
self._events = range(WEIGHT_SAMPLES)
self._weights = range(WEIGHT_HISTORY)
self._times = range(WEIGHT_HISTORY)
self._unit = "lb"
self._weightCnt = 0
self._prevWeight = 0
self._weight = 0
self._weightChange = 0
self.streamer = Streamer(bucket_name=BUCKET_NAME,bucket_key=BUCKET_KEY,access_key=ACCESS_KEY)
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 main_with_pppd():
global STREAM_COUNT
# Initialize the Initial State streamer
# Start the program by opening the cellular connection and creating a bucket for our data
if openPPPD():
print(
"\n\n\nOK ALRIGHT THEN! Everything looks good! Starting ISS streamer..."
)
streamer = Streamer(bucket_name=BUCKET_NAME,
bucket_key=BUCKET_KEY,
access_key=ACCESS_KEY,
buffer_size=20)
# Wait long enough for the request to complete
for c in range(INIT_DELAY):
print("Starting in T-minus {} second".format(INIT_DELAY - c))
sleep(1)
while True:
# Close the cellular connection
if closePPPD():
READ_COUNT = 0 # reset counter after closing connection
sleep(1)
# The range is how many data points we'll collect before streaming
for i in range(DATA_POINT):
# Make sure there's a GPS fix
if checkForFix():
# Get lat and long
print("i = {}".format(i))
if getCoord():
READ_COUNT += 1
latitude, longitude = getCoord()
coord = "lat:" + str(latitude) + "," + "lgt:" + str(
longitude)
print coord
# Buffer the coordinates to be streamed
print(
"Saving read #{} into buffer.".format(READ_COUNT))
streamer.log("Coordinates", coord)
sleep(SECONDS_BETWEEN_READS) # 1 second
# Turn the cellular connection on every 2 reads
if i == DATA_POINT - 1:
sleep(1)
print "opening connection"
if openPPPD():
STREAM_COUNT += 1
print("Streaming location to Initial State")
# streamer.log("Read Count",str(READ_COUNT))
streamer.log("Stream Count", str(STREAM_COUNT))
# Flush the streaming buffer queue and send the data
streamer.flush() # flush all the 4 readings to ISS
print("Streaming complete")
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!")
def main():
sense = SenseHat()
conditions = get_conditions()
astronomy = get_astronomy()
if ('current_observation' not in conditions) or ('moon_phase' not in astronomy):
print "Error! Wunderground API call failed, check your STATE and CITY and make sure your Wunderground API key is valid!"
if 'error' in conditions['response']:
print "Error Type: " + conditions['response']['error']['type']
print "Error Description: " + conditions['response']['error']['description']
exit()
else:
streamer = Streamer(bucket_name=BUCKET_NAME, bucket_key=BUCKET_KEY, access_key=ACCESS_KEY)
streamer.log(":house: Location",conditions['current_observation']['display_location']['full'])
while True:
# -------------- Sense Hat --------------
# Read the sensors
temp_c = sense.get_temperature()
humidity = sense.get_humidity()
pressure_mb = sense.get_pressure()
def sender_is():
if IS:
global gpspoll
streamer = Streamer(bucket_name="GPS Tracker",
bucket_key=ID,
access_key="00000000000000000000000000000000")
while 1:
time.sleep(5)
streamer.log("Satellites", gpspoll.sats)
if gpspoll.mode > 0:
streamer.log(
"Location", "{lat},{long}".format(lat=gpspoll.lat,
long=gpspoll.long))
streamer.log("Altitude", gpspoll.alt)
streamer.log("Error", max(gpspoll.accx, gpspoll.accz))
streamer.log("Error (vertical)", gpspoll.accy)
debug("I told IS my location.")
else:
debug("I'm not telling IS my location.")
def main():
# Wait for ntpd to run for sync of the clock
found_ntpd = False
cnt = 0
while found_ntpd == False:
for proc in psutil.process_iter():
if proc.name() == "ntpd":
found_ntpd = True
cnt += 1
if cnt == 60: # assume that ntpd has already run if not found in 60 seconds
found_ntpd = True
time.sleep(1)
time.sleep(60 * MINUTES_DELAY)
streamer = Streamer(bucket_name=BUCKET_NAME,
bucket_key=BUCKET_KEY,
access_key=ACCESS_KEY)
streamer.log(PROCESS_NAME, "Exited")
streamer.flush()
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 StartLog():
global logFile, lfOpen, Logging, streamOpen, fName, SampleC, logHeader, streamer
if (((lfOpen) or (streamOpen)) and (Logging == False)):
root.wm_title("DAQCplate Data Logger - LOGGING")
Header = "Time,"
for i in range(8):
if (DAQCpresent[i] == 1):
desc = ['', '', '', '', '', '', '', '']
desc = daqc[i].a2dDescriptors()
for k in range(8):
if (desc[k] != ''):
Header = Header + 'DAQC' + str(i) + '.' + desc[k] + ','
desc = ['', '', '', '', '', '', '', '']
desc = daqc[i].dinDescriptors()
for k in range(8):
if (desc[k] != ''):
Header = Header + 'DAQC' + str(i) + '.' + desc[k] + ','
Header = Header[:-1]
logHeader = Header
if (lfOpen):
logFile = open(fName, 'w')
# logFile.write(Header)
# logFile.write('\n')
if (streamOpen):
streamer = Streamer(bucket_name=StreamBucket.get(),
bucket_key=StreamIdentifier.get(),
access_key=StreamKey.get())
streamer.log("Pi-Plates", "DACQ Log Stream Starting")
Logging = True
SampleC = int(SampleCount.get())
else:
showerror(
"Logging",
"You must open a log file or a stream before you can start logging"
)
def main():
streamer = Streamer(bucket_name=BUCKET_NAME,
bucket_key=BUCKET_KEY,
access_key=ACCESS_KEY)
while True:
cpu_temp_c = get_cpu_temperature()
temp_c = weather.temperature()
temp_c_cal = temp_c - ((cpu_temp_c - temp_c) / 1.3)
if (METRIC_UNITS):
streamer.log(":desktop: CPU Temperature(C)", cpu_temp_c)
else:
cpu_temp_f = cpu_temp_c * 9.0 / 5.0 + 32.0
streamer.log(":desktop: CPU Temperature(F)",
str("{0:.2f}".format(cpu_temp_f)))
if isFloat(temp_c):
if (METRIC_UNITS):
# print("Temperature(C) = " + str(temp_c))
if (temp_c > -15) and (temp_c < 100):
streamer.log(":sunny: " + SENSOR_NAME + " Temperature(C)",
temp_c)
streamer.log(
":sunny: Calibrated " + SENSOR_NAME +
" Temperature(C)", temp_c_cal)
else:
temp_f = temp_c * 9.0 / 5.0 + 32.0
temp_f_cal = temp_c_cal * 9.0 / 5.0 + 32.0
# print("Temperature(F) = " + str("{0:.2f}".format(temp_f)))
if (temp_f > 0) and (temp_f < 110):
streamer.log(":sunny: " + SENSOR_NAME + " Temperature(F)",
str("{0:.2f}".format(temp_f)))
streamer.log(
":sunny: Calibrated " + SENSOR_NAME +
" Temperature(F)", str("{0:.2f}".format(temp_f_cal)))
streamer.flush()
time.sleep(60 * MINUTES_BETWEEN_READS)
