// /////////////////////////////////////////////////////////////////////
// VISIONARY 2.7 SKETCH BY CHANGPUAK.CH
// WRITTEN BY MIRCO DILL AND ALEXANDER SSE FRANK
// USES ARDUINO DUE AND RF-EXPLORER SHIELD
// IPA 12.02.2018 – 06.03.2018
// /////////////////////////////////////////////////////////////////////


//#include <Wire.h>

#include <RFExplorer_3GP_IoT.h>
#include "Adafruit_GFX.h"
#include "Adafruit_RA8875.h"
#include "stdlib.h"

#define RA8875_INT 4
#define RA8875_CS 10
#define RA8875_RESET 9
#define RA8875_MENUE_COLOR 0xFFFF

//Global 3G+ object for access to all RF Explorer IoT functionality
RFExplorer_3GP_IoT g_objRF; 
//Global variable for result in method processReceivedString()                      
unsigned short int g_nProcessResult=_RFE_IGNORE;  

Adafruit_RA8875 tft = Adafruit_RA8875(RA8875_CS, RA8875_RESET);
uint16_t tx, ty;
float xScale = 1024.0F/tft.width();
float yScale = 1024.0F/tft.height();

boolean touchEnable = true;
boolean touched = false;
boolean firstBand = true;

const float MAXAnfang = 15 ;
const float MAXEnde = 2700 ;
const float ZF = 433.92 ;
float center = 100.0 ;
float span = 20.0 ;
float start = 90.0 ;
float stop = 110.0 ;
float bandwidth = 48 ;
int TopLevel = -10 ;

// GRID
const int deltaX = 58 ;
const int deltaY = 45 ;
const int OffsetX = 40 ;
const int OffsetY = 9 ;
const int DOTSx = 10 * deltaX - 2 ;  // FOR ADAFRUIT RA8875
const int DOTSy =  9 * deltaY - 2 ;  // FOR ADAFRUIT RA8875

const int KeyW = 91 ;
const int KeyH = 61 ;
const int KeyD = 20 ;
const int radius = 9 ;


void setup()
{
  //delay(4999);

  Serial.begin(57600);
  //Wire.begin();

  digitalWrite(_RFE_GPIO2, LOW);                  
  // Set _RFE_GPIO2 as output, LOW -> Device mode to 2400bps
  g_objRF.resetHardware();                        
  // Reset 3G+ board
  delay(5000);                                    
  // Wait for 3G+ to complete initialization routines
  g_objRF.init();                                 
  // Initialize 3G+ library - Monitor SerialDebugger set 57600bps
  g_objRF.changeBaudrate(115200);                 
  // Change baudrate to 115Kbps, max reliable in Arduino DUE.
  delay(1000);                                    
  // Wait 1sec to stablish communication
  digitalWrite(_RFE_GPIO2, HIGH);     
  pinMode(_RFE_GPIO2, INPUT_PULLUP);              
  // Set _RFE_GPIO2 as a general port, no longer needed after start completed
  g_objRF.requestConfig();                        
  // Request of current configuration to 3G+ -> Device starts to send it setup and them SweepData
  g_objRF.changeNumberSteps(512);                 
  // Change baudrate to 115Kbps, max reliable in Arduino DUE.

  // Initialise the display
  if (!tft.begin(RA8875_800x480)) {
    Serial.println("RA8875 Not Found!");
    while (1);
  }
  //Serial.println("Found RA8875");

  pinMode(RA8875_INT, INPUT);
  digitalWrite(RA8875_INT, HIGH);

  tft.displayOn(true);
  tft.GPIOX(true);      // Enable TFT
  tft.PWM1config(true, RA8875_PWM_CLK_DIV1024); // Backlight
  tft.PWM1out(255);
  tft.fillScreen(RA8875_BLACK);
  tft.touchEnable(true);

  // SOME INFORMATION ...
  tft.textMode();
  tft.textEnlarge(2);
  tft.textTransparent(RA8875_WHITE);
  tft.textSetCursor(10, 10);
  tft.textWrite("ARDUINO / GENUINO (DUE)");
  tft.textSetCursor(10, 60);
  tft.textWrite("PROJECT 'SPECTRUM ANALYZER'");
  tft.textEnlarge(1);
  tft.textSetCursor(10, 130);
  tft.textWrite("A SPECTRUM ANALYZER FOR EVERYONE!");
  tft.textSetCursor(10, 160);
  tft.textWrite("WITH A RF EXPLORER 3G+ SHIELD IOT");
  tft.textSetCursor(10, 210);
  tft.textWrite("MINIMUM FREQUENCY :    15 MHz");
  tft.textSetCursor(10, 240);
  tft.textWrite("MAXIMUM FREQUENCY :  2700 MHz");
  tft.textSetCursor(10, 290);
  tft.textWrite("HARDWARE VERSION  :       1.0");
  tft.textSetCursor(10, 320);
  tft.textWrite("SOFTWARE VERSION  :  01.06.03");
  tft.textSetCursor(10, 370);
  tft.textWrite("SOFTWARE BY MIRCO DILL &");
  tft.textSetCursor(10, 400);
  tft.textWrite("AJARN CHANGPUAK (ALEXANDER SSE FRANK)");
  tft.textSetCursor(10, 450);
  tft.textWrite("USING ADAFRUIT & GITHUB LIBRARIES.");
  delay(9999);
  tft.fillScreen(RA8875_BLACK);

  MenueInfoButton();
  DrawCheckerBoard();
  ShowVerticalScale(TopLevel);
  ShowStart(center-span/2);
  ShowStop(center+span/2);
  Show9();
  tft.touchEnable(true);

  g_objRF.sendNewConfig((start*1000), (stop*1000)); 
  // send own configuration in area of own reference 100MHz signal
}
/*
void SerialHexOutput(byte value)
{
   Serial.print("0x");
   if (value < 0x10) Serial.print("0");
   Serial.print(value,HEX);
}
*/

