led-name-badge-ls32/lednamebadge.py

#!/usr/bin/env python3
# -*- encoding: utf-8 -*-
#
# (C) 2019 juergen@fabmail.org
#
# This is an upload tool for e.g.
# https://www.sertronics-shop.de/computer/pc-peripheriegeraete/usb-gadgets/led-name-tag-11x44-pixel-usb
# The font_11x44[] data was downloaded from such a device.
#
# Ubuntu install:
# ---------------
#  sudo apt-get install python3-usb
#
# Optional for image support:
#  sudo apt-get install python3-pil
#
# Windows install:
# ----------------
# For Windows, we need to set up the libusb API for the LED badge device.
# The way described here, uses [libusb-win32](https://github.com/mcuee/libusb-win32/wiki)
# in a quite low level way and in a quite old version:
#
# - Please use version 1.2.6.0 of 'libusb-win32`. It's still available on the
#   [old project repo on SourceForge](https://sourceforge.net/projects/libusb-win32/files/libusb-win32-releases/1.2.6.0/)
# - Then
#     - Extract the downloaded zip file and go to the directory `libusb-win32-bin-1.2.6.0\bin`
#     - Right click on `inf-wizard.exe` and `Run as Administrator`
#     - `Next` -> Select `0x0416 0x5020 LS32 Custm HID` (or similar with the same IDs)
#     - `Next` -> `Next` -> Save as dialog `LS32_Sustm_HID.inf` -> `Save` (just to proceed, we don't need that file)
#     - `Install Now...` -> Driver Install Complete -> `OK`
#
# There are other - meanwhile recommended, but untested here - ways to install and setup
# newer versions of `libusb-win32`: use
# [Zadig](https://zadig.akeo.ie/) (it is also available from the old libusb-win32 repo on
# [GitHub repo](https://github.com/mcuee/libusb-win32/releases) of newer releases)
# or [libusbK](https://libusbk.sourceforge.net/UsbK3/index.html)
#
# Of course, Python is needed:
#
# - Download latest python from [python.org](https://www.python.org/downloads/),
# or specific versions from [here](https://www.python.org/downloads/windows/)
#     - Checkmark the following options
#         - `[x]` install Launcher for all Users
#         - `[x]` Add Python X.Y to PATH
#     - Click the `Install Now ...` text message.
#     - Optionally click on the 'Disable path length limit' text message. This is always a good thing to do.
#
# Install needed the Python packages. On some systems (esp. those with Python 2
# *and* 3 installed), you have to address Python 3 explicitly by using the
# command `pip3` instead of `pip`.
#
# - Run cmd.exe as Administrator, enter:
#
#         pip install pyusb
#         pip install pillow

#
# v0.1, 2019-03-05, jw  initial draught. HID code is much simpler than expected.
# v0.2, 2019-03-07, jw  support for loading bitmaps added.
# v0.3              jw  option -p to preload graphics for inline use in text.
# v0.4, 2019-03-08, jw  Warning about unused images added. Examples added to the README.
# v0.5,             jw  Deprecated -p and CTRL-characters. We now use embedding within colons(:)
#                       Added builtin icons and -l to list them.
# v0.6, 2019-03-14, jw  Added --mode-help with hints and example for making animations.
#                       Options -b --blink, -a --ants added. Removed -p from usage.
# v0.7, 2019-05-20, jw  Support pyhidapi, fallback to usb.core. Added python2 compatibility.
# v0.8, 2019-05-23, jw  Support usb.core on windows via libusb-win32
# v0.9, 2019-07-17, jw  Support 48x12 configuration too.
# v0.10, 2019-09-09, jw Support for loading monochrome images. Typos fixed.
# v0.11, 2019-09-29, jw New option --brightness added.
# v0.12, 2019-12-27, jw hint at pip3 -- as discussed in https://github.com/jnweiger/led-name-badge-ls32/issues/19
# v0.13, 2023-11-14, bs modularization.
#     Some comments about this big change:
#     * I wanted to keep this one-python-file-for-complete-command-line-usage, but also needed to introduce importable
#       classes for writing own content to the device (my upcoming GUI editor). Therefore, the file was renamed to an
#       importable python file, and forwarding python files are introduced with the old file names for full
#       compatibility.
#     * A bit of code rearranging and cleanup was necessary for that goal, but I hope the original parts are still
#       recognizable, as I tried to keep all this refactoring as less, as possible and sense-making, but did not do
#       the full clean-codish refactoring. Keeping the classes in one file is part of that refactoring-omittance.
#     * There is some initialization code executed in the classes not needed, if not imported. This is nagging me
#       somehow, but it is acceptable, as we do not need to save every processor cycle, here :)
#     * Have fun!
# v0.14, 2024-06-02, bs extending write methods.
#     * Preparation for further or updated write methods, like bluetooth.
#     * Automatic or manual write method and device selection, See -M and -D (substituting -H) resp.
#       get_available_methods() and get_available_device_ids().


import argparse
import os
import re
import sys
import time
from array import array
from datetime import datetime


__version = "0.14"


