def exit(self):
# Reinitialize all rows and columns as input at exit
for i in range(len(self.ROWS)):
DigitalInputDevice(self.ROWS[i], pull_up=True)
# GPIO.setup(self.ROW[i], GPIO.IN, pull_up_down=GPIO.PUD_UP)
for j in range(len(self.COLUMNS)):
DigitalInputDevice(self.COLUMNS[j], pull_up=True)
def get_pressed(self):
# don't want to reactivate this function, within this function:
for obj in self._col_objects:
obj.when_activated = None
# have to close outputs to make them tristates
for obj in self._row_objects:
obj.close()
row_tristates = [
DigitalInputDevice(pin, pull_up=None, active_state=True)
for pin in self.row_pins
]
# store the keypresses in pressed_keys
pressed_keys = []
for row, pin in enumerate(self.row_pins):
row_tristates[row].close()
output = DigitalOutputDevice(pin)
for col, obj in enumerate(self._col_objects):
if obj.is_active:
pressed_keys.append(self.keymap[row][col])
output.close()
row_tristates[row] = DigitalInputDevice(pin,
pull_up=None,
active_state=True)
# cleanup
for obj in row_tristates:
obj.close()
self._reset_internal_objects()
return pressed_keys
def __init__(self, clockPin, dataPin):
for pin in (clockPin, dataPin):
assert isinstance(pin, int), 'Must be int'
self.alive = True
self.clock = DigitalInputDevice(clockPin)
self.data = DigitalInputDevice(dataPin)
self.last = None
def __init__(self,
clockPin,
dataPin,
switchPin=None,
rotaryCallback=None,
switchCallback=None,
rotaryBouncetime=0.050,
switchBouncetime=0.050):
# persist values
self.clockPin = DigitalInputDevice(clockPin,
pull_up=False,
bounce_time=rotaryBouncetime)
self.dataPin = DigitalInputDevice(dataPin,
pull_up=False,
bounce_time=rotaryBouncetime)
if None != switchPin:
self.switchPin = DigitalInputDevice(switchPin,
pull_up=False,
bounce_time=switchBouncetime)
else:
self.switchPin = None
self.rotaryCallback = rotaryCallback
self.switchCallback = switchCallback
self.rotaryBouncetime = rotaryBouncetime
self.switchBouncetime = switchBouncetime
# handle falling edge is a change to closed
# http://henrysbench.capnfatz.com/henrys-bench/arduino-sensors-and-input/keyes-ky-040-arduino-rotary-encoder-user-manual/
self.clockPin.pin.edges = "falling"
self.dataPin.pin.edges = "falling"
self.switchPin.pin.edges = "falling"
def __init__(self, pin_a, pin_b, pull_up=False):
"""
Uses for detect rotary encoder changes (set when_rotated attribute)
It takes one parameter which is +1 or +2 for clockwise and -1 or -2 for counterclockwise.
:param int pin_a:
Pin number of first (left) pin.
:param int pin_b:
Pin number of last (right) pin.
:param bool pull_up:
The common contact (middle) should be NOT connected to ground?
"""
self.gpio_a = DigitalInputDevice(pin=pin_a, pull_up=pull_up)
self.gpio_b = DigitalInputDevice(pin=pin_b, pull_up=pull_up)
self.gpio_a.when_activated = self.pulse
self.gpio_a.when_deactivated = self.pulse
self.gpio_b.when_activated = self.pulse
self.gpio_b.when_deactivated = self.pulse
self.old_a_value = self.gpio_a.is_active
self.old_b_value = self.gpio_b.is_active
self.table_values = TableValues()
def __init__(self, motor_forward, motor_backward, open_sensor,
close_sensor, max_time_open=60, max_time_close=45):
self.max_time_open = max_time_open
self.max_time_close = max_time_close
self.motor = Motor(motor_forward, motor_backward)
self.open_sensor = DigitalInputDevice(open_sensor)
self.close_sensor = DigitalInputDevice(close_sensor)
self.determine_state()
def __init__(self):
self._value1 = 0
self._value2 = 0
self._pump = DigitalOutputDevice(17) # GPIO 17
self._sensor1 = DigitalInputDevice(27) # GPIO 27
self._sensor2 = DigitalInputDevice(22) # GPIO 22
self._verification_delay = VERIFICATION_DELAY_PUMP_OFF # default pump off
self._last_pump_on_time = None
self._last_pump_off_time = None
def limit_refresh(self):
left = DigitalInputDevice(6)
right = DigitalInputDevice(13)
up = DigitalInputDevice(26)
down = DigitalInputDevice(19)
while True:
self.left_limit = left.value
self.right_limit = right.value
self.up_limit = up.value
self.down_limit = down.value
sleep(0.01)
def get_key(self):
# Set all columns as output low
for j in range(len(self.COLUMNS)):
DigitalOutputDevice(self.COLUMNS[j], active_high=False)
# GPIO.setup(self.COLUMNS[j], GPIO.OUT)
# GPIO.output(self.COLUMNS[j], GPIO.LOW)
# Set all rows as input
for i in range(len(self.ROWS)):
DigitalInputDevice(self.ROWS[i], pull_up=True)
# GPIO.setup(self.ROW[i], GPIO.IN, pull_up_down=GPIO.PUD_UP)
# Scan rows for pushed key/button
# A valid key press should set "row_val" between 0 and 3.
row_val = -1
for i in range(len(self.ROWS)):
# tmpRead = GPIO.input(self.ROWS[i])
tmp_read = DigitalInputDevice(self.ROWS[i]).is_active
if tmp_read == 0:
row_val = i
# if row_val is not 0 through 3 then no button was pressed and we can exit
if row_val < 0 or row_val > 3:
self.exit()
return
# Convert columns to input
for j in range(len(self.COLUMNS)):
# GPIO.setup(self.COLUMN[j], GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
DigitalInputDevice(self.COLUMNS[j], pull_up=True)
# Switch the i-th row found from scan to output
DigitalOutputDevice(self.ROWS[row_val], active_high=True)
# GPIO.setup(self.ROW[row_val], GPIO.OUT)
# GPIO.output(self.ROW[row_val], GPIO.HIGH)
# Scan columns for still-pushed key/button
# A valid key press should set "col_val" between 0 and 2.
col_val = -1
for j in range(len(self.COLUMNS)):
tmp_read = DigitalOutputDevice(self.COLUMNS[j]).is_active
# tmpRead = GPIO.input(self.COLUMN[j])
if tmp_read == 1:
col_val = j
# if col_val is not 0 thru 2 then no button was pressed and we can exit
if col_val < 0 or col_val > 2:
self.exit()
return
# Return the value of the key pressed
self.exit()
return self.KEYPAD[row_val][col_val]
def __init__(self, pin_a, pin_b, pull_up=True):
self.when_rotated = lambda *args: None
self.pin_a = DigitalInputDevice(pin=pin_a, pull_up=pull_up)
self.pin_b = DigitalInputDevice(pin=pin_b, pull_up=pull_up)
self.pin_a.when_activated = self._pulse
self.pin_a.when_deactivated = self._pulse
self.pin_b.when_activated = self._pulse
self.pin_b.when_deactivated = self._pulse
self._old_a_value = self.pin_a.is_active
self._old_b_value = self.pin_b.is_active
def __init__(self):
#set default
self.left = DigitalInputDevice(17)
self.mid = DigitalInputDevice(27)
self.right = DigitalInputDevice(22)
#ROS publisher
self.linePub = rospy.Publisher('lines', lines, queue_size=10)
rospy.init_node('lines', anonymous=True)
#this rate will drive the serial read rate
self.rate = rospy.Rate(20)
def wait_dup_ready(self):
"""
Function waits for DUP to indicate that it is ready. The DUP will
pulls DD line low when it is ready. Requires DD to be input when
function is called.
Return:
Returns 0 if function timed out waiting for DD line to go low
Returns 1 when DUP has indicated it is ready.
"""
count = 0
dev_dd = DigitalOutputDevice(pin=self.pin_dd)
dev_dd.on()
dev_dd.close()
self._wait()
dev_dd = DigitalInputDevice(pin=self.pin_dd)
while ((dev_dd.value == 1) and count < 16):
# Clock out 8 bits before checking if DD is low again
for _ in range(8):
self.dev_dc.on()
self._wait()
self.dev_dc.off()
self._wait()
count += 1
dev_dd.close()
if count == 16:
raise FlashError("Timeout for wait dup read")
def _read_debug_byte(self) -> int:
"""
Reads a byte from the debug interface. Requires DD to be
input when function is called.
Return
Returns the byte read.
"""
data = 0
dev_dd = DigitalInputDevice(pin=self.pin_dd)
for _ in range(8):
self.dev_dc.on()
data = data << 1
if dev_dd.value == 1:
data |= 0x01
self.dev_dc.off()
self._wait()
dev_dd.close()
return data
def __init__(self):
super().__init__()
self.logger = logging.getLogger(
'rpiplatesrecognition_client.RPIMotionSensor')
self.input_device = DigitalInputDevice(self.current_gpio_pin_number,
pull_up=False,
bounce_time=1)
def __init__(self):
path = pathlib.Path(__file__).parent
with open(path / 'event_multicast.yaml') as file:
self.config_data = yaml.load(file, Loader=yaml.FullLoader)
# self.auth=(self.config_data['user'],self.config_data['password'])
signal_pin = int(self.config_data.get('gpio_pin'))
self.button = DigitalInputDevice(signal_pin)
self.button.when_activated = self.prepare_action
self.button.when_deactivated = self.release_action
self.bounce_ts = 0
self.bounce_avoid = 1000
self.bounce_last = None
self.state = 0
self.addrinfo = socket.getaddrinfo(self.config_data.get('mgroup'),
None)[0]
self.s = socket.socket(self.addrinfo[0], socket.SOCK_DGRAM)
# Set Time-to-live (optional)
ttl_bin = struct.pack('@i', self.config_data.get('mttl'))
self.s.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, ttl_bin)
def setup():
encoder_a = DigitalInputDevice(12)
while True:
encoder_a.wait_for_active()
print('ON!')
encoder_a.wait_for_inactive()
print('OFF!')
def __init__(self, in1, in2, in3):
self.direction = OutputDevice(in1, initial_value=True) # direction Pin
self.speed = PWMOutputDevice(in2, initial_value=1,
frequency=980) # speed Pin
self.encoder = DigitalInputDevice(in3)
#self.encoder = SmoothedInputDevice(in3, threshold=0.01, partial=True)
self.total_time = 1.0 / (self.speed.frequency / 2.0)
def __init__(self, pin, label, level, activated_callback,
deactivated_callback):
'''
The parameters include two optional callback functions, one when
the bumper is activated, another when deactivated.
'''
self._log = Logger("bumper:" + label, level)
self._log.debug('initialising bumper:{} on pin {}...'.format(
label, pin))
self._enabled = False
if activated_callback is None:
self._log.error("no activated_callback argument provided.")
if deactivated_callback is None:
self._log.error("no deactivated_callback argument provided.")
self._pin = pin
self._label = label
self._sensor = DigitalInputDevice(pin,
bounce_time=BOUNCE_TIME_SEC,
pull_up=True)
self._activated_callback = activated_callback
self._deactivated_callback = deactivated_callback
self._sensor.when_activated = self._activated
self._sensor.when_deactivated = self._deactivated
self._wait_for_inactive = True
self._log.info('bumper on pin {} ready.'.format(label, pin))
def __init__(self, address=0x5b, bus_index=1):
# Initialisation definitions
self.bus = self.bus_init(bus_index)
self.address = address
# Register definitions
self.STATUS = 0x00
self.MODE = 0x01
self.RESULT = 0x02
self.ERROR = 0xE0
self.APP_VERIFY = 0xF3
self.APP_START = 0xF4
self.RESET = 0xFF
self.RESET_SEQUENCE = [0x11, 0xE5, 0x72, 0x8A]
# Mode definitions
self.MODE_0 = 0x00
self.MODE_1 = 0x10
self.MODE_2 = 0x20
self.MODE_3 = 0x30
self.MODE_4 = 0x40
self.INTERRUPT = 0x08
self.THRESHOLD = 0x04
# Valid range definitions
self.co2_min = 400
self.co2_max = 8192
self.tvoc_min = 0
self.tvoc_max = 1187
# Other definitions
self.max_retrial_num = 5
self.interrupt = DigitalInputDevice(18)
def __init__(self, pin):
self._value = 0
# setup gpiozero to call increment on each when_activated
self.encoder = DigitalInputDevice(pin)
self.encoder.when_activated = self._increment
self.encoder.when_deactivated = self._increment
def __init__(self, pin):
self._value = 0
#GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
#GPIO.add_event_detect(pin, GPIO.FALLING, callback=self._increment, bouncetime=10)
encoder = DigitalInputDevice(pin, pull_up=True)
encoder.when_activated = self._increment
encoder.when_deactivated = self._increment
async def parent():
alert_ready = DigitalInputDevice(ALERT_READY_PIN, pull_up=True)
bus = smbus.SMBus(DEVICE_BUS)
adc = ADS1015(bus, DEVICE_ADDRESS, alert_ready, channel=0)
async with trio.open_nursery() as nursery:
current_system = CurrentMeasure(nursery, adc, channel=2, notification_callbacks=[process_data])
nursery.start_soon(current_system.a_run_notification_loop)
def __init__(self):
self.rstPin = DigitalOutputDevice(self.PIN_NODE_RST)
self.btnPin = DigitalInputDevice(self.PIN_START_BTN)
self.outPin = DigitalOutputDevice(self.PIN_EXIT_EN, active_high=False)
self.snakeOnPin = DigitalOutputDevice(self.PIN_SNAKE_EN,
active_high=False)
#self.outPin.source = self.btnPin.values
return
def button_refresh(self):
b_out = DigitalInputDevice(27)
b_in = DigitalInputDevice(17)
bin_pre = 0
bout_pre = 0
while True:
bin_now = b_in.value
bout_now = b_out.value
sleep(0.01)
bin_now2 = b_in.value
bout_now2 = b_out.value
#sleep(0.01)
#bin_now3 = b_in.value
#bout_now3 = b_out.value
#sleep(0.01)
#bin_now4 = b_in.value
#bout_now4 = b_out.value
#sleep(0.01)
#bin_now5 = b_in.value
#bout_now5 = b_out.value
#if bin_now and bin_now2 and bin_now3 and bin_now4 and bin_now5:
if bin_now and bin_now2:
bin_now = 1
else:
bin_now = 0
if bout_now and bout_now2:
bout_now = 1
else:
bout_now = 0
if bin_now and not bin_pre:
print('power on ppp')
poweron_p()
elif bout_now and not bout_pre:
print('power on nnn')
poweron_n()
elif not any([bin_now, bout_now]) and any([bin_pre, bout_pre]):
sleep(0.1)
print('poweroff')
poweroff()
else:
pass
bin_pre = bin_now
bout_pre = bout_now
sleep(0.3)
def returnResults(self):
radar = DigitalInputDevice(self.__pin, pull_up=False, bounce_time=2.0)
if(radar.when_activated):
r = 1
return r
else:
r = 0
return r
def __init__(self):
self.adc = spidev.SpiDev()
self.pin_reset = DigitalOutputDevice(18, active_high=False)
self.pin_drdy = DigitalInputDevice(17)
self.pin_cs = DigitalOutputDevice(22, active_high=False)
self.exit_event = Event()
def __init__(self, pinA, pinB, rate = 1):
''' Construtor da classe. Entradas: pinA, pinB - canais do encoder
rate [= 1] - 1 / (N * PPR).'''
# Entradas da GPIO:
self.encA = DigitalInputDevice (pinA, pull_up = True)
self.encB = DigitalInputDevice (pinB, pull_up = True)
# Dados do encoder:
self.value = 0
self.rate = rate
# Estados dos pinos:
self.AState = False
self.BState = False
# Callbacks:
self.encA.when_actived = self.changeA
self.encB.when_actived = self.changeB
self.encA.when_deactived = self.changeA
self.encB.when_deactived = self.changeB
def get_reading():
d0_input = DigitalInputDevice(21)
if not d0_input.value:
print("moisture threshold reached")
return 0
else:
print("needs water")
return 1
def __init__(self):
self.snakeOnPin = DigitalOutputDevice(self.PIN_SNAKE_EN,
active_high=False)
self.snakeDonePin = DigitalInputDevice(self.PIN_SNAKE_DONE,
pull_up=False)
self.snakeDonePin.when_activated = self.onDone
self.done = False
self.enabled = False
return
def __init__(self):
self.logger = logging.getLogger(__name__)
super(SoundSensor, self).__init__()
self._stopper = Event()
self.logger.info("Starting sound sensor thread...")
# In case you want to use Remote GPIO
factory = PiGPIOFactory(host=settings.GPIOD_HOST)
self.do = DigitalInputDevice(self.pin, pin_factory=factory)
self.piBot = PiTelegramBot()
