Move from 16x2 LCD to TFT

[g7kse]

I've been stumped by this for a while and could do with some help

I've been using a sketch with an arduino and 16x2 LCD to decode morse code (CW) and its pretty good at it for a machine. I'd like to use it with a TTGO and I'm getting lost in translating the LCD code to use with the TFT. The display is a 1.4". I can use tft.print for the static text and try to use drawString for the updated numbers but they just overwrite each other rather than clear first then write (I think). So I could do with some help understanding where to go with this please. Every time I work through an error I seem to get another one, so going back to first principles would be better I think

So The bit I'm getting in a muddle with is...

  tft.setCursor (0,30);
  tft.print("WPM");
  tft.setCursor (186,30);
  tft.print(wpm);
  tft.drawLine(0, 35, 250, 35, TFT_BLUE);
  tft.setCursor (0,110);
  tft.print(DisplayLine);
  tft.fillScreen(TFT_BLACK);

This code excluded the tuning indicator for now as I couldn't get my head round it. Basics first. Display the WPM value and update when it is changed and write the decoded text as either a single line or as there is space, ideally one line, then move that line 'up one' then write a second line then repeat the process.

I'm sure this is not new but its new to me.

You will see that a lot of the oroginal code is for an arduino uno etc and a 16x2 line display. I'd just like it smaller and the TTGO seemed like a good idea. There is also a version for an SH1106 display here which I was trying to use for tips as well.

Complete original code

///////////////////////////////////////////////////////////////////////
// CW Decoder made by Hjalmar Skovholm Hansen OZ1JHM  VER 1.01       //
// Feel free to change, copy or what ever you like but respect       //
// that license is http://www.gnu.org/copyleft/gpl.html              //
// Discuss and give great ideas on                                   //
// https://groups.yahoo.com/neo/groups/oz1jhm/conversations/messages //
///////////////////////////////////////////////////////////////////////

// Amended by Andy Fletcher, MM0GYG
//
// 1. Added metrics to determine the cost of the Goertzel algorithm, 
//    the display to LCD, etc.
// 2. The metrics show that the call to updateinfolinelcd takes quite some time -- 
//    half as expensive as running the Goertzel algorithm -- 
//    so using LiquidCrystalFast rather than LiquidCrystal. This speeds up LCD writes
//    by about 1.5x
// 3. Optionally speed up the ADC to to get faster analogReads. However, this doesn't 
//    allow any better results at WPM > 30.
// 4. Cope with an Arduino DUE. Though this doesn't seem to help increase the max WPM
// 5. Added tuning aid to LCD. Tune for maximum '>'s.
// 6. Reduced magnitudelimit_low to suit TS-590 ACC2 output
// 7. Control magnitude_low with left/right buttons
//

///////////////////////////////////////////////////////////////////////////
// Read more here http://en.wikipedia.org/wiki/Goertzel_algorithm        //
// if you want to know about FFT the http://www.dspguide.com/pdfbook.htm //
///////////////////////////////////////////////////////////////////////////

// uncomment the next line to print metrics
// #define PRINT_METRICS

// uncomment the next line to send audio
// #define SEND_AUDIO

// uncomment the next line to allow (possibly dodgy) ADC speed up on Uno only
// #define SPEEDY_ADC

// uncomment the next line to print dits and dashes
// #define PRINT_DIDAHS

// uncomment the next line to enable config buttons
#define BUTTONS_ENABLED

// uncomment the next line to flash the LED
// #define FLASH_LED

// uncomment the next line to enable LCD tuning aid
#define LCD_TUNING_AID
#define LCD_TUNING_CHAR '>'

// change these as required
#define SPLASH1 "OZ1JHM CW Decoder"
#define SPLASH2 "MM0GYG rev v1.4"
#define DEFAULT_N 48.0
#define DEFAULT_BW 186
#define CONFIG_DELAY 200
#define SPLASH_DELAY 1000
#define MAGNITUDE_CHANGE 5


#include <LiquidCrystalFast.h>

///////////////////////////////////////////////
// select the pins used on the LCD panel      /
///////////////////////////////////////////////
//  LiquidCrystalFast lcd(RS, RW, EN, D4, D5, D6, D7) //
///////////////////////////////////////////////