class SimpleTextAndIcons:
    font_11x44 = (
        # 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
        0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00,
        0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x66, 0x66, 0x66, 0xfc, 0x00,
        0x00, 0x7c, 0xc6, 0xc6, 0xc0, 0xc0, 0xc0, 0xc6, 0xc6, 0x7c, 0x00,
        0x00, 0xfc, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0xfc, 0x00,
        0x00, 0xfe, 0x66, 0x62, 0x68, 0x78, 0x68, 0x62, 0x66, 0xfe, 0x00,
        0x00, 0xfe, 0x66, 0x62, 0x68, 0x78, 0x68, 0x60, 0x60, 0xf0, 0x00,
        0x00, 0x7c, 0xc6, 0xc6, 0xc0, 0xc0, 0xce, 0xc6, 0xc6, 0x7e, 0x00,
        0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00,
        0x00, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00,
        0x00, 0x1e, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0x78, 0x00,
        0x00, 0xe6, 0x66, 0x6c, 0x6c, 0x78, 0x6c, 0x6c, 0x66, 0xe6, 0x00,
        0x00, 0xf0, 0x60, 0x60, 0x60, 0x60, 0x60, 0x62, 0x66, 0xfe, 0x00,
        0x00, 0x82, 0xc6, 0xee, 0xfe, 0xd6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00,
        0x00, 0x86, 0xc6, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0xc6, 0xc6, 0x00,
        0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
        0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x60, 0x60, 0x60, 0xf0, 0x00,
        0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xd6, 0xde, 0x7c, 0x06,
        0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x6c, 0x66, 0x66, 0xe6, 0x00,
        0x00, 0x7c, 0xc6, 0xc6, 0x60, 0x38, 0x0c, 0xc6, 0xc6, 0x7c, 0x00,
        0x00, 0x7e, 0x7e, 0x5a, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00,
        0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
        0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00,
        0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xd6, 0xfe, 0xee, 0xc6, 0x82, 0x00,
        0x00, 0xc6, 0xc6, 0x6c, 0x7c, 0x38, 0x7c, 0x6c, 0xc6, 0xc6, 0x00,
        0x00, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x18, 0x18, 0x3c, 0x00,
        0x00, 0xfe, 0xc6, 0x86, 0x0c, 0x18, 0x30, 0x62, 0xc6, 0xfe, 0x00,

        # 'abcdefghijklmnopqrstuvwxyz'
        0x00, 0x00, 0x00, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0x76, 0x00,
        0x00, 0xe0, 0x60, 0x60, 0x7c, 0x66, 0x66, 0x66, 0x66, 0x7c, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc6, 0x7c, 0x00,
        0x00, 0x1c, 0x0c, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc6, 0x7c, 0x00,
        0x00, 0x1c, 0x36, 0x30, 0x78, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x76, 0xcc, 0xcc, 0x7c, 0x0c, 0xcc, 0x78,
        0x00, 0xe0, 0x60, 0x60, 0x6c, 0x76, 0x66, 0x66, 0x66, 0xe6, 0x00,
        0x00, 0x18, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00,
        0x0c, 0x0c, 0x00, 0x1c, 0x0c, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0x78,
        0x00, 0xe0, 0x60, 0x60, 0x66, 0x6c, 0x78, 0x78, 0x6c, 0xe6, 0x00,
        0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00,
        0x00, 0x00, 0x00, 0x00, 0xec, 0xfe, 0xd6, 0xd6, 0xd6, 0xc6, 0x00,
        0x00, 0x00, 0x00, 0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
        0x00, 0x00, 0x00, 0x00, 0xdc, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xf0,
        0x00, 0x00, 0x00, 0x00, 0x7c, 0xcc, 0xcc, 0x7c, 0x0c, 0x0c, 0x1e,
        0x00, 0x00, 0x00, 0x00, 0xde, 0x76, 0x60, 0x60, 0x60, 0xf0, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0x70, 0x1c, 0xc6, 0x7c, 0x00,
        0x00, 0x10, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x34, 0x18, 0x00,
        0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00,
        0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00,
        0x00, 0x00, 0x00, 0x00, 0xc6, 0xd6, 0xd6, 0xd6, 0xfe, 0x6c, 0x00,
        0x00, 0x00, 0x00, 0x00, 0xc6, 0x6c, 0x38, 0x38, 0x6c, 0xc6, 0x00,
        0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x0c, 0xf8,
        0x00, 0x00, 0x00, 0x00, 0xfe, 0x8c, 0x18, 0x30, 0x62, 0xfe, 0x00,

        # '0987654321^ !"\0$%&/()=?` °\\}][{'
        0x00, 0x7c, 0xc6, 0xce, 0xde, 0xf6, 0xe6, 0xc6, 0xc6, 0x7c, 0x00,
        0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x06, 0xc6, 0x7c, 0x00,
        0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
        0x00, 0xfe, 0xc6, 0x06, 0x0c, 0x18, 0x30, 0x30, 0x30, 0x30, 0x00,
        0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
        0x00, 0xfe, 0xc0, 0xc0, 0xfc, 0x06, 0x06, 0x06, 0xc6, 0x7c, 0x00,
        0x00, 0x0c, 0x1c, 0x3c, 0x6c, 0xcc, 0xfe, 0x0c, 0x0c, 0x1e, 0x00,
        0x00, 0x7c, 0xc6, 0x06, 0x06, 0x3c, 0x06, 0x06, 0xc6, 0x7c, 0x00,
        0x00, 0x7c, 0xc6, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc6, 0xfe, 0x00,
        0x00, 0x18, 0x38, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x00,
        0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x3c, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x18, 0x3c, 0x3c, 0x3c, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00,
        0x66, 0x66, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x7c, 0x04, 0x14, 0x18, 0x10, 0x10, 0x20,
        0x10, 0x7c, 0xd6, 0xd6, 0x70, 0x1c, 0xd6, 0xd6, 0x7c, 0x10, 0x10,
        0x00, 0x60, 0x92, 0x96, 0x6c, 0x10, 0x6c, 0xd2, 0x92, 0x0c, 0x00,
        0x00, 0x38, 0x6c, 0x6c, 0x38, 0x76, 0xdc, 0xcc, 0xcc, 0x76, 0x00,
        0x00, 0x00, 0x02, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x80, 0x00,
        0x00, 0x0c, 0x18, 0x30, 0x30, 0x30, 0x30, 0x30, 0x18, 0x0c, 0x00,
        0x00, 0x30, 0x18, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x18, 0x30, 0x00,
        0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x7c, 0xc6, 0xc6, 0x0c, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00,
        0x18, 0x18, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x7c, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x7c,
        0x00, 0x10, 0x28, 0x28, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x80, 0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x02, 0x00, 0x00,
        0x00, 0x70, 0x18, 0x18, 0x18, 0x0e, 0x18, 0x18, 0x18, 0x70, 0x00,
        0x00, 0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3c, 0x00,
        0x00, 0x3c, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3c, 0x00,
        0x00, 0x0e, 0x18, 0x18, 0x18, 0x70, 0x18, 0x18, 0x18, 0x0e, 0x00,

        # "@ ~ |<>,;.:-_#'+* "
        0x00, 0x00, 0x3c, 0x42, 0x9d, 0xa5, 0xad, 0xb6, 0x40, 0x3c, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0x00, 0x00, 0x00,
        0x00, 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x08, 0x08, 0x7c, 0x08, 0x08, 0x18, 0x18, 0x28, 0x28, 0x48, 0x18,
        0x00, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x00,
        0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x00,
        0x00, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x10, 0x20,
        0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x08, 0x10,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00,
        0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
        0x00, 0x6c, 0x6c, 0xfe, 0x6c, 0x6c, 0xfe, 0x6c, 0x6c, 0x00, 0x00,
        0x18, 0x18, 0x08, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x66, 0x3c, 0xff, 0x3c, 0x66, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        # "äöüÄÖÜß"
        0x00, 0xcc, 0xcc, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0x76, 0x00,
        0x00, 0xc6, 0xc6, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
        0x00, 0xcc, 0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00,
        0xc6, 0xc6, 0x38, 0x6c, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00,
        0xc6, 0xc6, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
        0xc6, 0xc6, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
        0x00, 0x3c, 0x66, 0x66, 0x66, 0x7c, 0x66, 0x66, 0x66, 0x6c, 0x60,

        # "àäòöùüèéêëôöûîïÿç"
        0x00, 0x60, 0x18, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0x76, 0x00,
        0x00, 0x6c, 0x6c, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0x76, 0x00,
        0x00, 0x60, 0x18, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
        0x00, 0x6c, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
        0x00, 0x60, 0x18, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00,
        0x00, 0x6c, 0x6c, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00,
        0x00, 0x60, 0x18, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc6, 0x7c, 0x00,
        0x00, 0x18, 0x60, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc6, 0x7c, 0x00,
        0x00, 0x10, 0x6c, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc6, 0x7c, 0x00,
        0x00, 0x6c, 0x6c, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc6, 0x7c, 0x00,
        0x00, 0x10, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
        0x00, 0x6c, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
        0x00, 0x10, 0x6c, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00,
        0x00, 0x10, 0x6c, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00,
        0x00, 0x6c, 0x6c, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00,
        0x00, 0x6c, 0x6c, 0x00, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x0c, 0xf8,
        0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc6, 0x7c, 0x10, 0x30,

        # "ÀÅÄÉÈÊËÖÔÜÛÙŸ"
        0x60, 0x18, 0x38, 0x6c, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00,
        0x10, 0x6c, 0x38, 0x6c, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00,
        0x6c, 0x6c, 0x38, 0x6c, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00,
        0x18, 0x60, 0xfe, 0x62, 0x68, 0x78, 0x68, 0x62, 0x66, 0xfe, 0x00,
        0x60, 0x18, 0xfe, 0x62, 0x68, 0x78, 0x68, 0x62, 0x66, 0xfe, 0x00,
        0x10, 0x6c, 0xfe, 0x62, 0x68, 0x78, 0x68, 0x62, 0x66, 0xfe, 0x00,
        0x6c, 0x6c, 0xfe, 0x62, 0x68, 0x78, 0x68, 0x62, 0x66, 0xfe, 0x00,
        0x6c, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,  # Ö
        0x10, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,  # Ô
        0x6c, 0x6c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,  # Ü
        0x10, 0x6c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,  # Û
        0x60, 0x18, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,  # Ù
        0x66, 0x66, 0x00, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x18, 0x3c, 0x00,  # Ÿ
    )

    charmap = u'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + \
              u'abcdefghijklmnopqrstuvwxyz' + \
              u'0987654321^ !"\0$%&/()=?` °\\}][{' + \
              u"@ ~ |<>,;.:-_#'+* " + \
              u"äöüÄÖÜß" + \
              u"àäòöùüèéêëôöûîïÿç" + \
              u"ÀÅÄÉÈÊËÖÔÜÛÙŸ"

    char_offsets = {}
    for i in range(len(charmap)):
        char_offsets[charmap[i]] = 11 * i
        # print(i, charmap[i], char_offsets[charmap[i]])

    bitmap_named = {
        'ball':      (array('B', (
            0b00000000,
            0b00000000,
            0b00111100,
            0b01111110,
            0b11111111,
            0b11111111,
            0b11111111,
            0b11111111,
            0b01111110,
            0b00111100,
            0b00000000
        )), 1, '\x1e'),
        'happy':     (array('B', (
            0b00000000,  # 0x00
            0b00000000,  # 0x00
            0b00111100,  # 0x3c
            0b01000010,  # 0x42
            0b10100101,  # 0xa5
            0b10000001,  # 0x81
            0b10100101,  # 0xa5
            0b10011001,  # 0x99
            0b01000010,  # 0x42
            0b00111100,  # 0x3c
            0b00000000  # 0x00
        )), 1, '\x1d'),
        'happy2':    (array('B', (0x00, 0x08, 0x14, 0x08, 0x01, 0x00, 0x00, 0x61, 0x30, 0x1c, 0x07,
                                  0x00, 0x20, 0x50, 0x20, 0x00, 0x80, 0x80, 0x86, 0x0c, 0x38, 0xe0)), 2, '\x1c'),
        'heart':     (array('B', (0x00, 0x00, 0x6c, 0x92, 0x82, 0x82, 0x44, 0x28, 0x10, 0x00, 0x00)), 1, '\x1b'),
        'HEART':     (array('B', (0x00, 0x00, 0x6c, 0xfe, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x00)), 1, '\x1a'),
        'heart2':    (array('B', (0x00, 0x0c, 0x12, 0x21, 0x20, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01,
                                  0x00, 0x60, 0x90, 0x08, 0x08, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00)), 2, '\x19'),
        'HEART2':    (array('B', (0x00, 0x0c, 0x1e, 0x3f, 0x3f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01,
                                  0x00, 0x60, 0xf0, 0xf8, 0xf8, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00)), 2, '\x18'),
        'fablab':    (array('B', (0x07, 0x0e, 0x1b, 0x03, 0x21, 0x2c, 0x2e, 0x26, 0x14, 0x1c, 0x06,
                                  0x80, 0x60, 0x30, 0x80, 0x88, 0x38, 0xe8, 0xc8, 0x10, 0x30, 0xc0)), 2, '\x17'),
        'bicycle':   (array('B', (0x01, 0x02, 0x00, 0x01, 0x07, 0x09, 0x12, 0x12, 0x10, 0x08, 0x07,
                                  0x00, 0x87, 0x81, 0x5f, 0x22, 0x94, 0x49, 0x5f, 0x49, 0x80, 0x00,
                                  0x00, 0x80, 0x00, 0x80, 0x70, 0xc8, 0x24, 0xe4, 0x04, 0x88, 0x70)), 3, '\x16'),
        'bicycle_r': (array('B', (0x00, 0x00, 0x00, 0x00, 0x07, 0x09, 0x12, 0x13, 0x10, 0x08, 0x07,
                                  0x00, 0xf0, 0x40, 0xfd, 0x22, 0x94, 0x49, 0xfd, 0x49, 0x80, 0x00,
                                  0x40, 0xa0, 0x80, 0x40, 0x70, 0xc8, 0x24, 0x24, 0x04, 0x88, 0x70)), 3, '\x15'),
        'owncloud':  (array('B', (0x00, 0x01, 0x02, 0x03, 0x06, 0x0c, 0x1a, 0x13, 0x11, 0x19, 0x0f,
                                  0x78, 0xcc, 0x87, 0xfc, 0x42, 0x81, 0x81, 0x81, 0x81, 0x43, 0xbd,
                                  0x00, 0x00, 0x00, 0x80, 0x80, 0xe0, 0x30, 0x10, 0x28, 0x28, 0xd0)), 3, '\x14'),
    }

    bitmap_builtin = {}
    for i in bitmap_named:
        bitmap_builtin[bitmap_named[i][2]] = bitmap_named[i]

    def __init__(self):
        self.bitmap_preloaded = [([], 0)]
        self.bitmaps_preloaded_unused = False

    def add_preload_img(self, filename):
        """Still used by main, but deprecated. PLease use ":"-notation for bitmap() / bitmap_text()"""
        self.bitmap_preloaded.append(SimpleTextAndIcons.bitmap_img(filename))
        self.bitmaps_preloaded_unused = True

    def are_preloaded_unused(self):
        """Still used by main, but deprecated. PLease use ":"-notation for bitmap() / bitmap_text()"""
        return self.bitmaps_preloaded_unused is True

    @staticmethod
    def _get_named_bitmaps_keys():
        return SimpleTextAndIcons.bitmap_named.keys()

    def bitmap_char(self, ch):
        """Returns a tuple of 11 bytes, it is the bitmap data of given character.
            Example: ch = '_' returns (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255).
            The bits in each byte are horizontal, highest bit is left.
        """
        if ord(ch) < 32:
            if ch in SimpleTextAndIcons.bitmap_builtin:
                return SimpleTextAndIcons.bitmap_builtin[ch][:2]

            self.bitmaps_preloaded_unused = False
            return self.bitmap_preloaded[ord(ch)]

        o = SimpleTextAndIcons.char_offsets[ch]
        return SimpleTextAndIcons.font_11x44[o:o + 11], 1

    def bitmap_text(self, text):
        """Returns a tuple of (buffer, length_in_byte_columns_aka_chars)
          We preprocess the text string for substitution patterns
          "::" is replaced with a single ":"
          ":1: is replaced with CTRL-A referencing the first preloaded or loaded image.
          ":happy:" is replaced with a reference to a builtin smiley glyph
          ":heart:" is replaced with a reference to a builtin heart glyph
          ":gfx/logo.png:" preloads the file gfx/logo.png and is replaced the corresponding control char.
        """

        def replace_symbolic(m):
            name = m.group(1)
            if name == '':
                return ':'
            if re.match('^[0-9]*$', name):  # py3 name.isdecimal()
                return chr(int(name))
            if '.' in name:
                self.bitmap_preloaded.append(SimpleTextAndIcons.bitmap_img(name))
                return chr(len(self.bitmap_preloaded) - 1)
            return SimpleTextAndIcons.bitmap_named[name][2]

        text = re.sub(r':([^:]*):', replace_symbolic, text)
        buf = array('B')
        cols = 0
        for c in text:
            (b, n) = self.bitmap_char(c)
            buf.extend(b)
            cols += n
        return buf, cols

    @staticmethod
    def bitmap_img(file):
        """Returns a tuple of (buffer, length_in_byte_columns) representing the given image file.
            It has to be an 8-bit grayscale image or a color image with 8 bit per channel. Color pixels are converted to
            grayscale by arithmetic mean. Threshold for an active led is then > 127.
            If the width is not a multiple on 8 it will be padded with empty pixel-columns.
        """
        try:
            from PIL import Image
        except:
            print("If you like to use images, the module pillow is needed. Try:")
            print("$ pip install pillow")
            LedNameBadge._print_common_install_hints('pillow', 'python3-pillow')
            sys.exit(1)

        im = Image.open(file)
        print("fetching bitmap from file %s -> (%d x %d)" % (file, im.width, im.height))
        if im.height != 11:
            sys.exit("%s: image height must be 11px. Seen %d" % (file, im.height))
        buf = array('B')
        cols = int((im.width + 7) / 8)
        for col in range(cols):
            for row in range(11):  # [0..10]
                byte_val = 0
                for bit in range(8):  # [0..7]
                    bit_val = 0
                    x = 8 * col + bit
                    if x < im.width and row < im.height:
                        pixel_color = im.getpixel((x, row))
                        if isinstance(pixel_color, tuple):
                            monochrome_color = sum(pixel_color[:3]) / len(pixel_color[:3])
                        elif isinstance(pixel_color, int):
                            monochrome_color = pixel_color
                        else:
                            sys.exit("%s: Unknown pixel format detected (%s)!" % (file, pixel_color))
                        if monochrome_color > 127:
                            bit_val = 1 << (7 - bit)
                        byte_val += bit_val
                buf.append(byte_val)
        im.close()
        return buf, cols

    def bitmap(self, arg):
        """If arg is a valid and existing path name, we load it as an image.
            Otherwise, we take it as a string (with ":"-notation, see bitmap_text()).
        """
        if os.path.exists(arg):
            return SimpleTextAndIcons.bitmap_img(arg)
        return self.bitmap_text(arg)


