Migrated from rm-hull/luma.oled#109

see https://github.com/rm-hull/ssd1306/blob/master/oled/serial.py#L96

Also, provide choice in demo_opts: https://github.com/rm-hull/ssd1306/blob/master/examples/demo_opts.py#L24

Was getting this traceback when there wasn't any I2C device connected to the RPi:

$ python examples/3d_box.py -i i2c
...
3d_box.py: error: [Errno 5] Input/output error
Error in atexit._run_exitfuncs:
Traceback (most recent call last):
  File "/home/pi/projects/pi-test/luma.core/luma/core/device.py", line 70, in cleanup
    self.hide()
  File "/home/pi/projects/pi-test/luma.core/luma/core/device.py", line 53, in hide
    self.command(self._const.DISPLAYOFF)
  File "/home/pi/projects/pi-test/luma.core/luma/core/device.py", line 32, in command
    self._serial_interface.command(*cmd)
  File "/home/pi/projects/pi-test/luma.core/luma/core/serial.py", line 63, in command
    self._bus.write_i2c_block_data(self._addr, self._cmd_mode, list(cmd))
  File "/home/pi/.virtualenvs/pi-test/lib/python3.4/site-packages/smbus2/smbus2.py", line 274, in write_i2c_block_data
    ioctl(self.fd, I2C_SMBUS, msg)
OSError: [Errno 5] Input/output error

I thought this OSError business was already fixed before; it should throw a devicenotfound error..

Mention that sub-projects specific issues should be reported in their sub-project's issue tracker, not here in core.

When I try to draw a text containing a unicode character, I get the following error:

error from callback <function on_message at 0xb64edef0>: 'ascii' codec can't encode character u'\u015b' in position 17: ordinal not in range(128)
  File "/usr/local/lib/python2.7/dist-packages/websocket/_app.py", line 269, in _callback
    callback(self, *args)
  File "pushbullet.py", line 48, in on_message
    term.println(title)
  File "/pishare/src/luma.core/luma/core/virtual.py", line 268, in println
    self.puts(text)
  File "/pishare/src/luma.core/luma/core/virtual.py", line 282, in puts
    for method, args in ansi_color.find_directives(text, self):
  File "/pishare/src/luma.core/luma/core/ansi_color.py", line 103, in find_directives
    for directive in parse_str(text):
  File "/pishare/src/luma.core/luma/core/ansi_color.py", line 62, in parse_str
    text = str(text)

Are there any plans to support encodings other than ASCII? Or is that a limitation of the PIL library?

Currently, the terminal class will check that text to be rendered using proportional fonts wont overflow over the right hand edge. If there is not enough width to display the next character, it will insert a newline. For example:

Add a constructor arg setting so that wrapping works at the word level, eg, the above string would render as

The quick brown fox
jumps over the lazy
dog

I am planning to run multiple I²C OLEDs with a Linux-based-Microcomputer which has two I²C interfaces. Now I have some Questions:

• How to enable I²C for example on this diplay? http://www.ebay.de/itm/0-96-I2C-IIC-SPI-Serial-128X64-OLED-LCD-Display-SSD1306-for-Arduino-51-STM32-/272475961798?hash=item3f70d539c6:g:EyUAAOSwo4pYRmeB
• How to select the I²C bus to be used?
• Is it possible to use multiple displays with the same address using an I²C multiplaxer like http://dsscircuits.com/sale/product/dssc0107 ?

Raphael

Somewhat related to rm-hull/luma.lcd#19

Use RPi.GPIO to bit-bang out 4 or 8 bus lines according to the HD44780 datasheet spec. The interface should have the same "shape" as the existing luma.core.interface.serial interfaces - i.e. implement data() and command() methods.

