steering-wheel/lib/arduino-ediptft-master/EDIPTFT.h

//
// Library for controlling Electronic Assembly eDIPTFT displays
//
//      Copyright (c) 2013 Stefan Gofferje. All rights reserved.
//
//      This library is free software; you can redistribute it and/or
//      modify it under the terms of the GNU Lesser General Public
//      License as published by the Free Software Foundation; either
//      version 2.1 of the License, or (at your option) any later
//      version.
//
//      This library is distributed in the hope that it will be
//      useful, but WITHOUT ANY WARRANTY; without even the implied
//      warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//      PURPOSE.  See the GNU Lesser General Public License for more
//      details.
//
//      You should have received a copy of the GNU Lesser General
//      Public License along with this library; if not, write to the
//      Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
//      Boston, MA 02110-1301 USA
//

#ifndef EDIPTFT_h
#define EDIPTFT_h

#include "Arduino.h"

// Devices
#define EDIP128 1
#define EDIP160 1
#define EDIP240 1
#define EDIP320 2

// Set your device
#define DEVICE EDIP320
#define COORD_SIZE DEVICE // Byte count for coordinates
#define SERIAL_DEV Serial3

#define EA_TRANSPARENT 0
#define EA_BLACK 1
#define EA_BLUE 2
#define EA_RED 3
#define EA_GREEN 4
#define EA_PURPLE 5
#define EA_CYAN 6
#define EA_YELLOW 7
#define EA_WHITE 8
#define EA_DARKGREY 9
#define EA_ORANGE 10
#define EA_LILA 11
#define EA_DARKPURPLE 12
#define EA_MINT 13
#define EA_GRASSGREEN 14
#define EA_LIGHTBLUE 15
#define EA_LIGHTGREY 16

// Fonts
#define EA_FONT8X8 0
#define EA_FONT4X6 1
#define EA_FONT6X8 2
#define EA_FONT7X12 3
#define EA_GENEVA10 4
#define EA_CHICAGO14 5
#define EA_SWISS30B 6
#define EA_BIGZIF57 7

#define NAK 0x15
#define ACK 0x06
#define ESC 0x1B

#define uint unsigned int

class EDIPTFT {
public:
  EDIPTFT(boolean smallprotocol = true, boolean disconnected = false);
  boolean disconnected;

  void begin(long baud = 115200);

  // helper functions
  char readByte();
  char waitandreadByte();
  unsigned char datainBuffer();
  int readBuffer(char* data);
  void smallProtoSelect(char address);
  void smallProtoDeselect(char address);
  void sendData(char* data, char len);

  // Basic display functions
  /*! \brief Clear display
   *
   * Clear display contents (all pixels off) and remove touch areas
   */
  void clear();

  /*! \brief Delete display
   *
   * Delete display contents (all pixels off). Touch areas are still active.
   */
  void deleteDisplay();

  /*! \brief Invert display
   *
   * Invert display contents (invert all pixels)
   */
  void invert();

  void setDisplayColor(char fg, char bg);

  void fillDisplayColor(char bg);

  /*! \brief Terminal on
   *
   * Terminal display is switched on if \a on is true
   *
   * \param on determine if terminal is switched on
   */
  void terminalOn(boolean on);

  /*! \brief Load internal image
   *
   * Load internal image with the \a nr (0..255) from the *EEPROM* memory to
   * \a x1, \a y1
   *
   * \param x1 x position of image on the display
   * \param y1 y position of image on the display
   * \param nr number of the image on the *EEPROM*
   */
  void loadImage(int x1, int y1, int nr);

  /*! \brief Cursor on/off
   *
   * Switch cursor on/off
   *
   * \param on `n1=0`: cursor is invisible, `n1=1`: cursor flashes
   */
  void cursorOn(boolean on);

  /*! \brief Position cursor
   *
   * origin upper-left corner `(1, 1)`
   *
   * \param col new cursor column
   * \param row new cursor row
   */
  void setCursor(char col, char row);

  void displayLight(char no);
  // Bargraph
  /*! \brief Define bargraph
   *
   * Define bargraph to form the rectangle enclosing the
   * bargraph. \a sv and \a ev are the values for `0%` and `100%`.
   *
   * \param dir direction ('L'eft, 'R'ight, 'O'up, 'U'down)
   * \param no bargraph number `1..32`
   * \param x1 upper left x coordinate
   * \param y1 upper left y coordinate
   * \param x2 lower right x coordinate
   * \param y2 lower right y coordinate
   * \param sv start value (0%)
   * \param ev end value (100%)

   * \param type set the style of the bargraph:\n
   *             `type=0`: pattern bar, \a mst=bar pattern,\n
   *             `type=1`: pattern bar in rectangle, \a mst=bar pattern,\n
   *             `type=2`: pattern line, \a mst=line width,\n
   *             `type=3`: pattern line in rectangle, \a mst=line width
   *
   * \param mst additional parameter for type specification
   */
  void defineBargraph(char dir, char no, int x1, int y1, int x2, int y2,
                      byte sv, byte ev, char type, char mst);

