/**********************************************************************************************
  10kHz to 120MHz VFO / RF Generator with Si5351 and Arduino Nano, with Zwischenfrquenz (ZF)
  offset + . See the schematics for wiring details. By J. CesarSound - ver 1.0 - Dec/2020.
  Originallösung verwendet PINCHANGE Interrupt etwas geändert auf Timer2 Interrupt
  Timer0 wird in Arduino für millis() verwendet
  Funktionen Wobbeln, Calibration via DCF-Frequenzabgleich mit Oszi, ev mit Lissajoufigur.
  und aus hist. Gründen 9 MHz an clk0 und clk2 90° phasenverschoben
  etwas FM-Modulation mit 2,5kHz    Jan 2022 adapted by eRDe mit Danke an CesarSound s.o.
***********************************************************************************************/

//Libraries
#include <Wire.h>                 //IDE Standard
//#include <Rotary.h>               //Ben Buxton https://github.com/brianlow/Rotary
#include <si5351.h>               //Etherkit https://github.com/etherkit/Si5351Arduino
#include <Adafruit_GFX.h>         //Adafruit GFX https://github.com/adafruit/Adafruit-GFX-Library
#include <Adafruit_SSD1306.h>     //Adafruit SSD1306 https://github.com/adafruit/Adafruit_SSD1306
#include <EEPROM.h>
//
//------------User preferences----------------------------------------------------------------
#define ZF  0              //Enter your ZF frequency, ex: 455000 = 455kHz, 10700 = 10.7MHz,
                           // direct convert receiver or RF generator, + will add ZF offfset.
#define FREQ_INIT  1000000 //Enter your initial frequency at startup, ex: 7000000 = 7MHz, 
#define XT_CAL_F   110000  //Si5351 calibration factor, adjust to get exatcly 10MHz. 
#define tunestep   A0      //Change the pin used by encoder push button if you want.
#define calib      4       //Taster für Calibration ACHTUNG RUHEKONTAKT!!!
#define wobble     8       //Schalter für Funktionswahl
#define phas9      9       //Schalter für 9 MHZ phasehift
#define trigger   10       //Triggerausgang für Osci bei wobbel Funktion
//---------------------------------------------------------------------------------------------

//Rotary r = Rotary(2, 3);    // die Originallösung verwendet PINCHANGE Interrupt
Adafruit_SSD1306 display = Adafruit_SSD1306(128, 64, &Wire);
Si5351 si5351;

unsigned long freq = FREQ_INIT;
unsigned long freqold, fstep, f_zfold;  //sehr feiner Unterschied  gggg  qqqq Vorsicht!
long f_zf = ZF;
long cal = XT_CAL_F;
unsigned long long pll_freq = 90000000000ULL; //Angabe für PLL_A
byte encoder = 1; 
byte stp, esaved = 0, leave = 1, done = 1;   // esaved = Status ob EEPROM Werte hält mit 010101
unsigned int period = 100;   //millis display active
unsigned long time_now = 0;  //millis display active
const int analogInPin = A1;  // Analog input pin für den Schleifer des Potentiometers 
int sensorValue = 0;         // lese  potentiometer

