def resetModem(): try: GPIO.setmode(GPIO.BOARD) GPIO.setup(onPin, GPIO.OUT) GPIO.setup(pwrKey, GPIO.OUT) GPIO.setup(statusPin, GPIO.IN) except Exception as e: pass GPIO.output(onPin, GPIO.LOW) # set the GSM ON/OFF pin to low to turn off the modem time.sleep(10) GPIO.output(onPin, GPIO.HIGH) # set the GSM ON/OFF pin to high to turn on the modem time.sleep(5) # Then Toggle the power key GPIO.output(pwrKey, GPIO.HIGH) GPIO.output(pwrKey, GPIO.LOW) time.sleep(5) GPIO.output(pwrKey, GPIO.HIGH) time.sleep(30) status = GPIO.input(statusPin) try: if status == 1: subprocess.call(['sudo sakis3g "connect" DNS="8.8.8.8" APN="CUSTOM_APN" CUSTOM_APN="airtelgprs.com" APN_USER="******" APN_PASS="******" USBINTERFACE="3" OTHER="USBMODEM" USBMODEM="1e0e:9001"'], shell=True) except Exception as e: print(e) time.sleep(5) print('GSM Status: ', GPIO.input(statusPin))
def resetModem(): GPIO.output( onPin, GPIO.LOW) # set the GSM ON/OFF pin to low to turn off the modem time.sleep(10) GPIO.output( onPin, GPIO.HIGH) # set the GSM ON/OFF pin to high to turn on the modem time.sleep(5) # Then Toggle the power key GPIO.output(pwrKey, GPIO.HIGH) GPIO.output(pwrKey, GPIO.LOW) time.sleep(5) GPIO.output(pwrKey, GPIO.HIGH) time.sleep(30) status = GPIO.input(statusPin) dns = '8.8.8.8' if gsmConf.get('DNS') is None else gsmConf.get('DNS') apn = 'airtelgprs.com' if gsmConf.get('APN') is None else gsmConf.get( 'APN') apnUser = '******' if gsmConf.get('APN_USER') is None else gsmConf.get( 'APN_USER') apnPass = '******' if gsmConf.get('APN_PASS') is None else gsmConf.get( 'APN_PASS') usbInterface = '3' if gsmConf.get('USBINTERFACE') is None else gsmConf.get( 'USBINTERFACE') usbModem = '1e0e:9001' if gsmConf.get('USBMODEM') is None else gsmConf.get( 'USBMODEM') command = f'sudo sakis3g "connect" DNS="{dns}" APN="CUSTOM_APN" CUSTOM_APN="{apn}" APN_USER="******" APN_PASS="******" USBINTERFACE="{usbInterface}" OTHER="USBMODEM" USBMODEM="{usbModem}"' try: if status == 1: subprocess.call([command], shell=True) except Exception as e: LOG.error('Error resetting modem : %s', e) time.sleep(5) LOG.info('GSM Status: %s', GPIO.input(statusPin))
def updateOutputUI(self): try: result = [] result_pwm = [] for rpi_output in self.rpi_outputs: pin = self.toInt(rpi_output['gpioPin']) if rpi_output['outputType']=='regular': val = GPIO.input(pin) if not rpi_output['activeLow'] else (not GPIO.input(pin)) result.append({pin:val}) if rpi_output['outputType']=='pwm': # self._logger.info("outputType is PWM") # self._logger.info("Got pin number: %s",pin) # self._logger.info("PWM_INSTANCES: %s",self.PWM_INSTANCES) for pwm in self.PWM_INSTANCES: if pin in pwm: if 'dutycycle' in pwm: pwmVal = pwm['dutycycle']; val = self.toInt(pwmVal) else: val = 100 result_pwm.append({pin:val}) # self._logger.info("result_pwm: %s", result_pwm) self._plugin_manager.send_plugin_message(self._identifier, dict(rpi_output=result,rpi_output_pwm=result_pwm)) except Exception as ex: template = "An exception of type {0} occurred on updateOutputUI. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) self._logger.warn(message) pass
def __pulse(self, channel): clk_state = GPIO.input(self.clk) dt_state = GPIO.input(self.dt) if clk_state != self.rotaryLastState: self.rotaryLastState = clk_state if dt_state != clk_state: self.menu.change_highlight(1) else: self.menu.change_highlight(-1) self.menu.render()
def radio_rx_cfg(): radio_write(0x01, 0x00) radio_write(0x01, 0x05) dio2 = GPIO.input(sx1276_DIO2) while (dio2 != 1): dio2 = GPIO.input(sx1276_DIO2) result = radio_read(0x01) return result
def relay_sensor_callback(self, _): while GPIO.input(self.pin_relay) == self.switch_pin_relay: self.relay_send_alert_count += 1 self.debug_only_output('Confirmations: ' + str(self.relay_send_alert_count)) sleep(self.poll_time / 1000) if self.confirmations <= self.relay_send_alert_count: self.relay_send_alert = True self.relay_send_alert_count = 0 self._logger.info("Relay Sensor Triggered!") self._plugin_manager.send_plugin_message( self._identifier, dict(title="Relay Sensor", type="error", autoClose=False, msg="Relay Sensor Triggered!")) if self.send_webhook: subprocess.Popen( "curl -X POST -H 'Content-Type: application/json' https://maker.ifttt.com/trigger/%s/with/key/%s" % (self.ifttt_applet_name_pin2, self.ifttt_secretkey), shell=True) self.debug_only_output("Pin 2 Sending a webhook to ifttt.") if self.pause_print: self.debug_only_output("Pausing print.") self._printer.pause_print() if self.gcode_relay: self.debug_only_output("Sending Relay Sensor GCODE") self._printer.commands(self.gcode_relay) break else: self.relay_send_alert = False self.relay_send_alert_count = 0
def send_blink(n_blink): sbuff = [0] * 64 sbuff[0] = 0x7e sbuff[1] = 0x8c sbuff[2] = 0x8a sbuff[3] = 0x92 sbuff[4] = 0x98 sbuff[5] = 0x86 sbuff[6] = 0xa0 sbuff[7] = 0xe0 sbuff[8] = 0x8c sbuff[9] = 0x8a sbuff[10] = 0x92 sbuff[11] = 0x84 sbuff[12] = 0xa6 sbuff[13] = 0x62 sbuff[14] = 0x61 ns = random.getrandbits(3) #radom integer of 3 bits nr = (ns + 1) & 0x07 sbuff[15] = (nr << 5) | (ns << 1) | 0x10 sbuff[16] = 0xf0 sbuff[17] = 0xa6 if n_blink > 0 and n_blink < 255: sbuff[18] = n_blink else: print("WRONG PARAMETERS INSERTED") return checksum = 0 for i in range(1, 17): checksum += sbuff[i] sbuff[61] = (~checksum) + 1 checksum = 0 for i in range(17, 61): checksum += sbuff[i] sbuff[62] = (~checksum) + 1 sbuff[63] = 0x7e #send the packet to the FIFO reg_value = radio_read(0x3f) radio_write(0x3f, reg_value | 0x10) #reset FIFO radio_tx_cfg() for i in range(0, 64): radio_write(0, sbuff[i]) while (GPIO.input(11) == 0): time.sleep(0.00001) print("INFORMATION FRAME SENT: DEBUG LED BLINK", n_blink, "TIMES") print("SEQUENCE NUMBER N(R):", hex(nr)) reg_value = radio_read(0x3f) radio_write(0x3f, reg_value | 0x10) #reset FIFO print("WAITING FOR REPLY...") base(4) ## wai for message with a timeout of 2 seconds base( 0 ) ## this maintains the radio at the receiver routine after the end of the transmission return
def test_input(): with patch("OPi.GPIO.sysfs") as mock: mock.input.return_value = GPIO.HIGH GPIO.setmode(GPIO.BOARD) GPIO.setup(23, GPIO.IN) assert GPIO.input(23) == GPIO.HIGH mock.input.assert_called_with(14)
def handlePrinterAction(self,channel): try: for rpi_input in self.rpi_inputs: if channel == self.toInt(rpi_input['gpioPin']) and rpi_input['eventType']=='printer' and \ ((rpi_input['edge']=='fall') ^ GPIO.input(self.toInt(rpi_input['gpioPin']))): if rpi_input['printerAction'] == 'resume': self._logger.info("Printer action resume.") self._printer.resume_print() elif rpi_input['printerAction'] == 'pause': self._logger.info("Printer action pause.") self._printer.pause_print() elif rpi_input['printerAction'] == 'cancel': self._logger.info("Printer action cancel.") self._printer.cancel_print() elif rpi_input['printerAction'] == 'stopTemperatureControl': self._logger.info("Printer action stoping temperature control.") self.enclosureSetTemperature = 0; self.handleTemperatureControl() for notification in self.notifications: if notification['printerAction']: msg = "Printer action: " + rpi_input['printerAction'] + " caused by input: " + str(rpi_input['label']) self.sendNotification(msg) except Exception as ex: template = "An exception of type {0} occurred on handlePrinterAction. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) self._logger.warn(message) pass
def test_input_and_output(): with patch("OPi.GPIO.sysfs") as mock: mock.input.return_value = GPIO.HIGH GPIO.setmode(GPIO.BOARD) GPIO.setup(23, GPIO.OUT) GPIO.output(23, not GPIO.input(23)) mock.input.assert_called_with(14) mock.output.assert_called_with(14, GPIO.LOW)
def change_battery(code): sbuff = [0] * 64 sbuff[0] = 0x7e sbuff[1] = 0x8c sbuff[2] = 0x8a sbuff[3] = 0x92 sbuff[4] = 0x98 sbuff[5] = 0x86 sbuff[6] = 0xa0 sbuff[7] = 0xe0 sbuff[8] = 0x8c sbuff[9] = 0x8a sbuff[10] = 0x92 sbuff[11] = 0x84 sbuff[12] = 0xa6 sbuff[13] = 0x62 sbuff[14] = 0x61 ns = random.getrandbits(3) #radom integer of 3 bits nr = (ns + 1) & 0x07 sbuff[15] = (nr << 5) | (ns << 1) | 0x10 sbuff[16] = 0xf0 sbuff[17] = 0xa8 sbuff[ 18] = code #0x00 for only reading / 0xf0 to switch to main / 0xff to switch to backup checksum = 0 for i in range(1, 17): checksum += sbuff[i] sbuff[61] = (~checksum) + 1 checksum = 0 for i in range(17, 61): checksum += sbuff[i] sbuff[62] = (~checksum) + 1 sbuff[63] = 0x7e #send the packet to the FIFO reg_value = radio_read(0x3f) radio_write(0x3f, reg_value | 0x10) #reset FIFO radio_tx_cfg() for i in range(0, 64): radio_write(0, sbuff[i]) while (GPIO.input(11) == 0): time.sleep(0.00001) print("INFORMATION FRAME SENT: CHANGE BATTERY CIRCUIT") print("SEQUENCE NUMBER N(R):", hex(nr)) reg_value = radio_read(0x3f) radio_write(0x3f, reg_value | 0x10) #reset FIFO print("WAITING FOR REPLY...") base(4) ## wait base( 0 ) ## this maintains the radio at the receiver routine after the end of the transmission return
def main(self): lastVolume = self.volume clkLastState = GPIO.input(config.clk) newVolume = lastVolume try: print("Started cattrotar!"); while True: clkState = GPIO.input(config.clk) dtState = GPIO.input(config.dt) # see if we got a change since last iteration of loop if clkState != clkLastState: if dtState != clkState: newVolume += .5 else: newVolume -= .5 # only if new volume has changed more than .5 and it's different than prior # volume levels do we actually update volume if newVolume % 1 == 0 and lastVolume != newVolume: # reset button state to be up self.button = 0 # set volume newVolume = self.setVolume(newVolume) lastVolume = newVolume # empty screen after 10 seconds if (time.time() - self.last_screen_update) > 10: self.show(' ') clkLastState = clkState sleep(0.001) except KeyboardInterrupt: print("\nkeyboard killed the process") finally: self.show('Bye!') sleep(0.5) self.show(' ') self.show(' ') print('cattrotar exiting') GPIO.cleanup()
def pinRead(self, pin): #print "pin",pin ,"set to", self.pinUse[pin] #print pin ," being read" try: return GPIO.input(pin) except Exception,e: print "Some error reading pin" ,pin print str(e) return 0
def readGPIO(): STATUS = 0 for pin in PIN_PGM: B = GPIO.input(pin) STATUS = STATUS | B STATUS = STATUS << 1 ## print "read GPIO char str int" , chr(STATUS+50) ,str(STATUS), STATUS return STATUS
def readNextBit(self): # Clock HX711 Digital Serial Clock (PD_SCK). DOUT will be # ready 1us after PD_SCK rising edge, so we sample after # lowering PD_SCL, when we know DOUT will be stable. GPIO.output(self.PD_SCK, True) GPIO.output(self.PD_SCK, False) value = GPIO.input(self.DOUT) # Convert Boolean to int and return it. return int(value)
def send_devices_info(): sbuff = [0] * 64 sbuff[0] = 0x7e sbuff[1] = 0x8c sbuff[2] = 0x8a sbuff[3] = 0x92 sbuff[4] = 0x98 sbuff[5] = 0x86 sbuff[6] = 0xa0 sbuff[7] = 0xe0 sbuff[8] = 0x8c sbuff[9] = 0x8a sbuff[10] = 0x92 sbuff[11] = 0x84 sbuff[12] = 0xa6 sbuff[13] = 0x62 sbuff[14] = 0x61 ns = random.getrandbits(3) #radom integer of 3 bits nr = (ns + 1) & 0x07 sbuff[15] = (nr << 5) | (ns << 1) | 0x10 sbuff[16] = 0xf0 sbuff[17] = 0xa2 checksum = 0 for i in range(1, 17): checksum += sbuff[i] sbuff[61] = (~checksum) + 1 checksum = 0 for i in range(17, 61): checksum += sbuff[i] sbuff[62] = (~checksum) + 1 sbuff[63] = 0x7e #send the packet to the FIFO reg_value = radio_read(0x3f) radio_write(0x3f, reg_value | 0x10) #reset FIFO radio_tx_cfg() for i in range(0, 64): radio_write(0, sbuff[i]) while (GPIO.input(11) == 0): time.sleep(0.00001) print("INFORMATION FRAME SENT: REQUEST DEVICE INFORMATION") print("SEQUENCE NUMBER N(R):", hex(nr)) reg_value = radio_read(0x3f) radio_write(0x3f, reg_value | 0x10) #reset FIFO print("WAITING FOR REPLY...") base(4) ## wait for message with a timeout base( 0 ) ## this maintains the radio at the receiver routine after the end of the transmission return
def index(): # get_Host_name_IP() now = datetime.now() #.time().strftime("%H:%M") hour = now.hour minute = now.minute weekday = now.weekday() pins = Pin.query.order_by(Pin.pin.asc()).all() dailyschedule = DailySchedule.query.all() weeklyschedule = WeeklySchedule.query.all() apis = API.query.all() pin_status = {} used_pin = [] for pin in pins: # read status of pin pin_status[pin.pin] = GPIO.input(pin.pin) used_pin.append(pin.pin) # tracking all ip to access if request.remote_addr not in ip_req: ip_req.append(request.remote_addr) days = [ "monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday" ] avalible_pins = [ 3, 5, 7, 8, 10, 11, 12, 13, 15, 16, 18, 19, 21, 22, 23, 24, 26 ] api_provider = ['openweathermap', 'darksky', 'opencagedata', 'weatherapi'] for pin in used_pin: # delete used pin avalible_pins.remove(pin) dayname = days[weekday] isalive = thread.isAlive() return render_template("index.html", totalprecip_mm=totalprecip_mm, maxtemp_c=maxtemp_c, apis=apis, api_provider=api_provider, dailyschedule=dailyschedule, weeklyschedule=weeklyschedule, hour=hour, minute=minute, weekday=weekday, pins=pins, pin_status=pin_status, dayname=dayname, avalible_pins=avalible_pins, ip_req=ip_req, isalive=isalive)
def set_menu(self, menu): self.menu = menu GPIO.add_event_detect(self.clk, GPIO.BOTH, callback=self.__pulse) GPIO.add_event_detect(self.dt, GPIO.BOTH, callback=self.__pulse) GPIO.add_event_detect(self.btn, GPIO.RISING, callback=self.__button, bouncetime=200) self.rotaryLastState = None self.btnLastState = GPIO.input(self.btn) self.clkLevel = 0 self.dtLevel = 0
def handleGPIOControl(self,channel): try: for rpi_input in self.rpi_inputs: if channel == self.toInt(rpi_input['gpioPin']) and rpi_input['eventType']=='gpio' and \ ((rpi_input['edge']=='fall') ^ GPIO.input(self.toInt(rpi_input['gpioPin']))): for rpi_output in self.rpi_outputs: if self.toInt(rpi_input['controlledIO']) == self.toInt(rpi_output['gpioPin']) and rpi_output['outputType']=='regular': if rpi_input['setControlledIO']=='toggle': val = GPIO.LOW if GPIO.input(self.toInt(rpi_output['gpioPin']))==GPIO.HIGH else GPIO.HIGH else: val = GPIO.LOW if rpi_input['setControlledIO']=='low' else GPIO.HIGH self.writeGPIO(self.toInt(rpi_output['gpioPin']),val) for notification in self.notifications: if notification['gpioAction']: msg = "GPIO control action caused by input " + str(rpi_input['label']) + ". Setting GPIO" + str(rpi_input['controlledIO']) + " to: " + str(rpi_input['setControlledIO']) self.sendNotification(msg) except Exception as ex: template = "An exception of type {0} occurred on handleGPIOControl. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) self._logger.warn(message) pass
def send_supervisory(nr): sbuff = [0] * 64 sbuff[0] = 0x7e sbuff[1] = 0x8c sbuff[2] = 0x8a sbuff[3] = 0x92 sbuff[4] = 0x98 sbuff[5] = 0x86 sbuff[6] = 0xa0 sbuff[7] = 0xe0 sbuff[8] = 0x8c sbuff[9] = 0x8a sbuff[10] = 0x92 sbuff[11] = 0x84 sbuff[12] = 0xa6 sbuff[13] = 0x62 sbuff[14] = 0x61 nr = nr & (0x07) sbuff[15] = (nr << 5) | 0x1d sbuff[16] = 0xf0 checksum = 0 for i in range(1, 17): checksum += sbuff[i] sbuff[61] = (~checksum) + 1 checksum = 0 for i in range(17, 61): checksum += sbuff[i] sbuff[62] = (~checksum) + 1 sbuff[63] = 0x7e #send the packet to th FIFO reg_value = radio_read(0x3f) radio_write(0x3f, reg_value | 0x10) #reset FIFO radio_tx_cfg() for i in range(0, 64): radio_write(0, sbuff[i]) while (GPIO.input(11) == 0): time.sleep(0.00001) print("SUPERVISORY COMMAND SENT | SEQUENCE NUMBER N(R)", hex(nr)) reg_value = radio_read(0x3f) radio_write(0x3f, reg_value | 0x10) #reset FIFO print("WAITING FOR REPLY...") base(4) ## wai for message with a timeout of 2 seconds base( 0 ) ## this maintains the radio at the receiver routine after the end of the transmission return
def EncoderCallback(channel): global preset global oldPreset global updateReq if not GPIO.input(encB) and preset < 127: preset += 1 elif preset > 0: preset -= 1 else: pass if oldPreset != preset: updateReq = True oldPreset = preset
def watch(self): if self.device is not None: for event in self.device.read_loop(): if event.type == 2: if event.value == 1: self._clockwise_tick() elif event.value == -1: self._counterclockwise_tick() else: while True: try: # Switch part if self.sw_callback: if GPIO.input(self.sw) == GPIO.LOW: self._switch_press() else: self._switch_release() # Encoder part clkState = GPIO.input(self.clk) dtState = GPIO.input(self.dt) if clkState != self.clk_last_state: if dtState != clkState: self._clockwise_tick() else: self._counterclockwise_tick() self.clk_last_state = clkState sleep(self.polling_interval / 1000) except BaseException as e: logger.info("Exiting...") logger.info(e) GPIO.cleanup() break return
def Buttons(): global preset, lastbuttontime while True: now = time.time() if not GPIO.input(BTN1) and (now - lastbuttontime) > 0.5: lastbuttontime = now preset -= 1 if preset < 0: preset = 127 LoadSamples() #print('BTN1=',GPIO.input(BTN1)) elif not GPIO.input(BTN2) and (now - lastbuttontime) > 0.5: lastbuttontime = now preset += 1 if preset > 127: preset = 0 LoadSamples() #print('BTN2=',GPIO.input(BTN2)) time.sleep(0.050)
def read_pin(pin): state = -1 if PFIO_MODULE: state = PFIO.digital_read(pin) if GPIO_MODULE: state = GPIO.input(pin) if MONITOR_OUT_INVERT: if state == 0: state = 1 elif state == 1: state = 0 return (state)
def outFunction(null): global Counter PIN_CLK_AKTUELL = GPIO.input(PIN_CLK) if PIN_CLK_AKTUELL != PIN_CLK_LETZTER: if GPIO.input(PIN_DT) != PIN_CLK_AKTUELL: Counter += 1 Richtung = True else: Richtung = False Counter = Counter - 1 print("Rotation detected: ") if Richtung: print("Rotational direction: Clockwise") else: print("Rotational direction: Counterclockwise") print("Current position: ", Counter) print "------------------------------"
def io_check(self): checks = {} if (self.io_check_count >= 65535): self.io_check_count = 0 else: self.io_check_count += 1 logging.debug("IO check " + str(self.io_check_count)) for name, chan in self.runtime.switch_channels.items(): result = self.runtime.ct_ios[name].update(GPIO.input(chan)) # value confirmed if result[0]: checks[name] = result[1] for name, chan in self.runtime.flip_channels.items(): result = self.runtime.ct_ios[name].update(int (not GPIO.input(chan))) if result[0]: checks[name] = result[1] for name, chan in self.runtime.pir_channels.items(): result = self.runtime.ct_ios[name].update(GPIO.input(chan)) # PIR's are special because they like to be on and are only turned off during # timed checkups if result[0] and result[1] and not self.runtime.last_pir_state[name]: checks[name] = result[1] self.runtime.last_pir_state[name] = result[1] # don't run the temperature power control if there is no such thing. try: result = self.runtime.temp_fault_sm.update(not GPIO.input(self.runtime.temp_fault)) if result[0]: checks["Temp Power Fault"] = result[1] except AttributeError: pass # notify if any values were changed if checks: self.notify('event', checks) else: logging.debug("Noting changed between timed io checks")
def resetModem(): GPIO.output( onPin, GPIO.LOW) # set the GSM ON/OFF pin to low to turn off the modem time.sleep(10) GPIO.output( onPin, GPIO.HIGH) # set the GSM ON/OFF pin to high to turn on the modem time.sleep(5) # Then Toggle the power key GPIO.output(pwrKey, GPIO.HIGH) GPIO.output(pwrKey, GPIO.LOW) time.sleep(5) GPIO.output(pwrKey, GPIO.HIGH) time.sleep(30) status = GPIO.input(statusPin) try: if status == 1: subprocess.Popen( ['wvdial -C /root/DataLogger/recovery/wvdial.conf'], shell=True) except Exception as e: print(e) time.sleep(5) print('GSM Status: ', GPIO.input(statusPin))
def basic_distance(trig_pin, echo_pin, celsius=20): """Return an unformatted distance in cm's as read directly from RPi.GPIO.""" speed_of_sound = 331.3 * math.sqrt(1 + (celsius / 273.15)) GPIO.setup(trig_pin, GPIO.OUT) GPIO.setup(echo_pin, GPIO.IN) GPIO.output(trig_pin, GPIO.LOW) time.sleep(0.1) GPIO.output(trig_pin, True) time.sleep(0.00001) GPIO.output(trig_pin, False) echo_status_counter = 1 while GPIO.input(echo_pin) == 0: if echo_status_counter < 1000: sonar_signal_off = time.time() echo_status_counter += 1 else: raise SystemError("Echo pulse was not received") while GPIO.input(echo_pin) == 1: sonar_signal_on = time.time() time_passed = sonar_signal_on - sonar_signal_off return time_passed * ((speed_of_sound * 100) / 2)
def startFilamentDetection(self): self.stopFilamentDetection() try: for rpi_input in self.rpi_inputs: if rpi_input['eventType'] == 'printer' and rpi_input['printerAction'] == 'filament' and self.toInt(rpi_input['gpioPin']) != 0: edge = GPIO.RISING if rpi_input['edge'] == 'rise' else GPIO.FALLING if GPIO.input(self.toInt(rpi_input['gpioPin'])) == (edge == GPIO.RISING): self._printer.pause_print() self._logger.info("Started printing with no filament.") else: GPIO.add_event_detect(self.toInt(rpi_input['gpioPin']), edge, callback= self.handleFilammentDetection, bouncetime=200) except Exception as ex: template = "An exception of type {0} occurred on startFilamentDetection. Arguments:\n{1!r}" message = template.format(type(ex).__name__, ex.args) self._logger.warn(message) pass
def pinRCTime (self,pin): reading = 0 #print "rc pin told to set to output" self.pinUpdate(pin,0) #print "rc changed to ouput" time.sleep(0.1) #print "sleep done" GPIO.setup(pin,GPIO.IN) #print "rc set to input" #time.sleep(3) #print "sleep 2 done" # This takes about 1 millisecond per loop cycle while (GPIO.input(pin) == GPIO.LOW) and (reading < 1000): reading += 1 #print "change back to output" GPIO.setup(pin,GPIO.OUT) self.pinUpdate(pin,0) return reading