def activate(): prevdata = [] global highbound global lowbound global flag framesize = 5 temp_sens = Bolt(conf.apikey, conf.device_id) sms = Sms(conf.ssid, conf.auth_token, conf.tonumber, conf.fromnumber) while True: response = temp_sens.analogRead('A0') data = json.loads(response) try: sensor_value = int(data['value']) temp = sensor_value / 10.24 print(temp) except Exception as e: print("Error", e) continue if flag == 1: bounds = computebounds.computebounds(prevdata, framesize) if not bounds: print("Need ", (framesize - len(prevdata)), " more points") prevdata.append(temp) time.sleep(5) continue try: if flag == 1: highbound = bounds[0] lowbound = bounds[1] print("High Bound = ", highbound, " Low Bound = ", lowbound) #highbound=data['up'] #lowbound=data['low'] if temp > highbound: try: print("Temperature has gone up to ", temp) response = sms.send_sms("Temperature has increased to " + str(temp)) break except Exception as e: print("Error", e) elif temp < lowbound: try: print("Temperature has gone down to ", temp) response = sms.send_sms("Temperature has decreased to " + str(temp)) break except Exception as e: print("Error", e) except Exception as e: print("Error ", e) prevdata.append(temp) time.sleep(5)
def sendSms(phno, msg): #print ('SMS') print(type(phno)) print("_", phno, "_") #print (msg) sms = Sms(conf.SID, conf.AUTH_TOKEN, phno, conf.FROM_NUMBER) try: print("SMS REQ") response = sms.send_sms(msg) print("RESP OF SMS TWIL: " + str(response)) print(" RESP STATUS: " + str(response.status)) except Exception as e: print("Error", e)
def laser(): API_KEY = "d1c0747d-cf58-4b22-b97a-cfae6ba9ae2e" DEVIVE_ID = "BOLT7487042" Mybolt = Bolt(API_KEY, DEVIVE_ID) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) print(json.loads(Mybolt.isOnline())['value']) while True: response = Mybolt.analogRead('A0') data = json.loads(response) print(data['value']) try: sensor_value = int(data['value']) print(sensor_value) if sensor_value < 1020: #response = sms.send_sms(" an unwanted access") response = Mybolt.digitalWrite('4', 'HIGH') sleep(0) else: response = Mybolt.digitalWrite('4', 'LOW') except Exception as e: print("error", e) sleep(10000)
def laser(): api_key = "b42f36a3-9e5b-440c-8fa4-c57de4e5c4ca" device_id = "BOLT3732040" mybolt = Bolt(api_key, device_id) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) print(json.loads(mybolt.isOnline())['value']) while True: response = mybolt.analogRead('A0') data = json.loads(response) print(data['value']) try: sensor_value = int(data['value']) print(sensor_value) if sensor_value < 1020: response = sms.send_sms(" an unwanted access") response = mybolt.digitalWrite('0', 'HIGH') sleep(20000) except Exception as e: print("error", e) sleep(10000)
import config #this file contains the SSID API Key and Bolt device ID import json,time from boltiot import Sms,Bolt #used to call methods to sen SMS and use Bolt WiFi Module mybolt = Bolt(config.API_KEY, config.DEVICE_ID) #To configure the Bolt WiFi Module sms = Sms(config.SSID, config.AUTH_TOKEN, config.TO_NUMBER, config.FROM_NUMBER) #To configure the Twilio SMS Service while True: response = mybolt.analogRead('A0') #Read the values data = json.loads(response) #store the response given recieved in JSON format if data['success'] != 1: # To detect if the value recieved contains keyword success and corresponding value should be 1 denoting STATUS OK print("There was an error and error is " + data['value'] ) time.sleep(10) continue print ("This is the value "+data['value']) #To print the Analog Value received form the Bolt WiFi Module try: moist=(int(data['value'])/1024)*100 #To convert the vales in Percentage moist = 100 - moist #To find the moisture content left in soil out of total 100% print ("The Moisture content is ",moist," % mg/L") except e: print("There was an error while parsing the response: ",e) continue try: #To find the moisture content of the land if moist < 30: print ("The Moisture level is highly decreased. SMS is sent.") response = sms.send_sms("THE MOISTURE CONTENT IN LAND IS LESS THAN 30%, SO PLEASE START MOTOR TO IRRIGATE LAND.THE LAND HIGHLY DRY") print("This is the response ")
Variance = 0 for data in history_data: Variance += math.pow((data - Mn), 2) Zn = factor * math.sqrt(Variance / frame_size) High_bound = history_data[frame_size - 1] + Zn Low_bound = history_data[frame_size - 1] - Zn return [High_bound, Low_bound] #sensor value=temperature*10.24 minimum_temp_limit = 4 * 10.24 maximum_temp_limit = 20 * 10.24 #api authentication mybolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) mailer = Email(conf.MAILGUN_API_KEY, conf.SANDBOX_URL, conf.SENDER_EMAIL, conf.RECIPIENT_EMAIL) history_data = [] while True: response = mybolt.analogRead('A0') data = json.loads(response) print("Sensor value : " + data['value']) temperature = float(data['value']) / 10.24 print("Temperature : " + str(temperature)) sensor_value = 0 try: sensor_value = int(data['value']) except Exception as e:
print("An error occurred in sending the alert message via Telegram") print(e) return False def get_bitcoin_price(): URL = "https://min-api.cryptocompare.com/data/price?fsym=BTC&tsyms=USD,JPY,EUR,INR" # REPLACE WITH CORRECT URL respons = requests.request("GET", URL) respons = json.loads(respons.text) current_price = respons["USD"] return current_price Selling_price = input("Enter Selling Price : ") mybolt = Bolt(conf.api_key, conf.device_id) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) mailer = Email(conf.MAILGUN_API_KEY, conf.SANDBOX_URL, conf.SENDER_MAIL, conf.RECIPIENT_MAIL) while True: c_price = get_bitcoin_price() print(get_bitcoin_price(), time.ctime()) if c_price >= Selling_price: # Enable Buzzer response_buzzer = mybolt.digitalWrite('0', 'HIGH') print(response_buzzer) # Send SMS response_SMS = sms.send_sms("The Bitcoin selling price is now : " + str(c_price)) # Send Mail response_mail = mailer.send_email(
import conf, json, time from boltiot import Sms, Bolt minimum_limit = 300 maximum_limit = 600 mybolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) while True: response = mybolt.analogRead('A0') data = json.loads(response) print(data['value']) try: sensor_value = int(data['value']) Temperature = (sensor_value * 100) / 1024 print(Temperature) if sensor_value > maximum_limit or sensor_value < minimum_limit: response = sms.send_sms("Current temperature value is " + str(Temperature)) except Exception as e: print("Error ", e) time.sleep(10)
import conf,json,time from boltiot import Bolt,Sms mybolt = Bolt(conf.API_KEY,conf.DEVICE_ID) sms = Sms(conf.SID,conf.AUTH_TOKEN,conf.TO_NUMBER,conf.FROM_NUMBER) old_state = 0 while True: print("Reading value from Bolt") response = mybolt.digitalRead('1') data = json.loads(response) print (data) new_state = int(data['value']) if old_state != new_state: #Change in state indicates that the garage door is openend or closed try: if new_state == 1: #value of new_state is 1 implies that garage door is open print("Making request to twilio to send SMS") #sending an SMS to the TO NUMBER response = sms.send_sms("Garage is open") print ("Response received from twilio is:"+str(response)) print ("Status of SMS at Twilio is :"+str(response.status)) elif new_state == 0: #value of new_state is 0 implies that garage door is closed print("Making request to twilio to send SMS") #sending an sms to the TO NUMBER response = sms.send_sms("Garage is closed") print ("Response received from twilio is:"+str(response)) print ("Status of SMS at Twilio is :"+str(response.status)) except Exception as e: print("Error occured: Below are the details") print (e) old_state = new_state #assign new_state value to the old_state for the next cycle
Variance = 0 for data in history_data: Variance += math.pow((data - Mn), 2) Zn = factor * math.sqrt(Variance / frame_size) High_bound = history_data[frame_size - 1] + Zn Low_Bound = history_data[frame_size - 1] - Zn return [High_bound, Low_Bound] minimum_limit = 4 maximum_limit = 7 mybolt = Bolt(email_conf.API_KEY, email_conf.DEVICE_ID) mailer = Email(email_conf.MAILGUN_API_KEY, email_conf.SANDBOX_URL, email_conf.SENDER_EMAIL, email_conf.RECIPIENT_EMAIL) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) history_data = [] while True: response = mybolt.analogRead('A0') data = json.loads(response) if data['success'] != '1': print("There was an error while retriving the data.") print("This is the error:" + data['value']) time.sleep(10) continue print("The sensor value is " + (data['value'])) sensor_value = 0
return None if len(history_data) > frame_size: del history_data[0:len(history_data) - frame_size] Mn = statistics.mean(history_data) Variance = 0 for data in history_data: Variance += math.pow((data - Mn), 2) Zn = 0 Zn = factor * math.sqrt(history_data[frame_size - 1]) + Zn Low_bound = history_data[frame_size - 1] - Zn High_bound = history_data[frame_size - 1] + Zn return [High_bound, Low_bound] mybolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) history_data = [] while True: response = mybolt.analogRead('A0') data = json.loads(response) if data['success'] != 1: print("There was an error while retriving the data.") print("This is the error:" + data['value']) time.sleep(10) continue sensor_value = int(data['value']) sensor_valuec = sensor_value / 10.24 print("Current Freezer Temperature is •C " + str(sensor_valuec)) sensor_value = 0 try: sensor_value = int(data['value'])
del history_data[0:len(history_data) - frame_size] Mn = statistics.mean(history_data) variance = 0 for data in history_data: variance += math.pow((data - Mn), 2) Zn = factor * math.sqrt(variance / frame_size) High_bound = history_data[frame_size - 1] + Zn Low_bound = history_data[frame_size - 1] - Zn return [High_bound, Low_bound] history_data = [] min = 20.48 max = 46.08 mybolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) mailer = Email(conf.MAILGUN_API_KEY, conf.SANDBOX_URL, conf.SENDER_EMAIL, conf.RECEPIENT_EMAIL) while True: print( "===========================================================================================================" ) print("Reading sensor value") response = mybolt.analogRead('A0') data = json.loads(response) if data['success'] != 1: print("There was an error while retriving the data.") print("This is the error:" + data['value']) time.sleep(10) continue try:
import conf, json, time from boltiot import Sms, Bolt minimum_limit = 100 maximum_limit = 100 mybolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) while True: response = mybolt.analogRead('A0') data = json.loads(response) print(data['value']) try: sensor_value = int(data['value']) print(sensor_value) if sensor_value > maximum_limit or sensor_value < minimum_limit: response = sms.send_sms("The current value of the sensor is" + str(sensor_value)) except Exception as e: print("Error", e) time.sleep(10)
history_data ) #it calculates the mean (Mn) value of the collected data points. Variance = 0 for data in history_data: Variance += math.pow( (data - Mn), 2) #This code helps to calculate the Variance of the data points. Zn = factor * math.sqrt(Variance / frame_size) High_bound = history_data[frame_size - 1] + Zn Low_bound = history_data[frame_size - 1] - Zn return [High_bound, Low_bound] #In the above code we have calculated the Z score (Zn) for the data and use it to calculate the upper and lower threshold bounds required to check if a new data point is normal or anomalous. mybolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) #Above codes are used to initialize the Bolt and SMS variables, which we will use to collect data and send SMS alerts. history_data = [ ] #Here we initialize an empty list with the name 'history_data' which we will use to store older data, so that we can calculate the Z-score. #The following while loop contains the code required to run the algorithm of anomaly detection. while True: response = mybolt.analogRead('A0') data = json.loads(response) if data['success'] != 1: print("There was an error while retriving the data.") print("This is the error:" + data['value']) time.sleep(10) continue print("Receiving Data...") print("This is the value " + data['value'], "(time :",
return None if len(history_data) > frame_size: del history_data[0:len(history_data) - frame_size] Mn = statistics.mean(history_data) Variance = 0 for data in history_data: Variance += math.pow((data - Mn), 2) Zn = factor * math.sqrt(Variance / frame_size) High_bound = history_data[frame_size - 1] + Zn Low_Bound = history_data[frame_size - 1] - Zn return [High_bound, Low_Bound] mybolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) sms_whatsapp = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_WHATSAPP, conf.FROM_WHATSAPP) mailer = Email(conf.MAILGUN_API_KEY, conf.SANDBOX_URL, conf.SENDER_EMAIL, conf.RECIPIENT_EMAIL) history_data = [] while True: response = mybolt.analogRead('A0') response1 = mybolt.analogRead('A0') response2 = mybolt.analogRead('A0') data = json.loads(response) if data['success'] != '1': print("There was an error while retriving the data.") print("This is the error:" + data['value']) time.sleep(5)
return None if len(history_data) > frame_size: del history_data[0:len(history_data) - frame_size] Mn = statistics.mean(history_data) Variance = 0 for data in history_data: Variance += math.pow((data - Mn), 2) Zn = factor * math.sqrt(Variance / frame_size) High_bound = history_data[frame_size - 1] + Zn Low_bound = history_data[frame_size - 1] - Zn return [High_bound, Low_bound] mybolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) history_data = [] mailer = Email(conf.MAILGUN_API_KEY, conf.SANDBOX_URL, conf.SENDER_EMAIL, conf.RECIPIENT_EMAIL) while True: response = mybolt.analogRead('A0') data = json.loads(response) if data['success'] != 1: print("There was an error while retriving the data.") print("This is the error:" + data['value']) time.sleep(10) continue print("Raw Temperature in Refrigerator is" + data['value']) degree = (float(data['value']) / 10.24)
import conf, json, time from boltiot import Sms, Bolt min_limit = 300 max_limit = 350 mybolt = Bolt(conf.akey, conf.did) Sms = Sms(comf.sid, conf.token, conf.tno, conf.fno) while True: print("Reading sensor value") response = mybolt.analogRead('A0') data = json.loads(response) print("Sensor value is: " + str(data['value'])) try: sensor_value = int(data['value']) if sensor_value > max_limit or sensor_value < min_limit: print("Making quest to twilio to send sms") response = Sms.send_sms("The current temp value is " + str(sensor_value)) print("Response recived from twilio is: " + str(response)) print("Status of sms at twilio is: " + str(response.status)) except Exception as e: print("Error occured: Below are the details") print(e) time.sleep(10)
import conf, requests, math, time, json from boltiot import Sms, bolt value1 = 20 value2 = 500 value3 = 1500 value4 = 500 data = [] #to empty the list for storing value mybolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) mybolt.digitalWrite(0,"LOW") def get_sv(pin): try: response = mybolt.analogRead(pin) data = json.loads(response) if data["success']!=1: print("Request Failed") print("Response", data) return -999 sensor_value = int(data["value"]) return sensor_value except Exception as e: print("Error") print(e) return -999 while True: print("Reading Sensor Value") response = mybolt.analogRead('A0')
import conf, json, time from boltiot import Bolt, Sms API_KEY = "b42f36a3-9e5b-440c-8fa4-c57de4e5c4ca" DEVIVE_ID = "BOLT3732040" Mybolt = Bolt(API_KEY, DEVIVE_ID) SSID = 'ACce54c48ff0e1271d7d50012d96ec89a3' AUTH_TOKEN = 'edaf33cf519a6efe6c8991f8bd397047' FROM_NUMBER = '+15083926124 ' TO_NUMBER = '+918077423699' sms = Sms(SSID, AUTH_TOKEN, TO_NUMBER, FROM_NUMBER) print(json.loads(Mybolt.isOnline())['value']) while True: response = Mybolt.analogRead('A0') data = json.loads(response) print(data['value']) try: sensor_value = int(data['value']) print(sensor_value) if sensor_value < 1020: #response = sms.send_sms(" an unwanted access") response = Mybolt.digitalWrite('4', 'HIGH') break except Exception as e: print("error", e) time.sleep(10000)
import math, json, time, conf, statistics from boltiot import Bolt, Sms min_limit = 10 max_limit = 100 mybolt = Bolt(conf.API_KEY, conf.device_id) sms = Sms(conf.SID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) def compute_bounds( history_data, frame_size, factor): if len(history_data) < frame_size: return None if len(history_data) > frame_size: del history_data[0:len(history_data) - frame_size] Mean_value = statistics.mean(history_data) Variance = 0 for data in history_data: Variance += math.pow((data - Mean_value), 2) Zn = factor * math.sqrt(Variance/frame_size) High_bound = history_data[frame_size-1] + Zn Low_bound = history_data[frame_size-1] - Zn return [High_bound, Low_bound] history_data = [] while True: print("Reading sensor value: ") response = mybolt.analogRead('A0') data = json.loads(response)
import conf, json, time from boltiot import Bolt, Sms minimum_limit = 100 maximum_limit = 1000 myBolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) while True: print("Reading the LDR sensor value") response = myBolt.analogRead('A0') data = json.loads(response) sensor_value = int(data['value']) print("LDR sensor value is :" + str(data['value'])) try: print("try block") except Exception as e: print("Exception")
import conf, json, time from boltiot import Sms, Bolt minimum_limit = 300 maximum_limit = 600 mybolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) while True: print("Reading sensor value") response = mybolt.analogRead('A0') data = json.loads(response) print("Sensor value is: " + str(data['value'])) try: sensor_value = int(data['value']) if sensor_value > maximum_limit or sensor_value < minimum_limit: print("Making request to Twilio to send a SMS") response = sms.send_sms( "The Current temperature sensor value is " + str(sensor_value)) print("Response received from Twilio is: " + str(response)) print("Status of SMS at Twilio is :" + str(response.status)) except Exception as e: print("Error occured: Below are the details") print(e) time.sleep(10) #Temperature=(100*sensor_value)/1024
import dest, json, time from boltiot import Sms, Bolt import json, time minimum_limit = 300 maximum_limit = 600 mybolt = Bolt( dest.api_key, dest.device_id) #dest is the file which contains apikey,device id ets. sms = Sms(dest.SID, dest.auth_token, dest.to_number, dest.from_number) while True: print("Reading sensor value") response = mybolt.analogRead('A0') data = json.loads(response) print("Sensor value is: " + str(data['value'])) try: sensor_value = int(data['value']) if sensor_value > maximum_limit or sensor_value < minimum_limit: print("Making request to Twilio to send a SMS") response = sms.send_sms( "The Current temperature sensor value is " + str(sensor_value)) print("Response received from Twilio is: " + str(response)) print("Status of SMS at Twilio is :" + str(response.status)) except Exception as e: print("Error occured: Below are the details") print(e) time.sleep(10)
return None if len(history_data) > frame_size: del history_data[0:len(history_data) - frame_size] Mn = statistics.mean(history_data) Variance = 0 for data in history_data: Variance += math.pow((data - Mn), 2) Zn = factor * math.sqrt(Variance / frame_size) High_bound = history_data[frame_size - 1] + Zn Low_bound = history_data[frame_size - 1] - Zn return [High_bound, Low_bound] mybolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) history_data = [] while True: mybolt.serialWrite("GetAnalogData") response = mybolt.serialRead(10) data = json.loads(response) if data['success'] != 1: print("There was an error while retriving the data.") print("This is the error:" + data['value']) time.sleep(10) continue print("This is the value " + data['value']) sensor_value = 0 try:
import conf, time, json from boltiot import Bolt, Sms maximum_limit = 200 minimum_limit = 100 mybolt = Bolt(conf.API_KEY,conf.DEVICE_ID) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) while True: response = mybolt.analogRead('A0') data = json.loads(response) print(data['value']) try: sensor_value = int(data['value']) print(sensor_value) if sensor_value > maximum_limit or sensor_value < minimum_limit: response = sms.send_sms("Your light sensor value is " +str(sensor_value)) except Exception as e: print("Error",e) time.sleep(10)
engine = pyttsx3.init() f = Figlet(font='slant', width=200) print(f.renderText('Hello , Welcome To Temperature Monitoring System')) engine.setProperty('rate', 160) voices = engine.getProperty('voices') engine.setProperty('voice', voices[1].id) engine.say("Hello, Everyone, Welcome To Temperature Monitoring System") engine.runAndWait() engine.say('Please Wait for a while, We are fetching our data') engine.runAndWait() time.sleep(2) minimum_limit = 400 #39.06 Degree Celsius maximum_limit = 600 #58.59 Degree Celsius mybolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) while True: fb = open("TempData1.txt", "a") fa = open("DangerTemp1.txt", "a") resp = mybolt.analogRead('A0') data = json.loads(resp) try: sensor_value = int(data['value']) Temperature = (100 * sensor_value) / 1024 Temp = round(Temperature, 2) print( f" Room Temperature at {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')} is : {Temp} Degree Celsius" ) engine.say(
import conf, json, time from boltiot import Sms, Bolt minimum_limit = 67 #the minimum threshold of heart rate maximum_limit = 110 #the maximum threshold of heart rate mybolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) while True: response = mybolt.analogRead('A0') data = json.loads(response) sensor_value1 = int(data['value']) sensor_value1 = sensor_value1 print("The current Heartbeat of patient is " + str(sensor_value1) + " BPM. And the Sensor Value is " + data['value']) sensor_value = 0 try: sensor_value = int(data['value']) except e: print("There was an error while parsing the response: ", e) continue try: if sensor_value > maximum_limit or sensor_value < minimum_limit: print("The heartbeat is abnormal.Sending SMS") response = sms.send_sms( "HeartBeat abnormal. The Current heartbeat is " + str(sensor_value1) + " BPM") print("This is the response for SMS ", response) except Exception as e: print("Error", e) time.sleep(5)
if len(history_data) > frame_size: del history_data[0:len(history_data) - frame_size] Mn = statistics.mean(history_data) Variance = 0 for data in history_data: Variance += math.pow((data - Mn), 2) Zn = factor * math.sqrt(Variance / frame_size) High_bound = history_data[frame_size - 1] + Zn Low_bound = history_data[frame_size - 1] - Zn return [High_bound, Low_bound] critical_limit = 20 #the critical_value of temperature maximum_limit = 35 #the maximum_value of temperature mybolt = Bolt(conf.API_KEY, conf.DEVICE_ID) sms = Sms(conf.SSID, conf.AUTH_TOKEN, conf.TO_NUMBER, conf.FROM_NUMBER) mailer = Email(email_conf.MAILGUN_API_KEY, email_conf.SANDBOXURL, email_conf.SENDER_EMAIL, email_conf.RECIPIENT_EMAIL) history_data = [] while True: response = mybolt.analogRead('A0') data = json.loads(response) if data['success'] != 1: print("There was an error while retriving the data.") print("This is the error:" + data['value']) time.sleep(10) continue print("This is the value " + data['value']) sensor_value = 0
"Pomodoro Clock <mailgun@{}>".format( os.environ['MAILGUN_URL']), "to": [os.environ['RECIPIENT_EMAIL']], "subject": "ALERT", "text": message }) if (os.environ['IS_ACTIVATED'] == '1'): message = "STOP! 45 mins is over. Go take a break!!" response = send_simple_message(message) print("Response EMAIL", response) sms = Sms(os.environ['SSID'], os.environ['AUTH_TOKEN'], os.environ['TO_NUMBER'], os.environ['FROM_NUMBER']) response = sms.send_sms(message) print("Response SMS", response) time.sleep(900) message = "Time's up, now get back to work!" response = send_simple_message(message) print("Response EMAIL", response) sms = Sms(os.environ['SSID'], os.environ['AUTH_TOKEN'], os.environ['TO_NUMBER'], os.environ['FROM_NUMBER']) response = sms.send_sms(message) print("Response SMS", response)
import time, json, math from boltiot import Bolt, Sms API_KEY = "b42f36a3-9e5b-440c-8fa4-c57de4e5c4ca" DEVIVE_ID = "BOLT3732040" # SELF NOTE need to change SSID = 'ACce54c48ff0e1271d7d50012d96ec89a3' AUTH_TOKEN = 'edaf33cf519a6efe6c8991f8bd397047' FROM_NUMBER = '+15083926124 ' TO_NUMBER = '+918077423699' Diameter = 14 Mybolt = Bolt(API_KEY, DEVIVE_ID) twillioMessage = Sms(SSID, AUTH_TOKEN, TO_NUMBER, FROM_NUMBER) status = Mybolt.isOnline() print(status) previousWaterLevel = 0 totalWaterConsumed = 0 criticalConsumption = 15 # Try 1 errorMaxValue = 350 def messageToUser(level='CRITICAL LEVEL'): twillioMessage.send_sms("ALERT!!!!!!! \nDear User, " + str(level) + " is crossed. Control excess water usages.") print('msg sent') while True: if status: