#include <msp430x16x.h>
#define uchar unsigned char
#define uint unsigned int
#define ulong unsigned long
#define bool char
#define true 1
#define false 0

#define SINGLETONE 0
#define FSK 1
#define RAMPEDFSK 2
#define CHIRP 3
#define BPSK 4

#define DOUT P4DIR |= 0xff
#define DIN  P4DIR &= ~0xff
#define DATAOUT P4OUT
#define DATAIN P4IN

#define SADDR P5DIR |= 0x3f
#define ADDR P5OUT

#define RD P3DIR |= BIT0
#define RDHIGH P3OUT |= BIT0
#define RDLOW P3OUT &= ~BIT0

#define WR P3DIR |= BIT1
#define WRHIGH P3OUT |= BIT1
#define WRLOW P3OUT &= ~BIT1

#define MRESET P3DIR |= BIT3
#define RESETHIGH P3OUT |= BIT3
#define RESETLOW P3OUT &= ~BIT3

#define SHAPEKEYING P3DIR |= BIT4
#define SHAPEKEYINGHIGH P3OUT |= BIT4
#define SHAPEKEYINGLOW P3OUT &= ~BIT4

#define FBH P3DIR |= BIT5
#define FBHHIGH P3OUT |= BIT5
#define FBHLOW P3OUT &= ~BIT5

#define UPDATE P3DIR |= BIT6
#define UPDATEHIGH P3OUT |= BIT6
#define UPDATELOW P3OUT &= ~BIT6

#define IORESET P5DIR |= BIT2
#define IORESETHIGH P5OUT |= BIT2
#define IORESETLOW P5OUT &= ~BIT2

#define SDO P5DIR |= BIT1
#define SDOHIGH P5OUT |= BIT1
#define SDOLOW P5OUT &= ~BIT1

#define SDIO P5DIR |= BIT0
#define SDIOHIGH P5OUT |= BIT0
#define SDIOLOW P5OUT &= ~BIT0

#define SCLK P3DIR |= BIT1
#define SCLKHIGH P3OUT |= BIT1
#define SCLKLOW P3OUT &= ~BIT1

#define CSB P3DIR |= BIT0
#define CSBHIGH P3OUT |= BIT0
#define CSBLOW P3OUT &= ~BIT0

uint systemclk;
void delay(uint time)
{
    uint i;
    for(i = 0; i < time; i++)
    {
        _NOP();
        _NOP();
        _NOP();
        _NOP();
    }
}

void MRST(void)
{
   RESETHIGH;
   delay(50);
   RESETLOW;
}

void IOUpdate(void)
{
    UPDATELOW;
    delay(5);
    UPDATEHIGH;
    delay(5);
    UPDATELOW;
}


void ParallelSendByte(uchar addr, uchar data)
{
    DOUT;
    WRHIGH;
    ADDR = (addr & 0x3f);
    WRLOW;
    DATAOUT = data;
    WRHIGH;
}

void SeriSendByte(uchar data)
{
}

uchar ParallelReadByte(uchar addr)
{
    uchar result;
    DIN;
    RDHIGH;
    ADDR = (addr & 0x3f);
    RDLOW;
    result = DATAIN;
    RDHIGH;
    return result;
}

uchar SeriReadByte()
{
    return 0;
}

void ParallelSetReg(uchar saddr, uchar *data, uchar n)
{
    uchar i;
    for(i = 0; i < n; i++)
    {
        ParallelSendByte(saddr + i, *data);
        data++;
    }
    IOUpdate();
}

void ParallelSetPhase(uchar saddr, float phase)
{
    uchar temp[2];
    uchar ph;
    
    ph = (uint) (phase * 45.51111111);
    ph = ph & 0x3fff;
    temp[0] = ph / 256;
    temp[1] = ph % 256;
    ParallelSetReg(saddr, temp, 2);
}

void ParallelSetPhase1(float phase)
{
    ParallelSetPhase(0, phase);
}

void ParallelSetPhase2(float phase)
{
    ParallelSetPhase(2, phase);
}

void ParallelSetFreq(uchar saddr, double freq)
{
    double ftw1;
    double t;
    uchar i;
    uchar temp[6];
    ftw1 = (freq * 281474976.710656 / (double) systemclk);
    t = (double)  (1099511627776);
    for(i = 0; i < 6; i++)
    {
        temp[i] = (uchar) (ftw1 / t);
        ftw1 = ftw1 - temp[i] * t;
        t = t / 256.0;
    }
    ParallelSetReg(saddr, temp, 6);
}

