def start(self, items, active=0, ok=None, back=None):
logger.debug('start')
max_width = self.device.width
if isinstance(items, list):
for item in items:
max_width = max(max_width, len(item) * 8 + 1)
self.gpio = Gpio(down=self.down,
up=self.up,
ok=self.__ok,
back=self.__back)
elif isinstance(items, str):
max_width = max(max_width, len(items) * 8 + 1)
self.gpio = Gpio(ok=self.__ok, back=self.__back)
# self.gpio.start()
self.virtual = viewport(self.device,
width=max_width,
height=(len(items) * 8))
self.active = 0
if ok:
self.ok = ok
if back:
self.back = back
with canvas(self.virtual) as draw:
if isinstance(items, list):
for i, item in enumerate(items):
text(draw, (1, i * 8),
item,
fill="white",
font=proportional(LCD_FONT))
if (item == active):
self.active = i
self.items = items
elif isinstance(items, str):
text(draw, (1, 0),
items,
fill="white",
font=proportional(LCD_FONT))
self.items = [items]
self.virtual.set_position((0, self.active * 8))
threading.Thread.start(self)
def __init__(self, config):
self.connection = None
self.exchange = None
self.queues = []
self.config = config
self._init_rabbitmq()
self.gpio = Gpio(config)
def __init__(self, triggerPort, echoPort, nSamples=5):
'''
Constructor
@param triggerPort: Port number of the trigger signal
@param echoPort: Port number of the echo port
@param nSamples: Number of samples to measure the distance
'''
self._nSamples = nSamples
#Configure ports
self._trigger = Gpio(triggerPort, Gpio.OUT)
self._trigger.setValue(Gpio.LOW)
self._echo = Gpio(echoPort, Gpio.IN)
time.sleep(2)
def __init__(self, config: Config):
self.config = config
self.gpio: GpioStub
if config.debug:
from dummy_gpio import DummyGpio
self.gpio: GpioStub = DummyGpio(config.gpio_out)
else:
from gpio import Gpio
self.gpio: GpioStub = Gpio(config.gpio_out)
def __init__(self, port, delay=0.1):
'''
Constructor
@param port: GPIO port number where the LED is connected to
@param delay: Time the LED is on and off. Default 0.1s
'''
self._port = Gpio(port, Gpio.OUT)
self._delay = delay
self._isRunning = False
self._doBlinkThread = None
def start(self, ok=None, back=None):
logger.debug('start')
self.gpio = Gpio(ok=self.__ok, back=self.__back)
# self.gpio.start()
if ok:
self.ok = ok
if back:
self.back = back
threading.Thread.start(self)
def run(self):
try:
self._init_menu()
self.music = Music(self.core, self.config['default_tracks'],
self.config['default_preset'])
self.display = DisplayWithPowerSaving(
self.config['display_min_brightness'],
self.config['display_max_brightness'],
self.config['display_off_time_from'],
self.config['display_off_time_to'])
self.gpio = Gpio(
self.config['buttons_enabled'], self.play_stop_music,
self._on_menu_click, self._on_menu_click_left,
self._on_menu_click_right, self.config['light_sensor_enabled'],
self._on_light_sensor, self.config['relay_enabled'])
self.ir_sender = IrSender(self.config['ir_remote'],
self.gpio.switch_relay)
self.ir_receiver = IrReceiver(
self.config['ir_receiver_enabled'], self.play_stop_music,
self._on_menu_click, self._on_menu_click_left,
self._on_menu_click_right, self.music.decrease_volume,
self.music.increase_volume, self.run_alert,
self._on_change_preset)
self.timer_on = TimerOn(self.play_music)
self.timer_off = TimerOff(self.stop_music)
self.alert = Alert(self.music, self.ir_sender,
self.config['alert_files'])
self.timer_alert = TimerAlert(self.run_alert)
self.time = Time()
self.date = Date([self.timer_on, self.timer_off, self.timer_alert])
self.menu = Menu(self.display, self.MENU, [
self.time, self.date, self.timer_on, self.timer_off,
self.timer_alert
])
while True:
self.menu.run()
if (self.stopped()):
break
else:
sleep(1)
except Exception as inst:
logging.error(inst)
finally:
self.ir_sender.stop()
self.ir_receiver.stop()
self.display.shutdown()
self.gpio.cleanup()
def main():
'''
Makes a LED to blink according to the distance meassured
by an ultrasonic sensor.
Finish when user press a toggle key.
'''
blinker = Blinker(27, MAX_DELAY) #P8.17
ultrasonic = Ultrasonic(66, 69) #P8.7, P8.9
key = Gpio(65, Gpio.IN) #P8.18
try:
print("Ready. Press toggle key to start.")
#Wait for key down event
while key.getValue() == Gpio.LOW:
sleep(0.2)
#Wait for key up event
while key.getValue() == Gpio.HIGH:
sleep(0.2)
print("Started. Press toggle key again to finish.")
blinker.start()
while key.getValue() == Gpio.LOW:
dist = ultrasonic.read()
delay = calculateDelay(dist)
blinker.setDelay(delay)
sleep(0.2)
print("Bye!")
finally:
key.cleanup()
blinker.stop()
blinker.cleanup()
ultrasonic.cleanup()
# Default game parameters
GAME_TOTAL_LINKS = 15
GAME_FIRST_LINK_0 = 10
GAME_FIRST_LINK_1 = 4
GAME_STEP_DELAY = 8
# Diagnostic parameters
DIAG_PATH_SEARCH_SRC = 0
DIAG_PATH_SEARCH_DST = len(ALL_NODE_NAMES) - 1
# Mock parameters
MOCK_FIRST_LINK_MIDDLE_NODE = 2
MOCK_SECOND_LINK_MIDDLE_NODE = 3
# Connectors representing GPIO groupings
NODE_0 = Connectors(Gpio(Gpio.BUS_ADDR_0, Gpio.GPB0), [
Gpio(Gpio.BUS_ADDR_0, Gpio.GPB1),
Gpio(Gpio.BUS_ADDR_0, Gpio.GPB2),
Gpio(Gpio.BUS_ADDR_0, Gpio.GPB3),
Gpio(Gpio.BUS_ADDR_0, Gpio.GPB4)
], DEBUG_MODE)
NODE_1 = Connectors(Gpio(Gpio.BUS_ADDR_0, Gpio.GPB5), [
Gpio(Gpio.BUS_ADDR_0, Gpio.GPB6),
Gpio(Gpio.BUS_ADDR_0, Gpio.GPA0),
Gpio(Gpio.BUS_ADDR_0, Gpio.GPA1),
Gpio(Gpio.BUS_ADDR_0, Gpio.GPA2)
], DEBUG_MODE)
NODE_2 = Connectors(Gpio(Gpio.BUS_ADDR_0, Gpio.GPA7), [
Gpio(Gpio.BUS_ADDR_0, Gpio.GPA6),
Gpio(Gpio.BUS_ADDR_0, Gpio.GPA5),
Gpio(Gpio.BUS_ADDR_0, Gpio.GPA4),
def __init__(self):
self.gpio = Gpio(self.context)
self.live = TelldusLive(self.context)
self.gpio.initPin('status:red')
self.gpio.initPin('status:green')
self.setNetworkLed()
def __init__(self, red_pin, green_pin, blue_pin):
self._red = Gpio(red_pin)
self._green = Gpio(green_pin)
self._blue = Gpio(blue_pin)
from gpio import Gpio
from time import sleep
led = Gpio(27, Gpio.OUT) #P8.17
key = Gpio(65, Gpio.IN) #P8.18
try:
light = Gpio.LOW
led.setValue(light)
lastKeyState = Gpio.LOW
print("Ready.\nPress toggle key to change led state or Ctrl+C to exit.")
while True:
keyState = key.getValue()
if lastKeyState != keyState and keyState == Gpio.HIGH:
light = not light
led.setValue(light)
print("Led state changed to {0}.".format("ON" if light else "OFF"))
lastKeyState = keyState
sleep(0.2)
except KeyboardInterrupt:
print("\nBye!")
finally:
def main(argv):
device_name = None
server_url = None
gpio_number = None
rgb = []
key = None
lock_id = None
logfile = None
mode = 'single_lock'
def help(cmd):
print cmd + '-i <input device> -u <server url> -g <gpio number> -k <secret key> -l <lock number> -o <logfile>'
try:
opts, args = getopt.getopt(argv, "hi:u:b:g:r:k:l:o:m:", [
"input=", "url=", "gpio=", "rgb=", "key=", "lock=", "logfile=",
"mode="
])
except getopt.GetoptError:
help(sys.argv[0])
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
help(sys.argv[0])
sys.exit()
elif opt in ("-i", "--input"):
device_name = arg
elif opt in ("-u", "--url"):
server_url = arg
elif opt in ("-g", "--gpio"):
gpio_number = arg
elif opt in ("-r", "--rgb"):
rgb.extend(arg.split(','))
elif opt in ("-k", "--key"):
key = arg
elif opt in ("-l", "--lock"):
lock_id = arg
elif opt in ("-o", "--logfile"):
logfile = arg
elif opt in ("-m", "--mode"):
mode = arg
if not server_url or not key:
help(sys.argv[0])
sys.exit(2)
if mode != 'single_lock' and mode != 'open_all':
print('unknown mode %s' % mode)
sys.exit(2)
# create lock
if gpio_number:
lock = Lock(lock_id, Gpio(gpio_number))
else:
lock = DummyLock(lock_id)
# create logger
if logfile:
logger = create_file_logger(logfile, lock)
else:
logger = create_stdout_logger(lock)
# create authenticator
logger.info("server url: %s" % server_url)
authenticator = Authenticator(server_url, key)
# create reader
if device_name:
reader = Reader(device_name)
else:
reader = DummyReader()
rgb_led = None
if rgb:
rgb_led = RgbLed(int(rgb[0]), int(rgb[1]), int(rgb[2]))
# read loop
for user_id in reader.read():
if mode == 'single_lock':
if authenticator.auth(lock, user_id):
if rgb_led:
rgb_led.green(1)
lock.open(pulse_time_s=1)
logger.info("%s: valid" % user_id)
if rgb_led:
rgb_led.green(0)
else:
if rgb_led:
rgb_led.red(1)
logger.info("%s: invalid" % user_id)
time.sleep(1)
if rgb_led:
rgb_led.red(0)
elif mode == 'open_all':
state = authenticator.auth(lock, user_id)
if state:
logger.info("%s: valid" % user_id)
if state == 'on':
logger.info("all on")
if rgb_led:
rgb_led.green(1)
rgb_led.red(0)
elif state == 'off':
logger.info("all off")
if rgb_led:
rgb_led.green(0)
rgb_led.red(1)
else:
logger.info("unknown state: %s" % state)
else:
logger.info("%s: invalid" % user_id)
def __init__(self):
Pyro.core.ObjBase.__init__(self)
self.adc = Adc() #adc.Adc()
self.pwm = Pwm() #pwm.OmapPwm()
self.gpio = Gpio() #gpio.Gpio()
def __init__(self, logger):
Logger.log.debug('{} initializing....'.format(__name__))
self.logger = logger
self.config = Config(logger=self.logger)
self.support = Support(config=self.config, logger=self.logger)
self.gpio = Gpio(config=self.config, logger=self.logger)
self.pollperm = Pollperm(logger=self.logger)
self.decoder = Decoder(config=self.config,
logger=self.logger,
gpio=self.gpio)
self.spi = SPI(config=self.config,
logger=self.logger,
decoder=self.decoder,
pollperm=self.pollperm)
self.codegen = Codegen(config=self.config,
logger=self.logger,
gpio=self.gpio,
spi=self.spi)
self.securitylevel = SecurityLevel(logger=self.logger)
self.gui = Mainwindow(self,
codegen=self.codegen,
config=self.config,
logger=self.logger,
support=self.support,
securitylevel=self.securitylevel)
self.switches = Switches(config=self.config,
logger=self.logger,
spi=self.spi,
gui=self.gui)
self.currentsense = CurrentSense(logger=self.logger,
spi=self.spi,
decoder=self.decoder,
gui=self.gui,
config=self.config)
self.pollvalues = Pollvalues(pollperm=self.pollperm,
logger=logger,
config=self.config,
currentsense=self.currentsense,
switches=self.switches,
sense_callback=self.poll_sense_callback,
switch_callback=self.poll_switch_callback)
self.securitywindow = SecurityWindow(logger=self.logger,
securitylevel=self.securitylevel)
self.window = self.gui.window
self.log = self.logger.log
self.knob_values = 0
self.rotary_0_pins = None
self.rotary_1_pins = None
self.rotary_2_pins = None
self.rotary_3_pins = None
self.rotary_0_pin_0_debounce = None
self.rotary_0_pin_1_debounce = None
self.rotary_1_pin_0_debounce = None
self.rotary_1_pin_1_debounce = None
self.rotary_2_pin_0_debounce = None
self.rotary_2_pin_1_debounce = None
self.rotary_3_pin_0_debounce = None
self.rotary_3_pin_1_debounce = None
self.gain0_val = 0
self.gain1_val = 0
self.gain_0_name = None
self.gain_1_name = None
self.gain_0_spi_channel = None
self.gain_1_spi_channel = None
self.gain_0_thresholds = None
self.gain_1_thresholds = None
self.GAIN_0_CS = None
self.GAIN_1_CS = None
self.speed0_val = 0
self.speed1_val = 0
self.speed_0_name = None
self.speed_1_name = None
self.speed_0_shape = None
self.speed_1_shape = None
self.speed_0_spi_channel = None
self.speed_1_spi_channel = None
self.speed_0_thresholds = None
self.speed_1_thresholds = None
self.screen_brightness_max = None
self.screen_brightness_min = None
self.display_brightness = None
self.spi_log_pause = False
self.SPEED_0_CS = None # 6 # SPEED SIMULATION TACH 1
self.SPEED_1_CS = None # 7 # SPEED SIMULATION TACH 2
self.load_from_config()
self.adc_scale = None
self.sense_amp_max_amps = None
self.sense_ad_vin = None # LM4128CQ1MF3.3/NOPB voltage reference
self.sense_ad_max_bits = 0 # AD7940 ADC
self.sense_scaling_factor_mv_amp = None # 110 milivolts per amp
self.sense_ad_max_scaled_value = None
self.speed0 = Speedgen(
pollperm=self.pollperm,
logger=self.logger,
config=self.config,
decoder=self.decoder,
spi=self.spi,
gpio=self.gpio,
name=self.speed_0_name,
shape=self.speed_0_shape,
spi_channel=self.speed_0_spi_channel,
chip_select=self.SPEED_0_CS,
pin_0=self.rotary_0_pins[0],
pin_1=self.rotary_0_pins[1],
pin_0_debounce=self.rotary_0_pin_0_debounce,
pin_1_debounce=self.rotary_0_pin_1_debounce,
thresholds=self.speed_0_thresholds,
callback=self.speed_callback,
commander_speed_move_callback=self.speed_move_callback)
self.speed1 = Speedgen(
pollperm=self.pollperm,
logger=self.logger,
config=self.config,
decoder=self.decoder,
spi=self.spi,
gpio=self.gpio,
name=self.speed_1_name,
shape=self.speed_1_shape,
spi_channel=self.speed_1_spi_channel,
chip_select=self.SPEED_1_CS,
pin_0=self.rotary_1_pins[0],
pin_1=self.rotary_1_pins[1],
pin_0_debounce=self.rotary_1_pin_0_debounce,
pin_1_debounce=self.rotary_1_pin_1_debounce,
thresholds=self.speed_1_thresholds,
callback=self.speed_callback,
commander_speed_move_callback=self.speed_move_callback)
self.gain0 = Gains(
pollperm=self.pollperm,
config=self.config,
logger=self.logger,
decoder=self.decoder,
spi=self.spi,
gpio=self.gpio,
name=self.gain_0_name,
spi_channel=self.gain_0_spi_channel,
chip_select=self.GAIN_0_CS,
pin_0=self.rotary_2_pins[0],
pin_1=self.rotary_2_pins[1],
pin_0_debounce=self.rotary_2_pin_0_debounce,
pin_1_debounce=self.rotary_2_pin_1_debounce,
thresholds=self.gain_0_thresholds,
callback=self.gains_callback,
commander_gain_move_callback=self.gain_move_callback)
self.gain1 = Gains(
pollperm=self.pollperm,
config=self.config,
logger=self.logger,
decoder=self.decoder,
spi=self.spi,
gpio=self.gpio,
name=self.gain_1_name,
spi_channel=self.gain_1_spi_channel,
chip_select=self.GAIN_1_CS,
pin_0=self.rotary_3_pins[0],
pin_1=self.rotary_3_pins[1],
pin_0_debounce=self.rotary_3_pin_0_debounce,
pin_1_debounce=self.rotary_3_pin_1_debounce,
thresholds=self.gain_1_thresholds,
callback=self.gains_callback,
commander_gain_move_callback=self.gain_move_callback)
self.startup_processes()
def get_gpio(pin):
gpio = Gpio(pin)
return gpio
