Simulador de Phase Locked Loop em SystemC-AMS

1. Introdução

Quando comecei a aprender SystemC-AMS, um dos primeiros circuitos que decidi implementar foi um Phase Locked Loop. A razão para isto é porque tive uma experiência a simular um PLL de 2.4GHz enquanto era membro do Grupo de Estudantes de Microelectrónica, e apercebi-me de como é difícil simular tal circuito, especialmente quando a frequência de saída e a frequência de referência estão várias ordens de grandeza separadas. O simulador tem de usar um passo de tempo pequeno para acomodar a frequência mais alta, mas ao mesmo tempo, o PLL vai demorar um tempo relativamente longo a bloquear e atingir o estado estacionário.

Outra razão para escolher este circuito é porque contém circuitos tanto analógicos como digitais, por isso é possível usar diferentes domínios de simulação como tempo discreto, tempo contínuo e sistemas lineares como pode ser visto mais tarde.

Os PLLs são usados numa ampla gama de aplicações desde a velha rádio FM até às comunicações móveis celulares 5G. Combinam a pureza espectral dos osciladores de quartzo com a agilidade dos osciladores controlados por tensão.

Este documento não pretende introduzir os leitores à teoria dos PLL. Para esse propósito existem vários livros e recursos online. Um bom ponto de partida poderão ser as seguintes lições do Dr. Shouribrata Chatterjee do IIT Delhi:

• Phase locked loop basics
• Charge pump
• Pll dynamics integer

SystemC AMS é uma extensão ao SystemC para funcionalidade analógica, mista e RF. O padrão SystemC AMS 2.0 foi lançado a 6 de Abril de 2016 como IEEE Std 1666.1-2016. ¹ No momento da escrita, está disponível para download sob a licença Apache 2.0 no site da COSEDA Technologies.

Após a primeira implementação deste simulador, na qual usei apenas ferramentas livremente disponíveis, a COSEDA Technologies gentilmente permitiu-me testar o seu software COSIDE® por um período de tempo. O software COSIDE® é baseado em GUI e apresenta as seguintes ferramentas e funcionalidades:

• Editor de Esquemas
• Visualizador de Formas de Onda
• Editor de Diagramas de Estado
• Modelação TLM
• Modelos Protegidos por IP
• Exportação de Modelos SystemC / SystemC AMS
• Bibliotecas SystemC AMS

Trata de todo o aborrecimento de compilar as bibliotecas e código fonte SystemC/SystemC-AMS. Também fornece funcionalidades de debug muito melhores que as ferramentas gratuitas. Sem mencionar que o editor de esquemas é imprescindível para sistemas complexos. Pode poupar inúmeras horas-homem em desenvolvimento e debug em aplicações profissionais.

Para aplicações académicas, ou quando limitações orçamentais não permitem comprar software dedicado, as ferramentas gratuitas podem ser usadas, à custa de mais tempo de desenvolvimento.

Neste documento ambas as implementações são apresentadas.

2. Domínios de Simulação SystemC-AMS

Antes de saltarmos para a implementação do sistema, é importante compreender os 3 diferentes domínios de simulação em SystemC-AMS. Existem três domínios diferentes e todos os três são usados neste exemplo. São eles:

• Discrete Event (DE): Este domínio de simulação é herdado do SystemC. É conduzido por eventos (por exemplo, por flancos de relógio) e é o domínio perfeito para descrever circuitos digitais. Do ponto de vista computacional, este é o domínio rápido pois o algoritmo só precisa de calcular novos estados, quando uma das condições de sensibilidade ocorre. Por exemplo, um flip-flop D permanecerá no mesmo estado até um novo flanco ascendente do sinal de relógio.

