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@143:e872d65a710d, 2017-03-19 (annotated)

Committer:: WiredHome
Date:: Sun Mar 19 22:11:04 2017 +0000
Revision:: 143:e872d65a710d
Parent:: 142:6e9bff59878a
Child:: 144:ba002c4b21b3

unbreaking change to SelectDrawingLayer to get the return value as an optional parameter.

Who changed what in which revision?

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