Details

Published: Tuesday, 24 September 2019 18:08

Hits: 3394

Matlab is proprietary tool, and it's license fees are in thousands of dollars. Many open source alternatives exist, which are as good or better than Matlab.

1. Octave: GNU Octave is most popular alternative, and has been in development for more than 30 years. It strives for exact compatibility, so many of your projects developed for MATLAB may run in Octave with no modification necessary. So, if already learned Matlab, you can seamlessly start using Octave. It's front end interface can be chosen to be same as Matlab.

2. Scilab: Best known alternative outside of Octave. It doesn't strive for exact compatibility with Matlab, but is very similar to Matlab

3. Mathematica: It offers features for machine learning, image processing, data mining, etc. It is a superior tool for symbolic mathematics.

4. Python: Python language itself supports a lot of packages which can do all the scientific computing done in Matlab. NumPy is the main package for scientific computing with Python. SymPy is another Python library for symbolic mathematics. It's preferred to use python, as you have to learn python or any other scripting language anyway.

Details

Published: Monday, 23 September 2019 18:03

Hits: 3443

Examples of few common signals in Fourier domain:

When we transform signals from time domain to frequency domain, it's just like any other transformation in maths. A function takes inputs, and transforms it. If there is 1:1 transformation, then we can recover the original input, by applying inverse function to output. However, one thing that stands out in conversion from time domain to frequency domain is that frequency domain bears resemblance to physics. It's easier to visualize sound waves in terms of frequency, so most of the examples about fourier conversion talk about sound waves, but fourier conversion can be applied to any data.

This link shows proof of FT of some common functions: http://www.thefouriertransform.com/pairs/fourier.php

Let's intuitively try some conversion from time domain to freq domain for the below waveforms for all 4 fourier domains: CTFS, CTFT, DTFS, DTFT. Then we'll do rigorous calculation to verify it:

1. Constant signal: This is a signal which is a constant value for all times (-∞ < t < ∞). Since this signal has no variation at all, we don't expect to have any sine/cosine waveforms to reconstruct this dc signal. Infact just the DC offset would be enough to construct this signal. So, in frequency spectrum, we don't expect to see any freq component except f=0 (DC signal).

CTFS: We assume signal to be periodic with arbitrary period T₀. We can do this since an infinite long constant signal can be broken into finite duration signals.

C_k = 1/T₀ ∫ x(t) e^-jω₀kt dt = 1/T₀ ∫ 1 * e^-jω₀kt dt = 1/T₀  [e^-jω₀kt ] /(-jω₀k) with limits = +T₀/2 to -T₀/2. For all non zero values of k, C_k = 0. For k=0, we do not integrate (since integration not possible with k in denominator), instead we do C₀ = 1/T₀ ∫ 1 * dt = 1.

So, only at f=0, we get C₀ = 1, all other freq components are 0 as expected.

CTFT: Since for CTFT, signal can be aperiodic, we can compute CTFT of dc signal directly

X(ω) = ∫ x(t) e^-jωt dt = ∫ 1 * e^-jωt dt = [e^-jωt ] /(-jω) with limits of t = +∞ to -∞. However, this doesn't converge to any value, as e^-jωt = cos(ωt) - j.sin(ωt) = which oscillates as t->∞. So, we guess that the answer is delta function. If that is true, then x(t) = 1/(2Π) ∫ X(ω) e^jωt dω = 1/(2Π) ∫ δ(ω) e^jωt dω = 1/(2Π). That implies that X(ω) = (2Π) δ(ω).

Here again, we see that for constant function, freq component exists only at ω=0, with magnitude=2Π

DTFS: If we take discrete samples of constant signal, then we get a signal which is 1 at all samples. Again, treating the signal as periodic with period T₀, with N samples in that period, we can compute DTFS.

x[n]=1 for n=0 to N-1. 

C_k = 1/N  ∑ x[n] e^-j(2Π/N)kn = 1/N  ∑ 1 * e^-j(2Π/N)kn for n=0 to N-1.

Now, we can calc exponential sum formula ∑ e^jkn for n=0 to n=N-1. This is same as sum of geometric series = (1 - e^jkN) / (1 - e^jk) = sin(1/2*N*k)/sin(1/2*k) * e^jk(N-1)/2