class WriteMethod:
    """Base class for a write method. That is a way to communicate with a device. Think of using different access
    libraries or interfaces for communication. Basically it implements the common parts of the functionalities
    'device detection' and 'write data' and defines te interfaces to the user and the concrete write method class.
    """

    def __init__(self):
        """Call it from your concrete class in your __init__ method with!
        """
        self.devices = {}

    def __del__(self):
        self.close()

    def get_name(self):
        """Returns the name of the write method.
        This method is to be implemented in your concrete class. It should just return a short and unique name.
        """
        raise NotImplementedError()

    def get_description(self):
        """Returns a description of the write method.
        This method is to be implemented in your concrete class. It should just return a short description
        of how the write method communicates with the device (think of libraries and interfaces).
        """
        raise NotImplementedError()

    def open(self, device_id):
        """Opens the communication channel to the device, similar to open a file. The device id is one of the ids
        returned by get_available_devices() or 'auto', which selects just the first device in that dict.
        It is the common part of the opening process. The concrete open is done in _open() and is to be implemented
        individually.
        """
        if self.is_ready() and self.is_device_present():
            actual_device_id = None
            if device_id == 'auto':
                actual_device_id = sorted(self.devices.keys())[0]
            else:
                if device_id in self.devices.keys():
                    actual_device_id = device_id

            if actual_device_id:
                return self._open(actual_device_id)
        return False

    def close(self):
        """Close the communication channel to the device, similar to closing a file.
        This method is to be implemented in your concrete class. It should close and free all handles and resources.
        """
        raise NotImplementedError()

    def get_available_devices(self):
        """Get all devices available via the concrete write method. It returns a dict with the device ids as keys
        and the device descriptions as values. These device ids are used with 'open()' to specify the wanted device.
        It the common part of this process. The concrete part is to be implemented in _get_available_devices()
        individually.
        """
        if self.is_ready() and not self.devices:
            self.devices = self._get_available_devices()
        return {did: data[0] for did, data in self.devices.items()}

    def is_device_present(self):
        """Returns True if there is one or more devices available via the concrete write method, False otherwise.
        """
        self.get_available_devices()
        return self.devices and len(self.devices) > 0

    def _open(self, device_id):
        """The concrete open action. This method is to be implemented in your concrete class. It shall open
        the communication channel to the device with the specified id, which is one of the ids returned by
        _get_available_devices(). It shall return True, if successful, otherwise False. The special id 'auto'
        is handled in open(). So, this method is called only with device ids from the dict returned by
        _get_available_devices().
        """
        raise NotImplementedError()

    def _get_available_devices(self):
        """The concrete get-the-list action. This method is to be implemented in your concrete class. It shall
        Return a dict with one entry per available device. The key of an entry is the device id, like it will be
        used in open() / _open(). The value af an entry is a tuple with any data according to the needs of your
        write method. The only defined element is the first one, which shall be a description of the individual
        device (e.g. manufacturer or bus number / address). E.g. { '1:5': ('Nametag 5 on bus 1', any, data)}
        """
        raise NotImplementedError()

    def is_ready(self):
        """Returns True, if the concrete write method is basically ready for operation, otherwise False.
        This method is to be implemented in your concrete class. Basically, if the import instruction for the
        needed Python modules and potentially a library / module initialization was successful, it shall return True.
        This method does not make any statement about concrete devices or device availability.
        """
        raise NotImplementedError()

    def has_device(self):
        """Returns True, if there is at least one device available with the concrete write method, otherwise False.
        This method is to be implemented in your concrete class.
        """
        raise NotImplementedError()

    def write(self, buf):
        """Call this to write data to the opened device.
        The concrete write action is to be implemented in _write()."""
        self.add_padding(buf, 64)
        self.check_length(buf, 8192)
        self._write(buf)

    @staticmethod
    def add_padding(buf, block_size):
        """The given data array will be extended with zeros according to the given block size. SO, afterwards the
        length of the array is a multiple of block_size.
        """
        need_padding = len(buf) % block_size
        if need_padding:
            buf.extend((0,) * (block_size - need_padding))

    @staticmethod
    def check_length(buf, max_size):
        """Just checks the length of the given data array and abort the program execution if it exceeds max_size.
        """
        if len(buf) > max_size:
            print("Writing more than %d bytes damages the display! Nothing written." % (max_size,))
            sys.exit(1)

    def _write(self, buf):
        """Write the given data array to the opened device.
        This method is to be implemented in your concrete class. It shall write the given data array to the opened
        device.
        """
        raise NotImplementedError()