char *dtostrf (double val, signed char width, unsigned char prec, char *sout)
{
  char fmt[20];
  sprintf(fmt, "%%%d.%df", width, prec);
  sprintf(sout, fmt, val);
  return sout;
}


void ShowStart(float Anfang)
{
  start = Anfang;
  if (start < MAXAnfang) start = MAXAnfang;
  char Wert[10];
  tft.textSetCursor(0, 439);
  tft.textMode();
  tft.textEnlarge(1);
  tft.textWrite("START:");
  dtostrf(Anfang,6,2,Wert);
  tft.textWrite(Wert);
  tft.textWrite(" MHz");
}


void ShowStop(float Ende)
{
  stop = Ende;
  if (stop > MAXEnde) stop = MAXEnde;
  char Wert[10];
  tft.textSetCursor(369, 439);
  tft.textMode();
  tft.textEnlarge(1);
  tft.textWrite("STOP:");
  dtostrf(Ende,6,2,Wert);
  tft.textWrite(Wert);
  tft.textWrite(" MHz");
}


void Show9()
{
  tft.textMode();
  tft.textEnlarge(0);
  tft.textSetCursor(642, 435);
  tft.textWrite("SPECTRUM ANALYZER");
  tft.textSetCursor(646, 457);
  tft.textWrite("WWW.CHANGPUAK.CH");
}


void ShowInputBuffer(String number)
{
  tft.textMode();
  tft.textEnlarge(2);
  tft.textTransparent(RA8875_BLUE);
  tft.textSetCursor(OffsetX+2*KeyW+23 , OffsetY+80+4);
  tft.textWrite(" 1 ");
  tft.graphicsMode();
}


