def update_lcd(self): if not self.lcd1.connected: self.lcd1 = lcd.LCD(0x3f) if not self.lcd2.connected: self.lcd2 = lcd.LCD(0x20) UNUSED_PARAMS = ('GPS', 'TIME') if len(self.data) == 0: return while dataread.DataRead.POSSIBLE_DATA[self.lcd_itr] in UNUSED_PARAMS: self.lcd_itr += 1 name = dataread.DataRead.POSSIBLE_DATA[self.lcd_itr] self.lcd1.send_string( name + '(' + Application.UNITS[name] + '): ' + str(self.data[name]), lcd.LCD.LINE_1) self.lcd_itr += 1 while dataread.DataRead.POSSIBLE_DATA[self.lcd_itr] in UNUSED_PARAMS: self.lcd_itr1 += 1 name = dataread.DataRead.POSSIBLE_DATA[self.lcd_itr] self.lcd1.send_string( name + '(' + Application.UNITS[name] + '): ' + str(self.data[name]), lcd.LCD.LINE_2) self.lcd_itr += 1 self.update_lcd_label()
def __init__(self): self.lcd = lcd.LCD() self.alive = True self.run = None self.measurement = None self.state = None self.controller = None
def main(): mylcd = lcd.LCD() mylcd.clear() mylcd.text(0, 0, lcd.pi_char + "hello, world!") off = 7 for c in lcd.bar_chars: mylcd.text(off, 1, c) off += 1 on = True col_map = (lcd.RED, lcd.GREEN, lcd.BLUE, lcd.WHITE) col = 0 try: while True: but = mylcd.buttonRead() if but is None or but == 0xc: break if but == 1: if not on: on = True if on: col = (col + 1) % 4 mylcd.text(4, 1, "%d" % col) mylcd.backlight(col_map[col]) on = False mylcd.text(0, 1, "%02x" % but) time.sleep(0.25) except KeyboardInterrupt: pass finally: mylcd.off() print("bye")
def process(pipe, config): import lcd print('lcd process on', os.getpid()) self.lcd = lcd.LCD(self.hat.config) self.lcd.pipe = pipe if self.lcd.use_glut: from OpenGL.GLUT import glutMainLoop, glutIdleFunc glutIdleFunc(self.lcd.poll) glutMainLoop() else: while True: self.lcd.poll()
def main(): screen = lcd.LCD() while True: clock_line = time.strftime('%I:%M %p') day_line = time.strftime('%A') date_line = time.strftime('%B %d, %Y') if time.localtime().tm_sec % 2: clock_line = clock_line[:2] + ' ' + clock_line[3:] if clock_line[0] == '0': clock_line = clock_line[1:] screen.set_lines([clock_line, day_line, ' ', date_line]) screen.send_lines()
def _update(self): self.timeout = None try: if self.lcd is None: self.lcd = lcd.LCD(self.ctrl.i2c, self.addr, self.height, self.width) if self.reset: self.lcd.reset() self.redraw = True self.reset = False cursorX, cursorY = -1, -1 for y in range(self.height): for x in range(self.width): c = self.page.data[x][y] if self.redraw or self.screen[x][y] != c: if cursorX != x or cursorY != y: self.lcd.goto(x, y) cursorX, cursorY = x, y self.lcd.put_char(c) cursorX += 1 self.screen[x][y] = c self.redraw = False except IOError as e: # Try next address #self.addr_num += 1 #if len(self.addrs) <= self.addr_num: self.addr_num = 0 #self.addr = self.addrs[self.addr_num] #self.lcd = None #self.log.warning('LCD communication failed, ' + # 'retrying on address 0x%02x: %s' % (self.addr, e)) #self.log.warning('LCD not present.') #self.reset = True self.reset = False
def main(): mylcd = lcd.LCD() print("using", mylcd.__class__.__name__) mylcd.clear() offset = 1 try: while True: but = mylcd.buttonRead() if but is None or but == 0xc: break elif but == lcd.BUTTON_LEFT | lcd.BUTTON_UP: offset -= 1 elif but == lcd.BUTTON_RIGHT | lcd.BUTTON_UP: offset += 1 show(mylcd, offset) time.sleep(1) except KeyboardInterrupt: pass finally: mylcd.off() print("bye")
def __init__(self): # read config self.config = { 'remote': False, 'host': '127.0.0.1', 'actions': {}, 'pi.ir': True, 'arduino.ir': False, 'arduino.nmea.in': False, 'arduino.nmea.out': False, 'arduino.nmea.baud': 4800, 'lcd': {} } self.configfilename = os.getenv('HOME') + '/.pypilot/hat.conf' print('loading config file:', self.configfilename) try: file = open(self.configfilename) config = pyjson.loads(file.read()) file.close() for name in config: self.config[name] = config[name] except Exception as e: print('config failed:', e) try: configfile = '/proc/device-tree/hat/custom_0' f = open(configfile) hat_config = pyjson.loads(f.read()) f.close() print('loaded device tree hat config') if not 'hat' in self.config or hat_config != self.config['hat']: self.config['hat'] = hat_config print('writing device tree hat to hat.conf') self.write_config() except Exception as e: print('failed to load', configfile, ':', e) if not 'hat' in self.config: if os.path.exists('/dev/spidev0.0'): print( 'assuming original 26 pin tinypilot with nokia5110 display' ) self.config['hat'] = { 'lcd': { 'driver': 'nokia5110', 'port': '/dev/spidev0.0' }, 'lirc': 'gpio4' } self.write_config() self.servo_timeout = time.monotonic() + 1 self.last_msg = {} self.last_msg['ap.enabled'] = False self.last_msg['ap.heading_command'] = 0 if self.config['remote']: host = self.config['host'] else: host = 'localhost' self.client = pypilotClient(host) self.client.registered = False self.watchlist = ['ap.enabled', 'ap.heading_command'] for name in self.watchlist: self.client.watch(name) self.lcd = lcd.LCD(self) self.gpio = gpio.gpio() self.arduino = Arduino(self) self.poller = select.poll() self.poller.register(self.arduino.pipe, select.POLLIN) self.lirc = lircd.lirc(self.config) self.lirc.registered = False self.keytimes = {} self.keytimeouts = {} # keypad for lcd interface self.actions = [] keypadnames = [ 'auto', 'menu', 'port1', 'starboard1', 'select', 'port10', 'starboard10', 'tack', 'dodge_port', 'dodge_starboard' ] for i in range(len(keypadnames)): self.actions.append(ActionKeypad(self.lcd, i, keypadnames[i])) # stateless actions for autopilot control self.actions += [ ActionEngage(self), ActionPypilot(self, 'disengage', 'ap.enabled', False), ActionHeading(self, 1), ActionHeading(self, -1), ActionHeading(self, 2), ActionHeading(self, -2), ActionHeading(self, 5), ActionHeading(self, -5), ActionHeading(self, 10), ActionHeading(self, -10), ActionPypilot(self, 'compassmode', 'ap.mode', 'compass'), ActionPypilot(self, 'gpsmode', 'ap.mode', 'gps'), ActionPypilot(self, 'windmode', 'ap.mode', 'wind'), ActionPypilot(self, 'center', 'servo.position', 0), ActionTack(self, 'tackport', 'port'), ActionTack(self, 'tackstarboard', 'starboard'), ActionNone() ] for action in self.actions: if action.name in self.config['actions']: action.keys = self.config['actions'][action.name] self.web = Web(self) def cleanup(signal_number, frame=None): print('got signal', signal_number, 'cleaning up', os.getpid()) childpids = [] processes = [self.arduino, self.web] for process in processes: if process.process: childpids.append(process.process.pid) if signal_number == signal.SIGCHLD: pid = os.waitpid(-1, os.WNOHANG) if not pid[0] in childpids: print('subprocess returned', pid, childpids) # flask or system makes process at startup that dies return print('child process', pid, childpids) while childpids: pid = childpids.pop() #print('kill!', pid, childpids, os.getpid()) try: os.kill(pid, signal.SIGTERM) # get backtrace except ProcessLookupError: pass # ok, process is already terminated sys.stdout.flush() for process in processes: process.process = False if signal_number != 'atexit': raise KeyboardInterrupt # to get backtrace on all processes sys.stdout.flush() for s in range(1, 16): if s != 9 and s != 13: signal.signal(s, cleanup) signal.signal(signal.SIGCHLD, cleanup) import atexit atexit.register(lambda: cleanup('atexit'))
try: import micropython except: pass def mandelbrot(): # returns True if c, complex, is in the Mandelbrot set # @micropython.native def in_set(c): z = 0 for i in range(40): z = z * z + c if abs(z) > 60: return False return True lcd.clear() for u in range(91): for v in range(31): if in_set((u / 30 - 2) + (v / 15 - 1) * 1j): lcd.set(u, v) lcd.show() # PC testing import lcd lcd = lcd.LCD(128, 32) mandelbrot()
# This Source describes Open Hardware and is licensed under the # # CERN-OHL-S v2. # # # # You may redistribute and modify this Source and make products # # using it under the terms of the CERN-OHL-S v2 (https:/cern.ch/cern-ohl). # # This Source is distributed WITHOUT ANY EXPRESS OR IMPLIED # # WARRANTY, INCLUDING OF MERCHANTABILITY, SATISFACTORY QUALITY AND FITNESS # # FOR A PARTICULAR PURPOSE. Please see the CERN-OHL-S v2 for applicable # # conditions. # # # # Source location: https://github.com/buildbotics # # # # As per CERN-OHL-S v2 section 4, should You produce hardware based on # # these sources, You must maintain the Source Location clearly visible on # # the external case of the CNC Controller or other product you make using # # this Source. # # # # For more information, email [email protected] # # # ################################################################################ import lcd if __name__ == "__main__": screen = lcd.LCD(1, 0x27) screen.clear() screen.display(0, 'Buildbotics', lcd.JUSTIFY_CENTER) screen.display(1, 'Controller', lcd.JUSTIFY_CENTER) screen.display(3, 'Booting...', lcd.JUSTIFY_CENTER)
KEYPAD = keypad.Keypad(settings["keypad_characters"], settings["keypad_row_pins"], settings["keypad_col_pins"]) # initialize PIR GPIO.setup(settings["pir_pin"], GPIO.IN) # initialize twilio # TWILIO_CLIENT = Client(settings["twilio_account_sid"], settings["twilio_auth_token"]) # initialize gas sensor GAS_SENSOR = DigitalInputDevice(settings["gas_pin"]) # initialize LCD LCD = lcd.LCD(settings["lcd_rs"], settings["lcd_e"], settings["lcd_d4"], settings["lcd_d5"], settings["lcd_d6"], settings["lcd_d7"], settings["lcd_chr"], settings["lcd_cmd"], settings["lcd_chars"], settings["lcd_line_1"], settings["lcd_line_2"]) # initialize relays and alarm for i in range(1, 4): x = "relay" + str(i) + "_pin" if x in settings and settings[x] > 0: GPIO.setup(settings[x], GPIO.OUT) GPIO.output(settings[x], 1) if "alarm_pin" in settings and settings["alarm_pin"] > 0: GPIO.setup(settings["alarm_pin"], GPIO.OUT) GPIO.output(settings["alarm_pin"], 1) # initialize DHT11 sensor DHT11_TEMP = None DHT11_HUM = None
def featurize_LCD_VLAD(list_of_demonstrations, kinematics, layer, net_name, folder, dimensions, batch_size, fname, config=[True, True, True]): M = dimensions[0] a = dimensions[1] print "Featurizing LCD + VLAD: ", layer, net_name, folder, M, a, batch_size BATCH_SIZE = batch_size if constants.SIMULATION: BATCH_SIZE = 5 data_X_PCA = {} data_X_CCA = {} data_X_GRP = {} size_sampled_matrices = [ utils.sample_matrix(kinematics[demo], sampling_rate=BATCH_SIZE).shape[0] for demo in list_of_demonstrations ] PC = min(100, min(size_sampled_matrices)) print "PC: ", PC for demonstration in list_of_demonstrations: print demonstration W = kinematics[demonstration] Z = load_cnn_features(demonstration, layer, folder, net_name) W_new = utils.sample_matrix(W, sampling_rate=BATCH_SIZE) Z_batch = None W_batch = None j = 1 Z_new = None IPython.embed() PATH_TO_ANNOTATION = constants.PATH_TO_DATA + constants.ANNOTATIONS_FOLDER + demonstration + "_" + str( constants.CAMERA) + ".p" start, end = utils.get_start_end_annotations(PATH_TO_ANNOTATION) Z = [] IPython.embed() for i in range(Z): vector_W = W[i] W_batch = utils.safe_concatenate(W_batch, vector_W) vector_Z = Z[i] vector_Z = vector_Z.reshape(M, a, a) vector_Z = lcd.LCD(vector_Z) Z_batch = utils.safe_concatenate(Z_batch, vector_Z) if (j == BATCH_SIZE): print "NEW BATCH", str(i) Z_batch_VLAD = encoding.encode_VLAD(Z_batch) Z_new = utils.safe_concatenate(Z_new, Z_batch_VLAD) # Re-initialize batch variables j = 0 Z_batch = None W_batch = None j += 1 # tail case if Z_batch is not None: print "TAIL CASE" print "NEW BATCH", str(i) Z_batch_VLAD = encoding.encode_VLAD(Z_batch) Z_new = utils.safe_concatenate(Z_new, Z_batch_VLAD) if config[0]: Z_new_pca = utils.pca_incremental(Z_new, PC=PC) print Z_new_pca.shape assert W_new.shape[0] == Z_new_pca.shape[0] X_PCA = np.concatenate((W_new, Z_new_pca), axis=1) data_X_PCA[demonstration] = X_PCA if config[1]: Z_new_cca = utils.cca(W_new, Z_new) print Z_new_cca.shape assert W_new.shape[0] == Z_new_cca.shape[0] X_CCA = np.concatenate((W_new, Z_new_cca), axis=1) data_X_CCA[demonstration] = X_CCA if config[2]: Z_new_grp = utils.grp(Z_new) print Z_new_grp.shape assert W_new.shape[0] == Z_new_grp.shape[0] X_GRP = np.concatenate((W_new, Z_new_grp), axis=1) data_X_GRP[demonstration] = X_GRP if config[0]: pickle.dump(data_X_PCA, open(PATH_TO_FEATURES + fname + "_PCA" + ".p", "wb")) if config[1]: pickle.dump(data_X_CCA, open(PATH_TO_FEATURES + fname + "_CCA" + ".p", "wb")) if config[2]: pickle.dump(data_X_GRP, open(PATH_TO_FEATURES + fname + "_GRP" + ".p", "wb"))
checksum = checksum ^ c i2cbus.write_byte(address, c) time.sleep(0.0005) i2cbus.write_byte(address, checksum) time.sleep(0.0005) if __name__ == '__main__': driveJoystick = None lastDriveJoystickMovement = 0 lastDriveCommand = 0 domeJoystick = None lastDomeJoystickMovement = 0 lastJoystickInit = time.time() lcdScreen = lcd.LCD() lcdScreen.init() lastDomeDirection = 0 lastDomeSpeed = 0 lastDomeUpdate = 0 genericAudioFiles = findFiles('/home/pi/audio/generic/') chatAudioFiles = findFiles('/home/pi/audio/chat/') happyAudioFiles = findFiles('/home/pi/audio/happy/') sadAudioFiles = findFiles('/home/pi/audio/sad/') whistleAudioFiles = findFiles('/home/pi/audio/whistle/') screamAudioFiles = findFiles('/home/pi/audio/scream/') domeAudioFiles = list(genericAudioFiles) domeAudioPending = [] driveAudioFiles = list(genericAudioFiles)
sensor.set_contrast(1) sensor.set_brightness(0) sensor.set_saturation(2) sensor.set_pixformat(sensor.RGB565) # Note: QQVGA2 is the LCD resolution. sensor.set_framesize(sensor.QQVGA2) # The following registers fine-tune the image # sensor window to align it with the FIR sensor. sensor.__write_reg(0xFF, 0x01) # switch to reg bank sensor.__write_reg(0x17, 0x1D) # set HSTART sensor.__write_reg(0x18, 0x47) # set HSTOP # Initialize LCD lcd = lcd.LCD() #lcd.clear(0x00) lcd.set_backlight(True) # FPS clock clock = time.clock() # Ambient temperature ta = 0.0 # Minimum object temperature to_min = 0.0 # Maximum object temperature to_max = 0.0 while (True): clock.tick()
if key == '#': offset += 2 elif key == '*' and offset > 0: offset -= 2 else: return key def input_number(self, value, update_function): while True: update_function(value) k = self._keypad.get_single_key() if k == '#': break if k == '*': value = value / 10 else: value *= 10 value += k return value import max7301 if __name__ == "__main__": import lcd lcd = lcd.LCD('localhost') io_device = max7301.MAX7301() ui = UI(io_device = io_device, lcd = lcd) print ui.choose('krobin moechte', ['pizza', 'doener'])
def __init__(self): self.ticks = 0 self.lcd_itr = 0 self.data = {} self.window = Gtk.Window(title='TDR') self.window.connect('destroy', Gtk.main_quit) self.window.set_resizable(False) self.window.set_size_request(800, 600) self.window.set_position(Gtk.WindowPosition.CENTER) self.container = Gtk.Fixed() self.window.add(self.container) self.bluetooth_label = Gtk.Label(label='Bluetooth: disconnected') self.container.put(self.bluetooth_label, 50, 50) self.data_label = Gtk.Label(label='Current data:') self.container.put(self.data_label, 50, 150) self.label = Gtk.Label() self.container.put(self.label, 100, 210) self.arduino_label = Gtk.Label() self.container.put(self.arduino_label, 500, 210) self.lcd_label = Gtk.Label() self.container.put(self.lcd_label, 500, 270) self.clear_reg_button = Gtk.Button(label='Clear register') self.clear_reg_button.connect('clicked', Application.clear_reg_button_clicked) self.container.put(self.clear_reg_button, 100, 500) self.graph_label = Gtk.Label(label='Graph settings:') self.container.put(self.graph_label, 400, 360) self.graph_win = Gtk.CheckButton(label='Display graphs') self.graph_win.connect('toggled', Application.checkbox_toggle) self.container.put(self.graph_win, 420, 390) self.sizex_entry = Gtk.Entry() self.sizex_entry.connect('changed', self.on_size_changed) self.container.put(self.sizex_entry, 420, 440) self.sizey_entry = Gtk.Entry() self.sizey_entry.connect('changed', self.on_size_changed) self.container.put(self.sizey_entry, 420, 480) self.graphparams_entry = Gtk.Entry() self.graphparams_entry.connect('changed', self.on_params_changed) self.container.put(self.graphparams_entry, 420, 520) self.sizex_entry.set_text(str(grapher.sizex)) self.sizey_entry.set_text(str(grapher.sizey)) self.graphparams_entry.set_text(grapher.graph_params) self.container.put(Gtk.Label(label='X size for graphics (inches)'), 600, 440) self.container.put(Gtk.Label(label='Y size for grahics (inches)'), 600, 480) self.container.put(Gtk.Label(label='Parameters for the graph'), 600, 520) self.window.show_all() self.datareader1 = dataread.DataRead('/dev/ttyACM0') self.datareader2 = dataread.DataRead('/dev/ttyACM1') self.bluetoothdv = bluetoothio.BluetoothIO() self.lcd1 = lcd.LCD(0x3f) self.lcd2 = lcd.LCD(0x20) self.update_arduino_label() self.update_lcd_label() self.graphprocess = Process(target=grapher.update_graph, args=['']) if not os.path.exists('register.json'): with open('register.json', 'w') as file: file.write('[\n]')
lcd.gotoxy(0,3) lcd.pr(padN('{:20}'.format(wstr),lcd_width,True)) if __name__ == '__main__': s = 'This is a very long string that must be rotated' r = RotatingString(s,16) for i in range(50): print(r.tick()) if False: import bb595 import lcd import random s8 = bb595.bb595() lcd = lcd.LCD(s8) lcd.begin() lcd.clear() lcd.backlight(0) last = datetime.datetime.now() while True: now = datetime.datetime.now() if now > (last + datetime.timedelta(seconds=1)): update_display(lcd,{'zones':'3', 'remaining':4922},None) last = now else: s8.shift8(random.randrange(256),'triacs')
def __init__(self): # read config try: configfile = '/proc/device-tree/hat/custom_0' f = open(configfile) self.hatconfig = json.loads(f.read()) f.close() except Exception as e: print('failed to load', configfile, ':', e) print('assuming original 26 pin tinypilot') self.hatconfig = False self.config = { 'remote': False, 'host': 'pypilot', 'actions': {}, 'lcd': {} } self.configfilename = os.getenv('HOME') + '/.pypilot/hat.conf' print('loading config file:', self.configfilename) try: file = open(self.configfilename) config = json.loads(file.read()) file.close() for name in config: self.config[name] = config[name] except Exception as e: print('config failed:', e) self.lastpollheading = time.time() self.servo_timeout = time.time() + 1 self.longsleep = 30 self.last_msg = {} self.client = False self.lcd = lcd.LCD(self) self.gpio = gpio.gpio() self.arduino = arduino.arduino(self.hatconfig) self.lirc = lirc.lirc() self.buzzer = buzzer.buzzer(self.hatconfig) # keypad for lcd interface self.actions = [] keypadnames = ['auto', 'menu', 'up', 'down', 'select', 'left', 'right'] for i in range(7): self.actions.append(ActionKeypad(self.lcd, i, keypadnames[i])) # stateless actions for autopilot control self.actions += [ ActionEngage(self), ActionPypilot(self, 'disengage', 'ap.enabled', False), ActionHeading(self, 1), ActionHeading(self, -1), ActionHeading(self, 2), ActionHeading(self, -2), ActionHeading(self, 10), ActionHeading(self, -10), ActionPypilot(self, 'compassmode', 'ap.mode', 'compass'), ActionPypilot(self, 'gpsmode', 'ap.mode', 'gps'), ActionPypilot(self, 'windmode', 'ap.mode', 'wind'), ActionTack(self, 'tackport', 'port'), ActionTack(self, 'tackstarboard', 'starboard') ] for action in self.actions: if action.name in self.config['actions']: action.keys = self.config['actions'][action.name] self.web = Web(self)