Python RPi.GPIO 模块，BCM 实例源码
我们从Python开源项目中，提取了以下15个代码示例，用于说明如何使用RPi.GPIO.BCM。
def __init__(self):
import RPi.GPIO as _GPIO
self.GPIO = _GPIO
self.GPIO.setwarnings(False)
self.GPIO.setmode(_GPIO.BCM)
def __init__(self, PIN, INOUT, STATUS=0):
self.Pin = PIN
self.Status = STATUS
self.InOut = INOUT
self.gpio = GPIO
self.gpio.setwarnings(False)
self.gpio.setmode(GPIO.BCM)
if self.InOut == 'OUT':
self.gpio.setup(self.Pin, self.gpio.OUT)
self.Change(self.Status)
elif self.InOut == 'IN':
self.gpio.setup(self.Pin, self.gpio.IN)
else:
raise ValueError('Could not set GPIO %d to %s direction' % (self.Pin, self.InOut))
def __init__(self, RPIN, Status=0):
self.R_PIN = RPIN
self.RStatus = Status
self.gpio = GPIO
self.gpio.setwarnings(False)
self.gpio.setmode(GPIO.BCM)
self.gpio.setup(self.R_PIN, self.gpio.OUT)
def __init__(self, cs_pin, clock_pin, data_pin, units = "c", board = GPIO.BCM):
'''Initialize Soft (Bitbang) SPI bus
Parameters:
- cs_pin: Chip Select (CS) / Slave Select (SS) pin (Any GPIO)
- clock_pin: Clock (SCLK / SCK) pin (Any GPIO)
- data_pin: Data input (SO / MOSI) pin (Any GPIO)
- units: (optional) unit of measurement to return. ("c" (default) | "k" | "f")
- board: (optional) pin numbering method as per RPi.GPIO library (GPIO.BCM (default) | GPIO.BOARD)
'''
self.cs_pin = cs_pin
self.clock_pin = clock_pin
self.data_pin = data_pin
self.units = units
self.data = None
self.board = board
# Initialize needed GPIO
GPIO.setmode(self.board)
GPIO.setup(self.cs_pin, GPIO.OUT)
GPIO.setup(self.clock_pin, GPIO.OUT)
GPIO.setup(self.data_pin, GPIO.IN)
# Pull chip select high to make chip inactive
GPIO.output(self.cs_pin, GPIO.HIGH)
def __init__(self, cs_pin, clock_pin, data_pin, units = "c", board = GPIO.BCM):
'''Initialize Soft (Bitbang) SPI bus
Parameters:
- cs_pin: Chip Select (CS) / Slave Select (SS) pin (Any GPIO)
- clock_pin: Clock (SCLK / SCK) pin (Any GPIO)
- data_pin: Data input (SO / MOSI) pin (Any GPIO)
- units: (optional) unit of measurement to return. ("c" (default) | "k" | "f")
- board: (optional) pin numbering method as per RPi.GPIO library (GPIO.BCM (default) | GPIO.BOARD)
'''
self.cs_pin = cs_pin
self.clock_pin = clock_pin
self.data_pin = data_pin
self.units = units
self.data = None
self.board = board
# Initialize needed GPIO
GPIO.setmode(self.board)
GPIO.setup(self.cs_pin, GPIO.OUT)
GPIO.setup(self.clock_pin, GPIO.OUT)
GPIO.setup(self.data_pin, GPIO.IN)
# Pull chip select high to make chip inactive
GPIO.output(self.cs_pin, GPIO.HIGH)
def __init__(self):
if gv.IS_DEBIAN:
self.thread_sleep = 0.1
else:
self.thread_sleep = 0.2
self.timeout_init = 3 # 3 sec
self.timeout_init /= self.thread_sleep # Adjust according to while loop sleep time
self.timeout = self.timeout_init
self.display_called = False
if (gv.USE_HD44780_16x2_LCD or gv.USE_HD44780_20x4_LCD) and gv.IS_DEBIAN:
import lcdcustomchars as lcdcc
import RPi.GPIO as GPIO
from RPLCD import CharLCD
self.lcd = CharLCD(pin_rs=gv.GPIO_LCD_RS, pin_rw=None, pin_e=gv.GPIO_LCD_E,
pins_data=[gv.GPIO_LCD_D4, gv.GPIO_LCD_D5, gv.GPIO_LCD_D6, gv.GPIO_LCD_D7],
numbering_mode=GPIO.BCM, cols=gv.LCD_COLS, rows=gv.LCD_ROWS)
self.lcd.create_char(1, lcdcc.block)
self.lcd.create_char(2, lcdcc.arrow_right_01)
self.lcd.create_char(3, lcdcc.voice_button_on)
self.lcd.create_char(4, lcdcc.voice_button_off)
if (gv.USE_HD44780_16x2_LCD or gv.USE_HD44780_20x4_LCD) and gv.SYSTEM_MODE == 2:
self.STRING_1 = ''
self.STRING_2 = ''
self.LCDThread = threading.Thread(target=self.lcd_main)
self.LCDThread.daemon = True
self.LCDThread.start()
# time.sleep(0.5)
# display('Start SamplerBox') # bug: the way autochorder is loaded causes issue
# time.sleep(0.5)
def __init__(self, pin_rs=25, pin_e=24, pins_db=[23, 17, 21, 22], GPIO=None):
# Emulate the old behavior of using RPi.GPIO if we haven't been given
# an explicit GPIO interface to use
if not GPIO:
import RPi.GPIO as GPIO
GPIO.setwarnings(False)
self.GPIO = GPIO
self.pin_rs = pin_rs
self.pin_e = pin_e
self.pins_db = pins_db
self.GPIO.setmode(GPIO.BCM)
self.GPIO.setup(self.pin_e, GPIO.OUT)
self.GPIO.setup(self.pin_rs, GPIO.OUT)
for pin in self.pins_db:
self.GPIO.setup(pin, GPIO.OUT)
self.write4bits(0x33) # initialization
self.write4bits(0x32) # initialization
self.write4bits(0x28) # 2 line 5x7 matrix
self.write4bits(0x0C) # turn cursor off 0x0E to enable cursor
self.write4bits(0x06) # shift cursor right
self.displaycontrol = self.LCD_DISPLAYON | self.LCD_CURSOROFF | self.LCD_BLINKOFF
self.displayfunction = self.LCD_4BITMODE | self.LCD_1LINE | self.LCD_5x8DOTS
self.displayfunction |= self.LCD_2LINE
# Initialize to default text direction (for romance languages)
self.displaymode = self.LCD_ENTRYLEFT | self.LCD_ENTRYSHIFTDECREMENT
self.write4bits(self.LCD_ENTRYMODESET | self.displaymode) # set the entry mode
self.clear()
def _gpio_get_pin(self, pin):
if (GPIO.getmode() == GPIO.BOARD and self.GPIOMode == 'BOARD') or (GPIO.getmode() == GPIO.BCM and self.GPIOMode == 'BCM'):
return pin
elif GPIO.getmode() == GPIO.BOARD and self.GPIOMode == 'BCM':
return self._gpio_bcm_to_board(pin)
elif GPIO.getmode() == GPIO.BCM and self.GPIOMode == 'BOARD':
return self._gpio_board_to_bcm(pin)
else:
return 0
def __init__(self, pin_rs=27, pin_e=22, pins_db=[25, 24, 23, 18], GPIO = None):
# Emulate the old behavior of using RPi.GPIO if we haven't been given
# an explicit GPIO interface to use
if not GPIO:
import RPi.GPIO as GPIO
self.GPIO = GPIO
self.pin_rs = pin_rs
self.pin_e = pin_e
self.pins_db = pins_db
self.used_gpio = self.pins_db[:]
self.used_gpio.append(pin_e)
self.used_gpio.append(pin_rs)
self.GPIO.setwarnings(False)
self.GPIO.setmode(GPIO.BCM)
self.GPIO.setup(self.pin_e, GPIO.OUT)
self.GPIO.setup(self.pin_rs, GPIO.OUT)
for pin in self.pins_db:
self.GPIO.setup(pin, GPIO.OUT)
self.write4bits(0x33) # initialization
self.write4bits(0x32) # initialization
self.write4bits(0x28) # 2 line 5x7 matrix
self.write4bits(0x0C) # turn cursor off 0x0E to enable cursor
self.write4bits(0x06) # shift cursor right
self.displaycontrol = self.LCD_DISPLAYON | self.LCD_CURSOROFF | self.LCD_BLINKOFF
self.displayfunction = self.LCD_4BITMODE | self.LCD_1LINE | self.LCD_5x8DOTS
self.displayfunction |= self.LCD_2LINE
""" Initialize to default text direction (for romance languages) """
self.displaymode = self.LCD_ENTRYLEFT | self.LCD_ENTRYSHIFTDECREMENT
self.write4bits(self.LCD_ENTRYMODESET | self.displaymode) # set the entry mode
self.clear()
def __init__(self, dir_pin, step_pin, enable_pin=None, pin_mode=GPIO.BCM,
ms1_pin=None, ms2_pin=None, ms3_pin=None):
super().__init__(dir_pin, step_pin, enable_pin, pin_mode)
self.ms3_pin = ms3_pin
self.ms2_pin = ms2_pin
self.ms1_pin = ms1_pin
def __init__(self, dir_pin, step_pin, enable_pin=None, pin_mode=GPIO.BCM):
super().__init__(pin_mode=pin_mode)
# Pins
self._dir_pin = dir_pin
self._step_pin = step_pin
self._enable_pin = enable_pin
def __init__(self, spi, dir_pin, step_pin, pin_mode=GPIO.BCM, current=300, resistor=150):
"""
Arguments
dir_pin - the pin where the direction pin is connected
step_pin - the pin where the step pin is connected
current - chopper current in milliamps
resistor - sense resistor value
"""
super().__init__(dir_pin=dir_pin, step_pin=step_pin, pin_mode=pin_mode)
self._microsteps = 1
self._spi = spi
# store the current and sense resistor value for later use
self._resistor = resistor
# we are not started yet
self._started = False
# by default cool step is not enabled
self._cool_step_enabled = False
# Holds the last result read from the spi bus
self._driver_status_result = None
# setting the default register values
# self.driver_control_register_value = set_bit(REGISTERS['DRIVER_CONTROL_REGISTER'], INITIAL_MICROSTEPPING)
# self._microsteps = (1 << INITIAL_MICROSTEPPING)
# self.chopper_config_register = REGISTERS['CHOPPER_CONFIG_REGISTER']
# self.cool_step_register_value = REGISTERS['COOL_STEP_REGISTER']
# self.stall_guard2_current_register_value = REGISTERS['STALL_GUARD2_LOAD_MEASURE_REGISTER']
# self.driver_configuration_register_value = set_bit(REGISTERS['DRIVER_CONFIG_REGISTER'], DRIVER_CONTROL_REGISTER['READ_STALL_GUARD_READING'])
# self.driver_control_register = DriverControlRegister()
# self.chopper_config_register = ChopperControllRegister()
# self.cool_step_register = CoolStepControlRegister()
# self.stall_guard2_register = StallGuard2ControlRegister()
# self.driver_config_register = DriverConfigRegister()
self._registers = {
DriverControlRegister: DriverControlRegister(),
ChopperControllRegister: ChopperControllRegister(),
CoolStepControlRegister: CoolStepControlRegister(),
StallGuard2ControlRegister: StallGuard2ControlRegister(),
DriverConfigRegister: DriverConfigRegister()
}
def __init__(self, pin_mode=GPIO.BCM, microsteps=1):
# Minimum stepper driver pulse width in microseconds.
# This is how long logic voltage will be applied to the STEP pin.
self._pulse_width_us = 2
# GPIO pin mode
self._pin_mode = pin_mode
# Microstep resolution
self._microsteps = microsteps
# Maximum speed limit
self._max_speed = None
def __init__(self):
if gv.SYSTEM_MODE == 1 and (gv.USE_HD44780_16x2_LCD or gv.USE_HD44780_20x4_LCD):
# Timing constants
self.E_PULSE = 0.0005
self.E_DELAY = 0.0005
self.display_called = False
self.temp_display = False
if gv.IS_DEBIAN:
self.thread_sleep = 0.05
else:
self.thread_sleep = 0.1
self.timeout_init = 2 # default timeout reset time
self.timeout_length = self.timeout_init # initial timeout length (timeout_custom will override)
self.STRING_1 = ''
self.STRING_2 = ''
self.STRING_3 = ''
self.STRING_4 = ''
self.STRING_1_PRIORITY = ''
self.STRING_2_PRIORITY = ''
self.STRING_3_PRIORITY = ''
self.STRING_4_PRIORITY = ''
self.loop_alive = True
if gv.IS_DEBIAN:
import RPi.GPIO as GPIO
from RPLCD import CursorMode
from RPLCD import CharLCD
self.lcd = CharLCD(pin_rs=gv.GPIO_LCD_RS, pin_rw=None, pin_e=gv.GPIO_LCD_E,
pins_data=[gv.GPIO_LCD_D4, gv.GPIO_LCD_D5, gv.GPIO_LCD_D6, gv.GPIO_LCD_D7],
numbering_mode=GPIO.BCM, cols=gv.LCD_COLS, rows=gv.LCD_ROWS, charmap='A00')
self.lcd.clear()
# Hide the cursor
self.lcd._set_cursor_mode(CursorMode.hide)
# Fill the display with blank spaces
for i in xrange(1, gv.LCD_ROWS+1):
self.lcd_string(' ', i)
# Write custom codes to the LCD
self.lcd.create_char(1, lcdcc.block)
self.lcd.create_char(2, lcdcc.pause)
self.lcd.create_char(3, lcdcc.voice_button_on)
self.lcd.create_char(4, lcdcc.voice_button_off)
self.lcd.create_char(5, lcdcc.block2)
self.lcd.create_char(6, lcdcc.loading_hour_glass)
self.LCDThread = threading.Thread(target=self.lcd_main)
self.LCDThread.daemon = True
self.LCDThread.start()
def _configure_gpio(self):
if not self._hasGPIO:
self._logger.error("RPi.GPIO is required.")
return
self._logger.info("Running RPi.GPIO version %s" % GPIO.VERSION)
if GPIO.VERSION < "0.6":
self._logger.error("RPi.GPIO version 0.6.0 or greater required.")
GPIO.setwarnings(False)
for pin in self._configuredGPIOPins:
self._logger.debug("Cleaning up pin %s" % pin)
try:
GPIO.cleanup(self._gpio_get_pin(pin))
except (RuntimeError, ValueError) as e:
self._logger.error(e)
self._configuredGPIOPins = []
if GPIO.getmode() is None:
if self.GPIOMode == 'BOARD':
GPIO.setmode(GPIO.BOARD)
elif self.GPIOMode == 'BCM':
GPIO.setmode(GPIO.BCM)
else:
return
if self.sensingMethod == 'GPIO':
self._logger.info("Using GPIO sensing to determine PSU on/off state.")
self._logger.info("Configuring GPIO for pin %s" % self.senseGPIOPin)
if self.senseGPIOPinPUD == 'PULL_UP':
pudsenseGPIOPin = GPIO.PUD_UP
elif self.senseGPIOPinPUD == 'PULL_DOWN':
pudsenseGPIOPin = GPIO.PUD_DOWN
else:
pudsenseGPIOPin = GPIO.PUD_OFF
try:
GPIO.setup(self._gpio_get_pin(self.senseGPIOPin), GPIO.IN, pull_up_down=pudsenseGPIOPin)
self._configuredGPIOPins.append(self.senseGPIOPin)
except (RuntimeError, ValueError) as e:
self._logger.error(e)
if self.switchingMethod == 'GPIO':
self._logger.info("Using GPIO for On/Off")
self._logger.info("Configuring GPIO for pin %s" % self.onoffGPIOPin)
try:
if not self.invertonoffGPIOPin:
initial_pin_output=GPIO.LOW
else:
initial_pin_output=GPIO.HIGH
GPIO.setup(self._gpio_get_pin(self.onoffGPIOPin), GPIO.OUT, initial=initial_pin_output)
self._configuredGPIOPins.append(self.onoffGPIOPin)
except (RuntimeError, ValueError) as e:
self._logger.error(e)