void MenueInfoButton()
{
  char Wert[10];
  // CENTER
  tft.fillRect(630, 9, 165, 40, RA8875_MENUE_COLOR);
  tft.drawRect(630, 9, 165, 110, RA8875_MENUE_COLOR);
  // SPAN
  tft.fillRect(630, 129, 165, 40, RA8875_MENUE_COLOR);
  tft.drawRect(630, 129, 165, 110, RA8875_MENUE_COLOR);
  // BANDWIDTH
  tft.fillRect(630, 249, 165, 40, RA8875_MENUE_COLOR);
  tft.drawRect(630, 249, 165, 110, RA8875_MENUE_COLOR);
  // SETTINGS
  tft.setTextColor(RA8875_BLACK, RA8875_MENUE_COLOR);
  tft.fillRect(630, 369, 165, 45, RA8875_MENUE_COLOR);
  tft.textMode();
  tft.textEnlarge(1);
  tft.textTransparent(RA8875_BLACK);
  // CENTER
  tft.textSetCursor(665, 12);
  tft.textWrite("CENTER");
  // SPAN
  tft.textSetCursor(680, 132);
  tft.textWrite("SPAN");
  // BANDWIDTH
  tft.textSetCursor(640, 252);
  tft.textWrite("BANDWIDTH");
  // SETTINGS
  tft.textSetCursor(645, 374);
  tft.textWrite("SETTINGS");

  // NUMERICAL VALUES
  tft.textTransparent(RA8875_WHITE);
  // CENTER FREQUENCY
  dtostrf(center,6,2,Wert);
  tft.textSetCursor(665, 66);
  tft.textWrite(Wert);
  // SPAN
  dtostrf(span,6,2,Wert);
  tft.textSetCursor(665, 186);
  tft.textWrite(Wert);
  // BANDWIDTH
  if (firstBand == false) bandwidth = g_objRF.getConfiguration()->getRBWKHZ();
  else 
  {
    bandwidth = 48;
    firstBand = false;
  }
  dtostrf(bandwidth,6,2,Wert);
  tft.textSetCursor(665, 306);
  tft.textWrite(Wert);
}


void DrawCheckerBoard()
{
  // VERTICAL
  for (int y=0; y<9; y++)
  {
    // HORIZONTAL
    for (int x=0; x<10; x++)
    {
      tft.drawRect(OffsetX + x*deltaX, y*deltaY+OffsetY, deltaX, deltaY, RA8875_WHITE);
      tft.fillRect(OffsetX + x*deltaX+1, y*deltaY+1+OffsetY, deltaX-2, deltaY-2, RA8875_BLACK);
    }
  }
  tft.drawRect(OffsetX-1, OffsetY-1, 10 * deltaX + 2, 9 * deltaY + 2, RA8875_WHITE);
}


void DrawRectangleMenue()
{
  // VERTICAL
  for (int y=0; y<9; y++)
  {
    // HORIZONTAL
    for (int x=0; x<10; x++)
    {
      tft.drawRect(OffsetX, OffsetY, 10 * deltaX, 9 * deltaY, RA8875_WHITE);
      tft.fillRect(OffsetX+1, OffsetY+1, 10 * deltaX - 2, 9 * deltaY - 2, RA8875_BLACK);
    }
  }
}


void ShowVerticalScale(int MaxLevel)
{
  tft.textMode();
  tft.textEnlarge(0);
  char string[6];
  for (int y=0; y<=9; y++)
  {
      tft.textSetCursor(0, y * deltaY);
      tft.textTransparent(RA8875_WHITE);
      itoa(TopLevel-y*10,string,10);
      tft.textWrite(string);
  }
}


unsigned int CalcDistance(int X1, int Y1, int X2, int Y2)
{
  return sqrt((Y2-Y1)*(Y2-Y1)+(X2-X1)*(X2-X1));
}