static uint8_t flag;         //Wert aus LUT 
/**********************Interrupt*********************************/
ISR(TIMER2_OVF_vect) 
{ const uint8_t enc_lut[16] = {0,0,2,0,0,0,0,1,0,0,0,0,0,0,0,0};
  uint8_t index;
  static uint8_t last;            //alte Encoderphasen  
  static uint8_t aktuell;         //aktuelle -"- 
  
  aktuell = PIND & 0b00001100;    //input PORTD PINS 2,3 und maskiere Encoder Phasen 
  
  index = aktuell | last >>2; //erzeuge index für enc_lut
  last = aktuell;             //altes last im Nirvana
  flag = enc_lut[index];    // flag ist ja global verwendbar
  
    if (flag == 1) {freq = freq + fstep; cal = cal + fstep; 
    if (freq >= 120000000) freq = 12000000;
    if (cal >=150000) cal = 150000;}
    if (flag == 2) {freq = freq - fstep; cal = cal - fstep;
    if (freq <= 10000)  freq =  10000;
    else if (freq < 10000) freq = 100000000;
    if (cal <= -150000) cal = -150000;
  }
}
/* Ende ISR Routine**************Start setup*******************/
void setup() 
{ Wire.begin();
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
  display.setTextColor(WHITE);
  display.display();
  
 // PCICR |= (1 << PCIE2);    //alte Version mit PinChangeInt
 // PCMSK2 |= (1 << PCINT18) | (1 << PCINT19);
  
  TCCR2A |= (1 << WGM21)|(0 << WGM20);          //CTC 
  TCCR2B |= (1 << CS22)| ( 1<<CS21)|(1<<CS20);  //XTAL / 64
  TIMSK2 |= 1 << TOIE2;             //enable Interrupt49
  OCR2A = 250;                      //für 1 ms Interrupt
  sei();
  pinMode(2, INPUT_PULLUP);         //Phase A
  pinMode(3, INPUT_PULLUP);         //Phase B
  pinMode(tunestep, INPUT_PULLUP);  // Encoderschalter = store last setting
  pinMode(wobble, INPUT_PULLUP);    // wobble
  pinMode(calib, INPUT_PULLUP);     // Calibration
  pinMode(phas9, INPUT_PULLUP);     // 9 MHZ 90° Phaseoffset
  pinMode(trigger, OUTPUT);         // Triggerpuls output
  digitalWrite(trigger, LOW);       // Init Triggerpuls für Oscillograph
   
  startup_text();
  stp = 3;
  setstep();

 //Hole letzte Einstellungen aus EEPROM.  wird nur gelesen, wenn Inhalt da ist
  esaved = EEPROM.read(22);              //eben das Muster b10101
  if (esaved == 0b10101) 
  {EEPROM.get(0, cal);
   EEPROM.get(5, freq);
   EEPROM.get(10, fstep);
   EEPROM.get(15, f_zf);
   stp = EEPROM.read(20);
  }
  si5351.init(SI5351_CRYSTAL_LOAD_8PF, 0, cal);
  si5351.output_enable(SI5351_CLK0, 1);                  //1 - Enable / 0 - Disable CLK
  si5351.output_enable(SI5351_CLK1, 1);
  si5351.output_enable(SI5351_CLK2, 1);
  si5351.drive_strength(SI5351_CLK0, SI5351_DRIVE_2MA);  //Output current 2MA,4MA,6MA,8MA

  layout();
  tunegen();
  displayfreq();
}
/**************************************************************/ 
/*-----------------------Main Loop----------------------------*/
/**************************************************************/
void loop()
 {   poti();
     time_now = millis() ;
     setstep();
  //   delay(300);
     
  if (leave == 1) tunegen() ; //restore Frequenzen nach phase90 & calib
  else  ((freqold != freq) || (f_zfold != f_zf ));
      { time_now = (millis() +300); tunegen();
        freqold = freq; f_zfold = f_zf; leave = 0;}

   if (digitalRead(calib) == HIGH) done = 1;
     {if (done ==1) EEPROM.get(0, cal); //ausgehend vom letzten Wert
      while(digitalRead(calib) == HIGH)  //bleib in schleife bis Lissajou steht
      {done = 0;  leave = 1;                      // 1x cal lesen reicht via done
       si5351.set_correction(cal, SI5351_PLL_INPUT_XO);
       delay(200); 
       displaycal(); 
       EEPROM.put(0, cal);    //echt geschrieben wird nur wenn Wert neu ist.
       f_zf = 2500;           // Phasenmodulation mit clk0 und clk1 gemeinsam
      }
     }
       
 if (digitalRead(tunestep) == LOW)      // Schalter vom Rotary speichert letzte Einstellung
   { time_now = (millis() + 300);       // cal wird unabhängig gespeichert!!
      save_last(); esaved = 21;
      delay(300);
   }
 if (digitalRead(wobble) == LOW)          //Wobbler
   { time_now = (millis() + 300);
     wobbler();
   }
 if (digitalRead(phas9) == LOW)          //SSB Basis
   { time_now = (millis() + 300); 
     phase90();
   }
  if (digitalRead(calib) == HIGH)  displaycal(); //zeige den Kalibrationswert in ppb
    else displayfreq(); 
    layout();
 }
// Ende Main Loop
/******************Subroutinen**************************************/ 

void tunegen()    //if (digitalRead(9) != LOW) 
  {//  si5351.set_correction(cal, SI5351_PLL_INPUT_XO); //in  main calib
   si5351.set_freq_manual((freq + f_zf) * 100ULL, pll_freq, SI5351_CLK1);//wobble, freq+f_zf
   si5351.set_freq_manual((freq + 0) * 100ULL, pll_freq, SI5351_CLK0);
   si5351.set_freq_manual(77500  * 100ULL, pll_freq, SI5351_CLK2); //für calibration Osci
  }

void setstep() 
  { switch (stp) 
   { case 0: f_zf = freq; break;    // setze IF offset
    case 1: fstep = 1; break;
    case 2: fstep = 10; break;
    case 3: fstep = 1000; break;
    case 4: fstep = 5000; break;
    case 5: fstep = 9000; break;
    case 6: fstep = 10000; break;
    case 7: fstep = 100000; break;
    case 8: fstep = 1000000; break;
    case 9: f_zf = 0; break;     // muss so gemacht werden, da freq < 10000 
                                      //ja nicht gewählt werden kann.
   }
  }

void save_last()  //save last setting in EEPROM 4x long, 1x byte ab addr 23 EEprom frei
   { //EEPROM.put(0, cal); //wird in der Calibration gespeichert
    EEPROM.put(5, freq); 
    EEPROM.put(10, fstep); 
    EEPROM.put(15, f_zf); 
    EEPROM.write(20, stp);
    EEPROM.write(22, esaved); //Kennzeichen für unwahrscheinliche 10101 als Zufall im EEPROM
   }
   
