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@127:db7f2c704693, 2016-08-06 (annotated)

Committer:
WiredHome
Date:
Sat Aug 06 20:04:23 2016 +0000
Revision:
127:db7f2c704693
Parent:
125:7a0b70f56550
Child:
131:5bd6ba2ee4a1
Added GetUserFont and GetTextFontSize apis, which were helpful for saving and restoring settings on the fly.

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