Also: Move luma.core.serial to luma.core.interface.serial and add this new functionality to luma.core.interface.parallel. Various breaking changes to device implementations to rename serial_interface= constructor arg to interface=. (done with #78)

(screen grab from https://cdn-shop.adafruit.com/datasheets/HD44780.pdf)

Hi,
I have an ssd1306 OLED connected to my ThinkPad via i2c and would like to use Luma to access it. However, it seems that it needs RPi.GPIO which obviously makes little sense in my case.
Is there a way to use the standard i2c kernel module instead?

When you visit the github pages for the luma libraries in a mobile browser it doesn't show any useful description in the readme, it only shows the list of links to sub-projects and the title of the library.

I like the new name :)

I'm wondering if splitting up the repo is the right thing to do though. I tend to like being able to grab everything with a single clone.

With a split repo, I'd suggest adding a single repo called just "luma" that would pull in everything, with a "git clone --recursive".

Getting this error with the examples on rpi2:

$ python examples/3d_box.py -i i2c --display sh1106
2017-02-27 00:12:45,674 - [Errno 121] Remote I/O error
Traceback (most recent call last):
  File "/home/pi/projects/pi-test/luma.examples/examples/demo_opts.py", line 87, in <module>
    rotate=args.rotate, mode=args.mode)
  File "/home/pi/projects/pi-test/luma.oled/luma/oled/device.py", line 70, in __init__
    self._const.CHARGEPUMP,         0x14)
  File "/home/pi/projects/pi-test/luma.core/luma/core/device.py", line 39, in command
    self._serial_interface.command(*cmd)
  File "/home/pi/projects/pi-test/luma.core/luma/core/serial.py", line 63, in command
    self._bus.write_i2c_block_data(self._addr, self._cmd_mode, list(cmd))
  File "/home/pi/.virtualenvs/pi-test/lib/python3.5/site-packages/smbus2/smbus2.py", line 274, in write_i2c_block_data
    ioctl(self.fd, I2C_SMBUS, msg)
OSError: [Errno 121] Remote I/O error

I have not hooked up any i2c sh1106 device.

Now that #2 is fixed, we should remove the deprecated bcm_DC and bcm_RST arguments from the spi class somewhere before the version 1.0.0 release.

Add capability wait in event loops rather than relying on time.sleep(...).

ref: https://docs.python.org/3/library/asyncio-eventloop.html#delayed-calls

Hi! We're using luma.oled library in ZPUI, and it's a great success so far. However, the luma-provided canvas was constraining us, so we did our own implementation, based off PIL.Image and PIL.ImageDraw directly. We, of course, used your canvas implementation as a reference.

So, a question about your canvas implementation - on line 45, del is used - what's the reasoning behind it? Is the draw object not collected by GC eventually (IIRC Python can deal with cycling references quite well)?

if an emulator does something different, keep it in it's respective package.

e.g. https://github.com/rm-hull/luma.core/blob/master/luma/core/emulator.py#L236 belongs in the led_matrix package..

