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@84:e102021864b5, 2015-01-12 (annotated)

Committer:
WiredHome
Date:
Mon Jan 12 01:10:35 2015 +0000
Revision:
84:e102021864b5
Parent:
83:7bad0068cca0
Child:
85:022bba13c5c4
Added SetOrientation method, to orient the display in one of 0, 90, 180, 270. Removed a rotation parameter from the SetTextFontControl method.

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