• Timed Data Flow (TDF): Neste domínio, o designer tem de descrever o comportamento do circuito no domínio do tempo programaticamente. Assim pode definir as suas próprias equações e eventos no domínio do tempo. O designer também precisa de especificar um passo de tempo para o qual o estado deve ser actualizado. Em termos de poder computacional este domínio pode ser muito custoso para passos de tempo pequenos. Contudo, na maioria dos sistemas de controlo, o passo de tempo pode ser relaxado à medida que o erro do sistema é reduzido ou o sistema se move para um estado estacionário. Esta técnica é chamada Dynamic Timed Data Flow (DTDF).

• Electrical Linear Networks (ELN): Neste domínio, o designer pode desenhar circuitos eléctricos com componentes lineares como resistências, condensadores e indutores. A biblioteca SystemC-AMS irá então derivar as equações do circuito e resolvê-las para cada passo de tempo. O esforço computacional é semelhante ao domínio TDF.

3. Visão Geral do Sistema

Os blocos constituintes do PLL, a sua ligação e os seus domínios de simulação são mostrados na seguinte imagem.

Figure 3.1: Diagrama de nível de sistema.

O Phase Frequency Detector (PFD) compara a fase do relógio de referência com a fase do sinal de realimentação. Se a fase do relógio de referência estiver à frente do sinal de realimentação, irá “dizer” à bomba de carga para “ir mais depressa”. Se o sinal de realimentação estiver à frente, irá “dizer” para “ir mais devagar”. Usando estes sinais up/down, a Charge Pump (CP) gera impulsos de corrente positiva ou negativa. Esta corrente é aplicada ao Loop Filter (LF), que a integra e gera a tensão de controlo que é aplicada ao Voltage Controlled Oscillator (VCO) e define a frequência da saída. O Frequency Divider pega no sinal de saída e divide a sua frequência por um factor predefinido, gerando o sinal de realimentação que é comparado com o relógio de referência.

4. Blocos constituintes

4.1 Phase Frequency Detector

O PFD tem 3 estados possíveis:

• Idle: Durante este estado, a saída do PFD é 0. A bomba de carga não fornece nem consome corrente para o filtro de loop.
• Up: Durante este estado, a saída do PFD é +1. A bomba de carga fornece corrente ao filtro de loop que por sua vez aumenta a tensão de controlo na entrada do VCO.
• Down: Durante este estado, a saída do PFD é -1. A bomba de carga consome corrente do filtro de loop que por sua vez diminui a tensão de controlo na entrada do VCO.

O diagrama de estados para o PFD é representado na figure 4.1.

Figure 4.1: Diagrama de estados do PFD

Existem 3 estados e 3 níveis de saída. O que significa que esta máquina de estados requer dois flip-flops e dois bits de saída. Esta máquina de estados é implementada no circuito da figure 4.2.

Figure 4.2: Circuito do Detector de Desvio de Frequência.

4.1.1 Implementação Com Ferramentas Open-Source

Este bloco pode ser modelado como um elemento de tempo discreto que é sensível aos flancos positivos das entradas de relógio. A implementação é directa:

/**
 * Processing thread
 */
void sc_pfdetector::sig_proc(void) {
	static int state = 0;
	int next_state;

	switch(state) {
		case IDLE:
			if(sc_in_fref && sc_in_fdiv) {
				// Both fref and fdiv went up during last
				// timestep: keep IDLE
				next_state = IDLE;
			} else if(sc_in_fref) {
				sc_out_up.write(true);
				next_state = UP;
			} else if(sc_in_fdiv) {
				sc_out_dn.write(true);
				next_state = DN;
			}
			break;
		case UP:
			if(sc_in_fdiv) {
				sc_out_up.write(false);
				next_state = IDLE;
			}
			break;
		case DN:
			if(sc_in_fref) {
				sc_out_dn.write(false);
				next_state = IDLE;
			}
			break;
	}

	state = next_state;

}

Este código implementa a máquina de estados ilustrada na figure 2.1. A única condição não ilustrada no diagrama é quando tanto V_ref como V_div sobem durante o último período de passo de tempo. Neste caso, ambas as transições devem ser ignoradas.

A implementação C++ do PFD pode ser encontrada no meu repositório GitHub:

• sc_pfdetector.cpp
• sc_pfdetector.h

4.1.2 Implementação com COSIDE®

Desenhar o esquema em COSIDE® é extremamente simples e intuitivo para qualquer pessoa habituada a desenhar esquemas em qualquer outro editor. A interface é apresentada na figure 4.3.

Figure 4.3: Interface do editor de esquemas COSIDE®.

A COSEDA fornece uma biblioteca completa e abrangente de componentes prontos a usar à distância de um clique do rato.

Existe uma biblioteca básica com todo o tipo de componentes analógicos e digitais e fontes. Existe uma biblioteca dedicada a componentes RF, como conversores, misturadores, fontes de ruído, moduladores, desmoduladores, etc. Claro que o utilizador é capaz de criar componentes personalizados e usá-los num diagrama de nível superior como pode ser visto mais abaixo neste documento.

O diagrama esquemático do PFD foi implementado usando dois flip-flops tipo D e uma porta AND da biblioteca COSIDE® como ilustrado na figure 4.4.

Figure 4.4: Implementação do PFD usando vista esquemática COSIDE®.

Ter uma interface tão rápida e fácil para criar os esquemas também facilita a criação de testbenches dedicados para cada bloco.

Isso também é possível usando ferramentas open source, mas é uma tarefa muito mais demorada. Criar um ficheiro CPP com todas as interligações, fontes e estímulos pode ser uma tarefa confusa e requer muita concentração e organização.

A figure 4.5 mostra o testbench que usei para testar o PFD.

Figure 4.5: Esquema do testbench do PFD.

O COSIDE® também fornece um visualizador de formas de onda incorporado. Pela experiência que tive, é muito mais rápido que os visualizadores de formas de onda livremente disponíveis que testei.

Figure 4.6: Resultados da simulação do PFD.

4.2 Charge Pump

A implementação da CP modela três imperfeições do circuito real: o descasamento de corrente, a região de tríodo do transístor e a corrente de fuga.² O descasamento de corrente e a corrente de fuga irão causar os espúrios de referência. A região de tríodo do transístor resultará no aumento do tempo de estabilização.

Ignorando o efeito de corpo, a equação para a corrente na região de saturação é:

$$I_\text{DSAT} = \frac{\mu_n C_\text{ox} W}{2L}\left(V_\text{GS} - V_\text{th}\right)^2 \tag{1}$$

Como I_DSAT e V_th são especificados:

$$\frac{\mu_n C_\text{ox} W}{L} = \frac{2 I_\text{DSAT}}{\left(V_\text{GS} - V_\text{th}\right)^2} \tag{2}$$

Quando a tensão de saída é menor que V_GS − V_th, os transístores operam na região de tríodo, seguindo a equação:

$$ I_\text{D} = \frac{\mu_n C_\text{ox} W}{L} \left( \left(V_\text{GS} - V_{th}\right)V_\text{DS} - \frac{{V_\text{DS}}^2}{2} \right) \tag{3}$$

Misturando as duas últimas equações e sabendo que V_GS = V_dd, a seguinte equação é obtida:

$$ I_\text{D} = \frac{2I_\text{DSAT}}{V_\text{DD} - V_{th}} V_\text{DS} - \frac{I_\text{DSAT}}{\left(V_\text{DD} - V_{th}\right)^2} \left.V_\text{DS}\right.^2 \tag{4} $$

Especificando, por exemplo, V_dd=3.3V, I_DSAT=100μA, e V_th=0.7V a solução é:

$$ I_\text{D} \approx 77 V_\text{DS} - 14.8 \left.V_\text{DS}\right.^2 \left(\mu A\right) \tag{5}$$

Assim, o I_D versus V_DS fica:

Figure 4.7: I_D versus V_DS.

A bomba de carga foi implementada num modelo Timed Data Flow, e o thread de processamento fica:

/**
 * Processing thread
 */
