mirror of
https://codeberg.org/mclemens/ubitxv6.git
synced 2024-09-05 11:54:33 -04:00
605 lines
16 KiB
C++
605 lines
16 KiB
C++
|
#include <Arduino.h>
|
||
|
#include <EEPROM.h>
|
||
|
#include "ubitx.h"
|
||
|
#include "nano_gui.h"
|
||
|
|
||
|
//#include "Adafruit_GFX.h"
|
||
|
//#include <XPT2046_Touchscreen.h>
|
||
|
#include <SPI.h>
|
||
|
#include <avr/pgmspace.h>
|
||
|
|
||
|
#define TFT_CS 10
|
||
|
#define TFT_RS 9
|
||
|
|
||
|
|
||
|
GFXfont *gfxFont = NULL;
|
||
|
//int touch_x, touch_y;
|
||
|
//XPT2046_Touchscreen ts(CS_PIN);
|
||
|
//TS_Point ts_point;
|
||
|
struct 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);
|
||
|
|
||
|
/*
|
||
|
//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.println(' ');
|
||
|
*/
|
||
|
|
||
|
}
|
||
|
|
||
|
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);
|
||
|
}
|
||
|
|
||
|
#define Z_THRESHOLD 400
|
||
|
#define Z_THRESHOLD_INT 75
|
||
|
#define MSEC_THRESHOLD 3
|
||
|
#define SPI_SETTING SPISettings(2000000, MSBFIRST, SPI_MODE0)
|
||
|
|
||
|
static uint32_t msraw=0x80000000;
|
||
|
static int16_t xraw=0, yraw=0, zraw=0;
|
||
|
static uint8_t rotation = 1;
|
||
|
|
||
|
static int16_t touch_besttwoavg( int16_t x , int16_t y , int16_t z ) {
|
||
|
int16_t da, db, dc;
|
||
|
int16_t reta = 0;
|
||
|
if ( x > y ) da = x - y; else da = y - x;
|
||
|
if ( x > z ) db = x - z; else db = z - x;
|
||
|
if ( z > y ) dc = z - y; else dc = y - z;
|
||
|
|
||
|
if ( da <= db && da <= dc ) reta = (x + y) >> 1;
|
||
|
else if ( db <= da && db <= dc ) reta = (x + z) >> 1;
|
||
|
else reta = (y + z) >> 1; // else if ( dc <= da && dc <= db ) reta = (x + y) >> 1;
|
||
|
|
||
|
return (reta);
|
||
|
}
|
||
|
|
||
|
static void touch_update(){
|
||
|
int16_t data[6];
|
||
|
|
||
|
uint32_t now = millis();
|
||
|
if (now - msraw < MSEC_THRESHOLD) return;
|
||
|
|
||
|
SPI.beginTransaction(SPI_SETTING);
|
||
|
digitalWrite(CS_PIN, LOW);
|
||
|
SPI.transfer(0xB1 /* Z1 */);
|
||
|
int16_t z1 = SPI.transfer16(0xC1 /* Z2 */) >> 3;
|
||
|
int z = z1 + 4095;
|
||
|
int16_t z2 = SPI.transfer16(0x91 /* X */) >> 3;
|
||
|
z -= z2;
|
||
|
if (z >= Z_THRESHOLD) {
|
||
|
SPI.transfer16(0x91 /* X */); // dummy X measure, 1st is always noisy
|
||
|
data[0] = SPI.transfer16(0xD1 /* Y */) >> 3;
|
||
|
data[1] = SPI.transfer16(0x91 /* X */) >> 3; // make 3 x-y measurements
|
||
|
data[2] = SPI.transfer16(0xD1 /* Y */) >> 3;
|
||
|
data[3] = SPI.transfer16(0x91 /* X */) >> 3;
|
||
|
}
|
||
|
else data[0] = data[1] = data[2] = data[3] = 0; // Compiler warns these values may be used unset on early exit.
|
||
|
data[4] = SPI.transfer16(0xD0 /* Y */) >> 3; // Last Y touch power down
|
||
|
data[5] = SPI.transfer16(0) >> 3;
|
||
|
digitalWrite(CS_PIN, HIGH);
|
||
|
SPI.endTransaction();
|
||
|
//Serial.printf("z=%d :: z1=%d, z2=%d ", z, z1, z2);
|
||
|
if (z < 0) z = 0;
|
||
|
if (z < Z_THRESHOLD) { // if ( !touched ) {
|
||
|
// Serial.println();
|
||
|
zraw = 0;
|
||
|
return;
|
||
|
}
|
||
|
zraw = z;
|
||
|
|
||
|
int16_t x = touch_besttwoavg( data[0], data[2], data[4] );
|
||
|
int16_t y = touch_besttwoavg( data[1], data[3], data[5] );
|
||
|
|
||
|
//Serial.printf(" %d,%d", x, y);
|
||
|
//Serial.println();
|
||
|
if (z >= Z_THRESHOLD) {
|
||
|
msraw = now; // good read completed, set wait
|
||
|
switch (rotation) {
|
||
|
case 0:
|
||
|
xraw = 4095 - y;
|
||
|
yraw = x;
|
||
|
break;
|
||
|
case 1:
|
||
|
xraw = x;
|
||
|
yraw = y;
|
||
|
break;
|
||
|
case 2:
|
||
|
xraw = y;
|
||
|
yraw = 4095 - x;
|
||
|
break;
|
||
|
default: // 3
|
||
|
xraw = 4095 - x;
|
||
|
yraw = 4095 - y;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
boolean readTouch(){
|
||
|
touch_update();
|
||
|
if (zraw >= Z_THRESHOLD) {
|
||
|
ts_point.x = xraw;
|
||
|
ts_point.y = yraw;
|
||
|
// Serial.print(ts_point.x); Serial.print(",");Serial.println(ts_point.y);
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
void scaleTouch(struct Point *p){
|
||
|
p->x = ((long)(p->x - offset_x) * 10l)/ (long)slope_x;
|
||
|
p->y = ((long)(p->y - offset_y) * 10l)/ (long)slope_y;
|
||
|
|
||
|
// Serial.print(p->x); Serial.print(",");Serial.println(p->y);
|
||
|
|
||
|
// 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);
|
||
|
}
|
||
|
|
||
|
|
||
|
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);
|
||
|
}
|
||
|
|
||
|
void displayPixel(unsigned int x, unsigned int y, unsigned int c){
|
||
|
unsigned int i,j;
|
||
|
digitalWrite(TFT_CS,LOW);
|
||
|
|
||
|
utftCmd(0x02c); //write_memory_start
|
||
|
utftAddress(x,y,x,y);
|
||
|
utftData(c>>8);
|
||
|
utftData(c);
|
||
|
|
||
|
digitalWrite(TFT_CS,HIGH);
|
||
|
}
|
||
|
|
||
|
void displayHline(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
|
||
|
l=l+x;
|
||
|
utftAddress(x,y,l,y);
|
||
|
j = l;
|
||
|
for(i=1;i<=j;i++)
|
||
|
{
|
||
|
utftData(c>>8);
|
||
|
utftData(c);
|
||
|
}
|
||
|
digitalWrite(TFT_CS,HIGH);
|
||
|
checkCAT();
|
||
|
}
|
||
|
|
||
|
void displayVline(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
|
||
|
l=l+y;
|
||
|
utftAddress(x,y,x,l);
|
||
|
j = l;
|
||
|
for(i=1;i<=l;i++)
|
||
|
{
|
||
|
utftData(c>>8);
|
||
|
utftData(c);
|
||
|
}
|
||
|
digitalWrite(TFT_CS,HIGH);
|
||
|
checkCAT();
|
||
|
}
|
||
|
|
||
|
void displayClear(unsigned int color){
|
||
|
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(color>>8);
|
||
|
utftData(color);
|
||
|
}
|
||
|
digitalWrite(TFT_CS,HIGH);
|
||
|
}
|
||
|
|
||
|
void displayRect(unsigned int x,unsigned int y,unsigned int w,unsigned int h,unsigned int c){
|
||
|
displayHline(x , y , w, c);
|
||
|
displayHline(x , y+h, w, c);
|
||
|
displayVline(x , y , h, c);
|
||
|
displayVline(x+w, y , h, c);
|
||
|
}
|
||
|
|
||
|
void displayFillrect(unsigned int x,unsigned int y,unsigned int w,unsigned int h,unsigned int c){
|
||
|
unsigned int i;
|
||
|
|
||
|
for(i=0;i<h;i++){
|
||
|
displayHline(x , y+i, w, c);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool xpt2046_Init(){
|
||
|
pinMode(CS_PIN, OUTPUT);
|
||
|
digitalWrite(CS_PIN, HIGH);
|
||
|
}
|
||
|
|
||
|
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);
|
||
|
xpt2046_Init();
|
||
|
|
||
|
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) {
|
||
|
displayHline(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) {
|
||
|
displayHline(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
|
||
|
}
|
||
|
|
||
|
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) {
|
||
|
|
||
|
displayFillrect(x1, y1, w ,h, background);
|
||
|
displayRect(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(DISPLAY_BLACK);
|
||
|
displayText("Click on the cross", 20,100, 200, 50, DISPLAY_WHITE, DISPLAY_BLACK, DISPLAY_BLACK);
|
||
|
|
||
|
// TOP-LEFT
|
||
|
displayHline(10,20,20,DISPLAY_WHITE);
|
||
|
displayVline(20,10,20, DISPLAY_WHITE);
|
||
|
|
||
|
while(!readTouch())
|
||
|
delay(100);
|
||
|
while(readTouch())
|
||
|
delay(100);
|
||
|
x1 = ts_point.x;
|
||
|
y1 = ts_point.y;
|
||
|
|
||
|
//rubout the previous one
|
||
|
displayHline(10,20,20,DISPLAY_BLACK);
|
||
|
displayVline(20,10,20, DISPLAY_BLACK);
|
||
|
|
||
|
delay(1000);
|
||
|
|
||
|
//TOP RIGHT
|
||
|
displayHline(290,20,20,DISPLAY_WHITE);
|
||
|
displayVline(300,10,20, DISPLAY_WHITE);
|
||
|
|
||
|
while(!readTouch())
|
||
|
delay(100);
|
||
|
while(readTouch())
|
||
|
delay(100);
|
||
|
x2 = ts_point.x;
|
||
|
y2 = ts_point.y;
|
||
|
|
||
|
displayHline(290,20,20,DISPLAY_BLACK);
|
||
|
displayVline(300,10,20, DISPLAY_BLACK);
|
||
|
|
||
|
delay(1000);
|
||
|
|
||
|
//BOTTOM LEFT
|
||
|
displayHline(10,220,20,DISPLAY_WHITE);
|
||
|
displayVline(20,210,20, DISPLAY_WHITE);
|
||
|
|
||
|
while(!readTouch())
|
||
|
delay(100);
|
||
|
x3 = ts_point.x;
|
||
|
y3 = ts_point.y;
|
||
|
|
||
|
while(readTouch())
|
||
|
delay(100);
|
||
|
displayHline(10,220,20,DISPLAY_BLACK);
|
||
|
displayVline(20,210,20, DISPLAY_BLACK);
|
||
|
|
||
|
delay(1000);
|
||
|
|
||
|
//BOTTOM RIGHT
|
||
|
displayHline(290,220,20,DISPLAY_WHITE);
|
||
|
displayVline(300,210,20, DISPLAY_WHITE);
|
||
|
|
||
|
while(!readTouch())
|
||
|
delay(100);
|
||
|
x4 = ts_point.x;
|
||
|
y4 = ts_point.y;
|
||
|
|
||
|
|
||
|
displayHline(290,220,20,DISPLAY_BLACK);
|
||
|
displayVline(300,210,20, DISPLAY_BLACK);
|
||
|
|
||
|
// we average two readings and divide them by half and store them as scaled integers 10 times their actual, fractional value
|
||
|
//the x points are located at 20 and 300 on x axis, hence, the delta x is 280, we take 28 instead, to preserve fractional value,
|
||
|
//there are two readings (x1,x2) and (x3, x4). Hence, we have to divide by 28 * 2 = 56
|
||
|
slope_x = ((x4 - x3) + (x2 - x1))/56;
|
||
|
//the y points are located at 20 and 220 on the y axis, hence, the delta is 200. we take it as 20 instead, to preserve the fraction value
|
||
|
//there are two readings (y1, y2) and (y3, y4). Hence we have to divide by 20 * 2 = 40
|
||
|
slope_y = ((y3 - y1) + (y4 - y2))/40;
|
||
|
|
||
|
//x1, y1 is at 20 pixels
|
||
|
offset_x = x1 + -((20 * slope_x)/10);
|
||
|
offset_y = y1 + -((20 * slope_y)/10);
|
||
|
|
||
|
/*
|
||
|
Serial.print(x1);Serial.print(':');Serial.println(y1);
|
||
|
Serial.print(x2);Serial.print(':');Serial.println(y2);
|
||
|
Serial.print(x3);Serial.print(':');Serial.println(y3);
|
||
|
Serial.print(x4);Serial.print(':');Serial.println(y4);
|
||
|
|
||
|
//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.println(' ');
|
||
|
*/
|
||
|
writeTouchCalibration();
|
||
|
displayClear(DISPLAY_BLACK);
|
||
|
}
|
||
|
|
||
|
|