2014-05-03 16:27:38 -06:00
|
|
|
/*
|
|
|
|
* This file is part of the Micro Python project, http://micropython.org/
|
|
|
|
*
|
|
|
|
* The MIT License (MIT)
|
|
|
|
*
|
|
|
|
* Copyright (c) 2013, 2014 Damien P. George
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2014-03-28 19:24:44 -06:00
|
|
|
#include <stdio.h>
|
2014-03-19 07:11:59 -06:00
|
|
|
#include <string.h>
|
|
|
|
#include <stm32f4xx_hal.h>
|
|
|
|
|
2014-05-02 09:03:04 -06:00
|
|
|
#include "mpconfig.h"
|
2014-03-19 07:11:59 -06:00
|
|
|
#include "nlr.h"
|
|
|
|
#include "misc.h"
|
|
|
|
|
|
|
|
#if MICROPY_HW_HAS_LCD
|
|
|
|
|
|
|
|
#include "qstr.h"
|
|
|
|
#include "parse.h"
|
|
|
|
#include "obj.h"
|
|
|
|
#include "runtime.h"
|
|
|
|
|
2014-06-14 17:41:47 -06:00
|
|
|
#include "pin.h"
|
|
|
|
#include "genhdr/pins.h"
|
|
|
|
#include "bufhelper.h"
|
|
|
|
#include "spi.h"
|
2014-03-19 07:11:59 -06:00
|
|
|
#include "font_petme128_8x8.h"
|
|
|
|
#include "lcd.h"
|
|
|
|
|
2014-08-02 07:35:38 -06:00
|
|
|
/// \moduleref pyb
|
|
|
|
/// \class LCD - LCD control for the LCD touch-sensor pyskin
|
|
|
|
///
|
|
|
|
/// The LCD class is used to control the LCD on the LCD touch-sensor pyskin,
|
|
|
|
/// LCD32MKv1.0. The LCD is a 128x32 pixel monochrome screen, part NHD-C12832A1Z.
|
|
|
|
///
|
|
|
|
/// The pyskin must be connected in either the X or Y positions, and then
|
|
|
|
/// an LCD object is made using:
|
|
|
|
///
|
|
|
|
/// lcd = pyb.LCD('X') # if pyskin is in the X position
|
|
|
|
/// lcd = pyb.LCD('Y') # if pyskin is in the Y position
|
|
|
|
///
|
|
|
|
/// Then you can use:
|
|
|
|
///
|
|
|
|
/// lcd.light(True) # turn the backlight on
|
|
|
|
/// lcd.write('Hello world!\n') # print text to the screen
|
|
|
|
///
|
|
|
|
/// This driver implements a double buffer for setting/getting pixels.
|
|
|
|
/// For example, to make a bouncing dot, try:
|
|
|
|
///
|
|
|
|
/// x = y = 0
|
|
|
|
/// dx = dy = 1
|
|
|
|
/// while True:
|
|
|
|
/// # update the dot's position
|
|
|
|
/// x += dx
|
|
|
|
/// y += dy
|
|
|
|
///
|
|
|
|
/// # make the dot bounce of the edges of the screen
|
|
|
|
/// if x <= 0 or x >= 127: dx = -dx
|
|
|
|
/// if y <= 0 or y >= 31: dy = -dy
|
|
|
|
///
|
|
|
|
/// lcd.fill(0) # clear the buffer
|
|
|
|
/// lcd.pixel(x, y, 1) # draw the dot
|
|
|
|
/// lcd.show() # show the buffer
|
|
|
|
/// pyb.delay(50) # pause for 50ms
|
|
|
|
|
2014-03-19 07:11:59 -06:00
|
|
|
#define LCD_INSTR (0)
|
|
|
|
#define LCD_DATA (1)
|
|
|
|
|
2014-06-14 17:41:47 -06:00
|
|
|
#define LCD_CHAR_BUF_W (16)
|
|
|
|
#define LCD_CHAR_BUF_H (4)
|
|
|
|
|
|
|
|
#define LCD_PIX_BUF_W (128)
|
|
|
|
#define LCD_PIX_BUF_H (32)
|
|
|
|
#define LCD_PIX_BUF_BYTE_SIZE (LCD_PIX_BUF_W * LCD_PIX_BUF_H / 8)
|
|
|
|
|
|
|
|
typedef struct _pyb_lcd_obj_t {
|
|
|
|
mp_obj_base_t base;
|
|
|
|
|
|
|
|
// hardware control for the LCD
|
|
|
|
SPI_HandleTypeDef *spi;
|
|
|
|
const pin_obj_t *pin_cs1;
|
|
|
|
const pin_obj_t *pin_rst;
|
|
|
|
const pin_obj_t *pin_a0;
|
|
|
|
const pin_obj_t *pin_bl;
|
|
|
|
|
|
|
|
// character buffer for stdout-like output
|
|
|
|
char char_buffer[LCD_CHAR_BUF_W * LCD_CHAR_BUF_H];
|
|
|
|
int line;
|
|
|
|
int column;
|
|
|
|
int next_line;
|
|
|
|
|
|
|
|
// double buffering for pixel buffer
|
|
|
|
byte pix_buf[LCD_PIX_BUF_BYTE_SIZE];
|
|
|
|
byte pix_buf2[LCD_PIX_BUF_BYTE_SIZE];
|
|
|
|
} pyb_lcd_obj_t;
|
|
|
|
|
|
|
|
STATIC void lcd_delay(void) {
|
2014-03-28 19:24:44 -06:00
|
|
|
__asm volatile ("nop\nnop");
|
|
|
|
}
|
|
|
|
|
2014-06-14 17:41:47 -06:00
|
|
|
STATIC void lcd_out(pyb_lcd_obj_t *lcd, int instr_data, uint8_t i) {
|
2014-03-28 19:24:44 -06:00
|
|
|
lcd_delay();
|
2014-06-14 17:41:47 -06:00
|
|
|
lcd->pin_cs1->gpio->BSRRH = lcd->pin_cs1->pin_mask; // CS=0; enable
|
2014-03-19 07:11:59 -06:00
|
|
|
if (instr_data == LCD_INSTR) {
|
2014-06-14 17:41:47 -06:00
|
|
|
lcd->pin_a0->gpio->BSRRH = lcd->pin_a0->pin_mask; // A0=0; select instr reg
|
2014-03-19 07:11:59 -06:00
|
|
|
} else {
|
2014-06-14 17:41:47 -06:00
|
|
|
lcd->pin_a0->gpio->BSRRL = lcd->pin_a0->pin_mask; // A0=1; select data reg
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
2014-06-14 17:41:47 -06:00
|
|
|
lcd_delay();
|
|
|
|
HAL_SPI_Transmit(lcd->spi, &i, 1, 1000);
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
|
|
|
|
2014-06-14 17:41:47 -06:00
|
|
|
// write a string to the LCD at the current cursor location
|
|
|
|
// output it straight away (doesn't use the pixel buffer)
|
|
|
|
STATIC void lcd_write_strn(pyb_lcd_obj_t *lcd, const char *str, unsigned int len) {
|
|
|
|
int redraw_min = lcd->line * LCD_CHAR_BUF_W + lcd->column;
|
|
|
|
int redraw_max = redraw_min;
|
|
|
|
for (; len > 0; len--, str++) {
|
|
|
|
// move to next line if needed
|
|
|
|
if (lcd->next_line) {
|
|
|
|
if (lcd->line + 1 < LCD_CHAR_BUF_H) {
|
|
|
|
lcd->line += 1;
|
|
|
|
} else {
|
|
|
|
lcd->line = LCD_CHAR_BUF_H - 1;
|
|
|
|
for (int i = 0; i < LCD_CHAR_BUF_W * (LCD_CHAR_BUF_H - 1); i++) {
|
|
|
|
lcd->char_buffer[i] = lcd->char_buffer[i + LCD_CHAR_BUF_W];
|
|
|
|
}
|
|
|
|
for (int i = 0; i < LCD_CHAR_BUF_W; i++) {
|
|
|
|
lcd->char_buffer[LCD_CHAR_BUF_W * (LCD_CHAR_BUF_H - 1) + i] = ' ';
|
|
|
|
}
|
|
|
|
redraw_min = 0;
|
|
|
|
redraw_max = LCD_CHAR_BUF_W * LCD_CHAR_BUF_H;
|
|
|
|
}
|
|
|
|
lcd->next_line = 0;
|
|
|
|
lcd->column = 0;
|
|
|
|
}
|
|
|
|
if (*str == '\n') {
|
|
|
|
lcd->next_line = 1;
|
|
|
|
} else if (*str == '\r') {
|
|
|
|
lcd->column = 0;
|
|
|
|
} else if (*str == '\b') {
|
|
|
|
if (lcd->column > 0) {
|
|
|
|
lcd->column--;
|
|
|
|
redraw_min = 0; // could optimise this to not redraw everything
|
|
|
|
}
|
|
|
|
} else if (lcd->column >= LCD_CHAR_BUF_W) {
|
|
|
|
lcd->next_line = 1;
|
|
|
|
str -= 1;
|
|
|
|
len += 1;
|
2014-03-19 07:11:59 -06:00
|
|
|
} else {
|
2014-06-14 17:41:47 -06:00
|
|
|
lcd->char_buffer[lcd->line * LCD_CHAR_BUF_W + lcd->column] = *str;
|
|
|
|
lcd->column += 1;
|
|
|
|
int max = lcd->line * LCD_CHAR_BUF_W + lcd->column;
|
|
|
|
if (max > redraw_max) {
|
|
|
|
redraw_max = max;
|
|
|
|
}
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-14 17:41:47 -06:00
|
|
|
// we must draw upside down, because the LCD is upside down
|
|
|
|
for (int i = redraw_min; i < redraw_max; i++) {
|
|
|
|
uint page = i / LCD_CHAR_BUF_W;
|
|
|
|
uint offset = 8 * (LCD_CHAR_BUF_W - 1 - (i - (page * LCD_CHAR_BUF_W)));
|
|
|
|
lcd_out(lcd, LCD_INSTR, 0xb0 | page); // page address set
|
|
|
|
lcd_out(lcd, LCD_INSTR, 0x10 | ((offset >> 4) & 0x0f)); // column address set upper
|
|
|
|
lcd_out(lcd, LCD_INSTR, 0x00 | (offset & 0x0f)); // column address set lower
|
|
|
|
int chr = lcd->char_buffer[i];
|
|
|
|
if (chr < 32 || chr > 126) {
|
|
|
|
chr = 127;
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
2014-06-14 17:41:47 -06:00
|
|
|
const uint8_t *chr_data = &font_petme128_8x8[(chr - 32) * 8];
|
|
|
|
for (int j = 7; j >= 0; j--) {
|
|
|
|
lcd_out(lcd, LCD_DATA, chr_data[j]);
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-02 07:35:38 -06:00
|
|
|
/// \classmethod \constructor(skin_position)
|
|
|
|
///
|
|
|
|
/// Construct an LCD object in the given skin position. `skin_position` can be 'X' or 'Y', and
|
|
|
|
/// should match the position where the LCD pyskin is plugged in.
|
2014-08-29 17:35:11 -06:00
|
|
|
STATIC mp_obj_t pyb_lcd_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
|
2014-06-14 17:41:47 -06:00
|
|
|
// check arguments
|
|
|
|
mp_arg_check_num(n_args, n_kw, 1, 1, false);
|
|
|
|
|
|
|
|
// get LCD position
|
|
|
|
const char *lcd_id = mp_obj_str_get_str(args[0]);
|
|
|
|
|
|
|
|
// create lcd object
|
|
|
|
pyb_lcd_obj_t *lcd = m_new_obj(pyb_lcd_obj_t);
|
|
|
|
lcd->base.type = &pyb_lcd_type;
|
|
|
|
|
|
|
|
// configure pins
|
|
|
|
// TODO accept an SPI object and pin objects for full customisation
|
|
|
|
if ((lcd_id[0] | 0x20) == 'x' && lcd_id[1] == '\0') {
|
|
|
|
lcd->spi = &SPIHandle1;
|
|
|
|
lcd->pin_cs1 = &pin_A2; // X3
|
|
|
|
lcd->pin_rst = &pin_A3; // X4
|
|
|
|
lcd->pin_a0 = &pin_A4; // X5
|
|
|
|
lcd->pin_bl = &pin_C5; // X12
|
|
|
|
} else if ((lcd_id[0] | 0x20) == 'y' && lcd_id[1] == '\0') {
|
|
|
|
lcd->spi = &SPIHandle2;
|
|
|
|
lcd->pin_cs1 = &pin_B8; // Y3
|
|
|
|
lcd->pin_rst = &pin_B9; // Y4
|
|
|
|
lcd->pin_a0 = &pin_B12; // Y5
|
|
|
|
lcd->pin_bl = &pin_B1; // Y12
|
2014-03-19 07:11:59 -06:00
|
|
|
} else {
|
2014-06-14 17:41:47 -06:00
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "LCD bus '%s' does not exist", lcd_id));
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
|
|
|
|
2014-06-14 17:41:47 -06:00
|
|
|
// init the SPI bus
|
|
|
|
SPI_InitTypeDef *init = &lcd->spi->Init;
|
|
|
|
init->Mode = SPI_MODE_MASTER;
|
2014-03-19 07:11:59 -06:00
|
|
|
|
2014-06-14 17:41:47 -06:00
|
|
|
// compute the baudrate prescaler from the desired baudrate
|
|
|
|
// select a prescaler that yields at most the desired baudrate
|
|
|
|
uint spi_clock;
|
|
|
|
if (lcd->spi->Instance == SPI1) {
|
|
|
|
// SPI1 is on APB2
|
|
|
|
spi_clock = HAL_RCC_GetPCLK2Freq();
|
|
|
|
} else {
|
|
|
|
// SPI2 and SPI3 are on APB1
|
|
|
|
spi_clock = HAL_RCC_GetPCLK1Freq();
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
2014-06-14 17:41:47 -06:00
|
|
|
uint br_prescale = spi_clock / 16000000; // datasheet says LCD can run at 20MHz, but we go for 16MHz
|
|
|
|
if (br_prescale <= 2) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2; }
|
|
|
|
else if (br_prescale <= 4) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4; }
|
|
|
|
else if (br_prescale <= 8) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8; }
|
|
|
|
else if (br_prescale <= 16) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16; }
|
|
|
|
else if (br_prescale <= 32) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32; }
|
|
|
|
else if (br_prescale <= 64) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64; }
|
|
|
|
else if (br_prescale <= 128) { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128; }
|
|
|
|
else { init->BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256; }
|
|
|
|
|
|
|
|
// data is sent bigendian, latches on rising clock
|
|
|
|
init->CLKPolarity = SPI_POLARITY_HIGH;
|
|
|
|
init->CLKPhase = SPI_PHASE_2EDGE;
|
|
|
|
init->Direction = SPI_DIRECTION_2LINES;
|
|
|
|
init->DataSize = SPI_DATASIZE_8BIT;
|
|
|
|
init->NSS = SPI_NSS_SOFT;
|
|
|
|
init->FirstBit = SPI_FIRSTBIT_MSB;
|
|
|
|
init->TIMode = SPI_TIMODE_DISABLED;
|
|
|
|
init->CRCCalculation = SPI_CRCCALCULATION_DISABLED;
|
|
|
|
init->CRCPolynomial = 0;
|
|
|
|
|
|
|
|
// init the SPI bus
|
2014-09-30 15:26:59 -06:00
|
|
|
spi_init(lcd->spi, false);
|
2014-06-14 17:41:47 -06:00
|
|
|
|
|
|
|
// set the pins to default values
|
|
|
|
lcd->pin_cs1->gpio->BSRRL = lcd->pin_cs1->pin_mask;
|
|
|
|
lcd->pin_rst->gpio->BSRRL = lcd->pin_rst->pin_mask;
|
|
|
|
lcd->pin_a0->gpio->BSRRL = lcd->pin_a0->pin_mask;
|
|
|
|
lcd->pin_bl->gpio->BSRRH = lcd->pin_bl->pin_mask;
|
|
|
|
|
|
|
|
// init the pins to be push/pull outputs
|
2014-03-19 07:11:59 -06:00
|
|
|
GPIO_InitTypeDef GPIO_InitStructure;
|
|
|
|
GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
|
|
|
|
GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
|
|
|
|
GPIO_InitStructure.Pull = GPIO_NOPULL;
|
|
|
|
|
2014-06-14 17:41:47 -06:00
|
|
|
GPIO_InitStructure.Pin = lcd->pin_cs1->pin_mask;
|
|
|
|
HAL_GPIO_Init(lcd->pin_cs1->gpio, &GPIO_InitStructure);
|
|
|
|
|
|
|
|
GPIO_InitStructure.Pin = lcd->pin_rst->pin_mask;
|
|
|
|
HAL_GPIO_Init(lcd->pin_rst->gpio, &GPIO_InitStructure);
|
|
|
|
|
|
|
|
GPIO_InitStructure.Pin = lcd->pin_a0->pin_mask;
|
|
|
|
HAL_GPIO_Init(lcd->pin_a0->gpio, &GPIO_InitStructure);
|
|
|
|
|
|
|
|
GPIO_InitStructure.Pin = lcd->pin_bl->pin_mask;
|
|
|
|
HAL_GPIO_Init(lcd->pin_bl->gpio, &GPIO_InitStructure);
|
2014-03-19 07:11:59 -06:00
|
|
|
|
|
|
|
// init the LCD
|
|
|
|
HAL_Delay(1); // wait a bit
|
2014-06-14 17:41:47 -06:00
|
|
|
lcd->pin_rst->gpio->BSRRH = lcd->pin_rst->pin_mask; // RST=0; reset
|
2014-03-19 07:11:59 -06:00
|
|
|
HAL_Delay(1); // wait for reset; 2us min
|
2014-06-14 17:41:47 -06:00
|
|
|
lcd->pin_rst->gpio->BSRRL = lcd->pin_rst->pin_mask; // RST=1; enable
|
2014-03-19 07:11:59 -06:00
|
|
|
HAL_Delay(1); // wait for reset; 2us min
|
2014-06-14 17:41:47 -06:00
|
|
|
lcd_out(lcd, LCD_INSTR, 0xa0); // ADC select, normal
|
|
|
|
lcd_out(lcd, LCD_INSTR, 0xc0); // common output mode select, normal (this flips the display)
|
|
|
|
lcd_out(lcd, LCD_INSTR, 0xa2); // LCD bias set, 1/9 bias
|
|
|
|
lcd_out(lcd, LCD_INSTR, 0x2f); // power control set, 0b111=(booster on, vreg on, vfollow on)
|
|
|
|
lcd_out(lcd, LCD_INSTR, 0x21); // v0 voltage regulator internal resistor ratio set, 0b001=small
|
|
|
|
lcd_out(lcd, LCD_INSTR, 0x81); // electronic volume mode set
|
|
|
|
lcd_out(lcd, LCD_INSTR, 0x28); // electronic volume register set
|
|
|
|
lcd_out(lcd, LCD_INSTR, 0x40); // display start line set, 0
|
|
|
|
lcd_out(lcd, LCD_INSTR, 0xaf); // LCD display, on
|
|
|
|
|
|
|
|
// clear LCD RAM
|
2014-03-19 07:11:59 -06:00
|
|
|
for (int page = 0; page < 4; page++) {
|
2014-06-14 17:41:47 -06:00
|
|
|
lcd_out(lcd, LCD_INSTR, 0xb0 | page); // page address set
|
|
|
|
lcd_out(lcd, LCD_INSTR, 0x10); // column address set upper
|
|
|
|
lcd_out(lcd, LCD_INSTR, 0x00); // column address set lower
|
2014-03-19 07:11:59 -06:00
|
|
|
for (int i = 0; i < 128; i++) {
|
2014-06-14 17:41:47 -06:00
|
|
|
lcd_out(lcd, LCD_DATA, 0x00);
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-14 17:41:47 -06:00
|
|
|
// clear local char buffer
|
|
|
|
memset(lcd->char_buffer, ' ', LCD_CHAR_BUF_H * LCD_CHAR_BUF_W);
|
|
|
|
lcd->line = 0;
|
|
|
|
lcd->column = 0;
|
|
|
|
lcd->next_line = 0;
|
|
|
|
|
|
|
|
// clear local pixel buffer
|
|
|
|
memset(lcd->pix_buf, 0, LCD_PIX_BUF_BYTE_SIZE);
|
|
|
|
memset(lcd->pix_buf2, 0, LCD_PIX_BUF_BYTE_SIZE);
|
|
|
|
|
|
|
|
return lcd;
|
|
|
|
}
|
|
|
|
|
2014-08-02 07:35:38 -06:00
|
|
|
/// \method command(instr_data, buf)
|
|
|
|
///
|
|
|
|
/// Send an arbitrary command to the LCD. Pass 0 for `instr_data` to send an
|
|
|
|
/// instruction, otherwise pass 1 to send data. `buf` is a buffer with the
|
|
|
|
/// instructions/data to send.
|
2014-06-14 17:41:47 -06:00
|
|
|
STATIC mp_obj_t pyb_lcd_command(mp_obj_t self_in, mp_obj_t instr_data_in, mp_obj_t val) {
|
|
|
|
pyb_lcd_obj_t *self = self_in;
|
|
|
|
|
|
|
|
// get whether instr or data
|
|
|
|
int instr_data = mp_obj_get_int(instr_data_in);
|
|
|
|
|
|
|
|
// get the buffer to send from
|
|
|
|
mp_buffer_info_t bufinfo;
|
|
|
|
uint8_t data[1];
|
|
|
|
pyb_buf_get_for_send(val, &bufinfo, data);
|
|
|
|
|
|
|
|
// send the data
|
|
|
|
for (uint i = 0; i < bufinfo.len; i++) {
|
|
|
|
lcd_out(self, instr_data, ((byte*)bufinfo.buf)[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_lcd_command_obj, pyb_lcd_command);
|
|
|
|
|
2014-08-02 07:35:38 -06:00
|
|
|
/// \method contrast(value)
|
|
|
|
///
|
|
|
|
/// Set the contrast of the LCD. Valid values are between 0 and 47.
|
2014-06-14 17:41:47 -06:00
|
|
|
STATIC mp_obj_t pyb_lcd_contrast(mp_obj_t self_in, mp_obj_t contrast_in) {
|
|
|
|
pyb_lcd_obj_t *self = self_in;
|
|
|
|
int contrast = mp_obj_get_int(contrast_in);
|
|
|
|
if (contrast < 0) {
|
|
|
|
contrast = 0;
|
|
|
|
} else if (contrast > 0x2f) {
|
|
|
|
contrast = 0x2f;
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
2014-06-14 17:41:47 -06:00
|
|
|
lcd_out(self, LCD_INSTR, 0x81); // electronic volume mode set
|
|
|
|
lcd_out(self, LCD_INSTR, contrast); // electronic volume register set
|
|
|
|
return mp_const_none;
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
2014-06-14 17:41:47 -06:00
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_lcd_contrast_obj, pyb_lcd_contrast);
|
2014-03-19 07:11:59 -06:00
|
|
|
|
2014-08-02 07:35:38 -06:00
|
|
|
/// \method light(value)
|
|
|
|
///
|
|
|
|
/// Turn the backlight on/off. True or 1 turns it on, False or 0 turns it off.
|
2014-06-14 17:41:47 -06:00
|
|
|
STATIC mp_obj_t pyb_lcd_light(mp_obj_t self_in, mp_obj_t value) {
|
|
|
|
pyb_lcd_obj_t *self = self_in;
|
|
|
|
if (mp_obj_is_true(value)) {
|
|
|
|
self->pin_bl->gpio->BSRRL = self->pin_bl->pin_mask; // set pin high to turn backlight on
|
|
|
|
} else {
|
|
|
|
self->pin_bl->gpio->BSRRH = self->pin_bl->pin_mask; // set pin low to turn backlight off
|
|
|
|
}
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_lcd_light_obj, pyb_lcd_light);
|
2014-03-19 07:11:59 -06:00
|
|
|
|
2014-08-02 07:35:38 -06:00
|
|
|
/// \method write(str)
|
|
|
|
///
|
|
|
|
/// Write the string `str` to the screen. It will appear immediately.
|
2014-06-14 17:41:47 -06:00
|
|
|
STATIC mp_obj_t pyb_lcd_write(mp_obj_t self_in, mp_obj_t str) {
|
|
|
|
pyb_lcd_obj_t *self = self_in;
|
2014-10-05 14:51:54 -06:00
|
|
|
mp_uint_t len;
|
2014-06-14 17:41:47 -06:00
|
|
|
const char *data = mp_obj_str_get_data(str, &len);
|
|
|
|
lcd_write_strn(self, data, len);
|
|
|
|
return mp_const_none;
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
2014-06-14 17:41:47 -06:00
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_lcd_write_obj, pyb_lcd_write);
|
2014-03-19 07:11:59 -06:00
|
|
|
|
2014-08-02 07:35:38 -06:00
|
|
|
/// \method fill(colour)
|
|
|
|
///
|
|
|
|
/// Fill the screen with the given colour (0 or 1 for white or black).
|
|
|
|
///
|
|
|
|
/// This method writes to the hidden buffer. Use `show()` to show the buffer.
|
2014-06-14 17:41:47 -06:00
|
|
|
STATIC mp_obj_t pyb_lcd_fill(mp_obj_t self_in, mp_obj_t col_in) {
|
|
|
|
pyb_lcd_obj_t *self = self_in;
|
|
|
|
int col = mp_obj_get_int(col_in);
|
|
|
|
if (col) {
|
|
|
|
col = 0xff;
|
|
|
|
}
|
|
|
|
memset(self->pix_buf, col, LCD_PIX_BUF_BYTE_SIZE);
|
|
|
|
memset(self->pix_buf2, col, LCD_PIX_BUF_BYTE_SIZE);
|
|
|
|
return mp_const_none;
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
2014-06-14 17:41:47 -06:00
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_lcd_fill_obj, pyb_lcd_fill);
|
2014-03-19 07:11:59 -06:00
|
|
|
|
2014-08-02 07:35:38 -06:00
|
|
|
/// \method get(x, y)
|
|
|
|
///
|
|
|
|
/// Get the pixel at the position `(x, y)`. Returns 0 or 1.
|
|
|
|
///
|
|
|
|
/// This method reads from the visible buffer.
|
2014-06-14 17:41:47 -06:00
|
|
|
STATIC mp_obj_t pyb_lcd_get(mp_obj_t self_in, mp_obj_t x_in, mp_obj_t y_in) {
|
|
|
|
pyb_lcd_obj_t *self = self_in;
|
|
|
|
int x = mp_obj_get_int(x_in);
|
|
|
|
int y = mp_obj_get_int(y_in);
|
|
|
|
if (0 <= x && x <= 127 && 0 <= y && y <= 31) {
|
|
|
|
uint byte_pos = x + 128 * ((uint)y >> 3);
|
|
|
|
if (self->pix_buf[byte_pos] & (1 << (y & 7))) {
|
|
|
|
return mp_obj_new_int(1);
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
2014-06-14 17:41:47 -06:00
|
|
|
}
|
|
|
|
return mp_obj_new_int(0);
|
|
|
|
}
|
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_lcd_get_obj, pyb_lcd_get);
|
|
|
|
|
2014-08-02 07:35:38 -06:00
|
|
|
/// \method pixel(x, y, colour)
|
|
|
|
///
|
|
|
|
/// Set the pixel at `(x, y)` to the given colour (0 or 1).
|
|
|
|
///
|
|
|
|
/// This method writes to the hidden buffer. Use `show()` to show the buffer.
|
2014-08-29 17:35:11 -06:00
|
|
|
STATIC mp_obj_t pyb_lcd_pixel(mp_uint_t n_args, const mp_obj_t *args) {
|
2014-06-14 17:41:47 -06:00
|
|
|
pyb_lcd_obj_t *self = args[0];
|
|
|
|
int x = mp_obj_get_int(args[1]);
|
|
|
|
int y = mp_obj_get_int(args[2]);
|
|
|
|
if (0 <= x && x <= 127 && 0 <= y && y <= 31) {
|
|
|
|
uint byte_pos = x + 128 * ((uint)y >> 3);
|
|
|
|
if (mp_obj_get_int(args[3]) == 0) {
|
|
|
|
self->pix_buf2[byte_pos] &= ~(1 << (y & 7));
|
2014-03-19 07:11:59 -06:00
|
|
|
} else {
|
2014-06-14 17:41:47 -06:00
|
|
|
self->pix_buf2[byte_pos] |= 1 << (y & 7);
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
|
|
|
}
|
2014-06-14 17:41:47 -06:00
|
|
|
return mp_const_none;
|
|
|
|
}
|
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_lcd_pixel_obj, 4, 4, pyb_lcd_pixel);
|
2014-03-19 07:11:59 -06:00
|
|
|
|
2014-08-02 07:35:38 -06:00
|
|
|
/// \method text(str, x, y, colour)
|
|
|
|
///
|
|
|
|
/// Draw the given text to the position `(x, y)` using the given colour (0 or 1).
|
|
|
|
///
|
|
|
|
/// This method writes to the hidden buffer. Use `show()` to show the buffer.
|
2014-08-29 17:35:11 -06:00
|
|
|
STATIC mp_obj_t pyb_lcd_text(mp_uint_t n_args, const mp_obj_t *args) {
|
2014-06-14 17:41:47 -06:00
|
|
|
// extract arguments
|
|
|
|
pyb_lcd_obj_t *self = args[0];
|
2014-10-05 14:51:54 -06:00
|
|
|
mp_uint_t len;
|
2014-06-14 17:41:47 -06:00
|
|
|
const char *data = mp_obj_str_get_data(args[1], &len);
|
|
|
|
int x0 = mp_obj_get_int(args[2]);
|
|
|
|
int y0 = mp_obj_get_int(args[3]);
|
|
|
|
int col = mp_obj_get_int(args[4]);
|
|
|
|
|
|
|
|
// loop over chars
|
|
|
|
for (const char *top = data + len; data < top; data++) {
|
|
|
|
// get char and make sure its in range of font
|
|
|
|
uint chr = *(byte*)data;
|
|
|
|
if (chr < 32 || chr > 127) {
|
2014-03-19 07:11:59 -06:00
|
|
|
chr = 127;
|
|
|
|
}
|
2014-06-14 17:41:47 -06:00
|
|
|
// get char data
|
2014-03-19 07:11:59 -06:00
|
|
|
const uint8_t *chr_data = &font_petme128_8x8[(chr - 32) * 8];
|
2014-06-14 17:41:47 -06:00
|
|
|
// loop over char data
|
|
|
|
for (uint j = 0; j < 8; j++, x0++) {
|
|
|
|
if (0 <= x0 && x0 < LCD_PIX_BUF_W) { // clip x
|
|
|
|
uint vline_data = chr_data[j]; // each byte of char data is a vertical column of 8 pixels, LSB at top
|
|
|
|
for (int y = y0; vline_data; vline_data >>= 1, y++) { // scan over vertical column
|
|
|
|
if (vline_data & 1) { // only draw if pixel set
|
|
|
|
if (0 <= y && y < LCD_PIX_BUF_H) { // clip y
|
|
|
|
uint byte_pos = x0 + LCD_PIX_BUF_W * ((uint)y >> 3);
|
|
|
|
if (col == 0) {
|
|
|
|
// clear pixel
|
|
|
|
self->pix_buf2[byte_pos] &= ~(1 << (y & 7));
|
|
|
|
} else {
|
|
|
|
// set pixel
|
|
|
|
self->pix_buf2[byte_pos] |= 1 << (y & 7);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-14 17:41:47 -06:00
|
|
|
return mp_const_none;
|
|
|
|
}
|
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_lcd_text_obj, 5, 5, pyb_lcd_text);
|
|
|
|
|
2014-08-02 07:35:38 -06:00
|
|
|
/// \method show()
|
|
|
|
///
|
|
|
|
/// Show the hidden buffer on the screen.
|
2014-06-14 17:41:47 -06:00
|
|
|
STATIC mp_obj_t pyb_lcd_show(mp_obj_t self_in) {
|
|
|
|
pyb_lcd_obj_t *self = self_in;
|
|
|
|
memcpy(self->pix_buf, self->pix_buf2, LCD_PIX_BUF_BYTE_SIZE);
|
|
|
|
for (uint page = 0; page < 4; page++) {
|
|
|
|
lcd_out(self, LCD_INSTR, 0xb0 | page); // page address set
|
|
|
|
lcd_out(self, LCD_INSTR, 0x10); // column address set upper; 0
|
|
|
|
lcd_out(self, LCD_INSTR, 0x00); // column address set lower; 0
|
|
|
|
for (uint i = 0; i < 128; i++) {
|
|
|
|
lcd_out(self, LCD_DATA, self->pix_buf[128 * page + 127 - i]);
|
|
|
|
}
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
2014-06-14 17:41:47 -06:00
|
|
|
return mp_const_none;
|
2014-03-19 07:11:59 -06:00
|
|
|
}
|
2014-06-14 17:41:47 -06:00
|
|
|
STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_lcd_show_obj, pyb_lcd_show);
|
|
|
|
|
|
|
|
STATIC const mp_map_elem_t pyb_lcd_locals_dict_table[] = {
|
|
|
|
// instance methods
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_command), (mp_obj_t)&pyb_lcd_command_obj },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_contrast), (mp_obj_t)&pyb_lcd_contrast_obj },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_light), (mp_obj_t)&pyb_lcd_light_obj },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_write), (mp_obj_t)&pyb_lcd_write_obj },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_fill), (mp_obj_t)&pyb_lcd_fill_obj },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_get), (mp_obj_t)&pyb_lcd_get_obj },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_pixel), (mp_obj_t)&pyb_lcd_pixel_obj },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_text), (mp_obj_t)&pyb_lcd_text_obj },
|
|
|
|
{ MP_OBJ_NEW_QSTR(MP_QSTR_show), (mp_obj_t)&pyb_lcd_show_obj },
|
|
|
|
};
|
|
|
|
|
|
|
|
STATIC MP_DEFINE_CONST_DICT(pyb_lcd_locals_dict, pyb_lcd_locals_dict_table);
|
|
|
|
|
|
|
|
const mp_obj_type_t pyb_lcd_type = {
|
|
|
|
{ &mp_type_type },
|
|
|
|
.name = MP_QSTR_LCD,
|
|
|
|
.make_new = pyb_lcd_make_new,
|
|
|
|
.locals_dict = (mp_obj_t)&pyb_lcd_locals_dict,
|
|
|
|
};
|
2014-03-19 07:11:59 -06:00
|
|
|
|
|
|
|
#endif // MICROPY_HW_HAS_LCD
|