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@144:ba002c4b21b3, 2017-05-06 (annotated)

Committer:: WiredHome
Date:: Sat May 06 20:14:48 2017 +0000
Revision:: 144:ba002c4b21b3
Parent:: 143:e872d65a710d
Child:: 146:373d59f08357

Added ThickLine API

Who changed what in which revision?

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