// DisplayTech LiquidCrystalFast lcd(8, 10, 9, 4, 5, 6, 7);
LiquidCrystalFast lcd(8, 9, 4, 5, 6, 7);

const int columns = 16; /// have to be 16 or 20
const int rows = 2;  /// have to be 2 or 4

int lcdindex = 0;
int line1[columns];
int line2[columns];

////////////////////////////////
// Define 8 specials letters  //
////////////////////////////////

byte U_umlaut[8] =   {B01010,B00000,B10001,B10001,B10001,B10001,B01110,B00000}; // '�'  
byte O_umlaut[8] =   {B01010,B00000,B01110,B10001,B10001,B10001,B01110,B00000}; // '�'  
byte A_umlaut[8] =   {B01010,B00000,B01110,B10001,B11111,B10001,B10001,B00000}; // '�'    
byte AE_capital[8] = {B01111,B10100,B10100,B11110,B10100,B10100,B10111,B00000}; // '�' 
byte OE_capital[8] = {B00001,B01110,B10011,B10101,B11001,B01110,B10000,B00000}; // '�' 
byte fullblock[8] =  {B11111,B11111,B11111,B11111,B11111,B11111,B11111,B11111};  
byte AA_capital[8] = {B00100,B00000,B01110,B10001,B11111,B10001,B10001,B00000}; // '�'   
byte emptyblock[8] =  {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B00000};  

int audioInPin = A1;
#ifdef SEND_AUDIO
int audioOutPin = 10;
#endif
int ledPin = 13;

float magnitude ;
int magnitudelimit = 100;
int magnitudelimit_low = 20;  // was 100. Works with TS-590 ACC2 output set to 9
int realstate = LOW;
int realstatebefore = LOW;
int filteredstate = LOW;
int filteredstatebefore = LOW;


///////////////////////////////////////////////////////////
// The sampling frq will be 8928 on a 16 mhz             //
// without any prescaler etc                             //
// because we need the tone in the center of the bins    //
// you can set the tone to 496, 558, 744 or 992          //
// then n the number of samples which give the bandwidth //
// can be (8928 / tone) * 1 or 2 or 3 or 4 etc           //
// init is 8928/558 = 16 *4 = 64 samples                 //
// try to take n = 96 or 128 ;o)                         //
// 48 will give you a bandwidth around 186 hz            //
// 64 will give you a bandwidth around 140 hz            //
// 96 will give you a bandwidth around 94 hz             //
// 128 will give you a bandwidth around 70 hz            //
// BUT remember that high n take a lot of time           //
// so you have to find the compromice - i use 48         //
///////////////////////////////////////////////////////////

float coeff;
float Q1 = 0;
float Q2 = 0;
float sine;
float cosine;  
#ifdef ARDUINO_AVR_UNO
float sampling_freq=8928.0;
float n = DEFAULT_N;
int testData[128]; // leave this at 128 no matter what N is chosen
#else
#ifdef ARDUINO_SAM_DUE
// a DUE has a 84MHz clock, UNO has 16MHz, so multiply up
float sampling_freq=8928.0 * (84/16);
float n=63.0*2;  // if you change here please change next line also 
int testData[63*2];
#else
#error "board not implemented"
#endif
#endif
float target_freq=558.0;

//////////////////////////////
// Noise Blanker time which //
// shall be computed so     //
// this is initial          //
//////////////////////////////
int nbtime = 6;  /// ms noise blanker         

long starttimehigh;
long highduration;
long lasthighduration;
long hightimesavg;
long lowtimesavg;
long startttimelow;
long lowduration;
long laststarttime = 0;

char code[20];
int stop = LOW;
int wpm;

#ifdef SPEEDY_ADC
// ADC prescalers
const unsigned char PS_16 = (1 << ADPS2);
const unsigned char PS_32 = (1 << ADPS2) | (1 << ADPS0);
const unsigned char PS_64 = (1 << ADPS2) | (1 << ADPS1);
const unsigned char PS_128 = (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);
#endif

