AD988 waveform generate (RaspberryPi, Python)

Question

There is a project that has not been in progress for about two weeks due to this problem. I tried to follow the data sheet, but I failed because I didn't know about the register when setting the frequency. Please explain in detail what's wrong with the code, what needs to be corrected, and what needs to be corrected to suit the purpose I want. I desperately need your help. Please help a sad graduate studen :(

What I want to do (proceed in this order)

1. DAC : Digital to Analog Converter (use AD9833 dds module)
2. Sweep frequency data generate
   • 32700hz~32800hz, 0.55s
   • 0.55/100 each frequency. ex : 1*(0.55/100)->32700Hz, 2*(0.55/100)->32701Hz
   • All frequency waveform output at once
3. waveform generate (sqaure wave, 0.55s)
4. send waveform to AD9833
5. Digital signal (frequency data) receive (another device)
6. measure frequency data generate (receive digital signal. ex : 32757Hz)
7. waveform generate (sqaure wave, 0.5s)
8. Repeat process 2 to 7

The code what I used to refer to

Application note: http://www.analog.com/media/en/technical-documentation/application-notes/AN-1070.pdf

Data Sheet: http://www.analog.com/media/en/technical-documentation/data-sheets/AD9833.pdf

Git-Hub : https://github.com/city028/AD9833 , https://github.com/KipCrossing/Micropython-AD9833/blob/master/ad9833.py

The code that I tried to do at python (vscode)

import spidev
import time
import RPi.GPIO as GPIO

spi = spidev.SpiDev()
spi.open(0, 0)
spi.max_speed_hz = 500000

def send_data(input):
    tx_msb = (input & 0xFFFC000) >> 14 # tx_msb = input >> 8
    tx_lsb = input & 0x3FF
    spi.xfer([tx_msb, tx_lsb])
    print(input, "=", hex(input))  

def __init__(self, spi_bus, cs, fsy, clk, fmclk=25):
        self.fmclk = fmclk * 10**6
        
        self.spi = spidev.SpiDev()
        self.spi.open(spi_bus, cs)
        self.spi.max_speed_hz = 5000000  # In AD9833 datasheet
        self.cs = cs
        self.fsy = fsy
        self.clk = clk

        GPIO.setmode(GPIO.BCM)
        GPIO.setup(cs, GPIO.OUT)
        GPIO.setup(fsy, GPIO.OUT)
        GPIO.setup(clk, GPIO.OUT)

        self.set_control_reg(B28=1, RESET=1)

        self.mode = "RESET"
        self.writeMode = "BOTH"
        self.freq0 = 0
        self.freq1 = 0
        self.phase0 = 0
        self.phase1 = 0

        return

def write_data(self, data):
        self.spi.xfer2(data)
        return

def set_control_reg(self, B28=1, HLB=0, FS=0, PS=0, RESET=0, SLP1=0, SLP12=0, OP=0, DIV2=0, MODE=0):
        self.B28 = B28
        self.HLB = HLB
        self.FS = FS
        self.PS = PS
        self.RESET = RESET
        self.SLP1 = SLP1
        self.SLP12 = SLP12
        self.OP = OP
        self.DIV2 = DIV2
        self.MODE = MODE

        controlReg = (B28 << 13) + (HLB << 12) + (FS << 11) + (PS << 10) + (RESET << 8) + (SLP1 << 7) + (SLP12 << 6) + (OP << 5) + (DIV2 << 3) + (MODE << 1)

        controlRegList = [(controlReg & 0xFF00) >> 8, controlReg & 0x00FF]

        self.write_data(controlRegList)

        return


start_frequency = 32600
end_frequency = 32800

for decimal_frequency in range(start_frequency, end_frequency):
 hex_frequency = hex(decimal_frequency)[2:]
 print(f"{decimal_frequency}Hz(10) -> 0x{hex_frequency}(16)")

Sweep_reset_reg = 0x0100
Sweep_MSB_reg = 0x1000
Sweep_FREQ_0_Reg_MSB = 0x4000
Sweep_LSB_reg = 0x0000
Sweep_FREQ_0_reg_LSB = 0x5FF5
Sweep_Blockwave = 0x0028


Measure_reset_reg = 0x0100
Measure_MSB_reg = 0x1000
Measure_FREQ_0_Reg_MSB = 0x4000
Measure_LSB_reg = 0x0000
Measure_FREQ_0_reg_LSB = 0x5FF5
Measure_Blockwave = 0x0028

Sleep12 = 0x0040
sweep_wait_time = 0.55
measure_wait_time = 0.5
num_iterations = 5  


def calculate_frequency(msb, lsb):
    full_value = ((msb & 0x3FFF) << 14) | (lsb & 0x3FFF)
    return full_value
Sweep_frequency = calculate_frequency(S_FREQ_0_Reg_MSB, S_FREQ_0_reg_LSB)
Measure_frequency = calculate_frequency(M_FREQ_0_Reg_MSB, M_FREQ_0_reg_LSB)
print(f"calculated frequency: {Sweep_frequency}")
print(f"calculated frequency: {Measure_frequency}")

send_data(S_reset_reg)  # Send a reset
send_data(S_MSB_reg)  # MSB setting
send_data(S_FREQ_0_Reg_MSB)  # Freq 0 reg for 400hz and 1400hz
send_data(S_LSB_reg)  # LSB setting
send_data(S_FREQ_0_reg_LSB)  # Freq 0 reg = 2300hz

for _ in range(num_iterations):
    send_data(Sweep_reset_reg)  # Send a reset
    send_data(Sweep_MSB_reg)  # MSB setting
    send_data(Sweep_FREQ_0_Reg_MSB)  # Freq 0 reg for 400hz and 1400hz
    send_data(Sweep_LSB_reg)  # LSB setting
    send_data(Sweep_FREQ_0_reg_LSB)  # Freq 0 reg = 2300hz
    send_data(Sweep_Blockwave)  # Blockwave output
    time.sleep(sweep_wait_time)

    send_data(Measure_reset_reg)  # Send a reset
    send_data(Measure_MSB_reg)  # MSB setting
    send_data(Measure_FREQ_0_Reg_MSB)  # Freq 0 reg for 400hz and 1400hz
    send_data(Measure_LSB_reg)  # LSB setting
    send_data(Measure_FREQ_0_reg_LSB)  # Freq 0 reg = 2300hz
    send_data(Measure_Blockwave)  # Blockwave output
    time.sleep(measure_wait_time)

send_data(Sleep12)

Output

The oscilloscope was able to detect pulse waves. But an unintended frequency has been output.