def GPIO_IO_TESTING():
print('== Testing GPIO INPUT/OUTPUT ==')
for mode in ['phys', 'TB', 'BCM']:
GPIO.setmode(modeMap[mode])
LPin = [pinTable[pins[0] - 1][mode] for pins in pairPins]
RPin = [pinTable[pins[1] - 1][mode] for pins in pairPins]
if (-1 in LPin or -1 in RPin):
print('Some pins use the 3.3V or GND pin.')
exit()
for IPin, OPin in [(LPin, RPin), (RPin, LPin)]:
GPIO.setup(IPin, GPIO.IN)
GPIO.setup(OPin, GPIO.OUT)
if (False in [GPIO.gpio_function(pin) == GPIO.IN for pin in IPin]
or False
in [GPIO.gpio_function(pin) == GPIO.OUT for pin in OPin]):
print('Check GPIO.gpio_function or GPIO.setup.')
exit()
for volt in [GPIO.HIGH, GPIO.LOW]:
GPIO.output(OPin, volt)
OResult = [GPIO.input(pin) == volt for pin in OPin]
IResult = [
GPIO.input(IPin[i]) == GPIO.input(OPin[i])
for i in range(len(IPin))
]
if (False in OResult):
print('Check Pin[%d].' % (OPin[OResult.index(False)]))
exit()
if (False in IResult):
print('Check Pin[%d].' % (IPin[IResult.index(False)]))
exit()
print("[PASS] GPIO.setmode(%s)" % (modeNameMap[mode]))
GPIO.cleanup()
print('===============================')
def GPIO_PULL_UPDW_TESTING():
checkPins = []
print('== Testing GPIO PULL_UP_DOWN ==')
testPin = gpioUsedPins
print("Check that nothing connects to those pins: %s" %
(','.join([str(x) for x in testPin])))
GPIO.setmode(GPIO.BOARD)
GPIO.setup(testPin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
for pin in testPin:
if (GPIO.input(pin) !=
InternalPullUpDnValue[PullUpDnPins[pin] if pin in
PullUpDnPins else GPIO.PUD_UP]):
checkPins.append(pin)
GPIO.setup(testPin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
for pin in testPin:
if (GPIO.input(pin) !=
InternalPullUpDnValue[PullUpDnPins[pin] if pin in
PullUpDnPins else GPIO.PUD_DOWN]):
checkPins.append(pin)
print("[%s] Pull Up and Down" %
('PASS' if len(checkPins) <= 0 else 'FAILED'))
if (len(checkPins) > 0):
print('Please check those pins: %s' %
(','.join([str(x) for x in checkPins])))
GPIO.cleanup()
print('===============================')
def __init__(self):
self.setPinMapping()
GPIOPort.__init__(self, max(self.pins) + 1)
self.post_value = True
self.post_function = True
self.gpio_setup = []
self.gpio_reset = []
self.gpio_map = None
self.pinFunctionSet = set()
self.valueFile = {pin:None for pin in self.pins}
self.functionFile = {pin:None for pin in self.pins}
self.callbacks = {}
self.edge_poll = select.epoll()
thread = Thread(target=self.pollEdges, daemon=True)
thread.start()
for pin in self.pins:
# Export the pins here to prevent a delay when accessing the values for the
# first time while waiting for the file group to be set
self.__checkFilesystemExport__(pin)
if gpio_library:
gpio_library.setmode(gpio_library.ASUS)
elif not Hardware().isRaspberryPi3():
# On the Pi 3 the memory mapped /dev/gpiomem file seems to give strange, inconsistent readings, like duplicated
# 4 byte sequences and "oipg" ASCII values. This might be some issue with the way Python mmap works since it didn't
# seem to happen with the wiringPi C library using uint32_t pointers. For now we just avoid using /dev/gpiomem on Pi 3.
try:
with open('/dev/gpiomem', 'rb') as gpiomem:
self.gpio_map = mmap.mmap(gpiomem.fileno(), BLOCK_SIZE, prot=mmap.PROT_READ)
except FileNotFoundError:
pass
except OSError as err:
error(err)
def __init__(self, config):
gpio.setwarnings(False)
gpio.cleanup()
gpio.setmode(gpio.BCM)
self.config = config
self.doors = [Door(n, c) for (n, c) in config['doors'].items()]
self.updateHandler = UpdateHandler(self)
for door in self.doors:
door.last_state = 'unknown'
door.last_state_time = time.time()
self.use_alerts = config['config']['use_alerts']
self.alert_type = config['alerts']['alert_type']
self.ttw = config['alerts']['time_to_wait']
if self.alert_type == 'smtp':
self.use_smtp = False
smtp_params = ("smtphost", "smtpport", "smtp_tls", "username",
"password", "to_email")
self.use_smtp = ('smtp'
in config['alerts']) and set(smtp_params) <= set(
config['alerts']['smtp'])
syslog.syslog("we are using SMTP")
elif self.alert_type == 'pushbullet':
self.pushbullet_access_token = config['alerts']['pushbullet'][
'access_token']
syslog.syslog("we are using Pushbullet")
elif self.alert_type == 'pushover':
self.pushover_user_key = config['alerts']['pushover']['user_key']
syslog.syslog("we are using Pushover")
else:
self.alert_type = None
syslog.syslog("No alerts configured")
def readLevel():
try:
GPIO.setWarnings(False)
GPIO.setmode(GPIO.BOARD)
Trigger_AusgangsPin = 7
Echo_EingangsPin = 8
GPIO.setup(Trigger_AusgangsPin, GPIO.OUT)
GPIO.setup(Echo_EingangsPin, GPIO.IN)
GPIO.output(Trigger_AusgangsPin, False)
AusschaltZeit = 0
GPIO.output(Trigger_AusgangsPin, True)
time.sleep(0.00001)
GPIO.output(Trigger_AusgangsPin, False)
EinschaltZeit = time.time()
while GPIO.input(Echo_EingangsPin) == 0:
EinschaltZeit = time.time(
) # Es wird solange die aktuelle Zeit gespeichert, bis das Signal aktiviert wird
while GPIO.input(Echo_EingangsPin) == 1:
AusschaltZeit = time.time(
) # Es wird die letzte Zeit aufgenommen, wo noch das Signal aktiv war
Dauer = AusschaltZeit - EinschaltZeit
Abstand = (Dauer * 34300) / 2
return Abstand
except:
return 0
def __init__(self):
self.setPinMapping()
GPIOPort.__init__(self, max(self.pins) + 1)
self.post_value = True
self.post_function = True
self.gpio_setup = []
self.gpio_reset = []
self.gpio_map = None
self.pinFunctionSet = set()
self.valueFile = {pin: None for pin in self.pins}
self.functionFile = {pin: None for pin in self.pins}
for pin in self.pins:
# Export the pins here to prevent a delay when accessing the values for the
# first time while waiting for the file group to be set
self.__checkFilesystemExport__(pin)
if gpio_library:
gpio_library.setmode(gpio_library.ASUS)
else:
try:
with open('/dev/gpiomem', 'rb') as gpiomem:
self.gpio_map = mmap.mmap(gpiomem.fileno(),
BLOCK_SIZE,
prot=mmap.PROT_READ)
except FileNotFoundError:
pass
except OSError as err:
error(err)
def __init__(self, dev='/dev/spidev2.0', spd=1000000):
spi.openSPI(device=dev, speed=spd)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.NRSTPD, GPIO.OUT)
GPIO.setup(18, GPIO.OUT)
GPIO.output(self.NRSTPD, 1)
self.MFRC522_Init()
def ProjectorOnOffSwitch(pin, state):
GPIO.setmode(GPIO.BOARD)
GPIO.setup(5, GPIO.OUT)
if state == 'off':
GPIO.output(5, GPIO.HIGH)
if state == 'on':
GPIO.output(5, GPIO.LOW)
return True
def setupGPIO(self):
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.DATA, GPIO.OUT)
GPIO.setup(self.SHIFT, GPIO.OUT)
GPIO.setup(self.STORE, GPIO.OUT)
GPIO.output(self.DATA, GPIO.LOW)
GPIO.output(self.SHIFT, GPIO.LOW)
GPIO.output(self.STORE, GPIO.LOW)
def __init__(self, headset):
Thread.__init__(self)
self.hs = headset
self.finish = False
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.DIAL_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(self.PULSE_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(self.HOOK_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
def glass(command):
GPIO.setmode(GPIO.BOARD)
GPIO.setup(3, GPIO.OUT)
print "in glass function", command
if command == "opaque":
GPIO.output(3, GPIO.LOW)
stm.sleep(1)
if command == "transparent":
GPIO.output(3, GPIO.HIGH)
stm.sleep(1)
return True
def servo(angle):
dutyCycle = (angle + 45) / 18 #convert degrees to duty cycle
GPIO.setmode(GPIO.ASUS)
GPIO.setwarnings(False)
servo = 32
GPIO.setup(servo, GPIO.OUT)
pwm = GPIO.PWM(servo, 50)
pwm.ChangeDutyCycle(dutyCycle)
time.sleep(1)
def _setup_sensor(self):
if self.sensor_enabled():
self._logger.info("Setting up sensor.")
if self.mode == 0:
self._logger.info("Using Board Mode")
GPIO.setmode(GPIO.BOARD)
else:
self._logger.info("Using BCM Mode")
GPIO.setmode(GPIO.BCM)
self._logger.info("Filament Sensor active on GPIO Pin [%s]"%self.pin)
GPIO.setup(self.pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
else:
self._logger.info("Pin not configured, won't work unless configured!")
def __init__(self):
rospy.init_node('l298_motorcontroller_node')
GPIO.setwarnings(False)
GPIO.setmode(GPIO.ASUS)
wheel_radius = 0.1
ticks_pr_round = 2.0
gear = 50.0
wheel_circumference = 2.0 * math.pi * wheel_radius * gear
m_pr_tick = wheel_circumference/ticks_pr_round
left_motor = SingleMotorController( 238, 185, 224, 168, m_pr_tick )
right_motor = None #SingleMotorController( 239, 223, 187, 188, m_pr_tick )
DifferentialDriveMotorController(left_motor, right_motor, 0.6)
def __init__(self, LED_OK, LED_NG, BTN_input):
""" Mamos setup"""
self.LED_OK = LED_OK
self.LED_NG = LED_NG
self.BTN_input = BTN_input
self.prev_input = False
try:
GPIO.setwarnings(False)
GPIO.setmode(GPIO.ASUS)
GPIO.setup(LED_OK, GPIO.OUT)
GPIO.setup(LED_NG, GPIO.OUT)
GPIO.setup(BTN_input, GPIO.IN, pull_up_down=GPIO.PUD_UP)
except:
pass
def cleanup():
import ASUS.GPIO as GPIO
import time
GPIO.setwarnings(False)
GPIO.setmode(GPIO.ASUS)
GPIO.setup(164, GPIO.IN)
GPIO.setup(166, GPIO.IN)
GPIO.setup(167, GPIO.IN)
time.sleep(0.5)
GPIO.setup(164, GPIO.HIGH)
GPIO.setup(166, GPIO.HIGH)
GPIO.setup(167, GPIO.HIGH)
time.sleep(0.5)
GPIO.setup(164, GPIO.LOW)
GPIO.setup(166, GPIO.LOW)
GPIO.setup(167, GPIO.LOW)
def triggerON(portNumber):
import ASUS.GPIO as GPIO
import time
GPIO.setwarnings(False)
GPIO.setmode(GPIO.ASUS)
light = portNumber
GPIO.setup(light, GPIO.OUT)
GPIO.output(light, GPIO.LOW)
try:
print("open led: {0}".format(light))
GPIO.output(light, GPIO.HIGH)
time.sleep(3)
GPIO.output(light, GPIO.LOW)
print("close led: {0}".format(light))
except KeyboardInterrupt:
GPIO.cleanup()
def __init__(self):
#GPIOs
self.led_pin = 7
self.fan_pin = 8
self.reset_pin = 3
self.power_pin = 5
self.check_pin = 10
#vars
self.fan_hysteresis = 5
self.fan_starttemp = 60
self.fan_hysteresis_pwm = 20
self.fan_starttemp_pwm = 60
self.reset_hold_short = 100
self.reset_hold_long = 500
self.debounce_time = 0.1
self.counter_time = 0.01
self.delay_until_reset = 2
self.is_pwm = False
#path
self.kintaro_folder = "/opt/KintaroSnes/"
self.start_folder = "start/"
self.intro_video = self.kintaro_folder + self.start_folder + "intro.mp4"
self.config_file = self.kintaro_folder + self.start_folder + "kintaro.config"
# self.temp_command = 'vcgencmd measure_temp'
#Set the GPIOs
GPIO.setmode(GPIO.BOARD) # Use the same layout as the pins
GPIO.setwarnings(False)
GPIO.setup(self.led_pin, GPIO.OUT) # LED Output
GPIO.setup(self.fan_pin, GPIO.OUT) # Fan normal Output
GPIO.setup(self.power_pin, GPIO.IN) # set pin as input
GPIO.setup(
self.reset_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP
) # set pin as input and switch on internal pull up resistor
GPIO.setup(self.check_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
if self.return_config_bool("PWM_FAN"):
self.is_pwm = True
self.pwm = GPIO.PWM(self.fan_pin, 50)
self.pwm.start(0)
def __init__(self, gpio_trigger, gpio_echo, range_min=10, range_max=400):
GPIO.setmode(GPIO.BCM)
self._gpio_trigger = gpio_trigger
self._gpio_echo = gpio_echo
self._range_min = range_min
self._range_max = range_max
self._is_reading = False
self._speed_sound = 17150.0 #- divided by 2 in cm/s
self._last_time_reading = 0
self._timeout = range_max / self._speed_sound * 2
GPIO.setup(gpio_trigger, GPIO.OUT)
GPIO.setup(gpio_echo, GPIO.IN)
#- Waiting for sensor to settle
GPIO.output(gpio_trigger, GPIO.LOW)
time.sleep(1)
def show():
"""Output the buffer to Blinkt!"""
global _gpio_setup
if not _gpio_setup:
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(DAT, GPIO.OUT)
GPIO.setup(CLK, GPIO.OUT)
_gpio_setup = True
_sof()
for pixel in pixels:
r, g, b, brightness = pixel
_write_byte(0b11100000 | brightness)
_write_byte(b)
_write_byte(g)
_write_byte(r)
_eof()
def GpioSetup():
GPIO.setwarnings(False) #disable warning
GPIO.setmode(GPIO.ASUS) #USE ASUS mode
GPIO.setup(encoder_sw, GPIO.IN, pull_up_down=GPIO.PUD_DOWN
) #encoder's switch input and disable pull up resistor
GPIO.setup(encoder_a, GPIO.IN) #define encoder channel A and B
GPIO.setup(encoder_b, GPIO.IN)
GPIO.add_event_detect(encoder_a, GPIO.RISING, callback=RotaryInterrupt)
GPIO.add_event_detect(encoder_b, GPIO.RISING, callback=RotaryInterrupt)
GPIO.add_event_detect(encoder_sw,
GPIO.RISING,
callback=SwitchInterrupt,
bouncetime=250)
GPIO.setup(usb_mode_sw, GPIO.OUT)
GPIO.setup(i2s_sw, GPIO.OUT)
GPIO.setup(ac_sw, GPIO.OUT)
GPIO.setup(dynalo_sw, GPIO.OUT)
GPIO.setup(relay_en, GPIO.OUT)
GPIO.setup(relay_s0, GPIO.OUT)
GPIO.setup(relay_s1, GPIO.OUT)
GPIO.setup(relay_s2, GPIO.OUT)
def __init__(self, inputs=[[0x48, 0]], rdy_pin=17):
self.inputs = inputs
self.rdy_pin = rdy_pin
self.current_input = 0
self.last_val = 0
rospy.init_node('adc_node')
GPIO.setwarnings(False)
GPIO.setmode(GPIO.ASUS)
GPIO.setup(self.rdy_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(self.rdy_pin,
GPIO.FALLING,
callback=self.reading_ready,
bouncetime=1)
self.waiting_for_ready = False
# Setup adc hi/low tresh to use for conversion ready signal
for ind in inputs:
adr = ind[0]
bus.write_i2c_block_data(adr, 0x02, [0b00000000, 0b00000000])
bus.write_i2c_block_data(adr, 0x03, [0b10000000, 0b00000000])
rospy.sleep(0.1)
self.get_next_reading()
import ASUS.GPIO as GPIO import dht11 import time import datetime # config DHT11_PIN = 5 LED_G_PIN = 8 LED_Y_PIN = 10 LED_R_PIN = 12 DETECT_INTERVAL = 5 # initialize GPIO GPIO.setwarnings(False) GPIO.setmode(GPIO.BOARD) GPIO.cleanup() GPIO.setup(LED_G_PIN, GPIO.OUT) GPIO.setup(LED_Y_PIN, GPIO.OUT) GPIO.setup(LED_R_PIN, GPIO.OUT) def resetled(): GPIO.output(LED_G_PIN, GPIO.LOW) GPIO.output(LED_Y_PIN, GPIO.LOW) GPIO.output(LED_R_PIN, GPIO.LOW) resetled() # read dht11 data
def __init__(self, debug=False):
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.cleanup()
self.piRevision = self.getPiRevision()
self.i2cbus = 1
if self.piRevision == 1:
self.i2cbus = 0
print "RPi.GPIO Version" , GPIO.VERSION
print "Board Revision" , self.piRevision
#Set some constants and initialise lists
self.numOfPins = 27 #there are actually 26 but python can't count properly :)
if self.piRevision > 2:
self.numOfPins = 41
self.PINPUT = 4
self.POUTPUT = 1
self.PPWM = 2
self.PUNUSED = 8
self.PSONAR = 16
self.PULTRA = 32
self.PSERVOD = 64
self.PSTEPPER = 128
self.PCOUNT = 256
self.PINPUTDOWN = 512
self.PINPUTNONE = 1024
self.PPWMMOTOR = 2048
self.PPWMLED = 4096
#self.INVERT = False
self.ledDim = 100
self.PWMMOTORFREQ = 10
self.dsSensorId = ""
self.senderLoopDelay = 0.2
self.mFreq = 10
self.ultraFreq = 1
self.pFreq = 200
self.pinUse = [self.PUNUSED] * self.numOfPins
self.servodPins = None
self.pinRef = [None] * self.numOfPins
self.pinCount = [0] * self.numOfPins
self.countDirection = [1] * self.numOfPins
self.pinEncoderDiff = [0] * self.numOfPins
self.encoderStopCounting = [0] * self.numOfPins
self.pinLastState = [0] * self.numOfPins
self.encoderTime = [0] * self.numOfPins
self.encoderTimeDiff = [0.0] * self.numOfPins
self.gpioLookup = [0] * self.numOfPins
self.callbackInUse = [False] * self.numOfPins
self.pinValue = [0] * self.numOfPins
self.pinInvert = [False] * self.numOfPins
#print "pinValue" , self.pinValue
#print "pin Value 3 = ", self.pinValue[3]
self.pinUltraRef = [None] * self.numOfPins
self.pinTrigger = [0] * self.numOfPins
self.pinTriggerName = ["x"] * self.numOfPins
self.anyTrigger = 0
self.pinServoValue = [None] * self.numOfPins
self.gpioMyPinEventDetected = [False] * self.numOfPins
self.pinTriggerLastState = [0] * self.numOfPins
self.encoderCallback = 0
self.piAndBash = [self.PUNUSED] * 16
self.pinEventEnabled = True
self.encoderInUse = 0
self.nunchuckLevel = 1
self.capTouch = None
self.capTouchHelper = None
self.ADS1015 = None
self.lightDirection = 0
self.lightValue = 0
self.lightInfo = False
self.autoLink = False
self.linkPrefix = None
self.validPins = [ 3, 5, 7, 8, 10,11,12,13, 15,16, 18,19, 21,22,23,24, 26]
if self.piRevision == 1:
# 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
# [ 3, 5,99,99, 7,99,99,26,24,21,19,23,99,99, 8,10,99,11,12,99,99,13,15,16,18,22,99]
self.gpioLookup = [99,99,99, 0,99, 1,99, 4,14,99,15,17,18,21,99,22,23,99,24,10,99, 9,25,11, 8,99, 7]
if self.piRevision == 2:
self.gpioLookup = [99,99,99, 2,99, 3,99, 4,14,99,15,17,18,27,99,22,23,99,24,10,99, 9,25,11, 8,99, 7]
if self.piRevision > 2:
self.validPins = [3, 5, 7, 8, 10,11,12,13, 15,16, 18,19, 21,22,23,24, 26,27,28, 29, 31,32,33, 35,36,37,38, 40]
self.gpioLookup = [99,99,99, 2,99, 3,99, 4,14,99,15,17,18,27,99,22,23,99,24,10,99, 9,25,11, 8,99, 7,99,99, 5,99, 6,12,13,99,19,16,26,20,99,21]
#self.ULTRA_IN_USE = [False] * self.PINS
#self.ultraTotalInUse = 0
#self.ultraSleep = 1.0
self.debug = debug
if self.debug:
print "sghGC Debug enabled"
import ASUS.GPIO as GPIO
import unittest
import time
GPIO.setmode(GPIO.ASUS)
GPIO.setup(252, GPIO.OUT)
pwm = GPIO.PWM(252, 50)
pwm.start(100)
while True:
for i in range(0, 3):
for x in range(0, 101, 5):
pwm.ChangeDutyCycle(x)
time.sleep(0.1)
for x in range(100, -1, -5):
pwm.ChangeDutyCycle(x)
time.sleep(0.1)
#-*-coding:utf-8-*-
import ASUS.GPIO as GPIO # Asus tinkerboard GPIO kütüphanesi eklendi
import time # time kütüphanesi eklendi
import serial # serial kütüphanesi eklendi
GPIO.setwarnings(False) # GPIO ile ilgili hatalar göz ardı edildi
GPIO.setmode(
GPIO.ASUS
) # GPIO modu GPIO.ASUS a göre seçildi (ona göre pin numaraları belirlenecek)
mz80_1 = 252 # 1. MZ80 (Dijital kızılötesi) sensörü için giriş portu belirlendi
mz80_2 = 253 # 2. MZ80 (Dijital kızılötesi) sensörü için giriş portu belirlendi
IR_analog_warn = 257 # Kızılötesi analog sensörlerin uyarı çıkışı
Ultrason_warn = 256 # Ultrasonik sensörlerin uyarı çıkışı
IR_digital_warn = 254 # Kızılötesi dijital sensörlerin uyarı çıkışı
GPIO.setup(
mz80_1,
GPIO.IN) # 1. MZ80 sensörünün çıkışı GPIO'da giriş olarak tanımlandı
GPIO.setup(
mz80_2,
GPIO.IN) # 2. MZ80 sensörünün çıkışı GPIO'da giriş olarak tanımlandı
GPIO.setup(
IR_analog_warn,
GPIO.OUT) # Kızılötesi analog sensörlerin uyarı çıkışı GPIO'da tanımlandı
GPIO.setup(
IR_digital_warn,
GPIO.OUT) # Kızılötesi dijital sensörlerin uyarı çıkışı GPIO'da tanımlandı
GPIO.setup(Ultrason_warn,
# 6 : Enable or Strobe
# 7 : Data Bit 0 - NOT USED
# 8 : Data Bit 1 - NOT USED
# 9 : Data Bit 2 - NOT USED
# 10: Data Bit 3 - NOT USED
# 11: Data Bit 4
# 12: Data Bit 5
# 13: Data Bit 6
# 14: Data Bit 7
# 15: LCD Backlight +5V**
# 16: LCD Backlight GND
#GPIO.setwarnings(False)
# Define GPIO to LCD mapping
GPIO.setmode(GPIO.BOARD) # Use BOARD GPIO numbers
class sgh_pnbLCD(object):
def __init__(self):
self.LCD_RS = 11
self.LCD_E = 12
self.LCD_D4 = 15
self.LCD_D5 = 16
self.LCD_D6 = 18
self.LCD_D7 = 22
# Define some device constants
self.LCD_WIDTH = 16 # Maximum characters per line
self.LCD_CHR = True
self.LCD_CMD = False
import ASUS.GPIO as GPIO
import os
from subprocess import call
from time import sleep
# **** Configuration **** #
GpioMode = GPIO.ASUS
MotionSensor = 257
TimeUntilDisplayOff = 10
# ****************************************** #
GPIO.setwarnings(False)
GPIO.setmode(GpioMode)
GPIO.setup(MotionSensor, GPIO.IN)
timer = TimeUntilDisplayOff
call(['xhost', '+'])
os.environ["DISPLAY"] = ":0.0"
try:
while True:
if GPIO.input(MotionSensor):
timer = TimeUntilDisplayOff
print("Setting timer to " + str(timer) + "s.")
if timer > 0:
timer -= 1
print("Timer: " + str(timer) + "s")
else:
def setUp(self):
GPIO.setmode(GPIO.BOARD)
GPIO.setup(LOOP_IN, GPIO.IN)
GPIO.setup(LOOP_OUT, GPIO.OUT)
def __init__(self):
self.m_b = Controller(24, 23, 25)
self.m_r = Controller(27, 22, 17)
GPIO.setmode(GPIO.BCM)
self.m_b.setUp()
