Delete tft_gui.ino

This commit is contained in:
Ashhar Farhan 2019-12-18 11:44:46 +05:30 committed by GitHub
parent e19bec690a
commit 55d56e6d61
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

View File

@ -1,596 +0,0 @@
#include <XPT2046_Touchscreen.h>
#include <SPI.h>
//#include "ubitx_font.h"
#include <avr/pgmspace.h>
#define TFT_CS 10
#define TFT_RS 9
// Color definitions
#define ILI9341_BLACK 0x0000 ///< 0, 0, 0
#define ILI9341_NAVY 0x000F ///< 0, 0, 123
#define ILI9341_DARKGREEN 0x03E0 ///< 0, 125, 0
#define ILI9341_DARKCYAN 0x03EF ///< 0, 125, 123
#define ILI9341_MAROON 0x7800 ///< 123, 0, 0
#define ILI9341_PURPLE 0x780F ///< 123, 0, 123
#define ILI9341_OLIVE 0x7BE0 ///< 123, 125, 0
#define ILI9341_LIGHTGREY 0xC618 ///< 198, 195, 198
#define ILI9341_DARKGREY 0x7BEF ///< 123, 125, 123
#define ILI9341_BLUE 0x001F ///< 0, 0, 255
#define ILI9341_GREEN 0x07E0 ///< 0, 255, 0
#define ILI9341_CYAN 0x07FF ///< 0, 255, 255
#define ILI9341_RED 0xF800 ///< 255, 0, 0
#define ILI9341_MAGENTA 0xF81F ///< 255, 0, 255
#define ILI9341_YELLOW 0xFFE0 ///< 255, 255, 0
#define ILI9341_WHITE 0xFFFF ///< 255, 255, 255
#define ILI9341_ORANGE 0xFD20 ///< 255, 165, 0
#define ILI9341_GREENYELLOW 0xAFE5 ///< 173, 255, 41
#define ILI9341_PINK 0xFC18 ///< 255, 130, 198
#define TEXT_LINE_HEIGHT 18
#define TEXT_LINE_INDENT 5
#define BUTTON_PUSH
#define BUTTON_CHECK
#define BUTTON_SPINNER
GFXfont *gfxFont = NULL;
XPT2046_Touchscreen ts(CS_PIN);
TS_Point ts_point;
//filled from a test run of calibration routine
int slope_x=104, slope_y=137, offset_x=28, offset_y=29;
void readTouchCalibration(){
EEPROM.get(SLOPE_X, slope_x);
EEPROM.get(SLOPE_Y, slope_y);
EEPROM.get(OFFSET_X, offset_x);
EEPROM.get(OFFSET_Y, offset_y);
if (slope_x < 10 || 200 < slope_x){
slope_x=104;
slope_y=137;
offset_x=28;
offset_y=29;
}
}
void writeTouchCalibration(){
EEPROM.put(SLOPE_X, slope_x);
EEPROM.put(SLOPE_Y, slope_y);
EEPROM.put(OFFSET_X, offset_x);
EEPROM.put(OFFSET_Y, offset_y);
}
boolean readTouch(){
boolean istouched = ts.touched();
if (istouched) {
ts_point = ts.getPoint();
return true;
}
return false;
}
void scaleTouch(TS_Point *p){
p->x = ((long)(p->x) * 10l)/(long)(slope_x) - offset_x;
p->y = ((long)(p->y) * 10l)/(long)(slope_y) - offset_y;
}
#if !defined(__INT_MAX__) || (__INT_MAX__ > 0xFFFF)
#define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr))
#else
#define pgm_read_pointer(addr) ((void *)pgm_read_word(addr))
#endif
inline GFXglyph * pgm_read_glyph_ptr(const GFXfont *gfxFont, uint8_t c)
{
#ifdef __AVR__
return &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
#else
// expression in __AVR__ section may generate "dereferencing type-punned pointer will break strict-aliasing rules" warning
// In fact, on other platforms (such as STM32) there is no need to do this pointer magic as program memory may be read in a usual way
// So expression may be simplified
return gfxFont->glyph + c;
#endif //__AVR__
}
inline uint8_t * pgm_read_bitmap_ptr(const GFXfont *gfxFont)
{
#ifdef __AVR__
return (uint8_t *)pgm_read_pointer(&gfxFont->bitmap);
#else
// expression in __AVR__ section generates "dereferencing type-punned pointer will break strict-aliasing rules" warning
// In fact, on other platforms (such as STM32) there is no need to do this pointer magic as program memory may be read in a usual way
// So expression may be simplified
return gfxFont->bitmap;
#endif //__AVR__
}
inline static void utft_write(unsigned char d)
{
SPI.transfer(d);
}
inline static void utftCmd(unsigned char VH)
{
*(portOutputRegister(digitalPinToPort(TFT_RS))) &= ~digitalPinToBitMask(TFT_RS);//LCD_RS=0;
utft_write(VH);
}
inline static void utftData(unsigned char VH)
{
*(portOutputRegister(digitalPinToPort(TFT_RS)))|= digitalPinToBitMask(TFT_RS);//LCD_RS=1;
utft_write(VH);
}
/*
void utftCmd_Data(unsigned char com,unsigned char dat)
{
utftCmd(com);
utftData(dat);
}
*/
static void utftAddress(unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2)
{
utftCmd(0x2a);
utftData(x1>>8);
utftData(x1);
utftData(x2>>8);
utftData(x2);
utftCmd(0x2b);
utftData(y1>>8);
utftData(y1);
utftData(y2>>8);
utftData(y2);
utftCmd(0x2c);
}
/*
inline void utftQuickfill(int16_t x1, int16_t y1, int16_t w, int16_t h, uint16_t color) {
int16_t x2, y2;
x2 = x1 + w;
y2 = y1 + h;
setAddrWindow(x, y, x2, y2);
writeColor(color, (uint32_t)w * h);
}
*/
void utftPixel(unsigned int x, unsigned int y, unsigned int c)
{
unsigned int i,j;
digitalWrite(TFT_CS,LOW);
utftCmd(0x02c); //write_memory_start
//digitalWrite(RS,HIGH);
//l=l+x;
utftAddress(x,y,x,y);
//j=l*2;
//for(i=1;i<=j;i++)
//{
utftData(c>>8);
utftData(c);
//utftData(c);
//utftData(c);
//}
digitalWrite(TFT_CS,HIGH);
}
void utftHline(unsigned int x, unsigned int y, unsigned int l, unsigned int c)
{
unsigned int i,j;
digitalWrite(TFT_CS,LOW);
utftCmd(0x02c); //write_memory_start
//digitalWrite(RS,HIGH);
l=l+x;
utftAddress(x,y,l,y);
// j=l*2;
j = l;
for(i=1;i<=j;i++)
{
utftData(c>>8);
utftData(c);
}
digitalWrite(TFT_CS,HIGH);
checkCAT();
}
void displayClear(unsigned int j)
{
unsigned int i,m;
digitalWrite(TFT_CS,LOW);
utftAddress(0,0,320,240);
for(i=0;i<320;i++)
for(m=0;m<240;m++)
{
utftData(j>>8);
utftData(j);
}
digitalWrite(TFT_CS,HIGH);
}
void utftVline(unsigned int x, unsigned int y, unsigned int l, unsigned int c)
{
unsigned int i,j;
digitalWrite(TFT_CS,LOW);
utftCmd(0x02c); //write_memory_start
//digitalWrite(RS,HIGH);
l=l+y;
utftAddress(x,y,x,l);
//j=l*2;
j = l;
for(i=1;i<=l;i++)
{
utftData(c>>8);
utftData(c);
}
digitalWrite(TFT_CS,HIGH);
checkCAT();
}
void utftRect(unsigned int x,unsigned int y,unsigned int w,unsigned int h,unsigned int c)
{
utftHline(x , y , w, c);
utftHline(x , y+h, w, c);
utftVline(x , y , h, c);
utftVline(x+w, y , h, c);
}
void utftFillrect(unsigned int x,unsigned int y,unsigned int w,unsigned int h,unsigned int c)
{
unsigned int i;
for(i=0;i<h;i++)
{
//utftHline(x , y , w, c);
utftHline(x , y+i, w, c);
}
}
void displayInit(void)
{
SPI.begin();
SPI.setClockDivider(SPI_CLOCK_DIV4); // 4 MHz (half speed)
SPI.setBitOrder(MSBFIRST);
SPI.setDataMode(SPI_MODE0);
gfxFont = &ubitx_font;
pinMode(TFT_CS,OUTPUT);
pinMode(TFT_RS,OUTPUT);
digitalWrite(TFT_CS,LOW); //CS
utftCmd(0xCB);
utftData(0x39);
utftData(0x2C);
utftData(0x00);
utftData(0x34);
utftData(0x02);
utftCmd(0xCF);
utftData(0x00);
utftData(0XC1);
utftData(0X30);
utftCmd(0xE8);
utftData(0x85);
utftData(0x00);
utftData(0x78);
utftCmd(0xEA);
utftData(0x00);
utftData(0x00);
utftCmd(0xED);
utftData(0x64);
utftData(0x03);
utftData(0X12);
utftData(0X81);
utftCmd(0xF7);
utftData(0x20);
utftCmd(0xC0); //Power control
utftData(0x23); //VRH[5:0]
utftCmd(0xC1); //Power control
utftData(0x10); //SAP[2:0];BT[3:0]
utftCmd(0xC5); //VCM control
utftData(0x3e); //Contrast
utftData(0x28);
utftCmd(0xC7); //VCM control2
utftData(0x86); //--
utftCmd(0x36); // Memory Access Control
utftData(0x28); // Make this horizontal display
utftCmd(0x3A);
utftData(0x55);
utftCmd(0xB1);
utftData(0x00);
utftData(0x18);
utftCmd(0xB6); // Display Function Control
utftData(0x08);
utftData(0x82);
utftData(0x27);
utftCmd(0x11); //Exit Sleep
delay(120);
utftCmd(0x29); //Display on
utftCmd(0x2c);
digitalWrite(TFT_CS,HIGH);
//now to init the touch screen controller
ts.begin();
ts.setRotation(1);
readTouchCalibration();
}
// Draw a character
/**************************************************************************/
/*!
@brief Draw a single character
@param x Bottom left corner x coordinate
@param y Bottom left corner y coordinate
@param c The 8-bit font-indexed character (likely ascii)
@param color 16-bit 5-6-5 Color to draw chraracter with
@param bg 16-bit 5-6-5 Color to fill background with (if same as color, no background)
@param size_x Font magnification level in X-axis, 1 is 'original' size
@param size_y Font magnification level in Y-axis, 1 is 'original' size
*/
/**************************************************************************/
#define FAST_TEXT 1
void displayChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg) {
c -= (uint8_t)pgm_read_byte(&gfxFont->first);
GFXglyph *glyph = pgm_read_glyph_ptr(gfxFont, c);
uint8_t *bitmap = pgm_read_bitmap_ptr(gfxFont);
uint16_t bo = pgm_read_word(&glyph->bitmapOffset);
uint8_t w = pgm_read_byte(&glyph->width),
h = pgm_read_byte(&glyph->height);
int8_t xo = pgm_read_byte(&glyph->xOffset),
yo = pgm_read_byte(&glyph->yOffset);
uint8_t xx, yy, bits = 0, bit = 0;
int16_t xo16 = 0, yo16 = 0;
digitalWrite(TFT_CS,LOW);
#ifdef FAST_TEXT
uint16_t hpc = 0; // Horizontal foreground pixel count
for(yy=0; yy<h; yy++) {
for(xx=0; xx<w; xx++) {
if(bit == 0) {
bits = pgm_read_byte(&bitmap[bo++]);
bit = 0x80;
}
if(bits & bit) hpc++;
else {
if (hpc) {
utftHline(x+xo+xx-hpc, y+yo+yy, hpc, color);
hpc=0;
}
}
bit >>= 1;
}
// Draw pixels for this line as we are about to increment yy
if (hpc) {
utftHline(x+xo+xx-hpc, y+yo+yy, hpc, color);
hpc=0;
}
checkCAT();
}
#else
for(yy=0; yy<h; yy++) {
for(xx=0; xx<w; xx++) {
if(!(bit++ & 7)) {
bits = pgm_read_byte(&bitmap[bo++]);
}
if(bits & 0x80) {
utftPixel(x+xo+xx, y+yo+yy, color);
}
bits <<= 1;
}
checkCAT();
}
#endif
}
/*
void displayChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg) {
// Character is assumed previously filtered by write() to eliminate
// newlines, returns, non-printable characters, etc. Calling
// drawChar() directly with 'bad' characters of font may cause mayhem!
c -= (uint8_t)pgm_read_byte(&gfxFont->first);
GFXglyph *glyph = pgm_read_glyph_ptr(gfxFont, c);
uint8_t *bitmap = pgm_read_bitmap_ptr(gfxFont);
uint16_t bo = pgm_read_word(&glyph->bitmapOffset);
uint8_t w = pgm_read_byte(&glyph->width),
h = pgm_read_byte(&glyph->height);
int8_t xo = pgm_read_byte(&glyph->xOffset),
yo = pgm_read_byte(&glyph->yOffset);
uint8_t xx, yy, bits = 0, bit = 0;
int16_t xo16 = 0, yo16 = 0;
digitalWrite(TFT_CS,LOW);
for(yy=0; yy<h; yy++) {
for(xx=0; xx<w; xx++) {
if(!(bit++ & 7)) {
bits = pgm_read_byte(&bitmap[bo++]);
}
if(bits & 0x80) {
utftPixel(x+xo+xx, y+yo+yy, color);
}
// else
// utftPixel(x+xo+xx, y+yo+yy, bg);
bits <<= 1;
}
checkCAT();
}
digitalWrite(TFT_CS,HIGH);
}
*/
int displayTextExtent(char *text) {
int ext = 0;
while(*text){
char c = *text++;
uint8_t first = pgm_read_byte(&gfxFont->first);
if((c >= first) && (c <= (uint8_t)pgm_read_byte(&gfxFont->last))) {
GFXglyph *glyph = pgm_read_glyph_ptr(gfxFont, c - first);
ext += (uint8_t)pgm_read_byte(&glyph->xAdvance);
}
}//end of the while loop of the characters to be printed
return ext;
}
void displayRawText(char *text, int x1, int y1, int color, int background){
while(*text){
char c = *text++;
uint8_t first = pgm_read_byte(&gfxFont->first);
if((c >= first) && (c <= (uint8_t)pgm_read_byte(&gfxFont->last))) {
GFXglyph *glyph = pgm_read_glyph_ptr(gfxFont, c - first);
uint8_t w = pgm_read_byte(&glyph->width),
h = pgm_read_byte(&glyph->height);
if((w > 0) && (h > 0)) { // Is there an associated bitmap?
int16_t xo = (int8_t)pgm_read_byte(&glyph->xOffset); // sic
displayChar(x1, y1+TEXT_LINE_HEIGHT, c, color, background);
checkCAT();
}
x1 += (uint8_t)pgm_read_byte(&glyph->xAdvance);
}
}//end of the while loop of the characters to be printed
}
// The generic routine to display one line on the LCD
void displayText(char *text, int x1, int y1, int w, int h, int color, int background, int border) {
utftFillrect(x1, y1, w ,h, background);
utftRect(x1, y1, w ,h, border);
x1 += (w - displayTextExtent(text))/2;
y1 += (h - TEXT_LINE_HEIGHT)/2;
while(*text){
char c = *text++;
uint8_t first = pgm_read_byte(&gfxFont->first);
if((c >= first) && (c <= (uint8_t)pgm_read_byte(&gfxFont->last))) {
GFXglyph *glyph = pgm_read_glyph_ptr(gfxFont, c - first);
uint8_t w = pgm_read_byte(&glyph->width),
h = pgm_read_byte(&glyph->height);
if((w > 0) && (h > 0)) { // Is there an associated bitmap?
int16_t xo = (int8_t)pgm_read_byte(&glyph->xOffset); // sic
displayChar(x1, y1+TEXT_LINE_HEIGHT, c, color, background);
checkCAT();
}
x1 += (uint8_t)pgm_read_byte(&glyph->xAdvance);
}
}//end of the while loop of the characters to be printed
}
void setupTouch(){
int x1, y1, x2, y2, x3, y3, x4, y4;
displayClear(ILI9341_BLACK);
displayText("Click on the cross", 20,100, 200, 50, ILI9341_WHITE, ILI9341_BLACK, ILI9341_BLACK);
// TOP-LEFT
utftHline(10,20,20,ILI9341_WHITE);
utftVline(20,10,20, ILI9341_WHITE);
while(!readTouch())
delay(100);
while(readTouch())
delay(100);
x1 = ts_point.x;
y1 = ts_point.y;
//rubout the previous one
utftHline(10,20,20,ILI9341_BLACK);
utftVline(20,10,20, ILI9341_BLACK);
delay(1000);
//TOP RIGHT
utftHline(290,20,20,ILI9341_WHITE);
utftVline(300,10,20, ILI9341_WHITE);
while(!readTouch())
delay(100);
while(readTouch())
delay(100);
x2 = ts_point.x;
y2 = ts_point.y;
utftHline(290,20,20,ILI9341_BLACK);
utftVline(300,10,20, ILI9341_BLACK);
delay(1000);
//BOTTOM LEFT
utftHline(10,220,20,ILI9341_WHITE);
utftVline(20,210,20, ILI9341_WHITE);
while(!readTouch())
delay(100);
x3 = ts_point.x;
y3 = ts_point.y;
while(readTouch())
delay(100);
utftHline(10,220,20,ILI9341_BLACK);
utftVline(20,210,20, ILI9341_BLACK);
delay(1000);
//BOTTOM RIGHT
utftHline(290,220,20,ILI9341_WHITE);
utftVline(300,210,20, ILI9341_WHITE);
while(!readTouch())
delay(100);
x4 = ts_point.x;
y4 = ts_point.y;
utftHline(290,220,20,ILI9341_BLACK);
utftVline(300,210,20, ILI9341_BLACK);
// we average two readings and divide them by half and store them as scaled integers 10 times their actual value
slope_x = ((x4 - x3) + (x2 - x1))/60; // divide by 300 will give each span it's slope, we add two of them so division reduces to 150 and then by 10 to scale it up : 15
slope_y = ((y3 - y1) + (y4 - y2))/44;
//x1, y1 is at 10 pixels
offset_x = x1 * 10 / slope_x - 10;
offset_y = y1 * 10 / slope_y - 10;
/* //for debugging
Serial.print(slope_x); Serial.print(' ');
Serial.print(slope_y); Serial.print(' ');
Serial.print(offset_x); Serial.print(' ');
Serial.println(offset_y); Serial.print(' ');
*/
writeTouchCalibration();
displayClear(ILI9341_BLACK);
}