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@151:ae94daaaf8ad, 2018-04-14 (annotated)

Committer:: WiredHome
Date:: Sat Apr 14 17:48:59 2018 +0000
Revision:: 151:ae94daaaf8ad
Parent:: 149:c62c4b2d6a15

Add support for scaling soft fonts, using the SetTextFontSize api.

Who changed what in which revision?

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