So, C_k = 1/N  ∑ 1 * e^-j(2Π/N)kn = 1/N  * (1 - e-^j(2Π/N)kN) / (1 - e-^j(2Π/N)k) = 1/N  * (1 - e-^j(2Π)k) / (1 - e-^j(2Π/N)k)

For k=0, C_k = C₀ = 1/N * ∑ 1 * 1 = 1/N * N  =1

For k≠0, C_k = 1/N  * (1 - e-^j(2Π)k) / (1 - e-^j(2Π/N)k) = 1/N * (1 - 1) / (1 - e-^j(2Π/N)k) = 0

Here, just as in CTFS, only at f=0, we get C₀ = 1, all other freq components are 0 as expected.

DTFT:  Here, again we have discrete samples, but signal is considered aperiodic. So, we can compute DTFT directly.

x[n]=1 for n=-∞ < n < ∞.

X(e^jω) = ∑ x[n] e^-jωn = ∑ 1* e^-jωn = with limits of t = +∞ to -∞. However, this doesn't converge to any value, for same reasons as CTFT. So, we guess answer as δ(e^jω)

=> x[n] = 1/(2Π) ∫ X(e^jω) e^jωn dω = 1/(2Π) ∫ δ(ω) e^jωn dω = 1/(2Π). That implies that X(e^jω) = (2Π) δ(e^jω).

So, as expected, freq component exists only at ω=0, with magnitude=2Π

DFT: DFT is same as DTFS. We can compute DFT by taking N samples of DTFT

DFT X_k or X[k] = samples of X(Ω) at discrete freq =  X(Ω) | _ω=2Πk/N where 0 <= k <= N-1.

Since X(e^jω) = (2Π) δ(e^jω) => X₀ = (2Π), X₁ to X_N-1 = 0 as delta function is 0 everywhere else. Result is same as DTFS, except for factor of (2Π) .

2. Impulse signal: It's denoted by δ(t). This is a signal which has a finite value at t=0, but is 0 everywhere else. For analog signals, it's impossible to construct such a signal (since analog signals need to go from 0->1 and then back from 1->0, which will always take a finite amount of time), but mathematically in the limit t->0, we can approximate such a signal. For discrete signal, such a signal is possible to construct by having sample at t=0 as "1", and "0" everywhere else. It's hard to visualize what freq components such a signal would have. But, we do observe that impulse func is an infinitely steep signal in limiting case where t->0. So, it should have infinite freq component in it. It should also have a DC freq component in it, as it's avg value is "1", and not "0". It turns out that such an impulse signal has all freq components from 0 to ∞, of equal magnitude. We can derive this by employing duality property of FT, where taking fourier of frq domain func, gives time domain function back. So, if we have constant signal in time domain, we get impulse func in freq domain, as we saw above. So, constant signal in freq domain will give impulse signal in time domain. That is how we get constant function in freq domain by using duality theorem.

3. train of impulses: It can be rep as periodic impulse func.

4. Sine/Cosine wave: This is a sine/cosine wave with a given freq. It may have a net dc value depending on whether the waveform is shifted up/down from y=0. If it has a net dc value, the only difference in freq spectrun would be that it would have a dc component (f=0) in it's freq spectrum.

A. periodic:

CTFS: It will have only 1 freq component at the freq of sine wave itself. So, C_k will be non zero only at that freq (all others will be 0). This can be seen intuitively as FS is summation of sine/cosine, and this waveform is exactly same as one of the terms, so no other terms of sine/cosine needed to make up this waveform. It also has dc freq component (at f=0) if the square signal has net +ve avg value.

CTFT: We can compute CTFT for any func, periodic or aperiodic. So, we compute CTFT for this signal, and expect to get same result as CTFS. However, as we explained in signal processing page, CTFT is an integral, and hence continuous. So, we'll get impulse function at each of the freq component instead of getting a single discrete line, as we get in CTFS.

B. non periodic: DTFT computed. It will be cont freq spectrum, with freq component similar to DTFS. However, now it's an impulse function centered at ω=+ω_k and ω=-ω_k.

For x(t)=sin(ω₀t) => X(ω) = (2Π)/i * 1/2 * [δ(ω-ω₀) - δ(ω+ω₀)] => 2 soln are +Π/i and -Π/i at ω=ω₀ and ω=-ω₀

For x(t)=cos(ω₀t) => X(ω) = (2Π) * 1/2 * [δ(ω-ω₀) + δ(ω+ω₀)] => 2 soln are +Π and +Π at ω=ω₀ and ω=-ω₀

