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@124:1690a7ae871c, 2016-07-31 (annotated)

Committer:: WiredHome
Date:: Sun Jul 31 20:59:01 2016 +0000
Revision:: 124:1690a7ae871c
Parent:: 123:2f45e80fec5f
Child:: 125:7a0b70f56550

Incorporated the Capacitive touch panel APIs in to the base RA8875 driver in a manner that integrated smoothly with the Resistive touch driver.

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