////////////////
// init setup //
////////////////
void setup() {

////////////////////////////////////
// The basic goertzel calculation //
////////////////////////////////////
  int  k;
  float omega;
  k = (int) (0.5 + ((n * target_freq) / sampling_freq));
  omega = (2.0 * PI * k) / n;
  sine = sin(omega);
  cosine = cos(omega);
  coeff = 2.0 * cosine;

///////////////////////////////
// define special characters //
///////////////////////////////
 lcd.createChar(0, U_umlaut); //     German
 lcd.createChar(1, O_umlaut); //     German, Swedish
 lcd.createChar(2, A_umlaut); //     German, Swedish 
 lcd.createChar(3, AE_capital); //   Danish, Norwegian
 lcd.createChar(4, OE_capital); //   Danish, Norwegian
 lcd.createChar(5, fullblock);        
 lcd.createChar(6, AA_capital); //   Danish, Norwegian, Swedish
 lcd.createChar(7, emptyblock); 
 lcd.clear(); 

 Serial.begin(115200); 
 pinMode(ledPin, OUTPUT);
 lcd.begin(columns, rows); 
  lcd.setCursor(0, 0); 
  lcd.print(SPLASH1);
  lcd.setCursor(0,1);
  lcd.print(SPLASH2);
 if ((columns == 20) and (rows == 4)) {
  lcd.setCursor(0, 2); // next line
  lcd.print("Fs=");
  lcd.print(sampling_freq);
  lcd.setCursor(0, 3); // next line
  lcd.print("Ft=");
  lcd.print(target_freq);
  lcd.print(", N=");
  lcd.print(n);
 }
 delay(SPLASH_DELAY);

#ifdef BUTTONS_ENABLED
//
// Get any changes to configuration
//
  {
    int buttonV, gettingConfig;
    int bandwidth = DEFAULT_BW;
  
    gettingConfig = 1;
    
    while (gettingConfig == 1) {
      lcd.setCursor(0, 0); 
      lcd.print(">Confg? N=");
      lcd.print(n);
      lcd.print(" ");
      lcd.setCursor(0, 1);
      lcd.print("low=");
      lcd.print(magnitudelimit_low);
      lcd.print(", bw=");
      lcd.print(bandwidth);
      lcd.print("Hz ");
      delay(CONFIG_DELAY);

      buttonV = analogRead(0); // read the buttons
    
      //
      // The button voltage determines which button has been pressed
      // 
      if (buttonV < 60) { // Right -- change magnitude lower limit
        magnitudelimit_low += MAGNITUDE_CHANGE;  
      }
      else if (buttonV < 200) { // Up
         // nothing to do
         lcd.setCursor(0, 0); // next line
         lcd.print("Up does nowt");
         delay(SPLASH_DELAY);
      }
      else if (buttonV < 400) { // Down -- change N cyclically
        // N = 128 is not allowed as it is too slow
        if (n < 48.1) {        // currently N is 48
          n = 64.0;
          bandwidth = 140;
        } else if (n < 64.1) { // currently N is 64
          n = 96.0;
          bandwidth = 94;
        } else {               // currently N is 96
          n = 48.0;
          bandwidth = 186;
        }
        
        // recalculate the Goertzel algorithm
        k = (int) (0.5 + ((n * target_freq) / sampling_freq));
        omega = (2.0 * PI * k) / n;
        sine = sin(omega);
        cosine = cos(omega);
        coeff = 2.0 * cosine;
      }
      else if (buttonV < 600){ // Left
        magnitudelimit_low -= MAGNITUDE_CHANGE;
      }
      else if (buttonV < 800){ // Select
        gettingConfig = 0;
      }
    } 
  }
#endif
 
 lcd.clear();
 for (int index = 0; index < columns; index++){
    line1[index] = '.';
    line2[index] = '-';
 }           

#ifdef SPEEDY_ADC
  // set up the ADC
  ADCSRA &= ~PS_128;  // clear bits set by Arduino library
  ADCSRA |= PS_16;
#endif 
 
}

