Very good! I'll read up on it tonight, and move the pin assignments so we have that capability. Also thinking maybe the 5V input can be potential divided and put into an ADC pin since that's also a monitoring type of thing, and can just flash a different pattern or have a third LED for that.

Non-interrupt alternative: I'm reading up on the generic timer peripherals of the CH32. If one of them can be used to validate if an input (the LD output) has been pulsing.

They support input capture mode, that could (maybe?) be used to check if an edge has occurred at the input, in the super-loop instead of with an interrupt.

If the current counter value <> previous, then there was at least one LD pulse...

Reading up a bit more, both the MAX2870 and the ADF4001 have a configurable lock-detect (LD) output pin. which can be set in two modes; digital, and analog-sourced (the output is digital in both cases, but the analog lock detect is supposedly more accurate). I wanted to have an LED that would indicate both out-of-lock, and unconfigured state (i.e. board powered up but no SPI config done), which is hard to do without using the analog detected version, which outputs narrow pulses when locked.

I figure it is a nice opportunity to learn how to use interrupts and try to use the CH32V003, as a 'monitor' chip. It will be programmed to detect pulses, and if it finds them, then the LED will be turned off. If the pulses disappear, then the LED blinks fast as a warning that something is wrong. This will be optional functionality, since it is only monitoring and not controlling anything other than the LEDs.

I've tested this source code (just with pulses from a sig-gen, I've no idea how narrow the pulses will be in real life, but if it doesn't work, then I can always switch it to the (perhaps less accurate) digital lock detect with just a code change.

/********************************
 * main.c
 * synth_monitor
 * rev 1 - shabaz - Feb 2024
 ********************************/

/*****************************************************
 * Connections
 * PC0 - ADF4001 MUX pin (Lock Detect) input
 * PC1 - MAX2870 LD pin (Lock Detect) input
 * PC3 - AD_OOL (ADF4001 Out of Lock LED output)
 * PC4 - AD_OOL (MAX2870 Out of Lock LED output)
 *****************************************************/

// ************ includes *************************
#include "debug.h"

// ************ defines **************************
#define FOREVER 1
#define TIMER_START_VAL 10
#define LED_PC3_ON GPIO_SetBits(GPIOC, GPIO_Pin_3);
#define LED_PC3_OFF GPIO_ResetBits(GPIOC, GPIO_Pin_3);
#define LED_PC4_ON GPIO_SetBits(GPIOC, GPIO_Pin_4);
#define LED_PC4_OFF GPIO_ResetBits(GPIOC, GPIO_Pin_4);

// ************ global variables *****************
uint16_t hold_timer_0 = 0;
uint16_t hold_timer_1 = 0;
uint8_t led_pc3_state = 0;
uint8_t led_pc4_state = 0;

// ************ function prototypes ***************
void EXTI7_0_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));


// ****************** functions *******************
void pc3_toggle_led(void) {
    led_pc3_state ^= 1;
    if (led_pc3_state) {
        LED_PC3_ON;
    } else {
        LED_PC3_OFF;
    }
}

void pc4_toggle_led(void) {
    led_pc4_state ^= 1;
    if (led_pc4_state) {
        LED_PC4_ON;
    } else {
        LED_PC4_OFF;
    }
}

void out_gpio_init(void) {
    GPIO_InitTypeDef GPIO_InitStructure = {0};

    // enable periph clock for GPIOC
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);

    // configure PC3 as output
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    // configure PC4 as output
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    GPIO_Init(GPIOC, &GPIO_InitStructure);
}

void ext_int_init(void) {
    GPIO_InitTypeDef GPIO_InitStructure = {0};
    EXTI_InitTypeDef EXTI_InitStructure = {0};
    NVIC_InitTypeDef NVIC_InitStructure = {0};

    // enable periph clock for AFIO and GPIOC
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOC, ENABLE);

    // configure PC0 as input with pull-up
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    // configure PC1 as input with pull-up
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    // enable EXTI0 interrupt for PC0
    GPIO_EXTILineConfig(GPIO_PortSourceGPIOC, GPIO_PinSource0);
    EXTI_InitStructure.EXTI_Line = EXTI_Line0;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_Init(&EXTI_InitStructure);

    // enable EXTI1 interrupt for PC1
    GPIO_EXTILineConfig(GPIO_PortSourceGPIOC, GPIO_PinSource1);
    EXTI_InitStructure.EXTI_Line = EXTI_Line1;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_Init(&EXTI_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = EXTI7_0_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

}

// **************** interrupt handlers *************
void EXTI7_0_IRQHandler(void) {
    // PC0
    if(EXTI_GetITStatus(EXTI_Line0)!=RESET) // PC0 interrupt occurred
    {
        hold_timer_0 = TIMER_START_VAL;
        LED_PC3_OFF;
        EXTI_ClearITPendingBit(EXTI_Line0);  // clear interrupt flag
    }
    // PC1
    if (EXTI_GetITStatus(EXTI_Line1)!=RESET) // PC1 interrupt occurred
    {
        hold_timer_1 = TIMER_START_VAL;
        LED_PC4_OFF;
        EXTI_ClearITPendingBit(EXTI_Line1);  // clear interrupt flag
    }
}

// *************************************************************
// ********************* main function *************************
// *************************************************************

int
main(void)
{
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    SystemCoreClockUpdate();
    Delay_Init();

    out_gpio_init(); // configure PC3 and PC4 as outputs (LEDs)
    ext_int_init(); // configure PC0 and PC1 as external interrupts

    // set hold timers to 0, i.e. assume both PLLs are out of lock
    hold_timer_0 = 0;
    hold_timer_1 = 0;

    while(FOREVER)
    {
        Delay_Ms(100);
        if (hold_timer_0) {
            hold_timer_0--;
        } else {
            pc3_toggle_led();
        }
        if (hold_timer_1) {
            hold_timer_1--;
        } else {
            pc4_toggle_led();
        }
    }

    return(0); // warning on this line is fine!
}

The proposed block diag.. it grew to three PLLs! This is the flow:

* On-board 10 MHz oscillator module, plus the capability to attach an external reference

* First PLL is used to generate a 27 MHz clock.

* Second PLL is a Si5351 combined PLL+VCO which can be configured with decent granularity to anything up to around 150.000MHz. This PLL is optional, it can be omitted and bypassed if desired.

* The output from the Si5351 (or the 27 MHz clock if the Si5351 is bypassed) clocks the MAX2870. The advantage of the Si5351 stage is that since it can be adjusted, that means we can achieve extremely high granularity (in the order of Hz or less). 

Although the design is now three times the size! I think it's worth it, since it allows very high granularity, suitable for any radio application, plus it can be locked to an external reference.

Regarding the PLL loop filter for the ADF4001, I wasn't looking forward to trying to figure it out, but I used the ADIsimPLL software, it is very neat, it generates the circuit plus provides lots of useful info. Really impressed. This was its output:

Putting it all together, here's the circuit. Very cramped! I might have to move to additional sheets, but I wanted to keep it to a single page if possible.

I think everything is there, apart from the connector to be able to attach to a microcontroller. Anyway, I'll leave it in this state for a week or so, in case there are any errors or suggestions.

Been refreshing myself on PLL intricacies by reading up and writing some notes.