RA8875 - Library to control a Graphics TFT connected to 4-…

Users » WiredHome » Code » RA8875

Library to control a Graphics TFT connected to 4-wire SPI - revised for the Raio RA8875 Display Controller.

Dependents: FRDM_RA8875_mPaint RA8875_Demo RA8875_KeyPadDemo SignalGenerator ... more

Enhanced touch-screen support - where it previous supported both the Resistive Touch and Capacitive Touch based on the FT5206 Touch Controller, now it also has support for the GSL1680 Touch Controller.

Offline Help Manual (Windows chm)

/media/uploads/WiredHome/ra8875.zip.bin (download, rename to .zip and unzip)

RA8875.cpp@77:9206c13aa527, 2014-12-26 (annotated)

Committer:: WiredHome
Date:: Fri Dec 26 21:34:28 2014 +0000
Revision:: 77:9206c13aa527
Parent:: 75:ca78388cfd77
Child:: 78:faf49c381591

Functioning touch panel updates - added method for calibration and a new API to get the touch in the "display" coordinate system.

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	12 Jan 2014
Imports:	363
Forks:	7
Commits:	210
Dependents:	20
Dependencies:	0
Followers:	13
Issues:	2

The code in this repository is MIT licensed.

Components

RA8875: 4" to 8" (WQVGA, WVGA, Multi-Touch, Keypad)