Last active
August 29, 2015 14:11
-
-
Save nvbn/80c7b434ee21c99f013d to your computer and use it in GitHub Desktop.
pyboard uasyncio CPS example
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
from uasyncio.core import get_event_loop | |
from ssd1306 import get_display | |
from ultrasonic import get_ultrasonic | |
from utils import get_gyro, alts | |
def main(): | |
display = get_display(pinout={'sda': 'Y10', | |
'scl': 'Y9'}, | |
height=64, | |
external_vcc=False) | |
current = {'dist': 0, 'xyz': (0, 0, 0)} | |
shared_q = alts(dist=get_ultrasonic('X1', 'X2'), | |
xyz=get_gyro()) | |
while True: | |
source, val = yield from shared_q.get() | |
current[source] = val | |
yield from display.put( | |
'Distance: {:0.2f}cm\n' | |
'x: {} y: {} z: {}'.format(current['dist'], *current['xyz'])) | |
loop = get_event_loop() | |
loop.call_soon(main()) | |
loop.run_forever() |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
# Originally: https://raw.githubusercontent.com/khenderick/micropython-drivers/master/ssd1306/ssd1306.py | |
# The MIT License (MIT) | |
# | |
# Copyright (c) 2014 Kenneth Henderick | |
# | |
# Permission is hereby granted, free of charge, to any person obtaining a copy | |
# of this software and associated documentation files (the "Software"), to deal | |
# in the Software without restriction, including without limitation the rights | |
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
# copies of the Software, and to permit persons to whom the Software is | |
# furnished to do so, subject to the following conditions: | |
# | |
# The above copyright notice and this permission notice shall be included in | |
# all copies or substantial portions of the Software. | |
# | |
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
# THE SOFTWARE. | |
import pyb | |
from utils import chan | |
# Constants | |
DISPLAYOFF = 0xAE | |
SETCONTRAST = 0x81 | |
DISPLAYALLON_RESUME = 0xA4 | |
DISPLAYALLON = 0xA5 | |
NORMALDISPLAY = 0xA6 | |
INVERTDISPLAY = 0xA7 | |
DISPLAYON = 0xAF | |
SETDISPLAYOFFSET = 0xD3 | |
SETCOMPINS = 0xDA | |
SETVCOMDETECT = 0xDB | |
SETDISPLAYCLOCKDIV = 0xD5 | |
SETPRECHARGE = 0xD9 | |
SETMULTIPLEX = 0xA8 | |
SETLOWCOLUMN = 0x00 | |
SETHIGHCOLUMN = 0x10 | |
SETSTARTLINE = 0x40 | |
MEMORYMODE = 0x20 | |
COLUMNADDR = 0x21 | |
PAGEADDR = 0x22 | |
COMSCANINC = 0xC0 | |
COMSCANDEC = 0xC8 | |
SEGREMAP = 0xA0 | |
CHARGEPUMP = 0x8D | |
EXTERNALVCC = 0x10 | |
SWITCHCAPVCC = 0x20 | |
SETPAGEADDR = 0xB0 | |
SETCOLADDR_LOW = 0x00 | |
SETCOLADDR_HIGH = 0x10 | |
ACTIVATE_SCROLL = 0x2F | |
DEACTIVATE_SCROLL = 0x2E | |
SET_VERTICAL_SCROLL_AREA = 0xA3 | |
RIGHT_HORIZONTAL_SCROLL = 0x26 | |
LEFT_HORIZONTAL_SCROLL = 0x27 | |
VERTICAL_AND_RIGHT_HORIZONTAL_SCROLL = 0x29 | |
VERTICAL_AND_LEFT_HORIZONTAL_SCROLL = 0x2A | |
# I2C devices are accessed through a Device ID. This is a 7-bit | |
# value but is sometimes expressed left-shifted by 1 as an 8-bit value. | |
# A pin on SSD1306 allows it to respond to ID 0x3C or 0x3D. The board | |
# I bought from ebay used a 0-ohm resistor to select between "0x78" | |
# (0x3c << 1) or "0x7a" (0x3d << 1). The default was set to "0x78" | |
DEVID = 0x3c | |
# I2C communication here is either <DEVID> <CTL_CMD> <command byte> | |
# or <DEVID> <CTL_DAT> <display buffer bytes> <> <> <> <>... | |
# These two values encode the Co (Continuation) bit as b7 and the | |
# D/C# (Data/Command Selection) bit as b6. | |
CTL_CMD = 0x80 | |
CTL_DAT = 0x40 | |
class Font5x8: | |
cols = 5 | |
rows = 8 | |
bytes = [ | |
0x00, 0x00, 0x00, 0x00, 0x00, | |
0x3E, 0x5B, 0x4F, 0x5B, 0x3E, | |
0x3E, 0x6B, 0x4F, 0x6B, 0x3E, | |
0x1C, 0x3E, 0x7C, 0x3E, 0x1C, | |
0x18, 0x3C, 0x7E, 0x3C, 0x18, | |
0x1C, 0x57, 0x7D, 0x57, 0x1C, | |
0x1C, 0x5E, 0x7F, 0x5E, 0x1C, | |
0x00, 0x18, 0x3C, 0x18, 0x00, | |
0xFF, 0xE7, 0xC3, 0xE7, 0xFF, | |
0x00, 0x18, 0x24, 0x18, 0x00, | |
0xFF, 0xE7, 0xDB, 0xE7, 0xFF, | |
0x30, 0x48, 0x3A, 0x06, 0x0E, | |
0x26, 0x29, 0x79, 0x29, 0x26, | |
0x40, 0x7F, 0x05, 0x05, 0x07, | |
0x40, 0x7F, 0x05, 0x25, 0x3F, | |
0x5A, 0x3C, 0xE7, 0x3C, 0x5A, | |
0x7F, 0x3E, 0x1C, 0x1C, 0x08, | |
0x08, 0x1C, 0x1C, 0x3E, 0x7F, | |
0x14, 0x22, 0x7F, 0x22, 0x14, | |
0x5F, 0x5F, 0x00, 0x5F, 0x5F, | |
0x06, 0x09, 0x7F, 0x01, 0x7F, | |
0x00, 0x66, 0x89, 0x95, 0x6A, | |
0x60, 0x60, 0x60, 0x60, 0x60, | |
0x94, 0xA2, 0xFF, 0xA2, 0x94, | |
0x08, 0x04, 0x7E, 0x04, 0x08, | |
0x10, 0x20, 0x7E, 0x20, 0x10, | |
0x08, 0x08, 0x2A, 0x1C, 0x08, | |
0x08, 0x1C, 0x2A, 0x08, 0x08, | |
0x1E, 0x10, 0x10, 0x10, 0x10, | |
0x0C, 0x1E, 0x0C, 0x1E, 0x0C, | |
0x30, 0x38, 0x3E, 0x38, 0x30, | |
0x06, 0x0E, 0x3E, 0x0E, 0x06, | |
0x00, 0x00, 0x00, 0x00, 0x00, | |
0x00, 0x00, 0x5F, 0x00, 0x00, | |
0x00, 0x07, 0x00, 0x07, 0x00, | |
0x14, 0x7F, 0x14, 0x7F, 0x14, | |
0x24, 0x2A, 0x7F, 0x2A, 0x12, | |
0x23, 0x13, 0x08, 0x64, 0x62, | |
0x36, 0x49, 0x56, 0x20, 0x50, | |
0x00, 0x08, 0x07, 0x03, 0x00, | |
0x00, 0x1C, 0x22, 0x41, 0x00, | |
0x00, 0x41, 0x22, 0x1C, 0x00, | |
0x2A, 0x1C, 0x7F, 0x1C, 0x2A, | |
0x08, 0x08, 0x3E, 0x08, 0x08, | |
0x00, 0x80, 0x70, 0x30, 0x00, | |
0x08, 0x08, 0x08, 0x08, 0x08, | |
0x00, 0x00, 0x60, 0x60, 0x00, | |
0x20, 0x10, 0x08, 0x04, 0x02, | |
0x3E, 0x51, 0x49, 0x45, 0x3E, | |
0x00, 0x42, 0x7F, 0x40, 0x00, | |
0x72, 0x49, 0x49, 0x49, 0x46, | |
0x21, 0x41, 0x49, 0x4D, 0x33, | |
0x18, 0x14, 0x12, 0x7F, 0x10, | |
0x27, 0x45, 0x45, 0x45, 0x39, | |
0x3C, 0x4A, 0x49, 0x49, 0x31, | |
0x41, 0x21, 0x11, 0x09, 0x07, | |
0x36, 0x49, 0x49, 0x49, 0x36, | |
0x46, 0x49, 0x49, 0x29, 0x1E, | |
0x00, 0x00, 0x14, 0x00, 0x00, | |
0x00, 0x40, 0x34, 0x00, 0x00, | |
0x00, 0x08, 0x14, 0x22, 0x41, | |
0x14, 0x14, 0x14, 0x14, 0x14, | |
0x00, 0x41, 0x22, 0x14, 0x08, | |
0x02, 0x01, 0x59, 0x09, 0x06, | |
0x3E, 0x41, 0x5D, 0x59, 0x4E, | |
0x7C, 0x12, 0x11, 0x12, 0x7C, | |
0x7F, 0x49, 0x49, 0x49, 0x36, | |
0x3E, 0x41, 0x41, 0x41, 0x22, | |
0x7F, 0x41, 0x41, 0x41, 0x3E, | |
0x7F, 0x49, 0x49, 0x49, 0x41, | |
0x7F, 0x09, 0x09, 0x09, 0x01, | |
0x3E, 0x41, 0x41, 0x51, 0x73, | |
0x7F, 0x08, 0x08, 0x08, 0x7F, | |
0x00, 0x41, 0x7F, 0x41, 0x00, | |
0x20, 0x40, 0x41, 0x3F, 0x01, | |
0x7F, 0x08, 0x14, 0x22, 0x41, | |
0x7F, 0x40, 0x40, 0x40, 0x40, | |
0x7F, 0x02, 0x1C, 0x02, 0x7F, | |
0x7F, 0x04, 0x08, 0x10, 0x7F, | |
0x3E, 0x41, 0x41, 0x41, 0x3E, | |
0x7F, 0x09, 0x09, 0x09, 0x06, | |
0x3E, 0x41, 0x51, 0x21, 0x5E, | |
0x7F, 0x09, 0x19, 0x29, 0x46, | |
0x26, 0x49, 0x49, 0x49, 0x32, | |
0x03, 0x01, 0x7F, 0x01, 0x03, | |
0x3F, 0x40, 0x40, 0x40, 0x3F, | |
0x1F, 0x20, 0x40, 0x20, 0x1F, | |
0x3F, 0x40, 0x38, 0x40, 0x3F, | |
0x63, 0x14, 0x08, 0x14, 0x63, | |
0x03, 0x04, 0x78, 0x04, 0x03, | |
0x61, 0x59, 0x49, 0x4D, 0x43, | |
0x00, 0x7F, 0x41, 0x41, 0x41, | |
0x02, 0x04, 0x08, 0x10, 0x20, | |
0x00, 0x41, 0x41, 0x41, 0x7F, | |
0x04, 0x02, 0x01, 0x02, 0x04, | |
0x40, 0x40, 0x40, 0x40, 0x40, | |
0x00, 0x03, 0x07, 0x08, 0x00, | |
0x20, 0x54, 0x54, 0x78, 0x40, | |
0x7F, 0x28, 0x44, 0x44, 0x38, | |
0x38, 0x44, 0x44, 0x44, 0x28, | |
0x38, 0x44, 0x44, 0x28, 0x7F, | |
0x38, 0x54, 0x54, 0x54, 0x18, | |
0x00, 0x08, 0x7E, 0x09, 0x02, | |
0x18, 0xA4, 0xA4, 0x9C, 0x78, | |
0x7F, 0x08, 0x04, 0x04, 0x78, | |
0x00, 0x44, 0x7D, 0x40, 0x00, | |
0x20, 0x40, 0x40, 0x3D, 0x00, | |
0x7F, 0x10, 0x28, 0x44, 0x00, | |
0x00, 0x41, 0x7F, 0x40, 0x00, | |
0x7C, 0x04, 0x78, 0x04, 0x78, | |
0x7C, 0x08, 0x04, 0x04, 0x78, | |
0x38, 0x44, 0x44, 0x44, 0x38, | |
0xFC, 0x18, 0x24, 0x24, 0x18, | |
0x18, 0x24, 0x24, 0x18, 0xFC, | |
0x7C, 0x08, 0x04, 0x04, 0x08, | |
0x48, 0x54, 0x54, 0x54, 0x24, | |
0x04, 0x04, 0x3F, 0x44, 0x24, | |
0x3C, 0x40, 0x40, 0x20, 0x7C, | |
0x1C, 0x20, 0x40, 0x20, 0x1C, | |
0x3C, 0x40, 0x30, 0x40, 0x3C, | |
0x44, 0x28, 0x10, 0x28, 0x44, | |
0x4C, 0x90, 0x90, 0x90, 0x7C, | |
0x44, 0x64, 0x54, 0x4C, 0x44, | |
0x00, 0x08, 0x36, 0x41, 0x00, | |
0x00, 0x00, 0x77, 0x00, 0x00, | |
0x00, 0x41, 0x36, 0x08, 0x00, | |
0x02, 0x01, 0x02, 0x04, 0x02, | |
0x3C, 0x26, 0x23, 0x26, 0x3C, | |
0x1E, 0xA1, 0xA1, 0x61, 0x12, | |
0x3A, 0x40, 0x40, 0x20, 0x7A, | |
0x38, 0x54, 0x54, 0x55, 0x59, | |
0x21, 0x55, 0x55, 0x79, 0x41, | |
0x21, 0x54, 0x54, 0x78, 0x41, | |
0x21, 0x55, 0x54, 0x78, 0x40, | |
0x20, 0x54, 0x55, 0x79, 0x40, | |
0x0C, 0x1E, 0x52, 0x72, 0x12, | |
0x39, 0x55, 0x55, 0x55, 0x59, | |
0x39, 0x54, 0x54, 0x54, 0x59, | |
0x39, 0x55, 0x54, 0x54, 0x58, | |
0x00, 0x00, 0x45, 0x7C, 0x41, | |
0x00, 0x02, 0x45, 0x7D, 0x42, | |
0x00, 0x01, 0x45, 0x7C, 0x40, | |
0xF0, 0x29, 0x24, 0x29, 0xF0, | |
0xF0, 0x28, 0x25, 0x28, 0xF0, | |
0x7C, 0x54, 0x55, 0x45, 0x00, | |
0x20, 0x54, 0x54, 0x7C, 0x54, | |
0x7C, 0x0A, 0x09, 0x7F, 0x49, | |
0x32, 0x49, 0x49, 0x49, 0x32, | |
0x32, 0x48, 0x48, 0x48, 0x32, | |
0x32, 0x4A, 0x48, 0x48, 0x30, | |
0x3A, 0x41, 0x41, 0x21, 0x7A, | |
0x3A, 0x42, 0x40, 0x20, 0x78, | |
0x00, 0x9D, 0xA0, 0xA0, 0x7D, | |
0x39, 0x44, 0x44, 0x44, 0x39, | |
0x3D, 0x40, 0x40, 0x40, 0x3D, | |
0x3C, 0x24, 0xFF, 0x24, 0x24, | |
0x48, 0x7E, 0x49, 0x43, 0x66, | |
0x2B, 0x2F, 0xFC, 0x2F, 0x2B, | |
0xFF, 0x09, 0x29, 0xF6, 0x20, | |
0xC0, 0x88, 0x7E, 0x09, 0x03, | |
0x20, 0x54, 0x54, 0x79, 0x41, | |
0x00, 0x00, 0x44, 0x7D, 0x41, | |
0x30, 0x48, 0x48, 0x4A, 0x32, | |
0x38, 0x40, 0x40, 0x22, 0x7A, | |
0x00, 0x7A, 0x0A, 0x0A, 0x72, | |
0x7D, 0x0D, 0x19, 0x31, 0x7D, | |
0x26, 0x29, 0x29, 0x2F, 0x28, | |
0x26, 0x29, 0x29, 0x29, 0x26, | |
0x30, 0x48, 0x4D, 0x40, 0x20, | |
0x38, 0x08, 0x08, 0x08, 0x08, | |
0x08, 0x08, 0x08, 0x08, 0x38, | |
0x2F, 0x10, 0xC8, 0xAC, 0xBA, | |
0x2F, 0x10, 0x28, 0x34, 0xFA, | |
0x00, 0x00, 0x7B, 0x00, 0x00, | |
0x08, 0x14, 0x2A, 0x14, 0x22, | |
0x22, 0x14, 0x2A, 0x14, 0x08, | |
0xAA, 0x00, 0x55, 0x00, 0xAA, | |
0xAA, 0x55, 0xAA, 0x55, 0xAA, | |
0x00, 0x00, 0x00, 0xFF, 0x00, | |
0x10, 0x10, 0x10, 0xFF, 0x00, | |
0x14, 0x14, 0x14, 0xFF, 0x00, | |
0x10, 0x10, 0xFF, 0x00, 0xFF, | |
0x10, 0x10, 0xF0, 0x10, 0xF0, | |
0x14, 0x14, 0x14, 0xFC, 0x00, | |
0x14, 0x14, 0xF7, 0x00, 0xFF, | |
0x00, 0x00, 0xFF, 0x00, 0xFF, | |
0x14, 0x14, 0xF4, 0x04, 0xFC, | |
0x14, 0x14, 0x17, 0x10, 0x1F, | |
0x10, 0x10, 0x1F, 0x10, 0x1F, | |
0x14, 0x14, 0x14, 0x1F, 0x00, | |
0x10, 0x10, 0x10, 0xF0, 0x00, | |
0x00, 0x00, 0x00, 0x1F, 0x10, | |
0x10, 0x10, 0x10, 0x1F, 0x10, | |
0x10, 0x10, 0x10, 0xF0, 0x10, | |
0x00, 0x00, 0x00, 0xFF, 0x10, | |
0x10, 0x10, 0x10, 0x10, 0x10, | |
0x10, 0x10, 0x10, 0xFF, 0x10, | |
0x00, 0x00, 0x00, 0xFF, 0x14, | |
0x00, 0x00, 0xFF, 0x00, 0xFF, | |
0x00, 0x00, 0x1F, 0x10, 0x17, | |
0x00, 0x00, 0xFC, 0x04, 0xF4, | |
0x14, 0x14, 0x17, 0x10, 0x17, | |
0x14, 0x14, 0xF4, 0x04, 0xF4, | |
0x00, 0x00, 0xFF, 0x00, 0xF7, | |
0x14, 0x14, 0x14, 0x14, 0x14, | |
0x14, 0x14, 0xF7, 0x00, 0xF7, | |
0x14, 0x14, 0x14, 0x17, 0x14, | |
0x10, 0x10, 0x1F, 0x10, 0x1F, | |
0x14, 0x14, 0x14, 0xF4, 0x14, | |
0x10, 0x10, 0xF0, 0x10, 0xF0, | |
0x00, 0x00, 0x1F, 0x10, 0x1F, | |
0x00, 0x00, 0x00, 0x1F, 0x14, | |
0x00, 0x00, 0x00, 0xFC, 0x14, | |
0x00, 0x00, 0xF0, 0x10, 0xF0, | |
0x10, 0x10, 0xFF, 0x10, 0xFF, | |
0x14, 0x14, 0x14, 0xFF, 0x14, | |
0x10, 0x10, 0x10, 0x1F, 0x00, | |
0x00, 0x00, 0x00, 0xF0, 0x10, | |
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, | |
0xF0, 0xF0, 0xF0, 0xF0, 0xF0, | |
0xFF, 0xFF, 0xFF, 0x00, 0x00, | |
0x00, 0x00, 0x00, 0xFF, 0xFF, | |
0x0F, 0x0F, 0x0F, 0x0F, 0x0F, | |
0x38, 0x44, 0x44, 0x38, 0x44, | |
0x7C, 0x2A, 0x2A, 0x3E, 0x14, | |
0x7E, 0x02, 0x02, 0x06, 0x06, | |
0x02, 0x7E, 0x02, 0x7E, 0x02, | |
0x63, 0x55, 0x49, 0x41, 0x63, | |
0x38, 0x44, 0x44, 0x3C, 0x04, | |
0x40, 0x7E, 0x20, 0x1E, 0x20, | |
0x06, 0x02, 0x7E, 0x02, 0x02, | |
0x99, 0xA5, 0xE7, 0xA5, 0x99, | |
0x1C, 0x2A, 0x49, 0x2A, 0x1C, | |
0x4C, 0x72, 0x01, 0x72, 0x4C, | |
0x30, 0x4A, 0x4D, 0x4D, 0x30, | |
0x30, 0x48, 0x78, 0x48, 0x30, | |
0xBC, 0x62, 0x5A, 0x46, 0x3D, | |
0x3E, 0x49, 0x49, 0x49, 0x00, | |
0x7E, 0x01, 0x01, 0x01, 0x7E, | |
0x2A, 0x2A, 0x2A, 0x2A, 0x2A, | |
0x44, 0x44, 0x5F, 0x44, 0x44, | |
0x40, 0x51, 0x4A, 0x44, 0x40, | |
0x40, 0x44, 0x4A, 0x51, 0x40, | |
0x00, 0x00, 0xFF, 0x01, 0x03, | |
0xE0, 0x80, 0xFF, 0x00, 0x00, | |
0x08, 0x08, 0x6B, 0x6B, 0x08, | |
0x36, 0x12, 0x36, 0x24, 0x36, | |
0x06, 0x0F, 0x09, 0x0F, 0x06, | |
0x00, 0x00, 0x18, 0x18, 0x00, | |
0x00, 0x00, 0x10, 0x10, 0x00, | |
0x30, 0x40, 0xFF, 0x01, 0x01, | |
0x00, 0x1F, 0x01, 0x01, 0x1E, | |
0x00, 0x19, 0x1D, 0x17, 0x12, | |
0x00, 0x3C, 0x3C, 0x3C, 0x3C, | |
0x00, 0x00, 0x00, 0x00, 0x00, | |
] | |
class SSD1306(object): | |
def __init__(self, pinout, height=32, external_vcc=True, i2c_devid=DEVID): | |
self.external_vcc = external_vcc | |
self.height = 32 if height == 32 else 64 | |
self.pages = int(self.height / 8) | |
self.columns = 128 | |
self.font = Font5x8() | |
# Infer interface type from entries in pinout{} | |
if 'dc' in pinout: | |
# SPI | |
rate = 16 * 1024 * 1024 | |
self.spi = pyb.SPI(2, pyb.SPI.MASTER, baudrate=rate, polarity=1, phase=0) # SCK: Y6: MOSI: Y8 | |
self.dc = pyb.Pin(pinout['dc'], pyb.Pin.OUT_PP, pyb.Pin.PULL_DOWN) | |
self.res = pyb.Pin(pinout['res'], pyb.Pin.OUT_PP, pyb.Pin.PULL_DOWN) | |
self.offset = 0 | |
else: | |
# Infer bus number from pin | |
if pinout['sda'] == 'X9': | |
self.i2c = pyb.I2C(1) | |
else: | |
self.i2c = pyb.I2C(2) | |
self.i2c.init(pyb.I2C.MASTER, baudrate=400000) # 400kHz | |
self.devid = i2c_devid | |
# used to reserve an extra byte in the image buffer AND as a way to | |
# infer the interface type | |
self.offset = 1 | |
# I2C command buffer | |
self.cbuffer = bytearray(2) | |
self.cbuffer[0] = CTL_CMD | |
def clear(self): | |
self.buffer = bytearray(self.offset + self.pages * self.columns) | |
if self.offset == 1: | |
self.buffer[0] = CTL_DAT | |
def write_command(self, command_byte): | |
if self.offset == 1: | |
self.cbuffer[1] = command_byte | |
self.i2c.send(self.cbuffer, addr=self.devid, timeout=5000) | |
else: | |
self.dc.low() | |
self.spi.send(command_byte) | |
def invert_display(self, invert): | |
self.write_command(INVERTDISPLAY if invert else NORMALDISPLAY) | |
def display(self): | |
self.write_command(COLUMNADDR) | |
self.write_command(0) | |
self.write_command(self.columns - 1) | |
self.write_command(PAGEADDR) | |
self.write_command(0) | |
self.write_command(self.pages - 1) | |
if self.offset == 1: | |
self.i2c.send(self.buffer, addr=self.devid, timeout=5000) | |
else: | |
self.dc.high() | |
self.spi.send(self.buffer) | |
def set_pixel(self, x, y, state): | |
index = x + (int(y / 8) * self.columns) | |
if state: | |
self.buffer[self.offset + index] |= (1 << (y & 7)) | |
else: | |
self.buffer[self.offset + index] &= ~(1 << (y & 7)) | |
def init_display(self): | |
chargepump = 0x10 if self.external_vcc else 0x14 | |
precharge = 0x22 if self.external_vcc else 0xf1 | |
multiplex = 0x1f if self.height == 32 else 0x3f | |
compins = 0x02 if self.height == 32 else 0x12 | |
contrast = 0xff # 0x8f if self.height == 32 else (0x9f if self.external_vcc else 0x9f) | |
data = [DISPLAYOFF, | |
SETDISPLAYCLOCKDIV, 0x80, | |
SETMULTIPLEX, multiplex, | |
SETDISPLAYOFFSET, 0x00, | |
SETSTARTLINE | 0x00, | |
CHARGEPUMP, chargepump, | |
MEMORYMODE, 0x00, | |
SEGREMAP | 0x10, | |
COMSCANDEC, | |
SETCOMPINS, compins, | |
SETCONTRAST, contrast, | |
SETPRECHARGE, precharge, | |
SETVCOMDETECT, 0x40, | |
DISPLAYALLON_RESUME, | |
NORMALDISPLAY, | |
DISPLAYON] | |
for item in data: | |
self.write_command(item) | |
self.clear() | |
self.display() | |
def poweron(self): | |
if self.offset == 1: | |
pyb.delay(10) | |
else: | |
self.res.high() | |
pyb.delay(1) | |
self.res.low() | |
pyb.delay(10) | |
self.res.high() | |
pyb.delay(10) | |
def poweroff(self): | |
self.write_command(DISPLAYOFF) | |
def contrast(self, contrast): | |
self.write_command(SETCONTRAST) | |
self.write_command(contrast) | |
class Display(SSD1306): | |
def __init__(self, *args, **kwargs): | |
self._power = False | |
self._initialised = False | |
self._last_lines = [] | |
super().__init__(*args, **kwargs) | |
def poweron(self): | |
super().poweron() | |
self._power = True | |
def poweroff(self): | |
super().poweroff() | |
self._power = False | |
def init_display(self): | |
super().init_display() | |
self._initialised = True | |
def __enter__(self): | |
if not self._power: | |
self.poweron() | |
if not self._initialised: | |
self.init_display() | |
self.clear() | |
return self | |
def __exit__(self, exc_type, exc_val, exc_tb): | |
self.display() | |
def draw_text(self, x, y, string, size=1, space=1): | |
font_bytes = self.font.bytes | |
font_cols = self.font.cols | |
for c in string: | |
p = ord(c) * font_cols | |
for col in range(0, font_cols): | |
mask = font_bytes[p] | |
p += 1 | |
py = y | |
for row in range(0, 8): | |
for sy in range(0, size): | |
px = x | |
for sx in range(0, size): | |
self.set_pixel(128 - px, py, mask & 0x1) | |
px += 1 | |
py += 1 | |
mask >>= 1 | |
x += size | |
x += space | |
def _get_lines(self, text): | |
for line in text.split('\n'): | |
while len(line) > 20: | |
yield line[:20] | |
line = line[20:] | |
if line: | |
yield line | |
def write(self, text): | |
lines = (self._last_lines + list(self._get_lines(str(text))))[-6:] | |
with self: | |
for n, line in enumerate(lines): | |
self.draw_text(5, 5 + 10 * n, line) | |
self._last_lines = lines | |
@chan | |
def get_display(q, *args, **kwargs): | |
display = Display(*args, **kwargs) | |
while True: | |
lines = yield from q.get() | |
display.write(lines) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
# Originally: https://raw.githubusercontent.com/mithru/MicropythonLibs/master/Ultrasonic/module/ultrasonic.py | |
## | |
# Ultrasonic library for MicroPython's pyboard. | |
# Compatible with HC-SR04 and SRF04. | |
# | |
# Copyright 2014 - Sergio Conde Gómez <skgsergio@gmail.com> | |
# | |
# This program is free software: you can redistribute it and/or modify | |
# it under the terms of the GNU General Public License as published by | |
# the Free Software Foundation, either version 3 of the License, or | |
# (at your option) any later version. | |
# | |
# This program is distributed in the hope that it will be useful, | |
# but WITHOUT ANY WARRANTY; without even the implied warranty of | |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
# GNU General Public License for more details. | |
# | |
# You should have received a copy of the GNU General Public License | |
# along with this program. If not, see <http://www.gnu.org/licenses/>. | |
## | |
import pyb | |
from uasyncio.core import sleep | |
from utils import chan | |
# Pin configuration. | |
# WARNING: Do not use PA4-X5 or PA5-X6 as the echo pin without a 1k resistor. | |
class Ultrasonic: | |
def __init__(self, tPin, ePin): | |
self.triggerPin = tPin | |
self.echoPin = ePin | |
# Init trigger pin (out) | |
self.trigger = pyb.Pin(self.triggerPin) | |
self.trigger.init(pyb.Pin.OUT_PP, pyb.Pin.PULL_NONE) | |
self.trigger.low() | |
# Init echo pin (in) | |
self.echo = pyb.Pin(self.echoPin) | |
self.echo.init(pyb.Pin.IN, pyb.Pin.PULL_NONE) | |
def distance_in_cm(self): | |
start = 0 | |
end = 0 | |
# Create a microseconds counter. | |
micros = pyb.Timer(2, prescaler=83, period=0x3fffffff) | |
micros.counter(0) | |
# Send a 10us pulse. | |
self.trigger.high() | |
yield from sleep(0.01) | |
self.trigger.low() | |
limit = 1000 | |
# Wait 'till whe pulse starts. | |
while self.echo.value() == 0 and limit: | |
start = micros.counter() | |
limit -= 1 | |
# Wait 'till the pulse is gone. | |
while self.echo.value() == 1 and limit: | |
end = micros.counter() | |
limit -= 1 | |
# Deinit the microseconds counter | |
micros.deinit() | |
# Calc the duration of the recieved pulse, divide the result by | |
# 2 (round-trip) and divide it by 29 (the speed of sound is | |
# 340 m/s and that is 29 us/cm). | |
dist_in_cm = ((end - start) / 2) / 29 | |
return dist_in_cm | |
@chan | |
def get_ultrasonic(q, *args, **kwargs): | |
ultrasonic = Ultrasonic(*args, **kwargs) | |
while True: | |
val = yield from ultrasonic.distance_in_cm() | |
yield from q.put(val) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
import pyb | |
from uasyncio.core import get_event_loop, sleep | |
from uasyncio.queues import Queue, QueueEmpty | |
class OnlyChanged(Queue): | |
def __init__(self, *args, **kwargs): | |
self._last_val = None | |
super().__init__(*args, **kwargs) | |
def put(self, val): | |
if val != self._last_val: | |
yield from super().put(val) | |
self._last_val = val | |
def chan(fn): | |
def wrapper(*args, **kwargs): | |
q = OnlyChanged(1) | |
get_event_loop().call_soon(fn(q, *args, **kwargs)) | |
return q | |
return wrapper | |
@chan | |
def get_gyro(q): | |
accel = pyb.Accel() | |
while True: | |
val = accel.filtered_xyz() | |
yield from q.put(val) | |
@chan | |
def alts(q, **queues): | |
while True: | |
for name, queue in queues.items(): | |
try: | |
val = queue.get_nowait() | |
yield from q.put((name, val)) | |
except QueueEmpty: | |
continue | |
yield from sleep(0.01) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment