def setup():
if os.path.isdir(ImagePath) == False:
os.mkdir(ImagePath, 0777)
try:
GPIO.cleanup()
finally:
pass
GPIO.setmode(GPIO.BOARD)
GPIO.setup(BeepPin, GPIO.OUT)
GPIO.setup(LedPin, GPIO.OUT)
GPIO.setup(ButtonPin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
ledOn()
beepOn()
time.sleep(0.1)
ledOff()
beepOff()
# Loop, wait for button press
python类IN的实例源码
def __init__(self):
gpio.setmode(gpio.BOARD)
# set up and init
self.trigger = 13
self.echo = 11
gpio.setup(self.trigger, gpio.OUT)
gpio.setup(self.echo, gpio.IN)
self.pulse_start = 0.
self.pulse_end = 0.
self.speed_of_sound = 343 * 100
self.max_distance = 100
self.min_distance = 1
def set_up_gpio(self):
GPIO.setmode(GPIO.BCM)
#GPIO.setup(camera_led_pin, GPIO.OUT, initial=False) # Set GPIO to output
GPIO.setup(config.led_pin_select,GPIO.OUT) # The 'Select' button LED
GPIO.setup(config.led_pin_left,GPIO.OUT) # The 'Left' button LED
GPIO.setup(config.led_pin_right,GPIO.OUT) # The 'Right' button LED
# Detect falling edge on all buttons
GPIO.setup(config.button_pin_select, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(config.button_pin_left, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(config.button_pin_right, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(config.button_pin_exit, GPIO.IN, pull_up_down=GPIO.PUD_UP)
# Drumminhands found it necessary to switch off LEDs initially
GPIO.output(config.led_pin_select, False)
GPIO.output(config.led_pin_left, False)
GPIO.output(config.led_pin_right, False)
def __GPIOInit(self):
"""
Initialises the GPIO pins for the pi
(tested on the Pi3 Model B+)
"""
# Set mode PIN numbering to BCM, and define GPIO pin functions
GPIO.setmode(GPIO.BCM)
# Setup Function for input Pins
inputBNTs = (self.__soundBNTs + self.__stepBNTs)
inputBNTs.append(self.__playBNT)
inputBNTs.append(self.__recBNT)
for b in inputBNTs:
GPIO.setup(b, GPIO.IN, pull_up_down=GPIO.PUD_UP)
# Func for ouput Pins
GPIO.setup(self.__LED, GPIO.OUT)
def send_gpio_order(param):
"""
GPIO????
type in(GPIO.IN) out(GPIO.OUT)
value 1 GPIO.HIGH 0 GPIO.LOW
:param param:
:return:
"""
print param
channel, type, value = param
try:
import RPi.GPIO as GPIO
except RuntimeError:
print("????")
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
if type == 'in':
GPIO.setup(channel, GPIO.IN)
GPIO.input(channel, value)
else:
GPIO.setup(channel, GPIO.OUT)
GPIO.output(channel, value)
def ReadAck(self):
GPIO.setup(self.SDA, GPIO.IN)
readbuffer =0
for i in range(8):
GPIO.output(self.SCL, GPIO.HIGH)
self.tick(2)
readbuffer |= (GPIO.input(self.SDA)<< 7) >> i
GPIO.output(self.SCL, GPIO.LOW)
self.tick(2)
GPIO.setup(self.SDA, GPIO.OUT)
GPIO.output(self.SDA, GPIO.LOW)
GPIO.output(self.SCL, GPIO.HIGH)
self.tick(2)
GPIO.output(self.SCL, GPIO.LOW)
GPIO.output(self.SDA, GPIO.LOW)
self.tick(2)
return readbuffer
def ReadNack(self):
GPIO.setup(self.SDA, GPIO.IN)
readbuffer =0
for i in range(8):
GPIO.output(self.SCL, GPIO.HIGH)
self.tick(2)
readbuffer |= (GPIO.input(self.SDA)<< 7) >> i
GPIO.output(self.SCL, GPIO.LOW)
self.tick(2)
GPIO.setup(self.SDA, GPIO.OUT)
GPIO.output(self.SDA, GPIO.HIGH)
GPIO.output(self.SCL, GPIO.HIGH)
self.tick(2)
GPIO.output(self.SCL, GPIO.LOW)
GPIO.output(self.SDA, GPIO.LOW)
self.tick(2)
return readbuffer
def signalDoorBell():
global doorBell
global belli
global bellSum
global previousDoorBell
global GPIO_doorBell
global GPIO_bell
if belli != 15:
GPIO.setmode(GPIO.BOARD)
GPIO.setup(GPIO_doorBell, GPIO.IN)
bellSum = bellSum + GPIO.input(GPIO_doorBell)
belli += 1
else:
belli = 0
if bellSum >= 15:
doorBell = 1
else:
doorBell = 0
if doorBell != previousDoorBell:
previousDoorBell = doorBell
DeviceControl.doorBell(doorBell)
print("Dang qian doorBell %s" % doorBell)
bellSum = 0
def signalshock():
global shocki
global shockSum
global shock
global GPIO_shock
if shocki != 5:
GPIO.setmode(GPIO.BOARD)
GPIO.setup(GPIO_shock, GPIO.IN)
shockSum = shockSum+GPIO.input(GPIO_shock)
shocki += 1
else:
shocki = 0
if shockSum >=2:
shock = 1
else:
shock = 0
global previousShock
if shock != previousShock:
previousShock = shock
print("Dang qian shock %s" % shock)
shockSum = 0
def signaliR():
global iRi
global iRSum
global iR
global GPIO_iR
if iRi != 5:
GPIO.setmode(GPIO.BOARD)
GPIO.setup(GPIO_iR, GPIO.IN)
iRSum = iRSum+GPIO.input(GPIO_iR)
iRi += 1
else:
iRi = 0
if iRSum >= 2:
iR = 1
else:
iR = 0
global previousIR
if iR != previousIR:
previousIR = iR
print("Dang qian IR %s"%iR)
iRSum = 0
IRStateMachine.stateJudge(iR)
# ??????
def __init__(self, ready):
Thread.__init__(self)
self.ready = ready
self.picked_up = False
self.on = True
self._ringer1 = 11
self._ringer2 = 13
self._button = 7
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(self._ringer1, GPIO.OUT)
GPIO.output(self._ringer1, GPIO.LOW)
GPIO.setup(self._ringer2, GPIO.OUT)
GPIO.output(self._ringer2, GPIO.LOW)
GPIO.setup(self._button, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
self._last_state = 0
self._last_ts = time.time()
self._last_check = time.time()
self._ring = 1
self.max_ring_cnt = 2
def main():
try:
while True:
for led in LEDS:
for idx, pin in enumerate(led):
if pin == O:
GPIO.setup(PINS[idx], GPIO.IN)
else:
GPIO.setup(PINS[idx], GPIO.OUT)
GPIO.output(PINS[idx], pin)
time.sleep(.1)
except KeyboardInterrupt:
pass
finally:
GPIO.cleanup()
sample_custom_ui_launcher.py 文件源码
项目：raspberry-gpio-emulator
作者: nosix
项目源码
文件源码
阅读 23
收藏 0
点赞 0
评论 0
def main():
import RPi.GPIO as GPIO
import time
try:
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(18, GPIO.OUT)
GPIO.setup(27, GPIO.IN)
while True:
time.sleep(1)
finally:
GPIO.cleanup()
def main():
import RPi.GPIO as GPIO
import time
try:
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(18, GPIO.OUT)
GPIO.setup(27, GPIO.IN)
while True:
time.sleep(1)
finally:
GPIO.cleanup()
def __init__(self, data):
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
self.SPIMOSI = 23
self.SPIMISO = 24
self.SPICLK = 18
self.SPICS = 25
if "mosiPin" in data:
self.SPIMOSI = data["mosiPin"]
if "misoPin" in data:
self.SPIMISO = data["misoPin"]
if "clkPin" in data:
self.SPICLK = data["clkPin"]
if "csPin" in data:
self.SPICS = data["csPin"]
GPIO.setup(self.SPIMOSI, GPIO.OUT)
GPIO.setup(self.SPIMISO, GPIO.IN)
GPIO.setup(self.SPICLK, GPIO.OUT)
GPIO.setup(self.SPICS, GPIO.OUT)
if MCP3008.sharedClass == None:
MCP3008.sharedClass = self
#read SPI data from MCP3008 chip, 8 possible adc's (0 thru 7)
def wait_pir(DEBUG=False):
""" Loops till PIR doesn't detect something"""
# setting GPIO PINs
with open(SETTINGS) as file:
settings = json.load(file)
logging.info('Setting GPIO PINS')
GPIO.setmode(GPIO.BOARD)
GPIO.setup(settings['pir_pin_board'], GPIO.IN)
#####################
# PIR cycle
logging.info('Starting PIR waiting cycle...')
if DEBUG:
while input('insert 1 to start...') != '1':
time.sleep(0.1)
else:
while GPIO.input(settings['pir_pin_board']) is not 1:
time.sleep(0.1)
logging.info('PIR detection')
return
def init_gpio(self, rpi_settings):
"""
Initialize GPIO pin to a default value. Leds are off by default
Mute button is set as an input
:param rpi_settings: RpiSettings object
"""
# All led are off by default
if self.rpi_settings.pin_led_muted:
GPIO.setup(rpi_settings.pin_led_muted, GPIO.OUT, initial=GPIO.LOW)
if self.rpi_settings.pin_led_started:
GPIO.setup(rpi_settings.pin_led_started, GPIO.OUT, initial=GPIO.LOW)
if self.rpi_settings.pin_led_listening:
GPIO.setup(rpi_settings.pin_led_listening, GPIO.OUT, initial=GPIO.LOW)
if self.rpi_settings.pin_led_talking:
GPIO.setup(rpi_settings.pin_led_talking, GPIO.OUT, initial=GPIO.LOW)
# MUTE button
if self.rpi_settings.pin_mute_button:
GPIO.setup(rpi_settings.pin_mute_button, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(rpi_settings.pin_mute_button, GPIO.FALLING,
callback=self.switch_kalliope_mute_led,
bouncetime=500)
def _r_byte(self):
"""
Read byte from the chip.
:return: byte value
:rtype: int
"""
# data pin is now input (pull-down resistor embedded in chip)
GPIO.setup(self._data_pin, GPIO.IN)
# clock the byte from chip
byte = 0
for i in range(8):
# make a high pulse on CLK pin
GPIO.output(self._clk_pin, GPIO.HIGH)
time.sleep(self.CLK_DELAY)
GPIO.output(self._clk_pin, GPIO.LOW)
time.sleep(self.CLK_DELAY)
# chip out data on clk falling edge: store current bit into byte
bit = GPIO.input(self._data_pin)
byte |= ((2 ** i) * bit)
# return byte value
return byte
def read_soil_moist_digital(gpio_pin):
reading = False
soil_value = None
count = 0
while reading == False:
GPIO.setup(gpio_pin, GPIO.IN)
try:
soil_value = GPIO.input(gpio_pin)
except Exception as e:
print("!!! couldn't read sensor, error " + str(e))
time.sleep(1)
if not soil_value == None:
print(" The sensor " + str(gpio_pin) + " returned a value of; " + str(soil_value))
return soil_value
count = count + 1
if count >= 10:
print("Sensor failed to read ten times, giving up...")
return 'none'
def __init__(self,pinA,pinB,callback):
self.pinA = pinA
self.pinB = pinB
#self.button = button
self.callback = callback
GPIO.setmode(GPIO.BCM)
# The following lines enable the internal pull-up resistors
# on version 2 (latest) boards
GPIO.setwarnings(False)
GPIO.setup(self.pinA, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(self.pinB, GPIO.IN, pull_up_down=GPIO.PUD_UP)
#GPIO.setup(self.button, GPIO.IN, pull_up_down=GPIO.PUD_UP)
# For version 1 (old) boards comment out the above four lines
# and un-comment the following 3 lines
#GPIO.setup(self.pinA, GPIO.IN)
#GPIO.setup(self.pinB, GPIO.IN)
#GPIO.setup(self.button, GPIO.IN)
# Add event detection to the GPIO inputs
GPIO.add_event_detect(self.pinA, GPIO.FALLING, callback=self.switch_event)
GPIO.add_event_detect(self.pinB, GPIO.FALLING, callback=self.switch_event)
#GPIO.add_event_detect(self.button, GPIO.BOTH, callback=self.button_event, bouncetime=200)
return
# Call back routine called by switch events
def RCtime (PiPin):
measurement = 0
# Discharge capacitor
GPIO.setup(PiPin, GPIO.OUT)
GPIO.output(PiPin, GPIO.LOW)
time.sleep(0.1)
GPIO.setup(PiPin, GPIO.IN)
# Count loops until voltage across
# capacitor reads high on GPIO
start = time.time()
while (GPIO.input(PiPin) == GPIO.LOW):
measurement += 1
end = time.time()
# print end - start
# return measurement
return str(end - start)
# Connects the socket
def RCtime (PiPin):
measurement = 0
# Discharge capacitor
GPIO.setup(PiPin, GPIO.OUT)
GPIO.output(PiPin, GPIO.LOW)
time.sleep(0.1)
GPIO.setup(PiPin, GPIO.IN)
# Count loops until voltage across
# capacitor reads high on GPIO
start = time.time()
while (GPIO.input(PiPin) == GPIO.LOW):
measurement += 1
end = time.time()
# print end - start
# return measurement
return str(end - start)
# Main program loop
def ResetIOT_HW(cls, bMode):
"""Set Raspberry pi GPIO pins and reset RF Explorer device
Parameters:
bMode -- True if the baudrate is set to 500000bps, False to 2400bps
"""
try:
import RPi.GPIO as GPIO
#print("RPi info: " + str(GPIO.RPI_INFO)) #information about your RPi:
#print("RPi.GPio version: " + GPIO.VERSION) #version of RPi.GPIO:
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD) #refer to the pin numbers on the P1 header of the Raspberry Pi board
GPIO.setup(12, GPIO.OUT) #set /reset (pin 12) to output
GPIO.output(12, False) #set /reset (pin 12) to LOW
GPIO.setup(21, GPIO.OUT) #set GPIO2 (pin 21) to output
GPIO.output(21, bMode) #set GPIO2 (pin 21) to HIGH (for 500Kbps)
time.sleep(0.1) #wait 100ms
GPIO.output(12, True) #set /reset to HIGH
time.sleep(2.5) #wait 2.5sec
GPIO.setup(21, GPIO.IN) #set GPIO2 to input
GPIO.cleanup() #clean up GPIO channels
except RuntimeError:
print("Error importing RPi.GPIO! This is probably because you need superuser privileges. You can achieve this by using 'sudo' to run your script")
def light_sense():
count = 0
#Output on the pin for
GPIO.setup(pin_to_circuit, GPIO.OUT)
GPIO.output(pin_to_circuit, GPIO.LOW)
time.sleep(0.1)
#Change the pin back to input
GPIO.setup(pin_to_circuit, GPIO.IN)
#Count until the pin goes high
while (GPIO.input(pin_to_circuit) == GPIO.LOW):
count += 1
if (count > 3000):
led5_on()
return count
else:
led5_off()
return count
def __init__(self, clockPin, dataPin, buttonPin,
rotaryCallback, buttonCallback, rotaryType):
# persist values
self.clockPin = clockPin
self.dataPin = dataPin
self.buttonPin = buttonPin
self.rotaryCallback = rotaryCallback
self.buttonCallback = buttonCallback
self.rotaryType = rotaryType
# setup pins
if self.rotaryType == "standard":
GPIO.setup(clockPin, GPIO.IN, pull_up_down=GPIO.PUD_UP) # All pins are pull up because both
GPIO.setup(dataPin, GPIO.IN, pull_up_down=GPIO.PUD_UP) # the encoder and the button
elif self.rotaryType == "keyes":
GPIO.setup(clockPin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) # All pins are pull up because both
GPIO.setup(dataPin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) # the encoder and the button
GPIO.setup(buttonPin, GPIO.IN, pull_up_down=GPIO.PUD_UP) # will be connected to Ground
def __init__(self, button_pins, bounce_time):
# Set bounce time
self.bounce_time = bounce_time
# Set buttons
self.buttons = button_pins
# Initialize display client
self.display = False
# We don't need warnings from GPIO
GPIO.setwarnings(False)
# Set button GPIO pins as inputs and enable interrupts
for button in button_pins:
if (button_pins[button] != False):
GPIO.setup(button_pins[button], GPIO.IN, pull_up_down = GPIO.PUD_UP)
GPIO.add_event_detect(button_pins[button], GPIO.FALLING, callback=self.button_pressed, bouncetime=self.bounce_time)
# Initalize MPD
self.mpd = False
# Register MPD client to send it commands
def calibrate(self):
print("calibrating...")
self.recharge_capacitors()
# GPIO.setup(sensor_inputs, GPIO.IN)
for pin in self.sensor_inputs:
time = self.get_sensor_reading(pin)
# Get the index from the map
index = self.sensor_indices[pin]
# This is the first iteration
if (self.max_val[index] == -1):
self.max_val[index] = time.microseconds
self.min_val[index] = time.microseconds
else:
# Store the min and max values seen during calibration
if (time.microseconds > self.max_val[index]):
self.max_val[index] = time.microseconds
elif (time.microseconds < self.min_val[index]):
self.min_val[index] = time.microseconds
# Print the calculated time in microseconds
print("Pin: " + str(pin))
print(time.microseconds)
def __init__(self, dout=4, pd_sck=18, gain=128, readBits=24, offset=-96096, scale=925):
self.PD_SCK = pd_sck
self.DOUT = dout
self.readBits = readBits
self.twosComplementOffset = 1 << readBits
self.twosComplementCheck = self.twosComplementOffset >> 1
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.PD_SCK, GPIO.OUT)
GPIO.setup(self.DOUT, GPIO.IN)
self.GAIN = 0
self.set_offset(offset)
self.set_scale(scale)
self.lastVal = 0
self.set_gain(gain)
def __initGPIOs(self):
#setup GPIO using Board numbering (pins, not GPIOs)
GPIO.setwarnings(False)
GPIO.cleanup()
GPIO.setmode(GPIO.BOARD)
#setup defined pins and event_detectors or outputs and initial states (initial is always 0, low)
for pin in pins_in_use:
if pins_in_use[pin][0] == GPIO.IN:
if pin == 5:
GPIO.setup(pin, pins_in_use[pin][0], pull_up_down=GPIO.PUD_UP)
else:
GPIO.setup(pin, pins_in_use[pin][0])
GPIO.add_event_detect(pin, pins_in_use[pin][1], callback=self.shoutItOut, bouncetime=100)
self.gpio_states.update({pin: 1})
elif pins_in_use[pin][0] == GPIO.OUT:
GPIO.setup(pin, pins_in_use[pin][0], initial=0)
def __init__(self,pinA,pinB,button,callback, parent):
self.pinA = pinA
self.pinB = pinB
self.button = button
self.callback = callback
self.parent = parent
if self.pinA is not None and self.pinB is not None:
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(self.pinA, GPIO.IN)
GPIO.setup(self.pinB, GPIO.IN)
GPIO.add_event_detect(self.pinA, GPIO.FALLING,
callback=self.switch_event)
GPIO.add_event_detect(self.pinB, GPIO.FALLING,
callback=self.switch_event)
if self.button is not None:
GPIO.setup(self.button, GPIO.IN)
GPIO.add_event_detect(self.button, GPIO.BOTH,
callback=self.button_event, bouncetime=200)
return
# Call back routine called by switch events