void ParallelSetFTW1(double freq)
{
    ParallelSetFreq(4, freq);
}

void ParallelSetFTW2(double freq)
{
    ParallelSetFreq(0x0a, freq);
}

void ParallelSetDFW(double freq)
{
    ParallelSetFreq(0x10, freq);
}

void ParallelSetUDClk(ulong clk)
{
    uchar temp[4];
    long t;
    uchar i;
    t = 16777216;
    for (i = 0; i < 4; i++)
    {
        temp[i] = clk / t;
        clk = clk % t;
        t =  t >> 8;
    }
    ParallelSetReg(0x16, temp, 4);
}

void ParallelSetRRClk(ulong clk)
{
    uchar temp[3];
    long t;
    uchar i;
    t = 65536;
    for (i = 0; i < 3; i++)
    {
        temp[i] = clk / t;
        clk = clk % t;
        t = t >> 8;
    }
    ParallelSetReg(0x1a, temp, 3);
}

void ParallelSetOutShapeKey(uchar saddr, uint amplitude)
{
    uchar temp[2];
    temp[0] = amplitude / 256;
    temp[1] = amplitude % 256;
    ParallelSetReg(saddr, temp, 2);
}

void ParallelSetOSKI(uint amplitude)
{
    ParallelSetOutShapeKey(0x21, amplitude);
}

void ParallelSetOSKQ(uint amplitude)
{
    ParallelSetOutShapeKey(0x23, amplitude);
}

void ParallelSetOSKRAMPRATE(uchar rate)
{
    ParallelSetReg(0x25, &rate,1);
}

void ParallelSetQDAC(uint data)
{
   uchar temp[2];
   temp[0] = data / 256;
   temp[1] = data % 256;
   ParallelSetReg(0x26, temp, 2);
}

void ParallelPowerDown(bool flag)
{
    uchar data;
    if (flag == true)
        data = 0x17;
    else
        data = 0x00;
   ParallelSetReg(0x1d, &data, 1);
}

void ParallelSetRefClk(uchar times)
{
    uchar data;
    if(times >=  4)
    {
        data = 0x20;
        if (times >= 10)
            data |= 0x40;
        data |= times;
        systemclk = systemclk * times;
        ParallelSetReg(0x1e, &data, 1);
    }
}

void ParallelSetMode(bool triangle, bool qdac, uchar mode)
{
    uchar data;
    data = (mode << 1);
    if (triangle == true)
        data |= 0x20;
    if (qdac == true)
        data |= 0x10;
    ParallelSetReg(0x1f, &data, 1);
}

void ParallelSetOSK(bool bypass, bool osken, bool oskint)
{
    uchar data;
    data = 0;
    if (bypass == true)
        data |= 0x40;
    if (osken == true)
        data |= 0x20;
    if (oskint == true)
        data |= 0x10;
    ParallelSetReg(0x20, &data, 1);
}

void ParallelInit(void)
{
    DOUT;
    SADDR;
    RD;
    WR;
    MRESET;
    SHAPEKEYING;
    FBH;
    UPDATE;
    MRST();
    SHAPEKEYINGLOW;
    FBHLOW;
    WRHIGH;
    RDHIGH;
    systemclk = 20;
    ParallelPowerDown(false);
    ParallelSetRefClk(4);
    ParallelSetMode(false, false, SINGLETONE);
    ParallelSetOSK(false, false, false);
}

void SeriInit(void)
{
}

void SingleTone(float freq, ulong amplitude)
{
    ParallelSetMode(false, false, SINGLETONE);
    ParallelSetFTW1(freq);
    ParallelSetOSKI(amplitude);
    ParallelSetOSKQ(amplitude);
}

void UnrampedFSK(float freq1, float freq2)
{
    ParallelSetMode(false, false, FSK);
    ParallelSetFTW1(freq1);
    ParallelSetFTW2(freq2);
}

void RampedFSK(bool triangle, float freq1, float freq2, float rampedfreq, ulong rrclk)
{
    ParallelSetMode(triangle, false, RAMPEDFSK);
    ParallelSetFTW1(freq1);
    ParallelSetFTW2(freq2);    
    ParallelSetDFW(rampedfreq);
    ParallelSetRRClk(rrclk);
}

void PSK(float freq, float phase1, float phase2)
{
    ParallelSetMode(false, false, BPSK);
    ParallelSetFTW1(freq);
    ParallelSetPhase1(phase1);
    ParallelSetPhase2(phase2);
}

void AM(void)
{
}