///////////////
// main loop //
///////////////
 void loop() {
  
#ifdef PRINT_METRICS
   metrics(1);
#endif

  ///////////////////////////////////// 
  // The basic where we get the tone //
  /////////////////////////////////////
  
  for (char index = 0; index < n; index++)
  {
    testData[index] = analogRead(audioInPin);
  }
  for (char index = 0; index < n; index++){
    float Q0;
    Q0 = coeff * Q1 - Q2 + (float) testData[index];
    Q2 = Q1;
    Q1 = Q0;  
  }
  float magnitudeSquared = (Q1*Q1)+(Q2*Q2)-Q1*Q2*coeff;  // we do only need the real part //
  magnitude = sqrt(magnitudeSquared);
  Q2 = 0;
  Q1 = 0;

#ifdef PRINT_METRICS
   metrics(2);
#endif
  // Serial.print(magnitude); Serial.println();  //// here you can measure magnitude for setup..
  
  /////////////////////////////////////////////////////////// 
  // here we will try to set the magnitude limit automatic //
  ///////////////////////////////////////////////////////////
  
  if (magnitude > magnitudelimit_low){
    magnitudelimit = (magnitudelimit +((magnitude - magnitudelimit)/6));  /// moving average filter
  }
 
  if (magnitudelimit < magnitudelimit_low)
  magnitudelimit = magnitudelimit_low;
  
  ////////////////////////////////////
  // now we check for the magnitude //
  ////////////////////////////////////

  if(magnitude > magnitudelimit*0.6) // just to have some space up 
     realstate = HIGH; 
  else
    realstate = LOW; 
  
  ///////////////////////////////////////////////////// 
  // here we clean up the state with a noise blanker //
  /////////////////////////////////////////////////////
 
  if (realstate != realstatebefore){
  laststarttime = millis();
  }
  if ((millis()-laststarttime)> nbtime){
  if (realstate != filteredstate){
    filteredstate = realstate;
  }
  }
 
 ////////////////////////////////////////////////////////////
 // Then we do want to have some durations on high and low //
 ////////////////////////////////////////////////////////////
 
 if (filteredstate != filteredstatebefore){
  if (filteredstate == HIGH){
    starttimehigh = millis();
    lowduration = (millis() - startttimelow);
  }

  if (filteredstate == LOW){
    startttimelow = millis();
    highduration = (millis() - starttimehigh);
        if (highduration < (2*hightimesavg) || hightimesavg == 0){
      hightimesavg = (highduration+hightimesavg+hightimesavg)/3;     // now we know avg dit time ( rolling 3 avg)
    }
    if (highduration > (5*hightimesavg) ){
      hightimesavg = highduration+hightimesavg;     // if speed decrease fast ..
    }
  }
  }

 ///////////////////////////////////////////////////////////////
 // now we will check which kind of baud we have - dit or dah //
 // and what kind of pause we do have 1 - 3 or 7 pause        //
 // we think that hightimeavg = 1 bit                         //
 ///////////////////////////////////////////////////////////////
 
#ifdef PRINT_METRICS
   metrics(3);
#endif
 if (filteredstate != filteredstatebefore){
  stop = LOW;
  if (filteredstate == LOW){  //// we did end a HIGH
   if (highduration < (hightimesavg*2) && highduration > (hightimesavg*0.6)){ /// 0.6 filter out false dits
  strcat(code,".");
#ifdef PRINT_DIDAHS
  Serial.print(".");
#endif
   }
   if (highduration > (hightimesavg*2) && highduration < (hightimesavg*6)){ 
  strcat(code,"-");
#ifdef PRINT_DIDAHS
  Serial.print("-");
#endif
  wpm = (wpm + (1200/((highduration)/3)))/2;  //// the most precise we can do ;o)
   }
  }
 
   if (filteredstate == HIGH){  //// we did end a LOW
   
   float lacktime = 1;
   if(wpm > 25)lacktime=1.0; ///  when high speeds we have to have a little more pause before new letter or new word 
   if(wpm > 30)lacktime=1.2;
   if(wpm > 35)lacktime=1.5;
   
   if (lowduration > (hightimesavg*(2*lacktime)) && lowduration < hightimesavg*(5*lacktime)){ // letter space
    docode();
  code[0] = '\0';
 #ifdef PRINT_DIDAHS
  Serial.print("/");
 #endif
   }
   if (lowduration >= hightimesavg*(5*lacktime)){ // word space
    docode();
  code[0] = '\0';
  printascii(32);
 #ifdef PRINT_DIDAHS
  Serial.println();
 #endif
   }
  }
 }
 
 //////////////////////////////
 // write if no more letters //
 //////////////////////////////

  if ((millis() - startttimelow) > (highduration * 6) && stop == LOW){
   docode();
   code[0] = '\0';
   stop = HIGH;
  }

#ifdef PRINT_METRICS
   metrics(4);
#endif
 /////////////////////////////////////
 // we will turn on and off the LED //
 // and the speaker                 //
 /////////////////////////////////////
 
   if(filteredstate == HIGH){ 
#ifdef FLASH_LED
     digitalWrite(ledPin, HIGH);
#endif
#ifdef SEND_AUDIO
   tone(audioOutPin,target_freq);
#endif
   }
   else{
#ifdef FLASH_LED
     digitalWrite(ledPin, LOW);
#endif
#ifdef SEND_AUDIO
   noTone(audioOutPin);
#endif
   }
 
 //////////////////////////////////
 // the end of main loop clean up//
 /////////////////////////////////
#ifdef PRINT_METRICS
   metrics(5);
#endif
   updateinfolinelcd();
#ifdef PRINT_METRICS
   metrics(6);
#endif
 realstatebefore = realstate;
 lasthighduration = highduration;
 filteredstatebefore = filteredstate;
 }


