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@142:6e9bff59878a, 2017-03-19 (annotated)

Committer:: WiredHome
Date:: Sun Mar 19 21:41:24 2017 +0000
Revision:: 142:6e9bff59878a
Parent:: 140:33ca352755a2
Child:: 143:e872d65a710d

Breaking change on SelectDrawingLayer command, which now returns the previous layer (making it far easier to restore layers).

Who changed what in which revision?

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