RA8875 - Library to control a Graphics TFT connected to 4-…

Users » WiredHome » Code » RA8875

Library to control a Graphics TFT connected to 4-wire SPI - revised for the Raio RA8875 Display Controller.

Dependents: FRDM_RA8875_mPaint RA8875_Demo RA8875_KeyPadDemo SignalGenerator ... more

Enhanced touch-screen support - where it previous supported both the Resistive Touch and Capacitive Touch based on the FT5206 Touch Controller, now it also has support for the GSL1680 Touch Controller.

Offline Help Manual (Windows chm)

/media/uploads/WiredHome/ra8875.zip.bin (download, rename to .zip and unzip)

RA8875.cpp@154:ad2450fc3dc3, 2018-08-17 (annotated)

Committer:: WiredHome
Date:: Fri Aug 17 01:29:06 2018 +0000
Revision:: 154:ad2450fc3dc3
Parent:: 153:8a85efb3eb71
Child:: 155:b3f225ae572c

Documentation updates for using resistive touch.

Who changed what in which revision?

User	Revision	Line number	New contents of line
WiredHome	152:a013ac0133e4	1	// RA8875 Display Controller Library.
WiredHome	152:a013ac0133e4	2	//
WiredHome	152:a013ac0133e4	3	// This is being created for a Raio RA8875-based display from buydisplay.com,
WiredHome	152:a013ac0133e4	4	// which is either 480 x 272 or 800 x 480, using a 4-wire SPI interface.
WiredHome	152:a013ac0133e4	5	// Support is provided for both a keypad and a resistive touch-screen.
WiredHome	152:a013ac0133e4	6	//
WiredHome	152:a013ac0133e4	7	// See the RA8875.h file for full details.
WiredHome	152:a013ac0133e4	8	//
WiredHome	152:a013ac0133e4	9	// 20161106: Updated the initialization to set the various registers based on
WiredHome	152:a013ac0133e4	10	// the BuyDisplay.com example code. This altered several registers
WiredHome	152:a013ac0133e4	11	// for the 800x480 display driver.
WiredHome	152:a013ac0133e4	12	//
WiredHome	19:3f82c1161fd2	13	#include "RA8875.h"
WiredHome	19:3f82c1161fd2	14
WiredHome	145:5eb2492acdda	15	//#include "Utility.h" // private memory manager
WiredHome	145:5eb2492acdda	16	#ifndef UTILITY_H
WiredHome	145:5eb2492acdda	17	#define swMalloc malloc // use the standard
WiredHome	145:5eb2492acdda	18	#define swFree free
WiredHome	145:5eb2492acdda	19	#endif
WiredHome	145:5eb2492acdda	20
WiredHome	41:2956a0a221e5	21	//#define DEBUG "RAIO"
WiredHome	19:3f82c1161fd2	22	// ...
WiredHome	19:3f82c1161fd2	23	// INFO("Stuff to show %d", var); // new-line is automatically appended
WiredHome	19:3f82c1161fd2	24	//
WiredHome	19:3f82c1161fd2	25	#if (defined(DEBUG) && !defined(TARGET_LPC11U24))
WiredHome	98:ecebed9b80b2	26	#define INFO(x, ...) std::printf("[INF %s %4d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome	98:ecebed9b80b2	27	#define WARN(x, ...) std::printf("[WRN %s %4d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome	98:ecebed9b80b2	28	#define ERR(x, ...) std::printf("[ERR %s %4d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome	98:ecebed9b80b2	29	static void HexDump(const char * title, const uint8_t * p, int count)
WiredHome	73:f22a18707b5e	30	{
WiredHome	73:f22a18707b5e	31	int i;
WiredHome	73:f22a18707b5e	32	char buf[100] = "0000: ";
WiredHome	73:f22a18707b5e	33
WiredHome	73:f22a18707b5e	34	if (*title)
WiredHome	73:f22a18707b5e	35	INFO("%s", title);
WiredHome	73:f22a18707b5e	36	for (i=0; i<count; ) {
WiredHome	73:f22a18707b5e	37	sprintf(buf + strlen(buf), "%02X ", *(p+i));
WiredHome	73:f22a18707b5e	38	if ((++i & 0x0F) == 0x00) {
WiredHome	73:f22a18707b5e	39	INFO("%s", buf);
WiredHome	73:f22a18707b5e	40	if (i < count)
WiredHome	73:f22a18707b5e	41	sprintf(buf, "%04X: ", i);
WiredHome	73:f22a18707b5e	42	else
WiredHome	73:f22a18707b5e	43	buf[0] = '\0';
WiredHome	73:f22a18707b5e	44	}
WiredHome	73:f22a18707b5e	45	}
WiredHome	73:f22a18707b5e	46	if (strlen(buf))
WiredHome	73:f22a18707b5e	47	INFO("%s", buf);
WiredHome	73:f22a18707b5e	48	}
WiredHome	19:3f82c1161fd2	49	#else
WiredHome	19:3f82c1161fd2	50	#define INFO(x, ...)
WiredHome	19:3f82c1161fd2	51	#define WARN(x, ...)
WiredHome	19:3f82c1161fd2	52	#define ERR(x, ...)
WiredHome	73:f22a18707b5e	53	#define HexDump(a, b, c)
WiredHome	19:3f82c1161fd2	54	#endif
WiredHome	19:3f82c1161fd2	55
WiredHome	109:7b94f06f085b	56	// Defaults. Users can override this with the init() method.
WiredHome	19:3f82c1161fd2	57	#define RA8875_DISPLAY_WIDTH 480
WiredHome	19:3f82c1161fd2	58	#define RA8875_DISPLAY_HEIGHT 272
WiredHome	43:3becae133285	59	#define RA8875_COLORDEPTH_BPP 16 /* Not an API */
WiredHome	19:3f82c1161fd2	60
WiredHome	19:3f82c1161fd2	61	#ifdef PERF_METRICS
WiredHome	19:3f82c1161fd2	62	#define PERFORMANCE_RESET performance.reset()
WiredHome	19:3f82c1161fd2	63	#define REGISTERPERFORMANCE(a) RegisterPerformance(a)
WiredHome	68:ab08efabfc88	64	#define COUNTIDLETIME(a) CountIdleTime(a)
WiredHome	73:f22a18707b5e	65	static const char *metricsName[] = {
WiredHome	109:7b94f06f085b	66	"Cls", "Pixel", "Pixel Stream", "Boolean Stream",
WiredHome	41:2956a0a221e5	67	"Read Pixel", "Read Pixel Stream",
WiredHome	73:f22a18707b5e	68	"Line",
WiredHome	73:f22a18707b5e	69	"Rectangle", "Rounded Rectangle",
WiredHome	68:ab08efabfc88	70	"Triangle", "Circle", "Ellipse"
WiredHome	19:3f82c1161fd2	71	};
WiredHome	91:ca5f829e6d27	72	uint16_t commandsUsed[256]; // track which commands are used with simple counter of number of hits.
WiredHome	19:3f82c1161fd2	73	#else
WiredHome	19:3f82c1161fd2	74	#define PERFORMANCE_RESET
WiredHome	19:3f82c1161fd2	75	#define REGISTERPERFORMANCE(a)
WiredHome	68:ab08efabfc88	76	#define COUNTIDLETIME(a)
WiredHome	19:3f82c1161fd2	77	#endif
WiredHome	19:3f82c1161fd2	78
WiredHome	73:f22a18707b5e	79	// When it is going to poll a register for completion, how many
WiredHome	19:3f82c1161fd2	80	// uSec should it wait between each polling activity.
WiredHome	19:3f82c1161fd2	81	#define POLLWAITuSec 10
WiredHome	19:3f82c1161fd2	82
WiredHome	75:ca78388cfd77	83	// Private RawKeyMap for the Keyboard interface
WiredHome	79:544eb4964795	84	static const uint8_t DefaultKeyMap[22] = {
WiredHome	77:9206c13aa527	85	0,
WiredHome	77:9206c13aa527	86	1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
WiredHome	75:ca78388cfd77	87	11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
WiredHome	75:ca78388cfd77	88	255
WiredHome	77:9206c13aa527	89	};
WiredHome	75:ca78388cfd77	90
WiredHome	79:544eb4964795	91	static const char * ErrMessages[] = {
WiredHome	79:544eb4964795	92	"noerror", ///< no errors, command completed successfully
WiredHome	89:04575562c961	93	"bad parameter", ///< one or more parameters are invalid
WiredHome	89:04575562c961	94	"file not found", ///< specified file could not be found
WiredHome	89:04575562c961	95	"not bmp format", ///< file is not a .bmp file
WiredHome	89:04575562c961	96	"not ico format", ///< file is not a .ico file
WiredHome	89:04575562c961	97	"not supported format", ///< file format is not yet supported
WiredHome	89:04575562c961	98	"image too big", ///< image is too large for the screen
WiredHome	89:04575562c961	99	"not enough ram", ///< could not allocate ram for scanline
WiredHome	125:7a0b70f56550	100	"touch cal. timeout", ///< calibration could not complete in time
WiredHome	125:7a0b70f56550	101	"external abort", ///< during an idle callback, the user code initiated an abort
WiredHome	79:544eb4964795	102	};
WiredHome	19:3f82c1161fd2	103
WiredHome	124:1690a7ae871c	104	RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset,
WiredHome	124:1690a7ae871c	105	const char *name)
WiredHome	58:26658a56112a	106	: GraphicsDisplay(name)
WiredHome	58:26658a56112a	107	, spi(mosi, miso, sclk)
WiredHome	19:3f82c1161fd2	108	, cs(csel)
WiredHome	19:3f82c1161fd2	109	, res(reset)
WiredHome	19:3f82c1161fd2	110	{
WiredHome	124:1690a7ae871c	111	useTouchPanel = TP_NONE;
WiredHome	124:1690a7ae871c	112	m_irq = NULL;
WiredHome	124:1690a7ae871c	113	m_i2c = NULL;
WiredHome	96:40b74dd3695b	114	c_callback = NULL;
WiredHome	96:40b74dd3695b	115	obj_callback = NULL;
WiredHome	96:40b74dd3695b	116	method_callback = NULL;
WiredHome	123:2f45e80fec5f	117	idle_callback = NULL;
WiredHome	153:8a85efb3eb71	118	fontScaleX = fontScaleY = 1;
WiredHome	19:3f82c1161fd2	119	}
WiredHome	19:3f82c1161fd2	120
WiredHome	124:1690a7ae871c	121
WiredHome	124:1690a7ae871c	122	RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset,
WiredHome	124:1690a7ae871c	123	PinName sda, PinName scl, PinName irq, const char * name)
WiredHome	124:1690a7ae871c	124	: GraphicsDisplay(name)
WiredHome	124:1690a7ae871c	125	, spi(mosi, miso, sclk)
WiredHome	124:1690a7ae871c	126	, cs(csel)
WiredHome	124:1690a7ae871c	127	, res(reset)
WiredHome	124:1690a7ae871c	128	{
WiredHome	124:1690a7ae871c	129	useTouchPanel = TP_CAP;
WiredHome	124:1690a7ae871c	130	m_irq = new InterruptIn(irq);
WiredHome	124:1690a7ae871c	131	m_i2c = new I2C(sda, scl);
WiredHome	124:1690a7ae871c	132	c_callback = NULL;
WiredHome	124:1690a7ae871c	133	obj_callback = NULL;
WiredHome	124:1690a7ae871c	134	method_callback = NULL;
WiredHome	124:1690a7ae871c	135	idle_callback = NULL;
WiredHome	153:8a85efb3eb71	136	fontScaleX = fontScaleY = 1;
WiredHome	124:1690a7ae871c	137
WiredHome	124:1690a7ae871c	138	// Cap touch panel config
WiredHome	124:1690a7ae871c	139	m_addr = (FT5206_I2C_ADDRESS << 1);
WiredHome	124:1690a7ae871c	140	m_i2c->frequency(FT5206_I2C_FREQUENCY);
WiredHome	124:1690a7ae871c	141
WiredHome	124:1690a7ae871c	142	// Interrupt
WiredHome	124:1690a7ae871c	143	m_irq->mode(PullUp);
WiredHome	124:1690a7ae871c	144	m_irq->enable_irq();
WiredHome	154:ad2450fc3dc3	145	#if (MBED_MAJOR_VERSION >= 5) \|\| (MBED_LIBRARY_VERSION > 128) // Is this the right version?
WiredHome	145:5eb2492acdda	146	m_irq->fall(callback(this, &RA8875::TouchPanelISR));
WiredHome	150:35a4db3081c1	147	#else
WiredHome	150:35a4db3081c1	148	m_irq->fall(this, &RA8875::TouchPanelISR);
WiredHome	150:35a4db3081c1	149	#endif
WiredHome	124:1690a7ae871c	150	TouchPanelInit();
WiredHome	124:1690a7ae871c	151	}
WiredHome	124:1690a7ae871c	152
WiredHome	124:1690a7ae871c	153
WiredHome	19:3f82c1161fd2	154	//RA8875::~RA8875()
WiredHome	19:3f82c1161fd2	155	//{
WiredHome	19:3f82c1161fd2	156	//}
WiredHome	19:3f82c1161fd2	157
WiredHome	154:ad2450fc3dc3	158
WiredHome	131:5bd6ba2ee4a1	159	RetCode_t RA8875::init(int width, int height, int color_bpp, uint8_t poweron, bool keypadon, bool touchscreenon)
WiredHome	79:544eb4964795	160	{
WiredHome	98:ecebed9b80b2	161	font = NULL; // no external font, use internal.
WiredHome	98:ecebed9b80b2	162	pKeyMap = DefaultKeyMap; // set default key map
WiredHome	98:ecebed9b80b2	163	_select(false); // deselect the display
WiredHome	98:ecebed9b80b2	164	frequency(RA8875_DEFAULT_SPI_FREQ); // data rate
WiredHome	79:544eb4964795	165	Reset();
WiredHome	134:f028ed71a0af	166	// Set PLL based on display size from buy-display.com sample code
WiredHome	134:f028ed71a0af	167	if (width == 800) {
WiredHome	134:f028ed71a0af	168	WriteCommand(0x88, 0x0C); // PLLC1 - Phase Lock Loop registers
WiredHome	134:f028ed71a0af	169	} else {
WiredHome	134:f028ed71a0af	170	WriteCommand(0x88, 0x0B); // PLLC1 - Phase Lock Loop registers
WiredHome	134:f028ed71a0af	171	}
WiredHome	79:544eb4964795	172	wait_ms(1);
WiredHome	79:544eb4964795	173	WriteCommand(0x89, 0x02);
WiredHome	79:544eb4964795	174	wait_ms(1);
WiredHome	79:544eb4964795	175
WiredHome	79:544eb4964795	176	// System Config Register (SYSR)
WiredHome	105:4f116006ba1f	177	screenbpp = color_bpp;
WiredHome	79:544eb4964795	178	if (color_bpp == 16) {
WiredHome	79:544eb4964795	179	WriteCommand(0x10, 0x0C); // 16-bpp (65K colors) color depth, 8-bit interface
WiredHome	79:544eb4964795	180	} else { // color_bpp == 8
WiredHome	79:544eb4964795	181	WriteCommand(0x10, 0x00); // 8-bpp (256 colors)
WiredHome	79:544eb4964795	182	}
WiredHome	134:f028ed71a0af	183
WiredHome	134:f028ed71a0af	184	// Set Pixel Clock Setting Register (PCSR) based on display size from buy-display.com sample code
WiredHome	134:f028ed71a0af	185	if (width == 800) {
WiredHome	134:f028ed71a0af	186	WriteCommand(0x04, 0x81); // PDAT on PCLK falling edge, PCLK = 4 x System Clock
WiredHome	134:f028ed71a0af	187	wait_ms(1);
WiredHome	134:f028ed71a0af	188
WiredHome	134:f028ed71a0af	189	// Horizontal Settings
WiredHome	134:f028ed71a0af	190	screenwidth = width;
WiredHome	134:f028ed71a0af	191	WriteCommand(0x14, width/8 - 1); //HDWR//Horizontal Display Width Setting Bit[6:0]
WiredHome	134:f028ed71a0af	192	WriteCommand(0x15, 0x00); //HNDFCR//Horizontal Non-Display Period fine tune Bit[3:0]
WiredHome	134:f028ed71a0af	193	WriteCommand(0x16, 0x03); //HNDR//Horizontal Non-Display Period Bit[4:0]
WiredHome	134:f028ed71a0af	194	WriteCommand(0x17, 0x03); //HSTR//HSYNC Start Position[4:0]
WiredHome	134:f028ed71a0af	195	WriteCommand(0x18, 0x0B); //HPWR//HSYNC Polarity ,The period width of HSYNC.
WiredHome	134:f028ed71a0af	196
WiredHome	134:f028ed71a0af	197	// Vertical Settings
WiredHome	134:f028ed71a0af	198	screenheight = height;
WiredHome	134:f028ed71a0af	199	WriteCommand(0x19, (height-1)&0xFF); //VDHR0 //Vertical Display Height Bit [7:0]
WiredHome	134:f028ed71a0af	200	WriteCommand(0x1a, (height-1)>>8); //VDHR1 //Vertical Display Height Bit [8]
WiredHome	134:f028ed71a0af	201	WriteCommand(0x1b, 0x20); //VNDR0 //Vertical Non-Display Period Bit [7:0]
WiredHome	134:f028ed71a0af	202	WriteCommand(0x1c, 0x00); //VNDR1 //Vertical Non-Display Period Bit [8]
WiredHome	134:f028ed71a0af	203	WriteCommand(0x1d, 0x16); //VSTR0 //VSYNC Start Position[7:0]
WiredHome	134:f028ed71a0af	204	WriteCommand(0x1e, 0x00); //VSTR1 //VSYNC Start Position[8]
WiredHome	134:f028ed71a0af	205	WriteCommand(0x1f, 0x01); //VPWR //VSYNC Polarity ,VSYNC Pulse Width[6:0]
WiredHome	134:f028ed71a0af	206	} else {
WiredHome	134:f028ed71a0af	207	WriteCommand(0x04, 0x82); // PDAT on PCLK falling edge, PCLK = 4 x System Clock
WiredHome	134:f028ed71a0af	208	wait_ms(1);
WiredHome	134:f028ed71a0af	209
WiredHome	134:f028ed71a0af	210	// Horizontal Settings
WiredHome	134:f028ed71a0af	211	screenwidth = width;
WiredHome	134:f028ed71a0af	212	WriteCommand(0x14, width/8 - 1); //HDWR//Horizontal Display Width Setting Bit[6:0]
WiredHome	134:f028ed71a0af	213	WriteCommand(0x15, 0x02); //HNDFCR//Horizontal Non-Display Period fine tune Bit[3:0]
WiredHome	134:f028ed71a0af	214	WriteCommand(0x16, 0x03); //HNDR//Horizontal Non-Display Period Bit[4:0]
WiredHome	134:f028ed71a0af	215	WriteCommand(0x17, 0x01); //HSTR//HSYNC Start Position[4:0]
WiredHome	134:f028ed71a0af	216	WriteCommand(0x18, 0x03); //HPWR//HSYNC Polarity ,The period width of HSYNC.
WiredHome	134:f028ed71a0af	217
WiredHome	134:f028ed71a0af	218	// Vertical Settings
WiredHome	134:f028ed71a0af	219	screenheight = height;
WiredHome	134:f028ed71a0af	220	WriteCommand(0x19, (height-1)&0xFF); //VDHR0 //Vertical Display Height Bit [7:0]
WiredHome	134:f028ed71a0af	221	WriteCommand(0x1a, (height-1)>>8); //VDHR1 //Vertical Display Height Bit [8]
WiredHome	134:f028ed71a0af	222	WriteCommand(0x1b, 0x0F); //VNDR0 //Vertical Non-Display Period Bit [7:0]
WiredHome	134:f028ed71a0af	223	WriteCommand(0x1c, 0x00); //VNDR1 //Vertical Non-Display Period Bit [8]
WiredHome	134:f028ed71a0af	224	WriteCommand(0x1d, 0x0e); //VSTR0 //VSYNC Start Position[7:0]
WiredHome	134:f028ed71a0af	225	WriteCommand(0x1e, 0x06); //VSTR1 //VSYNC Start Position[8]
WiredHome	134:f028ed71a0af	226	WriteCommand(0x1f, 0x01); //VPWR //VSYNC Polarity ,VSYNC Pulse Width[6:0]
WiredHome	134:f028ed71a0af	227	}
WiredHome	79:544eb4964795	228
WiredHome	100:0b084475d5a9	229	portraitmode = false;
WiredHome	133:e36dcfc2d756	230
WiredHome	79:544eb4964795	231	if (width >= 800 && height >= 480 && color_bpp > 8) {
WiredHome	79:544eb4964795	232	WriteCommand(0x20, 0x00); // DPCR - 1-layer mode when the resolution is too high
WiredHome	79:544eb4964795	233	} else {
WiredHome	79:544eb4964795	234	WriteCommand(0x20, 0x80); // DPCR - 2-layer mode
WiredHome	79:544eb4964795	235	}
WiredHome	79:544eb4964795	236
WiredHome	79:544eb4964795	237	// Set display image to Blue on Black as default
WiredHome	79:544eb4964795	238	window(0,0, width, height); // Initialize to full screen
WiredHome	79:544eb4964795	239	SetTextCursorControl();
WiredHome	79:544eb4964795	240	foreground(Blue);
WiredHome	79:544eb4964795	241	background(Black);
WiredHome	79:544eb4964795	242	cls(3);
WiredHome	79:544eb4964795	243
WiredHome	79:544eb4964795	244	Power(poweron);
WiredHome	131:5bd6ba2ee4a1	245	Backlight_u8(poweron);
WiredHome	81:01da2e34283d	246	if (keypadon)
WiredHome	81:01da2e34283d	247	KeypadInit();
WiredHome	124:1690a7ae871c	248	if (touchscreenon) {
WiredHome	124:1690a7ae871c	249	if (useTouchPanel == TP_NONE)
WiredHome	124:1690a7ae871c	250	useTouchPanel = TP_RES;
WiredHome	81:01da2e34283d	251	TouchPanelInit();
WiredHome	124:1690a7ae871c	252	}
WiredHome	79:544eb4964795	253	#ifdef PERF_METRICS
WiredHome	79:544eb4964795	254	performance.start();
WiredHome	79:544eb4964795	255	ClearPerformance();
WiredHome	79:544eb4964795	256	#endif
WiredHome	79:544eb4964795	257	return noerror;
WiredHome	79:544eb4964795	258	}
WiredHome	79:544eb4964795	259
WiredHome	79:544eb4964795	260
WiredHome	79:544eb4964795	261	RetCode_t RA8875::Reset(void)
WiredHome	79:544eb4964795	262	{
WiredHome	79:544eb4964795	263	RetCode_t ret;
WiredHome	79:544eb4964795	264
WiredHome	94:203729061e48	265	#if 0
WiredHome	94:203729061e48	266	if (res != (PinName)NC) {
WiredHome	94:203729061e48	267	res = 0; // Active low - assert reset
WiredHome	94:203729061e48	268	wait_ms(2); // must be > 1024 clock periods. (@25 MHz, this is 40.96 usec)
WiredHome	94:203729061e48	269	res = 1; // de-assert reset
WiredHome	94:203729061e48	270	}
WiredHome	94:203729061e48	271	#endif
WiredHome	94:203729061e48	272	ret = WriteCommand(0x01, 0x01); // Apply Display Off, Reset
WiredHome	94:203729061e48	273	wait_ms(2); // no idea if I need to wait, or how long
WiredHome	79:544eb4964795	274	if (ret == noerror) {
WiredHome	94:203729061e48	275	ret = WriteCommand(0x01, 0x00); // Display off, Remove reset
WiredHome	94:203729061e48	276	wait_ms(2); // no idea if I need to wait, or how long
WiredHome	79:544eb4964795	277	}
WiredHome	79:544eb4964795	278	return ret;
WiredHome	79:544eb4964795	279	}
WiredHome	79:544eb4964795	280
WiredHome	79:544eb4964795	281
WiredHome	79:544eb4964795	282	const char * RA8875::GetErrorMessage(RetCode_t code)
WiredHome	79:544eb4964795	283	{
WiredHome	79:544eb4964795	284	if (code >= LastErrCode)
WiredHome	79:544eb4964795	285	code = bad_parameter;
WiredHome	79:544eb4964795	286	return ErrMessages[code];
WiredHome	79:544eb4964795	287	}
WiredHome	79:544eb4964795	288
WiredHome	79:544eb4964795	289
WiredHome	61:8f3153bf0baa	290	uint16_t RA8875::GetDrawingLayer(void)
WiredHome	61:8f3153bf0baa	291	{
WiredHome	61:8f3153bf0baa	292	return (ReadCommand(0x41) & 0x01);
WiredHome	61:8f3153bf0baa	293	}
WiredHome	43:3becae133285	294
WiredHome	79:544eb4964795	295
WiredHome	143:e872d65a710d	296	RetCode_t RA8875::SelectDrawingLayer(uint16_t layer, uint16_t * prevLayer)
WiredHome	43:3becae133285	297	{
WiredHome	142:6e9bff59878a	298	unsigned char mwcr1 = ReadCommand(0x41); // retain all but the currently selected layer
WiredHome	143:e872d65a710d	299
WiredHome	143:e872d65a710d	300	if (prevLayer)
WiredHome	143:e872d65a710d	301	*prevLayer = mwcr1 & 1;
WiredHome	142:6e9bff59878a	302
WiredHome	142:6e9bff59878a	303	mwcr1 &= ~0x01; // remove the current layer
WiredHome	106:c80828f5dea4	304	if (screenwidth >= 800 && screenheight >= 480 && screenbpp > 8) {
WiredHome	142:6e9bff59878a	305	layer = 0;
WiredHome	43:3becae133285	306	} else if (layer > 1) {
WiredHome	142:6e9bff59878a	307	layer = 0;
WiredHome	43:3becae133285	308	}
WiredHome	143:e872d65a710d	309	return WriteCommand(0x41, mwcr1 \| layer);
WiredHome	43:3becae133285	310	}
WiredHome	43:3becae133285	311
WiredHome	44:207594dece70	312
WiredHome	82:f7d300f26540	313	RA8875::LayerMode_T RA8875::GetLayerMode(void)
WiredHome	82:f7d300f26540	314	{
WiredHome	82:f7d300f26540	315	return (LayerMode_T)(ReadCommand(0x52) & 0x7);
WiredHome	82:f7d300f26540	316	}
WiredHome	82:f7d300f26540	317
WiredHome	82:f7d300f26540	318
WiredHome	53:86d24b9480b9	319	RetCode_t RA8875::SetLayerMode(LayerMode_T mode)
WiredHome	44:207594dece70	320	{
WiredHome	53:86d24b9480b9	321	unsigned char ltpr0 = ReadCommand(0x52) & ~0x7; // retain all but the display layer mode
WiredHome	105:4f116006ba1f	322
WiredHome	53:86d24b9480b9	323	if (mode <= (LayerMode_T)6) {
WiredHome	53:86d24b9480b9	324	WriteCommand(0x52, ltpr0 \| (mode & 0x7));
WiredHome	53:86d24b9480b9	325	return noerror;
WiredHome	53:86d24b9480b9	326	} else {
WiredHome	53:86d24b9480b9	327	return bad_parameter;
WiredHome	53:86d24b9480b9	328	}
WiredHome	44:207594dece70	329	}
WiredHome	44:207594dece70	330
WiredHome	44:207594dece70	331
WiredHome	44:207594dece70	332	RetCode_t RA8875::SetLayerTransparency(uint8_t layer1, uint8_t layer2)
WiredHome	44:207594dece70	333	{
WiredHome	44:207594dece70	334	if (layer1 > 8)
WiredHome	44:207594dece70	335	layer1 = 8;
WiredHome	44:207594dece70	336	if (layer2 > 8)
WiredHome	44:207594dece70	337	layer2 = 8;
WiredHome	44:207594dece70	338	WriteCommand(0x53, ((layer2 & 0xF) << 4) \| (layer1 & 0xF));
WiredHome	44:207594dece70	339	return noerror;
WiredHome	44:207594dece70	340	}
WiredHome	44:207594dece70	341
WiredHome	44:207594dece70	342
WiredHome	53:86d24b9480b9	343	RetCode_t RA8875::SetBackgroundTransparencyColor(color_t color)
WiredHome	53:86d24b9480b9	344	{
WiredHome	133:e36dcfc2d756	345	return _writeColorTrio(0x67, color);
WiredHome	53:86d24b9480b9	346	}
WiredHome	53:86d24b9480b9	347
WiredHome	79:544eb4964795	348
WiredHome	73:f22a18707b5e	349	color_t RA8875::GetBackgroundTransparencyColor(void)
WiredHome	73:f22a18707b5e	350	{
WiredHome	73:f22a18707b5e	351	RGBQUAD q;
WiredHome	105:4f116006ba1f	352
WiredHome	73:f22a18707b5e	353	q.rgbRed = ReadCommand(0x67);
WiredHome	73:f22a18707b5e	354	q.rgbGreen = ReadCommand(0x68);
WiredHome	73:f22a18707b5e	355	q.rgbBlue = ReadCommand(0x69);
WiredHome	73:f22a18707b5e	356	return RGBQuadToRGB16(&q, 0);
WiredHome	73:f22a18707b5e	357	}
WiredHome	73:f22a18707b5e	358
WiredHome	71:dcac8efd842d	359
WiredHome	77:9206c13aa527	360	RetCode_t RA8875::KeypadInit(bool scanEnable, bool longDetect, uint8_t sampleTime, uint8_t scanFrequency,
WiredHome	77:9206c13aa527	361	uint8_t longTimeAdjustment, bool interruptEnable, bool wakeupEnable)
WiredHome	71:dcac8efd842d	362	{
WiredHome	71:dcac8efd842d	363	uint8_t value = 0;
WiredHome	77:9206c13aa527	364
WiredHome	71:dcac8efd842d	365	if (sampleTime > 3 \|\| scanFrequency > 7 \|\| longTimeAdjustment > 3)
WiredHome	71:dcac8efd842d	366	return bad_parameter;
WiredHome	71:dcac8efd842d	367	value \|= (scanEnable) ? 0x80 : 0x00;
WiredHome	71:dcac8efd842d	368	value \|= (longDetect) ? 0x40 : 0x00;
WiredHome	71:dcac8efd842d	369	value \|= (sampleTime & 0x03) << 4;
WiredHome	71:dcac8efd842d	370	value \|= (scanFrequency & 0x07);
WiredHome	75:ca78388cfd77	371	WriteCommand(0xC0, value); // KSCR1 - Enable Key Scan (and ignore possibility of an error)
WiredHome	77:9206c13aa527	372
WiredHome	71:dcac8efd842d	373	value = 0;
WiredHome	71:dcac8efd842d	374	value \|= (wakeupEnable) ? 0x80 : 0x00;
WiredHome	71:dcac8efd842d	375	value \|= (longTimeAdjustment & 0x03) << 2;
WiredHome	75:ca78388cfd77	376	WriteCommand(0xC1, value); // KSCR2 - (and ignore possibility of an error)
WiredHome	77:9206c13aa527	377
WiredHome	75:ca78388cfd77	378	value = ReadCommand(0xF0); // (and ignore possibility of an error)
WiredHome	71:dcac8efd842d	379	value &= ~0x10;
WiredHome	71:dcac8efd842d	380	value \|= (interruptEnable) ? 0x10 : 0x00;
WiredHome	75:ca78388cfd77	381	return WriteCommand(0xF0, value); // INT
WiredHome	71:dcac8efd842d	382	}
WiredHome	71:dcac8efd842d	383
WiredHome	79:544eb4964795	384
WiredHome	75:ca78388cfd77	385	RetCode_t RA8875::SetKeyMap(const uint8_t * CodeList)
WiredHome	75:ca78388cfd77	386	{
WiredHome	75:ca78388cfd77	387	pKeyMap = CodeList;
WiredHome	75:ca78388cfd77	388	return noerror;
WiredHome	75:ca78388cfd77	389	}
WiredHome	75:ca78388cfd77	390
WiredHome	79:544eb4964795	391
WiredHome	75:ca78388cfd77	392	bool RA8875::readable(void)
WiredHome	71:dcac8efd842d	393	{
WiredHome	71:dcac8efd842d	394	return (ReadCommand(0xF1) & 0x10); // check KS status - true if kbhit
WiredHome	71:dcac8efd842d	395	}
WiredHome	71:dcac8efd842d	396
WiredHome	79:544eb4964795	397
WiredHome	75:ca78388cfd77	398	uint8_t RA8875::getc(void)
WiredHome	71:dcac8efd842d	399	{
WiredHome	79:544eb4964795	400	//#define GETC_DEV // for development
WiredHome	77:9206c13aa527	401	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	402	uint8_t keyCode1, keyCode2;
WiredHome	77:9206c13aa527	403	#endif
WiredHome	75:ca78388cfd77	404	uint8_t keyCode3;
WiredHome	75:ca78388cfd77	405	static uint8_t count = 0;
WiredHome	75:ca78388cfd77	406	uint8_t col, row;
WiredHome	75:ca78388cfd77	407	uint8_t key;
WiredHome	123:2f45e80fec5f	408
WiredHome	75:ca78388cfd77	409	while (!readable()) {
WiredHome	71:dcac8efd842d	410	wait_us(POLLWAITuSec);
WiredHome	75:ca78388cfd77	411	// COUNTIDLETIME(POLLWAITuSec); // As it is voluntary to call the getc and pend. Don't tally it.
WiredHome	123:2f45e80fec5f	412	if (idle_callback) {
WiredHome	149:c62c4b2d6a15	413	if (external_abort == (*idle_callback)(getc_wait, 0)) {
WiredHome	123:2f45e80fec5f	414	return 0;
WiredHome	123:2f45e80fec5f	415	}
WiredHome	123:2f45e80fec5f	416	}
WiredHome	71:dcac8efd842d	417	}
WiredHome	71:dcac8efd842d	418	// read the key press number
WiredHome	71:dcac8efd842d	419	uint8_t keyNumReg = ReadCommand(0xC1) & 0x03;
WiredHome	75:ca78388cfd77	420	count++;
WiredHome	75:ca78388cfd77	421	switch (keyNumReg) {
WiredHome	75:ca78388cfd77	422	case 0x01: // one key
WiredHome	75:ca78388cfd77	423	keyCode3 = ReadCommand(0xC2);
WiredHome	77:9206c13aa527	424	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	425	keyCode2 = 0;
WiredHome	75:ca78388cfd77	426	keyCode1 = 0;
WiredHome	77:9206c13aa527	427	#endif
WiredHome	75:ca78388cfd77	428	break;
WiredHome	75:ca78388cfd77	429	case 0x02: // two keys
WiredHome	75:ca78388cfd77	430	keyCode3 = ReadCommand(0xC3);
WiredHome	77:9206c13aa527	431	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	432	keyCode2 = ReadCommand(0xC2);
WiredHome	75:ca78388cfd77	433	keyCode1 = 0;
WiredHome	77:9206c13aa527	434	#endif
WiredHome	75:ca78388cfd77	435	break;
WiredHome	75:ca78388cfd77	436	case 0x03: // three keys
WiredHome	75:ca78388cfd77	437	keyCode3 = ReadCommand(0xC4);
WiredHome	77:9206c13aa527	438	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	439	keyCode2 = ReadCommand(0xC3);
WiredHome	75:ca78388cfd77	440	keyCode1 = ReadCommand(0xC2);
WiredHome	77:9206c13aa527	441	#endif
WiredHome	75:ca78388cfd77	442	break;
WiredHome	75:ca78388cfd77	443	default: // no keys (key released)
WiredHome	75:ca78388cfd77	444	keyCode3 = 0xFF;
WiredHome	77:9206c13aa527	445	#ifdef GETC_DEV
WiredHome	75:ca78388cfd77	446	keyCode2 = 0;
WiredHome	75:ca78388cfd77	447	keyCode1 = 0;
WiredHome	77:9206c13aa527	448	#endif
WiredHome	75:ca78388cfd77	449	break;
WiredHome	75:ca78388cfd77	450	}
WiredHome	75:ca78388cfd77	451	if (keyCode3 == 0xFF)
WiredHome	75:ca78388cfd77	452	key = pKeyMap[0]; // Key value 0
WiredHome	75:ca78388cfd77	453	else {
WiredHome	75:ca78388cfd77	454	row = (keyCode3 >> 4) & 0x03;
WiredHome	75:ca78388cfd77	455	col = (keyCode3 & 7);
WiredHome	75:ca78388cfd77	456	key = row * 5 + col + 1; // Keys value 1 - 20
WiredHome	75:ca78388cfd77	457	if (key > 21) {
WiredHome	75:ca78388cfd77	458	key = 21;
WiredHome	75:ca78388cfd77	459	}
WiredHome	75:ca78388cfd77	460	key = pKeyMap[key];
WiredHome	75:ca78388cfd77	461	key \|= (keyCode3 & 0x80); // combine the key held flag
WiredHome	75:ca78388cfd77	462	}
WiredHome	77:9206c13aa527	463	#if GETC_DEV // for Development only
WiredHome	75:ca78388cfd77	464	SetTextCursor(0, 20);
WiredHome	75:ca78388cfd77	465	printf(" Reg: %02x\r\n", keyNumReg);
WiredHome	75:ca78388cfd77	466	printf(" key1: %02x\r\n", keyCode1);
WiredHome	75:ca78388cfd77	467	printf(" key2: %02x\r\n", keyCode2);
WiredHome	75:ca78388cfd77	468	printf(" key3: %02x\r\n", keyCode3);
WiredHome	75:ca78388cfd77	469	printf(" count: %02X\r\n", count);
WiredHome	75:ca78388cfd77	470	printf(" key: %02X\r\n", key);
WiredHome	77:9206c13aa527	471	#endif
WiredHome	75:ca78388cfd77	472	WriteCommand(0xF1, 0x10); // Clear KS status
WiredHome	75:ca78388cfd77	473	return key;
WiredHome	71:dcac8efd842d	474	}
WiredHome	71:dcac8efd842d	475
WiredHome	79:544eb4964795	476
WiredHome	19:3f82c1161fd2	477	#ifdef PERF_METRICS
WiredHome	19:3f82c1161fd2	478	void RA8875::ClearPerformance()
WiredHome	19:3f82c1161fd2	479	{
WiredHome	100:0b084475d5a9	480	int i;
WiredHome	100:0b084475d5a9	481
WiredHome	100:0b084475d5a9	482	for (i=0; i<METRICCOUNT; i++)
WiredHome	19:3f82c1161fd2	483	metrics[i] = 0;
WiredHome	75:ca78388cfd77	484	idletime_usec = 0;
WiredHome	100:0b084475d5a9	485	for (i=0; i<256; i++)
WiredHome	100:0b084475d5a9	486	commandsUsed[i] = 0;
WiredHome	19:3f82c1161fd2	487	}
WiredHome	19:3f82c1161fd2	488
WiredHome	79:544eb4964795	489
WiredHome	19:3f82c1161fd2	490	void RA8875::RegisterPerformance(method_e method)
WiredHome	19:3f82c1161fd2	491	{
WiredHome	19:3f82c1161fd2	492	unsigned long elapsed = performance.read_us();
WiredHome	73:f22a18707b5e	493
WiredHome	19:3f82c1161fd2	494	if (method < METRICCOUNT && elapsed > metrics[method])
WiredHome	19:3f82c1161fd2	495	metrics[method] = elapsed;
WiredHome	19:3f82c1161fd2	496	}
WiredHome	19:3f82c1161fd2	497
WiredHome	79:544eb4964795	498
WiredHome	66:468a11f05580	499	void RA8875::CountIdleTime(uint32_t t)
WiredHome	66:468a11f05580	500	{
WiredHome	75:ca78388cfd77	501	idletime_usec += t;
WiredHome	66:468a11f05580	502	}
WiredHome	44:207594dece70	503
WiredHome	79:544eb4964795	504
WiredHome	41:2956a0a221e5	505	void RA8875::ReportPerformance(Serial & pc)
WiredHome	19:3f82c1161fd2	506	{
WiredHome	100:0b084475d5a9	507	int i;
WiredHome	100:0b084475d5a9	508
WiredHome	41:2956a0a221e5	509	pc.printf("\r\nPerformance Metrics\r\n");
WiredHome	100:0b084475d5a9	510	for (i=0; i<METRICCOUNT; i++) {
WiredHome	41:2956a0a221e5	511	pc.printf("%10d uS %s\r\n", metrics[i], metricsName[i]);
WiredHome	66:468a11f05580	512	}
WiredHome	75:ca78388cfd77	513	pc.printf("%10d uS Idle time polling display for ready.\r\n", idletime_usec);
WiredHome	91:ca5f829e6d27	514	for (i=0; i<256; i++) {
WiredHome	91:ca5f829e6d27	515	if (commandsUsed[i])
WiredHome	100:0b084475d5a9	516	pc.printf("Command %02X used %5d times.\r\n", i, commandsUsed[i]);
WiredHome	91:ca5f829e6d27	517	}
WiredHome	19:3f82c1161fd2	518	}
WiredHome	19:3f82c1161fd2	519	#endif
WiredHome	19:3f82c1161fd2	520
WiredHome	44:207594dece70	521
WiredHome	82:f7d300f26540	522	bool RA8875::Intersect(rect_t rect, point_t p)
WiredHome	82:f7d300f26540	523	{
WiredHome	82:f7d300f26540	524	if (p.x >= min(rect.p1.x, rect.p2.x) && p.x <= max(rect.p1.x, rect.p2.x)
WiredHome	82:f7d300f26540	525	&& p.y >= min(rect.p1.y, rect.p2.y) && p.y <= max(rect.p1.y, rect.p2.y))
WiredHome	82:f7d300f26540	526	return true;
WiredHome	82:f7d300f26540	527	else
WiredHome	82:f7d300f26540	528	return false;
WiredHome	82:f7d300f26540	529	}
WiredHome	82:f7d300f26540	530
WiredHome	82:f7d300f26540	531
WiredHome	131:5bd6ba2ee4a1	532	bool RA8875::Intersect(rect_t rect1, rect_t rect2)
WiredHome	131:5bd6ba2ee4a1	533	{
WiredHome	147:3494792458d9	534	#if 1
WiredHome	147:3494792458d9	535	// If one rectangle is on left side of other
WiredHome	147:3494792458d9	536	if (max(rect1.p1.x,rect1.p2.x) < min(rect2.p1.x,rect2.p2.x)
WiredHome	147:3494792458d9	537	\|\| min(rect1.p1.x, rect1.p2.x) > max(rect2.p1.x, rect2.p2.x))
WiredHome	147:3494792458d9	538	return false;
WiredHome	147:3494792458d9	539	// If one rectangle is above other
WiredHome	147:3494792458d9	540	if (max(rect1.p1.y, rect1.p2.y) < min(rect2.p1.y, rect2.p2.y)
WiredHome	147:3494792458d9	541	\|\| min(rect1.p1.y, rect1.p2.y) > max(rect2.p1.y, rect2.p2.y))
WiredHome	147:3494792458d9	542	return false;
WiredHome	147:3494792458d9	543	return true; // all that's left is they overlap
WiredHome	147:3494792458d9	544	#else
WiredHome	131:5bd6ba2ee4a1	545	point_t bl, tr;
WiredHome	131:5bd6ba2ee4a1	546	bl.x = rect2.p1.x;
WiredHome	131:5bd6ba2ee4a1	547	bl.y = rect2.p2.y;
WiredHome	131:5bd6ba2ee4a1	548	tr.x = rect2.p2.x;
WiredHome	131:5bd6ba2ee4a1	549	tr.y = rect2.p1.y;
WiredHome	131:5bd6ba2ee4a1	550	if (Intersect(rect1, rect2.p1) \|\| Intersect(rect1, rect2.p2)
WiredHome	147:3494792458d9	551	\|\| Intersect(rect1, bl) \|\| Intersect(rect1, tr))
WiredHome	131:5bd6ba2ee4a1	552	return true;
WiredHome	131:5bd6ba2ee4a1	553	else
WiredHome	131:5bd6ba2ee4a1	554	return false;
WiredHome	147:3494792458d9	555	#endif
WiredHome	131:5bd6ba2ee4a1	556	}
WiredHome	131:5bd6ba2ee4a1	557
WiredHome	131:5bd6ba2ee4a1	558
WiredHome	147:3494792458d9	559	bool RA8875::Intersect(rect_t * pRect1, const rect_t * pRect2)
WiredHome	147:3494792458d9	560	{
WiredHome	147:3494792458d9	561	if (Intersect(pRect1, pRect2)) {
WiredHome	147:3494792458d9	562	rect_t iSect;
WiredHome	147:3494792458d9	563
WiredHome	148:33e99de1aca6	564	iSect.p1.x = max(min(pRect1->p1.x,pRect1->p2.x),min(pRect2->p1.x,pRect2->p2.x));
WiredHome	148:33e99de1aca6	565	iSect.p1.y = max(min(pRect1->p1.y,pRect1->p2.y),min(pRect2->p1.y,pRect2->p2.y));
WiredHome	148:33e99de1aca6	566	iSect.p2.x = min(max(pRect1->p1.x,pRect1->p2.x),max(pRect2->p1.x,pRect2->p2.x));
WiredHome	148:33e99de1aca6	567	iSect.p2.y = min(max(pRect1->p1.y,pRect1->p2.y),max(pRect2->p1.y,pRect2->p2.y));
WiredHome	147:3494792458d9	568	*pRect1 = iSect;
WiredHome	147:3494792458d9	569	return true;
WiredHome	147:3494792458d9	570	} else {
WiredHome	147:3494792458d9	571	return false;
WiredHome	147:3494792458d9	572	}
WiredHome	147:3494792458d9	573	}
WiredHome	147:3494792458d9	574
WiredHome	82:f7d300f26540	575
WiredHome	38:38d503b4fad6	576	RetCode_t RA8875::WriteCommandW(uint8_t command, uint16_t data)
WiredHome	38:38d503b4fad6	577	{
WiredHome	38:38d503b4fad6	578	WriteCommand(command, data & 0xFF);
WiredHome	38:38d503b4fad6	579	WriteCommand(command+1, data >> 8);
WiredHome	38:38d503b4fad6	580	return noerror;
WiredHome	38:38d503b4fad6	581	}
WiredHome	38:38d503b4fad6	582
WiredHome	44:207594dece70	583
WiredHome	19:3f82c1161fd2	584	RetCode_t RA8875::WriteCommand(unsigned char command, unsigned int data)
WiredHome	19:3f82c1161fd2	585	{
WiredHome	91:ca5f829e6d27	586	#ifdef PERF_METRICS
WiredHome	92:ce1ab76e8614	587	if (commandsUsed[command] < 65535)
WiredHome	91:ca5f829e6d27	588	commandsUsed[command]++;
WiredHome	91:ca5f829e6d27	589	#endif
WiredHome	79:544eb4964795	590	_select(true);
WiredHome	83:7bad0068cca0	591	_spiwrite(0x80); // RS:1 (Cmd/Status), RW:0 (Write)
WiredHome	79:544eb4964795	592	_spiwrite(command);
WiredHome	19:3f82c1161fd2	593	if (data <= 0xFF) { // only if in the valid range
WiredHome	79:544eb4964795	594	_spiwrite(0x00);
WiredHome	79:544eb4964795	595	_spiwrite(data);
WiredHome	19:3f82c1161fd2	596	}
WiredHome	79:544eb4964795	597	_select(false);
WiredHome	19:3f82c1161fd2	598	return noerror;
WiredHome	19:3f82c1161fd2	599	}
WiredHome	19:3f82c1161fd2	600
WiredHome	44:207594dece70	601
WiredHome	38:38d503b4fad6	602	RetCode_t RA8875::WriteDataW(uint16_t data)
WiredHome	38:38d503b4fad6	603	{
WiredHome	79:544eb4964795	604	_select(true);
WiredHome	83:7bad0068cca0	605	_spiwrite(0x00); // RS:0 (Data), RW:0 (Write)
WiredHome	79:544eb4964795	606	_spiwrite(data & 0xFF);
WiredHome	79:544eb4964795	607	_spiwrite(data >> 8);
WiredHome	79:544eb4964795	608	_select(false);
WiredHome	38:38d503b4fad6	609	return noerror;
WiredHome	38:38d503b4fad6	610	}
WiredHome	38:38d503b4fad6	611
WiredHome	44:207594dece70	612
WiredHome	19:3f82c1161fd2	613	RetCode_t RA8875::WriteData(unsigned char data)
WiredHome	19:3f82c1161fd2	614	{
WiredHome	79:544eb4964795	615	_select(true);
WiredHome	83:7bad0068cca0	616	_spiwrite(0x00); // RS:0 (Data), RW:0 (Write)
WiredHome	79:544eb4964795	617	_spiwrite(data);
WiredHome	79:544eb4964795	618	_select(false);
WiredHome	19:3f82c1161fd2	619	return noerror;
WiredHome	19:3f82c1161fd2	620	}
WiredHome	19:3f82c1161fd2	621
WiredHome	44:207594dece70	622
WiredHome	19:3f82c1161fd2	623	unsigned char RA8875::ReadCommand(unsigned char command)
WiredHome	19:3f82c1161fd2	624	{
WiredHome	19:3f82c1161fd2	625	WriteCommand(command);
WiredHome	19:3f82c1161fd2	626	return ReadData();
WiredHome	19:3f82c1161fd2	627	}
WiredHome	19:3f82c1161fd2	628
WiredHome	136:224e03d5c31f	629	uint16_t RA8875::ReadCommandW(unsigned char command)
WiredHome	136:224e03d5c31f	630	{
WiredHome	136:224e03d5c31f	631	WriteCommand(command);
WiredHome	136:224e03d5c31f	632	return ReadDataW();
WiredHome	136:224e03d5c31f	633	}
WiredHome	44:207594dece70	634
WiredHome	19:3f82c1161fd2	635	unsigned char RA8875::ReadData(void)
WiredHome	19:3f82c1161fd2	636	{
WiredHome	19:3f82c1161fd2	637	unsigned char data;
WiredHome	73:f22a18707b5e	638
WiredHome	79:544eb4964795	639	_select(true);
WiredHome	83:7bad0068cca0	640	_spiwrite(0x40); // RS:0 (Data), RW:1 (Read)
WiredHome	79:544eb4964795	641	data = _spiread();
WiredHome	79:544eb4964795	642	_select(false);
WiredHome	19:3f82c1161fd2	643	return data;
WiredHome	19:3f82c1161fd2	644	}
WiredHome	19:3f82c1161fd2	645
WiredHome	44:207594dece70	646
WiredHome	41:2956a0a221e5	647	uint16_t RA8875::ReadDataW(void)
WiredHome	41:2956a0a221e5	648	{
WiredHome	41:2956a0a221e5	649	uint16_t data;
WiredHome	73:f22a18707b5e	650
WiredHome	79:544eb4964795	651	_select(true);
WiredHome	83:7bad0068cca0	652	_spiwrite(0x40); // RS:0 (Data), RW:1 (Read)
WiredHome	79:544eb4964795	653	data = _spiread();
WiredHome	79:544eb4964795	654	data \|= (_spiread() << 8);
WiredHome	79:544eb4964795	655	_select(false);
WiredHome	41:2956a0a221e5	656	return data;
WiredHome	41:2956a0a221e5	657	}
WiredHome	41:2956a0a221e5	658
WiredHome	44:207594dece70	659
WiredHome	19:3f82c1161fd2	660	unsigned char RA8875::ReadStatus(void)
WiredHome	19:3f82c1161fd2	661	{
WiredHome	19:3f82c1161fd2	662	unsigned char data;
WiredHome	73:f22a18707b5e	663
WiredHome	79:544eb4964795	664	_select(true);
WiredHome	83:7bad0068cca0	665	_spiwrite(0xC0); // RS:1 (Cmd/Status), RW:1 (Read) (Read STSR)
WiredHome	79:544eb4964795	666	data = _spiread();
WiredHome	79:544eb4964795	667	_select(false);
WiredHome	19:3f82c1161fd2	668	return data;
WiredHome	19:3f82c1161fd2	669	}
WiredHome	19:3f82c1161fd2	670
WiredHome	79:544eb4964795	671
WiredHome	66:468a11f05580	672	/// @todo add a timeout and return false, but how long
WiredHome	66:468a11f05580	673	/// to wait since some operations can be very long.
WiredHome	66:468a11f05580	674	bool RA8875::_WaitWhileBusy(uint8_t mask)
WiredHome	66:468a11f05580	675	{
WiredHome	66:468a11f05580	676	int i = 20000/POLLWAITuSec; // 20 msec max
WiredHome	66:468a11f05580	677
WiredHome	67:9f834f0ff97d	678	while (i-- && ReadStatus() & mask) {
WiredHome	66:468a11f05580	679	wait_us(POLLWAITuSec);
WiredHome	68:ab08efabfc88	680	COUNTIDLETIME(POLLWAITuSec);
WiredHome	123:2f45e80fec5f	681	if (idle_callback) {
WiredHome	149:c62c4b2d6a15	682	if (external_abort == (*idle_callback)(status_wait, 0)) {
WiredHome	123:2f45e80fec5f	683	return false;
WiredHome	123:2f45e80fec5f	684	}
WiredHome	123:2f45e80fec5f	685	}
WiredHome	67:9f834f0ff97d	686	}
WiredHome	66:468a11f05580	687	if (i)
WiredHome	66:468a11f05580	688	return true;
WiredHome	66:468a11f05580	689	else
WiredHome	66:468a11f05580	690	return false;
WiredHome	66:468a11f05580	691	}
WiredHome	66:468a11f05580	692
WiredHome	79:544eb4964795	693
WiredHome	66:468a11f05580	694	/// @todo add a timeout and return false, but how long
WiredHome	66:468a11f05580	695	/// to wait since some operations can be very long.
WiredHome	66:468a11f05580	696	bool RA8875::_WaitWhileReg(uint8_t reg, uint8_t mask)
WiredHome	66:468a11f05580	697	{
WiredHome	66:468a11f05580	698	int i = 20000/POLLWAITuSec; // 20 msec max
WiredHome	66:468a11f05580	699
WiredHome	67:9f834f0ff97d	700	while (i-- && ReadCommand(reg) & mask) {
WiredHome	66:468a11f05580	701	wait_us(POLLWAITuSec);
WiredHome	68:ab08efabfc88	702	COUNTIDLETIME(POLLWAITuSec);
WiredHome	123:2f45e80fec5f	703	if (idle_callback) {
WiredHome	149:c62c4b2d6a15	704	if (external_abort == (*idle_callback)(command_wait, 0)) {
WiredHome	123:2f45e80fec5f	705	return false;
WiredHome	123:2f45e80fec5f	706	}
WiredHome	123:2f45e80fec5f	707	}
WiredHome	67:9f834f0ff97d	708	}
WiredHome	66:468a11f05580	709	if (i)
WiredHome	66:468a11f05580	710	return true;
WiredHome	66:468a11f05580	711	else
WiredHome	66:468a11f05580	712	return false;
WiredHome	66:468a11f05580	713	}
WiredHome	66:468a11f05580	714
WiredHome	106:c80828f5dea4	715	// RRRR RGGG GGGB BBBB
WiredHome	106:c80828f5dea4	716	// 4321 0543 2104 3210
WiredHome	106:c80828f5dea4	717	// RRRG GGBB
WiredHome	106:c80828f5dea4	718	// 2102 1010
WiredHome	105:4f116006ba1f	719	uint8_t RA8875::_cvt16to8(color_t c16)
WiredHome	105:4f116006ba1f	720	{
WiredHome	105:4f116006ba1f	721	return ((c16 >> 8) & 0xE0)
WiredHome	105:4f116006ba1f	722	\| ((c16 >> 6) & 0x1C)
WiredHome	105:4f116006ba1f	723	\| ((c16 >> 3) & 0x03);
WiredHome	105:4f116006ba1f	724	}
WiredHome	105:4f116006ba1f	725
WiredHome	106:c80828f5dea4	726	// RRRG GGBB
WiredHome	106:c80828f5dea4	727	// 2102 1010
WiredHome	106:c80828f5dea4	728	// RRRR RGGG GGGB BBBB
WiredHome	106:c80828f5dea4	729	// 2101 0543 2104 3210
WiredHome	105:4f116006ba1f	730	color_t RA8875::_cvt8to16(uint8_t c8)
WiredHome	105:4f116006ba1f	731	{
WiredHome	106:c80828f5dea4	732	color_t c16;
WiredHome	106:c80828f5dea4	733	color_t temp = (color_t)c8;
WiredHome	106:c80828f5dea4	734
WiredHome	106:c80828f5dea4	735	c16 = ((temp & 0xE0) << 8)
WiredHome	106:c80828f5dea4	736	\| ((temp & 0xC0) << 5)
WiredHome	106:c80828f5dea4	737	\| ((temp & 0x1C) << 6)
WiredHome	106:c80828f5dea4	738	\| ((temp & 0x1C) << 3)
WiredHome	106:c80828f5dea4	739	\| ((temp & 0x03) << 3)
WiredHome	106:c80828f5dea4	740	\| ((temp & 0x03) << 1)
WiredHome	106:c80828f5dea4	741	\| ((temp & 0x03) >> 1);
WiredHome	106:c80828f5dea4	742	c16 = (c16 << 8) \| (c16 >> 8);
WiredHome	105:4f116006ba1f	743	return c16;
WiredHome	105:4f116006ba1f	744	}
WiredHome	66:468a11f05580	745
WiredHome	133:e36dcfc2d756	746	RetCode_t RA8875::_writeColorTrio(uint8_t regAddr, color_t color)
WiredHome	133:e36dcfc2d756	747	{
WiredHome	133:e36dcfc2d756	748	RetCode_t rt = noerror;
WiredHome	133:e36dcfc2d756	749
WiredHome	133:e36dcfc2d756	750	if (screenbpp == 16) {
WiredHome	133:e36dcfc2d756	751	WriteCommand(regAddr+0, (color>>11)); // BGCR0
WiredHome	133:e36dcfc2d756	752	WriteCommand(regAddr+1, (unsigned char)(color>>5)); // BGCR1
WiredHome	133:e36dcfc2d756	753	rt = WriteCommand(regAddr+2, (unsigned char)(color)); // BGCR2
WiredHome	133:e36dcfc2d756	754	} else {
WiredHome	133:e36dcfc2d756	755	uint8_t r, g, b;
WiredHome	133:e36dcfc2d756	756
WiredHome	133:e36dcfc2d756	757	// RRRR RGGG GGGB BBBB RGB
WiredHome	133:e36dcfc2d756	758	// RRR GGG B B
WiredHome	133:e36dcfc2d756	759	r = (uint8_t)((color) >> 13);
WiredHome	133:e36dcfc2d756	760	g = (uint8_t)((color) >> 8);
WiredHome	133:e36dcfc2d756	761	b = (uint8_t)((color) >> 3);
WiredHome	133:e36dcfc2d756	762	WriteCommand(regAddr+0, r); // BGCR0
WiredHome	133:e36dcfc2d756	763	WriteCommand(regAddr+1, g); // BGCR1
WiredHome	133:e36dcfc2d756	764	rt = WriteCommand(regAddr+2, b); // BGCR2
WiredHome	133:e36dcfc2d756	765	}
WiredHome	133:e36dcfc2d756	766	return rt;
WiredHome	133:e36dcfc2d756	767	}
WiredHome	133:e36dcfc2d756	768
WiredHome	133:e36dcfc2d756	769	color_t RA8875::_readColorTrio(uint8_t regAddr)
WiredHome	133:e36dcfc2d756	770	{
WiredHome	133:e36dcfc2d756	771	color_t color;
WiredHome	133:e36dcfc2d756	772	uint8_t r, g, b;
WiredHome	133:e36dcfc2d756	773
WiredHome	133:e36dcfc2d756	774	r = ReadCommand(regAddr+0);
WiredHome	133:e36dcfc2d756	775	g = ReadCommand(regAddr+1);
WiredHome	133:e36dcfc2d756	776	b = ReadCommand(regAddr+2);
WiredHome	133:e36dcfc2d756	777	if (screenbpp == 16) {
WiredHome	133:e36dcfc2d756	778	// 000R RRRR 00GG GGGG 000B BBBB
WiredHome	133:e36dcfc2d756	779	// RRRR RGGG GGGB BBBB
WiredHome	133:e36dcfc2d756	780	color = (r & 0x1F) << 11;
WiredHome	133:e36dcfc2d756	781	color \|= (g & 0x3F) << 5;
WiredHome	133:e36dcfc2d756	782	color \|= (b & 0x1F);
WiredHome	133:e36dcfc2d756	783	} else {
WiredHome	133:e36dcfc2d756	784	// RRRG GGBB
WiredHome	133:e36dcfc2d756	785	// RRRR RGGG GGGB BBBB
WiredHome	133:e36dcfc2d756	786	color = (r & 0x07) << 13;
WiredHome	133:e36dcfc2d756	787	color \|= (g & 0x07) << 8;
WiredHome	133:e36dcfc2d756	788	color \|= (b & 0x03) << 3;
WiredHome	133:e36dcfc2d756	789	}
WiredHome	133:e36dcfc2d756	790	return color;
WiredHome	133:e36dcfc2d756	791	}
WiredHome	133:e36dcfc2d756	792
WiredHome	133:e36dcfc2d756	793
WiredHome	37:f19b7e7449dc	794	dim_t RA8875::fontwidth(void)
WiredHome	19:3f82c1161fd2	795	{
WiredHome	19:3f82c1161fd2	796	if (font == NULL)
WiredHome	55:dfbabef7003e	797	return (((ReadCommand(0x22) >> 2) & 0x3) + 1) * 8;
WiredHome	19:3f82c1161fd2	798	else
WiredHome	98:ecebed9b80b2	799	return extFontWidth;
WiredHome	19:3f82c1161fd2	800	}
WiredHome	19:3f82c1161fd2	801
WiredHome	44:207594dece70	802
WiredHome	37:f19b7e7449dc	803	dim_t RA8875::fontheight(void)
WiredHome	19:3f82c1161fd2	804	{
WiredHome	19:3f82c1161fd2	805	if (font == NULL)
WiredHome	23:a50ded45dbaf	806	return (((ReadCommand(0x22) >> 0) & 0x3) + 1) * 16;
WiredHome	19:3f82c1161fd2	807	else
WiredHome	98:ecebed9b80b2	808	return extFontHeight;
WiredHome	19:3f82c1161fd2	809	}
WiredHome	19:3f82c1161fd2	810
WiredHome	44:207594dece70	811
WiredHome	37:f19b7e7449dc	812	RetCode_t RA8875::locate(textloc_t column, textloc_t row)
WiredHome	19:3f82c1161fd2	813	{
WiredHome	32:0e4f2ae512e2	814	return SetTextCursor(column * fontwidth(), row * fontheight());
WiredHome	19:3f82c1161fd2	815	}
WiredHome	19:3f82c1161fd2	816
WiredHome	44:207594dece70	817
WiredHome	19:3f82c1161fd2	818	int RA8875::columns(void)
WiredHome	19:3f82c1161fd2	819	{
WiredHome	105:4f116006ba1f	820	return screenwidth / fontwidth();
WiredHome	19:3f82c1161fd2	821	}
WiredHome	19:3f82c1161fd2	822
WiredHome	44:207594dece70	823
WiredHome	19:3f82c1161fd2	824	int RA8875::rows(void)
WiredHome	19:3f82c1161fd2	825	{
WiredHome	105:4f116006ba1f	826	return screenheight / fontheight();
WiredHome	19:3f82c1161fd2	827	}
WiredHome	19:3f82c1161fd2	828
WiredHome	44:207594dece70	829
WiredHome	38:38d503b4fad6	830	dim_t RA8875::width(void)
WiredHome	19:3f82c1161fd2	831	{
WiredHome	90:d113d71ae4f0	832	if (portraitmode)
WiredHome	90:d113d71ae4f0	833	return screenheight;
WiredHome	90:d113d71ae4f0	834	else
WiredHome	90:d113d71ae4f0	835	return screenwidth;
WiredHome	19:3f82c1161fd2	836	}
WiredHome	19:3f82c1161fd2	837
WiredHome	44:207594dece70	838
WiredHome	38:38d503b4fad6	839	dim_t RA8875::height(void)
WiredHome	19:3f82c1161fd2	840	{
WiredHome	90:d113d71ae4f0	841	if (portraitmode)
WiredHome	90:d113d71ae4f0	842	return screenwidth;
WiredHome	90:d113d71ae4f0	843	else
WiredHome	90:d113d71ae4f0	844	return screenheight;
WiredHome	19:3f82c1161fd2	845	}
WiredHome	19:3f82c1161fd2	846
WiredHome	44:207594dece70	847
WiredHome	43:3becae133285	848	dim_t RA8875::color_bpp(void)
WiredHome	43:3becae133285	849	{
WiredHome	105:4f116006ba1f	850	return screenbpp;
WiredHome	43:3becae133285	851	}
WiredHome	43:3becae133285	852
WiredHome	103:7e0464ca6c5c	853	RetCode_t RA8875::SetTextCursor(point_t p)
WiredHome	103:7e0464ca6c5c	854	{
WiredHome	103:7e0464ca6c5c	855	return SetTextCursor(p.x, p.y);
WiredHome	103:7e0464ca6c5c	856	}
WiredHome	44:207594dece70	857
WiredHome	37:f19b7e7449dc	858	RetCode_t RA8875::SetTextCursor(loc_t x, loc_t y)
WiredHome	19:3f82c1161fd2	859	{
WiredHome	98:ecebed9b80b2	860	INFO("SetTextCursor(%d, %d)", x, y);
WiredHome	75:ca78388cfd77	861	cursor_x = x; // set these values for non-internal fonts
WiredHome	75:ca78388cfd77	862	cursor_y = y;
WiredHome	38:38d503b4fad6	863	WriteCommandW(0x2A, x);
WiredHome	38:38d503b4fad6	864	WriteCommandW(0x2C, y);
WiredHome	19:3f82c1161fd2	865	return noerror;
WiredHome	19:3f82c1161fd2	866	}
WiredHome	19:3f82c1161fd2	867
WiredHome	103:7e0464ca6c5c	868	point_t RA8875::GetTextCursor(void)
WiredHome	103:7e0464ca6c5c	869	{
WiredHome	103:7e0464ca6c5c	870	point_t p;
WiredHome	103:7e0464ca6c5c	871
WiredHome	103:7e0464ca6c5c	872	p.x = GetTextCursor_X();
WiredHome	103:7e0464ca6c5c	873	p.y = GetTextCursor_Y();
WiredHome	103:7e0464ca6c5c	874	return p;
WiredHome	103:7e0464ca6c5c	875	}
WiredHome	44:207594dece70	876
WiredHome	37:f19b7e7449dc	877	loc_t RA8875::GetTextCursor_Y(void)
WiredHome	29:422616aa04bd	878	{
WiredHome	98:ecebed9b80b2	879	loc_t y;
WiredHome	98:ecebed9b80b2	880
WiredHome	29:422616aa04bd	881	if (font == NULL)
WiredHome	98:ecebed9b80b2	882	y = ReadCommand(0x2C) \| (ReadCommand(0x2D) << 8);
WiredHome	29:422616aa04bd	883	else
WiredHome	98:ecebed9b80b2	884	y = cursor_y;
WiredHome	98:ecebed9b80b2	885	INFO("GetTextCursor_Y = %d", y);
WiredHome	98:ecebed9b80b2	886	return y;
WiredHome	29:422616aa04bd	887	}
WiredHome	29:422616aa04bd	888
WiredHome	44:207594dece70	889
WiredHome	37:f19b7e7449dc	890	loc_t RA8875::GetTextCursor_X(void)
WiredHome	29:422616aa04bd	891	{
WiredHome	98:ecebed9b80b2	892	loc_t x;
WiredHome	98:ecebed9b80b2	893
WiredHome	29:422616aa04bd	894	if (font == NULL)
WiredHome	98:ecebed9b80b2	895	x = ReadCommand(0x2A) \| (ReadCommand(0x2B) << 8);
WiredHome	29:422616aa04bd	896	else
WiredHome	98:ecebed9b80b2	897	x = cursor_x;
WiredHome	98:ecebed9b80b2	898	INFO("GetTextCursor_X = %d", x);
WiredHome	98:ecebed9b80b2	899	return x;
WiredHome	29:422616aa04bd	900	}
WiredHome	29:422616aa04bd	901
WiredHome	44:207594dece70	902
WiredHome	24:8ca861acf12d	903	RetCode_t RA8875::SetTextCursorControl(cursor_t cursor, bool blink)
WiredHome	23:a50ded45dbaf	904	{
WiredHome	23:a50ded45dbaf	905	unsigned char mwcr0 = ReadCommand(0x40) & 0x0F; // retain direction, auto-increase
WiredHome	43:3becae133285	906	unsigned char mwcr1 = ReadCommand(0x41) & 0x01; // retain currently selected layer
WiredHome	24:8ca861acf12d	907	unsigned char horz = 0;
WiredHome	24:8ca861acf12d	908	unsigned char vert = 0;
WiredHome	73:f22a18707b5e	909
WiredHome	24:8ca861acf12d	910	mwcr0 \|= 0x80; // text mode
WiredHome	24:8ca861acf12d	911	if (cursor != NOCURSOR)
WiredHome	24:8ca861acf12d	912	mwcr0 \|= 0x40; // visible
WiredHome	23:a50ded45dbaf	913	if (blink)
WiredHome	24:8ca861acf12d	914	mwcr0 \|= 0x20; // blink
WiredHome	23:a50ded45dbaf	915	WriteCommand(0x40, mwcr0); // configure the cursor
WiredHome	43:3becae133285	916	WriteCommand(0x41, mwcr1); // close the graphics cursor
WiredHome	24:8ca861acf12d	917	WriteCommand(0x44, 0x1f); // The cursor flashing cycle
WiredHome	24:8ca861acf12d	918	switch (cursor) {
WiredHome	24:8ca861acf12d	919	case IBEAM:
WiredHome	24:8ca861acf12d	920	horz = 0x01;
WiredHome	24:8ca861acf12d	921	vert = 0x1F;
WiredHome	24:8ca861acf12d	922	break;
WiredHome	24:8ca861acf12d	923	case UNDER:
WiredHome	24:8ca861acf12d	924	horz = 0x07;
WiredHome	24:8ca861acf12d	925	vert = 0x01;
WiredHome	24:8ca861acf12d	926	break;
WiredHome	24:8ca861acf12d	927	case BLOCK:
WiredHome	24:8ca861acf12d	928	horz = 0x07;
WiredHome	24:8ca861acf12d	929	vert = 0x1F;
WiredHome	24:8ca861acf12d	930	break;
WiredHome	24:8ca861acf12d	931	case NOCURSOR:
WiredHome	24:8ca861acf12d	932	default:
WiredHome	24:8ca861acf12d	933	break;
WiredHome	24:8ca861acf12d	934	}
WiredHome	24:8ca861acf12d	935	WriteCommand(0x4e, horz); // The cursor size horz
WiredHome	24:8ca861acf12d	936	WriteCommand(0x4f, vert); // The cursor size vert
WiredHome	23:a50ded45dbaf	937	return noerror;
WiredHome	23:a50ded45dbaf	938	}
WiredHome	23:a50ded45dbaf	939
WiredHome	44:207594dece70	940
WiredHome	19:3f82c1161fd2	941	RetCode_t RA8875::SetTextFont(RA8875::font_t font)
WiredHome	19:3f82c1161fd2	942	{
WiredHome	19:3f82c1161fd2	943	if (/font >= RA8875::ISO8859_1 && / font <= RA8875::ISO8859_4) {
WiredHome	19:3f82c1161fd2	944	WriteCommand(0x21, (unsigned int)(font));
WiredHome	19:3f82c1161fd2	945	return noerror;
WiredHome	19:3f82c1161fd2	946	} else {
WiredHome	19:3f82c1161fd2	947	return bad_parameter;
WiredHome	19:3f82c1161fd2	948	}
WiredHome	19:3f82c1161fd2	949	}
WiredHome	19:3f82c1161fd2	950
WiredHome	44:207594dece70	951
WiredHome	84:e102021864b5	952	RetCode_t RA8875::SetOrientation(RA8875::orientation_t angle)
WiredHome	84:e102021864b5	953	{
WiredHome	84:e102021864b5	954	uint8_t fncr1Val = ReadCommand(0x22);
WiredHome	84:e102021864b5	955	uint8_t dpcrVal = ReadCommand(0x20);
WiredHome	84:e102021864b5	956
WiredHome	84:e102021864b5	957	fncr1Val &= ~0x10; // remove the old direction bit
WiredHome	84:e102021864b5	958	dpcrVal &= ~0x0C; // remove the old scan direction bits
WiredHome	84:e102021864b5	959	switch (angle) {
WiredHome	84:e102021864b5	960	case RA8875::normal:
WiredHome	84:e102021864b5	961	//fncr1Val \|= 0x10;
WiredHome	84:e102021864b5	962	//dpcrVal \|= 0x00;
WiredHome	90:d113d71ae4f0	963	portraitmode = false;
WiredHome	84:e102021864b5	964	break;
WiredHome	84:e102021864b5	965	case RA8875::rotate_90:
WiredHome	84:e102021864b5	966	fncr1Val \|= 0x10;
WiredHome	84:e102021864b5	967	dpcrVal \|= 0x08;
WiredHome	90:d113d71ae4f0	968	portraitmode = true;
WiredHome	84:e102021864b5	969	break;
WiredHome	84:e102021864b5	970	case RA8875::rotate_180:
WiredHome	84:e102021864b5	971	//fncr1Val \|= 0x00;
WiredHome	84:e102021864b5	972	dpcrVal \|= 0x0C;
WiredHome	90:d113d71ae4f0	973	portraitmode = false;
WiredHome	84:e102021864b5	974	break;
WiredHome	84:e102021864b5	975	case RA8875::rotate_270:
WiredHome	84:e102021864b5	976	fncr1Val \|= 0x10;
WiredHome	84:e102021864b5	977	dpcrVal \|= 0x04;
WiredHome	90:d113d71ae4f0	978	portraitmode = true;
WiredHome	84:e102021864b5	979	break;
WiredHome	84:e102021864b5	980	default:
WiredHome	84:e102021864b5	981	return bad_parameter;
WiredHome	84:e102021864b5	982	}
WiredHome	100:0b084475d5a9	983	INFO("Orientation: %d, %d", angle, portraitmode);
WiredHome	84:e102021864b5	984	WriteCommand(0x22, fncr1Val);
WiredHome	84:e102021864b5	985	return WriteCommand(0x20, dpcrVal);
WiredHome	84:e102021864b5	986	}
WiredHome	84:e102021864b5	987
WiredHome	84:e102021864b5	988
WiredHome	19:3f82c1161fd2	989	RetCode_t RA8875::SetTextFontControl(fill_t fillit,
WiredHome	73:f22a18707b5e	990	RA8875::HorizontalScale hScale,
WiredHome	73:f22a18707b5e	991	RA8875::VerticalScale vScale,
WiredHome	73:f22a18707b5e	992	RA8875::alignment_t alignment)
WiredHome	19:3f82c1161fd2	993	{
WiredHome	73:f22a18707b5e	994	if (hScale >= 1 && hScale <= 4 &&
WiredHome	73:f22a18707b5e	995	vScale >= 1 && vScale <= 4) {
WiredHome	84:e102021864b5	996	uint8_t fncr1Val = ReadCommand(0x22);
WiredHome	84:e102021864b5	997
WiredHome	98:ecebed9b80b2	998	fncr1Val &= ~0x10; // do not disturb the rotate flag
WiredHome	19:3f82c1161fd2	999	if (alignment == align_full)
WiredHome	84:e102021864b5	1000	fncr1Val \|= 0x80;
WiredHome	19:3f82c1161fd2	1001	if (fillit == NOFILL)
WiredHome	84:e102021864b5	1002	fncr1Val \|= 0x40;
WiredHome	84:e102021864b5	1003	fncr1Val \|= ((hScale - 1) << 2);
WiredHome	84:e102021864b5	1004	fncr1Val \|= ((vScale - 1) << 0);
WiredHome	84:e102021864b5	1005	return WriteCommand(0x22, fncr1Val);
WiredHome	19:3f82c1161fd2	1006	} else {
WiredHome	19:3f82c1161fd2	1007	return bad_parameter;
WiredHome	19:3f82c1161fd2	1008	}
WiredHome	19:3f82c1161fd2	1009	}
WiredHome	19:3f82c1161fd2	1010
WiredHome	44:207594dece70	1011
WiredHome	19:3f82c1161fd2	1012	RetCode_t RA8875::SetTextFontSize(RA8875::HorizontalScale hScale, RA8875::VerticalScale vScale)
WiredHome	19:3f82c1161fd2	1013	{
WiredHome	19:3f82c1161fd2	1014	unsigned char reg = ReadCommand(0x22);
WiredHome	73:f22a18707b5e	1015
WiredHome	40:04aa280dfa39	1016	if (vScale == -1)
WiredHome	40:04aa280dfa39	1017	vScale = hScale;
WiredHome	19:3f82c1161fd2	1018	if (hScale >= 1 && hScale <= 4 && vScale >= 1 && vScale <= 4) {
WiredHome	153:8a85efb3eb71	1019	fontScaleX = hScale; // save for use with a Soft Font
WiredHome	153:8a85efb3eb71	1020	fontScaleY = vScale;
WiredHome	19:3f82c1161fd2	1021	reg &= 0xF0; // keep the high nibble as is.
WiredHome	19:3f82c1161fd2	1022	reg \|= ((hScale - 1) << 2);
WiredHome	19:3f82c1161fd2	1023	reg \|= ((vScale - 1) << 0);
WiredHome	19:3f82c1161fd2	1024	WriteCommand(0x22, reg);
WiredHome	19:3f82c1161fd2	1025	return noerror;
WiredHome	19:3f82c1161fd2	1026	} else {
WiredHome	19:3f82c1161fd2	1027	return bad_parameter;
WiredHome	19:3f82c1161fd2	1028	}
WiredHome	19:3f82c1161fd2	1029	}
WiredHome	19:3f82c1161fd2	1030
WiredHome	127:db7f2c704693	1031	RetCode_t RA8875::GetTextFontSize(RA8875::HorizontalScale * hScale, RA8875::VerticalScale * vScale)
WiredHome	127:db7f2c704693	1032	{
WiredHome	127:db7f2c704693	1033	unsigned char reg = ReadCommand(0x22);
WiredHome	127:db7f2c704693	1034
WiredHome	127:db7f2c704693	1035	if (hScale)
WiredHome	127:db7f2c704693	1036	*hScale = 1 + (reg >> 2) & 0x03;
WiredHome	127:db7f2c704693	1037	if (vScale)
WiredHome	127:db7f2c704693	1038	*vScale = 1 + reg & 0x03;
WiredHome	127:db7f2c704693	1039	return noerror;
WiredHome	127:db7f2c704693	1040	}
WiredHome	44:207594dece70	1041
WiredHome	19:3f82c1161fd2	1042	int RA8875::_putc(int c)
WiredHome	19:3f82c1161fd2	1043	{
WiredHome	29:422616aa04bd	1044	if (font == NULL) {
WiredHome	29:422616aa04bd	1045	return _internal_putc(c);
WiredHome	29:422616aa04bd	1046	} else {
WiredHome	29:422616aa04bd	1047	return _external_putc(c);
WiredHome	29:422616aa04bd	1048	}
WiredHome	29:422616aa04bd	1049	}
WiredHome	29:422616aa04bd	1050
WiredHome	44:207594dece70	1051
WiredHome	101:e0aad446094a	1052
WiredHome	101:e0aad446094a	1053	// Questions to ponder -
WiredHome	101:e0aad446094a	1054	// - if we choose to wrap to the next line, because the character won't fit on the current line,
WiredHome	101:e0aad446094a	1055	// should it erase the space to the width of the screen (in case there is leftover junk there)?
WiredHome	101:e0aad446094a	1056	// - it currently wraps from the bottom of the screen back to the top. I have pondered what
WiredHome	101:e0aad446094a	1057	// it might take to scroll the screen - but haven't thought hard enough about it.
WiredHome	101:e0aad446094a	1058	//
WiredHome	29:422616aa04bd	1059	int RA8875::_external_putc(int c)
WiredHome	29:422616aa04bd	1060	{
WiredHome	19:3f82c1161fd2	1061	if (c) {
WiredHome	19:3f82c1161fd2	1062	if (c == '\r') {
WiredHome	111:efe436c43aba	1063	cursor_x = windowrect.p1.x;
WiredHome	29:422616aa04bd	1064	} else if (c == '\n') {
WiredHome	98:ecebed9b80b2	1065	cursor_y += extFontHeight;
WiredHome	29:422616aa04bd	1066	} else {
WiredHome	109:7b94f06f085b	1067	dim_t charWidth, charHeight;
WiredHome	101:e0aad446094a	1068	const uint8_t * charRecord;
WiredHome	101:e0aad446094a	1069
WiredHome	101:e0aad446094a	1070	charRecord = getCharMetrics(c, &charWidth, &charHeight);
WiredHome	101:e0aad446094a	1071	//int advance = charwidth(c);
WiredHome	111:efe436c43aba	1072	INFO("(%d,%d) - (%d,%d):(%d,%d), charWidth: %d '%c", cursor_x, cursor_y,
WiredHome	111:efe436c43aba	1073	windowrect.p1.x, windowrect.p1.y, windowrect.p2.x, windowrect.p2.y,
WiredHome	111:efe436c43aba	1074	charWidth, c);
WiredHome	101:e0aad446094a	1075	if (charRecord) {
WiredHome	101:e0aad446094a	1076	//cursor_x += advance;
WiredHome	111:efe436c43aba	1077	if (cursor_x + charWidth >= windowrect.p2.x) {
WiredHome	111:efe436c43aba	1078	cursor_x = windowrect.p1.x;
WiredHome	101:e0aad446094a	1079	cursor_y += charHeight;
WiredHome	29:422616aa04bd	1080	}
WiredHome	111:efe436c43aba	1081	if (cursor_y + charHeight >= windowrect.p2.y) {
WiredHome	111:efe436c43aba	1082	cursor_y = windowrect.p1.y; // @todo Should it scroll?
WiredHome	101:e0aad446094a	1083	}
WiredHome	101:e0aad446094a	1084	(void)character(cursor_x, cursor_y, c);
WiredHome	153:8a85efb3eb71	1085	cursor_x += charWidth * fontScaleX;
WiredHome	29:422616aa04bd	1086	}
WiredHome	29:422616aa04bd	1087	}
WiredHome	29:422616aa04bd	1088	}
WiredHome	29:422616aa04bd	1089	return c;
WiredHome	29:422616aa04bd	1090	}
WiredHome	29:422616aa04bd	1091
WiredHome	44:207594dece70	1092
WiredHome	29:422616aa04bd	1093	int RA8875::_internal_putc(int c)
WiredHome	29:422616aa04bd	1094	{
WiredHome	29:422616aa04bd	1095	if (c) {
WiredHome	29:422616aa04bd	1096	unsigned char mwcr0;
WiredHome	73:f22a18707b5e	1097
WiredHome	29:422616aa04bd	1098	mwcr0 = ReadCommand(0x40);
WiredHome	29:422616aa04bd	1099	if ((mwcr0 & 0x80) == 0x00) {
WiredHome	29:422616aa04bd	1100	WriteCommand(0x40, 0x80 \| mwcr0); // Put in Text mode if not already
WiredHome	29:422616aa04bd	1101	}
WiredHome	29:422616aa04bd	1102	if (c == '\r') {
WiredHome	37:f19b7e7449dc	1103	loc_t x;
WiredHome	19:3f82c1161fd2	1104	x = ReadCommand(0x30) \| (ReadCommand(0x31) << 8); // Left edge of active window
WiredHome	38:38d503b4fad6	1105	WriteCommandW(0x2A, x);
WiredHome	19:3f82c1161fd2	1106	} else if (c == '\n') {
WiredHome	37:f19b7e7449dc	1107	loc_t y;
WiredHome	19:3f82c1161fd2	1108	y = ReadCommand(0x2C) \| (ReadCommand(0x2D) << 8); // current y location
WiredHome	19:3f82c1161fd2	1109	y += fontheight();
WiredHome	47:d96a09269f91	1110	if (y >= height()) // @TODO after bottom of active window, then scroll window?
WiredHome	19:3f82c1161fd2	1111	y = 0;
WiredHome	38:38d503b4fad6	1112	WriteCommandW(0x2C, y);
WiredHome	19:3f82c1161fd2	1113	} else {
WiredHome	29:422616aa04bd	1114	WriteCommand(0x02); // RA8875 Internal Fonts
WiredHome	79:544eb4964795	1115	_select(true);
WiredHome	29:422616aa04bd	1116	WriteData(c);
WiredHome	66:468a11f05580	1117	_WaitWhileBusy(0x80);
WiredHome	79:544eb4964795	1118	_select(false);
WiredHome	19:3f82c1161fd2	1119	}
WiredHome	19:3f82c1161fd2	1120	}
WiredHome	19:3f82c1161fd2	1121	return c;
WiredHome	19:3f82c1161fd2	1122	}
WiredHome	19:3f82c1161fd2	1123
WiredHome	44:207594dece70	1124
WiredHome	32:0e4f2ae512e2	1125	RetCode_t RA8875::_StartGraphicsStream(void)
WiredHome	32:0e4f2ae512e2	1126	{
WiredHome	32:0e4f2ae512e2	1127	WriteCommand(0x40,0x00); // Graphics write mode
WiredHome	32:0e4f2ae512e2	1128	WriteCommand(0x02); // Prepare for streaming data
WiredHome	32:0e4f2ae512e2	1129	return noerror;
WiredHome	32:0e4f2ae512e2	1130	}
WiredHome	32:0e4f2ae512e2	1131
WiredHome	44:207594dece70	1132
WiredHome	32:0e4f2ae512e2	1133	RetCode_t RA8875::_EndGraphicsStream(void)
WiredHome	32:0e4f2ae512e2	1134	{
WiredHome	32:0e4f2ae512e2	1135	return noerror;
WiredHome	32:0e4f2ae512e2	1136	}
WiredHome	32:0e4f2ae512e2	1137
WiredHome	44:207594dece70	1138
WiredHome	55:dfbabef7003e	1139	RetCode_t RA8875::_putp(color_t pixel)
WiredHome	32:0e4f2ae512e2	1140	{
WiredHome	38:38d503b4fad6	1141	WriteDataW((pixel>>8) \| (pixel<<8));
WiredHome	73:f22a18707b5e	1142	return noerror;
WiredHome	32:0e4f2ae512e2	1143	}
WiredHome	29:422616aa04bd	1144
WiredHome	44:207594dece70	1145
WiredHome	37:f19b7e7449dc	1146	void RA8875::puts(loc_t x, loc_t y, const char * string)
WiredHome	19:3f82c1161fd2	1147	{
WiredHome	19:3f82c1161fd2	1148	SetTextCursor(x,y);
WiredHome	19:3f82c1161fd2	1149	puts(string);
WiredHome	19:3f82c1161fd2	1150	}
WiredHome	19:3f82c1161fd2	1151
WiredHome	44:207594dece70	1152
WiredHome	19:3f82c1161fd2	1153	void RA8875::puts(const char * string)
WiredHome	19:3f82c1161fd2	1154	{
WiredHome	37:f19b7e7449dc	1155	if (font == NULL) {
WiredHome	100:0b084475d5a9	1156	WriteCommand(0x40,0x80); // Put in Text mode if internal font
WiredHome	37:f19b7e7449dc	1157	}
WiredHome	19:3f82c1161fd2	1158	if (*string != '\0') {
WiredHome	29:422616aa04bd	1159	while (*string) { // @TODO calling individual _putc is slower... optimizations?
WiredHome	19:3f82c1161fd2	1160	_putc(*string++);
WiredHome	19:3f82c1161fd2	1161	}
WiredHome	19:3f82c1161fd2	1162	}
WiredHome	19:3f82c1161fd2	1163	}
WiredHome	19:3f82c1161fd2	1164
WiredHome	44:207594dece70	1165
WiredHome	37:f19b7e7449dc	1166	RetCode_t RA8875::SetGraphicsCursor(loc_t x, loc_t y)
WiredHome	19:3f82c1161fd2	1167	{
WiredHome	38:38d503b4fad6	1168	WriteCommandW(0x46, x);
WiredHome	38:38d503b4fad6	1169	WriteCommandW(0x48, y);
WiredHome	19:3f82c1161fd2	1170	return noerror;
WiredHome	19:3f82c1161fd2	1171	}
WiredHome	19:3f82c1161fd2	1172
WiredHome	136:224e03d5c31f	1173	RetCode_t RA8875::SetGraphicsCursor(point_t p)
WiredHome	136:224e03d5c31f	1174	{
WiredHome	136:224e03d5c31f	1175	return SetGraphicsCursor(p.x, p.y);
WiredHome	136:224e03d5c31f	1176	}
WiredHome	136:224e03d5c31f	1177
WiredHome	136:224e03d5c31f	1178	point_t RA8875::GetGraphicsCursor(void)
WiredHome	136:224e03d5c31f	1179	{
WiredHome	136:224e03d5c31f	1180	point_t p;
WiredHome	136:224e03d5c31f	1181
WiredHome	136:224e03d5c31f	1182	p.x = ReadCommandW(0x46);
WiredHome	136:224e03d5c31f	1183	p.y = ReadCommandW(0x48);
WiredHome	136:224e03d5c31f	1184	return p;
WiredHome	136:224e03d5c31f	1185	}
WiredHome	44:207594dece70	1186
WiredHome	41:2956a0a221e5	1187	RetCode_t RA8875::SetGraphicsCursorRead(loc_t x, loc_t y)
WiredHome	41:2956a0a221e5	1188	{
WiredHome	41:2956a0a221e5	1189	WriteCommandW(0x4A, x);
WiredHome	41:2956a0a221e5	1190	WriteCommandW(0x4C, y);
WiredHome	41:2956a0a221e5	1191	return noerror;
WiredHome	41:2956a0a221e5	1192	}
WiredHome	41:2956a0a221e5	1193
WiredHome	111:efe436c43aba	1194	RetCode_t RA8875::window(rect_t r)
WiredHome	111:efe436c43aba	1195	{
WiredHome	111:efe436c43aba	1196	return window(r.p1.x, r.p1.y, r.p2.x + 1 - r.p1.x, r.p2.y + 1 - r.p1.y);
WiredHome	111:efe436c43aba	1197	}
WiredHome	44:207594dece70	1198
WiredHome	37:f19b7e7449dc	1199	RetCode_t RA8875::window(loc_t x, loc_t y, dim_t width, dim_t height)
WiredHome	19:3f82c1161fd2	1200	{
WiredHome	111:efe436c43aba	1201	INFO("window(%d,%d,%d,%d)", x, y, width, height);
WiredHome	111:efe436c43aba	1202	if (width == (dim_t)-1)
WiredHome	111:efe436c43aba	1203	width = screenwidth - x;
WiredHome	111:efe436c43aba	1204	if (height == (dim_t)-1)
WiredHome	111:efe436c43aba	1205	height = screenheight - y;
WiredHome	111:efe436c43aba	1206	windowrect.p1.x = x;
WiredHome	111:efe436c43aba	1207	windowrect.p1.y = y;
WiredHome	111:efe436c43aba	1208	windowrect.p2.x = x + width - 1;
WiredHome	111:efe436c43aba	1209	windowrect.p2.y = y + height - 1;
WiredHome	37:f19b7e7449dc	1210	GraphicsDisplay::window(x,y, width,height);
WiredHome	38:38d503b4fad6	1211	WriteCommandW(0x30, x);
WiredHome	38:38d503b4fad6	1212	WriteCommandW(0x32, y);
WiredHome	38:38d503b4fad6	1213	WriteCommandW(0x34, (x+width-1));
WiredHome	38:38d503b4fad6	1214	WriteCommandW(0x36, (y+height-1));
WiredHome	111:efe436c43aba	1215	//SetTextCursor(x,y);
WiredHome	111:efe436c43aba	1216	//SetGraphicsCursor(x,y);
WiredHome	19:3f82c1161fd2	1217	return noerror;
WiredHome	19:3f82c1161fd2	1218	}
WiredHome	19:3f82c1161fd2	1219
WiredHome	44:207594dece70	1220
WiredHome	61:8f3153bf0baa	1221	RetCode_t RA8875::cls(uint16_t layers)
WiredHome	19:3f82c1161fd2	1222	{
WiredHome	61:8f3153bf0baa	1223	RetCode_t ret;
WiredHome	73:f22a18707b5e	1224
WiredHome	19:3f82c1161fd2	1225	PERFORMANCE_RESET;
WiredHome	61:8f3153bf0baa	1226	if (layers == 0) {
WiredHome	61:8f3153bf0baa	1227	ret = clsw(FULLWINDOW);
WiredHome	61:8f3153bf0baa	1228	} else if (layers > 3) {
WiredHome	61:8f3153bf0baa	1229	ret = bad_parameter;
WiredHome	61:8f3153bf0baa	1230	} else {
WiredHome	61:8f3153bf0baa	1231	uint16_t prevLayer = GetDrawingLayer();
WiredHome	61:8f3153bf0baa	1232	if (layers & 1) {
WiredHome	61:8f3153bf0baa	1233	SelectDrawingLayer(0);
WiredHome	61:8f3153bf0baa	1234	clsw(FULLWINDOW);
WiredHome	61:8f3153bf0baa	1235	}
WiredHome	61:8f3153bf0baa	1236	if (layers & 2) {
WiredHome	61:8f3153bf0baa	1237	SelectDrawingLayer(1);
WiredHome	61:8f3153bf0baa	1238	clsw(FULLWINDOW);
WiredHome	61:8f3153bf0baa	1239	}
WiredHome	142:6e9bff59878a	1240	SelectDrawingLayer(prevLayer);
WiredHome	61:8f3153bf0baa	1241	}
WiredHome	135:af519fe4ba91	1242	ret = SetTextCursor(0,0);
WiredHome	135:af519fe4ba91	1243	ret = locate(0,0);
WiredHome	19:3f82c1161fd2	1244	REGISTERPERFORMANCE(PRF_CLS);
WiredHome	61:8f3153bf0baa	1245	return ret;
WiredHome	19:3f82c1161fd2	1246	}
WiredHome	19:3f82c1161fd2	1247
WiredHome	44:207594dece70	1248
WiredHome	19:3f82c1161fd2	1249	RetCode_t RA8875::clsw(RA8875::Region_t region)
WiredHome	19:3f82c1161fd2	1250	{
WiredHome	19:3f82c1161fd2	1251	PERFORMANCE_RESET;
WiredHome	19:3f82c1161fd2	1252	WriteCommand(0x8E, (region == ACTIVEWINDOW) ? 0xC0 : 0x80);
WiredHome	131:5bd6ba2ee4a1	1253	if (!_WaitWhileReg(0x8E, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	1254	REGISTERPERFORMANCE(PRF_CLS);
WiredHome	131:5bd6ba2ee4a1	1255	return external_abort;
WiredHome	131:5bd6ba2ee4a1	1256	}
WiredHome	19:3f82c1161fd2	1257	REGISTERPERFORMANCE(PRF_CLS);
WiredHome	19:3f82c1161fd2	1258	return noerror;
WiredHome	19:3f82c1161fd2	1259	}
WiredHome	19:3f82c1161fd2	1260
WiredHome	44:207594dece70	1261
WiredHome	87:ee2240581aa7	1262	RetCode_t RA8875::pixel(point_t p, color_t color)
WiredHome	87:ee2240581aa7	1263	{
WiredHome	87:ee2240581aa7	1264	return pixel(p.x, p.y, color);
WiredHome	87:ee2240581aa7	1265	}
WiredHome	87:ee2240581aa7	1266
WiredHome	87:ee2240581aa7	1267	RetCode_t RA8875::pixel(point_t p)
WiredHome	87:ee2240581aa7	1268	{
WiredHome	87:ee2240581aa7	1269	return pixel(p.x, p.y);
WiredHome	87:ee2240581aa7	1270	}
WiredHome	87:ee2240581aa7	1271
WiredHome	37:f19b7e7449dc	1272	RetCode_t RA8875::pixel(loc_t x, loc_t y, color_t color)
WiredHome	19:3f82c1161fd2	1273	{
WiredHome	62:ba5d33438fda	1274	RetCode_t ret;
WiredHome	73:f22a18707b5e	1275
WiredHome	62:ba5d33438fda	1276	PERFORMANCE_RESET;
WiredHome	62:ba5d33438fda	1277	ret = pixelStream(&color, 1, x,y);
WiredHome	62:ba5d33438fda	1278	REGISTERPERFORMANCE(PRF_DRAWPIXEL);
WiredHome	62:ba5d33438fda	1279	return ret;
WiredHome	19:3f82c1161fd2	1280	}
WiredHome	19:3f82c1161fd2	1281
WiredHome	44:207594dece70	1282
WiredHome	37:f19b7e7449dc	1283	RetCode_t RA8875::pixel(loc_t x, loc_t y)
WiredHome	19:3f82c1161fd2	1284	{
WiredHome	19:3f82c1161fd2	1285	RetCode_t ret;
WiredHome	73:f22a18707b5e	1286
WiredHome	19:3f82c1161fd2	1287	PERFORMANCE_RESET;
WiredHome	19:3f82c1161fd2	1288	color_t color = GetForeColor();
WiredHome	62:ba5d33438fda	1289	ret = pixelStream(&color, 1, x, y);
WiredHome	41:2956a0a221e5	1290	REGISTERPERFORMANCE(PRF_DRAWPIXEL);
WiredHome	19:3f82c1161fd2	1291	return ret;
WiredHome	19:3f82c1161fd2	1292	}
WiredHome	19:3f82c1161fd2	1293
WiredHome	44:207594dece70	1294
WiredHome	41:2956a0a221e5	1295	RetCode_t RA8875::pixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
WiredHome	41:2956a0a221e5	1296	{
WiredHome	41:2956a0a221e5	1297	PERFORMANCE_RESET;
WiredHome	41:2956a0a221e5	1298	SetGraphicsCursor(x, y);
WiredHome	109:7b94f06f085b	1299	_StartGraphicsStream();
WiredHome	79:544eb4964795	1300	_select(true);
WiredHome	79:544eb4964795	1301	_spiwrite(0x00); // Cmd: write data
WiredHome	41:2956a0a221e5	1302	while (count--) {
WiredHome	105:4f116006ba1f	1303	if (screenbpp == 16) {
WiredHome	105:4f116006ba1f	1304	_spiwrite(*p >> 8);
WiredHome	105:4f116006ba1f	1305	_spiwrite(*p & 0xFF);
WiredHome	105:4f116006ba1f	1306	} else {
WiredHome	105:4f116006ba1f	1307	_spiwrite(_cvt16to8(*p));
WiredHome	105:4f116006ba1f	1308	}
WiredHome	41:2956a0a221e5	1309	p++;
WiredHome	41:2956a0a221e5	1310	}
WiredHome	79:544eb4964795	1311	_select(false);
WiredHome	109:7b94f06f085b	1312	_EndGraphicsStream();
WiredHome	41:2956a0a221e5	1313	REGISTERPERFORMANCE(PRF_PIXELSTREAM);
WiredHome	41:2956a0a221e5	1314	return(noerror);
WiredHome	41:2956a0a221e5	1315	}
WiredHome	41:2956a0a221e5	1316
WiredHome	153:8a85efb3eb71	1317	// With a font scale X = 1, a pixel stream is "abcdefg..."
WiredHome	153:8a85efb3eb71	1318	// With a font scale X = 2, a pixel stream is "aabbccddeeffgg..."
WiredHome	153:8a85efb3eb71	1319	// With a font scale Y = 2, a pixel stream is "abcdefg..."
WiredHome	153:8a85efb3eb71	1320	// "abcdefg..."
WiredHome	153:8a85efb3eb71	1321	//
WiredHome	109:7b94f06f085b	1322	RetCode_t RA8875::booleanStream(loc_t x, loc_t y, dim_t w, dim_t h, const uint8_t * boolStream)
WiredHome	109:7b94f06f085b	1323	{
WiredHome	109:7b94f06f085b	1324	PERFORMANCE_RESET;
WiredHome	153:8a85efb3eb71	1325	const uint8_t * rowStream;
WiredHome	111:efe436c43aba	1326	rect_t restore = windowrect;
WiredHome	153:8a85efb3eb71	1327	window(x, y, w * fontScaleX, h * fontScaleY); // Scale from font scale factors
WiredHome	109:7b94f06f085b	1328	SetGraphicsCursor(x, y);
WiredHome	109:7b94f06f085b	1329	_StartGraphicsStream();
WiredHome	109:7b94f06f085b	1330	_select(true);
WiredHome	109:7b94f06f085b	1331	_spiwrite(0x00); // Cmd: write data
WiredHome	109:7b94f06f085b	1332	while (h--) {
WiredHome	153:8a85efb3eb71	1333	for (int dy=0; dy<fontScaleY; dy++) { // Vertical Font Scale Factor
WiredHome	153:8a85efb3eb71	1334	uint8_t pixels = w;
WiredHome	153:8a85efb3eb71	1335	uint8_t bitmask = 0x01;
WiredHome	153:8a85efb3eb71	1336	rowStream = boolStream;
WiredHome	153:8a85efb3eb71	1337	while (pixels) {
WiredHome	153:8a85efb3eb71	1338	uint8_t byte = *rowStream;
WiredHome	153:8a85efb3eb71	1339	//INFO("byte, mask: %02X, %02X", byte, bitmask);
WiredHome	153:8a85efb3eb71	1340	color_t c = (byte & bitmask) ? _foreground : _background;
WiredHome	153:8a85efb3eb71	1341
WiredHome	153:8a85efb3eb71	1342	for (int dx=0; dx<fontScaleX; dx++) { // Horizontal Font Scale Factor
WiredHome	153:8a85efb3eb71	1343	if (screenbpp == 16) {
WiredHome	153:8a85efb3eb71	1344	_spiwrite(c >> 8);
WiredHome	153:8a85efb3eb71	1345	_spiwrite(c & 0xFF);
WiredHome	153:8a85efb3eb71	1346	} else {
WiredHome	153:8a85efb3eb71	1347	_spiwrite(_cvt16to8(c));
WiredHome	153:8a85efb3eb71	1348	}
WiredHome	109:7b94f06f085b	1349	}
WiredHome	153:8a85efb3eb71	1350	bitmask <<= 1;
WiredHome	153:8a85efb3eb71	1351	if (pixels > 1 && bitmask == 0) {
WiredHome	153:8a85efb3eb71	1352	bitmask = 0x01;
WiredHome	153:8a85efb3eb71	1353	rowStream++;
WiredHome	153:8a85efb3eb71	1354	}
WiredHome	153:8a85efb3eb71	1355	pixels--;
WiredHome	109:7b94f06f085b	1356	}
WiredHome	109:7b94f06f085b	1357	}
WiredHome	153:8a85efb3eb71	1358	boolStream += (rowStream - boolStream + 1);
WiredHome	109:7b94f06f085b	1359	}
WiredHome	109:7b94f06f085b	1360	_select(false);
WiredHome	109:7b94f06f085b	1361	_EndGraphicsStream();
WiredHome	111:efe436c43aba	1362	window(restore);
WiredHome	109:7b94f06f085b	1363	REGISTERPERFORMANCE(PRF_BOOLSTREAM);
WiredHome	109:7b94f06f085b	1364	return(noerror);
WiredHome	109:7b94f06f085b	1365	}
WiredHome	44:207594dece70	1366
WiredHome	41:2956a0a221e5	1367	color_t RA8875::getPixel(loc_t x, loc_t y)
WiredHome	41:2956a0a221e5	1368	{
WiredHome	41:2956a0a221e5	1369	color_t pixel;
WiredHome	73:f22a18707b5e	1370
WiredHome	41:2956a0a221e5	1371	PERFORMANCE_RESET;
WiredHome	41:2956a0a221e5	1372	WriteCommand(0x40,0x00); // Graphics write mode
WiredHome	41:2956a0a221e5	1373	SetGraphicsCursorRead(x, y);
WiredHome	41:2956a0a221e5	1374	WriteCommand(0x02);
WiredHome	79:544eb4964795	1375	_select(true);
WiredHome	79:544eb4964795	1376	_spiwrite(0x40); // Cmd: read data
WiredHome	79:544eb4964795	1377	_spiwrite(0x00); // dummy read
WiredHome	105:4f116006ba1f	1378	if (screenbpp == 16) {
WiredHome	105:4f116006ba1f	1379	pixel = _spiread();
WiredHome	105:4f116006ba1f	1380	pixel \|= (_spiread() << 8);
WiredHome	105:4f116006ba1f	1381	} else {
WiredHome	105:4f116006ba1f	1382	pixel = _cvt8to16(_spiread());
WiredHome	105:4f116006ba1f	1383	}
WiredHome	79:544eb4964795	1384	_select(false);
WiredHome	41:2956a0a221e5	1385	REGISTERPERFORMANCE(PRF_READPIXEL);
WiredHome	41:2956a0a221e5	1386	return pixel;
WiredHome	41:2956a0a221e5	1387	}
WiredHome	41:2956a0a221e5	1388
WiredHome	44:207594dece70	1389
WiredHome	41:2956a0a221e5	1390	RetCode_t RA8875::getPixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
WiredHome	41:2956a0a221e5	1391	{
WiredHome	41:2956a0a221e5	1392	color_t pixel;
WiredHome	86:e86b355940f4	1393	RetCode_t ret = noerror;
WiredHome	73:f22a18707b5e	1394
WiredHome	41:2956a0a221e5	1395	PERFORMANCE_RESET;
WiredHome	86:e86b355940f4	1396	ret = WriteCommand(0x40,0x00); // Graphics write mode
WiredHome	86:e86b355940f4	1397	ret = SetGraphicsCursorRead(x, y);
WiredHome	86:e86b355940f4	1398	ret = WriteCommand(0x02);
WiredHome	79:544eb4964795	1399	_select(true);
WiredHome	79:544eb4964795	1400	_spiwrite(0x40); // Cmd: read data
WiredHome	79:544eb4964795	1401	_spiwrite(0x00); // dummy read
WiredHome	106:c80828f5dea4	1402	if (screenbpp == 16)
WiredHome	106:c80828f5dea4	1403	_spiwrite(0x00); // dummy read is only necessary when in 16-bit mode
WiredHome	41:2956a0a221e5	1404	while (count--) {
WiredHome	105:4f116006ba1f	1405	if (screenbpp == 16) {
WiredHome	105:4f116006ba1f	1406	pixel = _spiread();
WiredHome	105:4f116006ba1f	1407	pixel \|= (_spiread() << 8);
WiredHome	105:4f116006ba1f	1408	} else {
WiredHome	105:4f116006ba1f	1409	pixel = _cvt8to16(_spiread());
WiredHome	105:4f116006ba1f	1410	}
WiredHome	41:2956a0a221e5	1411	*p++ = pixel;
WiredHome	41:2956a0a221e5	1412	}
WiredHome	79:544eb4964795	1413	_select(false);
WiredHome	41:2956a0a221e5	1414	REGISTERPERFORMANCE(PRF_READPIXELSTREAM);
WiredHome	86:e86b355940f4	1415	return ret;
WiredHome	41:2956a0a221e5	1416	}
WiredHome	41:2956a0a221e5	1417
WiredHome	44:207594dece70	1418
WiredHome	83:7bad0068cca0	1419	RetCode_t RA8875::line(point_t p1, point_t p2)
WiredHome	83:7bad0068cca0	1420	{
WiredHome	83:7bad0068cca0	1421	return line(p1.x, p1.y, p2.x, p2.y);
WiredHome	83:7bad0068cca0	1422	}
WiredHome	83:7bad0068cca0	1423
WiredHome	83:7bad0068cca0	1424
WiredHome	83:7bad0068cca0	1425	RetCode_t RA8875::line(point_t p1, point_t p2, color_t color)
WiredHome	83:7bad0068cca0	1426	{
WiredHome	83:7bad0068cca0	1427	return line(p1.x, p1.y, p2.x, p2.y, color);
WiredHome	83:7bad0068cca0	1428	}
WiredHome	83:7bad0068cca0	1429
WiredHome	83:7bad0068cca0	1430
WiredHome	37:f19b7e7449dc	1431	RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2, color_t color)
WiredHome	19:3f82c1161fd2	1432	{
WiredHome	19:3f82c1161fd2	1433	foreground(color);
WiredHome	19:3f82c1161fd2	1434	return line(x1,y1,x2,y2);
WiredHome	19:3f82c1161fd2	1435	}
WiredHome	19:3f82c1161fd2	1436
WiredHome	44:207594dece70	1437
WiredHome	37:f19b7e7449dc	1438	RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2)
WiredHome	19:3f82c1161fd2	1439	{
WiredHome	19:3f82c1161fd2	1440	PERFORMANCE_RESET;
WiredHome	62:ba5d33438fda	1441	if (x1 == x2 && y1 == y2) {
WiredHome	60:2dfd574f63bd	1442	pixel(x1, y1);
WiredHome	62:ba5d33438fda	1443	} else {
WiredHome	60:2dfd574f63bd	1444	WriteCommandW(0x91, x1);
WiredHome	60:2dfd574f63bd	1445	WriteCommandW(0x93, y1);
WiredHome	60:2dfd574f63bd	1446	WriteCommandW(0x95, x2);
WiredHome	60:2dfd574f63bd	1447	WriteCommandW(0x97, y2);
WiredHome	60:2dfd574f63bd	1448	unsigned char drawCmd = 0x00; // Line
WiredHome	60:2dfd574f63bd	1449	WriteCommand(0x90, drawCmd);
WiredHome	60:2dfd574f63bd	1450	WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	1451	if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	1452	REGISTERPERFORMANCE(PRF_DRAWLINE);
WiredHome	131:5bd6ba2ee4a1	1453	return external_abort;
WiredHome	131:5bd6ba2ee4a1	1454	}
WiredHome	60:2dfd574f63bd	1455	}
WiredHome	19:3f82c1161fd2	1456	REGISTERPERFORMANCE(PRF_DRAWLINE);
WiredHome	19:3f82c1161fd2	1457	return noerror;
WiredHome	19:3f82c1161fd2	1458	}
WiredHome	19:3f82c1161fd2	1459
WiredHome	144:ba002c4b21b3	1460
WiredHome	144:ba002c4b21b3	1461	RetCode_t RA8875::ThickLine(point_t p1, point_t p2, dim_t thickness, color_t color)
WiredHome	144:ba002c4b21b3	1462	{
WiredHome	144:ba002c4b21b3	1463	if (thickness == 1) {
WiredHome	144:ba002c4b21b3	1464	line(p1,p2, color);
WiredHome	144:ba002c4b21b3	1465	} else {
WiredHome	144:ba002c4b21b3	1466	int dx = abs(p2.x-p1.x), sx = p1.x<p2.x ? 1 : -1;
WiredHome	144:ba002c4b21b3	1467	int dy = abs(p2.y-p1.y), sy = p1.y<p2.y ? 1 : -1;
WiredHome	144:ba002c4b21b3	1468	int err = (dx>dy ? dx : -dy)/2, e2;
WiredHome	144:ba002c4b21b3	1469
WiredHome	144:ba002c4b21b3	1470	for (;;) {
WiredHome	144:ba002c4b21b3	1471	fillcircle(p1.x, p1.y, thickness/2, color);
WiredHome	144:ba002c4b21b3	1472	if (p1.x==p2.x && p1.y==p2.y)
WiredHome	144:ba002c4b21b3	1473	break;
WiredHome	144:ba002c4b21b3	1474	e2 = err;
WiredHome	144:ba002c4b21b3	1475	if (e2 >-dx)
WiredHome	144:ba002c4b21b3	1476	{ err -= dy; p1.x += sx; }
WiredHome	144:ba002c4b21b3	1477	if (e2 < dy)
WiredHome	144:ba002c4b21b3	1478	{ err += dx; p1.y += sy; }
WiredHome	144:ba002c4b21b3	1479	}
WiredHome	144:ba002c4b21b3	1480	}
WiredHome	144:ba002c4b21b3	1481	return noerror;
WiredHome	144:ba002c4b21b3	1482	}
WiredHome	144:ba002c4b21b3	1483
WiredHome	144:ba002c4b21b3	1484
WiredHome	107:f9ccffcb84f1	1485	//
WiredHome	107:f9ccffcb84f1	1486	// Rectangle functions all mostly helpers to the basic rectangle function
WiredHome	107:f9ccffcb84f1	1487	//
WiredHome	107:f9ccffcb84f1	1488
WiredHome	81:01da2e34283d	1489	RetCode_t RA8875::fillrect(rect_t r, color_t color, fill_t fillit)
WiredHome	81:01da2e34283d	1490	{
WiredHome	81:01da2e34283d	1491	return rect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, color, fillit);
WiredHome	81:01da2e34283d	1492	}
WiredHome	44:207594dece70	1493
WiredHome	73:f22a18707b5e	1494	RetCode_t RA8875::fillrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	1495	color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	1496	{
WiredHome	19:3f82c1161fd2	1497	return rect(x1,y1,x2,y2,color,fillit);
WiredHome	19:3f82c1161fd2	1498	}
WiredHome	19:3f82c1161fd2	1499
WiredHome	81:01da2e34283d	1500	RetCode_t RA8875::rect(rect_t r, color_t color, fill_t fillit)
WiredHome	81:01da2e34283d	1501	{
WiredHome	81:01da2e34283d	1502	return rect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, color, fillit);
WiredHome	81:01da2e34283d	1503	}
WiredHome	44:207594dece70	1504
WiredHome	73:f22a18707b5e	1505	RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	1506	color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	1507	{
WiredHome	19:3f82c1161fd2	1508	foreground(color);
WiredHome	19:3f82c1161fd2	1509	return rect(x1,y1,x2,y2,fillit);
WiredHome	19:3f82c1161fd2	1510	}
WiredHome	19:3f82c1161fd2	1511
WiredHome	73:f22a18707b5e	1512	RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	1513	fill_t fillit)
WiredHome	19:3f82c1161fd2	1514	{
WiredHome	85:022bba13c5c4	1515	RetCode_t ret = noerror;
WiredHome	19:3f82c1161fd2	1516	PERFORMANCE_RESET;
WiredHome	85:022bba13c5c4	1517	// check for bad_parameter
WiredHome	105:4f116006ba1f	1518	if (x1 < 0 \|\| x1 >= screenwidth \|\| x2 < 0 \|\| x2 >= screenwidth
WiredHome	105:4f116006ba1f	1519	\|\| y1 < 0 \|\| y1 >= screenheight \|\| y2 < 0 \|\| y2 >= screenheight) {
WiredHome	85:022bba13c5c4	1520	ret = bad_parameter;
WiredHome	100:0b084475d5a9	1521	} else {
WiredHome	85:022bba13c5c4	1522	if (x1 == x2 && y1 == y2) {
WiredHome	85:022bba13c5c4	1523	pixel(x1, y1);
WiredHome	85:022bba13c5c4	1524	} else if (x1 == x2) {
WiredHome	85:022bba13c5c4	1525	line(x1, y1, x2, y2);
WiredHome	85:022bba13c5c4	1526	} else if (y1 == y2) {
WiredHome	85:022bba13c5c4	1527	line(x1, y1, x2, y2);
WiredHome	85:022bba13c5c4	1528	} else {
WiredHome	85:022bba13c5c4	1529	WriteCommandW(0x91, x1);
WiredHome	85:022bba13c5c4	1530	WriteCommandW(0x93, y1);
WiredHome	85:022bba13c5c4	1531	WriteCommandW(0x95, x2);
WiredHome	85:022bba13c5c4	1532	WriteCommandW(0x97, y2);
WiredHome	85:022bba13c5c4	1533	unsigned char drawCmd = 0x10; // Rectangle
WiredHome	85:022bba13c5c4	1534	if (fillit == FILL)
WiredHome	85:022bba13c5c4	1535	drawCmd \|= 0x20;
WiredHome	85:022bba13c5c4	1536	WriteCommand(0x90, drawCmd);
WiredHome	85:022bba13c5c4	1537	ret = WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	1538	if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	1539	REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
WiredHome	131:5bd6ba2ee4a1	1540	return external_abort;
WiredHome	131:5bd6ba2ee4a1	1541	}
WiredHome	85:022bba13c5c4	1542	}
WiredHome	19:3f82c1161fd2	1543	}
WiredHome	19:3f82c1161fd2	1544	REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
WiredHome	85:022bba13c5c4	1545	return ret;
WiredHome	19:3f82c1161fd2	1546	}
WiredHome	19:3f82c1161fd2	1547
WiredHome	44:207594dece70	1548
WiredHome	107:f9ccffcb84f1	1549	//
WiredHome	107:f9ccffcb84f1	1550	// rounded rectangle functions are mostly helpers to the base round rect
WiredHome	107:f9ccffcb84f1	1551	//
WiredHome	107:f9ccffcb84f1	1552
WiredHome	107:f9ccffcb84f1	1553	RetCode_t RA8875::fillroundrect(rect_t r, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	107:f9ccffcb84f1	1554	{
WiredHome	107:f9ccffcb84f1	1555	return roundrect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, radius1, radius2, color, fillit);
WiredHome	107:f9ccffcb84f1	1556	}
WiredHome	107:f9ccffcb84f1	1557
WiredHome	73:f22a18707b5e	1558	RetCode_t RA8875::fillroundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	1559	dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	1560	{
WiredHome	19:3f82c1161fd2	1561	foreground(color);
WiredHome	19:3f82c1161fd2	1562	return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
WiredHome	19:3f82c1161fd2	1563	}
WiredHome	19:3f82c1161fd2	1564
WiredHome	107:f9ccffcb84f1	1565	RetCode_t RA8875::roundrect(rect_t r, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	107:f9ccffcb84f1	1566	{
WiredHome	107:f9ccffcb84f1	1567	return roundrect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, radius1, radius2, color, fillit);
WiredHome	107:f9ccffcb84f1	1568	}
WiredHome	44:207594dece70	1569
WiredHome	73:f22a18707b5e	1570	RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	1571	dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	1572	{
WiredHome	19:3f82c1161fd2	1573	foreground(color);
WiredHome	19:3f82c1161fd2	1574	return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
WiredHome	19:3f82c1161fd2	1575	}
WiredHome	19:3f82c1161fd2	1576
WiredHome	44:207594dece70	1577
WiredHome	73:f22a18707b5e	1578	RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	1579	dim_t radius1, dim_t radius2, fill_t fillit)
WiredHome	19:3f82c1161fd2	1580	{
WiredHome	19:3f82c1161fd2	1581	RetCode_t ret = noerror;
WiredHome	73:f22a18707b5e	1582
WiredHome	19:3f82c1161fd2	1583	PERFORMANCE_RESET;
WiredHome	105:4f116006ba1f	1584	if (x1 < 0 \|\| x1 >= screenwidth \|\| x2 < 0 \|\| x2 >= screenwidth
WiredHome	105:4f116006ba1f	1585	\|\| y1 < 0 \|\| y1 >= screenheight \|\| y2 < 0 \|\| y2 >= screenheight) {
WiredHome	85:022bba13c5c4	1586	ret = bad_parameter;
WiredHome	85:022bba13c5c4	1587	} else if (x1 > x2 \|\| y1 > y2 \|\| (radius1 > (x2-x1)/2) \|\| (radius2 > (y2-y1)/2) ) {
WiredHome	21:3c1efb192927	1588	ret = bad_parameter;
WiredHome	21:3c1efb192927	1589	} else if (x1 == x2 && y1 == y2) {
WiredHome	19:3f82c1161fd2	1590	pixel(x1, y1);
WiredHome	19:3f82c1161fd2	1591	} else if (x1 == x2) {
WiredHome	19:3f82c1161fd2	1592	line(x1, y1, x2, y2);
WiredHome	19:3f82c1161fd2	1593	} else if (y1 == y2) {
WiredHome	19:3f82c1161fd2	1594	line(x1, y1, x2, y2);
WiredHome	19:3f82c1161fd2	1595	} else {
WiredHome	38:38d503b4fad6	1596	WriteCommandW(0x91, x1);
WiredHome	38:38d503b4fad6	1597	WriteCommandW(0x93, y1);
WiredHome	38:38d503b4fad6	1598	WriteCommandW(0x95, x2);
WiredHome	38:38d503b4fad6	1599	WriteCommandW(0x97, y2);
WiredHome	38:38d503b4fad6	1600	WriteCommandW(0xA1, radius1);
WiredHome	38:38d503b4fad6	1601	WriteCommandW(0xA3, radius2);
WiredHome	21:3c1efb192927	1602	// Should not need this...
WiredHome	38:38d503b4fad6	1603	WriteCommandW(0xA5, 0);
WiredHome	38:38d503b4fad6	1604	WriteCommandW(0xA7, 0);
WiredHome	19:3f82c1161fd2	1605	unsigned char drawCmd = 0x20; // Rounded Rectangle
WiredHome	19:3f82c1161fd2	1606	if (fillit == FILL)
WiredHome	19:3f82c1161fd2	1607	drawCmd \|= 0x40;
WiredHome	19:3f82c1161fd2	1608	WriteCommand(0xA0, drawCmd);
WiredHome	19:3f82c1161fd2	1609	WriteCommand(0xA0, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	1610	if (!_WaitWhileReg(0xA0, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	1611	REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
WiredHome	131:5bd6ba2ee4a1	1612	return external_abort;
WiredHome	131:5bd6ba2ee4a1	1613	}
WiredHome	19:3f82c1161fd2	1614	}
WiredHome	19:3f82c1161fd2	1615	REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
WiredHome	19:3f82c1161fd2	1616	return ret;
WiredHome	19:3f82c1161fd2	1617	}
WiredHome	19:3f82c1161fd2	1618
WiredHome	44:207594dece70	1619
WiredHome	107:f9ccffcb84f1	1620	//
WiredHome	107:f9ccffcb84f1	1621	// triangle functions
WiredHome	107:f9ccffcb84f1	1622	//
WiredHome	107:f9ccffcb84f1	1623
WiredHome	73:f22a18707b5e	1624	RetCode_t RA8875::triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	1625	loc_t x3, loc_t y3, color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	1626	{
WiredHome	20:6e2e4a8372eb	1627	RetCode_t ret;
WiredHome	20:6e2e4a8372eb	1628
WiredHome	105:4f116006ba1f	1629	if (x1 < 0 \|\| x1 >= screenwidth \|\| x2 < 0 \|\| x2 >= screenwidth \|\| x3 < 0 \|\| x3 >= screenwidth
WiredHome	105:4f116006ba1f	1630	\|\| y1 < 0 \|\| y1 >= screenheight \|\| y2 < 0 \|\| y2 >= screenheight \|\| y3 < 0 \|\| y3 >= screenheight)
WiredHome	85:022bba13c5c4	1631	ret = bad_parameter;
WiredHome	19:3f82c1161fd2	1632	foreground(color);
WiredHome	20:6e2e4a8372eb	1633	ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
WiredHome	20:6e2e4a8372eb	1634	return ret;
WiredHome	19:3f82c1161fd2	1635	}
WiredHome	19:3f82c1161fd2	1636
WiredHome	44:207594dece70	1637
WiredHome	73:f22a18707b5e	1638	RetCode_t RA8875::filltriangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	1639	loc_t x3, loc_t y3, color_t color, fill_t fillit)
WiredHome	73:f22a18707b5e	1640	{
WiredHome	73:f22a18707b5e	1641	RetCode_t ret;
WiredHome	73:f22a18707b5e	1642
WiredHome	73:f22a18707b5e	1643	foreground(color);
WiredHome	73:f22a18707b5e	1644	ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
WiredHome	73:f22a18707b5e	1645	return ret;
WiredHome	73:f22a18707b5e	1646	}
WiredHome	73:f22a18707b5e	1647
WiredHome	73:f22a18707b5e	1648
WiredHome	73:f22a18707b5e	1649	RetCode_t RA8875::triangle(loc_t x1, loc_t y1 ,loc_t x2, loc_t y2,
WiredHome	73:f22a18707b5e	1650	loc_t x3, loc_t y3, fill_t fillit)
WiredHome	19:3f82c1161fd2	1651	{
WiredHome	19:3f82c1161fd2	1652	RetCode_t ret = noerror;
WiredHome	73:f22a18707b5e	1653
WiredHome	19:3f82c1161fd2	1654	PERFORMANCE_RESET;
WiredHome	19:3f82c1161fd2	1655	if (x1 == x2 && y1 == y2 && x1 == x3 && y1 == y3) {
WiredHome	19:3f82c1161fd2	1656	pixel(x1, y1);
WiredHome	19:3f82c1161fd2	1657	} else {
WiredHome	38:38d503b4fad6	1658	WriteCommandW(0x91, x1);
WiredHome	38:38d503b4fad6	1659	WriteCommandW(0x93, y1);
WiredHome	38:38d503b4fad6	1660	WriteCommandW(0x95, x2);
WiredHome	38:38d503b4fad6	1661	WriteCommandW(0x97, y2);
WiredHome	38:38d503b4fad6	1662	WriteCommandW(0xA9, x3);
WiredHome	38:38d503b4fad6	1663	WriteCommandW(0xAB, y3);
WiredHome	19:3f82c1161fd2	1664	unsigned char drawCmd = 0x01; // Triangle
WiredHome	19:3f82c1161fd2	1665	if (fillit == FILL)
WiredHome	19:3f82c1161fd2	1666	drawCmd \|= 0x20;
WiredHome	19:3f82c1161fd2	1667	WriteCommand(0x90, drawCmd);
WiredHome	19:3f82c1161fd2	1668	WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	1669	if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	1670	REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
WiredHome	131:5bd6ba2ee4a1	1671	return external_abort;
WiredHome	131:5bd6ba2ee4a1	1672	}
WiredHome	19:3f82c1161fd2	1673	}
WiredHome	19:3f82c1161fd2	1674	REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
WiredHome	19:3f82c1161fd2	1675	return ret;
WiredHome	19:3f82c1161fd2	1676	}
WiredHome	19:3f82c1161fd2	1677
WiredHome	83:7bad0068cca0	1678
WiredHome	83:7bad0068cca0	1679	RetCode_t RA8875::circle(point_t p, dim_t radius,
WiredHome	83:7bad0068cca0	1680	color_t color, fill_t fillit)
WiredHome	83:7bad0068cca0	1681	{
WiredHome	83:7bad0068cca0	1682	foreground(color);
WiredHome	83:7bad0068cca0	1683	return circle(p.x,p.y,radius,fillit);
WiredHome	83:7bad0068cca0	1684	}
WiredHome	83:7bad0068cca0	1685
WiredHome	83:7bad0068cca0	1686
WiredHome	83:7bad0068cca0	1687	RetCode_t RA8875::fillcircle(point_t p, dim_t radius,
WiredHome	83:7bad0068cca0	1688	color_t color, fill_t fillit)
WiredHome	83:7bad0068cca0	1689	{
WiredHome	83:7bad0068cca0	1690	foreground(color);
WiredHome	83:7bad0068cca0	1691	return circle(p.x,p.y,radius,fillit);
WiredHome	83:7bad0068cca0	1692	}
WiredHome	83:7bad0068cca0	1693
WiredHome	83:7bad0068cca0	1694
WiredHome	83:7bad0068cca0	1695	RetCode_t RA8875::circle(point_t p, dim_t radius, fill_t fillit)
WiredHome	83:7bad0068cca0	1696	{
WiredHome	83:7bad0068cca0	1697	return circle(p.x,p.y,radius,fillit);
WiredHome	83:7bad0068cca0	1698	}
WiredHome	83:7bad0068cca0	1699
WiredHome	83:7bad0068cca0	1700
WiredHome	73:f22a18707b5e	1701	RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius,
WiredHome	73:f22a18707b5e	1702	color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	1703	{
WiredHome	19:3f82c1161fd2	1704	foreground(color);
WiredHome	19:3f82c1161fd2	1705	return circle(x,y,radius,fillit);
WiredHome	19:3f82c1161fd2	1706	}
WiredHome	19:3f82c1161fd2	1707
WiredHome	44:207594dece70	1708
WiredHome	73:f22a18707b5e	1709	RetCode_t RA8875::fillcircle(loc_t x, loc_t y, dim_t radius,
WiredHome	73:f22a18707b5e	1710	color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	1711	{
WiredHome	19:3f82c1161fd2	1712	foreground(color);
WiredHome	19:3f82c1161fd2	1713	return circle(x,y,radius,fillit);
WiredHome	19:3f82c1161fd2	1714	}
WiredHome	19:3f82c1161fd2	1715
WiredHome	44:207594dece70	1716
WiredHome	37:f19b7e7449dc	1717	RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius, fill_t fillit)
WiredHome	19:3f82c1161fd2	1718	{
WiredHome	19:3f82c1161fd2	1719	RetCode_t ret = noerror;
WiredHome	73:f22a18707b5e	1720
WiredHome	19:3f82c1161fd2	1721	PERFORMANCE_RESET;
WiredHome	105:4f116006ba1f	1722	if (radius <= 0 \|\| (x - radius) < 0 \|\| (x + radius) > screenwidth
WiredHome	105:4f116006ba1f	1723	\|\| (y - radius) < 0 \|\| (y + radius) > screenheight) {
WiredHome	19:3f82c1161fd2	1724	ret = bad_parameter;
WiredHome	19:3f82c1161fd2	1725	} else if (radius == 1) {
WiredHome	19:3f82c1161fd2	1726	pixel(x,y);
WiredHome	19:3f82c1161fd2	1727	} else {
WiredHome	38:38d503b4fad6	1728	WriteCommandW(0x99, x);
WiredHome	38:38d503b4fad6	1729	WriteCommandW(0x9B, y);
WiredHome	19:3f82c1161fd2	1730	WriteCommand(0x9d, radius & 0xFF);
WiredHome	19:3f82c1161fd2	1731	unsigned char drawCmd = 0x00; // Circle
WiredHome	19:3f82c1161fd2	1732	if (fillit == FILL)
WiredHome	19:3f82c1161fd2	1733	drawCmd \|= 0x20;
WiredHome	19:3f82c1161fd2	1734	WriteCommand(0x90, drawCmd);
WiredHome	19:3f82c1161fd2	1735	WriteCommand(0x90, 0x40 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	1736	if (!_WaitWhileReg(0x90, 0x40)) {
WiredHome	131:5bd6ba2ee4a1	1737	REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
WiredHome	131:5bd6ba2ee4a1	1738	return external_abort;
WiredHome	131:5bd6ba2ee4a1	1739	}
WiredHome	19:3f82c1161fd2	1740	}
WiredHome	19:3f82c1161fd2	1741	REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
WiredHome	19:3f82c1161fd2	1742	return ret;
WiredHome	19:3f82c1161fd2	1743	}
WiredHome	19:3f82c1161fd2	1744
WiredHome	44:207594dece70	1745
WiredHome	37:f19b7e7449dc	1746	RetCode_t RA8875::ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	19:3f82c1161fd2	1747	{
WiredHome	19:3f82c1161fd2	1748	foreground(color);
WiredHome	25:9556a3a9b7cc	1749	return ellipse(x,y,radius1,radius2,fillit);
WiredHome	19:3f82c1161fd2	1750	}
WiredHome	19:3f82c1161fd2	1751
WiredHome	44:207594dece70	1752
WiredHome	37:f19b7e7449dc	1753	RetCode_t RA8875::fillellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome	25:9556a3a9b7cc	1754	{
WiredHome	25:9556a3a9b7cc	1755	foreground(color);
WiredHome	25:9556a3a9b7cc	1756	return ellipse(x,y,radius1,radius2,fillit);
WiredHome	25:9556a3a9b7cc	1757	}
WiredHome	44:207594dece70	1758
WiredHome	73:f22a18707b5e	1759
WiredHome	37:f19b7e7449dc	1760	RetCode_t RA8875::ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, fill_t fillit)
WiredHome	19:3f82c1161fd2	1761	{
WiredHome	19:3f82c1161fd2	1762	RetCode_t ret = noerror;
WiredHome	73:f22a18707b5e	1763
WiredHome	19:3f82c1161fd2	1764	PERFORMANCE_RESET;
WiredHome	105:4f116006ba1f	1765	if (radius1 <= 0 \|\| radius2 <= 0 \|\| (x - radius1) < 0 \|\| (x + radius1) > screenwidth
WiredHome	105:4f116006ba1f	1766	\|\| (y - radius2) < 0 \|\| (y + radius2) > screenheight) {
WiredHome	85:022bba13c5c4	1767	ret = bad_parameter;
WiredHome	25:9556a3a9b7cc	1768	} else if (radius1 == 1 && radius2 == 1) {
WiredHome	19:3f82c1161fd2	1769	pixel(x, y);
WiredHome	19:3f82c1161fd2	1770	} else {
WiredHome	38:38d503b4fad6	1771	WriteCommandW(0xA5, x);
WiredHome	38:38d503b4fad6	1772	WriteCommandW(0xA7, y);
WiredHome	38:38d503b4fad6	1773	WriteCommandW(0xA1, radius1);
WiredHome	38:38d503b4fad6	1774	WriteCommandW(0xA3, radius2);
WiredHome	19:3f82c1161fd2	1775	unsigned char drawCmd = 0x00; // Ellipse
WiredHome	19:3f82c1161fd2	1776	if (fillit == FILL)
WiredHome	19:3f82c1161fd2	1777	drawCmd \|= 0x40;
WiredHome	19:3f82c1161fd2	1778	WriteCommand(0xA0, drawCmd);
WiredHome	19:3f82c1161fd2	1779	WriteCommand(0xA0, 0x80 + drawCmd); // Start drawing.
WiredHome	131:5bd6ba2ee4a1	1780	if (!_WaitWhileReg(0xA0, 0x80)) {
WiredHome	131:5bd6ba2ee4a1	1781	REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
WiredHome	131:5bd6ba2ee4a1	1782	return external_abort;
WiredHome	131:5bd6ba2ee4a1	1783	}
WiredHome	19:3f82c1161fd2	1784	}
WiredHome	19:3f82c1161fd2	1785	REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
WiredHome	19:3f82c1161fd2	1786	return ret;
WiredHome	19:3f82c1161fd2	1787	}
WiredHome	19:3f82c1161fd2	1788
WiredHome	44:207594dece70	1789
WiredHome	68:ab08efabfc88	1790	RetCode_t RA8875::frequency(unsigned long Hz, unsigned long Hz2)
WiredHome	19:3f82c1161fd2	1791	{
WiredHome	66:468a11f05580	1792	spiwritefreq = Hz;
WiredHome	68:ab08efabfc88	1793	if (Hz2 != 0)
WiredHome	68:ab08efabfc88	1794	spireadfreq = Hz2;
WiredHome	68:ab08efabfc88	1795	else
WiredHome	68:ab08efabfc88	1796	spireadfreq = Hz/2;
WiredHome	68:ab08efabfc88	1797	_setWriteSpeed(true);
WiredHome	19:3f82c1161fd2	1798	// __ ___
WiredHome	19:3f82c1161fd2	1799	// Clock ___A Rising edge latched
WiredHome	19:3f82c1161fd2	1800	// ___ ____
WiredHome	19:3f82c1161fd2	1801	// Data ___X____
WiredHome	19:3f82c1161fd2	1802	spi.format(8, 3); // 8 bits and clock to data phase 0
WiredHome	19:3f82c1161fd2	1803	return noerror;
WiredHome	19:3f82c1161fd2	1804	}
WiredHome	19:3f82c1161fd2	1805
WiredHome	68:ab08efabfc88	1806	void RA8875::_setWriteSpeed(bool writeSpeed)
WiredHome	68:ab08efabfc88	1807	{
WiredHome	68:ab08efabfc88	1808	if (writeSpeed) {
WiredHome	68:ab08efabfc88	1809	spi.frequency(spiwritefreq);
WiredHome	68:ab08efabfc88	1810	spiWriteSpeed = true;
WiredHome	68:ab08efabfc88	1811	} else {
WiredHome	68:ab08efabfc88	1812	spi.frequency(spireadfreq);
WiredHome	68:ab08efabfc88	1813	spiWriteSpeed = false;
WiredHome	68:ab08efabfc88	1814	}
WiredHome	68:ab08efabfc88	1815	}
WiredHome	44:207594dece70	1816
WiredHome	131:5bd6ba2ee4a1	1817
WiredHome	131:5bd6ba2ee4a1	1818
WiredHome	131:5bd6ba2ee4a1	1819	RetCode_t RA8875::BlockMove(uint8_t dstLayer, uint8_t dstDataSelect, point_t dstPoint,
WiredHome	131:5bd6ba2ee4a1	1820	uint8_t srcLayer, uint8_t srcDataSelect, point_t srcPoint,
WiredHome	137:9e09f6081ef1	1821	dim_t bte_width, dim_t bte_height,
WiredHome	131:5bd6ba2ee4a1	1822	uint8_t bte_op_code, uint8_t bte_rop_code)
WiredHome	131:5bd6ba2ee4a1	1823	{
WiredHome	131:5bd6ba2ee4a1	1824	uint8_t cmd;
WiredHome	131:5bd6ba2ee4a1	1825
WiredHome	131:5bd6ba2ee4a1	1826	PERFORMANCE_RESET;
WiredHome	137:9e09f6081ef1	1827	///@todo range check and error return rather than to secretly fix
WiredHome	131:5bd6ba2ee4a1	1828	srcPoint.x &= 0x3FF; // prevent high bits from doing unexpected things
WiredHome	131:5bd6ba2ee4a1	1829	srcPoint.y &= 0x1FF;
WiredHome	131:5bd6ba2ee4a1	1830	dstPoint.x &= 0x3FF;
WiredHome	131:5bd6ba2ee4a1	1831	dstPoint.y &= 0x1FF;
WiredHome	131:5bd6ba2ee4a1	1832	WriteCommandW(0x54, srcPoint.x);
WiredHome	137:9e09f6081ef1	1833	WriteCommandW(0x56, ((dim_t)(srcLayer & 1) << 15) \| srcPoint.y);
WiredHome	131:5bd6ba2ee4a1	1834	WriteCommandW(0x58, dstPoint.x);
WiredHome	137:9e09f6081ef1	1835	WriteCommandW(0x5A, ((dim_t)(dstLayer & 1) << 15) \| dstPoint.y);
WiredHome	131:5bd6ba2ee4a1	1836	WriteCommandW(0x5C, bte_width);
WiredHome	131:5bd6ba2ee4a1	1837	WriteCommandW(0x5E, bte_height);
WiredHome	131:5bd6ba2ee4a1	1838	WriteCommand(0x51, ((bte_rop_code & 0x0F) << 4) \| (bte_op_code & 0x0F));
WiredHome	131:5bd6ba2ee4a1	1839	cmd = ((srcDataSelect & 1) << 6) \| ((dstDataSelect & 1) << 5);
WiredHome	131:5bd6ba2ee4a1	1840	WriteCommand(0x50, 0x80 \| cmd); // enable the BTE
WiredHome	131:5bd6ba2ee4a1	1841	if (!_WaitWhileBusy(0x40)) {
WiredHome	131:5bd6ba2ee4a1	1842	REGISTERPERFORMANCE(PRF_BLOCKMOVE);
WiredHome	131:5bd6ba2ee4a1	1843	return external_abort;
WiredHome	131:5bd6ba2ee4a1	1844	}
WiredHome	131:5bd6ba2ee4a1	1845	REGISTERPERFORMANCE(PRF_BLOCKMOVE);
WiredHome	131:5bd6ba2ee4a1	1846	return noerror;
WiredHome	131:5bd6ba2ee4a1	1847	}
WiredHome	131:5bd6ba2ee4a1	1848
WiredHome	131:5bd6ba2ee4a1	1849
WiredHome	19:3f82c1161fd2	1850	RetCode_t RA8875::Power(bool on)
WiredHome	19:3f82c1161fd2	1851	{
WiredHome	19:3f82c1161fd2	1852	WriteCommand(0x01, (on) ? 0x80 : 0x00);
WiredHome	19:3f82c1161fd2	1853	return noerror;
WiredHome	19:3f82c1161fd2	1854	}
WiredHome	19:3f82c1161fd2	1855
WiredHome	44:207594dece70	1856
WiredHome	131:5bd6ba2ee4a1	1857	RetCode_t RA8875::Backlight_u8(uint8_t brightness)
WiredHome	19:3f82c1161fd2	1858	{
WiredHome	19:3f82c1161fd2	1859	static bool is_enabled = false;
WiredHome	131:5bd6ba2ee4a1	1860
WiredHome	19:3f82c1161fd2	1861	if (brightness == 0) {
WiredHome	19:3f82c1161fd2	1862	WriteCommand(0x8a); // Disable the PWM
WiredHome	19:3f82c1161fd2	1863	WriteData(0x00);
WiredHome	19:3f82c1161fd2	1864	is_enabled = false;
WiredHome	19:3f82c1161fd2	1865	} else if (!is_enabled) {
WiredHome	19:3f82c1161fd2	1866	WriteCommand(0x8a); // Enable the PWM
WiredHome	19:3f82c1161fd2	1867	WriteData(0x80);
WiredHome	19:3f82c1161fd2	1868	WriteCommand(0x8a); // Not sure why this is needed, but following the pattern
WiredHome	19:3f82c1161fd2	1869	WriteData(0x81); // open PWM (SYS_CLK / 2 as best I can tell)
WiredHome	19:3f82c1161fd2	1870	is_enabled = true;
WiredHome	19:3f82c1161fd2	1871	}
WiredHome	19:3f82c1161fd2	1872	WriteCommand(0x8b, brightness); // Brightness parameter 0xff-0x00
WiredHome	19:3f82c1161fd2	1873	return noerror;
WiredHome	19:3f82c1161fd2	1874	}
WiredHome	19:3f82c1161fd2	1875
WiredHome	86:e86b355940f4	1876	uint8_t RA8875::GetBacklight_u8(void)
WiredHome	86:e86b355940f4	1877	{
WiredHome	86:e86b355940f4	1878	return ReadCommand(0x8b);
WiredHome	86:e86b355940f4	1879	}
WiredHome	44:207594dece70	1880
WiredHome	19:3f82c1161fd2	1881	RetCode_t RA8875::Backlight(float brightness)
WiredHome	19:3f82c1161fd2	1882	{
WiredHome	19:3f82c1161fd2	1883	unsigned char b;
WiredHome	73:f22a18707b5e	1884
WiredHome	29:422616aa04bd	1885	if (brightness >= 1.0)
WiredHome	19:3f82c1161fd2	1886	b = 255;
WiredHome	29:422616aa04bd	1887	else if (brightness <= 0.0)
WiredHome	19:3f82c1161fd2	1888	b = 0;
WiredHome	19:3f82c1161fd2	1889	else
WiredHome	19:3f82c1161fd2	1890	b = (unsigned char)(brightness * 255);
WiredHome	19:3f82c1161fd2	1891	return Backlight_u8(b);
WiredHome	19:3f82c1161fd2	1892	}
WiredHome	19:3f82c1161fd2	1893
WiredHome	86:e86b355940f4	1894	float RA8875::GetBacklight(void)
WiredHome	86:e86b355940f4	1895	{
WiredHome	86:e86b355940f4	1896	return (float)(GetBacklight_u8())/255;
WiredHome	86:e86b355940f4	1897	}
WiredHome	44:207594dece70	1898
WiredHome	98:ecebed9b80b2	1899	RetCode_t RA8875::SelectUserFont(const uint8_t * _font)
WiredHome	98:ecebed9b80b2	1900	{
WiredHome	98:ecebed9b80b2	1901	INFO("Cursor(%d,%d) %p", cursor_x, cursor_y, _font);
WiredHome	98:ecebed9b80b2	1902	INFO("Text C(%d,%d)", GetTextCursor_X(), GetTextCursor_Y());
WiredHome	98:ecebed9b80b2	1903	if (_font) {
WiredHome	98:ecebed9b80b2	1904	HexDump("Font Memory", _font, 16);
WiredHome	98:ecebed9b80b2	1905	extFontHeight = _font[6];
WiredHome	98:ecebed9b80b2	1906	uint32_t totalWidth = 0;
WiredHome	98:ecebed9b80b2	1907	uint16_t firstChar = _font[3] * 256 + _font[2];
WiredHome	98:ecebed9b80b2	1908	uint16_t lastChar = _font[5] * 256 + _font[4];
WiredHome	98:ecebed9b80b2	1909	uint16_t i;
WiredHome	98:ecebed9b80b2	1910
WiredHome	98:ecebed9b80b2	1911	for (i=firstChar; i<=lastChar; i++) {
WiredHome	98:ecebed9b80b2	1912	// 8 bytes of preamble to the first level lookup table
WiredHome	98:ecebed9b80b2	1913	uint16_t offsetToCharLookup = 8 + 4 * (i - firstChar); // 4-bytes: width(pixels), 16-bit offset from table start, 0
WiredHome	98:ecebed9b80b2	1914	totalWidth += _font[offsetToCharLookup];
WiredHome	98:ecebed9b80b2	1915	}
WiredHome	98:ecebed9b80b2	1916	extFontWidth = totalWidth / (lastChar - firstChar);
WiredHome	98:ecebed9b80b2	1917	INFO("Font Metrics: Avg W: %2d, H: %2d, First:%d, Last:%d", extFontWidth, extFontHeight, firstChar, lastChar);
WiredHome	98:ecebed9b80b2	1918	}
WiredHome	98:ecebed9b80b2	1919	SetTextCursor(GetTextCursor_X(), GetTextCursor_Y()); // soft-font cursor -> hw cursor
WiredHome	98:ecebed9b80b2	1920	font = _font;
WiredHome	98:ecebed9b80b2	1921	return GraphicsDisplay::SelectUserFont(_font);
WiredHome	98:ecebed9b80b2	1922	}
WiredHome	44:207594dece70	1923
WiredHome	19:3f82c1161fd2	1924	RetCode_t RA8875::background(color_t color)
WiredHome	19:3f82c1161fd2	1925	{
WiredHome	37:f19b7e7449dc	1926	GraphicsDisplay::background(color);
WiredHome	133:e36dcfc2d756	1927	return _writeColorTrio(0x60, color);
WiredHome	19:3f82c1161fd2	1928	}
WiredHome	19:3f82c1161fd2	1929
WiredHome	44:207594dece70	1930
WiredHome	19:3f82c1161fd2	1931	RetCode_t RA8875::background(unsigned char r, unsigned char g, unsigned char b)
WiredHome	19:3f82c1161fd2	1932	{
WiredHome	37:f19b7e7449dc	1933	background(RGB(r,g,b));
WiredHome	19:3f82c1161fd2	1934	return noerror;
WiredHome	19:3f82c1161fd2	1935	}
WiredHome	19:3f82c1161fd2	1936
WiredHome	44:207594dece70	1937
WiredHome	19:3f82c1161fd2	1938	RetCode_t RA8875::foreground(color_t color)
WiredHome	19:3f82c1161fd2	1939	{
WiredHome	37:f19b7e7449dc	1940	GraphicsDisplay::foreground(color);
WiredHome	133:e36dcfc2d756	1941	return _writeColorTrio(0x63, color);
WiredHome	19:3f82c1161fd2	1942	}
WiredHome	19:3f82c1161fd2	1943
WiredHome	44:207594dece70	1944
WiredHome	37:f19b7e7449dc	1945	RetCode_t RA8875::foreground(unsigned char r, unsigned char g, unsigned char b)
WiredHome	19:3f82c1161fd2	1946	{
WiredHome	37:f19b7e7449dc	1947	foreground(RGB(r,g,b));
WiredHome	19:3f82c1161fd2	1948	return noerror;
WiredHome	19:3f82c1161fd2	1949	}
WiredHome	19:3f82c1161fd2	1950
WiredHome	44:207594dece70	1951
WiredHome	37:f19b7e7449dc	1952	color_t RA8875::GetForeColor(void)
WiredHome	19:3f82c1161fd2	1953	{
WiredHome	133:e36dcfc2d756	1954	return _readColorTrio(0x63);
WiredHome	19:3f82c1161fd2	1955	}
WiredHome	19:3f82c1161fd2	1956
WiredHome	44:207594dece70	1957
WiredHome	19:3f82c1161fd2	1958	color_t RA8875::DOSColor(int i)
WiredHome	73:f22a18707b5e	1959	{
WiredHome	73:f22a18707b5e	1960	const color_t colors[16] = {
WiredHome	19:3f82c1161fd2	1961	Black, Blue, Green, Cyan,
WiredHome	19:3f82c1161fd2	1962	Red, Magenta, Brown, Gray,
WiredHome	19:3f82c1161fd2	1963	Charcoal, BrightBlue, BrightGreen, BrightCyan,
WiredHome	19:3f82c1161fd2	1964	Orange, Pink, Yellow, White
WiredHome	73:f22a18707b5e	1965	};
WiredHome	85:022bba13c5c4	1966	if (i >= 0 && i < 16)
WiredHome	19:3f82c1161fd2	1967	return colors[i];
WiredHome	19:3f82c1161fd2	1968	else
WiredHome	19:3f82c1161fd2	1969	return 0;
WiredHome	73:f22a18707b5e	1970	}
WiredHome	19:3f82c1161fd2	1971
WiredHome	44:207594dece70	1972
WiredHome	73:f22a18707b5e	1973	const char * RA8875::DOSColorNames(int i)
WiredHome	73:f22a18707b5e	1974	{
WiredHome	73:f22a18707b5e	1975	const char * names[16] = {
WiredHome	19:3f82c1161fd2	1976	"Black", "Blue", "Green", "Cyan",
WiredHome	19:3f82c1161fd2	1977	"Red", "Magenta", "Brown", "Gray",
WiredHome	19:3f82c1161fd2	1978	"Charcoal", "BrightBlue", "BrightGreen", "BrightCyan",
WiredHome	19:3f82c1161fd2	1979	"Orange", "Pink", "Yellow", "White"
WiredHome	73:f22a18707b5e	1980	};
WiredHome	85:022bba13c5c4	1981	if (i >= 0 && i < 16)
WiredHome	19:3f82c1161fd2	1982	return names[i];
WiredHome	19:3f82c1161fd2	1983	else
WiredHome	19:3f82c1161fd2	1984	return NULL;
WiredHome	73:f22a18707b5e	1985	}
WiredHome	19:3f82c1161fd2	1986
WiredHome	19:3f82c1161fd2	1987
WiredHome	19:3f82c1161fd2	1988	///////////////////////////////////////////////////////////////
WiredHome	19:3f82c1161fd2	1989	// Private functions
WiredHome	19:3f82c1161fd2	1990
WiredHome	79:544eb4964795	1991	unsigned char RA8875::_spiwrite(unsigned char data)
WiredHome	19:3f82c1161fd2	1992	{
WiredHome	19:3f82c1161fd2	1993	unsigned char retval;
WiredHome	73:f22a18707b5e	1994
WiredHome	68:ab08efabfc88	1995	if (!spiWriteSpeed)
WiredHome	68:ab08efabfc88	1996	_setWriteSpeed(true);
WiredHome	19:3f82c1161fd2	1997	retval = spi.write(data);
WiredHome	19:3f82c1161fd2	1998	return retval;
WiredHome	19:3f82c1161fd2	1999	}
WiredHome	19:3f82c1161fd2	2000
WiredHome	44:207594dece70	2001
WiredHome	79:544eb4964795	2002	unsigned char RA8875::_spiread(void)
WiredHome	19:3f82c1161fd2	2003	{
WiredHome	19:3f82c1161fd2	2004	unsigned char retval;
WiredHome	19:3f82c1161fd2	2005	unsigned char data = 0;
WiredHome	73:f22a18707b5e	2006
WiredHome	68:ab08efabfc88	2007	if (spiWriteSpeed)
WiredHome	68:ab08efabfc88	2008	_setWriteSpeed(false);
WiredHome	19:3f82c1161fd2	2009	retval = spi.write(data);
WiredHome	19:3f82c1161fd2	2010	return retval;
WiredHome	19:3f82c1161fd2	2011	}
WiredHome	19:3f82c1161fd2	2012
WiredHome	44:207594dece70	2013
WiredHome	79:544eb4964795	2014	RetCode_t RA8875::_select(bool chipsel)
WiredHome	19:3f82c1161fd2	2015	{
WiredHome	19:3f82c1161fd2	2016	cs = (chipsel == true) ? 0 : 1;
WiredHome	19:3f82c1161fd2	2017	return noerror;
WiredHome	19:3f82c1161fd2	2018	}
WiredHome	19:3f82c1161fd2	2019
WiredHome	44:207594dece70	2020
WiredHome	72:ecffe56af969	2021	RetCode_t RA8875::PrintScreen(uint16_t layer, loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP)
WiredHome	72:ecffe56af969	2022	{
WiredHome	74:686faa218914	2023	(void)layer;
WiredHome	96:40b74dd3695b	2024
WiredHome	96:40b74dd3695b	2025	// AttachPrintHandler(this, RA8875::_printCallback);
WiredHome	96:40b74dd3695b	2026	// return PrintScreen(x,y,w,h);
WiredHome	74:686faa218914	2027	return PrintScreen(x, y, w, h, Name_BMP);
WiredHome	72:ecffe56af969	2028	}
WiredHome	72:ecffe56af969	2029
WiredHome	96:40b74dd3695b	2030	RetCode_t RA8875::_printCallback(RA8875::filecmd_t cmd, uint8_t * buffer, uint16_t size)
WiredHome	96:40b74dd3695b	2031	{
WiredHome	96:40b74dd3695b	2032	HexDump("CB", buffer, size);
WiredHome	96:40b74dd3695b	2033	switch(cmd) {
WiredHome	96:40b74dd3695b	2034	case RA8875::OPEN:
WiredHome	96:40b74dd3695b	2035	//pc.printf("About to write %lu bytes\r\n", (uint32_t )buffer);
WiredHome	96:40b74dd3695b	2036	_printFH = fopen("file.bmp", "w+b");
WiredHome	96:40b74dd3695b	2037	if (_printFH == 0)
WiredHome	96:40b74dd3695b	2038	return file_not_found;
WiredHome	96:40b74dd3695b	2039	break;
WiredHome	96:40b74dd3695b	2040	case RA8875::WRITE:
WiredHome	96:40b74dd3695b	2041	//pc.printf(" Write %4u bytes\r\n", size);
WiredHome	96:40b74dd3695b	2042	fwrite(buffer, 1, size, _printFH);
WiredHome	96:40b74dd3695b	2043	break;
WiredHome	96:40b74dd3695b	2044	case RA8875::CLOSE:
WiredHome	96:40b74dd3695b	2045	//pc.printf(" close\r\n");
WiredHome	96:40b74dd3695b	2046	fclose(_printFH);
WiredHome	96:40b74dd3695b	2047	_printFH = 0;
WiredHome	96:40b74dd3695b	2048	break;
WiredHome	96:40b74dd3695b	2049	default:
WiredHome	96:40b74dd3695b	2050	//pc.printf("Unexpected callback %d\r\n", cmd);
WiredHome	96:40b74dd3695b	2051	return file_not_found;
WiredHome	96:40b74dd3695b	2052	//break;
WiredHome	96:40b74dd3695b	2053	}
WiredHome	96:40b74dd3695b	2054	return noerror;
WiredHome	96:40b74dd3695b	2055	}
WiredHome	96:40b74dd3695b	2056
WiredHome	96:40b74dd3695b	2057	RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h)
WiredHome	96:40b74dd3695b	2058	{
WiredHome	96:40b74dd3695b	2059	BITMAPFILEHEADER BMP_Header;
WiredHome	96:40b74dd3695b	2060	BITMAPINFOHEADER BMP_Info;
WiredHome	96:40b74dd3695b	2061	uint8_t * lineBuffer = NULL;
WiredHome	96:40b74dd3695b	2062	color_t * pixelBuffer = NULL;
WiredHome	96:40b74dd3695b	2063	color_t * pixelBuffer2 = NULL;
WiredHome	96:40b74dd3695b	2064
WiredHome	98:ecebed9b80b2	2065	INFO("(%d,%d) - (%d,%d)", x,y,w,h);
WiredHome	105:4f116006ba1f	2066	if (x >= 0 && x < screenwidth
WiredHome	105:4f116006ba1f	2067	&& y >= 0 && y < screenheight
WiredHome	105:4f116006ba1f	2068	&& w > 0 && x + w <= screenwidth
WiredHome	105:4f116006ba1f	2069	&& h > 0 && y + h <= screenheight) {
WiredHome	96:40b74dd3695b	2070
WiredHome	96:40b74dd3695b	2071	BMP_Header.bfType = BF_TYPE;
WiredHome	96:40b74dd3695b	2072	BMP_Header.bfSize = (w * h * sizeof(RGBQUAD)) + sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome	96:40b74dd3695b	2073	BMP_Header.bfReserved1 = 0;
WiredHome	96:40b74dd3695b	2074	BMP_Header.bfReserved2 = 0;
WiredHome	96:40b74dd3695b	2075	BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome	96:40b74dd3695b	2076
WiredHome	96:40b74dd3695b	2077	BMP_Info.biSize = sizeof(BMP_Info);
WiredHome	96:40b74dd3695b	2078	BMP_Info.biWidth = w;
WiredHome	96:40b74dd3695b	2079	BMP_Info.biHeight = h;
WiredHome	96:40b74dd3695b	2080	BMP_Info.biPlanes = 1;
WiredHome	96:40b74dd3695b	2081	BMP_Info.biBitCount = 24;
WiredHome	96:40b74dd3695b	2082	BMP_Info.biCompression = BI_RGB;
WiredHome	96:40b74dd3695b	2083	BMP_Info.biSizeImage = 0;
WiredHome	96:40b74dd3695b	2084	BMP_Info.biXPelsPerMeter = 0;
WiredHome	96:40b74dd3695b	2085	BMP_Info.biYPelsPerMeter = 0;
WiredHome	96:40b74dd3695b	2086	BMP_Info.biClrUsed = 0;
WiredHome	96:40b74dd3695b	2087	BMP_Info.biClrImportant = 0;
WiredHome	96:40b74dd3695b	2088
WiredHome	96:40b74dd3695b	2089	// Allocate the memory we need to proceed
WiredHome	96:40b74dd3695b	2090	int lineBufSize = ((24 * w + 7)/8);
WiredHome	145:5eb2492acdda	2091	lineBuffer = (uint8_t *)swMalloc(lineBufSize);
WiredHome	96:40b74dd3695b	2092	if (lineBuffer == NULL) {
WiredHome	96:40b74dd3695b	2093	ERR("Not enough RAM for PrintScreen lineBuffer");
WiredHome	96:40b74dd3695b	2094	return(not_enough_ram);
WiredHome	96:40b74dd3695b	2095	}
WiredHome	96:40b74dd3695b	2096
WiredHome	96:40b74dd3695b	2097	#define DOUBLEBUF /* one larger buffer instead of two */
WiredHome	96:40b74dd3695b	2098
WiredHome	96:40b74dd3695b	2099	#ifdef DOUBLEBUF
WiredHome	96:40b74dd3695b	2100	// In the "#else", pixelBuffer2 malloc returns a value,
WiredHome	96:40b74dd3695b	2101	// but is actually causing a failure later.
WiredHome	96:40b74dd3695b	2102	// This test helps determine if it is truly out of memory,
WiredHome	96:40b74dd3695b	2103	// or if malloc is broken.
WiredHome	145:5eb2492acdda	2104	pixelBuffer = (color_t )swMalloc(2 w * sizeof(color_t));
WiredHome	96:40b74dd3695b	2105	pixelBuffer2 = pixelBuffer + (w * sizeof(color_t));
WiredHome	96:40b74dd3695b	2106	#else
WiredHome	145:5eb2492acdda	2107	pixelBuffer = (color_t )swMalloc(w sizeof(color_t));
WiredHome	145:5eb2492acdda	2108	pixelBuffer2 = (color_t )swMalloc(w sizeof(color_t));
WiredHome	96:40b74dd3695b	2109	#endif
WiredHome	96:40b74dd3695b	2110	if (pixelBuffer == NULL \|\| pixelBuffer2 == NULL) {
WiredHome	96:40b74dd3695b	2111	ERR("Not enough RAM for pixelBuffer");
WiredHome	96:40b74dd3695b	2112	#ifndef DOUBLEBUF
WiredHome	96:40b74dd3695b	2113	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	2114	swFree(pixelBuffer2);
WiredHome	96:40b74dd3695b	2115	#endif
WiredHome	96:40b74dd3695b	2116	if (pixelBuffer)
WiredHome	145:5eb2492acdda	2117	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	2118	swFree(lineBuffer);
WiredHome	96:40b74dd3695b	2119	return(not_enough_ram);
WiredHome	96:40b74dd3695b	2120	}
WiredHome	96:40b74dd3695b	2121
WiredHome	96:40b74dd3695b	2122	// Get the file primed...
WiredHome	96:40b74dd3695b	2123	privateCallback(OPEN, (uint8_t *)&BMP_Header.bfSize, 4);
WiredHome	96:40b74dd3695b	2124
WiredHome	96:40b74dd3695b	2125	// Be optimistic - don't check for errors.
WiredHome	96:40b74dd3695b	2126	HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome	96:40b74dd3695b	2127	//fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome	96:40b74dd3695b	2128	privateCallback(WRITE, (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome	96:40b74dd3695b	2129
WiredHome	96:40b74dd3695b	2130	HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome	96:40b74dd3695b	2131	//fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome	96:40b74dd3695b	2132	privateCallback(WRITE, (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome	96:40b74dd3695b	2133
WiredHome	96:40b74dd3695b	2134	//color_t transparency = GetBackgroundTransparencyColor();
WiredHome	96:40b74dd3695b	2135	LayerMode_T ltpr0 = GetLayerMode();
WiredHome	96:40b74dd3695b	2136
WiredHome	96:40b74dd3695b	2137	uint16_t prevLayer = GetDrawingLayer();
WiredHome	96:40b74dd3695b	2138	// If only one of the layers is visible, select that layer
WiredHome	96:40b74dd3695b	2139	switch(ltpr0) {
WiredHome	96:40b74dd3695b	2140	case ShowLayer0:
WiredHome	96:40b74dd3695b	2141	SelectDrawingLayer(0);
WiredHome	96:40b74dd3695b	2142	break;
WiredHome	96:40b74dd3695b	2143	case ShowLayer1:
WiredHome	96:40b74dd3695b	2144	SelectDrawingLayer(1);
WiredHome	96:40b74dd3695b	2145	break;
WiredHome	96:40b74dd3695b	2146	default:
WiredHome	96:40b74dd3695b	2147	break;
WiredHome	96:40b74dd3695b	2148	}
WiredHome	96:40b74dd3695b	2149
WiredHome	96:40b74dd3695b	2150	// Read the display from the last line toward the top
WiredHome	96:40b74dd3695b	2151	// so we can write the file in one pass.
WiredHome	96:40b74dd3695b	2152	for (int j = h - 1; j >= 0; j--) {
WiredHome	149:c62c4b2d6a15	2153	if (idle_callback) {
WiredHome	149:c62c4b2d6a15	2154	(idle_callback)(progress, (h - 1 - j) 100 / (h - 1));
WiredHome	149:c62c4b2d6a15	2155	}
WiredHome	149:c62c4b2d6a15	2156
WiredHome	96:40b74dd3695b	2157	if (ltpr0 >= 2) // Need to combine the layers...
WiredHome	96:40b74dd3695b	2158	SelectDrawingLayer(0); // so read layer 0 first
WiredHome	96:40b74dd3695b	2159	// Read one line of pixels to a local buffer
WiredHome	96:40b74dd3695b	2160	if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome	96:40b74dd3695b	2161	ERR("getPixelStream error, and no recovery handler...");
WiredHome	96:40b74dd3695b	2162	}
WiredHome	96:40b74dd3695b	2163	if (ltpr0 >= 2) { // Need to combine the layers...
WiredHome	96:40b74dd3695b	2164	SelectDrawingLayer(1); // so read layer 1 next
WiredHome	96:40b74dd3695b	2165	if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
WiredHome	96:40b74dd3695b	2166	ERR("getPixelStream error, and no recovery handler...");
WiredHome	96:40b74dd3695b	2167	}
WiredHome	96:40b74dd3695b	2168	}
WiredHome	96:40b74dd3695b	2169	INFO("1st Color: %04X", pixelBuffer[0]);
WiredHome	96:40b74dd3695b	2170	HexDump("Raster", (uint8_t *)pixelBuffer, w);
WiredHome	96:40b74dd3695b	2171	// Convert the local buffer to RGBQUAD format
WiredHome	96:40b74dd3695b	2172	int lb = 0;
WiredHome	96:40b74dd3695b	2173	for (int i=0; i<w; i++) {
WiredHome	96:40b74dd3695b	2174	RGBQUAD q0 = RGB16ToRGBQuad(pixelBuffer[x+i]); // Scale to 24-bits
WiredHome	96:40b74dd3695b	2175	RGBQUAD q1 = RGB16ToRGBQuad(pixelBuffer2[x+i]); // Scale to 24-bits
WiredHome	96:40b74dd3695b	2176	switch (ltpr0) {
WiredHome	96:40b74dd3695b	2177	case 0:
WiredHome	96:40b74dd3695b	2178	case 1:
WiredHome	96:40b74dd3695b	2179	case 2: // lighten-overlay (@TODO Not supported yet)
WiredHome	96:40b74dd3695b	2180	case 6: // Floating Windows (@TODO not sure how to support)
WiredHome	96:40b74dd3695b	2181	default: // Reserved...
WiredHome	96:40b74dd3695b	2182	lineBuffer[lb++] = q0.rgbBlue;
WiredHome	96:40b74dd3695b	2183	lineBuffer[lb++] = q0.rgbGreen;
WiredHome	96:40b74dd3695b	2184	lineBuffer[lb++] = q0.rgbRed;
WiredHome	96:40b74dd3695b	2185	break;
WiredHome	96:40b74dd3695b	2186	case 3: // transparent mode (@TODO Read the background color register for transparent)
WiredHome	96:40b74dd3695b	2187	case 4: // boolean or
WiredHome	96:40b74dd3695b	2188	lineBuffer[lb++] = q0.rgbBlue \| q1.rgbBlue;
WiredHome	96:40b74dd3695b	2189	lineBuffer[lb++] = q0.rgbGreen \| q1.rgbGreen;
WiredHome	96:40b74dd3695b	2190	lineBuffer[lb++] = q0.rgbRed \| q1.rgbRed;
WiredHome	96:40b74dd3695b	2191	break;
WiredHome	96:40b74dd3695b	2192	case 5: // boolean AND
WiredHome	96:40b74dd3695b	2193	lineBuffer[lb++] = q0.rgbBlue & q1.rgbBlue;
WiredHome	96:40b74dd3695b	2194	lineBuffer[lb++] = q0.rgbGreen & q1.rgbGreen;
WiredHome	96:40b74dd3695b	2195	lineBuffer[lb++] = q0.rgbRed & q1.rgbRed;
WiredHome	96:40b74dd3695b	2196	break;
WiredHome	96:40b74dd3695b	2197	}
WiredHome	96:40b74dd3695b	2198	}
WiredHome	96:40b74dd3695b	2199	if (j == h - 1) {
WiredHome	96:40b74dd3695b	2200	HexDump("Line", lineBuffer, lineBufSize);
WiredHome	96:40b74dd3695b	2201	}
WiredHome	96:40b74dd3695b	2202	// Write to disk
WiredHome	96:40b74dd3695b	2203	//fwrite(lineBuffer, sizeof(char), lb, Image);
WiredHome	96:40b74dd3695b	2204	privateCallback(WRITE, (uint8_t *)lineBuffer, lb);
WiredHome	96:40b74dd3695b	2205	}
WiredHome	96:40b74dd3695b	2206	SelectDrawingLayer(prevLayer);
WiredHome	96:40b74dd3695b	2207	//fclose(Image);
WiredHome	96:40b74dd3695b	2208	privateCallback(CLOSE, NULL, 0);
WiredHome	96:40b74dd3695b	2209
WiredHome	96:40b74dd3695b	2210	#ifndef DOUBLEBUF
WiredHome	96:40b74dd3695b	2211	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	2212	swFree(pixelBuffer2);
WiredHome	96:40b74dd3695b	2213	#endif
WiredHome	96:40b74dd3695b	2214	if (pixelBuffer)
WiredHome	145:5eb2492acdda	2215	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	2216	swFree(lineBuffer);
WiredHome	96:40b74dd3695b	2217	INFO("Image closed");
WiredHome	96:40b74dd3695b	2218	return noerror;
WiredHome	96:40b74dd3695b	2219	} else {
WiredHome	96:40b74dd3695b	2220	return bad_parameter;
WiredHome	96:40b74dd3695b	2221	}
WiredHome	96:40b74dd3695b	2222	}
WiredHome	79:544eb4964795	2223
WiredHome	72:ecffe56af969	2224	RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP)
WiredHome	72:ecffe56af969	2225	{
WiredHome	72:ecffe56af969	2226	BITMAPFILEHEADER BMP_Header;
WiredHome	72:ecffe56af969	2227	BITMAPINFOHEADER BMP_Info;
WiredHome	86:e86b355940f4	2228	uint8_t * lineBuffer = NULL;
WiredHome	86:e86b355940f4	2229	color_t * pixelBuffer = NULL;
WiredHome	86:e86b355940f4	2230	color_t * pixelBuffer2 = NULL;
WiredHome	86:e86b355940f4	2231
WiredHome	72:ecffe56af969	2232	INFO("(%d,%d) - (%d,%d) %s", x,y,w,h,Name_BMP);
WiredHome	105:4f116006ba1f	2233	if (x >= 0 && x < screenwidth
WiredHome	105:4f116006ba1f	2234	&& y >= 0 && y < screenheight
WiredHome	105:4f116006ba1f	2235	&& w > 0 && x + w <= screenwidth
WiredHome	105:4f116006ba1f	2236	&& h > 0 && y + h <= screenheight) {
WiredHome	72:ecffe56af969	2237
WiredHome	72:ecffe56af969	2238	BMP_Header.bfType = BF_TYPE;
WiredHome	72:ecffe56af969	2239	BMP_Header.bfSize = (w * h * sizeof(RGBQUAD)) + sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome	72:ecffe56af969	2240	BMP_Header.bfReserved1 = 0;
WiredHome	72:ecffe56af969	2241	BMP_Header.bfReserved2 = 0;
WiredHome	72:ecffe56af969	2242	BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome	73:f22a18707b5e	2243
WiredHome	72:ecffe56af969	2244	BMP_Info.biSize = sizeof(BMP_Info);
WiredHome	72:ecffe56af969	2245	BMP_Info.biWidth = w;
WiredHome	72:ecffe56af969	2246	BMP_Info.biHeight = h;
WiredHome	72:ecffe56af969	2247	BMP_Info.biPlanes = 1;
WiredHome	72:ecffe56af969	2248	BMP_Info.biBitCount = 24;
WiredHome	72:ecffe56af969	2249	BMP_Info.biCompression = BI_RGB;
WiredHome	72:ecffe56af969	2250	BMP_Info.biSizeImage = 0;
WiredHome	72:ecffe56af969	2251	BMP_Info.biXPelsPerMeter = 0;
WiredHome	72:ecffe56af969	2252	BMP_Info.biYPelsPerMeter = 0;
WiredHome	72:ecffe56af969	2253	BMP_Info.biClrUsed = 0;
WiredHome	72:ecffe56af969	2254	BMP_Info.biClrImportant = 0;
WiredHome	72:ecffe56af969	2255
WiredHome	86:e86b355940f4	2256	// Allocate the memory we need to proceed
WiredHome	86:e86b355940f4	2257	int lineBufSize = ((24 * w + 7)/8);
WiredHome	145:5eb2492acdda	2258	lineBuffer = (uint8_t *)swMalloc(lineBufSize);
WiredHome	86:e86b355940f4	2259	if (lineBuffer == NULL) {
WiredHome	86:e86b355940f4	2260	ERR("Not enough RAM for PrintScreen lineBuffer");
WiredHome	86:e86b355940f4	2261	return(not_enough_ram);
WiredHome	86:e86b355940f4	2262	}
WiredHome	86:e86b355940f4	2263
WiredHome	86:e86b355940f4	2264	#define DOUBLEBUF /* one larger buffer instead of two */
WiredHome	86:e86b355940f4	2265
WiredHome	86:e86b355940f4	2266	#ifdef DOUBLEBUF
WiredHome	86:e86b355940f4	2267	// In the "#else", pixelBuffer2 malloc returns a value,
WiredHome	86:e86b355940f4	2268	// but is actually causing a failure later.
WiredHome	86:e86b355940f4	2269	// This test helps determine if it is truly out of memory,
WiredHome	86:e86b355940f4	2270	// or if malloc is broken.
WiredHome	145:5eb2492acdda	2271	pixelBuffer = (color_t )swMalloc(2 w * sizeof(color_t));
WiredHome	86:e86b355940f4	2272	pixelBuffer2 = pixelBuffer + (w * sizeof(color_t));
WiredHome	86:e86b355940f4	2273	#else
WiredHome	145:5eb2492acdda	2274	pixelBuffer = (color_t )swMalloc(w sizeof(color_t));
WiredHome	145:5eb2492acdda	2275	pixelBuffer2 = (color_t )swMalloc(w sizeof(color_t));
WiredHome	86:e86b355940f4	2276	#endif
WiredHome	86:e86b355940f4	2277	if (pixelBuffer == NULL \|\| pixelBuffer2 == NULL) {
WiredHome	86:e86b355940f4	2278	ERR("Not enough RAM for pixelBuffer");
WiredHome	86:e86b355940f4	2279	#ifndef DOUBLEBUF
WiredHome	86:e86b355940f4	2280	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	2281	swFree(pixelBuffer2);
WiredHome	86:e86b355940f4	2282	#endif
WiredHome	86:e86b355940f4	2283	if (pixelBuffer)
WiredHome	145:5eb2492acdda	2284	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	2285	swFree(lineBuffer);
WiredHome	86:e86b355940f4	2286	return(not_enough_ram);
WiredHome	86:e86b355940f4	2287	}
WiredHome	86:e86b355940f4	2288
WiredHome	72:ecffe56af969	2289	FILE *Image = fopen(Name_BMP, "wb");
WiredHome	72:ecffe56af969	2290	if (!Image) {
WiredHome	86:e86b355940f4	2291	ERR("Can't open file for write");
WiredHome	86:e86b355940f4	2292	#ifndef DOUBLEBUF
WiredHome	86:e86b355940f4	2293	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	2294	swFree(pixelBuffer2);
WiredHome	86:e86b355940f4	2295	#endif
WiredHome	86:e86b355940f4	2296	if (pixelBuffer)
WiredHome	145:5eb2492acdda	2297	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	2298	swFree(lineBuffer);
WiredHome	72:ecffe56af969	2299	return(file_not_found);
WiredHome	72:ecffe56af969	2300	}
WiredHome	72:ecffe56af969	2301
WiredHome	72:ecffe56af969	2302	// Be optimistic - don't check for errors.
WiredHome	93:6fbc516de05e	2303	HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome	95:ef538bd687c0	2304	fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome	73:f22a18707b5e	2305
WiredHome	93:6fbc516de05e	2306	HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome	95:ef538bd687c0	2307	fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome	73:f22a18707b5e	2308
WiredHome	95:ef538bd687c0	2309	//color_t transparency = GetBackgroundTransparencyColor();
WiredHome	95:ef538bd687c0	2310	LayerMode_T ltpr0 = GetLayerMode();
WiredHome	73:f22a18707b5e	2311
WiredHome	73:f22a18707b5e	2312	uint16_t prevLayer = GetDrawingLayer();
WiredHome	73:f22a18707b5e	2313	// If only one of the layers is visible, select that layer
WiredHome	73:f22a18707b5e	2314	switch(ltpr0) {
WiredHome	95:ef538bd687c0	2315	case ShowLayer0:
WiredHome	73:f22a18707b5e	2316	SelectDrawingLayer(0);
WiredHome	73:f22a18707b5e	2317	break;
WiredHome	95:ef538bd687c0	2318	case ShowLayer1:
WiredHome	73:f22a18707b5e	2319	SelectDrawingLayer(1);
WiredHome	73:f22a18707b5e	2320	break;
WiredHome	73:f22a18707b5e	2321	default:
WiredHome	73:f22a18707b5e	2322	break;
WiredHome	73:f22a18707b5e	2323	}
WiredHome	73:f22a18707b5e	2324
WiredHome	72:ecffe56af969	2325	// Read the display from the last line toward the top
WiredHome	72:ecffe56af969	2326	// so we can write the file in one pass.
WiredHome	72:ecffe56af969	2327	for (int j = h - 1; j >= 0; j--) {
WiredHome	149:c62c4b2d6a15	2328	if (idle_callback) {
WiredHome	149:c62c4b2d6a15	2329	(idle_callback)(progress, (h - 1 - j) 100 / (h - 1));
WiredHome	149:c62c4b2d6a15	2330	}
WiredHome	149:c62c4b2d6a15	2331
WiredHome	73:f22a18707b5e	2332	if (ltpr0 >= 2) // Need to combine the layers...
WiredHome	73:f22a18707b5e	2333	SelectDrawingLayer(0); // so read layer 0 first
WiredHome	72:ecffe56af969	2334	// Read one line of pixels to a local buffer
WiredHome	72:ecffe56af969	2335	if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome	72:ecffe56af969	2336	ERR("getPixelStream error, and no recovery handler...");
WiredHome	72:ecffe56af969	2337	}
WiredHome	73:f22a18707b5e	2338	if (ltpr0 >= 2) { // Need to combine the layers...
WiredHome	86:e86b355940f4	2339	SelectDrawingLayer(1); // so read layer 1 next
WiredHome	73:f22a18707b5e	2340	if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
WiredHome	73:f22a18707b5e	2341	ERR("getPixelStream error, and no recovery handler...");
WiredHome	73:f22a18707b5e	2342	}
WiredHome	73:f22a18707b5e	2343	}
WiredHome	93:6fbc516de05e	2344	INFO("1st Color: %04X", pixelBuffer[0]);
WiredHome	93:6fbc516de05e	2345	HexDump("Raster", (uint8_t *)pixelBuffer, w);
WiredHome	72:ecffe56af969	2346	// Convert the local buffer to RGBQUAD format
WiredHome	72:ecffe56af969	2347	int lb = 0;
WiredHome	72:ecffe56af969	2348	for (int i=0; i<w; i++) {
WiredHome	73:f22a18707b5e	2349	RGBQUAD q0 = RGB16ToRGBQuad(pixelBuffer[x+i]); // Scale to 24-bits
WiredHome	73:f22a18707b5e	2350	RGBQUAD q1 = RGB16ToRGBQuad(pixelBuffer2[x+i]); // Scale to 24-bits
WiredHome	73:f22a18707b5e	2351	switch (ltpr0) {
WiredHome	73:f22a18707b5e	2352	case 0:
WiredHome	73:f22a18707b5e	2353	case 1:
WiredHome	73:f22a18707b5e	2354	case 2: // lighten-overlay (@TODO Not supported yet)
WiredHome	73:f22a18707b5e	2355	case 6: // Floating Windows (@TODO not sure how to support)
WiredHome	73:f22a18707b5e	2356	default: // Reserved...
WiredHome	73:f22a18707b5e	2357	lineBuffer[lb++] = q0.rgbBlue;
WiredHome	73:f22a18707b5e	2358	lineBuffer[lb++] = q0.rgbGreen;
WiredHome	73:f22a18707b5e	2359	lineBuffer[lb++] = q0.rgbRed;
WiredHome	73:f22a18707b5e	2360	break;
WiredHome	73:f22a18707b5e	2361	case 3: // transparent mode (@TODO Read the background color register for transparent)
WiredHome	73:f22a18707b5e	2362	case 4: // boolean or
WiredHome	73:f22a18707b5e	2363	lineBuffer[lb++] = q0.rgbBlue \| q1.rgbBlue;
WiredHome	73:f22a18707b5e	2364	lineBuffer[lb++] = q0.rgbGreen \| q1.rgbGreen;
WiredHome	73:f22a18707b5e	2365	lineBuffer[lb++] = q0.rgbRed \| q1.rgbRed;
WiredHome	73:f22a18707b5e	2366	break;
WiredHome	73:f22a18707b5e	2367	case 5: // boolean AND
WiredHome	73:f22a18707b5e	2368	lineBuffer[lb++] = q0.rgbBlue & q1.rgbBlue;
WiredHome	73:f22a18707b5e	2369	lineBuffer[lb++] = q0.rgbGreen & q1.rgbGreen;
WiredHome	73:f22a18707b5e	2370	lineBuffer[lb++] = q0.rgbRed & q1.rgbRed;
WiredHome	73:f22a18707b5e	2371	break;
WiredHome	73:f22a18707b5e	2372	}
WiredHome	72:ecffe56af969	2373	}
WiredHome	95:ef538bd687c0	2374	if (j == h - 1) {
WiredHome	73:f22a18707b5e	2375	HexDump("Line", lineBuffer, lineBufSize);
WiredHome	95:ef538bd687c0	2376	}
WiredHome	72:ecffe56af969	2377	// Write to disk
WiredHome	72:ecffe56af969	2378	fwrite(lineBuffer, sizeof(char), lb, Image);
WiredHome	72:ecffe56af969	2379	}
WiredHome	73:f22a18707b5e	2380	SelectDrawingLayer(prevLayer);
WiredHome	72:ecffe56af969	2381	fclose(Image);
WiredHome	86:e86b355940f4	2382	#ifndef DOUBLEBUF
WiredHome	86:e86b355940f4	2383	if (pixelBuffer2)
WiredHome	145:5eb2492acdda	2384	swFree(pixelBuffer2);
WiredHome	86:e86b355940f4	2385	#endif
WiredHome	86:e86b355940f4	2386	if (pixelBuffer)
WiredHome	145:5eb2492acdda	2387	swFree(pixelBuffer);
WiredHome	145:5eb2492acdda	2388	swFree(lineBuffer);
WiredHome	73:f22a18707b5e	2389	INFO("Image closed");
WiredHome	72:ecffe56af969	2390	return noerror;
WiredHome	72:ecffe56af969	2391	} else {
WiredHome	72:ecffe56af969	2392	return bad_parameter;
WiredHome	72:ecffe56af969	2393	}
WiredHome	72:ecffe56af969	2394	}
WiredHome	72:ecffe56af969	2395
WiredHome	72:ecffe56af969	2396
WiredHome	72:ecffe56af969	2397	// ##########################################################################
WiredHome	72:ecffe56af969	2398	// ##########################################################################
WiredHome	72:ecffe56af969	2399	// ##########################################################################
WiredHome	72:ecffe56af969	2400
WiredHome	23:a50ded45dbaf	2401	#ifdef TESTENABLE
WiredHome	23:a50ded45dbaf	2402
WiredHome	98:ecebed9b80b2	2403	#include "BPG_Arial08x08.h"
WiredHome	98:ecebed9b80b2	2404	#include "BPG_Arial20x20.h"
WiredHome	37:f19b7e7449dc	2405
WiredHome	23:a50ded45dbaf	2406	// ______________ ______________ ______________ _______________
WiredHome	23:a50ded45dbaf	2407	// /_____ _____/ / ___________/ / ___________/ /_____ ______/
WiredHome	23:a50ded45dbaf	2408	// / / / / / / / /
WiredHome	23:a50ded45dbaf	2409	// / / / /___ / /__________ / /
WiredHome	23:a50ded45dbaf	2410	// / / / ____/ /__________ / / /
WiredHome	23:a50ded45dbaf	2411	// / / / / / / / /
WiredHome	23:a50ded45dbaf	2412	// / / / /__________ ___________/ / / /
WiredHome	23:a50ded45dbaf	2413	// /__/ /_____________/ /_____________/ /__/
WiredHome	23:a50ded45dbaf	2414	//
WiredHome	23:a50ded45dbaf	2415	// Everything from here down is test code.
WiredHome	75:ca78388cfd77	2416	//
WiredHome	41:2956a0a221e5	2417	bool SuppressSlowStuff = false;
WiredHome	23:a50ded45dbaf	2418
WiredHome	49:c5182231d1b9	2419	void TextWrapTest(RA8875 & display, Serial & pc)
WiredHome	49:c5182231d1b9	2420	{
WiredHome	49:c5182231d1b9	2421	if (!SuppressSlowStuff)
WiredHome	49:c5182231d1b9	2422	pc.printf("Text Wrap Test\r\n");
WiredHome	49:c5182231d1b9	2423	display.background(Black);
WiredHome	49:c5182231d1b9	2424	display.foreground(Blue);
WiredHome	49:c5182231d1b9	2425	display.cls();
WiredHome	49:c5182231d1b9	2426	display.Backlight_u8(255);
WiredHome	100:0b084475d5a9	2427	display.puts("Text Wrap Test.\r\n");
WiredHome	52:e6039a823420	2428	for (int i=1; i<60; i++) {
WiredHome	52:e6039a823420	2429	display.printf("L%2d\n", i % 17);
WiredHome	49:c5182231d1b9	2430	if (!SuppressSlowStuff)
WiredHome	52:e6039a823420	2431	wait_ms(100);
WiredHome	49:c5182231d1b9	2432	}
WiredHome	49:c5182231d1b9	2433	if (!SuppressSlowStuff)
WiredHome	49:c5182231d1b9	2434	wait_ms(3000);
WiredHome	49:c5182231d1b9	2435	}
WiredHome	49:c5182231d1b9	2436
WiredHome	75:ca78388cfd77	2437
WiredHome	75:ca78388cfd77	2438	void ShowKey(RA8875 & display, int key)
WiredHome	75:ca78388cfd77	2439	{
WiredHome	75:ca78388cfd77	2440	loc_t col, row;
WiredHome	75:ca78388cfd77	2441	dim_t r1 = 25;
WiredHome	75:ca78388cfd77	2442	color_t color = (key & 0x80) ? Red : Green;
WiredHome	75:ca78388cfd77	2443
WiredHome	75:ca78388cfd77	2444	key &= 0x7F; // remove the long-press flag
WiredHome	75:ca78388cfd77	2445	row = (key - 1) / 5;
WiredHome	75:ca78388cfd77	2446	col = (key - 1) % 5;
WiredHome	75:ca78388cfd77	2447	if (col > 5) col = 5;
WiredHome	75:ca78388cfd77	2448	if (row > 4) row = 4;
WiredHome	75:ca78388cfd77	2449	display.circle(450 - + (2 * r1) * col, 200 - (2 * r1) * row, r1-2, color, FILL);
WiredHome	75:ca78388cfd77	2450	}
WiredHome	75:ca78388cfd77	2451
WiredHome	75:ca78388cfd77	2452	void HideKey(RA8875 & display, int key)
WiredHome	75:ca78388cfd77	2453	{
WiredHome	75:ca78388cfd77	2454	loc_t col, row;
WiredHome	75:ca78388cfd77	2455	dim_t r1 = 25;
WiredHome	75:ca78388cfd77	2456
WiredHome	75:ca78388cfd77	2457	row = (key - 1) / 5;
WiredHome	75:ca78388cfd77	2458	col = (key - 1) % 5;
WiredHome	75:ca78388cfd77	2459	if (col > 5) col = 5;
WiredHome	75:ca78388cfd77	2460	if (row > 4) row = 4;
WiredHome	75:ca78388cfd77	2461	display.background(Black);
WiredHome	75:ca78388cfd77	2462	display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Black, FILL);
WiredHome	75:ca78388cfd77	2463	display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Blue);
WiredHome	75:ca78388cfd77	2464	}
WiredHome	75:ca78388cfd77	2465
WiredHome	75:ca78388cfd77	2466	void KeyPadTest(RA8875 & display, Serial & pc)
WiredHome	75:ca78388cfd77	2467	{
WiredHome	75:ca78388cfd77	2468	const uint8_t myMap[22] = {
WiredHome	77:9206c13aa527	2469	0,
WiredHome	75:ca78388cfd77	2470	'a', 'b', 'c', 'd', 'e',
WiredHome	75:ca78388cfd77	2471	'f', 'g', 'h', 'i', 'j',
WiredHome	75:ca78388cfd77	2472	'k', 'l', 'm', 'n', 'o',
WiredHome	75:ca78388cfd77	2473	'p', 'q', 'r', 's', 't',
WiredHome	75:ca78388cfd77	2474	'x'
WiredHome	75:ca78388cfd77	2475	};
WiredHome	77:9206c13aa527	2476
WiredHome	75:ca78388cfd77	2477	display.background(Black);
WiredHome	75:ca78388cfd77	2478	display.foreground(Blue);
WiredHome	75:ca78388cfd77	2479	display.cls();
WiredHome	75:ca78388cfd77	2480	display.Backlight_u8(255);
WiredHome	100:0b084475d5a9	2481	display.puts("KeyPad Test. Touch the keypad...");
WiredHome	75:ca78388cfd77	2482	pc.printf("\r\n"
WiredHome	75:ca78388cfd77	2483	"Raw KeyPad Test. Keypad returns the key-number.\r\n"
WiredHome	75:ca78388cfd77	2484	"Press [most] any PC keyboard key to advance to next test.\r\n");
WiredHome	75:ca78388cfd77	2485	RetCode_t ret = display.KeypadInit(true, true, 3, 7, 3);
WiredHome	75:ca78388cfd77	2486	if (ret != noerror)
WiredHome	75:ca78388cfd77	2487	pc.printf("returncode from KeypadInit is %d\r\n", ret);
WiredHome	75:ca78388cfd77	2488	int lastKey = 0;
WiredHome	75:ca78388cfd77	2489	while (!pc.readable()) {
WiredHome	75:ca78388cfd77	2490	if (display.readable()) {
WiredHome	75:ca78388cfd77	2491	int key = display.getc();
WiredHome	75:ca78388cfd77	2492	if (key) {
WiredHome	75:ca78388cfd77	2493	if (((key & 0x7F) != lastKey) && (lastKey != 0))
WiredHome	75:ca78388cfd77	2494	HideKey(display, lastKey);
WiredHome	75:ca78388cfd77	2495	ShowKey(display, key);
WiredHome	75:ca78388cfd77	2496	lastKey = key & 0x7F;
WiredHome	75:ca78388cfd77	2497	} else {
WiredHome	75:ca78388cfd77	2498	// erase the last one
WiredHome	75:ca78388cfd77	2499	if (lastKey)
WiredHome	75:ca78388cfd77	2500	HideKey(display, lastKey);
WiredHome	75:ca78388cfd77	2501	}
WiredHome	75:ca78388cfd77	2502	}
WiredHome	75:ca78388cfd77	2503	}
WiredHome	75:ca78388cfd77	2504	(void)pc.getc();
WiredHome	75:ca78388cfd77	2505	pc.printf("\r\n"
WiredHome	75:ca78388cfd77	2506	"Map KeyPad Test. Keypad returns the remapped key 'a' - 't'.\r\n"
WiredHome	75:ca78388cfd77	2507	"Press [most] any PC keyboard key to advance to exit test.\r\n");
WiredHome	75:ca78388cfd77	2508	display.SetKeyMap(myMap);
WiredHome	75:ca78388cfd77	2509	while (!pc.readable()) {
WiredHome	75:ca78388cfd77	2510	if (display.readable()) {
WiredHome	75:ca78388cfd77	2511	int key = display.getc();
WiredHome	75:ca78388cfd77	2512	bool longPress = key & 0x80;
WiredHome	75:ca78388cfd77	2513	display.SetTextCursor(0, 120);
WiredHome	75:ca78388cfd77	2514	display.printf("Long Press: %d\r\n", longPress);
WiredHome	75:ca78388cfd77	2515	display.printf(" Remapped: %c %02X\r\n", (key) ? key & 0x7F : ' ', key);
WiredHome	75:ca78388cfd77	2516	}
WiredHome	75:ca78388cfd77	2517	}
WiredHome	75:ca78388cfd77	2518	(void)pc.getc();
WiredHome	75:ca78388cfd77	2519	display.SetKeyMap();
WiredHome	75:ca78388cfd77	2520	pc.printf("\r\n");
WiredHome	75:ca78388cfd77	2521	}
WiredHome	75:ca78388cfd77	2522
WiredHome	23:a50ded45dbaf	2523	void TextCursorTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	2524	{
WiredHome	75:ca78388cfd77	2525	const char * iCursor = "The I-Beam cursor should be visible for this text.\r\n";
WiredHome	75:ca78388cfd77	2526	const char * uCursor = "The Underscore cursor should be visible for this text.\r\n";
WiredHome	75:ca78388cfd77	2527	const char * bCursor = "The Block cursor should be visible for this text.\r\n";
WiredHome	37:f19b7e7449dc	2528	const char * bbCursor = "The Blinking Block cursor should be visible for this text.\r\n";
WiredHome	23:a50ded45dbaf	2529	const char * p;
WiredHome	100:0b084475d5a9	2530	int delay = 60;
WiredHome	73:f22a18707b5e	2531
WiredHome	41:2956a0a221e5	2532	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	2533	pc.printf("Text Cursor Test\r\n");
WiredHome	73:f22a18707b5e	2534	else
WiredHome	41:2956a0a221e5	2535	delay = 0;
WiredHome	23:a50ded45dbaf	2536	display.background(Black);
WiredHome	23:a50ded45dbaf	2537	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	2538	display.cls();
WiredHome	25:9556a3a9b7cc	2539	display.Backlight_u8(255);
WiredHome	100:0b084475d5a9	2540	display.puts("Text Cursor Test.");
WiredHome	73:f22a18707b5e	2541
WiredHome	23:a50ded45dbaf	2542	// visible, non-blinking
WiredHome	24:8ca861acf12d	2543	display.SetTextCursor(0,20);
WiredHome	53:86d24b9480b9	2544	display.SetTextCursorControl(RA8875::IBEAM, false);
WiredHome	24:8ca861acf12d	2545	p = iCursor;
WiredHome	23:a50ded45dbaf	2546	while (*p) {
WiredHome	24:8ca861acf12d	2547	display._putc(*p++);
WiredHome	41:2956a0a221e5	2548	wait_ms(delay);
WiredHome	24:8ca861acf12d	2549	}
WiredHome	24:8ca861acf12d	2550
WiredHome	53:86d24b9480b9	2551	display.SetTextCursorControl(RA8875::UNDER, false);
WiredHome	24:8ca861acf12d	2552	p = uCursor;
WiredHome	24:8ca861acf12d	2553	while (*p) {
WiredHome	24:8ca861acf12d	2554	display._putc(*p++);
WiredHome	41:2956a0a221e5	2555	wait_ms(delay);
WiredHome	23:a50ded45dbaf	2556	}
WiredHome	73:f22a18707b5e	2557
WiredHome	53:86d24b9480b9	2558	display.SetTextCursorControl(RA8875::BLOCK, false);
WiredHome	24:8ca861acf12d	2559	p = bCursor;
WiredHome	24:8ca861acf12d	2560	while (*p) {
WiredHome	24:8ca861acf12d	2561	display._putc(*p++);
WiredHome	41:2956a0a221e5	2562	wait_ms(delay);
WiredHome	24:8ca861acf12d	2563	}
WiredHome	24:8ca861acf12d	2564
WiredHome	53:86d24b9480b9	2565	display.SetTextCursorControl(RA8875::BLOCK, true);
WiredHome	24:8ca861acf12d	2566	p = bbCursor;
WiredHome	24:8ca861acf12d	2567	while (*p) {
WiredHome	24:8ca861acf12d	2568	display._putc(*p++);
WiredHome	41:2956a0a221e5	2569	wait_ms(delay);
WiredHome	24:8ca861acf12d	2570	}
WiredHome	41:2956a0a221e5	2571	wait_ms(delay * 20);
WiredHome	53:86d24b9480b9	2572	display.SetTextCursorControl(RA8875::NOCURSOR, false);
WiredHome	23:a50ded45dbaf	2573	}
WiredHome	23:a50ded45dbaf	2574
WiredHome	44:207594dece70	2575
WiredHome	23:a50ded45dbaf	2576	void BacklightTest(RA8875 & display, Serial & pc, float ramptime)
WiredHome	23:a50ded45dbaf	2577	{
WiredHome	29:422616aa04bd	2578	char buf[60];
WiredHome	41:2956a0a221e5	2579	unsigned int w = (ramptime * 1000)/ 256;
WiredHome	41:2956a0a221e5	2580	int delay = 200;
WiredHome	41:2956a0a221e5	2581
WiredHome	41:2956a0a221e5	2582	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	2583	pc.printf("Backlight Test - ramp over %f sec.\r\n", ramptime);
WiredHome	41:2956a0a221e5	2584	else {
WiredHome	41:2956a0a221e5	2585	delay = 0;
WiredHome	41:2956a0a221e5	2586	w = 0;
WiredHome	41:2956a0a221e5	2587	}
WiredHome	23:a50ded45dbaf	2588	display.Backlight_u8(0);
WiredHome	29:422616aa04bd	2589	display.background(White);
WiredHome	23:a50ded45dbaf	2590	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	2591	display.cls();
WiredHome	100:0b084475d5a9	2592	display.puts("RA8875 Backlight Test - Ramp up.");
WiredHome	41:2956a0a221e5	2593	wait_ms(delay);
WiredHome	38:38d503b4fad6	2594	for (int i=0; i <= 255; i++) {
WiredHome	141:2ec78a50dc98	2595	snprintf(buf, sizeof(buf), "%3d, %4d", i, w);
WiredHome	37:f19b7e7449dc	2596	display.puts(100,100,buf);
WiredHome	23:a50ded45dbaf	2597	display.Backlight_u8(i);
WiredHome	29:422616aa04bd	2598	wait_ms(w);
WiredHome	23:a50ded45dbaf	2599	}
WiredHome	23:a50ded45dbaf	2600	}
WiredHome	23:a50ded45dbaf	2601
WiredHome	44:207594dece70	2602
WiredHome	23:a50ded45dbaf	2603	void BacklightTest2(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	2604	{
WiredHome	41:2956a0a221e5	2605	int delay = 20;
WiredHome	41:2956a0a221e5	2606
WiredHome	41:2956a0a221e5	2607	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	2608	pc.printf("Backlight Test 2\r\n");
WiredHome	41:2956a0a221e5	2609	else
WiredHome	41:2956a0a221e5	2610	delay = 0;
WiredHome	41:2956a0a221e5	2611
WiredHome	23:a50ded45dbaf	2612	// Dim it out at the end of the tests.
WiredHome	37:f19b7e7449dc	2613	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	2614	display.puts(0,0, "Ramp Backlight down.");
WiredHome	23:a50ded45dbaf	2615	// Ramp it off
WiredHome	23:a50ded45dbaf	2616	for (int i=255; i != 0; i--) {
WiredHome	23:a50ded45dbaf	2617	display.Backlight_u8(i);
WiredHome	41:2956a0a221e5	2618	wait_ms(delay);
WiredHome	23:a50ded45dbaf	2619	}
WiredHome	23:a50ded45dbaf	2620	display.Backlight_u8(0);
WiredHome	23:a50ded45dbaf	2621	}
WiredHome	23:a50ded45dbaf	2622
WiredHome	44:207594dece70	2623
WiredHome	23:a50ded45dbaf	2624	void ExternalFontTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	2625	{
WiredHome	41:2956a0a221e5	2626	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	2627	pc.printf("External Font Test\r\n");
WiredHome	23:a50ded45dbaf	2628	display.background(Black);
WiredHome	23:a50ded45dbaf	2629	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	2630	display.cls();
WiredHome	100:0b084475d5a9	2631	display.puts("External Font Test.");
WiredHome	23:a50ded45dbaf	2632	display.Backlight(1);
WiredHome	37:f19b7e7449dc	2633
WiredHome	98:ecebed9b80b2	2634	display.SelectUserFont(BPG_Arial08x08);
WiredHome	73:f22a18707b5e	2635	display.puts(0,30, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome	37:f19b7e7449dc	2636
WiredHome	98:ecebed9b80b2	2637	display.SelectUserFont(BPG_Arial20x20);
WiredHome	37:f19b7e7449dc	2638	display.puts("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome	98:ecebed9b80b2	2639
WiredHome	98:ecebed9b80b2	2640	display.SelectUserFont();
WiredHome	73:f22a18707b5e	2641
WiredHome	37:f19b7e7449dc	2642	display.puts("Normal font again.");
WiredHome	37:f19b7e7449dc	2643	//display.window(0,0, display.width(), display.height());
WiredHome	23:a50ded45dbaf	2644	}
WiredHome	23:a50ded45dbaf	2645
WiredHome	44:207594dece70	2646
WiredHome	23:a50ded45dbaf	2647	void DOSColorTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	2648	{
WiredHome	41:2956a0a221e5	2649	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	2650	pc.printf("DOS Color Test\r\n");
WiredHome	23:a50ded45dbaf	2651	display.background(Black);
WiredHome	23:a50ded45dbaf	2652	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	2653	display.cls();
WiredHome	100:0b084475d5a9	2654	display.puts("DOS Colors - Fore");
WiredHome	23:a50ded45dbaf	2655	display.puts(280,0, "Back");
WiredHome	23:a50ded45dbaf	2656	display.background(Gray);
WiredHome	23:a50ded45dbaf	2657	for (int i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	2658	display.foreground(display.DOSColor(i));
WiredHome	23:a50ded45dbaf	2659	display.puts(160, i*16, display.DOSColorNames(i));
WiredHome	23:a50ded45dbaf	2660	display.background(Black);
WiredHome	23:a50ded45dbaf	2661	}
WiredHome	23:a50ded45dbaf	2662	display.foreground(White);
WiredHome	23:a50ded45dbaf	2663	for (int i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	2664	display.background(display.DOSColor(i));
WiredHome	23:a50ded45dbaf	2665	display.puts(360, i*16, display.DOSColorNames(i));
WiredHome	23:a50ded45dbaf	2666	display.foreground(White);
WiredHome	23:a50ded45dbaf	2667	}
WiredHome	23:a50ded45dbaf	2668	}
WiredHome	23:a50ded45dbaf	2669
WiredHome	44:207594dece70	2670
WiredHome	23:a50ded45dbaf	2671	void WebColorTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	2672	{
WiredHome	41:2956a0a221e5	2673	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	2674	pc.printf("Web Color Test\r\n");
WiredHome	23:a50ded45dbaf	2675	display.background(Black);
WiredHome	23:a50ded45dbaf	2676	display.foreground(Blue);
WiredHome	32:0e4f2ae512e2	2677	display.window(0,0, display.width(), display.height());
WiredHome	23:a50ded45dbaf	2678	display.cls();
WiredHome	59:fb40aad4efd4	2679	display.SetTextFontSize(1,1);
WiredHome	59:fb40aad4efd4	2680	display.puts(200,0, "Web Color Test");
WiredHome	59:fb40aad4efd4	2681	display.SetTextCursor(0,0);
WiredHome	59:fb40aad4efd4	2682	display.puts(" ");
WiredHome	59:fb40aad4efd4	2683	for (int i=0; i<16; i++)
WiredHome	59:fb40aad4efd4	2684	display.printf("%X", i&0xF);
WiredHome	59:fb40aad4efd4	2685	display.puts("\r\n0 ");
WiredHome	23:a50ded45dbaf	2686	for (int i=0; i<sizeof(WebColors)/sizeof(WebColors[0]); i++) {
WiredHome	23:a50ded45dbaf	2687	display.background(WebColors[i]);
WiredHome	23:a50ded45dbaf	2688	display.puts(" ");
WiredHome	59:fb40aad4efd4	2689	if (i % 16 == 15 && i < 255) {
WiredHome	59:fb40aad4efd4	2690	display.printf("\r\n%X ", ((i+1)/16));
WiredHome	59:fb40aad4efd4	2691	}
WiredHome	23:a50ded45dbaf	2692	}
WiredHome	23:a50ded45dbaf	2693	display.SetTextFontSize(1,1);
WiredHome	23:a50ded45dbaf	2694	}
WiredHome	23:a50ded45dbaf	2695
WiredHome	44:207594dece70	2696
WiredHome	37:f19b7e7449dc	2697	void PixelTest(RA8875 & display, Serial & pc)
WiredHome	37:f19b7e7449dc	2698	{
WiredHome	37:f19b7e7449dc	2699	int i, c, x, y;
WiredHome	37:f19b7e7449dc	2700
WiredHome	41:2956a0a221e5	2701	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	2702	pc.printf("Pixel Test\r\n");
WiredHome	37:f19b7e7449dc	2703	display.background(Black);
WiredHome	37:f19b7e7449dc	2704	display.foreground(Blue);
WiredHome	37:f19b7e7449dc	2705	display.cls();
WiredHome	100:0b084475d5a9	2706	display.puts("Pixel Test");
WiredHome	37:f19b7e7449dc	2707	for (i=0; i<1000; i++) {
WiredHome	37:f19b7e7449dc	2708	x = rand() % 480;
WiredHome	37:f19b7e7449dc	2709	y = 16 + rand() % (272-16);
WiredHome	37:f19b7e7449dc	2710	c = rand() % 16;
WiredHome	37:f19b7e7449dc	2711	//pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome	37:f19b7e7449dc	2712	display.pixel(x,y, display.DOSColor(c));
WiredHome	37:f19b7e7449dc	2713	}
WiredHome	37:f19b7e7449dc	2714	}
WiredHome	37:f19b7e7449dc	2715
WiredHome	44:207594dece70	2716
WiredHome	23:a50ded45dbaf	2717	void LineTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	2718	{
WiredHome	23:a50ded45dbaf	2719	int i, x, y, x2, y2;
WiredHome	23:a50ded45dbaf	2720
WiredHome	41:2956a0a221e5	2721	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	2722	pc.printf("Line Test\r\n");
WiredHome	23:a50ded45dbaf	2723	display.background(Black);
WiredHome	23:a50ded45dbaf	2724	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	2725	display.cls();
WiredHome	100:0b084475d5a9	2726	display.puts("Line Test");
WiredHome	23:a50ded45dbaf	2727	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	2728	// Lines
WiredHome	23:a50ded45dbaf	2729	x = rand() % 480;
WiredHome	23:a50ded45dbaf	2730	y = rand() % 272;
WiredHome	23:a50ded45dbaf	2731	x2 = rand() % 480;
WiredHome	23:a50ded45dbaf	2732	y2 = rand() % 272;
WiredHome	23:a50ded45dbaf	2733	display.line(x,y, x2,y2, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	2734	}
WiredHome	62:ba5d33438fda	2735	display.foreground(BrightRed);
WiredHome	62:ba5d33438fda	2736	display.foreground(BrightGreen);
WiredHome	62:ba5d33438fda	2737	display.foreground(BrightBlue);
WiredHome	62:ba5d33438fda	2738	display.line(55,50, 79,74, BrightRed);
WiredHome	62:ba5d33438fda	2739	display.line(57,50, 81,74, BrightGreen);
WiredHome	62:ba5d33438fda	2740	display.line(59,50, 83,74, BrightBlue);
WiredHome	62:ba5d33438fda	2741	// horz
WiredHome	62:ba5d33438fda	2742	display.line(30,40, 32,40, BrightRed);
WiredHome	62:ba5d33438fda	2743	display.line(30,42, 32,42, BrightGreen);
WiredHome	62:ba5d33438fda	2744	display.line(30,44, 32,44, BrightBlue);
WiredHome	62:ba5d33438fda	2745	// vert
WiredHome	62:ba5d33438fda	2746	display.line(20,40, 20,42, BrightRed);
WiredHome	62:ba5d33438fda	2747	display.line(22,40, 22,42, BrightGreen);
WiredHome	62:ba5d33438fda	2748	display.line(24,40, 24,42, BrightBlue);
WiredHome	62:ba5d33438fda	2749	// compare point to line-point
WiredHome	62:ba5d33438fda	2750	display.pixel(20,50, BrightRed);
WiredHome	62:ba5d33438fda	2751	display.pixel(22,50, BrightGreen);
WiredHome	62:ba5d33438fda	2752	display.pixel(24,50, BrightBlue);
WiredHome	62:ba5d33438fda	2753	display.line(20,52, 20,52, BrightRed);
WiredHome	62:ba5d33438fda	2754	display.line(22,52, 22,52, BrightGreen);
WiredHome	62:ba5d33438fda	2755	display.line(24,52, 24,52, BrightBlue);
WiredHome	73:f22a18707b5e	2756
WiredHome	62:ba5d33438fda	2757	// point
WiredHome	62:ba5d33438fda	2758	display.line(50,50, 50,50, Red);
WiredHome	62:ba5d33438fda	2759	display.line(52,52, 52,52, Green);
WiredHome	62:ba5d33438fda	2760	display.line(54,54, 54,54, Blue);
WiredHome	62:ba5d33438fda	2761	display.line(60,60, 60,60, BrightRed);
WiredHome	62:ba5d33438fda	2762	display.line(62,62, 62,62, BrightGreen);
WiredHome	62:ba5d33438fda	2763	display.line(64,64, 64,64, BrightBlue);
WiredHome	62:ba5d33438fda	2764	display.line(70,70, 70,70, DarkRed);
WiredHome	62:ba5d33438fda	2765	display.line(72,72, 72,72, DarkGreen);
WiredHome	62:ba5d33438fda	2766	display.line(74,74, 74,74, DarkBlue);
WiredHome	23:a50ded45dbaf	2767	}
WiredHome	23:a50ded45dbaf	2768
WiredHome	44:207594dece70	2769
WiredHome	23:a50ded45dbaf	2770	void RectangleTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	2771	{
WiredHome	23:a50ded45dbaf	2772	int i, x1,y1, x2,y2;
WiredHome	23:a50ded45dbaf	2773
WiredHome	41:2956a0a221e5	2774	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	2775	pc.printf("Rectangle Test\r\n");
WiredHome	23:a50ded45dbaf	2776	display.background(Black);
WiredHome	23:a50ded45dbaf	2777	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	2778	display.cls();
WiredHome	100:0b084475d5a9	2779	display.puts("Rectangle Test");
WiredHome	23:a50ded45dbaf	2780	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	2781	x1 = rand() % 240;
WiredHome	23:a50ded45dbaf	2782	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	2783	x2 = rand() % 240;
WiredHome	23:a50ded45dbaf	2784	y2 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	2785	display.rect(x1,y1, x2,y2, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	2786
WiredHome	23:a50ded45dbaf	2787	x1 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	2788	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	2789	x2 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	2790	y2 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	2791	display.rect(x1,y1, x2,y2, FILL);
WiredHome	23:a50ded45dbaf	2792	}
WiredHome	23:a50ded45dbaf	2793	}
WiredHome	23:a50ded45dbaf	2794
WiredHome	44:207594dece70	2795
WiredHome	44:207594dece70	2796	void LayerTest(RA8875 & display, Serial & pc)
WiredHome	44:207594dece70	2797	{
WiredHome	44:207594dece70	2798	loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome	44:207594dece70	2799
WiredHome	44:207594dece70	2800	if (!SuppressSlowStuff)
WiredHome	44:207594dece70	2801	pc.printf("Layer Test\r\n");
WiredHome	44:207594dece70	2802
WiredHome	50:2c4f474a2453	2803	display.SelectDrawingLayer(0);
WiredHome	44:207594dece70	2804	display.background(Black);
WiredHome	44:207594dece70	2805	display.foreground(Blue);
WiredHome	44:207594dece70	2806	display.cls();
WiredHome	100:0b084475d5a9	2807	display.puts("Layer 0");
WiredHome	44:207594dece70	2808	for (i=0; i<16; i++) {
WiredHome	44:207594dece70	2809	x1 = rand() % 240;
WiredHome	44:207594dece70	2810	y1 = 50 + rand() % 200;
WiredHome	44:207594dece70	2811	x2 = x1 + rand() % 100;
WiredHome	44:207594dece70	2812	y2 = y1 + rand() % 100;
WiredHome	44:207594dece70	2813	r1 = rand() % (x2 - x1)/2;
WiredHome	44:207594dece70	2814	r2 = rand() % (y2 - y1)/2;
WiredHome	44:207594dece70	2815	display.roundrect(x1,y1, x2,y2, r1,r2, display.DOSColor(i));
WiredHome	44:207594dece70	2816	if (!SuppressSlowStuff)
WiredHome	44:207594dece70	2817	wait_ms(20);
WiredHome	44:207594dece70	2818	}
WiredHome	44:207594dece70	2819	if (!SuppressSlowStuff)
WiredHome	44:207594dece70	2820	wait_ms(1000);
WiredHome	44:207594dece70	2821
WiredHome	50:2c4f474a2453	2822	display.SelectDrawingLayer(1);
WiredHome	44:207594dece70	2823	display.background(Black);
WiredHome	44:207594dece70	2824	display.foreground(Yellow);
WiredHome	44:207594dece70	2825	display.cls();
WiredHome	44:207594dece70	2826	display.puts(240,0, "Layer 1");
WiredHome	44:207594dece70	2827	for (i=0; i<16; i++) {
WiredHome	44:207594dece70	2828	x1 = 300 + rand() % 100;
WiredHome	44:207594dece70	2829	y1 = 70 + rand() % 200;
WiredHome	44:207594dece70	2830	r1 = rand() % min(y1 - 20, 100);
WiredHome	44:207594dece70	2831	display.circle(x1,y1,r1, display.DOSColor(i));
WiredHome	44:207594dece70	2832	if (!SuppressSlowStuff)
WiredHome	44:207594dece70	2833	wait_ms(20);
WiredHome	44:207594dece70	2834	}
WiredHome	56:7a85d226ad0d	2835	display.SetLayerMode(RA8875::ShowLayer1); // Show it after the build-up
WiredHome	44:207594dece70	2836	if (!SuppressSlowStuff)
WiredHome	44:207594dece70	2837	wait_ms(2000);
WiredHome	44:207594dece70	2838
WiredHome	50:2c4f474a2453	2839	display.SelectDrawingLayer(0);
WiredHome	56:7a85d226ad0d	2840	display.SetLayerMode(RA8875::ShowLayer0); // Show Layer 0 again
WiredHome	44:207594dece70	2841	if (!SuppressSlowStuff)
WiredHome	44:207594dece70	2842	wait_ms(1000);
WiredHome	53:86d24b9480b9	2843	display.SetLayerMode(RA8875::TransparentMode); // Transparent mode
WiredHome	44:207594dece70	2844	if (!SuppressSlowStuff)
WiredHome	44:207594dece70	2845	wait_ms(1000);
WiredHome	44:207594dece70	2846	for (i=0; i<=8; i++) {
WiredHome	44:207594dece70	2847	display.SetLayerTransparency(i, 8-i);
WiredHome	44:207594dece70	2848	if (!SuppressSlowStuff)
WiredHome	44:207594dece70	2849	wait_ms(200);
WiredHome	44:207594dece70	2850	}
WiredHome	73:f22a18707b5e	2851
WiredHome	44:207594dece70	2852	// Restore before we exit
WiredHome	44:207594dece70	2853	display.SetLayerTransparency(0, 0);
WiredHome	56:7a85d226ad0d	2854	display.SetLayerMode(RA8875::ShowLayer0); // Restore to layer 0
WiredHome	44:207594dece70	2855	}
WiredHome	44:207594dece70	2856
WiredHome	44:207594dece70	2857
WiredHome	23:a50ded45dbaf	2858	void RoundRectTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	2859	{
WiredHome	37:f19b7e7449dc	2860	loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome	23:a50ded45dbaf	2861
WiredHome	41:2956a0a221e5	2862	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	2863	pc.printf("Round Rectangle Test\r\n");
WiredHome	23:a50ded45dbaf	2864	display.background(Black);
WiredHome	23:a50ded45dbaf	2865	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	2866	display.cls();
WiredHome	100:0b084475d5a9	2867	display.puts("Rounded Rectangle Test");
WiredHome	73:f22a18707b5e	2868
WiredHome	23:a50ded45dbaf	2869	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	2870	x1 = rand() % 240;
WiredHome	23:a50ded45dbaf	2871	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	2872	x2 = x1 + rand() % 100;
WiredHome	23:a50ded45dbaf	2873	y2 = y1 + rand() % 100;
WiredHome	23:a50ded45dbaf	2874	r1 = rand() % (x2 - x1)/2;
WiredHome	23:a50ded45dbaf	2875	r2 = rand() % (y2 - y1)/2;
WiredHome	23:a50ded45dbaf	2876	display.roundrect(x1,y1, x2,y2, 5,8, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	2877
WiredHome	23:a50ded45dbaf	2878	x1 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	2879	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	2880	x2 = x1 + rand() % 100;
WiredHome	23:a50ded45dbaf	2881	y2 = y1 + rand() % 100;
WiredHome	23:a50ded45dbaf	2882	r1 = rand() % (x2 - x1)/2;
WiredHome	23:a50ded45dbaf	2883	r2 = rand() % (y2 - y1)/2;
WiredHome	23:a50ded45dbaf	2884	display.roundrect(x1,y1, x2,y2, r1,r2, FILL);
WiredHome	23:a50ded45dbaf	2885	}
WiredHome	23:a50ded45dbaf	2886	}
WiredHome	23:a50ded45dbaf	2887
WiredHome	44:207594dece70	2888
WiredHome	23:a50ded45dbaf	2889	void TriangleTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	2890	{
WiredHome	23:a50ded45dbaf	2891	int i, x1, y1, x2, y2, x3, y3;
WiredHome	23:a50ded45dbaf	2892
WiredHome	41:2956a0a221e5	2893	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	2894	pc.printf("Triangle Test\r\n");
WiredHome	23:a50ded45dbaf	2895	display.background(Black);
WiredHome	23:a50ded45dbaf	2896	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	2897	display.cls();
WiredHome	23:a50ded45dbaf	2898	display.puts(0,0, "Triangle Test");
WiredHome	23:a50ded45dbaf	2899
WiredHome	23:a50ded45dbaf	2900	x1 = 150;
WiredHome	23:a50ded45dbaf	2901	y1 = 2;
WiredHome	23:a50ded45dbaf	2902	x2 = 190;
WiredHome	23:a50ded45dbaf	2903	y2 = 7;
WiredHome	23:a50ded45dbaf	2904	x3 = 170;
WiredHome	23:a50ded45dbaf	2905	y3 = 16;
WiredHome	23:a50ded45dbaf	2906	display.triangle(x1,y1, x2,y2, x3,y3);
WiredHome	23:a50ded45dbaf	2907
WiredHome	23:a50ded45dbaf	2908	x1 = 200;
WiredHome	23:a50ded45dbaf	2909	y1 = 2;
WiredHome	23:a50ded45dbaf	2910	x2 = 240;
WiredHome	23:a50ded45dbaf	2911	y2 = 7;
WiredHome	23:a50ded45dbaf	2912	x3 = 220;
WiredHome	23:a50ded45dbaf	2913	y3 = 16;
WiredHome	23:a50ded45dbaf	2914	display.filltriangle(x1,y1, x2,y2, x3,y3, BrightRed);
WiredHome	23:a50ded45dbaf	2915
WiredHome	23:a50ded45dbaf	2916	x1 = 300;
WiredHome	23:a50ded45dbaf	2917	y1 = 2;
WiredHome	23:a50ded45dbaf	2918	x2 = 340;
WiredHome	23:a50ded45dbaf	2919	y2 = 7;
WiredHome	23:a50ded45dbaf	2920	x3 = 320;
WiredHome	23:a50ded45dbaf	2921	y3 = 16;
WiredHome	23:a50ded45dbaf	2922	display.triangle(x1,y1, x2,y2, x3,y3, NOFILL);
WiredHome	23:a50ded45dbaf	2923
WiredHome	23:a50ded45dbaf	2924	x1 = 400;
WiredHome	23:a50ded45dbaf	2925	y1 = 2;
WiredHome	23:a50ded45dbaf	2926	x2 = 440;
WiredHome	23:a50ded45dbaf	2927	y2 = 7;
WiredHome	23:a50ded45dbaf	2928	x3 = 420;
WiredHome	23:a50ded45dbaf	2929	y3 = 16;
WiredHome	23:a50ded45dbaf	2930	display.triangle(x1,y1, x2,y2, x3,y3, Blue);
WiredHome	23:a50ded45dbaf	2931
WiredHome	23:a50ded45dbaf	2932	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	2933	x1 = rand() % 240;
WiredHome	23:a50ded45dbaf	2934	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	2935	x2 = rand() % 240;
WiredHome	23:a50ded45dbaf	2936	y2 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	2937	x3 = rand() % 240;
WiredHome	23:a50ded45dbaf	2938	y3 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	2939	display.triangle(x1,y1, x2,y2, x3,y3, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	2940	x1 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	2941	y1 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	2942	x2 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	2943	y2 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	2944	x3 = 240 + rand() % 240;
WiredHome	23:a50ded45dbaf	2945	y3 = 50 + rand() % 200;
WiredHome	23:a50ded45dbaf	2946	display.triangle(x1,y1, x2,y2, x3,y3, FILL);
WiredHome	23:a50ded45dbaf	2947	}
WiredHome	23:a50ded45dbaf	2948	}
WiredHome	23:a50ded45dbaf	2949
WiredHome	44:207594dece70	2950
WiredHome	23:a50ded45dbaf	2951	void CircleTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	2952	{
WiredHome	23:a50ded45dbaf	2953	int i, x, y, r1;
WiredHome	23:a50ded45dbaf	2954
WiredHome	41:2956a0a221e5	2955	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	2956	pc.printf("Circle Test\r\n");
WiredHome	23:a50ded45dbaf	2957	display.background(Black);
WiredHome	23:a50ded45dbaf	2958	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	2959	display.cls();
WiredHome	100:0b084475d5a9	2960	display.puts("Circle Test");
WiredHome	23:a50ded45dbaf	2961	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	2962	x = 100 + rand() % 100;
WiredHome	23:a50ded45dbaf	2963	y = 70 + rand() % 200;
WiredHome	23:a50ded45dbaf	2964	r1 = rand() % min(y - 20, 100);
WiredHome	23:a50ded45dbaf	2965	//pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome	23:a50ded45dbaf	2966	display.circle(x,y,r1, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	2967
WiredHome	23:a50ded45dbaf	2968	x = 300 + rand() % 100;
WiredHome	23:a50ded45dbaf	2969	y = 70 + rand() % 200;
WiredHome	23:a50ded45dbaf	2970	r1 = rand() % min(y - 20, 100);
WiredHome	23:a50ded45dbaf	2971	//pc.printf(" (%d,%d) - %d FILL\r\n", x,y,r1);
WiredHome	23:a50ded45dbaf	2972	display.circle(x,y,r1, display.DOSColor(i), FILL);
WiredHome	23:a50ded45dbaf	2973	}
WiredHome	23:a50ded45dbaf	2974	}
WiredHome	23:a50ded45dbaf	2975
WiredHome	44:207594dece70	2976
WiredHome	23:a50ded45dbaf	2977	void EllipseTest(RA8875 & display, Serial & pc)
WiredHome	23:a50ded45dbaf	2978	{
WiredHome	23:a50ded45dbaf	2979	int i,x,y,r1,r2;
WiredHome	23:a50ded45dbaf	2980
WiredHome	41:2956a0a221e5	2981	if (!SuppressSlowStuff)
WiredHome	41:2956a0a221e5	2982	pc.printf("Ellipse Test\r\n");
WiredHome	23:a50ded45dbaf	2983	display.background(Black);
WiredHome	23:a50ded45dbaf	2984	display.foreground(Blue);
WiredHome	23:a50ded45dbaf	2985	display.cls();
WiredHome	100:0b084475d5a9	2986	display.puts("Ellipse Test");
WiredHome	23:a50ded45dbaf	2987	for (i=0; i<16; i++) {
WiredHome	23:a50ded45dbaf	2988	x = 100 + rand() % 100;
WiredHome	23:a50ded45dbaf	2989	y = 70 + rand() % 200;
WiredHome	23:a50ded45dbaf	2990	r1 = rand() % min(y - 20, 100);
WiredHome	23:a50ded45dbaf	2991	r2 = rand() % min(y - 20, 100);
WiredHome	23:a50ded45dbaf	2992	display.ellipse(x,y,r1,r2, display.DOSColor(i));
WiredHome	23:a50ded45dbaf	2993
WiredHome	23:a50ded45dbaf	2994	x = 300 + rand() % 100;
WiredHome	23:a50ded45dbaf	2995	y = 70 + rand() % 200;
WiredHome	23:a50ded45dbaf	2996	r1 = rand() % min(y - 20, 100);
WiredHome	23:a50ded45dbaf	2997	r2 = rand() % min(y - 20, 100);
WiredHome	23:a50ded45dbaf	2998	display.ellipse(x,y,r1,r2, FILL);
WiredHome	23:a50ded45dbaf	2999	}
WiredHome	23:a50ded45dbaf	3000	}
WiredHome	23:a50ded45dbaf	3001
WiredHome	44:207594dece70	3002
WiredHome	37:f19b7e7449dc	3003	void TestGraphicsBitmap(RA8875 & display, Serial & pc)
WiredHome	37:f19b7e7449dc	3004	{
WiredHome	37:f19b7e7449dc	3005	LocalFileSystem local("local");
WiredHome	41:2956a0a221e5	3006	if (!SuppressSlowStuff)
WiredHome	73:f22a18707b5e	3007	pc.printf("Bitmap File Load\r\n");
WiredHome	37:f19b7e7449dc	3008	display.background(Black);
WiredHome	37:f19b7e7449dc	3009	display.foreground(Blue);
WiredHome	37:f19b7e7449dc	3010	display.cls();
WiredHome	100:0b084475d5a9	3011	display.puts("Graphics Test, loading /local/TestPat.bmp");
WiredHome	37:f19b7e7449dc	3012	wait(3);
WiredHome	37:f19b7e7449dc	3013
WiredHome	37:f19b7e7449dc	3014	int r = display.RenderBitmapFile(0,0, "/local/TestPat.bmp");
WiredHome	59:fb40aad4efd4	3015	if (!SuppressSlowStuff)
WiredHome	59:fb40aad4efd4	3016	pc.printf(" returned %d\r\n", r);
WiredHome	37:f19b7e7449dc	3017	}
WiredHome	37:f19b7e7449dc	3018
WiredHome	44:207594dece70	3019
WiredHome	77:9206c13aa527	3020	void TouchPanelTest(RA8875 & display, Serial & pc)
WiredHome	77:9206c13aa527	3021	{
WiredHome	77:9206c13aa527	3022	Timer t;
WiredHome	98:ecebed9b80b2	3023	int x, y;
WiredHome	78:faf49c381591	3024	tpMatrix_t calmatrix;
WiredHome	78:faf49c381591	3025
WiredHome	77:9206c13aa527	3026	display.background(Black);
WiredHome	77:9206c13aa527	3027	display.foreground(Blue);
WiredHome	77:9206c13aa527	3028	display.cls();
WiredHome	100:0b084475d5a9	3029	display.puts("Touch Panel Test\r\n");
WiredHome	78:faf49c381591	3030	pc.printf("Touch Panel Test\r\n");
WiredHome	77:9206c13aa527	3031	display.TouchPanelInit();
WiredHome	78:faf49c381591	3032	pc.printf(" TP: c - calibrate, r - restore, t - test\r\n");
WiredHome	78:faf49c381591	3033	int c = pc.getc();
WiredHome	78:faf49c381591	3034	if (c == 'c') {
WiredHome	78:faf49c381591	3035	point_t pTest[3] =
WiredHome	78:faf49c381591	3036	{ { 50, 50 }, {450, 150}, {225,250} };
WiredHome	78:faf49c381591	3037	point_t pSample[3];
WiredHome	78:faf49c381591	3038	for (int i=0; i<3; i++) {
WiredHome	78:faf49c381591	3039	display.foreground(Blue);
WiredHome	78:faf49c381591	3040	display.printf(" (%3d,%3d) => ", pTest[i].x, pTest[i].y);
WiredHome	78:faf49c381591	3041	display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, White);
WiredHome	78:faf49c381591	3042	display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, White);
WiredHome	79:544eb4964795	3043	while (!display.TouchPanelA2DFiltered(&x, &y))
WiredHome	78:faf49c381591	3044	wait_ms(20);
WiredHome	78:faf49c381591	3045	pSample[i].x = x;
WiredHome	78:faf49c381591	3046	pSample[i].y = y;
WiredHome	78:faf49c381591	3047	display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, Black);
WiredHome	78:faf49c381591	3048	display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, Black);
WiredHome	78:faf49c381591	3049	display.foreground(Blue);
WiredHome	78:faf49c381591	3050	display.printf(" (%4d,%4d)\r\n", x,y);
WiredHome	79:544eb4964795	3051	while (display.TouchPanelA2DFiltered(&x, &y))
WiredHome	78:faf49c381591	3052	wait_ms(20);
WiredHome	78:faf49c381591	3053	wait(2);
WiredHome	78:faf49c381591	3054	}
WiredHome	81:01da2e34283d	3055	display.TouchPanelComputeCalibration(pTest, pSample, &calmatrix);
WiredHome	78:faf49c381591	3056	display.printf(" Writing calibration to tpcal.cfg\r\n");
WiredHome	78:faf49c381591	3057	FILE * fh = fopen("/local/tpcal.cfg", "wb");
WiredHome	78:faf49c381591	3058	if (fh) {
WiredHome	78:faf49c381591	3059	fwrite(&calmatrix, sizeof(calmatrix), 1, fh);
WiredHome	78:faf49c381591	3060	fclose(fh);
WiredHome	78:faf49c381591	3061	}
WiredHome	78:faf49c381591	3062	display.printf(" Calibration is complete.");
WiredHome	78:faf49c381591	3063	} else if (c == 'r') {
WiredHome	78:faf49c381591	3064	display.printf(" Reading calibration from tpcal.cfg\r\n");
WiredHome	78:faf49c381591	3065	FILE * fh = fopen("/local/tpcal.cfg", "rb");
WiredHome	78:faf49c381591	3066	if (fh) {
WiredHome	78:faf49c381591	3067	fread(&calmatrix, sizeof(calmatrix), 1, fh);
WiredHome	78:faf49c381591	3068	fclose(fh);
WiredHome	78:faf49c381591	3069	}
WiredHome	78:faf49c381591	3070	display.printf(" Calibration is complete.");
WiredHome	78:faf49c381591	3071	display.TouchPanelSetMatrix(&calmatrix);
WiredHome	77:9206c13aa527	3072	}
WiredHome	77:9206c13aa527	3073	t.start();
WiredHome	77:9206c13aa527	3074	do {
WiredHome	77:9206c13aa527	3075	point_t point = {0, 0};
WiredHome	79:544eb4964795	3076	if (display.TouchPanelReadable(&point)) {
WiredHome	77:9206c13aa527	3077	display.pixel(point.x, point.y, Red);
WiredHome	77:9206c13aa527	3078	}
WiredHome	77:9206c13aa527	3079	} while (t.read_ms() < 30000);
WiredHome	77:9206c13aa527	3080	pc.printf(">");
WiredHome	77:9206c13aa527	3081	}
WiredHome	77:9206c13aa527	3082
WiredHome	77:9206c13aa527	3083
WiredHome	41:2956a0a221e5	3084	void SpeedTest(RA8875 & display, Serial & pc)
WiredHome	41:2956a0a221e5	3085	{
WiredHome	41:2956a0a221e5	3086	Timer t;
WiredHome	41:2956a0a221e5	3087	SuppressSlowStuff = true;
WiredHome	41:2956a0a221e5	3088	pc.printf("\r\nSpeedTest disables delays, runs tests, reports overall time.\r\n");
WiredHome	41:2956a0a221e5	3089	t.start();
WiredHome	41:2956a0a221e5	3090	// do stuff fast
WiredHome	41:2956a0a221e5	3091	TextCursorTest(display, pc);
WiredHome	49:c5182231d1b9	3092	TextWrapTest(display, pc);
WiredHome	41:2956a0a221e5	3093	BacklightTest(display, pc, 0);
WiredHome	41:2956a0a221e5	3094	BacklightTest2(display, pc);
WiredHome	41:2956a0a221e5	3095	ExternalFontTest(display, pc);
WiredHome	41:2956a0a221e5	3096	DOSColorTest(display, pc);
WiredHome	41:2956a0a221e5	3097	WebColorTest(display, pc);
WiredHome	41:2956a0a221e5	3098	PixelTest(display, pc);
WiredHome	41:2956a0a221e5	3099	LineTest(display, pc);
WiredHome	41:2956a0a221e5	3100	RectangleTest(display, pc);
WiredHome	41:2956a0a221e5	3101	RoundRectTest(display, pc);
WiredHome	41:2956a0a221e5	3102	TriangleTest(display, pc);
WiredHome	41:2956a0a221e5	3103	CircleTest(display, pc);
WiredHome	41:2956a0a221e5	3104	EllipseTest(display, pc);
WiredHome	44:207594dece70	3105	LayerTest(display, pc);
WiredHome	41:2956a0a221e5	3106	//TestGraphicsBitmap(display, pc);
WiredHome	41:2956a0a221e5	3107	pc.printf("SpeedTest completed in %d msec\r\n", t.read_ms());
WiredHome	73:f22a18707b5e	3108	#ifdef PERF_METRICS
WiredHome	41:2956a0a221e5	3109	display.ReportPerformance(pc);
WiredHome	73:f22a18707b5e	3110	#endif
WiredHome	41:2956a0a221e5	3111	SuppressSlowStuff = false;
WiredHome	41:2956a0a221e5	3112	}
WiredHome	41:2956a0a221e5	3113
WiredHome	44:207594dece70	3114
WiredHome	41:2956a0a221e5	3115	void PrintScreen(RA8875 & display, Serial & pc)
WiredHome	41:2956a0a221e5	3116	{
WiredHome	41:2956a0a221e5	3117	if (!SuppressSlowStuff)
WiredHome	73:f22a18707b5e	3118	pc.printf("PrintScreen\r\n");
WiredHome	41:2956a0a221e5	3119	display.PrintScreen( 0,0, 480,272, "/local/Capture.bmp");
WiredHome	41:2956a0a221e5	3120	}
WiredHome	41:2956a0a221e5	3121
WiredHome	44:207594dece70	3122
WiredHome	23:a50ded45dbaf	3123	void RunTestSet(RA8875 & lcd, Serial & pc)
WiredHome	23:a50ded45dbaf	3124	{
WiredHome	23:a50ded45dbaf	3125	int q = 0;
WiredHome	23:a50ded45dbaf	3126	int automode = 0;
WiredHome	49:c5182231d1b9	3127	const unsigned char modelist[] = "BDWtGLlFROTPCEbw"; // auto-test in this order.
WiredHome	23:a50ded45dbaf	3128
WiredHome	23:a50ded45dbaf	3129	while(1) {
WiredHome	23:a50ded45dbaf	3130	pc.printf("\r\n"
WiredHome	41:2956a0a221e5	3131	"B - Backlight up b - backlight dim\r\n"
WiredHome	41:2956a0a221e5	3132	"D - DOS Colors W - Web Colors\r\n"
WiredHome	41:2956a0a221e5	3133	"t - text cursor G - Graphics Bitmap\r\n"
WiredHome	41:2956a0a221e5	3134	"L - Lines F - external Font\r\n"
WiredHome	41:2956a0a221e5	3135	"R - Rectangles O - rOund rectangles\r\n"
WiredHome	41:2956a0a221e5	3136	"T - Triangles P - Pixels \r\n"
WiredHome	41:2956a0a221e5	3137	"C - Circles E - Ellipses\r\n"
WiredHome	41:2956a0a221e5	3138	"A - Auto Test mode S - Speed Test\r\n"
WiredHome	77:9206c13aa527	3139	"K - Keypad Test s - touch screen test\r\n"
WiredHome	41:2956a0a221e5	3140	"p - print screen r - reset \r\n"
WiredHome	49:c5182231d1b9	3141	"l - layer test w - wrapping text \r\n"
WiredHome	73:f22a18707b5e	3142	#ifdef PERF_METRICS
WiredHome	41:2956a0a221e5	3143	"0 - clear performance 1 - report performance\r\n"
WiredHome	73:f22a18707b5e	3144	#endif
WiredHome	23:a50ded45dbaf	3145	"> ");
WiredHome	23:a50ded45dbaf	3146	if (automode == -1 \|\| pc.readable()) {
WiredHome	23:a50ded45dbaf	3147	automode = -1;
WiredHome	37:f19b7e7449dc	3148	q = pc.getc();
WiredHome	37:f19b7e7449dc	3149	while (pc.readable())
WiredHome	37:f19b7e7449dc	3150	pc.getc();
WiredHome	23:a50ded45dbaf	3151	} else if (automode >= 0) {
WiredHome	23:a50ded45dbaf	3152	q = modelist[automode];
WiredHome	23:a50ded45dbaf	3153	}
WiredHome	23:a50ded45dbaf	3154	switch(q) {
WiredHome	73:f22a18707b5e	3155	#ifdef PERF_METRICS
WiredHome	41:2956a0a221e5	3156	case '0':
WiredHome	41:2956a0a221e5	3157	lcd.ClearPerformance();
WiredHome	41:2956a0a221e5	3158	break;
WiredHome	41:2956a0a221e5	3159	case '1':
WiredHome	41:2956a0a221e5	3160	lcd.ReportPerformance(pc);
WiredHome	41:2956a0a221e5	3161	break;
WiredHome	73:f22a18707b5e	3162	#endif
WiredHome	23:a50ded45dbaf	3163	case 'A':
WiredHome	23:a50ded45dbaf	3164	automode = 0;
WiredHome	23:a50ded45dbaf	3165	break;
WiredHome	23:a50ded45dbaf	3166	case 'B':
WiredHome	41:2956a0a221e5	3167	BacklightTest(lcd, pc, 2);
WiredHome	23:a50ded45dbaf	3168	break;
WiredHome	23:a50ded45dbaf	3169	case 'b':
WiredHome	23:a50ded45dbaf	3170	BacklightTest2(lcd, pc);
WiredHome	23:a50ded45dbaf	3171	break;
WiredHome	23:a50ded45dbaf	3172	case 'D':
WiredHome	23:a50ded45dbaf	3173	DOSColorTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3174	break;
WiredHome	75:ca78388cfd77	3175	case 'K':
WiredHome	75:ca78388cfd77	3176	KeyPadTest(lcd, pc);
WiredHome	75:ca78388cfd77	3177	break;
WiredHome	23:a50ded45dbaf	3178	case 'W':
WiredHome	23:a50ded45dbaf	3179	WebColorTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3180	break;
WiredHome	23:a50ded45dbaf	3181	case 't':
WiredHome	23:a50ded45dbaf	3182	TextCursorTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3183	break;
WiredHome	49:c5182231d1b9	3184	case 'w':
WiredHome	49:c5182231d1b9	3185	TextWrapTest(lcd, pc);
WiredHome	49:c5182231d1b9	3186	break;
WiredHome	23:a50ded45dbaf	3187	case 'F':
WiredHome	23:a50ded45dbaf	3188	ExternalFontTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3189	break;
WiredHome	23:a50ded45dbaf	3190	case 'L':
WiredHome	23:a50ded45dbaf	3191	LineTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3192	break;
WiredHome	44:207594dece70	3193	case 'l':
WiredHome	44:207594dece70	3194	LayerTest(lcd, pc);
WiredHome	44:207594dece70	3195	break;
WiredHome	23:a50ded45dbaf	3196	case 'R':
WiredHome	23:a50ded45dbaf	3197	RectangleTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3198	break;
WiredHome	23:a50ded45dbaf	3199	case 'O':
WiredHome	23:a50ded45dbaf	3200	RoundRectTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3201	break;
WiredHome	41:2956a0a221e5	3202	case 'p':
WiredHome	41:2956a0a221e5	3203	PrintScreen(lcd, pc);
WiredHome	41:2956a0a221e5	3204	break;
WiredHome	41:2956a0a221e5	3205	case 'S':
WiredHome	41:2956a0a221e5	3206	SpeedTest(lcd, pc);
WiredHome	41:2956a0a221e5	3207	break;
WiredHome	77:9206c13aa527	3208	case 's':
WiredHome	77:9206c13aa527	3209	TouchPanelTest(lcd, pc);
WiredHome	77:9206c13aa527	3210	break;
WiredHome	23:a50ded45dbaf	3211	case 'T':
WiredHome	23:a50ded45dbaf	3212	TriangleTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3213	break;
WiredHome	37:f19b7e7449dc	3214	case 'P':
WiredHome	37:f19b7e7449dc	3215	PixelTest(lcd, pc);
WiredHome	37:f19b7e7449dc	3216	break;
WiredHome	37:f19b7e7449dc	3217	case 'G':
WiredHome	37:f19b7e7449dc	3218	TestGraphicsBitmap(lcd, pc);
WiredHome	37:f19b7e7449dc	3219	break;
WiredHome	23:a50ded45dbaf	3220	case 'C':
WiredHome	23:a50ded45dbaf	3221	CircleTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3222	break;
WiredHome	23:a50ded45dbaf	3223	case 'E':
WiredHome	23:a50ded45dbaf	3224	EllipseTest(lcd, pc);
WiredHome	23:a50ded45dbaf	3225	break;
WiredHome	23:a50ded45dbaf	3226	case 'r':
WiredHome	23:a50ded45dbaf	3227	pc.printf("Resetting ...\r\n");
WiredHome	23:a50ded45dbaf	3228	wait_ms(20);
WiredHome	23:a50ded45dbaf	3229	mbed_reset();
WiredHome	23:a50ded45dbaf	3230	break;
WiredHome	75:ca78388cfd77	3231	case ' ':
WiredHome	75:ca78388cfd77	3232	break;
WiredHome	23:a50ded45dbaf	3233	default:
WiredHome	23:a50ded45dbaf	3234	printf("huh?\n");
WiredHome	23:a50ded45dbaf	3235	break;
WiredHome	23:a50ded45dbaf	3236	}
WiredHome	23:a50ded45dbaf	3237	if (automode >= 0) {
WiredHome	23:a50ded45dbaf	3238	automode++;
WiredHome	23:a50ded45dbaf	3239	if (automode >= sizeof(modelist))
WiredHome	23:a50ded45dbaf	3240	automode = 0;
WiredHome	23:a50ded45dbaf	3241	wait_ms(2000);
WiredHome	23:a50ded45dbaf	3242	}
WiredHome	23:a50ded45dbaf	3243	wait_ms(200);
WiredHome	23:a50ded45dbaf	3244	}
WiredHome	23:a50ded45dbaf	3245	}
WiredHome	23:a50ded45dbaf	3246
WiredHome	79:544eb4964795	3247	#endif // TESTENABLE

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	12 Jan 2014
Imports:	363
Forks:	7
Commits:	210
Dependents:	20
Dependencies:	0
Followers:	13
Issues:	2

The code in this repository is MIT licensed.

Components

RA8875: 4" to 8" (WQVGA, WVGA, Multi-Touch, Keypad)