void poti()                             // read in the analog in value:
  {  sensorValue = analogRead(analogInPin);  // map it to the range of the analog out:
     stp = map(sensorValue, 0, 1023, 0, 9); // change the analog out value for switchcase
  }

void wobbler()                       // auf clk0, clk1 zeigt fzentral von wobble
  {  unsigned long fstart, wobstep;  //Startfrequenz und Hub aus dem Input rechnen, 64 Steps
     register unsigned long fnow;  // register: in den 31 Registern anlegen, fnow oft benutzt
     uint8_t i;
    fstart = (freq - (f_zf >>1)); wobstep = f_zf >>6; //Hub/2 und wobstep = Hub/64
                                       
    while(digitalRead(wobble) == LOW) //wenn Schalter "Wobbler" gerückt sonst endet wobbeln
    { i = 0;                          //innere while Schleife neu starten
      digitalWrite(trigger, HIGH);    // und Triggerpuls generieren
      delay(2);                       // Dauer für X-Y auf Osci via Sägezahn
      digitalWrite(trigger, LOW);     // Triggerpuls für Osci-Timebase fertig
      displayfreq();
      while( i++  <64)                //zuerst Vergleich, dann increm. bis Abbruchkriterium
      { fnow = fstart + (i * wobstep);
        si5351.set_freq_manual((fnow) * 100ULL, pll_freq, SI5351_CLK0); 
      }
    }
  }

void phase90()  // ehemalige Freq. für SSB-Quarzfilter  90°-phase clk0 zu clk1
  {   unsigned long freqi = 9000000; leave = 1;   
     si5351.set_freq_manual((freqi) * 100ULL, pll_freq, SI5351_CLK0);
     si5351.set_freq_manual((freqi) * 100ULL, pll_freq, SI5351_CLK1);
     si5351.set_phase(SI5351_CLK0, 0);
     si5351.set_phase(SI5351_CLK1, 100);  //900/9=100 also offset = 100
     si5351.pll_reset(SI5351_PLLA);       // aus library examples, ist nötig
     
     display.clearDisplay();
     display.setTextSize(2); display.setCursor(20, 1);
     display.print(freqi);
     layout();
     display.display();
 
     while(digitalRead(phas9) == LOW)
    { delay(100);                       //bleib solange 
    }    
   }
  
/***************************displayroutinen*********************************/  
void displaycal()
  { display.clearDisplay();
    display.setTextSize(2); display.setCursor(10, 1);
    display.print("Calibrate");
    display.setCursor(20, 25);
    display.print(cal);
    display.display();
  }

void displayfreq() 
{  unsigned int m = freq / 1000000;
   unsigned int k = (freq % 1000000) / 1000;
   unsigned int h = (freq % 1000) / 1;

  display.clearDisplay();
  display.setTextSize(2);

  char buffer[15] = "";
  if (m < 1) 
  {  display.setCursor(41, 1); sprintf(buffer, "%003d.%003d", k, h);
  }
  else if (m < 100) 
  {  display.setCursor(5, 1); sprintf(buffer, "%2d.%003d.%003d", m, k, h);
  }
  else if (m >= 100) 
  {  unsigned int h = (freq % 1000) / 10;
     display.setCursor(5, 1); sprintf(buffer, "%2d.%003d.%02d", m, k, h);
  }
  display.print(buffer);
}

void layout() 
{ display.setTextColor(WHITE);
  display.drawLine(0, 20, 127, 20, WHITE);
  display.drawLine(0, 43, 127, 43, WHITE);
  display.drawLine(105, 24, 105, 39, WHITE);
  display.setTextSize(1);
  display.setCursor(2, 25);
  display.print("Step:");
  display.setTextSize(2);
  if (stp == 1) display.print("1Hz");  if (stp == 2) display.print("10Hz"); 
  if (stp == 3) display.print("1k");   if (stp == 4) display.print("5k"); 
  if (stp == 5) display.print("9k");   if (stp == 6) display.print("10k"); 
  if (stp == 7) display.print("100k"); if (stp == 8) display.print("1MHz");
  if (stp == 0) display.print("setIF");if (stp == 9) display.print("clrIF"); 
  display.setCursor(2, 48);
  display.setTextSize(1);
  display.print("ZF:  ");
  display.setTextSize(2);
  display.print(f_zf/1000);
  if (f_zf != 0) display.print("k");
  display.setTextSize(1);
  display.setCursor(110, 23);
  if (freq < 1000000) display.print("kHz");
  if (freq >= 1000000) display.print("MHz");
  display.setCursor(110, 33);
  if (f_zf == 0) display.print("VFO");
  if (f_zf != 0) display.print("L O");
  display.display();
}

void startup_text() 
{ display.setTextSize(1);
  display.setCursor(4, 5);
  display.print("Si5351");
  display.setCursor(4, 20);
  display.print("Signal Generator");
  display.setCursor(4, 35);
  display.print("Version 0.0");
  display.setCursor(4, 50);
  display.print(">> eRDe <<");
  display.display();
  delay(2500);
  display.clearDisplay();
}