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@156:4bdb2772128d, 2018-11-19 (annotated)

Committer:: WiredHome
Date:: Mon Nov 19 02:21:41 2018 +0000
Revision:: 156:4bdb2772128d
Parent:: 155:b3f225ae572c
Child:: 157:1565f38ca44b

Add a macro for backward compatibility

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