/* Modul für den ADF4350  */

#include "stdtypes.h"
#include "startup.h"
#include "m051.h"
#include "systick.h"
#include "serialdlg.h"
#include "conv.h"
#include "lcd.h"
#include "gdi.h"
#include "tasten.h"
#include "hfgen.h"

/****************** Hardware-Anschluß *************************/

/* Enable  ist immer high = ein
   LE      ist P0.1  (zum ADF4350)
   DATA    ist P0.2  (zum ADF4350)
   CLK     ist P0.3  (zum ADF4350)
   MUX     ist P4.2  (vom ADF4350)
   LOCKDET ist P4.1  (vom ADF4350, LD, Pin 25)
*/
#define b_LE    (1<<1)
#define b_DATA  (1<<2)
#define b_CLK   (1<<3)


#define Fphase  24999792.0    // Phasen-Vergleichs-Frequenz

double Frequenz;
dword  Divider;
byte   BandCode;
bool   enabled;
int    muxnum;


/*  Registerbeschreibung:
Initialisierung nach Einschalten: zuerst Register 5, dann 4 3 2 1 0
physisches Datenspiel:
CLK auf low, dann LE auf low, dann 32x [Bit an DATA, dann L/H Flanke an CLK], dann LE suf hi
Bit 31 zuerst, Bit 0 zuletzt. Die Bits [2,1,0] sind die Registernummer (0..5, 6+7 gibt's nicht)

Einstellbare Counter:
R-Counter (10 Bit) teilt die Referenzfrequenz herunter auf die Phasenkomparator-Frequenz
N-Counter (INT, FRAC und MOD) teilt die VCO-Frequenz (aus 3x16 = 48 internen Oszillatoren)
immer wenn R0 geändert wird, sucht der Chip einen geeigneten Oszillator heraus.

Gewählte Betriebsart (nach ADIsimPLL)
Oszillator:               50 MHz
Phasenvergleichsfrequenz: 25 MHz
RefDivider:                2
RefDoubler:                disabled
Modulus:                   2500
Prescaler:                 8
BandSelClockDivider:       250     (25 MHz / 250 --> 100 kHz. die Bandselect-Logik verträgt max. 125 kHz)
daraus der Kanalabstand:   10 kHz

*/

/* Register 5:
Bits 16+15: Setup für Pin 25 (LD): 0 und 2 = low, 3 = high, 1 = digital Lock Detect */

#define wfRegister5 ((1<<15) | 5)


void SendADF4350 (dword L)
{ byte B;
  int i;
  B = P0_DOUT & ~b_CLK;
  P0_DOUT = B;
  B = B & ~b_LE;
  P0_DOUT = B;
  i = 32;
  while (i)
  { B &= ~b_DATA;
    if (L & 0x80000000) B |= b_DATA;
    P0_DOUT = B;
    L = L << 1;
    P0_DOUT = B | b_CLK;
    --i;
  }
  P0_DOUT = B | b_LE;
}



/* Konstanten für Register 4 */
#define RfPower       3      /* +5 dB */
#define RfEnable      1      /* ob an oder nicht */
#define AuxPower      3      /* +5 dB */
#define AuxEnable     1      /* ob an oder nicht */
#define AuxSelect     0      /* 0=divided, 1=fundamental */
#define MuteTilLock   0      /* ob still bis Lock detekted */
#define BandSelCkDiv  250    /* 25MHz/250 --> 100 kHz */
#define FbSelect      1      /* direkt ab Oszillator (2.2-4.4GHz) */

/* Konstanten für Register 3 */
#define ClkDivCount   60     /* Counter für Fast-Lock */
#define ClkDivMode    1      /* 1=FastLock, 2=ReSync,0=aus */
#define CycleSlipDet  0      /*  */

/* Konstanten für Register 2 */
#define Polarity      1      /* positiv */
#define CPump_ma      0      /* 0: 0.31 mA .. 15: 5 mA */
#define RCounter      0      /* 1:1 */
#define RDoubler      0      /* Ref-Eingangs-Verdoppler */
#define RDivBy2       1      /* Ref:2 nach RCounter */
#define SpurNoise     3      /* low Spur (=Dither)  */

/* Konstanten für Register 1 */
#define Modulus       2500   /* ergibt 10 kHz Auflösung */
#define PhaseValue    1      /* ADI: 'recommended'.. */
#define Prescaler     1      /* 1: 8/9 */


/********* mit dieser Funktion wird der ADF4350 gestartet ********/
void SetupADF4350 (void)
{ dword L;

  /* Register 5: nur Signal an LD */
  SendADF4350(wfRegister5);

  /* Register 4: */
  L =  4 +              /* Registernummer */
      (RfPower  << 3) +
      (RfEnable << 5) +
      (AuxPower << 6) +
      (AuxEnable<< 8) +
      (AuxSelect<< 9) +
      (MuteTilLock<<10) +
      (BandSelCkDiv<<12) +
      (BandCode << 20) +
      (FbSelect << 23);
  SendADF4350(L);

  /* Register 3: */
  L = 3 +              /* Registernummer */
     (ClkDivCount<<3) +
     (ClkDivMode<<15) +
     (CycleSlipDet<<18);
  SendADF4350(L);

  /* Register 2: */
  L = muxnum;
  L = (L<<26) +  2 +   /* Registernummer */
     (Polarity<<6) +
     (CPump_ma<<9) +
     (RCounter<<14)+
     (RDivBy2<<24) +
     (RDoubler<<25)+
     (SpurNoise<<29);
  SendADF4350(L);

  /* Register 1: */
  L = 1 +             /* Registernummer */
      (Modulus<<3) +
      (PhaseValue<<15) +
      (Prescaler<<27);
  SendADF4350(L);

  /* Register 0: */
  SendADF4350(Divider << 3);
}


void FrequenzEinstellen (void)
{ byte   bc;
  double ft;
  dword  d, m;

  /* nicht hängenbleiben */
  if (Frequenz < 137500000) Frequenz = 137500000;

  /* Bandcode ermitteln */
  bc = 0;
  ft = Frequenz;
  while (ft < 2200000000)
  { ft = ft * 2;
    ++bc;
  }
  ft = ft / Fphase;
  d  = ft;           // ganzer Teil

  ft = ft - d;       // Rest
  m = ft * Modulus;

  Divider = (d << 12) | m;
  BandCode = bc;

  if (!enabled) return;
  SetupADF4350();
}


void StartADF4350 (void)
{ dword L;
  L =  4 +              /* Registernummer */
      (RfPower  << 3) +
      (RfEnable << 5) +
      (AuxPower << 6) +
      (AuxEnable<< 8) +
      (AuxSelect<< 9) +
      (MuteTilLock<<10) +
      (BandSelCkDiv<<12) +
      (BandCode << 20) +
      (FbSelect << 23);
  SendADF4350(L);

  L = muxnum;
  L = (L<<26) +  2 +   /* Registernummer */
     (Polarity<<6) +
     (CPump_ma<<9) +
     (RCounter<<14)+
     (RDivBy2<<24) +
     (RDoubler<<25)+
     (SpurNoise<<29);
  SendADF4350(L);
}

void StopADF4350 (void)
{  SendADF4350((1<<9) | 4);  /* VCO aus */
   SendADF4350((7<<3) | 2);  /* Counter-Reset, CP aus, Power down */
}