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

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

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

Who changed what in which revision?

User	Revision	Line number	New contents of line
WiredHome	78:faf49c381591	1	///
WiredHome	78:faf49c381591	2	/// @mainpage RA8875 Display Controller Driver library
WiredHome	78:faf49c381591	3	///
WiredHome	78:faf49c381591	4	/// The RA8875 Display controller is a powerful interface for low cost displays. It
WiredHome	78:faf49c381591	5	/// can support displays up to 800 x 600 pixels x 16-bit color. Another common
WiredHome	78:faf49c381591	6	/// implementation is 480 x 272 x 16 with two layers. The two layers can be
WiredHome	78:faf49c381591	7	/// exchanged, or blended in various ways (transparency, OR, AND, and more).
WiredHome	78:faf49c381591	8	/// It includes graphics acceleration capabilities for drawing primitives,
WiredHome	78:faf49c381591	9	/// such as line, rectangle, circles, and more.
WiredHome	78:faf49c381591	10	///
WiredHome	101:e0aad446094a	11	/// It is not a display for super-fast animations, video, picture frames and so forth,
WiredHome	101:e0aad446094a	12	/// at least when using the SPI ports. Performance has not been evaluated with one
WiredHome	101:e0aad446094a	13	/// of the parallel port options.
WiredHome	101:e0aad446094a	14	///
WiredHome	78:faf49c381591	15	/// The controller additionally supports backlight control (via PWM), keypad scanning
WiredHome	125:7a0b70f56550	16	/// (for a 4 x 5 matrix) and resistive touch-panel support. Recently support for a
WiredHome	125:7a0b70f56550	17	/// capacitive touch screen was integrated, in a manner that makes the resistive and
WiredHome	125:7a0b70f56550	18	/// capactive interfaces nearly identical.
WiredHome	78:faf49c381591	19	///
WiredHome	78:faf49c381591	20	/// @section Display_Config Display Configuration
WiredHome	78:faf49c381591	21	///
WiredHome	78:faf49c381591	22	/// This section details basics for bringing the display online. At a minimum,
WiredHome	78:faf49c381591	23	/// the display is instantiated. After that any of the available commands
WiredHome	78:faf49c381591	24	/// may be issued.
WiredHome	78:faf49c381591	25	///
WiredHome	78:faf49c381591	26	/// During the instantiation, the display is powered on, cleared, and the backlight
WiredHome	78:faf49c381591	27	/// is energized. Additionally, the keypad and touchscreen features are activated.
WiredHome	78:faf49c381591	28	/// It is important to keep in mind that the keypad had the default mapping, and
WiredHome	78:faf49c381591	29	/// the touchscreen does not have the calibration matrix configured, so additional
WiredHome	78:faf49c381591	30	/// steps may be necessary.
WiredHome	78:faf49c381591	31	///
WiredHome	78:faf49c381591	32	/// @code
WiredHome	78:faf49c381591	33	/// RA8875 lcd(p5, p6, p7, p12, NC, "tft");
WiredHome	81:01da2e34283d	34	/// lcd.init();
WiredHome	78:faf49c381591	35	/// lcd.foreground(Blue);
WiredHome	78:faf49c381591	36	/// lcd.line(0,0, 479,271);
WiredHome	78:faf49c381591	37	/// ...
WiredHome	78:faf49c381591	38	/// @endcode
WiredHome	78:faf49c381591	39	///
WiredHome	78:faf49c381591	40	/// @section Touch_Panel Touch Panel
WiredHome	78:faf49c381591	41	///
WiredHome	78:faf49c381591	42	/// The supported touch panel interface is for a resistive panel, and is natively
WiredHome	78:faf49c381591	43	/// supported by the RA8875 controller. There are a few steps to enable this interface.
WiredHome	78:faf49c381591	44	///
WiredHome	78:faf49c381591	45	/// @subsection Touch_Panel_Enable Touch Panel Enable
WiredHome	78:faf49c381591	46	///
WiredHome	106:c80828f5dea4	47	/// See @ref TouchPanelInit has two forms - fully automatic, and controlled. See the APIs for
WiredHome	78:faf49c381591	48	/// details.
WiredHome	78:faf49c381591	49	///
WiredHome	78:faf49c381591	50	/// @subsection Touch_Panel_Calibration
WiredHome	78:faf49c381591	51	///
WiredHome	78:faf49c381591	52	/// The touch panel is not initially calibrated on startup. The application should
WiredHome	78:faf49c381591	53	/// provide a means to activate the calibration process, and that should not require
WiredHome	78:faf49c381591	54	/// the touchscreen as it may not yet be usable. Alternately, a calibration matrix
WiredHome	78:faf49c381591	55	/// can be loaded from non-volatile and installed.
WiredHome	78:faf49c381591	56	///
WiredHome	78:faf49c381591	57	/// @section Keypad Keypad
WiredHome	78:faf49c381591	58	///
WiredHome	78:faf49c381591	59	/// The keypad has a default keypad mapping, but there is an API that permits
WiredHome	78:faf49c381591	60	/// installing a custom keymap.
WiredHome	78:faf49c381591	61	///
WiredHome	101:e0aad446094a	62	/// @todo Add APIs for the 2nd PWM channel, which might be quite useful as a simple
WiredHome	101:e0aad446094a	63	/// beeper.
WiredHome	101:e0aad446094a	64	/// @todo Figure out how to "init()" in the constructor. I ran into some issues if
WiredHome	101:e0aad446094a	65	/// the display was instantiated before main(), and the code would not run,
WiredHome	101:e0aad446094a	66	/// thus the exposure and activation of the init() function. If the constructor
WiredHome	101:e0aad446094a	67	/// was within main(), then it seemed to work as expected.
WiredHome	101:e0aad446094a	68	///
WiredHome	19:3f82c1161fd2	69	#ifndef RA8875_H
WiredHome	19:3f82c1161fd2	70	#define RA8875_H
WiredHome	19:3f82c1161fd2	71	#include <mbed.h>
WiredHome	19:3f82c1161fd2	72
WiredHome	77:9206c13aa527	73	#include "RA8875_Regs.h"
WiredHome	19:3f82c1161fd2	74	#include "GraphicsDisplay.h"
WiredHome	19:3f82c1161fd2	75
WiredHome	41:2956a0a221e5	76	#define RA8875_DEFAULT_SPI_FREQ 5000000
WiredHome	19:3f82c1161fd2	77
WiredHome	19:3f82c1161fd2	78	// Define this to enable code that monitors the performance of various
WiredHome	19:3f82c1161fd2	79	// graphics commands.
WiredHome	78:faf49c381591	80	//#define PERF_METRICS
WiredHome	19:3f82c1161fd2	81
WiredHome	23:a50ded45dbaf	82	// What better place for some test code than in here and the companion
WiredHome	23:a50ded45dbaf	83	// .cpp file. See also the bottom of this file.
WiredHome	99:66edf771373a	84	//#define TESTENABLE
WiredHome	19:3f82c1161fd2	85
WiredHome	19:3f82c1161fd2	86	/// DOS colors - slightly color enhanced
WiredHome	20:6e2e4a8372eb	87	#define Black (color_t)(RGB(0,0,0))
WiredHome	20:6e2e4a8372eb	88	#define Blue (color_t)(RGB(0,0,187))
WiredHome	20:6e2e4a8372eb	89	#define Green (color_t)(RGB(0,187,0))
WiredHome	20:6e2e4a8372eb	90	#define Cyan (color_t)(RGB(0,187,187))
WiredHome	20:6e2e4a8372eb	91	#define Red (color_t)(RGB(187,0,0))
WiredHome	20:6e2e4a8372eb	92	#define Magenta (color_t)(RGB(187,0,187))
WiredHome	81:01da2e34283d	93	#define Brown (color_t)(RGB(63,63,0))
WiredHome	20:6e2e4a8372eb	94	#define Gray (color_t)(RGB(187,187,187))
WiredHome	20:6e2e4a8372eb	95	#define Charcoal (color_t)(RGB(85,85,85))
WiredHome	62:ba5d33438fda	96	#define BrightBlue (color_t)(RGB(0,0,255))
WiredHome	62:ba5d33438fda	97	#define BrightGreen (color_t)(RGB(0,255,0))
WiredHome	62:ba5d33438fda	98	#define BrightCyan (color_t)(RGB(0,255,255))
WiredHome	62:ba5d33438fda	99	#define BrightRed (color_t)(RGB(255,0,0))
WiredHome	20:6e2e4a8372eb	100	#define Orange (color_t)(RGB(255,85,85))
WiredHome	20:6e2e4a8372eb	101	#define Pink (color_t)(RGB(255,85,255))
WiredHome	81:01da2e34283d	102	#define Yellow (color_t)(RGB(187,187,0))
WiredHome	20:6e2e4a8372eb	103	#define White (color_t)(RGB(255,255,255))
WiredHome	20:6e2e4a8372eb	104
WiredHome	62:ba5d33438fda	105	#define DarkBlue (color_t)(RGB(0,0,63))
WiredHome	62:ba5d33438fda	106	#define DarkGreen (color_t)(RGB(0,63,0))
WiredHome	62:ba5d33438fda	107	#define DarkCyan (color_t)(RGB(0,63,63))
WiredHome	62:ba5d33438fda	108	#define DarkRed (color_t)(RGB(63,0,0))
WiredHome	62:ba5d33438fda	109	#define DarkMagenta (color_t)(RGB(63,0,63))
WiredHome	62:ba5d33438fda	110	#define DarkBrown (color_t)(RGB(63,63,0))
WiredHome	62:ba5d33438fda	111	#define DarkGray (color_t)(RGB(63,63,63))
WiredHome	61:8f3153bf0baa	112
WiredHome	82:f7d300f26540	113	#define min(a,b) ((a<b)?a:b)
WiredHome	82:f7d300f26540	114	#define max(a,b) ((a>b)?a:b)
WiredHome	82:f7d300f26540	115
WiredHome	19:3f82c1161fd2	116
WiredHome	124:1690a7ae871c	117	/// FT5206 definitions follow
WiredHome	124:1690a7ae871c	118	#define FT5206_I2C_FREQUENCY 400000
WiredHome	124:1690a7ae871c	119
WiredHome	124:1690a7ae871c	120	#define FT5206_I2C_ADDRESS 0x38
WiredHome	124:1690a7ae871c	121	#define FT5206_NUMBER_OF_REGISTERS 31 // there are more registers, but this
WiredHome	124:1690a7ae871c	122	// is enough to get all 5 touch coordinates.
WiredHome	124:1690a7ae871c	123
WiredHome	124:1690a7ae871c	124	#define FT5206_NUMBER_OF_TOTAL_REGISTERS 0xFE
WiredHome	124:1690a7ae871c	125
WiredHome	124:1690a7ae871c	126	#define FT5206_DEVICE_MODE 0x00 // Normal, test, etc.
WiredHome	124:1690a7ae871c	127	#define FT5206_GEST_ID 0x01 // Gesture detected
WiredHome	124:1690a7ae871c	128	#define FT5206_TD_STATUS 0x02 // How many points detected (3:0). 1-5 is valid.
WiredHome	124:1690a7ae871c	129
WiredHome	124:1690a7ae871c	130	#define FT5206_TOUCH1_XH 0x03 // Event Flag, Touch X Position
WiredHome	124:1690a7ae871c	131	#define FT5206_TOUCH1_XL 0x04
WiredHome	124:1690a7ae871c	132	#define FT5206_TOUCH1_YH 0x05 // Touch ID, Touch Y Position
WiredHome	124:1690a7ae871c	133	#define FT5206_TOUCH1_YL 0x06
WiredHome	124:1690a7ae871c	134
WiredHome	124:1690a7ae871c	135	#define FT5206_TOUCH2_XH 0x09 // Event Flag, Touch X Position
WiredHome	124:1690a7ae871c	136	#define FT5206_TOUCH2_XL 0x0a
WiredHome	124:1690a7ae871c	137	#define FT5206_TOUCH2_YH 0x0b // Touch ID, Touch Y Position
WiredHome	124:1690a7ae871c	138	#define FT5206_TOUCH2_YL 0x0c
WiredHome	124:1690a7ae871c	139
WiredHome	124:1690a7ae871c	140	#define FT5206_TOUCH3_XH 0x0f // Event Flag, Touch X Position
WiredHome	124:1690a7ae871c	141	#define FT5206_TOUCH3_XL 0x10
WiredHome	124:1690a7ae871c	142	#define FT5206_TOUCH3_YH 0x11 // Touch ID, Touch Y Position
WiredHome	124:1690a7ae871c	143	#define FT5206_TOUCH3_YL 0x12
WiredHome	124:1690a7ae871c	144
WiredHome	124:1690a7ae871c	145	#define FT5206_TOUCH4_XH 0x15 // Event Flag, Touch X Position
WiredHome	124:1690a7ae871c	146	#define FT5206_TOUCH4_XL 0x16
WiredHome	124:1690a7ae871c	147	#define FT5206_TOUCH4_YH 0x17 // Touch ID, Touch Y Position
WiredHome	124:1690a7ae871c	148	#define FT5206_TOUCH4_YL 0x18
WiredHome	124:1690a7ae871c	149
WiredHome	124:1690a7ae871c	150	#define FT5206_TOUCH5_XH 0x1b // Event Flag, Touch X Position
WiredHome	124:1690a7ae871c	151	#define FT5206_TOUCH5_XL 0x1c
WiredHome	124:1690a7ae871c	152	#define FT5206_TOUCH5_YH 0x1d // Touch ID, Touch Y Position
WiredHome	124:1690a7ae871c	153	#define FT5206_TOUCH5_YL 0x1e
WiredHome	124:1690a7ae871c	154
WiredHome	124:1690a7ae871c	155	// For typical usage, the registers listed below are not used.
WiredHome	124:1690a7ae871c	156	#define FT5206_ID_G_THGROUP 0x80 // Valid touching detect threshold
WiredHome	124:1690a7ae871c	157	#define FT5206_ID_G_THPEAK 0x81 // Valid touching peak detect threshold
WiredHome	124:1690a7ae871c	158	#define FT5206_ID_G_THCAL 0x82 // The threshold when calculating the focus of touching
WiredHome	124:1690a7ae871c	159	#define FT5206_ID_G_THWATER 0x83 // The threshold when there is surface water
WiredHome	124:1690a7ae871c	160	#define FT5206_ID_G_THTEMP 0x84 // The threshold of temperature compensation
WiredHome	124:1690a7ae871c	161	#define FT5206_ID_G_CTRL 0x86 // Power control mode
WiredHome	124:1690a7ae871c	162	#define FT5206_ID_G_TIME_ENTER_MONITOR 0x87 // The timer of entering monitor status
WiredHome	124:1690a7ae871c	163	#define FT5206_ID_G_PERIODACTIVE 0x88 // Period Active
WiredHome	124:1690a7ae871c	164	#define FT5206_ID_G_PERIODMONITOR 0x89 // The timer of entering idle while in monitor status
WiredHome	124:1690a7ae871c	165	#define FT5206_ID_G_AUTO_CLB_MODE 0xA0 // Auto calibration mode
WiredHome	124:1690a7ae871c	166
WiredHome	124:1690a7ae871c	167	#define FT5206_TOUCH_LIB_VERSION_H 0xA1 // Firmware Library Version H byte
WiredHome	124:1690a7ae871c	168	#define FT5206_TOUCH_LIB_VERSION_L 0xA2 // Firmware Library Version L byte
WiredHome	124:1690a7ae871c	169	#define FT5206_ID_G_CIPHER 0xA3 // Chip vendor ID
WiredHome	124:1690a7ae871c	170	#define FT5206_G_MODE 0xA4 // The interrupt status to host
WiredHome	124:1690a7ae871c	171	#define FT5206_ID_G_PMODE 0xA5 // Power Consume Mode
WiredHome	124:1690a7ae871c	172	#define FT5206_FIRMID 0xA6 // Firmware ID
WiredHome	124:1690a7ae871c	173	#define FT5206_ID_G_STATE 0xA7 // Running State
WiredHome	124:1690a7ae871c	174	#define FT5206_ID_G_FT5201ID 0xA8 // CTPM Vendor ID
WiredHome	124:1690a7ae871c	175	#define FT5206_ID_G_ERR 0xA9 // Error Code
WiredHome	124:1690a7ae871c	176	#define FT5206_ID_G_CLB 0xAA // Configure TP module during calibration in Test Mode
WiredHome	124:1690a7ae871c	177	#define FT5206_ID_G_B_AREA_TH 0xAE // The threshold of big area
WiredHome	124:1690a7ae871c	178	#define FT5206_LOG_MSG_CNT 0xFE // The log MSG count
WiredHome	124:1690a7ae871c	179	#define FT5206_LOG_CUR_CHA 0xFF // Current character of log message, will point to the next
WiredHome	124:1690a7ae871c	180	// character when one character is read.
WiredHome	124:1690a7ae871c	181	#define FT5206_GEST_ID_MOVE_UP 0x10
WiredHome	124:1690a7ae871c	182	#define FT5206_GEST_ID_MOVE_LEFT 0x14
WiredHome	124:1690a7ae871c	183	#define FT5206_GEST_ID_MOVE_DOWN 0x18
WiredHome	124:1690a7ae871c	184	#define FT5206_GEST_ID_MOVE_RIGHT 0x1c
WiredHome	124:1690a7ae871c	185	#define FT5206_GEST_ID_ZOOM_IN 0x48
WiredHome	124:1690a7ae871c	186	#define FT5206_GEST_ID_ZOOM_OUT 0x49
WiredHome	124:1690a7ae871c	187	#define FT5206_GEST_ID_NO_GESTURE 0x00
WiredHome	124:1690a7ae871c	188
WiredHome	124:1690a7ae871c	189	#define FT5206_EVENT_FLAG_PUT_DOWN 0x00
WiredHome	124:1690a7ae871c	190	#define FT5206_EVENT_FLAG_PUT_UP 0x01
WiredHome	124:1690a7ae871c	191	#define FT5206_EVENT_FLAG_CONTACT 0x02
WiredHome	124:1690a7ae871c	192	#define FT5206_EVENT_FLAG_RESERVED 0x03
WiredHome	124:1690a7ae871c	193
WiredHome	124:1690a7ae871c	194	#define FT5206_ID_G_POLLING_MODE 0x00
WiredHome	124:1690a7ae871c	195	#define FT5206_ID_G_TRIGGER_MODE 0x01
WiredHome	124:1690a7ae871c	196
WiredHome	124:1690a7ae871c	197	#define FT5206_ID_G_PMODE_ACTIVE 0x00
WiredHome	124:1690a7ae871c	198	#define FT5206_ID_G_PMODE_MONITOR 0x01
WiredHome	124:1690a7ae871c	199	#define FT5206_ID_G_PMODE_HIBERNATE 0x03
WiredHome	124:1690a7ae871c	200
WiredHome	124:1690a7ae871c	201	#define FT5206_ID_G_STATE_CONFIGURE 0x00
WiredHome	124:1690a7ae871c	202	#define FT5206_ID_G_STATE_WORK 0x01
WiredHome	124:1690a7ae871c	203	#define FT5206_ID_G_STATE_CALIBRATION 0x02
WiredHome	124:1690a7ae871c	204	#define FT5206_ID_G_STATE_FACTORY 0x03
WiredHome	124:1690a7ae871c	205	#define FT5206_ID_G_STATE_AUTO_CALIBRATION 0x04
WiredHome	124:1690a7ae871c	206	/// end of FT5206 definitions
WiredHome	124:1690a7ae871c	207
WiredHome	124:1690a7ae871c	208
WiredHome	19:3f82c1161fd2	209	//namespace SW_graphics
WiredHome	19:3f82c1161fd2	210	//{
WiredHome	19:3f82c1161fd2	211
WiredHome	96:40b74dd3695b	212	class FPointerDummy; // used by the callback methods.
WiredHome	24:8ca861acf12d	213
WiredHome	21:3c1efb192927	214	/// This is a graphics library for the Raio RA8875 Display Controller chip
WiredHome	21:3c1efb192927	215	/// attached to a 4-wire SPI interface.
WiredHome	21:3c1efb192927	216	///
WiredHome	56:7a85d226ad0d	217	/// It offers both primitive and high level APIs.
WiredHome	56:7a85d226ad0d	218	///
WiredHome	21:3c1efb192927	219	/// Central to this API is a coordinate system, where the origin (0,0) is in
WiredHome	56:7a85d226ad0d	220	/// the top-left corner of the display, and the width (x) extends positive to the
WiredHome	56:7a85d226ad0d	221	/// right and the height (y) extends positive toward the bottom.
WiredHome	21:3c1efb192927	222	///
WiredHome	125:7a0b70f56550	223	/// @note As there are both graphics and text commands, one must take care to use
WiredHome	21:3c1efb192927	224	/// the proper coordinate system for each. Some of the text APIs are in units
WiredHome	29:422616aa04bd	225	/// of column and row, which is measured in character positions (and dependent
WiredHome	56:7a85d226ad0d	226	/// on the font size), where other text APIs permit pixel level positioning.
WiredHome	56:7a85d226ad0d	227	///
WiredHome	56:7a85d226ad0d	228	/// @code
WiredHome	56:7a85d226ad0d	229	/// #include "RA8875.h"
WiredHome	56:7a85d226ad0d	230	/// RA8875 lcd(p5, p6, p7, p12, NC, "tft");
WiredHome	56:7a85d226ad0d	231	///
WiredHome	56:7a85d226ad0d	232	/// int main()
WiredHome	56:7a85d226ad0d	233	/// {
WiredHome	81:01da2e34283d	234	/// lcd.init();
WiredHome	56:7a85d226ad0d	235	/// lcd.printf("printing 3 x 2 = %d", 3*2);
WiredHome	56:7a85d226ad0d	236	/// lcd.circle( 400,25, 25, BrightRed);
WiredHome	56:7a85d226ad0d	237	/// lcd.fillcircle( 400,25, 15, RGB(128,255,128));
WiredHome	56:7a85d226ad0d	238	/// lcd.ellipse( 440,75, 35,20, BrightBlue);
WiredHome	56:7a85d226ad0d	239	/// lcd.fillellipse( 440,75, 25,10, Blue);
WiredHome	56:7a85d226ad0d	240	/// lcd.triangle( 440,100, 475,110, 450,125, Magenta);
WiredHome	56:7a85d226ad0d	241	/// lcd.filltriangle( 445,105, 467,111, 452,120, Cyan);
WiredHome	56:7a85d226ad0d	242	/// lcd.rect( 400,130, 475,155, Brown);
WiredHome	56:7a85d226ad0d	243	/// lcd.fillrect( 405,135, 470,150, Pink);
WiredHome	56:7a85d226ad0d	244	/// lcd.roundrect( 410,160, 475,190, 10,8, Yellow);
WiredHome	56:7a85d226ad0d	245	/// lcd.fillroundrect(415,165, 470,185, 5,3, Orange);
WiredHome	56:7a85d226ad0d	246	/// lcd.line( 430,200, 460,230, RGB(0,255,0));
WiredHome	56:7a85d226ad0d	247	/// for (int i=0; i<=30; i+=5)
WiredHome	56:7a85d226ad0d	248	/// lcd.pixel(435+i,200+i, White);
WiredHome	56:7a85d226ad0d	249	/// }
WiredHome	56:7a85d226ad0d	250	/// @endcode
WiredHome	29:422616aa04bd	251	///
WiredHome	31:c72e12cd5c67	252	/// @todo Add Scroll support for text.
WiredHome	75:ca78388cfd77	253	/// @todo Add Hardware reset signal - but testing to date indicates it is not needed.
WiredHome	44:207594dece70	254	/// @todo Add high level objects - x-y graph, meter, others... but these will
WiredHome	44:207594dece70	255	/// probably be best served in another class, since they may not
WiredHome	44:207594dece70	256	/// be needed for many uses.
WiredHome	21:3c1efb192927	257	///
WiredHome	19:3f82c1161fd2	258	class RA8875 : public GraphicsDisplay
WiredHome	19:3f82c1161fd2	259	{
WiredHome	19:3f82c1161fd2	260	public:
WiredHome	53:86d24b9480b9	261	/// cursor type to be shown as the text cursor.
WiredHome	53:86d24b9480b9	262	typedef enum
WiredHome	53:86d24b9480b9	263	{
WiredHome	53:86d24b9480b9	264	NOCURSOR, ///< cursor is hidden
WiredHome	53:86d24b9480b9	265	IBEAM, ///< \| cursor
WiredHome	53:86d24b9480b9	266	UNDER, ///< _ cursor
WiredHome	53:86d24b9480b9	267	BLOCK ///< Block cursor
WiredHome	53:86d24b9480b9	268	} cursor_t;
WiredHome	53:86d24b9480b9	269
WiredHome	19:3f82c1161fd2	270	/// font type selection.
WiredHome	19:3f82c1161fd2	271	typedef enum
WiredHome	19:3f82c1161fd2	272	{
WiredHome	31:c72e12cd5c67	273	ISO8859_1, ///< ISO8859-1 font
WiredHome	31:c72e12cd5c67	274	ISO8859_2, ///< ISO8859-2 font
WiredHome	31:c72e12cd5c67	275	ISO8859_3, ///< ISO8859-3 font
WiredHome	31:c72e12cd5c67	276	ISO8859_4 ///< ISO8859-4 font
WiredHome	19:3f82c1161fd2	277	} font_t;
WiredHome	19:3f82c1161fd2	278
WiredHome	84:e102021864b5	279	/// display orientation
WiredHome	19:3f82c1161fd2	280	typedef enum
WiredHome	19:3f82c1161fd2	281	{
WiredHome	84:e102021864b5	282	normal, ///< normal (landscape) orientation
WiredHome	84:e102021864b5	283	rotate_0 = normal, ///< alternate to 'normal'
WiredHome	84:e102021864b5	284	rotate_90, ///< rotated clockwise 90 degree
WiredHome	84:e102021864b5	285	rotate_180, ///< rotated (clockwise) 180 degree
WiredHome	84:e102021864b5	286	rotate_270, ///< rotated clockwise 270 degree
WiredHome	84:e102021864b5	287	} orientation_t;
WiredHome	19:3f82c1161fd2	288
WiredHome	19:3f82c1161fd2	289	/// alignment
WiredHome	19:3f82c1161fd2	290	typedef enum
WiredHome	19:3f82c1161fd2	291	{
WiredHome	31:c72e12cd5c67	292	align_none, ///< align - none
WiredHome	31:c72e12cd5c67	293	align_full ///< align - full
WiredHome	19:3f82c1161fd2	294	} alignment_t;
WiredHome	19:3f82c1161fd2	295
WiredHome	127:db7f2c704693	296	/// Font Horizontal Scale factor - 1, 2, 3 4
WiredHome	40:04aa280dfa39	297	typedef int HorizontalScale;
WiredHome	19:3f82c1161fd2	298
WiredHome	127:db7f2c704693	299	/// Font Vertical Scale factor - 1, 2, 3, 4
WiredHome	40:04aa280dfa39	300	typedef int VerticalScale;
WiredHome	19:3f82c1161fd2	301
WiredHome	19:3f82c1161fd2	302	/// Clear screen region
WiredHome	19:3f82c1161fd2	303	typedef enum
WiredHome	19:3f82c1161fd2	304	{
WiredHome	31:c72e12cd5c67	305	FULLWINDOW, ///< Full screen
WiredHome	31:c72e12cd5c67	306	ACTIVEWINDOW ///< active window/region
WiredHome	19:3f82c1161fd2	307	} Region_t;
WiredHome	19:3f82c1161fd2	308
WiredHome	61:8f3153bf0baa	309	/// Set the Layer Display Mode. @ref SetLayerMode
WiredHome	53:86d24b9480b9	310	typedef enum
WiredHome	53:86d24b9480b9	311	{
WiredHome	61:8f3153bf0baa	312	ShowLayer0, ///< Only layer 0 is visible, layer 1 is hidden (default)
WiredHome	56:7a85d226ad0d	313	ShowLayer1, ///< Only layer 1 is visible, layer 0 is hidden
WiredHome	53:86d24b9480b9	314	LightenOverlay, ///< Lighten-overlay mode
WiredHome	53:86d24b9480b9	315	TransparentMode, ///< Transparent mode
WiredHome	53:86d24b9480b9	316	BooleanOR, ///< Boolean OR mode
WiredHome	53:86d24b9480b9	317	BooleanAND, ///< Boolean AND mode
WiredHome	53:86d24b9480b9	318	FloatingWindow ///< Floating Window mode
WiredHome	53:86d24b9480b9	319	} LayerMode_T;
WiredHome	53:86d24b9480b9	320
hexley	54:e117ad10fba6	321	/// Touch Panel modes
hexley	54:e117ad10fba6	322	typedef enum
hexley	54:e117ad10fba6	323	{
hexley	54:e117ad10fba6	324	TP_Auto, ///< Auto touch detection mode
hexley	54:e117ad10fba6	325	TP_Manual, ///< Manual touch detection mode
hexley	54:e117ad10fba6	326	} tpmode_t;
WiredHome	96:40b74dd3695b	327
WiredHome	96:40b74dd3695b	328	/// printscreen callback commands
WiredHome	96:40b74dd3695b	329	typedef enum
WiredHome	96:40b74dd3695b	330	{
WiredHome	96:40b74dd3695b	331	OPEN, ///< command to open the file. cast uint32_t * to the buffer to get the total size to be written.
WiredHome	96:40b74dd3695b	332	WRITE, ///< command to write some data, buffer points to the data and the size is in bytes.
WiredHome	96:40b74dd3695b	333	CLOSE, ///< command to close the file
WiredHome	96:40b74dd3695b	334	} filecmd_t;
WiredHome	96:40b74dd3695b	335
WiredHome	96:40b74dd3695b	336	/// print screen callback
WiredHome	96:40b74dd3695b	337	///
WiredHome	96:40b74dd3695b	338	/// The special form of the print screen will pass one blob at a time
WiredHome	96:40b74dd3695b	339	/// to the callback. There are basic command declaring that the stream
WiredHome	96:40b74dd3695b	340	/// can be opened, a block written, and the stream closed. There is
WiredHome	96:40b74dd3695b	341	/// also a command to communicate the total size being delivered.
WiredHome	96:40b74dd3695b	342	///
WiredHome	96:40b74dd3695b	343	/// @code
WiredHome	96:40b74dd3695b	344	/// lcd.PrintScreen(x,y,w,h,callback);
WiredHome	96:40b74dd3695b	345	/// ...
WiredHome	96:40b74dd3695b	346	/// void callback(filecmd_t cmd, uint8_t * buffer, uint16_t size) {
WiredHome	96:40b74dd3695b	347	/// switch(cmd) {
WiredHome	96:40b74dd3695b	348	/// case OPEN:
WiredHome	96:40b74dd3695b	349	/// pc.printf("About to write %u bytes\r\n", (uint32_t )buffer);
WiredHome	96:40b74dd3695b	350	/// fh = fopen("file.bmp", "w+b");
WiredHome	96:40b74dd3695b	351	/// break;
WiredHome	96:40b74dd3695b	352	/// case WRITE:
WiredHome	96:40b74dd3695b	353	/// fwrite(buffer, size, fh);
WiredHome	96:40b74dd3695b	354	/// break;
WiredHome	96:40b74dd3695b	355	/// case CLOSE:
WiredHome	96:40b74dd3695b	356	/// fclose(fh);
WiredHome	96:40b74dd3695b	357	/// break;
WiredHome	96:40b74dd3695b	358	/// default:
WiredHome	96:40b74dd3695b	359	/// pc.printf("Unexpected callback %d\r\n", cmd);
WiredHome	96:40b74dd3695b	360	/// break;
WiredHome	96:40b74dd3695b	361	/// }
WiredHome	96:40b74dd3695b	362	/// }
WiredHome	96:40b74dd3695b	363	/// @endcode
WiredHome	96:40b74dd3695b	364	///
WiredHome	106:c80828f5dea4	365	/// @param cmd is the command to execute. See @ref filecmd_t.
WiredHome	96:40b74dd3695b	366	/// @param buffer is a pointer to the buffer being passed.
WiredHome	96:40b74dd3695b	367	/// @param size is the number of bytes in the buffer.
WiredHome	123:2f45e80fec5f	368	/// @returns the noerror signal.
WiredHome	96:40b74dd3695b	369	///
WiredHome	96:40b74dd3695b	370	typedef RetCode_t (* PrintCallback_T)(filecmd_t cmd, uint8_t * buffer, uint16_t size);
hexley	54:e117ad10fba6	371
WiredHome	125:7a0b70f56550	372	/// Idle reason provided in the Idle Callback
WiredHome	123:2f45e80fec5f	373	typedef enum {
WiredHome	123:2f45e80fec5f	374	unknown, ///< reason has not been assigned (this should not happen)
WiredHome	123:2f45e80fec5f	375	status_wait, ///< driver is polling the status register while busy
WiredHome	123:2f45e80fec5f	376	command_wait, ///< driver is polling the command register while busy
WiredHome	123:2f45e80fec5f	377	getc_wait, ///< user has called the getc function
WiredHome	123:2f45e80fec5f	378	touch_wait, ///< user has called the touch function
WiredHome	123:2f45e80fec5f	379	touchcal_wait ///< driver is performing a touch calibration
WiredHome	123:2f45e80fec5f	380	} IdleReason_T;
WiredHome	123:2f45e80fec5f	381
WiredHome	123:2f45e80fec5f	382	/// Idle Callback
WiredHome	123:2f45e80fec5f	383	///
WiredHome	123:2f45e80fec5f	384	/// This defines the interface for an idle callback. That is, when the
WiredHome	125:7a0b70f56550	385	/// driver is held up, pending some event, it can call a previously registered
WiredHome	123:2f45e80fec5f	386	/// idle function. This could be most useful for servicing a watchdog.
WiredHome	123:2f45e80fec5f	387	///
WiredHome	123:2f45e80fec5f	388	/// The user code, which is notified via this API, can force the idle
WiredHome	123:2f45e80fec5f	389	/// to abort, by returning the external_abort value back to the driver.
WiredHome	125:7a0b70f56550	390	/// It is important to note that the abort could leave the driver in
WiredHome	125:7a0b70f56550	391	/// an undesireable state, so this should be used with care.
WiredHome	125:7a0b70f56550	392	///
WiredHome	125:7a0b70f56550	393	/// @note Should it be called the BusyCallback? It is true, that it will
WiredHome	125:7a0b70f56550	394	/// call this function when the RA8875 is busy, but this is also
WiredHome	125:7a0b70f56550	395	/// when the CPU is largely idle.
WiredHome	125:7a0b70f56550	396	///
WiredHome	125:7a0b70f56550	397	/// @code
WiredHome	125:7a0b70f56550	398	/// RetCode_t myIdle_handler(RA8875::IdleReason_T reason)
WiredHome	125:7a0b70f56550	399	/// {
WiredHome	125:7a0b70f56550	400	/// idleFlasher = !idleFlasher;
WiredHome	125:7a0b70f56550	401	/// if (it_has_been_too_long())
WiredHome	125:7a0b70f56550	402	/// return external_abort;
WiredHome	125:7a0b70f56550	403	/// else
WiredHome	125:7a0b70f56550	404	/// return noerror;
WiredHome	125:7a0b70f56550	405	/// }
WiredHome	125:7a0b70f56550	406	/// @endcode
WiredHome	125:7a0b70f56550	407	///
WiredHome	125:7a0b70f56550	408	/// @param reason informs the callback why it is idle.
WiredHome	123:2f45e80fec5f	409	/// @returns noerror to allow the driver continue waiting.
WiredHome	123:2f45e80fec5f	410	/// @returns external_abort if the pending action should be aborted.
WiredHome	123:2f45e80fec5f	411	///
WiredHome	125:7a0b70f56550	412	typedef RetCode_t (* IdleCallback_T)(IdleReason_T reason);
WiredHome	123:2f45e80fec5f	413
WiredHome	125:7a0b70f56550	414	/// Basic constructor for a display based on the RAiO RA8875
WiredHome	125:7a0b70f56550	415	/// display controller, which can be used with no touchscreen,
WiredHome	125:7a0b70f56550	416	/// or the RA8875 managed resistive touchscreen.
WiredHome	124:1690a7ae871c	417	///
WiredHome	124:1690a7ae871c	418	/// This constructor differs from the alternate by supportting
WiredHome	124:1690a7ae871c	419	/// either No Touch Screen, or the RA8875 built-in resistive
WiredHome	125:7a0b70f56550	420	/// touch screen. If the application requires the use of the
WiredHome	125:7a0b70f56550	421	/// capacitive touchscreen, the alternate constructor should
WiredHome	125:7a0b70f56550	422	/// be used.
WiredHome	19:3f82c1161fd2	423	///
WiredHome	61:8f3153bf0baa	424	/// This configures the registers and calls the @ref init method.
WiredHome	61:8f3153bf0baa	425	///
WiredHome	56:7a85d226ad0d	426	/// @code
WiredHome	56:7a85d226ad0d	427	/// #include "RA8875.h"
WiredHome	56:7a85d226ad0d	428	/// RA8875 lcd(p5, p6, p7, p12, NC, "tft");
WiredHome	56:7a85d226ad0d	429	///
WiredHome	56:7a85d226ad0d	430	/// int main()
WiredHome	56:7a85d226ad0d	431	/// {
WiredHome	81:01da2e34283d	432	/// lcd.init();
WiredHome	56:7a85d226ad0d	433	/// lcd.printf("printing 3 x 2 = %d", 3*2);
WiredHome	56:7a85d226ad0d	434	/// lcd.circle(400,25, 25, BrightRed);
WiredHome	56:7a85d226ad0d	435	/// }
WiredHome	56:7a85d226ad0d	436	/// @endcode
WiredHome	56:7a85d226ad0d	437	///
WiredHome	72:ecffe56af969	438	/// @param[in] mosi is the SPI master out slave in pin on the mbed.
WiredHome	72:ecffe56af969	439	/// @param[in] miso is the SPI master in slave out pin on the mbed.
WiredHome	72:ecffe56af969	440	/// @param[in] sclk is the SPI shift clock pin on the mbed.
WiredHome	72:ecffe56af969	441	/// @param[in] csel is the DigitalOut pin on the mbed to use as the
WiredHome	19:3f82c1161fd2	442	/// active low chip select for the display controller.
WiredHome	72:ecffe56af969	443	/// @param[in] reset is the DigitalOut pin on the mbed to use as the
WiredHome	19:3f82c1161fd2	444	/// active low reset input on the display controller -
WiredHome	19:3f82c1161fd2	445	/// but this is not currently used.
WiredHome	72:ecffe56af969	446	/// @param[in] name is a text name for this object, which will permit
WiredHome	72:ecffe56af969	447	/// capturing stdout to puts() and printf() directly to it.
WiredHome	19:3f82c1161fd2	448	///
WiredHome	124:1690a7ae871c	449	RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset,
WiredHome	124:1690a7ae871c	450	const char * name = "lcd");
WiredHome	124:1690a7ae871c	451
WiredHome	124:1690a7ae871c	452
WiredHome	124:1690a7ae871c	453	/// Constructor for a display based on the RAiO RA8875
WiredHome	124:1690a7ae871c	454	/// display controller (use for TouchScreen: Capacitive only)
WiredHome	124:1690a7ae871c	455	///
WiredHome	124:1690a7ae871c	456	/// This constructor differs from the alternate by including support
WiredHome	124:1690a7ae871c	457	/// for the Capactive Touch screen.
WiredHome	124:1690a7ae871c	458	///
WiredHome	125:7a0b70f56550	459	/// @code
WiredHome	125:7a0b70f56550	460	/// #include "RA8875.h"
WiredHome	125:7a0b70f56550	461	/// RA8875 lcd(p5, p6, p7, p12, NC, p9,p10,p13, "tft");
WiredHome	125:7a0b70f56550	462	///
WiredHome	125:7a0b70f56550	463	/// int main()
WiredHome	125:7a0b70f56550	464	/// {
WiredHome	125:7a0b70f56550	465	/// lcd.init();
WiredHome	125:7a0b70f56550	466	/// lcd.printf("printing 3 x 2 = %d", 3*2);
WiredHome	125:7a0b70f56550	467	/// lcd.circle(400,25, 25, BrightRed);
WiredHome	125:7a0b70f56550	468	/// TouchCode_t tp = lcd.TouchPanelReadable();
WiredHome	125:7a0b70f56550	469	/// if (tp == touch)
WiredHome	125:7a0b70f56550	470	/// ...
WiredHome	125:7a0b70f56550	471	/// }
WiredHome	125:7a0b70f56550	472	/// @endcode
WiredHome	125:7a0b70f56550	473	///
WiredHome	124:1690a7ae871c	474	/// @param[in] mosi is the SPI master out slave in pin on the mbed.
WiredHome	124:1690a7ae871c	475	/// @param[in] miso is the SPI master in slave out pin on the mbed.
WiredHome	124:1690a7ae871c	476	/// @param[in] sclk is the SPI shift clock pin on the mbed.
WiredHome	124:1690a7ae871c	477	/// @param[in] csel is the DigitalOut pin on the mbed to use as the
WiredHome	124:1690a7ae871c	478	/// active low chip select for the display controller.
WiredHome	124:1690a7ae871c	479	/// @param[in] reset is the DigitalOut pin on the mbed to use as the
WiredHome	124:1690a7ae871c	480	/// active low reset input on the display controller -
WiredHome	124:1690a7ae871c	481	/// but this is not currently used.
WiredHome	124:1690a7ae871c	482	/// @param[in] sda is the I2C Serial Data pin you are wiring to the FT5206.
WiredHome	124:1690a7ae871c	483	/// @param[in] scl is the I2C Serial Clock pin you are wiring to the FT5206.
WiredHome	124:1690a7ae871c	484	/// @param[in] irq is the Interrupt Request pin you are wiring to the FT5206.
WiredHome	124:1690a7ae871c	485	/// @param[in] name is a text name for this object, which will permit
WiredHome	124:1690a7ae871c	486	/// capturing stdout to puts() and printf() directly to it.
WiredHome	124:1690a7ae871c	487	///
WiredHome	124:1690a7ae871c	488	RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset,
WiredHome	124:1690a7ae871c	489	PinName sda, PinName scl, PinName irq, const char * name = "lcd");
WiredHome	124:1690a7ae871c	490
WiredHome	19:3f82c1161fd2	491
WiredHome	45:679c2fb8480c	492	// Destructor doesn't have much to do as this would typically be created
WiredHome	45:679c2fb8480c	493	// at startup, and not at runtime.
WiredHome	19:3f82c1161fd2	494	//~RA8875();
WiredHome	19:3f82c1161fd2	495
WiredHome	79:544eb4964795	496	/// Initialize the driver.
WiredHome	79:544eb4964795	497	///
WiredHome	132:a5d7a8541683	498	/// The RA8875 can control typical displays from the 480x272 to 800x480, and it supports 8 or 16-bit color.
WiredHome	132:a5d7a8541683	499	/// It also supports 2 graphics layers, but it cannot support 2 layers at the maximum color depth and
WiredHome	132:a5d7a8541683	500	/// screen size. When configured under 480x400, it will support both 16-bit color depth and 2 drawing layers.
WiredHome	132:a5d7a8541683	501	/// Above 480x400 it support either 16-bit color, or 2 layers, but not both.
WiredHome	132:a5d7a8541683	502	///
WiredHome	132:a5d7a8541683	503	/// Typical of the displays that are readily purchased, you will find 480x272 and 800x480 resolutions.
WiredHome	106:c80828f5dea4	504	///
WiredHome	81:01da2e34283d	505	/// @param[in] width in pixels to configure the display for. This parameter is optional
WiredHome	81:01da2e34283d	506	/// and the default is 480.
WiredHome	81:01da2e34283d	507	/// @param[in] height in pixels to configure the display for. This parameter is optional
WiredHome	81:01da2e34283d	508	/// and the default is 272.
WiredHome	81:01da2e34283d	509	/// @param[in] color_bpp can be either 8 or 16, but must be consistent
WiredHome	81:01da2e34283d	510	/// with the width and height parameters. This parameter is optional
WiredHome	81:01da2e34283d	511	/// and the default is 16.
WiredHome	131:5bd6ba2ee4a1	512	/// @param[in] poweron defines if the display should be initialized into the power-on or off state.
WiredHome	132:a5d7a8541683	513	/// If power is non-zero(on), the backlight is set to this value. This parameter is optional
WiredHome	131:5bd6ba2ee4a1	514	/// and the default is 255 (on and full brightness). See @ref Power.
WiredHome	81:01da2e34283d	515	/// @param[in] keypadon defines if the keypad support should be enabled. This parameter is optional
WiredHome	106:c80828f5dea4	516	/// and the default is true (enabled). See @ref KeypadInit.
WiredHome	124:1690a7ae871c	517	/// @param[in] touchscreeenon defines if the touchscreen support should be enabled.
WiredHome	132:a5d7a8541683	518	/// This parameter is optional and the default is true (enabled). See @ref TouchPanelInit.
WiredHome	124:1690a7ae871c	519	/// - If the constructor was called with support for the capacitive driver, this
WiredHome	124:1690a7ae871c	520	/// parameter causes the driver to initialize.
WiredHome	124:1690a7ae871c	521	/// - If the constructor was called without support for the capacitive driver, this
WiredHome	124:1690a7ae871c	522	/// parameter is used to enable and initialize the resistive touchscreen driver.
WiredHome	106:c80828f5dea4	523	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	79:544eb4964795	524	///
WiredHome	81:01da2e34283d	525	RetCode_t init(int width = 480, int height = 272, int color_bpp = 16,
WiredHome	131:5bd6ba2ee4a1	526	uint8_t poweron = 255, bool keypadon = true, bool touchscreeenon = true);
WiredHome	124:1690a7ae871c	527
WiredHome	125:7a0b70f56550	528
WiredHome	79:544eb4964795	529	/// Get a pointer to the error code.
WiredHome	79:544eb4964795	530	///
WiredHome	79:544eb4964795	531	/// This method returns a pointer to a text string that matches the
WiredHome	106:c80828f5dea4	532	/// code. See @ref RetCode_t.
WiredHome	79:544eb4964795	533	///
WiredHome	79:544eb4964795	534	/// @param[in] code is the return value from RetCode_t to look up.
WiredHome	79:544eb4964795	535	/// @returns a pointer to the text message representing code. If code
WiredHome	79:544eb4964795	536	/// is not a valid value, then it returns the text for bad_parameter;
WiredHome	125:7a0b70f56550	537	///
WiredHome	79:544eb4964795	538	const char * GetErrorMessage(RetCode_t code);
WiredHome	79:544eb4964795	539
WiredHome	79:544eb4964795	540
WiredHome	50:2c4f474a2453	541	/// Select the drawing layer for subsequent commands.
WiredHome	43:3becae133285	542	///
WiredHome	43:3becae133285	543	/// If the screen configuration is 480 x 272, or if it is 800 x 480
WiredHome	43:3becae133285	544	/// and 8-bit color, the the display supports two layers, which can
WiredHome	43:3becae133285	545	/// be independently drawn on and shown. Additionally, complex
WiredHome	43:3becae133285	546	/// operations involving both layers are permitted.
WiredHome	43:3becae133285	547	///
WiredHome	142:6e9bff59878a	548	/// @attention If the current display configuration does not support
WiredHome	142:6e9bff59878a	549	/// multiple layers, then layer 0 will be selected.
WiredHome	142:6e9bff59878a	550	///
WiredHome	56:7a85d226ad0d	551	/// @code
WiredHome	56:7a85d226ad0d	552	/// //lcd.SetLayerMode(OnlyLayer0); // default is layer 0
WiredHome	56:7a85d226ad0d	553	/// lcd.rect(400,130, 475,155,Brown);
WiredHome	56:7a85d226ad0d	554	/// lcd.SelectDrawingLayer(1);
WiredHome	56:7a85d226ad0d	555	/// lcd.circle(400,25, 25, BrightRed);
WiredHome	56:7a85d226ad0d	556	/// wait(1);
WiredHome	56:7a85d226ad0d	557	/// lcd.SetLayerMode(ShowLayer1);
WiredHome	56:7a85d226ad0d	558	/// @endcode
WiredHome	56:7a85d226ad0d	559	///
WiredHome	61:8f3153bf0baa	560	/// @attention The user manual refers to Layer 1 and Layer 2, however the
WiredHome	61:8f3153bf0baa	561	/// actual register values are value 0 and 1. This API as well as
WiredHome	61:8f3153bf0baa	562	/// others that reference the layers use the values 0 and 1 for
WiredHome	61:8f3153bf0baa	563	/// cleaner iteration in the code.
WiredHome	43:3becae133285	564	///
WiredHome	72:ecffe56af969	565	/// @param[in] layer is 0 or 1 to select the layer for subsequent
WiredHome	61:8f3153bf0baa	566	/// commands.
WiredHome	143:e872d65a710d	567	/// @param[out] prevLayer is an optiona pointer to where the previous layer
WiredHome	143:e872d65a710d	568	/// will be written, making it a little easer to restore layers.
WiredHome	143:e872d65a710d	569	/// Writes 0 or 1 when the pointer is not NULL.
WiredHome	143:e872d65a710d	570	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	143:e872d65a710d	571	///
WiredHome	143:e872d65a710d	572	virtual RetCode_t SelectDrawingLayer(uint16_t layer, uint16_t * prevLayer = NULL);
WiredHome	125:7a0b70f56550	573
WiredHome	43:3becae133285	574
WiredHome	61:8f3153bf0baa	575	/// Get the currently active drawing layer.
WiredHome	61:8f3153bf0baa	576	///
WiredHome	61:8f3153bf0baa	577	/// This returns a value, 0 or 1, based on the screen configuration
WiredHome	61:8f3153bf0baa	578	/// and the currently active drawing layer.
WiredHome	61:8f3153bf0baa	579	///
WiredHome	61:8f3153bf0baa	580	/// @code
WiredHome	61:8f3153bf0baa	581	/// uint16_t prevLayer = lcd.GetDrawingLayer();
WiredHome	61:8f3153bf0baa	582	/// lcd.SelectDrawingLayer(x);
WiredHome	61:8f3153bf0baa	583	/// lcd.circle(400,25, 25, BrightRed);
WiredHome	61:8f3153bf0baa	584	/// lcd.SelectDrawingLayer(prevLayer);
WiredHome	61:8f3153bf0baa	585	/// @endcode
WiredHome	61:8f3153bf0baa	586	///
WiredHome	61:8f3153bf0baa	587	/// @attention The user manual refers to Layer 1 and Layer 2, however the
WiredHome	61:8f3153bf0baa	588	/// actual register values are value 0 and 1. This API as well as
WiredHome	61:8f3153bf0baa	589	/// others that reference the layers use the values 0 and 1 for
WiredHome	61:8f3153bf0baa	590	/// cleaner iteration in the code.
WiredHome	61:8f3153bf0baa	591	///
WiredHome	61:8f3153bf0baa	592	/// @returns the current drawing layer; 0 or 1.
WiredHome	61:8f3153bf0baa	593	///
WiredHome	142:6e9bff59878a	594	virtual uint16_t GetDrawingLayer(void);
WiredHome	125:7a0b70f56550	595
WiredHome	61:8f3153bf0baa	596
WiredHome	44:207594dece70	597	/// Set the Layer presentation mode.
WiredHome	44:207594dece70	598	///
WiredHome	44:207594dece70	599	/// This sets the presentation mode for layers, and permits showing
WiredHome	44:207594dece70	600	/// a single layer, or applying a mode where the two layers
WiredHome	44:207594dece70	601	/// are combined using one of the hardware methods.
WiredHome	44:207594dece70	602	///
WiredHome	61:8f3153bf0baa	603	/// Refer to the RA8875 data sheet for full details.
WiredHome	61:8f3153bf0baa	604	///
WiredHome	56:7a85d226ad0d	605	/// @code
WiredHome	56:7a85d226ad0d	606	/// //lcd.SetLayerMode(OnlyLayer0); // default is layer 0
WiredHome	56:7a85d226ad0d	607	/// lcd.rect(400,130, 475,155,Brown);
WiredHome	56:7a85d226ad0d	608	/// lcd.SelectDrawingLayer(1);
WiredHome	56:7a85d226ad0d	609	/// lcd.circle(400,25, 25, BrightRed);
WiredHome	56:7a85d226ad0d	610	/// wait(1);
WiredHome	56:7a85d226ad0d	611	/// lcd.SetLayerMode(ShowLayer1);
WiredHome	56:7a85d226ad0d	612	/// @endcode
WiredHome	56:7a85d226ad0d	613	///
WiredHome	72:ecffe56af969	614	/// @param[in] mode sets the mode in the Layer Transparency Register.
WiredHome	106:c80828f5dea4	615	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	44:207594dece70	616	///
WiredHome	53:86d24b9480b9	617	RetCode_t SetLayerMode(LayerMode_T mode);
WiredHome	125:7a0b70f56550	618
WiredHome	44:207594dece70	619
WiredHome	82:f7d300f26540	620	/// Get the Layer presentation mode.
WiredHome	82:f7d300f26540	621	///
WiredHome	106:c80828f5dea4	622	/// This gets the current layer mode. See @ref LayerMode_T.
WiredHome	82:f7d300f26540	623	///
WiredHome	82:f7d300f26540	624	/// @returns layer mode.
WiredHome	82:f7d300f26540	625	///
WiredHome	82:f7d300f26540	626	LayerMode_T GetLayerMode(void);
WiredHome	125:7a0b70f56550	627
WiredHome	82:f7d300f26540	628
WiredHome	44:207594dece70	629	/// Set the layer transparency for each layer.
WiredHome	44:207594dece70	630	///
WiredHome	44:207594dece70	631	/// Set the transparency, where the range of values is
WiredHome	44:207594dece70	632	/// from zero (fully visible) to eight (fully transparent).
WiredHome	44:207594dece70	633	/// The input value is automatically limited to this range.
WiredHome	44:207594dece70	634	///
WiredHome	56:7a85d226ad0d	635	/// @code
WiredHome	56:7a85d226ad0d	636	/// // draw something on each layer, then step-fade across
WiredHome	56:7a85d226ad0d	637	/// display.SetLayerMode(RA8875::TransparentMode);
WiredHome	56:7a85d226ad0d	638	/// for (i=0; i<=8; i++) {
WiredHome	56:7a85d226ad0d	639	/// display.SetLayerTransparency(i, 8-i);
WiredHome	56:7a85d226ad0d	640	/// wait_ms(200);
WiredHome	56:7a85d226ad0d	641	/// }
WiredHome	56:7a85d226ad0d	642	/// @endcode
WiredHome	56:7a85d226ad0d	643	///
WiredHome	72:ecffe56af969	644	/// @param[in] layer1 sets the layer 1 transparency.
WiredHome	72:ecffe56af969	645	/// @param[in] layer2 sets the layer 2 transparency.
WiredHome	106:c80828f5dea4	646	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	44:207594dece70	647	///
WiredHome	44:207594dece70	648	RetCode_t SetLayerTransparency(uint8_t layer1, uint8_t layer2);
WiredHome	125:7a0b70f56550	649
WiredHome	44:207594dece70	650
WiredHome	53:86d24b9480b9	651	/// Set the background color register used for transparency.
WiredHome	53:86d24b9480b9	652	///
WiredHome	53:86d24b9480b9	653	/// This command sets the background color registers that are used
WiredHome	53:86d24b9480b9	654	/// in the transparent color operations involving the layers.
WiredHome	53:86d24b9480b9	655	///
WiredHome	72:ecffe56af969	656	/// @param[in] color is optional and expressed in 16-bit format. If not
WiredHome	53:86d24b9480b9	657	/// supplied, a default of Black is used.
WiredHome	106:c80828f5dea4	658	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	53:86d24b9480b9	659	///
WiredHome	53:86d24b9480b9	660	RetCode_t SetBackgroundTransparencyColor(color_t color = RGB(0,0,0));
hexley	54:e117ad10fba6	661
WiredHome	73:f22a18707b5e	662
WiredHome	73:f22a18707b5e	663	/// Get the background color value used for transparency.
WiredHome	73:f22a18707b5e	664	///
WiredHome	73:f22a18707b5e	665	/// This command reads the background color registers that define
WiredHome	73:f22a18707b5e	666	/// the transparency color for operations involving layers.
WiredHome	73:f22a18707b5e	667	///
WiredHome	73:f22a18707b5e	668	/// @returns the color.
WiredHome	73:f22a18707b5e	669	///
WiredHome	73:f22a18707b5e	670	color_t GetBackgroundTransparencyColor(void);
WiredHome	73:f22a18707b5e	671
WiredHome	125:7a0b70f56550	672
hexley	54:e117ad10fba6	673	/// Initialize theTouch Panel controller with default values
hexley	54:e117ad10fba6	674	///
WiredHome	78:faf49c381591	675	/// This activates the simplified touch panel init, which may work for
WiredHome	78:faf49c381591	676	/// most uses. The alternate API is available if fine-grained control
WiredHome	124:1690a7ae871c	677	/// of the numerous settings of the resistive panel is needed.
WiredHome	78:faf49c381591	678	///
WiredHome	106:c80828f5dea4	679	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	56:7a85d226ad0d	680	///
hexley	54:e117ad10fba6	681	RetCode_t TouchPanelInit(void);
hexley	54:e117ad10fba6	682
WiredHome	125:7a0b70f56550	683
hexley	54:e117ad10fba6	684	/// Initialize the Touch Panel controller with detailed settings.
hexley	54:e117ad10fba6	685	///
WiredHome	78:faf49c381591	686	/// This is the detailed touch panel init, which provides the ability
WiredHome	124:1690a7ae871c	687	/// to set nearly every option.
WiredHome	124:1690a7ae871c	688	///
WiredHome	124:1690a7ae871c	689	/// @note If the capacitive touch panel was constructed, this behaves
WiredHome	124:1690a7ae871c	690	/// the same as the simplified version.
WiredHome	78:faf49c381591	691	///
hexley	54:e117ad10fba6	692	/// @param[in] bTpEnable Touch Panel enable/disable control:
hexley	54:e117ad10fba6	693	/// - TP_ENABLE: enable the touch panel
hexley	54:e117ad10fba6	694	/// - TP_DISABLE: disable the touch panel
WiredHome	56:7a85d226ad0d	695	/// @param[in] bTpAutoManual Touch Panel operating mode:
hexley	54:e117ad10fba6	696	/// - TP_MODE_AUTO: automatic capture
hexley	54:e117ad10fba6	697	/// - TP_MODE_MANUAL: manual capture
WiredHome	56:7a85d226ad0d	698	/// @param[in] bTpDebounce Debounce circuit enable for touch panel interrupt:
hexley	54:e117ad10fba6	699	/// - TP_DEBOUNCE_OFF: disable the debounce circuit
hexley	54:e117ad10fba6	700	/// - TP_DEBOUNCE_ON: enable the debounce circuit
WiredHome	56:7a85d226ad0d	701	/// @param[in] bTpManualMode When Manual Mode is selected, this sets the mode:
hexley	54:e117ad10fba6	702	/// - TP_MANUAL_IDLE: touch panel is idle
hexley	54:e117ad10fba6	703	/// - TP_MANUAL_WAIT: wait for touch panel event
hexley	54:e117ad10fba6	704	/// - TP_MANUAL_LATCH_X: latch X data
hexley	54:e117ad10fba6	705	/// - TP_MANUAL_LATCH_Y: latch Y data
WiredHome	56:7a85d226ad0d	706	/// @param[in] bTpAdcClkDiv Sets the ADC clock as a fraction of the System CLK:
hexley	54:e117ad10fba6	707	/// - TP_ADC_CLKDIV_1: Use CLK
hexley	54:e117ad10fba6	708	/// - TP_ADC_CLKDIV_2: Use CLK/2
hexley	54:e117ad10fba6	709	/// - TP_ADC_CLKDIV_4: Use CLK/4
hexley	54:e117ad10fba6	710	/// - TP_ADC_CLKDIV_8: Use CLK/8
hexley	54:e117ad10fba6	711	/// - TP_ADC_CLKDIV_16: Use CLK/16
hexley	54:e117ad10fba6	712	/// - TP_ADC_CLKDIV_32: Use CLK/32
hexley	54:e117ad10fba6	713	/// - TP_ADC_CLKDIV_64: Use CLK/64
hexley	54:e117ad10fba6	714	/// - TP_ADC_CLKDIV_128: Use CLK/128
WiredHome	56:7a85d226ad0d	715	/// @param[in] bTpAdcSampleTime Touch Panel sample time delay before ADC data is ready:
hexley	54:e117ad10fba6	716	/// - TP_ADC_SAMPLE_512_CLKS: Wait 512 system clocks
hexley	54:e117ad10fba6	717	/// - TP_ADC_SAMPLE_1024_CLKS: Wait 1024 system clocks
hexley	54:e117ad10fba6	718	/// - TP_ADC_SAMPLE_2048_CLKS: Wait 2048 system clocks
hexley	54:e117ad10fba6	719	/// - TP_ADC_SAMPLE_4096_CLKS: Wait 4096 system clocks
hexley	54:e117ad10fba6	720	/// - TP_ADC_SAMPLE_8192_CLKS: Wait 8192 system clocks
hexley	54:e117ad10fba6	721	/// - TP_ADC_SAMPLE_16384_CLKS: Wait 16384 system clocks
hexley	54:e117ad10fba6	722	/// - TP_ADC_SAMPLE_32768_CLKS: Wait 32768 system clocks
hexley	54:e117ad10fba6	723	/// - TP_ADC_SAMPLE_65536_CLKS: Wait 65536 system clocks
WiredHome	106:c80828f5dea4	724	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	56:7a85d226ad0d	725	///
WiredHome	78:faf49c381591	726	RetCode_t TouchPanelInit(uint8_t bTpEnable, uint8_t bTpAutoManual, uint8_t bTpDebounce,
WiredHome	78:faf49c381591	727	uint8_t bTpManualMode, uint8_t bTpAdcClkDiv, uint8_t bTpAdcSampleTime);
WiredHome	53:86d24b9480b9	728
WiredHome	123:2f45e80fec5f	729
WiredHome	123:2f45e80fec5f	730	/// Get the screen calibrated point of touch.
WiredHome	123:2f45e80fec5f	731	///
WiredHome	123:2f45e80fec5f	732	/// This method determines if there is a touch and if so it will provide
WiredHome	123:2f45e80fec5f	733	/// the screen-relative touch coordinates. This method can be used in
WiredHome	123:2f45e80fec5f	734	/// a manner similar to Serial.readable(), to determine if there was a
WiredHome	123:2f45e80fec5f	735	/// touch and indicate that - but not care about the coordinates. Alternately,
WiredHome	123:2f45e80fec5f	736	/// if a valid pointer to a point_t is provided, then if a touch is detected
WiredHome	123:2f45e80fec5f	737	/// the point_t will be populated with data.
WiredHome	123:2f45e80fec5f	738	///
WiredHome	123:2f45e80fec5f	739	/// @code
WiredHome	123:2f45e80fec5f	740	/// Timer t;
WiredHome	123:2f45e80fec5f	741	/// t.start();
WiredHome	123:2f45e80fec5f	742	/// do {
WiredHome	123:2f45e80fec5f	743	/// point_t point = {0, 0};
WiredHome	123:2f45e80fec5f	744	/// if (display.TouchPanelReadable(&point)) {
WiredHome	123:2f45e80fec5f	745	/// display.pixel(point, Red);
WiredHome	123:2f45e80fec5f	746	/// }
WiredHome	123:2f45e80fec5f	747	/// } while (t.read_ms() < 30000);
WiredHome	123:2f45e80fec5f	748	/// @endcode
WiredHome	123:2f45e80fec5f	749	///
WiredHome	123:2f45e80fec5f	750	/// @param[out] TouchPoint is a pointer to a point_t, which is set as the touch point, if a touch is registered.
WiredHome	123:2f45e80fec5f	751	/// @returns a value indicating the state of the touch,
WiredHome	123:2f45e80fec5f	752	/// - no_cal: no calibration matrix is available, touch coordinates are not returned.
WiredHome	123:2f45e80fec5f	753	/// - no_touch: no touch is detected, touch coordinates are not returned.
WiredHome	123:2f45e80fec5f	754	/// - touch: touch is detected, touch coordinates are returned.
WiredHome	123:2f45e80fec5f	755	/// - held: held after touch, touch coordinates are returned.
WiredHome	123:2f45e80fec5f	756	/// - release: indicates a release, touch coordinates are returned.
WiredHome	123:2f45e80fec5f	757	///
WiredHome	123:2f45e80fec5f	758	TouchCode_t TouchPanelReadable(point_t * TouchPoint = NULL);
WiredHome	123:2f45e80fec5f	759
WiredHome	125:7a0b70f56550	760
WiredHome	124:1690a7ae871c	761	/// Get the reported touch gesture, if any.
WiredHome	124:1690a7ae871c	762	///
WiredHome	124:1690a7ae871c	763	/// If it could detect a gesture, it will return a value based on
WiredHome	132:a5d7a8541683	764	/// the interpreted gesture.
WiredHome	124:1690a7ae871c	765	///
WiredHome	124:1690a7ae871c	766	/// Valid gesture values are:
WiredHome	124:1690a7ae871c	767	/// @li 0x00 No gesture
WiredHome	132:a5d7a8541683	768	/// @li 0x48 Zoom in
WiredHome	132:a5d7a8541683	769	/// @li 0x49 Zoom out
WiredHome	132:a5d7a8541683	770	///
WiredHome	132:a5d7a8541683	771	/// The following gestures are defined in the FT5206 specification, but
WiredHome	132:a5d7a8541683	772	/// do not appear to work.
WiredHome	124:1690a7ae871c	773	/// @li 0x10 Move up
WiredHome	124:1690a7ae871c	774	/// @li 0x14 Move left
WiredHome	124:1690a7ae871c	775	/// @li 0x18 Move down
WiredHome	124:1690a7ae871c	776	/// @li 0x1C Move right
WiredHome	124:1690a7ae871c	777	///
WiredHome	124:1690a7ae871c	778	/// @returns gesture information.
WiredHome	124:1690a7ae871c	779	///
WiredHome	124:1690a7ae871c	780	uint8_t TouchGesture(void) { return gesture; }
WiredHome	124:1690a7ae871c	781
WiredHome	123:2f45e80fec5f	782
WiredHome	124:1690a7ae871c	783	/// Get the count of registered touches.
WiredHome	124:1690a7ae871c	784	///
WiredHome	124:1690a7ae871c	785	/// @returns count of touch points to communicate; 0 to 5.
WiredHome	124:1690a7ae871c	786	///
WiredHome	124:1690a7ae871c	787	int TouchCount(void) { return numberOfTouchPoints; }
WiredHome	125:7a0b70f56550	788
WiredHome	124:1690a7ae871c	789
WiredHome	124:1690a7ae871c	790	/// Get the count of possible touch channels.
WiredHome	124:1690a7ae871c	791	///
WiredHome	124:1690a7ae871c	792	/// @returns count of touch channels supported by the hardware.
WiredHome	124:1690a7ae871c	793	///
WiredHome	124:1690a7ae871c	794	int TouchChannels(void);
WiredHome	125:7a0b70f56550	795
WiredHome	124:1690a7ae871c	796
WiredHome	124:1690a7ae871c	797	/// Get the Touch ID value for a specified touch channel.
WiredHome	124:1690a7ae871c	798	///
WiredHome	124:1690a7ae871c	799	/// Touch ID is a tracking number based on the order of the touch
WiredHome	124:1690a7ae871c	800	/// detections. The first touch is ID 0, the next is ID 1, and
WiredHome	124:1690a7ae871c	801	/// so on. If the first touch is lifted (no touch), the touch count
WiredHome	124:1690a7ae871c	802	/// decrements, and the remaining touch is communicated on
WiredHome	124:1690a7ae871c	803	/// touch channel zero, even as the Touch ID remains as originally
WiredHome	124:1690a7ae871c	804	/// reported (1 in this example). In this way, it is easy to track
WiredHome	132:a5d7a8541683	805	/// a specific touch.
WiredHome	124:1690a7ae871c	806	///
WiredHome	124:1690a7ae871c	807	/// It is possible to query the data for a channel that is not
WiredHome	124:1690a7ae871c	808	/// presently reported as touched.
WiredHome	124:1690a7ae871c	809	///
WiredHome	124:1690a7ae871c	810	/// @param[in] channel is the touch channel, from 0 to 4, or 0 to getTouchCount()-1
WiredHome	124:1690a7ae871c	811	/// It defaults to 0, in case the user is not interested in multi-touch.
WiredHome	124:1690a7ae871c	812	/// @returns the touch ID, or 15 if you get the ID for an untouched channel.
WiredHome	124:1690a7ae871c	813	/// @returns 0 if an invalid channel is queried.
WiredHome	124:1690a7ae871c	814	///
WiredHome	124:1690a7ae871c	815	uint8_t TouchID(uint8_t channel = 0) { return (channel < 5) ? touchInfo[channel].touchID : touchInfo[0].touchID; }
WiredHome	125:7a0b70f56550	816
WiredHome	124:1690a7ae871c	817
WiredHome	124:1690a7ae871c	818	/// Get the Touch Code for a touch channel.
WiredHome	124:1690a7ae871c	819	///
WiredHome	124:1690a7ae871c	820	/// It is possible to query the data for a channel that is not
WiredHome	124:1690a7ae871c	821	/// presently reported as touched.
WiredHome	124:1690a7ae871c	822	///
WiredHome	124:1690a7ae871c	823	/// @param[in] channel is the touch channel, from 0 to 4, or 0 to getTouchCount()-1
WiredHome	124:1690a7ae871c	824	/// It defaults to 0, in case the user is not interested in multi-touch.
WiredHome	124:1690a7ae871c	825	/// @returns the touch code (@ref TouchCode_t).
WiredHome	124:1690a7ae871c	826	/// @returns channel 0 information if an invalid channel is queried.
WiredHome	124:1690a7ae871c	827	///
WiredHome	124:1690a7ae871c	828	TouchCode_t TouchCode(uint8_t channel = 0) { return (channel < 5) ? touchInfo[channel].touchCode : touchInfo[0].touchCode; }
WiredHome	124:1690a7ae871c	829
WiredHome	125:7a0b70f56550	830
WiredHome	124:1690a7ae871c	831	/// Get the coordinates for a touch channel.
WiredHome	124:1690a7ae871c	832	///
WiredHome	124:1690a7ae871c	833	/// This returns the (X,Y) coordinates for a touch channel.
WiredHome	132:a5d7a8541683	834	///
WiredHome	124:1690a7ae871c	835	///
WiredHome	124:1690a7ae871c	836	/// It is possible to query the data for a channel that is not
WiredHome	124:1690a7ae871c	837	/// presently reported as touched.
WiredHome	124:1690a7ae871c	838	///
WiredHome	124:1690a7ae871c	839	/// @param[in] channel is an optional touch channel, from 0 to 4, or 0 to getTouchCount()-1.
WiredHome	124:1690a7ae871c	840	/// It defaults to 0, in case the user is not interested in multi-touch.
WiredHome	124:1690a7ae871c	841	/// @returns the coordinates as a point_t structure.
WiredHome	124:1690a7ae871c	842	/// @returns channel 0 information if an invalid channel is queried.
WiredHome	124:1690a7ae871c	843	///
WiredHome	124:1690a7ae871c	844	point_t TouchCoordinates(uint8_t channel = 0) { return (channel < 5) ? touchInfo[channel].coordinates : touchInfo[0].coordinates; }
WiredHome	125:7a0b70f56550	845
WiredHome	131:5bd6ba2ee4a1	846
WiredHome	79:544eb4964795	847	/// Poll the TouchPanel and on a touch event return the a to d filtered x, y coordinates.
hexley	54:e117ad10fba6	848	///
WiredHome	78:faf49c381591	849	/// This method reads the touch controller, which has a 10-bit range for each the
WiredHome	79:544eb4964795	850	/// x and the y axis.
WiredHome	79:544eb4964795	851	///
WiredHome	79:544eb4964795	852	/// @note The returned values are not in display (pixel) units but are in analog to
WiredHome	79:544eb4964795	853	/// digital converter units.
WiredHome	78:faf49c381591	854	///
WiredHome	131:5bd6ba2ee4a1	855	/// @note This API is usually not needed and is likely to be deprecated.
WiredHome	131:5bd6ba2ee4a1	856	/// See @ref TouchPanelComputeCalibration.
WiredHome	106:c80828f5dea4	857	/// See @ref TouchPanelReadable.
WiredHome	78:faf49c381591	858	///
WiredHome	79:544eb4964795	859	/// @param[out] x is the x scale a/d value.
WiredHome	79:544eb4964795	860	/// @param[out] y is the y scale a/d value.
WiredHome	83:7bad0068cca0	861	/// @returns a value indicating the state of the touch,
WiredHome	83:7bad0068cca0	862	/// - no_cal: no calibration matrix is available, touch coordinates are not returned.
WiredHome	83:7bad0068cca0	863	/// - no_touch: no touch is detected, touch coordinates are not returned.
WiredHome	83:7bad0068cca0	864	/// - touch: touch is detected, touch coordinates are returned.
WiredHome	83:7bad0068cca0	865	/// - held: held after touch, touch coordinates are returned.
WiredHome	83:7bad0068cca0	866	/// - release: indicates a release, touch coordinates are returned.
WiredHome	56:7a85d226ad0d	867	///
WiredHome	83:7bad0068cca0	868	TouchCode_t TouchPanelA2DFiltered(int x, int y);
hexley	54:e117ad10fba6	869
WiredHome	125:7a0b70f56550	870
WiredHome	79:544eb4964795	871	/// Poll the TouchPanel and on a touch event return the a to d raw x, y coordinates.
hexley	54:e117ad10fba6	872	///
WiredHome	78:faf49c381591	873	/// This method reads the touch controller, which has a 10-bit range for each the
WiredHome	78:faf49c381591	874	/// x and the y axis. A number of samples of the raw data are taken, filtered,
WiredHome	79:544eb4964795	875	/// and the results are returned.
WiredHome	78:faf49c381591	876	///
WiredHome	79:544eb4964795	877	/// @note The returned values are not in display (pixel) units but are in analog to
WiredHome	79:544eb4964795	878	/// digital converter units.
WiredHome	79:544eb4964795	879	///
WiredHome	131:5bd6ba2ee4a1	880	/// @note This API is usually not needed and is likely to be deprecated.
WiredHome	131:5bd6ba2ee4a1	881	/// See @ref TouchPanelComputeCalibration.
WiredHome	106:c80828f5dea4	882	/// See @ref TouchPanelReadable.
WiredHome	78:faf49c381591	883	///
WiredHome	79:544eb4964795	884	/// @param[out] x is the x scale a/d value.
WiredHome	79:544eb4964795	885	/// @param[out] y is the y scale a/d value.
WiredHome	83:7bad0068cca0	886	/// @returns a value indicating the state of the touch,
WiredHome	83:7bad0068cca0	887	/// - no_cal: no calibration matrix is available, touch coordinates are not returned.
WiredHome	83:7bad0068cca0	888	/// - no_touch: no touch is detected, touch coordinates are not returned.
WiredHome	83:7bad0068cca0	889	/// - touch: touch is detected, touch coordinates are returned.
WiredHome	83:7bad0068cca0	890	/// - held: held after touch, touch coordinates are returned.
WiredHome	83:7bad0068cca0	891	/// - release: indicates a release, touch coordinates are returned.
WiredHome	83:7bad0068cca0	892	///
WiredHome	83:7bad0068cca0	893	TouchCode_t TouchPanelA2DRaw(int x, int y);
WiredHome	125:7a0b70f56550	894
WiredHome	83:7bad0068cca0	895
WiredHome	85:022bba13c5c4	896	/// Wait for a touch panel touch and return it.
WiredHome	85:022bba13c5c4	897	///
WiredHome	85:022bba13c5c4	898	/// This method is similar to Serial.getc() in that it will wait for a touch
WiredHome	85:022bba13c5c4	899	/// and then return. In order to extract the coordinates of the touch, a
WiredHome	85:022bba13c5c4	900	/// valid pointer to a point_t must be provided.
WiredHome	85:022bba13c5c4	901	///
WiredHome	85:022bba13c5c4	902	/// @note There is no timeout on this function, so its use is not recommended.
WiredHome	85:022bba13c5c4	903	///
WiredHome	85:022bba13c5c4	904	/// @code
WiredHome	85:022bba13c5c4	905	/// Timer t;
WiredHome	85:022bba13c5c4	906	/// t.start();
WiredHome	85:022bba13c5c4	907	/// do {
WiredHome	85:022bba13c5c4	908	/// point_t point = {0, 0};
WiredHome	85:022bba13c5c4	909	/// display.TouchPanelGet(&point); // hangs here until touch
WiredHome	85:022bba13c5c4	910	/// display.pixel(point, Red);
WiredHome	85:022bba13c5c4	911	/// } while (t.read_ms() < 30000);
WiredHome	85:022bba13c5c4	912	/// @endcode
WiredHome	85:022bba13c5c4	913	///
WiredHome	85:022bba13c5c4	914	/// @param[out] TouchPoint is the touch point, if a touch is registered.
WiredHome	85:022bba13c5c4	915	/// @returns a value indicating the state of the touch,
WiredHome	85:022bba13c5c4	916	/// - no_cal: no calibration matrix is available, touch coordinates are not returned.
WiredHome	85:022bba13c5c4	917	/// - no_touch: no touch is detected, touch coordinates are not returned.
WiredHome	85:022bba13c5c4	918	/// - touch: touch is detected, touch coordinates are returned.
WiredHome	85:022bba13c5c4	919	/// - held: held after touch, touch coordinates are returned.
WiredHome	85:022bba13c5c4	920	/// - release: indicates a release, touch coordinates are returned.
WiredHome	85:022bba13c5c4	921	///
WiredHome	85:022bba13c5c4	922	TouchCode_t TouchPanelGet(point_t * TouchPoint);
WiredHome	85:022bba13c5c4	923
WiredHome	83:7bad0068cca0	924
WiredHome	77:9206c13aa527	925	/// Calibrate the touch panel.
WiredHome	77:9206c13aa527	926	///
WiredHome	77:9206c13aa527	927	/// This method accepts two lists - one list is target points in ,
WiredHome	77:9206c13aa527	928	/// display coordinates and the other is a lit of raw touch coordinate
WiredHome	77:9206c13aa527	929	/// values. It generates a calibration matrix for later use. This
WiredHome	77:9206c13aa527	930	/// matrix is also accessible to the calling API, which may store
WiredHome	77:9206c13aa527	931	/// the matrix in persistent memory and then install the calibration
WiredHome	77:9206c13aa527	932	/// matrix on the next power cycle. By doing so, it can avoid the
WiredHome	77:9206c13aa527	933	/// need to calibrate on every power cycle.
WiredHome	77:9206c13aa527	934	///
WiredHome	81:01da2e34283d	935	/// @note The methods "TouchPanelComputeCalibration", "TouchPanelReadable", and
WiredHome	77:9206c13aa527	936	/// indirectly the "TouchPanelSetMatrix" methods are all derived
WiredHome	77:9206c13aa527	937	/// from a program by Carlos E. Vidales. See the copyright note
WiredHome	77:9206c13aa527	938	/// for further details. See also the article
WiredHome	77:9206c13aa527	939	/// http://www.embedded.com/design/system-integration/4023968/How-To-Calibrate-Touch-Screens
WiredHome	77:9206c13aa527	940	///
WiredHome	77:9206c13aa527	941	/// @copyright Copyright (c) 2001, Carlos E. Vidales. All rights reserved.
WiredHome	78:faf49c381591	942	/// This sample program was written and put in the public domain
WiredHome	78:faf49c381591	943	/// by Carlos E. Vidales. The program is provided "as is"
WiredHome	78:faf49c381591	944	/// without warranty of any kind, either expressed or implied.
WiredHome	78:faf49c381591	945	/// If you choose to use the program within your own products
WiredHome	78:faf49c381591	946	/// you do so at your own risk, and assume the responsibility
WiredHome	78:faf49c381591	947	/// for servicing, repairing or correcting the program should
WiredHome	78:faf49c381591	948	/// it prove defective in any manner.
WiredHome	78:faf49c381591	949	/// You may copy and distribute the program's source code in any
WiredHome	78:faf49c381591	950	/// medium, provided that you also include in each copy an
WiredHome	78:faf49c381591	951	/// appropriate copyright notice and disclaimer of warranty.
WiredHome	78:faf49c381591	952	/// You may also modify this program and distribute copies of
WiredHome	78:faf49c381591	953	/// it provided that you include prominent notices stating
WiredHome	78:faf49c381591	954	/// that you changed the file(s) and the date of any change,
WiredHome	78:faf49c381591	955	/// and that you do not charge any royalties or licenses for
WiredHome	78:faf49c381591	956	/// its use.
WiredHome	77:9206c13aa527	957	///
WiredHome	77:9206c13aa527	958	/// @param[in] display is a pointer to a set of 3 points, which
WiredHome	77:9206c13aa527	959	/// are in display units of measure. These are the targets
WiredHome	77:9206c13aa527	960	/// the calibration was aiming for.
WiredHome	77:9206c13aa527	961	/// @param[in] screen is a pointer to a set of 3 points, which
WiredHome	77:9206c13aa527	962	/// are in touchscreen units of measure. These are the
WiredHome	77:9206c13aa527	963	/// registered touches.
WiredHome	77:9206c13aa527	964	/// @param[out] matrix is an optional parameter to hold the calibration matrix
WiredHome	77:9206c13aa527	965	/// as a result of the calibration. This can be saved in
WiredHome	77:9206c13aa527	966	/// non-volatile memory to recover the calibration after a power fail.
WiredHome	106:c80828f5dea4	967	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	77:9206c13aa527	968	///
WiredHome	81:01da2e34283d	969	RetCode_t TouchPanelComputeCalibration(point_t display[3], point_t screen[3], tpMatrix_t * matrix);
WiredHome	81:01da2e34283d	970
WiredHome	81:01da2e34283d	971
WiredHome	81:01da2e34283d	972	/// Perform the touch panel calibration process.
WiredHome	81:01da2e34283d	973	///
WiredHome	81:01da2e34283d	974	/// This method provides the easy "shortcut" to calibrating the touch panel.
WiredHome	81:01da2e34283d	975	/// The process will automatically generate the calibration points, present
WiredHome	81:01da2e34283d	976	/// the targets on-screen, detect the touches, compute the calibration
WiredHome	81:01da2e34283d	977	/// matrix, and optionally provide the calibration matrix to the calling code
WiredHome	81:01da2e34283d	978	/// for persistence in non-volatile memory.
WiredHome	81:01da2e34283d	979	///
WiredHome	81:01da2e34283d	980	/// @param[out] matrix is an optional parameter to hold the calibration matrix
WiredHome	81:01da2e34283d	981	/// as a result of the calibration. This can be saved in
WiredHome	81:01da2e34283d	982	/// non-volatile memory to recover the calibration after a power fail.
WiredHome	106:c80828f5dea4	983	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	81:01da2e34283d	984	///
WiredHome	85:022bba13c5c4	985	RetCode_t TouchPanelCalibrate(tpMatrix_t * matrix = NULL);
WiredHome	81:01da2e34283d	986
WiredHome	125:7a0b70f56550	987
WiredHome	81:01da2e34283d	988	/// Perform the touch panel calibration process.
WiredHome	81:01da2e34283d	989	///
WiredHome	81:01da2e34283d	990	/// This method provides the easy "shortcut" to calibrating the touch panel.
WiredHome	81:01da2e34283d	991	/// The process will automatically generate the calibration points, present
WiredHome	81:01da2e34283d	992	/// the targets on-screen, detect the touches, compute the calibration
WiredHome	81:01da2e34283d	993	/// matrix, and optionally provide the calibration matrix to the calling code
WiredHome	81:01da2e34283d	994	/// for persistence in non-volatile memory.
WiredHome	81:01da2e34283d	995	///
WiredHome	81:01da2e34283d	996	/// @param[in] msg is a text message to present on the screen during the
WiredHome	81:01da2e34283d	997	/// calibration process.
WiredHome	81:01da2e34283d	998	/// @param[out] matrix is an optional parameter to hold the calibration matrix
WiredHome	81:01da2e34283d	999	/// as a result of the calibration. This can be saved in
WiredHome	81:01da2e34283d	1000	/// non-volatile memory to recover the calibration after a power fail.
WiredHome	88:bfddef6ec836	1001	/// @param[in] maxwait_s is the maximum number of seconds to wait for a touch
WiredHome	88:bfddef6ec836	1002	/// calibration. If no touch panel installed, it then reports
WiredHome	88:bfddef6ec836	1003	/// touch_cal_timeout.
WiredHome	106:c80828f5dea4	1004	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	81:01da2e34283d	1005	///
WiredHome	88:bfddef6ec836	1006	RetCode_t TouchPanelCalibrate(const char * msg, tpMatrix_t * matrix = NULL, int maxwait_s = 15);
WiredHome	77:9206c13aa527	1007
WiredHome	125:7a0b70f56550	1008
WiredHome	77:9206c13aa527	1009	/// Set the calibration matrix for the touch panel.
WiredHome	77:9206c13aa527	1010	///
WiredHome	77:9206c13aa527	1011	/// This method is used to set the calibration matrix for the touch panel. After
WiredHome	106:c80828f5dea4	1012	/// performing the calibration (See @ref TouchPanelComputeCalibration), the matrix can be stored.
WiredHome	77:9206c13aa527	1013	/// On a subsequence power cycle, the matrix may be restored from non-volatile and
WiredHome	77:9206c13aa527	1014	/// passed in to this method. It will then be held to perform the corrections when
WiredHome	77:9206c13aa527	1015	/// reading the touch panel point.
WiredHome	77:9206c13aa527	1016	///
WiredHome	78:faf49c381591	1017	/// @code
WiredHome	78:faf49c381591	1018	/// FILE * fh = fopen("/local/tpmatrix.cfg", "r");
WiredHome	78:faf49c381591	1019	/// if (fh) {
WiredHome	78:faf49c381591	1020	/// tpMatrix_t matrix;
WiredHome	78:faf49c381591	1021	/// if (fread(fh, &matrix, sizeof(tpMatrix_t))) {
WiredHome	78:faf49c381591	1022	/// lcd.TouchPanelSetMatrix(&matrix);
WiredHome	78:faf49c381591	1023	/// }
WiredHome	78:faf49c381591	1024	/// fclose(fh);
WiredHome	78:faf49c381591	1025	/// }
WiredHome	78:faf49c381591	1026	/// @endcode
WiredHome	78:faf49c381591	1027	///
WiredHome	77:9206c13aa527	1028	/// @param[in] matrix is a pointer to the touch panel calibration matrix.
WiredHome	106:c80828f5dea4	1029	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	77:9206c13aa527	1030	///
WiredHome	77:9206c13aa527	1031	RetCode_t TouchPanelSetMatrix(tpMatrix_t * matrix);
WiredHome	78:faf49c381591	1032
WiredHome	125:7a0b70f56550	1033
WiredHome	75:ca78388cfd77	1034	#if 0
hexley	54:e117ad10fba6	1035	/// Append interrupt handler for specific RA8875 interrupt source
hexley	54:e117ad10fba6	1036	///
hexley	54:e117ad10fba6	1037	/// @param[in] bISRType Interrupt Source, should be:
hexley	54:e117ad10fba6	1038	/// - RA8875_INT_KEYSCAN: KEYCAN interrupt
hexley	54:e117ad10fba6	1039	/// - RA8875_INT_DMA: DMA interrupt
hexley	54:e117ad10fba6	1040	/// - RA8875_INT_TP: Touch panel interrupt
hexley	54:e117ad10fba6	1041	/// - RA8875_INT_BTE: BTE process complete interrupt
hexley	54:e117ad10fba6	1042	/// - RA8875_INT_BTEMCU_FONTWR: Multi-purpose interrupt (see spec sheet)
WiredHome	56:7a85d226ad0d	1043	/// @param[in] fptr is a callback function to handle the interrupt event.
WiredHome	56:7a85d226ad0d	1044	/// @returns none
hexley	54:e117ad10fba6	1045	///
hexley	54:e117ad10fba6	1046	void AppendISR(uint8_t bISRType, void(*fptr)(void));
hexley	54:e117ad10fba6	1047
hexley	54:e117ad10fba6	1048	/// Unappend interrupt handler for specific RA8875 interrupt source
hexley	54:e117ad10fba6	1049	///
hexley	54:e117ad10fba6	1050	/// @param[in] bISRType Interrupt Source, should be:
hexley	54:e117ad10fba6	1051	/// - RA8875_INT_KEYSCAN: KEYCAN interrupt
hexley	54:e117ad10fba6	1052	/// - RA8875_INT_DMA: DMA interrupt
hexley	54:e117ad10fba6	1053	/// - RA8875_INT_TP: Touch panel interrupt
hexley	54:e117ad10fba6	1054	/// - RA8875_INT_BTE: BTE process complete interrupt
hexley	54:e117ad10fba6	1055	/// - RA8875_INT_BTEMCU_FONTWR: Multi-purpose interrupt (see spec sheet)
hexley	54:e117ad10fba6	1056	/// @return none
hexley	54:e117ad10fba6	1057	///
hexley	54:e117ad10fba6	1058	void UnAppendISR(uint8_t bISRType);
WiredHome	75:ca78388cfd77	1059	#endif
WiredHome	77:9206c13aa527	1060
WiredHome	125:7a0b70f56550	1061
WiredHome	71:dcac8efd842d	1062	/// Initialize the keypad interface on the RA8875 controller.
WiredHome	71:dcac8efd842d	1063	///
WiredHome	71:dcac8efd842d	1064	/// Enables the keypad subsystem. It will scan the 4 x 5 matrix
WiredHome	131:5bd6ba2ee4a1	1065	/// and make available key presses.
WiredHome	71:dcac8efd842d	1066	///
WiredHome	71:dcac8efd842d	1067	/// @note See section 5-13 of RAIO RA8875 data sheet for more details.
WiredHome	125:7a0b70f56550	1068	/// @note When using the display from buy-display.com, be sure that
WiredHome	71:dcac8efd842d	1069	/// the option for the keypad is configured on the hardware.
WiredHome	71:dcac8efd842d	1070	///
WiredHome	71:dcac8efd842d	1071	/// All parameters are optional.
WiredHome	76:c981284eb513	1072	/// @param[in] scanEnable when true, enables the key scan function (default: true).
WiredHome	76:c981284eb513	1073	/// @param[in] longDetect when true, additionally enables the long key held detection (default: false).
WiredHome	71:dcac8efd842d	1074	/// @param[in] sampleTime setting (range: 0 - 3, default: 0).
WiredHome	71:dcac8efd842d	1075	/// @param[in] scanFrequency setting (range: 0 - 7, default: 0).
WiredHome	71:dcac8efd842d	1076	/// @param[in] longTimeAdjustment (range: 0 - 3, default: 0).
WiredHome	76:c981284eb513	1077	/// @param[in] interruptEnable when true, enables interrupts from keypress (default: false).
WiredHome	76:c981284eb513	1078	/// @param[in] wakeupEnable when true, activates the wakeup function (default: false).
WiredHome	71:dcac8efd842d	1079	///
WiredHome	106:c80828f5dea4	1080	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	71:dcac8efd842d	1081	///
WiredHome	71:dcac8efd842d	1082	RetCode_t KeypadInit(bool scanEnable = true, bool longDetect = false,
WiredHome	71:dcac8efd842d	1083	uint8_t sampleTime = 0, uint8_t scanFrequency = 0,
WiredHome	71:dcac8efd842d	1084	uint8_t longTimeAdjustment = 0,
WiredHome	71:dcac8efd842d	1085	bool interruptEnable = false, bool wakeupEnable = false);
WiredHome	71:dcac8efd842d	1086
WiredHome	125:7a0b70f56550	1087
WiredHome	75:ca78388cfd77	1088	/// Create Key Code definitions for the key matrix.
WiredHome	75:ca78388cfd77	1089	///
WiredHome	75:ca78388cfd77	1090	/// This API provides a table of 22 key-code assignments for the matrix of keys.
WiredHome	75:ca78388cfd77	1091	/// This can be used to translate the keys 1 - 20 into some other value, as
WiredHome	75:ca78388cfd77	1092	/// well as to communicate the "no key" (zero) and "error state" (21).
WiredHome	75:ca78388cfd77	1093	///
WiredHome	75:ca78388cfd77	1094	/// In this way, a keypad could easily emulate a piece of a keyboard, transforming
WiredHome	75:ca78388cfd77	1095	/// 0 - 20 into the values 0, '0', '1', '2', '3', '4', '5', '6', '7', '8',
WiredHome	125:7a0b70f56550	1096	/// '9', '+', '-', '*' , '/', '=', '(bs)', '(cr)', and so on...
WiredHome	75:ca78388cfd77	1097	///
WiredHome	75:ca78388cfd77	1098	/// @code
WiredHome	75:ca78388cfd77	1099	/// // Return Value by Row, Column Example reassignment
WiredHome	75:ca78388cfd77	1100	/// // Column 0 1 2 3 4
WiredHome	75:ca78388cfd77	1101	/// // +-------------------------+ +-------------------------+
WiredHome	76:c981284eb513	1102	/// // Row 0 \| 1 2 3 4 5 \| \| '7' '8' '9' ',' '<-' \|
WiredHome	75:ca78388cfd77	1103	/// // 1 \| 6 7 8 9 10 \| \| '4' '5' '6' '/' '-' \|
WiredHome	75:ca78388cfd77	1104	/// // 2 \| 11 12 13 14 15 \| \| '1' '2' '3' '*' '+' \|
WiredHome	76:c981284eb513	1105	/// // 3 \| 16 17 18 19 20 \| \| '0' '.' '(' ')' '\n' \|
WiredHome	75:ca78388cfd77	1106	/// // +-------------------------+ +-------------------------+
WiredHome	75:ca78388cfd77	1107	/// // Return value 0 = No Key pressed
WiredHome	75:ca78388cfd77	1108	/// // Return value 21 = Error
WiredHome	77:9206c13aa527	1109	/// const uint8_t CodeList[22] =
WiredHome	77:9206c13aa527	1110	/// {0, '7', '8', '9', ',', '\h',
WiredHome	77:9206c13aa527	1111	/// '4', '5', '6', '/', '-',
WiredHome	77:9206c13aa527	1112	/// '1', '2', '3', '*', '+',
WiredHome	77:9206c13aa527	1113	/// '0', '.', '(', ')', '\n',
WiredHome	77:9206c13aa527	1114	/// '\x1b'};
WiredHome	77:9206c13aa527	1115	/// lcd.SetKeyMap(CodeList);
WiredHome	75:ca78388cfd77	1116	/// @endcode
WiredHome	75:ca78388cfd77	1117	///
WiredHome	75:ca78388cfd77	1118	/// @param[in] CodeList is a pointer to an always available byte-array
WiredHome	75:ca78388cfd77	1119	/// where the first 22 bytes are used as the transformation
WiredHome	75:ca78388cfd77	1120	/// from raw code to your reassigned value.
WiredHome	75:ca78388cfd77	1121	/// If CodeList is NULL, the original raw value key map is
WiredHome	75:ca78388cfd77	1122	/// restored.
WiredHome	75:ca78388cfd77	1123	/// @returns noerror.
WiredHome	75:ca78388cfd77	1124	///
WiredHome	75:ca78388cfd77	1125	RetCode_t SetKeyMap(const uint8_t * CodeList = NULL);
WiredHome	75:ca78388cfd77	1126
WiredHome	125:7a0b70f56550	1127
WiredHome	71:dcac8efd842d	1128	/// Determine if a key has been hit
WiredHome	71:dcac8efd842d	1129	///
WiredHome	71:dcac8efd842d	1130	/// @returns true if a key has been hit
WiredHome	71:dcac8efd842d	1131	///
WiredHome	75:ca78388cfd77	1132	bool readable();
WiredHome	71:dcac8efd842d	1133
WiredHome	125:7a0b70f56550	1134
WiredHome	71:dcac8efd842d	1135	/// Blocking read of the keypad.
WiredHome	71:dcac8efd842d	1136	///
WiredHome	125:7a0b70f56550	1137	/// @note: This is a blocking read, so it is important to first call _kbhit()
WiredHome	71:dcac8efd842d	1138	/// to avoid hanging your processes.
WiredHome	71:dcac8efd842d	1139	///
WiredHome	71:dcac8efd842d	1140	/// A keypad connected to the RA8875 is connected in a matrix of 4 rows and 5 columns.
WiredHome	75:ca78388cfd77	1141	/// When pressed, this method will return a code in the range of 1 through 20, reserving
WiredHome	75:ca78388cfd77	1142	/// the value 0 to indicate that no key is pressed.
WiredHome	71:dcac8efd842d	1143	///
WiredHome	71:dcac8efd842d	1144	/// Additionally, if configured to detect a "long press", bit 7 will be set to indicate
WiredHome	71:dcac8efd842d	1145	/// this. In this situation, first a "normal press" would be detected and signaled and
WiredHome	71:dcac8efd842d	1146	/// soon after that a "long press" of the same key would be detected and communicated.
WiredHome	71:dcac8efd842d	1147	///
WiredHome	75:ca78388cfd77	1148	/// @return 8-bit where bit 7 indicates a long press. The remaining bits indicate the
WiredHome	75:ca78388cfd77	1149	/// keypress using 0 = no key pressed, 1 - 20 = the key pressed.
WiredHome	71:dcac8efd842d	1150	///
WiredHome	75:ca78388cfd77	1151	uint8_t getc();
WiredHome	75:ca78388cfd77	1152
WiredHome	82:f7d300f26540	1153
WiredHome	82:f7d300f26540	1154	/// Determine if a point is within a rectangle.
WiredHome	82:f7d300f26540	1155	///
WiredHome	82:f7d300f26540	1156	/// @param[in] rect is a rectangular region to use.
WiredHome	82:f7d300f26540	1157	/// @param[in] p is a point to analyze to see if it is within the rect.
WiredHome	82:f7d300f26540	1158	/// @returns true if p is within rect.
WiredHome	82:f7d300f26540	1159	///
WiredHome	82:f7d300f26540	1160	bool Intersect(rect_t rect, point_t p);
WiredHome	82:f7d300f26540	1161
WiredHome	131:5bd6ba2ee4a1	1162	/// Determine if a rectangle intersects another rectangle.
WiredHome	131:5bd6ba2ee4a1	1163	///
WiredHome	131:5bd6ba2ee4a1	1164	/// @param[in] rect1 is a rectangular region.
WiredHome	131:5bd6ba2ee4a1	1165	/// @param[in] rect2 is a second rectangular region.
WiredHome	131:5bd6ba2ee4a1	1166	/// @returns true if rect1 and rect2 intersect.
WiredHome	131:5bd6ba2ee4a1	1167	///
WiredHome	131:5bd6ba2ee4a1	1168	bool Intersect(rect_t rect1, rect_t rect2);
WiredHome	82:f7d300f26540	1169
WiredHome	38:38d503b4fad6	1170	/// Write a command to the display with a word of data.
WiredHome	38:38d503b4fad6	1171	///
WiredHome	38:38d503b4fad6	1172	/// This is a high level command, and may invoke several primitives.
WiredHome	38:38d503b4fad6	1173	///
WiredHome	72:ecffe56af969	1174	/// @param[in] command is the command to write.
WiredHome	72:ecffe56af969	1175	/// @param[in] data is data to be written to the command register.
WiredHome	106:c80828f5dea4	1176	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	38:38d503b4fad6	1177	///
WiredHome	38:38d503b4fad6	1178	RetCode_t WriteCommandW(uint8_t command, uint16_t data);
WiredHome	38:38d503b4fad6	1179
WiredHome	125:7a0b70f56550	1180
WiredHome	19:3f82c1161fd2	1181	/// Write a command to the display
WiredHome	19:3f82c1161fd2	1182	///
WiredHome	19:3f82c1161fd2	1183	/// This is a high level command, and may invoke several primitives.
WiredHome	19:3f82c1161fd2	1184	///
WiredHome	72:ecffe56af969	1185	/// @param[in] command is the command to write.
WiredHome	72:ecffe56af969	1186	/// @param[in] data is optional data to be written to the command register
WiredHome	19:3f82c1161fd2	1187	/// and only occurs if the data is in the range [0 - 0xFF].
WiredHome	106:c80828f5dea4	1188	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1189	///
WiredHome	32:0e4f2ae512e2	1190	virtual RetCode_t WriteCommand(unsigned char command, unsigned int data = 0xFFFF);
WiredHome	125:7a0b70f56550	1191
WiredHome	19:3f82c1161fd2	1192
WiredHome	38:38d503b4fad6	1193	/// Write a data word to the display
WiredHome	38:38d503b4fad6	1194	///
WiredHome	38:38d503b4fad6	1195	/// This is a high level command, and may invoke several primitives.
WiredHome	38:38d503b4fad6	1196	///
WiredHome	72:ecffe56af969	1197	/// @param[in] data is the data to write.
WiredHome	106:c80828f5dea4	1198	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	38:38d503b4fad6	1199	///
WiredHome	38:38d503b4fad6	1200	RetCode_t WriteDataW(uint16_t data);
WiredHome	125:7a0b70f56550	1201
WiredHome	38:38d503b4fad6	1202
WiredHome	19:3f82c1161fd2	1203	/// Write a data byte to the display
WiredHome	19:3f82c1161fd2	1204	///
WiredHome	19:3f82c1161fd2	1205	/// This is a high level command, and may invoke several primitives.
WiredHome	19:3f82c1161fd2	1206	///
WiredHome	72:ecffe56af969	1207	/// @param[in] data is the data to write.
WiredHome	106:c80828f5dea4	1208	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1209	///
WiredHome	32:0e4f2ae512e2	1210	virtual RetCode_t WriteData(unsigned char data);
WiredHome	125:7a0b70f56550	1211
WiredHome	19:3f82c1161fd2	1212
WiredHome	19:3f82c1161fd2	1213	/// Read a command register
WiredHome	19:3f82c1161fd2	1214	///
WiredHome	72:ecffe56af969	1215	/// @param[in] command is the command register to read.
WiredHome	19:3f82c1161fd2	1216	/// @returns the value read from the register.
WiredHome	19:3f82c1161fd2	1217	///
WiredHome	19:3f82c1161fd2	1218	unsigned char ReadCommand(unsigned char command);
WiredHome	136:224e03d5c31f	1219
WiredHome	136:224e03d5c31f	1220
WiredHome	136:224e03d5c31f	1221	/// Read a word from a command register
WiredHome	136:224e03d5c31f	1222	///
WiredHome	136:224e03d5c31f	1223	/// @param[in] command is the command register to read.
WiredHome	136:224e03d5c31f	1224	/// @returns the value read from the register.
WiredHome	136:224e03d5c31f	1225	///
WiredHome	136:224e03d5c31f	1226	uint16_t ReadCommandW(unsigned char command);
WiredHome	19:3f82c1161fd2	1227
WiredHome	136:224e03d5c31f	1228
WiredHome	41:2956a0a221e5	1229	/// Read a data byte from the display
WiredHome	19:3f82c1161fd2	1230	///
WiredHome	19:3f82c1161fd2	1231	/// This is a high level command, and may invoke several primitives.
WiredHome	19:3f82c1161fd2	1232	///
WiredHome	19:3f82c1161fd2	1233	/// @returns data that was read.
WiredHome	19:3f82c1161fd2	1234	///
WiredHome	19:3f82c1161fd2	1235	unsigned char ReadData(void);
WiredHome	125:7a0b70f56550	1236
WiredHome	19:3f82c1161fd2	1237
WiredHome	41:2956a0a221e5	1238	/// Read a word from the display
WiredHome	41:2956a0a221e5	1239	///
WiredHome	41:2956a0a221e5	1240	/// This is a high level command, and may invoke several primitives.
WiredHome	41:2956a0a221e5	1241	///
WiredHome	41:2956a0a221e5	1242	/// @returns data that was read.
WiredHome	41:2956a0a221e5	1243	///
WiredHome	41:2956a0a221e5	1244	uint16_t ReadDataW(void);
WiredHome	41:2956a0a221e5	1245
WiredHome	125:7a0b70f56550	1246
WiredHome	19:3f82c1161fd2	1247	/// Read the display status
WiredHome	19:3f82c1161fd2	1248	///
WiredHome	19:3f82c1161fd2	1249	/// This is a high level command, and may invoke several primitives.
WiredHome	19:3f82c1161fd2	1250	///
WiredHome	19:3f82c1161fd2	1251	/// @returns data that was read.
WiredHome	19:3f82c1161fd2	1252	///
WiredHome	19:3f82c1161fd2	1253	unsigned char ReadStatus(void);
WiredHome	19:3f82c1161fd2	1254
WiredHome	125:7a0b70f56550	1255
WiredHome	19:3f82c1161fd2	1256	/// get the width in pixels of the currently active font
WiredHome	19:3f82c1161fd2	1257	///
WiredHome	19:3f82c1161fd2	1258	/// @returns font width in pixels.
WiredHome	19:3f82c1161fd2	1259	///
WiredHome	37:f19b7e7449dc	1260	dim_t fontwidth(void);
WiredHome	19:3f82c1161fd2	1261
WiredHome	125:7a0b70f56550	1262
WiredHome	19:3f82c1161fd2	1263	/// get the height in pixels of the currently active font
WiredHome	19:3f82c1161fd2	1264	///
WiredHome	19:3f82c1161fd2	1265	/// @returns font height in pixels.
WiredHome	19:3f82c1161fd2	1266	///
WiredHome	37:f19b7e7449dc	1267	dim_t fontheight(void);
WiredHome	125:7a0b70f56550	1268
WiredHome	19:3f82c1161fd2	1269
WiredHome	19:3f82c1161fd2	1270	/// get the number of colums based on the currently active font
WiredHome	19:3f82c1161fd2	1271	///
WiredHome	19:3f82c1161fd2	1272	/// @returns number of columns.
WiredHome	19:3f82c1161fd2	1273	///
WiredHome	19:3f82c1161fd2	1274	virtual int columns(void);
WiredHome	19:3f82c1161fd2	1275
WiredHome	125:7a0b70f56550	1276
WiredHome	19:3f82c1161fd2	1277	/// get the number of rows based on the currently active font
WiredHome	19:3f82c1161fd2	1278	///
WiredHome	19:3f82c1161fd2	1279	/// @returns number of rows.
WiredHome	19:3f82c1161fd2	1280	///
WiredHome	19:3f82c1161fd2	1281	virtual int rows(void);
WiredHome	19:3f82c1161fd2	1282
WiredHome	125:7a0b70f56550	1283
WiredHome	19:3f82c1161fd2	1284	/// get the screen width in pixels
WiredHome	19:3f82c1161fd2	1285	///
WiredHome	19:3f82c1161fd2	1286	/// @returns screen width in pixels.
WiredHome	19:3f82c1161fd2	1287	///
WiredHome	38:38d503b4fad6	1288	virtual dim_t width(void);
WiredHome	19:3f82c1161fd2	1289
WiredHome	125:7a0b70f56550	1290
WiredHome	19:3f82c1161fd2	1291	/// get the screen height in pixels
WiredHome	19:3f82c1161fd2	1292	///
WiredHome	19:3f82c1161fd2	1293	/// @returns screen height in pixels.
WiredHome	19:3f82c1161fd2	1294	///
WiredHome	38:38d503b4fad6	1295	virtual dim_t height(void);
WiredHome	19:3f82c1161fd2	1296
WiredHome	125:7a0b70f56550	1297
WiredHome	43:3becae133285	1298	/// get the color depth in bits per pixel.
WiredHome	43:3becae133285	1299	///
WiredHome	43:3becae133285	1300	/// @returns 8 or 16 only.
WiredHome	43:3becae133285	1301	///
WiredHome	43:3becae133285	1302	virtual dim_t color_bpp(void);
WiredHome	43:3becae133285	1303
WiredHome	19:3f82c1161fd2	1304	/// Set cursor position based on the current font size.
WiredHome	19:3f82c1161fd2	1305	///
WiredHome	72:ecffe56af969	1306	/// @param[in] column is the horizontal position in character positions
WiredHome	72:ecffe56af969	1307	/// @param[in] row is the vertical position in character positions
WiredHome	106:c80828f5dea4	1308	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1309	///
WiredHome	37:f19b7e7449dc	1310	virtual RetCode_t locate(textloc_t column, textloc_t row);
WiredHome	19:3f82c1161fd2	1311
WiredHome	125:7a0b70f56550	1312
WiredHome	19:3f82c1161fd2	1313	/// Prepare the controller to write text to the screen by positioning
WiredHome	19:3f82c1161fd2	1314	/// the cursor.
WiredHome	19:3f82c1161fd2	1315	///
WiredHome	56:7a85d226ad0d	1316	/// @code
WiredHome	56:7a85d226ad0d	1317	/// lcd.SetTextCursor(100, 25);
WiredHome	56:7a85d226ad0d	1318	/// lcd.puts("Hello");
WiredHome	56:7a85d226ad0d	1319	/// @endcode
WiredHome	56:7a85d226ad0d	1320	///
WiredHome	72:ecffe56af969	1321	/// @param[in] x is the horizontal position in pixels (from the left edge)
WiredHome	72:ecffe56af969	1322	/// @param[in] y is the vertical position in pixels (from the top edge)
WiredHome	106:c80828f5dea4	1323	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1324	///
WiredHome	37:f19b7e7449dc	1325	RetCode_t SetTextCursor(loc_t x, loc_t y);
WiredHome	29:422616aa04bd	1326
WiredHome	125:7a0b70f56550	1327
WiredHome	103:7e0464ca6c5c	1328	/// Prepare the controller to write text to the screen by positioning
WiredHome	103:7e0464ca6c5c	1329	/// the cursor.
WiredHome	103:7e0464ca6c5c	1330	///
WiredHome	103:7e0464ca6c5c	1331	/// @code
WiredHome	103:7e0464ca6c5c	1332	/// point_t point = {100, 25};
WiredHome	103:7e0464ca6c5c	1333	/// lcd.SetTextCursor(point);
WiredHome	103:7e0464ca6c5c	1334	/// lcd.puts("Hello");
WiredHome	103:7e0464ca6c5c	1335	/// @endcode
WiredHome	103:7e0464ca6c5c	1336	///
WiredHome	103:7e0464ca6c5c	1337	/// @param[in] p is the x:y point in pixels from the top-left.
WiredHome	106:c80828f5dea4	1338	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	103:7e0464ca6c5c	1339	///
WiredHome	103:7e0464ca6c5c	1340	RetCode_t SetTextCursor(point_t p);
WiredHome	103:7e0464ca6c5c	1341
WiredHome	125:7a0b70f56550	1342
WiredHome	37:f19b7e7449dc	1343	/// Get the current cursor position in pixels.
WiredHome	37:f19b7e7449dc	1344	///
WiredHome	56:7a85d226ad0d	1345	/// @code
WiredHome	56:7a85d226ad0d	1346	/// point_t point = GetTextCursor();
WiredHome	56:7a85d226ad0d	1347	/// if (point.x > 100 && point.y > 150)
WiredHome	56:7a85d226ad0d	1348	/// //...
WiredHome	56:7a85d226ad0d	1349	/// @endcode
WiredHome	56:7a85d226ad0d	1350	///
WiredHome	37:f19b7e7449dc	1351	/// @returns cursor position.
WiredHome	37:f19b7e7449dc	1352	///
WiredHome	37:f19b7e7449dc	1353	point_t GetTextCursor(void);
WiredHome	37:f19b7e7449dc	1354
WiredHome	125:7a0b70f56550	1355
WiredHome	29:422616aa04bd	1356	/// Get the current cursor horizontal position in pixels.
WiredHome	29:422616aa04bd	1357	///
WiredHome	29:422616aa04bd	1358	/// @returns cursor position horizontal offset.
WiredHome	29:422616aa04bd	1359	///
WiredHome	37:f19b7e7449dc	1360	loc_t GetTextCursor_X(void);
WiredHome	29:422616aa04bd	1361
WiredHome	125:7a0b70f56550	1362
WiredHome	29:422616aa04bd	1363	/// Get the current cursor vertical position in pixels.
WiredHome	29:422616aa04bd	1364	///
WiredHome	29:422616aa04bd	1365	/// @returns cursor position vertical offset.
WiredHome	29:422616aa04bd	1366	///
WiredHome	37:f19b7e7449dc	1367	loc_t GetTextCursor_Y(void);
WiredHome	29:422616aa04bd	1368
WiredHome	125:7a0b70f56550	1369
WiredHome	23:a50ded45dbaf	1370	/// Configure additional Cursor Control settings.
WiredHome	23:a50ded45dbaf	1371	///
WiredHome	23:a50ded45dbaf	1372	/// This API lets you modify other cursor control settings;
WiredHome	23:a50ded45dbaf	1373	/// Cursor visible/hidden, Cursor blink/normal,
WiredHome	23:a50ded45dbaf	1374	/// Cursor I-Beam/underscore/box.
WiredHome	23:a50ded45dbaf	1375	///
WiredHome	72:ecffe56af969	1376	/// @param[in] cursor can be set to NOCURSOR (default), IBEAM,
WiredHome	24:8ca861acf12d	1377	/// UNDER, or BLOCK.
WiredHome	72:ecffe56af969	1378	/// @param[in] blink can be set to true or false (default false)
WiredHome	106:c80828f5dea4	1379	/// @returns success/failure code. See @ref RetCode_t
WiredHome	23:a50ded45dbaf	1380	///
WiredHome	24:8ca861acf12d	1381	RetCode_t SetTextCursorControl(cursor_t cursor = NOCURSOR, bool blink = false);
WiredHome	125:7a0b70f56550	1382
WiredHome	23:a50ded45dbaf	1383
WiredHome	98:ecebed9b80b2	1384	/// Select the built-in ISO 8859-X font to use next.
WiredHome	19:3f82c1161fd2	1385	///
WiredHome	19:3f82c1161fd2	1386	/// Supported fonts: ISO 8859-1, -2, -3, -4
WiredHome	19:3f82c1161fd2	1387	///
WiredHome	125:7a0b70f56550	1388	/// @note This only modifies the choice of font from the RA8875 internal
WiredHome	98:ecebed9b80b2	1389	/// fonts.
WiredHome	98:ecebed9b80b2	1390	///
WiredHome	72:ecffe56af969	1391	/// @param[in] font selects the font for the subsequent text rendering.
WiredHome	19:3f82c1161fd2	1392	///
WiredHome	19:3f82c1161fd2	1393	/// @note if either hScale or vScale is outside of its permitted range,
WiredHome	19:3f82c1161fd2	1394	/// the command is not executed.
WiredHome	106:c80828f5dea4	1395	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1396	///
WiredHome	19:3f82c1161fd2	1397	RetCode_t SetTextFont(font_t font = ISO8859_1);
WiredHome	19:3f82c1161fd2	1398
WiredHome	125:7a0b70f56550	1399
WiredHome	84:e102021864b5	1400	/// Sets the display orientation.
WiredHome	84:e102021864b5	1401	///
WiredHome	84:e102021864b5	1402	/// @note This command does not let you "merge" text onto an existing
WiredHome	84:e102021864b5	1403	/// image, since it reuses the memory for the new orientation.
WiredHome	84:e102021864b5	1404	/// Therefore, it is recommended that you issue a cls() prior
WiredHome	84:e102021864b5	1405	/// to sending text to the screen, or you end with a blended
WiredHome	84:e102021864b5	1406	/// image that is probably not as intended.
WiredHome	84:e102021864b5	1407	///
WiredHome	125:7a0b70f56550	1408	/// @note This command only operates on the RA8875 internal fonts.
WiredHome	98:ecebed9b80b2	1409	///
WiredHome	84:e102021864b5	1410	/// @code
WiredHome	84:e102021864b5	1411	/// lcd.cls();
WiredHome	84:e102021864b5	1412	/// lcd.SetOrientation(RA8875::normal);
WiredHome	84:e102021864b5	1413	/// lcd.puts(30,30, "Normal Landscape");
WiredHome	84:e102021864b5	1414	/// wait_ms(2500);
WiredHome	84:e102021864b5	1415	///
WiredHome	84:e102021864b5	1416	/// lcd.cls();
WiredHome	84:e102021864b5	1417	/// lcd.SetOrientation(RA8875::rotate_90);
WiredHome	84:e102021864b5	1418	/// lcd.puts(30,30, "Rotated 90 Text\r\n");
WiredHome	84:e102021864b5	1419	/// wait_ms(2500);
WiredHome	84:e102021864b5	1420	///
WiredHome	84:e102021864b5	1421	/// lcd.cls();
WiredHome	84:e102021864b5	1422	/// lcd.SetOrientation(RA8875::rotate_180);
WiredHome	84:e102021864b5	1423	/// lcd.puts(30,30, "Rotated 180 Text\r\n");
WiredHome	84:e102021864b5	1424	/// wait_ms(2500);
WiredHome	84:e102021864b5	1425	///
WiredHome	84:e102021864b5	1426	/// lcd.cls();
WiredHome	84:e102021864b5	1427	/// lcd.SetOrientation(RA8875::rotate_270);
WiredHome	84:e102021864b5	1428	/// lcd.puts(30,30, "Rotated 270 Text\r\n");
WiredHome	84:e102021864b5	1429	/// wait_ms(2500);
WiredHome	84:e102021864b5	1430	/// @endcode
WiredHome	84:e102021864b5	1431	///
WiredHome	84:e102021864b5	1432	/// @param[in] angle defaults to normal, but can be rotated
WiredHome	84:e102021864b5	1433	/// - normal \| rotate_0
WiredHome	84:e102021864b5	1434	/// - rotate_90 (clockwise)
WiredHome	84:e102021864b5	1435	/// - rotate_180
WiredHome	84:e102021864b5	1436	/// - rotate_270 (clockwise)
WiredHome	106:c80828f5dea4	1437	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	84:e102021864b5	1438	///
WiredHome	84:e102021864b5	1439	RetCode_t SetOrientation(orientation_t angle = normal);
WiredHome	84:e102021864b5	1440
WiredHome	125:7a0b70f56550	1441
WiredHome	19:3f82c1161fd2	1442	/// Control the font behavior.
WiredHome	19:3f82c1161fd2	1443	///
WiredHome	19:3f82c1161fd2	1444	/// This command lets you make several modifications to any text that
WiredHome	56:7a85d226ad0d	1445	/// will be written to the screen.
WiredHome	19:3f82c1161fd2	1446	///
WiredHome	125:7a0b70f56550	1447	/// @note This command only operates on the RA8875 internal fonts.
WiredHome	98:ecebed9b80b2	1448	///
WiredHome	19:3f82c1161fd2	1449	/// Options can be combined:
WiredHome	19:3f82c1161fd2	1450	/// Default:
WiredHome	19:3f82c1161fd2	1451	/// @li Full alignment disabled,
WiredHome	19:3f82c1161fd2	1452	/// @li Font with Background color,
WiredHome	84:e102021864b5	1453	/// @li Font in normal orientiation, or rotated 90, 180, or 270 clockwise,
WiredHome	84:e102021864b5	1454	/// @li Horizontal scale x 1, 2, 3, or 4
WiredHome	84:e102021864b5	1455	/// @li Vertical scale x 1, 2, 3, or 4
WiredHome	84:e102021864b5	1456	///
WiredHome	84:e102021864b5	1457	/// @note alignment is a special mode for the fonts, when mixing half and
WiredHome	84:e102021864b5	1458	/// full fonts on one presentation. 'align_full' starts each full
WiredHome	84:e102021864b5	1459	/// character on an even alignment. See section 7-4-7 of the RA8875
WiredHome	84:e102021864b5	1460	/// specification.
WiredHome	19:3f82c1161fd2	1461	///
WiredHome	72:ecffe56af969	1462	/// @param[in] fillit defaults to FILL, but can be NOFILL
WiredHome	72:ecffe56af969	1463	/// @param[in] hScale defaults to 1, but can be 1, 2, 3, or 4,
WiredHome	19:3f82c1161fd2	1464	/// and scales the font size by this amount.
WiredHome	72:ecffe56af969	1465	/// @param[in] vScale defaults to 1, but can be 1, 2, 3, or 4,
WiredHome	19:3f82c1161fd2	1466	/// and scales the font size by this amount.
WiredHome	72:ecffe56af969	1467	/// @param[in] alignment defaults to align_none, but can be
WiredHome	19:3f82c1161fd2	1468	/// align_full.
WiredHome	19:3f82c1161fd2	1469	///
WiredHome	19:3f82c1161fd2	1470	/// @note if either hScale or vScale is outside of its permitted range,
WiredHome	19:3f82c1161fd2	1471	/// the command is not executed.
WiredHome	106:c80828f5dea4	1472	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1473	///
WiredHome	19:3f82c1161fd2	1474	RetCode_t SetTextFontControl(fill_t fillit = FILL,
WiredHome	19:3f82c1161fd2	1475	HorizontalScale hScale = 1,
WiredHome	19:3f82c1161fd2	1476	VerticalScale vScale = 1,
WiredHome	19:3f82c1161fd2	1477	alignment_t alignment = align_none);
WiredHome	19:3f82c1161fd2	1478
WiredHome	125:7a0b70f56550	1479
WiredHome	98:ecebed9b80b2	1480	/// Control the font size of the RA8875 internal fonts.
WiredHome	19:3f82c1161fd2	1481	///
WiredHome	19:3f82c1161fd2	1482	/// This command lets you set the font enlargement for both horizontal
WiredHome	19:3f82c1161fd2	1483	/// and vertical, independent of the rotation, background, and
WiredHome	106:c80828f5dea4	1484	/// alignment. See @ref SetTextFontControl.
WiredHome	19:3f82c1161fd2	1485	///
WiredHome	125:7a0b70f56550	1486	/// @note This command only operates on the RA8875 internal fonts.
WiredHome	98:ecebed9b80b2	1487	///
WiredHome	72:ecffe56af969	1488	/// @param[in] hScale defaults to 1, but can be 1, 2, 3, or 4,
WiredHome	19:3f82c1161fd2	1489	/// and scales the font size by this amount.
WiredHome	72:ecffe56af969	1490	/// @param[in] vScale is an optional parameter that defaults to the hScale value,
WiredHome	40:04aa280dfa39	1491	/// but can be 1, 2, 3, or 4, and scales the font size by this amount.
WiredHome	40:04aa280dfa39	1492	///
WiredHome	40:04aa280dfa39	1493	/// @code
WiredHome	40:04aa280dfa39	1494	/// lcd.SetTextFontSize(2); // Set the font to 2x normal size
WiredHome	56:7a85d226ad0d	1495	/// lcd.puts("Two times");
WiredHome	40:04aa280dfa39	1496	/// lcd.SetTextFontSize(2,3); // Set the font to 2x Width and 3x Height
WiredHome	56:7a85d226ad0d	1497	/// lcd.puts("22 3h");
WiredHome	40:04aa280dfa39	1498	/// lcd.SetTextFontSize(); // Restore to normal size in both dimensions
WiredHome	56:7a85d226ad0d	1499	/// lcd.puts("normal");
WiredHome	40:04aa280dfa39	1500	/// @endcode
WiredHome	19:3f82c1161fd2	1501	///
WiredHome	19:3f82c1161fd2	1502	/// @note if either hScale or vScale is outside of its permitted range,
WiredHome	19:3f82c1161fd2	1503	/// the command is not executed.
WiredHome	106:c80828f5dea4	1504	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1505	///
WiredHome	40:04aa280dfa39	1506	RetCode_t SetTextFontSize(HorizontalScale hScale = 1, VerticalScale vScale = -1);
WiredHome	127:db7f2c704693	1507
WiredHome	127:db7f2c704693	1508
WiredHome	127:db7f2c704693	1509	/// Get the text font size of the RA8875 internal fonts.
WiredHome	127:db7f2c704693	1510	///
WiredHome	127:db7f2c704693	1511	/// This command lets you retrieve the current settings for the font
WiredHome	127:db7f2c704693	1512	/// horizontal and vertical scale factors. The return value is
WiredHome	127:db7f2c704693	1513	/// one of the scale factors 1, 2, 3, or 4.
WiredHome	127:db7f2c704693	1514	///
WiredHome	127:db7f2c704693	1515	/// @param[out] hScale is a pointer to memory where the horizontal scale factor
WiredHome	127:db7f2c704693	1516	/// will be written. If the pointer is null, that item will be ignored.
WiredHome	127:db7f2c704693	1517	/// @param[out] vScale is a pointer to memory where the vertical scale factor
WiredHome	127:db7f2c704693	1518	/// will be written. If the pointer is null, that item will be ignored.
WiredHome	127:db7f2c704693	1519	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	127:db7f2c704693	1520	///
WiredHome	127:db7f2c704693	1521	RetCode_t GetTextFontSize(HorizontalScale * hScale, VerticalScale * vScale);
WiredHome	125:7a0b70f56550	1522
WiredHome	19:3f82c1161fd2	1523	/// put a character on the screen.
WiredHome	19:3f82c1161fd2	1524	///
WiredHome	72:ecffe56af969	1525	/// @param[in] c is the character.
WiredHome	19:3f82c1161fd2	1526	/// @returns the character, or EOF if there is an error.
WiredHome	19:3f82c1161fd2	1527	///
WiredHome	19:3f82c1161fd2	1528	virtual int _putc(int c);
WiredHome	19:3f82c1161fd2	1529
WiredHome	125:7a0b70f56550	1530
WiredHome	19:3f82c1161fd2	1531	/// Write string of text to the display
WiredHome	19:3f82c1161fd2	1532	///
WiredHome	56:7a85d226ad0d	1533	/// @code
WiredHome	56:7a85d226ad0d	1534	/// lcd.puts("Test STring");
WiredHome	56:7a85d226ad0d	1535	/// @endcode
WiredHome	56:7a85d226ad0d	1536	///
WiredHome	72:ecffe56af969	1537	/// @param[in] string is the null terminated string to send to the display.
WiredHome	19:3f82c1161fd2	1538	///
WiredHome	19:3f82c1161fd2	1539	void puts(const char * string);
WiredHome	125:7a0b70f56550	1540
WiredHome	19:3f82c1161fd2	1541
WiredHome	19:3f82c1161fd2	1542	/// Write string of text to the display at the specified location.
WiredHome	19:3f82c1161fd2	1543	///
WiredHome	56:7a85d226ad0d	1544	/// @code
WiredHome	56:7a85d226ad0d	1545	/// lcd.puts(10,25, "Test STring");
WiredHome	56:7a85d226ad0d	1546	/// @endcode
WiredHome	56:7a85d226ad0d	1547	///
WiredHome	72:ecffe56af969	1548	/// @param[in] x is the horizontal position in pixels (from the left edge)
WiredHome	72:ecffe56af969	1549	/// @param[in] y is the vertical position in pixels (from the top edge)
WiredHome	72:ecffe56af969	1550	/// @param[in] string is the null terminated string to send to the display.
WiredHome	19:3f82c1161fd2	1551	///
WiredHome	37:f19b7e7449dc	1552	void puts(loc_t x, loc_t y, const char * string);
WiredHome	19:3f82c1161fd2	1553
WiredHome	125:7a0b70f56550	1554
WiredHome	19:3f82c1161fd2	1555	/// Prepare the controller to write binary data to the screen by positioning
WiredHome	19:3f82c1161fd2	1556	/// the memory cursor.
WiredHome	19:3f82c1161fd2	1557	///
WiredHome	72:ecffe56af969	1558	/// @param[in] x is the horizontal position in pixels (from the left edge)
WiredHome	72:ecffe56af969	1559	/// @param[in] y is the vertical position in pixels (from the top edge)
WiredHome	106:c80828f5dea4	1560	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1561	///
WiredHome	37:f19b7e7449dc	1562	virtual RetCode_t SetGraphicsCursor(loc_t x, loc_t y);
WiredHome	125:7a0b70f56550	1563
WiredHome	136:224e03d5c31f	1564	/// Prepare the controller to write binary data to the screen by positioning
WiredHome	136:224e03d5c31f	1565	/// the memory cursor.
WiredHome	136:224e03d5c31f	1566	///
WiredHome	136:224e03d5c31f	1567	/// @param[in] p is the point representing the cursor position to set
WiredHome	136:224e03d5c31f	1568	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	136:224e03d5c31f	1569	///
WiredHome	136:224e03d5c31f	1570	virtual RetCode_t SetGraphicsCursor(point_t p);
WiredHome	136:224e03d5c31f	1571
WiredHome	136:224e03d5c31f	1572	/// Read the current graphics cursor position as a point.
WiredHome	136:224e03d5c31f	1573	///
WiredHome	136:224e03d5c31f	1574	/// @returns the graphics cursor as a point.
WiredHome	136:224e03d5c31f	1575	///
WiredHome	136:224e03d5c31f	1576	virtual point_t GetGraphicsCursor(void);
WiredHome	136:224e03d5c31f	1577
WiredHome	19:3f82c1161fd2	1578
WiredHome	41:2956a0a221e5	1579	/// Prepare the controller to read binary data from the screen by positioning
WiredHome	41:2956a0a221e5	1580	/// the memory read cursor.
WiredHome	41:2956a0a221e5	1581	///
WiredHome	72:ecffe56af969	1582	/// @param[in] x is the horizontal position in pixels (from the left edge)
WiredHome	72:ecffe56af969	1583	/// @param[in] y is the vertical position in pixels (from the top edge)
WiredHome	106:c80828f5dea4	1584	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	41:2956a0a221e5	1585	///
WiredHome	41:2956a0a221e5	1586	virtual RetCode_t SetGraphicsCursorRead(loc_t x, loc_t y);
WiredHome	41:2956a0a221e5	1587
WiredHome	125:7a0b70f56550	1588
WiredHome	111:efe436c43aba	1589	/// Set the window, constraining where items are written to the screen.
WiredHome	111:efe436c43aba	1590	///
WiredHome	111:efe436c43aba	1591	/// After setting the window, text and graphics are constrained to this
WiredHome	111:efe436c43aba	1592	/// window. Text will wrap from the right edge back to the left and down
WiredHome	111:efe436c43aba	1593	/// one row and from the bottom to the top. Graphics drawing will be clipped
WiredHome	111:efe436c43aba	1594	/// at the edge of the window.
WiredHome	111:efe436c43aba	1595	///
WiredHome	111:efe436c43aba	1596	/// @note If the initial text write is outside the window, it will be shown
WiredHome	111:efe436c43aba	1597	/// where the cursor position it. Once the write hits the right edge of
WiredHome	111:efe436c43aba	1598	/// the defined window, it will then wrap back to the left edge. Once it
WiredHome	111:efe436c43aba	1599	/// hits the bottom, it wraps to the top of the window. For this reason,
WiredHome	111:efe436c43aba	1600	/// it is common to set the text cursor to the window.
WiredHome	19:3f82c1161fd2	1601	///
WiredHome	111:efe436c43aba	1602	/// @code
WiredHome	111:efe436c43aba	1603	/// rect_t r = {10,10, 90,90};
WiredHome	111:efe436c43aba	1604	/// lcd.window(r);
WiredHome	111:efe436c43aba	1605	/// lcd.SetTextCursor(r.p1.x, r.p1.y);
WiredHome	111:efe436c43aba	1606	/// lcd.puts("012345678901234567890123456789012345678901234567890");
WiredHome	111:efe436c43aba	1607	/// lcd.window(); restore to full screen
WiredHome	111:efe436c43aba	1608	/// @endcode
WiredHome	111:efe436c43aba	1609	///
WiredHome	111:efe436c43aba	1610	/// @param[in] r is the rect_t used to set the window.
WiredHome	111:efe436c43aba	1611	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	111:efe436c43aba	1612	///
WiredHome	111:efe436c43aba	1613	virtual RetCode_t window(rect_t r);
WiredHome	111:efe436c43aba	1614
WiredHome	125:7a0b70f56550	1615
WiredHome	111:efe436c43aba	1616	/// Set the window, constraining where items are written to the screen.
WiredHome	111:efe436c43aba	1617	///
WiredHome	111:efe436c43aba	1618	/// After setting the window, text and graphics are constrained to this
WiredHome	111:efe436c43aba	1619	/// window. Text will wrap from the right edge back to the left and down
WiredHome	111:efe436c43aba	1620	/// one row and from the bottom to the top. Graphics drawing will be clipped
WiredHome	111:efe436c43aba	1621	/// at the edge of the window.
WiredHome	111:efe436c43aba	1622	///
WiredHome	114:dbfb996bfbf3	1623	/// @note if no parameters are provided, it restores the window to full screen.
WiredHome	114:dbfb996bfbf3	1624	///
WiredHome	111:efe436c43aba	1625	/// @note If the initial text write is outside the window, it will be shown
WiredHome	111:efe436c43aba	1626	/// where the cursor position it. Once the write hits the right edge of
WiredHome	111:efe436c43aba	1627	/// the defined window, it will then wrap back to the left edge. Once it
WiredHome	111:efe436c43aba	1628	/// hits the bottom, it wraps to the top of the window. For this reason,
WiredHome	111:efe436c43aba	1629	/// it is common to set the text cursor to the window.
WiredHome	19:3f82c1161fd2	1630	///
WiredHome	56:7a85d226ad0d	1631	/// @code
WiredHome	56:7a85d226ad0d	1632	/// lcd.window(10,10, 80,80);
WiredHome	111:efe436c43aba	1633	/// lcd.SetTextCursor(10,10);
WiredHome	56:7a85d226ad0d	1634	/// lcd.puts("012345678901234567890123456789012345678901234567890");
WiredHome	111:efe436c43aba	1635	/// lcd.window(); restore to full screen
WiredHome	56:7a85d226ad0d	1636	/// @endcode
WiredHome	56:7a85d226ad0d	1637	///
WiredHome	72:ecffe56af969	1638	/// @param[in] x is the left edge in pixels.
WiredHome	72:ecffe56af969	1639	/// @param[in] y is the top edge in pixels.
WiredHome	72:ecffe56af969	1640	/// @param[in] width is the window width in pixels.
WiredHome	72:ecffe56af969	1641	/// @param[in] height is the window height in pixels.
WiredHome	106:c80828f5dea4	1642	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1643	///
WiredHome	111:efe436c43aba	1644	virtual RetCode_t window(loc_t x = 0, loc_t y = 0, dim_t width = (dim_t)-1, dim_t height = (dim_t)-1);
WiredHome	19:3f82c1161fd2	1645
WiredHome	125:7a0b70f56550	1646
WiredHome	61:8f3153bf0baa	1647	/// Clear either the specified layer, or the active layer.
WiredHome	19:3f82c1161fd2	1648	///
WiredHome	61:8f3153bf0baa	1649	/// The behavior is to clear the whole screen for the specified
WiredHome	61:8f3153bf0baa	1650	/// layer. When not specified, the active drawing layer is cleared.
WiredHome	61:8f3153bf0baa	1651	/// This command can also be used to specifically clear either,
WiredHome	106:c80828f5dea4	1652	/// or both layers. See @ref clsw().
WiredHome	19:3f82c1161fd2	1653	///
WiredHome	56:7a85d226ad0d	1654	/// @code
WiredHome	56:7a85d226ad0d	1655	/// lcd.cls();
WiredHome	56:7a85d226ad0d	1656	/// @endcode
WiredHome	56:7a85d226ad0d	1657	///
WiredHome	72:ecffe56af969	1658	/// @param[in] layers is optional. If not provided, the active layer
WiredHome	61:8f3153bf0baa	1659	/// is cleared. If bit 0 is set, layer 0 is cleared, if bit
WiredHome	61:8f3153bf0baa	1660	/// 1 is set, layer 1 is cleared. If both are set, both layers
WiredHome	61:8f3153bf0baa	1661	/// are cleared. Any other value does not cause an action.
WiredHome	61:8f3153bf0baa	1662	///
WiredHome	106:c80828f5dea4	1663	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1664	///
WiredHome	61:8f3153bf0baa	1665	virtual RetCode_t cls(uint16_t layers = 0);
WiredHome	125:7a0b70f56550	1666
WiredHome	19:3f82c1161fd2	1667
WiredHome	19:3f82c1161fd2	1668	/// Clear the screen, or clear only the active window.
WiredHome	19:3f82c1161fd2	1669	///
WiredHome	19:3f82c1161fd2	1670	/// The default behavior is to clear the whole screen. With the optional
WiredHome	19:3f82c1161fd2	1671	/// parameter, the action can be restricted to the active window, which
WiredHome	106:c80828f5dea4	1672	/// can be set with the See @ref window method.
WiredHome	19:3f82c1161fd2	1673	///
WiredHome	56:7a85d226ad0d	1674	/// @code
WiredHome	56:7a85d226ad0d	1675	/// lcd.window(20,20, 40,10);
WiredHome	56:7a85d226ad0d	1676	/// lcd.clsw();
WiredHome	56:7a85d226ad0d	1677	/// @endcode
WiredHome	56:7a85d226ad0d	1678	///
WiredHome	72:ecffe56af969	1679	/// @param[in] region is an optional parameter that defaults to FULLWINDOW
WiredHome	19:3f82c1161fd2	1680	/// or may be set to ACTIVEWINDOW.
WiredHome	106:c80828f5dea4	1681	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1682	///
WiredHome	19:3f82c1161fd2	1683	RetCode_t clsw(RA8875::Region_t region = FULLWINDOW);
WiredHome	19:3f82c1161fd2	1684
WiredHome	125:7a0b70f56550	1685
WiredHome	19:3f82c1161fd2	1686	/// Set the background color.
WiredHome	19:3f82c1161fd2	1687	///
WiredHome	72:ecffe56af969	1688	/// @param[in] color is expressed in 16-bit format.
WiredHome	106:c80828f5dea4	1689	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1690	///
WiredHome	19:3f82c1161fd2	1691	virtual RetCode_t background(color_t color);
WiredHome	125:7a0b70f56550	1692
WiredHome	19:3f82c1161fd2	1693
WiredHome	19:3f82c1161fd2	1694	/// Set the background color.
WiredHome	19:3f82c1161fd2	1695	///
WiredHome	72:ecffe56af969	1696	/// @param[in] r is the red element of the color.
WiredHome	72:ecffe56af969	1697	/// @param[in] g is the green element of the color.
WiredHome	72:ecffe56af969	1698	/// @param[in] b is the blue element of the color.
WiredHome	106:c80828f5dea4	1699	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1700	///
WiredHome	19:3f82c1161fd2	1701	virtual RetCode_t background(unsigned char r, unsigned char g, unsigned char b);
WiredHome	19:3f82c1161fd2	1702
WiredHome	125:7a0b70f56550	1703
WiredHome	19:3f82c1161fd2	1704	/// Set the foreground color.
WiredHome	19:3f82c1161fd2	1705	///
WiredHome	72:ecffe56af969	1706	/// @param[in] color is expressed in 16-bit format.
WiredHome	106:c80828f5dea4	1707	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1708	///
WiredHome	19:3f82c1161fd2	1709	virtual RetCode_t foreground(color_t color);
WiredHome	19:3f82c1161fd2	1710
WiredHome	125:7a0b70f56550	1711
WiredHome	19:3f82c1161fd2	1712	/// Set the foreground color.
WiredHome	19:3f82c1161fd2	1713	///
WiredHome	72:ecffe56af969	1714	/// @param[in] r is the red element of the color.
WiredHome	72:ecffe56af969	1715	/// @param[in] g is the green element of the color.
WiredHome	72:ecffe56af969	1716	/// @param[in] b is the blue element of the color.
WiredHome	106:c80828f5dea4	1717	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1718	///
WiredHome	37:f19b7e7449dc	1719	virtual RetCode_t foreground(unsigned char r, unsigned char g, unsigned char b);
WiredHome	19:3f82c1161fd2	1720
WiredHome	125:7a0b70f56550	1721
WiredHome	19:3f82c1161fd2	1722	/// Get the current foreground color value.
WiredHome	19:3f82c1161fd2	1723	///
WiredHome	19:3f82c1161fd2	1724	/// @returns the current foreground color.
WiredHome	19:3f82c1161fd2	1725	///
WiredHome	37:f19b7e7449dc	1726	color_t GetForeColor(void);
WiredHome	87:ee2240581aa7	1727
WiredHome	125:7a0b70f56550	1728
WiredHome	87:ee2240581aa7	1729	/// Draw a pixel in the specified color.
WiredHome	87:ee2240581aa7	1730	///
WiredHome	87:ee2240581aa7	1731	/// @note Unlike many other operations, this does not
WiredHome	87:ee2240581aa7	1732	/// set the forecolor!
WiredHome	87:ee2240581aa7	1733	///
WiredHome	87:ee2240581aa7	1734	/// @param[in] p is the point_t defining the location.
WiredHome	106:c80828f5dea4	1735	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	87:ee2240581aa7	1736	///
WiredHome	87:ee2240581aa7	1737	virtual RetCode_t pixel(point_t p, color_t color);
WiredHome	87:ee2240581aa7	1738
WiredHome	125:7a0b70f56550	1739
WiredHome	87:ee2240581aa7	1740	/// Draw a pixel in the current foreground color.
WiredHome	87:ee2240581aa7	1741	///
WiredHome	87:ee2240581aa7	1742	/// @param[in] p is the point_t defining the location.
WiredHome	106:c80828f5dea4	1743	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	87:ee2240581aa7	1744	///
WiredHome	87:ee2240581aa7	1745	virtual RetCode_t pixel(point_t p);
WiredHome	125:7a0b70f56550	1746
WiredHome	19:3f82c1161fd2	1747
WiredHome	19:3f82c1161fd2	1748	/// Draw a pixel in the specified color.
WiredHome	19:3f82c1161fd2	1749	///
WiredHome	41:2956a0a221e5	1750	/// @note Unlike many other operations, this does not
WiredHome	41:2956a0a221e5	1751	/// set the forecolor!
WiredHome	19:3f82c1161fd2	1752	///
WiredHome	72:ecffe56af969	1753	/// @param[in] x is the horizontal offset to this pixel.
WiredHome	72:ecffe56af969	1754	/// @param[in] y is the vertical offset to this pixel.
WiredHome	72:ecffe56af969	1755	/// @param[in] color defines the color for the pixel.
WiredHome	106:c80828f5dea4	1756	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1757	///
WiredHome	37:f19b7e7449dc	1758	virtual RetCode_t pixel(loc_t x, loc_t y, color_t color);
WiredHome	19:3f82c1161fd2	1759
WiredHome	125:7a0b70f56550	1760
WiredHome	19:3f82c1161fd2	1761	/// Draw a pixel in the current foreground color.
WiredHome	19:3f82c1161fd2	1762	///
WiredHome	72:ecffe56af969	1763	/// @param[in] x is the horizontal offset to this pixel.
WiredHome	72:ecffe56af969	1764	/// @param[in] y is the veritical offset to this pixel.
WiredHome	106:c80828f5dea4	1765	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1766	///
WiredHome	37:f19b7e7449dc	1767	virtual RetCode_t pixel(loc_t x, loc_t y);
WiredHome	19:3f82c1161fd2	1768
WiredHome	125:7a0b70f56550	1769
WiredHome	41:2956a0a221e5	1770	/// Get a pixel from the display.
WiredHome	41:2956a0a221e5	1771	///
WiredHome	72:ecffe56af969	1772	/// @param[in] x is the horizontal offset to this pixel.
WiredHome	72:ecffe56af969	1773	/// @param[in] y is the vertical offset to this pixel.
WiredHome	41:2956a0a221e5	1774	/// @returns the pixel. see @color_t
WiredHome	41:2956a0a221e5	1775	///
WiredHome	41:2956a0a221e5	1776	virtual color_t getPixel(loc_t x, loc_t y);
WiredHome	41:2956a0a221e5	1777
WiredHome	125:7a0b70f56550	1778
WiredHome	136:224e03d5c31f	1779	/// Write an RGB565 stream of pixels to the display.
WiredHome	41:2956a0a221e5	1780	///
WiredHome	72:ecffe56af969	1781	/// @param[in] p is a pointer to a color_t array to write.
WiredHome	72:ecffe56af969	1782	/// @param[in] count is the number of pixels to write.
WiredHome	72:ecffe56af969	1783	/// @param[in] x is the horizontal position on the display.
WiredHome	72:ecffe56af969	1784	/// @param[in] y is the vertical position on the display.
WiredHome	106:c80828f5dea4	1785	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	41:2956a0a221e5	1786	///
WiredHome	41:2956a0a221e5	1787	virtual RetCode_t pixelStream(color_t * p, uint32_t count, loc_t x, loc_t y);
WiredHome	41:2956a0a221e5	1788
WiredHome	125:7a0b70f56550	1789
WiredHome	41:2956a0a221e5	1790	/// Get a stream of pixels from the display.
WiredHome	41:2956a0a221e5	1791	///
WiredHome	72:ecffe56af969	1792	/// @param[in] p is a pointer to a color_t array to accept the stream.
WiredHome	72:ecffe56af969	1793	/// @param[in] count is the number of pixels to read.
WiredHome	72:ecffe56af969	1794	/// @param[in] x is the horizontal offset to this pixel.
WiredHome	72:ecffe56af969	1795	/// @param[in] y is the vertical offset to this pixel.
WiredHome	106:c80828f5dea4	1796	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	41:2956a0a221e5	1797	///
WiredHome	41:2956a0a221e5	1798	virtual RetCode_t getPixelStream(color_t * p, uint32_t count, loc_t x, loc_t y);
WiredHome	131:5bd6ba2ee4a1	1799
WiredHome	131:5bd6ba2ee4a1	1800
WiredHome	109:7b94f06f085b	1801	/// Write a boolean stream to the display.
WiredHome	109:7b94f06f085b	1802	///
WiredHome	109:7b94f06f085b	1803	/// This takes a bit stream in memory and using the current color settings
WiredHome	109:7b94f06f085b	1804	/// it will stream it to the display. Along the way, each bit is translated
WiredHome	109:7b94f06f085b	1805	/// to either the foreground or background color value and then that pixel
WiredHome	109:7b94f06f085b	1806	/// is pushed onward.
WiredHome	109:7b94f06f085b	1807	///
WiredHome	109:7b94f06f085b	1808	/// This is similar, but different, to the @ref pixelStream API, which is
WiredHome	109:7b94f06f085b	1809	/// given a stream of color values.
WiredHome	109:7b94f06f085b	1810	///
WiredHome	109:7b94f06f085b	1811	/// @param[in] x is the horizontal position on the display.
WiredHome	109:7b94f06f085b	1812	/// @param[in] y is the vertical position on the display.
WiredHome	109:7b94f06f085b	1813	/// @param[in] w is the width of the rectangular region to fill.
WiredHome	109:7b94f06f085b	1814	/// @param[in] h is the height of the rectangular region to fill.
WiredHome	109:7b94f06f085b	1815	/// @param[in] boolStream is the inline memory image from which to extract
WiredHome	109:7b94f06f085b	1816	/// the bitstream.
WiredHome	109:7b94f06f085b	1817	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	109:7b94f06f085b	1818	///
WiredHome	109:7b94f06f085b	1819	virtual RetCode_t booleanStream(loc_t x, loc_t y, dim_t w, dim_t h, const uint8_t * boolStream);
WiredHome	125:7a0b70f56550	1820
WiredHome	109:7b94f06f085b	1821
WiredHome	19:3f82c1161fd2	1822	/// Draw a line in the specified color
WiredHome	19:3f82c1161fd2	1823	///
WiredHome	19:3f82c1161fd2	1824	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	1825	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	1826	///
WiredHome	83:7bad0068cca0	1827	/// @param[in] p1 is the point to start the line.
WiredHome	83:7bad0068cca0	1828	/// @param[in] p2 is the point to end the line.
WiredHome	83:7bad0068cca0	1829	/// @param[in] color defines the foreground color.
WiredHome	106:c80828f5dea4	1830	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	83:7bad0068cca0	1831	///
WiredHome	83:7bad0068cca0	1832	RetCode_t line(point_t p1, point_t p2, color_t color);
WiredHome	83:7bad0068cca0	1833
WiredHome	125:7a0b70f56550	1834
WiredHome	83:7bad0068cca0	1835	/// Draw a line
WiredHome	83:7bad0068cca0	1836	///
WiredHome	83:7bad0068cca0	1837	/// Draws a line using the foreground color setting.
WiredHome	83:7bad0068cca0	1838	///
WiredHome	83:7bad0068cca0	1839	/// @param[in] p1 is the point to start the line.
WiredHome	83:7bad0068cca0	1840	/// @param[in] p2 is the point to end the line.
WiredHome	106:c80828f5dea4	1841	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	83:7bad0068cca0	1842	///
WiredHome	83:7bad0068cca0	1843	RetCode_t line(point_t p1, point_t p2);
WiredHome	125:7a0b70f56550	1844
WiredHome	83:7bad0068cca0	1845
WiredHome	83:7bad0068cca0	1846	/// Draw a line in the specified color
WiredHome	83:7bad0068cca0	1847	///
WiredHome	83:7bad0068cca0	1848	/// @note As a side effect, this changes the current
WiredHome	83:7bad0068cca0	1849	/// foreground color for subsequent operations.
WiredHome	83:7bad0068cca0	1850	///
WiredHome	72:ecffe56af969	1851	/// @param[in] x1 is the horizontal start of the line.
WiredHome	72:ecffe56af969	1852	/// @param[in] y1 is the vertical start of the line.
WiredHome	72:ecffe56af969	1853	/// @param[in] x2 is the horizontal end of the line.
WiredHome	72:ecffe56af969	1854	/// @param[in] y2 is the vertical end of the line.
WiredHome	72:ecffe56af969	1855	/// @param[in] color defines the foreground color.
WiredHome	106:c80828f5dea4	1856	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1857	///
WiredHome	56:7a85d226ad0d	1858	RetCode_t line(loc_t x1, loc_t y1, loc_t x2, loc_t y2, color_t color);
WiredHome	19:3f82c1161fd2	1859
WiredHome	125:7a0b70f56550	1860
WiredHome	19:3f82c1161fd2	1861	/// Draw a line
WiredHome	19:3f82c1161fd2	1862	///
WiredHome	19:3f82c1161fd2	1863	/// Draws a line using the foreground color setting.
WiredHome	19:3f82c1161fd2	1864	///
WiredHome	72:ecffe56af969	1865	/// @param[in] x1 is the horizontal start of the line.
WiredHome	72:ecffe56af969	1866	/// @param[in] y1 is the vertical start of the line.
WiredHome	72:ecffe56af969	1867	/// @param[in] x2 is the horizontal end of the line.
WiredHome	72:ecffe56af969	1868	/// @param[in] y2 is the vertical end of the line.
WiredHome	106:c80828f5dea4	1869	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1870	///
WiredHome	37:f19b7e7449dc	1871	RetCode_t line(loc_t x1, loc_t y1, loc_t x2, loc_t y2);
WiredHome	19:3f82c1161fd2	1872
WiredHome	125:7a0b70f56550	1873
WiredHome	19:3f82c1161fd2	1874	/// Draw a rectangle in the specified color
WiredHome	19:3f82c1161fd2	1875	///
WiredHome	19:3f82c1161fd2	1876	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	1877	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	1878	///
WiredHome	81:01da2e34283d	1879	/// @param[in] rect defines the rectangle.
WiredHome	81:01da2e34283d	1880	/// @param[in] color defines the foreground color.
WiredHome	81:01da2e34283d	1881	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	106:c80828f5dea4	1882	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	81:01da2e34283d	1883	///
WiredHome	82:f7d300f26540	1884	RetCode_t rect(rect_t rect, color_t color, fill_t fillit = NOFILL);
WiredHome	81:01da2e34283d	1885
WiredHome	125:7a0b70f56550	1886
WiredHome	125:7a0b70f56550	1887	/// Draw a filled rectangle in the specified color
WiredHome	81:01da2e34283d	1888	///
WiredHome	81:01da2e34283d	1889	/// @note As a side effect, this changes the current
WiredHome	81:01da2e34283d	1890	/// foreground color for subsequent operations.
WiredHome	81:01da2e34283d	1891	///
WiredHome	81:01da2e34283d	1892	/// @param[in] rect defines the rectangle.
WiredHome	81:01da2e34283d	1893	/// @param[in] color defines the foreground color.
WiredHome	81:01da2e34283d	1894	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	106:c80828f5dea4	1895	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	81:01da2e34283d	1896	///
WiredHome	81:01da2e34283d	1897	RetCode_t fillrect(rect_t rect, color_t color, fill_t fillit = FILL);
WiredHome	81:01da2e34283d	1898
WiredHome	125:7a0b70f56550	1899
WiredHome	81:01da2e34283d	1900	/// Draw a rectangle in the specified color
WiredHome	81:01da2e34283d	1901	///
WiredHome	81:01da2e34283d	1902	/// @note As a side effect, this changes the current
WiredHome	81:01da2e34283d	1903	/// foreground color for subsequent operations.
WiredHome	81:01da2e34283d	1904	///
WiredHome	72:ecffe56af969	1905	/// @param[in] x1 is the horizontal start of the line.
WiredHome	72:ecffe56af969	1906	/// @param[in] y1 is the vertical start of the line.
WiredHome	72:ecffe56af969	1907	/// @param[in] x2 is the horizontal end of the line.
WiredHome	72:ecffe56af969	1908	/// @param[in] y2 is the vertical end of the line.
WiredHome	72:ecffe56af969	1909	/// @param[in] color defines the foreground color.
WiredHome	81:01da2e34283d	1910	/// @param[in] fillit is optional to FILL the rectangle. default is FILL.
WiredHome	106:c80828f5dea4	1911	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1912	///
WiredHome	37:f19b7e7449dc	1913	RetCode_t rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	19:3f82c1161fd2	1914	color_t color, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	1915
WiredHome	125:7a0b70f56550	1916
WiredHome	19:3f82c1161fd2	1917	/// Draw a filled rectangle in the specified color
WiredHome	19:3f82c1161fd2	1918	///
WiredHome	19:3f82c1161fd2	1919	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	1920	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	1921	///
WiredHome	72:ecffe56af969	1922	/// @param[in] x1 is the horizontal start of the line.
WiredHome	72:ecffe56af969	1923	/// @param[in] y1 is the vertical start of the line.
WiredHome	72:ecffe56af969	1924	/// @param[in] x2 is the horizontal end of the line.
WiredHome	72:ecffe56af969	1925	/// @param[in] y2 is the vertical end of the line.
WiredHome	72:ecffe56af969	1926	/// @param[in] color defines the foreground color.
WiredHome	72:ecffe56af969	1927	/// @param[in] fillit is optional to NOFILL the rectangle. default is FILL.
WiredHome	106:c80828f5dea4	1928	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1929	///
WiredHome	37:f19b7e7449dc	1930	virtual RetCode_t fillrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	19:3f82c1161fd2	1931	color_t color, fill_t fillit = FILL);
WiredHome	19:3f82c1161fd2	1932
WiredHome	125:7a0b70f56550	1933
WiredHome	19:3f82c1161fd2	1934	/// Draw a rectangle
WiredHome	19:3f82c1161fd2	1935	///
WiredHome	19:3f82c1161fd2	1936	/// Draws a rectangle using the foreground color setting.
WiredHome	19:3f82c1161fd2	1937	///
WiredHome	72:ecffe56af969	1938	/// @param[in] x1 is the horizontal start of the line.
WiredHome	72:ecffe56af969	1939	/// @param[in] y1 is the vertical start of the line.
WiredHome	72:ecffe56af969	1940	/// @param[in] x2 is the horizontal end of the line.
WiredHome	72:ecffe56af969	1941	/// @param[in] y2 is the vertical end of the line.
WiredHome	72:ecffe56af969	1942	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	106:c80828f5dea4	1943	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1944	///
WiredHome	37:f19b7e7449dc	1945	RetCode_t rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	19:3f82c1161fd2	1946	fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	1947
WiredHome	125:7a0b70f56550	1948
WiredHome	19:3f82c1161fd2	1949	/// Draw a filled rectangle with rounded corners using the specified color.
WiredHome	19:3f82c1161fd2	1950	///
WiredHome	21:3c1efb192927	1951	/// This draws a rounded rectangle. A numbers of checks are made on the values,
WiredHome	21:3c1efb192927	1952	/// and it could reduce this to drawing a line (if either x1 == x2, or y1 == y2),
WiredHome	21:3c1efb192927	1953	/// or a single point (x1 == x2 && y1 == y2). If the radius parameters are
WiredHome	21:3c1efb192927	1954	/// > 1/2 the length of that side (width or height), an error value is returned.
WiredHome	21:3c1efb192927	1955	///
WiredHome	19:3f82c1161fd2	1956	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	1957	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	1958	///
WiredHome	72:ecffe56af969	1959	/// @param[in] x1 is the horizontal start of the line and must be <= x2.
WiredHome	72:ecffe56af969	1960	/// @param[in] y1 is the vertical start of the line and must be <= y2.
WiredHome	72:ecffe56af969	1961	/// @param[in] x2 is the horizontal end of the line and must be >= x1.
WiredHome	72:ecffe56af969	1962	/// @param[in] y2 is the vertical end of the line and must be >= y1.
WiredHome	72:ecffe56af969	1963	/// @param[in] radius1 defines the horizontal radius of the curved corner. Take care
WiredHome	21:3c1efb192927	1964	/// that this value < 1/2 the width of the rectangle, or bad_parameter
WiredHome	21:3c1efb192927	1965	/// is returned.
WiredHome	72:ecffe56af969	1966	/// @param[in] radius2 defines the vertical radius of the curved corner. Take care
WiredHome	21:3c1efb192927	1967	/// that this value < 1/2 the height of the rectangle, or bad_parameter
WiredHome	21:3c1efb192927	1968	/// is returned.
WiredHome	72:ecffe56af969	1969	/// @param[in] color defines the foreground color.
WiredHome	72:ecffe56af969	1970	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	106:c80828f5dea4	1971	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	1972	///
WiredHome	37:f19b7e7449dc	1973	RetCode_t fillroundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	37:f19b7e7449dc	1974	dim_t radius1, dim_t radius2, color_t color, fill_t fillit = FILL);
WiredHome	19:3f82c1161fd2	1975
WiredHome	125:7a0b70f56550	1976
WiredHome	107:f9ccffcb84f1	1977	/// Draw a filled rectangle with rounded corners using the specified color.
WiredHome	107:f9ccffcb84f1	1978	///
WiredHome	107:f9ccffcb84f1	1979	/// This draws a rounded rectangle. A numbers of checks are made on the values,
WiredHome	107:f9ccffcb84f1	1980	/// and it could reduce this to drawing a line (if either x1 == x2, or y1 == y2),
WiredHome	107:f9ccffcb84f1	1981	/// or a single point (x1 == x2 && y1 == y2). If the radius parameters are
WiredHome	107:f9ccffcb84f1	1982	/// > 1/2 the length of that side (width or height), an error value is returned.
WiredHome	107:f9ccffcb84f1	1983	///
WiredHome	107:f9ccffcb84f1	1984	/// @note As a side effect, this changes the current
WiredHome	107:f9ccffcb84f1	1985	/// foreground color for subsequent operations.
WiredHome	107:f9ccffcb84f1	1986	///
WiredHome	107:f9ccffcb84f1	1987	/// @param[in] r is the rectangle to draw.
WiredHome	107:f9ccffcb84f1	1988	/// @param[in] radius1 defines the horizontal radius of the curved corner. Take care
WiredHome	107:f9ccffcb84f1	1989	/// that this value < 1/2 the width of the rectangle, or bad_parameter
WiredHome	107:f9ccffcb84f1	1990	/// is returned.
WiredHome	107:f9ccffcb84f1	1991	/// @param[in] radius2 defines the vertical radius of the curved corner. Take care
WiredHome	107:f9ccffcb84f1	1992	/// that this value < 1/2 the height of the rectangle, or bad_parameter
WiredHome	107:f9ccffcb84f1	1993	/// is returned.
WiredHome	107:f9ccffcb84f1	1994	/// @param[in] color defines the foreground color.
WiredHome	107:f9ccffcb84f1	1995	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	107:f9ccffcb84f1	1996	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	107:f9ccffcb84f1	1997	///
WiredHome	107:f9ccffcb84f1	1998	RetCode_t fillroundrect(rect_t r,
WiredHome	107:f9ccffcb84f1	1999	dim_t radius1, dim_t radius2, color_t color, fill_t fillit = FILL);
WiredHome	107:f9ccffcb84f1	2000
WiredHome	125:7a0b70f56550	2001
WiredHome	107:f9ccffcb84f1	2002	/// Draw a rectangle with rounded corners using the specified color.
WiredHome	107:f9ccffcb84f1	2003	///
WiredHome	107:f9ccffcb84f1	2004	/// This draws a rounded rectangle. A numbers of checks are made on the values,
WiredHome	107:f9ccffcb84f1	2005	/// and it could reduce this to drawing a line (if either x1 == x2, or y1 == y2),
WiredHome	107:f9ccffcb84f1	2006	/// or a single point (x1 == x2 && y1 == y2). If the radius parameters are
WiredHome	107:f9ccffcb84f1	2007	/// > 1/2 the length of that side (width or height), an error value is returned.
WiredHome	107:f9ccffcb84f1	2008	///
WiredHome	107:f9ccffcb84f1	2009	/// @note As a side effect, this changes the current
WiredHome	107:f9ccffcb84f1	2010	/// foreground color for subsequent operations.
WiredHome	107:f9ccffcb84f1	2011	///
WiredHome	107:f9ccffcb84f1	2012	/// @param[in] r is the rectangle to draw.
WiredHome	107:f9ccffcb84f1	2013	/// @param[in] radius1 defines the horizontal radius of the curved corner. Take care
WiredHome	107:f9ccffcb84f1	2014	/// that this value < 1/2 the width of the rectangle, or bad_parameter
WiredHome	107:f9ccffcb84f1	2015	/// is returned.
WiredHome	107:f9ccffcb84f1	2016	/// @param[in] radius2 defines the vertical radius of the curved corner. Take care
WiredHome	107:f9ccffcb84f1	2017	/// that this value < 1/2 the height of the rectangle, or bad_parameter
WiredHome	107:f9ccffcb84f1	2018	/// is returned.
WiredHome	107:f9ccffcb84f1	2019	/// @param[in] color defines the foreground color.
WiredHome	107:f9ccffcb84f1	2020	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	107:f9ccffcb84f1	2021	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	107:f9ccffcb84f1	2022	///
WiredHome	107:f9ccffcb84f1	2023	RetCode_t roundrect(rect_t r,
WiredHome	107:f9ccffcb84f1	2024	dim_t radius1, dim_t radius2, color_t color, fill_t fillit = NOFILL);
WiredHome	107:f9ccffcb84f1	2025
WiredHome	125:7a0b70f56550	2026
WiredHome	19:3f82c1161fd2	2027	/// Draw a rectangle with rounded corners using the specified color.
WiredHome	19:3f82c1161fd2	2028	///
WiredHome	21:3c1efb192927	2029	/// This draws a rounded rectangle. A numbers of checks are made on the values,
WiredHome	21:3c1efb192927	2030	/// and it could reduce this to drawing a line (if either x1 == x2, or y1 == y2),
WiredHome	21:3c1efb192927	2031	/// or a single point (x1 == x2 && y1 == y2). If the radius parameters are
WiredHome	21:3c1efb192927	2032	/// > 1/2 the length of that side (width or height), an error value is returned.
WiredHome	21:3c1efb192927	2033	///
WiredHome	19:3f82c1161fd2	2034	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	2035	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	2036	///
WiredHome	72:ecffe56af969	2037	/// @param[in] x1 is the horizontal start of the line and must be <= x2.
WiredHome	72:ecffe56af969	2038	/// @param[in] y1 is the vertical start of the line and must be <= y2.
WiredHome	72:ecffe56af969	2039	/// @param[in] x2 is the horizontal end of the line and must be >= x1.
WiredHome	72:ecffe56af969	2040	/// @param[in] y2 is the vertical end of the line and must be >= y1.
WiredHome	72:ecffe56af969	2041	/// @param[in] radius1 defines the horizontal radius of the curved corner. Take care
WiredHome	21:3c1efb192927	2042	/// that this value < 1/2 the width of the rectangle, or bad_parameter
WiredHome	21:3c1efb192927	2043	/// is returned.
WiredHome	72:ecffe56af969	2044	/// @param[in] radius2 defines the vertical radius of the curved corner. Take care
WiredHome	21:3c1efb192927	2045	/// that this value < 1/2 the height of the rectangle, or bad_parameter
WiredHome	21:3c1efb192927	2046	/// is returned.
WiredHome	72:ecffe56af969	2047	/// @param[in] color defines the foreground color.
WiredHome	72:ecffe56af969	2048	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	106:c80828f5dea4	2049	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2050	///
WiredHome	37:f19b7e7449dc	2051	RetCode_t roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	37:f19b7e7449dc	2052	dim_t radius1, dim_t radius2, color_t color, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	2053
WiredHome	125:7a0b70f56550	2054
WiredHome	19:3f82c1161fd2	2055	/// Draw a rectangle with rounded corners.
WiredHome	19:3f82c1161fd2	2056	///
WiredHome	21:3c1efb192927	2057	/// This draws a rounded rectangle. A numbers of checks are made on the values,
WiredHome	21:3c1efb192927	2058	/// and it could reduce this to drawing a line (if either x1 == x2, or y1 == y2),
WiredHome	21:3c1efb192927	2059	/// or a single point (x1 == x2 && y1 == y2). If the radius parameters are
WiredHome	21:3c1efb192927	2060	/// > 1/2 the length of that side (width or height), an error value is returned.
WiredHome	19:3f82c1161fd2	2061	///
WiredHome	72:ecffe56af969	2062	/// @param[in] x1 is the horizontal start of the line and must be <= x2.
WiredHome	72:ecffe56af969	2063	/// @param[in] y1 is the vertical start of the line and must be <= y2.
WiredHome	72:ecffe56af969	2064	/// @param[in] x2 is the horizontal end of the line and must be >= x1.
WiredHome	72:ecffe56af969	2065	/// @param[in] y2 is the vertical end of the line and must be >= y1.
WiredHome	72:ecffe56af969	2066	/// @param[in] radius1 defines the horizontal radius of the curved corner. Take care
WiredHome	21:3c1efb192927	2067	/// that this value < 1/2 the width of the rectangle, or bad_parameter
WiredHome	21:3c1efb192927	2068	/// is returned.
WiredHome	72:ecffe56af969	2069	/// @param[in] radius2 defines the vertical radius of the curved corner. Take care
WiredHome	21:3c1efb192927	2070	/// that this value < 1/2 the height of the rectangle, or bad_parameter
WiredHome	21:3c1efb192927	2071	/// is returned.
WiredHome	72:ecffe56af969	2072	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	106:c80828f5dea4	2073	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2074	///
WiredHome	37:f19b7e7449dc	2075	RetCode_t roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	37:f19b7e7449dc	2076	dim_t radius1, dim_t radius2, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	2077
WiredHome	125:7a0b70f56550	2078
WiredHome	19:3f82c1161fd2	2079	/// Draw a triangle in the specified color.
WiredHome	19:3f82c1161fd2	2080	///
WiredHome	19:3f82c1161fd2	2081	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	2082	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	2083	///
WiredHome	72:ecffe56af969	2084	/// @param[in] x1 is the horizontal for point 1.
WiredHome	72:ecffe56af969	2085	/// @param[in] y1 is the vertical for point 1.
WiredHome	72:ecffe56af969	2086	/// @param[in] x2 is the horizontal for point 2.
WiredHome	72:ecffe56af969	2087	/// @param[in] y2 is the vertical for point 2.
WiredHome	72:ecffe56af969	2088	/// @param[in] x3 is the horizontal for point 3.
WiredHome	72:ecffe56af969	2089	/// @param[in] y3 is the vertical for point 3.
WiredHome	72:ecffe56af969	2090	/// @param[in] color defines the foreground color.
WiredHome	72:ecffe56af969	2091	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	106:c80828f5dea4	2092	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2093	///
WiredHome	37:f19b7e7449dc	2094	RetCode_t triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	37:f19b7e7449dc	2095	loc_t x3, loc_t y3, color_t color, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	2096
WiredHome	125:7a0b70f56550	2097
WiredHome	19:3f82c1161fd2	2098	/// Draw a filled triangle in the specified color.
WiredHome	19:3f82c1161fd2	2099	///
WiredHome	19:3f82c1161fd2	2100	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	2101	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	2102	///
WiredHome	72:ecffe56af969	2103	/// @param[in] x1 is the horizontal for point 1.
WiredHome	72:ecffe56af969	2104	/// @param[in] y1 is the vertical for point 1.
WiredHome	72:ecffe56af969	2105	/// @param[in] x2 is the horizontal for point 2.
WiredHome	72:ecffe56af969	2106	/// @param[in] y2 is the vertical for point 2.
WiredHome	72:ecffe56af969	2107	/// @param[in] x3 is the horizontal for point 3.
WiredHome	72:ecffe56af969	2108	/// @param[in] y3 is the vertical for point 3.
WiredHome	72:ecffe56af969	2109	/// @param[in] color defines the foreground color.
WiredHome	72:ecffe56af969	2110	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	106:c80828f5dea4	2111	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2112	///
WiredHome	37:f19b7e7449dc	2113	RetCode_t filltriangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	37:f19b7e7449dc	2114	loc_t x3, loc_t y3, color_t color, fill_t fillit = FILL);
WiredHome	19:3f82c1161fd2	2115
WiredHome	125:7a0b70f56550	2116
WiredHome	19:3f82c1161fd2	2117	/// Draw a triangle
WiredHome	19:3f82c1161fd2	2118	///
WiredHome	19:3f82c1161fd2	2119	/// Draws a triangle using the foreground color setting.
WiredHome	19:3f82c1161fd2	2120	///
WiredHome	72:ecffe56af969	2121	/// @param[in] x1 is the horizontal for point 1.
WiredHome	72:ecffe56af969	2122	/// @param[in] y1 is the vertical for point 1.
WiredHome	72:ecffe56af969	2123	/// @param[in] x2 is the horizontal for point 2.
WiredHome	72:ecffe56af969	2124	/// @param[in] y2 is the vertical for point 2.
WiredHome	72:ecffe56af969	2125	/// @param[in] x3 is the horizontal for point 3.
WiredHome	72:ecffe56af969	2126	/// @param[in] y3 is the vertical for point 3.
WiredHome	72:ecffe56af969	2127	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	106:c80828f5dea4	2128	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2129	///
WiredHome	37:f19b7e7449dc	2130	RetCode_t triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	37:f19b7e7449dc	2131	loc_t x3, loc_t y3, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	2132
WiredHome	83:7bad0068cca0	2133
WiredHome	83:7bad0068cca0	2134	/// Draw a circle using the specified color.
WiredHome	83:7bad0068cca0	2135	///
WiredHome	83:7bad0068cca0	2136	/// @note As a side effect, this changes the current
WiredHome	83:7bad0068cca0	2137	/// foreground color for subsequent operations.
WiredHome	83:7bad0068cca0	2138	///
WiredHome	83:7bad0068cca0	2139	/// @param[in] p defines the center of the circle.
WiredHome	83:7bad0068cca0	2140	/// @param[in] radius defines the size of the circle.
WiredHome	83:7bad0068cca0	2141	/// @param[in] color defines the foreground color.
WiredHome	125:7a0b70f56550	2142	/// @param[in] fillit is optional to FILL the circle. default is NOFILL.
WiredHome	106:c80828f5dea4	2143	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	83:7bad0068cca0	2144	///
WiredHome	83:7bad0068cca0	2145	RetCode_t circle(point_t p, dim_t radius, color_t color, fill_t fillit = NOFILL);
WiredHome	83:7bad0068cca0	2146
WiredHome	125:7a0b70f56550	2147
WiredHome	83:7bad0068cca0	2148	/// Draw a filled circle using the specified color.
WiredHome	83:7bad0068cca0	2149	///
WiredHome	83:7bad0068cca0	2150	/// @note As a side effect, this changes the current
WiredHome	83:7bad0068cca0	2151	/// foreground color for subsequent operations.
WiredHome	83:7bad0068cca0	2152	///
WiredHome	83:7bad0068cca0	2153	/// @param[in] p defines the center of the circle.
WiredHome	83:7bad0068cca0	2154	/// @param[in] radius defines the size of the circle.
WiredHome	83:7bad0068cca0	2155	/// @param[in] color defines the foreground color.
WiredHome	125:7a0b70f56550	2156	/// @param[in] fillit is optional to FILL the circle. default is FILL.
WiredHome	106:c80828f5dea4	2157	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	83:7bad0068cca0	2158	///
WiredHome	83:7bad0068cca0	2159	RetCode_t fillcircle(point_t p, dim_t radius, color_t color, fill_t fillit = FILL);
WiredHome	83:7bad0068cca0	2160
WiredHome	125:7a0b70f56550	2161
WiredHome	83:7bad0068cca0	2162	/// Draw a circle.
WiredHome	83:7bad0068cca0	2163	///
WiredHome	83:7bad0068cca0	2164	/// Draws a circle using the foreground color setting.
WiredHome	83:7bad0068cca0	2165	///
WiredHome	83:7bad0068cca0	2166	/// @param[in] p defines the center of the circle.
WiredHome	83:7bad0068cca0	2167	/// @param[in] radius defines the size of the circle.
WiredHome	125:7a0b70f56550	2168	/// @param[in] fillit is optional to FILL the circle. default is NOFILL.
WiredHome	106:c80828f5dea4	2169	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	83:7bad0068cca0	2170	///
WiredHome	83:7bad0068cca0	2171	RetCode_t circle(point_t p, dim_t radius, fill_t fillit = NOFILL);
WiredHome	83:7bad0068cca0	2172
WiredHome	125:7a0b70f56550	2173
WiredHome	19:3f82c1161fd2	2174	/// Draw a circle using the specified color.
WiredHome	19:3f82c1161fd2	2175	///
WiredHome	19:3f82c1161fd2	2176	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	2177	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	2178	///
WiredHome	72:ecffe56af969	2179	/// @param[in] x is the horizontal center of the circle.
WiredHome	72:ecffe56af969	2180	/// @param[in] y is the vertical center of the circle.
WiredHome	72:ecffe56af969	2181	/// @param[in] radius defines the size of the circle.
WiredHome	72:ecffe56af969	2182	/// @param[in] color defines the foreground color.
WiredHome	125:7a0b70f56550	2183	/// @param[in] fillit is optional to FILL the circle. default is NOFILL.
WiredHome	106:c80828f5dea4	2184	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2185	///
WiredHome	37:f19b7e7449dc	2186	RetCode_t circle(loc_t x, loc_t y, dim_t radius, color_t color, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	2187
WiredHome	125:7a0b70f56550	2188
WiredHome	19:3f82c1161fd2	2189	/// Draw a filled circle using the specified color.
WiredHome	19:3f82c1161fd2	2190	///
WiredHome	19:3f82c1161fd2	2191	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	2192	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	2193	///
WiredHome	72:ecffe56af969	2194	/// @param[in] x is the horizontal center of the circle.
WiredHome	72:ecffe56af969	2195	/// @param[in] y is the vertical center of the circle.
WiredHome	72:ecffe56af969	2196	/// @param[in] radius defines the size of the circle.
WiredHome	72:ecffe56af969	2197	/// @param[in] color defines the foreground color.
WiredHome	125:7a0b70f56550	2198	/// @param[in] fillit is optional to FILL the circle. default is FILL.
WiredHome	106:c80828f5dea4	2199	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2200	///
WiredHome	37:f19b7e7449dc	2201	RetCode_t fillcircle(loc_t x, loc_t y, dim_t radius, color_t color, fill_t fillit = FILL);
WiredHome	19:3f82c1161fd2	2202
WiredHome	125:7a0b70f56550	2203
WiredHome	19:3f82c1161fd2	2204	/// Draw a circle.
WiredHome	19:3f82c1161fd2	2205	///
WiredHome	19:3f82c1161fd2	2206	/// Draws a circle using the foreground color setting.
WiredHome	19:3f82c1161fd2	2207	///
WiredHome	72:ecffe56af969	2208	/// @param[in] x is the horizontal center of the circle.
WiredHome	72:ecffe56af969	2209	/// @param[in] y is the vertical center of the circle.
WiredHome	72:ecffe56af969	2210	/// @param[in] radius defines the size of the circle.
WiredHome	125:7a0b70f56550	2211	/// @param[in] fillit is optional to FILL the circle. default is NOFILL.
WiredHome	106:c80828f5dea4	2212	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2213	///
WiredHome	37:f19b7e7449dc	2214	RetCode_t circle(loc_t x, loc_t y, dim_t radius, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	2215
WiredHome	19:3f82c1161fd2	2216	/// Draw an Ellipse using the specified color
WiredHome	19:3f82c1161fd2	2217	///
WiredHome	19:3f82c1161fd2	2218	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	2219	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	2220	///
WiredHome	72:ecffe56af969	2221	/// @param[in] x is the horizontal center of the ellipse.
WiredHome	72:ecffe56af969	2222	/// @param[in] y is the vertical center of the ellipse.
WiredHome	72:ecffe56af969	2223	/// @param[in] radius1 defines the horizontal radius of the ellipse.
WiredHome	72:ecffe56af969	2224	/// @param[in] radius2 defines the vertical radius of the ellipse.
WiredHome	72:ecffe56af969	2225	/// @param[in] color defines the foreground color.
WiredHome	72:ecffe56af969	2226	/// @param[in] fillit defines whether the circle is filled or not.
WiredHome	106:c80828f5dea4	2227	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2228	///
WiredHome	37:f19b7e7449dc	2229	RetCode_t ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2,
WiredHome	19:3f82c1161fd2	2230	color_t color, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	2231
WiredHome	125:7a0b70f56550	2232
WiredHome	25:9556a3a9b7cc	2233	/// Draw a filled Ellipse using the specified color
WiredHome	25:9556a3a9b7cc	2234	///
WiredHome	25:9556a3a9b7cc	2235	/// @note As a side effect, this changes the current
WiredHome	25:9556a3a9b7cc	2236	/// foreground color for subsequent operations.
WiredHome	25:9556a3a9b7cc	2237	///
WiredHome	72:ecffe56af969	2238	/// @param[in] x is the horizontal center of the ellipse.
WiredHome	72:ecffe56af969	2239	/// @param[in] y is the vertical center of the ellipse.
WiredHome	72:ecffe56af969	2240	/// @param[in] radius1 defines the horizontal radius of the ellipse.
WiredHome	72:ecffe56af969	2241	/// @param[in] radius2 defines the vertical radius of the ellipse.
WiredHome	72:ecffe56af969	2242	/// @param[in] color defines the foreground color.
WiredHome	72:ecffe56af969	2243	/// @param[in] fillit defines whether the circle is filled or not.
WiredHome	106:c80828f5dea4	2244	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	25:9556a3a9b7cc	2245	///
WiredHome	37:f19b7e7449dc	2246	RetCode_t fillellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2,
WiredHome	25:9556a3a9b7cc	2247	color_t color, fill_t fillit = FILL);
WiredHome	25:9556a3a9b7cc	2248
WiredHome	125:7a0b70f56550	2249
WiredHome	19:3f82c1161fd2	2250	/// Draw an Ellipse
WiredHome	19:3f82c1161fd2	2251	///
WiredHome	19:3f82c1161fd2	2252	/// Draws it using the foreground color setting.
WiredHome	19:3f82c1161fd2	2253	///
WiredHome	72:ecffe56af969	2254	/// @param[in] x is the horizontal center of the ellipse.
WiredHome	72:ecffe56af969	2255	/// @param[in] y is the vertical center of the ellipse.
WiredHome	72:ecffe56af969	2256	/// @param[in] radius1 defines the horizontal radius of the ellipse.
WiredHome	72:ecffe56af969	2257	/// @param[in] radius2 defines the vertical radius of the ellipse.
WiredHome	72:ecffe56af969	2258	/// @param[in] fillit defines whether the circle is filled or not.
WiredHome	106:c80828f5dea4	2259	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2260	///
WiredHome	37:f19b7e7449dc	2261	RetCode_t ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	2262
WiredHome	125:7a0b70f56550	2263
WiredHome	131:5bd6ba2ee4a1	2264
WiredHome	131:5bd6ba2ee4a1	2265	/// Block Move
WiredHome	131:5bd6ba2ee4a1	2266	///
WiredHome	131:5bd6ba2ee4a1	2267	/// The Block Move API activates the RA8875 Block Transfer Engine. Due to the complex
WiredHome	131:5bd6ba2ee4a1	2268	/// set of possible operations, the user should read the related sections of the
WiredHome	131:5bd6ba2ee4a1	2269	/// RA8875 user manual.
WiredHome	131:5bd6ba2ee4a1	2270	///
WiredHome	131:5bd6ba2ee4a1	2271	/// Some operations may require that other registers are configured, such as the
WiredHome	131:5bd6ba2ee4a1	2272	/// foreground and background color registers, and others. Those must be set
WiredHome	131:5bd6ba2ee4a1	2273	/// outside of this API.
WiredHome	131:5bd6ba2ee4a1	2274	///
WiredHome	138:61e93bed397e	2275	/// @code
WiredHome	138:61e93bed397e	2276	/// int main()
WiredHome	138:61e93bed397e	2277	/// {
WiredHome	138:61e93bed397e	2278	/// point_t src;
WiredHome	138:61e93bed397e	2279	/// point_t dst;
WiredHome	138:61e93bed397e	2280	/// TouchCode_t touch;
WiredHome	138:61e93bed397e	2281	/// const dim_t RECT_W = 100;
WiredHome	138:61e93bed397e	2282	/// const dim_t RECT_H = 100;
WiredHome	138:61e93bed397e	2283	///
WiredHome	138:61e93bed397e	2284	/// pc.baud(460800); //I like a snappy terminal, so crank it up!
WiredHome	138:61e93bed397e	2285	/// pc.printf("\r\nRA8875 BTE Move Test - Build " __DATE__ " " __TIME__ "\r\n");
WiredHome	138:61e93bed397e	2286	/// lcd.init(LCD_W,LCD_H,LCD_C, BL_NORM);
WiredHome	138:61e93bed397e	2287	/// lcd.TouchPanelInit();
WiredHome	138:61e93bed397e	2288	/// #ifndef CAP_TOUCH
WiredHome	138:61e93bed397e	2289	/// InitTS(); // Calibration for resistive touch panel
WiredHome	138:61e93bed397e	2290	/// #endif
WiredHome	138:61e93bed397e	2291	///
WiredHome	138:61e93bed397e	2292	/// RetCode_t r = lcd.RenderImageFile(0,0,"/local/fullscrn.jpg");
WiredHome	138:61e93bed397e	2293	/// if (r) pc.printf(" Error: %d; %s\r\n", r, lcd.GetErrorMessage(r));
WiredHome	138:61e93bed397e	2294	/// while (1) {
WiredHome	138:61e93bed397e	2295	/// touch = lcd.TouchPanelReadable();
WiredHome	138:61e93bed397e	2296	/// if (touch) {
WiredHome	138:61e93bed397e	2297	/// point_t xy = lcd.TouchCoordinates();
WiredHome	138:61e93bed397e	2298	/// TouchCode_t t = lcd.TouchCode();
WiredHome	138:61e93bed397e	2299	///
WiredHome	138:61e93bed397e	2300	/// if (t == touch) {
WiredHome	138:61e93bed397e	2301	/// src = ComputeTopLeftOfRect(xy, RECT_W/2, RECT_H/2, LCD_W, LCD_H);
WiredHome	138:61e93bed397e	2302	/// } else if (t == release) {
WiredHome	138:61e93bed397e	2303	/// dst = ComputeTopLeftOfRect(xy, RECT_W/2, RECT_H/2, LCD_W, LCD_H);
WiredHome	138:61e93bed397e	2304	/// r = lcd.BlockMove(0,0,dst, 0,0,src, RECT_W,RECT_H, 0x2, 0xC);
WiredHome	138:61e93bed397e	2305	/// }
WiredHome	138:61e93bed397e	2306	/// }
WiredHome	138:61e93bed397e	2307	/// }
WiredHome	138:61e93bed397e	2308	/// }
WiredHome	138:61e93bed397e	2309	/// @endcode
WiredHome	138:61e93bed397e	2310	///
WiredHome	139:99ec74e3273f	2311	/// @param[in] dstLayer layer [5B.7]. layer value is 0 or 1 representing layer 1 and 2.
WiredHome	131:5bd6ba2ee4a1	2312	/// @param[in] dstDataSelect [50.5] defines the destination data type 0: block, 1: linear.
WiredHome	131:5bd6ba2ee4a1	2313	/// @param[in] dstPoint [58-5B] is a point_t defining the destination coordinate.
WiredHome	139:99ec74e3273f	2314	/// @param[in] srcLayer layer [57.7]. layer value is 0 or 1 representing layer 1 and 2.
WiredHome	131:5bd6ba2ee4a1	2315	/// @param[in] srcDataSelect [50.6] defines the source data type 0: block, 1: linear.
WiredHome	131:5bd6ba2ee4a1	2316	/// @param[in] srcPoint [54-57] is a point_t defining the source coordinate.
WiredHome	131:5bd6ba2ee4a1	2317	/// @param[in] bte_width [5C-5D]. operation width.
WiredHome	131:5bd6ba2ee4a1	2318	/// @param[in] bte_height [5E-5F]. operation height.
WiredHome	131:5bd6ba2ee4a1	2319	/// @param[in] bte_op_code [51.3-0] defines the raster operation function
WiredHome	131:5bd6ba2ee4a1	2320	/// (write/read/move/...)
WiredHome	131:5bd6ba2ee4a1	2321	/// @param[in] bte_rop_code [51.7-4] defines what type of BTE operation to perform
WiredHome	131:5bd6ba2ee4a1	2322	/// (what is placed at the destination)
WiredHome	131:5bd6ba2ee4a1	2323	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	131:5bd6ba2ee4a1	2324	///
WiredHome	131:5bd6ba2ee4a1	2325	RetCode_t BlockMove(uint8_t dstLayer, uint8_t dstDataSelect, point_t dstPoint,
WiredHome	131:5bd6ba2ee4a1	2326	uint8_t srcLayer, uint8_t srcDataSelect, point_t srcPoint,
WiredHome	137:9e09f6081ef1	2327	dim_t bte_width, dim_t bte_height,
WiredHome	131:5bd6ba2ee4a1	2328	uint8_t bte_op_code, uint8_t bte_rop_code);
WiredHome	131:5bd6ba2ee4a1	2329
WiredHome	131:5bd6ba2ee4a1	2330
WiredHome	19:3f82c1161fd2	2331	/// Control display power
WiredHome	19:3f82c1161fd2	2332	///
WiredHome	72:ecffe56af969	2333	/// @param[in] on when set to true will turn on the display, when false it is turned off.
WiredHome	106:c80828f5dea4	2334	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2335	///
WiredHome	19:3f82c1161fd2	2336	RetCode_t Power(bool on);
WiredHome	19:3f82c1161fd2	2337
WiredHome	125:7a0b70f56550	2338
WiredHome	19:3f82c1161fd2	2339	/// Reset the display controller via the Software Reset interface.
WiredHome	19:3f82c1161fd2	2340	///
WiredHome	106:c80828f5dea4	2341	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2342	///
WiredHome	19:3f82c1161fd2	2343	RetCode_t Reset(void);
WiredHome	19:3f82c1161fd2	2344
WiredHome	125:7a0b70f56550	2345
WiredHome	19:3f82c1161fd2	2346	/// Set backlight brightness.
WiredHome	19:3f82c1161fd2	2347	///
WiredHome	19:3f82c1161fd2	2348	/// When the built-in PWM is used to control the backlight, this
WiredHome	19:3f82c1161fd2	2349	/// API can be used to set the brightness.
WiredHome	19:3f82c1161fd2	2350	///
WiredHome	72:ecffe56af969	2351	/// @param[in] brightness ranges from 0 (off) to 255 (full on)
WiredHome	106:c80828f5dea4	2352	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2353	///
WiredHome	131:5bd6ba2ee4a1	2354	RetCode_t Backlight_u8(uint8_t brightness);
WiredHome	125:7a0b70f56550	2355
WiredHome	19:3f82c1161fd2	2356
WiredHome	86:e86b355940f4	2357	/// Get backlight brightness.
WiredHome	86:e86b355940f4	2358	///
WiredHome	86:e86b355940f4	2359	/// @returns backlight setting from 0 (off) to 255 (full on).
WiredHome	86:e86b355940f4	2360	///
WiredHome	86:e86b355940f4	2361	uint8_t GetBacklight_u8(void);
WiredHome	86:e86b355940f4	2362
WiredHome	19:3f82c1161fd2	2363	/// Set backlight brightness.
WiredHome	19:3f82c1161fd2	2364	///
WiredHome	19:3f82c1161fd2	2365	/// When the built-in PWM is used to control the backlight, this
WiredHome	19:3f82c1161fd2	2366	/// API can be used to set the brightness.
WiredHome	19:3f82c1161fd2	2367	///
WiredHome	72:ecffe56af969	2368	/// @param[in] brightness ranges from 0.0 (off) to 1.0 (full on)
WiredHome	106:c80828f5dea4	2369	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2370	///
WiredHome	19:3f82c1161fd2	2371	RetCode_t Backlight(float brightness);
WiredHome	19:3f82c1161fd2	2372
WiredHome	125:7a0b70f56550	2373
WiredHome	86:e86b355940f4	2374	/// Get backlight brightness.
WiredHome	86:e86b355940f4	2375	///
WiredHome	86:e86b355940f4	2376	/// @returns backlight setting from 0 (off) to 1.0 (full on).
WiredHome	86:e86b355940f4	2377	///
WiredHome	86:e86b355940f4	2378	float GetBacklight(void);
WiredHome	86:e86b355940f4	2379
WiredHome	125:7a0b70f56550	2380
WiredHome	98:ecebed9b80b2	2381	/// Select a User Font for all subsequent text.
WiredHome	98:ecebed9b80b2	2382	///
WiredHome	98:ecebed9b80b2	2383	/// @note Tool to create the fonts is accessible from its creator
WiredHome	98:ecebed9b80b2	2384	/// available at http://www.mikroe.com.
WiredHome	98:ecebed9b80b2	2385	/// For version 1.2.0.0, choose the "Export for TFT and new GLCD"
WiredHome	98:ecebed9b80b2	2386	/// format.
WiredHome	98:ecebed9b80b2	2387	///
WiredHome	98:ecebed9b80b2	2388	/// @param[in] font is a pointer to a specially formed font resource.
WiredHome	98:ecebed9b80b2	2389	/// @returns error code.
WiredHome	98:ecebed9b80b2	2390	///
WiredHome	98:ecebed9b80b2	2391	virtual RetCode_t SelectUserFont(const uint8_t * font = NULL);
WiredHome	98:ecebed9b80b2	2392
WiredHome	127:db7f2c704693	2393	/// Get the currently selected user font.
WiredHome	127:db7f2c704693	2394	///
WiredHome	127:db7f2c704693	2395	/// @returns a pointer to the font, or null, if no user font is selected.
WiredHome	127:db7f2c704693	2396	///
WiredHome	127:db7f2c704693	2397	virtual const uint8_t * GetUserFont(void) { return font; }
WiredHome	19:3f82c1161fd2	2398
WiredHome	19:3f82c1161fd2	2399	/// Get the RGB value for a DOS color.
WiredHome	19:3f82c1161fd2	2400	///
WiredHome	125:7a0b70f56550	2401	/// @code
WiredHome	125:7a0b70f56550	2402	/// color_t color = DOSColor(12);
WiredHome	125:7a0b70f56550	2403	/// @endcode
WiredHome	125:7a0b70f56550	2404	///
WiredHome	72:ecffe56af969	2405	/// @param[in] i is the color, in the range 0 to 15;
WiredHome	19:3f82c1161fd2	2406	/// @returns the RGB color of the selected index, or 0
WiredHome	19:3f82c1161fd2	2407	/// if the index is out of bounds.
WiredHome	19:3f82c1161fd2	2408	///
WiredHome	19:3f82c1161fd2	2409	color_t DOSColor(int i);
WiredHome	19:3f82c1161fd2	2410
WiredHome	125:7a0b70f56550	2411
WiredHome	19:3f82c1161fd2	2412	/// Get the color name (string) for a DOS color.
WiredHome	19:3f82c1161fd2	2413	///
WiredHome	125:7a0b70f56550	2414	/// @code
WiredHome	125:7a0b70f56550	2415	/// printf("color is %s\n", DOSColorNames(12));
WiredHome	125:7a0b70f56550	2416	/// @endcode
WiredHome	125:7a0b70f56550	2417	///
WiredHome	72:ecffe56af969	2418	/// @param[in] i is the color, in the range 0 to 15;
WiredHome	19:3f82c1161fd2	2419	/// @returns a pointer to a string with the color name,
WiredHome	19:3f82c1161fd2	2420	/// or NULL if the index is out of bounds.
WiredHome	19:3f82c1161fd2	2421	///
WiredHome	19:3f82c1161fd2	2422	const char * DOSColorNames(int i);
WiredHome	19:3f82c1161fd2	2423
WiredHome	125:7a0b70f56550	2424
WiredHome	55:dfbabef7003e	2425	/// Advanced method indicating the start of a graphics stream.
WiredHome	55:dfbabef7003e	2426	///
WiredHome	55:dfbabef7003e	2427	/// This is called prior to a stream of pixel data being sent.
WiredHome	55:dfbabef7003e	2428	/// This may cause register configuration changes in the derived
WiredHome	55:dfbabef7003e	2429	/// class in order to prepare the hardware to accept the streaming
WiredHome	55:dfbabef7003e	2430	/// data.
WiredHome	55:dfbabef7003e	2431	///
WiredHome	106:c80828f5dea4	2432	/// Following this command, a series of See @ref _putp() commands can
WiredHome	55:dfbabef7003e	2433	/// be used to send individual pixels to the screen.
WiredHome	55:dfbabef7003e	2434	///
WiredHome	106:c80828f5dea4	2435	/// To conclude the graphics stream, See @ref _EndGraphicsStream should
WiredHome	55:dfbabef7003e	2436	/// be callled.
WiredHome	55:dfbabef7003e	2437	///
WiredHome	55:dfbabef7003e	2438	/// @returns error code.
WiredHome	55:dfbabef7003e	2439	///
WiredHome	55:dfbabef7003e	2440	virtual RetCode_t _StartGraphicsStream(void);
WiredHome	125:7a0b70f56550	2441
WiredHome	55:dfbabef7003e	2442
WiredHome	55:dfbabef7003e	2443	/// Advanced method to put a single color pixel to the screen.
WiredHome	55:dfbabef7003e	2444	///
WiredHome	55:dfbabef7003e	2445	/// This method may be called as many times as necessary after
WiredHome	106:c80828f5dea4	2446	/// See @ref _StartGraphicsStream() is called, and it should be followed
WiredHome	55:dfbabef7003e	2447	/// by _EndGraphicsStream.
WiredHome	55:dfbabef7003e	2448	///
WiredHome	125:7a0b70f56550	2449	/// @code
WiredHome	125:7a0b70f56550	2450	/// _putp(DOSColor(12));
WiredHome	125:7a0b70f56550	2451	/// @endcode
WiredHome	125:7a0b70f56550	2452	///
WiredHome	72:ecffe56af969	2453	/// @param[in] pixel is a color value to be put on the screen.
WiredHome	55:dfbabef7003e	2454	/// @returns error code.
WiredHome	55:dfbabef7003e	2455	///
WiredHome	55:dfbabef7003e	2456	virtual RetCode_t _putp(color_t pixel);
WiredHome	125:7a0b70f56550	2457
WiredHome	55:dfbabef7003e	2458
WiredHome	55:dfbabef7003e	2459	/// Advanced method indicating the end of a graphics stream.
WiredHome	55:dfbabef7003e	2460	///
WiredHome	55:dfbabef7003e	2461	/// This is called to conclude a stream of pixel data that was sent.
WiredHome	55:dfbabef7003e	2462	/// This may cause register configuration changes in the derived
WiredHome	55:dfbabef7003e	2463	/// class in order to stop the hardware from accept the streaming
WiredHome	55:dfbabef7003e	2464	/// data.
WiredHome	55:dfbabef7003e	2465	///
WiredHome	55:dfbabef7003e	2466	/// @returns error code.
WiredHome	55:dfbabef7003e	2467	///
WiredHome	55:dfbabef7003e	2468	virtual RetCode_t _EndGraphicsStream(void);
WiredHome	19:3f82c1161fd2	2469
WiredHome	125:7a0b70f56550	2470
WiredHome	57:bd53a9e165a1	2471	/// Set the SPI port frequency (in Hz).
WiredHome	57:bd53a9e165a1	2472	///
WiredHome	66:468a11f05580	2473	/// This uses the mbed SPI driver, and is therefore dependent on
WiredHome	66:468a11f05580	2474	/// its capabilities. The RA8875 can accept writes via SPI faster
WiredHome	66:468a11f05580	2475	/// than a read can be performed. The frequency set by this API
WiredHome	66:468a11f05580	2476	/// is for the SPI writes. It will automatically reduce the SPI
WiredHome	66:468a11f05580	2477	/// clock rate when a read is performed, and restore it for the
WiredHome	68:ab08efabfc88	2478	/// next write. Alternately, the 2nd parameters permits setting
WiredHome	68:ab08efabfc88	2479	/// the read speed rather than letting it compute it automatically.
WiredHome	57:bd53a9e165a1	2480	///
WiredHome	66:468a11f05580	2481	/// @note The primary effect of this is to recover more CPU cycles
WiredHome	66:468a11f05580	2482	/// for your application code. Keep in mind that when more than
WiredHome	66:468a11f05580	2483	/// one command is sent to the display controller, that it
WiredHome	66:468a11f05580	2484	/// will wait for the controller to finish the prior command.
WiredHome	66:468a11f05580	2485	/// In this case, the performance is limited by the RA8875.
WiredHome	57:bd53a9e165a1	2486	///
WiredHome	72:ecffe56af969	2487	/// @param[in] Hz is the frequency in Hz, tested range includes the
WiredHome	66:468a11f05580	2488	/// range from 1,000,000 (1MHz) to 10,000,000 (10 MHz). Values
WiredHome	66:468a11f05580	2489	/// outside this range will be accepted, but operation may
WiredHome	76:c981284eb513	2490	/// be unreliable. This depends partially on your hardware design
WiredHome	76:c981284eb513	2491	/// and the wires connecting the display module.
WiredHome	76:c981284eb513	2492	/// The default value is 5,000,000, which should work for most
WiredHome	76:c981284eb513	2493	/// applications as a starting point.
WiredHome	72:ecffe56af969	2494	/// @param[in] Hz2 is an optional parameter and will set the read
WiredHome	68:ab08efabfc88	2495	/// speed independently of the write speed.
WiredHome	106:c80828f5dea4	2496	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	57:bd53a9e165a1	2497	///
WiredHome	68:ab08efabfc88	2498	RetCode_t frequency(unsigned long Hz = RA8875_DEFAULT_SPI_FREQ, unsigned long Hz2 = 0);
WiredHome	125:7a0b70f56550	2499
WiredHome	125:7a0b70f56550	2500
WiredHome	72:ecffe56af969	2501	/// This method captures the specified area as a 24-bit bitmap file.
WiredHome	72:ecffe56af969	2502	///
WiredHome	72:ecffe56af969	2503	/// Even though this is a 16-bit display, the stored image is in
WiredHome	72:ecffe56af969	2504	/// 24-bit format.
WiredHome	72:ecffe56af969	2505	///
WiredHome	73:f22a18707b5e	2506	/// This method will interrogate the current display setting and
WiredHome	73:f22a18707b5e	2507	/// create a bitmap based on those settings. For instance, if
WiredHome	73:f22a18707b5e	2508	/// only layer 1 is visible, then the bitmap is only layer 1. However,
WiredHome	73:f22a18707b5e	2509	/// if there is some other operation in effect (transparent mode).
WiredHome	73:f22a18707b5e	2510	///
WiredHome	72:ecffe56af969	2511	/// @param[in] x is the left edge of the region to capture
WiredHome	72:ecffe56af969	2512	/// @param[in] y is the top edge of the region to capture
WiredHome	72:ecffe56af969	2513	/// @param[in] w is the width of the region to capture
WiredHome	72:ecffe56af969	2514	/// @param[in] h is the height of the region to capture.
WiredHome	72:ecffe56af969	2515	/// @param[out] Name_BMP is the filename to write the image to.
WiredHome	72:ecffe56af969	2516	/// @return success or error code.
WiredHome	72:ecffe56af969	2517	///
WiredHome	72:ecffe56af969	2518	RetCode_t PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP);
WiredHome	125:7a0b70f56550	2519
WiredHome	72:ecffe56af969	2520
WiredHome	96:40b74dd3695b	2521	/// This method captures the specified area as a 24-bit bitmap file
WiredHome	96:40b74dd3695b	2522	/// and delivers it to the previously attached callback.
WiredHome	96:40b74dd3695b	2523	///
WiredHome	96:40b74dd3695b	2524	/// Even though this is a 16-bit display, the stored image is in
WiredHome	96:40b74dd3695b	2525	/// 24-bit format.
WiredHome	96:40b74dd3695b	2526	///
WiredHome	96:40b74dd3695b	2527	/// This method will interrogate the current display setting and
WiredHome	96:40b74dd3695b	2528	/// create a bitmap based on those settings. For instance, if
WiredHome	96:40b74dd3695b	2529	/// only layer 1 is visible, then the bitmap is only layer 1. However,
WiredHome	96:40b74dd3695b	2530	/// if there is some other operation in effect (transparent mode), it
WiredHome	96:40b74dd3695b	2531	/// will return the blended image.
WiredHome	96:40b74dd3695b	2532	///
WiredHome	96:40b74dd3695b	2533	/// @param[in] x is the left edge of the region to capture
WiredHome	96:40b74dd3695b	2534	/// @param[in] y is the top edge of the region to capture
WiredHome	96:40b74dd3695b	2535	/// @param[in] w is the width of the region to capture
WiredHome	96:40b74dd3695b	2536	/// @param[in] h is the height of the region to capture.
WiredHome	96:40b74dd3695b	2537	/// @return success or error code.
WiredHome	96:40b74dd3695b	2538	///
WiredHome	96:40b74dd3695b	2539	RetCode_t PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h);
WiredHome	125:7a0b70f56550	2540
WiredHome	96:40b74dd3695b	2541
WiredHome	96:40b74dd3695b	2542	/// PrintScreen callback registration.
WiredHome	96:40b74dd3695b	2543	///
WiredHome	96:40b74dd3695b	2544	/// This method attaches a simple c-compatible callback of type PrintCallback_T.
WiredHome	96:40b74dd3695b	2545	/// Then, the PrintScreen(x,y,w,h) method is called. Each chunk of data in the
WiredHome	96:40b74dd3695b	2546	/// BMP file to be created is passed to this callback.
WiredHome	96:40b74dd3695b	2547	///
WiredHome	123:2f45e80fec5f	2548	/// @param callback is the optional callback function. Without a callback function
WiredHome	123:2f45e80fec5f	2549	/// it will unregister the handler.
WiredHome	96:40b74dd3695b	2550	///
WiredHome	123:2f45e80fec5f	2551	void AttachPrintHandler(PrintCallback_T callback = NULL) { c_callback = callback; }
WiredHome	96:40b74dd3695b	2552
WiredHome	125:7a0b70f56550	2553
WiredHome	96:40b74dd3695b	2554	/// PrintScreen callback registration.
WiredHome	96:40b74dd3695b	2555	///
WiredHome	96:40b74dd3695b	2556	/// This method attaches a c++ class method as a callback of type PrintCallback_T.
WiredHome	96:40b74dd3695b	2557	/// Then, the PrintScreen(x,y,w,h) method is called. Each chunk of data in the
WiredHome	96:40b74dd3695b	2558	/// BMP file to be created is passed to this callback.
WiredHome	96:40b74dd3695b	2559	///
WiredHome	96:40b74dd3695b	2560	/// @param object is the class hosting the callback function.
WiredHome	102:fc60bfa0199f	2561	/// @param method is the callback method in the object to activate.
WiredHome	96:40b74dd3695b	2562	///
WiredHome	96:40b74dd3695b	2563	template <class T>
WiredHome	102:fc60bfa0199f	2564	void AttachPrintHandler(T object, RetCode_t (T::method)(void)) {
WiredHome	102:fc60bfa0199f	2565	obj_callback = (FPointerDummy *)object;
WiredHome	108:7415c405ee08	2566	method_callback = (uint32_t (FPointerDummy::)(uint32_t, uint8_t , uint16_t))method;
WiredHome	96:40b74dd3695b	2567	}
WiredHome	96:40b74dd3695b	2568
WiredHome	125:7a0b70f56550	2569
WiredHome	72:ecffe56af969	2570	/// This method captures the specified area as a 24-bit bitmap file,
WiredHome	72:ecffe56af969	2571	/// including the option of layer selection.
WiredHome	72:ecffe56af969	2572	///
WiredHome	125:7a0b70f56550	2573	/// @note This method is deprecated as the alternate PrintScreen API
WiredHome	74:686faa218914	2574	/// automatically examines the display layer configuration.
WiredHome	74:686faa218914	2575	/// Therefore, calls to this API will ignore the layer parameter
WiredHome	74:686faa218914	2576	/// and automatically execute the other method.
WiredHome	74:686faa218914	2577	///
WiredHome	72:ecffe56af969	2578	/// Even though this is a 16-bit display, the stored image is in
WiredHome	72:ecffe56af969	2579	/// 24-bit format.
WiredHome	72:ecffe56af969	2580	///
WiredHome	72:ecffe56af969	2581	/// @param[in] layer is 0 or 1 to select the layer to extract.
WiredHome	72:ecffe56af969	2582	/// @param[in] x is the left edge of the region to capture
WiredHome	72:ecffe56af969	2583	/// @param[in] y is the top edge of the region to capture
WiredHome	72:ecffe56af969	2584	/// @param[in] w is the width of the region to capture
WiredHome	72:ecffe56af969	2585	/// @param[in] h is the height of the region to capture.
WiredHome	72:ecffe56af969	2586	/// @param[out] Name_BMP is the filename to write the image to.
WiredHome	72:ecffe56af969	2587	/// @return success or error code.
WiredHome	72:ecffe56af969	2588	///
WiredHome	72:ecffe56af969	2589	RetCode_t PrintScreen(uint16_t layer, loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP);
WiredHome	125:7a0b70f56550	2590
WiredHome	72:ecffe56af969	2591
WiredHome	123:2f45e80fec5f	2592	/// idle callback registration.
WiredHome	123:2f45e80fec5f	2593	///
WiredHome	125:7a0b70f56550	2594	/// This method attaches a simple c-compatible callback of type IdleCallback_T.
WiredHome	123:2f45e80fec5f	2595	/// Then, at any time when the display driver is waiting, it will call the
WiredHome	123:2f45e80fec5f	2596	/// registered function. This is probably most useful if you want to service
WiredHome	123:2f45e80fec5f	2597	/// a watchdog, when you may have called an API that will "hang" waiting
WiredHome	123:2f45e80fec5f	2598	/// on the user.
WiredHome	123:2f45e80fec5f	2599	///
WiredHome	123:2f45e80fec5f	2600	/// @param callback is the idle callback function. Without a callback function
WiredHome	123:2f45e80fec5f	2601	/// it will unregister the handler.
WiredHome	123:2f45e80fec5f	2602	///
WiredHome	123:2f45e80fec5f	2603	void AttachIdleHandler(IdleCallback_T callback = NULL) { idle_callback = callback; }
WiredHome	57:bd53a9e165a1	2604
WiredHome	133:e36dcfc2d756	2605
WiredHome	19:3f82c1161fd2	2606	#ifdef PERF_METRICS
WiredHome	19:3f82c1161fd2	2607	/// Clear the performance metrics to zero.
WiredHome	19:3f82c1161fd2	2608	void ClearPerformance();
WiredHome	19:3f82c1161fd2	2609
WiredHome	66:468a11f05580	2610	/// Count idle time.
WiredHome	66:468a11f05580	2611	///
WiredHome	72:ecffe56af969	2612	/// @param[in] t is the amount of idle time to accumulate.
WiredHome	66:468a11f05580	2613	///
WiredHome	66:468a11f05580	2614	void CountIdleTime(uint32_t t);
WiredHome	66:468a11f05580	2615
WiredHome	19:3f82c1161fd2	2616	/// Report the performance metrics for drawing functions using
WiredHome	41:2956a0a221e5	2617	/// the available serial channel.
WiredHome	41:2956a0a221e5	2618	///
WiredHome	72:ecffe56af969	2619	/// @param[in,out] pc is the serial channel to write to.
WiredHome	41:2956a0a221e5	2620	///
WiredHome	41:2956a0a221e5	2621	void ReportPerformance(Serial & pc);
WiredHome	19:3f82c1161fd2	2622	#endif
WiredHome	19:3f82c1161fd2	2623
hexley	54:e117ad10fba6	2624
WiredHome	19:3f82c1161fd2	2625	private:
WiredHome	124:1690a7ae871c	2626	/// Touch panel parameters - common to both resistive and capacitive
WiredHome	124:1690a7ae871c	2627
WiredHome	124:1690a7ae871c	2628	/// Data type to indicate which TP, if any, is in use.
WiredHome	124:1690a7ae871c	2629	typedef enum {
WiredHome	124:1690a7ae871c	2630	TP_NONE, ///< no touch panel in use
WiredHome	124:1690a7ae871c	2631	TP_RES, ///< resistive touch panel using RA8875
WiredHome	124:1690a7ae871c	2632	TP_CAP, ///< capacitive touch panel using FT5206
WiredHome	124:1690a7ae871c	2633	} WhichTP_T;
WiredHome	124:1690a7ae871c	2634
WiredHome	124:1690a7ae871c	2635	/// boolean flag set true when using Capacitive touch panel, and false
WiredHome	124:1690a7ae871c	2636	/// for resistive.
WiredHome	124:1690a7ae871c	2637	WhichTP_T useTouchPanel; ///< Indicates which TP is selected for use.
WiredHome	124:1690a7ae871c	2638
WiredHome	124:1690a7ae871c	2639	/// Touch State used by TouchPanelReadable. See @ref TouchCode_t.
WiredHome	124:1690a7ae871c	2640	TouchCode_t touchState;
WiredHome	124:1690a7ae871c	2641
WiredHome	124:1690a7ae871c	2642	////////////////// Start of Capacitive Touch Panel parameters
WiredHome	124:1690a7ae871c	2643
WiredHome	124:1690a7ae871c	2644	uint8_t getTouchPositions(void);
WiredHome	124:1690a7ae871c	2645	void TouchPanelISR(void);
WiredHome	124:1690a7ae871c	2646	uint16_t numberOfTouchPoints;
WiredHome	124:1690a7ae871c	2647	uint8_t gesture; ///< Holds the reported gesture information.
WiredHome	124:1690a7ae871c	2648
WiredHome	124:1690a7ae871c	2649	/// Touch Information data structure
WiredHome	124:1690a7ae871c	2650	typedef struct {
WiredHome	124:1690a7ae871c	2651	uint8_t touchID; ///< Contains the touch ID, which is the "order" of touch, from 0 to n-1
WiredHome	124:1690a7ae871c	2652	TouchCode_t touchCode; ///< Contains the touch code; no_touch, touch, held, release
WiredHome	124:1690a7ae871c	2653	point_t coordinates; ///< Contains the X,Y coordinate of the touch
WiredHome	124:1690a7ae871c	2654	} touchInfo_T;
WiredHome	124:1690a7ae871c	2655
WiredHome	124:1690a7ae871c	2656	touchInfo_T touchInfo[5]; /// Contains the actual touch information in an array from 0 to n-1
WiredHome	124:1690a7ae871c	2657
WiredHome	124:1690a7ae871c	2658	InterruptIn * m_irq;
WiredHome	124:1690a7ae871c	2659	I2C * m_i2c;
WiredHome	124:1690a7ae871c	2660	int m_addr;
WiredHome	124:1690a7ae871c	2661	uint8_t data[2];
WiredHome	124:1690a7ae871c	2662
WiredHome	124:1690a7ae871c	2663	bool panelTouched;
WiredHome	124:1690a7ae871c	2664	void writeRegister8(uint8_t reg, uint8_t val);
WiredHome	124:1690a7ae871c	2665	uint8_t readRegister8(uint8_t reg);
WiredHome	124:1690a7ae871c	2666
WiredHome	124:1690a7ae871c	2667
WiredHome	124:1690a7ae871c	2668	////////////////// Start of Resistive Touch Panel parameters
WiredHome	124:1690a7ae871c	2669
WiredHome	124:1690a7ae871c	2670	/// Resistive Touch Panel register name definitions
WiredHome	77:9206c13aa527	2671	#define TPCR0 0x70
WiredHome	77:9206c13aa527	2672	#define TPCR1 0x71
WiredHome	77:9206c13aa527	2673	#define TPXH 0x72
WiredHome	77:9206c13aa527	2674	#define TPYH 0x73
WiredHome	77:9206c13aa527	2675	#define TPXYL 0x74
WiredHome	77:9206c13aa527	2676	#define INTC1 0xF0
WiredHome	77:9206c13aa527	2677	#define INTC2 0xF1
hexley	54:e117ad10fba6	2678
hexley	54:e117ad10fba6	2679	/// Specify the default settings for the Touch Panel, where different from the chip defaults
WiredHome	77:9206c13aa527	2680	#define TP_MODE_DEFAULT TP_MODE_AUTO
WiredHome	77:9206c13aa527	2681	#define TP_DEBOUNCE_DEFAULT TP_DEBOUNCE_ON
WiredHome	77:9206c13aa527	2682	#define TP_ADC_CLKDIV_DEFAULT TP_ADC_CLKDIV_8
hexley	54:e117ad10fba6	2683
WiredHome	77:9206c13aa527	2684	#define TP_ADC_SAMPLE_DEFAULT_CLKS TP_ADC_SAMPLE_8192_CLKS
hexley	54:e117ad10fba6	2685
hexley	54:e117ad10fba6	2686	/// Other Touch Panel params
WiredHome	77:9206c13aa527	2687	#define TPBUFSIZE 16 // Depth of the averaging buffers for x and y data
hexley	54:e117ad10fba6	2688
WiredHome	83:7bad0068cca0	2689	// Needs both a ticker and a timer. (could have created a timer from the ticker, but this is easier).
WiredHome	83:7bad0068cca0	2690	// on a touch, the timer is reset.
WiredHome	83:7bad0068cca0	2691	// the ticker monitors the timer to see if it has been a long time since
WiredHome	83:7bad0068cca0	2692	// a touch, and if so, it then clears the sample counter so it doesn't get partial old
WiredHome	83:7bad0068cca0	2693	// and partial new.
WiredHome	83:7bad0068cca0	2694
WiredHome	83:7bad0068cca0	2695	/// Touch Panel ticker
WiredHome	83:7bad0068cca0	2696	Ticker touchTicker;
WiredHome	83:7bad0068cca0	2697
WiredHome	83:7bad0068cca0	2698	/// Touch Panel timer
WiredHome	83:7bad0068cca0	2699	Timer touchTimer;
WiredHome	83:7bad0068cca0	2700
WiredHome	83:7bad0068cca0	2701	/// keeps track of which sample we're collecting to filter out the noise.
WiredHome	83:7bad0068cca0	2702	int touchSample;
WiredHome	83:7bad0068cca0	2703
WiredHome	83:7bad0068cca0	2704	/// Private function for touch ticker callback.
WiredHome	83:7bad0068cca0	2705	void _TouchTicker(void);
WiredHome	83:7bad0068cca0	2706
WiredHome	77:9206c13aa527	2707	/// Touch Panel calibration matrix.
WiredHome	77:9206c13aa527	2708	tpMatrix_t tpMatrix;
hexley	54:e117ad10fba6	2709
WiredHome	124:1690a7ae871c	2710	////////////////// End of Touch Panel parameters
WiredHome	124:1690a7ae871c	2711
WiredHome	124:1690a7ae871c	2712
WiredHome	29:422616aa04bd	2713	/// Internal function to put a character using the built-in (internal) font engine
WiredHome	29:422616aa04bd	2714	///
WiredHome	101:e0aad446094a	2715	/// @param[in] c is the character to put to the screen.
WiredHome	29:422616aa04bd	2716	/// @returns the character put.
WiredHome	29:422616aa04bd	2717	///
WiredHome	29:422616aa04bd	2718	int _internal_putc(int c);
WiredHome	29:422616aa04bd	2719
WiredHome	29:422616aa04bd	2720	/// Internal function to put a character using the external font engine
WiredHome	29:422616aa04bd	2721	///
WiredHome	101:e0aad446094a	2722	/// @param[in] c is the character to put to the screen.
WiredHome	29:422616aa04bd	2723	/// @returns the character put.
WiredHome	29:422616aa04bd	2724	///
WiredHome	29:422616aa04bd	2725	int _external_putc(int c);
WiredHome	29:422616aa04bd	2726
WiredHome	101:e0aad446094a	2727	/// Internal function to get the actual width of a character when using the external font engine
WiredHome	101:e0aad446094a	2728	///
WiredHome	101:e0aad446094a	2729	/// @param[in] c is the character to get the width.
WiredHome	101:e0aad446094a	2730	/// @returns the width in pixels of the character. zero if not found.
WiredHome	101:e0aad446094a	2731	///
WiredHome	101:e0aad446094a	2732	int _external_getCharWidth(int c);
WiredHome	101:e0aad446094a	2733
WiredHome	133:e36dcfc2d756	2734	/// Write color to an RGB register set
WiredHome	133:e36dcfc2d756	2735	///
WiredHome	133:e36dcfc2d756	2736	/// This API takes a color value, and writes it into the specified
WiredHome	133:e36dcfc2d756	2737	/// color registers, which are a trio of 3 registers. The actual
WiredHome	133:e36dcfc2d756	2738	/// trio write is performed based on whether the display is configured
WiredHome	133:e36dcfc2d756	2739	/// for 8 or 16 bits per pixel.
WiredHome	133:e36dcfc2d756	2740	///
WiredHome	133:e36dcfc2d756	2741	/// @param[in] regAddr is the register address starting the trio
WiredHome	133:e36dcfc2d756	2742	/// @param[in] color is the color to write
WiredHome	133:e36dcfc2d756	2743	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	133:e36dcfc2d756	2744	///
WiredHome	133:e36dcfc2d756	2745	RetCode_t _writeColorTrio(uint8_t regAddr, color_t color);
WiredHome	133:e36dcfc2d756	2746
WiredHome	133:e36dcfc2d756	2747	/// Read color from an RGB register set
WiredHome	133:e36dcfc2d756	2748	///
WiredHome	133:e36dcfc2d756	2749	/// This API reads a color value from a trio of registers. The actual
WiredHome	133:e36dcfc2d756	2750	/// trio write is performed based on whether the display is configured
WiredHome	133:e36dcfc2d756	2751	/// for 8 or 16 bits per pixel.
WiredHome	133:e36dcfc2d756	2752	///
WiredHome	133:e36dcfc2d756	2753	/// @param[in] regAddr is the register address starting the trio
WiredHome	133:e36dcfc2d756	2754	/// @returns color_t value
WiredHome	133:e36dcfc2d756	2755	///
WiredHome	133:e36dcfc2d756	2756	color_t _readColorTrio(uint8_t regAddr);
WiredHome	133:e36dcfc2d756	2757
WiredHome	133:e36dcfc2d756	2758
WiredHome	105:4f116006ba1f	2759	/// Convert a 16-bit color value to an 8-bit value
WiredHome	105:4f116006ba1f	2760	///
WiredHome	105:4f116006ba1f	2761	/// @param[in] c16 is the 16-bit color value to convert.
WiredHome	105:4f116006ba1f	2762	/// @returns 8-bit color value.
WiredHome	105:4f116006ba1f	2763	///
WiredHome	105:4f116006ba1f	2764	uint8_t _cvt16to8(color_t c16);
WiredHome	105:4f116006ba1f	2765
WiredHome	105:4f116006ba1f	2766	/// Convert an 8-bit color value to a 16-bit value
WiredHome	105:4f116006ba1f	2767	///
WiredHome	105:4f116006ba1f	2768	/// @param[in] c8 is the 8-bit color value to convert.
WiredHome	105:4f116006ba1f	2769	/// @returns 16-bit color value.
WiredHome	105:4f116006ba1f	2770	///
WiredHome	105:4f116006ba1f	2771	color_t _cvt8to16(uint8_t c8);
WiredHome	105:4f116006ba1f	2772
WiredHome	19:3f82c1161fd2	2773	/// Select the peripheral to use it.
WiredHome	19:3f82c1161fd2	2774	///
WiredHome	72:ecffe56af969	2775	/// @param[in] chipsel when true will select the peripheral, and when false
WiredHome	19:3f82c1161fd2	2776	/// will deselect the chip. This is the logical selection, and
WiredHome	19:3f82c1161fd2	2777	/// the pin selection is the invert of this.
WiredHome	106:c80828f5dea4	2778	/// @returns success/failure code. See @ref RetCode_t.
WiredHome	19:3f82c1161fd2	2779	///
WiredHome	79:544eb4964795	2780	RetCode_t _select(bool chipsel);
WiredHome	19:3f82c1161fd2	2781
WiredHome	66:468a11f05580	2782	/// Wait while the status register indicates the controller is busy.
WiredHome	66:468a11f05580	2783	///
WiredHome	72:ecffe56af969	2784	/// @param[in] mask is the mask of bits to monitor.
WiredHome	66:468a11f05580	2785	/// @returns true if a normal exit.
WiredHome	66:468a11f05580	2786	/// @returns false if a timeout exit.
WiredHome	66:468a11f05580	2787	///
WiredHome	66:468a11f05580	2788	bool _WaitWhileBusy(uint8_t mask);
WiredHome	66:468a11f05580	2789
WiredHome	66:468a11f05580	2790	/// Wait while the the register anded with the mask is true.
WiredHome	66:468a11f05580	2791	///
WiredHome	72:ecffe56af969	2792	/// @param[in] reg is the register to monitor
WiredHome	72:ecffe56af969	2793	/// @param[in] mask is the bit mask to monitor
WiredHome	66:468a11f05580	2794	/// @returns true if it was a normal exit
WiredHome	66:468a11f05580	2795	/// @returns false if it was a timeout that caused the exit.
WiredHome	66:468a11f05580	2796	///
WiredHome	66:468a11f05580	2797	bool _WaitWhileReg(uint8_t reg, uint8_t mask);
WiredHome	66:468a11f05580	2798
WiredHome	68:ab08efabfc88	2799	/// set the spi port to either the write or the read speed.
WiredHome	68:ab08efabfc88	2800	///
WiredHome	68:ab08efabfc88	2801	/// This is a private API used to toggle between the write
WiredHome	68:ab08efabfc88	2802	/// and the read speed for the SPI port to the RA8875, since
WiredHome	68:ab08efabfc88	2803	/// it can accept writes faster than reads.
WiredHome	68:ab08efabfc88	2804	///
WiredHome	72:ecffe56af969	2805	/// @param[in] writeSpeed when true selects the write frequency,
WiredHome	68:ab08efabfc88	2806	/// and when false it selects the read frequency.
WiredHome	68:ab08efabfc88	2807	///
WiredHome	68:ab08efabfc88	2808	void _setWriteSpeed(bool writeSpeed);
WiredHome	68:ab08efabfc88	2809
WiredHome	19:3f82c1161fd2	2810	/// The most primitive - to write a data value to the SPI interface.
WiredHome	19:3f82c1161fd2	2811	///
WiredHome	72:ecffe56af969	2812	/// @param[in] data is the value to write.
WiredHome	19:3f82c1161fd2	2813	/// @returns a value read from the port, since SPI is often shift
WiredHome	19:3f82c1161fd2	2814	/// in while shifting out.
WiredHome	19:3f82c1161fd2	2815	///
WiredHome	79:544eb4964795	2816	unsigned char _spiwrite(unsigned char data);
WiredHome	19:3f82c1161fd2	2817
WiredHome	19:3f82c1161fd2	2818	/// The most primitive - to read a data value to the SPI interface.
WiredHome	19:3f82c1161fd2	2819	///
WiredHome	19:3f82c1161fd2	2820	/// This is really just a specialcase of the write command, where
WiredHome	19:3f82c1161fd2	2821	/// the value zero is written in order to read.
WiredHome	19:3f82c1161fd2	2822	///
WiredHome	19:3f82c1161fd2	2823	/// @returns a value read from the port, since SPI is often shift
WiredHome	19:3f82c1161fd2	2824	/// in while shifting out.
WiredHome	19:3f82c1161fd2	2825	///
WiredHome	79:544eb4964795	2826	unsigned char _spiread();
WiredHome	19:3f82c1161fd2	2827
WiredHome	75:ca78388cfd77	2828	const uint8_t * pKeyMap;
WiredHome	75:ca78388cfd77	2829
WiredHome	19:3f82c1161fd2	2830	SPI spi; ///< spi port
WiredHome	68:ab08efabfc88	2831	bool spiWriteSpeed; ///< indicates if the current mode is write or read
WiredHome	68:ab08efabfc88	2832	unsigned long spiwritefreq; ///< saved write freq
WiredHome	66:468a11f05580	2833	unsigned long spireadfreq; ///< saved read freq
WiredHome	19:3f82c1161fd2	2834	DigitalOut cs; ///< chip select pin, assumed active low
WiredHome	19:3f82c1161fd2	2835	DigitalOut res; ///< reset pin, assumed active low
WiredHome	90:d113d71ae4f0	2836
WiredHome	105:4f116006ba1f	2837	// display metrics to avoid lengthy spi read queries
WiredHome	105:4f116006ba1f	2838	uint8_t screenbpp; ///< configured bits per pixel
WiredHome	90:d113d71ae4f0	2839	dim_t screenwidth; ///< configured screen width
WiredHome	90:d113d71ae4f0	2840	dim_t screenheight; ///< configured screen height
WiredHome	111:efe436c43aba	2841	rect_t windowrect; ///< window commands are held here for speed of access
WiredHome	90:d113d71ae4f0	2842	bool portraitmode; ///< set true when in portrait mode (w,h are reversed)
WiredHome	90:d113d71ae4f0	2843
WiredHome	19:3f82c1161fd2	2844	const unsigned char * font; ///< reference to an external font somewhere in memory
WiredHome	98:ecebed9b80b2	2845	uint8_t extFontHeight; ///< computed from the font table when the user sets the font
WiredHome	98:ecebed9b80b2	2846	uint8_t extFontWidth; ///< computed from the font table when the user sets the font
WiredHome	98:ecebed9b80b2	2847
WiredHome	90:d113d71ae4f0	2848	loc_t cursor_x, cursor_y; ///< used for external fonts only
WiredHome	19:3f82c1161fd2	2849
WiredHome	19:3f82c1161fd2	2850	#ifdef PERF_METRICS
WiredHome	19:3f82c1161fd2	2851	typedef enum
WiredHome	19:3f82c1161fd2	2852	{
WiredHome	19:3f82c1161fd2	2853	PRF_CLS,
WiredHome	41:2956a0a221e5	2854	PRF_DRAWPIXEL,
WiredHome	41:2956a0a221e5	2855	PRF_PIXELSTREAM,
WiredHome	109:7b94f06f085b	2856	PRF_BOOLSTREAM,
WiredHome	41:2956a0a221e5	2857	PRF_READPIXEL,
WiredHome	41:2956a0a221e5	2858	PRF_READPIXELSTREAM,
WiredHome	19:3f82c1161fd2	2859	PRF_DRAWLINE,
WiredHome	19:3f82c1161fd2	2860	PRF_DRAWRECTANGLE,
WiredHome	19:3f82c1161fd2	2861	PRF_DRAWROUNDEDRECTANGLE,
WiredHome	19:3f82c1161fd2	2862	PRF_DRAWTRIANGLE,
WiredHome	19:3f82c1161fd2	2863	PRF_DRAWCIRCLE,
WiredHome	19:3f82c1161fd2	2864	PRF_DRAWELLIPSE,
WiredHome	131:5bd6ba2ee4a1	2865	PRF_BLOCKMOVE,
WiredHome	19:3f82c1161fd2	2866	METRICCOUNT
WiredHome	19:3f82c1161fd2	2867	} method_e;
WiredHome	19:3f82c1161fd2	2868	unsigned long metrics[METRICCOUNT];
WiredHome	75:ca78388cfd77	2869	unsigned long idletime_usec;
WiredHome	19:3f82c1161fd2	2870	void RegisterPerformance(method_e method);
WiredHome	19:3f82c1161fd2	2871	Timer performance;
WiredHome	19:3f82c1161fd2	2872	#endif
WiredHome	96:40b74dd3695b	2873
WiredHome	96:40b74dd3695b	2874	RetCode_t _printCallback(RA8875::filecmd_t cmd, uint8_t * buffer, uint16_t size);
WiredHome	96:40b74dd3695b	2875
WiredHome	96:40b74dd3695b	2876	FILE * _printFH; ///< PrintScreen file handle
WiredHome	96:40b74dd3695b	2877
WiredHome	96:40b74dd3695b	2878	RetCode_t privateCallback(filecmd_t cmd, uint8_t * buffer, uint16_t size) {
WiredHome	96:40b74dd3695b	2879	if (c_callback != NULL) {
WiredHome	96:40b74dd3695b	2880	return (*c_callback)(cmd, buffer, size);
WiredHome	96:40b74dd3695b	2881	}
WiredHome	96:40b74dd3695b	2882	else {
WiredHome	96:40b74dd3695b	2883	if (obj_callback != NULL && method_callback != NULL) {
WiredHome	96:40b74dd3695b	2884	return (obj_callback->*method_callback)(cmd, buffer, size);
WiredHome	96:40b74dd3695b	2885	}
WiredHome	96:40b74dd3695b	2886	}
WiredHome	96:40b74dd3695b	2887	return noerror;
WiredHome	96:40b74dd3695b	2888	}
WiredHome	96:40b74dd3695b	2889
WiredHome	96:40b74dd3695b	2890	RetCode_t (* c_callback)(filecmd_t cmd, uint8_t * buffer, uint16_t size);
WiredHome	96:40b74dd3695b	2891	FPointerDummy *obj_callback;
WiredHome	96:40b74dd3695b	2892	RetCode_t (FPointerDummy::method_callback)(filecmd_t cmd, uint8_t buffer, uint16_t size);
WiredHome	123:2f45e80fec5f	2893	RetCode_t (* idle_callback)(IdleReason_T reason);
WiredHome	19:3f82c1161fd2	2894	};
WiredHome	19:3f82c1161fd2	2895
WiredHome	96:40b74dd3695b	2896
WiredHome	19:3f82c1161fd2	2897	//} // namespace
WiredHome	19:3f82c1161fd2	2898
WiredHome	19:3f82c1161fd2	2899	//using namespace SW_graphics;
WiredHome	19:3f82c1161fd2	2900
WiredHome	23:a50ded45dbaf	2901
WiredHome	23:a50ded45dbaf	2902	#ifdef TESTENABLE
WiredHome	23:a50ded45dbaf	2903	// ______________ ______________ ______________ _______________
WiredHome	23:a50ded45dbaf	2904	// /_____ _____/ / ___________/ / ___________/ /_____ ______/
WiredHome	23:a50ded45dbaf	2905	// / / / / / / / /
WiredHome	23:a50ded45dbaf	2906	// / / / /___ / /__________ / /
WiredHome	23:a50ded45dbaf	2907	// / / / ____/ /__________ / / /
WiredHome	23:a50ded45dbaf	2908	// / / / / / / / /
WiredHome	23:a50ded45dbaf	2909	// / / / /__________ ___________/ / / /
WiredHome	23:a50ded45dbaf	2910	// /__/ /_____________/ /_____________/ /__/
WiredHome	23:a50ded45dbaf	2911
WiredHome	23:a50ded45dbaf	2912	#include "WebColors.h"
WiredHome	23:a50ded45dbaf	2913	#include <algorithm>
WiredHome	23:a50ded45dbaf	2914
WiredHome	23:a50ded45dbaf	2915	extern "C" void mbed_reset();
WiredHome	23:a50ded45dbaf	2916
WiredHome	23:a50ded45dbaf	2917	/// This activates a small set of tests for the graphics library.
WiredHome	23:a50ded45dbaf	2918	///
WiredHome	23:a50ded45dbaf	2919	/// Call this API and pass it the reference to the display class.
WiredHome	23:a50ded45dbaf	2920	/// It will then run a series of tests. It accepts interaction via
WiredHome	23:a50ded45dbaf	2921	/// stdin to switch from automatic test mode to manual, run a specific
WiredHome	23:a50ded45dbaf	2922	/// test, or to exit the test mode.
WiredHome	23:a50ded45dbaf	2923	///
WiredHome	72:ecffe56af969	2924	/// @param[in] lcd is a reference to the display class.
WiredHome	72:ecffe56af969	2925	/// @param[in] pc is a reference to a serial interface, typically the USB to PC.
WiredHome	23:a50ded45dbaf	2926	///
WiredHome	23:a50ded45dbaf	2927	void RunTestSet(RA8875 & lcd, Serial & pc);
WiredHome	23:a50ded45dbaf	2928
WiredHome	23:a50ded45dbaf	2929
WiredHome	23:a50ded45dbaf	2930	// To enable the test code, uncomment this section, or copy the
WiredHome	23:a50ded45dbaf	2931	// necessary pieces to your "main()".
WiredHome	23:a50ded45dbaf	2932	//
WiredHome	23:a50ded45dbaf	2933	// #include "mbed.h"
WiredHome	23:a50ded45dbaf	2934	// #include "RA8875.h"
WiredHome	23:a50ded45dbaf	2935	// RA8875 lcd(p5, p6, p7, p12, NC, "tft"); // MOSI, MISO, SCK, /ChipSelect, /reset, name
WiredHome	23:a50ded45dbaf	2936	// Serial pc(USBTX, USBRX);
WiredHome	23:a50ded45dbaf	2937	// extern "C" void mbed_reset();
WiredHome	23:a50ded45dbaf	2938	// int main()
WiredHome	23:a50ded45dbaf	2939	// {
WiredHome	23:a50ded45dbaf	2940	// pc.baud(460800); // I like a snappy terminal, so crank it up!
WiredHome	23:a50ded45dbaf	2941	// pc.printf("\r\nRA8875 Test - Build " __DATE__ " " __TIME__ "\r\n");
WiredHome	23:a50ded45dbaf	2942	//
WiredHome	23:a50ded45dbaf	2943	// pc.printf("Turning on display\r\n");
WiredHome	101:e0aad446094a	2944	// lcd.init();
WiredHome	23:a50ded45dbaf	2945	// lcd.Reset();
WiredHome	23:a50ded45dbaf	2946	// lcd.Power(true); // display power is on, but the backlight is independent
WiredHome	23:a50ded45dbaf	2947	// lcd.Backlight(0.5);
WiredHome	23:a50ded45dbaf	2948	// RunTestSet(lcd, pc);
WiredHome	23:a50ded45dbaf	2949	// }
WiredHome	23:a50ded45dbaf	2950
WiredHome	23:a50ded45dbaf	2951	#endif // TESTENABLE
WiredHome	23:a50ded45dbaf	2952
WiredHome	56:7a85d226ad0d	2953	#endif

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)