• Into the file “cdsLibMgr.lib” was created the menu item “SVN Unlock Cell”
• Into the file “svnLockCell.il” were created the procedures “svnUnlockCell” and “svnUnlockCellFormCB”
• Inside the procedures “svnUnlockCellFormCB” and “svnUnlockCVFormCB” were made the following changes:

• where you have: if( !(rexMatchp(“.*.svn$”, file~>readPath) || rexMatchp(“.*%”, file~>readPath))
• was changed to: if( !(rexMatchp(“.*.svn$”, file~>readPath) || rexMatchp(” “, file~>readPath))

Behaviors observed:

• We don´t want the files *.cd% under version control, but if for some reason they are under version control that exist the possibility to lock them or unlock them.
• Copying a “cell” or a “view” by “Library Manager” doesn´t copy files *.cd% which is not a problem because we don´t want these files under version control.
• The command “[user@host CDSVN]$ svn lock *” or “[user@host CDSVN/bin]$ lock directory/” locks the files *.cd%, however, the “CDSVN Unlock Cell” or “CDSVN Unlock View” does not unlock.
• The “CDSVN Lock Cell” or “CDSVN Lock View” does not unlock the files *.cd%, however, the commands “[user@host CDSVN]$ svn unlock *” or “[user@host CDSVN/bin]$ unlock directory/” are able to unlock.
• Copying by the command “[user@host CDSVN]$ svn copy” copies the files *.cd% only if they are already under version control. The same behavior occurs for “CDSVN Copy Cell” or “CDSVN Copy View”. This is not a problem.
• The command “[user@host CDSVN]$ svn add”, “CDSVN Add Cell” or “CDSVN Add View” does not add files *.cd% even because this type of file is in the list of ignored files as showed below:
  [user@host /home/user/.subversion] vi config
  global-ignores = *.cd% *.cd- *.cdslck *.Cat% *.abstract.status *.abstract.messages *.inca* *inca* .cdsvmod expand.cfg% transcript_ms

  [user@host CDSVN/]vi cadence_ignores.txt
  *.cd%
  *.cd-
  *.cdslck
  *.Cat%
  *.abstract.status
  *.abstract.messages
  *.inca*
  *inca*
  ….
  cdsvmod
  expand.cfg%
  transcript_ms

Their updated files are attached. Special thanks to PCS for coordinating this. Remember, the CDSVN scripts are licensed under GPL.

cdsLibMgr.il
svnLockCell.il
cdsLibMgr.il

Unfortunately, this can’t be done over a large range, because as Foster’s reactance theorem states, as soon as you deviate a little from your center frequency, both the inductive reactance of your antenna and the reactance of whatever you’re using to cancel it (most likely a capacitive element) both increase (go toward ). So, for every change in frequency from the center frequency, your antenna reactance goes up by some amount , but your matching element’s reactance also goes up by some amount .

If you had a Non-Foster element, the reactance of your tuning element would go down by some amount , compensating for the increased reactance of the antenna. You would then have  a broadband (or broader) match.

Most attempts to do this have required the use of active elements (such as gyrators) so synthesis a negative impedance. However, I’m wondering if  a switched-capacitor circuit can be used to synthesize this Non-Foster reactance. Most analyses of switched-capacitor circuits show that they are synthetic resistors at frequencies far below the switching frequency. However, what does the impedance look like near the switching frequency?

Well, since you’re pumping current into the circuit at exactly the rate of switching, you should see a large voltage. As a result, it should look like a high-impedance near the switching frequency. I would tend to believe that the switching function takes the usual function and modulates it up to the switching frequency. (I haven’t proved this and probably won’t ever prove it.) However, if one thinks about the following picture, the current coming into the capacitor can be seen as the independent variable. Then, the voltage is the regular voltage, except mixed by the switching function. Thus, the product should be some modulated version of the fundamental capacitor’s impedance.

The upshot of all this mixing is that just below the switching frequency, one would have a reactance that’s decreasing. (I’m doing a considerable amount of hand-waiving here, excluding such things as aliases of the switching harmonics.) What’s even cooler about this reactance is that the Non-Foster region is determined by the switching frequency–so, one could move it around just by changing the switching frequency. You’d effectively have a digitally-tunable antenna.

There are a number of problems with this scheme, most notably the radiation of switching noise and any switched-capacitor noise effects. However, I think it’s worth looking at and building upon.

If the distribution is Gaussian, the mean and median are equal.

(Mean is defined as where is the probability distribution function (PDF) of —that is, it’s a average of X, weighted with the probability density of . The median defined as —that is, the point where is equally likely to be lower than or greater than (50% probability).)

Many times in engineering and process control, we keep track of the mean and standard deviation. One of the reasons is that if the thing we’re trying to control is Gaussian, the mean/median and standard deviation give us good design criteria to minimize failure: if we allow our system to tolerate 3 standard deviations () around the mean/median, then it has a 99.7% chance of success (0.3% chance of failure).

However, we can generalize this: if we wanted to be more lax, we could only design (or require) the system to tolerate 2 standard deviations (4.5% failure). In some cases, systems are designed to tolerate 4 standard deviations (0.006% failure). So, one can design the system to tolerate , where is some factor (3, 2, 4 for example) that determines the probability of failure.

However, what if the distribution is bimodal? Take for example, two modes of operation (each more or less Gaussian):

Due to the asymmetric distribution, the mean and median are now not the same. In this case, we could posit that some secondary mode (or external factor) causes that second hump. Let’s call the main hump the primary mode and the smaller hump the secondary mode. If things are behaving “normally” we get the first hump, but some failure or aberration causes the second hump.

However, what if the system was more sensitive to this failure (secondary mode). Then, we’d see something like:

Notice what happened? The median stayed exactly the same. However the mean mislabeled “average”) moved proportionally to that secondary hump. Incidentally, the standard deviation () also moved proportionally to the distance between the two humps—but let’s focus on the fact that the mean just changed.

The question you’re probably asking is “what’s so bad about that”? Well, if you’re computing six-sigma-like design criteria, you’re taking . Recall, however, that we could pick any factor depending on the probability of failure we want (I should say want to avoid). So, when both the average and the standard deviation change, how can we be sure we’re getting the right value for ?

The nice thing about picking the median as the average is that it doesn’t depend on the magnitude of the secondary mode—only on the probability of the secondary mode. The magnitude of failure impacts the standard deviation. I like to view these (median and standard deviation) sas two independent metrics that tell different stories.

Another thing to note is that one could view the 2nd illustration above as an input to a nonlinear amplifier (for example) and the 3rd illustration as the output. That’s another nice thing about the median: it commutes with a monotonic nonlinearity. That is, if is monotonic, and , then . So, we don’t have to worry so much that we’re measuring the correct independent variable. Our median will give us the same information (albeit in a different, nonlinear domain).

You’ll notice that this post has Matt Miller listed as the author. Poojan requested Matt’s comments on his differential circuit post. Poojan was impressed with my comments enough that he decided to make it a follow-up post. So, this post is co-written by both Poojan and Matt.

Gain

Some of you asked whether the differential circuit being biased at half the current therefore has half the transconductance, and therefore lower gain. The answer is that it depends.
The single-ended circuit has an output current $$i_o = g_m \times v_i$$. In many cases, the only thing this circuit can drive is a single-ended load $$Z_L$$.
The differential circuit has an output current $$i_{o+} = g_m \times v_i/2$$; $$i_{o-} = -g_m \times v_i/2$$.
So, the question comes down to whether we can subtract the two currents $$i_{o+}$$ and $$i_{o-}$$ to produce a differential current. Although one can think of it that way, it’s really more accurately to define the current flowing out of one side and into the other. The current, therefore, doesn’t change. However, all other things being equal, the load on the differential circuit will be $$2Z_L$$. Therefore, the gain is the same.

Free Lunch

Some of you questioned the 4x boost in dynamic range that the differential circuit gives over its single-ended counterpart. While I made some mistakes with the equations (they’re fixed now), the result was correct: the differential circuit does have 6 dB higher dynamic range. Where did this come from? Well, it’s the basic advantage of the differential circuit: while a single-ended circuit can only swing +/- Vx, a differential circuit (where the output is defined as the difference of two single-ended circuits) has a swing of twice that: +/- 2Vx. Having twice the voltage is equivalent to 4x the power (and in both cases, that’s 6 dB improvement).

There’s No Such Thing

If some of you feel that this can’t be possible, please keep in mind the long disclaimer at the beginning of the last post: there are no universally better circuits. There are only certain circuits that are better suited for certain applications. In this case, the differential circuit gets its benefit from improved output range. However, the gain doesn’t change. Therefore, there’s an intrinsic assumption here: the circuit will tolerate a higher output, but there’s no gain to make the output higher. We didn’t intrinsically get double the gain, so we can’t take advantage of the dynamic range without sticking some gain ahead of the circuit.
That’s requirement is perfectly fine in a lot of cases. In many cases, you already have a ton of gain and automatic gain-control (AGC) ahead of the circuit. In that case, the AGC range can be reduced (possibly improving overall performance). This is true (for example) in the baseband filter at the end of an RF line-up. For that application, the figure of merit really is dynamic range. Similarly, in an ADC, the extra dynamic range might mean more effective bits of resolution.

Cheap Lunch

We’ve given the impression that the dynamic range can’t be leveraged in (for example) an RF LNA. Turns out that it can—for relatively cheap (although  not for free). If one were to stick a 1:4 (impedance ratio) balun ahead of the circuit, one would get this voltage gain for relatively cheap (meaning, the cost of the balun). In many cases, some form of impedance transformer (matching network) is required anyway, so putting a balun in isn’t a great cost.
The balun doubles the voltage but quadruples the output impedance. This is actually a good thing: the differential circuit has 4x the input impedance of the single-ended circuit. Let’s call the single-ended circuit’s input impedance $$Z_i$$. The differential circuit has $$2Z_i$$ input impedance on each side (we’ve cut the single-ended circuit in half). However, these input impedances get stacked to form the fully differential input impedance, so we get $$4Z_i$$ as the input impedance of the differential circuit:

versus

From my personal blog:

I’ve been lucky enough to find myself in a team that’s intent on finding the best circuit design for a given application. This doesn’t happen often to many people, but I feel that I’ve had more than my share of this opportunity.

The conclusion is usually that we come up with some topology (let’s call it circuit X) that optimizes all the performance criteria. I walk away wanting to generalize the experience with the lesson that circuit X is the best circuit ever, and I want to use it everywhere.

Inevitably, I find that some other topology Y is better suited for some other application. There were some specific constraints or conditions on circuit X that don’t apply to circuit Y, and as a result, circuit Y is more optimal for application Y.

It is for this reason that I won’t say that differential circuits are always better than their single ended counter-part. I will say that in my experience, I’ve come across the case where the differential circuit—or, really, the differential approach—is more effective than its single-ended counterpart. However, that’s not why I’ve decided to write this post.

Unfortunately, I’ve come across several engineers that make the generalization error in the opposite direction: they state that single-ended circuits save current. I will present a counter-example that is sufficient to disprove this generalization. Keep in mind that it doesn’t prove the opposite generalization (that differential circuits are always better).

Voltage-Mode Output

The two cases below assume that the dynamic range is limited by output voltage: that is, the circuit will clip its output and that determines the high-end of the dynamic range.

Single-Ended Dynamic Range

Consider the single-ended CMOS amplifier shown below:

The output noise voltage is given by:

$$v_{n,o}^2 = \frac{8kTg_m \times |Z_L|^2}{3} = \frac{8kT \times I_{DD} \times |Z_L|^2}{3*V_{DSAT,N}}$$

The maximum output voltage swing (zero-to-peak) is given by:

$$V_{o,max} = \frac{V_{DD} – V_{DSAT,P} – V_{DSAT,N}}{2}$$

The dynamic range is:

$$DR = \frac{|V_{o,max}|^2}{v_{n,o}^2} = \frac{(V_{DD} – V_{DSAT,P} – V_{DSAT,N})^2 \times 3V_{DSAT,N}}{4 \times 8kT \times I_{DD} \times |Z_L|^2}$$

Differential Dynamic Range

Consider the differential CMOS amplifier:

The output noise voltage is given by (I_D is the current in each side of the differential pair; it is half of I_DD, the total current):

$$v_{n,o}^2 = \frac{8kTg_m \times |Z_L|^2}{3} = \frac{8kT \times 2 \times I_{D} \times |Z_L|^2}{3*V_{DSAT,N}} = \frac{8kT \times I_{DD} \times |Z_L|^2}{3*V_{DSAT,N}}$$

The maximum output voltage swing (zero-to-peak) is given by:

$$V_{o,max} = V_{DD} – V_{DSAT,P} – V_{DSAT,N} – V_{DSAT,N2}$$

The dynamic range is:

$$DR = \frac{|V_{o,max}|^2}{v_{n,o}^2} = \frac{4(V_{DD} – V_{DSAT,P} – V_{DSAT,N} – V_{DSAT,N2})^2 \times 3V_{DSAT,N}}{4 \times 8kT \times I_{DD} \times |Z_L|^2}$$

Comparison

We see that the dynamic range is equivalent in both cases. The difference is the terms 4(V_DD – V_DSAT,P – V_DSAT,N – V_DSAT,N2) in the differential case versus (V_DD – V_DSAT,P – V_DSAT,N) in the single-ended case. In many cases, the differential dynamic range is larger. In fact, as long as

V_DSAT,N2 < 3/4(V_DD – V_DSAT,P – V_DSAT,N)

However, in the case where you can’t meet this requirement, you can get rid of MN2 (albeit at the cost of common-mode rejection).

Conclusion

We’ve seen a case where the differential circuit shows more dynamic range than the single-ended counterpart. My guess is that most people who say that differential means more current don’t realize that you don’t have to have the same current in each branch of the differential circuit (you can split the current in half).

One limitation of the above analysis is that I assume that the input voltage is available in a differential form, and that the output is consumable in its differential form. Obviously, if this isn’t the case, the above analysis may or may not work. The case becomes more specific and the generalization fails.

That said, I’ve seen plenty of line-ups where a transformer/balun is placed off-chip to convert the chip’s inputs/outputs to differential. Requiring differential I/O at the chip level doesn’t mean requiring differential I/O at the board level.

Current-Mode Output

I’ve detailed the use of current-mode circuits before. It’s possible to treat this as a special case of the voltage-mode output analysis, with Z_L being small. The only problem with that extrapolation is that if Z_L is small, the maximum swing probably won’t be dictated by voltage: the circuit will slew way before it clips. As a result, instead of V_o,max being given by the previous equation, we have:

Single-ended:

$$V_{o,max} = \frac{\alpha \times I_{DD} \times |Z_L|}{2}$$

Differential:

$$V_{o,max} = \alpha \times I_{DD} \times |Z_L|$$

where α is a factor that indicates what fraction of quiescent current can be used as signal current.

The advantage is even more apparent: you’re getting 4× the dynamic range.

Additional Benefits

In addition to the improved dynamic range (power-drain efficiency), differential circuits offer:

• Reduced susceptibility to supply noise: a good chunk of supply noise appears as common-mode, so a fully-differential circuit will reject (ignore) it
• Improved IM2: IM2 generally appears as common-mode and to a large amount gets rejected
• Reduce supply bounce (more beneficial for switch-mode circuits): since there’s a complementary action at the nodes in the differential circuit, much less noise is induced on the supply during dynamic operation

Disadvantages

I can only point out a few disadvantages to the approaches presented here—and they really have nothing to do with single-ended (versus differential) circuits:

• Common-mode feedback: you’re generally going to need a common-mode feedback (and common-mode sensing). However, even the single-ended topology (shown above) requires some bias adjustment to set its output bias voltage. This is more of a property of CMOS design (high-impedance loads) than a trade-off of single-ended/differential circuits.
• Lower swing: once again, this is a property of the differential pair. But, a lot of the differential benefit (common-mode rejection ratio) comes from using the differential pair.

True disadvantages:

• If you’re using minimum-size devices, you end up spending twice the current with the differential circuit than with the single-ended version. However, when (in analog design), have you used minimum-sized devices?
• The benefits of differential circuits occur when you get to analyze the noise and signal swing differentially. However, if the circuit you’re driving doesn’t respond to a differential input, the benefits aren’t as great.

Conclusion

It seems to me that most of the people that globally avoid differential circuits subscribe to the thought that since there are two current branches, there must be double the current. However, like I said above, this is only true if your branches are using minimum-sized devices. Otherwise, you can always split the device in half and distribute the same current across a differential pair.

I know a very good IC designer and PCB designer. My experience with him is as an IC layout designer. However, most of his PCB customers cite him as the best PCB layout designer they’ve come across. I’ll focus on his IC skills, since I can attest to that.

He’s most often hired as a consultant embedded in a design team. However, he’s capable of and set up for turn-key work (taking schematics and sending back GDS II). He’s skilled in Cadence (Virtuoso XL, Assura) and Mentor (IC Layout, Calibre) design tools.

If you’re interested, fill out the Feedback (Contact Us) form. I will forward requests to him.

He’s worked on the following products (since I’ve met him) and much more:

• CMOS 90 nm transceiver IC including ADC/DAC, RF: massive integration effort, requiring careful shielding and differential matching of many RF/analog lines
• IBM 8WL BiCMOS IC including high-linearity mixer with feedback: extremely compact layout, minimizing RF parasitics
• CMOS 90 nm continuous-time sigma-delta ADC: detailed matching (common centroiding) of CMOS devices and matching of routing parasitics
• TSMC 0.18 um CMOS class-D audio amplifier IC: integration and isolation of several analog blocks with large digital circuit
• CMOS 0.18 um all-digital RF transmitter (resulted in this publication)

Each of the above has been a first-pass success. He contracted for over a decade at Motorola Labs (Motorola’s corporate research center at their headquarters near Chicago), Atmel, Freescale Semiconductor, and several Motorola product groups. He ran a circuit board development group at Tellabs. He’s extremely pleasant to work with and does very well in a team environment (both as a lead developer and as a team member).

He is a US citizen.

He is available for hourly contracting.

Introduction

In general, we are trying to produce the signal

where is the in-phase (I) component and is the quadrature (Q) of our complex baseband signal. In general, RF transmitters have a modulator circuit which carries out this math. These are called Cartesian modulators and are generally drawn as:

This diagram is meant to be interpreted as a high-level circuit schematic. Namely, the output is a wire-sum of the the individual mixer outputs.

can also be written as

where and . Then, we lose the need to sum the signals and we can simply implement:

Cartesian Inefficiency

The inefficiency of the Cartesian modulator is not in the individual mixers themselves (they are equivalent between Cartesian and polar). The inefficiency lies in the summing of the two mixer outputs: some current flows from the I-mixer into the Q-mixer and is dissipated by the Q-mixer’s output resistance. Indeed, we could get a high efficiency RF modulator if we could stop this current flowing. Indeed, if the component mixers were high output impedance (i.e. current sources), this summing could be done efficiently.

Switched-Mode Modulators

It should be noted that while we desire , what usually gets implemented is where is a square wave at the carrier frequency. This works because has a component of —albeit with some higher order terms. However, these terms can usually be filtered out.

Interleaving

What if, instead of summing the two signals, we interleaved them. That is, we spit out a sequence (at 4x the carrier frequency) of [+ x_I, –x_Q, –x_I, +x_Q]? It turns out that this is equivalent to multiplying by a [+1,0,-1,0] sequence (which also has a term of ) and multiplying by a [0, –1, 0, +1] sequence (which has a term of ).

It turns out that the cases where the I- and Q- LO’s overlap is very inefficient, and it contributes nothing to the output signal power. (The term in [+1, 0, –1, 0] is smaller than the term in [+1, +1, –1, –1]. However, we are concerned about efficiency—the ratio of power produced to power dissipated—not absolute output power.)

This can be implemented efficiently by the following switching circuit:

For clarity, I’ve shown the circuit as a single-balanced (single-ended) output, but it can be (and should be) implemented as a fully differential output.

So, we want to break down our continuous-time sigma-delta feedback into two paths:

1. A low-precision tight loop that delivers the first sample to the quantizer
2. A higher-precision loop that goes through a clock delay to minimize “metastability” (indecision)

DAC Feedback

As a small aside, recall that the DAC feedback looks similar to the following:

The input to the quantizer is the convolution of this signal with the impulse response h(t) of the noise-shaping filter H(s). As we did with the impulse-invariant transform, we break down the noise-shaping filter into partial-fraction expansion:

Each of these is a single-pole filter, with an impulse response that looks something like:

Dual-Filter Analysis

The first sample at the quantizer is the convolution of a DAC symbol with the impulse response. This amounts to the integral over one sample period:

The rest of the samples can be passed through a filter that looks like this:

The main difference between this remaining filter and the original is that it is scaled by . Note that the delay in the filter is already included in the system due to the extra clock delay by the second DAC.

Summary

So, in the end, we have replaced with:

Introduction

The impulse invariant transform (IIT) is a method of taking a continuous-time system H(s) and converting it to a discrete-time system. There are multiple ways of doing this, but the IIT does so with the constraint that the impulse response of the discrete-time system is a sampled version of the impulse response of the continuous-time system.

Here’s an illustration:

…gets converted to…

…with the characteristic that the discrete-time impulse response is a sampled version of the continuous-time:

Rational Systems

This doesn’t seem like a big deal—nor very accurate. The illustration above implies that we’re taking an IIR response from the continuous-time system and sampling as a discrete-time FIR.

However, the IIT actually does something better: if H(s) is rational (composed of a numerator and denominator):

…then the IIT lets us re-write this system as a discrete-time rational system:

…of course, with the property that . is the sampling period (typically, during transformation from continous-time to discrete-time, the continuous-time impulse response is scaled by the sample period).

Example

Here’s an example:

First, we break it down into its partial fraction expansion:

Solving (taking limits of s to +j and -j):

Now, the IIT prescribes how to take single-pole transfer functions and convert them to the z-domain.

…which means that:

Application

The impulse invariant transform is useful in modelling continuous-time sigma-delta, allowing one to analyze the mixed-mode continuous-time sigma-delta as a purely discrete-time system.

Most notably, in considering the stability of continuous-time sigma-delta ADC’s, the transformation is useful in allowing one to replace the continuous-time noise-shaping filter with a discrete-time equivalent. One could then perform a closed-loop analytic analysis on the system. This is the procedure advocated in Delta-Sigma Data Converters: Theory, Design, and Simulation. However, the book only prescribes a rule-of-thumb, and in general, one must simulate the sigma-delta rigorously to gain confidence of stability.

Arguably, this transformation was more useful in the past, when high-level mixed-mode simulators (Simulink) were not available. In that case, the only way to simulate the continous-time sigma-delta was to model at a discrete-time. Nowadays (in my experience) Simulink is fast enough that it’s easier to keep the mixed-mode nature of the system intact (i.e. not model it as a purely discrete-time system). However, I can imagine a case of either very long simulations or a regression analysis system where the cycle-accurate discrete-time model may become useful again.

I had been working on a pulse-width-modulation (PWM) design. It was a pseudo-digital implementation, in that the output was clocked by a high-speed clock. The actual switching rate was much lower than this clock. I wanted to simulate this design in Cadence/Spectre by running a transient and then taking an FFT.

However, I ran into a bit of a snag: the quantization clock and my input clock rates were defined by the design, and they weren’t up to me. Moreover, these weren’t related by a power of 2. Unfortunately, Cadence Ocean (Skill) commands only allow for a radix-2 (power of 2 length) FFT. So, I was stuck. I needed a way to do a non-radix-2 FFT in Cadence. Here’s how I solved it using Matlab and getting Cadence and Matlab to talk (in a limited fashion).

What I ended up doing was writing some Skill IPC (inter-process communication) code that:

1. Dumped the time-domain data to a text file on disk (in Cadence/Skill)
2. Read the time-domain data using Matlab
3. Perform the FFT (in Matlab)
4. Write the frequency-domain data to a text file (in Matlab)
5. Read the frequency-domain data (in Cadence/Skill)
6. Plot FFT and compute SNR/SNDR (in Cadence/Skill)

The scripts

These files are copyright Poojan Wagh, 2009. They are released under the GPL. See http://www.gnu.org/licenses/gpl.txt.

These files come with absolutely no warranty, expressed or implied. Use at your own risk. If these scripts destroy your entire design database, that’s your fault for using them.

The Ocean Script

Here’s the ocean script I used. It’s called text.txt, because it is actually contained as a cell-view (text file type). Here’s a run-through of the code:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; copy this into CIW:
; runscript( "pwm3_sim" "reg0650_tran_paw" "ocean_ultrasim_getsndr_baseline" )
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

I’ve defined runscript() as a function which loads and executes a text-file cell-view.

; Copyright (c) 2009 Poojan Wagh
; Released under GPL (http://www.gnu.org/licenses/gpl.txt)
; $Revision: 1511 $
library = "pwm3_sim"
cell = "reg0650_tran_paw"
view = "config_baseline"
proc= "typ"
cap = "typ"
res = "typ"

library, cell, view, proc (typ/wcs/bcs), etc. are all defined as skill variables for easier changing & for future corner simulation

lsfqueue =  nil
jobname = "reg0650_tran_paw_baseline"

In case we want to use LSF for load-balancing

wad = getShellEnvVar("WORKAREA_DIR")
dumpfile = strcat(wad "/matfft/reg0650_tran_paw_baseline.pwm")

WORKAREA_DIR is the area where cadence is started. The PWM dump-out file will be in a mattfft subdirectory of it.

runit = t;
plotpsd = t;

runit determines whether we run the simulation or just plot the FFT/SNR/SNDR. plotpsd determines if we plot the power spectral density (PSD) or not (mostly for debugging).

;;;;;;;;;  Max Amplitude
inputmag =1.8;
vidc = 0.0;
fR = 460k;
ncs = 36;
fQ = ncs*fR;

inputmag is how high of an input signal we are sending to the PWM modulator. fR is the switching rate. fQ is the sampling rate. Note that fR=36*fQ, so this we don’t want a radix-2 FFT. Doing a radix-2 FFT would result in spectral leakage (and corrupt our SNR measurement).

;Changes 1024 pts **************************************
ncyc = 1024;
kcyc = 512;
simtime = (ncyc+kcyc)/fR
fbin = fR/ncyc;
fin = 13*fbin;
bw = round(20E3/fbin)*fbin;

I run the simulation for a total of $$\over{ncyc+kcyc}{fR}$$ cycles of fR. However, I throw away the first kcyc cycles to allow for startup transients.

; procedures used in this script:
; write a command to matlab
procedure( writemat(mipc cmd )
  ipcWaitForProcess(mipc)
  ipcWriteProcess(mipc sprintf(nil "disp 'Executing %s'\n" cmd));
  ipcWaitForProcess(mipc)
  ipcWriteProcess(mipc sprintf(nil "%s\n" cmd));
  )

This (above) is a little wrapper skill function that sends a command to Matlab. I made it so that it also displays the command being executed in Cadence (for debugging).

The following function computes the PSD by sending commands to Matlab

; compute psd from matlab
procedure( matpsd( dumpfile fR ncs ncyc)
  let( (fin psdfile fswfile freqvec psdvec persist matlog)
    printf("Starting matlab to compute PSD\n")
    sprintf(matlog "%s.log" dumpfile)
    printf("Matlab log file: %s\n" matlog)
    workareadir = getShellEnvVar("WORKAREA_DIR")
    mipc = ipcBeginProcess(strcat("cd " workareadir "/matfft && matlab -nodisplay -logfile " matlog))
    writemat(mipc "clear all");
    writemat(mipc "global ncs dt fsw")
    writemat(mipc sprintf(nil "fsw = %g" fR));
    writemat(mipc sprintf(nil "ncs = %u" ncs));
    writemat(mipc sprintf(nil "ncyc = %u" ncyc));
    writemat(mipc "dt = 1/(fsw*ncs)");
    writemat(mipc sprintf(nil "[yout, xin] = readpwm('%s');" dumpfile))
    writemat(mipc "[Py, freq] = getpsd(sign(yout), ncs*fsw, ncs*ncyc);");
    sprintf(psdfile "%s.psd" dumpfile);
    writemat(mipc sprintf(nil "fout = fopen('%s', 'w')" psdfile))
    writemat(mipc "fprintf(fout, '%.12g %.12g\\n', [freq(:) Py(:)]')")
    writemat(mipc "fclose(fout)")
    writemat(mipc "exit");
    printf("Waiting for Matlab to finish");
    ; wait for matlab to finish:
    while( ipcIsAliveProcess(mipc)
      printf(".")
      ipcSleep(1)
    )
    fin = infile(psdfile);
    freqvec = nil;
    psdvec = nil
    printf("Reading results from Matlab\n");
    while( fscanf(fin "%f %f" frq psd)
      if(!freqvec then
        freqvec = drCreateVec('double list(frq))
      else
        drAddElem(freqvec frq);
      )
      if(!psdvec then
        psdvec = drCreateVec('double list(psd))
      else
        drAddElem(psdvec psd)
      )
    )
    close(fin);
    psdpwm = drCreateWaveform(freqvec psdvec)
  ) ; let
  psdpwm        ; return psdpwm
) ; procedure

You’ll notice that the skill variables are actually sent to matlab, not hard-coded anywhere. So, changing the variable assignments in the skill/ocean file will be reflected in Matlab. Several Matlab helper functions are used:

• readpwm reads the text file
• getpsd computes the psd
  • bh4 defines a minimum 4-term blackman-harris window; when I wrote this script, it was not available in Matlab

Each of these Matlab .m files are included in the attached tarball. In addition, I define a few Ocean/Skill helper functions:

sumpsd sums up spectral power over a frequency range (fstart to fend):

procedure( sumpsd( psd fstart fend)
  if(fstart < fend then
    integ( clip(psd fstart fend) )
  else
    0.0
  )
)

getpow gets the spectral power of a tone centered at fc and takes into account spectral growth around fc by speclobew bins of the FFT:

; get power of signal centered at fc
procedure( getpow( psd fc fbin )
  let( list( (speclobew 5) )
    sumpsd(psd fc-speclobew*fbin fc+speclobew*fbin)
  )
)

Define simulator, output directory, etc:

simulator( 'UltraSim )
resultsDir( strcat( wad "/simulation/" library "/" cell "/" view "/" simulator() ) )

In case we want to use LSF for load-sharing:

if(lsfqueue then
  hostMode( 'distributed )
else
  hostMode( 'local )
  )

Define the test bench cell to be simulated (in read-only mode):

design(	library cell view "r" )

Define model files. Note that the proc,cap, etc. Skill variables are used:

printf("$Revision: 1511 $ Using rev1e model files\n")
modelFile(
    list("/pdk_dir/amsmodels/spectre/rev1e.scs" "base")
    list("/pdk_dir/amsmodels/spectre/rev1e.scs" strcat(proc "_fet"))
    list("/pdk_dir/amsmodels/spectre/rev1e.scs" strcat(proc "_bjt"))
    list("/pdk_dir/amsmodels/spectre/rev1e.scs" strcat(cap  "_capacitor"))
    list("/pdk_dir/amsmodels/spectre/rev1e.scs" strcat(res  "_resistor"))
    list("/pdk_dir/amsmodels/spectre/rev1e.scs" strcat(proc "_diode"))
)

Define the simulation time and analysis options:

sprintf(sstop, "%.12g", simtime);
analysis('tran ?stop sstop  ?saveOP t  ?write "spectre.ic"
		?writefinal "spectre.fc"  ?method "gear2"  ?strobeperiod "1.0/fQ"  ?maxstepU "1.0/(16*fQ)"  )

Define design variables. Note that these are assigned from the Skill variables, so changing just the skill variables at the top of the file propage down through the design netlist and into matlab

desVar(	  "fR" fR	)
desVar(	  "vdd" 2.5	)
desVar(	  "vidc" vidc	)
desVar(	  "inputmag" inputmag	)
desVar(	  "fin" fin	)
desVar(	  "fQ" "36*fR"	)

UltraSim simulation options:

option(	'tol  "0.001"
	'dc  "spectre DC (3)"
	'scale  ""
	'wf_format  "PSF"
	'pn_method  "keep"
	'analog  "off"
	'speed  "Extreme Accuracy (1)"
	'sim_mode  "Analog (A)"
)

saveOption('UsimOptionDepth "20")
saveOption('UsimOptionAllAnalogNV t)
saveOption('UsimOptionProbeAnalog t)
temp( 27 )

Actually run the simulation:

; either this:
if(runit then
  startrun = getCurrentTime()
  if(lsfqueue then
    run( ?queue lsfqueue ?block t ?jobName jobname)
  else
    run()
  )
  endrun = getCurrentTime()
  runtime = compareTime(endrun, startrun);
  printf("Run took %d hours %d minutes %d seconds\n" floor(runtime/60/60) mod(floor(runtime/60), 60) mod(runtime, 60));
else
  openResults(resultsDir());
)
selectResults( 'tran )

Dump out the time-domain file:

if(dumpfile then
  printf("dumping to file %s\n" dumpfile)
  ocnPrint(v("/PWM_P")-v("/PWM_M") ?output dumpfile ?precision 12 ?numberNotation `none)
)

Compute the PSD through Matlab

if(plotpsd then
  psdpwm = matpsd( dumpfile fR ncs ncyc )
  ; PSig = sumpsd(psdpwm fin-5*fbin fin+5*fbin)     ; Signal Power
  PSig = getpow(psdpwm fin fbin)                                        ; Signal Power
  PND = sumpsd(psdpwm 0 min(bw fin-6*fbin)) + sumpsd(psdpwm fin+6*fbin bw) ; Noise Power
  PN = PND;
  exbw = 0;
  ; for SNR measurement, exclude odd-mode distortion
  ; from 3*fin to bw
  for( k 1 floor(bw/2/fin)
    fex1 = (2*k+1)*fin-5*fbin
    fex2 = min(bw (2*k+1)*fin+5*fbin)
    psdex = sumpsd(psdpwm fex1 fex2);
    ; printf("k = %u Excluding distortion from %f kHz to %f kHz (%g - %g)\n" 2*k+1 fex1 fex2 PN psdex)
    PN = PN - psdex;
    exbw = exbw + (fex2-fex1);
    ; printf("Excluding distortion from %f kHz to %f kHz (%f kHz)\n" fex1/1.0k fex2/1.0k (fex2-fex1)/1.0k);
  )
  PN = PN / (1 - exbw/bw)           ;compensate for frequencies we have excluded
                                    ;(assuming white noise)
  SNDR = PSig/PND;
  SNR = PSig/PN;
  SNDRdB = db10(SNDR);
  SNRdB = db10(SNR);
  printf("SNDR [%s/%s/%s]= %.2f dB\n" library cell view SNDRdB);
  printf("SNR [%s/%s/%s]= %.2f dB\n" library cell view SNRdB);
  sprintf(wintitle "PSD of Digitized PWM [%s/%s/%s] SNDR = %.0f dB NSR = %.0f dB" library cell view SNDRdB SNRdB)
  plot(db10(clip(psdpwm, fin-5*fbin, fin+5*fbin)) db10(psdpwm) ?expr list("Desired Signal" wintitle))
  xLimit(list(0 bw))
)

I use vim

; vim: ft=ocean

ReadPWM

This little matlab function reads the text file and assigns variables in Matlab:

function [yout, xin] = readpwm(filename)
  [time, pwm, xin] = textread(filename, '%f %f %f', -1, 'headerlines', 5);
  yout = pwm;

GetPSD

This matlab function gets the PSD from the time-domain data:

% function [ypsd, freq] = getpsd(x, fs, [psdlen])
%   return psd ypsd and frequency scaling of signal x
%   with sample rate fs and psd length psdlen.
%   copied from getpsd.m
function [ypsd, freq] = getpsd(x, fs, psdlen)
  x = x(:)';
  if(nargin > 2)
    if(psdlen < length(x))
      y = x(1:psdlen).*bh4(psdlen);
    else
      y = x .* bh4(length(x));
    end
  end
  ypsd = abs(psd(y, psdlen)).^2;
  freq = (0:psdlen-1)*fs/psdlen;

Note that it also does the limiting function (using only the last psdlen values in the time-domain data).

BH4

Minimum 4-term blackman-harris window:

function [bh] = bh4(N)
% w = bh4(N)
%
%    Generates Blackman-Harris window of length N
%
a0=0.35875;
a1=0.48829;
a2=0.14128;
a3=0.01168;
theta = (0:N-1)*2*pi/N;
bh=a0-a1*cos(theta)+a2*cos(2*theta)-a3*cos(3*theta);

The Tarball

All the above scripts are contained matfft.

IPC

All of the above was done using Cadence IPC. This is basically a set of functions that let you remote-control another command. The standard input/output (stdin/stdout) of the child process is connected to the Cadence instance. Using ipcReadProcess in Cadence reads the child’s stdout. Using ipcWriteProcess writes to the child’s stdout. In theory, one could run any Matlab program from Cadence using this method.

However, one could read/write to any text-mode program using this method. For a while, I thought about using FFTW and coding a small C program to compute the above FFT’s. The same C program could be controlled using IPC. However, I wasn’t getting paid to program (at the time), and I already had most of the functions already in Matlab.