  /*! \brief Update bargraph
   *
   * Set and draw the bargraph *no* to the new *value*
   *
   * \param no number of the bargraph `1..32`
   * \param val new value of the bargraph
   */
  void updateBargraph(char no, char val);

  void setBargraphColor(char no, char fg, char bg, char fr);

  /*! \brief Set bargraph by touch
   *
   * The bargraph with number *no* is defined for input by touch panel
   *
   * \param no number of the bargraph `1..32`
   */
  void makeBargraphTouch(char no);

  void linkBargraphLight(char no);

  /*! \brief Delete bargraph
   *
   * The definition of the bargraph with number *no* becomes invalid. If the
   * bargraph was defined as input with touch, the touchfield will also be
   * deleted.
   *
   * \param no number of the bargraph `1..32`
   * \param n1 additional parameter\n
   *           `n1=0`: bargraph remains visible\n
   *           `n1=1`: bargraph is deleted
   */
  void deleteBargraph(char no, char n1);

  // Instrument
  void defineInstrument(char no, int x1, int y1, char image, char angle,
                        char sv, char ev);
  void updateInstrument(char no, char val);
  void redrawInstrument(char no);
  void deleteInstrument(char no, char n1, char n2);

  // Text
  void setTextColor(char fg, char bg);

  /*! \brief Set font
   *
   * Set font with the number *font*
   *
   * \param font font number `font=0..15`, use font defines here
   */
  void setTextFont(char font);

  void setTextSize(int xsize, int ysize);

  /*! \brief Set text angle
   *
   * Set text output angle
   *
   * \param angle text output angle\n
                  `angle=0`: 0°
                  `angle=1`: 90°
   */
  void setTextAngle(char angle);

  /*! \brief Draw text on display
   *
   * Draw a *text* on screen. Several lines are separated by the character `|`
   * ($7C).
   * * place text between `~`: characters flash on/off
   * * place text between `@`: characters flash inversely
   * * use `\\` as to escape special characters
   *
   * \param x1: x coordinate
   * \param y1: y coordinate
   * \param justification set text justification to `L`(eft), `R`(ight),
   *                      `C`(enter)
   * \param text text to draw on display
   */
  void drawText(uint16_t x1, uint16_t y1, char justification, const char* text);

  /*! \brief Draw text on display in an area
   *
   * Draw a *text* on screen. Several lines are separated by the character `|`
   * ($7C).
   * * place text between `~`: characters flash on/off
   * * place text between `@`: characters flash inversely
   * * use `\\` as to escape special characters
   *
   * \param align set alignment in the rectangle. 1 = top left, 2 = top
   * center, 3 = top right, 4 = center left, 5 = center, 6 = center right, 7 =
   * bottom left, 8 = bottom center, 9 = bottom right.
   * \param text text to draw on display
   */
  void drawTextInRect(int x1, int y1, int x2, int y2, uint8_t align,
                      const char* text);

  // Rectangle and Line
  void setLineColor(char fg, char bg);

  /*! \brief Point size/line thickness
   *
   * \param x x-point size (1..15)
   * \param y y-point size (1..15)
   */
  void setLineThick(char x, char y);

  /*! \brief Draw straight line
   *
   * Draw straight line from point *x1*, *y1* to point *x2*, *y2*
   */
  void drawLine(int x1, int y1, int x2, int y2);

  /*! \brief Draw rectangle
   *
   * Draw four straight lines as a rectangle from *x1*, *y1* to *x2*, *y2*
   */
  void drawRect(int x1, int y1, int x2, int y2);

  void drawRectf(int x1, int y1, int x2, int y2, char color);

  /*! \brief Clear rectangular area */
  void clearRect(int x1, int y1, int x2, int y2);

  // Touch keys

  /*! \brief Define touch key
   *
   * Key remains pressed as long as there is contact. The area from *x1*, *y1*
   * to *x2*, *y2* is drawn with actual border and defined as a key.
   * The label is drawn with the current touch font. The first character
   * determines the alignment of the text (`L`(eft), `R`(ight), `C`(enter)).
   * Multiline texts are separated by the character `|`.
   *
   * \param down return/touchmacro (1-255) if pressed
   * \param up return/touchmacro (1-255) if released
   * \param text label of the touch key
   */
  void defineTouchKey(int x1, int y1, int x2, int y2, char down, char up,
                      const char* text);

