#include <Arduino.h>
#include <SPI.h>

#define PIN_ADC A6

#define AD9951_RESET PB1
#define AD9951_IO_UPDATE PB10

const float MAX_FREQUENCY = 400e6; // Максимальная частота (400 МГц)
// Частота системного генератора (без PLL)
#define SYSTEM_CLOCK 100e6 // 100 МГц

void resetAD9951()
{
    digitalWrite(AD9951_RESET, HIGH);
    delayMicroseconds(10);
    digitalWrite(AD9951_RESET, LOW);
}

// Функция для записи в регистр AD9951
void writeAD9951Register(byte address, byte data[], byte numBytes)
{
    // digitalWrite(AD9951_CS, LOW);
    SPI.transfer(address); // Отправляем адрес регистра
    for (byte i = 0; i < numBytes; i++)
    {
        SPI.transfer(data[i]); // Отправляем данные
    }
    // digitalWrite(AD9951_CS, HIGH);

    // Обновление вывода
    digitalWrite(AD9951_IO_UPDATE, HIGH);
    delay(1);
    digitalWrite(AD9951_IO_UPDATE, LOW);
}

// Функция для настройки частоты
void setFrequency(double frequency)
{
    // Рассчитываем значение для регистра частоты (32 бита)
    // unsigned long freqWord = (unsigned long)((frequency * pow(2, 32)) / (SYSTEM_CLOCK * 4));

    // Clock rate = 100MHz
    // unsigned long freqWord = (unsigned long)frequency * 42.94967296;

    // Clock rate = 400MHz
    unsigned long freqWord = (unsigned long)frequency * 10.73741824;

    byte freqData[4];
    freqData[0] = (freqWord >> 24) & 0xFF; // MSB
    freqData[1] = (freqWord >> 16) & 0xFF;
    freqData[2] = (freqWord >> 8) & 0xFF;
    freqData[3] = freqWord & 0xFF; // LSB

    // Отправка регистра частоты
    // SPI.transfer((frequencyWord >> 24) & 0xFF); // MSB
    // SPI.transfer((frequencyWord >> 16) & 0xFF);
    // SPI.transfer((frequencyWord >> 8) & 0xFF);
    // SPI.transfer(frequencyWord & 0xFF); // LSB

    writeAD9951Register(0x04, freqData, 4); // Запись в регистр частоты (CFR)
}

// Функция для настройки амплитуды (0-1023 соответствует 0-полная амплитуда)
void setAmplitude(unsigned int amplitude)
{
    if (amplitude > 1023)
        amplitude = 1023;

    byte ampData[2];
    ampData[0] = (amplitude >> 8) & 0x03; // Только 2 младших бита
    ampData[1] = amplitude & 0xFF;

    writeAD9951Register(0x03, ampData, 2); // Запись в регистр амплитуды (ACR)
}

// Функция для настройки PLL (множитель 4)
// Функция для настройки PLL (множитель 4)
void configurePLL()
{
    byte cfr1Data[2];
    // CFR1: PLL множитель 4 (биты D7-D4 = 0011)
    cfr1Data[0] = 0x00; // PLL=4x, VCO gain=high (бит D3=0)
    cfr1Data[1] = 0x30; // 0011 в старших битах для PLL=4x

    writeAD9951Register(0x01, cfr1Data, 2);
}

/********************************************************************************************* */
// void RESET2()
// {
//     digitalWrite(AD9951_RESET, HIGH);
//     delayMicroseconds(10);
//     digitalWrite(AD9951_RESET, LOW);
// }

uint32_t multiplier = 4;

void CONFIG()
{                                                // Множитель от 4 до 20
    uint32_t cfr1_value = (multiplier - 4) << 4; // Сдвиг битов для D7-D4
    // spi_send_byte(0x24);// 0x04 << 3

    // CS_LOW();

    SPI.transfer(0x01);

    // SPI.transfer(cfr1_value);
    SPI.transfer(0);
    SPI.transfer(0);
    SPI.transfer(0x24); // Младший байт

    // CS_HIGH();

    // Обновить регистры (IO_UPDATE)
    digitalWrite(AD9951_IO_UPDATE, HIGH);
    delay(1);
    digitalWrite(AD9951_IO_UPDATE, LOW);
}

void setFrequency2(unsigned long ftw)
{
    // Активировать выбор микросхемы
    // CS_LOW();

    // Передать адрес регистра FTW (0x04)
    SPI.transfer(0x04);

    // Передать 32-битное значение FTW
    SPI.transfer((ftw >> 24) & 0xFF); // Старший байт
    SPI.transfer((ftw >> 16) & 0xFF);
    SPI.transfer((ftw >> 8) & 0xFF);
    SPI.transfer(ftw & 0xFF); // Младший байт

    // Деактивировать выбор микросхемы
    // CS_HIGH();

    // Обновить регистры (IO_UPDATE)
    digitalWrite(AD9951_IO_UPDATE, HIGH);
    delay(1);
    digitalWrite(AD9951_IO_UPDATE, LOW);
}
/********************************************************************************************* */

