240x320 keyboard touch

[suntchi2018]

Hi everyone,
by chance some good soul has created a touch keyboard with lowercase and uppercase suitable for a 240x320 display.

[Bodmer]

The code you noticed in #1616 is the only implementation I have seen.

[suntchi2018]

Thanks Bodmer, I wanted to implement a keyboard in my seasoner, and I tried that code but in addition to not understanding how it works, I have a lot of difficulty modifying it for my needs.
There are some "if" with "else" without parentheses that I've never seen and I need to figure out how they work, plus I don't understand how to align touch to keyboard.

`/*
#define TFT_BLACK 0x0000
#define TFT_NAVY 0x000F
#define TFT_DARKGREEN 0x03E0
#define TFT_DARKCYAN 0x03EF
#define TFT_MAROON 0x7800
#define TFT_PURPLE 0x780F
#define TFT_OLIVE 0x7BE0
#define TFT_LIGHTGREY 0xD69A
#define TFT_DARKGREY 0x7BEF
#define TFT_BLUE 0x001F
#define TFT_GREEN 0x07E0
#define TFT_CYAN 0x07FF
#define TFT_RED 0xF800
#define TFT_MAGENTA 0xF81F
#define TFT_YELLOW 0xFFE0
#define TFT_WHITE 0xFFFF
#define TFT_ORANGE 0xFDA0
#define TFT_GREENYELLOW 0xB7E0
#define TFT_PINK 0xFE19 //Lighter pink, was 0xFC9F
#define TFT_BROWN 0x9A60
#define TFT_GOLD 0xFEA0
#define TFT_SILVER 0xC618
#define TFT_SKYBLUE 0x867D
#define TFT_VIOLET 0x915C
*/

#include <FS.h> //spiffs miatt
#include "TFT_eSPI.h"
#include <SPI.h>

unsigned long currentMillis, previousMillis;
int SORTAV = 31; // 31
int OSZTAV = 157; // 100
int xx = 1; int yy = 1;
uint8_t thingchannel = 1;
uint8_t chtorles;
uint16_t t_x = 0, t_y = 0; // To store the touch coordinates

#define IsWithin(x, a, b) ((x>=a)&&(x<=b))

TFT_eSPI tft = TFT_eSPI();

// Posizione tastiera
#define KEYY 95 // KEYBOARD Y POS OFFSET
#define KEYLX 12 // KEYBOARD LEFT X POS

//Dimensione tasti e spaziatura
#define KEYDIST 30 //30 KEY DISTANCE
#define KEYH 25 //25 key height
#define KEYW 25 //25 key WIDTH

// posizione testo
#define KEYTOX 8 //5 KEY TEXT OFFSET X
#define KEYTOY 6 //5 KEY TEXT OFFSET Y
#define SKEYW (KEYDIST+(KEYW/2)) //special keys size
#define KEYDELAY 300 //ritardo

const char Mobile_KBUP[3][13] PROGMEM = {
{0, 13, 10, 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P'},
{0, 13, 10, 'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', '.'},
{3, 10, 7, 'Z', 'X', 'C', 'V', 'B', 'N', 'M'},
};

const char Mobile_KBDN[3][13] PROGMEM = {
{0, 13, 10, 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p'},
{0, 13, 10, 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', '.'},
{3, 10, 7, 'z', 'x', 'c', 'v', 'b', 'n', 'm'},
};

const char Mobile_SymKeys[3][13] PROGMEM = {
{0, 13, 10, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'},
{1, 12, 9, '\', '|', '[', ']', '{', '}', '$', '^', ''},
{3, 10, 7, '#', '&', '@', '<', ';', '>', ''}
};

const char Mobile_NumKeys[3][13] PROGMEM = {
{0, 13, 10, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'},
{0, 13, 10, '~', ''', '"', '+', '!', '%', '/', '=', '(', ')'},
{3, 10, 7, '&', '@', ',', '.', '-', '*', ':' }
};

void updateBottomStatus(unsigned int colorbg, unsigned int colorfg, String text);

const char textLimit = 25;
char MyBuffer[textLimit + 1] = "abc123";

void MakeKB_Button(const char type[][13]) {

tft.setTextSize(1);
tft.setTextFont(2);//4 **************
tft.setTextColor(TFT_WHITE, TFT_RED);
for (int y = 0; y < 3; y++) {
int ShiftRight = (KEYDIST / 2) * pgm_read_byte(&(type[y][0]));
for (int x = 3; x < 13; x++) {
if (x >= pgm_read_byte(&(type[y][1])))
break;

  drawButton(KEYLX + (KEYDIST * (x - 3)) + ShiftRight, KEYY + (KEYDIST * y), KEYW, KEYH); // this will draw the button on the screen by so many pixels
  
  tft.setCursor(KEYLX + KEYTOX + (KEYDIST * (x - 3)) + ShiftRight, KEYY + KEYTOY + (KEYDIST * y));
  tft.print(char(pgm_read_byte(&(type[y][x]))));
}

}
//ShiftKey
drawButton(KEYLX, KEYY + (2 * KEYDIST), KEYDIST, KEYH);
tft.setCursor(KEYLX + (2 * KEYTOX) - 8 , KEYY + (2 * KEYDIST) + KEYTOY - 2);
tft.print(" ^ ");

//Special Characters
drawButton(KEYLX, KEYY + (3 * KEYDIST), (KEYDIST + KEYW), KEYH);
tft.setCursor(KEYLX + 1 + KEYTOX / 2, KEYY + (3 * KEYDIST) + KEYTOY - 2);
tft.print(F(" Spec "));

//BackSpace
drawButton(KEYLX + (8 * KEYDIST) + (KEYDIST / 2), KEYY + (2 * KEYDIST), SKEYW, KEYH);
tft.setCursor(KEYLX + (8 * KEYDIST) + (KEYDIST / 2) + KEYTOX + 8, KEYY + (2 * KEYDIST) + KEYTOY);
tft.print(F("<-"));

//Return
drawButton(KEYLX + (8 * KEYDIST) + (KEYDIST / 2), KEYY + (3 * KEYDIST), SKEYW, KEYH);
tft.setCursor(KEYLX + (8 * KEYDIST) + (KEYDIST / 2) + 4 + KEYTOX, KEYY + (3 * KEYDIST) + KEYTOY + 1);
tft.print(F("RT"));

//Spacebar
drawButton(KEYLX + (2 * KEYDIST), KEYY + (3 * KEYDIST), 6 * KEYDIST, KEYH);
tft.setCursor(KEYLX + (2 * KEYDIST) + 55 + KEYTOX, KEYY + (3 * KEYDIST) + KEYTOY + 1);
tft.print(F("SPACE BAR"));
}

void drawButton(int x, int y, int w, int h) {
// grey
tft.fillRoundRect(x - 3, y + 3, w, h, 3, TFT_BLUE);
// white
tft.fillRoundRect(x, y, w, h, 3, TFT_WHITE);
//red
tft.fillRoundRect(x + 1, y + 1, w - 1 * 2, h - 1 * 2, 3, TFT_RED);
}

char bufIndex = 0;

void GetKeyPress(char * textBuffer) {
//
char key = 0;
//static
bool shiftk = false, special = false, back = false, lastSp = false, lastSh = false;
tft.setTextSize(2);
bufIndex = strlen(textBuffer);
while (1) {
// Retrieve a point
// Pressed will be set true is there is a valid touch on the screen
boolean pressed = tft.getTouch(&t_x, &t_y);

if (pressed) {
  Serial.print(t_x);
  Serial.print(",");
  Serial.println(t_y);

  //ShiftKey
  if (TouchButton(KEYLX, KEYY + (2 * KEYDIST), KEYDIST, KEYH)) {
    shiftk = !shiftk;
    delay(KEYDELAY);
  }
  if (TouchButton(KEYLX, KEYY + (3 * KEYDIST), (KEYDIST + KEYW), KEYH)); {
    special = !special;
    delay(KEYDELAY);
  }

  if (special != lastSp || shiftk != lastSh) {
    if (special) {
      if (shiftk) {
        tft.fillRect(0, KEYY, 479, 319 - KEYLX, TFT_BLUE);
        MakeKB_Button(Mobile_SymKeys);
        Serial.println("Mobile_SymKeys");
        } else {
          tft.fillRect(0, KEYY, 479, 319 - KEYLX, TFT_BLUE);
          MakeKB_Button(Mobile_NumKeys);
          Serial.println("Mobile_NumKeys");
      }
    } else {
      tft.fillRect(0, KEYY, 479, 319 - KEYLX, TFT_BLUE);
    if (shiftk) 
        MakeKB_Button(Mobile_KBUP);
    else
        MakeKB_Button(Mobile_KBDN);
       tft.setTextColor(TFT_WHITE, TFT_RED);
       Serial.println("Mobile_KBUP");
    }
    
   if (special) 
      tft.setTextColor(TFT_RED, TFT_GREEN); 
   else
      tft.setTextColor(TFT_WHITE, TFT_RED);
      tft.setCursor(KEYLX + 1 + KEYTOX / 2, KEYY + (3 * KEYDIST) + KEYTOY - 2);
      tft.print(F(" Spec "));
   
   if (shiftk)
      tft.setTextColor(TFT_RED, TFT_GREEN);
   else
      tft.setTextColor(TFT_WHITE, TFT_RED);
      
   tft.setCursor(KEYLX + (2 * KEYTOX) - 8 , KEYY + (2 * KEYDIST) + KEYTOY - 2);
   tft.print(" ^ ");
   lastSh = shiftk;
   lastSp = special;
   lastSh = shiftk;
  } 

  for (int y = 0; y < 3; y++) {
    int ShiftRight;
    if (special) {
     if (shiftk)
        ShiftRight = (KEYDIST / 2) * pgm_read_byte(&(Mobile_SymKeys[y][0]));
     else
        ShiftRight = (KEYDIST / 2) * pgm_read_byte(&(Mobile_NumKeys[y][0]));
     }
     else
      ShiftRight = (KEYDIST / 2) * pgm_read_byte(&(Mobile_KBUP[y][0]));

    for (int x = 3; x < 13; x++) {
      if (x >=  (special ? (shiftk ? pgm_read_byte(&(Mobile_SymKeys[y][1])) : pgm_read_byte(&(Mobile_NumKeys[y][1]))) : pgm_read_byte(&(Mobile_KBUP[y][1])) )) 
        break;
      
      if (TouchButton(KEYLX + (KEYDIST * (x - 3)) + ShiftRight, KEYY + (KEYDIST * y), KEYW, KEYH)) {
        
        if (bufIndex < (textLimit - 1)) {
          delay(KEYDELAY);

          if (special) {
            if (shiftk)
              textBuffer[bufIndex] = pgm_read_byte(&(Mobile_SymKeys[y][x]));
            else
              textBuffer[bufIndex] = pgm_read_byte(&(Mobile_NumKeys[y][x]));
          } else {
            if (shiftk) 
              textBuffer[bufIndex] = pgm_read_byte(&(Mobile_KBUP[y][x]));
            else
              textBuffer[bufIndex] = pgm_read_byte(&(Mobile_KBDN[y][x]));
          }
          bufIndex++;
        }
        break;
      }
    }
  }

  //Spacebar
  if (TouchButton(KEYLX + (2 * KEYDIST), KEYY + (3 * KEYDIST), 6 * KEYDIST, KEYH)) {
    textBuffer[bufIndex++] = ' ';
    delay(KEYDELAY);
  }

  //BackSpace
  if (TouchButton(KEYLX + (8 * KEYDIST) + (KEYDIST / 2), KEYY + (2 * KEYDIST), SKEYW, KEYH)) {
    if ((bufIndex) > 0) 
      bufIndex--;
      textBuffer[bufIndex] = 0;
      tft.fillRect(0, 100, 480, 20, TFT_BLUE); //Button Shading
      delay(KEYDELAY);
  }

    //Return
    if (TouchButton(KEYLX + (8 * KEYDIST) + (KEYDIST / 2), KEYY + (3 * KEYDIST), SKEYW, KEYH)) {
       Serial.println();
       Serial.println(textBuffer);
       return;
    }
  }
  tft.setTextColor(TFT_WHITE, TFT_RED);
  tft.setCursor(KEYLX, 10);// 100 posizione del testo scritto/buffer max 25 caratteri
  tft.print(textBuffer);

}
}

//*****************************************************************************************************
void setup(void) {
Serial.begin(115200);
tft.init();

tft.setRotation(1);

tft.fillScreen(TFT_BLUE);
tft.setCursor(0, 20);//0,20
tft.setTextFont(1);
tft.setTextSize(2);
tft.setTextColor(TFT_WHITE, TFT_BLACK);
tft.println("XXX");

while (tft.getTouch(&t_x, &t_y));
tft.fillScreen(TFT_BLUE);
tft.setTextSize(2);
}

//*****************************************************************************************************
void loop() {

// See if there's any touch data for us
GetKeyPress(MyBuffer);
tft.setTextColor(TFT_LIGHTGREY, TFT_BLUE); // Colore tasti
tft.setCursor(KEYLX, 10);
tft.print(MyBuffer);

Serial.println(MyBuffer);
for (char ii = 0; ii < textLimit; ii++) {
MyBuffer[ii] = '\0';
}
delay(1000);
tft.fillScreen(TFT_LIGHTGREY);
MakeKB_Button(Mobile_KBDN);
delay(1000);

}

//******************************************************************
byte TouchButton(int x, int y, int w, int h) {

int X, Y;
Y = t_y;
X = t_x;
byte zz = IsWithin(X, x, x + w) & IsWithin(Y, y, y + h);
Serial.print(" in:"); Serial.println(zz);
return (zz);
}

//*********************************************************************************
void updateBottomStatus(unsigned int colorbg, unsigned int colorfg, String text) {

tft.setTextDatum(TL_DATUM);
tft.setCursor(5, 300);
tft.setTextFont(1);
tft.setTextSize(2);
tft.setTextColor(colorbg, colorfg);
tft.print(text);

}
`