String GetKeyBoard()
{
  boolean pressed = false;
  unsigned int Value = 0;
  String Result = "N" ;
  unsigned int Distance ;
  unsigned int Error = 115 ; // Max Error 120
  unsigned int HalfW = KeyW / 2 ;
  unsigned int HalfH = KeyH / 2 ;
  unsigned int HalfD = KeyD / 2 ;

  digitalWrite(RA8875_INT, HIGH);
  tft.touchEnable(true);
  /* Wait around for touch events */
  while (digitalRead(RA8875_INT)) { delay(1); }   // DANGEROUS !!!!
  if (tft.touched())
  {
    if (!pressed)
    {
    delay(290);
    tft.touchRead(&tx, &ty);
    pressed = true;
    //Serial.print(tx); Serial.print(", "); Serial.println(ty);
    }
  }
  // CALCULATE RADII AND FIND KEY WITH MINIMUM DISTANCE TO CENTER
  // THE COORDINATES HAVE BEEN FOUND WTH THE "CALIBRATEUR"
  // 0 ///////////////////////////////////////////////////////
  Distance = CalcDistance(178, 450, tx, ty);
  if ( Distance < Error ) { Error = Distance ; Result = "0" ; }
  // 1 ///////////////////////////////////////////////////////
  Distance = CalcDistance(306, 450, tx, ty);
  if ( Distance < Error ) { Error = Distance ; Result = "1" ; }
  // 2 ///////////////////////////////////////////////////////
  Distance = CalcDistance(439, 450, tx, ty);
  if ( Distance < Error ) { Error = Distance ; Result = "2" ; }
  // 3 ///////////////////////////////////////////////////////
  Distance = CalcDistance(568, 450, tx, ty);
  if ( Distance < Error ) { Error = Distance ; Result = "3" ; }
  // 4 ///////////////////////////////////////////////////////
  Distance = CalcDistance(699, 450, tx, ty);
  if ( Distance < Error ) { Error = Distance ; Result = "4" ; }
  // 5 ///////////////////////////////////////////////////////
  Distance = CalcDistance(162, 600, tx, ty);
  if ( Distance < Error ) { Error = Distance ; Result = "5" ; }
  // 6 ///////////////////////////////////////////////////////
  Distance = CalcDistance(308, 600, tx, ty);
  if ( Distance < Error ) { Error = Distance ; Result = "6" ; }
  // 7 ///////////////////////////////////////////////////////
  Distance = CalcDistance(440, 600, tx, ty);
  if ( Distance < Error ) { Error = Distance ; Result = "7" ; }
  // 8 ///////////////////////////////////////////////////////
  Distance = CalcDistance(565, 600, tx, ty);
  if ( Distance < Error ) { Error = Distance ; Result = "8" ; }
  // 9 ///////////////////////////////////////////////////////
  Distance = CalcDistance(678, 600, tx, ty);
  if ( Distance < Error ) { Error = Distance ; Result = "9" ; }
  // . ///////////////////////////////////////////////////////
  Distance = CalcDistance(176, 740, tx, ty);
  if ( Distance < Error ) { Error = Distance ; Result = "." ; }
  // C ///////////////////////////////////////////////////////
  Distance = CalcDistance(376, 740, tx, ty);
  if ( Distance < Error ) { Error = Distance ; Result = "C" ; }
  // E ///////////////////////////////////////////////////////
  Distance = CalcDistance(621, 740, tx, ty);
  if ( Distance < Error ) { Error = Distance ; Result = "E" ; }
  //Serial.print(Distance,DEC);
  //Serial.print(" KEY : ");
  //Serial.println(Result);
  //Serial.println(Error, DEC);
  return Result;
}


float GetNewValue()
{
  float Value ;
  String Wert = " " ;
  String NewValue = " ";
  boolean Fertig = false ;
  tft.textEnlarge(2);

  while (Fertig < 1)
  {
  tft.graphicsMode();
  NewValue = GetKeyBoard();
  tft.textMode();
  if (NewValue == "C")
  {
    Wert = " " ;
    tft.graphicsMode();
    tft.fillRect(OffsetX+20, OffsetY+80, 5*KeyW+4*KeyD, KeyH, RA8875_BLACK);
    tft.drawRoundRect(OffsetX+20, OffsetY+80, 5*KeyW+4*KeyD, KeyH, radius, RA8875_WHITE);
    tft.textMode();
  }

  if (NewValue == "E") Fertig = true ;
  if ((NewValue >= "0") && (NewValue <= "9")) Wert += NewValue ;
  if (NewValue == ".") Wert += NewValue ;
  if (Wert.length() > 8) Fertig = true ;
  tft.textTransparent(RA8875_BLUE);
  tft.textSetCursor(OffsetX+150, OffsetY+84);
  tft.print(Wert);
  //Serial.println(Wert);
  }
  Value = Wert.toFloat();
  return Value ;
}