3. Step signal: This is a step signal, going from 0 to 1 at certain time t.

4. square signal: This signal can have any duty cycle. It's 1 for a while, and 0 elsewhere. It can be thought of as a +ve step signal followed by -ve step signal.

A. periodic: For periodic sqaure wave, we have CTFS, which has freq component at freq=1/T, 3/T, 5/T (i.e odd harmonics). It also has dc freq component (at f=0), if the square signal has net +ve avg value. F

B. non-periodic: For non-periodic square wave, we calc CTFT, which turns out to be a sinc func, where sinc func is defined as sinc(t) = sin(Πt)/(Πt)

5. rectangular signal:

6.

Matlab: We can use Matlab software to plot these functions. We use fourier function to calc FT for any function. There is no func for giving FS of periodic func. Instead, we have to solve the series for FS, and have the result plotted. FT is easier to calc using in built "fourier" func, and it can be done for both periodic and aperiodic signals.

Matlab code for plotting the CTFT is:

syms x;
f = exp(-2*x^2); %this is the func whose FT we want. We'll replace this func with our desired func below.
FT = fourier(f); %calculates FT(w) for given f(x). FT is calculated in terms of radians (w)
ezplot(FT,[-1000,+1000]); %plots FT(w) over -1000 rad to +1000rad. By default, it plots from -2Π to +2Π rad

1. Unit Impulse  (aka Dirac delta): use f=dirac(x) => gives o/p=1, i.e a dc plot with value=1 at all x.

2. Sine wave: use f=sin(2*pi*x); => gives o/p as Π(-i)(dirac(w-2Π) - dirac(w+2Π)), since dirac func is infinite at +2Π and -2Π and 0 elsewhere, we just see 0 everywhere

3. Cosine wave: use f=cos(2*pi*x); => gives o/p as Π(dirac(w-2Π) + dirac(w+2Π)), again we just see 0 everywhere

2. Square signal: use f = rectangularPulse(a,b,x). Here a=starting of high pulse, b=end of high pulse. By default, if no a or b provided, i.e rectangularPulse(x), then a=-1/2, b=+1/2

syms x;
f=dirac(x);
FT = fourier(f);
ezplot(FT,[-1000,+1000]);

Details

Published: Thursday, 19 September 2019 16:13

Hits: 3098

Welcome to Maaldaar !!

This site is organized in various sections.

- Education:

- Finance:

- Bank and Credit card Deals

- Shopping deals

- Travel

- Attractions

- Misc info

Details

Published: Tuesday, 17 September 2019 19:43

Hits: 2963

JASPER Gold: JASPER Design Automation bought by Cadence in 2014, and tool now called Jasper Gold (JG):

JG gives more ROI compared to sims, as bugs are caught early and require only 50% manpower.

Jasper provides a wide range of Applications (Apps) covering: Formal Property Verification, Sequential Equivalence Checking, Low-Power Verification, Connectivity Verification, Config/Status Register Verification, X-Propagation Analysis, Structural Property Synthesis, and Behavioral Property Synthesis (just to name a few). Lint and CDC (synchronizers and data coherency issues) too.

formal property verification  (FPV):
-----------------------
it checks if RTL meets certain properties specified. It uses design only, no tb as illegal states specified in assertions are checked for. It helps catch bugs early.
In any line of RTL code, we can right click, and select Activate->visualize line and that will bring up waveform, showing how that RTL target is reached w/o the need for tb.
proofgrid => properties are being proven by running engines.

Sequential Equivalence Checking (SEC):
----------------
Formally prove RTL vs RTL. This is for ECO where we want to formally prove that only intended changes are there.

Low-Power Verification:
----------
automatically creates power aware RTL (UPF/CPF), creates set of checks and evaluates them for all possible i/p combos/ does power aware structural, func and Seq checks
Reduce transitions on clk/mem, does pwr opt, minimizes retention flops

Config/Status Register Verification (CSR):
-------------------
given a reg spec and RTL, automatically derives all properties and runs formal to prove them. IP_XACT i/p as in reg modelling of UVM.
any discrepancy b/w RTL and spec are highlighted with counter examples

X-Propagation Analysis:
--------------
Detect X. verify design init and reset behaviour. Flop reset minimization flow. It can replace GLS.