class WriteLibUsb(WriteMethod):
    """Write to a device using pyusb and libusb. The device ids consist of the bus number, the device number on that bus
    and the endpoint number.
    """
    _module_loaded = False
    try:
        import usb.core
        import usb.util
        _module_loaded = True
        print("Module usb.core detected")
    except:
        pass

    def __init__(self):
        WriteMethod.__init__(self)
        self.description = None
        self.dev = None
        self.endpoint = None

    def get_name(self):
        return 'libusb'

    def get_description(self):
        return 'Program a device connected via USB using the pyusb package and libusb.'

    def _open(self, device_id):
        self.description = self.devices[device_id][0]
        self.dev = self.devices[device_id][1]
        self.endpoint = self.devices[device_id][2]
        print("Libusb device initialized")
        return True

    def close(self):
        if self.dev:
            self.dev.reset()
            WriteLibUsb.usb.util.dispose_resources(self.dev)
        self.description = None
        self.dev = None
        self.endpoint = None

    def _get_available_devices(self):
        devs = WriteLibUsb.usb.core.find(idVendor=0x0416, idProduct=0x5020, find_all=True)
        devices = {}
        for d in devs:
            try:
                # win32: NotImplementedError: is_kernel_driver_active
                if d.is_kernel_driver_active(0):
                    d.detach_kernel_driver(0)
            except:
                pass
            try:
                d.set_configuration()
            except WriteLibUsb.usb.core.USBError:
                # TODO: use all the nice output in _find_write_method(), somehow.
                print("No read access to device list!")
                LedNameBadge._print_sudo_hints()
                sys.exit(1)

            cfg = d.get_active_configuration()[0, 0]
            eps = WriteLibUsb.usb.util.find_descriptor(
                cfg,
                find_all=True,
                custom_match=lambda e: WriteLibUsb.usb.util.endpoint_direction(e.bEndpointAddress) == WriteLibUsb.usb.util.ENDPOINT_OUT)
            for ep in eps:
                did = "%d:%d:%d" % (d.bus, d.address, ep.bEndpointAddress)
                descr = ("%s - %s (bus=%d dev=%d endpoint=%d)" %
                         (d.manufacturer, d.product, d.bus, d.address, ep.bEndpointAddress))
                devices[did] = (descr, d, ep)
        return devices

    def is_ready(self):
        return WriteLibUsb._module_loaded

    def has_device(self):
        return self.dev is not None

    def _write(self, buf):
        if not self.dev:
            return

        try:
            # win32: NotImplementedError: is_kernel_driver_active
            if self.dev.is_kernel_driver_active(0):
                self.dev.detach_kernel_driver(0)
        except:
            pass

        try:
            self.dev.set_configuration()
        except WriteLibUsb.usb.core.USBError:
            # TODO: use all the nice output in _find_write_method(), somehow.
            print("No write access to device!")
            LedNameBadge._print_sudo_hints()
            sys.exit(1)

        print("Write using %s via libusb" % (self.description,))
        for i in range(int(len(buf) / 64)):
            time.sleep(0.1)
            self.endpoint.write(buf[i * 64:i * 64 + 64])