void sca_tdf_chargepump::processing(void) {

	double charge = 0,
			discharge = 0,
			mismatch = 0,
			i = 0;

	// Discharge (NMOS)
	if(sca_tdf_in_vcp>mosfet_vtn) {
		// Saturation
		discharge=-current_dn;
	} else {
		// Triode
		double vds = sca_tdf_in_vcp;
		discharge=-((2.0/(vdd-mosfet_vth))*current_dn*vds-(1.0/pow(vdd-mosfet_vth,2.0))*current_dn*pow(vds,2.0));
	}

	// Charge (PMOS)
	if(sca_tdf_in_vcp<mosfet_vtp) {
		// Saturation
		charge=current_up;
	} else {
		// Triode
		double vds = vdd-sca_tdf_in_vcp;
		charge=(2.0/(vdd-mosfet_vth))*current_up*vds-(1.0/pow(vdd-mosfet_vth,2.0))*current_up*pow(vds,2.0);
	}

	mismatch=charge+discharge;

	/**
	 * Set the output current depending on the inputs state
	 * (up/down)
	 */
	if(sc_in_up && !sc_in_dn) {
		i = charge;
	}
	else if(!sc_in_up && sc_in_dn) {
		i = discharge;
	}
	else if(!sc_in_up && !sc_in_dn) {
		i = -current_leak;
	}
	else if(sc_in_up && sc_in_dn) {
		i = mismatch;
	}

	/**
	 * Limit the output current if the loop filter input voltage
	 * is out of limits (V_CTRL < 0 || V_CTRL > vdd)
	 */
	if((sca_tdf_in_vcp>vdd && i>0) || (sca_tdf_in_vcp<0 && i<0)) {
		i=0;
	}

	sca_tdf_out_ictrl = i;
}

O thread sca_tdf_chargepump::processing executa uma vez por passo de tempo. Na primeira parte do código, o i_ds de ambos os transístores é calculado para a região de operação actual. Na segunda parte, a corrente de saída resultante é calculada baseada nos resultados anteriores e no estado dos sinais de entrada up e down. Finalmente, a condição final é usada para prevenir que a tensão na saída da bomba de carga suba acima de VDD ou desça abaixo do terra.

Como mencionado, o COSIDE® tem uma excelente biblioteca de componentes, mas falta-lhe dispositivos não-lineares como transístores. Assim, este bloco foi implementado de forma similar na versão open-source e na versão COSIDE®.

A implementação do código open-source fica:

• sca_tdf_chargepump.cpp
• sca_tdf_chargepump.h

4.3 Loop Filter

A corrente da bomba de carga flui para - ou do - filtro de loop gerando uma tensão V_cp. Note que esta tensão tem de ser realimentada para a bomba de carga, para calcular o ponto de operação dos transístores (V_DS). O filtro tem uma grande importância para o desempenho e estabilidade do circuito.

Figure 4.8: Esquema equivalente da Bomba de Carga e Filtro de Loop.

A figure 4.8 mostra um filtro de 3ª ordem. Onde a tensão de saída é obtida nos terminais de C₃. No caso do filtro ser configurado para 2ª ordem, R₃ e C₃ são removidos, e V_ctrl é ligado ao mesmo nó que V_cp. A teoria por trás do projecto do filtro não é coberta aqui. Mas existem muitos livros sobre o assunto como “PLL performance, simulation, and design” ³ que tem muitos exemplos práticos. Existem também calculadoras online ⁴ e até aplicações de fontes fidedignas como a Texas Instruments ⁵.

4.3.1 Implementação Com Ferramentas Open-Source

O filtro de loop foi implementado usando o seguinte código:

/**
 * Constructor implementation
 */
