def measure_distance(samples=41): sensor = HCSR04(trigger_pin=3, echo_pin=12) distances = list() for i in range(0, samples - 1): reading = sensor.distance_cm() * 10.0 if reading is not None and reading > 0.0: distances.append(reading) time.sleep(0.15) distances.sort() if len(distances) == 0: distance = None else: mean_distance_mm = sum(distances) / len(distances) median_distance_mm = distances[int((samples - 1) / 2)] ##print(min(distances),mean_distance_mm,median_distance_mm,max(distances)) distance = median_distance_mm if len(distances) < 9: q1 = None q3 = None else: g1 = distances[int((samples) / 4)] g3 = distances[int(3 * (samples) / 4)] return distance, q1, q3
def main(): with open('config.json', 'r') as file: config = ujson.load(file) # Get main parameters from config file config.json IP = config['host'] PORT = config['port'] LOG_PORT = config['logPort'] HOST = '{}:{}/'.format(IP, PORT) LOG = '{}:{}/'.format(IP, LOG_PORT) # Set main variables for algorithm CHIP_ID = machine.unique_id() if CHIP_ID == b'upy-non-unique': CHIP_ID = 'agent-{}'.format(int(utime.time())) GET_VALUE_FUNCTION = lambda *args: func(*args) else: CHIP_ID = ubinascii.hexlify(machine.unique_id()) trig_pin = 16 echo_pin = 0 sensor = HCSR04(trigger_pin=trig_pin, echo_pin=echo_pin) GET_VALUE_FUNCTION = lambda *args: sensor.distance_cm() # Run agent program run(CHIP_ID, HOST, LOG, GET_VALUE_FUNCTION)
def main(): try: connectWifi(SSID, PASSWORD) except Exception as e: print('Error %s' % e) sensor = HCSR04(trigger_pin=16, echo_pin=0)
def init(): i2c = I2C(scl=Pin(19), sda=Pin(18)) oled = ssd1306.SSD1306_I2C(128, 64, i2c, 0x3c) hcsr04 = HCSR04(trigger_pin=32, echo_pin=35, echo_timeout_us=1000000) hcsr501Pin = Pin(26, Pin.IN) hcsr501Pin.irq(trigger=Pin.IRQ_FALLING, handler=interruptCallbackHandler) return oled, hcsr04
def print_distance(trigger_pin=trigger_pin_num, echo_pin=echo_pin_num, c=sound_speed, interval=sleep_time): sensor = HCSR04(trigger_pin, echo_pin, c) led = Pin(2, Pin.OUT) led.value(0) while True: led.value(1) print(sensor.distance()) utime.sleep(interval)
def record_dist(prefix='NAME', interval_ms=100, record_time=10, trigger_pin_num=12, echo_pin_num=14, sound_speed=343, write_file=1): rtc = RTC() sensor = HCSR04(trigger_pin=trigger_pin_num, echo_pin=echo_pin_num, c=sound_speed) print('\nUsing sampling interval ', interval_ms, ' milliseconds...') print('Recording data for ', record_time, ' seconds...\n') ID = hexlify(unique_id()).decode( 'utf-8') # Unique ID of the microprocessor tmp_file = 'tmp.txt' # A temporary filename; we will write partial data to this file, and rename only if sampling datafile = open(tmp_file, 'w') print('\n\n****Beginning Recording ****\n\n') timestamp = str(utime.mktime(rtc.datetime())) if write_file == 1: filename = prefix + '_' + ID + '_' + timestamp + '.txt' print('\nCreating data file: ', filename) sample_num = (record_time * 1000) / 100 for sample in range(sample_num + 1): t_onboard = rtc.datetime() dist = sensor.distance() data_str = '' print(dist) if write_file == 1: for t in [sample,t_onboard[0],t_onboard[1],t_onboard[2],t_onboard[4],t_onboard[5], \ t_onboard[6],t_onboard[7], dist]: data_str += '{} '.format(t) if sample == 0: datafile = open(tmp_file, 'w') else: # If the first sample, overwrite old tmp_file if it exists df = datafile.write( "%s\n" % data_str ) # df contains the "result" of the write statement (success or failure) else: print(sample,t_onboard[0],t_onboard[1],t_onboard[2],t_onboard[3],t_onboard[4],t_onboard[5], \ t_onboard[6],t_onboard[7], dist) if sample < sample_num: # Sleep only if another sample is to be taken utime.sleep_ms(interval_ms) #--------------------------------------- # Done with the comparison loop; change the temporary filename to the permanent one, now that sampling is complete if write_file == 1: #--------------------------------------- datafile.close() rename(tmp_file, filename)
def __init__(self, io_id, io_user, io_key, frequency, port=1883): # Turn sensors on/off self.sensor_on = True # Save variables passed for use in other methods self.io_id = io_id self.io_user = io_user self.io_key = io_key self.update_frequency = frequency self.port = port self.sensor = HCSR04() utime.sleep_ms(100) print("Weather MQTT client is ready.")
def HCSR(readings=[10, 5], limit=300, echo_timeout_us=500 * 10): "[send pulses, min N of positive reply], within limit mm" hc = HCSR04(trigger_pin=HCSR_TRIGGER, echo_pin=HCSR_SENSOR, echo_timeout_us=echo_timeout_us) READ = [] for x in range(0, readings[0]): try: distance = hc.distance_mm() READ.append(distance) #(int(distance < limit)) except Exception as e: if str(e).find('Out of range') != -1: pass else: print('ERROR getting distance ' + str(e)) return (len([i for i in READ if i]) >= readings[1], READ)
def measure_dist(prefix='ocn351', interval_ms=100, record_time=10, trigger_pin_num=12, echo_pin_num=14, sound_speed=343, write_file=0): sensor = HCSR04(trigger_pin=trigger_pin_num, echo_pin=echo_pin_num, c=sound_speed) # Set up the HCSR04 print('\nUsing sampling interval ', interval_ms, ' milliseconds...') print('Recording data for ', record_time, ' seconds...\n') print('\n\n****Beginning Recording ****\n\n') runTimer = Timer(-1) # Initiate a timer tmp_file = 'tmp.txt' # A temporary filename; we will write partial data to this file, and rename only if sampling rtc = RTC() # intiate a real-time clock variable ID = hexlify(unique_id()).decode( 'utf-8') # Unique ID of the microprocessor timestamp = str(utime.mktime( rtc.datetime())) # Create a string time stamp from the real-time clock filename = prefix + '_' + ID + '_' + timestamp + '.txt' # Define a filename to be used if writing a file if write_file == 1: # If writing a file... print('\nCreating data file: ', filename, '\n\n') # Notify user datafile = open( tmp_file, 'w') # Create and open a temporary file for data to be logged to else: # if not writing a file... datafile = '' # Create an empty variable to be passed along print('\nNot writing data to file\n') # Notify user # Run a timer that executes our record_dist function periodically, with the interval of the period defined from interval_ms runTimer.init(period=interval_ms, mode=Timer.PERIODIC, callback=lambda t: record_dist(sensor, write_file, tmp_file, rtc, datafile)) utime.sleep( record_time ) # Sleep and let the timer run for the length of time defined by record_time runTimer.deinit() # At the end of our sleep, stop the timer if write_file == 1: # If we've been writing a file... datafile.close() # Close the temporary file rename( tmp_file, filename ) # Rename the temporary file with the filename constructed above
def Grab_DATA_Devices_Send(): from dht import DHT11 from hcsr04 import HCSR04 import MQ2 global Devices_Data, Mqtt_User, MQTT_Client while True: sleep(5) #dht:[pin,[],[]] for i in Devices["DHT"]: DHT = DHT11(Pin(i, Pin.IN, Pin.PULL_UP)) DHT.measure() Devices_Data["DHT"].append([i, DHT.temperature, DHT.humidity]) # for i in Devices["GSense"]: # GS = MQ2(pinData = i, baseVoltage = 5) # GS.calibrate() # Devices_Data["GSense"].append([i,GS.readSmoke(), GS.readLPG(), GS.readMethane(), readHydrogen()]) # #checking smoke (recheck the values online!!!) # if Devices_Data["GSense"][j][0]>500 or Devices_Data["GSense"][j][1]>500: # Alarm = True # Fire_Gas_Alarm() j = 0 for i in Devices["Ultrason"]: US = HCSR04(trigger_pin=i[0], echo_pin=i[1]) if US.distance_cm() > 3.0: #Door id and the second value is bool either open or not Devices_Data["Ultrason"][j] = [i[0], {"value": True}] else: Devices_Data["Ultrason"][j] = [i[0], {"value": False}] j += 1 try: MQTT_Client.publish( bytes(Mqtt_User + "/Values", "UTF-8"), bytes( "{'data':" + str(Devices_Data) + ",'clientid':" + MQTT_ClientID + "}", "UTF-8")) except OSError as e: restart_and_reconnect()
def __init__(self, config, verbose=0): self.verbose = verbose self.source = 'WaterLevel' self.channel = 'WaterLevel' self.config = config self.ultrasound = HCSR04( trigger_pin=config['pinout']['ultrasound']['trig_pin'], echo_pin=config['pinout']['ultrasound']['echo_pin']) self.tank_model = config['device']['tank']['model'] self.tank_height = config['device']['tank']['height'] self.tank_volume = config['device']['tank']['volume'] self.lid_inclination = config['device']['tank']['lid_inclination'] self.read_interval = config['device']['level_read_interval'] self.start = None self.level_queue = [] self.queue_depth = 10 self.calibration_depth = 100 self._calibrated = False self.level_average = 0 self.level_percentile = 0.0 self.level_volume = 0 self.level_readings = 0
def measure_dist(prefix='ocn351', interval_ms=100, record_time=5, trigger_pin_num=12, echo_pin_num=13, sound_speed=343, write_file=0): global startSampleFlag startSampleFlag = 0 sensor = HCSR04(trigger_pin=trigger_pin_num, echo_pin=echo_pin_num, c=sound_speed) # Set up the HCSR04 print('\nUsing sampling interval ', interval_ms, ' milliseconds...') print('Recording data for ', record_time, ' seconds...\n') print('\n\n****Beginning Recording ****\n\n') runTimer = Timer(-1) # Initiate a timer tmp_file = 'tmp.txt' # A temporary filename; we will write partial data to this file, and rename only if sampling rtc = RTC() # intiate a real-time clock variable ID = hexlify(unique_id()).decode( 'utf-8') # Unique ID of the microprocessor timestamp = str(utime.mktime( rtc.datetime())) # Create a string time stamp from the real-time clock filename = prefix + '_' + ID + '_' + timestamp + '.txt' # Define a filename to be used if writing a file if write_file == 1: # If writing a file... print('\nCreating data file: ', filename, '\n\n') # Notify user datafile = open( tmp_file, 'w') # Create and open a temporary file for data to be logged to else: # if not writing a file... datafile = '' # Create an empty variable to be passed along print('\nNot writing data to file\n') # Notify user # Run a timer that executes our record_dist function periodically, with the interval of the period defined from interval_ms print('\nWaiting For Trigger\n') while True: if startSampleFlag == 1: startSampleFlag = 0 init_record(runTimer, record_time, interval_ms, sensor, write_file, tmp_file, rtc, datafile, filename)
def coleta(): sensor = HCSR04(trigger_pin=16, echo_pin=0) servo = machine.PWM(machine.Pin(12), freq=50) distance = sensor.distance_cm() i = 30 servo.duty(30) while i < 115: #Giro do servo servo.duty(i) time.sleep(0.5) distance = sensor.distance_cm() #Leitura do sensor time.sleep(0.5) if distance > 60: print('60,', end='') else: print(distance, ',', end='') time.sleep(0.5) i = i + 14 #Logica de rotação em 30 gráus print(' ') print('---x-----x----') time.sleep(1)
from hcsr04 import HCSR04 from machine import Pin,I2C import ssd1306 import time i2c = I2C(0) #i2c hardware olarak baslatildi ESP32 icin scl=18, sda=19 oled=ssd1306.SSD1306_I2C(128,64,i2c) sensor = HCSR04(trigger_pin=13, echo_pin=15,echo_timeout_us=1000000) try: while True: distance = sensor.distance_cm() print(distance) oled.fill(0) oled.text("Distance:",30,20) oled.text(str(distance),30,40) oled.show() time.sleep(0.1) except KeyboardInterrupt: pass
# TRIG 13 # ECHO 15 # GND G from hcsr04 import HCSR04 # import hcsr04 from machine import Pin, I2C from ssd1306 import SSD1306_I2C import time import neopixel led_sayisi = 8 np = neopixel.NeoPixel(Pin(4), led_sayisi) oled = SSD1306_I2C(128, 64, I2C(0)) #i2c hardware olarak kullaniliyor MesafeSensoru = HCSR04(trigger_pin=13, echo_pin=15, echo_timeout_us=1000000) while True: mesafe = int(MesafeSensoru.distance_cm()) print(mesafe, " cm") oled.fill(0) oled.text("Mesafe", 30, 20) oled.text(str(mesafe), 30, 40) # degiskenler once string'e cevirilmelidir oled.show() if mesafe < 10: for n in range(led_sayisi): np[n] = (32, 0, 0)
from hcsr04 import HCSR04 sensor = HCSR04(trigger_pin=16, echo_pin=0) distance = sensor.distance_cm() print('Distance:', distance, 'cm') distance = sensor.distance_mm() print('Distance:', distance, 'mm') ############################ from hcsr04 import HCSR04 sensor = HCSR04(trigger_pin=16, echo_pin=0, echo_timeout_us=1000000) distance = sensor.distance_cm() print('Distance:', distance, 'cm') ############################ from hcsr04 import HCSR04 sensor = HCSR04(trigger_pin=16, echo_pin=0, echo_timeout_us=10000) try: distance = sensor.distance_cm() print('Distance:', distance, 'cm') except OSError as ex:
def __init__(self, trigger_pin, echo_pin, bottle_height_cm, ml_per_cm): self.sensor = HCSR04(trigger_pin=trigger_pin, echo_pin=echo_pin) self.bottle_height_cm = bottle_height_cm self.ml_per_cm = ml_per_cm
RANDOM_TURN_MAX = 1000 # ms COLLISION_THRESHOLD = 30 # cm APPROACH_THRESHOLD = 100 #cm MAX_SPEED_THRESHOLD = 250 #cm LR_COMPENSATION = +10 # %, -10 slows L motor comared to R ULTRASONIC_SAMPLING = 1000 # ms, how often detect obstacle moto_L1 = Pin(pinout.MOTOR_1A, Pin.OUT) moto_L2 = Pin(pinout.MOTOR_2A, Pin.OUT) moto_L = PWM(Pin(pinout.MOTOR_12EN, Pin.OUT), freq=500, duty=0) moto_R3 = Pin(pinout.MOTOR_3A, Pin.OUT) moto_R4 = Pin(pinout.MOTOR_4A, Pin.OUT) moto_R = PWM(Pin(pinout.MOTOR_34EN, Pin.OUT), freq=500, duty=0) echo = HCSR04(trigger_pin=pinout.PWM2_PIN, echo_pin=pinout.PWM1_PIN) def compensate_speed_left(speed): return speed + int(speed / 100 * LR_COMPENSATION / 2) def compensate_speed_right(speed): return speed - int(speed / 100 * LR_COMPENSATION / 2) def forward(speed): moto_L1.value(0) moto_L2.value(1) moto_R3.value(0)
import urequests import socket #driver for distance_cm() from hcsr04 import HCSR04 CFG_BSSID='SRRU-IoT' CFG_BSSID_PASS='******' FRONT_LED = machine.Pin(2, machine.Pin.OUT) P1 = machine.Pin(16, machine.Pin.OUT) P2 = machine.Pin(5, machine.Pin.OUT) P3 = machine.Pin(4, machine.Pin.OUT) P4 = machine.Pin(0, machine.Pin.OUT) FRONT = HCSR04(trigger_pin=12, echo_pin=14, echo_timeout_us=1000000) def __init__(): print("INIT") print('Frequency ', machine.freq()) FRONT_LED.value(1) ap = network.WLAN(network.AP_IF) ap.active(False) def stop(): print("stop") FRONT_LED.value(0) P1.on() P2.on() P3.on() P4.on()
from hcsr04 import HCSR04 import time sensor = HCSR04(trigger_pin=26, echo_pin=25) while 1: distance = sensor.distance_cm() print('Distance:', distance, 'cm') time.sleep(.3)
import time import RPi.GPIO as GPIO import threading from hx711 import HX711 from hcsr04 import HCSR04 GPIO.setwarnings(False) hx = HX711(5, 6) hx.set_reading_format("MSB", "MSB") hx.set_reference_unit(95.20) hx.reset() hx.tare() hc = HCSR04(18, 24) def measure_dist(): d = hc.distance() return d def measure_wt(): val = max(0, int(hx.get_weight(5))) return val while True: time.sleep(0.1) x = measure_dist() time.sleep(0.1) y = measure_wt()
def __init__(self): self.hcsr04 = HCSR04(trigger_pin=Pin.P14, echo_pin=Pin.P15)
def __init__(self, *args, **kwargs): print("Initializing distance") super().__init__(*args, **kwargs) self.sensor = HCSR04(trigger_pin=self.settings["trigger_pin"], echo_pin=self.settings["echo_pin"])
from hcsr04 import HCSR04 from time import sleep_ms sensor = HCSR04(trigger_pin=19, echo_pin=18) while True: print(sensor.distance_cm()) sleep_ms(50)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) from hcsr04 import HCSR04 self.sensor = HCSR04(trigger_pin=self.settings["trig_pin"], echo_pin=self.settings["echo_pin"])
import json import time # libraries used for sensors for RPi import RPi.GPIO as GPIO import threading from hx711 import HX711 from hcsr04 import HCSR04 GPIO.setwarnings(False) hx = HX711(5, 6) # GPIO pins from RPI used for the load-cell sensor hx.set_reading_format("MSB", "MSB") hx.set_reference_unit(95.20) # calibrating load cell hx.reset() hx.tare() hc = HCSR04(18, 24) # GPIO pins from RPI used for the ultra-sonic sensor # allows data to be read over groups think-speak channel def readData(): URl = 'https://api.thingspeak.com/channels/1173908/feeds.json?api_key=6G647UFZ4V0F7XL2&results=2' KEY = '6G647UFZ4V0F7XL2' HEADER = '&results=1' NEW_URL = URl + KEY + HEADER #print(NEW_URL) get_data = requests.get(NEW_URL).json() #print(get_data) channel_id = get_data['channel']['id']
wlan = None s = None mySensorArray1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] mySensorArray2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] mySensorArray3 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] mySensorArray4 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] mySensorArray5 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] hitCount1 = 0 hitCount2 = 0 hitCount3 = 0 hitCount4 = 0 hitCount5 = 0 mySensor1 = HCSR04(trigger_pin=12, echo_pin=4) mySensor2 = HCSR04(trigger_pin=14, echo_pin=16) mySensor3 = HCSR04(trigger_pin=27, echo_pin=17) mySensor4 = HCSR04(trigger_pin=26, echo_pin=5) mySensor5 = HCSR04(trigger_pin=25, echo_pin=18) mySensorBaseAvg = 270 ##REMEMBER TO SET TO ACTUAL VALUE! for x in range(9): mySensorArray1[x] = mySensorBaseAvg for x in range(9): mySensorArray2[x] = mySensorBaseAvg for x in range(9): mySensorArray3[x] = mySensorBaseAvg for x in range(9): mySensorArray4[x] = mySensorBaseAvg
print("Received disconnect message. Shutting down.") sys.exit() ## For H-bridge pin1a = machine.PWM(machine.Pin(27), freq=1000) pin1b = machine.PWM(machine.Pin(14), freq=1000) pin2a = machine.PWM(machine.Pin(12), freq=1000) pin2b = machine.PWM(machine.Pin(13), freq=1000) set_zero() ## set pin 26 as a pwm pin for servo rotation servo_pin = machine.PWM(machine.Pin(26), freq=50) servo_pin.duty(77) ## For HCSR04 sensor = HCSR04(trigger_pin=25, echo_pin=33, echo_timeout_us=3000) # set pin 25 and 33 as as trigger and echo pin event = None localIP = '0.0.0.0' localPort = 3000 bufferSize = 1024 msgFromServer = "Hello UDP Client" ##bytesToSend = str.encode(msgFromServer) UDPServerSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) UDPServerSocket.bind((localIP, localPort)) UDPServerSocket.settimeout(0.01)
def init(): i2c = I2C(scl=Pin(19), sda=Pin(18)) oled = ssd1306.SSD1306_I2C(128, 64, i2c, 0x3c) sensor = HCSR04(trigger_pin=32, echo_pin=35, echo_timeout_us=1000000) return oled, sensor
from hcsr04 import HCSR04 import time from payloader import Payloader import utime import urequests as u import ujson while True: sensor = HCSR04(trigger_pin=5, echo_pin=4) distance = sensor.distance_cm() data = { "jarak-1": distance, "jarak-2": distance } #di bagian ini diisi dengan data yang dikirim #jika data ada banyak maka perlu di format menggunakan bentuk JSON dengan data menjadi nilai-nya col = 'ultrasonik' #nama collection diisi dengan nama identifikasi sensor p = Payloader(data, col) p.send() utime.sleep_ms(1000)