class WriteUsbHidApi(WriteMethod):
    """Write to a device connected to USB using pyhidapi and libhidapi. The device ids are simply the device paths as
    used by libhidapi.
    """
    _module_loaded = False
    try:
        import pyhidapi
        pyhidapi.hid_init()
        _module_loaded = True
        print("Module pyhidapi detected")
    except:
        pass

    def __init__(self):
        WriteMethod.__init__(self)
        self.description = None
        self.path = None
        self.dev = None

    def get_name(self):
        return 'hidapi'

    def get_description(self):
        return 'Program a device connected via USB using the pyhidapi package and libhidapi.'

    def _open(self, device_id):
        self.description = self.devices[device_id][0]
        self.path = self.devices[device_id][1]
        self.dev = WriteUsbHidApi.pyhidapi.hid_open_path(self.path)
        if self.dev:
            print("Hidapi device initialized")

        return self.dev is not None

    def close(self):
        if self.dev is not None:
            WriteUsbHidApi.pyhidapi.hid_close(self.dev)
        self.description = None
        self.path = None
        self.dev = None

    def _get_available_devices(self):
        device_infos = WriteUsbHidApi.pyhidapi.hid_enumerate(0x0416, 0x5020)
        devices = {}
        for d in device_infos:
            did = "%s" % (str(d.path.decode('ascii')),)
            descr = "%s - %s (if=%d)" % (d.manufacturer_string, d.product_string, d.interface_number)
            devices[did] = (descr, d.path)
        return devices

    def is_ready(self):
        return WriteUsbHidApi._module_loaded

    def has_device(self):
        return self.dev is not None

    def _write(self, buf):
        if not self.dev:
            return

        print("Write using [%s] via hidapi" % (self.description,))
        for i in range(int(len(buf) / 64)):
            # sendbuf must contain "report ID" as first byte. "0" does the job here.
            sendbuf = array('B', [0])
            # Then, put the 64 payload bytes into the buffer
            sendbuf.extend(buf[i * 64:i * 64 + 64])
            WriteUsbHidApi.pyhidapi.hid_write(self.dev, sendbuf)