sc_lfilter::sc_lfilter (sc_module_name name_,
		int order_,
		double c1_value_,
		double r2_value_,
		double c2_value_,
		double r3_value_,
		double c3_value_ ):
		sc_module(name_)
{
	// Variables initialization
	order=order_;
	r0_value=1e-6;
	c1_value=c1_value_;
	r2_value=r2_value_;
	c2_value=c2_value_;
	r3_value=r3_value_;
	c3_value=c3_value_;

	// Convert the TDF input to an ELN current
	i_in = new sca_eln::sca_tdf_isource("i_in", 1.0);
	i_in->inp(sca_tdf_in_ictrl);
	i_in->p(gnd);
	i_in->n(node0);

	// Shunt resistor used for debug purposes
	r0 = new sca_eln::sca_r("r0", 1e-6);
	r0->p(node0);
	r0->n(node1);

	// Convert the output voltage from ELN to TDF
	v_cp = new sca_eln::sca_tdf_vsink("v_cp", 1.0);
	v_cp->p(node1);
	v_cp->n(gnd);
	v_cp->outp(sca_tdf_out_vcp);

	c1 = new sca_eln::sca_c("c1", c1_value);
	c1->p(node1);
	c1->n(gnd);

	// First part
	r2 = new sca_eln::sca_r("r2", r2_value);
	r2->p(node1);
	r2->n(node2);
	c2 = new sca_eln::sca_c("c2", c2_value);
	c2->p(node2);
	c2->n(gnd);

	// Convert the output voltage from ELN to TDF
	v_out = new sca_eln::sca_tdf_vsink("v_vout", 1.0);
	v_out->n(gnd);
	v_out->outp(sca_tdf_out_vctrl);

	if(order==2) {
		v_out->p(node1);
	}
	if(order==3) {
		// If the order is 3, add the extra components
		r3 = new sca_eln::sca_r("r3", r3_value);
		c3 = new sca_eln::sca_c("c3", c3_value);
		r3->p(node1);
		r3->n(node3);
		c3->p(node3);
		c3->n(gnd);
		v_out->p(node3);
	}

}

A implementação completa pode ser encontrada em:

• sc_lfilter.cpp
• sc_lfilter.h

4.3.2 Implementação com COSIDE®

Mais uma vez a vantagem do IDE COSIDE® torna-se muito clara. Em vez das 70 linhas de código da secção anterior (mais o ficheiro header), é possível desenhar rapidamente o esquema:

Figure 4.9: Esquema do filtro de loop em COSIDE®.

4.4 Oscilador controlado por tensão

O VCO converte a tensão de controlo numa frequência seguindo as equações:

$ f(t) = f_{min} + k_{vo} V_{ctrl} \tag{6}$

Onde, f_min é a frequência mínima de oscilação quando V_ctrl é zero, e k_vo é o ganho do VCO. Se a tensão de controlo fosse constante, a expressão para a tensão de saída seria simplesmente:

$ v_{o}(t) = V_{cm} + V_{cm} \sin \big( (f_{min} + k_{vo} V_{ctrl}) \times 2 \pi \times t \big) \tag{7}$

Mas como a tensão de controlo muda com o tempo, a matemática não é tão directa. Em vez disso, a frequência instantânea precisa de ser integrada para obter o ângulo instantâneo para cada passo de tempo. As equações para isto são:

$ v_{o}(t) = V_{cm} + V_{cm} \sin \Bigg( \int_{0}^{t} \omega(\tau) d\tau \Bigg) \tag{8}$

onde,

$ \omega(\tau) = 2\pi\big(f_{min}+k_{vo} V_{ctrl}(\tau)\big)\tag{9}$

Note que o integral pode ser limitado entre 0 e 2π. Em SystemVerilog AMS existe uma função chamada idtmod que implementa este integral. Neste caso, foi implementada com o seguinte código C++:

double idtmod(double frequency, double time) {
	static double time0 = 0;
	static double phi0 = 0;

	double T { 1 / frequency };
	double phi = phi0 + 2*M_PI*(time-time0)/T;

	phi0 = phi = fmod(phi, 2*M_PI);		// Limit the phase between 0 and 2*pi
	time0 = time;						// Save the time for the next integration

	return phi;
}

O resultado é ilustrado na figure 4.10

Figure 4.10: Fase instantânea calculada pelo idtmod.

