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@136:224e03d5c31f, 2016-11-16 (annotated)

Committer:: WiredHome
Date:: Wed Nov 16 02:48:45 2016 +0000
Revision:: 136:224e03d5c31f
Parent:: 135:af519fe4ba91
Child:: 137:9e09f6081ef1

JPG Rendering can now write to display in 8-bit color format, not just 16-bit color format.

Who changed what in which revision?

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