Have just experienced this on a branch, but is also happening on master (see https://travis-ci.org/rm-hull/luma.core/jobs/259461663#L313). This did build cleanly on master - it was green, restarted it, and now failing !

@thijstriemstra - any ideas/insight?

• test_i2c_init_device_not_found
• test_i2c_init_device_permission_error

It uses the Apache 2.0 license, which is compatible with the MIT license, which some people rather like to avoid. If you're one of those, use Python 3.4 or newer which doesn't need the monotonic package at all.

See http://setuptools.readthedocs.io/en/latest/setuptools.html#declaring-platform-specific-dependencies

Hi !
As a beginner, I'm trying to understand luma.core, and I'm learning the various concepts and terminology used for GUI.
One thing suprised me: If I read the viewport's page on Wikipedia, it's not the same concept as I understand it in caroussel.py or crawl.py.
From wikipedia:

the viewport is the visible portion of a 2D area which is larger than the visualization device

But in caroussel.py, the viewport is larger than the visualization device.

Am I wrong ?

See https://help.github.com/articles/signing-commits-with-gpg/

I'm trying to write a python script that takes a string as parameter and shows it on the display.
but if I call a simple draw.text() it shows and turn it off the display, i mean, i need to import time and call a delay to see the msg, then the text goes away after the program exits.
My question is if there is some way to let the text on display after script ends?
I was reading about the set of statements with/as, and saw that they are made in a way it guarantees the end of the methods called, i could have understood wrong, but is there another way to call the method draw.text() not using 'with' and 'as'?
If this is not the best or known solution and someone could explain another way of achieve the goal of let the text on the display after the script finishes it's execution it will be great, any help is appreciated.
the device is an orange pi zero, and it's on i2c0, default address0x3c
Thanks in advance for any help!!
Any additional info just ask i will provide asap.

Similar to #41, could be nice to have an alternative bit-banged GPIO interface for serial devices. I'm working on a project with a few screens on the same device, and being able to put a pcd8544 on gpio instead of hardware SPI would be a nice alternative to making all the hardware play nice together.

Could also be a (slow) fallback for those who can't get hardware SPI or I2C running on their oddball systems.

No worries if this seems out of scope for luma!

let's also add *.py.orig to .gitignore..

Disable projects and wiki tabs for sub-projects that do not have a them (all except luma.oled it seems).

When creating a new font, do I need to write a column 0x00 so that there is a space between any two characters?

For example: Assume the number 3 is to be displayed in an area of 3 columns * 8 rows. Assuming it the 3 the bit pattern of the columns is 0x49, 0x49, 0x7F.

Is it necessary to add an additional 0x00 to create a space between any two characters? In such a case the bit patterns of the columns will then be 0x49, 0x49, 0x7F, 0x00.

From what I have observed, every character in the LCD_FONT has its last three columns 0x00 whereas TINY_FONT only has the last column as 0x00.

For my project, I wanted to fit 8 numbers on a single 4in1 cascaded (8*8) matrix using static text. But none of the existing fonts were capable of doing so. TINY_FONT, in my opinion, wasn't looking big enough to read easily whilst optimizing the display area. So I'm currently trying to create a font that is similar to a 7 segment font wherein each character only consumes a fixed area of 3 columns & 7 rows. The 4th column will act as a space between the two characters.
My reference font style is: 7 Segment Font
The 7SEG_FONT only supports Capital Letters(0x41 - 0x5A inclusive) & Numbers(0x30 - 0x39 inclusive). I haven't calculated the bit patterns for any other special characters since I feel that the purpose of this font is only for a few static display alpha-numeric applications.

Hi !
Following my question for menu management #112 I'd like to know if it's possible to support the Sharp memory LCD. These low power LCDs are a good solution when you want something readable under direct sunlight, without the e-ink drawback (slow refresh rate).
I plan to use this lcd on my bike for collection photos for OpenStreetMap contributions (you can see more here).

Sharp Memory LCD doc:
datasheet
programming Memory LCD
Some code on github:
https://github.com/MakerDyne/Memory-LCD-for-Raspberry-Pi

Add an implementation that uses (any) GPIO pins to simulate the SPI protocol in software. It is likely to be slow, but useful for those devices which are hardwired, but not to the SPI pins (WTF?) eg: https://www.amazon.co.uk/SunFounder-Raspberry-PCD8544-Backlight-Compatible/dp/B01GPV7M1W/ref=sr_1_1?ie=UTF8&qid=1485198921&sr=8-1&keywords=pcd8544

See also: https://github.com/adafruit/Adafruit_Python_GPIO/blob/master/Adafruit_GPIO/SPI.py#L150

luma.core v1.0.0 was released but the legacy package still exists. Let's add a deprecation warning and/or note to the module(s) that it'll be removed eventually.

It's currently printed twice (and becoming a long list). I also suggest to use pygame or different emulator as the default option.

  --display {ssd1306,ssd1322,ssd1325,ssd1331,sh1106,pcd8544,st7735,max7219,neopixel,capture,gifanim,pygame}, -d {ssd1306,ssd1322,ssd1325,ssd1331,sh1106,pcd8544,st7735,max7219,neopixel,capture,gifanim,pygame}
                        Display type, supports real devices or emulators
                        (default: ssd1306)

Being able to reuse the demo_opts, argparser code, in luma.examples would be beneficial for sub-projects. You would be able to use the parser code to create a command-line script that handles all compatible luma libraries.

I'm not sure if it belongs in core or a new luma.commandline-something llibrary. Thoughts?

Raspbian stretch includes pip 9.0.1 so the pip upgrade thing is not necessary anymore and should only be recommended when using jessie or older.

https://packages.debian.org/stretch/python-pip

Can we have a new release? 🍰

Some tests are failing on an RPI2 that has i2c/spi enabled.

Getting this warning lately:

/home/pi/projects/pi-test/luma.oled/.tox/py35/lib/python3.5/site-packages/pytest_warnings/__init__.py:44:
UserWarning: pytest-warnings plugin was introduced in core pytest on 3.1, please uninstall pytest-warnings
  warnings.warn('pytest-warnings plugin was introduced in core pytest on 3.1, please '

https://github.com/rm-hull/luma.core/blob/master/luma/core/device.py#L24

What would the consequences be?

Should probably move noop class out of luma.core.serial too.

PCF8574 allows you to use multiple I2C devices (example). Is this something that can be supported?

Migrated from rm-hull/luma.oled#53:

From the docs "Supporting 3-wire SPI would be trivial but has not been implemented yet (no devices to test with)."

See https://github.com/rm-hull/luma.core/blob/master/luma/core/serial.py#L96

bcm is shorthand for 'broadcom' pin assignment, and is specific to RPi implementations, whereas gpio is a more general term, and should be used if ever a generic GPIO library replaces RPi.GPIO

coveralls is being run after each travis build (aka for every python build) which is overkill; only do it once.

Type of Raspberry Pi

Next Thing C.H.I.P.

Linux Kernel version

Linux compy386 4.4.13-ntc-mlc #1 SMP Tue Dec 6 21:38:00 UTC 2016 armv7l GNU/Linux

Expected behaviour

Would love to see support for CHIP_IO, the C.H.I.P. version of RPi.GPIO :) I bet it would be just a few lines in lib.py and serial.py. (I will try this out myself but I am pretty noob.)

Actual behaviour

Traceback (most recent call last):
  File "st7735.py", line 14, in <module>
    serial = spi(port=0, device=0, bcm_DC=23, bcm_RST=24)
  File "/usr/local/lib/python2.7/dist-packages/luma/core/serial.py", line 163, in __init__
    self._gpio = gpio or self.__rpi_gpio__()
  File "/usr/local/lib/python2.7/dist-packages/luma/core/lib.py", line 23, in __rpi_gpio__
    import RPi.GPIO
ImportError: No module named RPi.GPIO

can this script be moved to the docs or a github gist page?

Currently the same instructions to enable spi/i2c are duplicated across the various luma sub-projects. I think common docs like how to enable spi should be in the core docs, and device specific installation instructions belong in the specific sub-project docs.

it mentions something about pygame that we don't use here.

Scrolling with the terminal when the background colour is not black is buggy - see the yellow bar at the bottom.

Hi !
I'm looking for a way to write an interactive menu on a lcd screen connected to an arduino. Something like this one : https://www.youtube.com/watch?v=ak5TsUFhyf8
As I didn't see any component for menu items, is luma a good library to start with ? My python skills are limited.

puts() processes a string of characters one at time, but this could be changed to be made aware of ANSI escape sequences, particularly the color codes below.

On encountering a new (valid) color code, the self.color and/or self.bgcolor could be set accordingly. Also need to consider what the reset code (ESC[0m) would reset the colors to.

(screen grab taken from http://ascii-table.com/ansi-escape-sequences.php)