// void setPLLMultiplier(byte multiplier)
// {
//     byte cfr1Data[3] = {0};

//     // Установка множителя PLL (биты D7-D4 регистра CFR1)
//     switch (multiplier)
//     {
//     case 1:
//         cfr1Data[2] = 0x00; // 0000
//         break;
//     case 2:
//         cfr1Data[2] = 0x10; // 0001
//         break;
//     case 4:
//         cfr1Data[2] = 0x30; // 0011 (для 4x)
//         break;
//     case 8:
//         cfr1Data[2] = 0x50; // 0101
//         break;
//     case 16:
//         cfr1Data[2] = 0x70; // 0111
//         break;
//     case 20:
//         cfr1Data[2] = 0x90; // 1001
//         break;
//     default:
//         cfr1Data[2] = 0x30; // по умолчанию 4x
//     }

//     // Дополнительные настройки CFR1:
//     cfr1Data[0] |= 0x00; // VCO gain (0 = high, 1 = low)
//     cfr1Data[2] |= 0x01; // PLL enabled (бит D0)

//     writeAD9951Register(0x01, cfr1Data, 3); // Адрес CFR1 = 0x01
// }
void setPLLMultiplier(byte multiplier)
{
    byte cfr1Data[3] = {0};

    // Правильная настройка PLL множителя (биты D7-D4)
    switch (multiplier)
    {
    case 1:
        cfr1Data[0] = 0x00; // PLL bypass (0x0)
        cfr1Data[2] = 0x00; // PLL disabled
        break;
    case 2:
        cfr1Data[0] = 0x00; // VCO gain high
        cfr1Data[2] = 0x11; // 0001 (2x) + PLL enabled
        break;
    case 4:
        cfr1Data[0] = 0x00; // VCO gain high
        cfr1Data[2] = 0x31; // 0011 (4x) + PLL enabled
        break;
    case 8:
        cfr1Data[0] = 0x00; // VCO gain high
        cfr1Data[2] = 0x51; // 0101 (8x) + PLL enabled
        break;
    case 16:
        cfr1Data[0] = 0x00; // VCO gain high
        cfr1Data[2] = 0x71; // 0111 (16x) + PLL enabled
        break;
    case 20:
        cfr1Data[0] = 0x00; // VCO gain high
        cfr1Data[2] = 0x91; // 1001 (20x) + PLL enabled
        break;
    default:
        cfr1Data[0] = 0x00; // по умолчанию 4x
        cfr1Data[2] = 0x31; // 0011 (4x) + PLL enabled
    }

    writeAD9951Register(0x01, cfr1Data, 3); // Адрес CFR1 = 0x01
}

void setup()
{
    delay(500);
    Serial.begin(115200); // Инициализация последовательного порта
    while (!Serial)
    {
        // yield;
    }
    Serial.println("");
    Serial.println("hello");

    delay(500);
    return;

    // pinMode(CS_PIN, OUTPUT);
    pinMode(AD9951_RESET, OUTPUT);
    pinMode(AD9951_IO_UPDATE, OUTPUT);
    // digitalWrite(CS_PIN, HIGH);

    // Инициализация SPI
    SPI.begin();
    SPI.setBitOrder(MSBFIRST);
    SPI.setDataMode(SPI_MODE0); // !!!!!!!
    SPI.setClockDivider(SPI_CLOCK_DIV32);

    delay(500);
    /***********************************************************************************/

    resetAD9951();
    CONFIG();
    // setPLLMultiplier(4);
    setFrequency(10e6);

    //   setAmplitude(1023);

    return;

    // Сброс AD9951
    resetAD9951();
    delay(100);

    // Настройка PLL (множитель 4)
    configurePLL();
    delay(100);

    // Настройка частоты (например, 10 МГц)
    setFrequency(10e6);
    delay(100);

    // Настройка амплитуды (максимальная)
    // setAmplitude(1023);

    // // Обновление вывода
    // digitalWrite(AD9951_IO_UPDATE, HIGH);
    // delay(1);
    // digitalWrite(AD9951_IO_UPDATE, LOW);

    Serial.println("ready");
}

int cnt = 0;
void loop()
{
    Serial.println(cnt++);
    delay(1000);
}

void loop2()
{
    if (Serial.available() > 0)
    {
        long frequency = Serial.parseInt(); // Чтение частоты из UART
        if (frequency > 0 && frequency <= MAX_FREQUENCY)
        {
            setFrequency(frequency);
            Serial.print("Frequency set to: ");
            Serial.println(frequency);
        }
        else
        {
            Serial.println("Invalid frequency. Please enter a value between 0 and 400000000.");
        }
    }
}