AFL (automatic Formal Linting):
------------------------------
This consists of
1. Basic Lint checks (HAL = HDL Analysis and Linting) - Naming, coding style, structural, DFT, sim-synth mismatch, etc.
   - Naming and File format checks = RTL_NAMING, RTL_FILEFORMAT
   - Coding style checks - semantics, portability of code = RTL_CODINGSTYLE
   - synthesizability/sim-synth mismatch checks - identifies unsynthesizable constructs, pre-synth/post-synth mismatch = RTL_SYNTH, RTL_SIMSYNTH
   - Structural checks - pesudo synthesize RTL to get structural view, look for feedthru, combinatorial paths = STRUCTURAL
   - FSM checks - compliance to FSM modeling style = FSM
   - Race condition checks - detect all sim race statically possible - read-write, write-write etc = RTL_SIMRACE
   - DFT checks - both in func and test mode that make nodes Uncontrollable and Unobservable = DFT. ADVANCE_DFT
   
2. Advanced Lint checks - (also known as SPS) Structural Property synthesis (SPS):
- automatic checks from RTL such as arithmetic/range overflow, dead code, FSM livelock/deadlock, pragma, bus contention etc. No TB required. These checks do require specifying clock and reset.
   - X assignment = checks whether X assignment are reachable
   - Arithmetic overflow = whetheroverflow can occur in case of arithmetic op
   - Bus contention = whether multiple drivers can drive conflicting values on bus
   - Range overflow = for array access
   - FSM Livelock/deadlock = when design gets stuck in a state.
   - Case = whether certain synthesis pragmas are honored
   - code coverage reachability:
     - Block = If all branches in RTL are reachable
     - FSM = If all branches of FSM are reachable
     - Toggle = If all signals can be toggled
- automated and manual property ranking and classification
- these properties can be fed back into formal or sim env

Behavioral Property synthesis (BPS):
---------------
while SPS is automatically extracted from RTL, BPS is extracted from sim traces (which can be in VCD, FSDB or SHM format), so quality of properties tied to quality and maturity of sims. It's suggested to run periodically thru out the project.
- synthesis of multi cycle, hand shake, implication, black box and white box properties from sim (flow is there w/o sim also).
  - multi cycle = more than 1 or 2 cycle that may never fire in sims
  - automatic properties (assert, assume, cover) as FIFO, counters, FSMs, 1-hot.
    = assert: onehot = $onehot0 ({c0.hit,c1.hit,c2.hit}) => implies one hot
    = assert: FIFO = (q.head == q.tail) |-> q.empty => implies empty state if head eq tail
    = cover: FIFO = !$stable(fifo.rd_ptr) && !$stable(fifo.wr_ptr) => implies tests never change both fifo ptr together
  - user defined properties by specifying interacting signals
- automated and manual property ranking and classification
- properties are classified, and coverage holes are identified via sim. TB is refined and sim rerun to inc func cov. formal cov is also enhanced by analyzing these properties.
- these properties can be fed back into formal or sim env

Formal coverage:
--------
Coverage is of 3 types:
 - Code coverage => checked via imc
 - Func coverage: via cover properties written in TB as SVA/PSL
 - Formal coverage: proof coverage, bound coverage, stimuli coverage

Is my property set complete?

Unreachability:
---------
analyze sim coverage. determine formally unreachable code. No formal expertise reqd, as it just proves reachability/unreachabilty of coverage holes

-------------------------------------
running JG for AFL checks: run irun as usual, just add -jg option.
-------
irun ¡Vjg ¡Vafl ¡Vgui -64 ¡Vjgargs ¡¥-use_license_option¡¦ ¡Vinput <setup>.tcl => this invokes JG with AFL

inputs:
1. custom rule file - selected checks
2. design info file - blackbox, lint pragma
3. custom tcl file - clock, reset, selected checks => This does advanced lint checks
   - syntax: clock <clk_signal> reset <rst_signal>

on the gui, under AFL section on top, we see buttons for these:
1. configure Auto Formal checks
2. extract Auto Formal checks
3. export properties to a task
4. prove exported Auto Formal coverage and checks
5. generate reports: from the extra pull down button at end, click "generate_report -> auto or violation checks". This generates concise report for all viols in html format.

On the bottom of gui, we have violation viewer, waiver list, Auto Formal properties, ..
To create waiver, click on any violation, right click waiver and add waiver for that viol.


--------------------