O thread de processamento é então muito simples de implementar como se segue.

/**
 * Processing thread
 */
void sca_tdf_vcoscillator::processing(void) {
	double frequency = kvo*sca_tdf_in_vctrl.read() + fmin;
	double time = sc_time_stamp().to_seconds();

	double phi=idtmod(frequency, time);

	sca_tdf_out_fout.write((double)(vcm+vcm*sin(phi)));
	sca_tdf_out_fout_freq.write(frequency);

}

O mesmo código foi usado para implementação com ferramentas open-source e COSIDE®:

• sca_tdf_vcoscillator.cpp
• sca_tdf_vcoscillator.h

4.5 Divisor de frequência

Finalmente, o Divisor de Frequência divide a frequência de saída por um factor de N.

$f_{div} = \frac{f_{out}}{N} \tag{10} $

4.5.1 Implementação Com Ferramentas Open-Source

O código da função de processamento fica:

/**
 * Processing thread
 */
void sca_tdf_divider::processing(void) { // our workhorse method

	if(sca_tdf_in_fin.read() >= vcm and state == false) {
		state = true;
		counter += 2;
		if(counter >= factor) {
			counter = 0;
			state_div = !state_div;
		}
	}
	else if(sca_tdf_in_fin.read() < vcm){
		state = false;
	}
	sc_out_fout.write(state_div);
}

Também converte o sinal de saída do domínio timed data flow para tempo discreto para ser usado como entrada no detector de fase.

4.5.2 Implementação com COSIDE®

Em COSIDE®, mais uma vez o editor de esquemas foi usado para projectar o esquema do divisor de frequência. A implementação é ilustrada na figure 4.11.

Figure 4.11: Esquema do divisor de frequência em COSIDE®.

4.6 Nível superior

4.6.1 Implementação Com Ferramentas Open-Source

No ficheiro fonte principal, todos os blocos são instanciados e ligados. Duas bibliotecas extra foram usadas:

• JSON for Modern C++: Usada para analisar o ficheiro de configuração contendo todas as variáveis de simulação.
• Lightweight C++ command line option parser: Usada para analisar o argumento da linha de comando.

O ficheiro fonte completo pode ser encontrado no repositório github.

4.6.2 Implementação com COSIDE®

A figure 4.12 mostra a implementação de nível superior em COSIDE®. Por razões óbvias, é muito mais legível e fácil de entender que o equivalente C++.

Figure 4.12: Esquema de nível superior do PLL em COSIDE®.

Neste caso, um componente chamado Parameter Reader foi usado para analisar a configuração de um ficheiro de texto. Este componente é parte da biblioteca COSIDE®.

5. Resultados das simulações

Quatro simulações foram conduzidas tanto na versão COSIDE® como Open Source do simulador PLL. Em todas elas, a frequência de saída foi definida para 2.45-GHz. Um filtro de loop de segunda ordem e de terceira ordem foi testado e ambos foram calculados para 45° de margem de fase (60° seria um melhor projecto, mas ter algum overshoot força o PFD a gerar impulsos negativos (down)). A figure 5.1 mostra o cálculo do filtro de loop usando a calculadora da Texas Instruments. Como declarado antes, a corrente de saída da bomba de carga é 100µA. Existem duas configurações para a corrente de fuga: 100nA e 50uA.

Figure 5.1: Calculadora de Filtro de Loop da Texas Instruments.

As combinações são então:

• Filtro de loop de 2ª ordem, fuga de 100nA (Download: JSON, PAR).
• Filtro de loop de 2ª ordem, fuga de 50nA (Download: JSON, PAR).
• Filtro de loop de 3ª ordem, fuga de 100nA (Download: JSON, PAR).
• Filtro de loop de 3ª ordem, fuga de 50nA (Download: JSON, PAR).

