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@131:5bd6ba2ee4a1, 2016-08-12 (annotated)

Committer:: WiredHome
Date:: Fri Aug 12 11:30:33 2016 +0000
Revision:: 131:5bd6ba2ee4a1
Parent:: 127:db7f2c704693
Child:: 133:e36dcfc2d756
Child:: 139:99ec74e3273f

Added API for BlockMove, and a minor revision to the init to accept a backlight setting directly.

Who changed what in which revision?

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