def main(): # tell the GPIO module that we want to use the # chip's pin numbering scheme GPIO.setmode(GPIO.BCM) # setup pin 25 as an output GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.setup(17, GPIO.OUT) # GPIO.setup(25,GPIO.OUT) # GPIO.output(25,True) while True: pressed = not GPIO.input(18) if pressed: # the button is being pressed, so turn on the green LED # and turn off the red LED GPIO.output(17,True) # GPIO.output(25,False) print "button true" else: # the button isn't being pressed, so turn off the green LED # and turn on the red LED GPIO.output(17,False) # GPIO.output(25,True) print "button false" time.sleep(0.1) print "button pushed" GPIO.cleanup()
def distance(measure): gpio.setmode(gpio.BOARD) gpio.setup(TRIG, gpio.OUT) gpio.setup(ECHO, gpio.IN) gpio.output(TRIG, False) gpio.output(TRIG, True) time.sleep(0.00001) gpio.output(TRIG, False) sig = 0 nosig = 0 while gpio.input(ECHO) == 0: nosig = time.time() while gpio.input(ECHO) == 1: sig = time.time() if nosig != None and sig != None: tl = sig - nosig distance = tl * 17150 distance = round(distance, 2) gpio.cleanup() return distance
def __new__(cls, port, consigne = 0): #Initialisation du nouveau moteur if port in cls._MOTEURS: #Si le port est déjà pris raise MoteurExistErreur if port not in Moteur._PORTS: #Si le port est dispo raise MoteurPortErreur if consigne < -100 or consigne > 100: #Si la vitesse est comprise dans [-100;100] raise MoteurConsigneError self = object.__new__(cls) self._port = port self._isRuning = False self._consigne = consigne cls._MOTEURS[port] = self if port == 'A': pinA = 33 pinB = 35 self._pinTacho1 = 7 self._pinTAcho2 = 11 elif port == 'B': pinA = 37 pinB = 40 else: pinA = 38 pinB = 36 GPIO.setup(pinA, GPIO.OUT) #On initialise les pins en sortie GPIO.setup(pinB, GPIO.OUT) self._pwm1 = GPIO.PWM(pinA, 1000) #On les mets en tant que sortie PWMs self._pwm2 = GPIO.PWM(pinB, 1000) #GPIO.setup(self._pinTacho1, GPIO.IN) #On initialise les entrée pour récupéré signal tacho #GPIO.setup(self._pinTacho2, GPIO.IN) return self
def led_setup(): io.setmode(io.BOARD) for val in LED: io.setup(val, io.OUT) for val in RGB: io.setup(RGB[val], io.OUT)
def reset(self): if self._rst > 0: GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) GPIO.setup(self._rst, GPIO.OUT) # toggle pin GPIO.output(self._rst, GPIO.HIGH) sleep(0.1) GPIO.output(self._rst, GPIO.LOW) sleep(0.1) GPIO.output(self._rst, GPIO.HIGH) sleep(0.2) # give it some time to come back GPIO.cleanup(self._rst)
def read_data(): base=0 data=[] # reset GPIO.setmode(GPIO.BCM) GPIO.setup( DHT11_DATA_PIN , GPIO.OUT) GPIO.output( DHT11_DATA_PIN , GPIO.LOW) time.sleep(0.03) # 必须大于18ms GPIO.setup( DHT11_DATA_PIN , GPIO.IN) while GPIO.input( DHT11_DATA_PIN ) == GPIO.HIGH: continue while GPIO.input( DHT11_DATA_PIN ) == GPIO.LOW: continue # 固定拉高80us,可用来做基准 while GPIO.input( DHT11_DATA_PIN ) == GPIO.HIGH: base += 1 continue base = base / 2 # Get data while len(data)< DHT11_DATA_LEN*8: i = 0 # 检测50us以上的低位 while GPIO.input( DHT11_DATA_PIN ) == GPIO.LOW: continue # 此时电平为高,持续26-28us表示0,否则持续70us表示1 while GPIO.input( DHT11_DATA_PIN ) == GPIO.HIGH: i += 1 if i > 100: #最后一个数据也许不会拉低,手动判断 break if i < base: data.append(0) else: data.append(1) print("DHT11 get data: ", data) return data
def right_stop_at_black(): cap = cv2.VideoCapture(0) time.sleep(2) GPIO.setmode (GPIO.BCM) GPIO.setwarnings (False) GPIO.setup (23, GPIO.OUT) GPIO.setup (22, GPIO.OUT) PWML = GPIO.PWM (22,1) PWMR1 = GPIO.PWM (23,1) PWMR1.start(0) PWML.start(0) counter =0 while(1): ret, img = cap.read() PWMR1.ChangeDutyCycle(100) PWML.ChangeDutyCycle(100) ret,thresh = cv2.threshold(img,100,255,cv2.THRESH_BINARY) b1,g1,r1 = thresh[240,500] if b1==255: counter+=1 continue if counter>0: PWMR1.stop() PWML.stop() break GPIO.cleanup() cap.release() return
def main(): GPIO.cleanup() GPIO.setmode(GPIO.BCM) #Relais als Ausgang schalten GPIO.setup(RELAIS, GPIO.OUT) #Eimersensor als Eingang schalten GPIO.setup(SENSOR_BUCKET_PIN,GPIO.IN) #Datenbank initialisieren db = DATABASE() # Aktuelle Luftfeuchtigkeit holen humidity = db.getLatestHumidity() # Checken ob Wasser im Eimer ist if isBucketEmpty(): db.saveBucketEmpty() else: db.saveStatus("OK") # Giessen wenn Luftfeuchtigkeit unter 90 % if humidity < HUMIDITY_LIMIT: db.saveWatering(WATERING_TIME) GPIO.output(RELAIS, GPIO.HIGH) time.sleep(WATERING_TIME) GPIO.output(RELAIS, GPIO.LOW) else: GPIO.output(RELAIS, GPIO.LOW)
def init(self): app.logger.info("INIT GPIO") try: GPIO.setmode(GPIO.BCM) app.logger.info(app.brewapp_hardware_config) for h in app.brewapp_hardware_config: hw = app.brewapp_hardware_config[h]; app.logger.info(hw) g = self.translateDeviceName(hw["config"]["switch"]) app.logger.info(g) if(g != None): app.logger.info("SETUP HARDWARE: " + str(h) + " GPIO: " + str(g)) GPIO.setup(g, GPIO.OUT) if(self.getConfigValue(h, "inverted", False)): app.logger.warning("SETUP INVERTED") GPIO.output(g, 1) else: app.logger.warning("SETUP NOT INVERTED") GPIO.output(g, 0) app.brewapp_gpio = True self.state = True app.logger.info("ALL GPIO INITIALIZED") except Exception as e: app.logger.error("SETUP GPIO FAILED " + str(e)) app.brewapp_gpio = False self.state = False
def flickerLED(times = 1, ledPin = 23): GPIO.setup(ledPin, GPIO.OUT) for i in range(times): GPIO.output(ledPin, True) time.sleep(0.1) GPIO.output(ledPin, False) time.sleep(0.1)
def initBrickPi(): BrickPiSetup() # setup the serial port for communication BrickPi.MotorEnable[PORT_A] = 1 #Enable the Motor A BrickPi.MotorEnable[PORT_B] = 1 #Enable the Motor B BrickPi.MotorEnable[PORT_C] = 1 #Enable the Motor C BrickPi.MotorEnable[PORT_D] = 1 #Enable the Motor D BrickPi.MotorSpeed[PORT_A] = 0 #Set the speed of MotorA (-255 to 255) BrickPi.MotorSpeed[PORT_B] = 0 #Set the speed of MotorB (-255 to 255) BrickPi.MotorSpeed[PORT_C] = 0 #Set the speed of MotorC (-255 to 255) BrickPi.MotorSpeed[PORT_D] = 0 #Set the speed of MotorD (-255 to 255) BrickPi.SensorType[PORT_1] = TYPE_SENSOR_TOUCH #Bumper right bumper BrickPi.SensorType[PORT_4] = TYPE_SENSOR_TOUCH #Bumper left bumper BrickPiSetupSensors() #Send the properties of sensors to BrickPi #Setup GPIO for LEDs GPIO.setwarnings(False) GPIO.setmode(GPIO.BOARD) GPIO.setup(12, GPIO.OUT) #right LED GPIO.setup(13, GPIO.OUT) #left LED updateStuff = threading.Thread( target=updateBrickPi ); updateStuff.start()
def __init__(self): GPIO.setmode(GPIO.BCM) GPIO.setup(4,GPIO.IN,pull_up_down = GPIO.PUD_DOWN) ''' Constructor ''' #config=dict() #with open('apiconfigs.txt', 'rb') as fp: #config = json.load(fp) #self.twitter=Twitter(config["twitter"]) #self.facebook=Facebook(config["facebook"]) #self.printer=Printer() #self.uploader=UploadServer() self.cameraToRasterQueue = Queue.Queue() self.rasterToPrinterQueue = Queue.Queue() self.cameraToSocialPreprocessorQueue = Queue.Queue() self.quitEvent = threading.Event() print "made events and queues" print "init imageprocessor and social preprocessor" self.imageProcessor=ImageProcessor( self.quitEvent, self.cameraToRasterQueue, self.rasterToPrinterQueue, self.cameraToSocialPreprocessorQueue) print "init picamera" #GPIO.setup(18,GPIO.OUT) #pwmLed=GPIO.PWM(18,2000) ledDriver=LedDriver() self.picamera=Picamera( self.quitEvent, self.cameraToRasterQueue,self.cameraToSocialPreprocessorQueue,ledDriver) print "init printer" self.printer=SimpleThermalPrinter( self.quitEvent, self.rasterToPrinterQueue) '''state thread'''
def __init__(self): threading.Thread.__init__(self) #threading-class initialisieren self.daemon = True self.port = rc.config.get('monitor','arduino_port') self.sensor_threshold_min = rc.config.getint('monitor','sensor_threshold_min') self.pir = rc.config.getboolean('monitor','pir') if(self.pir): import RPi.GPIO as GPIO self.pirGPIO = rc.config.getint('monitor','pirGPIO') GPIO.setmode(GPIO.BOARD) GPIO.setup(self.pirGPIO,GPIO.IN) self.pirFunc = rc.config.getint('monitor','pirFunc') #pir works as sensor or filter if (self.pirFunc == 2): self.pirStarttime = 0 #try: # import pigpio #except ImportError: # self.pigpio = None #else: # self.pigpio = pigpio # self.pirGPIO = rc.config.getint('monitor','pirGPIO') # self.pirFunc = rc.config.getint('monitor','pirFunc') # self.pigpio.start() # self.pigpio.set_mode(self.pirGPIO, self.pigpio.INPUT) # if (self.pirFunc == 2): # self.pirStarttime = 0 self.starttime = 0 #read absence self.absence = absence.Absence()
def __init__(self, channel, led_pin, f): self.channel = channel self.f = f self.led_pin = led_pin self.p = Process(target=self.target_f) GPIO.setup(self.channel, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(self.led_pin, GPIO.OUT, initial=GPIO.LOW)
def init_RF12() : GPIO.setmode(GPIO.BOARD) GPIO.setup(18, GPIO.IN, pull_up_down = GPIO.PUD_UP) GPIO.setup(22, GPIO.IN, pull_up_down = GPIO.PUD_DOWN) writeCmd(0x0000) # initial SPI transfer added to avoid power-up problem time.sleep (5) # Give RFM12B time to boot up writeCmd(0x0000) writeCmd(0x80E7) #CREG 1 EL (ena TX), EF (ena RX FIFO), 12.0pF writeCmd(0x82D9) #er,!ebb,ET,ES,EX,!eb,!ew,DC // receive writeCmd(0xA640) #CREG 3 96-3960 freq range of values within band writeCmd(0xC647) #CREG 4 approx 49.2 Kbps, i.e. 10000/29/(1+6) Kbps writeCmd(0x94A0) #CREG 5 VDI,FAST,BW=134kHz,0dBm,-91dBm writeCmd(0xC2AC) #CREG 6 AL,!ml,DIG,DQD4 writeCmd(0xCA83) #CREG 7 0x83 FIFO8,2-SYNC,!ff,!DR writeCmd(0xCED4) #SYNC=2DXX writeCmd(0xC483) #CREG 9 @PWR,NO RSTRIC,!st,!fi,OE,EN writeCmd(0x9850) #C!mp,90kHz,MAX OUT writeCmd(0xCC17) #CPLL Setting Command writeCmd(0xE000) #CREG 12 Wake-Up Timer Command. Disabled writeCmd(0xC800) #CREG 13 Low Duty-Cycle Command. Disabled writeCmd(0xC040) #CREG 14 1.66MHz,3.1V fifoReset()
def __init__(self, lm1, lm2, rm1, rm2): self.status = "x" self.leftMotor = [lm1, lm2] self.rightMotor = [rm1, rm2] self.motors = self.leftMotor + self.rightMotor GPIO.setup(self.motors, GPIO.OUT) self.stop()
def set(pin, status): GPIO.setup(pin, GPIO.OUT) if status == True: status=GPIO.LOW else: status=GPIO.HIGH GPIO.output(pin, status)
def initilise_gpio(self): gpio.setwarnings(False) gpio.setmode(gpio.BCM) for mapping in self.gpio_mapping['mapping']: gpio_pin = int(self.gpio_mapping['mapping'][mapping]) gpio.setup(gpio_pin, gpio.OUT)
def main(): # tell the GPIO module that we want to use the # chip's pin numbering scheme GPIO.setmode(GPIO.BCM) # setup pin 25 as an output GPIO.setup(17,GPIO.IN) GPIO.setup(18,GPIO.IN) while True: if GPIO.input(17): print "Vision Api activated" try: rc = subprocess.call("cd /home/pi/unblind && sh /home/pi/unblind/visionapi.sh && cd -", shell=True) except OSError as e: print( e ) print "button17 true" if GPIO.input(18): print "OCR Api activated" try: rc = subprocess.call("cd /home/pi/unblind && sh /home/pi/unblind/ocr.sh && cd -", shell=True) except OSError as e: print( e ) print "button18 true" time.sleep(0.1) GPIO.cleanup()
def __init__(self): self._gpio_map = {"PWM2":37, "DIR_CLK":38, "PWM3":35, "PWM4":36, "DIR_EN":33, "DIR_UP":31, "PWM1":32, "DIR_LATCH":29} self._pwm_map = [] GPIO.cleanup() GPIO.setmode(GPIO.BOARD) # set GPIO OUT mode for i in iter(self._gpio_map): GPIO.setup(self._gpio_map[i], GPIO.OUT) # set PWM #GPIO.output(self._gpio_map["PWM1"], GPIO.HIGH) #GPIO.output(self._gpio_map["PWM2"], GPIO.HIGH) #GPIO.output(self._gpio_map["PWM3"], GPIO.HIGH) #GPIO.output(self._gpio_map["PWM4"], GPIO.HIGH) # set PWM p1 = GPIO.PWM(self._gpio_map["PWM1"], 255) p2 = GPIO.PWM(self._gpio_map["PWM2"], 255) p3 = GPIO.PWM(self._gpio_map["PWM3"], 255) p4 = GPIO.PWM(self._gpio_map["PWM4"], 255) self._pwm_map = [p1, p2, p3, p4] for i in self._pwm_map: i.start(100)
def setup(): gpio.setmode(gpio.BOARD) gpio.setup([ds, clock, latch], gpio.OUT) gpio.output([ds, clock, latch], gpio.LOW) gpio.setup([inc, count], gpio.IN, pull_up_down=gpio.PUD_UP)
def sonar(): while finished != True: global globalstop GPIO_TRIGGER = 8 GPIO_ECHO = 8 GPIO.setup(8, GPIO.OUT) # Send 10us pulse to trigger GPIO.output(GPIO_TRIGGER, True) time.sleep(0.00001) GPIO.output(GPIO_TRIGGER, False) start = time.time() count = time.time() GPIO.setup(8, GPIO.IN) while GPIO.input(GPIO_ECHO) == 0 and time.time() - count < 0.1: start = time.time() stop = time.time() while GPIO.input(GPIO_ECHO) == 1: stop = time.time() # Calculate pulse length elapsed = stop - start # Distance pulse travelled in that time is time # multiplied by the speed of sound (cm/s) distance = elapsed * 34000 # That was the distance there and back so halve the value distance = distance / 2 if distance < 20: globalstop = 1 print("Too close") else: globalstop = 0 print("Far") time.sleep(1)
def __init__(self, input_pin, reverse_logic, ding, dong, ha_informer): """ Create a doorbell that listens on input_pin and plays a 'ding' sound when it's pressed and a 'dong' sound when it's released. """ threading.Thread.__init__(self) self.daemon = True self.running = True self.inpin = input_pin self.reverse_logic = reverse_logic self.ding = ding self.dong = dong self.ding.start() self.dong.start() self.ha_informer = ha_informer self.ha_informer.start() if self.reverse_logic: self.ding_edge = GPIO.FALLING self.dong_edge = GPIO.RISING else: self.ding_edge = GPIO.RISING self.dong_edge = GPIO.FALLING GPIO.setmode(GPIO.BCM) GPIO.setup(self.inpin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) self.logging = logging.getLogger(self.__class__.__name__)
def recv_ack(self): gp.output(self.sda_pin, 1) gp.setup(self.sda_pin, gp.IN) res = self.get_sda_lv() self.clk_one() gp.setup(self.sda_pin, gp.OUT) return res
def __init__(self): pygame.mixer.init(44100) self.pin = 10 GPIO.setwarnings(False) GPIO.setmode(GPIO.BOARD) GPIO.setup(self.pin, GPIO.IN) self.sounds = { 0: [pygame.mixer.Sound('/home/pi/space_balls/sounds/start.ogg')], 1: [pygame.mixer.Sound('/home/pi/space_balls/sounds/shoot.ogg')], 2: [pygame.mixer.Sound('/home/pi/space_balls/sounds/hit.ogg')], 3: [pygame.mixer.Sound('/home/pi/space_balls/sounds/lose_evil.ogg'), pygame.mixer.Sound('/home/pi/space_balls/sounds/lose_cmon.ogg'), pygame.mixer.Sound('/home/pi/space_balls/sounds/lose_blimp.ogg'), pygame.mixer.Sound('/home/pi/space_balls/sounds/lose_friends.ogg'), pygame.mixer.Sound('/home/pi/space_balls/sounds/lose_goof.ogg'), pygame.mixer.Sound('/home/pi/space_balls/sounds/lose_gunner.ogg')] } self.SEND_SOUND = 0; self.dev = usb.core.find(idVendor = 0x6666, idProduct = 0x0003) if self.dev is None: raise ValueError('No USB device found matching idVendor and idProduct') self.dev.set_configuration() GPIO.add_event_detect(self.pin, GPIO.RISING, callback=self.receive_sound) if GPIO.input(self.pin): self.receive_sound(self.pin)
def __init__(self): self.log('AquaPi initializing...') GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) GPIO.setup(PIN_POWER, GPIO.OUT) self.led = BlinkM() self.led.reset() self.led.set_fade_speed(self.led_fade_speed) # self.led.write_script_line(Scripts.TRANSFER, 0, 10, 'c', 0xff, 0xff, 0xff) # self.led.write_script_line(Scripts.TRANSFER, 1, 10, 'c', 0x00, 0x00, 0x00) self.spi = spidev.SpiDev() self.spi.open(0, SPI_ADC) self.sio = serial.Serial('/dev/ttyAMA0', 9600, serial.EIGHTBITS, serial.PARITY_NONE, serial.STOPBITS_ONE, 1) self.sensor_temp = TempSensor(self.spi, ADC_TEMP) self.sensor_light = AnalogSensor(self.spi, ADC_LIGHT) self.sensor_liquid = SerialSensor(self.sio) self.metro_sensor_sample = Metro(500) self.metro_sensor_send = Metro(30000) self.metro_poll = Metro(6000) self.metro_health = Metro(180000) self.events = deque() self.running = False self.current_color = False self.happy()
def main(): try: # 继电器停止 GPIO.setup(GPIO_RELAY, GPIO.IN) # 启动 呼吸灯 thread_led() # 读取传感器 load_sensor() # 读取天气预报 get_caiyun() # OLED 屏幕显示,附带整点报时 thread_oled() # 启动读取思科路由状态 thread_cisco() # 启动读取传感器参数线程 thread_sensor() # 启动读取彩云天气 thread_caiyun() while True: time.sleep(1) except KeyboardInterrupt: thread_run = False print('User press Ctrl+c ,exit;') finally: cleanup() pass
def main(): LED_OFF = 0 LED_ON = 1 - LED_OFF button_pins = [17, 13, 20, 23] led_pins = [27, 19, 21, 24] for pin in button_pins: GPIO.setup( pin, GPIO.IN, pull_up_down = GPIO.PUD_DOWN ) for pin in led_pins: GPIO.setup( pin, GPIO.OUT, initial = LED_OFF ) led = 0 while True: text = '' for pin in [0,1,2,3]: text += '{0}'.format(pin) if GPIO.input(button_pins[pin]) else ' ' print(text) GPIO.output(led_pins[led], LED_OFF) led += 1 if led == 4: led = 0 GPIO.output(led_pins[led], LED_ON) time.sleep(0.5)
def setup_pin(self, pin): """ Setup pin for this relay :rtype: None """ # TODO add some extra checks here. Maybe verify BCM? GPIO.setup(pin, GPIO.OUT)
def __init__(self, VCC_Pin, Signal_Pin): self.VCC_Pin = VCC_Pin self. Signal_Pin = Signal_Pin GPIO.setmode(GPIO.BCM) GPIO.setup(VCC_Pin, GPIO.OUT, initial=True) GPIO.output(VCC_Pin, GPIO.HIGH) GPIO.setup(Signal_Pin, GPIO.IN, initial=False)
#!/usr/bin/env python import time import RPi.GPIO as GPIO #Main GPIO.setmode(GPIO.BOARD) GPIO.setup(16,GPIO.OUT) GPIO.output(16,GPIO.HIGH) while True: aux=raw_input('\nPress s to take a shot, q to quit: ') if aux is 's': GPIO.output(16,GPIO.LOW) time.sleep(0.5) GPIO.output(16,GPIO.HIGH) elif aux is 'q': GPIO.cleanup() break
def setup(): GPIO.setmode(GPIO.BOARD) GPIO.setup(LedPin, GPIO.OUT) GPIO.output(LedPin, GPIO.HIGH)
import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) GPIO.setup(37,GPIO.OUT) print "LED on" GPIO.output(37,GPIO.HIGH) time.sleep(1) print "LED off" GPIO.output(37,GPIO.LOW)
def run_printer(q, completion): completion.value = -1 # -1 indicates no active job, otherwise a percentage GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) GPIO.setup(RIGHT_PULSE, GPIO.OUT) GPIO.setup(RIGHT_DIRECTION, GPIO.OUT) GPIO.setup(LEFT_PULSE, GPIO.OUT) GPIO.setup(LEFT_DIRECTION, GPIO.OUT) GPIO.output(RIGHT_PULSE, GPIO.HIGH) GPIO.output(RIGHT_DIRECTION, GPIO.HIGH) GPIO.output(LEFT_PULSE, GPIO.HIGH) GPIO.output(LEFT_DIRECTION, GPIO.LOW) GPIO.setup(LEFT_LIMIT, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.setup(RIGHT_LIMIT, GPIO.IN, pull_up_down=GPIO.PUD_UP) pen_up() drawing = False left = right = origin_x = origin_y = -1 while True: job = q.get() if job == 'STOP': break lines_max = lines_left = len(job) for l in [line.strip() for line in job]: lines_left -= 1 completion.value = 1 - lines_left / lines_max if not l or l.startswith(';'): # Blank line or comment continue elif l == 'G28': # Centering routine (required before we can move in the coordinate system) left, right, origin_x, origin_y = center() drawing = False elif l.startswith('G0 '): # Fast move (pen up) if drawing: pen_up() drawing = False m = re.search( r'G0 X(?P<x>-?\d+(\.\d*)?) Y(?P<y>-?\d+(\.\d*)?)', l) # Normal X, Y coordinate move if m: if origin_x < 0: continue # Refuse to move in the coordinate system if we have not centered left, right = move_to(origin_x + float(m.group('x')), origin_y + -1 * float(m.group('y')), left, right) continue m = re.search(r'G0 L(?P<left>-?\d+) R(?P<right>-?\d+)', l) # Manual L, R step move if m: left_shift, right_shift = int(m.group('left')), int( m.group('right')) if left_shift > 0: GPIO.output(LEFT_DIRECTION, GPIO.LOW) else: GPIO.output(LEFT_DIRECTION, GPIO.HIGH) pulse(LEFT_PULSE, abs(left_shift)) if right_shift > 0: GPIO.output(RIGHT_DIRECTION, GPIO.HIGH) else: GPIO.output(RIGHT_DIRECTION, GPIO.LOW) pulse(RIGHT_PULSE, abs(right_shift)) left = right = origin_x = origin_y = -1 # Manual movements invalidate any calibrated coordinates elif l.startswith('G1 '): # Draw (pen down) if origin_x < 0: continue # Refuse to move in the coordinate system if we have not centered if not drawing: pen_down() drawing = True m = re.search( r'G1 X(?P<x>-?\d+(\.\d*)?) Y(?P<y>-?\d+(\.\d*)?).*', l) if m: left, right = move_to(origin_x + float(m.group('x')), origin_y + -1 * float(m.group('y')), left, right) completion.value = -1 GPIO.cleanup()
import time # import datetime # import csv # import threading # import os import RPi.GPIO as GPIO import board import busio import adafruit_ads1x15.ads1015 as ADS from adafruit_ads1x15.analog_in import AnalogIn #import numpy as np P_LED_pins = [21] GPIO.setmode(GPIO.BCM) GPIO.setup(P_LED_pins, GPIO.OUT) GPIO.output(P_LED_pins, 1) # Create the I2C bus i2c = busio.I2C(board.SCL, board.SDA) # Create the ADC object using the I2C bus ads = ADS.ADS1015(i2c) # Create single-ended input on channel 0 # photoreceptor_channel = 0 pd = AnalogIn(ads, ADS.P0) print("{:>5}\t{:>5}".format('raw', 'v'))
def main(): GPIO.setmode(GPIO.BOARD) #setting the pin numbering method of raspberry pi ####################setting pins as output or input for the sensor and motors ###################motors, servo, and trigger pins os ultrasonic sensor will be set as output ##################echo pin will be set as input GPIO.setup(TRIG1, GPIO.OUT) GPIO.setup(ECHO1, GPIO.IN) GPIO.setup(TRIG2, GPIO.OUT) GPIO.setup(ECHO2, GPIO.IN) GPIO.setup(TRIG3, GPIO.OUT) GPIO.setup(ECHO3, GPIO.IN) GPIO.setup(servo1, GPIO.OUT) GPIO.setup(servo2, GPIO.OUT) GPIO.setup(left1, GPIO.OUT) GPIO.setup(left2, GPIO.OUT) GPIO.setup(right1, GPIO.OUT) GPIO.setup(right2, GPIO.OUT) ################################### #######initially setting the pins in OFF condition GPIO.output(TRIG1, False) GPIO.output(TRIG2, False) GPIO.output(TRIG3, False) ######################### ####for initialization of the servo motor .....a servo motor will work with a PWM signal of 50HZ frequency pwm1 = GPIO.PWM(servo1, 50) pwm2 = GPIO.PWM(servo2, 50) ###################################### #########setting a threshold distance value for the sensors that is if the distance between obstacle and ultrasonic sensor is less than threshod value than all the process of image processing will be executed max_front_dist = 25 max_left_dist = 20 max_right_dist = 20 ##################3 #######starting servo motor with a PWM value of 5 the full rotation of servo motor will be between 0-12 where 0 correspinds to 0 degree and 12 correspinds to 180 degree rotation pwm1.start(5) pwm2.start(5) time.sleep(2) ####giving a little delay for everything to setup ######this will keep on running on and on in loop try: while True: #####string distance calculated by sensors in variables front_dist = check_front_dist() left_dist = check_left_dist() right_dist = check_right_dist() ################3 #####logic for the autonomous movement ####if front sendor encounters some obstacle if front_dist < max_front_dist: stop() pwm1.ChangeDutyCycle( 7 ) #change the angle of servo with camera to face towards the obstacle time.sleep(1) isHuman = cam( ) #isHuamn will store the value True of False i.e. whether the obstacle is person or not if isHuman == True: #if obstacle is person then rotate to shield towards human in order to protect him/her fro the UV light print("human detected") pwm2.ChangeDutyCycle(7) time.sleep(1) else: print("human not detected") ####for autonomous movement....that is after encountering an obstacel turn the not to a side where the obstacle is farther means if the distance from left sensor 20cm and form right sendor it si 30 cm then the bot will move to the right and vice versa if right_dist > left_dist: if right_dist < max_right_dist and left_dist < max_left_dist: #if both senors encounter obstacle that is less then threshold value of distance then bot first move backwards and the figure out left or right stop() time.sleep(tf) backward() time.sleep(1) else: right() time.sleep(0.5) elif left_dist > right_dist: if right_dist < max_right_dist and left_dist < max_left_dist: stop() time.sleep(tf) backward() time.sleep(1) else: left() time.sleep(0.5) ###############if obstacle is on right then take snapshot process it and check whether human or not and move the shield the accordingly and then rotate to the left elif right_dist < max_right_dist: stop() pwm1.ChangeDutyCycle(11) time.sleep(1) isHuman = cam() if isHuman == True: print("human detected") pwm2.ChangeDutyCycle(11) time.sleep(1) else: print("human not detected") left() time.sleep(0.5) ############same as uppper one but rotate to rigth elif left_dist < max_left_dist: stop() pwm1.ChangeDutyCycle(3) time.sleep(1) isHuman = cam() if isHuman == True: print("human detected") pwm2.ChangeDutyCycle(3) time.sleep(1) else: print("human not detected") right() time.sleep(0.5) #####if there is not obstacle then keep on moving forward else: forward() #######if CTRl+C is pressed the program will terminate and all the pins of raspberry pi will be cleared whichever logic they hold right now except KeyboardInterrupt: GPIO.cleanup()
def setup_GPIO(self, pinRain, pinVent1, pinVent2): GPIO.setmode(GPIO.BCM) GPIO.setup(pinVent1, GPIO.OUT, initial=1) GPIO.setup(pinVent2, GPIO.OUT, initial=1) GPIO.setup(pinRain, GPIO.IN)
#!/usr/bin/python # -*- coding: utf-8 -*- # http://elecrow.com/ import RPi.GPIO as GPIO import time # define motion pin motion_pin = 16 # set GPIO as GPIO.BOARD GPIO.setmode(GPIO.BOARD) # set pin mode as INPUT GPIO.setup(motion_pin, GPIO.IN) try: while True: if(GPIO.input(motion_pin) == 0): print("Nothing moves ...") elif(GPIO.input(motion_pin) == 1): print("Motion detected!") time.sleep(0.1) except KeyboardInterrupt: GPIO.cleanup()
break else: time.sleep(0.5) def button_callback(channel): #buffer = "S%s" % (quote_array[idx]) buffer = "Spush me" print(buffer + "\n") serial.write(buffer.encode()) wait_for_ready() #idx += 1 serial = serial.Serial("/dev/ttyAMA0", baudrate=9600) serial.write(str.encode("\n")) time.sleep(1) serial.write(str.encode("V15\n")) # Adjust volume wait_for_ready() print("Ready...\n") f = open("quotefile.txt", "r") for x in f: quote_array.append(x) GPIO.setwarnings(False) # Ignore warning for now GPIO.setmode(GPIO.BOARD) # Use physical pin numbering GPIO.setup(15, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) # Set pin 15 to be an input pin and set initial value to be pulled low (off) GPIO.add_event_detect(15,GPIO.RISING,callback=button_callback, bouncetime = 2000) # Setup event on pin 15 rising edge message = input("Press enter to quit\n\n") # Run until someone presses enter GPIO.cleanup() # Clean up
import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) PIR_PIN = 20 GPIO.setup(PIR_PIN, GPIO.IN) def getMotion(): while True: if GPIO.input(PIR_PIN): return True else: return False
# 10_RGB_LED.py from tkinter import * import RPi.GPIO as GPIO import time # Configure the Pi to use the BCM (Broadcom) pin names, rather than the pin positions GPIO.setmode(GPIO.BCM) GPIO.setup(18, GPIO.OUT) GPIO.setup(23, GPIO.OUT) GPIO.setup(24, GPIO.OUT) # Start Pulse Width Modulation (PWM) on the red, green and blue channels pwmRed = GPIO.PWM(18, 500) pwmRed.start(100) pwmGreen = GPIO.PWM(23, 500) pwmGreen.start(100) pwmBlue = GPIO.PWM(24, 500) pwmBlue.start(100) # group together all of the GUI code into a class called App class App: # this function gets called when the app is created def __init__(self, master): # A frame holds the various GUI controls frame = Frame(master) frame.pack()
#Libraries import RPi.GPIO as GPIO import time #GPIO Mode (BOARD / BCM) GPIO.setmode(GPIO.BOARD) #set GPIO Pins GPIO_TRIGGER = 13 GPIO_ECHO = 11 #set GPIO direction (IN / OUT) GPIO.setup(GPIO_TRIGGER, GPIO.OUT) GPIO.setup(GPIO_ECHO, GPIO.IN) def distance(): # set Trigger to HIGH GPIO.output(GPIO_TRIGGER, True) # set Trigger after 0.01ms to LOW time.sleep(0.00001) GPIO.output(GPIO_TRIGGER, False) StartTime = time.time() StopTime = time.time() # save StartTime while GPIO.input(GPIO_ECHO) == 0: StartTime = time.time() # save time of arrival
import RPi.GPIO as GPIO #Import GPIO library import time #Import time library GPIO.setmode(GPIO.BCM) #Set GPIO pin numbering GPIO_TRIGGER = 23 GPIO_ECHO = 24 #Associate pin 14 to Echo print ("Posture Test in progress") GPIO.setup(GPIO_TRIGGER,GPIO.OUT) #Set pin as GPIO out GPIO.setup(GPIO_ECHO,GPIO.IN) #Set pin as GPIO in while True: GPIO.output(GPIO_TRIGGER, False) #Set TRIG as LOW print ("Checking Stance") #Checking the User stance time.sleep(10) #Checking the user stance for 30 Seconds GPIO.output(GPIO_TRIGGER, True) #Set TRIG as HIGH time.sleep(0.00001) #Delay of 0.00001 seconds GPIO.output(GPIO_TRIGGER, False) #Set TRIG as LOW while GPIO.input(GPIO_ECHO)==0: #Check if Echo is LOW pulse_start = time.time() #Time of the last LOW pulse while GPIO.input(GPIO_ECHO)==1: #Check whether Echo is HIGH pulse_end = time.time() #Time of the last HIGH pulse pulse_duration = pulse_end - pulse_start #pulse duration to a variable distance = pulse_duration * 17150 #Calculate distance
import time import RPi.GPIO as GPIO USING_PIN = 12 GPIO.setmode(GPIO.BOARD) GPIO.setup(USING_PIN, GPIO.OUT) p = GPIO.PWM(USING_PIN, 50) p.start(0) try: while 1: for dc in range(0, 101, 5): p.ChangeDutyCycle(dc) time.sleep(0.1) for dc in range(100, -1, -5): p.ChangeDutyCycle(dc) time.sleep(0.1) except KeyboardInterrupt: pass p.stop() GPIO.cleanup()
import math import atexit pin = 16 # pin 12 is 6th from the left on the outside steering_angle = 0 pwm = GPIO.PWM(pin, 10) pwm.start(get_duty_cycle()) def get_duty_cycle(): return 1.5 + (get_steering_angld()/2) def get_steering_angle(): return steering_angle def set_steering_angld(new_steering_angle): steering_angle = new_steering_angle pwm.ChangeDutyCycle(get_duty_cycle) @atexit.register def goodbye(): pwm.stop() GPIO.cleanup() GPIO.setmode(GPIO.BOARD) GPIO.setup(pin, GPIO.OUT)
# Based on https://maker.pro/raspberry-pi/tutorial/how-to-interface-a-pir-motion-sensor-with-raspberry-pi-gpio # just seeing that the PIR works. import RPi.GPIO as GPIO import time GPIO.setwarnings(False) GPIO.setmode(GPIO.BOARD) GPIO.setup(11, GPIO.IN) #Read output from PIR motion sensor while True: i = GPIO.input(11) if i == 0: #When output from motion sensor is LOW print "No intruders", i time.sleep(0.1) elif i == 1: #When output from motion sensor is HIGH print "Intruder detected", i time.sleep(0.1)
tail = -10 # Index of last 'off' pixel color = 0xFF0000 # 'On' color (starts red) def makeColor(r, g, b): return (r << 16) + (g << 8) + b def colorWheel(wheelPos): """ 0 is red, 85 is green, 170 is blue """ if wheelPos < 85: return makeColor(255 - wheelPos * 3, wheelPos * 3, 0) elif wheelPos < 170: wheelPos -= 85 return makeColor(0, 255 - wheelPos * 3, wheelPos * 3) else: wheelPos -= 170 return makeColor(wheelPos * 3, 0, 255 - wheelPos * 3) GPIO.setmode(GPIO.BCM) # Turn off warnings... GPIO.setwarnings(False) GPIO.setup(LED, GPIO.OUT) # Setup the Inputs GPIO.setup(IRLED, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BOARD) LED_PIN=12 GPIO.setup(LED_PIN,GPIO.OUT) def mos(list): if list == 1: GPIO.output(LED_PIN,GPIO.HIGH) time.sleep(1) GPIO.output(LED_PIN,GPIO.LOW) time.sleep(0.5) elif list == 0: GPIO.output(LED_PIN,GPIO.HIGH) time.sleep(0.5) GPIO.output(LED_PIN,GPIO.LOW) time.sleep(0.5) _A=[0, 1] _B=[1,0, 0, 0] _C=[1, 0, 1, 0] _D=[1, 0, 0] _E=[0] _F=[0, 0, 1, 0] _G=[1, 1, 0] _H=[0, 0, 0, 0] _I=[0, 0] _J=[0, 1, 1, 1] _K=[1, 0, 1] _L=[0, 1, 0, 0] _M=[1, 1] _N=[1, 0] _O=[1, 1, 1]
from time import sleep import os ############ # CONSTANTS# ############ # Input pin is 15 (GPIO22) INPUT_PIN = 15 # To turn on debug print outs, set to 1 DEBUG = 1 ################### # INITIALIZE PINS # ################### GPIO.setmode(GPIO.BOARD) GPIO.setup(INPUT_PIN, GPIO.IN,pull_up_down=GPIO.PUD_DOWN) #GPIO.setup(INPUT_PIN, GPIO.IN) # Main loop, listen for infinite packets while True: print("\nWaiting for GPIO low") # If there was a transmission, wait until it finishes #GPIO.wait_for_edge(INPUT_PIN, GPIO.RISING) value = 1 while value: sleep(0.001) #print("Last read value: {}".format(value)) value = GPIO.input(INPUT_PIN) # timestamps for pulses and packet reception
maxSpeed = 1000 aceleracion = False try: GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) if(mineral): Giro = 21 Velocidad = 20 motor = "Mineral" else: Giro = 26 Velocidad = 25 motor = "Levadura" GPIO.setup(Velocidad,GPIO.OUT) GPIO.setup(Giro,GPIO.OUT) stepper = GPIO.PWM(Velocidad,300) stepper.start(0) print(motor," arrancado") c = 0 while True: stepper.ChangeDutyCycle(50) if aceleracion: for i in range(10,maxSpeed,10): stepperSpeed(stepper,i) time.sleep(0.1) for i in reversed(range(10,maxSpeed,10)): stepperSpeed(stepper,i)
def set_pin_data(channel): #GPIO.setup(channel, GPIO.IN) GPIO.setup(channel, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) # set initial value to be pulled low (off) GPIO.add_event_detect(channel, GPIO.RISING, callback=button_callback) print("channel %s active" % channel)
from count import count_above from multiprocessing import Process import time #import ray import threading import json #ray.init() i = 0 ls = np.zeros((100, 800, 1280), dtype=np.uint8) results = np.zeros((800, 1280), dtype=np.uint8) adc_threshold1 = np.uint8(10) pix_threshold = np.uint8(199) camera = arducam.mipi_camera() GPIO.setmode(GPIO.BOARD) GPIO.setup(7, GPIO.IN) GPIO.setup(8, GPIO.IN) GPIO.setup(9, GPIO.OUT, initial - GPIO.LOW) GPIO.setup(10, GPIO.OUT, initial=GPIO.LOW) start_proc = threading.Event() next_frame = threading.Event() start_cap = threading.Event() counter = 0 loop = 0 def wait_sig(): while (True): if (GPIO.input(7)):
import RPi.GPIO as IO # calling for header file which helps us use GPIO’s of PI import time # calling for time to provide delays in program IO.setwarnings(False) # do not show any warnings x=1 IO.setmode (IO.BCM) # programming the GPIO by BCM pin numbers. (like PIN29 as‘GPIO5’) IO.setup(4,IO.OUT) # initialize GPIO Pins as an output. IO.setup(5,IO.OUT) IO.setup(6,IO.OUT) while 1: # execute loop forever for y in range(8): # loop for counting up 8 times IO.output(4,1) # pull up the data pin for every bit. time.sleep(0.1) # wait for 100ms IO.output(5,1) # pull CLOCK pin high time.sleep(0.1) IO.output(5,0) # pull CLOCK pin down, to send a rising edge IO.output(4,0) # clear the DATA pin IO.output(6,1) # pull the SHIFT pin high to put the 8 bit data out parallel time.sleep(0.1) IO.output(6,0) # pull down the SHIFT pin for y in range(8): # loop for counting up 8 times IO.output(4,0) # clear the DATA pin, to send 0 time.sleep(0.1) # wait for 100ms IO.output(5,1) # pull CLOCK pin high time.sleep(0.1) IO.output(5,0) # pull CLOCK pin down, to send a rising edge IO.output(4,0) # keep the DATA bit low to keep the countdown IO.output(6,1) # pull the SHIFT pin high to put the 8 bit data out parallel time.sleep(0.1) IO.output(6,0)
# -*- coding: UTF-8 -*- import RPi.GPIO as GPIO import time ### 設定 PIN_L_1 = 22 PIN_L_2 = 27 PIN_L_3 = 17 GPIO.setmode(GPIO.BCM) GPIO.setup(PIN_L_1, GPIO.IN) GPIO.setup(PIN_L_2, GPIO.IN) GPIO.setup(PIN_L_3, GPIO.IN) status_l_1 = 0; status_l_2 = 0; status_l_3 = 0; ### ヘッダ print("Content-Type: text/event-stream") print("Connection: close") print("") try: while True: print("event: heartbeat") print("data: alive") print("") value_l_1 = GPIO.input(PIN_L_1) if value_l_1 != status_l_1:
import time import RPi.GPIO as GPIO import config_pins GPIO.setmode(GPIO.BOARD) GPIO.setwarnings(False) GPIO.setup(config_pins.pin_empfangen, GPIO.IN) dit = 0.3 initial_lichttimer_start = False initial_dunkeltimer_start = False initial_letzte_zeichen_timer = False def main(): empfange_paket() def empfange_paket(): empfangsstring = '' #Wechsel von Hell auf Dunkel oder Dunkel auf Hell change = False ersteZeichenSchonEmpfangen = False letzteZeichenDesPakets = True anzeige_empfangsstring_zum_schluss = True letzte_zeichen_timer_start()
import http.server import socketserver import shutil import os import time import sys import json if sys.argv[1] != "dev": import RPi.GPIO as GPIO GPIO.setmode(GPIO.BOARD) GPIO.setup(12, GPIO.OUT, initial=GPIO.LOW) port = 8080 class QuackHandler(http.server.BaseHTTPRequestHandler): server_version = "Quack/2.0" def do_GET(self): f = self.send_head() if f: try: self.copyfile(f, self.wfile) finally: f.close() def do_HEAD(self): f = self.send_head() if f: f.close()
def setup(): GPIO.setmode(GPIO.BCM) GPIO.setup(LED_PIN, GPIO.OUT)
def initialize(): # Main program block GPIO.setmode(GPIO.BCM) # Use BCM GPIO numbers GPIO.setup(LCD_E, GPIO.OUT) # E GPIO.setup(LCD_RS, GPIO.OUT) # RS GPIO.setup(LCD_D4, GPIO.OUT) # DB4 GPIO.setup(LCD_D5, GPIO.OUT) # DB5 GPIO.setup(LCD_D6, GPIO.OUT) # DB6 GPIO.setup(LCD_D7, GPIO.OUT) # DB7 GPIO.setup(LED_ON, GPIO.OUT) # Backlight enable # Initialise display lcd_init() time.sleep(0.2)
import RPi.GPIO as GPIO from time import sleep GPIO.setmode(GPIO.BOARD) Motor1A = 16 Motor1B = 18 Motor1E = 22 GPIO.setup(Motor1A, GPIO.OUT) GPIO.setup(Motor1B, GPIO.OUT) GPIO.setup(Motor1E, GPIO.OUT) print("Turning motor on") GPIO.output(Motor1A, GPIO.HIGH) GPIO.output(Motor1B, GPIO.LOW) GPIO.output(Motor1E, GPIO.HIGH) sleep(10) print("Stopping motor") GPIO.output(Motor1E, GPIO.LOW) GPIO.cleanup()
#!/usr/bin/python import RPi.GPIO as GPIO import time from time import gmtime, strftime # GPIO stuff GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) doorSensor = 4 doorStatus = "Door " GPIO.setup(doorSensor, GPIO.IN, pull_up_down=GPIO.PUD_UP) try: #while True: doorStatus += "open" if GPIO.input(doorSensor) == 1 else "closed" #time.sleep(0.1) print doorStatus except (KeyboardInterrupt): print "\n CTRL+C" except Exception as e: GPIO.cleanup() finally: GPIO.cleanup()