linear steps and ideally continuous sweep.
For a continuous sweep, it makes no sense to use a DDS IC: continuous implies you'd update the frequency for every output sample, and then you could just calculate the output sample yourself and generate it using a DAC:
In fact, that'd be totally doable here:
linear frequency … from 1-20 MHz.
"only" requires 38 MHz of sampling rate (40 MHz is probably easier to generate, so go with that).
arduino, teensy, or a raspberry pi
- Arduino is pretty certainly not your platform of choice: Lower-end microcontrollers with an execution environment that's not especially optimized for real-time signal generation tasks
- Raspberry Pi: the modern raspberry Pis have plenty of compute power, but running Raspbian or similar they're really not real-time systems, so that'd make your task harder
- Teensy: there's different versions, and you're picking the outdated Teensy 3.2. That's an uneasy restriction: the MCU runs at 72 MHz, which makes frequent updates harder, but in essence, you can use this to update your DDC chip.
Really, though, using a separate DDC with a microcontroller here just makes everything harder:
- you need a clock source. That should be significantly higher than your maximum frequency – the 120 MHz input that the AD9850 can work with sounds like a good idea, but none of the controllers you propose can work with that, so you suddenly have either multiple independent clocks in your system (which will sooner or later mean jitter, probably pretty instantly), or a complex clocking tree that is way more complex to design than the rest of your system.
- you want a continuous chirp. One can implement that with a DDC, but that requires per-sample updates. Cool if your DDC is part of your controller. Not cool if it's on a separate IC.
- it's an expensive solution.
You can solve this in multiple ways. Either
- you use the Teensy 3.2 you want, and live with the fact that you can only do stepped-frequency, not cintinous sweep; relatively easy: you program a timer interrupt service routine that triggers the frequency update.
- you use a modern Teensy (Teensy 4.0) that is way faster, and can make your steps so short that it nearly looks as if you're continuous. (At 120 MHz clkin, the AD9850 can, I think, check the datasheet on that, update frequency at most 6.66... million times a second. With the 600 MHz CPU of the Teensy 4.0, you'd have more than 100 CPU cycles to calculate the new phase increment word and send it – that would work).
- you use an FPGA, and implement a DDC yourself in that, and go through that with increasing speed. You'd connect a DAC to that. You exchange your happiness and sanity for continuous sweeping.
- You use a more powerful computer (essentially, a PC or server or good laptop) and compute the chirp samples on that, and use a arbitrary waveform generator/SDR device to generate the analog signal.
Option 3. is definitely the "industry standard" way of doing this – but it also requires you to learn how to design FPGA applications and to have an FPGA eval board – not an easy requirement.
But honestly: PCs these days are fast, and SDR devices not that expensive. You could trivially implement a chirp in say, GNU Radio and use the so-cheap-it-hurts fl2k project as a DAC. No embedded programming necessary. So, I'd actually recommend option 4. However, using the extremely cheap FL2K solution would make incorporating PPS triggering impossible. You'd have to go for something like an Ettus N200 + BasicTX to allow for that.