def buildCube(self): #Creats a 4x4x4 array to store all the #LED objects and represent the cube #all the led pins are initially set to #1,1 which will be changed later LedArray = [[[LED(1, 1) for i in range(4)] for j in range(4)] for k in range(4)] #A tripple nested for loop where z represents #what row (Height) we are on, and x and y are #the coordinate positions of the LED we are #currently creating. # #*Note: the commented number in each if #represents the GPIO of the row we are on. for x in range(4): for y in range(4): for z in range(4): if (x == 0): LedArray[x][y][z] = LED(24, self.colArray[y][z]) #24 elif (x == 1): LedArray[x][y][z] = LED(23, self.colArray[y][z]) #23 elif (x == 2): LedArray[x][y][z] = LED(18, self.colArray[y][z]) #18 elif (x == 3): LedArray[x][y][z] = LED(21, self.colArray[y][z]) #21 #return the created array of LED Objects return LedArray
def password_entered(self, correct, count_attempt=True): """ Resets digit timeout and stores the time of entry. Also handles the attempts count and LEDs. """ self.digit_timeout.reset() self.ignore_digits = True self.current_input = [] if pi_leds_available: pi_leds.set_leds(0) self.access_log_append("code", correct) if correct: if PRINT_MSGS: print("Unlocked!") self.correct_clear_timeout.restart() self.incorrect_attempts = 0 self.iface.flash_green_led() self.logger.log("password correct, attempts reset and LED pulsed") else: if count_attempt and USE_MAX_ATTEMPTS: self.incorrect_attempts += 1 if PRINT_MSGS: print("Incorrect, you have {} more tries left".format( MAX_ATTEMPTS - self.incorrect_attempts)) elif count_attempt and not USE_MAX_ATTEMPTS and PRINT_MSGS: print("Incorrect!") self.incorrect_clear_timeout.restart() self.iface.flash_red_led() if self.incorrect_attempts == MAX_ATTEMPTS: self.lockout() self.logger.log( "password incorrect, attempts: {}, LED pulsed".format( self.incorrect_attempts))
def turnOnOffLED(GPIOpin, LDR_DO): if LDR_DO == 1: print("Dark") LED.TurnOnLED(GPIOpin) else: print("light") LED.TurnOffLED(GPIOpin)
class IOManager(object): def __init__(self): led = 11 button = 13 GPIO.setmode(GPIO.BOARD) GPIO.setup(led, GPIO.OUT) self.__scanner = Scanner() self.__button = Button(button) self.__led = LED(led) self.__printer = Printer() #set up connections and variables for button, light, printer, and scanner def getButton(self): return self.__button.getButtonBool() def getScan(self): return self.__scanner.getInput() def setLight(self, value): self.__led.setValue(value) def blinkLight(self): self.__led.blink() def printReceipt(self, items): if items: self.__printer.printHeader() for item in items: self.__printer.printItem(item) self.__printer.printTotals(items) self.__printer.complete()
def do_blink(): onValue = request.forms.get('on') offValue = request.forms.get('off') if onValue and not offValue: LED.led_on(18) elif not onValue and offValue: LED.led_off(18) return html
def action(selection): if (selection == 1): system("echo Shutdown selected!") LED.ON(10, 0, 0) system("shutdown now") elif (selection == 2): system("echo Restart selected!") LED.ON(10, 8, 0) system("reboot now")
async def display_message(ctx): # Check if there's any stored messages if len(messageBacklog) > 0: # Remove message from backlog msg = messageBacklog.pop(0) # Send message await ctx.send("Sending the following message: " + msg) LED.deconstruct_message(msg) else: await ctx.send("There are currently no messages to send!")
def motion(GPIOnum): global counter if GPIO.input(GPIOnum): counter += 1 LED.TurnOnLED(2) print("Motion detected{0}".format(counter)) else: LED.TurnOffLED(2) print("Motion not detected")
def __init__(self, iface, logger, stdout, DEMO_MODE=False): self.DEMO_MODE = DEMO_MODE self.iface = iface # store interface wrapper self.logger = logger # store logger self.stdout = stdout # store standard output if not self.DEMO_MODE: self.stdout.start_overwrite_output() # bind to digit recevied event self.iface.digit_received.bind(self.digit_received_handler) self._digit_timeout_time = None self.digit_timeout = Timeout(0.1) # the digit timeout self.digit_timeout.elapsed.bind(self.digit_timeout_elapsed) self.password = [] # password store if os.path.isfile(PWORD_FILE): # file exists, read and use with open(PWORD_FILE) as f: self.password = f.read().strip() # reads and cleans up self.logger.log("password read as {}", self.password) else: self.password = DEFAULT_PWORD # use default password self.logger.log("password defaulted to {}", self.password) with open(PWORD_FILE, "w") as f: f.write(self.password) # write new password.txt self.logger.log("wrote new password file to {}", PWORD_FILE) self.access_log = open(ACCESS_LOG_FILE, "a+") self.access_log_append("startup", None) self.current_input = [] # current digit input self.locked_out = False # whether the user is locked out # the locked out timeout (supposed to go from 59-0, but should output # each second) self.locked_timeout = Timeout(1) self.locked_timeout.elapsed.bind(self.locked_timeout_elapsed) self.incorrect_attempts = 0 # the number of incorrect attempts self.locked_time_left = 0 # the amount of time left for the user to be locked out self.ignore_digits = False self.correct_clear_timeout = Timeout(3) self.correct_clear_timeout.elapsed.bind(self.clear_timeout_elapsed) self.incorrect_clear_timeout = Timeout(1) self.incorrect_clear_timeout.elapsed.bind(self.clear_timeout_elapsed) self.cover_digit_timeout = Timeout(1) self.cover_digit_timeout.elapsed.bind(self.cover_digit_timeout_elapsed) if pi_leds_available: pi_leds.setup_leds() else: self.logger.logw( "unable to import LED lib, RPi LEDs will not be functional") self.logger.loge(_pi_leds_import_error) self.logger.log("code lock init complete")
def motion(gpio_num): global count if gpio.input(gpio_num): if gpio.input(23): # if dark count += 1 LED.turnON(2) print('Motion detected {}.'.format(count)) print('LDR is {}'.format(gpio.input(23))) else: LED.turnOFF(2) print('Motion not detected')
def boot(duration): print("*[CUBE - BOOT]*") IO.setmode(IO.BCM) IO.setwarnings(0) ULTRASOUND.setup() PUMP.setup() LED.setup() LED.bootBlinking(duration) start()
def boot(): print("*[CUBE - BOOT]*") IO.setmode(IO.BCM) IO.setwarnings(0) ULTRASOUND.setup() PUMP.setup() LED.setup() duration = DATA.load_waitForInternetConnection() + BOOTING_EXTRATIME LED.bootBlinking(duration) start()
def digit_timeout_elapsed(self): """ Handles the elapsed event of the digit timeout. """ now = time.time() passed = now - self._digit_timeout_time self.logger.logd( "digit timeout: {} seconds have passed since last input", passed) if pi_leds_available: pi_leds.set_leds(max(0, min(passed / DIGIT_TIMEOUT_LENGTH, 1))) if passed >= DIGIT_TIMEOUT_LENGTH: self.password_entered(False, False) self.stdout.overwrite_text = "" else: self.digit_timeout.restart()
def setInstance(self, GPIO): if self.useSensor[0] : self.sensorTimerControl.append(DHT11.Control(self.all_pin[0], GPIO, self.topic,[0, 1])) self.sensorTimerControlIndex.append(0) self.sensorTimerControlIndex.append(1) if self.useSensor[1] : self.sensorDetectControl.append(Fire.Control(self.all_pin[1], GPIO, self.topic, 0)) self.sensorDetectControlIndex.append(0) if self.useSensor[2] : self.sensorDetectControl.append(Shock.Control(self.all_pin[4], GPIO, self.topic, 1)) self.sensorDetectControlIndex.append(1) if self.useSensor[3] : self.sensorDetectControl.append(IR.Control(self.all_pin[5], GPIO, self.topic, 2)) self.sensorDetectControlIndex.append(2) if self.useSensor[4] : self.sensorDetectControl.append(Gas.Control(self.adc_pin[0], self.topic, 3)) self.sensorDetectControlIndex.append(3) if self.useSensor[5] : self.sensorTimerControl.append(Cds.Control(self.all_pin[7], GPIO, self.topic, 2)) self.sensorTimerControlIndex.append(2) if self.useSensor[6] : self.button_instance = Button.Control(self.all_pin[6], GPIO, self.topic) if self.useSensor[7] : self.led_instance = LED.LED(self.all_pin[2], self.all_pin[3], GPIO) self.led_instance.write(1) if self.useSensor[8] : self.sensorMoveControl.append(SG90.SG90(self.all_pin[8], self.all_pin[9], GPIO)) if self.useSensor[9] : self.sensorTimerControl.append(PM2008M.Control(self.topic,[3, 4])) self.sensorTimerControlIndex.append(3) self.sensorTimerControlIndex.append(4)
def __init__(self): #On prépare un fichier temporaire tant que le script est lancé #pid = str(os.getpid()) #pidfile = "/tmp/controleur.pid" #try: # #On teste si le fichier existe déja # if os.path.isfile(pidfile): # os.link(pidfile,"daemon_python") # else: # file(pidfile, 'w').write(pid) # os.link(pidfile,"daemon_python") #except IOError as e: # message = "I/O error("+str(e.errno)+"): "+str(e.strerror) # print(message) #On effectue le vrai travail ici #On instancie les classes principales self.stop_event = threading.Event() self.surveillance_serveur = surveillance_serveur.Surveillance_serveur( self, self.stop_event) self.surveillance_serie = surveillance_serie.Surveillance_serie( self, self.stop_event) self.traitement = traitement.Traitement(self, self.stop_event) self.video = video.Video(self.stop_event) self.led = LED.LED(self.stop_event) #On met les threads en mode daemon, quand le controleur est tué, on tue tous les threads self.surveillance_serveur.daemon = True self.surveillance_serie.daemon = True self.traitement.daemon = True self.video.daemon = True self.led.daemon = True
def led(): while 1: config = loadConfig() debugPrint("Mode: " + config["mode"]) if config["mode"] == "static": LED.fadeToRGB(float(config["static"]["red"]), float(config["static"]["green"]), float(config["static"]["blue"]), .25, True) elif config["mode"] == "breathing": for color in config["breathing"]: LED.fadeToRGB(float(color["red"]), float(color["green"]), float(color["blue"]), float(color["fadeDuration"]), True) sleep(float(color["timeout"])) elif config["mode"] == "disabled": sleep(1)
def initLEDs(self): hbox_led = QtGui.QHBoxLayout() hbox_cb = QtGui.QHBoxLayout() colors = ['r', 'a', 'y', 'g', 'b', 'p', 'r', 'a'] for i in range(8): #self.relay_cb.append(Relay_QCheckBox(self, i+1, btn_name, 0, pow(2,i))) lbl = QtGui.QLabel("Relay " + str(i)) lbl.setAlignment(QtCore.Qt.AlignCenter | QtCore.Qt.AlignVCenter) lbl.setFixedHeight(20) lbl.setStyleSheet("QLabel { text-decoration:underline; \ font-size:14px; \ font-weight:bold; \ color:rgb(255,255,255);}") self.leds.append(LED(i, 50, 'g')) vbox = QtGui.QVBoxLayout() vbox.addWidget(lbl) vbox.addWidget(self.leds[i]) self.leds[i].setAlignment(QtCore.Qt.AlignCenter | QtCore.Qt.AlignVCenter) hbox_led.addLayout(vbox) #hbox_led.setAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter) hbox_led.setAlignment(QtCore.Qt.AlignCenter | QtCore.Qt.AlignVCenter) #hbox_led.addLayout(vbox_rx) self.led_fr.setLayout(hbox_led)
def __init__ (self): ''' A nice debugging aid - can print any simple or complex variable ''' self.pp = pprint.PrettyPrinter(indent=4) ''' Create the list of bits ''' for bitNr in range(8): b = LED(self.BitNames[bitNr], self.BitPins[bitNr], bitNr, self.BitValues[bitNr], self.BitStates[bitNr], self.BitColors[bitNr], self.BitBlinkRates[bitNr], self.BitProcesses[bitNr], self.BitDescriptions[bitNr]) b.status = self.ledStateString("On", "Off") self.Bits.append(b) return None
def __init__(self, car_name): self.car = Car(car_name) self.car.steering.turning_max = 50 self.color = self.car.color_getter self.flag = True self.buzzer = Buzzer.Buzz() self.led = LED.Led() self.song = Buzzer_Elise.Elise()
def watchdog_mode_fnc(frame_image): gray = cv2.cvtColor(frame_image, cv2.COLOR_BGR2GRAY) gray = cv2.GaussianBlur(gray, (21, 21), 0) if avg is None: print("[INFO] starting background model...") avg = gray.copy().astype("float") rawCapture.truncate(0) return cv2.accumulateWeighted(gray, avg, 0.5) frameDelta = cv2.absdiff(gray, cv2.convertScaleAbs(avg)) # threshold the delta image, dilate the thresholded image to fill # in holes, then find contours on thresholded image thresh = cv2.threshold(frameDelta, 5, 255, cv2.THRESH_BINARY)[1] thresh = cv2.dilate(thresh, None, iterations=2) cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours(cnts) #print('x') # loop over the contours for c in cnts: # if the contour is too small, ignore it if cv2.contourArea(c) < 5000: return # compute the bounding box for the contour, draw it on the frame, # and update the text (x, y, w, h) = cv2.boundingRect(c) cv2.rectangle(frame_image, (x, y), (x + w, y + h), (128, 255, 0), 1) text = "Occupied" motionCounter += 1 #print(motionCounter) #print(text) LED.colorWipe(Color(255, 16, 0)) lastMovtionCaptured = timestamp if (timestamp - lastMovtionCaptured).seconds >= 0.5: LED.colorWipe(Color(255, 255, 0))
def __init__(self): led = 11 button = 13 GPIO.setmode(GPIO.BOARD) GPIO.setup(led, GPIO.OUT) self.__scanner = Scanner() self.__button = Button(button) self.__led = LED(led) self.__printer = Printer()
def webhook(): global check data = request.get_json() if data["object"] == "page": for entry in data["entry"]: for msg_event in entry["messaging"]: sender_id = msg_event["sender"]["id"] if msg_event.get("message"): message_text = msg_event["message"]["text"] #print(message_text) if message_text == "turn off led": LED.Setup(2, "OUT") LED.TurnOffLED(2) send_msg("1447614532010378", "turn off led") #print(message_text) log(data) return "ok", 200
def main(): try: loadConfig() ledProcess = multiprocessing.Process(target=led) # ledProcess.start() # lcdProcess = multiprocessing.Process(target=LCD) #lcdProcess.start() monDevice = multiprocessing.Process(target=MonitorDevice) monDevice.start() CGISocket.listen(5) print 'Listening.' subprocess.Popen( "sudo sh -c 'echo 1 > /sys/class/leds/led0/brightness'", shell=True) while 1: conn, add = CGISocket.accept() client(conn, add) except KeyboardInterrupt: print "\nGoodbye" subprocess.Popen( "sudo sh -c 'echo 0 > /sys/class/leds/led0/brightness'", shell=True) # ledProcess.terminate() LED.fadeToRGB(0, 0, 0, 0.005, False, True) try: carConnection.close() except: print colored("Failed to close carConnection", "red") os._exit(0) except Exception, e: print "Error!" print colored(str(e), "red") traceback.print_exc()
def monitor_distance(LED, min_distance_m=0.1): '''Monitor distance using ultasonic module and change LED based on distance''' while True: current_distance = round(ultra.checkdist(), 2) if_debug_log("distance: " + str(current_distance)) if current_distance > (2 * min_distance_m): #distance far, normal white LED LED.colorWipe(Color(255, 255, 255)) if_debug_log("distance: " + str(current_distance) + " --> normal, LED white") elif (current_distance > (min_distance_m) and current_distance <= (2 * min_distance_m)): #getting closer, LED yellow LED.colorWipe(Color(255, 255, 0)) if_debug_log("distance: " + str(current_distance) + " --> getting closer, LED yellow") elif current_distance <= min_distance_m: #too close, LED red LED.colorWipe(Color(255, 0, 0)) if_debug_log("distance: " + str(current_distance) + " --> too close, LED red")
def server(): gpio.setmode(gpio.BCM) LED.setup(21, 'out') server_socket = bt.BluetoothSocket(bt.RFCOMM) server_socket.bind(('', 3)) server_socket.listen(1) conn_socket, address = server_socket.accept() try: while True: data = conn_socket.recv(1024) data = str(data, 'utf-8') print(data) if data == 'turn on': print('receive "{}"'.format(data)) LED.turnON(21) elif data == 'turn off': print('receive "{}"'.format(data)) LED.turnOFF(21) send_data = input() conn_socket.send(send_data) finally: conn_socket.close() server_socket.close() gpio.cleanup()
def server(): bind_ip = '192.168.10.33' bind_port = 8888 server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server_socket.bind((bind_ip, bind_port)) server_socket.listen(5) print('Listening on {}'.format((bind_ip, bind_port))) gpio.setmode(gpio.BCM) LED.setup(21, 'out') try: conn_socket, addr = server_socket.accept() print('Accept connection from {}'.format((addr[0], addr[1]))) while True: data = conn_socket.recv(1024) data = str(data, 'utf-8') if data == 'turn on': LED.turnON(21) elif data == 'turn off': LED.turnOFF(21) print(data) finally: server_socket.close() conn_socket.close() gpio.cleanup()
def mainLogic(): LED.Blink(5, 5, 5, 1, 2, 3, 1100) while (True): GPIO.wait_for_edge(pin, GPIO.FALLING) sleep(softDebounce) # Software button debounce count = 0 while (True): LED.ON(ledMatrix[count][0], ledMatrix[count][1], ledMatrix[count][2]) isPressed = GPIO.wait_for_edge(pin, GPIO.FALLING, timeout=confirmTimeout) sleep(softDebounce) # Software button debounce if (isPressed): count = (count + 1) % 3 # Makes sure the selection is 0-2 if ( count == 0 ): # Goes back to start if all options got scrolled through LED.OFF() break else: # Acts when a timeout occurs on non-zero selection LED.OFF() action(count) break
def update(): print("VOLUME - UPDATE") distanceFull = DATA.load_distanceFull() distanceEmpty = DATA.load_distanceEmpty() distance = DATA.load_distance() range = distanceEmpty - distanceFull percentage = 0.0 if distance < distanceEmpty: diffFromEmpty = distanceEmpty - distance percentage = diffFromEmpty / range print("VOLUME - UPDATE - PERCENTAGE = [%.2f]" % percentage) volumeMax = DATA.load_volumeMax() volume = volumeMax * percentage print("VOLUME - UPDATE - VOLUME = [%d]" % volume) DATA.save_volume(volume) DATA.save_percentage(percentage) warningPercentage = DATA.load_warningPercentage() LED.setup() if percentage < warningPercentage: LED.red() shouldSend = DATA.load_shouldSend() print("********************************************************** SHOULD SEND = ") print(shouldSend) if shouldSend: print("********************************************************** SEND NOTIF") # sending = DATA.load_sending() # print("********************************************************** SENDING = ") # print(sending) # if not sending: # DATA.save_sending(1) # DATA.save_shouldSend(0) # APNS.sendNotification() else: if percentage > 0.5: print("********************************************************** SHOULD SEND SET TO 1") DATA.save_shouldSend(1) LED.blue()
def initTable(self): self.relay_table = Relay_Table(self.main_window) self.cb_group = QtGui.QButtonGroup() self.cb_group.setExclusive(False) for i in range(8): #cb = QtGui.QCheckBox("Relay " + str(i)) cb = QtGui.QCheckBox("{:03d}".format(pow(2, i))) cb.setStyleSheet("QCheckBox { font-size:14px; \ background-color:rgb(0,0,0); \ color:rgb(255,255,255) ; }") self.cb_group.addButton(cb, i) rb_on = QtGui.QRadioButton("ON") rb_on.setStyleSheet("QRadioButton { font-size:14px; \ background-color:rgb(0,0,0); \ color:rgb(255,255,255) ; }") rb_off = QtGui.QRadioButton("OFF") rb_off.setStyleSheet("QRadioButton { font-size:14px; \ background-color:rgb(0,0,0); \ color:rgb(255,255,255) ; }") rb_off.setChecked(True) self.relay_rb_on.append(rb_on) self.relay_rb_off.append(rb_off) self.relay_cb.append(cb) self.table_led.append(LED(i, 20, 'g')) self.relay_table.add_relay( self.cfg['relay']['map'][i], \ self.table_led[i], \ self.relay_cb[i], \ self.relay_rb_on[i], \ self.relay_rb_off[i] ) self.relay_cb[i].clicked.connect(self.table_led[i].set_state) self.cb_group.buttonClicked.connect(self.cbClicked) grid = QtGui.QGridLayout() grid.addWidget(self.relay_table, 0, 0, 2, 2) grid.setSpacing(0) grid.setContentsMargins(0, 0, 0, 0) grid.setRowStretch(0, 1) self.table_fr.setLayout(grid)
def init(s,l): global screen,led screen=s led=LED.create(l) ico['0']=load('img/0.pbm',25,64) ico['1']=load('img/1.pbm',25,64) ico['2']=load('img/2.pbm',25,64) ico['3']=load('img/3.pbm',25,64) ico['4']=load('img/4.pbm',25,64) ico['5']=load('img/5.pbm',25,64) ico['6']=load('img/6.pbm',25,64) ico['7']=load('img/7.pbm',25,64) ico['8']=load('img/8.pbm',25,64) ico['9']=load('img/9.pbm',25,64) ico['flash']=load('img/flash.pbm',3,64) ico['am']=load('img/am.pbm',25,32) ico['pm']=load('img/pm.pbm',25,32) ico['cycle']=load('img/cycle.pbm',25,32) ico['cycle_error']=load('img/cycle_error.pbm',25,32) ico['love']=load('img/love.pbm',25,32)
def __init__(self): super(DisplayOLEDSkill, self).__init__(name="DisplayOLEDSkill") self.myLEDs = LED.theLEDs() self.myDisplay = DISPLAY.theDisplay() self.myLEDs.start() self.myDisplay.start() GPIO.setmode(GPIO.BCM) GPIO.setup(self.bshutdown, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(self.brestart, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(self.bsleep1, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(self.bsleep1, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.add_event_detect(self.bshutdown, GPIO.RISING, callback=self.button_shutdown) GPIO.add_event_detect(self.brestart, GPIO.RISING, callback=self.button_restart) GPIO.add_event_detect(self.bsleep1, GPIO.RISING, callback=self.button_stop_alarm)
def main(): rfid_reader = SimpleMFRC522.SimpleMFRC522() temp_sensor = Adafruit_DHT.DHT11 temp_pin = 4 # Physical pin is 7 init() #initialize the GPIO pins dbh = DB_Helper.DB_Helper() try: while True: print "Please place the tag to the RFID reader." # Turn ON LED to indicate that RFID is ready for reading LED.ledON() # Get the RFID id, text = rfid_reader.read() print "RFID: " + str(id) LED.ledOFF() # Code for reading the DHT11 Humidity and Temperature Sensor humidity, temperature = Adafruit_DHT.read_retry( temp_sensor, temp_pin) print "Temp={0:0.1f}C Humidity={1:0.1f}%".format( temperature, humidity) #Fetch the TagId from db.tbl_Tag base on RFID tagId = dbh.getTagId(id) #Insert the temperature, humidity and RFID to Data table inserted = dbh.addEntry(tagId, temperature, humidity) # Turn ON the buzzer to indicate that data is sent to Database if inserted is True: ActiveBuzzer.beep() except KeyboardInterrupt: dbh.destroy() LED.ledOFF() cleanGPIO()
import socket import RPi.GPIO as GPIO import LED import sys bind_ip = '192.168.1.11' bind_port = 8888 client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server_address = (bind_ip,bind_port) print('connect to {} port {}'.format(*server_address)) client.connect(server_address) LED.Setup(14, 'OUT') try: print('Accepted connection') while True: data = client.recv(1024) print(data) if data == b'turn on led': LED.TurnOnLED(14) else : LED.TurnOffLED(14) except KeyboardInterrupt: client.close() GPIO.cleanup() finally: server.close()
#!/usr/bin/env python #encoding=utf-8 from bottle import run, get, post, request import LED meta = '<meta name="viewport" content="width=device-width,initial-scale=1.0,user-scalable=yes">' form = ''' <form action="/bright" method="post"> <input type="range" name="brightvalue" value="0" min="0" max="100"> <input type="submit" value="Bright"> </form> ''' html = meta + form led_instance = LED.led_brightness(18) @get('/bright') def bright(): return html @post('/bright') def do_bright(): sliderValue = request.forms.get('brightvalue') led_instance.duty(int(sliderValue)) return '%s<br>%s' % (sliderValue, html) run(host='192.168.18.101', port=8080, debug=True)
while continue_reading: # Scan for cards (status,TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL) # If a card is found if status == MIFAREReader.MI_OK: print "Card detected" # Get the UID of the card (status,uid) = MIFAREReader.MFRC522_Anticoll() # If we have the UID, continue if status == MIFAREReader.MI_OK: Buzzer.setup() LED.setup() Buzzer.beep() LED.led() # Print UID print "Card read UID: "+str(uid[0])+","+str(uid[1])+","+str(uid[2])+","+str(uid[3]) if uid[0]==150 and uid[1]==110 and uid[2]==1 and uid[3]==164: print "Welcom, Jason :)" if uid[0]==133 and uid[1]==94 and uid[2]==233 and uid[3]==171: print "Welcom, Lucy :)" # This is the default key for authentication key = [0xFF,0xFF,0xFF,0xFF,0xFF,0xFF] # Select the scanned tag
GPIO 11 UV_CLOCK GPIO 10 UV_DOUT GPIO 21 temperature_CLOCK GPIO 20 temperature_DOUT """ def int16bit(b): return (ord(b[0]) << 8) + ord(b[1]) arduino = serial.Serial('/dev/ttyACM0', 9600) pi = pigpio.pi() led = LED.light(pi) led.all_off() pm25 = pmsA003.sensor('/dev/ttyUSB0') dht = DHT22.sensor(pi, 4) # Un-comment the line below to convert the temperature to Fahrenheit. # temperature = temperature * 9/5.0 + 32 # Note that sometimes you won't get a reading and # the results will be null (because Linux can't # guarantee the timing of calls to read the sensor). # If this happens try again! while True:
def slowBlink(led, numOfBlinks): for x in range(numOfBlinks): led.turnOn() time.sleep(slowBlinkDelay) led.turnOff() time.sleep(slowBlinkDelay)