class WaterDetector(Sensor): """ water detector driver """ def __init__(self, gpio_pin): self._gpio_pin = gpio_pin self._gpio = None self._is_connected = False def connect(self): self._gpio = GPIO(self._gpio_pin, "in") self._is_connected = True return True def disconnect(self): self._is_connected = False self._gpio = None return True def is_connected(self): return self._is_connected def is_water_full(self): """ Returns: bool: return True if detect water full, otherwise return False """ return self._gpio.read()
def read_GPIOLIST(): for num in range(7): gpio_in = GPIO(GPIO_num_list[num]) GPIO_directon_list[num] = gpio_in.direction GPIO_value_list[num] = gpio_in.read() gpio_in.close() return GPIO_name_list, GPIO_directon_list, GPIO_value_list
class config(object): DONE_ITS = 100 CHUNK = 4 * 1024 DELAY = 10e-3 MODE = 3 def __init__(self, ss_pin, cdone_pin, creset_pin, spidev): self.ss = GPIO(ss_pin, "out") self.cdone = GPIO(cdone_pin, "in") self.creset = GPIO(creset_pin, "out") self.spidev = spidev def sleep(self): time.sleep(self.DELAY) def set_ss(self, val): self.ss.write(val) def reset(self, val): if val: self.creset.write(False) else: self.creset.write(True) def wait_done(self): done = 0 cnt = 0 while done == 0 and cnt < self.DONE_ITS: self.sleep() done = self.cdone.read() cnt += 1 return done def sram_config(self, image): self.reset(True) self.sleep() self.set_ss(False) self.sleep() self.reset(False) self.sleep() for i in range(0, len(image), self.CHUNK): self.spidev.transfer(image[i:i + self.CHUNK]) # extra 49 bits self.spidev.transfer(7 * [0])
def read_analog_sensor(self): """ Reads the Sump Pump sensor. :return: Distance to Sump Pump water. :rtype: float """ trig=GPIO(23, 'out') echo=GPIO(24, 'in') # Pulse to trigger sensor trig.write(False) time.sleep(0.00001) trig.write(True) time.sleep(0.00001) trig.write(False) while echo.read()==False: pulse_start=time.time() while echo.read()==True: pulse_end= time.time() pulse_duration=pulse_end-pulse_start # Quick explaination of the formula: # The pulse duration is to the object and back, so the # distance is one half of the pulse duration. The speed of # sound in air is 340 meters/second. There are 100 centimeters # in a meter. distance=pulse_duration*340/2*100 distance=round(distance, 2) trig.close() echo.close() return distance
def play(device, f): periodsize = f.getframerate() // 8 device = alsaaudio.PCM() #Aspetta per farlo partire data = f.readframes(periodsize) #Prebuffering #Polling gpio4_12 = GPIO("/dev/gpiochip4", 12, "in") while (gpio4_12.read() == True): a = None #Leggi e suona while data: device.write(data) data = f.readframes(periodsize)
def read(self, pin): """Read bool value from a pin. Args: pin (int): the pin to read from Return: bool: value of digital pin reading """ with self._gpio_lock: gpio_pin = GPIO(pin, "in") value = gpio_pin.read() gpio_pin.close() self.logger.debug("Read value from GPIO pin {}: {}".format( pin, value)) return bool(value)
class InputMonitor(threading.Thread): def __init__(self, gpio_pin=None): threading.Thread.__init__(self) self._is_gpio = gpio_pin is not None if self._is_gpio: self._gpio = GPIO(gpio_pin, 'in') self._lock = threading.Lock() self._is_key_pressed = False self._last_key_pressed_time = time.monotonic() def is_key_pressed(self): self._lock.acquire() if self._is_key_pressed: self._is_key_pressed = False self._lock.release() return True self._lock.release() return False def run(self): while True: if self._is_gpio: v = self._gpio.read() diff = time.monotonic() - self._last_key_pressed_time if v \ and not self._is_key_pressed \ and diff > 0.2: self._lock.acquire() self._is_key_pressed = True self._last_key_pressed_time = time.monotonic() self._lock.release() time.sleep(0.1) else: input() self._lock.acquire() self._is_key_pressed = True self._lock.release()
class UserInputs(object): """Tests that values can be written and read from a GPIO pin""" def __init__(self, logging): self.gpio = None if isinstance(self, UserInputOne): self.gpio = GPIO(pin=85, direction=OUT) elif isinstance(self, UserInputTwo): self.gpio = GPIO(pin=86, direction=OUT) elif isinstance(self, UserInputThree): self.gpio = GPIO(pin=90, direction=OUT) self.logging = logging def test_high(self): """Tests that high values can be written and read from the GPIO pin""" return self._test(True) def test_low(self): """Tests that low values can be written and read from the GPIO pin""" return self._test(False) def _test(self, level): try: self.gpio.write(level) logging.debug("Value written") val = self.gpio.read() if val is level: self.logging.debug("Value read is the one same as the one written") return True else: message = "Value read is different to the one written: " + str(val) + " != " + str(level) self.logging.fatal() return False except Exception as ex: self.logging.fatal(ex) return False
# Toggle LED through GPIO function # Author: Peter Mankowski from periphery import GPIO import time # GPIO init gpio = GPIO(138, "low") # Parameters declarations count = 0 How_many_counts = 4 sleep_del = 0.1 """ gpio.write(True) time.sleep(1) """ # Toggle GPIO feature while (count < How_many_counts): count = count + 1 value = gpio.read() gpio.write(not value) time.sleep(sleep_del) gpio.close()
def getpoint(): maxHeight = 480 maxWidth = 640 capture = cv2.VideoCapture(0) capture.set(3, maxWidth) capture.set(4, maxHeight) gpio_get = GPIO(38, "in") while True: ret, image = capture.read() image = cv2.resize(image, (640, 480), interpolation=cv2.INTER_CUBIC) image = cv2.flip(image, 1) # gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) cv2.imshow('frame', image) # time_in+=1 k = cv2.waitKey(1) value = gpio_get.read() if value == False: break gpio_get.close() # 颜色范围 low_color = np.array([35, 43, 46]) up_color = np.array([77, 255, 255]) # 图像处理 hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV) # 颜色过滤 mask = cv2.inRange(hsv, low_color, up_color) # 边缘检测 cannyimg = cv2.Canny(mask, 10, 200) # cv2.imshow("img",cannyimg) # cv2.waitKey(0) # 闭运算 print("1") kernelX = cv2.getStructuringElement(cv2.MORPH_RECT, (17, 5)) cannyimg = cv2.morphologyEx(cannyimg, cv2.MORPH_CLOSE, kernelX) circles = cv2.HoughCircles(cannyimg, cv2.HOUGH_GRADIENT, 1, 20, param1=100, param2=5, minRadius=2, maxRadius=13) circles = np.uint16(np.around(circles)) print("2") center = [[circles[0][0][0], circles[0][0][1]], [circles[0][1][0], circles[0][1][1]], [circles[0][2][0], circles[0][2][1]], [circles[0][3][0], circles[0][3][1]]] print("3") n = len(center) for i in range(n): # Last i elements are already in place for j in range(0, n - i - 1): if center[j][0] > center[j + 1][0]: center[j], center[j + 1] = center[j + 1], center[j] if center[0][1] > center[1][1]: center[0], center[1] = center[1], center[0] if center[2][1] > center[3][1]: center[2], center[3] = center[3], center[2] center[1], center[2] = center[2], center[1] print("4") # original pts pts_o = np.float32([center[0], center[1], center[2], center[3]]) # 这四个点为原始图片上数独的位置 pts_d = np.float32([[0, 0], [600, 0], [0, 600], [600, 600]]) # 这是变换之后的图上四个点的位置 print("5") # get transform matrix M = cv2.getPerspectiveTransform(pts_o, pts_d) print("6") # apply transformation dst = cv2.warpPerspective(image, M, (600, 600)) # 最后一参数是输出dst的尺寸。可以和原来图片尺寸不一致。按需求来确定 print("7") image = dst # cv2.imshow("img",image) # cv2.waitKey(0) # low_color2 = np.array([80, 20, 20]) # up_color2 = np.array([255, 150, 80]) low_color2 = np.array([130, 0, 0]) up_color2 = np.array([255, 150, 100]) # print("8") n = len(point) print(n) for index in range(n): # print("xxxxx") bgr = image[point[index][0], point[index][1]] bgr = np.array(bgr) if (low_color2 <= bgr).all() and (up_color2 >= bgr).all(): if point[index][2] == 0: point[index][2] = 1 # print("xxxxxx") print(index, type(index)) return index
class TM1637: I2C_COMM1 = 0x40 I2C_COMM2 = 0xC0 I2C_COMM3 = 0x80 digit_to_segment = [ 0b0111111, # 0 0b0000110, # 1 0b1011011, # 2 0b1001111, # 3 0b1100110, # 4 0b1101101, # 5 0b1111101, # 6 0b0000111, # 7 0b1111111, # 8 0b1101111, # 9 0b1110111, # A 0b1111100, # b 0b0111001, # C 0b1011110, # d 0b1111001, # E 0b1110001 # F ] def __init__(self, clk, dio): self.clk = clk self.dio = dio self.brightness = 0x0f self.gpio_clk = GPIO(self.clk, "out") self.gpio_dio = GPIO(self.dio, "out") def bit_delay(self): sleep(0.001) return def set_segments(self, segments, pos=0): # Write COMM1 self.start() self.write_byte(self.I2C_COMM1) self.stop() # Write COMM2 + first digit address self.start() self.write_byte(self.I2C_COMM2 + pos) for seg in segments: self.write_byte(seg) self.stop() # Write COMM3 + brightness self.start() self.write_byte(self.I2C_COMM3 + self.brightness) self.stop() def start(self): self.gpio_clk.write(True) self.gpio_dio.write(True) self.gpio_dio.write(False) self.gpio_clk.write(False) def stop(self): self.gpio_clk.write(False) self.gpio_dio.write(False) self.gpio_clk.write(True) self.gpio_dio.write(True) def write_byte(self, data): #print("data={:x}".format(data)) for i in range(8): self.gpio_clk.write(False) if data & 0x01: self.gpio_dio.write(True) else: self.gpio_dio.write(False) data >>= 1 self.gpio_clk.write(True) self.gpio_clk.write(False) self.gpio_dio.write(True) self.gpio_clk.write(True) self.gpio_dio = GPIO(self.dio, "in") while self.gpio_dio.read(): sleep(0.001) if self.gpio_dio.read(): self.gpio_dio = GPIO(self.dio, "out") self.gpio_dio.write(False) self.gpio_dio = GPIO(self.dio, "in") self.gpio_dio = GPIO(self.dio, "out")
class SPIComms(object): # Message headers defined for this communication protocl HEADERS = {"heartbeat": b'\x10', "message": b'\x20', "config": b'\x30'} def __init__(self, source): self.source = source self.data_length = self.source.get_flatten_length() # Store heartbeat received from microcontroller # Used to make sure that microcontroller is still available self.prev_heartbeat_count = 0 self.heartbeat_count = 0 # Create the data format message # Message is 4 bytes long # Defined in communication doc self.data_format_message = [0, self.data_length, 0, 0] self.spi = None self.signal_pin = None self.comm_thread = None self.max_error_count = 50 self.data_lock = threading.Lock() self.data = np.zeros(shape=(self.data_length, ), dtype=np.float32) def start(self): # Open spidev0.0 device with mode 0 and max speed 100 kHz if (self.spi is None): self.spi = SPI("/dev/spidev0.0", 0, 30000) #, bit_order= "lsb") # Open GPIO pin connection if (self.signal_pin is None): self.signal_pin = GPIO(6, "in") if (self.comm_thread is None): print("starting comms thread") self.comm_thread = threading.Thread(target=self._comm_thread_fn, daemon=True) self.comm_thread.start() def set_data(self, data): with self.data_lock: np.copyto(self.data, data) def _comm_thread_fn(self): while True: # Initialize the communications with the microcontoller self._comm_init() error_count = 0 while error_count < self.max_error_count: # heartbeat header self.prev_heartbeat_count = self.heartbeat_count self.heartbeat_count = int.from_bytes( self.spi.transfer(self.HEADERS["heartbeat"]), "little") if (self.heartbeat_count <= self.prev_heartbeat_count): print("ERROR") error_count += 1 else: error_count = 0 if (self.signal_pin.read()): print("Transferring data") self.spi.transfer(self.HEADERS['message']) with self.data_lock: self.data = self.source.tobytes() self.spi.transfer(self.data) time.sleep(0.01) def _comm_init(self): # Flags to store where in the comm init program is init_signal_received = False print("Starting init") # Create an array storing the responses received from the microcontroller responses = [b'\x00', b'\x00', b'\x00'] # Loop init process while not init_signal_received: # Pop the first response and append the last response responses.pop(0) responses.append(self.spi.transfer(b'\xFF')) startTime = time.time() # Read pin for 100 ms to check for correct response # Correct response is high on the signal pin and 0xFF, 0xFE, 0xFD heartbeat sequence while time.time() - startTime < 0.1: if (self.signal_pin.read() and responses == [b'\xff', b'\xfe', b'\xfd']): init_signal_received = True break print("Received signal, waiting for heartbeat") self.spi.transfer(self.HEADERS["config"]) responses = self.spi.transfer(b'\x00\x00\x00\x00') # Store the last two heartbeats self.prev_heartbeat_count = responses[2] self.heartbeat_count = responses[3] print("Heartbeat received, successful init!") # Wait until we receive request for data while (not self.signal_pin.read()): time.sleep(0.1) print("Received high on pin") print("Transmitting format message") # Transferring data format message self.spi.transfer(self.HEADERS["config"]) time.sleep(1) self.spi.transfer(self.data_format_message)
from periphery import GPIO dir(GPIO) gpio4_12 = GPIO("/dev/gpiochip4", 12, "in") gpio_green = GPIO("/dev/gpiochip1", 24, "out") gpio_red = GPIO("/dev/gpiochip1", 25, "out") gpio_blue = GPIO("/dev/gpiochip2", 23, "out") while True: #value = gpio4_12.read() event_gpio = gpio4_12.read() print(str(event_gpio)) #print(str(value))
"""Digital IO (Input/Output) using periphery""" from periphery import GPIO # 根据具体板卡的LED灯和按键连接修改使用的Chip和Line LED_CHIP = "/dev/gpiochip3" LED_LINE_OFFSET = 19 BUTTON_CHIP = "/dev/gpiochip4" BUTTON_LINE_OFFSET = 1 led = GPIO(LED_CHIP, LED_LINE_OFFSET, "out") button = GPIO(BUTTON_CHIP, BUTTON_LINE_OFFSET, "in") try: while True: led.write(button.read()) finally: led.write(True) led.close() button.close()
def main(): print("initializing") pool = ThreadPool(processes=1) #Time operator have to push button after product is detected IMG_SAVE_DELAY = 500 #This is used to signal that if operator dont push button then save image to approved folder flagPhotoSensor = False #Resolution on image resolution = (1280, 720) #Paths to put images path_approved = '/media/storage/good/' path_not_approved = '/media/storage/bad/' #Create camera object that takes images and store in approved or not approved folder camera = Camera(resolution, 'png', path_approved, path_not_approved) #GPIO stuff on_off = GPIO(7, 'in') disallowed_img = GPIO(138, 'in') disallowed_img.edge = 'rising' photoSensor = GPIO(140, 'in') photoSensor.edge = 'rising' #Create Display object display = Display() #Variable to handle debounce on input from photosensor lastPhotoSensorValue = False #Variable to handle debounce on input from operator button lastOperatorBtnValue = False #Get time in ms currentTime_ms = lambda: int(round(time.time() * 1000)) #Calculate new time - old time to get time difference between two events deltaTime_ms = lambda oldTime_ms: int(round(time.time() * 1000) ) - oldTime_ms #Store time to calculate time difference oldTime_ms = currentTime_ms() print("initialization done") #Run forever while True: #If system is turned on by switch, run program display.off() if on_off.read() or True: print("System started") #Make sure no old values are stored flagPhotoSensor = False camera.camera.start() #Stay in loop as long as system is turned on while on_off.read() or True: #If there is a product in front of camera, take a picture and record the time if photoSensor.read( ) and not lastPhotoSensorValue and not flagPhotoSensor: #img = camera.camera.get_image() async_img = pool.apply_async(camera.take_image) oldTime_ms = currentTime_ms() #Save that photo sensor has been high flagPhotoSensor = True #If operator push button before IMG_SAVE_DELAY time, save image to not approved folder #and blink red light once to inform operator while deltaTime_ms(oldTime_ms) <= IMG_SAVE_DELAY: if disallowed_img.read() and not lastOperatorBtnValue: img = async_img.get() threading.Thread(target=display.show_img, args=(img, False)).start() camera.save_img(img, False) flagPhotoSensor = False lastOperatorBtnValue = disallowed_img.read() #if operator dont push button before IMG_SAVE_DELAY time run out, save #image to approved folder and blink green light. if (deltaTime_ms(oldTime_ms) > IMG_SAVE_DELAY) and flagPhotoSensor: img = async_img.get() threading.Thread(target=display.show_img, args=(img, True)).start() camera.save_img(img, True) flagPhotoSensor = False camera.camera.stop() lastPhotoSensorValue = photoSensor.read()
class Pin: """Pins dont exist in CPython so...lets make our own!""" IN = "in" OUT = "out" LOW = 0 HIGH = 1 PULL_NONE = 0 PULL_UP = 1 PULL_DOWN = 2 id = None _value = LOW _mode = IN def __init__(self, pin_id): self.id = pin_id if isinstance(pin_id, tuple): self._num = int(pin_id[1]) self._chippath = "/dev/gpiochip{}".format(pin_id[0]) else: self._num = int(pin_id) self._chippath = "/dev/gpiochip0" self._line = None def __repr__(self): return str(self.id) def __eq__(self, other): return self.id == other def init(self, mode=IN, pull=None): """Initialize the Pin""" if mode is not None: if mode == self.IN: self._mode = self.IN if self._line is not None: self._line.close() self._line = GPIO(self._chippath, int(self._num), self.IN) elif mode == self.OUT: self._mode = self.OUT if self._line is not None: self._line.close() self._line = GPIO(self._chippath, int(self._num), self.OUT) else: raise RuntimeError("Invalid mode for pin: %s" % self.id) if pull is not None: if pull == self.PULL_UP: raise NotImplementedError( "Internal pullups not supported in periphery, " "use physical resistor instead!" ) if pull == self.PULL_DOWN: raise NotImplementedError( "Internal pulldowns not supported in periphery, " "use physical resistor instead!" ) raise RuntimeError("Invalid pull for pin: %s" % self.id) def value(self, val=None): """Set or return the Pin Value""" if val is not None: if val == self.LOW: self._value = val self._line.write(False) return None if val == self.HIGH: self._value = val self._line.write(True) return None raise RuntimeError("Invalid value for pin") return self.HIGH if self._line.read() else self.LOW
from periphery import GPIO gpio_get = GPIO(38, "in") while 1: value = gpio_get.read() print(value) gpio_get.close()
# Robot Code for Tech Garage # Author: Danny Dasilva # License: Public Domain from app.Robot import Controller, Py_Hat from My_Custom_Code import my_custom_teleop, my_custom_autonomous from time import sleep import os from periphery import GPIO from time import sleep gpio_in = GPIO(8, "in") while True: value = gpio_in.read() if value == False: break else: print("custom code") #my_custom_teleop() my_custom_autonomous() sleep(.01) gpio_in.close() #controller class controller = Controller() # initialize Pi Hat hat = Py_Hat(address=96)
from periphery import GPIO enable_switch = GPIO(160, "in") # === DEBUG === flag = False count = 1 cap = cv2.VideoCapture(0) # === pastAngles = [0, 0] # used to smooth out startUp = True velo = 700 #between 600 and 800 for forwards while (cap.isOpened()): # ON Button code while (not enable_switch.read()): # We want to pause the program pwm.set_pwm(steer, 0, steer_mid) pwm.set_pwm(gas, 0, gas_mid) time.sleep(1) startUp = False # Image Capture _, frame = cap.read() #frame=cv2.imread('obsflipdummy.png') saveFrame = frame frame = resizeMe(frame, 3) #frame = frame[frame.shape[0]/2:frame.shape[0]-1,:,:] #frame=np.uint8((frame.astype(float)/16.)**2)