From 43d9f9916a7d13ae0bb32589b4bfee833678bbef Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Mon, 23 Jan 2017 14:36:19 +1100
Subject: drivers/display: Add driver and test for uPy LCD160CR display.

---
 drivers/display/lcd160cr.py      | 464 +++++++++++++++++++++++++++++++++++++++
 drivers/display/lcd160cr_test.py | 161 ++++++++++++++
 2 files changed, 625 insertions(+)
 create mode 100644 drivers/display/lcd160cr.py
 create mode 100644 drivers/display/lcd160cr_test.py

(limited to 'drivers/display')

diff --git a/drivers/display/lcd160cr.py b/drivers/display/lcd160cr.py
new file mode 100644
index 000000000..0861f8233
--- /dev/null
+++ b/drivers/display/lcd160cr.py
@@ -0,0 +1,464 @@
+# Driver for official MicroPython LCD160CR display
+# MIT license; Copyright (c) 2017 Damien P. George
+
+from micropython import const
+from utime import sleep_ms
+from ustruct import calcsize, pack_into
+import uerrno, machine
+
+# for set_orient
+PORTRAIT = const(0)
+LANDSCAPE = const(1)
+PORTRAIT_UPSIDEDOWN = const(2)
+LANDSCAPE_UPSIDEDOWN = const(3)
+
+# for set_startup_deco; can be or'd
+STARTUP_DECO_NONE = const(0)
+STARTUP_DECO_MLOGO = const(1)
+STARTUP_DECO_INFO = const(2)
+
+_uart_baud_table = {
+    2400: 0,
+    4800: 1,
+    9600: 2,
+    19200: 3,
+    38400: 4,
+    57600: 5,
+    115200: 6,
+    230400: 7,
+    460800: 8,
+}
+
+class LCD160CR:
+    def __init__(self, connect=None, *, pwr=None, i2c=None, spi=None, i2c_addr=98):
+        if connect in ('X', 'Y', 'XY', 'YX'):
+            i = connect[-1]
+            j = connect[0]
+            y = j + '4'
+        elif connect == 'C':
+            i = 2
+            j = 2
+            y = 'A7'
+        else:
+            if pwr is None or i2c is None or spi is None:
+                raise ValueError('must specify valid "connect" or all of "pwr", "i2c" and "spi"')
+
+        if pwr is None:
+            pwr = machine.Pin(y, machine.Pin.OUT)
+        if i2c is None:
+            i2c = machine.I2C(i, freq=1000000)
+        if spi is None:
+            spi = machine.SPI(j, baudrate=13500000, polarity=0, phase=0)
+
+        if not pwr.value():
+            pwr(1)
+            sleep_ms(10)
+        # else:
+        # alread have power
+        # lets be optimistic...
+
+        # set connections
+        self.pwr = pwr
+        self.i2c = i2c
+        self.spi = spi
+        self.i2c_addr = i2c_addr
+
+        # create temp buffers and memoryviews
+        self.buf16 = bytearray(16)
+        self.buf19 = bytearray(19)
+        self.buf = [None] * 10
+        for i in range(1, 10):
+            self.buf[i] = memoryview(self.buf16)[0:i]
+        self.buf1 = self.buf[1]
+        self.array4 = [0, 0, 0, 0]
+
+        # set default orientation and window
+        self.set_orient(PORTRAIT)
+        self._fcmd2b('<BBBBBB', 0x76, 0, 0, self.w, self.h) # viewport 'v'
+        self._fcmd2b('<BBBBBB', 0x79, 0, 0, self.w, self.h) # window 'y'
+
+    def _send(self, cmd):
+        i = self.i2c.writeto(self.i2c_addr, cmd)
+        if i == len(cmd):
+            return
+        cmd = memoryview(cmd)
+        n = len(cmd)
+        while True:
+            i += self.i2c.writeto(self.i2c_addr, cmd[i:])
+            if i == n:
+                return
+            sleep_ms(10)
+
+    def _fcmd2(self, fmt, a0, a1=0, a2=0):
+        buf = self.buf[calcsize(fmt)]
+        pack_into(fmt, buf, 0, 2, a0, a1, a2)
+        self._send(buf)
+
+    def _fcmd2b(self, fmt, a0, a1, a2, a3, a4=0):
+        buf = self.buf[calcsize(fmt)]
+        pack_into(fmt, buf, 0, 2, a0, a1, a2, a3, a4)
+        self._send(buf)
+
+    def _waitfor(self, n, buf):
+        t = 5000
+        while t:
+            self.i2c.readfrom_into(self.i2c_addr, self.buf1)
+            if self.buf1[0] >= n:
+                self.i2c.readfrom_into(self.i2c_addr, buf)
+                return
+            t -= 1
+            sleep_ms(1)
+        raise OSError(uerrno.ETIMEDOUT)
+
+    def oflush(self, n=255):
+        t = 5000
+        while t:
+            self.i2c.readfrom_into(self.i2c_addr + 1, self.buf1)
+            r = self.buf1[0]
+            if r >= n:
+                return
+            t -= 1
+            machine.idle()
+        raise OSError(uerrno.ETIMEDOUT)
+
+    def iflush(self):
+        t = 5000
+        while t:
+            self.i2c.readfrom_into(self.i2c_addr, self.buf16)
+            if self.buf16[0] == 0:
+                return
+            t -= 1
+            sleep_ms(1)
+        raise OSError(uerrno.ETIMEDOUT)
+
+    #### MISC METHODS ####
+
+    @staticmethod
+    def rgb(r, g, b):
+        return ((b & 0xf8) << 8) | ((g & 0xfc) << 3) | (r >> 3)
+
+    @staticmethod
+    def clip_line(c, w, h):
+        while True:
+            ca = ce = 0
+            if c[1] < 0:
+                ca |= 8
+            elif c[1] > h:
+                ca |= 4
+            if c[0] < 0:
+                ca |= 1
+            elif c[0] > w:
+                ca |= 2
+            if c[3] < 0:
+                ce |= 8
+            elif c[3] > h:
+                ce |= 4
+            if c[2] < 0:
+                ce |= 1
+            elif c[2] > w:
+                ce |= 2
+            if ca & ce:
+                return False
+            elif ca | ce:
+                ca |= ce
+                if ca & 1:
+                    if c[2] < c[0]:
+                        c[0], c[2] = c[2], c[0]
+                        c[1], c[3] = c[3], c[1]
+                    c[1] += ((-c[0]) * (c[3] - c[1])) // (c[2] - c[0])
+                    c[0] = 0
+                elif ca & 2:
+                    if c[2] < c[0]:
+                        c[0], c[2] = c[2], c[0]
+                        c[1], c[3] = c[3], c[1]
+                    c[3] += ((w - 1 - c[2]) * (c[3] - c[1])) // (c[2] - c[0])
+                    c[2] = w - 1
+                elif ca & 4:
+                    if c[0] == c[2]:
+                        if c[1] >= h:
+                            c[1] = h - 1
+                        if c[3] >= h:
+                            c[3] = h - 1
+                    else:
+                        if c[3] < c[1]:
+                            c[0], c[2] = c[2], c[0]
+                            c[1], c[3] = c[3], c[1]
+                        c[2] += ((h - 1 - c[3]) * (c[2] - c[0])) // (c[3] - c[1])
+                        c[3] = h - 1
+                else:
+                    if c[0] == c[2]:
+                        if c[1] < 0:
+                            c[1] = 0
+                        if c[3] < 0:
+                            c[3] = 0
+                    else:
+                        if c[3] < c[1]:
+                            c[0], c[2] = c[2], c[0]
+                            c[1], c[3] = c[3], c[1]
+                        c[0] += ((-c[1]) * (c[2] - c[0])) // (c[3] - c[1])
+                        c[1] = 0
+            else:
+                return True
+
+    #### SETUP COMMANDS ####
+
+    def set_power(self, on):
+        self.pwr(value)
+        sleep_ms(15)
+
+    def set_orient(self, orient):
+        self._fcmd2('<BBB', 0x14, (orient & 3) + 4)
+        # update width and height variables
+        self.iflush()
+        self._send(b'\x02g0')
+        self._waitfor(4, self.buf[5])
+        self.w = self.buf[5][1]
+        self.h = self.buf[5][2]
+
+    def set_brightness(self, value):
+        self._fcmd2('<BBB', 0x16, value)
+
+    def set_i2c_addr(self, addr):
+        # 0x0e set i2c addr
+        if addr & 3:
+            raise ValueError('must specify mod 4 aligned address')
+        self._fcmd2('<BBW', 0x0e, 0x433249 | (addr << 24))
+
+    def set_uart_baudrate(self, baudrate):
+        try:
+            baudrate = _uart_baud_table[baudrate]
+        except KeyError:
+            raise ValueError('invalid baudrate')
+        self._fcmd2('<BBB', 0x18, baudrate)
+
+    def set_startup_deco(self, value):
+        self._fcmd2('<BBB', 0x19, value)
+
+    def save_to_flash(self):
+        self._fcmd2('<BBB', 0x66, 'n')
+
+    #### PIXEL ACCESS ####
+
+    def set_pixel(self, x, y, c):
+        self._fcmd2b('<BBBBH', 0x41, x, y, c)
+
+    def get_pixel(self, x, y):
+        self._fcmd2b('<BBBB', 0x61, x, y)
+        t = 1000
+        while t:
+            self.i2c.readfrom_into(self.i2c_addr, self.buf1)
+            if self.buf1[0] >= 2:
+                self.i2c.readfrom_into(self.i2c_addr, self.buf[3])
+                return self.buf[3][1] + self.buf[3][2] << 8
+            t -= 1
+            sleep_ms(1)
+        raise OSError(uerrno.ETIMEDOUT)
+
+    def get_line(self, x, y, buf):
+        l = len(buf) // 2
+        self._fcmd2b('<BBBBB', 0x10, l, x, y)
+        t = 1000
+        while t:
+            self.i2c.readfrom_into(self.i2c_addr, self.buf1)
+            if self.buf1[0] >= l:
+                self.i2c.readfrom_into(self.i2c_addr, buf)
+                return
+            t -= 1
+            sleep_ms(1)
+        raise OSError(uerrno.ETIMEDOUT)
+
+    def screen_dump(self, buf):
+        line = bytearray(self.w + 1)
+        h = len(buf) // (2 * self.w)
+        if h > self.h:
+            h = self.h
+        for i in range(h):
+            ix = i * self.w * 2
+            self.get_line(0, i, line)
+            for j in range(1, len(line)):
+                buf[ix] = line[j]
+                ix += 1
+            self.get_line(self.w // 2, i, line)
+            for j in range(1, len(line)):
+                buf[ix] = line[j]
+                ix += 1
+
+    def screen_load(self, buf):
+        l = self.w * self.h * 2+2
+        self._fcmd2b('<BBHBBB', 0x70, l, 16, self.w, self.h)
+        n = 0
+        ar = memoryview(buf)
+        while n < len(buf):
+            if len(buf) - n >= 0x200:
+                self._send(ar[n:n + 0x200])
+                n += 0x200
+            else:
+                self._send(ar[n:])
+                while n < self.w * self.h * 2:
+                    self._send(b'\x00')
+                    n += 1
+
+    #### TEXT COMMANDS ####
+
+    def set_pos(self, x, y):
+        self._fcmd2('<BBBB', 0x58, x, y)
+
+    def set_text_color(self, fg, bg):
+        self._fcmd2('<BBHH', 0x63, fg, bg)
+
+    def set_font(self, font, scale=0, bold=0, trans=0, scroll=0):
+        self._fcmd2('<BBBB', 0x46, (scroll << 7) | (trans << 6) | ((font & 3) << 4) | (bold & 0xf), scale & 0xff)
+
+    def write(self, s):
+        # TODO: eventually check for room in LCD input queue
+        self._send(s)
+
+    #### PRIMITIVE DRAWING COMMANDS ####
+
+    def set_pen(self, line, fill):
+        self._fcmd2('<BBHH', 0x50, line, fill)
+
+    def erase(self):
+        self._send(b'\x02\x45')
+
+    def dot(self, x, y):
+        if 0 <= x < self.w and 0 <= y < self.h:
+            self._fcmd2('<BBBB', 0x4b, x, y)
+
+    def rect(self, x, y, w, h, cmd=0x72):
+        if x + w <= 0 or y + h <= 0 or x >= self.w or y >= self.h:
+            return
+        elif x < 0 or y < 0:
+            left = top = True
+            if x < 0:
+                left = False
+                w += x
+                x = 0
+            if y < 0:
+                top = False
+                h += y
+                y = 0
+            if cmd == 0x51 or cmd == 0x72:
+                # draw interior
+                self._fcmd2b('<BBBBBB', 0x51, x, y, min(w, 255), min(h, 255))
+            if cmd == 0x57 or cmd == 0x72:
+                # draw outline
+                if left:
+                    self._fcmd2b('<BBBBBB', 0x57, x, y, 1, min(h, 255))
+                if top:
+                    self._fcmd2b('<BBBBBB', 0x57, x, y, min(w, 255), 1)
+                if x + w < self.w:
+                    self._fcmd2b('<BBBBBB', 0x57, x + w, y, 1, min(h, 255))
+                if y + h < self.h:
+                    self._fcmd2b('<BBBBBB', 0x57, x, y + h, min(w, 255), 1)
+        else:
+            self._fcmd2b('<BBBBBB', cmd, x, y, min(w, 255), min(h, 255))
+
+    def rect_outline(self, x, y, w, h):
+        self.rect(x, y, w, h, 0x57)
+
+    def rect_interior(self, x, y, w, h):
+        self.rect(x, y, w, h, 0x51)
+
+    def line(self, x1, y1, x2, y2):
+        ar4 = self.array4
+        ar4[0] = x1
+        ar4[1] = y1
+        ar4[2] = x2
+        ar4[3] = y2
+        if self.clip_line(ar4, self.w, self.h):
+            self._fcmd2b('<BBBBBB', 0x4c, ar4[0], ar4[1], ar4[2], ar4[3])
+
+    def dot_no_clip(self, x, y):
+        self._fcmd2('<BBBB', 0x4b, x, y)
+
+    def rect_no_clip(self, x, y, w, h):
+        self._fcmd2b('<BBBBBB', 0x72, x, y, w, h)
+
+    def rect_outline_no_clip(self, x, y, w, h):
+        self._fcmd2b('<BBBBBB', 0x57, x, y, w, h)
+
+    def rect_interior_no_clip(self, x, y, w, h):
+        self._fcmd2b('<BBBBBB', 0x51, x, y, w, h)
+
+    def line_no_clip(self, x1, y1, x2, y2):
+        self._fcmd2b('<BBBBBB', 0x4c, x1, y1, x2, y2)
+
+    def poly_dot(self, data):
+        if len(data) & 1:
+            raise ValueError('must specify even number of bytes')
+        self._fcmd2('<BBB', 0x71, len(data) // 2)
+        self._send(data)
+
+    def poly_line(self, data):
+        if len(data) & 1:
+            raise ValueError('must specify even number of bytes')
+        self._fcmd2('<BBB', 0x78, len(data) // 2)
+        self._send(data)
+
+    #### TOUCH COMMANDS ####
+
+    def touch_config(self, calib=False, save=False, irq=None):
+        self._fcmd2('<BBBB', 0x7a, (irq is not None) << 2 | save << 1 | calib, bool(irq) << 7)
+
+    def is_touched(self):
+        self._send(b'\x02T')
+        b = self.buf[4]
+        self._waitfor(3, b)
+        return b[1] >> 7 != 0
+
+    def get_touch(self):
+        self._send(b'\x02T') # implicit LCD output flush
+        b = self.buf[4]
+        self._waitfor(3, b)
+        return b[1] >> 7, b[2], b[3]
+
+    #### ADVANCED COMMANDS ####
+
+    def set_spi_win(self, x, y, w, h):
+        pack_into('<BBBHHHHHHHH', self.buf19, 0, 2, 0x55, 10, x, y, x + w - 1, y + h - 1, 0, 0, 0, 0xffff)
+        self._send(self.buf19)
+
+    def fast_spi(self, flush=True):
+        if flush:
+            self.oflush()
+        self._send(b'\x02\x12')
+        return self.spi
+
+    def show_framebuf(self, buf):
+        self.fast_spi().write(buf)
+
+    def set_scroll(self, on):
+        self._fcmd2('<BBB', 0x15, on)
+
+    def set_scroll_win(self, win, x=-1, y=0, w=0, h=0, vec=0, pat=0, fill=0x07e0, color=0):
+        pack_into('<BBBHHHHHHHH', self.buf19, 0, 2, 0x55, win, x, y, w, h, vec, pat, fill, color)
+        self._send(self.buf19)
+
+    def set_scroll_win_param(self, win, param, value):
+        self._fcmd2b('<BBBBH', 0x75, win, param, value)
+
+    def set_scroll_buf(self, s):
+        l = len(s)
+        if l > 32:
+            raise ValueError('length must be 32 or less')
+        self._fcmd2('<BBB', 0x11, l)
+        self._send(s)
+
+    def jpeg_start(self, l):
+        self.oflush()
+        self._fcmd2('<BBH', 0x6a, l)
+
+    def jpeg_data(self, buf):
+        self._send(buf)
+
+    def jpeg(self, buf):
+        self.jpeg_start(len(buf))
+        self.jpeg_data(buf)
+
+    def feed_wdt(self):
+        self._send(b'\x02\x17')
+
+    def reset(self):
+        self._send(b'\x02Y\xef\xbe\xad\xde')
+        sleep_ms(15)
diff --git a/drivers/display/lcd160cr_test.py b/drivers/display/lcd160cr_test.py
new file mode 100644
index 000000000..5571a4c3a
--- /dev/null
+++ b/drivers/display/lcd160cr_test.py
@@ -0,0 +1,161 @@
+# Driver test for official MicroPython LCD160CR display
+# MIT license; Copyright (c) 2017 Damien P. George
+
+import time, math, framebuf, lcd160cr
+
+def get_lcd(lcd):
+    if type(lcd) is str:
+        lcd = lcd160cr.LCD160CR(lcd)
+    return lcd
+
+def show_adc(lcd, adc):
+    data = [adc.read_core_temp(), adc.read_core_vbat(), 3.3]
+    try:
+        data[2] = adc.read_vref()
+    except:
+        pass
+    for i in range(3):
+        lcd.set_text_color((825, 1625, 1600)[i], 0)
+        lcd.set_font(2)
+        lcd.set_pos(0, 100 + i * 16)
+        lcd.write('%4s: ' % ('TEMP', 'VBAT', 'VREF')[i])
+        if i > 0:
+            s = '%6.3fV' % data[i]
+        else:
+            s = '%5.1f°C' % data[i]
+        lcd.set_font(1, bold=0, scale=1)
+        lcd.write(s)
+
+def test_features(lcd):
+    # if we run on pyboard then use ADC and RTC features
+    try:
+        import pyb
+        adc = pyb.ADCAll(12, 0xf0000)
+        rtc = pyb.RTC()
+    except:
+        adc = None
+        rtc = None
+
+    # set orientation and clear screen
+    lcd = get_lcd(lcd)
+    lcd.set_orient(lcd160cr.PORTRAIT)
+    lcd.set_pen(0, 0)
+    lcd.erase()
+
+    # create M-logo
+    mlogo = framebuf.FrameBuffer(bytearray(17 * 17 * 2), 17, 17, framebuf.RGB565)
+    mlogo.fill(0)
+    mlogo.fill_rect(1, 1, 15, 15, 0xffffff)
+    mlogo.vline(4, 4, 12, 0)
+    mlogo.vline(8, 1, 12, 0)
+    mlogo.vline(12, 4, 12, 0)
+    mlogo.vline(14, 13, 2, 0)
+
+    # create inline framebuf
+    offx = 14
+    offy = 19
+    w = 100
+    h = 75
+    fbuf = framebuf.FrameBuffer(bytearray(w * h * 2), w, h, framebuf.RGB565)
+    lcd.set_spi_win(offx, offy, w, h)
+
+    # initialise loop parameters
+    tx = ty = 0
+    t0 = time.ticks_us()
+
+    for i in range(300):
+        # update position of cross-hair
+        t, tx2, ty2 = lcd.get_touch()
+        if t:
+            tx2 -= offx
+            ty2 -= offy
+            if tx2 >= 0 and ty2 >= 0 and tx2 < w and ty2 < h:
+                tx, ty = tx2, ty2
+        else:
+             tx = (tx + 1) % w
+             ty = (ty + 1) % h
+
+        # create and show the inline framebuf
+        fbuf.fill(lcd.rgb(128 + int(64 * math.cos(0.1 * i)), 128, 192))
+        fbuf.line(w // 2, h // 2,
+            w // 2 + int(40 * math.cos(0.2 * i)),
+            h // 2 + int(40 * math.sin(0.2 * i)),
+            lcd.rgb(128, 255, 64))
+        fbuf.hline(0, ty, w, lcd.rgb(64, 64, 64))
+        fbuf.vline(tx, 0, h, lcd.rgb(64, 64, 64))
+        fbuf.rect(tx - 3, ty - 3, 7, 7, lcd.rgb(64, 64, 64))
+        for phase in (-0.2, 0, 0.2):
+            x = w // 2 - 8 + int(50 * math.cos(0.05 * i + phase))
+            y = h // 2 - 8 + int(32 * math.sin(0.05 * i + phase))
+            fbuf.blit(mlogo, x, y)
+        for j in range(-3, 3):
+            fbuf.text('MicroPython',
+                5, h // 2 + 9 * j + int(20 * math.sin(0.1 * (i + j))),
+                lcd.rgb(128 + 10 * j, 0, 128 - 10 * j))
+        lcd.show_framebuf(fbuf)
+
+        # show results from the ADC
+        if adc:
+            show_adc(lcd, adc)
+
+        # show the time
+        if rtc:
+            lcd.set_pos(2, 0)
+            lcd.set_font(1)
+            t = rtc.datetime()
+            lcd.write('%4d-%02d-%02d %2d:%02d:%02d.%01d' % (t[0], t[1], t[2], t[4], t[5], t[6], t[7] // 100000))
+
+        # compute the frame rate
+        t1 = time.ticks_us()
+        dt = time.ticks_diff(t1, t0)
+        t0 = t1
+
+        # show the frame rate
+        lcd.set_pos(2, 9)
+        lcd.write('%.2f fps' % (1000000 / dt))
+
+def test_mandel(lcd):
+    # set orientation and clear screen
+    lcd = get_lcd(lcd)
+    lcd.set_orient(lcd160cr.PORTRAIT)
+    lcd.set_pen(0, 0xffff)
+    lcd.erase()
+
+    # function to compute Mandelbrot pixels
+    def in_set(c):
+        z = 0
+        for i in range(32):
+            z = z * z + c
+            if abs(z) > 100:
+                return i
+        return 0
+
+    # cache width and height of LCD
+    w = lcd.w
+    h = lcd.h
+
+    # create the buffer for each line and set SPI parameters
+    line = bytearray(w * 2)
+    lcd.set_spi_win(0, 0, w, h)
+    spi = lcd.fast_spi()
+
+    # draw the Mandelbrot set line-by-line
+    for v in range(h):
+        for u in range(w):
+            c = in_set((v / ((h - 1) / 3.2) - 2.3) + (u / ((w - 1) / 2.4) - 1.2) * 1j)
+            if c < 16:
+                rgb = c << 12 | c << 6
+            else:
+                rgb = 0xf800 | c << 6
+            line[2 * u] = rgb
+            line[2 * u + 1] = rgb >> 8
+        spi.write(line)
+
+def test_all(lcd):
+    lcd = get_lcd(lcd)
+    test_features(lcd)
+    test_mandel(lcd)
+
+print('To run all tests: test_all(<lcd>)')
+print('Individual tests are: test_features, test_mandel')
+print('<lcd> argument should be a connection, eg "X", or an LCD160CR object')
-- 
cgit v1.2.3


From 8f3e07f17d545d78fa031c1eba8e907a7cd08808 Mon Sep 17 00:00:00 2001
From: Stephan Brauer <stebra42@gmail.com>
Date: Thu, 16 Feb 2017 21:49:25 +0100
Subject: drivers/display/lcd160cr: Use correct variable in set_power().

---
 drivers/display/lcd160cr.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'drivers/display')

diff --git a/drivers/display/lcd160cr.py b/drivers/display/lcd160cr.py
index 0861f8233..a5da64348 100644
--- a/drivers/display/lcd160cr.py
+++ b/drivers/display/lcd160cr.py
@@ -203,7 +203,7 @@ class LCD160CR:
     #### SETUP COMMANDS ####
 
     def set_power(self, on):
-        self.pwr(value)
+        self.pwr(on)
         sleep_ms(15)
 
     def set_orient(self, orient):
-- 
cgit v1.2.3


From b0a6dda115e34436cc1774661a57348aee9dbb81 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Tue, 21 Feb 2017 17:40:34 +1100
Subject: drivers/display/lcd160cr: Fix bugs with lcd.get_pixel().

Fixes issues #2880 and #2881.
---
 drivers/display/lcd160cr.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'drivers/display')

diff --git a/drivers/display/lcd160cr.py b/drivers/display/lcd160cr.py
index a5da64348..c17a1f189 100644
--- a/drivers/display/lcd160cr.py
+++ b/drivers/display/lcd160cr.py
@@ -243,13 +243,13 @@ class LCD160CR:
         self._fcmd2b('<BBBBH', 0x41, x, y, c)
 
     def get_pixel(self, x, y):
-        self._fcmd2b('<BBBB', 0x61, x, y)
+        self._fcmd2('<BBBB', 0x61, x, y)
         t = 1000
         while t:
             self.i2c.readfrom_into(self.i2c_addr, self.buf1)
             if self.buf1[0] >= 2:
                 self.i2c.readfrom_into(self.i2c_addr, self.buf[3])
-                return self.buf[3][1] + self.buf[3][2] << 8
+                return self.buf[3][1] | self.buf[3][2] << 8
             t -= 1
             sleep_ms(1)
         raise OSError(uerrno.ETIMEDOUT)
-- 
cgit v1.2.3


From 8400d0461d3bb444f10242c82c5c44d4d7cbef16 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Fri, 24 Feb 2017 17:22:57 +1100
Subject: drivers/display/lcd160cr: Fix bug with save_to_flash method.

---
 drivers/display/lcd160cr.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'drivers/display')

diff --git a/drivers/display/lcd160cr.py b/drivers/display/lcd160cr.py
index c17a1f189..d63dc3975 100644
--- a/drivers/display/lcd160cr.py
+++ b/drivers/display/lcd160cr.py
@@ -235,7 +235,7 @@ class LCD160CR:
         self._fcmd2('<BBB', 0x19, value)
 
     def save_to_flash(self):
-        self._fcmd2('<BBB', 0x66, 'n')
+        self._send(b'\x02fn')
 
     #### PIXEL ACCESS ####
 
-- 
cgit v1.2.3


From 528aeb3bf3e42c235f5822de04b16778d284a7df Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Mon, 27 Feb 2017 18:39:35 +1100
Subject: drivers/display/lcd160cr: Add check that JPEG size is less than
 65536.

---
 drivers/display/lcd160cr.py | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'drivers/display')

diff --git a/drivers/display/lcd160cr.py b/drivers/display/lcd160cr.py
index d63dc3975..0cf52f2ef 100644
--- a/drivers/display/lcd160cr.py
+++ b/drivers/display/lcd160cr.py
@@ -446,6 +446,8 @@ class LCD160CR:
         self._send(s)
 
     def jpeg_start(self, l):
+        if l > 0xffff:
+            raise ValueError('length must be 65535 or less')
         self.oflush()
         self._fcmd2('<BBH', 0x6a, l)
 
-- 
cgit v1.2.3


From f351c6db5e4c0bf75d5d647e69a047da739606a8 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Wed, 17 May 2017 19:53:13 +1000
Subject: drivers/display/lcd160cr: Fix get_line method and enhance
 screen_dump.

The docs are updated and describe the new behaviour of these methods.
---
 docs/library/lcd160cr.rst   | 18 +++++++++++++-----
 drivers/display/lcd160cr.py | 38 +++++++++++++++++++++++---------------
 2 files changed, 36 insertions(+), 20 deletions(-)

(limited to 'drivers/display')

diff --git a/docs/library/lcd160cr.rst b/docs/library/lcd160cr.rst
index 76828d32d..bd4741298 100644
--- a/docs/library/lcd160cr.rst
+++ b/docs/library/lcd160cr.rst
@@ -150,11 +150,19 @@ The following methods manipulate individual pixels on the display.
 
 .. method:: LCD160CR.get_line(x, y, buf)
 
-    Get a line of pixels into the given buffer.
-
-.. method:: LCD160CR.screen_dump(buf)
-
-    Dump the entire screen to the given buffer.
+    Low-level method to get a line of pixels into the given buffer.
+    To read `n` pixels `buf` should be `2*n+1` bytes in length.  The first byte
+    is a dummy byte and should be ignored, and subsequent bytes represent the
+    pixels in the line starting at coordinate `(x, y)`.
+
+.. method:: LCD160CR.screen_dump(buf, x=0, y=0, w=None, h=None)
+
+    Dump the contents of the screen to the given buffer.  The parameters `x` and `y`
+    specify the starting coordinate, and `w` and `h` the size of the region.  If `w`
+    or `h` are `None` then they will take on their maximum values, set by the size
+    of the screen minus the given `x` and `y` values.  `buf` should be large enough
+    to hold `2*w*h` bytes.  If it's smaller then only the initial horizontal lines
+    will be stored.
 
 .. method:: LCD160CR.screen_load(buf)
 
diff --git a/drivers/display/lcd160cr.py b/drivers/display/lcd160cr.py
index 0cf52f2ef..dd9ab9985 100644
--- a/drivers/display/lcd160cr.py
+++ b/drivers/display/lcd160cr.py
@@ -257,6 +257,7 @@ class LCD160CR:
     def get_line(self, x, y, buf):
         l = len(buf) // 2
         self._fcmd2b('<BBBBB', 0x10, l, x, y)
+        l *= 2
         t = 1000
         while t:
             self.i2c.readfrom_into(self.i2c_addr, self.buf1)
@@ -267,21 +268,28 @@ class LCD160CR:
             sleep_ms(1)
         raise OSError(uerrno.ETIMEDOUT)
 
-    def screen_dump(self, buf):
-        line = bytearray(self.w + 1)
-        h = len(buf) // (2 * self.w)
-        if h > self.h:
-            h = self.h
-        for i in range(h):
-            ix = i * self.w * 2
-            self.get_line(0, i, line)
-            for j in range(1, len(line)):
-                buf[ix] = line[j]
-                ix += 1
-            self.get_line(self.w // 2, i, line)
-            for j in range(1, len(line)):
-                buf[ix] = line[j]
-                ix += 1
+    def screen_dump(self, buf, x=0, y=0, w=None, h=None):
+        if w is None:
+            w = self.w - x
+        if h is None:
+            h = self.h - y
+        if w <= 127:
+            line = bytearray(2 * w + 1)
+            line2 = None
+        else:
+            # split line if more than 254 bytes needed
+            buflen = (w + 1) // 2
+            line = bytearray(2 * buflen + 1)
+            line2 = memoryview(line)[:2 * (w - buflen) + 1]
+        for i in range(min(len(buf) // (2 * w), h)):
+            ix = i * w * 2
+            self.get_line(x, y + i, line)
+            buf[ix:ix + len(line) - 1] = memoryview(line)[1:]
+            ix += len(line) - 1
+            if line2:
+                self.get_line(x + buflen, y + i, line2)
+                buf[ix:ix + len(line2) - 1] = memoryview(line2)[1:]
+                ix += len(line2) - 1
 
     def screen_load(self, buf):
         l = self.w * self.h * 2+2
-- 
cgit v1.2.3


From 55dd83a7bac340cbc85a8abafb1ff4eb2a187ce6 Mon Sep 17 00:00:00 2001
From: Damien George <damien.p.george@gmail.com>
Date: Wed, 17 May 2017 19:54:38 +1000
Subject: drivers/display/lcd160cr_test: Allow test to take orientation
 parameter.

---
 drivers/display/lcd160cr_test.py | 32 +++++++++++++++++++++-----------
 1 file changed, 21 insertions(+), 11 deletions(-)

(limited to 'drivers/display')

diff --git a/drivers/display/lcd160cr_test.py b/drivers/display/lcd160cr_test.py
index 5571a4c3a..8b7ef4555 100644
--- a/drivers/display/lcd160cr_test.py
+++ b/drivers/display/lcd160cr_test.py
@@ -16,17 +16,25 @@ def show_adc(lcd, adc):
         pass
     for i in range(3):
         lcd.set_text_color((825, 1625, 1600)[i], 0)
-        lcd.set_font(2)
-        lcd.set_pos(0, 100 + i * 16)
+        if lcd.h == 160:
+            lcd.set_font(2)
+            lcd.set_pos(0, 100 + i * 16)
+        else:
+            lcd.set_font(2, trans=1)
+            lcd.set_pos(0, lcd.h-60 + i * 16)
         lcd.write('%4s: ' % ('TEMP', 'VBAT', 'VREF')[i])
         if i > 0:
             s = '%6.3fV' % data[i]
         else:
             s = '%5.1f°C' % data[i]
-        lcd.set_font(1, bold=0, scale=1)
+        if lcd.h == 160:
+            lcd.set_font(1, bold=0, scale=1)
+        else:
+            lcd.set_font(1, bold=0, scale=1, trans=1)
+            lcd.set_pos(45, lcd.h-60 + i * 16)
         lcd.write(s)
 
-def test_features(lcd):
+def test_features(lcd, orient=lcd160cr.PORTRAIT):
     # if we run on pyboard then use ADC and RTC features
     try:
         import pyb
@@ -38,7 +46,7 @@ def test_features(lcd):
 
     # set orientation and clear screen
     lcd = get_lcd(lcd)
-    lcd.set_orient(lcd160cr.PORTRAIT)
+    lcd.set_orient(orient)
     lcd.set_pen(0, 0)
     lcd.erase()
 
@@ -114,10 +122,10 @@ def test_features(lcd):
         lcd.set_pos(2, 9)
         lcd.write('%.2f fps' % (1000000 / dt))
 
-def test_mandel(lcd):
+def test_mandel(lcd, orient=lcd160cr.PORTRAIT):
     # set orientation and clear screen
     lcd = get_lcd(lcd)
-    lcd.set_orient(lcd160cr.PORTRAIT)
+    lcd.set_orient(orient)
     lcd.set_pen(0, 0xffff)
     lcd.erase()
 
@@ -140,9 +148,11 @@ def test_mandel(lcd):
     spi = lcd.fast_spi()
 
     # draw the Mandelbrot set line-by-line
+    hh = ((h - 1) / 3.2)
+    ww = ((w - 1) / 2.4)
     for v in range(h):
         for u in range(w):
-            c = in_set((v / ((h - 1) / 3.2) - 2.3) + (u / ((w - 1) / 2.4) - 1.2) * 1j)
+            c = in_set((v / hh - 2.3) + (u / ww - 1.2) * 1j)
             if c < 16:
                 rgb = c << 12 | c << 6
             else:
@@ -151,10 +161,10 @@ def test_mandel(lcd):
             line[2 * u + 1] = rgb >> 8
         spi.write(line)
 
-def test_all(lcd):
+def test_all(lcd, orient=lcd160cr.PORTRAIT):
     lcd = get_lcd(lcd)
-    test_features(lcd)
-    test_mandel(lcd)
+    test_features(lcd, orient)
+    test_mandel(lcd, orient)
 
 print('To run all tests: test_all(<lcd>)')
 print('Individual tests are: test_features, test_mandel')
-- 
cgit v1.2.3


From 1c9ee497562ab49c00d190ff91b6689979f922f4 Mon Sep 17 00:00:00 2001
From: Paul Sokolovsky <pfalcon@users.sourceforge.net>
Date: Sun, 23 Apr 2017 11:35:34 +0300
Subject: drivers: Replace deprecated Pin.high()/low() methods with
 .__call__(1/0).

---
 drivers/display/ssd1306.py   | 22 +++++++++++-----------
 drivers/nrf24l01/nrf24l01.py | 40 ++++++++++++++++++++--------------------
 drivers/onewire/ds18x20.py   |  6 +++---
 drivers/sdcard/sdcard.py     | 24 ++++++++++++------------
 4 files changed, 46 insertions(+), 46 deletions(-)

(limited to 'drivers/display')

diff --git a/drivers/display/ssd1306.py b/drivers/display/ssd1306.py
index a8c11a1d0..53bcb0d2d 100644
--- a/drivers/display/ssd1306.py
+++ b/drivers/display/ssd1306.py
@@ -139,23 +139,23 @@ class SSD1306_SPI(SSD1306):
 
     def write_cmd(self, cmd):
         self.spi.init(baudrate=self.rate, polarity=0, phase=0)
-        self.cs.high()
-        self.dc.low()
-        self.cs.low()
+        self.cs(1)
+        self.dc(0)
+        self.cs(0)
         self.spi.write(bytearray([cmd]))
-        self.cs.high()
+        self.cs(1)
 
     def write_data(self, buf):
         self.spi.init(baudrate=self.rate, polarity=0, phase=0)
-        self.cs.high()
-        self.dc.high()
-        self.cs.low()
+        self.cs(1)
+        self.dc(1)
+        self.cs(0)
         self.spi.write(buf)
-        self.cs.high()
+        self.cs(1)
 
     def poweron(self):
-        self.res.high()
+        self.res(1)
         time.sleep_ms(1)
-        self.res.low()
+        self.res(0)
         time.sleep_ms(10)
-        self.res.high()
+        self.res(1)
diff --git a/drivers/nrf24l01/nrf24l01.py b/drivers/nrf24l01/nrf24l01.py
index 788906dc0..b45c137c6 100644
--- a/drivers/nrf24l01/nrf24l01.py
+++ b/drivers/nrf24l01/nrf24l01.py
@@ -66,8 +66,8 @@ class NRF24L01:
         ce.init(ce.OUT, value=0)
 
         # reset everything
-        self.ce.low()
-        self.cs.high()
+        self.ce(0)
+        self.cs(1)
         self.payload_size = payload_size
         self.pipe0_read_addr = None
         utime.sleep_ms(5)
@@ -109,36 +109,36 @@ class NRF24L01:
             self.spi.init(master, baudrate=baudrate, polarity=0, phase=0)
 
     def reg_read(self, reg):
-        self.cs.low()
+        self.cs(0)
         self.spi.readinto(self.buf, reg)
         self.spi.readinto(self.buf)
-        self.cs.high()
+        self.cs(1)
         return self.buf[0]
 
     def reg_write_bytes(self, reg, buf):
-        self.cs.low()
+        self.cs(0)
         self.spi.readinto(self.buf, 0x20 | reg)
         self.spi.write(buf)
-        self.cs.high()
+        self.cs(1)
         return self.buf[0]
 
     def reg_write(self, reg, value):
-        self.cs.low()
+        self.cs(0)
         self.spi.readinto(self.buf, 0x20 | reg)
         ret = self.buf[0]
         self.spi.readinto(self.buf, value)
-        self.cs.high()
+        self.cs(1)
         return ret
 
     def flush_rx(self):
-        self.cs.low()
+        self.cs(0)
         self.spi.readinto(self.buf, FLUSH_RX)
-        self.cs.high()
+        self.cs(1)
 
     def flush_tx(self):
-        self.cs.low()
+        self.cs(0)
         self.spi.readinto(self.buf, FLUSH_TX)
-        self.cs.high()
+        self.cs(1)
 
     # power is one of POWER_x defines; speed is one of SPEED_x defines
     def set_power_speed(self, power, speed):
@@ -190,11 +190,11 @@ class NRF24L01:
 
         self.flush_rx()
         self.flush_tx()
-        self.ce.high()
+        self.ce(1)
         utime.sleep_us(130)
 
     def stop_listening(self):
-        self.ce.low()
+        self.ce(0)
         self.flush_tx()
         self.flush_rx()
 
@@ -204,10 +204,10 @@ class NRF24L01:
 
     def recv(self):
         # get the data
-        self.cs.low()
+        self.cs(0)
         self.spi.readinto(self.buf, R_RX_PAYLOAD)
         buf = self.spi.read(self.payload_size)
-        self.cs.high()
+        self.cs(1)
         # clear RX ready flag
         self.reg_write(STATUS, RX_DR)
 
@@ -229,17 +229,17 @@ class NRF24L01:
         self.reg_write(CONFIG, (self.reg_read(CONFIG) | PWR_UP) & ~PRIM_RX)
         utime.sleep_us(150)
         # send the data
-        self.cs.low()
+        self.cs(0)
         self.spi.readinto(self.buf, W_TX_PAYLOAD)
         self.spi.write(buf)
         if len(buf) < self.payload_size:
             self.spi.write(b'\x00' * (self.payload_size - len(buf))) # pad out data
-        self.cs.high()
+        self.cs(1)
 
         # enable the chip so it can send the data
-        self.ce.high()
+        self.ce(1)
         utime.sleep_us(15) # needs to be >10us
-        self.ce.low()
+        self.ce(0)
 
     # returns None if send still in progress, 1 for success, 2 for fail
     def send_done(self):
diff --git a/drivers/onewire/ds18x20.py b/drivers/onewire/ds18x20.py
index 342f4b28a..72adcbfd4 100644
--- a/drivers/onewire/ds18x20.py
+++ b/drivers/onewire/ds18x20.py
@@ -7,11 +7,11 @@ temperature sensors.  It supports multiple devices on the same 1-wire bus.
 The following example assumes the ground of your DS18x20 is connected to
 Y11, vcc is connected to Y9 and the data pin is connected to Y10.
 
->>> from pyb import Pin
+>>> from machine import Pin
 >>> gnd = Pin('Y11', Pin.OUT_PP)
->>> gnd.low()
+>>> gnd.off()
 >>> vcc = Pin('Y9', Pin.OUT_PP)
->>> vcc.high()
+>>> vcc.on()
 
 >>> from ds18x20 import DS18X20
 >>> d = DS18X20(Pin('Y10'))
diff --git a/drivers/sdcard/sdcard.py b/drivers/sdcard/sdcard.py
index cbf447415..e749d5376 100644
--- a/drivers/sdcard/sdcard.py
+++ b/drivers/sdcard/sdcard.py
@@ -130,7 +130,7 @@ class SDCard:
         raise OSError("timeout waiting for v2 card")
 
     def cmd(self, cmd, arg, crc, final=0, release=True):
-        self.cs.low()
+        self.cs(0)
 
         # create and send the command
         buf = self.cmdbuf
@@ -150,12 +150,12 @@ class SDCard:
                 for j in range(final):
                     self.spi.write(b'\xff')
                 if release:
-                    self.cs.high()
+                    self.cs(1)
                     self.spi.write(b'\xff')
                 return response
 
         # timeout
-        self.cs.high()
+        self.cs(1)
         self.spi.write(b'\xff')
         return -1
 
@@ -164,15 +164,15 @@ class SDCard:
         self.spi.read(1, 0xff) # ignore stuff byte
         for _ in range(_CMD_TIMEOUT):
             if self.spi.read(1, 0xff)[0] == 0xff:
-                self.cs.high()
+                self.cs(1)
                 self.spi.write(b'\xff')
                 return 0    # OK
-        self.cs.high()
+        self.cs(1)
         self.spi.write(b'\xff')
         return 1 # timeout
 
     def readinto(self, buf):
-        self.cs.low()
+        self.cs(0)
 
         # read until start byte (0xff)
         while self.spi.read(1, 0xff)[0] != 0xfe:
@@ -186,11 +186,11 @@ class SDCard:
         self.spi.write(b'\xff')
         self.spi.write(b'\xff')
 
-        self.cs.high()
+        self.cs(1)
         self.spi.write(b'\xff')
 
     def write(self, token, buf):
-        self.cs.low()
+        self.cs(0)
 
         # send: start of block, data, checksum
         self.spi.read(1, token)
@@ -200,7 +200,7 @@ class SDCard:
 
         # check the response
         if (self.spi.read(1, 0xff)[0] & 0x1f) != 0x05:
-            self.cs.high()
+            self.cs(1)
             self.spi.write(b'\xff')
             return
 
@@ -208,18 +208,18 @@ class SDCard:
         while self.spi.read(1, 0xff)[0] == 0:
             pass
 
-        self.cs.high()
+        self.cs(1)
         self.spi.write(b'\xff')
 
     def write_token(self, token):
-        self.cs.low()
+        self.cs(0)
         self.spi.read(1, token)
         self.spi.write(b'\xff')
         # wait for write to finish
         while self.spi.read(1, 0xff)[0] == 0x00:
             pass
 
-        self.cs.high()
+        self.cs(1)
         self.spi.write(b'\xff')
 
     def count(self):
-- 
cgit v1.2.3