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@109:7b94f06f085b, 2016-03-05 (annotated)

Committer:: WiredHome
Date:: Sat Mar 05 19:22:13 2016 +0000
Revision:: 109:7b94f06f085b
Parent:: 107:f9ccffcb84f1
Child:: 111:efe436c43aba

Updated some data types to more consistently use loc_t and dim_t.

; Added a booleanStream api which is handy for soft fonts. It takes a pixel stream and translates it to forecolor and backcolor.

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