  /*! \brief Define touch switch
   *
   * Status of the switch toggles after each contact. The area from *x1*, *y1*
   * to *x2*, *y2* is drawn with actual border and defined as a key.
   * The label is drawn with the current touch font. The first character
   * determines the alignment of the text (`L`(eft), `R`(ight), `C`(enter)).
   * Multiline texts are separated by the character `|`.
   *
   * \param down return/touchmacro (1-255) if pressed
   * \param up return/touchmacro (1-255) if released
   * \param text label of the touch key
   */
  void defineTouchSwitch(int x1, int y1, int x2, int y2, char down, char up,
                         const char* text);

  /*! \brief Define touch switch with image
   *
   * Status of the switch toggles after each contact. Image number *img* is
   * loaded to *x*, *y* and defined as a switch.
   * The label is drawn with the current touch font. The first character
   * determines the alignment of the text (`L`(eft), `R`(ight), `C`(enter)).
   * Multiline texts are separated by the character `|`.
   *
   * \param down return/touchmacro (1-255) if pressed
   * \param up return/touchmacro (1-255) if released
   * \param text label of the touch switch
   */
  void defineTouchSwitch(int x, int y, int img, char downcode, char upcode,
                         const char* text);

  /*! \brief Set touch switch
   *
   * Set the status of the touch switch with the return code *code*
   * to *value*.
   *
   * \param code Return code of the switch
   * \param value `value=0`: OFF, `value=1`: ON
   */
  void setTouchSwitch(char code, char value);

  void setTouchkeyColors(char n1, char n2, char n3, char s1, char s2, char s3);

  /*! \brief Label font
   *
   * Apply font with number *font* for touch key labels
   */
  void setTouchkeyFont(char font);

  void setTouchkeyLabelColors(char nf, char sf);

  /*! \brief Radio group for switches
   *
   * `group=0`: newly defined switches don't belong to a group
   * `group=1..255`: newly defined switches are assigned to the group with
   *                 the given number
   * Only one switch in a group is active at once. All others are deactivated.
   * For switches only the *down code* is applicable. The *up code* will be
   * ignored.
   */
  void setTouchGroup(char group);

  /*! \brief Delete toch area by up- or downcode
   *
   *  The touch area with the return code is removed from the touch query
   *
   *  \param code the code of the touch area (code=0: all touch areas)
   *  \param n1 n1==0: the area remains visible on the display,
   *            n1==1: the area is deleted
   */
  void removeTouchArea(char code, char n1);

  // Macro Calls
  /*! \brief Run macro
   *
   * Call the (normal) macro with number *nr* (max. 7 levels).
   */
  void callMacro(uint nr);

  /*! \brief Run touch macro
   *
   * Call touch macro with number *nr* (max. 7 levels)
   */
  void callTouchMacro(uint nr);

  /*! \brief Run menu macro
   *
   * Call menu macro with number *nr* (max. 7 levels)
   */
  void callMenuMacro(uint nr);

  /*! \brief Define touch key with menu function
   *
   * Define the area from *x1*, *y1* to *x2*, *y2*  as a menu key.
   * The first character determines the direction in which the menu opens
   * (R=right,L=left,O=up,U=down) The second character determines the alignment
   * of the touch text (C=center,L=left-,R=right justified) The menu items are
   * separated by the character '|' ($7C,dec:124) (e.g.
   * "UCkey|item1|item2|item3". The key text is written with the current touch
   * font and the menu items are written with the current menu font. The
   * background of the menu is saved automatically. \param downcode `1-255`
   * return/touchmacro if pressed \param upcode `1-255` return/touchmacro if
   * released \param mnucode return/menumacro+(item nr - 1) after selection of a
   *                menu item
   * \param text string with the key text and menu items
   */
  void defineTouchMenu(int x1, int y1, int x2, int y2, char downcode,
                       char upcode, char mnucode, const char* text);

  /*! \brief Send *open* signal after a Menu open request has been sent from
   * TFT.
   *
   *  If a touch menu is not set to open automatically the TFT sends a
   *  request 'ESC T 0'. This function sends 'ESC N T 2' to open the menu.
   */
  void openTouchMenu();

  /*! \brief Set menu font
   *
   * Set font with number *font* (`0..15`) for menu display
   */
  void setMenuFont(char font);

  /*! \brief enable/disable touchmenu automation
   *
   * if val==true touch menu opens automatically, if val==false touchmenu
   * doesn' t open automatically, instead a request is sent to the
   * host computer, which can then open the menu with openTouchMenu()
   */
  void setTouchMenuAutomation(bool val);

private:
  boolean _smallprotocol;
  int _counter;
  unsigned char bytesAvailable();
  void waitBytesAvailable();
  void sendByte(char data);
  void sendSmall(char* data, char len);
  void sendSmallDC2(char* data, char len);
};
#endif