////////////////////////////////
// translate cw code to ascii //
////////////////////////////////

void docode(){
    if (strcmp(code,".-") == 0) printascii(65);
  if (strcmp(code,"-...") == 0) printascii(66);
  if (strcmp(code,"-.-.") == 0) printascii(67);
  if (strcmp(code,"-..") == 0) printascii(68);
  if (strcmp(code,".") == 0) printascii(69);
  if (strcmp(code,"..-.") == 0) printascii(70);
  if (strcmp(code,"--.") == 0) printascii(71);
  if (strcmp(code,"....") == 0) printascii(72);
  if (strcmp(code,"..") == 0) printascii(73);
  if (strcmp(code,".---") == 0) printascii(74);
  if (strcmp(code,"-.-") == 0) printascii(75);
  if (strcmp(code,".-..") == 0) printascii(76);
  if (strcmp(code,"--") == 0) printascii(77);
  if (strcmp(code,"-.") == 0) printascii(78);
  if (strcmp(code,"---") == 0) printascii(79);
  if (strcmp(code,".--.") == 0) printascii(80);
  if (strcmp(code,"--.-") == 0) printascii(81);
  if (strcmp(code,".-.") == 0) printascii(82);
  if (strcmp(code,"...") == 0) printascii(83);
  if (strcmp(code,"-") == 0) printascii(84);
  if (strcmp(code,"..-") == 0) printascii(85);
  if (strcmp(code,"...-") == 0) printascii(86);
  if (strcmp(code,".--") == 0) printascii(87);
  if (strcmp(code,"-..-") == 0) printascii(88);
  if (strcmp(code,"-.--") == 0) printascii(89);
  if (strcmp(code,"--..") == 0) printascii(90);

  if (strcmp(code,".----") == 0) printascii(49);
  if (strcmp(code,"..---") == 0) printascii(50);
  if (strcmp(code,"...--") == 0) printascii(51);
  if (strcmp(code,"....-") == 0) printascii(52);
  if (strcmp(code,".....") == 0) printascii(53);
  if (strcmp(code,"-....") == 0) printascii(54);
  if (strcmp(code,"--...") == 0) printascii(55);
  if (strcmp(code,"---..") == 0) printascii(56);
  if (strcmp(code,"----.") == 0) printascii(57);
  if (strcmp(code,"-----") == 0) printascii(48);

  if (strcmp(code,"..--..") == 0) printascii(63);
  if (strcmp(code,".-.-.-") == 0) printascii(46);
  if (strcmp(code,"--..--") == 0) printascii(44);
  if (strcmp(code,"-.-.--") == 0) printascii(33);
  if (strcmp(code,".--.-.") == 0) printascii(64);
  if (strcmp(code,"---...") == 0) printascii(58);
  if (strcmp(code,"-....-") == 0) printascii(45);
  if (strcmp(code,"-..-.") == 0) printascii(47);

  if (strcmp(code,"-.--.") == 0) printascii(40);
  if (strcmp(code,"-.--.-") == 0) printascii(41);
  if (strcmp(code,".-...") == 0) printascii(95);
  if (strcmp(code,"...-..-") == 0) printascii(36);
  if (strcmp(code,"...-.-") == 0) printascii(62);
  if (strcmp(code,".-.-.") == 0) printascii(60);
  if (strcmp(code,"...-.") == 0) printascii(126);
  //////////////////
  // The specials //
  //////////////////
  if (strcmp(code,".-.-") == 0) printascii(3);
  if (strcmp(code,"---.") == 0) printascii(4);
  if (strcmp(code,".--.-") == 0) printascii(6);

}