void DrawKeyBoard()
{
  tft.graphicsMode();
  // RESULT BOX
  tft.drawRoundRect(OffsetX+20,OffsetY+80,5*KeyW+4*KeyD,KeyH,radius,RA8875_WHITE);
  // 0
  tft.drawRoundRect(OffsetX+20, OffsetY+80+KeyH+KeyD,KeyW,KeyH,radius,RA8875_WHITE);
  // 1
  tft.drawRoundRect(OffsetX+20+KeyW+KeyD,OffsetY+80+KeyH+KeyD,KeyW,KeyH,radius,RA8875_WHITE);
  // 2
  tft.drawRoundRect(OffsetX+20+2*KeyW+2*KeyD,OffsetY+80+KeyH+KeyD,KeyW,KeyH,radius, RA8875_WHITE);
  // 3
  tft.drawRoundRect(OffsetX+20+3*KeyW+3*KeyD, OffsetY+80+KeyH+KeyD, KeyW, KeyH, radius, RA8875_WHITE);
  // 4
  tft.drawRoundRect(OffsetX+20+4*KeyW+4*KeyD, OffsetY+80+KeyH+KeyD, KeyW, KeyH, radius, RA8875_WHITE);
  // 5
  tft.drawRoundRect(OffsetX+20, OffsetY+80+2*KeyH+2*KeyD, KeyW, KeyH, radius, RA8875_WHITE);
  // 6
  tft.drawRoundRect(OffsetX+20+KeyW+KeyD, OffsetY+80+2*KeyH+2*KeyD, KeyW, KeyH, radius, RA8875_WHITE);
  // 7
  tft.drawRoundRect(OffsetX+20+2*KeyW+2*KeyD, OffsetY+80+2*KeyH+2*KeyD, KeyW, KeyH, radius, RA8875_WHITE);
  // 8
  tft.drawRoundRect(OffsetX+20+3*KeyW+3*KeyD, OffsetY+80+2*KeyH+2*KeyD, KeyW, KeyH, radius, RA8875_WHITE);
  // 9
  tft.drawRoundRect(OffsetX+20+4*KeyW+4*KeyD, OffsetY+80+2*KeyH+2*KeyD, KeyW, KeyH, radius, RA8875_WHITE);
  // .
  tft.drawRoundRect(OffsetX+20, OffsetY+80+3*KeyH+3*KeyD, KeyW, KeyH, radius, RA8875_WHITE);
  // CLR
  tft.drawRoundRect(OffsetX+20+KeyW+KeyD, OffsetY+80+3*KeyH+3*KeyD, KeyW*2+KeyD, KeyH, radius, RA8875_WHITE);
  // ENTER
  tft.drawRoundRect(OffsetX+20+3*KeyW+3*KeyD, OffsetY+80+3*KeyH+3*KeyD, KeyW*2+KeyD, KeyH, radius, RA8875_WHITE);
  // DISPLAY DIGITS / TEXT
  tft.textMode();
  tft.textEnlarge(2);
  tft.textSetCursor(OffsetX+7+KeyW/2, OffsetY+80+KeyH+KeyD+4);
  tft.textWrite("0");
  tft.textSetCursor(OffsetX+7+KeyW+KeyD+KeyW/2, OffsetY+80+KeyH+KeyD+4);
  tft.textWrite("1");
  tft.textSetCursor(OffsetX+7+2*KeyW+2*KeyD+KeyW/2, OffsetY+80+KeyH+KeyD+4);
  tft.textWrite("2");
  tft.textSetCursor(OffsetX+7+3*KeyW+3*KeyD+KeyW/2, OffsetY+80+KeyH+KeyD+4);
  tft.textWrite("3");
  tft.textSetCursor(OffsetX+7+4*KeyW+4*KeyD+KeyW/2, OffsetY+80+KeyH+KeyD+4);
  tft.textWrite("4");
  tft.textSetCursor(OffsetX+7+KeyW/2, OffsetY+80+2*KeyH+2*KeyD+4);
  tft.textWrite("5");
  tft.textSetCursor(OffsetX+7+KeyW+KeyD+KeyW/2, OffsetY+80+2*KeyH+2*KeyD+4);
  tft.textWrite("6");
  tft.textSetCursor(OffsetX+7+2*KeyW+2*KeyD+KeyW/2, OffsetY+80+2*KeyH+2*KeyD+4);
  tft.textWrite("7");
  tft.textSetCursor(OffsetX+7+3*KeyW+3*KeyD+KeyW/2, OffsetY+80+2*KeyH+2*KeyD+4);
  tft.textWrite("8");
  tft.textSetCursor(OffsetX+7+4*KeyW+4*KeyD+KeyW/2, OffsetY+80+2*KeyH+2*KeyD+4);
  tft.textWrite("9");
  tft.textSetCursor(OffsetX+7+KeyW/2, OffsetY+80+3*KeyH+3*KeyD+4);
  tft.textWrite(".");
  tft.textSetCursor(OffsetX+7+KeyW+KeyD+KeyW/2+10, OffsetY+80+3*KeyH+3*KeyD+4);
  tft.textWrite("CLEAR");
  tft.textSetCursor(OffsetX+7+3*KeyW+3*KeyD+KeyW/2+10, OffsetY+80+3*KeyH+3*KeyD+4);
  tft.textWrite("ENTER");
}


