RA8875 - KSM edits to RA8875

Users » kerrysmartin » Code » RA8875

KSM edits to RA8875

RA8875.cpp@176:4ab96d33a8ec, 2019-03-24 (annotated)

Committer:: WiredHome
Date:: Sun Mar 24 14:49:49 2019 +0000
Revision:: 176:4ab96d33a8ec
Parent:: 175:7be3a1fb7fc2

Correct a defect recently introduced, where the resistive touch screen failed to have memory allocated to hold the touch information.

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	11 Jul 2019
Imports:	5
Forks:	0
Commits:	178
Dependents:	1
Dependencies:	0
Followers:	1

RA8875.cpp@176:4ab96d33a8ec, 2019-03-24 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning