RA8875 - Library to control a Graphics TFT connected to 4-…

Users » WiredHome » Code » RA8875

Library to control a Graphics TFT connected to 4-wire SPI - revised for the Raio RA8875 Display Controller.

Dependents: FRDM_RA8875_mPaint RA8875_Demo RA8875_KeyPadDemo SignalGenerator ... more

Enhanced touch-screen support - where it previous supported both the Resistive Touch and Capacitive Touch based on the FT5206 Touch Controller, now it also has support for the GSL1680 Touch Controller.

Offline Help Manual (Windows chm)

/media/uploads/WiredHome/ra8875.zip.bin (download, rename to .zip and unzip)

RA8875.h@83:7bad0068cca0, 2015-01-01 (annotated)

Committer:: WiredHome
Date:: Thu Jan 01 20:35:37 2015 +0000
Revision:: 83:7bad0068cca0
Parent:: 82:f7d300f26540
Child:: 84:e102021864b5

Improve touch interface to automatically provide no_touch, touch, held, release, no_cal value.; Touch API return codes were modified to accommodate this.; Enhance some APIs with (point_t p) parameters.; Minor internal documentation improvement.

Who changed what in which revision?

User	Revision	Line number	New contents of line
WiredHome	78:faf49c381591	1	///
WiredHome	78:faf49c381591	2	/// @mainpage RA8875 Display Controller Driver library
WiredHome	78:faf49c381591	3	///
WiredHome	78:faf49c381591	4	/// The RA8875 Display controller is a powerful interface for low cost displays. It
WiredHome	78:faf49c381591	5	/// can support displays up to 800 x 600 pixels x 16-bit color. Another common
WiredHome	78:faf49c381591	6	/// implementation is 480 x 272 x 16 with two layers. The two layers can be
WiredHome	78:faf49c381591	7	/// exchanged, or blended in various ways (transparency, OR, AND, and more).
WiredHome	78:faf49c381591	8	/// It includes graphics acceleration capabilities for drawing primitives,
WiredHome	78:faf49c381591	9	/// such as line, rectangle, circles, and more.
WiredHome	78:faf49c381591	10	///
WiredHome	78:faf49c381591	11	/// The controller additionally supports backlight control (via PWM), keypad scanning
WiredHome	78:faf49c381591	12	/// (for a 4 x 5 matrix) and resistive touch-panel support.
WiredHome	78:faf49c381591	13	///
WiredHome	78:faf49c381591	14	/// @section Display_Config Display Configuration
WiredHome	78:faf49c381591	15	///
WiredHome	78:faf49c381591	16	/// This section details basics for bringing the display online. At a minimum,
WiredHome	78:faf49c381591	17	/// the display is instantiated. After that any of the available commands
WiredHome	78:faf49c381591	18	/// may be issued.
WiredHome	78:faf49c381591	19	///
WiredHome	78:faf49c381591	20	/// During the instantiation, the display is powered on, cleared, and the backlight
WiredHome	78:faf49c381591	21	/// is energized. Additionally, the keypad and touchscreen features are activated.
WiredHome	78:faf49c381591	22	/// It is important to keep in mind that the keypad had the default mapping, and
WiredHome	78:faf49c381591	23	/// the touchscreen does not have the calibration matrix configured, so additional
WiredHome	78:faf49c381591	24	/// steps may be necessary.
WiredHome	78:faf49c381591	25	///
WiredHome	78:faf49c381591	26	/// @code
WiredHome	78:faf49c381591	27	/// RA8875 lcd(p5, p6, p7, p12, NC, "tft");
WiredHome	81:01da2e34283d	28	/// lcd.init();
WiredHome	78:faf49c381591	29	/// lcd.foreground(Blue);
WiredHome	78:faf49c381591	30	/// lcd.line(0,0, 479,271);
WiredHome	78:faf49c381591	31	/// ...
WiredHome	78:faf49c381591	32	/// @endcode
WiredHome	78:faf49c381591	33	///
WiredHome	78:faf49c381591	34	/// @section Touch_Panel Touch Panel
WiredHome	78:faf49c381591	35	///
WiredHome	78:faf49c381591	36	/// The supported touch panel interface is for a resistive panel, and is natively
WiredHome	78:faf49c381591	37	/// supported by the RA8875 controller. There are a few steps to enable this interface.
WiredHome	78:faf49c381591	38	///
WiredHome	78:faf49c381591	39	/// @subsection Touch_Panel_Enable Touch Panel Enable
WiredHome	78:faf49c381591	40	///
WiredHome	78:faf49c381591	41	/// @see TouchPanelInit has two forms - fully automatic, and controlled. See the APIs for
WiredHome	78:faf49c381591	42	/// details.
WiredHome	78:faf49c381591	43	///
WiredHome	78:faf49c381591	44	/// @subsection Touch_Panel_Calibration
WiredHome	78:faf49c381591	45	///
WiredHome	78:faf49c381591	46	/// The touch panel is not initially calibrated on startup. The application should
WiredHome	78:faf49c381591	47	/// provide a means to activate the calibration process, and that should not require
WiredHome	78:faf49c381591	48	/// the touchscreen as it may not yet be usable. Alternately, a calibration matrix
WiredHome	78:faf49c381591	49	/// can be loaded from non-volatile and installed.
WiredHome	78:faf49c381591	50	///
WiredHome	78:faf49c381591	51	/// @section Keypad Keypad
WiredHome	78:faf49c381591	52	///
WiredHome	78:faf49c381591	53	/// The keypad has a default keypad mapping, but there is an API that permits
WiredHome	78:faf49c381591	54	/// installing a custom keymap.
WiredHome	78:faf49c381591	55	///
WiredHome	19:3f82c1161fd2	56	#ifndef RA8875_H
WiredHome	19:3f82c1161fd2	57	#define RA8875_H
WiredHome	19:3f82c1161fd2	58	#include <mbed.h>
WiredHome	19:3f82c1161fd2	59
WiredHome	77:9206c13aa527	60	#include "RA8875_Regs.h"
WiredHome	19:3f82c1161fd2	61	#include "GraphicsDisplay.h"
WiredHome	19:3f82c1161fd2	62
WiredHome	41:2956a0a221e5	63	#define RA8875_DEFAULT_SPI_FREQ 5000000
WiredHome	19:3f82c1161fd2	64
WiredHome	19:3f82c1161fd2	65	// Define this to enable code that monitors the performance of various
WiredHome	19:3f82c1161fd2	66	// graphics commands.
WiredHome	78:faf49c381591	67	//#define PERF_METRICS
WiredHome	19:3f82c1161fd2	68
WiredHome	23:a50ded45dbaf	69	// What better place for some test code than in here and the companion
WiredHome	23:a50ded45dbaf	70	// .cpp file. See also the bottom of this file.
WiredHome	79:544eb4964795	71	//#define TESTENABLE
WiredHome	19:3f82c1161fd2	72
WiredHome	19:3f82c1161fd2	73	/// DOS colors - slightly color enhanced
WiredHome	20:6e2e4a8372eb	74	#define Black (color_t)(RGB(0,0,0))
WiredHome	20:6e2e4a8372eb	75	#define Blue (color_t)(RGB(0,0,187))
WiredHome	20:6e2e4a8372eb	76	#define Green (color_t)(RGB(0,187,0))
WiredHome	20:6e2e4a8372eb	77	#define Cyan (color_t)(RGB(0,187,187))
WiredHome	20:6e2e4a8372eb	78	#define Red (color_t)(RGB(187,0,0))
WiredHome	20:6e2e4a8372eb	79	#define Magenta (color_t)(RGB(187,0,187))
WiredHome	81:01da2e34283d	80	#define Brown (color_t)(RGB(63,63,0))
WiredHome	20:6e2e4a8372eb	81	#define Gray (color_t)(RGB(187,187,187))
WiredHome	20:6e2e4a8372eb	82	#define Charcoal (color_t)(RGB(85,85,85))
WiredHome	62:ba5d33438fda	83	#define BrightBlue (color_t)(RGB(0,0,255))
WiredHome	62:ba5d33438fda	84	#define BrightGreen (color_t)(RGB(0,255,0))
WiredHome	62:ba5d33438fda	85	#define BrightCyan (color_t)(RGB(0,255,255))
WiredHome	62:ba5d33438fda	86	#define BrightRed (color_t)(RGB(255,0,0))
WiredHome	20:6e2e4a8372eb	87	#define Orange (color_t)(RGB(255,85,85))
WiredHome	20:6e2e4a8372eb	88	#define Pink (color_t)(RGB(255,85,255))
WiredHome	81:01da2e34283d	89	#define Yellow (color_t)(RGB(187,187,0))
WiredHome	20:6e2e4a8372eb	90	#define White (color_t)(RGB(255,255,255))
WiredHome	20:6e2e4a8372eb	91
WiredHome	62:ba5d33438fda	92	#define DarkBlue (color_t)(RGB(0,0,63))
WiredHome	62:ba5d33438fda	93	#define DarkGreen (color_t)(RGB(0,63,0))
WiredHome	62:ba5d33438fda	94	#define DarkCyan (color_t)(RGB(0,63,63))
WiredHome	62:ba5d33438fda	95	#define DarkRed (color_t)(RGB(63,0,0))
WiredHome	62:ba5d33438fda	96	#define DarkMagenta (color_t)(RGB(63,0,63))
WiredHome	62:ba5d33438fda	97	#define DarkBrown (color_t)(RGB(63,63,0))
WiredHome	62:ba5d33438fda	98	#define DarkGray (color_t)(RGB(63,63,63))
WiredHome	61:8f3153bf0baa	99
WiredHome	82:f7d300f26540	100	#define min(a,b) ((a<b)?a:b)
WiredHome	82:f7d300f26540	101	#define max(a,b) ((a>b)?a:b)
WiredHome	82:f7d300f26540	102
WiredHome	19:3f82c1161fd2	103
WiredHome	19:3f82c1161fd2	104	//namespace SW_graphics
WiredHome	19:3f82c1161fd2	105	//{
WiredHome	19:3f82c1161fd2	106
WiredHome	24:8ca861acf12d	107
WiredHome	21:3c1efb192927	108	/// This is a graphics library for the Raio RA8875 Display Controller chip
WiredHome	21:3c1efb192927	109	/// attached to a 4-wire SPI interface.
WiredHome	21:3c1efb192927	110	///
WiredHome	56:7a85d226ad0d	111	/// It offers both primitive and high level APIs.
WiredHome	56:7a85d226ad0d	112	///
WiredHome	21:3c1efb192927	113	/// Central to this API is a coordinate system, where the origin (0,0) is in
WiredHome	56:7a85d226ad0d	114	/// the top-left corner of the display, and the width (x) extends positive to the
WiredHome	56:7a85d226ad0d	115	/// right and the height (y) extends positive toward the bottom.
WiredHome	21:3c1efb192927	116	///
WiredHome	56:7a85d226ad0d	117	/// @caution As there are both graphics and text commands, one must take care to use
WiredHome	21:3c1efb192927	118	/// the proper coordinate system for each. Some of the text APIs are in units
WiredHome	29:422616aa04bd	119	/// of column and row, which is measured in character positions (and dependent
WiredHome	56:7a85d226ad0d	120	/// on the font size), where other text APIs permit pixel level positioning.
WiredHome	56:7a85d226ad0d	121	///
WiredHome	56:7a85d226ad0d	122	/// @code
WiredHome	56:7a85d226ad0d	123	/// #include "RA8875.h"
WiredHome	56:7a85d226ad0d	124	/// RA8875 lcd(p5, p6, p7, p12, NC, "tft");
WiredHome	56:7a85d226ad0d	125	///
WiredHome	56:7a85d226ad0d	126	/// int main()
WiredHome	56:7a85d226ad0d	127	/// {
WiredHome	81:01da2e34283d	128	/// lcd.init();
WiredHome	56:7a85d226ad0d	129	/// lcd.printf("printing 3 x 2 = %d", 3*2);
WiredHome	56:7a85d226ad0d	130	/// lcd.circle( 400,25, 25, BrightRed);
WiredHome	56:7a85d226ad0d	131	/// lcd.fillcircle( 400,25, 15, RGB(128,255,128));
WiredHome	56:7a85d226ad0d	132	/// lcd.ellipse( 440,75, 35,20, BrightBlue);
WiredHome	56:7a85d226ad0d	133	/// lcd.fillellipse( 440,75, 25,10, Blue);
WiredHome	56:7a85d226ad0d	134	/// lcd.triangle( 440,100, 475,110, 450,125, Magenta);
WiredHome	56:7a85d226ad0d	135	/// lcd.filltriangle( 445,105, 467,111, 452,120, Cyan);
WiredHome	56:7a85d226ad0d	136	/// lcd.rect( 400,130, 475,155, Brown);
WiredHome	56:7a85d226ad0d	137	/// lcd.fillrect( 405,135, 470,150, Pink);
WiredHome	56:7a85d226ad0d	138	/// lcd.roundrect( 410,160, 475,190, 10,8, Yellow);
WiredHome	56:7a85d226ad0d	139	/// lcd.fillroundrect(415,165, 470,185, 5,3, Orange);
WiredHome	56:7a85d226ad0d	140	/// lcd.line( 430,200, 460,230, RGB(0,255,0));
WiredHome	56:7a85d226ad0d	141	/// for (int i=0; i<=30; i+=5)
WiredHome	56:7a85d226ad0d	142	/// lcd.pixel(435+i,200+i, White);
WiredHome	56:7a85d226ad0d	143	/// }
WiredHome	56:7a85d226ad0d	144	/// @endcode
WiredHome	29:422616aa04bd	145	///
WiredHome	31:c72e12cd5c67	146	/// @todo Add Scroll support for text.
WiredHome	37:f19b7e7449dc	147	/// @todo Improve sync between internal and external font support - cursor, window, scroll.
WiredHome	75:ca78388cfd77	148	/// @todo Add Hardware reset signal - but testing to date indicates it is not needed.
WiredHome	44:207594dece70	149	/// @todo Add high level objects - x-y graph, meter, others... but these will
WiredHome	44:207594dece70	150	/// probably be best served in another class, since they may not
WiredHome	44:207594dece70	151	/// be needed for many uses.
WiredHome	21:3c1efb192927	152	///
WiredHome	19:3f82c1161fd2	153	class RA8875 : public GraphicsDisplay
WiredHome	19:3f82c1161fd2	154	{
WiredHome	19:3f82c1161fd2	155	public:
WiredHome	53:86d24b9480b9	156	/// cursor type to be shown as the text cursor.
WiredHome	53:86d24b9480b9	157	typedef enum
WiredHome	53:86d24b9480b9	158	{
WiredHome	53:86d24b9480b9	159	NOCURSOR, ///< cursor is hidden
WiredHome	53:86d24b9480b9	160	IBEAM, ///< \| cursor
WiredHome	53:86d24b9480b9	161	UNDER, ///< _ cursor
WiredHome	53:86d24b9480b9	162	BLOCK ///< Block cursor
WiredHome	53:86d24b9480b9	163	} cursor_t;
WiredHome	53:86d24b9480b9	164
WiredHome	19:3f82c1161fd2	165	/// font type selection.
WiredHome	19:3f82c1161fd2	166	typedef enum
WiredHome	19:3f82c1161fd2	167	{
WiredHome	31:c72e12cd5c67	168	ISO8859_1, ///< ISO8859-1 font
WiredHome	31:c72e12cd5c67	169	ISO8859_2, ///< ISO8859-2 font
WiredHome	31:c72e12cd5c67	170	ISO8859_3, ///< ISO8859-3 font
WiredHome	31:c72e12cd5c67	171	ISO8859_4 ///< ISO8859-4 font
WiredHome	19:3f82c1161fd2	172	} font_t;
WiredHome	19:3f82c1161fd2	173
WiredHome	19:3f82c1161fd2	174	/// font rotation selection
WiredHome	19:3f82c1161fd2	175	typedef enum
WiredHome	19:3f82c1161fd2	176	{
WiredHome	31:c72e12cd5c67	177	normal, ///< normal orientation
WiredHome	31:c72e12cd5c67	178	rotated ///< rotated orientation
WiredHome	19:3f82c1161fd2	179	} font_angle_t;
WiredHome	19:3f82c1161fd2	180
WiredHome	19:3f82c1161fd2	181	/// alignment
WiredHome	19:3f82c1161fd2	182	typedef enum
WiredHome	19:3f82c1161fd2	183	{
WiredHome	31:c72e12cd5c67	184	align_none, ///< align - none
WiredHome	31:c72e12cd5c67	185	align_full ///< align - full
WiredHome	19:3f82c1161fd2	186	} alignment_t;
WiredHome	19:3f82c1161fd2	187
WiredHome	19:3f82c1161fd2	188	/// Scale factor - 1, 2, 3 4
WiredHome	40:04aa280dfa39	189	typedef int HorizontalScale;
WiredHome	19:3f82c1161fd2	190
WiredHome	19:3f82c1161fd2	191	/// Scale factor - 1, 2, 3, 4
WiredHome	40:04aa280dfa39	192	typedef int VerticalScale;
WiredHome	19:3f82c1161fd2	193
WiredHome	19:3f82c1161fd2	194	/// Clear screen region
WiredHome	19:3f82c1161fd2	195	typedef enum
WiredHome	19:3f82c1161fd2	196	{
WiredHome	31:c72e12cd5c67	197	FULLWINDOW, ///< Full screen
WiredHome	31:c72e12cd5c67	198	ACTIVEWINDOW ///< active window/region
WiredHome	19:3f82c1161fd2	199	} Region_t;
WiredHome	19:3f82c1161fd2	200
WiredHome	61:8f3153bf0baa	201	/// Set the Layer Display Mode. @ref SetLayerMode
WiredHome	53:86d24b9480b9	202	typedef enum
WiredHome	53:86d24b9480b9	203	{
WiredHome	61:8f3153bf0baa	204	ShowLayer0, ///< Only layer 0 is visible, layer 1 is hidden (default)
WiredHome	56:7a85d226ad0d	205	ShowLayer1, ///< Only layer 1 is visible, layer 0 is hidden
WiredHome	53:86d24b9480b9	206	LightenOverlay, ///< Lighten-overlay mode
WiredHome	53:86d24b9480b9	207	TransparentMode, ///< Transparent mode
WiredHome	53:86d24b9480b9	208	BooleanOR, ///< Boolean OR mode
WiredHome	53:86d24b9480b9	209	BooleanAND, ///< Boolean AND mode
WiredHome	53:86d24b9480b9	210	FloatingWindow ///< Floating Window mode
WiredHome	53:86d24b9480b9	211	} LayerMode_T;
WiredHome	53:86d24b9480b9	212
hexley	54:e117ad10fba6	213	/// Touch Panel modes
hexley	54:e117ad10fba6	214	typedef enum
hexley	54:e117ad10fba6	215	{
hexley	54:e117ad10fba6	216	TP_Auto, ///< Auto touch detection mode
hexley	54:e117ad10fba6	217	TP_Manual, ///< Manual touch detection mode
hexley	54:e117ad10fba6	218	} tpmode_t;
hexley	54:e117ad10fba6	219
WiredHome	19:3f82c1161fd2	220	/// Constructor for a display based on the RAiO RA8875
WiredHome	19:3f82c1161fd2	221	/// display controller.
WiredHome	19:3f82c1161fd2	222	///
WiredHome	61:8f3153bf0baa	223	/// This configures the registers and calls the @ref init method.
WiredHome	61:8f3153bf0baa	224	///
WiredHome	56:7a85d226ad0d	225	/// @code
WiredHome	56:7a85d226ad0d	226	/// #include "RA8875.h"
WiredHome	56:7a85d226ad0d	227	/// RA8875 lcd(p5, p6, p7, p12, NC, "tft");
WiredHome	56:7a85d226ad0d	228	///
WiredHome	56:7a85d226ad0d	229	/// int main()
WiredHome	56:7a85d226ad0d	230	/// {
WiredHome	81:01da2e34283d	231	/// lcd.init();
WiredHome	56:7a85d226ad0d	232	/// lcd.printf("printing 3 x 2 = %d", 3*2);
WiredHome	56:7a85d226ad0d	233	/// lcd.circle(400,25, 25, BrightRed);
WiredHome	56:7a85d226ad0d	234	/// }
WiredHome	56:7a85d226ad0d	235	/// @endcode
WiredHome	56:7a85d226ad0d	236	///
WiredHome	72:ecffe56af969	237	/// @param[in] mosi is the SPI master out slave in pin on the mbed.
WiredHome	72:ecffe56af969	238	/// @param[in] miso is the SPI master in slave out pin on the mbed.
WiredHome	72:ecffe56af969	239	/// @param[in] sclk is the SPI shift clock pin on the mbed.
WiredHome	72:ecffe56af969	240	/// @param[in] csel is the DigitalOut pin on the mbed to use as the
WiredHome	19:3f82c1161fd2	241	/// active low chip select for the display controller.
WiredHome	72:ecffe56af969	242	/// @param[in] reset is the DigitalOut pin on the mbed to use as the
WiredHome	19:3f82c1161fd2	243	/// active low reset input on the display controller -
WiredHome	19:3f82c1161fd2	244	/// but this is not currently used.
WiredHome	72:ecffe56af969	245	/// @param[in] name is a text name for this object, which will permit
WiredHome	72:ecffe56af969	246	/// capturing stdout to puts() and printf() directly to it.
WiredHome	19:3f82c1161fd2	247	///
WiredHome	19:3f82c1161fd2	248	RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset, const char * name = "lcd");
WiredHome	19:3f82c1161fd2	249
WiredHome	45:679c2fb8480c	250	// Destructor doesn't have much to do as this would typically be created
WiredHome	45:679c2fb8480c	251	// at startup, and not at runtime.
WiredHome	19:3f82c1161fd2	252	//~RA8875();
WiredHome	19:3f82c1161fd2	253
WiredHome	79:544eb4964795	254	/// Initialize the driver.
WiredHome	79:544eb4964795	255	///
WiredHome	81:01da2e34283d	256	/// @param[in] width in pixels to configure the display for. This parameter is optional
WiredHome	81:01da2e34283d	257	/// and the default is 480.
WiredHome	81:01da2e34283d	258	/// @param[in] height in pixels to configure the display for. This parameter is optional
WiredHome	81:01da2e34283d	259	/// and the default is 272.
WiredHome	81:01da2e34283d	260	/// @param[in] color_bpp can be either 8 or 16, but must be consistent
WiredHome	81:01da2e34283d	261	/// with the width and height parameters. This parameter is optional
WiredHome	81:01da2e34283d	262	/// and the default is 16.
WiredHome	79:544eb4964795	263	/// @param[in] power defines if the display should be left in the power-on or off state.
WiredHome	81:01da2e34283d	264	/// If power is true (on), the backlight is set to 100%. This parameter is optional
WiredHome	81:01da2e34283d	265	/// and the default is true (on). @see Power.
WiredHome	81:01da2e34283d	266	/// @param[in] keypadon defines if the keypad support should be enabled. This parameter is optional
WiredHome	81:01da2e34283d	267	/// and the default is true (enabled). @see KeypadInit.
WiredHome	81:01da2e34283d	268	/// @param[in] touchscreeenon defines if the keypad support should be enabled. This parameter is optional
WiredHome	81:01da2e34283d	269	/// and the default is true (enabled). @see TouchPanelInit.
WiredHome	79:544eb4964795	270	/// @returns success/failure code. @see RetCode_t.
WiredHome	79:544eb4964795	271	///
WiredHome	81:01da2e34283d	272	RetCode_t init(int width = 480, int height = 272, int color_bpp = 16,
WiredHome	81:01da2e34283d	273	bool poweron = true, bool keypadon = true, bool touchscreeenon = true);
WiredHome	79:544eb4964795	274
WiredHome	79:544eb4964795	275	/// Get a pointer to the error code.
WiredHome	79:544eb4964795	276	///
WiredHome	79:544eb4964795	277	/// This method returns a pointer to a text string that matches the
WiredHome	79:544eb4964795	278	/// code. @see RetCode_t.
WiredHome	79:544eb4964795	279	///
WiredHome	79:544eb4964795	280	/// @param[in] code is the return value from RetCode_t to look up.
WiredHome	79:544eb4964795	281	/// @returns a pointer to the text message representing code. If code
WiredHome	79:544eb4964795	282	/// is not a valid value, then it returns the text for bad_parameter;
WiredHome	79:544eb4964795	283	const char * GetErrorMessage(RetCode_t code);
WiredHome	79:544eb4964795	284
WiredHome	79:544eb4964795	285
WiredHome	50:2c4f474a2453	286	/// Select the drawing layer for subsequent commands.
WiredHome	43:3becae133285	287	///
WiredHome	43:3becae133285	288	/// If the screen configuration is 480 x 272, or if it is 800 x 480
WiredHome	43:3becae133285	289	/// and 8-bit color, the the display supports two layers, which can
WiredHome	43:3becae133285	290	/// be independently drawn on and shown. Additionally, complex
WiredHome	43:3becae133285	291	/// operations involving both layers are permitted.
WiredHome	43:3becae133285	292	///
WiredHome	56:7a85d226ad0d	293	/// @code
WiredHome	56:7a85d226ad0d	294	/// //lcd.SetLayerMode(OnlyLayer0); // default is layer 0
WiredHome	56:7a85d226ad0d	295	/// lcd.rect(400,130, 475,155,Brown);
WiredHome	56:7a85d226ad0d	296	/// lcd.SelectDrawingLayer(1);
WiredHome	56:7a85d226ad0d	297	/// lcd.circle(400,25, 25, BrightRed);
WiredHome	56:7a85d226ad0d	298	/// wait(1);
WiredHome	56:7a85d226ad0d	299	/// lcd.SetLayerMode(ShowLayer1);
WiredHome	56:7a85d226ad0d	300	/// @endcode
WiredHome	56:7a85d226ad0d	301	///
WiredHome	61:8f3153bf0baa	302	/// @attention The user manual refers to Layer 1 and Layer 2, however the
WiredHome	61:8f3153bf0baa	303	/// actual register values are value 0 and 1. This API as well as
WiredHome	61:8f3153bf0baa	304	/// others that reference the layers use the values 0 and 1 for
WiredHome	61:8f3153bf0baa	305	/// cleaner iteration in the code.
WiredHome	43:3becae133285	306	///
WiredHome	72:ecffe56af969	307	/// @param[in] layer is 0 or 1 to select the layer for subsequent
WiredHome	61:8f3153bf0baa	308	/// commands.
WiredHome	43:3becae133285	309	/// @returns success/failure code. @see RetCode_t.
WiredHome	43:3becae133285	310	///
WiredHome	50:2c4f474a2453	311	RetCode_t SelectDrawingLayer(uint16_t layer);
WiredHome	43:3becae133285	312
WiredHome	61:8f3153bf0baa	313	/// Get the currently active drawing layer.
WiredHome	61:8f3153bf0baa	314	///
WiredHome	61:8f3153bf0baa	315	/// This returns a value, 0 or 1, based on the screen configuration
WiredHome	61:8f3153bf0baa	316	/// and the currently active drawing layer.
WiredHome	61:8f3153bf0baa	317	///
WiredHome	61:8f3153bf0baa	318	/// @code
WiredHome	61:8f3153bf0baa	319	/// uint16_t prevLayer = lcd.GetDrawingLayer();
WiredHome	61:8f3153bf0baa	320	/// lcd.SelectDrawingLayer(x);
WiredHome	61:8f3153bf0baa	321	/// lcd.circle(400,25, 25, BrightRed);
WiredHome	61:8f3153bf0baa	322	/// lcd.SelectDrawingLayer(prevLayer);
WiredHome	61:8f3153bf0baa	323	/// @endcode
WiredHome	61:8f3153bf0baa	324	///
WiredHome	61:8f3153bf0baa	325	/// @attention The user manual refers to Layer 1 and Layer 2, however the
WiredHome	61:8f3153bf0baa	326	/// actual register values are value 0 and 1. This API as well as
WiredHome	61:8f3153bf0baa	327	/// others that reference the layers use the values 0 and 1 for
WiredHome	61:8f3153bf0baa	328	/// cleaner iteration in the code.
WiredHome	61:8f3153bf0baa	329	///
WiredHome	61:8f3153bf0baa	330	/// @returns the current drawing layer; 0 or 1.
WiredHome	61:8f3153bf0baa	331	///
WiredHome	61:8f3153bf0baa	332	uint16_t GetDrawingLayer(void);
WiredHome	61:8f3153bf0baa	333
WiredHome	44:207594dece70	334	/// Set the Layer presentation mode.
WiredHome	44:207594dece70	335	///
WiredHome	44:207594dece70	336	/// This sets the presentation mode for layers, and permits showing
WiredHome	44:207594dece70	337	/// a single layer, or applying a mode where the two layers
WiredHome	44:207594dece70	338	/// are combined using one of the hardware methods.
WiredHome	44:207594dece70	339	///
WiredHome	61:8f3153bf0baa	340	/// Refer to the RA8875 data sheet for full details.
WiredHome	61:8f3153bf0baa	341	///
WiredHome	56:7a85d226ad0d	342	/// @code
WiredHome	56:7a85d226ad0d	343	/// //lcd.SetLayerMode(OnlyLayer0); // default is layer 0
WiredHome	56:7a85d226ad0d	344	/// lcd.rect(400,130, 475,155,Brown);
WiredHome	56:7a85d226ad0d	345	/// lcd.SelectDrawingLayer(1);
WiredHome	56:7a85d226ad0d	346	/// lcd.circle(400,25, 25, BrightRed);
WiredHome	56:7a85d226ad0d	347	/// wait(1);
WiredHome	56:7a85d226ad0d	348	/// lcd.SetLayerMode(ShowLayer1);
WiredHome	56:7a85d226ad0d	349	/// @endcode
WiredHome	56:7a85d226ad0d	350	///
WiredHome	72:ecffe56af969	351	/// @param[in] mode sets the mode in the Layer Transparency Register.
WiredHome	44:207594dece70	352	/// @returns success/failure code. @see RetCode_t.
WiredHome	44:207594dece70	353	///
WiredHome	53:86d24b9480b9	354	RetCode_t SetLayerMode(LayerMode_T mode);
WiredHome	44:207594dece70	355
WiredHome	82:f7d300f26540	356	/// Get the Layer presentation mode.
WiredHome	82:f7d300f26540	357	///
WiredHome	82:f7d300f26540	358	/// This gets the current layer mode. @see LayerMode_T.
WiredHome	82:f7d300f26540	359	///
WiredHome	82:f7d300f26540	360	/// @returns layer mode.
WiredHome	82:f7d300f26540	361	///
WiredHome	82:f7d300f26540	362	LayerMode_T GetLayerMode(void);
WiredHome	82:f7d300f26540	363
WiredHome	44:207594dece70	364	/// Set the layer transparency for each layer.
WiredHome	44:207594dece70	365	///
WiredHome	44:207594dece70	366	/// Set the transparency, where the range of values is
WiredHome	44:207594dece70	367	/// from zero (fully visible) to eight (fully transparent).
WiredHome	44:207594dece70	368	/// The input value is automatically limited to this range.
WiredHome	44:207594dece70	369	///
WiredHome	56:7a85d226ad0d	370	/// @code
WiredHome	56:7a85d226ad0d	371	/// // draw something on each layer, then step-fade across
WiredHome	56:7a85d226ad0d	372	/// display.SetLayerMode(RA8875::TransparentMode);
WiredHome	56:7a85d226ad0d	373	/// for (i=0; i<=8; i++) {
WiredHome	56:7a85d226ad0d	374	/// display.SetLayerTransparency(i, 8-i);
WiredHome	56:7a85d226ad0d	375	/// wait_ms(200);
WiredHome	56:7a85d226ad0d	376	/// }
WiredHome	56:7a85d226ad0d	377	/// @endcode
WiredHome	56:7a85d226ad0d	378	///
WiredHome	72:ecffe56af969	379	/// @param[in] layer1 sets the layer 1 transparency.
WiredHome	72:ecffe56af969	380	/// @param[in] layer2 sets the layer 2 transparency.
WiredHome	44:207594dece70	381	/// @returns success/failure code. @see RetCode_t.
WiredHome	44:207594dece70	382	///
WiredHome	44:207594dece70	383	RetCode_t SetLayerTransparency(uint8_t layer1, uint8_t layer2);
WiredHome	44:207594dece70	384
WiredHome	53:86d24b9480b9	385	/// Set the background color register used for transparency.
WiredHome	53:86d24b9480b9	386	///
WiredHome	53:86d24b9480b9	387	/// This command sets the background color registers that are used
WiredHome	53:86d24b9480b9	388	/// in the transparent color operations involving the layers.
WiredHome	53:86d24b9480b9	389	///
WiredHome	72:ecffe56af969	390	/// @param[in] color is optional and expressed in 16-bit format. If not
WiredHome	53:86d24b9480b9	391	/// supplied, a default of Black is used.
WiredHome	53:86d24b9480b9	392	/// @returns success/failure code. @see RetCode_t.
WiredHome	53:86d24b9480b9	393	///
WiredHome	53:86d24b9480b9	394	RetCode_t SetBackgroundTransparencyColor(color_t color = RGB(0,0,0));
hexley	54:e117ad10fba6	395
WiredHome	73:f22a18707b5e	396
WiredHome	73:f22a18707b5e	397	/// Get the background color value used for transparency.
WiredHome	73:f22a18707b5e	398	///
WiredHome	73:f22a18707b5e	399	/// This command reads the background color registers that define
WiredHome	73:f22a18707b5e	400	/// the transparency color for operations involving layers.
WiredHome	73:f22a18707b5e	401	///
WiredHome	73:f22a18707b5e	402	/// @returns the color.
WiredHome	73:f22a18707b5e	403	///
WiredHome	73:f22a18707b5e	404	color_t GetBackgroundTransparencyColor(void);
WiredHome	73:f22a18707b5e	405
hexley	54:e117ad10fba6	406	/// Initialize theTouch Panel controller with default values
hexley	54:e117ad10fba6	407	///
WiredHome	78:faf49c381591	408	/// This activates the simplified touch panel init, which may work for
WiredHome	78:faf49c381591	409	/// most uses. The alternate API is available if fine-grained control
WiredHome	78:faf49c381591	410	/// is needed for the numerous settings.
WiredHome	78:faf49c381591	411	///
WiredHome	56:7a85d226ad0d	412	/// @returns success/failure code. @see RetCode_t.
WiredHome	56:7a85d226ad0d	413	///
hexley	54:e117ad10fba6	414	RetCode_t TouchPanelInit(void);
hexley	54:e117ad10fba6	415
hexley	54:e117ad10fba6	416	/// Initialize the Touch Panel controller with detailed settings.
hexley	54:e117ad10fba6	417	///
WiredHome	78:faf49c381591	418	/// This is the detailed touch panel init, which provides the ability
WiredHome	78:faf49c381591	419	/// to set nearly every possible option.
WiredHome	78:faf49c381591	420	///
hexley	54:e117ad10fba6	421	/// @param[in] bTpEnable Touch Panel enable/disable control:
hexley	54:e117ad10fba6	422	/// - TP_ENABLE: enable the touch panel
hexley	54:e117ad10fba6	423	/// - TP_DISABLE: disable the touch panel
WiredHome	56:7a85d226ad0d	424	/// @param[in] bTpAutoManual Touch Panel operating mode:
hexley	54:e117ad10fba6	425	/// - TP_MODE_AUTO: automatic capture
hexley	54:e117ad10fba6	426	/// - TP_MODE_MANUAL: manual capture
WiredHome	56:7a85d226ad0d	427	/// @param[in] bTpDebounce Debounce circuit enable for touch panel interrupt:
hexley	54:e117ad10fba6	428	/// - TP_DEBOUNCE_OFF: disable the debounce circuit
hexley	54:e117ad10fba6	429	/// - TP_DEBOUNCE_ON: enable the debounce circuit
WiredHome	56:7a85d226ad0d	430	/// @param[in] bTpManualMode When Manual Mode is selected, this sets the mode:
hexley	54:e117ad10fba6	431	/// - TP_MANUAL_IDLE: touch panel is idle
hexley	54:e117ad10fba6	432	/// - TP_MANUAL_WAIT: wait for touch panel event
hexley	54:e117ad10fba6	433	/// - TP_MANUAL_LATCH_X: latch X data
hexley	54:e117ad10fba6	434	/// - TP_MANUAL_LATCH_Y: latch Y data
WiredHome	56:7a85d226ad0d	435	/// @param[in] bTpAdcClkDiv Sets the ADC clock as a fraction of the System CLK:
hexley	54:e117ad10fba6	436	/// - TP_ADC_CLKDIV_1: Use CLK
hexley	54:e117ad10fba6	437	/// - TP_ADC_CLKDIV_2: Use CLK/2
hexley	54:e117ad10fba6	438	/// - TP_ADC_CLKDIV_4: Use CLK/4
hexley	54:e117ad10fba6	439	/// - TP_ADC_CLKDIV_8: Use CLK/8
hexley	54:e117ad10fba6	440	/// - TP_ADC_CLKDIV_16: Use CLK/16
hexley	54:e117ad10fba6	441	/// - TP_ADC_CLKDIV_32: Use CLK/32
hexley	54:e117ad10fba6	442	/// - TP_ADC_CLKDIV_64: Use CLK/64
hexley	54:e117ad10fba6	443	/// - TP_ADC_CLKDIV_128: Use CLK/128
WiredHome	56:7a85d226ad0d	444	/// @param[in] bTpAdcSampleTime Touch Panel sample time delay before ADC data is ready:
hexley	54:e117ad10fba6	445	/// - TP_ADC_SAMPLE_512_CLKS: Wait 512 system clocks
hexley	54:e117ad10fba6	446	/// - TP_ADC_SAMPLE_1024_CLKS: Wait 1024 system clocks
hexley	54:e117ad10fba6	447	/// - TP_ADC_SAMPLE_2048_CLKS: Wait 2048 system clocks
hexley	54:e117ad10fba6	448	/// - TP_ADC_SAMPLE_4096_CLKS: Wait 4096 system clocks
hexley	54:e117ad10fba6	449	/// - TP_ADC_SAMPLE_8192_CLKS: Wait 8192 system clocks
hexley	54:e117ad10fba6	450	/// - TP_ADC_SAMPLE_16384_CLKS: Wait 16384 system clocks
hexley	54:e117ad10fba6	451	/// - TP_ADC_SAMPLE_32768_CLKS: Wait 32768 system clocks
hexley	54:e117ad10fba6	452	/// - TP_ADC_SAMPLE_65536_CLKS: Wait 65536 system clocks
WiredHome	56:7a85d226ad0d	453	/// @returns success/failure code. @see RetCode_t.
WiredHome	56:7a85d226ad0d	454	///
WiredHome	78:faf49c381591	455	RetCode_t TouchPanelInit(uint8_t bTpEnable, uint8_t bTpAutoManual, uint8_t bTpDebounce,
WiredHome	78:faf49c381591	456	uint8_t bTpManualMode, uint8_t bTpAdcClkDiv, uint8_t bTpAdcSampleTime);
WiredHome	53:86d24b9480b9	457
WiredHome	79:544eb4964795	458	/// Poll the TouchPanel and on a touch event return the a to d filtered x, y coordinates.
hexley	54:e117ad10fba6	459	///
WiredHome	78:faf49c381591	460	/// This method reads the touch controller, which has a 10-bit range for each the
WiredHome	79:544eb4964795	461	/// x and the y axis.
WiredHome	79:544eb4964795	462	///
WiredHome	79:544eb4964795	463	/// @note The returned values are not in display (pixel) units but are in analog to
WiredHome	79:544eb4964795	464	/// digital converter units.
WiredHome	78:faf49c381591	465	///
WiredHome	81:01da2e34283d	466	/// @note This API is usually not needed. @see TouchPanelComputeCalibration.
WiredHome	79:544eb4964795	467	/// @see TouchPanelReadable.
WiredHome	78:faf49c381591	468	///
WiredHome	79:544eb4964795	469	/// @param[out] x is the x scale a/d value.
WiredHome	79:544eb4964795	470	/// @param[out] y is the y scale a/d value.
WiredHome	83:7bad0068cca0	471	/// @returns a value indicating the state of the touch,
WiredHome	83:7bad0068cca0	472	/// - no_cal: no calibration matrix is available, touch coordinates are not returned.
WiredHome	83:7bad0068cca0	473	/// - no_touch: no touch is detected, touch coordinates are not returned.
WiredHome	83:7bad0068cca0	474	/// - touch: touch is detected, touch coordinates are returned.
WiredHome	83:7bad0068cca0	475	/// - held: held after touch, touch coordinates are returned.
WiredHome	83:7bad0068cca0	476	/// - release: indicates a release, touch coordinates are returned.
WiredHome	56:7a85d226ad0d	477	///
WiredHome	83:7bad0068cca0	478	TouchCode_t TouchPanelA2DFiltered(int x, int y);
hexley	54:e117ad10fba6	479
WiredHome	79:544eb4964795	480	/// Poll the TouchPanel and on a touch event return the a to d raw x, y coordinates.
hexley	54:e117ad10fba6	481	///
WiredHome	78:faf49c381591	482	/// This method reads the touch controller, which has a 10-bit range for each the
WiredHome	78:faf49c381591	483	/// x and the y axis. A number of samples of the raw data are taken, filtered,
WiredHome	79:544eb4964795	484	/// and the results are returned.
WiredHome	78:faf49c381591	485	///
WiredHome	79:544eb4964795	486	/// @note The returned values are not in display (pixel) units but are in analog to
WiredHome	79:544eb4964795	487	/// digital converter units.
WiredHome	79:544eb4964795	488	///
WiredHome	81:01da2e34283d	489	/// @note This API is usually not needed. @see TouchPanelComputeCalibration.
WiredHome	79:544eb4964795	490	/// @see TouchPanelReadable.
WiredHome	78:faf49c381591	491	///
WiredHome	79:544eb4964795	492	/// @param[out] x is the x scale a/d value.
WiredHome	79:544eb4964795	493	/// @param[out] y is the y scale a/d value.
WiredHome	83:7bad0068cca0	494	/// @returns a value indicating the state of the touch,
WiredHome	83:7bad0068cca0	495	/// - no_cal: no calibration matrix is available, touch coordinates are not returned.
WiredHome	83:7bad0068cca0	496	/// - no_touch: no touch is detected, touch coordinates are not returned.
WiredHome	83:7bad0068cca0	497	/// - touch: touch is detected, touch coordinates are returned.
WiredHome	83:7bad0068cca0	498	/// - held: held after touch, touch coordinates are returned.
WiredHome	83:7bad0068cca0	499	/// - release: indicates a release, touch coordinates are returned.
WiredHome	83:7bad0068cca0	500	///
WiredHome	83:7bad0068cca0	501	TouchCode_t TouchPanelA2DRaw(int x, int y);
WiredHome	83:7bad0068cca0	502
WiredHome	83:7bad0068cca0	503	/// Get the screen calibrated point of touch.
WiredHome	83:7bad0068cca0	504	///
WiredHome	83:7bad0068cca0	505	/// This method determines if there is a touch and if so it will provide
WiredHome	83:7bad0068cca0	506	/// the screen-relative touch coordinates. This method can be used in
WiredHome	83:7bad0068cca0	507	/// a manner similar to Serial.readable(), to determine if there was a
WiredHome	83:7bad0068cca0	508	/// touch and indicate that - but not care about the coordinates. Alternately,
WiredHome	83:7bad0068cca0	509	/// if a valid pointer to a point_t is provided, then if a touch is detected
WiredHome	83:7bad0068cca0	510	/// the point_t will be populated with data.
WiredHome	56:7a85d226ad0d	511	///
WiredHome	83:7bad0068cca0	512	/// @code
WiredHome	83:7bad0068cca0	513	/// Timer t;
WiredHome	83:7bad0068cca0	514	/// t.start();
WiredHome	83:7bad0068cca0	515	/// do {
WiredHome	83:7bad0068cca0	516	/// point_t point = {0, 0};
WiredHome	83:7bad0068cca0	517	/// if (display.TouchPanelReadable(&point)) {
WiredHome	83:7bad0068cca0	518	/// display.pixel(point.x, point.y, Red);
WiredHome	83:7bad0068cca0	519	/// }
WiredHome	83:7bad0068cca0	520	/// } while (t.read_ms() < 30000);
WiredHome	83:7bad0068cca0	521	/// @endcode
WiredHome	83:7bad0068cca0	522	///
WiredHome	83:7bad0068cca0	523	/// @param[out] touch is the touch point, if a touch is registered.
WiredHome	83:7bad0068cca0	524	/// @returns a value indicating the state of the touch,
WiredHome	83:7bad0068cca0	525	/// - no_cal: no calibration matrix is available, touch coordinates are not returned.
WiredHome	83:7bad0068cca0	526	/// - no_touch: no touch is detected, touch coordinates are not returned.
WiredHome	83:7bad0068cca0	527	/// - touch: touch is detected, touch coordinates are returned.
WiredHome	83:7bad0068cca0	528	/// - held: held after touch, touch coordinates are returned.
WiredHome	83:7bad0068cca0	529	/// - release: indicates a release, touch coordinates are returned.
WiredHome	83:7bad0068cca0	530	///
WiredHome	83:7bad0068cca0	531	TouchCode_t TouchPanelReadable(point_t * touch = NULL);
WiredHome	83:7bad0068cca0	532
WiredHome	77:9206c13aa527	533	/// Calibrate the touch panel.
WiredHome	77:9206c13aa527	534	///
WiredHome	77:9206c13aa527	535	/// This method accepts two lists - one list is target points in ,
WiredHome	77:9206c13aa527	536	/// display coordinates and the other is a lit of raw touch coordinate
WiredHome	77:9206c13aa527	537	/// values. It generates a calibration matrix for later use. This
WiredHome	77:9206c13aa527	538	/// matrix is also accessible to the calling API, which may store
WiredHome	77:9206c13aa527	539	/// the matrix in persistent memory and then install the calibration
WiredHome	77:9206c13aa527	540	/// matrix on the next power cycle. By doing so, it can avoid the
WiredHome	77:9206c13aa527	541	/// need to calibrate on every power cycle.
WiredHome	77:9206c13aa527	542	///
WiredHome	81:01da2e34283d	543	/// @note The methods "TouchPanelComputeCalibration", "TouchPanelReadable", and
WiredHome	77:9206c13aa527	544	/// indirectly the "TouchPanelSetMatrix" methods are all derived
WiredHome	77:9206c13aa527	545	/// from a program by Carlos E. Vidales. See the copyright note
WiredHome	77:9206c13aa527	546	/// for further details. See also the article
WiredHome	77:9206c13aa527	547	/// http://www.embedded.com/design/system-integration/4023968/How-To-Calibrate-Touch-Screens
WiredHome	77:9206c13aa527	548	///
WiredHome	77:9206c13aa527	549	/// @copyright Copyright (c) 2001, Carlos E. Vidales. All rights reserved.
WiredHome	78:faf49c381591	550	/// This sample program was written and put in the public domain
WiredHome	78:faf49c381591	551	/// by Carlos E. Vidales. The program is provided "as is"
WiredHome	78:faf49c381591	552	/// without warranty of any kind, either expressed or implied.
WiredHome	78:faf49c381591	553	/// If you choose to use the program within your own products
WiredHome	78:faf49c381591	554	/// you do so at your own risk, and assume the responsibility
WiredHome	78:faf49c381591	555	/// for servicing, repairing or correcting the program should
WiredHome	78:faf49c381591	556	/// it prove defective in any manner.
WiredHome	78:faf49c381591	557	/// You may copy and distribute the program's source code in any
WiredHome	78:faf49c381591	558	/// medium, provided that you also include in each copy an
WiredHome	78:faf49c381591	559	/// appropriate copyright notice and disclaimer of warranty.
WiredHome	78:faf49c381591	560	/// You may also modify this program and distribute copies of
WiredHome	78:faf49c381591	561	/// it provided that you include prominent notices stating
WiredHome	78:faf49c381591	562	/// that you changed the file(s) and the date of any change,
WiredHome	78:faf49c381591	563	/// and that you do not charge any royalties or licenses for
WiredHome	78:faf49c381591	564	/// its use.
WiredHome	77:9206c13aa527	565	///
WiredHome	77:9206c13aa527	566	/// @param[in] display is a pointer to a set of 3 points, which
WiredHome	77:9206c13aa527	567	/// are in display units of measure. These are the targets
WiredHome	77:9206c13aa527	568	/// the calibration was aiming for.
WiredHome	77:9206c13aa527	569	/// @param[in] screen is a pointer to a set of 3 points, which
WiredHome	77:9206c13aa527	570	/// are in touchscreen units of measure. These are the
WiredHome	77:9206c13aa527	571	/// registered touches.
WiredHome	77:9206c13aa527	572	/// @param[out] matrix is an optional parameter to hold the calibration matrix
WiredHome	77:9206c13aa527	573	/// as a result of the calibration. This can be saved in
WiredHome	77:9206c13aa527	574	/// non-volatile memory to recover the calibration after a power fail.
WiredHome	77:9206c13aa527	575	/// @returns success/failure code. @see RetCode_t.
WiredHome	77:9206c13aa527	576	///
WiredHome	81:01da2e34283d	577	RetCode_t TouchPanelComputeCalibration(point_t display[3], point_t screen[3], tpMatrix_t * matrix);
WiredHome	81:01da2e34283d	578
WiredHome	81:01da2e34283d	579
WiredHome	81:01da2e34283d	580	/// Perform the touch panel calibration process.
WiredHome	81:01da2e34283d	581	///
WiredHome	81:01da2e34283d	582	/// This method provides the easy "shortcut" to calibrating the touch panel.
WiredHome	81:01da2e34283d	583	/// The process will automatically generate the calibration points, present
WiredHome	81:01da2e34283d	584	/// the targets on-screen, detect the touches, compute the calibration
WiredHome	81:01da2e34283d	585	/// matrix, and optionally provide the calibration matrix to the calling code
WiredHome	81:01da2e34283d	586	/// for persistence in non-volatile memory.
WiredHome	81:01da2e34283d	587	///
WiredHome	81:01da2e34283d	588	/// @param[out] matrix is an optional parameter to hold the calibration matrix
WiredHome	81:01da2e34283d	589	/// as a result of the calibration. This can be saved in
WiredHome	81:01da2e34283d	590	/// non-volatile memory to recover the calibration after a power fail.
WiredHome	81:01da2e34283d	591	/// @returns success/failure code. @see RetCode_t.
WiredHome	81:01da2e34283d	592	///
WiredHome	81:01da2e34283d	593	RetCode_t TouchPanelCalibrate(tpMatrix_t * matrix);
WiredHome	81:01da2e34283d	594
WiredHome	81:01da2e34283d	595	/// Perform the touch panel calibration process.
WiredHome	81:01da2e34283d	596	///
WiredHome	81:01da2e34283d	597	/// This method provides the easy "shortcut" to calibrating the touch panel.
WiredHome	81:01da2e34283d	598	/// The process will automatically generate the calibration points, present
WiredHome	81:01da2e34283d	599	/// the targets on-screen, detect the touches, compute the calibration
WiredHome	81:01da2e34283d	600	/// matrix, and optionally provide the calibration matrix to the calling code
WiredHome	81:01da2e34283d	601	/// for persistence in non-volatile memory.
WiredHome	81:01da2e34283d	602	///
WiredHome	81:01da2e34283d	603	/// @param[in] msg is a text message to present on the screen during the
WiredHome	81:01da2e34283d	604	/// calibration process.
WiredHome	81:01da2e34283d	605	/// @param[out] matrix is an optional parameter to hold the calibration matrix
WiredHome	81:01da2e34283d	606	/// as a result of the calibration. This can be saved in
WiredHome	81:01da2e34283d	607	/// non-volatile memory to recover the calibration after a power fail.
WiredHome	81:01da2e34283d	608	/// @returns success/failure code. @see RetCode_t.
WiredHome	81:01da2e34283d	609	///
WiredHome	81:01da2e34283d	610	RetCode_t TouchPanelCalibrate(const char * msg, tpMatrix_t * matrix = NULL);
WiredHome	77:9206c13aa527	611
WiredHome	79:544eb4964795	612	/// Wait for a touch panel touch and return it.
WiredHome	79:544eb4964795	613	///
WiredHome	79:544eb4964795	614	/// This method is similar to Serial.getc() in that it will wait for a touch
WiredHome	79:544eb4964795	615	/// and then return. In order to extract the coordinates of the touch, a
WiredHome	79:544eb4964795	616	/// valid pointer to a point_t must be provided.
WiredHome	79:544eb4964795	617	///
WiredHome	79:544eb4964795	618	/// @note There is no timeout on this function, so its use is not recommended.
WiredHome	78:faf49c381591	619	///
WiredHome	79:544eb4964795	620	/// @code
WiredHome	79:544eb4964795	621	/// Timer t;
WiredHome	79:544eb4964795	622	/// t.start();
WiredHome	79:544eb4964795	623	/// do {
WiredHome	79:544eb4964795	624	/// point_t point = {0, 0};
WiredHome	79:544eb4964795	625	/// display.TouchPanelGet(&point);
WiredHome	79:544eb4964795	626	/// display.pixel(point.x, point.y, Red);
WiredHome	79:544eb4964795	627	/// } while (t.read_ms() < 30000);
WiredHome	79:544eb4964795	628	/// @endcode
WiredHome	79:544eb4964795	629	///
WiredHome	79:544eb4964795	630	/// @param[out] touch is the touch point, if a touch is registered.
WiredHome	79:544eb4964795	631	/// @returns true if a touch was registered, and touch is updated.
WiredHome	79:544eb4964795	632	/// @returns false if no touch was detected, or if the calibration matrix is not defined.
WiredHome	79:544eb4964795	633	///
WiredHome	79:544eb4964795	634	bool TouchPanelGet(point_t * touch);
WiredHome	78:faf49c381591	635
WiredHome	77:9206c13aa527	636	/// Set the calibration matrix for the touch panel.
WiredHome	77:9206c13aa527	637	///
WiredHome	77:9206c13aa527	638	/// This method is used to set the calibration matrix for the touch panel. After
WiredHome	81:01da2e34283d	639	/// performing the calibration (@see TouchPanelComputeCalibration), the matrix can be stored.
WiredHome	77:9206c13aa527	640	/// On a subsequence power cycle, the matrix may be restored from non-volatile and
WiredHome	77:9206c13aa527	641	/// passed in to this method. It will then be held to perform the corrections when
WiredHome	77:9206c13aa527	642	/// reading the touch panel point.
WiredHome	77:9206c13aa527	643	///
WiredHome	78:faf49c381591	644	/// @code
WiredHome	78:faf49c381591	645	/// FILE * fh = fopen("/local/tpmatrix.cfg", "r");
WiredHome	78:faf49c381591	646	/// if (fh) {
WiredHome	78:faf49c381591	647	/// tpMatrix_t matrix;
WiredHome	78:faf49c381591	648	/// if (fread(fh, &matrix, sizeof(tpMatrix_t))) {
WiredHome	78:faf49c381591	649	/// lcd.TouchPanelSetMatrix(&matrix);
WiredHome	78:faf49c381591	650	/// }
WiredHome	78:faf49c381591	651	/// fclose(fh);
WiredHome	78:faf49c381591	652	/// }
WiredHome	78:faf49c381591	653	/// @endcode
WiredHome	78:faf49c381591	654	///
WiredHome	77:9206c13aa527	655	/// @param[in] matrix is a pointer to the touch panel calibration matrix.
WiredHome	77:9206c13aa527	656	/// @returns success/failure code. @see RetCode_t.
WiredHome	77:9206c13aa527	657	///
WiredHome	77:9206c13aa527	658	RetCode_t TouchPanelSetMatrix(tpMatrix_t * matrix);
WiredHome	78:faf49c381591	659
WiredHome	75:ca78388cfd77	660	#if 0
hexley	54:e117ad10fba6	661	/// Append interrupt handler for specific RA8875 interrupt source
hexley	54:e117ad10fba6	662	///
hexley	54:e117ad10fba6	663	/// @param[in] bISRType Interrupt Source, should be:
hexley	54:e117ad10fba6	664	/// - RA8875_INT_KEYSCAN: KEYCAN interrupt
hexley	54:e117ad10fba6	665	/// - RA8875_INT_DMA: DMA interrupt
hexley	54:e117ad10fba6	666	/// - RA8875_INT_TP: Touch panel interrupt
hexley	54:e117ad10fba6	667	/// - RA8875_INT_BTE: BTE process complete interrupt
hexley	54:e117ad10fba6	668	/// - RA8875_INT_BTEMCU_FONTWR: Multi-purpose interrupt (see spec sheet)
WiredHome	56:7a85d226ad0d	669	/// @param[in] fptr is a callback function to handle the interrupt event.
WiredHome	56:7a85d226ad0d	670	/// @returns none
hexley	54:e117ad10fba6	671	///
hexley	54:e117ad10fba6	672	void AppendISR(uint8_t bISRType, void(*fptr)(void));
hexley	54:e117ad10fba6	673
hexley	54:e117ad10fba6	674	/// Unappend interrupt handler for specific RA8875 interrupt source
hexley	54:e117ad10fba6	675	///
hexley	54:e117ad10fba6	676	/// @param[in] bISRType Interrupt Source, should be:
hexley	54:e117ad10fba6	677	/// - RA8875_INT_KEYSCAN: KEYCAN interrupt
hexley	54:e117ad10fba6	678	/// - RA8875_INT_DMA: DMA interrupt
hexley	54:e117ad10fba6	679	/// - RA8875_INT_TP: Touch panel interrupt
hexley	54:e117ad10fba6	680	/// - RA8875_INT_BTE: BTE process complete interrupt
hexley	54:e117ad10fba6	681	/// - RA8875_INT_BTEMCU_FONTWR: Multi-purpose interrupt (see spec sheet)
hexley	54:e117ad10fba6	682	/// @return none
hexley	54:e117ad10fba6	683	///
hexley	54:e117ad10fba6	684	void UnAppendISR(uint8_t bISRType);
WiredHome	75:ca78388cfd77	685	#endif
WiredHome	77:9206c13aa527	686
WiredHome	71:dcac8efd842d	687	/// Initialize the keypad interface on the RA8875 controller.
WiredHome	71:dcac8efd842d	688	///
WiredHome	71:dcac8efd842d	689	/// Enables the keypad subsystem. It will scan the 4 x 5 matrix
WiredHome	71:dcac8efd842d	690	/// and make available key presses.
WiredHome	71:dcac8efd842d	691	///
WiredHome	71:dcac8efd842d	692	/// @note See section 5-13 of RAIO RA8875 data sheet for more details.
WiredHome	71:dcac8efd842d	693	/// @caution When using the display from buy-display.com, be sure that
WiredHome	71:dcac8efd842d	694	/// the option for the keypad is configured on the hardware.
WiredHome	71:dcac8efd842d	695	///
WiredHome	71:dcac8efd842d	696	/// All parameters are optional.
WiredHome	76:c981284eb513	697	/// @param[in] scanEnable when true, enables the key scan function (default: true).
WiredHome	76:c981284eb513	698	/// @param[in] longDetect when true, additionally enables the long key held detection (default: false).
WiredHome	71:dcac8efd842d	699	/// @param[in] sampleTime setting (range: 0 - 3, default: 0).
WiredHome	71:dcac8efd842d	700	/// @param[in] scanFrequency setting (range: 0 - 7, default: 0).
WiredHome	71:dcac8efd842d	701	/// @param[in] longTimeAdjustment (range: 0 - 3, default: 0).
WiredHome	76:c981284eb513	702	/// @param[in] interruptEnable when true, enables interrupts from keypress (default: false).
WiredHome	76:c981284eb513	703	/// @param[in] wakeupEnable when true, activates the wakeup function (default: false).
WiredHome	71:dcac8efd842d	704	///
WiredHome	71:dcac8efd842d	705	/// @returns success/failure code. @see RetCode_t.
WiredHome	71:dcac8efd842d	706	///
WiredHome	71:dcac8efd842d	707	RetCode_t KeypadInit(bool scanEnable = true, bool longDetect = false,
WiredHome	71:dcac8efd842d	708	uint8_t sampleTime = 0, uint8_t scanFrequency = 0,
WiredHome	71:dcac8efd842d	709	uint8_t longTimeAdjustment = 0,
WiredHome	71:dcac8efd842d	710	bool interruptEnable = false, bool wakeupEnable = false);
WiredHome	71:dcac8efd842d	711
WiredHome	75:ca78388cfd77	712	/// Create Key Code definitions for the key matrix.
WiredHome	75:ca78388cfd77	713	///
WiredHome	75:ca78388cfd77	714	/// This API provides a table of 22 key-code assignments for the matrix of keys.
WiredHome	75:ca78388cfd77	715	/// This can be used to translate the keys 1 - 20 into some other value, as
WiredHome	75:ca78388cfd77	716	/// well as to communicate the "no key" (zero) and "error state" (21).
WiredHome	75:ca78388cfd77	717	///
WiredHome	75:ca78388cfd77	718	/// In this way, a keypad could easily emulate a piece of a keyboard, transforming
WiredHome	75:ca78388cfd77	719	/// 0 - 20 into the values 0, '0', '1', '2', '3', '4', '5', '6', '7', '8',
WiredHome	75:ca78388cfd77	720	/// '9', '+', '-', '*' , '/', '=', '<bs>', '<cr>', and so on...
WiredHome	75:ca78388cfd77	721	///
WiredHome	75:ca78388cfd77	722	/// @code
WiredHome	75:ca78388cfd77	723	/// // Return Value by Row, Column Example reassignment
WiredHome	75:ca78388cfd77	724	/// // Column 0 1 2 3 4
WiredHome	75:ca78388cfd77	725	/// // +-------------------------+ +-------------------------+
WiredHome	76:c981284eb513	726	/// // Row 0 \| 1 2 3 4 5 \| \| '7' '8' '9' ',' '<-' \|
WiredHome	75:ca78388cfd77	727	/// // 1 \| 6 7 8 9 10 \| \| '4' '5' '6' '/' '-' \|
WiredHome	75:ca78388cfd77	728	/// // 2 \| 11 12 13 14 15 \| \| '1' '2' '3' '*' '+' \|
WiredHome	76:c981284eb513	729	/// // 3 \| 16 17 18 19 20 \| \| '0' '.' '(' ')' '\n' \|
WiredHome	75:ca78388cfd77	730	/// // +-------------------------+ +-------------------------+
WiredHome	75:ca78388cfd77	731	/// // Return value 0 = No Key pressed
WiredHome	75:ca78388cfd77	732	/// // Return value 21 = Error
WiredHome	77:9206c13aa527	733	/// const uint8_t CodeList[22] =
WiredHome	77:9206c13aa527	734	/// {0, '7', '8', '9', ',', '\h',
WiredHome	77:9206c13aa527	735	/// '4', '5', '6', '/', '-',
WiredHome	77:9206c13aa527	736	/// '1', '2', '3', '*', '+',
WiredHome	77:9206c13aa527	737	/// '0', '.', '(', ')', '\n',
WiredHome	77:9206c13aa527	738	/// '\x1b'};
WiredHome	77:9206c13aa527	739	/// lcd.SetKeyMap(CodeList);
WiredHome	75:ca78388cfd77	740	/// @endcode
WiredHome	75:ca78388cfd77	741	///
WiredHome	75:ca78388cfd77	742	/// @param[in] CodeList is a pointer to an always available byte-array
WiredHome	75:ca78388cfd77	743	/// where the first 22 bytes are used as the transformation
WiredHome	75:ca78388cfd77	744	/// from raw code to your reassigned value.
WiredHome	75:ca78388cfd77	745	/// If CodeList is NULL, the original raw value key map is
WiredHome	75:ca78388cfd77	746	/// restored.
WiredHome	75:ca78388cfd77	747	/// @returns noerror.
WiredHome	75:ca78388cfd77	748	///
WiredHome	75:ca78388cfd77	749	RetCode_t SetKeyMap(const uint8_t * CodeList = NULL);
WiredHome	75:ca78388cfd77	750
WiredHome	71:dcac8efd842d	751	/// Determine if a key has been hit
WiredHome	71:dcac8efd842d	752	///
WiredHome	71:dcac8efd842d	753	/// @returns true if a key has been hit
WiredHome	71:dcac8efd842d	754	///
WiredHome	75:ca78388cfd77	755	bool readable();
WiredHome	71:dcac8efd842d	756
WiredHome	71:dcac8efd842d	757	/// Blocking read of the keypad.
WiredHome	71:dcac8efd842d	758	///
WiredHome	71:dcac8efd842d	759	/// @caution: This is a blocking read, so it is important to first call _kbhit()
WiredHome	71:dcac8efd842d	760	/// to avoid hanging your processes.
WiredHome	71:dcac8efd842d	761	///
WiredHome	71:dcac8efd842d	762	/// A keypad connected to the RA8875 is connected in a matrix of 4 rows and 5 columns.
WiredHome	75:ca78388cfd77	763	/// When pressed, this method will return a code in the range of 1 through 20, reserving
WiredHome	75:ca78388cfd77	764	/// the value 0 to indicate that no key is pressed.
WiredHome	71:dcac8efd842d	765	///
WiredHome	71:dcac8efd842d	766	/// Additionally, if configured to detect a "long press", bit 7 will be set to indicate
WiredHome	71:dcac8efd842d	767	/// this. In this situation, first a "normal press" would be detected and signaled and
WiredHome	71:dcac8efd842d	768	/// soon after that a "long press" of the same key would be detected and communicated.
WiredHome	71:dcac8efd842d	769	///
WiredHome	75:ca78388cfd77	770	/// @return 8-bit where bit 7 indicates a long press. The remaining bits indicate the
WiredHome	75:ca78388cfd77	771	/// keypress using 0 = no key pressed, 1 - 20 = the key pressed.
WiredHome	71:dcac8efd842d	772	///
WiredHome	75:ca78388cfd77	773	uint8_t getc();
WiredHome	75:ca78388cfd77	774
WiredHome	82:f7d300f26540	775
WiredHome	82:f7d300f26540	776	/// Determine if a point is within a rectangle.
WiredHome	82:f7d300f26540	777	///
WiredHome	82:f7d300f26540	778	/// @param[in] rect is a rectangular region to use.
WiredHome	82:f7d300f26540	779	/// @param[in] p is a point to analyze to see if it is within the rect.
WiredHome	82:f7d300f26540	780	/// @returns true if p is within rect.
WiredHome	82:f7d300f26540	781	///
WiredHome	82:f7d300f26540	782	bool Intersect(rect_t rect, point_t p);
WiredHome	82:f7d300f26540	783
WiredHome	82:f7d300f26540	784
WiredHome	38:38d503b4fad6	785	/// Write a command to the display with a word of data.
WiredHome	38:38d503b4fad6	786	///
WiredHome	38:38d503b4fad6	787	/// This is a high level command, and may invoke several primitives.
WiredHome	38:38d503b4fad6	788	///
WiredHome	72:ecffe56af969	789	/// @param[in] command is the command to write.
WiredHome	72:ecffe56af969	790	/// @param[in] data is data to be written to the command register.
WiredHome	38:38d503b4fad6	791	/// @returns success/failure code. @see RetCode_t.
WiredHome	38:38d503b4fad6	792	///
WiredHome	38:38d503b4fad6	793	RetCode_t WriteCommandW(uint8_t command, uint16_t data);
WiredHome	38:38d503b4fad6	794
WiredHome	19:3f82c1161fd2	795	/// Write a command to the display
WiredHome	19:3f82c1161fd2	796	///
WiredHome	19:3f82c1161fd2	797	/// This is a high level command, and may invoke several primitives.
WiredHome	19:3f82c1161fd2	798	///
WiredHome	72:ecffe56af969	799	/// @param[in] command is the command to write.
WiredHome	72:ecffe56af969	800	/// @param[in] data is optional data to be written to the command register
WiredHome	19:3f82c1161fd2	801	/// and only occurs if the data is in the range [0 - 0xFF].
WiredHome	19:3f82c1161fd2	802	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	803	///
WiredHome	32:0e4f2ae512e2	804	virtual RetCode_t WriteCommand(unsigned char command, unsigned int data = 0xFFFF);
WiredHome	19:3f82c1161fd2	805
WiredHome	38:38d503b4fad6	806	/// Write a data word to the display
WiredHome	38:38d503b4fad6	807	///
WiredHome	38:38d503b4fad6	808	/// This is a high level command, and may invoke several primitives.
WiredHome	38:38d503b4fad6	809	///
WiredHome	72:ecffe56af969	810	/// @param[in] data is the data to write.
WiredHome	38:38d503b4fad6	811	/// @returns success/failure code. @see RetCode_t.
WiredHome	38:38d503b4fad6	812	///
WiredHome	38:38d503b4fad6	813	RetCode_t WriteDataW(uint16_t data);
WiredHome	38:38d503b4fad6	814
WiredHome	19:3f82c1161fd2	815	/// Write a data byte to the display
WiredHome	19:3f82c1161fd2	816	///
WiredHome	19:3f82c1161fd2	817	/// This is a high level command, and may invoke several primitives.
WiredHome	19:3f82c1161fd2	818	///
WiredHome	72:ecffe56af969	819	/// @param[in] data is the data to write.
WiredHome	19:3f82c1161fd2	820	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	821	///
WiredHome	32:0e4f2ae512e2	822	virtual RetCode_t WriteData(unsigned char data);
WiredHome	19:3f82c1161fd2	823
WiredHome	19:3f82c1161fd2	824	/// Read a command register
WiredHome	19:3f82c1161fd2	825	///
WiredHome	72:ecffe56af969	826	/// @param[in] command is the command register to read.
WiredHome	19:3f82c1161fd2	827	/// @returns the value read from the register.
WiredHome	19:3f82c1161fd2	828	///
WiredHome	19:3f82c1161fd2	829	unsigned char ReadCommand(unsigned char command);
WiredHome	19:3f82c1161fd2	830
WiredHome	41:2956a0a221e5	831	/// Read a data byte from the display
WiredHome	19:3f82c1161fd2	832	///
WiredHome	19:3f82c1161fd2	833	/// This is a high level command, and may invoke several primitives.
WiredHome	19:3f82c1161fd2	834	///
WiredHome	19:3f82c1161fd2	835	/// @returns data that was read.
WiredHome	19:3f82c1161fd2	836	///
WiredHome	19:3f82c1161fd2	837	unsigned char ReadData(void);
WiredHome	19:3f82c1161fd2	838
WiredHome	41:2956a0a221e5	839	/// Read a word from the display
WiredHome	41:2956a0a221e5	840	///
WiredHome	41:2956a0a221e5	841	/// This is a high level command, and may invoke several primitives.
WiredHome	41:2956a0a221e5	842	///
WiredHome	41:2956a0a221e5	843	/// @returns data that was read.
WiredHome	41:2956a0a221e5	844	///
WiredHome	41:2956a0a221e5	845	uint16_t ReadDataW(void);
WiredHome	41:2956a0a221e5	846
WiredHome	19:3f82c1161fd2	847	/// Read the display status
WiredHome	19:3f82c1161fd2	848	///
WiredHome	19:3f82c1161fd2	849	/// This is a high level command, and may invoke several primitives.
WiredHome	19:3f82c1161fd2	850	///
WiredHome	19:3f82c1161fd2	851	/// @returns data that was read.
WiredHome	19:3f82c1161fd2	852	///
WiredHome	19:3f82c1161fd2	853	unsigned char ReadStatus(void);
WiredHome	19:3f82c1161fd2	854
WiredHome	19:3f82c1161fd2	855	/// get the width in pixels of the currently active font
WiredHome	19:3f82c1161fd2	856	///
WiredHome	19:3f82c1161fd2	857	/// @returns font width in pixels.
WiredHome	19:3f82c1161fd2	858	///
WiredHome	37:f19b7e7449dc	859	dim_t fontwidth(void);
WiredHome	19:3f82c1161fd2	860
WiredHome	19:3f82c1161fd2	861	/// get the height in pixels of the currently active font
WiredHome	19:3f82c1161fd2	862	///
WiredHome	19:3f82c1161fd2	863	/// @returns font height in pixels.
WiredHome	19:3f82c1161fd2	864	///
WiredHome	37:f19b7e7449dc	865	dim_t fontheight(void);
WiredHome	19:3f82c1161fd2	866
WiredHome	19:3f82c1161fd2	867	/// get the number of colums based on the currently active font
WiredHome	19:3f82c1161fd2	868	///
WiredHome	19:3f82c1161fd2	869	/// @returns number of columns.
WiredHome	19:3f82c1161fd2	870	///
WiredHome	19:3f82c1161fd2	871	virtual int columns(void);
WiredHome	19:3f82c1161fd2	872
WiredHome	19:3f82c1161fd2	873	/// get the number of rows based on the currently active font
WiredHome	19:3f82c1161fd2	874	///
WiredHome	19:3f82c1161fd2	875	/// @returns number of rows.
WiredHome	19:3f82c1161fd2	876	///
WiredHome	19:3f82c1161fd2	877	virtual int rows(void);
WiredHome	19:3f82c1161fd2	878
WiredHome	19:3f82c1161fd2	879	/// get the screen width in pixels
WiredHome	19:3f82c1161fd2	880	///
WiredHome	19:3f82c1161fd2	881	/// @returns screen width in pixels.
WiredHome	19:3f82c1161fd2	882	///
WiredHome	38:38d503b4fad6	883	virtual dim_t width(void);
WiredHome	19:3f82c1161fd2	884
WiredHome	19:3f82c1161fd2	885	/// get the screen height in pixels
WiredHome	19:3f82c1161fd2	886	///
WiredHome	19:3f82c1161fd2	887	/// @returns screen height in pixels.
WiredHome	19:3f82c1161fd2	888	///
WiredHome	38:38d503b4fad6	889	virtual dim_t height(void);
WiredHome	19:3f82c1161fd2	890
WiredHome	43:3becae133285	891	/// get the color depth in bits per pixel.
WiredHome	43:3becae133285	892	///
WiredHome	43:3becae133285	893	/// @returns 8 or 16 only.
WiredHome	43:3becae133285	894	///
WiredHome	43:3becae133285	895	virtual dim_t color_bpp(void);
WiredHome	43:3becae133285	896
WiredHome	19:3f82c1161fd2	897	/// Set cursor position based on the current font size.
WiredHome	19:3f82c1161fd2	898	///
WiredHome	72:ecffe56af969	899	/// @param[in] column is the horizontal position in character positions
WiredHome	72:ecffe56af969	900	/// @param[in] row is the vertical position in character positions
WiredHome	19:3f82c1161fd2	901	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	902	///
WiredHome	37:f19b7e7449dc	903	virtual RetCode_t locate(textloc_t column, textloc_t row);
WiredHome	19:3f82c1161fd2	904
WiredHome	19:3f82c1161fd2	905	/// Prepare the controller to write text to the screen by positioning
WiredHome	19:3f82c1161fd2	906	/// the cursor.
WiredHome	19:3f82c1161fd2	907	///
WiredHome	56:7a85d226ad0d	908	/// @code
WiredHome	56:7a85d226ad0d	909	/// lcd.SetTextCursor(100, 25);
WiredHome	56:7a85d226ad0d	910	/// lcd.puts("Hello");
WiredHome	56:7a85d226ad0d	911	/// @endcode
WiredHome	56:7a85d226ad0d	912	///
WiredHome	72:ecffe56af969	913	/// @param[in] x is the horizontal position in pixels (from the left edge)
WiredHome	72:ecffe56af969	914	/// @param[in] y is the vertical position in pixels (from the top edge)
WiredHome	19:3f82c1161fd2	915	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	916	///
WiredHome	37:f19b7e7449dc	917	RetCode_t SetTextCursor(loc_t x, loc_t y);
WiredHome	29:422616aa04bd	918
WiredHome	37:f19b7e7449dc	919	/// Get the current cursor position in pixels.
WiredHome	37:f19b7e7449dc	920	///
WiredHome	56:7a85d226ad0d	921	/// @code
WiredHome	56:7a85d226ad0d	922	/// point_t point = GetTextCursor();
WiredHome	56:7a85d226ad0d	923	/// if (point.x > 100 && point.y > 150)
WiredHome	56:7a85d226ad0d	924	/// //...
WiredHome	56:7a85d226ad0d	925	/// @endcode
WiredHome	56:7a85d226ad0d	926	///
WiredHome	37:f19b7e7449dc	927	/// @returns cursor position.
WiredHome	37:f19b7e7449dc	928	///
WiredHome	37:f19b7e7449dc	929	point_t GetTextCursor(void);
WiredHome	37:f19b7e7449dc	930
WiredHome	29:422616aa04bd	931	/// Get the current cursor horizontal position in pixels.
WiredHome	29:422616aa04bd	932	///
WiredHome	29:422616aa04bd	933	/// @returns cursor position horizontal offset.
WiredHome	29:422616aa04bd	934	///
WiredHome	37:f19b7e7449dc	935	loc_t GetTextCursor_X(void);
WiredHome	29:422616aa04bd	936
WiredHome	29:422616aa04bd	937	/// Get the current cursor vertical position in pixels.
WiredHome	29:422616aa04bd	938	///
WiredHome	29:422616aa04bd	939	/// @returns cursor position vertical offset.
WiredHome	29:422616aa04bd	940	///
WiredHome	37:f19b7e7449dc	941	loc_t GetTextCursor_Y(void);
WiredHome	29:422616aa04bd	942
WiredHome	23:a50ded45dbaf	943	/// Configure additional Cursor Control settings.
WiredHome	23:a50ded45dbaf	944	///
WiredHome	23:a50ded45dbaf	945	/// This API lets you modify other cursor control settings;
WiredHome	23:a50ded45dbaf	946	/// Cursor visible/hidden, Cursor blink/normal,
WiredHome	23:a50ded45dbaf	947	/// Cursor I-Beam/underscore/box.
WiredHome	23:a50ded45dbaf	948	///
WiredHome	72:ecffe56af969	949	/// @param[in] cursor can be set to NOCURSOR (default), IBEAM,
WiredHome	24:8ca861acf12d	950	/// UNDER, or BLOCK.
WiredHome	72:ecffe56af969	951	/// @param[in] blink can be set to true or false (default false)
WiredHome	23:a50ded45dbaf	952	/// @returns success/failure code. @see RetCode_t
WiredHome	23:a50ded45dbaf	953	///
WiredHome	24:8ca861acf12d	954	RetCode_t SetTextCursorControl(cursor_t cursor = NOCURSOR, bool blink = false);
WiredHome	23:a50ded45dbaf	955
WiredHome	19:3f82c1161fd2	956	/// Select the ISO 8859-X font to use next.
WiredHome	19:3f82c1161fd2	957	///
WiredHome	19:3f82c1161fd2	958	/// Supported fonts: ISO 8859-1, -2, -3, -4
WiredHome	19:3f82c1161fd2	959	///
WiredHome	72:ecffe56af969	960	/// @param[in] font selects the font for the subsequent text rendering.
WiredHome	19:3f82c1161fd2	961	///
WiredHome	19:3f82c1161fd2	962	/// @note if either hScale or vScale is outside of its permitted range,
WiredHome	19:3f82c1161fd2	963	/// the command is not executed.
WiredHome	19:3f82c1161fd2	964	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	965	///
WiredHome	19:3f82c1161fd2	966	RetCode_t SetTextFont(font_t font = ISO8859_1);
WiredHome	19:3f82c1161fd2	967
WiredHome	19:3f82c1161fd2	968	/// Control the font behavior.
WiredHome	19:3f82c1161fd2	969	///
WiredHome	19:3f82c1161fd2	970	/// This command lets you make several modifications to any text that
WiredHome	56:7a85d226ad0d	971	/// will be written to the screen.
WiredHome	19:3f82c1161fd2	972	///
WiredHome	19:3f82c1161fd2	973	/// Options can be combined:
WiredHome	19:3f82c1161fd2	974	/// Default:
WiredHome	19:3f82c1161fd2	975	/// @li Full alignment disabled,
WiredHome	19:3f82c1161fd2	976	/// @li Font with Background color,
WiredHome	19:3f82c1161fd2	977	/// @li Font in normal orientiation,
WiredHome	19:3f82c1161fd2	978	/// @li Horizontal scale x 1
WiredHome	19:3f82c1161fd2	979	/// @li Vertical scale x 1
WiredHome	19:3f82c1161fd2	980	/// @li alignment
WiredHome	19:3f82c1161fd2	981	///
WiredHome	72:ecffe56af969	982	/// @param[in] fillit defaults to FILL, but can be NOFILL
WiredHome	72:ecffe56af969	983	/// @param[in] angle defaults to normal, but can be rotated
WiredHome	72:ecffe56af969	984	/// @param[in] hScale defaults to 1, but can be 1, 2, 3, or 4,
WiredHome	19:3f82c1161fd2	985	/// and scales the font size by this amount.
WiredHome	72:ecffe56af969	986	/// @param[in] vScale defaults to 1, but can be 1, 2, 3, or 4,
WiredHome	19:3f82c1161fd2	987	/// and scales the font size by this amount.
WiredHome	72:ecffe56af969	988	/// @param[in] alignment defaults to align_none, but can be
WiredHome	19:3f82c1161fd2	989	/// align_full.
WiredHome	19:3f82c1161fd2	990	///
WiredHome	19:3f82c1161fd2	991	/// @note if either hScale or vScale is outside of its permitted range,
WiredHome	19:3f82c1161fd2	992	/// the command is not executed.
WiredHome	19:3f82c1161fd2	993	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	994	///
WiredHome	19:3f82c1161fd2	995	RetCode_t SetTextFontControl(fill_t fillit = FILL,
WiredHome	19:3f82c1161fd2	996	font_angle_t angle = normal,
WiredHome	19:3f82c1161fd2	997	HorizontalScale hScale = 1,
WiredHome	19:3f82c1161fd2	998	VerticalScale vScale = 1,
WiredHome	19:3f82c1161fd2	999	alignment_t alignment = align_none);
WiredHome	19:3f82c1161fd2	1000
WiredHome	19:3f82c1161fd2	1001	/// Control the font size
WiredHome	19:3f82c1161fd2	1002	///
WiredHome	19:3f82c1161fd2	1003	/// This command lets you set the font enlargement for both horizontal
WiredHome	19:3f82c1161fd2	1004	/// and vertical, independent of the rotation, background, and
WiredHome	19:3f82c1161fd2	1005	/// alignment. @see SetTextFontControl.
WiredHome	19:3f82c1161fd2	1006	///
WiredHome	72:ecffe56af969	1007	/// @param[in] hScale defaults to 1, but can be 1, 2, 3, or 4,
WiredHome	19:3f82c1161fd2	1008	/// and scales the font size by this amount.
WiredHome	72:ecffe56af969	1009	/// @param[in] vScale is an optional parameter that defaults to the hScale value,
WiredHome	40:04aa280dfa39	1010	/// but can be 1, 2, 3, or 4, and scales the font size by this amount.
WiredHome	40:04aa280dfa39	1011	///
WiredHome	40:04aa280dfa39	1012	/// @code
WiredHome	40:04aa280dfa39	1013	/// lcd.SetTextFontSize(2); // Set the font to 2x normal size
WiredHome	56:7a85d226ad0d	1014	/// lcd.puts("Two times");
WiredHome	40:04aa280dfa39	1015	/// lcd.SetTextFontSize(2,3); // Set the font to 2x Width and 3x Height
WiredHome	56:7a85d226ad0d	1016	/// lcd.puts("22 3h");
WiredHome	40:04aa280dfa39	1017	/// lcd.SetTextFontSize(); // Restore to normal size in both dimensions
WiredHome	56:7a85d226ad0d	1018	/// lcd.puts("normal");
WiredHome	40:04aa280dfa39	1019	/// @endcode
WiredHome	19:3f82c1161fd2	1020	///
WiredHome	19:3f82c1161fd2	1021	/// @note if either hScale or vScale is outside of its permitted range,
WiredHome	19:3f82c1161fd2	1022	/// the command is not executed.
WiredHome	19:3f82c1161fd2	1023	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1024	///
WiredHome	40:04aa280dfa39	1025	RetCode_t SetTextFontSize(HorizontalScale hScale = 1, VerticalScale vScale = -1);
WiredHome	19:3f82c1161fd2	1026
WiredHome	19:3f82c1161fd2	1027	/// put a character on the screen.
WiredHome	19:3f82c1161fd2	1028	///
WiredHome	72:ecffe56af969	1029	/// @param[in] c is the character.
WiredHome	19:3f82c1161fd2	1030	/// @returns the character, or EOF if there is an error.
WiredHome	19:3f82c1161fd2	1031	///
WiredHome	19:3f82c1161fd2	1032	virtual int _putc(int c);
WiredHome	19:3f82c1161fd2	1033
WiredHome	19:3f82c1161fd2	1034	/// Write string of text to the display
WiredHome	19:3f82c1161fd2	1035	///
WiredHome	56:7a85d226ad0d	1036	/// @code
WiredHome	56:7a85d226ad0d	1037	/// lcd.puts("Test STring");
WiredHome	56:7a85d226ad0d	1038	/// @endcode
WiredHome	56:7a85d226ad0d	1039	///
WiredHome	72:ecffe56af969	1040	/// @param[in] string is the null terminated string to send to the display.
WiredHome	19:3f82c1161fd2	1041	///
WiredHome	19:3f82c1161fd2	1042	void puts(const char * string);
WiredHome	19:3f82c1161fd2	1043
WiredHome	19:3f82c1161fd2	1044	/// Write string of text to the display at the specified location.
WiredHome	19:3f82c1161fd2	1045	///
WiredHome	56:7a85d226ad0d	1046	/// @code
WiredHome	56:7a85d226ad0d	1047	/// lcd.puts(10,25, "Test STring");
WiredHome	56:7a85d226ad0d	1048	/// @endcode
WiredHome	56:7a85d226ad0d	1049	///
WiredHome	72:ecffe56af969	1050	/// @param[in] x is the horizontal position in pixels (from the left edge)
WiredHome	72:ecffe56af969	1051	/// @param[in] y is the vertical position in pixels (from the top edge)
WiredHome	72:ecffe56af969	1052	/// @param[in] string is the null terminated string to send to the display.
WiredHome	19:3f82c1161fd2	1053	///
WiredHome	37:f19b7e7449dc	1054	void puts(loc_t x, loc_t y, const char * string);
WiredHome	19:3f82c1161fd2	1055
WiredHome	19:3f82c1161fd2	1056	/// Prepare the controller to write binary data to the screen by positioning
WiredHome	19:3f82c1161fd2	1057	/// the memory cursor.
WiredHome	19:3f82c1161fd2	1058	///
WiredHome	72:ecffe56af969	1059	/// @param[in] x is the horizontal position in pixels (from the left edge)
WiredHome	72:ecffe56af969	1060	/// @param[in] y is the vertical position in pixels (from the top edge)
WiredHome	19:3f82c1161fd2	1061	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1062	///
WiredHome	37:f19b7e7449dc	1063	virtual RetCode_t SetGraphicsCursor(loc_t x, loc_t y);
WiredHome	19:3f82c1161fd2	1064
WiredHome	41:2956a0a221e5	1065	/// Prepare the controller to read binary data from the screen by positioning
WiredHome	41:2956a0a221e5	1066	/// the memory read cursor.
WiredHome	41:2956a0a221e5	1067	///
WiredHome	72:ecffe56af969	1068	/// @param[in] x is the horizontal position in pixels (from the left edge)
WiredHome	72:ecffe56af969	1069	/// @param[in] y is the vertical position in pixels (from the top edge)
WiredHome	41:2956a0a221e5	1070	/// @returns success/failure code. @see RetCode_t.
WiredHome	41:2956a0a221e5	1071	///
WiredHome	41:2956a0a221e5	1072	virtual RetCode_t SetGraphicsCursorRead(loc_t x, loc_t y);
WiredHome	41:2956a0a221e5	1073
WiredHome	19:3f82c1161fd2	1074	/// Set the window, which controls where items are written to the screen.
WiredHome	19:3f82c1161fd2	1075	///
WiredHome	19:3f82c1161fd2	1076	/// When something hits the window width, it wraps back to the left side
WiredHome	19:3f82c1161fd2	1077	/// and down a row. If the initial write is outside the window, it will
WiredHome	19:3f82c1161fd2	1078	/// be captured into the window when it crosses a boundary.
WiredHome	19:3f82c1161fd2	1079	///
WiredHome	56:7a85d226ad0d	1080	/// @code
WiredHome	56:7a85d226ad0d	1081	/// lcd.window(10,10, 80,80);
WiredHome	56:7a85d226ad0d	1082	/// lcd.puts("012345678901234567890123456789012345678901234567890");
WiredHome	56:7a85d226ad0d	1083	/// @endcode
WiredHome	56:7a85d226ad0d	1084	///
WiredHome	72:ecffe56af969	1085	/// @param[in] x is the left edge in pixels.
WiredHome	72:ecffe56af969	1086	/// @param[in] y is the top edge in pixels.
WiredHome	72:ecffe56af969	1087	/// @param[in] width is the window width in pixels.
WiredHome	72:ecffe56af969	1088	/// @param[in] height is the window height in pixels.
WiredHome	19:3f82c1161fd2	1089	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1090	///
WiredHome	37:f19b7e7449dc	1091	virtual RetCode_t window(loc_t x, loc_t y, dim_t width, dim_t height);
WiredHome	19:3f82c1161fd2	1092
WiredHome	61:8f3153bf0baa	1093	/// Clear either the specified layer, or the active layer.
WiredHome	19:3f82c1161fd2	1094	///
WiredHome	61:8f3153bf0baa	1095	/// The behavior is to clear the whole screen for the specified
WiredHome	61:8f3153bf0baa	1096	/// layer. When not specified, the active drawing layer is cleared.
WiredHome	61:8f3153bf0baa	1097	/// This command can also be used to specifically clear either,
WiredHome	61:8f3153bf0baa	1098	/// or both layers. @see clsw().
WiredHome	19:3f82c1161fd2	1099	///
WiredHome	56:7a85d226ad0d	1100	/// @code
WiredHome	56:7a85d226ad0d	1101	/// lcd.cls();
WiredHome	56:7a85d226ad0d	1102	/// @endcode
WiredHome	56:7a85d226ad0d	1103	///
WiredHome	72:ecffe56af969	1104	/// @param[in] layers is optional. If not provided, the active layer
WiredHome	61:8f3153bf0baa	1105	/// is cleared. If bit 0 is set, layer 0 is cleared, if bit
WiredHome	61:8f3153bf0baa	1106	/// 1 is set, layer 1 is cleared. If both are set, both layers
WiredHome	61:8f3153bf0baa	1107	/// are cleared. Any other value does not cause an action.
WiredHome	61:8f3153bf0baa	1108	///
WiredHome	19:3f82c1161fd2	1109	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1110	///
WiredHome	61:8f3153bf0baa	1111	virtual RetCode_t cls(uint16_t layers = 0);
WiredHome	19:3f82c1161fd2	1112
WiredHome	19:3f82c1161fd2	1113	/// Clear the screen, or clear only the active window.
WiredHome	19:3f82c1161fd2	1114	///
WiredHome	19:3f82c1161fd2	1115	/// The default behavior is to clear the whole screen. With the optional
WiredHome	19:3f82c1161fd2	1116	/// parameter, the action can be restricted to the active window, which
WiredHome	32:0e4f2ae512e2	1117	/// can be set with the @see window method.
WiredHome	19:3f82c1161fd2	1118	///
WiredHome	56:7a85d226ad0d	1119	/// @code
WiredHome	56:7a85d226ad0d	1120	/// lcd.window(20,20, 40,10);
WiredHome	56:7a85d226ad0d	1121	/// lcd.clsw();
WiredHome	56:7a85d226ad0d	1122	/// @endcode
WiredHome	56:7a85d226ad0d	1123	///
WiredHome	72:ecffe56af969	1124	/// @param[in] region is an optional parameter that defaults to FULLWINDOW
WiredHome	19:3f82c1161fd2	1125	/// or may be set to ACTIVEWINDOW.
WiredHome	19:3f82c1161fd2	1126	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1127	///
WiredHome	19:3f82c1161fd2	1128	RetCode_t clsw(RA8875::Region_t region = FULLWINDOW);
WiredHome	19:3f82c1161fd2	1129
WiredHome	19:3f82c1161fd2	1130	/// Set the background color.
WiredHome	19:3f82c1161fd2	1131	///
WiredHome	72:ecffe56af969	1132	/// @param[in] color is expressed in 16-bit format.
WiredHome	19:3f82c1161fd2	1133	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1134	///
WiredHome	19:3f82c1161fd2	1135	virtual RetCode_t background(color_t color);
WiredHome	19:3f82c1161fd2	1136
WiredHome	19:3f82c1161fd2	1137	/// Set the background color.
WiredHome	19:3f82c1161fd2	1138	///
WiredHome	72:ecffe56af969	1139	/// @param[in] r is the red element of the color.
WiredHome	72:ecffe56af969	1140	/// @param[in] g is the green element of the color.
WiredHome	72:ecffe56af969	1141	/// @param[in] b is the blue element of the color.
WiredHome	19:3f82c1161fd2	1142	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1143	///
WiredHome	19:3f82c1161fd2	1144	virtual RetCode_t background(unsigned char r, unsigned char g, unsigned char b);
WiredHome	19:3f82c1161fd2	1145
WiredHome	19:3f82c1161fd2	1146	/// Set the foreground color.
WiredHome	19:3f82c1161fd2	1147	///
WiredHome	72:ecffe56af969	1148	/// @param[in] color is expressed in 16-bit format.
WiredHome	19:3f82c1161fd2	1149	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1150	///
WiredHome	19:3f82c1161fd2	1151	virtual RetCode_t foreground(color_t color);
WiredHome	19:3f82c1161fd2	1152
WiredHome	19:3f82c1161fd2	1153	/// Set the foreground color.
WiredHome	19:3f82c1161fd2	1154	///
WiredHome	72:ecffe56af969	1155	/// @param[in] r is the red element of the color.
WiredHome	72:ecffe56af969	1156	/// @param[in] g is the green element of the color.
WiredHome	72:ecffe56af969	1157	/// @param[in] b is the blue element of the color.
WiredHome	19:3f82c1161fd2	1158	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1159	///
WiredHome	37:f19b7e7449dc	1160	virtual RetCode_t foreground(unsigned char r, unsigned char g, unsigned char b);
WiredHome	19:3f82c1161fd2	1161
WiredHome	19:3f82c1161fd2	1162	/// Get the current foreground color value.
WiredHome	19:3f82c1161fd2	1163	///
WiredHome	19:3f82c1161fd2	1164	/// @returns the current foreground color.
WiredHome	19:3f82c1161fd2	1165	///
WiredHome	37:f19b7e7449dc	1166	color_t GetForeColor(void);
WiredHome	19:3f82c1161fd2	1167
WiredHome	19:3f82c1161fd2	1168	/// Draw a pixel in the specified color.
WiredHome	19:3f82c1161fd2	1169	///
WiredHome	41:2956a0a221e5	1170	/// @note Unlike many other operations, this does not
WiredHome	41:2956a0a221e5	1171	/// set the forecolor!
WiredHome	19:3f82c1161fd2	1172	///
WiredHome	72:ecffe56af969	1173	/// @param[in] x is the horizontal offset to this pixel.
WiredHome	72:ecffe56af969	1174	/// @param[in] y is the vertical offset to this pixel.
WiredHome	72:ecffe56af969	1175	/// @param[in] color defines the color for the pixel.
WiredHome	19:3f82c1161fd2	1176	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1177	///
WiredHome	37:f19b7e7449dc	1178	virtual RetCode_t pixel(loc_t x, loc_t y, color_t color);
WiredHome	19:3f82c1161fd2	1179
WiredHome	19:3f82c1161fd2	1180	/// Draw a pixel in the current foreground color.
WiredHome	19:3f82c1161fd2	1181	///
WiredHome	72:ecffe56af969	1182	/// @param[in] x is the horizontal offset to this pixel.
WiredHome	72:ecffe56af969	1183	/// @param[in] y is the veritical offset to this pixel.
WiredHome	19:3f82c1161fd2	1184	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1185	///
WiredHome	37:f19b7e7449dc	1186	virtual RetCode_t pixel(loc_t x, loc_t y);
WiredHome	19:3f82c1161fd2	1187
WiredHome	41:2956a0a221e5	1188	/// Get a pixel from the display.
WiredHome	41:2956a0a221e5	1189	///
WiredHome	72:ecffe56af969	1190	/// @param[in] x is the horizontal offset to this pixel.
WiredHome	72:ecffe56af969	1191	/// @param[in] y is the vertical offset to this pixel.
WiredHome	41:2956a0a221e5	1192	/// @returns the pixel. see @color_t
WiredHome	41:2956a0a221e5	1193	///
WiredHome	41:2956a0a221e5	1194	virtual color_t getPixel(loc_t x, loc_t y);
WiredHome	41:2956a0a221e5	1195
WiredHome	41:2956a0a221e5	1196	/// Write a stream of pixels to the display.
WiredHome	41:2956a0a221e5	1197	///
WiredHome	72:ecffe56af969	1198	/// @param[in] p is a pointer to a color_t array to write.
WiredHome	72:ecffe56af969	1199	/// @param[in] count is the number of pixels to write.
WiredHome	72:ecffe56af969	1200	/// @param[in] x is the horizontal position on the display.
WiredHome	72:ecffe56af969	1201	/// @param[in] y is the vertical position on the display.
WiredHome	41:2956a0a221e5	1202	/// @returns success/failure code. @see RetCode_t.
WiredHome	41:2956a0a221e5	1203	///
WiredHome	41:2956a0a221e5	1204	virtual RetCode_t pixelStream(color_t * p, uint32_t count, loc_t x, loc_t y);
WiredHome	41:2956a0a221e5	1205
WiredHome	41:2956a0a221e5	1206	/// Get a stream of pixels from the display.
WiredHome	41:2956a0a221e5	1207	///
WiredHome	72:ecffe56af969	1208	/// @param[in] p is a pointer to a color_t array to accept the stream.
WiredHome	72:ecffe56af969	1209	/// @param[in] count is the number of pixels to read.
WiredHome	72:ecffe56af969	1210	/// @param[in] x is the horizontal offset to this pixel.
WiredHome	72:ecffe56af969	1211	/// @param[in] y is the vertical offset to this pixel.
WiredHome	41:2956a0a221e5	1212	/// @returns success/failure code. @see RetCode_t.
WiredHome	41:2956a0a221e5	1213	///
WiredHome	41:2956a0a221e5	1214	virtual RetCode_t getPixelStream(color_t * p, uint32_t count, loc_t x, loc_t y);
WiredHome	41:2956a0a221e5	1215
WiredHome	19:3f82c1161fd2	1216	/// Draw a line in the specified color
WiredHome	19:3f82c1161fd2	1217	///
WiredHome	19:3f82c1161fd2	1218	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	1219	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	1220	///
WiredHome	83:7bad0068cca0	1221	/// @param[in] p1 is the point to start the line.
WiredHome	83:7bad0068cca0	1222	/// @param[in] p2 is the point to end the line.
WiredHome	83:7bad0068cca0	1223	/// @param[in] color defines the foreground color.
WiredHome	83:7bad0068cca0	1224	/// @returns success/failure code. @see RetCode_t.
WiredHome	83:7bad0068cca0	1225	///
WiredHome	83:7bad0068cca0	1226	RetCode_t line(point_t p1, point_t p2, color_t color);
WiredHome	83:7bad0068cca0	1227
WiredHome	83:7bad0068cca0	1228	/// Draw a line
WiredHome	83:7bad0068cca0	1229	///
WiredHome	83:7bad0068cca0	1230	/// Draws a line using the foreground color setting.
WiredHome	83:7bad0068cca0	1231	///
WiredHome	83:7bad0068cca0	1232	/// @param[in] p1 is the point to start the line.
WiredHome	83:7bad0068cca0	1233	/// @param[in] p2 is the point to end the line.
WiredHome	83:7bad0068cca0	1234	/// @returns success/failure code. @see RetCode_t.
WiredHome	83:7bad0068cca0	1235	///
WiredHome	83:7bad0068cca0	1236	RetCode_t line(point_t p1, point_t p2);
WiredHome	83:7bad0068cca0	1237
WiredHome	83:7bad0068cca0	1238	/// Draw a line in the specified color
WiredHome	83:7bad0068cca0	1239	///
WiredHome	83:7bad0068cca0	1240	/// @note As a side effect, this changes the current
WiredHome	83:7bad0068cca0	1241	/// foreground color for subsequent operations.
WiredHome	83:7bad0068cca0	1242	///
WiredHome	72:ecffe56af969	1243	/// @param[in] x1 is the horizontal start of the line.
WiredHome	72:ecffe56af969	1244	/// @param[in] y1 is the vertical start of the line.
WiredHome	72:ecffe56af969	1245	/// @param[in] x2 is the horizontal end of the line.
WiredHome	72:ecffe56af969	1246	/// @param[in] y2 is the vertical end of the line.
WiredHome	72:ecffe56af969	1247	/// @param[in] color defines the foreground color.
WiredHome	19:3f82c1161fd2	1248	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1249	///
WiredHome	56:7a85d226ad0d	1250	RetCode_t line(loc_t x1, loc_t y1, loc_t x2, loc_t y2, color_t color);
WiredHome	19:3f82c1161fd2	1251
WiredHome	19:3f82c1161fd2	1252	/// Draw a line
WiredHome	19:3f82c1161fd2	1253	///
WiredHome	19:3f82c1161fd2	1254	/// Draws a line using the foreground color setting.
WiredHome	19:3f82c1161fd2	1255	///
WiredHome	72:ecffe56af969	1256	/// @param[in] x1 is the horizontal start of the line.
WiredHome	72:ecffe56af969	1257	/// @param[in] y1 is the vertical start of the line.
WiredHome	72:ecffe56af969	1258	/// @param[in] x2 is the horizontal end of the line.
WiredHome	72:ecffe56af969	1259	/// @param[in] y2 is the vertical end of the line.
WiredHome	19:3f82c1161fd2	1260	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1261	///
WiredHome	37:f19b7e7449dc	1262	RetCode_t line(loc_t x1, loc_t y1, loc_t x2, loc_t y2);
WiredHome	19:3f82c1161fd2	1263
WiredHome	19:3f82c1161fd2	1264	/// Draw a rectangle in the specified color
WiredHome	19:3f82c1161fd2	1265	///
WiredHome	19:3f82c1161fd2	1266	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	1267	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	1268	///
WiredHome	81:01da2e34283d	1269	/// @param[in] rect defines the rectangle.
WiredHome	81:01da2e34283d	1270	/// @param[in] color defines the foreground color.
WiredHome	81:01da2e34283d	1271	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	81:01da2e34283d	1272	/// @returns success/failure code. @see RetCode_t.
WiredHome	81:01da2e34283d	1273	///
WiredHome	82:f7d300f26540	1274	RetCode_t rect(rect_t rect, color_t color, fill_t fillit = NOFILL);
WiredHome	81:01da2e34283d	1275
WiredHome	81:01da2e34283d	1276	/// Draw a filled rectangle in the specified color
WiredHome	81:01da2e34283d	1277	///
WiredHome	81:01da2e34283d	1278	/// @note As a side effect, this changes the current
WiredHome	81:01da2e34283d	1279	/// foreground color for subsequent operations.
WiredHome	81:01da2e34283d	1280	///
WiredHome	81:01da2e34283d	1281	/// @param[in] rect defines the rectangle.
WiredHome	81:01da2e34283d	1282	/// @param[in] color defines the foreground color.
WiredHome	81:01da2e34283d	1283	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	81:01da2e34283d	1284	/// @returns success/failure code. @see RetCode_t.
WiredHome	81:01da2e34283d	1285	///
WiredHome	81:01da2e34283d	1286	RetCode_t fillrect(rect_t rect, color_t color, fill_t fillit = FILL);
WiredHome	81:01da2e34283d	1287
WiredHome	81:01da2e34283d	1288	/// Draw a rectangle in the specified color
WiredHome	81:01da2e34283d	1289	///
WiredHome	81:01da2e34283d	1290	/// @note As a side effect, this changes the current
WiredHome	81:01da2e34283d	1291	/// foreground color for subsequent operations.
WiredHome	81:01da2e34283d	1292	///
WiredHome	72:ecffe56af969	1293	/// @param[in] x1 is the horizontal start of the line.
WiredHome	72:ecffe56af969	1294	/// @param[in] y1 is the vertical start of the line.
WiredHome	72:ecffe56af969	1295	/// @param[in] x2 is the horizontal end of the line.
WiredHome	72:ecffe56af969	1296	/// @param[in] y2 is the vertical end of the line.
WiredHome	72:ecffe56af969	1297	/// @param[in] color defines the foreground color.
WiredHome	81:01da2e34283d	1298	/// @param[in] fillit is optional to FILL the rectangle. default is FILL.
WiredHome	19:3f82c1161fd2	1299	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1300	///
WiredHome	37:f19b7e7449dc	1301	RetCode_t rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	19:3f82c1161fd2	1302	color_t color, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	1303
WiredHome	19:3f82c1161fd2	1304	/// Draw a filled rectangle in the specified color
WiredHome	19:3f82c1161fd2	1305	///
WiredHome	19:3f82c1161fd2	1306	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	1307	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	1308	///
WiredHome	72:ecffe56af969	1309	/// @param[in] x1 is the horizontal start of the line.
WiredHome	72:ecffe56af969	1310	/// @param[in] y1 is the vertical start of the line.
WiredHome	72:ecffe56af969	1311	/// @param[in] x2 is the horizontal end of the line.
WiredHome	72:ecffe56af969	1312	/// @param[in] y2 is the vertical end of the line.
WiredHome	72:ecffe56af969	1313	/// @param[in] color defines the foreground color.
WiredHome	72:ecffe56af969	1314	/// @param[in] fillit is optional to NOFILL the rectangle. default is FILL.
WiredHome	19:3f82c1161fd2	1315	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1316	///
WiredHome	37:f19b7e7449dc	1317	virtual RetCode_t fillrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	19:3f82c1161fd2	1318	color_t color, fill_t fillit = FILL);
WiredHome	19:3f82c1161fd2	1319
WiredHome	19:3f82c1161fd2	1320	/// Draw a rectangle
WiredHome	19:3f82c1161fd2	1321	///
WiredHome	19:3f82c1161fd2	1322	/// Draws a rectangle using the foreground color setting.
WiredHome	19:3f82c1161fd2	1323	///
WiredHome	72:ecffe56af969	1324	/// @param[in] x1 is the horizontal start of the line.
WiredHome	72:ecffe56af969	1325	/// @param[in] y1 is the vertical start of the line.
WiredHome	72:ecffe56af969	1326	/// @param[in] x2 is the horizontal end of the line.
WiredHome	72:ecffe56af969	1327	/// @param[in] y2 is the vertical end of the line.
WiredHome	72:ecffe56af969	1328	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	19:3f82c1161fd2	1329	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1330	///
WiredHome	37:f19b7e7449dc	1331	RetCode_t rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	19:3f82c1161fd2	1332	fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	1333
WiredHome	19:3f82c1161fd2	1334	/// Draw a filled rectangle with rounded corners using the specified color.
WiredHome	19:3f82c1161fd2	1335	///
WiredHome	21:3c1efb192927	1336	/// This draws a rounded rectangle. A numbers of checks are made on the values,
WiredHome	21:3c1efb192927	1337	/// and it could reduce this to drawing a line (if either x1 == x2, or y1 == y2),
WiredHome	21:3c1efb192927	1338	/// or a single point (x1 == x2 && y1 == y2). If the radius parameters are
WiredHome	21:3c1efb192927	1339	/// > 1/2 the length of that side (width or height), an error value is returned.
WiredHome	21:3c1efb192927	1340	///
WiredHome	19:3f82c1161fd2	1341	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	1342	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	1343	///
WiredHome	72:ecffe56af969	1344	/// @param[in] x1 is the horizontal start of the line and must be <= x2.
WiredHome	72:ecffe56af969	1345	/// @param[in] y1 is the vertical start of the line and must be <= y2.
WiredHome	72:ecffe56af969	1346	/// @param[in] x2 is the horizontal end of the line and must be >= x1.
WiredHome	72:ecffe56af969	1347	/// @param[in] y2 is the vertical end of the line and must be >= y1.
WiredHome	72:ecffe56af969	1348	/// @param[in] radius1 defines the horizontal radius of the curved corner. Take care
WiredHome	21:3c1efb192927	1349	/// that this value < 1/2 the width of the rectangle, or bad_parameter
WiredHome	21:3c1efb192927	1350	/// is returned.
WiredHome	72:ecffe56af969	1351	/// @param[in] radius2 defines the vertical radius of the curved corner. Take care
WiredHome	21:3c1efb192927	1352	/// that this value < 1/2 the height of the rectangle, or bad_parameter
WiredHome	21:3c1efb192927	1353	/// is returned.
WiredHome	72:ecffe56af969	1354	/// @param[in] color defines the foreground color.
WiredHome	72:ecffe56af969	1355	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	19:3f82c1161fd2	1356	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1357	///
WiredHome	37:f19b7e7449dc	1358	RetCode_t fillroundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	37:f19b7e7449dc	1359	dim_t radius1, dim_t radius2, color_t color, fill_t fillit = FILL);
WiredHome	19:3f82c1161fd2	1360
WiredHome	19:3f82c1161fd2	1361	/// Draw a rectangle with rounded corners using the specified color.
WiredHome	19:3f82c1161fd2	1362	///
WiredHome	21:3c1efb192927	1363	/// This draws a rounded rectangle. A numbers of checks are made on the values,
WiredHome	21:3c1efb192927	1364	/// and it could reduce this to drawing a line (if either x1 == x2, or y1 == y2),
WiredHome	21:3c1efb192927	1365	/// or a single point (x1 == x2 && y1 == y2). If the radius parameters are
WiredHome	21:3c1efb192927	1366	/// > 1/2 the length of that side (width or height), an error value is returned.
WiredHome	21:3c1efb192927	1367	///
WiredHome	19:3f82c1161fd2	1368	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	1369	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	1370	///
WiredHome	72:ecffe56af969	1371	/// @param[in] x1 is the horizontal start of the line and must be <= x2.
WiredHome	72:ecffe56af969	1372	/// @param[in] y1 is the vertical start of the line and must be <= y2.
WiredHome	72:ecffe56af969	1373	/// @param[in] x2 is the horizontal end of the line and must be >= x1.
WiredHome	72:ecffe56af969	1374	/// @param[in] y2 is the vertical end of the line and must be >= y1.
WiredHome	72:ecffe56af969	1375	/// @param[in] radius1 defines the horizontal radius of the curved corner. Take care
WiredHome	21:3c1efb192927	1376	/// that this value < 1/2 the width of the rectangle, or bad_parameter
WiredHome	21:3c1efb192927	1377	/// is returned.
WiredHome	72:ecffe56af969	1378	/// @param[in] radius2 defines the vertical radius of the curved corner. Take care
WiredHome	21:3c1efb192927	1379	/// that this value < 1/2 the height of the rectangle, or bad_parameter
WiredHome	21:3c1efb192927	1380	/// is returned.
WiredHome	72:ecffe56af969	1381	/// @param[in] color defines the foreground color.
WiredHome	72:ecffe56af969	1382	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	19:3f82c1161fd2	1383	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1384	///
WiredHome	37:f19b7e7449dc	1385	RetCode_t roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	37:f19b7e7449dc	1386	dim_t radius1, dim_t radius2, color_t color, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	1387
WiredHome	19:3f82c1161fd2	1388	/// Draw a rectangle with rounded corners.
WiredHome	19:3f82c1161fd2	1389	///
WiredHome	21:3c1efb192927	1390	/// This draws a rounded rectangle. A numbers of checks are made on the values,
WiredHome	21:3c1efb192927	1391	/// and it could reduce this to drawing a line (if either x1 == x2, or y1 == y2),
WiredHome	21:3c1efb192927	1392	/// or a single point (x1 == x2 && y1 == y2). If the radius parameters are
WiredHome	21:3c1efb192927	1393	/// > 1/2 the length of that side (width or height), an error value is returned.
WiredHome	19:3f82c1161fd2	1394	///
WiredHome	72:ecffe56af969	1395	/// @param[in] x1 is the horizontal start of the line and must be <= x2.
WiredHome	72:ecffe56af969	1396	/// @param[in] y1 is the vertical start of the line and must be <= y2.
WiredHome	72:ecffe56af969	1397	/// @param[in] x2 is the horizontal end of the line and must be >= x1.
WiredHome	72:ecffe56af969	1398	/// @param[in] y2 is the vertical end of the line and must be >= y1.
WiredHome	72:ecffe56af969	1399	/// @param[in] radius1 defines the horizontal radius of the curved corner. Take care
WiredHome	21:3c1efb192927	1400	/// that this value < 1/2 the width of the rectangle, or bad_parameter
WiredHome	21:3c1efb192927	1401	/// is returned.
WiredHome	72:ecffe56af969	1402	/// @param[in] radius2 defines the vertical radius of the curved corner. Take care
WiredHome	21:3c1efb192927	1403	/// that this value < 1/2 the height of the rectangle, or bad_parameter
WiredHome	21:3c1efb192927	1404	/// is returned.
WiredHome	72:ecffe56af969	1405	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	19:3f82c1161fd2	1406	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1407	///
WiredHome	37:f19b7e7449dc	1408	RetCode_t roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	37:f19b7e7449dc	1409	dim_t radius1, dim_t radius2, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	1410
WiredHome	19:3f82c1161fd2	1411	/// Draw a triangle in the specified color.
WiredHome	19:3f82c1161fd2	1412	///
WiredHome	19:3f82c1161fd2	1413	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	1414	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	1415	///
WiredHome	72:ecffe56af969	1416	/// @param[in] x1 is the horizontal for point 1.
WiredHome	72:ecffe56af969	1417	/// @param[in] y1 is the vertical for point 1.
WiredHome	72:ecffe56af969	1418	/// @param[in] x2 is the horizontal for point 2.
WiredHome	72:ecffe56af969	1419	/// @param[in] y2 is the vertical for point 2.
WiredHome	72:ecffe56af969	1420	/// @param[in] x3 is the horizontal for point 3.
WiredHome	72:ecffe56af969	1421	/// @param[in] y3 is the vertical for point 3.
WiredHome	72:ecffe56af969	1422	/// @param[in] color defines the foreground color.
WiredHome	72:ecffe56af969	1423	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	19:3f82c1161fd2	1424	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1425	///
WiredHome	37:f19b7e7449dc	1426	RetCode_t triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	37:f19b7e7449dc	1427	loc_t x3, loc_t y3, color_t color, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	1428
WiredHome	19:3f82c1161fd2	1429	/// Draw a filled triangle in the specified color.
WiredHome	19:3f82c1161fd2	1430	///
WiredHome	19:3f82c1161fd2	1431	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	1432	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	1433	///
WiredHome	72:ecffe56af969	1434	/// @param[in] x1 is the horizontal for point 1.
WiredHome	72:ecffe56af969	1435	/// @param[in] y1 is the vertical for point 1.
WiredHome	72:ecffe56af969	1436	/// @param[in] x2 is the horizontal for point 2.
WiredHome	72:ecffe56af969	1437	/// @param[in] y2 is the vertical for point 2.
WiredHome	72:ecffe56af969	1438	/// @param[in] x3 is the horizontal for point 3.
WiredHome	72:ecffe56af969	1439	/// @param[in] y3 is the vertical for point 3.
WiredHome	72:ecffe56af969	1440	/// @param[in] color defines the foreground color.
WiredHome	72:ecffe56af969	1441	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	19:3f82c1161fd2	1442	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1443	///
WiredHome	37:f19b7e7449dc	1444	RetCode_t filltriangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	37:f19b7e7449dc	1445	loc_t x3, loc_t y3, color_t color, fill_t fillit = FILL);
WiredHome	19:3f82c1161fd2	1446
WiredHome	19:3f82c1161fd2	1447	/// Draw a triangle
WiredHome	19:3f82c1161fd2	1448	///
WiredHome	19:3f82c1161fd2	1449	/// Draws a triangle using the foreground color setting.
WiredHome	19:3f82c1161fd2	1450	///
WiredHome	72:ecffe56af969	1451	/// @param[in] x1 is the horizontal for point 1.
WiredHome	72:ecffe56af969	1452	/// @param[in] y1 is the vertical for point 1.
WiredHome	72:ecffe56af969	1453	/// @param[in] x2 is the horizontal for point 2.
WiredHome	72:ecffe56af969	1454	/// @param[in] y2 is the vertical for point 2.
WiredHome	72:ecffe56af969	1455	/// @param[in] x3 is the horizontal for point 3.
WiredHome	72:ecffe56af969	1456	/// @param[in] y3 is the vertical for point 3.
WiredHome	72:ecffe56af969	1457	/// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome	19:3f82c1161fd2	1458	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1459	///
WiredHome	37:f19b7e7449dc	1460	RetCode_t triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome	37:f19b7e7449dc	1461	loc_t x3, loc_t y3, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	1462
WiredHome	83:7bad0068cca0	1463
WiredHome	83:7bad0068cca0	1464	/// Draw a circle using the specified color.
WiredHome	83:7bad0068cca0	1465	///
WiredHome	83:7bad0068cca0	1466	/// @note As a side effect, this changes the current
WiredHome	83:7bad0068cca0	1467	/// foreground color for subsequent operations.
WiredHome	83:7bad0068cca0	1468	///
WiredHome	83:7bad0068cca0	1469	/// @param[in] p defines the center of the circle.
WiredHome	83:7bad0068cca0	1470	/// @param[in] radius defines the size of the circle.
WiredHome	83:7bad0068cca0	1471	/// @param[in] color defines the foreground color.
WiredHome	83:7bad0068cca0	1472	/// @returns success/failure code. @see RetCode_t.
WiredHome	83:7bad0068cca0	1473	///
WiredHome	83:7bad0068cca0	1474	RetCode_t circle(point_t p, dim_t radius, color_t color, fill_t fillit = NOFILL);
WiredHome	83:7bad0068cca0	1475
WiredHome	83:7bad0068cca0	1476	/// Draw a filled circle using the specified color.
WiredHome	83:7bad0068cca0	1477	///
WiredHome	83:7bad0068cca0	1478	/// @note As a side effect, this changes the current
WiredHome	83:7bad0068cca0	1479	/// foreground color for subsequent operations.
WiredHome	83:7bad0068cca0	1480	///
WiredHome	83:7bad0068cca0	1481	/// @param[in] p defines the center of the circle.
WiredHome	83:7bad0068cca0	1482	/// @param[in] radius defines the size of the circle.
WiredHome	83:7bad0068cca0	1483	/// @param[in] color defines the foreground color.
WiredHome	83:7bad0068cca0	1484	/// @returns success/failure code. @see RetCode_t.
WiredHome	83:7bad0068cca0	1485	///
WiredHome	83:7bad0068cca0	1486	RetCode_t fillcircle(point_t p, dim_t radius, color_t color, fill_t fillit = FILL);
WiredHome	83:7bad0068cca0	1487
WiredHome	83:7bad0068cca0	1488	/// Draw a circle.
WiredHome	83:7bad0068cca0	1489	///
WiredHome	83:7bad0068cca0	1490	/// Draws a circle using the foreground color setting.
WiredHome	83:7bad0068cca0	1491	///
WiredHome	83:7bad0068cca0	1492	/// @param[in] p defines the center of the circle.
WiredHome	83:7bad0068cca0	1493	/// @param[in] radius defines the size of the circle.
WiredHome	83:7bad0068cca0	1494	/// @returns success/failure code. @see RetCode_t.
WiredHome	83:7bad0068cca0	1495	///
WiredHome	83:7bad0068cca0	1496	RetCode_t circle(point_t p, dim_t radius, fill_t fillit = NOFILL);
WiredHome	83:7bad0068cca0	1497
WiredHome	19:3f82c1161fd2	1498	/// Draw a circle using the specified color.
WiredHome	19:3f82c1161fd2	1499	///
WiredHome	19:3f82c1161fd2	1500	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	1501	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	1502	///
WiredHome	72:ecffe56af969	1503	/// @param[in] x is the horizontal center of the circle.
WiredHome	72:ecffe56af969	1504	/// @param[in] y is the vertical center of the circle.
WiredHome	72:ecffe56af969	1505	/// @param[in] radius defines the size of the circle.
WiredHome	72:ecffe56af969	1506	/// @param[in] color defines the foreground color.
WiredHome	19:3f82c1161fd2	1507	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1508	///
WiredHome	37:f19b7e7449dc	1509	RetCode_t circle(loc_t x, loc_t y, dim_t radius, color_t color, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	1510
WiredHome	19:3f82c1161fd2	1511	/// Draw a filled circle using the specified color.
WiredHome	19:3f82c1161fd2	1512	///
WiredHome	19:3f82c1161fd2	1513	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	1514	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	1515	///
WiredHome	72:ecffe56af969	1516	/// @param[in] x is the horizontal center of the circle.
WiredHome	72:ecffe56af969	1517	/// @param[in] y is the vertical center of the circle.
WiredHome	72:ecffe56af969	1518	/// @param[in] radius defines the size of the circle.
WiredHome	72:ecffe56af969	1519	/// @param[in] color defines the foreground color.
WiredHome	19:3f82c1161fd2	1520	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1521	///
WiredHome	37:f19b7e7449dc	1522	RetCode_t fillcircle(loc_t x, loc_t y, dim_t radius, color_t color, fill_t fillit = FILL);
WiredHome	19:3f82c1161fd2	1523
WiredHome	19:3f82c1161fd2	1524	/// Draw a circle.
WiredHome	19:3f82c1161fd2	1525	///
WiredHome	19:3f82c1161fd2	1526	/// Draws a circle using the foreground color setting.
WiredHome	19:3f82c1161fd2	1527	///
WiredHome	72:ecffe56af969	1528	/// @param[in] x is the horizontal center of the circle.
WiredHome	72:ecffe56af969	1529	/// @param[in] y is the vertical center of the circle.
WiredHome	72:ecffe56af969	1530	/// @param[in] radius defines the size of the circle.
WiredHome	19:3f82c1161fd2	1531	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1532	///
WiredHome	37:f19b7e7449dc	1533	RetCode_t circle(loc_t x, loc_t y, dim_t radius, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	1534
WiredHome	19:3f82c1161fd2	1535	/// Draw an Ellipse using the specified color
WiredHome	19:3f82c1161fd2	1536	///
WiredHome	19:3f82c1161fd2	1537	/// @note As a side effect, this changes the current
WiredHome	19:3f82c1161fd2	1538	/// foreground color for subsequent operations.
WiredHome	19:3f82c1161fd2	1539	///
WiredHome	72:ecffe56af969	1540	/// @param[in] x is the horizontal center of the ellipse.
WiredHome	72:ecffe56af969	1541	/// @param[in] y is the vertical center of the ellipse.
WiredHome	72:ecffe56af969	1542	/// @param[in] radius1 defines the horizontal radius of the ellipse.
WiredHome	72:ecffe56af969	1543	/// @param[in] radius2 defines the vertical radius of the ellipse.
WiredHome	72:ecffe56af969	1544	/// @param[in] color defines the foreground color.
WiredHome	72:ecffe56af969	1545	/// @param[in] fillit defines whether the circle is filled or not.
WiredHome	19:3f82c1161fd2	1546	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1547	///
WiredHome	37:f19b7e7449dc	1548	RetCode_t ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2,
WiredHome	19:3f82c1161fd2	1549	color_t color, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	1550
WiredHome	25:9556a3a9b7cc	1551	/// Draw a filled Ellipse using the specified color
WiredHome	25:9556a3a9b7cc	1552	///
WiredHome	25:9556a3a9b7cc	1553	/// @note As a side effect, this changes the current
WiredHome	25:9556a3a9b7cc	1554	/// foreground color for subsequent operations.
WiredHome	25:9556a3a9b7cc	1555	///
WiredHome	72:ecffe56af969	1556	/// @param[in] x is the horizontal center of the ellipse.
WiredHome	72:ecffe56af969	1557	/// @param[in] y is the vertical center of the ellipse.
WiredHome	72:ecffe56af969	1558	/// @param[in] radius1 defines the horizontal radius of the ellipse.
WiredHome	72:ecffe56af969	1559	/// @param[in] radius2 defines the vertical radius of the ellipse.
WiredHome	72:ecffe56af969	1560	/// @param[in] color defines the foreground color.
WiredHome	72:ecffe56af969	1561	/// @param[in] fillit defines whether the circle is filled or not.
WiredHome	25:9556a3a9b7cc	1562	/// @returns success/failure code. @see RetCode_t.
WiredHome	25:9556a3a9b7cc	1563	///
WiredHome	37:f19b7e7449dc	1564	RetCode_t fillellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2,
WiredHome	25:9556a3a9b7cc	1565	color_t color, fill_t fillit = FILL);
WiredHome	25:9556a3a9b7cc	1566
WiredHome	19:3f82c1161fd2	1567	/// Draw an Ellipse
WiredHome	19:3f82c1161fd2	1568	///
WiredHome	19:3f82c1161fd2	1569	/// Draws it using the foreground color setting.
WiredHome	19:3f82c1161fd2	1570	///
WiredHome	72:ecffe56af969	1571	/// @param[in] x is the horizontal center of the ellipse.
WiredHome	72:ecffe56af969	1572	/// @param[in] y is the vertical center of the ellipse.
WiredHome	72:ecffe56af969	1573	/// @param[in] radius1 defines the horizontal radius of the ellipse.
WiredHome	72:ecffe56af969	1574	/// @param[in] radius2 defines the vertical radius of the ellipse.
WiredHome	72:ecffe56af969	1575	/// @param[in] fillit defines whether the circle is filled or not.
WiredHome	19:3f82c1161fd2	1576	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1577	///
WiredHome	37:f19b7e7449dc	1578	RetCode_t ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, fill_t fillit = NOFILL);
WiredHome	19:3f82c1161fd2	1579
WiredHome	19:3f82c1161fd2	1580	/// Control display power
WiredHome	19:3f82c1161fd2	1581	///
WiredHome	72:ecffe56af969	1582	/// @param[in] on when set to true will turn on the display, when false it is turned off.
WiredHome	19:3f82c1161fd2	1583	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1584	///
WiredHome	19:3f82c1161fd2	1585	RetCode_t Power(bool on);
WiredHome	19:3f82c1161fd2	1586
WiredHome	19:3f82c1161fd2	1587	/// Reset the display controller via the Software Reset interface.
WiredHome	19:3f82c1161fd2	1588	///
WiredHome	19:3f82c1161fd2	1589	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1590	///
WiredHome	19:3f82c1161fd2	1591	RetCode_t Reset(void);
WiredHome	19:3f82c1161fd2	1592
WiredHome	19:3f82c1161fd2	1593	/// Set backlight brightness.
WiredHome	19:3f82c1161fd2	1594	///
WiredHome	19:3f82c1161fd2	1595	/// When the built-in PWM is used to control the backlight, this
WiredHome	19:3f82c1161fd2	1596	/// API can be used to set the brightness.
WiredHome	19:3f82c1161fd2	1597	///
WiredHome	72:ecffe56af969	1598	/// @param[in] brightness ranges from 0 (off) to 255 (full on)
WiredHome	19:3f82c1161fd2	1599	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1600	///
WiredHome	19:3f82c1161fd2	1601	RetCode_t Backlight_u8(unsigned char brightness);
WiredHome	19:3f82c1161fd2	1602
WiredHome	19:3f82c1161fd2	1603	/// Set backlight brightness.
WiredHome	19:3f82c1161fd2	1604	///
WiredHome	19:3f82c1161fd2	1605	/// When the built-in PWM is used to control the backlight, this
WiredHome	19:3f82c1161fd2	1606	/// API can be used to set the brightness.
WiredHome	19:3f82c1161fd2	1607	///
WiredHome	72:ecffe56af969	1608	/// @param[in] brightness ranges from 0.0 (off) to 1.0 (full on)
WiredHome	19:3f82c1161fd2	1609	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1610	///
WiredHome	19:3f82c1161fd2	1611	RetCode_t Backlight(float brightness);
WiredHome	19:3f82c1161fd2	1612
WiredHome	32:0e4f2ae512e2	1613	/// Select a bitmap font (provided by the user) for all subsequent text.
WiredHome	19:3f82c1161fd2	1614	///
WiredHome	19:3f82c1161fd2	1615	/// @note Tool to create the fonts is accessible from its creator
WiredHome	19:3f82c1161fd2	1616	/// available at http://www.mikroe.com.
WiredHome	19:3f82c1161fd2	1617	/// Change the data to an array of type char[].
WiredHome	19:3f82c1161fd2	1618	///
WiredHome	72:ecffe56af969	1619	/// @param[in] font is a pointer to a specially formed font array.
WiredHome	19:3f82c1161fd2	1620	/// This special font array has a 4-byte header, followed by
WiredHome	19:3f82c1161fd2	1621	/// the data:
WiredHome	19:3f82c1161fd2	1622	/// - the number of bytes per char
WiredHome	19:3f82c1161fd2	1623	/// - the vertical size in pixels for each character
WiredHome	19:3f82c1161fd2	1624	/// - the horizontal size in pixels for each character
WiredHome	19:3f82c1161fd2	1625	/// - the number of bytes per vertical line (width of the array)
WiredHome	19:3f82c1161fd2	1626	/// @returns error code.
WiredHome	19:3f82c1161fd2	1627	///
WiredHome	30:e0f2da88bdf6	1628	virtual RetCode_t set_font(const unsigned char * font = NULL);
WiredHome	19:3f82c1161fd2	1629
WiredHome	19:3f82c1161fd2	1630	/// Get the RGB value for a DOS color.
WiredHome	19:3f82c1161fd2	1631	///
WiredHome	72:ecffe56af969	1632	/// @param[in] i is the color, in the range 0 to 15;
WiredHome	19:3f82c1161fd2	1633	/// @returns the RGB color of the selected index, or 0
WiredHome	19:3f82c1161fd2	1634	/// if the index is out of bounds.
WiredHome	19:3f82c1161fd2	1635	///
WiredHome	19:3f82c1161fd2	1636	color_t DOSColor(int i);
WiredHome	19:3f82c1161fd2	1637
WiredHome	19:3f82c1161fd2	1638	/// Get the color name (string) for a DOS color.
WiredHome	19:3f82c1161fd2	1639	///
WiredHome	72:ecffe56af969	1640	/// @param[in] i is the color, in the range 0 to 15;
WiredHome	19:3f82c1161fd2	1641	/// @returns a pointer to a string with the color name,
WiredHome	19:3f82c1161fd2	1642	/// or NULL if the index is out of bounds.
WiredHome	19:3f82c1161fd2	1643	///
WiredHome	19:3f82c1161fd2	1644	const char * DOSColorNames(int i);
WiredHome	19:3f82c1161fd2	1645
WiredHome	55:dfbabef7003e	1646	/// Advanced method indicating the start of a graphics stream.
WiredHome	55:dfbabef7003e	1647	///
WiredHome	55:dfbabef7003e	1648	/// This is called prior to a stream of pixel data being sent.
WiredHome	55:dfbabef7003e	1649	/// This may cause register configuration changes in the derived
WiredHome	55:dfbabef7003e	1650	/// class in order to prepare the hardware to accept the streaming
WiredHome	55:dfbabef7003e	1651	/// data.
WiredHome	55:dfbabef7003e	1652	///
WiredHome	55:dfbabef7003e	1653	/// Following this command, a series of @see _putp() commands can
WiredHome	55:dfbabef7003e	1654	/// be used to send individual pixels to the screen.
WiredHome	55:dfbabef7003e	1655	///
WiredHome	55:dfbabef7003e	1656	/// To conclude the graphics stream, @see _EndGraphicsStream should
WiredHome	55:dfbabef7003e	1657	/// be callled.
WiredHome	55:dfbabef7003e	1658	///
WiredHome	55:dfbabef7003e	1659	/// @returns error code.
WiredHome	55:dfbabef7003e	1660	///
WiredHome	55:dfbabef7003e	1661	virtual RetCode_t _StartGraphicsStream(void);
WiredHome	55:dfbabef7003e	1662
WiredHome	55:dfbabef7003e	1663	/// Advanced method to put a single color pixel to the screen.
WiredHome	55:dfbabef7003e	1664	///
WiredHome	55:dfbabef7003e	1665	/// This method may be called as many times as necessary after
WiredHome	55:dfbabef7003e	1666	/// @see _StartGraphicsStream() is called, and it should be followed
WiredHome	55:dfbabef7003e	1667	/// by _EndGraphicsStream.
WiredHome	55:dfbabef7003e	1668	///
WiredHome	72:ecffe56af969	1669	/// @param[in] pixel is a color value to be put on the screen.
WiredHome	55:dfbabef7003e	1670	/// @returns error code.
WiredHome	55:dfbabef7003e	1671	///
WiredHome	55:dfbabef7003e	1672	virtual RetCode_t _putp(color_t pixel);
WiredHome	55:dfbabef7003e	1673
WiredHome	55:dfbabef7003e	1674	/// Advanced method indicating the end of a graphics stream.
WiredHome	55:dfbabef7003e	1675	///
WiredHome	55:dfbabef7003e	1676	/// This is called to conclude a stream of pixel data that was sent.
WiredHome	55:dfbabef7003e	1677	/// This may cause register configuration changes in the derived
WiredHome	55:dfbabef7003e	1678	/// class in order to stop the hardware from accept the streaming
WiredHome	55:dfbabef7003e	1679	/// data.
WiredHome	55:dfbabef7003e	1680	///
WiredHome	55:dfbabef7003e	1681	/// @returns error code.
WiredHome	55:dfbabef7003e	1682	///
WiredHome	55:dfbabef7003e	1683	virtual RetCode_t _EndGraphicsStream(void);
WiredHome	19:3f82c1161fd2	1684
WiredHome	57:bd53a9e165a1	1685	/// Set the SPI port frequency (in Hz).
WiredHome	57:bd53a9e165a1	1686	///
WiredHome	66:468a11f05580	1687	/// This uses the mbed SPI driver, and is therefore dependent on
WiredHome	66:468a11f05580	1688	/// its capabilities. The RA8875 can accept writes via SPI faster
WiredHome	66:468a11f05580	1689	/// than a read can be performed. The frequency set by this API
WiredHome	66:468a11f05580	1690	/// is for the SPI writes. It will automatically reduce the SPI
WiredHome	66:468a11f05580	1691	/// clock rate when a read is performed, and restore it for the
WiredHome	68:ab08efabfc88	1692	/// next write. Alternately, the 2nd parameters permits setting
WiredHome	68:ab08efabfc88	1693	/// the read speed rather than letting it compute it automatically.
WiredHome	57:bd53a9e165a1	1694	///
WiredHome	66:468a11f05580	1695	/// @note The primary effect of this is to recover more CPU cycles
WiredHome	66:468a11f05580	1696	/// for your application code. Keep in mind that when more than
WiredHome	66:468a11f05580	1697	/// one command is sent to the display controller, that it
WiredHome	66:468a11f05580	1698	/// will wait for the controller to finish the prior command.
WiredHome	66:468a11f05580	1699	/// In this case, the performance is limited by the RA8875.
WiredHome	57:bd53a9e165a1	1700	///
WiredHome	72:ecffe56af969	1701	/// @param[in] Hz is the frequency in Hz, tested range includes the
WiredHome	66:468a11f05580	1702	/// range from 1,000,000 (1MHz) to 10,000,000 (10 MHz). Values
WiredHome	66:468a11f05580	1703	/// outside this range will be accepted, but operation may
WiredHome	76:c981284eb513	1704	/// be unreliable. This depends partially on your hardware design
WiredHome	76:c981284eb513	1705	/// and the wires connecting the display module.
WiredHome	76:c981284eb513	1706	/// The default value is 5,000,000, which should work for most
WiredHome	76:c981284eb513	1707	/// applications as a starting point.
WiredHome	72:ecffe56af969	1708	/// @param[in] Hz2 is an optional parameter and will set the read
WiredHome	68:ab08efabfc88	1709	/// speed independently of the write speed.
WiredHome	57:bd53a9e165a1	1710	/// @returns success/failure code. @see RetCode_t.
WiredHome	57:bd53a9e165a1	1711	///
WiredHome	68:ab08efabfc88	1712	RetCode_t frequency(unsigned long Hz = RA8875_DEFAULT_SPI_FREQ, unsigned long Hz2 = 0);
WiredHome	57:bd53a9e165a1	1713
WiredHome	72:ecffe56af969	1714	/// This method captures the specified area as a 24-bit bitmap file.
WiredHome	72:ecffe56af969	1715	///
WiredHome	72:ecffe56af969	1716	/// Even though this is a 16-bit display, the stored image is in
WiredHome	72:ecffe56af969	1717	/// 24-bit format.
WiredHome	72:ecffe56af969	1718	///
WiredHome	73:f22a18707b5e	1719	/// This method will interrogate the current display setting and
WiredHome	73:f22a18707b5e	1720	/// create a bitmap based on those settings. For instance, if
WiredHome	73:f22a18707b5e	1721	/// only layer 1 is visible, then the bitmap is only layer 1. However,
WiredHome	73:f22a18707b5e	1722	/// if there is some other operation in effect (transparent mode).
WiredHome	73:f22a18707b5e	1723	///
WiredHome	72:ecffe56af969	1724	/// @param[in] x is the left edge of the region to capture
WiredHome	72:ecffe56af969	1725	/// @param[in] y is the top edge of the region to capture
WiredHome	72:ecffe56af969	1726	/// @param[in] w is the width of the region to capture
WiredHome	72:ecffe56af969	1727	/// @param[in] h is the height of the region to capture.
WiredHome	72:ecffe56af969	1728	/// @param[out] Name_BMP is the filename to write the image to.
WiredHome	72:ecffe56af969	1729	/// @return success or error code.
WiredHome	72:ecffe56af969	1730	///
WiredHome	72:ecffe56af969	1731	RetCode_t PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP);
WiredHome	72:ecffe56af969	1732
WiredHome	72:ecffe56af969	1733	/// This method captures the specified area as a 24-bit bitmap file,
WiredHome	72:ecffe56af969	1734	/// including the option of layer selection.
WiredHome	72:ecffe56af969	1735	///
WiredHome	74:686faa218914	1736	/// @caution This method is deprecated as the alternate PrintScreen API
WiredHome	74:686faa218914	1737	/// automatically examines the display layer configuration.
WiredHome	74:686faa218914	1738	/// Therefore, calls to this API will ignore the layer parameter
WiredHome	74:686faa218914	1739	/// and automatically execute the other method.
WiredHome	74:686faa218914	1740	///
WiredHome	72:ecffe56af969	1741	/// Even though this is a 16-bit display, the stored image is in
WiredHome	72:ecffe56af969	1742	/// 24-bit format.
WiredHome	72:ecffe56af969	1743	///
WiredHome	72:ecffe56af969	1744	/// @param[in] layer is 0 or 1 to select the layer to extract.
WiredHome	72:ecffe56af969	1745	/// @param[in] x is the left edge of the region to capture
WiredHome	72:ecffe56af969	1746	/// @param[in] y is the top edge of the region to capture
WiredHome	72:ecffe56af969	1747	/// @param[in] w is the width of the region to capture
WiredHome	72:ecffe56af969	1748	/// @param[in] h is the height of the region to capture.
WiredHome	72:ecffe56af969	1749	/// @param[out] Name_BMP is the filename to write the image to.
WiredHome	72:ecffe56af969	1750	/// @return success or error code.
WiredHome	72:ecffe56af969	1751	///
WiredHome	72:ecffe56af969	1752	RetCode_t PrintScreen(uint16_t layer, loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP);
WiredHome	72:ecffe56af969	1753
WiredHome	57:bd53a9e165a1	1754
WiredHome	19:3f82c1161fd2	1755	#ifdef PERF_METRICS
WiredHome	19:3f82c1161fd2	1756	/// Clear the performance metrics to zero.
WiredHome	19:3f82c1161fd2	1757	void ClearPerformance();
WiredHome	19:3f82c1161fd2	1758
WiredHome	66:468a11f05580	1759	/// Count idle time.
WiredHome	66:468a11f05580	1760	///
WiredHome	72:ecffe56af969	1761	/// @param[in] t is the amount of idle time to accumulate.
WiredHome	66:468a11f05580	1762	///
WiredHome	66:468a11f05580	1763	void CountIdleTime(uint32_t t);
WiredHome	66:468a11f05580	1764
WiredHome	19:3f82c1161fd2	1765	/// Report the performance metrics for drawing functions using
WiredHome	41:2956a0a221e5	1766	/// the available serial channel.
WiredHome	41:2956a0a221e5	1767	///
WiredHome	72:ecffe56af969	1768	/// @param[in,out] pc is the serial channel to write to.
WiredHome	41:2956a0a221e5	1769	///
WiredHome	41:2956a0a221e5	1770	void ReportPerformance(Serial & pc);
WiredHome	19:3f82c1161fd2	1771	#endif
WiredHome	19:3f82c1161fd2	1772
hexley	54:e117ad10fba6	1773
WiredHome	19:3f82c1161fd2	1774	private:
hexley	54:e117ad10fba6	1775	/// Touch Panel register name definitions
WiredHome	77:9206c13aa527	1776	#define TPCR0 0x70
WiredHome	77:9206c13aa527	1777	#define TPCR1 0x71
WiredHome	77:9206c13aa527	1778	#define TPXH 0x72
WiredHome	77:9206c13aa527	1779	#define TPYH 0x73
WiredHome	77:9206c13aa527	1780	#define TPXYL 0x74
WiredHome	77:9206c13aa527	1781	#define INTC1 0xF0
WiredHome	77:9206c13aa527	1782	#define INTC2 0xF1
hexley	54:e117ad10fba6	1783
hexley	54:e117ad10fba6	1784	/// Specify the default settings for the Touch Panel, where different from the chip defaults
WiredHome	77:9206c13aa527	1785	#define TP_MODE_DEFAULT TP_MODE_AUTO
WiredHome	77:9206c13aa527	1786	#define TP_DEBOUNCE_DEFAULT TP_DEBOUNCE_ON
WiredHome	77:9206c13aa527	1787	#define TP_ADC_CLKDIV_DEFAULT TP_ADC_CLKDIV_8
hexley	54:e117ad10fba6	1788
WiredHome	77:9206c13aa527	1789	#define TP_ADC_SAMPLE_DEFAULT_CLKS TP_ADC_SAMPLE_8192_CLKS
hexley	54:e117ad10fba6	1790
hexley	54:e117ad10fba6	1791	/// Other Touch Panel params
WiredHome	77:9206c13aa527	1792	#define TPBUFSIZE 16 // Depth of the averaging buffers for x and y data
hexley	54:e117ad10fba6	1793
WiredHome	83:7bad0068cca0	1794	// Needs both a ticker and a timer. (could have created a timer from the ticker, but this is easier).
WiredHome	83:7bad0068cca0	1795	// on a touch, the timer is reset.
WiredHome	83:7bad0068cca0	1796	// the ticker monitors the timer to see if it has been a long time since
WiredHome	83:7bad0068cca0	1797	// a touch, and if so, it then clears the sample counter so it doesn't get partial old
WiredHome	83:7bad0068cca0	1798	// and partial new.
WiredHome	83:7bad0068cca0	1799
WiredHome	83:7bad0068cca0	1800	/// Touch State used by TouchPanelReadable. @see TouchCode_t.
WiredHome	83:7bad0068cca0	1801	TouchCode_t touchState;
WiredHome	83:7bad0068cca0	1802
WiredHome	83:7bad0068cca0	1803	/// Touch Panel ticker
WiredHome	83:7bad0068cca0	1804	Ticker touchTicker;
WiredHome	83:7bad0068cca0	1805
WiredHome	83:7bad0068cca0	1806	/// Touch Panel timer
WiredHome	83:7bad0068cca0	1807	Timer touchTimer;
WiredHome	83:7bad0068cca0	1808
WiredHome	83:7bad0068cca0	1809	/// keeps track of which sample we're collecting to filter out the noise.
WiredHome	83:7bad0068cca0	1810	int touchSample;
WiredHome	83:7bad0068cca0	1811
WiredHome	83:7bad0068cca0	1812	/// Private function for touch ticker callback.
WiredHome	83:7bad0068cca0	1813	void _TouchTicker(void);
WiredHome	83:7bad0068cca0	1814
WiredHome	77:9206c13aa527	1815	/// Touch Panel calibration matrix.
WiredHome	77:9206c13aa527	1816	tpMatrix_t tpMatrix;
hexley	54:e117ad10fba6	1817
WiredHome	29:422616aa04bd	1818	/// Internal function to put a character using the built-in (internal) font engine
WiredHome	29:422616aa04bd	1819	///
WiredHome	72:ecffe56af969	1820	/// @param[in] is the character to put to the screen.
WiredHome	29:422616aa04bd	1821	/// @returns the character put.
WiredHome	29:422616aa04bd	1822	///
WiredHome	29:422616aa04bd	1823	int _internal_putc(int c);
WiredHome	29:422616aa04bd	1824
WiredHome	29:422616aa04bd	1825	/// Internal function to put a character using the external font engine
WiredHome	29:422616aa04bd	1826	///
WiredHome	72:ecffe56af969	1827	/// @param[in] is the character to put to the screen.
WiredHome	29:422616aa04bd	1828	/// @returns the character put.
WiredHome	29:422616aa04bd	1829	///
WiredHome	29:422616aa04bd	1830	int _external_putc(int c);
WiredHome	29:422616aa04bd	1831
WiredHome	19:3f82c1161fd2	1832	/// Select the peripheral to use it.
WiredHome	19:3f82c1161fd2	1833	///
WiredHome	72:ecffe56af969	1834	/// @param[in] chipsel when true will select the peripheral, and when false
WiredHome	19:3f82c1161fd2	1835	/// will deselect the chip. This is the logical selection, and
WiredHome	19:3f82c1161fd2	1836	/// the pin selection is the invert of this.
WiredHome	19:3f82c1161fd2	1837	/// @returns success/failure code. @see RetCode_t.
WiredHome	19:3f82c1161fd2	1838	///
WiredHome	79:544eb4964795	1839	RetCode_t _select(bool chipsel);
WiredHome	19:3f82c1161fd2	1840
WiredHome	66:468a11f05580	1841	/// Wait while the status register indicates the controller is busy.
WiredHome	66:468a11f05580	1842	///
WiredHome	72:ecffe56af969	1843	/// @param[in] mask is the mask of bits to monitor.
WiredHome	66:468a11f05580	1844	/// @returns true if a normal exit.
WiredHome	66:468a11f05580	1845	/// @returns false if a timeout exit.
WiredHome	66:468a11f05580	1846	///
WiredHome	66:468a11f05580	1847	bool _WaitWhileBusy(uint8_t mask);
WiredHome	66:468a11f05580	1848
WiredHome	66:468a11f05580	1849	/// Wait while the the register anded with the mask is true.
WiredHome	66:468a11f05580	1850	///
WiredHome	72:ecffe56af969	1851	/// @param[in] reg is the register to monitor
WiredHome	72:ecffe56af969	1852	/// @param[in] mask is the bit mask to monitor
WiredHome	66:468a11f05580	1853	/// @returns true if it was a normal exit
WiredHome	66:468a11f05580	1854	/// @returns false if it was a timeout that caused the exit.
WiredHome	66:468a11f05580	1855	///
WiredHome	66:468a11f05580	1856	bool _WaitWhileReg(uint8_t reg, uint8_t mask);
WiredHome	66:468a11f05580	1857
WiredHome	68:ab08efabfc88	1858	/// set the spi port to either the write or the read speed.
WiredHome	68:ab08efabfc88	1859	///
WiredHome	68:ab08efabfc88	1860	/// This is a private API used to toggle between the write
WiredHome	68:ab08efabfc88	1861	/// and the read speed for the SPI port to the RA8875, since
WiredHome	68:ab08efabfc88	1862	/// it can accept writes faster than reads.
WiredHome	68:ab08efabfc88	1863	///
WiredHome	72:ecffe56af969	1864	/// @param[in] writeSpeed when true selects the write frequency,
WiredHome	68:ab08efabfc88	1865	/// and when false it selects the read frequency.
WiredHome	68:ab08efabfc88	1866	///
WiredHome	68:ab08efabfc88	1867	void _setWriteSpeed(bool writeSpeed);
WiredHome	68:ab08efabfc88	1868
WiredHome	19:3f82c1161fd2	1869	/// The most primitive - to write a data value to the SPI interface.
WiredHome	19:3f82c1161fd2	1870	///
WiredHome	72:ecffe56af969	1871	/// @param[in] data is the value to write.
WiredHome	19:3f82c1161fd2	1872	/// @returns a value read from the port, since SPI is often shift
WiredHome	19:3f82c1161fd2	1873	/// in while shifting out.
WiredHome	19:3f82c1161fd2	1874	///
WiredHome	79:544eb4964795	1875	unsigned char _spiwrite(unsigned char data);
WiredHome	19:3f82c1161fd2	1876
WiredHome	19:3f82c1161fd2	1877	/// The most primitive - to read a data value to the SPI interface.
WiredHome	19:3f82c1161fd2	1878	///
WiredHome	19:3f82c1161fd2	1879	/// This is really just a specialcase of the write command, where
WiredHome	19:3f82c1161fd2	1880	/// the value zero is written in order to read.
WiredHome	19:3f82c1161fd2	1881	///
WiredHome	19:3f82c1161fd2	1882	/// @returns a value read from the port, since SPI is often shift
WiredHome	19:3f82c1161fd2	1883	/// in while shifting out.
WiredHome	19:3f82c1161fd2	1884	///
WiredHome	79:544eb4964795	1885	unsigned char _spiread();
WiredHome	19:3f82c1161fd2	1886
WiredHome	75:ca78388cfd77	1887	const uint8_t * pKeyMap;
WiredHome	75:ca78388cfd77	1888
WiredHome	19:3f82c1161fd2	1889	SPI spi; ///< spi port
WiredHome	68:ab08efabfc88	1890	bool spiWriteSpeed; ///< indicates if the current mode is write or read
WiredHome	68:ab08efabfc88	1891	unsigned long spiwritefreq; ///< saved write freq
WiredHome	66:468a11f05580	1892	unsigned long spireadfreq; ///< saved read freq
WiredHome	19:3f82c1161fd2	1893	DigitalOut cs; ///< chip select pin, assumed active low
WiredHome	19:3f82c1161fd2	1894	DigitalOut res; ///< reset pin, assumed active low
WiredHome	19:3f82c1161fd2	1895	const unsigned char * font; ///< reference to an external font somewhere in memory
WiredHome	37:f19b7e7449dc	1896	loc_t cursor_x, cursor_y; ///< used for external fonts only
WiredHome	19:3f82c1161fd2	1897
WiredHome	19:3f82c1161fd2	1898	#ifdef PERF_METRICS
WiredHome	19:3f82c1161fd2	1899	typedef enum
WiredHome	19:3f82c1161fd2	1900	{
WiredHome	19:3f82c1161fd2	1901	PRF_CLS,
WiredHome	41:2956a0a221e5	1902	PRF_DRAWPIXEL,
WiredHome	41:2956a0a221e5	1903	PRF_PIXELSTREAM,
WiredHome	41:2956a0a221e5	1904	PRF_READPIXEL,
WiredHome	41:2956a0a221e5	1905	PRF_READPIXELSTREAM,
WiredHome	19:3f82c1161fd2	1906	PRF_DRAWLINE,
WiredHome	19:3f82c1161fd2	1907	PRF_DRAWRECTANGLE,
WiredHome	19:3f82c1161fd2	1908	PRF_DRAWROUNDEDRECTANGLE,
WiredHome	19:3f82c1161fd2	1909	PRF_DRAWTRIANGLE,
WiredHome	19:3f82c1161fd2	1910	PRF_DRAWCIRCLE,
WiredHome	19:3f82c1161fd2	1911	PRF_DRAWELLIPSE,
WiredHome	19:3f82c1161fd2	1912	METRICCOUNT
WiredHome	19:3f82c1161fd2	1913	} method_e;
WiredHome	19:3f82c1161fd2	1914	unsigned long metrics[METRICCOUNT];
WiredHome	75:ca78388cfd77	1915	unsigned long idletime_usec;
WiredHome	19:3f82c1161fd2	1916	void RegisterPerformance(method_e method);
WiredHome	19:3f82c1161fd2	1917	Timer performance;
WiredHome	19:3f82c1161fd2	1918	#endif
WiredHome	19:3f82c1161fd2	1919	};
WiredHome	19:3f82c1161fd2	1920
WiredHome	19:3f82c1161fd2	1921	//} // namespace
WiredHome	19:3f82c1161fd2	1922
WiredHome	19:3f82c1161fd2	1923	//using namespace SW_graphics;
WiredHome	19:3f82c1161fd2	1924
WiredHome	23:a50ded45dbaf	1925
WiredHome	23:a50ded45dbaf	1926	#ifdef TESTENABLE
WiredHome	23:a50ded45dbaf	1927	// ______________ ______________ ______________ _______________
WiredHome	23:a50ded45dbaf	1928	// /_____ _____/ / ___________/ / ___________/ /_____ ______/
WiredHome	23:a50ded45dbaf	1929	// / / / / / / / /
WiredHome	23:a50ded45dbaf	1930	// / / / /___ / /__________ / /
WiredHome	23:a50ded45dbaf	1931	// / / / ____/ /__________ / / /
WiredHome	23:a50ded45dbaf	1932	// / / / / / / / /
WiredHome	23:a50ded45dbaf	1933	// / / / /__________ ___________/ / / /
WiredHome	23:a50ded45dbaf	1934	// /__/ /_____________/ /_____________/ /__/
WiredHome	23:a50ded45dbaf	1935
WiredHome	23:a50ded45dbaf	1936	#include "WebColors.h"
WiredHome	23:a50ded45dbaf	1937	#include <algorithm>
WiredHome	23:a50ded45dbaf	1938
WiredHome	23:a50ded45dbaf	1939	extern "C" void mbed_reset();
WiredHome	23:a50ded45dbaf	1940
WiredHome	23:a50ded45dbaf	1941	/// This activates a small set of tests for the graphics library.
WiredHome	23:a50ded45dbaf	1942	///
WiredHome	23:a50ded45dbaf	1943	/// Call this API and pass it the reference to the display class.
WiredHome	23:a50ded45dbaf	1944	/// It will then run a series of tests. It accepts interaction via
WiredHome	23:a50ded45dbaf	1945	/// stdin to switch from automatic test mode to manual, run a specific
WiredHome	23:a50ded45dbaf	1946	/// test, or to exit the test mode.
WiredHome	23:a50ded45dbaf	1947	///
WiredHome	72:ecffe56af969	1948	/// @param[in] lcd is a reference to the display class.
WiredHome	72:ecffe56af969	1949	/// @param[in] pc is a reference to a serial interface, typically the USB to PC.
WiredHome	23:a50ded45dbaf	1950	///
WiredHome	23:a50ded45dbaf	1951	void RunTestSet(RA8875 & lcd, Serial & pc);
WiredHome	23:a50ded45dbaf	1952
WiredHome	23:a50ded45dbaf	1953
WiredHome	23:a50ded45dbaf	1954	// To enable the test code, uncomment this section, or copy the
WiredHome	23:a50ded45dbaf	1955	// necessary pieces to your "main()".
WiredHome	23:a50ded45dbaf	1956	//
WiredHome	23:a50ded45dbaf	1957	// #include "mbed.h"
WiredHome	23:a50ded45dbaf	1958	// #include "RA8875.h"
WiredHome	23:a50ded45dbaf	1959	// RA8875 lcd(p5, p6, p7, p12, NC, "tft"); // MOSI, MISO, SCK, /ChipSelect, /reset, name
WiredHome	23:a50ded45dbaf	1960	// Serial pc(USBTX, USBRX);
WiredHome	23:a50ded45dbaf	1961	// extern "C" void mbed_reset();
WiredHome	23:a50ded45dbaf	1962	// int main()
WiredHome	23:a50ded45dbaf	1963	// {
WiredHome	23:a50ded45dbaf	1964	// pc.baud(460800); // I like a snappy terminal, so crank it up!
WiredHome	23:a50ded45dbaf	1965	// pc.printf("\r\nRA8875 Test - Build " __DATE__ " " __TIME__ "\r\n");
WiredHome	23:a50ded45dbaf	1966	//
WiredHome	23:a50ded45dbaf	1967	// pc.printf("Turning on display\r\n");
WiredHome	23:a50ded45dbaf	1968	// lcd.Reset();
WiredHome	23:a50ded45dbaf	1969	// lcd.Power(true); // display power is on, but the backlight is independent
WiredHome	23:a50ded45dbaf	1970	// lcd.Backlight(0.5);
WiredHome	23:a50ded45dbaf	1971	// RunTestSet(lcd, pc);
WiredHome	23:a50ded45dbaf	1972	// }
WiredHome	23:a50ded45dbaf	1973
WiredHome	23:a50ded45dbaf	1974	#endif // TESTENABLE
WiredHome	23:a50ded45dbaf	1975
WiredHome	56:7a85d226ad0d	1976	#endif

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	12 Jan 2014
Imports:	363
Forks:	7
Commits:	210
Dependents:	20
Dependencies:	0
Followers:	13
Issues:	2

The code in this repository is MIT licensed.

Components

RA8875: 4" to 8" (WQVGA, WVGA, Multi-Touch, Keypad)