void loop()
{
  tft.graphicsMode();
  tft.touchEnable(true);
  unsigned int KeyPressed = 9 ;
  unsigned int LastAction = 0 ;
  unsigned int Distance ;
  unsigned int Error = 150 ; // Max Error 150

  if (! digitalRead(RA8875_INT))
  {
    if (tft.touched())
    {
    tft.touchEnable(false);
    tft.touchRead(&tx, &ty);
    // CENTER = 1
    Distance = CalcDistance(890, 240, tx, ty);
    if ( Distance < Error ) { Error = Distance ; KeyPressed = 1 ; }
    // SPAN = 2
    Distance = CalcDistance(890, 460, tx, ty);
    if ( Distance < Error ) { Error = Distance ; KeyPressed = 2 ; }
    // BANDWIDTH = 3
    Distance = CalcDistance(890, 680, tx, ty);
    if ( Distance < Error ) { Error = Distance ; KeyPressed = 3 ; }
    // SETTINGS = 4
    Distance = CalcDistance(890, 804, tx, ty);
    if ( Distance < Error ) { Error = Distance ; KeyPressed = 4 ; }
    //Serial.println(Error, DEC);
    /*
    Serial.print("Loop Touched @ ");
    Serial.print(tx); Serial.print(", "); Serial.println(ty);
    Serial.println(KeyPressed);
    */
    }
  }

  switch (KeyPressed)
    {
    case 1: // "c"
      // NEW CENTER FREQUENCY
      DrawRectangleMenue();
      tft.textMode();
      tft.textEnlarge(2);
      tft.textSetCursor(OffsetX+20,OffsetY+15);
      tft.textTransparent(RA8875_YELLOW);
      tft.textWrite("ENTER NEW CENTER [MHz]");
      DrawKeyBoard();
      center = GetNewValue();
      start = center - (span/2);
      stop = center + (span/2);
      if (start < MAXAnfang) start = MAXAnfang;
      if (stop > MAXEnde) stop = MAXEnde;
      center = (start + stop) /2 ;
      span = stop - start ;
      tft.fillScreen(RA8875_BLACK);
      DrawCheckerBoard();
      ShowVerticalScale(TopLevel);
      ShowStart(start);
      ShowStop(stop);
      Show9();
      // SEND NEW CONFIG.
      g_objRF.sendNewConfig((start*1000), (stop*1000));
      do  //Wait for message received is User Config from 3G+
      {
        g_objRF.updateBuffer();
        g_nProcessResult = g_objRF.processReceivedString();  
      }
      while(!((g_nProcessResult == _RFE_SUCCESS) && (g_objRF.getLastMessage() == _CONFIG_MESSAGE)));
      MenueInfoButton();
      //Serial.println(g_objRF.getConfiguration()->getFreqSpectrumSteps());
      break;
    case 2: // "s"
      // NEW SPAN FREQUENCY
      DrawRectangleMenue();
      tft.textMode();
      tft.textEnlarge(2);
      tft.textSetCursor(OffsetX+20,OffsetY+15);
      tft.textTransparent(RA8875_YELLOW);
      tft.textWrite("ENTER NEW SPAN [MHz]");
      DrawKeyBoard();
      span = GetNewValue();
      if (center + span/2 > MAXEnde) span = 2*(MAXEnde-center) ;
      if (center - span/2 < MAXAnfang) span = 2*(center-MAXAnfang) ;
      if (span > 600.0) span = 600.0 ;
      tft.fillScreen(RA8875_BLACK);
      DrawCheckerBoard();
      ShowVerticalScale(TopLevel);
      ShowStart(center-span/2);
      ShowStop(center+span/2);
      Show9();
      // SEND NEW CONFIG.
      g_objRF.sendNewConfig((start*1000), (stop*1000));
      do  //Wait for message received is User Config from 3G+
      {
        g_objRF.updateBuffer();
        g_nProcessResult = g_objRF.processReceivedString();  
      }
      while(!((g_nProcessResult == _RFE_SUCCESS) && (g_objRF.getLastMessage() == _CONFIG_MESSAGE)));
      MenueInfoButton();
      //Serial.println(g_objRF.getConfiguration()->getFreqSpectrumSteps());
      break;
    case 3: // "b"
      MenueInfoButton();
      DrawCheckerBoard();
      ShowVerticalScale(TopLevel);
      ShowStart(center-span/2);
      ShowStop(center+span/2);
      Show9();
      break;
    case 4 : // "S"
      // SETTINGS
      DrawRectangleMenue() ;
      tft.textMode();
      tft.textEnlarge(2);
      tft.textSetCursor(OffsetX+20,OffsetY+15);
      tft.textTransparent(RA8875_YELLOW);
      tft.textWrite("SETTINGS :");
      delay(5000);
      MenueInfoButton();
      DrawCheckerBoard();
      ShowVerticalScale(TopLevel);
      ShowStart(center-span/2);
      ShowStop(center+span/2);
      Show9();
      break;
    default:
      // DO NOTHING
      break ;
    }

  do  //Wait for message received is SweepData from 3G+
  {
    g_objRF.updateBuffer();
    g_nProcessResult = g_objRF.processReceivedString();  
  } 
  while (!((g_nProcessResult == _RFE_SUCCESS) && (g_objRF.getLastMessage() == _SWEEP_MESSAGE) && g_objRF.isValid()));

  DrawCheckerBoard();

  int xPixelStep1 ;
  int yPixelStep1 ;
  int xPixelStep2 = 0;
  int yPixelStep2 = 0;

  for (unsigned short int nIndexStep = 0; nIndexStep<g_objRF.getConfiguration()->getFreqSpectrumSteps(); nIndexStep++)
  {
    //Print every step of sweep data onto display
    int stepFreq = g_objRF.getSweepData()->getFrequencyKHZ(nIndexStep);
    int stepAmp  = g_objRF.getSweepData()->getAmplitudeDBM(nIndexStep);
    if (stepAmp <= (TopLevel -90))
    {
      stepAmp = TopLevel -90;
    }
    if (stepAmp > TopLevel)
    {
      stepAmp = TopLevel;
    }
    Serial.print(stepAmp);
    Serial.print(", ");
    xPixelStep1 = map(stepFreq, start*1000, stop*1000, OffsetX+1, DOTSx+OffsetX+3);   
    // scale fequency to pixel on display
    yPixelStep1 = map(stepAmp, TopLevel, TopLevel -90, OffsetY-1, DOTSy+OffsetY);   
    // scale amplitude to pixel on display
    if (xPixelStep2 != 0 && yPixelStep2 != 0)
    {
      tft.drawLine(xPixelStep2, yPixelStep2, xPixelStep1, yPixelStep1, RA8875_YELLOW);
      tft.drawLine(xPixelStep2+1, yPixelStep2+1, xPixelStep1+1, yPixelStep1+1, RA8875_YELLOW);
    }
    //Serial.println(stepAmp);
    xPixelStep2 = xPixelStep1;
    yPixelStep2 = yPixelStep1;
  }
  Serial.println();
  Serial.println();
}

// /////////////////////////////////////////////////////////////////////
// END OF FILE.
// /////////////////////////////////////////////////////////////////////