class WriteSerial(WriteMethod):
    """Write to a device with the open-source firmware via the USB serial port using pyserial.
    """
    _module_loaded = False
    try:
        import serial
        _module_loaded = True
        print("Module pyserial detected")
    except:
        pass

    def __init__(self):
        WriteMethod.__init__(self)
        self.description = None
        self.path = None
        self.dev = None

    def get_name(self):
        return 'pyserial'

    def get_description(self):
        return 'Program a device with the open-source firmware, connected via USB, using the pyserial package.'

    def _open(self, device_id):
        import serial
        self.description = self.devices[device_id][0]
        self.path = self.devices[device_id][1]
        self.dev = serial.Serial(self.path)
        if self.dev:
            print("Pyserial device initialized")

        return self.dev is not None

    def close(self):
        if self.dev is not None:
            self.dev.close()
        self.description = None
        self.path = None
        self.dev = None

    def _get_available_devices(self):
        import serial.tools.list_ports
        ports = serial.tools.list_ports.comports()

        devices = {}
        for port, desc, hwid in ports:
            if desc == "n/a": 
                continue
            devices[port] = (f"{desc} ({hwid})", port)
        return devices

    def is_ready(self):
        return WriteSerial._module_loaded

    def has_device(self):
        return self.dev is not None

    def _write(self, buf):
        if not self.dev:
            return

        print("Write using [%s] via pyserial" % (self.description,))
        self.dev.write(buf)


