RA8875 - KSM edits to RA8875

Users » kerrysmartin » Code » RA8875

KSM edits to RA8875

RA8875.cpp@163:17526689a3ed, 2019-02-13 (annotated)

Committer:: WiredHome
Date:: Wed Feb 13 04:20:12 2019 +0000
Revision:: 163:17526689a3ed
Parent:: 162:a2d7f1988711
Child:: 164:76edd7d9cb68

Add ability to PrintScreen as an 8-bit bitmap, as an alternate to the default of 24-bit.

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

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning