{"id":648,"date":"2009-01-19T09:43:53","date_gmt":"2009-01-19T14:43:53","guid":{"rendered":"https:\/\/www.circuitdesign.info\/blog\/2009\/01\/non-radix-2-fft-in-cadenceoceanskillspectre-using-cadenc-ipc-to-talk-to-matlab-or-anything-else\/"},"modified":"2009-01-20T14:49:29","modified_gmt":"2009-01-20T19:49:29","slug":"non-radix-2-fft-in-cadenceoceanskillspectre-using-cadenc-ipc-to-talk-to-matlab-or-anything-else","status":"publish","type":"post","link":"https:\/\/www.circuitdesign.info\/blog\/2009\/01\/non-radix-2-fft-in-cadenceoceanskillspectre-using-cadenc-ipc-to-talk-to-matlab-or-anything-else\/","title":{"rendered":"Non-Radix-2 FFT in Cadence\/Ocean\/Skill\/Spectre | Using Cadence IPC to talk to Matlab (or anything else)"},"content":{"rendered":"

Introduction<\/h2>\n

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.<\/p>\n

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).<\/p>\n

What I ended up doing was writing some Skill IPC (inter-process communication) code that:<\/p>\n

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

    The scripts<\/h2>\n

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

    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.<\/p>\n

    The Ocean Script<\/h3>\n

    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:<\/p>\n

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\r\n; copy this into CIW:\r\n; runscript( \"pwm3_sim\" \"reg0650_tran_paw\" \"ocean_ultrasim_getsndr_baseline\" )\r\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<\/pre>\n
    I’ve defined runscript() as a function which loads and executes a text-file cell-view.<\/p>\n
    ; Copyright (c) 2009 Poojan Wagh\r\n; Released under GPL (http:\/\/www.gnu.org\/licenses\/gpl.txt)\r\n; $Revision: 1511 $\r\nlibrary = \"pwm3_sim\"\r\ncell = \"reg0650_tran_paw\"\r\nview = \"config_baseline\"\r\nproc= \"typ\"\r\ncap = \"typ\"\r\nres = \"typ\"<\/pre>\n
    library, cell, view, proc (typ\/wcs\/bcs), etc. are all defined as skill variables for easier changing & for future corner simulation<\/p>\n
    lsfqueue =  nil\r\njobname = \"reg0650_tran_paw_baseline\"<\/pre>\n
    In case we want to use LSF for load-balancing<\/p>\n
    wad = getShellEnvVar(\"WORKAREA_DIR\")\r\ndumpfile = strcat(wad \"\/matfft\/reg0650_tran_paw_baseline.pwm\")<\/pre>\n
    WORKAREA_DIR is the area where cadence is started. The PWM dump-out file will be in a mattfft<\/code> subdirectory of it.<\/p>\n
    runit = t;\r\nplotpsd = t;<\/pre>\n
    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).<\/p>\n
    ;;;;;;;;;  Max Amplitude\r\ninputmag =1.8;\r\nvidc = 0.0;\r\nfR = 460k;\r\nncs = 36;\r\nfQ = ncs*fR;<\/pre>\n
    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).<\/p>\n
    ;Changes 1024 pts **************************************\r\nncyc = 1024;\r\nkcyc = 512;\r\nsimtime = (ncyc+kcyc)\/fR\r\nfbin = fR\/ncyc;\r\nfin = 13*fbin;\r\nbw = round(20E3\/fbin)*fbin;<\/pre>\n
    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.<\/p>\n
    ; procedures used in this script:\r\n; write a command to matlab\r\nprocedure( writemat(mipc cmd )\r\n  ipcWaitForProcess(mipc)\r\n  ipcWriteProcess(mipc sprintf(nil \"disp 'Executing %s'\\n\" cmd));\r\n  ipcWaitForProcess(mipc)\r\n  ipcWriteProcess(mipc sprintf(nil \"%s\\n\" cmd));\r\n  )<\/pre>\n
    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).<\/p>\n
    The following function computes the PSD by sending commands to Matlab<\/p>\n
    ; compute psd from matlab\r\nprocedure( matpsd( dumpfile fR ncs ncyc)\r\n  let( (fin psdfile fswfile freqvec psdvec persist matlog)\r\n    printf(\"Starting matlab to compute PSD\\n\")\r\n    sprintf(matlog \"%s.log\" dumpfile)\r\n    printf(\"Matlab log file: %s\\n\" matlog)\r\n    workareadir = getShellEnvVar(\"WORKAREA_DIR\")\r\n    mipc = ipcBeginProcess(strcat(\"cd \" workareadir \"\/matfft && matlab -nodisplay -logfile \" matlog))\r\n    writemat(mipc \"clear all\");\r\n    writemat(mipc \"global ncs dt fsw\")\r\n    writemat(mipc sprintf(nil \"fsw = %g\" fR));\r\n    writemat(mipc sprintf(nil \"ncs = %u\" ncs));\r\n    writemat(mipc sprintf(nil \"ncyc = %u\" ncyc));\r\n    writemat(mipc \"dt = 1\/(fsw*ncs)\");\r\n    writemat(mipc sprintf(nil \"[yout, xin] = readpwm('%s');\" dumpfile))\r\n    writemat(mipc \"[Py, freq] = getpsd(sign(yout), ncs*fsw, ncs*ncyc);\");\r\n    sprintf(psdfile \"%s.psd\" dumpfile);\r\n    writemat(mipc sprintf(nil \"fout = fopen('%s', 'w')\" psdfile))\r\n    writemat(mipc \"fprintf(fout, '%.12g %.12g\\\\n', [freq(:) Py(:)]')\")\r\n    writemat(mipc \"fclose(fout)\")\r\n    writemat(mipc \"exit\");\r\n    printf(\"Waiting for Matlab to finish\");\r\n    ; wait for matlab to finish:\r\n    while( ipcIsAliveProcess(mipc)\r\n      printf(\".\")\r\n      ipcSleep(1)\r\n    )\r\n    fin = infile(psdfile);\r\n    freqvec = nil;\r\n    psdvec = nil\r\n    printf(\"Reading results from Matlab\\n\");\r\n    while( fscanf(fin \"%f %f\" frq psd)\r\n      if(!freqvec then\r\n        freqvec = drCreateVec('double list(frq))\r\n      else\r\n        drAddElem(freqvec frq);\r\n      )\r\n      if(!psdvec then\r\n        psdvec = drCreateVec('double list(psd))\r\n      else\r\n        drAddElem(psdvec psd)\r\n      )\r\n    )\r\n    close(fin);\r\n    psdpwm = drCreateWaveform(freqvec psdvec)\r\n  ) ; let\r\n  psdpwm        ; return psdpwm\r\n) ; procedure<\/pre>\n
    You’ll notice that the skill variables are actually sent to matlab<\/em>, 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:<\/p>\n