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@85:022bba13c5c4, 2015-01-13 (annotated)

Committer:
WiredHome
Date:
Tue Jan 13 12:31:44 2015 +0000
Revision:
85:022bba13c5c4
Parent:
84:e102021864b5
Child:
86:e86b355940f4
Improved error checking on several methods. In general, if the relevant coordinates of an object are offscreen, it will return bad_parameter, rather than to draw it badly.

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