class LedNameBadge:
    _protocol_header_template = (
        0x77, 0x61, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    )

    @staticmethod
    def header(lengths, speeds, modes, blinks, ants, brightness=100, date=datetime.now()):
        """Create a protocol header
            * length, speeds, modes, blinks, ants are iterables with at least one element
            * lengths[0] is the number of chars/byte-columns of the first text/bitmap, lengths[1] of the second,
              and so on...
            * len(length) should match the designated bitmap data
            * speeds come in as 1..8, but will be decremented to 0..7, here.
            * modes: 0..8
            * blinks and ants: 0..1 or even False...True,
            * brightness, if given, is any number, but it'll be limited to 25, 50, 75, 100 (percent), here
            * date, if given, is a datetime object. It will be written in the header, but is not to be seen on the
              devices screen.
        """
        try:
            lengths_sum = sum(lengths)
        except:
            raise TypeError("Please give a list or tuple with at least one number: " + str(lengths))
        if lengths_sum > (8192 - len(LedNameBadge._protocol_header_template)) / 11 + 1:
            raise ValueError("The given lengths seem to be far too high: " + str(lengths))

        ants = LedNameBadge._prepare_iterable(ants, 0, 1)
        blinks = LedNameBadge._prepare_iterable(blinks, 0, 1)
        speeds = LedNameBadge._prepare_iterable(speeds, 1, 8)
        modes = LedNameBadge._prepare_iterable(modes, 0, 8)

        speeds = [x - 1 for x in speeds]

        h = list(LedNameBadge._protocol_header_template)

        if brightness <= 25:
            h[5] = 0x40
        elif brightness <= 50:
            h[5] = 0x20
        elif brightness <= 75:
            h[5] = 0x10
        # else default 100% == 0x00

        for i in range(8):
            h[6] += blinks[i] << i
            h[7] += ants[i] << i

        for i in range(8):
            h[8 + i] = 16 * speeds[i] + modes[i]

        for i in range(len(lengths)):
            h[17 + (2 * i) - 1] = lengths[i] // 256
            h[17 + (2 * i)] = lengths[i] % 256

        try:
            h[38 + 0] = date.year % 100
            h[38 + 1] = date.month
            h[38 + 2] = date.day
            h[38 + 3] = date.hour
            h[38 + 4] = date.minute
            h[38 + 5] = date.second
        except:
            raise TypeError("Please give a datetime object: " + str(date))

        return h

    @staticmethod
    def _prepare_iterable(iterable, min_, max_):
        try:
            iterable = [min(max(x, min_), max_) for x in iterable]
            iterable = tuple(iterable) + (iterable[-1],) * (8 - len(iterable))  # repeat last element
            return iterable
        except:
            raise TypeError("Please give a list or tuple with at least one number: " + str(iterable))

    @staticmethod
    def write(buf, method='auto', device_id='auto'):
        """Write the given buffer to the given device.
            It has to begin with a protocol header as provided by header() and followed by the bitmap data.
            In short: the bitmap data is organized in bytes with 8 horizontal pixels per byte and 11 resp. 12
            bytes per (8 pixels wide) byte-column. Then just put one byte-column after the other and one bitmap
            after the other.
            The two optional parameters specify the write method and device, which shall be programmed. See
            get_available_methods() and get_available_device_ids(). There are two special values each: 'list'
            will print the implemented / available write methods resp. the available devices, 'auto' (default) will
            choose an appropriate write method resp. the first device found.
        """
        write_method = LedNameBadge._find_write_method(method, device_id)
        if write_method:
            write_method.write(buf)
            write_method.close()

    @staticmethod
    def get_available_methods():
        """
        Returns the implemented / available write methods as a dict. Each entry has the method name as the key and a
        tuple as the value with the method description and a boolean indicating the readiness of that write method.
        Basically it is ready if all necessary libraries and Python modules could be loaded. The method name can be
        used as a parameter value for write().
        """
        auto_order_methods = LedNameBadge._get_auto_order_method_list()
        return {m.get_name(): (m.get_description(), m.is_ready()) for m in auto_order_methods}

    @staticmethod
    def get_available_device_ids(method):
        """Returns all devices available via the given write method as a dict. Each entry has the device id as the key
        and the device description as the value. The device id can be used as a parameter value for write().
        """
        auto_order_methods = LedNameBadge._get_auto_order_method_list()
        wanted_method = [m for m in auto_order_methods if m.get_name() == method]
        if wanted_method:
            return wanted_method[0].get_available_devices()
        return []

    @staticmethod
    def _find_write_method(method, device_id):
        """Here we try to concentrate all special cases, decisions and messages around the manual or automatic
        selection of write methods and device. This way it is a bit easier to extend or modify the different
        working run time environments (think of operating system, python version, installed libraries and python
        modules, ands so on.)"""
        auto_order_methods = LedNameBadge._get_auto_order_method_list()
        hidapi = [m for m in auto_order_methods if m.get_name() == 'hidapi'][0]
        libusb = [m for m in auto_order_methods if m.get_name() == 'libusb'][0]

        if method == 'list':
            LedNameBadge._print_available_methods(auto_order_methods)
            sys.exit(0)

        if method not in [m.get_name() for m in auto_order_methods] and method != 'auto':
            print("Unknown write method '%s'." % (method,))
            LedNameBadge._print_available_methods(auto_order_methods)
            sys.exit(1)

        if method == 'auto':
            if sys.version_info[0] < 3:
                method = libusb.get_name()
                print("Preferring method %s over %s with Python 2.x" % (libusb.get_name(), hidapi.get_name()))
                print("because of https://github.com/jnweiger/led-badge-ls32/issues/9")
            elif sys.platform.startswith('darwin'):
                method = hidapi.get_name()
                print("Selected method %s with MacOs" % (hidapi.get_name(),))
            elif sys.platform.startswith('win'):
                method = libusb.get_name()
                print("Selected method %s with Windows" % (libusb.get_name(),))
            elif not libusb.is_ready() and not hidapi.is_ready():
                if sys.version_info[0] < 3 or sys.platform.startswith('win'):
                    LedNameBadge._print_libusb_install_hints(libusb.get_name())
                    sys.exit(1)
                elif sys.platform.startswith('darwin'):
                    LedNameBadge._print_hidapi_install_hints(hidapi.get_name())
                    sys.exit(1)
                else:
                    print("One of the python packages 'pyhidapi' or 'pyusb' is needed to run this program (or both).")
                    LedNameBadge._print_libusb_install_hints(libusb.get_name())
                    LedNameBadge._print_hidapi_install_hints(hidapi.get_name())
                    sys.exit(1)

        if method == libusb.get_name():
            if sys.platform.startswith('darwin'):
                print("For MacOs, please use method '%s' or 'auto'." % (hidapi.get_name(),))
                print("Or help us implementing support for MacOs.")
                sys.exit(1)
            elif not libusb.is_ready():
                LedNameBadge._print_libusb_install_hints(libusb.get_name())
                sys.exit(1)

        if method == hidapi.get_name():
            if sys.version_info[0] < 3:
                print("Please use method '%s' or 'auto' with python-2.x" % (libusb.get_name(),))
                print("because of https://github.com/jnweiger/led-badge-ls32/issues/9")
                sys.exit(1)
            elif not hidapi.is_ready():
                LedNameBadge._print_hidapi_install_hints(hidapi.get_name())
                sys.exit(1)

            if sys.platform.startswith('win') and hidapi.is_ready():
                print("Method '%s' is not tested under Windows. If not working, please use '%s' or 'auto'" % (
                    hidapi.get_name(), libusb.get_name()))
                print("Or help us implementing support for Windows.")
                # But it is not forbidden

        first_method_found = None
        for m in auto_order_methods:
            if method == 'auto' or method == m.get_name():
                if not first_method_found:
                    first_method_found = m
                if device_id == 'list':
                    LedNameBadge._print_available_devices(m)
                    sys.exit(0)
                elif m.open(device_id):
                    return m

        device_id_str = ''
        if device_id != 'auto':
            device_id_str = ' with device_id %s' % (device_id,)

        print("The device is not available with write method '%s'%s." % (method, device_id_str))
        if first_method_found:
            LedNameBadge._print_available_devices(first_method_found)
        print("* Is a led tag device with vendorID 0x0416 and productID 0x5020 connected?")
        if device_id != 'auto':
            print("* Have you given the right device_id?")
            print("  Find the available device ids with option -D list")
        print("* If it is connected and still do not work:")
        LedNameBadge._print_sudo_hints()
        sys.exit(1)

    @staticmethod
    def _get_auto_order_method_list():
        return [WriteUsbHidApi(), WriteLibUsb(), WriteSerial()]

    @staticmethod
    def _print_available_methods(methods):
        print("Available write methods:")
        print("  'auto': selects the most appropriate of the available methods (default)")
        for m in methods:
            LedNameBadge._print_one_method(m)

    @staticmethod
    def _print_one_method(m):
        print("  '%s': %s" % (m.get_name(), m.get_description()))

    @staticmethod
    def _print_available_devices(method_obj):
        if method_obj.is_device_present():
            print("Known device ids with method '%s' are:" % (method_obj.get_name(),))
            for did, descr in sorted(method_obj.get_available_devices().items()):
                LedNameBadge._print_one_device(did, descr)
        else:
            print("No devices with method '%s' found." % (method_obj.get_name(),))

    @staticmethod
    def _print_one_device(did, descr):
        print("  '%s': %s" % (did, descr))

    @staticmethod
    def _print_libusb_install_hints(name):
        print("The method %s is not possible to be used:" % (name,))
        print("The modules 'usb.core' and 'usb.util' could not be loaded.")
        print("* Have you installed the corresponding python package 'pyusb'? Try:")
        print("  $ pip install pyusb")
        LedNameBadge._print_common_install_hints('pyusb', 'python3-usb')
        if sys.platform.startswith('win'):
            print("* Have you installed the libusb driver or libusb-filter for the device?")
        elif sys.platform.startswith('linux'):
            print("* Is the library itself installed? Try the following")
            print("  (or similar, suitable for your distro; the exact command and package name might be different):")
            print("  $ sudo apt-get install libusb-1.0-0")

    @staticmethod
    def _print_hidapi_install_hints(name):
        print("The method %s is not possible to be used:" % (name,))
        print("The module 'pyhidapi' could not be loaded.")
        print("* Have you installed the corresponding python package 'pyhidapi'? Try:")
        print("  $ pip install pyhidapi")
        LedNameBadge._print_common_install_hints('pyhidapi', 'python3-hidapi')
        if sys.platform.startswith('darwin'):
            print("* Have you installed the library itself? Try:")
            print("  $ brew install hidapi")
        elif sys.platform.startswith('linux'):
            print("* Is the library itself installed? Try the following")
            print("  (or similar, suitable for your distro; the exact command and package name might be different):")
            print("  $ sudo apt-get install libhidapi-hidraw0")
            print("* If the library is still not found by the module. Try the following")
            print(
                "  (or similar, suitable for your distro; the exact command, library name and paths might be different):")
            print("  $ sudo ln -s /usr/lib/x86_64-linux-gnu/libhidapi-hidraw.so.0  /usr/local/lib/")

    @staticmethod
    def _print_common_install_hints(pip_package, pm_package):
        print("  (You may need to use pip3 or pip2 instead of pip depending on your python version.)")
        if sys.platform.startswith('win'):
            print("  (You may need to run cmd.exe as Administrator for system wide module installation.)")
        if sys.platform.startswith('linux'):
            print("  (You may need prepend 'sudo' for system wide module installation.)")
            print("  (You may also use your package manager. Try the following, e.g for %s)" % (pip_package,))
            print("  (or similar, suitable for your distro; the exact command and package name might be different):")
            print("  $ sudo apt install %s" % (pm_package,))

    @staticmethod
    def _print_sudo_hints():
        print("Maybe, you have to run this program with administrator rights.")
        if sys.platform.startswith('win'):
            print("* Open start menu, type 'cmd', click 'Run as Administrator'")
        if sys.platform.startswith('linux'):
            print("* If Try with sudo or")
            print("* If you run the program from a virtual env, you may need to open a root shell beforehand.")
            print("* Best: add a udev rule like described in README.md.")


