class OLED(object): #OLED Functions def __init__(self, platform, urn, status): self.status = status spi_urn = urn gpio_urn = platform.get_integration_references(spi_urn)[0] self.status.Debug("GPIO URN: %s" % gpio_urn) self.status.Debug("SPI URN: %s" % spi_urn) self.gpio = GPIO(platform, gpio_urn, status) self.spi = SPI(platform, spi_urn, status) self.status = status #Setup the controller self.platform = platform self.status = status self.spi.set_spi_clock_rate(1000000) self.status.Important("Clock Rate: %d" % self.spi.get_spi_clock_rate()) #self.spi.set_tx_polarity(False) #self.spi.set_rx_polarity(True) self.spi.set_spi_mode(3) self.spi.set_spi_slave_select(0, True) self.spi.auto_ss_control_enable(True) self.spi.set_character_length(8) self.buffer_len = self.spi.get_max_character_length() / 8 self.gpio.set_port_direction(0xFFFFFFFF) #Setup the GPIOs self.set_command_mode() self.enable_vdd(False) self.enable_vbat(False) time.sleep(0.001) self.setup() def reset(self): self.status.Important("Resetting OLED") self.gpio.set_bit_value(RESET, 0) time.sleep(0.01) self.gpio.set_bit_value(RESET, 1) def set_data_mode(self): self.gpio.set_bit_value(DATA_COMMAND_MODE, 1) def set_command_mode(self): self.gpio.set_bit_value(DATA_COMMAND_MODE, 0) def enable_vbat(self, enable): if enable: self.gpio.set_bit_value(VBAT_ENABLE, 0) else: self.gpio.set_bit_value(VBAT_ENABLE, 1) def enable_vdd(self, enable): if enable: self.gpio.set_bit_value(VDD_ENABLE, 0) else: self.gpio.set_bit_value(VDD_ENABLE, 1) def send_command(self, command): #if isinstance(command, list): # command = Array('B', command) #elif isinstance(command, int): # command = Array('B', [command]) command = Array('B', [command]) #print "command: %s" % str(command) self.spi.set_write_data(command) self.spi.start_transaction() #XXX: This should be pushed to a background thread! while self.spi.is_busy(): time.sleep(0.01) def write_buffer(self, buf): column_index = 0 for i in range(4): #Set the Page command self.set_command_mode() self.send_command(0x22) self.send_command(i) #Start from the left column self.send_command(0x00) self.send_command(0x10) self.set_data_mode() self.put_column_buffer(i, buf) def put_column_buffer(self, column_index, buf): pos = 0 column_width = 128 buf_pos = column_index * column_width last_buf_pos = buf_pos + column_width #self.buffer_len for i in range ((column_index * 128), ((column_index * 128) + 128)): #self.send_command(Array('B', [buf[i]])) self.spi.set_write_data([buf[i]]) self.spi.start_transaction() while self.spi.is_busy(): time.sleep(0.01) def setup(self): self.status.Important("Power Up") self.set_command_mode() self.status.Important("Enable VDD") self.enable_vdd(True) time.sleep(0.001) #Disable the Display self.status.Important("Disable display") self.send_command(0xAE) #Reset the display self.status.Important("Reset display") self.reset() #Set the charge pump and set pre-charge period command self.status.Important("Setup charge pump and pre-charge pump") self.send_command(0x8D) self.send_command(0x14) self.send_command(0xD9) self.send_command(0xF1) #Turn on VBAT self.status.Important("Turn on VBAT") self.enable_vbat(True) time.sleep(0.1) #Invert the display self.status.Important("Invert Display") self.send_command(0xA1) #Remap Columns self.send_command(0xC8) #Remap Rows self.status.Important("Set the command to select sequence COMM configuration") self.send_command(0xDA) self.send_command(0x20) self.status.Important("Enable display") self.send_command(0xAF)
class Controller(NysaBaseController): @staticmethod def get_name(): return APP_NAME @staticmethod def get_driver(): return DRIVER def __init__(self): super (Controller, self).__init__() self.gpio_actions = GPIOActions() self.gpio_actions.get_pressed.connect(self.register_get_pressed) self.gpio_actions.set_pressed.connect(self.register_set_pressed) self.gpio_actions.gpio_out_changed.connect(self.gpio_out_changed) self.gpio_actions.direction_changed.connect(self.direction_changed) self.gpio_actions.interrupt_en_changed.connect(self.interrupt_en_changed) self.gpio_actions.interrupt_edge_changed.connect(self.interrupt_edge_changed) self.gpio_actions.interrupt_both_edge_changed.connect(self.interrupt_both_edge_changed) self.gpio_actions.read_start_stop.connect(self.read_start_stop) self.gpio_actions.gpio_input_changed.connect(self.gpio_input_changed) self.gpio_actions.gpio_interrupt.connect(self.process_interrupts) def _initialize(self, platform, urn): self.v = GPIOWidget(count = 32, gpio_actions = self.gpio_actions) self.gpio = GPIO(platform, urn, debug = False) #Initialize the thread with a 40mS timeout self.v.add_register(0, "Value", initial_value = self.gpio.get_port_raw()) self.v.add_register(1, "Direction", initial_value = self.gpio.get_port_direction()) self.v.add_register(2, "Interrupts", initial_value = self.gpio.get_interrupts()) self.v.add_register(3, "Interrupt Enable", initial_value = self.gpio.get_interrupt_enable()) self.v.add_register(4, "Interrupt Edge", initial_value = self.gpio.get_interrupt_edge()) self.v.add_register(5, "Interrupt Both Edge", initial_value = self.gpio.get_interrupt_both_edge()) self.v.add_register(6, "Interrupt Timeout", initial_value = self.gpio.get_interrupt_timeout()) self.v.add_register(7, "Read Clock Rate", initial_value = self.gpio.get_clock_rate()) self.gpio.register_interrupt_callback(self.interrupt_callback) def start_tab_view(self, platform, urn, status): self.status = status self.status.Verbose("Thread name: %s" % QThread.currentThread().objectName()) self._initialize(platform, urn) def get_view(self): return self.v def read_start_stop(self, start_stop, rate): self.status.Verbose("Enter Read/startstop") def gpio_input_changed(self, value): self.status.Verbose("Input Changed") #Input Changed self.v.set_register(0, value) def register_get_pressed(self, index): self.status.Verbose("Register Get Pressed: %d" % index) value = self.gpio.read_register(index) self.v.set_register(index, value) def register_set_pressed(self, index, value): self.status.Verbose("Register Set Pressed: %d: %d" % (index, value)) self.gpio.write_register(index, value) def gpio_out_changed(self, index, val): self.status.Verbose( "GPIO Out: %d : %s" % (index, str(val))) self.gpio.set_bit_value(index, val) def direction_changed(self, index, value): self.status.Verbose( "GPIO Direction: %d : %s" % (index, str(value))) self.gpio.enable_register_bit(1, index, value) def interrupt_en_changed(self, index, value): self.status.Verbose("Interrupt En Changed: %d : %s" % (index, str(value))) self.gpio.enable_register_bit(3, index, value) def interrupt_edge_changed(self, index, value): self.status.Verbose("Interrupt Edge Changed %d : %s" % (index, str(value))) self.gpio.enable_register_bit(4, index, value) def interrupt_both_edge_changed(self, index, value): self.status.Verbose("Interrupt Both Edges Changed %d: %s" % (index, str(value))) self.gpio.enable_register_bit(5, index, value) def process_interrupts(self): self.status.Verbose("Process interrupts") value = self.gpio.get_port_raw() interrupts = self.gpio.get_interrupts() self.v.set_register(2, interrupts) self.gpio_actions.gpio_input_changed.emit(value) def interrupt_callback(self): self.status.Verbose("Received interrupt callback") self.gpio_actions.gpio_interrupt.emit()