A figure 5.2 mostra a resposta transitória para a versão de filtro de loop de 2ª ordem com fuga de 100nA na bomba de carga simulada com versões COSIDE® e Open Source. Como esperado, ambas as versões dos resultados são idênticas (dica: use a versão interactiva para aumentar o zoom e ver a diferença). Existe um ligeiro overshoot na resposta, como esperado de um sistema com margem de fase de 45°, e depois estabiliza nos desejados 2.45-GHz.

Figure 5.2: Simulação transitória, COSIDE® vs Open Source, filtro de 2ª ordem (versão interactiva).

A figure 5.3 mostra a resposta transitória para o filtro de loop de 3ª ordem. Novamente, ambas as versões do simulador têm os mesmos resultados.

Figure 5.3: Simulação transitória, COSIDE® vs Open Source, filtro de 3ª ordem (versão interactiva).

Como esperado, o filtro de 3ª ordem tem uma saída mais suave pois os componentes extra actuam como um filtro passa-baixo. A figure 5.4 mostra ambas as simulações lado-a-lado e a figure 5.5 mostra uma comparação entre ambos os ripples na saída após o estado estacionário ser atingido.

Figure 5.4: Simulação transitória, filtro de 2ª vs 3ª ordem (versão interactiva).

Figure 5.5: Simulação transitória, filtro de 2ª vs 3ª ordem (detalhe) (versão interactiva).

Como previamente declarado, este ripple é causado pela corrente de fuga na bomba de carga, que força o PLL a compensar por ela - gerando impulsos UP esporádicos

• para manter a frequência próxima do valor escolhido.

O espectro de frequência do PLL é ilustrado na figure 5.6. Mostra uma comparação entre filtro de loop de 2ª ordem e 3ª ordem. Como esperado, o de 3ª ordem tem um espúrio de referência menor (-37.8-dBc versus -33.2-dBc). Este espúrio de referência é a representação do ripple mostrado nos resultados da simulação transitória mas no domínio da frequência. A frequência central é bastante precisa com uma variação de apenas +2 PPM do valor desejado. Isto só é possível porque muitas não-idealidades não são simuladas neste modelo, como descasamentos, offsets de tensão, ruído, etc. Contudo, o leitor pode tomar este exemplo como referência e adicionar outras não-idealidades.

Figure 5.6: Espectro de Frequência, filtro de 2ª vs 3ª ordem (versão interactiva).

Quando comparando com literatura existente, este projecto tem pior desempenho em termos de ruído de fase e espúrio de referência. ⁶ Isto é porque o ganho geral desta configuração é bastante pequeno. O ganho de laço aberto é definido por:

$ G(s)=\frac{I_{cp}}{2 \pi} . F(s) . \frac{k_{vco}}{s}.\frac{1}{N} \tag{11} $

Onde F(s) é a função de transferência do filtro de loop. As únicas variáveis directamente proporcionais ao ganho (I_cp e k_vco) são relativamente pequenas. I_cp pode ser facilmente aumentado à custa de componentes passivos maiores no filtro. O ganho do VCO pode ser também facilmente aumentado.

Outra forma de reduzir os espúrios é reduzir a fuga na bomba de carga que os está a causar em primeiro lugar. Em sistemas reais contudo, os espúrios podem ser causados por acoplamento entre o oscilador de referência e o estágio de saída do PLL. Este acoplamento por sua vez pode ser causado por mau projecto (i.e. mau isolamento entre diferentes domínios) e/ou acoplamento da fonte de alimentação. Por esta razão, blocos de gestão de energia para sistemas RF precisam de assegurar uma boa relação de rejeição da fonte de alimentação (PSRR).

A figure 5.7 mostra uma comparação entre fuga de 100nA e fuga de 50nA e a diferença é mais de 5-dBc.

Figure 5.7: Espectro de Frequência, fuga de 100nA vs 50nA (versão interactiva).

6. Download

A versão open-source deste exemplo está disponível no meu repositório GitHub. Pode ser compilado em Windows, MacOS e Linux.

A implementação COSIDE@ é gentilmente mantida pela COSEDA e está disponível no seu website, em:

• https://www.coseda-tech.com/download

7. Referências