def main():
    parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter,
                                     description='Upload messages or graphics to a 11x44 led badge via USB HID.\nVersion %s from https://github.com/jnweiger/led-badge-ls32\n -- see there for more examples and for updates.' % __version,
                                     epilog='Example combining image and text:\n sudo %s "I:HEART2:you"' % sys.argv[0])
    parser.add_argument('-t', '--type', default='11x44',
                        help="Type of display: supported values are 12x48 or (default) 11x44. Rename the program to led-badge-12x48, to switch the default.")
    parser.add_argument('-H',
                        '--hid',
                        default='0',
                        help="Deprecated, only for backwards compatibility, please use -M! Set to 1 to ensure connect via HID API, program will then not fallback to usb.core library.")
    parser.add_argument('-M',
                        '--method',
                        default='auto',
                        help="Force using the given write method. Use one of 'auto', 'list' or whatever list is printing.")
    parser.add_argument('-D',
                        '--device-id',
                        default='auto',
                        help="Force using the given device id, if ambiguous. Use one of 'auto', 'list' or whatever list is printing.")
    parser.add_argument('-s', '--speed', default='4', help="Scroll speed (Range 1..8). Up to 8 comma-separated values.")
    parser.add_argument('-B', '--brightness', default='100',
                        help="Brightness for the display in percent: 25, 50, 75, or 100.")
    parser.add_argument('-m', '--mode', default='0',
                        help="Up to 8 mode values: Scroll-left(0) -right(1) -up(2) -down(3); still-centered(4); animation(5); drop-down(6); curtain(7); laser(8); See '--mode-help' for more details.")
    parser.add_argument('-b', '--blink', default='0', help="1: blinking, 0: normal. Up to 8 comma-separated values.")
    parser.add_argument('-a',
                        '--ants',
                        default='0',
                        help="1: animated border, 0: normal. Up to 8 comma-separated values.")
    parser.add_argument('-p', '--preload', metavar='FILE', action='append',
                        help=argparse.SUPPRESS)  # "Load bitmap images. Use ^A, ^B, ^C, ... in text messages to make them visible. Deprecated, embed within ':' instead")
    parser.add_argument('-l',
                        '--list-names',
                        action='version',
                        help="list named icons to be embedded in messages and exit.",
                        version=':' + ':  :'.join(SimpleTextAndIcons._get_named_bitmaps_keys()) + ':  ::  or e.g. :path/to/some_icon.png:')
    parser.add_argument('message', metavar='MESSAGE', nargs='+',
                        help="Up to 8 message texts with embedded builtin icons or loaded images within colons(:) -- See -l for a list of builtins.")
    parser.add_argument('--mode-help', action='version', help=argparse.SUPPRESS, version="""
    
    -m 5 "Animation"
    
     Animation frames are 6 character (or 48px) wide. Upload an animation of
     N frames as one image N*48 pixels wide, 11 pixels high.
     Frames run from left to right and repeat endless.
     Speeds [1..8] result in ca. [1.2 1.3 2.0 2.4 2.8 4.5 7.5 15] fps.
    
     Example of a slowly beating heart:
      sudo %s -s1 -m5 "  :heart2:    :HEART2:"
    
    -m 9 "Smooth"
    -m 10 "Rotate"
    
     These modes are mentioned in the BMP Badge software.
     Text is shown static, or sometimes (longer texts?) not shown at all.
     One significant difference is: The text of the first message stays visible after
     upload, even if the USB cable remains connected.
     (No "rotation" or "smoothing"(?) effect can be expected, though)
    """ % sys.argv[0])
    args = parser.parse_args()

    creator = SimpleTextAndIcons()

    if args.preload:
        for filename in args.preload:
            creator.add_preload_img(filename)

    msg_bitmaps = []
    for msg_arg in args.message:
        msg_bitmaps.append(creator.bitmap(msg_arg))

    if creator.are_preloaded_unused():
        print(
            "\nWARNING:\n Your preloaded images are not used.\n Try without '-p' or embed the control character '^A' in your message.\n")

    if '12' in args.type or '12' in sys.argv[0]:
        print("Type: 12x48")
        for msg_bitmap in msg_bitmaps:
            # trivial hack to support 12x48 badges:
            # patch extra empty lines into the message stream.
            for i in reversed(range(1, int(len(msg_bitmap[0]) / 11) + 1)):
                msg_bitmap[0][i * 11:i * 11] = array('B', [0])
    else:
        print("Type: 11x44")

    lengths = [b[1] for b in msg_bitmaps]
    speeds = split_to_ints(args.speed)
    modes = split_to_ints(args.mode)
    blinks = split_to_ints(args.blink)
    ants = split_to_ints(args.ants)
    brightness = int(args.brightness)

    buf = array('B')
    buf.extend(LedNameBadge.header(lengths, speeds, modes, blinks, ants, brightness))

    for msg_bitmap in msg_bitmaps:
        buf.extend(msg_bitmap[0])

    # Translate -H to -M parameter
    method = args.method
    if args.hid == 1:
        print("Option -H is deprecated, please use -M!")
        if not method or method == 'auto':
            method = 'hidapi'
        else:
            sys.exit("Parameter values are ambiguous. Please use -M only.")

    LedNameBadge.write(buf, method, args.device_id)


def split_to_ints(list_str):
    return [int(x) for x in re.split(r'[\s,]+', list_str)]


if __name__ == '__main__':
    main()