def show():
"""Output the buffer"""
global _gpio_setup
if not _gpio_setup:
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup([DAT,CLK,CS],GPIO.OUT)
_gpio_setup = True
GPIO.output(CS, 0)
_sof()
for pixel in pixels:
r, g, b, brightness = pixel
_write_byte(0b11100000 | brightness)
_write_byte(b)
_write_byte(g)
_write_byte(r)
_eof()
GPIO.output(CS, 1)
python类setmode()的实例源码
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
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 __init__(self):
print('init robot gpio')
# set up hardware
gpio.setmode(gpio.BOARD) # use pin numbers not gpio numbers
# wheels ( 4 wheel motors )
self.reverse_left = 38
self.reverse_right = 35
self.forward_left = 40
self.forward_right = 37
gpio.setup(self.reverse_left, gpio.OUT)
gpio.setup(self.forward_left, gpio.OUT)
gpio.setup(self.forward_right, gpio.OUT)
gpio.setup(self.reverse_right, gpio.OUT)
self.wheel_pulse = 0.2
#self.actions = ['forward', 'reverse', 'turn_left', 'turn_right', 'hard_left', 'hard_right']
self.actions = ['forward', 'reverse', 'hard_left', 'hard_right']
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 __init__(self, dev='/dev/spidev0.0', speed=1000000, pin_rst=22, pin_ce=0):
self.pin_rst = pin_rst
self.pin_ce = pin_ce
SPI.openSPI(device=dev, speed=speed)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(pin_rst, GPIO.OUT)
GPIO.output(pin_rst, 1)
if pin_ce != 0:
GPIO.setup(pin_ce, GPIO.OUT)
GPIO.output(pin_ce, 1)
self.reset()
self.dev_write(0x2A, 0x8D)
self.dev_write(0x2B, 0x3E)
self.dev_write(0x2D, 30)
self.dev_write(0x2C, 0)
self.dev_write(0x15, 0x40)
self.dev_write(0x11, 0x3D)
self.set_antenna(True)
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 init(self,bitrate,SDAPIN,SCLPIN):
if(SDAPIN != SCLPIN):
self.SCL = SCLPIN
self.SDA = SDAPIN
else:
print "SDA = GPIO"+str(self.SDA)+" SCL = GPIO"+str(self.SCL)
#configer SCL as output
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(self.SCL, GPIO.OUT)
GPIO.setup(self.SDA, GPIO.OUT)
GPIO.output(self.SDA, GPIO.HIGH)
GPIO.output(self.SCL, GPIO.HIGH)
if bitrate == 100:
self.int_clk = 0.0000025
elif bitrate == 400:
self.int_clk = 0.000000625
elif bitrate == 1000:
self.int_clk = 1
elif bitrate == 3200:
self.int_clk = 1
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, channel, invert=False):
from navio import adafruit_pwm_servo_driver as pwm
from navio import util
import RPi.GPIO as GPIO
util.check_apm()
#Navio+ requires the GPIO line 27 to be set to low
#before the PCA9685 is accesed
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(27, GPIO.OUT)
GPIO.output(27,GPIO.LOW)
#GPIO.cleanup()
self.frequency = 60
self.channel = channel
self.invert = invert
self.pwm = pwm.PWM()
self.pwm.setPWMFreq(self.frequency)
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 __init__(self):
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.dir_pin, GPIO.OUT)
GPIO.setup(self.pulse_pin, GPIO.OUT)
GPIO.setup(self.ms1_pin, GPIO.OUT)
GPIO.setup(self.ms2_pin, GPIO.OUT)
GPIO.setup(self.sleep_pin, GPIO.OUT)
GPIO.setup(self.reset_pin, GPIO.OUT)
dir=False
GPIO.output(self.dir_pin, dir)
GPIO.output(self.pulse_pin, False)
GPIO.output(self.ms1_pin, True)
GPIO.output(self.ms2_pin, False)
GPIO.output(self.sleep_pin, False)
GPIO.output(self.reset_pin, True)
self.p1 = GPIO.PWM(self.pulse_pin, self.pulse_freq)
def main():
import RPi.GPIO as GPIO
try:
print('UNKNOWN:%d' % GPIO.UNKNOWN)
print('SERIAL:%d' % GPIO.SERIAL)
print('SPI:%d' % GPIO.SPI)
print('I2C:%d' % GPIO.I2C)
print('HARD_PWM:%d' % GPIO.HARD_PWM)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(3, GPIO.OUT)
for pin in range(1, 41):
try:
print('%02d: %d' % (pin, GPIO.gpio_function(pin)))
except ValueError as ex:
print(ex)
finally:
GPIO.cleanup()
def main():
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(12, GPIO.OUT)
p = GPIO.PWM(12, 50)
try:
p.start(0)
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)
finally:
p.stop()
GPIO.cleanup()
sample_custom_ui_launcher.py 文件源码
项目：raspberry-gpio-emulator
作者: nosix
项目源码
文件源码
阅读 21
收藏 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, left_p=13, right_p=15, forward_p=12, backward_p=11,
apply_time=0.3, wait_time=0):
self.left_p = left_p
self.right_p = right_p
self.forward_p = forward_p
self.backward_p = backward_p
self.apply_time = apply_time
self.wait_time = wait_time
print("Setting up GPIO pins.")
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.backward_p, GPIO.OUT) # Backwards.
GPIO.setup(self.forward_p, GPIO.OUT) # Forwards.
GPIO.setup(self.left_p, GPIO.OUT) # Left.
GPIO.setup(self.right_p, GPIO.OUT) # Right.
# Reset in case they're still on from before.
GPIO.output(self.backward_p, 0)
GPIO.output(self.forward_p, 0)
GPIO.output(self.left_p, 0)
GPIO.output(self.right_p, 0)
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__(self, rpi_settings=None, callback=None):
"""
Class used to:
- manage RPI GPIO
- thread to catch mute button signal
The object receive a rpi settings object which contains pin number to use on the Rpi
When a signal is caught form the mute button, the callback method from the main controller is called
:param rpi_settings: Settings object with GPIO pin number to use
:type rpi_settings: RpiSettings
:param callback: Callback function from the main controller to call when the mute button is pressed
"""
super(RpiUtils, self).__init__()
GPIO.setmode(GPIO.BCM) # Use GPIO name
GPIO.setwarnings(False)
self.rpi_settings = rpi_settings
self.callback = callback
self.init_gpio(self.rpi_settings)
def __init__(self, clk_pin=11, data_pin=13, ce_pin=15):
# init GPIO
# no warnings
GPIO.setwarnings(False)
# use safer pin number (avoid GPIO renumber on each Pi release)
GPIO.setmode(GPIO.BOARD)
# set GPIO pins
self._clk_pin = clk_pin
self._data_pin = data_pin
self._ce_pin = ce_pin
# CLK and CE (sometime call RST) pin are always output
GPIO.setup(self._clk_pin, GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(self._ce_pin, GPIO.OUT, initial=GPIO.LOW)
# turn off WP (write protect)
self._start_tx()
self._w_byte(0x8e)
self._w_byte(0x00)
self._end_tx()
# charge mode is disabled
self._start_tx()
self._w_byte(0x90)
self._w_byte(0x00)
self._end_tx()
def __init__(self, dev='/dev/spidev0.0', speed=1000000, pin_rst=22, pin_ce=0):
self.pin_rst = pin_rst
self.pin_ce = pin_ce
SPI.openSPI(device=dev, speed=speed)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(pin_rst, GPIO.OUT)
GPIO.output(pin_rst, 1)
if pin_ce != 0:
GPIO.setup(pin_ce, GPIO.OUT)
GPIO.output(pin_ce, 1)
self.reset()
self.dev_write(0x2A, 0x8D)
self.dev_write(0x2B, 0x3E)
self.dev_write(0x2D, 30)
self.dev_write(0x2C, 0)
self.dev_write(0x15, 0x40)
self.dev_write(0x11, 0x3D)
self.set_antenna(True)
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 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 _setup_pin(self, pin):
self._logger.debug(u"_setup_pin(%s)" % (pin,))
if pin:
p = None
if self._pigpiod is None:
self._pigpiod = pigpio.pi()
if self._settings.get_boolean(['pigpiod']):
if not self._pigpiod.connected:
self._logger.error(u"Unable to communicate with PiGPIOd")
else:
p = PiGPIOpin(self._pigpiod, pin, self._logger)
else:
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(pin, GPIO.OUT)
GPIO.output(pin, GPIO.HIGH)
p = GPIO.PWM(pin, 100)
p.start(100)
return p
def __init__(self, direction_channel, pwm=None, offset=True):
'''Init a motor on giving dir. channel and PWM channel.'''
if self._DEBUG:
print self._DEBUG_INFO, "Debug on"
self.direction_channel = direction_channel
self._pwm = pwm
self._offset = offset
self.forward_offset = self._offset
self.backward_offset = not self.forward_offset
self._speed = 0
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
if self._DEBUG:
print self._DEBUG_INFO, 'setup motor direction channel at', direction_channel
print self._DEBUG_INFO, 'setup motor pwm channel as', self._pwm.__name__
GPIO.setup(self.direction_channel, GPIO.OUT)
def __init__(self, logger, d = 20, motor_setup = 0, motor_driver = 1,\
pid = 1, reset = 1, r = 10):
self.logger = logger
GPIO.setmode(GPIO.BCM)
self.GPIO = GPIO
self.motor_controller = motor_setup
self.motor_driver = motor_driver
if motor_driver == gpio:
self.driver = motor_drivers.ada_motor_driver(GPIO, logger)
elif motor_driver == i2c:
self.driver = motor_drivers.i2c_motor_driver(logger)
if motor_setup == mecanum:
self.controller = motor_controllers.mecanum(logger)
if motor_driver == i2c:
self.driver.init_module(pid,reset,4)
elif motor_setup == differential:
self.controller = motor_controllers.differential(d)
if motor_driver == i2c:
self.driver.init_module(pid,reset,2)
#TODO: write motor_setup == omni
#TODO: fix wiringpi
# wiringpi.wiringPiSetup()
# wiringpi.pinMode(1, 2)