/////////////////////////////////////
// print the ascii code to the lcd //
// one a time so we can generate   //
// special letters                 //
/////////////////////////////////////
void printascii(int asciinumber){

int fail = 0;
if (rows == 4 and columns == 16)fail = -4; /// to fix the library problem with 4*16 display http://forum.arduino.cc/index.php/topic,14604.0.html
 
 if (lcdindex > columns-1){
  lcdindex = 0;
  if (rows==4){
    for (int i = 0; i <= columns-1 ; i++){
    lcd.setCursor(i,rows-3);
    lcd.write(line2[i]);
    line2[i]=line1[i];
    }
   }
  for (int i = 0; i <= columns-1 ; i++){
    lcd.setCursor(i+fail,rows-2);
    lcd.write(line1[i]);
  lcd.setCursor(i+fail,rows-1);
    lcd.write(32);
  }
 }
 line1[lcdindex]=asciinumber;
 lcd.setCursor(lcdindex+fail,rows-1);
 lcd.write(asciinumber);
 lcdindex += 1;
}

void updateinfolinelcd(){
/////////////////////////////////////
// here we update the upper line   //
// with the speed and a tuning aid //
/////////////////////////////////////

  int place;
  unsigned mag, magSpace, magOffset;
  char magChar;

  place = 2; // Allow for two digits at extreme LHS
  if (wpm<10){
    lcd.setCursor((place)-2,0);
    lcd.print("0");
    lcd.setCursor((place)-1,0);
    lcd.print(wpm);
    lcd.setCursor((place),0);
    lcd.print(" WPM");
  }
  else{
    lcd.setCursor((place)-2,0);
    lcd.print(wpm);
    lcd.setCursor((place),0);
    lcd.print(" WPM ");
  }

#ifdef LCD_TUNING_AID
  // tuning aid
  magOffset = place + 5; // allow for WPM chars
  magSpace = columns - magOffset;
  mag = magnitude/magnitudelimit_low; 
  if (mag > magSpace) { // handle overflow
    mag = magSpace; 
  }
  lcd.setCursor(magOffset, 0); // allow for two digits followed by WPM
  for (int i = 0; i < magSpace; i++) {
    magChar = i < mag ? LCD_TUNING_CHAR : ' ';
    lcd.write(magChar);
  }
#endif
}

#ifdef PRINT_METRICS
// send metrics to serial output
unsigned long last_time = 0;
void metrics(int location) {
  unsigned long time;

// loc,time,delta
  Serial.print(location);
  Serial.print(",");
  time = micros();
  Serial.print(time);
  Serial.print(",");
  Serial.println(time - last_time);
  last_time = time;
}
#endif

[Bodmer]

To overwrite old text you must set a background colour:

tft.setTextColor(TFT_WHITE, TFT_BLACK);

In this case white is the foreground colour and black is for background.

The library has the basic Adafruit_GFX comaptible functions. I suspect the tutorial here will be of help:
https://learn.adafruit.com/adafruit-gfx-graphics-library/graphics-primitives