David Smart / RA8875 Featured

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

Fork of SPI_TFT by Peter Drescher

See Components - RA8875 Based Display

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@82:f7d300f26540, 2014-12-30 (annotated)

Committer:
WiredHome
Date:
Tue Dec 30 23:45:37 2014 +0000
Revision:
82:f7d300f26540
Parent:
81:01da2e34283d
Child:
83:7bad0068cca0
Added helpful API for computing intersection of a point in a rectangle.; Fixed the rect API for default NOFILL.;

Who changed what in which revision?

UserRevisionLine numberNew 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 56:7a85d226ad0d 471 /// @returns true if touch was detected, in which case the x and y values were set.
WiredHome 56:7a85d226ad0d 472 ///
WiredHome 79:544eb4964795 473 bool TouchPanelA2DFiltered(loc_t *x, loc_t *y);
hexley 54:e117ad10fba6 474
WiredHome 79:544eb4964795 475 /// Poll the TouchPanel and on a touch event return the a to d raw x, y coordinates.
hexley 54:e117ad10fba6 476 ///
WiredHome 78:faf49c381591 477 /// This method reads the touch controller, which has a 10-bit range for each the
WiredHome 78:faf49c381591 478 /// x and the y axis. A number of samples of the raw data are taken, filtered,
WiredHome 79:544eb4964795 479 /// and the results are returned.
WiredHome 78:faf49c381591 480 ///
WiredHome 79:544eb4964795 481 /// @note The returned values are not in display (pixel) units but are in analog to
WiredHome 79:544eb4964795 482 /// digital converter units.
WiredHome 79:544eb4964795 483 ///
WiredHome 81:01da2e34283d 484 /// @note This API is usually not needed. @see TouchPanelComputeCalibration.
WiredHome 79:544eb4964795 485 /// @see TouchPanelReadable.
WiredHome 78:faf49c381591 486 ///
WiredHome 79:544eb4964795 487 /// @param[out] x is the x scale a/d value.
WiredHome 79:544eb4964795 488 /// @param[out] y is the y scale a/d value.
WiredHome 56:7a85d226ad0d 489 /// @returns true if touch was detected, in which case the x and y values were set.
WiredHome 56:7a85d226ad0d 490 ///
WiredHome 79:544eb4964795 491 bool TouchPanelA2DRaw(loc_t *x, loc_t *y);
hexley 54:e117ad10fba6 492
WiredHome 77:9206c13aa527 493 /// Calibrate the touch panel.
WiredHome 77:9206c13aa527 494 ///
WiredHome 77:9206c13aa527 495 /// This method accepts two lists - one list is target points in ,
WiredHome 77:9206c13aa527 496 /// display coordinates and the other is a lit of raw touch coordinate
WiredHome 77:9206c13aa527 497 /// values. It generates a calibration matrix for later use. This
WiredHome 77:9206c13aa527 498 /// matrix is also accessible to the calling API, which may store
WiredHome 77:9206c13aa527 499 /// the matrix in persistent memory and then install the calibration
WiredHome 77:9206c13aa527 500 /// matrix on the next power cycle. By doing so, it can avoid the
WiredHome 77:9206c13aa527 501 /// need to calibrate on every power cycle.
WiredHome 77:9206c13aa527 502 ///
WiredHome 81:01da2e34283d 503 /// @note The methods "TouchPanelComputeCalibration", "TouchPanelReadable", and
WiredHome 77:9206c13aa527 504 /// indirectly the "TouchPanelSetMatrix" methods are all derived
WiredHome 77:9206c13aa527 505 /// from a program by Carlos E. Vidales. See the copyright note
WiredHome 77:9206c13aa527 506 /// for further details. See also the article
WiredHome 77:9206c13aa527 507 /// http://www.embedded.com/design/system-integration/4023968/How-To-Calibrate-Touch-Screens
WiredHome 77:9206c13aa527 508 ///
WiredHome 77:9206c13aa527 509 /// @copyright Copyright (c) 2001, Carlos E. Vidales. All rights reserved.
WiredHome 78:faf49c381591 510 /// This sample program was written and put in the public domain
WiredHome 78:faf49c381591 511 /// by Carlos E. Vidales. The program is provided "as is"
WiredHome 78:faf49c381591 512 /// without warranty of any kind, either expressed or implied.
WiredHome 78:faf49c381591 513 /// If you choose to use the program within your own products
WiredHome 78:faf49c381591 514 /// you do so at your own risk, and assume the responsibility
WiredHome 78:faf49c381591 515 /// for servicing, repairing or correcting the program should
WiredHome 78:faf49c381591 516 /// it prove defective in any manner.
WiredHome 78:faf49c381591 517 /// You may copy and distribute the program's source code in any
WiredHome 78:faf49c381591 518 /// medium, provided that you also include in each copy an
WiredHome 78:faf49c381591 519 /// appropriate copyright notice and disclaimer of warranty.
WiredHome 78:faf49c381591 520 /// You may also modify this program and distribute copies of
WiredHome 78:faf49c381591 521 /// it provided that you include prominent notices stating
WiredHome 78:faf49c381591 522 /// that you changed the file(s) and the date of any change,
WiredHome 78:faf49c381591 523 /// and that you do not charge any royalties or licenses for
WiredHome 78:faf49c381591 524 /// its use.
WiredHome 77:9206c13aa527 525 ///
WiredHome 77:9206c13aa527 526 /// @param[in] display is a pointer to a set of 3 points, which
WiredHome 77:9206c13aa527 527 /// are in display units of measure. These are the targets
WiredHome 77:9206c13aa527 528 /// the calibration was aiming for.
WiredHome 77:9206c13aa527 529 /// @param[in] screen is a pointer to a set of 3 points, which
WiredHome 77:9206c13aa527 530 /// are in touchscreen units of measure. These are the
WiredHome 77:9206c13aa527 531 /// registered touches.
WiredHome 77:9206c13aa527 532 /// @param[out] matrix is an optional parameter to hold the calibration matrix
WiredHome 77:9206c13aa527 533 /// as a result of the calibration. This can be saved in
WiredHome 77:9206c13aa527 534 /// non-volatile memory to recover the calibration after a power fail.
WiredHome 77:9206c13aa527 535 /// @returns success/failure code. @see RetCode_t.
WiredHome 77:9206c13aa527 536 ///
WiredHome 81:01da2e34283d 537 RetCode_t TouchPanelComputeCalibration(point_t display[3], point_t screen[3], tpMatrix_t * matrix);
WiredHome 81:01da2e34283d 538
WiredHome 81:01da2e34283d 539
WiredHome 81:01da2e34283d 540 /// Perform the touch panel calibration process.
WiredHome 81:01da2e34283d 541 ///
WiredHome 81:01da2e34283d 542 /// This method provides the easy "shortcut" to calibrating the touch panel.
WiredHome 81:01da2e34283d 543 /// The process will automatically generate the calibration points, present
WiredHome 81:01da2e34283d 544 /// the targets on-screen, detect the touches, compute the calibration
WiredHome 81:01da2e34283d 545 /// matrix, and optionally provide the calibration matrix to the calling code
WiredHome 81:01da2e34283d 546 /// for persistence in non-volatile memory.
WiredHome 81:01da2e34283d 547 ///
WiredHome 81:01da2e34283d 548 /// @param[out] matrix is an optional parameter to hold the calibration matrix
WiredHome 81:01da2e34283d 549 /// as a result of the calibration. This can be saved in
WiredHome 81:01da2e34283d 550 /// non-volatile memory to recover the calibration after a power fail.
WiredHome 81:01da2e34283d 551 /// @returns success/failure code. @see RetCode_t.
WiredHome 81:01da2e34283d 552 ///
WiredHome 81:01da2e34283d 553 RetCode_t TouchPanelCalibrate(tpMatrix_t * matrix);
WiredHome 81:01da2e34283d 554
WiredHome 81:01da2e34283d 555 /// Perform the touch panel calibration process.
WiredHome 81:01da2e34283d 556 ///
WiredHome 81:01da2e34283d 557 /// This method provides the easy "shortcut" to calibrating the touch panel.
WiredHome 81:01da2e34283d 558 /// The process will automatically generate the calibration points, present
WiredHome 81:01da2e34283d 559 /// the targets on-screen, detect the touches, compute the calibration
WiredHome 81:01da2e34283d 560 /// matrix, and optionally provide the calibration matrix to the calling code
WiredHome 81:01da2e34283d 561 /// for persistence in non-volatile memory.
WiredHome 81:01da2e34283d 562 ///
WiredHome 81:01da2e34283d 563 /// @param[in] msg is a text message to present on the screen during the
WiredHome 81:01da2e34283d 564 /// calibration process.
WiredHome 81:01da2e34283d 565 /// @param[out] matrix is an optional parameter to hold the calibration matrix
WiredHome 81:01da2e34283d 566 /// as a result of the calibration. This can be saved in
WiredHome 81:01da2e34283d 567 /// non-volatile memory to recover the calibration after a power fail.
WiredHome 81:01da2e34283d 568 /// @returns success/failure code. @see RetCode_t.
WiredHome 81:01da2e34283d 569 ///
WiredHome 81:01da2e34283d 570 RetCode_t TouchPanelCalibrate(const char * msg, tpMatrix_t * matrix = NULL);
WiredHome 77:9206c13aa527 571
WiredHome 78:faf49c381591 572 /// Get the screen calibrated point of touch.
WiredHome 78:faf49c381591 573 ///
WiredHome 78:faf49c381591 574 /// This method determines if there is a touch and if so it will provide
WiredHome 79:544eb4964795 575 /// the screen-relative touch coordinates. This method can be used in
WiredHome 79:544eb4964795 576 /// a manner similar to Serial.readable(), to determine if there was a
WiredHome 79:544eb4964795 577 /// touch and indicate that - but not care about the coordinates. Alternately,
WiredHome 79:544eb4964795 578 /// if a valid pointer to a point_t is provided, then if a touch is detected
WiredHome 79:544eb4964795 579 /// the point_t will be populated with data.
WiredHome 78:faf49c381591 580 ///
WiredHome 78:faf49c381591 581 /// @code
WiredHome 78:faf49c381591 582 /// Timer t;
WiredHome 78:faf49c381591 583 /// t.start();
WiredHome 78:faf49c381591 584 /// do {
WiredHome 78:faf49c381591 585 /// point_t point = {0, 0};
WiredHome 79:544eb4964795 586 /// if (display.TouchPanelReadable(&point)) {
WiredHome 78:faf49c381591 587 /// display.pixel(point.x, point.y, Red);
WiredHome 78:faf49c381591 588 /// }
WiredHome 78:faf49c381591 589 /// } while (t.read_ms() < 30000);
WiredHome 78:faf49c381591 590 /// @endcode
WiredHome 78:faf49c381591 591 ///
WiredHome 78:faf49c381591 592 /// @param[out] touch is the touch point, if a touch is registered.
WiredHome 79:544eb4964795 593 /// @returns true if a touch was registered, and touch is updated.
WiredHome 79:544eb4964795 594 /// @returns false if no touch was detected, or if the calibration matrix is not defined.
WiredHome 79:544eb4964795 595 ///
WiredHome 79:544eb4964795 596 bool TouchPanelReadable(point_t * touch = NULL);
WiredHome 79:544eb4964795 597
WiredHome 79:544eb4964795 598 /// Wait for a touch panel touch and return it.
WiredHome 79:544eb4964795 599 ///
WiredHome 79:544eb4964795 600 /// This method is similar to Serial.getc() in that it will wait for a touch
WiredHome 79:544eb4964795 601 /// and then return. In order to extract the coordinates of the touch, a
WiredHome 79:544eb4964795 602 /// valid pointer to a point_t must be provided.
WiredHome 79:544eb4964795 603 ///
WiredHome 79:544eb4964795 604 /// @note There is no timeout on this function, so its use is not recommended.
WiredHome 78:faf49c381591 605 ///
WiredHome 79:544eb4964795 606 /// @code
WiredHome 79:544eb4964795 607 /// Timer t;
WiredHome 79:544eb4964795 608 /// t.start();
WiredHome 79:544eb4964795 609 /// do {
WiredHome 79:544eb4964795 610 /// point_t point = {0, 0};
WiredHome 79:544eb4964795 611 /// display.TouchPanelGet(&point);
WiredHome 79:544eb4964795 612 /// display.pixel(point.x, point.y, Red);
WiredHome 79:544eb4964795 613 /// } while (t.read_ms() < 30000);
WiredHome 79:544eb4964795 614 /// @endcode
WiredHome 79:544eb4964795 615 ///
WiredHome 79:544eb4964795 616 /// @param[out] touch is the touch point, if a touch is registered.
WiredHome 79:544eb4964795 617 /// @returns true if a touch was registered, and touch is updated.
WiredHome 79:544eb4964795 618 /// @returns false if no touch was detected, or if the calibration matrix is not defined.
WiredHome 79:544eb4964795 619 ///
WiredHome 79:544eb4964795 620 bool TouchPanelGet(point_t * touch);
WiredHome 78:faf49c381591 621
WiredHome 77:9206c13aa527 622 /// Set the calibration matrix for the touch panel.
WiredHome 77:9206c13aa527 623 ///
WiredHome 77:9206c13aa527 624 /// This method is used to set the calibration matrix for the touch panel. After
WiredHome 81:01da2e34283d 625 /// performing the calibration (@see TouchPanelComputeCalibration), the matrix can be stored.
WiredHome 77:9206c13aa527 626 /// On a subsequence power cycle, the matrix may be restored from non-volatile and
WiredHome 77:9206c13aa527 627 /// passed in to this method. It will then be held to perform the corrections when
WiredHome 77:9206c13aa527 628 /// reading the touch panel point.
WiredHome 77:9206c13aa527 629 ///
WiredHome 78:faf49c381591 630 /// @code
WiredHome 78:faf49c381591 631 /// FILE * fh = fopen("/local/tpmatrix.cfg", "r");
WiredHome 78:faf49c381591 632 /// if (fh) {
WiredHome 78:faf49c381591 633 /// tpMatrix_t matrix;
WiredHome 78:faf49c381591 634 /// if (fread(fh, &matrix, sizeof(tpMatrix_t))) {
WiredHome 78:faf49c381591 635 /// lcd.TouchPanelSetMatrix(&matrix);
WiredHome 78:faf49c381591 636 /// }
WiredHome 78:faf49c381591 637 /// fclose(fh);
WiredHome 78:faf49c381591 638 /// }
WiredHome 78:faf49c381591 639 /// @endcode
WiredHome 78:faf49c381591 640 ///
WiredHome 77:9206c13aa527 641 /// @param[in] matrix is a pointer to the touch panel calibration matrix.
WiredHome 77:9206c13aa527 642 /// @returns success/failure code. @see RetCode_t.
WiredHome 77:9206c13aa527 643 ///
WiredHome 77:9206c13aa527 644 RetCode_t TouchPanelSetMatrix(tpMatrix_t * matrix);
WiredHome 78:faf49c381591 645
WiredHome 75:ca78388cfd77 646 #if 0
hexley 54:e117ad10fba6 647 /// Append interrupt handler for specific RA8875 interrupt source
hexley 54:e117ad10fba6 648 ///
hexley 54:e117ad10fba6 649 /// @param[in] bISRType Interrupt Source, should be:
hexley 54:e117ad10fba6 650 /// - RA8875_INT_KEYSCAN: KEYCAN interrupt
hexley 54:e117ad10fba6 651 /// - RA8875_INT_DMA: DMA interrupt
hexley 54:e117ad10fba6 652 /// - RA8875_INT_TP: Touch panel interrupt
hexley 54:e117ad10fba6 653 /// - RA8875_INT_BTE: BTE process complete interrupt
hexley 54:e117ad10fba6 654 /// - RA8875_INT_BTEMCU_FONTWR: Multi-purpose interrupt (see spec sheet)
WiredHome 56:7a85d226ad0d 655 /// @param[in] fptr is a callback function to handle the interrupt event.
WiredHome 56:7a85d226ad0d 656 /// @returns none
hexley 54:e117ad10fba6 657 ///
hexley 54:e117ad10fba6 658 void AppendISR(uint8_t bISRType, void(*fptr)(void));
hexley 54:e117ad10fba6 659
hexley 54:e117ad10fba6 660 /// Unappend interrupt handler for specific RA8875 interrupt source
hexley 54:e117ad10fba6 661 ///
hexley 54:e117ad10fba6 662 /// @param[in] bISRType Interrupt Source, should be:
hexley 54:e117ad10fba6 663 /// - RA8875_INT_KEYSCAN: KEYCAN interrupt
hexley 54:e117ad10fba6 664 /// - RA8875_INT_DMA: DMA interrupt
hexley 54:e117ad10fba6 665 /// - RA8875_INT_TP: Touch panel interrupt
hexley 54:e117ad10fba6 666 /// - RA8875_INT_BTE: BTE process complete interrupt
hexley 54:e117ad10fba6 667 /// - RA8875_INT_BTEMCU_FONTWR: Multi-purpose interrupt (see spec sheet)
hexley 54:e117ad10fba6 668 /// @return none
hexley 54:e117ad10fba6 669 ///
hexley 54:e117ad10fba6 670 void UnAppendISR(uint8_t bISRType);
WiredHome 75:ca78388cfd77 671 #endif
WiredHome 77:9206c13aa527 672
WiredHome 71:dcac8efd842d 673 /// Initialize the keypad interface on the RA8875 controller.
WiredHome 71:dcac8efd842d 674 ///
WiredHome 71:dcac8efd842d 675 /// Enables the keypad subsystem. It will scan the 4 x 5 matrix
WiredHome 71:dcac8efd842d 676 /// and make available key presses.
WiredHome 71:dcac8efd842d 677 ///
WiredHome 71:dcac8efd842d 678 /// @note See section 5-13 of RAIO RA8875 data sheet for more details.
WiredHome 71:dcac8efd842d 679 /// @caution When using the display from buy-display.com, be sure that
WiredHome 71:dcac8efd842d 680 /// the option for the keypad is configured on the hardware.
WiredHome 71:dcac8efd842d 681 ///
WiredHome 71:dcac8efd842d 682 /// All parameters are optional.
WiredHome 76:c981284eb513 683 /// @param[in] scanEnable when true, enables the key scan function (default: true).
WiredHome 76:c981284eb513 684 /// @param[in] longDetect when true, additionally enables the long key held detection (default: false).
WiredHome 71:dcac8efd842d 685 /// @param[in] sampleTime setting (range: 0 - 3, default: 0).
WiredHome 71:dcac8efd842d 686 /// @param[in] scanFrequency setting (range: 0 - 7, default: 0).
WiredHome 71:dcac8efd842d 687 /// @param[in] longTimeAdjustment (range: 0 - 3, default: 0).
WiredHome 76:c981284eb513 688 /// @param[in] interruptEnable when true, enables interrupts from keypress (default: false).
WiredHome 76:c981284eb513 689 /// @param[in] wakeupEnable when true, activates the wakeup function (default: false).
WiredHome 71:dcac8efd842d 690 ///
WiredHome 71:dcac8efd842d 691 /// @returns success/failure code. @see RetCode_t.
WiredHome 71:dcac8efd842d 692 ///
WiredHome 71:dcac8efd842d 693 RetCode_t KeypadInit(bool scanEnable = true, bool longDetect = false,
WiredHome 71:dcac8efd842d 694 uint8_t sampleTime = 0, uint8_t scanFrequency = 0,
WiredHome 71:dcac8efd842d 695 uint8_t longTimeAdjustment = 0,
WiredHome 71:dcac8efd842d 696 bool interruptEnable = false, bool wakeupEnable = false);
WiredHome 71:dcac8efd842d 697
WiredHome 75:ca78388cfd77 698 /// Create Key Code definitions for the key matrix.
WiredHome 75:ca78388cfd77 699 ///
WiredHome 75:ca78388cfd77 700 /// This API provides a table of 22 key-code assignments for the matrix of keys.
WiredHome 75:ca78388cfd77 701 /// This can be used to translate the keys 1 - 20 into some other value, as
WiredHome 75:ca78388cfd77 702 /// well as to communicate the "no key" (zero) and "error state" (21).
WiredHome 75:ca78388cfd77 703 ///
WiredHome 75:ca78388cfd77 704 /// In this way, a keypad could easily emulate a piece of a keyboard, transforming
WiredHome 75:ca78388cfd77 705 /// 0 - 20 into the values 0, '0', '1', '2', '3', '4', '5', '6', '7', '8',
WiredHome 75:ca78388cfd77 706 /// '9', '+', '-', '*' , '/', '=', '<bs>', '<cr>', and so on...
WiredHome 75:ca78388cfd77 707 ///
WiredHome 75:ca78388cfd77 708 /// @code
WiredHome 75:ca78388cfd77 709 /// // Return Value by Row, Column Example reassignment
WiredHome 75:ca78388cfd77 710 /// // Column 0 1 2 3 4
WiredHome 75:ca78388cfd77 711 /// // +-------------------------+ +-------------------------+
WiredHome 76:c981284eb513 712 /// // Row 0 | 1 2 3 4 5 | | '7' '8' '9' ',' '<-' |
WiredHome 75:ca78388cfd77 713 /// // 1 | 6 7 8 9 10 | | '4' '5' '6' '/' '-' |
WiredHome 75:ca78388cfd77 714 /// // 2 | 11 12 13 14 15 | | '1' '2' '3' '*' '+' |
WiredHome 76:c981284eb513 715 /// // 3 | 16 17 18 19 20 | | '0' '.' '(' ')' '\n' |
WiredHome 75:ca78388cfd77 716 /// // +-------------------------+ +-------------------------+
WiredHome 75:ca78388cfd77 717 /// // Return value 0 = No Key pressed
WiredHome 75:ca78388cfd77 718 /// // Return value 21 = Error
WiredHome 77:9206c13aa527 719 /// const uint8_t CodeList[22] =
WiredHome 77:9206c13aa527 720 /// {0, '7', '8', '9', ',', '\h',
WiredHome 77:9206c13aa527 721 /// '4', '5', '6', '/', '-',
WiredHome 77:9206c13aa527 722 /// '1', '2', '3', '*', '+',
WiredHome 77:9206c13aa527 723 /// '0', '.', '(', ')', '\n',
WiredHome 77:9206c13aa527 724 /// '\x1b'};
WiredHome 77:9206c13aa527 725 /// lcd.SetKeyMap(CodeList);
WiredHome 75:ca78388cfd77 726 /// @endcode
WiredHome 75:ca78388cfd77 727 ///
WiredHome 75:ca78388cfd77 728 /// @param[in] CodeList is a pointer to an always available byte-array
WiredHome 75:ca78388cfd77 729 /// where the first 22 bytes are used as the transformation
WiredHome 75:ca78388cfd77 730 /// from raw code to your reassigned value.
WiredHome 75:ca78388cfd77 731 /// If CodeList is NULL, the original raw value key map is
WiredHome 75:ca78388cfd77 732 /// restored.
WiredHome 75:ca78388cfd77 733 /// @returns noerror.
WiredHome 75:ca78388cfd77 734 ///
WiredHome 75:ca78388cfd77 735 RetCode_t SetKeyMap(const uint8_t * CodeList = NULL);
WiredHome 75:ca78388cfd77 736
WiredHome 71:dcac8efd842d 737 /// Determine if a key has been hit
WiredHome 71:dcac8efd842d 738 ///
WiredHome 71:dcac8efd842d 739 /// @returns true if a key has been hit
WiredHome 71:dcac8efd842d 740 ///
WiredHome 75:ca78388cfd77 741 bool readable();
WiredHome 71:dcac8efd842d 742
WiredHome 71:dcac8efd842d 743 /// Blocking read of the keypad.
WiredHome 71:dcac8efd842d 744 ///
WiredHome 71:dcac8efd842d 745 /// @caution: This is a blocking read, so it is important to first call _kbhit()
WiredHome 71:dcac8efd842d 746 /// to avoid hanging your processes.
WiredHome 71:dcac8efd842d 747 ///
WiredHome 71:dcac8efd842d 748 /// A keypad connected to the RA8875 is connected in a matrix of 4 rows and 5 columns.
WiredHome 75:ca78388cfd77 749 /// When pressed, this method will return a code in the range of 1 through 20, reserving
WiredHome 75:ca78388cfd77 750 /// the value 0 to indicate that no key is pressed.
WiredHome 71:dcac8efd842d 751 ///
WiredHome 71:dcac8efd842d 752 /// Additionally, if configured to detect a "long press", bit 7 will be set to indicate
WiredHome 71:dcac8efd842d 753 /// this. In this situation, first a "normal press" would be detected and signaled and
WiredHome 71:dcac8efd842d 754 /// soon after that a "long press" of the same key would be detected and communicated.
WiredHome 71:dcac8efd842d 755 ///
WiredHome 75:ca78388cfd77 756 /// @return 8-bit where bit 7 indicates a long press. The remaining bits indicate the
WiredHome 75:ca78388cfd77 757 /// keypress using 0 = no key pressed, 1 - 20 = the key pressed.
WiredHome 71:dcac8efd842d 758 ///
WiredHome 75:ca78388cfd77 759 uint8_t getc();
WiredHome 75:ca78388cfd77 760
WiredHome 82:f7d300f26540 761
WiredHome 82:f7d300f26540 762 /// Determine if a point is within a rectangle.
WiredHome 82:f7d300f26540 763 ///
WiredHome 82:f7d300f26540 764 /// @param[in] rect is a rectangular region to use.
WiredHome 82:f7d300f26540 765 /// @param[in] p is a point to analyze to see if it is within the rect.
WiredHome 82:f7d300f26540 766 /// @returns true if p is within rect.
WiredHome 82:f7d300f26540 767 ///
WiredHome 82:f7d300f26540 768 bool Intersect(rect_t rect, point_t p);
WiredHome 82:f7d300f26540 769
WiredHome 82:f7d300f26540 770
WiredHome 38:38d503b4fad6 771 /// Write a command to the display with a word of data.
WiredHome 38:38d503b4fad6 772 ///
WiredHome 38:38d503b4fad6 773 /// This is a high level command, and may invoke several primitives.
WiredHome 38:38d503b4fad6 774 ///
WiredHome 72:ecffe56af969 775 /// @param[in] command is the command to write.
WiredHome 72:ecffe56af969 776 /// @param[in] data is data to be written to the command register.
WiredHome 38:38d503b4fad6 777 /// @returns success/failure code. @see RetCode_t.
WiredHome 38:38d503b4fad6 778 ///
WiredHome 38:38d503b4fad6 779 RetCode_t WriteCommandW(uint8_t command, uint16_t data);
WiredHome 38:38d503b4fad6 780
WiredHome 19:3f82c1161fd2 781 /// Write a command to the display
WiredHome 19:3f82c1161fd2 782 ///
WiredHome 19:3f82c1161fd2 783 /// This is a high level command, and may invoke several primitives.
WiredHome 19:3f82c1161fd2 784 ///
WiredHome 72:ecffe56af969 785 /// @param[in] command is the command to write.
WiredHome 72:ecffe56af969 786 /// @param[in] data is optional data to be written to the command register
WiredHome 19:3f82c1161fd2 787 /// and only occurs if the data is in the range [0 - 0xFF].
WiredHome 19:3f82c1161fd2 788 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 789 ///
WiredHome 32:0e4f2ae512e2 790 virtual RetCode_t WriteCommand(unsigned char command, unsigned int data = 0xFFFF);
WiredHome 19:3f82c1161fd2 791
WiredHome 38:38d503b4fad6 792 /// Write a data word to the display
WiredHome 38:38d503b4fad6 793 ///
WiredHome 38:38d503b4fad6 794 /// This is a high level command, and may invoke several primitives.
WiredHome 38:38d503b4fad6 795 ///
WiredHome 72:ecffe56af969 796 /// @param[in] data is the data to write.
WiredHome 38:38d503b4fad6 797 /// @returns success/failure code. @see RetCode_t.
WiredHome 38:38d503b4fad6 798 ///
WiredHome 38:38d503b4fad6 799 RetCode_t WriteDataW(uint16_t data);
WiredHome 38:38d503b4fad6 800
WiredHome 19:3f82c1161fd2 801 /// Write a data byte to the display
WiredHome 19:3f82c1161fd2 802 ///
WiredHome 19:3f82c1161fd2 803 /// This is a high level command, and may invoke several primitives.
WiredHome 19:3f82c1161fd2 804 ///
WiredHome 72:ecffe56af969 805 /// @param[in] data is the data to write.
WiredHome 19:3f82c1161fd2 806 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 807 ///
WiredHome 32:0e4f2ae512e2 808 virtual RetCode_t WriteData(unsigned char data);
WiredHome 19:3f82c1161fd2 809
WiredHome 19:3f82c1161fd2 810 /// Read a command register
WiredHome 19:3f82c1161fd2 811 ///
WiredHome 72:ecffe56af969 812 /// @param[in] command is the command register to read.
WiredHome 19:3f82c1161fd2 813 /// @returns the value read from the register.
WiredHome 19:3f82c1161fd2 814 ///
WiredHome 19:3f82c1161fd2 815 unsigned char ReadCommand(unsigned char command);
WiredHome 19:3f82c1161fd2 816
WiredHome 41:2956a0a221e5 817 /// Read a data byte from the display
WiredHome 19:3f82c1161fd2 818 ///
WiredHome 19:3f82c1161fd2 819 /// This is a high level command, and may invoke several primitives.
WiredHome 19:3f82c1161fd2 820 ///
WiredHome 19:3f82c1161fd2 821 /// @returns data that was read.
WiredHome 19:3f82c1161fd2 822 ///
WiredHome 19:3f82c1161fd2 823 unsigned char ReadData(void);
WiredHome 19:3f82c1161fd2 824
WiredHome 41:2956a0a221e5 825 /// Read a word from the display
WiredHome 41:2956a0a221e5 826 ///
WiredHome 41:2956a0a221e5 827 /// This is a high level command, and may invoke several primitives.
WiredHome 41:2956a0a221e5 828 ///
WiredHome 41:2956a0a221e5 829 /// @returns data that was read.
WiredHome 41:2956a0a221e5 830 ///
WiredHome 41:2956a0a221e5 831 uint16_t ReadDataW(void);
WiredHome 41:2956a0a221e5 832
WiredHome 19:3f82c1161fd2 833 /// Read the display status
WiredHome 19:3f82c1161fd2 834 ///
WiredHome 19:3f82c1161fd2 835 /// This is a high level command, and may invoke several primitives.
WiredHome 19:3f82c1161fd2 836 ///
WiredHome 19:3f82c1161fd2 837 /// @returns data that was read.
WiredHome 19:3f82c1161fd2 838 ///
WiredHome 19:3f82c1161fd2 839 unsigned char ReadStatus(void);
WiredHome 19:3f82c1161fd2 840
WiredHome 19:3f82c1161fd2 841 /// get the width in pixels of the currently active font
WiredHome 19:3f82c1161fd2 842 ///
WiredHome 19:3f82c1161fd2 843 /// @returns font width in pixels.
WiredHome 19:3f82c1161fd2 844 ///
WiredHome 37:f19b7e7449dc 845 dim_t fontwidth(void);
WiredHome 19:3f82c1161fd2 846
WiredHome 19:3f82c1161fd2 847 /// get the height in pixels of the currently active font
WiredHome 19:3f82c1161fd2 848 ///
WiredHome 19:3f82c1161fd2 849 /// @returns font height in pixels.
WiredHome 19:3f82c1161fd2 850 ///
WiredHome 37:f19b7e7449dc 851 dim_t fontheight(void);
WiredHome 19:3f82c1161fd2 852
WiredHome 19:3f82c1161fd2 853 /// get the number of colums based on the currently active font
WiredHome 19:3f82c1161fd2 854 ///
WiredHome 19:3f82c1161fd2 855 /// @returns number of columns.
WiredHome 19:3f82c1161fd2 856 ///
WiredHome 19:3f82c1161fd2 857 virtual int columns(void);
WiredHome 19:3f82c1161fd2 858
WiredHome 19:3f82c1161fd2 859 /// get the number of rows based on the currently active font
WiredHome 19:3f82c1161fd2 860 ///
WiredHome 19:3f82c1161fd2 861 /// @returns number of rows.
WiredHome 19:3f82c1161fd2 862 ///
WiredHome 19:3f82c1161fd2 863 virtual int rows(void);
WiredHome 19:3f82c1161fd2 864
WiredHome 19:3f82c1161fd2 865 /// get the screen width in pixels
WiredHome 19:3f82c1161fd2 866 ///
WiredHome 19:3f82c1161fd2 867 /// @returns screen width in pixels.
WiredHome 19:3f82c1161fd2 868 ///
WiredHome 38:38d503b4fad6 869 virtual dim_t width(void);
WiredHome 19:3f82c1161fd2 870
WiredHome 19:3f82c1161fd2 871 /// get the screen height in pixels
WiredHome 19:3f82c1161fd2 872 ///
WiredHome 19:3f82c1161fd2 873 /// @returns screen height in pixels.
WiredHome 19:3f82c1161fd2 874 ///
WiredHome 38:38d503b4fad6 875 virtual dim_t height(void);
WiredHome 19:3f82c1161fd2 876
WiredHome 43:3becae133285 877 /// get the color depth in bits per pixel.
WiredHome 43:3becae133285 878 ///
WiredHome 43:3becae133285 879 /// @returns 8 or 16 only.
WiredHome 43:3becae133285 880 ///
WiredHome 43:3becae133285 881 virtual dim_t color_bpp(void);
WiredHome 43:3becae133285 882
WiredHome 19:3f82c1161fd2 883 /// Set cursor position based on the current font size.
WiredHome 19:3f82c1161fd2 884 ///
WiredHome 72:ecffe56af969 885 /// @param[in] column is the horizontal position in character positions
WiredHome 72:ecffe56af969 886 /// @param[in] row is the vertical position in character positions
WiredHome 19:3f82c1161fd2 887 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 888 ///
WiredHome 37:f19b7e7449dc 889 virtual RetCode_t locate(textloc_t column, textloc_t row);
WiredHome 19:3f82c1161fd2 890
WiredHome 19:3f82c1161fd2 891 /// Prepare the controller to write text to the screen by positioning
WiredHome 19:3f82c1161fd2 892 /// the cursor.
WiredHome 19:3f82c1161fd2 893 ///
WiredHome 56:7a85d226ad0d 894 /// @code
WiredHome 56:7a85d226ad0d 895 /// lcd.SetTextCursor(100, 25);
WiredHome 56:7a85d226ad0d 896 /// lcd.puts("Hello");
WiredHome 56:7a85d226ad0d 897 /// @endcode
WiredHome 56:7a85d226ad0d 898 ///
WiredHome 72:ecffe56af969 899 /// @param[in] x is the horizontal position in pixels (from the left edge)
WiredHome 72:ecffe56af969 900 /// @param[in] y is the vertical position in pixels (from the top edge)
WiredHome 19:3f82c1161fd2 901 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 902 ///
WiredHome 37:f19b7e7449dc 903 RetCode_t SetTextCursor(loc_t x, loc_t y);
WiredHome 29:422616aa04bd 904
WiredHome 37:f19b7e7449dc 905 /// Get the current cursor position in pixels.
WiredHome 37:f19b7e7449dc 906 ///
WiredHome 56:7a85d226ad0d 907 /// @code
WiredHome 56:7a85d226ad0d 908 /// point_t point = GetTextCursor();
WiredHome 56:7a85d226ad0d 909 /// if (point.x > 100 && point.y > 150)
WiredHome 56:7a85d226ad0d 910 /// //...
WiredHome 56:7a85d226ad0d 911 /// @endcode
WiredHome 56:7a85d226ad0d 912 ///
WiredHome 37:f19b7e7449dc 913 /// @returns cursor position.
WiredHome 37:f19b7e7449dc 914 ///
WiredHome 37:f19b7e7449dc 915 point_t GetTextCursor(void);
WiredHome 37:f19b7e7449dc 916
WiredHome 29:422616aa04bd 917 /// Get the current cursor horizontal position in pixels.
WiredHome 29:422616aa04bd 918 ///
WiredHome 29:422616aa04bd 919 /// @returns cursor position horizontal offset.
WiredHome 29:422616aa04bd 920 ///
WiredHome 37:f19b7e7449dc 921 loc_t GetTextCursor_X(void);
WiredHome 29:422616aa04bd 922
WiredHome 29:422616aa04bd 923 /// Get the current cursor vertical position in pixels.
WiredHome 29:422616aa04bd 924 ///
WiredHome 29:422616aa04bd 925 /// @returns cursor position vertical offset.
WiredHome 29:422616aa04bd 926 ///
WiredHome 37:f19b7e7449dc 927 loc_t GetTextCursor_Y(void);
WiredHome 29:422616aa04bd 928
WiredHome 23:a50ded45dbaf 929 /// Configure additional Cursor Control settings.
WiredHome 23:a50ded45dbaf 930 ///
WiredHome 23:a50ded45dbaf 931 /// This API lets you modify other cursor control settings;
WiredHome 23:a50ded45dbaf 932 /// Cursor visible/hidden, Cursor blink/normal,
WiredHome 23:a50ded45dbaf 933 /// Cursor I-Beam/underscore/box.
WiredHome 23:a50ded45dbaf 934 ///
WiredHome 72:ecffe56af969 935 /// @param[in] cursor can be set to NOCURSOR (default), IBEAM,
WiredHome 24:8ca861acf12d 936 /// UNDER, or BLOCK.
WiredHome 72:ecffe56af969 937 /// @param[in] blink can be set to true or false (default false)
WiredHome 23:a50ded45dbaf 938 /// @returns success/failure code. @see RetCode_t
WiredHome 23:a50ded45dbaf 939 ///
WiredHome 24:8ca861acf12d 940 RetCode_t SetTextCursorControl(cursor_t cursor = NOCURSOR, bool blink = false);
WiredHome 23:a50ded45dbaf 941
WiredHome 19:3f82c1161fd2 942 /// Select the ISO 8859-X font to use next.
WiredHome 19:3f82c1161fd2 943 ///
WiredHome 19:3f82c1161fd2 944 /// Supported fonts: ISO 8859-1, -2, -3, -4
WiredHome 19:3f82c1161fd2 945 ///
WiredHome 72:ecffe56af969 946 /// @param[in] font selects the font for the subsequent text rendering.
WiredHome 19:3f82c1161fd2 947 ///
WiredHome 19:3f82c1161fd2 948 /// @note if either hScale or vScale is outside of its permitted range,
WiredHome 19:3f82c1161fd2 949 /// the command is not executed.
WiredHome 19:3f82c1161fd2 950 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 951 ///
WiredHome 19:3f82c1161fd2 952 RetCode_t SetTextFont(font_t font = ISO8859_1);
WiredHome 19:3f82c1161fd2 953
WiredHome 19:3f82c1161fd2 954 /// Control the font behavior.
WiredHome 19:3f82c1161fd2 955 ///
WiredHome 19:3f82c1161fd2 956 /// This command lets you make several modifications to any text that
WiredHome 56:7a85d226ad0d 957 /// will be written to the screen.
WiredHome 19:3f82c1161fd2 958 ///
WiredHome 19:3f82c1161fd2 959 /// Options can be combined:
WiredHome 19:3f82c1161fd2 960 /// Default:
WiredHome 19:3f82c1161fd2 961 /// @li Full alignment disabled,
WiredHome 19:3f82c1161fd2 962 /// @li Font with Background color,
WiredHome 19:3f82c1161fd2 963 /// @li Font in normal orientiation,
WiredHome 19:3f82c1161fd2 964 /// @li Horizontal scale x 1
WiredHome 19:3f82c1161fd2 965 /// @li Vertical scale x 1
WiredHome 19:3f82c1161fd2 966 /// @li alignment
WiredHome 19:3f82c1161fd2 967 ///
WiredHome 72:ecffe56af969 968 /// @param[in] fillit defaults to FILL, but can be NOFILL
WiredHome 72:ecffe56af969 969 /// @param[in] angle defaults to normal, but can be rotated
WiredHome 72:ecffe56af969 970 /// @param[in] hScale defaults to 1, but can be 1, 2, 3, or 4,
WiredHome 19:3f82c1161fd2 971 /// and scales the font size by this amount.
WiredHome 72:ecffe56af969 972 /// @param[in] vScale defaults to 1, but can be 1, 2, 3, or 4,
WiredHome 19:3f82c1161fd2 973 /// and scales the font size by this amount.
WiredHome 72:ecffe56af969 974 /// @param[in] alignment defaults to align_none, but can be
WiredHome 19:3f82c1161fd2 975 /// align_full.
WiredHome 19:3f82c1161fd2 976 ///
WiredHome 19:3f82c1161fd2 977 /// @note if either hScale or vScale is outside of its permitted range,
WiredHome 19:3f82c1161fd2 978 /// the command is not executed.
WiredHome 19:3f82c1161fd2 979 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 980 ///
WiredHome 19:3f82c1161fd2 981 RetCode_t SetTextFontControl(fill_t fillit = FILL,
WiredHome 19:3f82c1161fd2 982 font_angle_t angle = normal,
WiredHome 19:3f82c1161fd2 983 HorizontalScale hScale = 1,
WiredHome 19:3f82c1161fd2 984 VerticalScale vScale = 1,
WiredHome 19:3f82c1161fd2 985 alignment_t alignment = align_none);
WiredHome 19:3f82c1161fd2 986
WiredHome 19:3f82c1161fd2 987 /// Control the font size
WiredHome 19:3f82c1161fd2 988 ///
WiredHome 19:3f82c1161fd2 989 /// This command lets you set the font enlargement for both horizontal
WiredHome 19:3f82c1161fd2 990 /// and vertical, independent of the rotation, background, and
WiredHome 19:3f82c1161fd2 991 /// alignment. @see SetTextFontControl.
WiredHome 19:3f82c1161fd2 992 ///
WiredHome 72:ecffe56af969 993 /// @param[in] hScale defaults to 1, but can be 1, 2, 3, or 4,
WiredHome 19:3f82c1161fd2 994 /// and scales the font size by this amount.
WiredHome 72:ecffe56af969 995 /// @param[in] vScale is an optional parameter that defaults to the hScale value,
WiredHome 40:04aa280dfa39 996 /// but can be 1, 2, 3, or 4, and scales the font size by this amount.
WiredHome 40:04aa280dfa39 997 ///
WiredHome 40:04aa280dfa39 998 /// @code
WiredHome 40:04aa280dfa39 999 /// lcd.SetTextFontSize(2); // Set the font to 2x normal size
WiredHome 56:7a85d226ad0d 1000 /// lcd.puts("Two times");
WiredHome 40:04aa280dfa39 1001 /// lcd.SetTextFontSize(2,3); // Set the font to 2x Width and 3x Height
WiredHome 56:7a85d226ad0d 1002 /// lcd.puts("2*2 3*h");
WiredHome 40:04aa280dfa39 1003 /// lcd.SetTextFontSize(); // Restore to normal size in both dimensions
WiredHome 56:7a85d226ad0d 1004 /// lcd.puts("normal");
WiredHome 40:04aa280dfa39 1005 /// @endcode
WiredHome 19:3f82c1161fd2 1006 ///
WiredHome 19:3f82c1161fd2 1007 /// @note if either hScale or vScale is outside of its permitted range,
WiredHome 19:3f82c1161fd2 1008 /// the command is not executed.
WiredHome 19:3f82c1161fd2 1009 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1010 ///
WiredHome 40:04aa280dfa39 1011 RetCode_t SetTextFontSize(HorizontalScale hScale = 1, VerticalScale vScale = -1);
WiredHome 19:3f82c1161fd2 1012
WiredHome 19:3f82c1161fd2 1013 /// put a character on the screen.
WiredHome 19:3f82c1161fd2 1014 ///
WiredHome 72:ecffe56af969 1015 /// @param[in] c is the character.
WiredHome 19:3f82c1161fd2 1016 /// @returns the character, or EOF if there is an error.
WiredHome 19:3f82c1161fd2 1017 ///
WiredHome 19:3f82c1161fd2 1018 virtual int _putc(int c);
WiredHome 19:3f82c1161fd2 1019
WiredHome 19:3f82c1161fd2 1020 /// Write string of text to the display
WiredHome 19:3f82c1161fd2 1021 ///
WiredHome 56:7a85d226ad0d 1022 /// @code
WiredHome 56:7a85d226ad0d 1023 /// lcd.puts("Test STring");
WiredHome 56:7a85d226ad0d 1024 /// @endcode
WiredHome 56:7a85d226ad0d 1025 ///
WiredHome 72:ecffe56af969 1026 /// @param[in] string is the null terminated string to send to the display.
WiredHome 19:3f82c1161fd2 1027 ///
WiredHome 19:3f82c1161fd2 1028 void puts(const char * string);
WiredHome 19:3f82c1161fd2 1029
WiredHome 19:3f82c1161fd2 1030 /// Write string of text to the display at the specified location.
WiredHome 19:3f82c1161fd2 1031 ///
WiredHome 56:7a85d226ad0d 1032 /// @code
WiredHome 56:7a85d226ad0d 1033 /// lcd.puts(10,25, "Test STring");
WiredHome 56:7a85d226ad0d 1034 /// @endcode
WiredHome 56:7a85d226ad0d 1035 ///
WiredHome 72:ecffe56af969 1036 /// @param[in] x is the horizontal position in pixels (from the left edge)
WiredHome 72:ecffe56af969 1037 /// @param[in] y is the vertical position in pixels (from the top edge)
WiredHome 72:ecffe56af969 1038 /// @param[in] string is the null terminated string to send to the display.
WiredHome 19:3f82c1161fd2 1039 ///
WiredHome 37:f19b7e7449dc 1040 void puts(loc_t x, loc_t y, const char * string);
WiredHome 19:3f82c1161fd2 1041
WiredHome 19:3f82c1161fd2 1042 /// Prepare the controller to write binary data to the screen by positioning
WiredHome 19:3f82c1161fd2 1043 /// the memory cursor.
WiredHome 19:3f82c1161fd2 1044 ///
WiredHome 72:ecffe56af969 1045 /// @param[in] x is the horizontal position in pixels (from the left edge)
WiredHome 72:ecffe56af969 1046 /// @param[in] y is the vertical position in pixels (from the top edge)
WiredHome 19:3f82c1161fd2 1047 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1048 ///
WiredHome 37:f19b7e7449dc 1049 virtual RetCode_t SetGraphicsCursor(loc_t x, loc_t y);
WiredHome 19:3f82c1161fd2 1050
WiredHome 41:2956a0a221e5 1051 /// Prepare the controller to read binary data from the screen by positioning
WiredHome 41:2956a0a221e5 1052 /// the memory read cursor.
WiredHome 41:2956a0a221e5 1053 ///
WiredHome 72:ecffe56af969 1054 /// @param[in] x is the horizontal position in pixels (from the left edge)
WiredHome 72:ecffe56af969 1055 /// @param[in] y is the vertical position in pixels (from the top edge)
WiredHome 41:2956a0a221e5 1056 /// @returns success/failure code. @see RetCode_t.
WiredHome 41:2956a0a221e5 1057 ///
WiredHome 41:2956a0a221e5 1058 virtual RetCode_t SetGraphicsCursorRead(loc_t x, loc_t y);
WiredHome 41:2956a0a221e5 1059
WiredHome 19:3f82c1161fd2 1060 /// Set the window, which controls where items are written to the screen.
WiredHome 19:3f82c1161fd2 1061 ///
WiredHome 19:3f82c1161fd2 1062 /// When something hits the window width, it wraps back to the left side
WiredHome 19:3f82c1161fd2 1063 /// and down a row. If the initial write is outside the window, it will
WiredHome 19:3f82c1161fd2 1064 /// be captured into the window when it crosses a boundary.
WiredHome 19:3f82c1161fd2 1065 ///
WiredHome 56:7a85d226ad0d 1066 /// @code
WiredHome 56:7a85d226ad0d 1067 /// lcd.window(10,10, 80,80);
WiredHome 56:7a85d226ad0d 1068 /// lcd.puts("012345678901234567890123456789012345678901234567890");
WiredHome 56:7a85d226ad0d 1069 /// @endcode
WiredHome 56:7a85d226ad0d 1070 ///
WiredHome 72:ecffe56af969 1071 /// @param[in] x is the left edge in pixels.
WiredHome 72:ecffe56af969 1072 /// @param[in] y is the top edge in pixels.
WiredHome 72:ecffe56af969 1073 /// @param[in] width is the window width in pixels.
WiredHome 72:ecffe56af969 1074 /// @param[in] height is the window height in pixels.
WiredHome 19:3f82c1161fd2 1075 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1076 ///
WiredHome 37:f19b7e7449dc 1077 virtual RetCode_t window(loc_t x, loc_t y, dim_t width, dim_t height);
WiredHome 19:3f82c1161fd2 1078
WiredHome 61:8f3153bf0baa 1079 /// Clear either the specified layer, or the active layer.
WiredHome 19:3f82c1161fd2 1080 ///
WiredHome 61:8f3153bf0baa 1081 /// The behavior is to clear the whole screen for the specified
WiredHome 61:8f3153bf0baa 1082 /// layer. When not specified, the active drawing layer is cleared.
WiredHome 61:8f3153bf0baa 1083 /// This command can also be used to specifically clear either,
WiredHome 61:8f3153bf0baa 1084 /// or both layers. @see clsw().
WiredHome 19:3f82c1161fd2 1085 ///
WiredHome 56:7a85d226ad0d 1086 /// @code
WiredHome 56:7a85d226ad0d 1087 /// lcd.cls();
WiredHome 56:7a85d226ad0d 1088 /// @endcode
WiredHome 56:7a85d226ad0d 1089 ///
WiredHome 72:ecffe56af969 1090 /// @param[in] layers is optional. If not provided, the active layer
WiredHome 61:8f3153bf0baa 1091 /// is cleared. If bit 0 is set, layer 0 is cleared, if bit
WiredHome 61:8f3153bf0baa 1092 /// 1 is set, layer 1 is cleared. If both are set, both layers
WiredHome 61:8f3153bf0baa 1093 /// are cleared. Any other value does not cause an action.
WiredHome 61:8f3153bf0baa 1094 ///
WiredHome 19:3f82c1161fd2 1095 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1096 ///
WiredHome 61:8f3153bf0baa 1097 virtual RetCode_t cls(uint16_t layers = 0);
WiredHome 19:3f82c1161fd2 1098
WiredHome 19:3f82c1161fd2 1099 /// Clear the screen, or clear only the active window.
WiredHome 19:3f82c1161fd2 1100 ///
WiredHome 19:3f82c1161fd2 1101 /// The default behavior is to clear the whole screen. With the optional
WiredHome 19:3f82c1161fd2 1102 /// parameter, the action can be restricted to the active window, which
WiredHome 32:0e4f2ae512e2 1103 /// can be set with the @see window method.
WiredHome 19:3f82c1161fd2 1104 ///
WiredHome 56:7a85d226ad0d 1105 /// @code
WiredHome 56:7a85d226ad0d 1106 /// lcd.window(20,20, 40,10);
WiredHome 56:7a85d226ad0d 1107 /// lcd.clsw();
WiredHome 56:7a85d226ad0d 1108 /// @endcode
WiredHome 56:7a85d226ad0d 1109 ///
WiredHome 72:ecffe56af969 1110 /// @param[in] region is an optional parameter that defaults to FULLWINDOW
WiredHome 19:3f82c1161fd2 1111 /// or may be set to ACTIVEWINDOW.
WiredHome 19:3f82c1161fd2 1112 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1113 ///
WiredHome 19:3f82c1161fd2 1114 RetCode_t clsw(RA8875::Region_t region = FULLWINDOW);
WiredHome 19:3f82c1161fd2 1115
WiredHome 19:3f82c1161fd2 1116 /// Set the background color.
WiredHome 19:3f82c1161fd2 1117 ///
WiredHome 72:ecffe56af969 1118 /// @param[in] color is expressed in 16-bit format.
WiredHome 19:3f82c1161fd2 1119 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1120 ///
WiredHome 19:3f82c1161fd2 1121 virtual RetCode_t background(color_t color);
WiredHome 19:3f82c1161fd2 1122
WiredHome 19:3f82c1161fd2 1123 /// Set the background color.
WiredHome 19:3f82c1161fd2 1124 ///
WiredHome 72:ecffe56af969 1125 /// @param[in] r is the red element of the color.
WiredHome 72:ecffe56af969 1126 /// @param[in] g is the green element of the color.
WiredHome 72:ecffe56af969 1127 /// @param[in] b is the blue element of the color.
WiredHome 19:3f82c1161fd2 1128 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1129 ///
WiredHome 19:3f82c1161fd2 1130 virtual RetCode_t background(unsigned char r, unsigned char g, unsigned char b);
WiredHome 19:3f82c1161fd2 1131
WiredHome 19:3f82c1161fd2 1132 /// Set the foreground color.
WiredHome 19:3f82c1161fd2 1133 ///
WiredHome 72:ecffe56af969 1134 /// @param[in] color is expressed in 16-bit format.
WiredHome 19:3f82c1161fd2 1135 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1136 ///
WiredHome 19:3f82c1161fd2 1137 virtual RetCode_t foreground(color_t color);
WiredHome 19:3f82c1161fd2 1138
WiredHome 19:3f82c1161fd2 1139 /// Set the foreground color.
WiredHome 19:3f82c1161fd2 1140 ///
WiredHome 72:ecffe56af969 1141 /// @param[in] r is the red element of the color.
WiredHome 72:ecffe56af969 1142 /// @param[in] g is the green element of the color.
WiredHome 72:ecffe56af969 1143 /// @param[in] b is the blue element of the color.
WiredHome 19:3f82c1161fd2 1144 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1145 ///
WiredHome 37:f19b7e7449dc 1146 virtual RetCode_t foreground(unsigned char r, unsigned char g, unsigned char b);
WiredHome 19:3f82c1161fd2 1147
WiredHome 19:3f82c1161fd2 1148 /// Get the current foreground color value.
WiredHome 19:3f82c1161fd2 1149 ///
WiredHome 19:3f82c1161fd2 1150 /// @returns the current foreground color.
WiredHome 19:3f82c1161fd2 1151 ///
WiredHome 37:f19b7e7449dc 1152 color_t GetForeColor(void);
WiredHome 19:3f82c1161fd2 1153
WiredHome 19:3f82c1161fd2 1154 /// Draw a pixel in the specified color.
WiredHome 19:3f82c1161fd2 1155 ///
WiredHome 41:2956a0a221e5 1156 /// @note Unlike many other operations, this does not
WiredHome 41:2956a0a221e5 1157 /// set the forecolor!
WiredHome 19:3f82c1161fd2 1158 ///
WiredHome 72:ecffe56af969 1159 /// @param[in] x is the horizontal offset to this pixel.
WiredHome 72:ecffe56af969 1160 /// @param[in] y is the vertical offset to this pixel.
WiredHome 72:ecffe56af969 1161 /// @param[in] color defines the color for the pixel.
WiredHome 19:3f82c1161fd2 1162 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1163 ///
WiredHome 37:f19b7e7449dc 1164 virtual RetCode_t pixel(loc_t x, loc_t y, color_t color);
WiredHome 19:3f82c1161fd2 1165
WiredHome 19:3f82c1161fd2 1166 /// Draw a pixel in the current foreground color.
WiredHome 19:3f82c1161fd2 1167 ///
WiredHome 72:ecffe56af969 1168 /// @param[in] x is the horizontal offset to this pixel.
WiredHome 72:ecffe56af969 1169 /// @param[in] y is the veritical offset to this pixel.
WiredHome 19:3f82c1161fd2 1170 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1171 ///
WiredHome 37:f19b7e7449dc 1172 virtual RetCode_t pixel(loc_t x, loc_t y);
WiredHome 19:3f82c1161fd2 1173
WiredHome 41:2956a0a221e5 1174 /// Get a pixel from the display.
WiredHome 41:2956a0a221e5 1175 ///
WiredHome 72:ecffe56af969 1176 /// @param[in] x is the horizontal offset to this pixel.
WiredHome 72:ecffe56af969 1177 /// @param[in] y is the vertical offset to this pixel.
WiredHome 41:2956a0a221e5 1178 /// @returns the pixel. see @color_t
WiredHome 41:2956a0a221e5 1179 ///
WiredHome 41:2956a0a221e5 1180 virtual color_t getPixel(loc_t x, loc_t y);
WiredHome 41:2956a0a221e5 1181
WiredHome 41:2956a0a221e5 1182 /// Write a stream of pixels to the display.
WiredHome 41:2956a0a221e5 1183 ///
WiredHome 72:ecffe56af969 1184 /// @param[in] p is a pointer to a color_t array to write.
WiredHome 72:ecffe56af969 1185 /// @param[in] count is the number of pixels to write.
WiredHome 72:ecffe56af969 1186 /// @param[in] x is the horizontal position on the display.
WiredHome 72:ecffe56af969 1187 /// @param[in] y is the vertical position on the display.
WiredHome 41:2956a0a221e5 1188 /// @returns success/failure code. @see RetCode_t.
WiredHome 41:2956a0a221e5 1189 ///
WiredHome 41:2956a0a221e5 1190 virtual RetCode_t pixelStream(color_t * p, uint32_t count, loc_t x, loc_t y);
WiredHome 41:2956a0a221e5 1191
WiredHome 41:2956a0a221e5 1192 /// Get a stream of pixels from the display.
WiredHome 41:2956a0a221e5 1193 ///
WiredHome 72:ecffe56af969 1194 /// @param[in] p is a pointer to a color_t array to accept the stream.
WiredHome 72:ecffe56af969 1195 /// @param[in] count is the number of pixels to read.
WiredHome 72:ecffe56af969 1196 /// @param[in] x is the horizontal offset to this pixel.
WiredHome 72:ecffe56af969 1197 /// @param[in] y is the vertical offset to this pixel.
WiredHome 41:2956a0a221e5 1198 /// @returns success/failure code. @see RetCode_t.
WiredHome 41:2956a0a221e5 1199 ///
WiredHome 41:2956a0a221e5 1200 virtual RetCode_t getPixelStream(color_t * p, uint32_t count, loc_t x, loc_t y);
WiredHome 41:2956a0a221e5 1201
WiredHome 19:3f82c1161fd2 1202 /// Draw a line in the specified color
WiredHome 19:3f82c1161fd2 1203 ///
WiredHome 19:3f82c1161fd2 1204 /// @note As a side effect, this changes the current
WiredHome 19:3f82c1161fd2 1205 /// foreground color for subsequent operations.
WiredHome 19:3f82c1161fd2 1206 ///
WiredHome 72:ecffe56af969 1207 /// @param[in] x1 is the horizontal start of the line.
WiredHome 72:ecffe56af969 1208 /// @param[in] y1 is the vertical start of the line.
WiredHome 72:ecffe56af969 1209 /// @param[in] x2 is the horizontal end of the line.
WiredHome 72:ecffe56af969 1210 /// @param[in] y2 is the vertical end of the line.
WiredHome 72:ecffe56af969 1211 /// @param[in] color defines the foreground color.
WiredHome 19:3f82c1161fd2 1212 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1213 ///
WiredHome 56:7a85d226ad0d 1214 RetCode_t line(loc_t x1, loc_t y1, loc_t x2, loc_t y2, color_t color);
WiredHome 19:3f82c1161fd2 1215
WiredHome 19:3f82c1161fd2 1216 /// Draw a line
WiredHome 19:3f82c1161fd2 1217 ///
WiredHome 19:3f82c1161fd2 1218 /// Draws a line using the foreground color setting.
WiredHome 19:3f82c1161fd2 1219 ///
WiredHome 72:ecffe56af969 1220 /// @param[in] x1 is the horizontal start of the line.
WiredHome 72:ecffe56af969 1221 /// @param[in] y1 is the vertical start of the line.
WiredHome 72:ecffe56af969 1222 /// @param[in] x2 is the horizontal end of the line.
WiredHome 72:ecffe56af969 1223 /// @param[in] y2 is the vertical end of the line.
WiredHome 19:3f82c1161fd2 1224 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1225 ///
WiredHome 37:f19b7e7449dc 1226 RetCode_t line(loc_t x1, loc_t y1, loc_t x2, loc_t y2);
WiredHome 19:3f82c1161fd2 1227
WiredHome 19:3f82c1161fd2 1228 /// Draw a rectangle in the specified color
WiredHome 19:3f82c1161fd2 1229 ///
WiredHome 19:3f82c1161fd2 1230 /// @note As a side effect, this changes the current
WiredHome 19:3f82c1161fd2 1231 /// foreground color for subsequent operations.
WiredHome 19:3f82c1161fd2 1232 ///
WiredHome 81:01da2e34283d 1233 /// @param[in] rect defines the rectangle.
WiredHome 81:01da2e34283d 1234 /// @param[in] color defines the foreground color.
WiredHome 81:01da2e34283d 1235 /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome 81:01da2e34283d 1236 /// @returns success/failure code. @see RetCode_t.
WiredHome 81:01da2e34283d 1237 ///
WiredHome 82:f7d300f26540 1238 RetCode_t rect(rect_t rect, color_t color, fill_t fillit = NOFILL);
WiredHome 81:01da2e34283d 1239
WiredHome 81:01da2e34283d 1240 /// Draw a filled rectangle in the specified color
WiredHome 81:01da2e34283d 1241 ///
WiredHome 81:01da2e34283d 1242 /// @note As a side effect, this changes the current
WiredHome 81:01da2e34283d 1243 /// foreground color for subsequent operations.
WiredHome 81:01da2e34283d 1244 ///
WiredHome 81:01da2e34283d 1245 /// @param[in] rect defines the rectangle.
WiredHome 81:01da2e34283d 1246 /// @param[in] color defines the foreground color.
WiredHome 81:01da2e34283d 1247 /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome 81:01da2e34283d 1248 /// @returns success/failure code. @see RetCode_t.
WiredHome 81:01da2e34283d 1249 ///
WiredHome 81:01da2e34283d 1250 RetCode_t fillrect(rect_t rect, color_t color, fill_t fillit = FILL);
WiredHome 81:01da2e34283d 1251
WiredHome 81:01da2e34283d 1252 /// Draw a rectangle in the specified color
WiredHome 81:01da2e34283d 1253 ///
WiredHome 81:01da2e34283d 1254 /// @note As a side effect, this changes the current
WiredHome 81:01da2e34283d 1255 /// foreground color for subsequent operations.
WiredHome 81:01da2e34283d 1256 ///
WiredHome 72:ecffe56af969 1257 /// @param[in] x1 is the horizontal start of the line.
WiredHome 72:ecffe56af969 1258 /// @param[in] y1 is the vertical start of the line.
WiredHome 72:ecffe56af969 1259 /// @param[in] x2 is the horizontal end of the line.
WiredHome 72:ecffe56af969 1260 /// @param[in] y2 is the vertical end of the line.
WiredHome 72:ecffe56af969 1261 /// @param[in] color defines the foreground color.
WiredHome 81:01da2e34283d 1262 /// @param[in] fillit is optional to FILL the rectangle. default is FILL.
WiredHome 19:3f82c1161fd2 1263 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1264 ///
WiredHome 37:f19b7e7449dc 1265 RetCode_t rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 19:3f82c1161fd2 1266 color_t color, fill_t fillit = NOFILL);
WiredHome 19:3f82c1161fd2 1267
WiredHome 19:3f82c1161fd2 1268 /// Draw a filled rectangle in the specified color
WiredHome 19:3f82c1161fd2 1269 ///
WiredHome 19:3f82c1161fd2 1270 /// @note As a side effect, this changes the current
WiredHome 19:3f82c1161fd2 1271 /// foreground color for subsequent operations.
WiredHome 19:3f82c1161fd2 1272 ///
WiredHome 72:ecffe56af969 1273 /// @param[in] x1 is the horizontal start of the line.
WiredHome 72:ecffe56af969 1274 /// @param[in] y1 is the vertical start of the line.
WiredHome 72:ecffe56af969 1275 /// @param[in] x2 is the horizontal end of the line.
WiredHome 72:ecffe56af969 1276 /// @param[in] y2 is the vertical end of the line.
WiredHome 72:ecffe56af969 1277 /// @param[in] color defines the foreground color.
WiredHome 72:ecffe56af969 1278 /// @param[in] fillit is optional to NOFILL the rectangle. default is FILL.
WiredHome 19:3f82c1161fd2 1279 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1280 ///
WiredHome 37:f19b7e7449dc 1281 virtual RetCode_t fillrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 19:3f82c1161fd2 1282 color_t color, fill_t fillit = FILL);
WiredHome 19:3f82c1161fd2 1283
WiredHome 19:3f82c1161fd2 1284 /// Draw a rectangle
WiredHome 19:3f82c1161fd2 1285 ///
WiredHome 19:3f82c1161fd2 1286 /// Draws a rectangle using the foreground color setting.
WiredHome 19:3f82c1161fd2 1287 ///
WiredHome 72:ecffe56af969 1288 /// @param[in] x1 is the horizontal start of the line.
WiredHome 72:ecffe56af969 1289 /// @param[in] y1 is the vertical start of the line.
WiredHome 72:ecffe56af969 1290 /// @param[in] x2 is the horizontal end of the line.
WiredHome 72:ecffe56af969 1291 /// @param[in] y2 is the vertical end of the line.
WiredHome 72:ecffe56af969 1292 /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome 19:3f82c1161fd2 1293 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1294 ///
WiredHome 37:f19b7e7449dc 1295 RetCode_t rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 19:3f82c1161fd2 1296 fill_t fillit = NOFILL);
WiredHome 19:3f82c1161fd2 1297
WiredHome 19:3f82c1161fd2 1298 /// Draw a filled rectangle with rounded corners using the specified color.
WiredHome 19:3f82c1161fd2 1299 ///
WiredHome 21:3c1efb192927 1300 /// This draws a rounded rectangle. A numbers of checks are made on the values,
WiredHome 21:3c1efb192927 1301 /// and it could reduce this to drawing a line (if either x1 == x2, or y1 == y2),
WiredHome 21:3c1efb192927 1302 /// or a single point (x1 == x2 && y1 == y2). If the radius parameters are
WiredHome 21:3c1efb192927 1303 /// > 1/2 the length of that side (width or height), an error value is returned.
WiredHome 21:3c1efb192927 1304 ///
WiredHome 19:3f82c1161fd2 1305 /// @note As a side effect, this changes the current
WiredHome 19:3f82c1161fd2 1306 /// foreground color for subsequent operations.
WiredHome 19:3f82c1161fd2 1307 ///
WiredHome 72:ecffe56af969 1308 /// @param[in] x1 is the horizontal start of the line and must be <= x2.
WiredHome 72:ecffe56af969 1309 /// @param[in] y1 is the vertical start of the line and must be <= y2.
WiredHome 72:ecffe56af969 1310 /// @param[in] x2 is the horizontal end of the line and must be >= x1.
WiredHome 72:ecffe56af969 1311 /// @param[in] y2 is the vertical end of the line and must be >= y1.
WiredHome 72:ecffe56af969 1312 /// @param[in] radius1 defines the horizontal radius of the curved corner. Take care
WiredHome 21:3c1efb192927 1313 /// that this value < 1/2 the width of the rectangle, or bad_parameter
WiredHome 21:3c1efb192927 1314 /// is returned.
WiredHome 72:ecffe56af969 1315 /// @param[in] radius2 defines the vertical radius of the curved corner. Take care
WiredHome 21:3c1efb192927 1316 /// that this value < 1/2 the height of the rectangle, or bad_parameter
WiredHome 21:3c1efb192927 1317 /// is returned.
WiredHome 72:ecffe56af969 1318 /// @param[in] color defines the foreground color.
WiredHome 72:ecffe56af969 1319 /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome 19:3f82c1161fd2 1320 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1321 ///
WiredHome 37:f19b7e7449dc 1322 RetCode_t fillroundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 37:f19b7e7449dc 1323 dim_t radius1, dim_t radius2, color_t color, fill_t fillit = FILL);
WiredHome 19:3f82c1161fd2 1324
WiredHome 19:3f82c1161fd2 1325 /// Draw a rectangle with rounded corners using the specified color.
WiredHome 19:3f82c1161fd2 1326 ///
WiredHome 21:3c1efb192927 1327 /// This draws a rounded rectangle. A numbers of checks are made on the values,
WiredHome 21:3c1efb192927 1328 /// and it could reduce this to drawing a line (if either x1 == x2, or y1 == y2),
WiredHome 21:3c1efb192927 1329 /// or a single point (x1 == x2 && y1 == y2). If the radius parameters are
WiredHome 21:3c1efb192927 1330 /// > 1/2 the length of that side (width or height), an error value is returned.
WiredHome 21:3c1efb192927 1331 ///
WiredHome 19:3f82c1161fd2 1332 /// @note As a side effect, this changes the current
WiredHome 19:3f82c1161fd2 1333 /// foreground color for subsequent operations.
WiredHome 19:3f82c1161fd2 1334 ///
WiredHome 72:ecffe56af969 1335 /// @param[in] x1 is the horizontal start of the line and must be <= x2.
WiredHome 72:ecffe56af969 1336 /// @param[in] y1 is the vertical start of the line and must be <= y2.
WiredHome 72:ecffe56af969 1337 /// @param[in] x2 is the horizontal end of the line and must be >= x1.
WiredHome 72:ecffe56af969 1338 /// @param[in] y2 is the vertical end of the line and must be >= y1.
WiredHome 72:ecffe56af969 1339 /// @param[in] radius1 defines the horizontal radius of the curved corner. Take care
WiredHome 21:3c1efb192927 1340 /// that this value < 1/2 the width of the rectangle, or bad_parameter
WiredHome 21:3c1efb192927 1341 /// is returned.
WiredHome 72:ecffe56af969 1342 /// @param[in] radius2 defines the vertical radius of the curved corner. Take care
WiredHome 21:3c1efb192927 1343 /// that this value < 1/2 the height of the rectangle, or bad_parameter
WiredHome 21:3c1efb192927 1344 /// is returned.
WiredHome 72:ecffe56af969 1345 /// @param[in] color defines the foreground color.
WiredHome 72:ecffe56af969 1346 /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome 19:3f82c1161fd2 1347 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1348 ///
WiredHome 37:f19b7e7449dc 1349 RetCode_t roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 37:f19b7e7449dc 1350 dim_t radius1, dim_t radius2, color_t color, fill_t fillit = NOFILL);
WiredHome 19:3f82c1161fd2 1351
WiredHome 19:3f82c1161fd2 1352 /// Draw a rectangle with rounded corners.
WiredHome 19:3f82c1161fd2 1353 ///
WiredHome 21:3c1efb192927 1354 /// This draws a rounded rectangle. A numbers of checks are made on the values,
WiredHome 21:3c1efb192927 1355 /// and it could reduce this to drawing a line (if either x1 == x2, or y1 == y2),
WiredHome 21:3c1efb192927 1356 /// or a single point (x1 == x2 && y1 == y2). If the radius parameters are
WiredHome 21:3c1efb192927 1357 /// > 1/2 the length of that side (width or height), an error value is returned.
WiredHome 19:3f82c1161fd2 1358 ///
WiredHome 72:ecffe56af969 1359 /// @param[in] x1 is the horizontal start of the line and must be <= x2.
WiredHome 72:ecffe56af969 1360 /// @param[in] y1 is the vertical start of the line and must be <= y2.
WiredHome 72:ecffe56af969 1361 /// @param[in] x2 is the horizontal end of the line and must be >= x1.
WiredHome 72:ecffe56af969 1362 /// @param[in] y2 is the vertical end of the line and must be >= y1.
WiredHome 72:ecffe56af969 1363 /// @param[in] radius1 defines the horizontal radius of the curved corner. Take care
WiredHome 21:3c1efb192927 1364 /// that this value < 1/2 the width of the rectangle, or bad_parameter
WiredHome 21:3c1efb192927 1365 /// is returned.
WiredHome 72:ecffe56af969 1366 /// @param[in] radius2 defines the vertical radius of the curved corner. Take care
WiredHome 21:3c1efb192927 1367 /// that this value < 1/2 the height of the rectangle, or bad_parameter
WiredHome 21:3c1efb192927 1368 /// is returned.
WiredHome 72:ecffe56af969 1369 /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome 19:3f82c1161fd2 1370 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1371 ///
WiredHome 37:f19b7e7449dc 1372 RetCode_t roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 37:f19b7e7449dc 1373 dim_t radius1, dim_t radius2, fill_t fillit = NOFILL);
WiredHome 19:3f82c1161fd2 1374
WiredHome 19:3f82c1161fd2 1375 /// Draw a triangle in the specified color.
WiredHome 19:3f82c1161fd2 1376 ///
WiredHome 19:3f82c1161fd2 1377 /// @note As a side effect, this changes the current
WiredHome 19:3f82c1161fd2 1378 /// foreground color for subsequent operations.
WiredHome 19:3f82c1161fd2 1379 ///
WiredHome 72:ecffe56af969 1380 /// @param[in] x1 is the horizontal for point 1.
WiredHome 72:ecffe56af969 1381 /// @param[in] y1 is the vertical for point 1.
WiredHome 72:ecffe56af969 1382 /// @param[in] x2 is the horizontal for point 2.
WiredHome 72:ecffe56af969 1383 /// @param[in] y2 is the vertical for point 2.
WiredHome 72:ecffe56af969 1384 /// @param[in] x3 is the horizontal for point 3.
WiredHome 72:ecffe56af969 1385 /// @param[in] y3 is the vertical for point 3.
WiredHome 72:ecffe56af969 1386 /// @param[in] color defines the foreground color.
WiredHome 72:ecffe56af969 1387 /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome 19:3f82c1161fd2 1388 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1389 ///
WiredHome 37:f19b7e7449dc 1390 RetCode_t triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 37:f19b7e7449dc 1391 loc_t x3, loc_t y3, color_t color, fill_t fillit = NOFILL);
WiredHome 19:3f82c1161fd2 1392
WiredHome 19:3f82c1161fd2 1393 /// Draw a filled triangle in the specified color.
WiredHome 19:3f82c1161fd2 1394 ///
WiredHome 19:3f82c1161fd2 1395 /// @note As a side effect, this changes the current
WiredHome 19:3f82c1161fd2 1396 /// foreground color for subsequent operations.
WiredHome 19:3f82c1161fd2 1397 ///
WiredHome 72:ecffe56af969 1398 /// @param[in] x1 is the horizontal for point 1.
WiredHome 72:ecffe56af969 1399 /// @param[in] y1 is the vertical for point 1.
WiredHome 72:ecffe56af969 1400 /// @param[in] x2 is the horizontal for point 2.
WiredHome 72:ecffe56af969 1401 /// @param[in] y2 is the vertical for point 2.
WiredHome 72:ecffe56af969 1402 /// @param[in] x3 is the horizontal for point 3.
WiredHome 72:ecffe56af969 1403 /// @param[in] y3 is the vertical for point 3.
WiredHome 72:ecffe56af969 1404 /// @param[in] color defines the foreground color.
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 filltriangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 37:f19b7e7449dc 1409 loc_t x3, loc_t y3, color_t color, fill_t fillit = FILL);
WiredHome 19:3f82c1161fd2 1410
WiredHome 19:3f82c1161fd2 1411 /// Draw a triangle
WiredHome 19:3f82c1161fd2 1412 ///
WiredHome 19:3f82c1161fd2 1413 /// Draws a triangle using the foreground color setting.
WiredHome 19:3f82c1161fd2 1414 ///
WiredHome 72:ecffe56af969 1415 /// @param[in] x1 is the horizontal for point 1.
WiredHome 72:ecffe56af969 1416 /// @param[in] y1 is the vertical for point 1.
WiredHome 72:ecffe56af969 1417 /// @param[in] x2 is the horizontal for point 2.
WiredHome 72:ecffe56af969 1418 /// @param[in] y2 is the vertical for point 2.
WiredHome 72:ecffe56af969 1419 /// @param[in] x3 is the horizontal for point 3.
WiredHome 72:ecffe56af969 1420 /// @param[in] y3 is the vertical for point 3.
WiredHome 72:ecffe56af969 1421 /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL.
WiredHome 19:3f82c1161fd2 1422 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1423 ///
WiredHome 37:f19b7e7449dc 1424 RetCode_t triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 37:f19b7e7449dc 1425 loc_t x3, loc_t y3, fill_t fillit = NOFILL);
WiredHome 19:3f82c1161fd2 1426
WiredHome 19:3f82c1161fd2 1427 /// Draw a circle using the specified color.
WiredHome 19:3f82c1161fd2 1428 ///
WiredHome 19:3f82c1161fd2 1429 /// @note As a side effect, this changes the current
WiredHome 19:3f82c1161fd2 1430 /// foreground color for subsequent operations.
WiredHome 19:3f82c1161fd2 1431 ///
WiredHome 72:ecffe56af969 1432 /// @param[in] x is the horizontal center of the circle.
WiredHome 72:ecffe56af969 1433 /// @param[in] y is the vertical center of the circle.
WiredHome 72:ecffe56af969 1434 /// @param[in] radius defines the size of the circle.
WiredHome 72:ecffe56af969 1435 /// @param[in] color defines the foreground color.
WiredHome 19:3f82c1161fd2 1436 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1437 ///
WiredHome 37:f19b7e7449dc 1438 RetCode_t circle(loc_t x, loc_t y, dim_t radius, color_t color, fill_t fillit = NOFILL);
WiredHome 19:3f82c1161fd2 1439
WiredHome 19:3f82c1161fd2 1440 /// Draw a filled circle using the specified color.
WiredHome 19:3f82c1161fd2 1441 ///
WiredHome 19:3f82c1161fd2 1442 /// @note As a side effect, this changes the current
WiredHome 19:3f82c1161fd2 1443 /// foreground color for subsequent operations.
WiredHome 19:3f82c1161fd2 1444 ///
WiredHome 72:ecffe56af969 1445 /// @param[in] x is the horizontal center of the circle.
WiredHome 72:ecffe56af969 1446 /// @param[in] y is the vertical center of the circle.
WiredHome 72:ecffe56af969 1447 /// @param[in] radius defines the size of the circle.
WiredHome 72:ecffe56af969 1448 /// @param[in] color defines the foreground color.
WiredHome 19:3f82c1161fd2 1449 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1450 ///
WiredHome 37:f19b7e7449dc 1451 RetCode_t fillcircle(loc_t x, loc_t y, dim_t radius, color_t color, fill_t fillit = FILL);
WiredHome 19:3f82c1161fd2 1452
WiredHome 19:3f82c1161fd2 1453 /// Draw a circle.
WiredHome 19:3f82c1161fd2 1454 ///
WiredHome 19:3f82c1161fd2 1455 /// Draws a circle using the foreground color setting.
WiredHome 19:3f82c1161fd2 1456 ///
WiredHome 72:ecffe56af969 1457 /// @param[in] x is the horizontal center of the circle.
WiredHome 72:ecffe56af969 1458 /// @param[in] y is the vertical center of the circle.
WiredHome 72:ecffe56af969 1459 /// @param[in] radius defines the size of the circle.
WiredHome 19:3f82c1161fd2 1460 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1461 ///
WiredHome 37:f19b7e7449dc 1462 RetCode_t circle(loc_t x, loc_t y, dim_t radius, fill_t fillit = NOFILL);
WiredHome 19:3f82c1161fd2 1463
WiredHome 19:3f82c1161fd2 1464 /// Draw an Ellipse using the specified color
WiredHome 19:3f82c1161fd2 1465 ///
WiredHome 19:3f82c1161fd2 1466 /// @note As a side effect, this changes the current
WiredHome 19:3f82c1161fd2 1467 /// foreground color for subsequent operations.
WiredHome 19:3f82c1161fd2 1468 ///
WiredHome 72:ecffe56af969 1469 /// @param[in] x is the horizontal center of the ellipse.
WiredHome 72:ecffe56af969 1470 /// @param[in] y is the vertical center of the ellipse.
WiredHome 72:ecffe56af969 1471 /// @param[in] radius1 defines the horizontal radius of the ellipse.
WiredHome 72:ecffe56af969 1472 /// @param[in] radius2 defines the vertical radius of the ellipse.
WiredHome 72:ecffe56af969 1473 /// @param[in] color defines the foreground color.
WiredHome 72:ecffe56af969 1474 /// @param[in] fillit defines whether the circle is filled or not.
WiredHome 19:3f82c1161fd2 1475 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1476 ///
WiredHome 37:f19b7e7449dc 1477 RetCode_t ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2,
WiredHome 19:3f82c1161fd2 1478 color_t color, fill_t fillit = NOFILL);
WiredHome 19:3f82c1161fd2 1479
WiredHome 25:9556a3a9b7cc 1480 /// Draw a filled Ellipse using the specified color
WiredHome 25:9556a3a9b7cc 1481 ///
WiredHome 25:9556a3a9b7cc 1482 /// @note As a side effect, this changes the current
WiredHome 25:9556a3a9b7cc 1483 /// foreground color for subsequent operations.
WiredHome 25:9556a3a9b7cc 1484 ///
WiredHome 72:ecffe56af969 1485 /// @param[in] x is the horizontal center of the ellipse.
WiredHome 72:ecffe56af969 1486 /// @param[in] y is the vertical center of the ellipse.
WiredHome 72:ecffe56af969 1487 /// @param[in] radius1 defines the horizontal radius of the ellipse.
WiredHome 72:ecffe56af969 1488 /// @param[in] radius2 defines the vertical radius of the ellipse.
WiredHome 72:ecffe56af969 1489 /// @param[in] color defines the foreground color.
WiredHome 72:ecffe56af969 1490 /// @param[in] fillit defines whether the circle is filled or not.
WiredHome 25:9556a3a9b7cc 1491 /// @returns success/failure code. @see RetCode_t.
WiredHome 25:9556a3a9b7cc 1492 ///
WiredHome 37:f19b7e7449dc 1493 RetCode_t fillellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2,
WiredHome 25:9556a3a9b7cc 1494 color_t color, fill_t fillit = FILL);
WiredHome 25:9556a3a9b7cc 1495
WiredHome 19:3f82c1161fd2 1496 /// Draw an Ellipse
WiredHome 19:3f82c1161fd2 1497 ///
WiredHome 19:3f82c1161fd2 1498 /// Draws it using the foreground color setting.
WiredHome 19:3f82c1161fd2 1499 ///
WiredHome 72:ecffe56af969 1500 /// @param[in] x is the horizontal center of the ellipse.
WiredHome 72:ecffe56af969 1501 /// @param[in] y is the vertical center of the ellipse.
WiredHome 72:ecffe56af969 1502 /// @param[in] radius1 defines the horizontal radius of the ellipse.
WiredHome 72:ecffe56af969 1503 /// @param[in] radius2 defines the vertical radius of the ellipse.
WiredHome 72:ecffe56af969 1504 /// @param[in] fillit defines whether the circle is filled or not.
WiredHome 19:3f82c1161fd2 1505 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1506 ///
WiredHome 37:f19b7e7449dc 1507 RetCode_t ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, fill_t fillit = NOFILL);
WiredHome 19:3f82c1161fd2 1508
WiredHome 19:3f82c1161fd2 1509 /// Control display power
WiredHome 19:3f82c1161fd2 1510 ///
WiredHome 72:ecffe56af969 1511 /// @param[in] on when set to true will turn on the display, when false it is turned off.
WiredHome 19:3f82c1161fd2 1512 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1513 ///
WiredHome 19:3f82c1161fd2 1514 RetCode_t Power(bool on);
WiredHome 19:3f82c1161fd2 1515
WiredHome 19:3f82c1161fd2 1516 /// Reset the display controller via the Software Reset interface.
WiredHome 19:3f82c1161fd2 1517 ///
WiredHome 19:3f82c1161fd2 1518 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1519 ///
WiredHome 19:3f82c1161fd2 1520 RetCode_t Reset(void);
WiredHome 19:3f82c1161fd2 1521
WiredHome 19:3f82c1161fd2 1522 /// Set backlight brightness.
WiredHome 19:3f82c1161fd2 1523 ///
WiredHome 19:3f82c1161fd2 1524 /// When the built-in PWM is used to control the backlight, this
WiredHome 19:3f82c1161fd2 1525 /// API can be used to set the brightness.
WiredHome 19:3f82c1161fd2 1526 ///
WiredHome 72:ecffe56af969 1527 /// @param[in] brightness ranges from 0 (off) to 255 (full on)
WiredHome 19:3f82c1161fd2 1528 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1529 ///
WiredHome 19:3f82c1161fd2 1530 RetCode_t Backlight_u8(unsigned char brightness);
WiredHome 19:3f82c1161fd2 1531
WiredHome 19:3f82c1161fd2 1532 /// Set backlight brightness.
WiredHome 19:3f82c1161fd2 1533 ///
WiredHome 19:3f82c1161fd2 1534 /// When the built-in PWM is used to control the backlight, this
WiredHome 19:3f82c1161fd2 1535 /// API can be used to set the brightness.
WiredHome 19:3f82c1161fd2 1536 ///
WiredHome 72:ecffe56af969 1537 /// @param[in] brightness ranges from 0.0 (off) to 1.0 (full on)
WiredHome 19:3f82c1161fd2 1538 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1539 ///
WiredHome 19:3f82c1161fd2 1540 RetCode_t Backlight(float brightness);
WiredHome 19:3f82c1161fd2 1541
WiredHome 32:0e4f2ae512e2 1542 /// Select a bitmap font (provided by the user) for all subsequent text.
WiredHome 19:3f82c1161fd2 1543 ///
WiredHome 19:3f82c1161fd2 1544 /// @note Tool to create the fonts is accessible from its creator
WiredHome 19:3f82c1161fd2 1545 /// available at http://www.mikroe.com.
WiredHome 19:3f82c1161fd2 1546 /// Change the data to an array of type char[].
WiredHome 19:3f82c1161fd2 1547 ///
WiredHome 72:ecffe56af969 1548 /// @param[in] font is a pointer to a specially formed font array.
WiredHome 19:3f82c1161fd2 1549 /// This special font array has a 4-byte header, followed by
WiredHome 19:3f82c1161fd2 1550 /// the data:
WiredHome 19:3f82c1161fd2 1551 /// - the number of bytes per char
WiredHome 19:3f82c1161fd2 1552 /// - the vertical size in pixels for each character
WiredHome 19:3f82c1161fd2 1553 /// - the horizontal size in pixels for each character
WiredHome 19:3f82c1161fd2 1554 /// - the number of bytes per vertical line (width of the array)
WiredHome 19:3f82c1161fd2 1555 /// @returns error code.
WiredHome 19:3f82c1161fd2 1556 ///
WiredHome 30:e0f2da88bdf6 1557 virtual RetCode_t set_font(const unsigned char * font = NULL);
WiredHome 19:3f82c1161fd2 1558
WiredHome 19:3f82c1161fd2 1559 /// Get the RGB value for a DOS color.
WiredHome 19:3f82c1161fd2 1560 ///
WiredHome 72:ecffe56af969 1561 /// @param[in] i is the color, in the range 0 to 15;
WiredHome 19:3f82c1161fd2 1562 /// @returns the RGB color of the selected index, or 0
WiredHome 19:3f82c1161fd2 1563 /// if the index is out of bounds.
WiredHome 19:3f82c1161fd2 1564 ///
WiredHome 19:3f82c1161fd2 1565 color_t DOSColor(int i);
WiredHome 19:3f82c1161fd2 1566
WiredHome 19:3f82c1161fd2 1567 /// Get the color name (string) for a DOS color.
WiredHome 19:3f82c1161fd2 1568 ///
WiredHome 72:ecffe56af969 1569 /// @param[in] i is the color, in the range 0 to 15;
WiredHome 19:3f82c1161fd2 1570 /// @returns a pointer to a string with the color name,
WiredHome 19:3f82c1161fd2 1571 /// or NULL if the index is out of bounds.
WiredHome 19:3f82c1161fd2 1572 ///
WiredHome 19:3f82c1161fd2 1573 const char * DOSColorNames(int i);
WiredHome 19:3f82c1161fd2 1574
WiredHome 55:dfbabef7003e 1575 /// Advanced method indicating the start of a graphics stream.
WiredHome 55:dfbabef7003e 1576 ///
WiredHome 55:dfbabef7003e 1577 /// This is called prior to a stream of pixel data being sent.
WiredHome 55:dfbabef7003e 1578 /// This may cause register configuration changes in the derived
WiredHome 55:dfbabef7003e 1579 /// class in order to prepare the hardware to accept the streaming
WiredHome 55:dfbabef7003e 1580 /// data.
WiredHome 55:dfbabef7003e 1581 ///
WiredHome 55:dfbabef7003e 1582 /// Following this command, a series of @see _putp() commands can
WiredHome 55:dfbabef7003e 1583 /// be used to send individual pixels to the screen.
WiredHome 55:dfbabef7003e 1584 ///
WiredHome 55:dfbabef7003e 1585 /// To conclude the graphics stream, @see _EndGraphicsStream should
WiredHome 55:dfbabef7003e 1586 /// be callled.
WiredHome 55:dfbabef7003e 1587 ///
WiredHome 55:dfbabef7003e 1588 /// @returns error code.
WiredHome 55:dfbabef7003e 1589 ///
WiredHome 55:dfbabef7003e 1590 virtual RetCode_t _StartGraphicsStream(void);
WiredHome 55:dfbabef7003e 1591
WiredHome 55:dfbabef7003e 1592 /// Advanced method to put a single color pixel to the screen.
WiredHome 55:dfbabef7003e 1593 ///
WiredHome 55:dfbabef7003e 1594 /// This method may be called as many times as necessary after
WiredHome 55:dfbabef7003e 1595 /// @see _StartGraphicsStream() is called, and it should be followed
WiredHome 55:dfbabef7003e 1596 /// by _EndGraphicsStream.
WiredHome 55:dfbabef7003e 1597 ///
WiredHome 72:ecffe56af969 1598 /// @param[in] pixel is a color value to be put on the screen.
WiredHome 55:dfbabef7003e 1599 /// @returns error code.
WiredHome 55:dfbabef7003e 1600 ///
WiredHome 55:dfbabef7003e 1601 virtual RetCode_t _putp(color_t pixel);
WiredHome 55:dfbabef7003e 1602
WiredHome 55:dfbabef7003e 1603 /// Advanced method indicating the end of a graphics stream.
WiredHome 55:dfbabef7003e 1604 ///
WiredHome 55:dfbabef7003e 1605 /// This is called to conclude a stream of pixel data that was sent.
WiredHome 55:dfbabef7003e 1606 /// This may cause register configuration changes in the derived
WiredHome 55:dfbabef7003e 1607 /// class in order to stop the hardware from accept the streaming
WiredHome 55:dfbabef7003e 1608 /// data.
WiredHome 55:dfbabef7003e 1609 ///
WiredHome 55:dfbabef7003e 1610 /// @returns error code.
WiredHome 55:dfbabef7003e 1611 ///
WiredHome 55:dfbabef7003e 1612 virtual RetCode_t _EndGraphicsStream(void);
WiredHome 19:3f82c1161fd2 1613
WiredHome 57:bd53a9e165a1 1614 /// Set the SPI port frequency (in Hz).
WiredHome 57:bd53a9e165a1 1615 ///
WiredHome 66:468a11f05580 1616 /// This uses the mbed SPI driver, and is therefore dependent on
WiredHome 66:468a11f05580 1617 /// its capabilities. The RA8875 can accept writes via SPI faster
WiredHome 66:468a11f05580 1618 /// than a read can be performed. The frequency set by this API
WiredHome 66:468a11f05580 1619 /// is for the SPI writes. It will automatically reduce the SPI
WiredHome 66:468a11f05580 1620 /// clock rate when a read is performed, and restore it for the
WiredHome 68:ab08efabfc88 1621 /// next write. Alternately, the 2nd parameters permits setting
WiredHome 68:ab08efabfc88 1622 /// the read speed rather than letting it compute it automatically.
WiredHome 57:bd53a9e165a1 1623 ///
WiredHome 66:468a11f05580 1624 /// @note The primary effect of this is to recover more CPU cycles
WiredHome 66:468a11f05580 1625 /// for your application code. Keep in mind that when more than
WiredHome 66:468a11f05580 1626 /// one command is sent to the display controller, that it
WiredHome 66:468a11f05580 1627 /// will wait for the controller to finish the prior command.
WiredHome 66:468a11f05580 1628 /// In this case, the performance is limited by the RA8875.
WiredHome 57:bd53a9e165a1 1629 ///
WiredHome 72:ecffe56af969 1630 /// @param[in] Hz is the frequency in Hz, tested range includes the
WiredHome 66:468a11f05580 1631 /// range from 1,000,000 (1MHz) to 10,000,000 (10 MHz). Values
WiredHome 66:468a11f05580 1632 /// outside this range will be accepted, but operation may
WiredHome 76:c981284eb513 1633 /// be unreliable. This depends partially on your hardware design
WiredHome 76:c981284eb513 1634 /// and the wires connecting the display module.
WiredHome 76:c981284eb513 1635 /// The default value is 5,000,000, which should work for most
WiredHome 76:c981284eb513 1636 /// applications as a starting point.
WiredHome 72:ecffe56af969 1637 /// @param[in] Hz2 is an optional parameter and will set the read
WiredHome 68:ab08efabfc88 1638 /// speed independently of the write speed.
WiredHome 57:bd53a9e165a1 1639 /// @returns success/failure code. @see RetCode_t.
WiredHome 57:bd53a9e165a1 1640 ///
WiredHome 68:ab08efabfc88 1641 RetCode_t frequency(unsigned long Hz = RA8875_DEFAULT_SPI_FREQ, unsigned long Hz2 = 0);
WiredHome 57:bd53a9e165a1 1642
WiredHome 72:ecffe56af969 1643 /// This method captures the specified area as a 24-bit bitmap file.
WiredHome 72:ecffe56af969 1644 ///
WiredHome 72:ecffe56af969 1645 /// Even though this is a 16-bit display, the stored image is in
WiredHome 72:ecffe56af969 1646 /// 24-bit format.
WiredHome 72:ecffe56af969 1647 ///
WiredHome 73:f22a18707b5e 1648 /// This method will interrogate the current display setting and
WiredHome 73:f22a18707b5e 1649 /// create a bitmap based on those settings. For instance, if
WiredHome 73:f22a18707b5e 1650 /// only layer 1 is visible, then the bitmap is only layer 1. However,
WiredHome 73:f22a18707b5e 1651 /// if there is some other operation in effect (transparent mode).
WiredHome 73:f22a18707b5e 1652 ///
WiredHome 72:ecffe56af969 1653 /// @param[in] x is the left edge of the region to capture
WiredHome 72:ecffe56af969 1654 /// @param[in] y is the top edge of the region to capture
WiredHome 72:ecffe56af969 1655 /// @param[in] w is the width of the region to capture
WiredHome 72:ecffe56af969 1656 /// @param[in] h is the height of the region to capture.
WiredHome 72:ecffe56af969 1657 /// @param[out] Name_BMP is the filename to write the image to.
WiredHome 72:ecffe56af969 1658 /// @return success or error code.
WiredHome 72:ecffe56af969 1659 ///
WiredHome 72:ecffe56af969 1660 RetCode_t PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP);
WiredHome 72:ecffe56af969 1661
WiredHome 72:ecffe56af969 1662 /// This method captures the specified area as a 24-bit bitmap file,
WiredHome 72:ecffe56af969 1663 /// including the option of layer selection.
WiredHome 72:ecffe56af969 1664 ///
WiredHome 74:686faa218914 1665 /// @caution This method is deprecated as the alternate PrintScreen API
WiredHome 74:686faa218914 1666 /// automatically examines the display layer configuration.
WiredHome 74:686faa218914 1667 /// Therefore, calls to this API will ignore the layer parameter
WiredHome 74:686faa218914 1668 /// and automatically execute the other method.
WiredHome 74:686faa218914 1669 ///
WiredHome 72:ecffe56af969 1670 /// Even though this is a 16-bit display, the stored image is in
WiredHome 72:ecffe56af969 1671 /// 24-bit format.
WiredHome 72:ecffe56af969 1672 ///
WiredHome 72:ecffe56af969 1673 /// @param[in] layer is 0 or 1 to select the layer to extract.
WiredHome 72:ecffe56af969 1674 /// @param[in] x is the left edge of the region to capture
WiredHome 72:ecffe56af969 1675 /// @param[in] y is the top edge of the region to capture
WiredHome 72:ecffe56af969 1676 /// @param[in] w is the width of the region to capture
WiredHome 72:ecffe56af969 1677 /// @param[in] h is the height of the region to capture.
WiredHome 72:ecffe56af969 1678 /// @param[out] Name_BMP is the filename to write the image to.
WiredHome 72:ecffe56af969 1679 /// @return success or error code.
WiredHome 72:ecffe56af969 1680 ///
WiredHome 72:ecffe56af969 1681 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 1682
WiredHome 57:bd53a9e165a1 1683
WiredHome 19:3f82c1161fd2 1684 #ifdef PERF_METRICS
WiredHome 19:3f82c1161fd2 1685 /// Clear the performance metrics to zero.
WiredHome 19:3f82c1161fd2 1686 void ClearPerformance();
WiredHome 19:3f82c1161fd2 1687
WiredHome 66:468a11f05580 1688 /// Count idle time.
WiredHome 66:468a11f05580 1689 ///
WiredHome 72:ecffe56af969 1690 /// @param[in] t is the amount of idle time to accumulate.
WiredHome 66:468a11f05580 1691 ///
WiredHome 66:468a11f05580 1692 void CountIdleTime(uint32_t t);
WiredHome 66:468a11f05580 1693
WiredHome 19:3f82c1161fd2 1694 /// Report the performance metrics for drawing functions using
WiredHome 41:2956a0a221e5 1695 /// the available serial channel.
WiredHome 41:2956a0a221e5 1696 ///
WiredHome 72:ecffe56af969 1697 /// @param[in,out] pc is the serial channel to write to.
WiredHome 41:2956a0a221e5 1698 ///
WiredHome 41:2956a0a221e5 1699 void ReportPerformance(Serial & pc);
WiredHome 19:3f82c1161fd2 1700 #endif
WiredHome 19:3f82c1161fd2 1701
hexley 54:e117ad10fba6 1702
WiredHome 19:3f82c1161fd2 1703 private:
hexley 54:e117ad10fba6 1704 /// Touch Panel register name definitions
WiredHome 77:9206c13aa527 1705 #define TPCR0 0x70
WiredHome 77:9206c13aa527 1706 #define TPCR1 0x71
WiredHome 77:9206c13aa527 1707 #define TPXH 0x72
WiredHome 77:9206c13aa527 1708 #define TPYH 0x73
WiredHome 77:9206c13aa527 1709 #define TPXYL 0x74
WiredHome 77:9206c13aa527 1710 #define INTC1 0xF0
WiredHome 77:9206c13aa527 1711 #define INTC2 0xF1
hexley 54:e117ad10fba6 1712
hexley 54:e117ad10fba6 1713 /// Specify the default settings for the Touch Panel, where different from the chip defaults
WiredHome 77:9206c13aa527 1714 #define TP_MODE_DEFAULT TP_MODE_AUTO
WiredHome 77:9206c13aa527 1715 #define TP_DEBOUNCE_DEFAULT TP_DEBOUNCE_ON
WiredHome 77:9206c13aa527 1716 #define TP_ADC_CLKDIV_DEFAULT TP_ADC_CLKDIV_8
hexley 54:e117ad10fba6 1717
WiredHome 77:9206c13aa527 1718 #define TP_ADC_SAMPLE_DEFAULT_CLKS TP_ADC_SAMPLE_8192_CLKS
hexley 54:e117ad10fba6 1719
hexley 54:e117ad10fba6 1720 /// Other Touch Panel params
WiredHome 77:9206c13aa527 1721 #define TPBUFSIZE 16 // Depth of the averaging buffers for x and y data
hexley 54:e117ad10fba6 1722
WiredHome 77:9206c13aa527 1723 /// Touch Panel calibration matrix.
WiredHome 77:9206c13aa527 1724 tpMatrix_t tpMatrix;
hexley 54:e117ad10fba6 1725
WiredHome 29:422616aa04bd 1726 /// Internal function to put a character using the built-in (internal) font engine
WiredHome 29:422616aa04bd 1727 ///
WiredHome 72:ecffe56af969 1728 /// @param[in] is the character to put to the screen.
WiredHome 29:422616aa04bd 1729 /// @returns the character put.
WiredHome 29:422616aa04bd 1730 ///
WiredHome 29:422616aa04bd 1731 int _internal_putc(int c);
WiredHome 29:422616aa04bd 1732
WiredHome 29:422616aa04bd 1733 /// Internal function to put a character using the external font engine
WiredHome 29:422616aa04bd 1734 ///
WiredHome 72:ecffe56af969 1735 /// @param[in] is the character to put to the screen.
WiredHome 29:422616aa04bd 1736 /// @returns the character put.
WiredHome 29:422616aa04bd 1737 ///
WiredHome 29:422616aa04bd 1738 int _external_putc(int c);
WiredHome 29:422616aa04bd 1739
WiredHome 19:3f82c1161fd2 1740 /// Select the peripheral to use it.
WiredHome 19:3f82c1161fd2 1741 ///
WiredHome 72:ecffe56af969 1742 /// @param[in] chipsel when true will select the peripheral, and when false
WiredHome 19:3f82c1161fd2 1743 /// will deselect the chip. This is the logical selection, and
WiredHome 19:3f82c1161fd2 1744 /// the pin selection is the invert of this.
WiredHome 19:3f82c1161fd2 1745 /// @returns success/failure code. @see RetCode_t.
WiredHome 19:3f82c1161fd2 1746 ///
WiredHome 79:544eb4964795 1747 RetCode_t _select(bool chipsel);
WiredHome 19:3f82c1161fd2 1748
WiredHome 66:468a11f05580 1749 /// Wait while the status register indicates the controller is busy.
WiredHome 66:468a11f05580 1750 ///
WiredHome 72:ecffe56af969 1751 /// @param[in] mask is the mask of bits to monitor.
WiredHome 66:468a11f05580 1752 /// @returns true if a normal exit.
WiredHome 66:468a11f05580 1753 /// @returns false if a timeout exit.
WiredHome 66:468a11f05580 1754 ///
WiredHome 66:468a11f05580 1755 bool _WaitWhileBusy(uint8_t mask);
WiredHome 66:468a11f05580 1756
WiredHome 66:468a11f05580 1757 /// Wait while the the register anded with the mask is true.
WiredHome 66:468a11f05580 1758 ///
WiredHome 72:ecffe56af969 1759 /// @param[in] reg is the register to monitor
WiredHome 72:ecffe56af969 1760 /// @param[in] mask is the bit mask to monitor
WiredHome 66:468a11f05580 1761 /// @returns true if it was a normal exit
WiredHome 66:468a11f05580 1762 /// @returns false if it was a timeout that caused the exit.
WiredHome 66:468a11f05580 1763 ///
WiredHome 66:468a11f05580 1764 bool _WaitWhileReg(uint8_t reg, uint8_t mask);
WiredHome 66:468a11f05580 1765
WiredHome 68:ab08efabfc88 1766 /// set the spi port to either the write or the read speed.
WiredHome 68:ab08efabfc88 1767 ///
WiredHome 68:ab08efabfc88 1768 /// This is a private API used to toggle between the write
WiredHome 68:ab08efabfc88 1769 /// and the read speed for the SPI port to the RA8875, since
WiredHome 68:ab08efabfc88 1770 /// it can accept writes faster than reads.
WiredHome 68:ab08efabfc88 1771 ///
WiredHome 72:ecffe56af969 1772 /// @param[in] writeSpeed when true selects the write frequency,
WiredHome 68:ab08efabfc88 1773 /// and when false it selects the read frequency.
WiredHome 68:ab08efabfc88 1774 ///
WiredHome 68:ab08efabfc88 1775 void _setWriteSpeed(bool writeSpeed);
WiredHome 68:ab08efabfc88 1776
WiredHome 19:3f82c1161fd2 1777 /// The most primitive - to write a data value to the SPI interface.
WiredHome 19:3f82c1161fd2 1778 ///
WiredHome 72:ecffe56af969 1779 /// @param[in] data is the value to write.
WiredHome 19:3f82c1161fd2 1780 /// @returns a value read from the port, since SPI is often shift
WiredHome 19:3f82c1161fd2 1781 /// in while shifting out.
WiredHome 19:3f82c1161fd2 1782 ///
WiredHome 79:544eb4964795 1783 unsigned char _spiwrite(unsigned char data);
WiredHome 19:3f82c1161fd2 1784
WiredHome 19:3f82c1161fd2 1785 /// The most primitive - to read a data value to the SPI interface.
WiredHome 19:3f82c1161fd2 1786 ///
WiredHome 19:3f82c1161fd2 1787 /// This is really just a specialcase of the write command, where
WiredHome 19:3f82c1161fd2 1788 /// the value zero is written in order to read.
WiredHome 19:3f82c1161fd2 1789 ///
WiredHome 19:3f82c1161fd2 1790 /// @returns a value read from the port, since SPI is often shift
WiredHome 19:3f82c1161fd2 1791 /// in while shifting out.
WiredHome 19:3f82c1161fd2 1792 ///
WiredHome 79:544eb4964795 1793 unsigned char _spiread();
WiredHome 19:3f82c1161fd2 1794
WiredHome 75:ca78388cfd77 1795 const uint8_t * pKeyMap;
WiredHome 75:ca78388cfd77 1796
WiredHome 19:3f82c1161fd2 1797 SPI spi; ///< spi port
WiredHome 68:ab08efabfc88 1798 bool spiWriteSpeed; ///< indicates if the current mode is write or read
WiredHome 68:ab08efabfc88 1799 unsigned long spiwritefreq; ///< saved write freq
WiredHome 66:468a11f05580 1800 unsigned long spireadfreq; ///< saved read freq
WiredHome 19:3f82c1161fd2 1801 DigitalOut cs; ///< chip select pin, assumed active low
WiredHome 19:3f82c1161fd2 1802 DigitalOut res; ///< reset pin, assumed active low
WiredHome 19:3f82c1161fd2 1803 const unsigned char * font; ///< reference to an external font somewhere in memory
WiredHome 37:f19b7e7449dc 1804 loc_t cursor_x, cursor_y; ///< used for external fonts only
WiredHome 19:3f82c1161fd2 1805
WiredHome 19:3f82c1161fd2 1806 #ifdef PERF_METRICS
WiredHome 19:3f82c1161fd2 1807 typedef enum
WiredHome 19:3f82c1161fd2 1808 {
WiredHome 19:3f82c1161fd2 1809 PRF_CLS,
WiredHome 41:2956a0a221e5 1810 PRF_DRAWPIXEL,
WiredHome 41:2956a0a221e5 1811 PRF_PIXELSTREAM,
WiredHome 41:2956a0a221e5 1812 PRF_READPIXEL,
WiredHome 41:2956a0a221e5 1813 PRF_READPIXELSTREAM,
WiredHome 19:3f82c1161fd2 1814 PRF_DRAWLINE,
WiredHome 19:3f82c1161fd2 1815 PRF_DRAWRECTANGLE,
WiredHome 19:3f82c1161fd2 1816 PRF_DRAWROUNDEDRECTANGLE,
WiredHome 19:3f82c1161fd2 1817 PRF_DRAWTRIANGLE,
WiredHome 19:3f82c1161fd2 1818 PRF_DRAWCIRCLE,
WiredHome 19:3f82c1161fd2 1819 PRF_DRAWELLIPSE,
WiredHome 19:3f82c1161fd2 1820 METRICCOUNT
WiredHome 19:3f82c1161fd2 1821 } method_e;
WiredHome 19:3f82c1161fd2 1822 unsigned long metrics[METRICCOUNT];
WiredHome 75:ca78388cfd77 1823 unsigned long idletime_usec;
WiredHome 19:3f82c1161fd2 1824 void RegisterPerformance(method_e method);
WiredHome 19:3f82c1161fd2 1825 Timer performance;
WiredHome 19:3f82c1161fd2 1826 #endif
WiredHome 19:3f82c1161fd2 1827 };
WiredHome 19:3f82c1161fd2 1828
WiredHome 19:3f82c1161fd2 1829 //} // namespace
WiredHome 19:3f82c1161fd2 1830
WiredHome 19:3f82c1161fd2 1831 //using namespace SW_graphics;
WiredHome 19:3f82c1161fd2 1832
WiredHome 23:a50ded45dbaf 1833
WiredHome 23:a50ded45dbaf 1834 #ifdef TESTENABLE
WiredHome 23:a50ded45dbaf 1835 // ______________ ______________ ______________ _______________
WiredHome 23:a50ded45dbaf 1836 // /_____ _____/ / ___________/ / ___________/ /_____ ______/
WiredHome 23:a50ded45dbaf 1837 // / / / / / / / /
WiredHome 23:a50ded45dbaf 1838 // / / / /___ / /__________ / /
WiredHome 23:a50ded45dbaf 1839 // / / / ____/ /__________ / / /
WiredHome 23:a50ded45dbaf 1840 // / / / / / / / /
WiredHome 23:a50ded45dbaf 1841 // / / / /__________ ___________/ / / /
WiredHome 23:a50ded45dbaf 1842 // /__/ /_____________/ /_____________/ /__/
WiredHome 23:a50ded45dbaf 1843
WiredHome 23:a50ded45dbaf 1844 #include "WebColors.h"
WiredHome 23:a50ded45dbaf 1845 #include "Arial12x12.h"
WiredHome 23:a50ded45dbaf 1846 #include <algorithm>
WiredHome 23:a50ded45dbaf 1847
WiredHome 23:a50ded45dbaf 1848 extern "C" void mbed_reset();
WiredHome 23:a50ded45dbaf 1849
WiredHome 23:a50ded45dbaf 1850 /// This activates a small set of tests for the graphics library.
WiredHome 23:a50ded45dbaf 1851 ///
WiredHome 23:a50ded45dbaf 1852 /// Call this API and pass it the reference to the display class.
WiredHome 23:a50ded45dbaf 1853 /// It will then run a series of tests. It accepts interaction via
WiredHome 23:a50ded45dbaf 1854 /// stdin to switch from automatic test mode to manual, run a specific
WiredHome 23:a50ded45dbaf 1855 /// test, or to exit the test mode.
WiredHome 23:a50ded45dbaf 1856 ///
WiredHome 72:ecffe56af969 1857 /// @param[in] lcd is a reference to the display class.
WiredHome 72:ecffe56af969 1858 /// @param[in] pc is a reference to a serial interface, typically the USB to PC.
WiredHome 23:a50ded45dbaf 1859 ///
WiredHome 23:a50ded45dbaf 1860 void RunTestSet(RA8875 & lcd, Serial & pc);
WiredHome 23:a50ded45dbaf 1861
WiredHome 23:a50ded45dbaf 1862
WiredHome 23:a50ded45dbaf 1863 // To enable the test code, uncomment this section, or copy the
WiredHome 23:a50ded45dbaf 1864 // necessary pieces to your "main()".
WiredHome 23:a50ded45dbaf 1865 //
WiredHome 23:a50ded45dbaf 1866 // #include "mbed.h"
WiredHome 23:a50ded45dbaf 1867 // #include "RA8875.h"
WiredHome 23:a50ded45dbaf 1868 // RA8875 lcd(p5, p6, p7, p12, NC, "tft"); // MOSI, MISO, SCK, /ChipSelect, /reset, name
WiredHome 23:a50ded45dbaf 1869 // Serial pc(USBTX, USBRX);
WiredHome 23:a50ded45dbaf 1870 // extern "C" void mbed_reset();
WiredHome 23:a50ded45dbaf 1871 // int main()
WiredHome 23:a50ded45dbaf 1872 // {
WiredHome 23:a50ded45dbaf 1873 // pc.baud(460800); // I like a snappy terminal, so crank it up!
WiredHome 23:a50ded45dbaf 1874 // pc.printf("\r\nRA8875 Test - Build " __DATE__ " " __TIME__ "\r\n");
WiredHome 23:a50ded45dbaf 1875 //
WiredHome 23:a50ded45dbaf 1876 // pc.printf("Turning on display\r\n");
WiredHome 23:a50ded45dbaf 1877 // lcd.Reset();
WiredHome 23:a50ded45dbaf 1878 // lcd.Power(true); // display power is on, but the backlight is independent
WiredHome 23:a50ded45dbaf 1879 // lcd.Backlight(0.5);
WiredHome 23:a50ded45dbaf 1880 // RunTestSet(lcd, pc);
WiredHome 23:a50ded45dbaf 1881 // }
WiredHome 23:a50ded45dbaf 1882
WiredHome 23:a50ded45dbaf 1883 #endif // TESTENABLE
WiredHome 23:a50ded45dbaf 1884
WiredHome 56:7a85d226ad0d 1885 #endif