RA8875 - KSM edits to RA8875

Users » kerrysmartin » Code » RA8875

KSM edits to RA8875

RA8875.h@165:695c24cc5197, 2019-02-24 (annotated)

Committer:: WiredHome
Date:: Sun Feb 24 00:40:00 2019 +0000
Revision:: 165:695c24cc5197
Parent:: 164:76edd7d9cb68
Child:: 166:53fd4a876dac

Initial refactoring to add support for another Cap Sense touch controller - based on the GSL1680.

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	11 Jul 2019
Imports:	5
Forks:	0
Commits:	178
Dependents:	1
Dependencies:	0
Followers:	1

RA8875.h@165:695c24cc5197, 2019-02-24 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning