def draw():
uni = UnicornHATMini()
uni.clear()
uni.set_rotation(0)
uni.set_brightness(0.1)
display_width, display_height = uni.get_shape()
interval = 60 / 17
interval = 5
while True:
data = getData()
for x in range(display_width):
if x >= len(data):
r = g = 0
else:
r = 255 if data[x] == 0 else 0
g = 255 if data[x] == 1 else 0
for y in range(display_height):
uni.set_pixel(x, y, r, g, 0)
uni.show()
time.sleep(interval)
def __init__(self, color_provider):
hat = UnicornHATMini()
hat.set_rotation(self.DEFAULT_ROTATION)
hat.set_brightness(self.DEFAULT_BRIGHTNESS)
self.display_width, self.display_height = hat.get_shape()
self.unicornhatmini = hat
self.color_provider = color_provider
def test_set_rotation(GPIO, spidev):
from unicornhatmini import UnicornHATMini
unicornhatmini = UnicornHATMini()
shapes = {0: (17, 7), 90: (7, 17), 180: (17, 7), 270: (7, 17)}
for rotation in (0, 90, 180, 270):
unicornhatmini.set_rotation(rotation)
assert unicornhatmini.get_shape() == shapes[rotation]
unicornhatmini.set_pixel(0, 0, 255, 255, 255)
class UnicornHatMiniNotifier(_UnicornHatNotifier):
"""
A notifier for the Unicorn HAT Mini.
"""
def __init__(self, brightness=0.5):
"""
@see _UnicornHatNotifier.__init__()
"""
super(UnicornHatMiniNotifier, self).__init__(brightness=brightness)
from unicornhatmini import UnicornHATMini
self._hat = UnicornHATMini()
def _brightness(self, brightness):
"""
@see _UnicornHatNotifier._brightness
"""
self._hat.set_brightness(brightness)
def _rotation(self, rotation):
"""
@see _UnicornHatNotifier._rotation
"""
self._hat.set_rotation(rotation)
def _get_shape(self):
"""
@see _UnicornHatNotifier._get_shape
"""
return self._hat.get_shape()
def _set_pixel(self, x, y, r, g, b):
"""
@see _UnicornHatNotifier._set_pixel
"""
self._hat.set_pixel(x, y, r, g, b)
def _show(self):
"""
@see _UnicornHatNotifier._show
"""
self._hat.show()
def _off(self):
"""
@see _UnicornHatNotifier._off
"""
self._hat.clear()
self._hat.show()
def draw(width):
uni = UnicornHATMini()
uni.clear()
uni.set_rotation(0)
uni.set_brightness(0.1)
display_width, display_height = uni.get_shape()
r, g, b = getColour(width)
for x in range(display_width):
for y in range(display_height):
if width > x: uni.set_pixel(x, y, r, g, b)
else: uni.set_pixel(x, y, 0, 0, 0)
uni.show()
time.sleep(3)
uni.clear()
uni.show()
def draw(data):
uni = UnicornHATMini()
uni.clear()
uni.set_rotation(0)
uni.set_brightness(0.1)
display_width, display_height = uni.get_shape()
for x in range(display_width):
r = g = 0
if len(data) > x:
if data[x] == 1: g = 255
elif data[x] == 2: r = 255
elif data[x] == 3:
r = 255
g = 150
for y in range(display_height):
uni.set_pixel(x, y, r, g, 0)
uni.show()
time.sleep(2)
uni.clear()
uni.show()
class UnicornWrapper:
def __init__(self, hat=None):
if hat is None:
try:
spidev.SpiDev(0, 0)
hat = 'mini'
except FileNotFoundError:
hat = 'phat'
if hat == 'mini':
self.hat = UnicornHATMini()
self.type = hat
self.hat.set_brightness(0.5)
self.hat.set_rotation(90)
elif hat == 'dummy':
self.hat = None
self.type = 'none'
else:
self.hat = unicornhat
self.type = hat
self.hat.set_layout(unicornhat.PHAT)
self.hat.brightness(0.5)
self.hat.rotation(90)
self.brightness = 0.5
self.rotation = 0
self.width, self.height = self.hat.get_shape()
def getType(self):
return self.type
def getHat(self):
return self.hat
def clear(self):
return self.hat.clear()
def getShape(self):
return self.hat.get_shape()
def setAll(self, r, g, b):
self.hat.set_all(r, g, b)
def getBrightness(self):
if self.type == 'phat':
return self.hat.get_brightness()
return self.brightness
def setBrightness(self, brightness):
self.brightness = brightness
if self.type == 'phat':
f = io.StringIO()
with contextlib.redirect_stdout(f):
self.hat.brightness(brightness)
elif self.type == 'mini':
self.hat.set_brightness(brightness)
def setPixel(self, x, y, r, g, b):
self.hat.set_pixel(x, y, r, g, b)
def setColour(self, r=None, g=None, b=None, RGB=None):
if RGB is not None:
r = RGB[0]
g = RGB[1]
b = RGB[2]
self.hat.clear()
for x in range(self.width):
for y in range(self.height):
self.setPixel(x, y, r, g, b)
self.hat.show()
def setRotation(self, r=0):
if self.type == 'phat':
self.hat.rotation(r)
elif self.type == 'mini':
self.hat.set_rotation(r)
self.rotation = r
def getRotation(self):
return self.rotation
def show(self):
self.hat.show()
def off(self):
self.hat.clear()
self.hat.show()
# Colour converstion operations as we only understand RGB
def hsvIntToRGB(self, h, s, v):
h = h / 360
s = s / 100
v = v / 100
return tuple(round(i * 255) for i in colorsys.hsv_to_rgb(h, s, v))
def htmlToRGB(self, html):
if len(html) is 6:
r = int(f"{html[0]}{html[1]}", 16)
g = int(f"{html[2]}{html[3]}", 16)
b = int(f"{html[4]}{html[5]}", 16)
elif len(html) > 6:
r = int(f"{html[1]}{html[2]}", 16)
g = int(f"{html[3]}{html[4]}", 16)
b = int(f"{html[5]}{html[6]}", 16)
else:
raise Exception(
"The Hex value is not in the correct format it should RRGGBB or #RRGGBB the same as HTML"
)
return tuple(r, g, b)
import time
from unicornhatmini import UnicornHATMini
print("""
Unicorn HAT Mini: The game of life
Press Ctrl+C to exit!
""")
# Avoid retina-searage!
unicornhatmini = UnicornHATMini()
unicornhatmini.set_brightness(0.1)
unicornhatmini.set_rotation(0)
# The height and width of the forest.
width, height = unicornhatmini.get_shape()
# Initial probability of a grid square having a tree
initial_life = 0.25
# p = probability of life growing, f = probability of fire
p = 0.0001
f = 0.0005
# Each square's neighbour coordinates
hood = ((-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1))
# button stub
button_map = {5: "A", 6: "B", 16: "X", 24: "Y"}
button_a = Button(5)
class Writer():
def __init__(self):
self.uni = UnicornHATMini()
self.uni.clear()
self.uni.set_rotation(0)
self.uni.set_brightness(0.1)
display_width, display_height = self.uni.get_shape()
self.display_width = display_width
self.display_height = display_height
self.font = ImageFont.truetype(
os.path.dirname(os.path.realpath(__file__)) + "/5x7.ttf", 8)
def drawText(self, text):
text_width, text_height = self.font.getsize(text)
image = Image.new('P', (text_width + self.display_width +
self.display_width, self.display_height), 0)
draw = ImageDraw.Draw(image)
draw.text((self.display_width, -1), text, font=self.font, fill=255)
return image
def getColour(self, s):
if s == "Rainbow": return s
mapValue = {
"Red": "255,10,0",
"Green": "0,255,10",
"Blue": "0,10,255",
"White": "255,255,255",
"Black": "0,0,0"
}[s]
try:
r, g, b = mapValue.split(",")
except NameError:
r, g, b = s.split(",")
return [int(r), int(g), int(b)]
def scroll(self, text, colour="Rainbow", show_total=1):
image = self.drawText(text)
show_count = 0
offset_x = 0
if colour != "Rainbow": r, g, b = self.getColour(colour)
while show_count < show_total:
for y in range(self.display_height):
for x in range(self.display_width):
hue = (time.time() /
10.0) + (x / float(self.display_width * 2))
if colour == "Rainbow":
r, g, b = [
int(c * 255) for c in hsv_to_rgb(hue, 1.0, 1.0)
]
if image.getpixel((x + offset_x, y)) == 255:
self.uni.set_pixel(x, y, r, g, b)
else:
self.uni.set_pixel(x, y, 0, 0, 0)
offset_x += 1
if offset_x + self.display_width > image.size[0]:
offset_x = 0
show_count = show_count + 1
self.uni.show()
time.sleep(0.05)
def clear(self):
self.uni.clear()
self.uni.show()
time.sleep(0.05)
# The text we want to display. You should probably keep this line and replace it below
# That way you'll have a guide as to what characters are supported!
text = "abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789 #@&!?{}<>[]();:.,'%*=+-=$_\\/ :-)"
unicornhatmini = UnicornHATMini()
rotation = 0
if len(sys.argv) > 1:
try:
rotation = int(sys.argv[1])
except ValueError:
print("Usage: {} <rotation>".format(sys.argv[0]))
sys.exit(1)
unicornhatmini.set_rotation(rotation)
display_width, display_height = unicornhatmini.get_shape()
print("{}x{}".format(display_width, display_height))
unicornhatmini.set_brightness(0.1)
font = ImageFont.truetype("5x7.ttf", 8)
text_width, text_height = font.getsize(text)
image = Image.new('P',
(text_width + display_width + display_width, display_height),
0)
draw = ImageDraw.Draw(image)
# Draw the text into the image