Version check
Download
1 / 67

Version Check - PowerPoint PPT Presentation


  • 53 Views
  • Uploaded on

Version Check. Next. The presentation was created with Microsoft PowerPoint 2003.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Version Check' - burton-coffey


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Version check
Version Check

Next

The presentation was created with Microsoft PowerPoint 2003.

If you see that the text below overlaps or mouse pointer does not move or the "Next" at the bottom Right Hand Side of the slide is not blinking we suggest that you download the free software provided by Microsoft: "PowerPoint Viewer 2003". Then install the software and run the presentation using this viewer.

For your convenience the link to the Microsoft web site is:

PowerPoint Viewer 2003

If animation is OK, proceed to the next slide.

>>> From Idea to Product <<<

>>> From Idea to Product <<<


Cellot

From Idea to Product & ASIC

Development Demonstration


Introduction
Introduction

Next

  • The following is a demonstration for using the FPCL Developer Environment to develop an application:

  • The demonstration utilizes schematic capture and CSL (Cellot Simulation Language).

  • The targetapplication is a simple FIR filter:

    8 Tap, 8 Bit (19 Bit out)

>>> From Idea to Product <<<

>>> From Idea to Product <<<

Please note:

Italic fonts are used for additional explanation


Development steps
Development Steps

Next

There are two steps in the “From Idea to Product” procedure:

  • Check the Idea (the theoretical solution):

    Define the application and check that the idea is feasible.

    The result can be used as a reference to the needed application.

  • Implement the application.

    The result is a downloadable code.

This presentation shows how a user implements the application.


Next

Containers and Gates

Container is an FPCL Object tool that can hold other (subordinate) Containers and / or Functions (Shown graphically on next slide).Functions are stored in Gates.The input of the gate is the input of the function. The output of the gate is the output of the function.


Developer environment

Library

Container

Next

FPCL mapping

Developer Environment

Application

Container

Sub Application

Compiler

Eliminates Containers

Container

Container

Connections

Cell

Container

Container

Container

Function

Function

Function

Function


Next

The user starts with an empty page which is the Schematic View of the Application Container.When the user double-clicks the Container’s representation (icon) it enters into the Container's schematic diagram. This enables inserting the subordinate Containers, the Gates holding the functions and documentation.


Next

8 Tap 8 Bit FIR Filter

Opens an “Explorer type” window from which the user can choose an empty documentation sheet.

!

The user double-clicksthe documentation icon for the documentation sheet to appear

This is an empty page ready to insert the application

The user adds a heading …

and continues with documentation:

Choose “Documentation” from the “Library” menu …

Cellot Inc.

Slide-7

Cellot Proprietary


Next

8 Tap 8 Bit FIR Filter

The user inserts the documentation in this documentation sheet

and returns back to the upper schematic diagram of the upper container

Cellot Inc.

Slide-8

Cellot Proprietary


The schematic now includes the container heading and an icon for the documentation

Next

The schematic now includes the Container heading and an icon for the documentation.

During the idea definition and analysis process, the user:

  • Creates the filter function using float numbers.

  • Converts the float into integer resulting in a model of the application which applies the exact needed result.


Next

The user creates a Container to hold the reference (float type) application

adds a grid, resizes the Container icon to the appropriate dimension and adds text to define the Container. The result is shown in the next slide.

Cellot Inc.

Slide-10

Cellot Proprietary


Next

Right click

The user adds float type input and output pins

Cellot Inc.

Slide-11

Cellot Proprietary


Similarly the user adds a float type output pin

Next

Similarly, the user adds a float type output pin

The Container for the float filter which has just been created is not empty: it shows the two pins the user added. These two pins are automatically inserted into the Container schematic diagram.


Next

Double-Click

The user double-clicks on the Container to edit its schematic diagram

Cellot Inc.

Slide-13

Cellot Proprietary


Next

The input and output pins are already inserted.

The filter formula is:

Y = (X0+X7)*h0 + (X1+X6)*h1 + (X2+X5)*h2 + (X3+X4)*h3

This means a function (gate) with 8 (float) inputs (X0 – X7) and one output (Y)

Locate the gate,

Please c l i c k y o u r m o u s e to see how the function (gate) reference is implemented:

… and adds 8 float inputs and 1 float outputs

Cellot Inc.

Slide-14

Cellot Proprietary


Next

Right click

The user connects the function gate output to the automatically created output pin

Cellot Inc.

Slide-15

Cellot Proprietary


Next

The Gate is ready to host the function:

Y = (X0+X7)*h0 + (X1+X6)*h1 + (X2+X5)*h2 + (X3+X4)*h3

where:

h0, h1, h2, h3 are constants provided by the application engineer.

X0, X1, … X7 are the gate inputs.

X0 is the filter input

Any other Xn is the Xn-1, delayed by one clock.

The next slide demonstrates creation of the Delay:


Next

Double-Click

The user inserts one float input pin and eight float output pins …

… and connects the pins

The user double-clicks on the “Delay” Container to enter into its schematic diagram

Cellot Inc.

Slide-17

Cellot Proprietary


Next

A delay is achieved by routing a signal via a register. This register has float input and float output!The overall delay is achieved by routing the input signal via 8 registers:


Next

Clicking this button enables the user a multiple paste operation

Right Click

Again, the schematic of the “Delay” Container is not empty: the pins are already there.

Cellot Inc.

Slide-19

Cellot Proprietary


Next

The user exits insertion mode and connects the lines

and back to the float filter schematic diagram

Cellot Inc.

Slide-20

Cellot Proprietary


Next

By now, you’ve seen the schematic diagrams of the following: original schematic diagram, filter, documentation and delay.

Top

Container

Float

Filter

Doc

Filter

Formula

Delay

Reg

Reg

Reg

Reg

Reg

Reg

Reg

Reg

The top level is the top container hosting the original schematic diagram.

To help navigating in the application, the user activates the “Auto Expand” feature in the left bar:


Next

Clicking on this icon leads the user to the upper schematic diagram. The user can continue clicking until reaching the Top Container.

The Top Container (to be presented later) is the only Container not included on any schematic diagram.

Cellot Inc.

Slide-22

Cellot Proprietary


Next

The last step to complete building the float reference filter is to insert the function code.


Next

Right Click

Cellot Inc.

Slide-24

Cellot Proprietary


Next

float fFirFilter(float fI0, // The filter input

float fI1, // The filter input delayed 1 time

float fI2, // The filter input delayed 2 times

float fI3, // The filter input delayed 3 times

float fI4, // The filter input delayed 4 times

float fI5, // The filter input delayed 5 times

float fI6, // The filter input delayed 6 times

float fI7) // The filter input delayed 7 times

{

// Brief: Calculate a filter output sample according to the filter formula

// Get: 8 float inputs, each is delayed one clock after the other

// Return: float calculation of the formula

// The Band-Pass Filter coefficients (the ‘:’ note means definition)

// ~~~~~~~~~~~~~~~~~~~~~~~~~

K0 : -0.09112012; // LP: -0.05418289 // BP:-0.09112012

K1 : -0.2961822; // LP: -0.09458317 // BP:-0.2961822

K2 : -0.08889319; // LP: 0.1416305 // BP:-0.08889319

K3 : 0.4576864; // LP: 0.4554365 // BP:+0.4576864

return (fI0 + fI7)*K0 + (fI1 + fI6)*K1 + (fI2 + fI5)*K2 + (fI3 + fI4)*K3;

}

Cellot Inc.

Slide-25

Cellot Proprietary


Next

The filter is now ready and needs to be tested.

In order to test the filter, the user needs a generator. The user uses an FM generator to test the application.

The user can use a ready-made FM Generator from the library, or build one.

The method of creating the generator is the same as creating the filter or any other application.

In this demonstration, a ready-made FM Generator from the library is used:


Next

Opens an “Explorer type” window from which you can choose the appropriate saved application

The user connects the FM generator output to the referenceFilter input

Cellot Inc.

Slide-27

Cellot Proprietary


Next

Have you noticed?

When the line is connected, the icon which indicates an error in the application disappears.

Lets see this again:


Next

The user connects the FM generator output to the Filter (reference) input

Cellot Inc.

Slide-29

Cellot Proprietary


Next

This happens as there is a thread compiling the application, even during editing which saves the user compilation time.

Nevertheless, the user can compile any function or Container independently:


Next

Right click

Cellot Inc.

Slide-31

Cellot Proprietary


Next

If there is an error, the user will get a detailed message similar to the following:

The user can scroll down the message box to see more details


Next

Now it’s time to see the results:


Next

Right click

Double-click

FM and Filter Reference

Cellot Inc.

Slide-34

Cellot Proprietary


Next

In the following slide, the user can drag and drop any pin or connection point from the schematic diagram to the simulation window.


Next

Drag

Drag

Drop

Drop

Cellot Inc.

Slide-36

Cellot Proprietary


Next

Using the same tool, the user creates the integer implementation (with the exact same formula)


Next

Right click

Cellot Inc.

Slide-38

Confidential


Next

The procedure of changing the pins and the formula from float to integer is not shown.

However, the outcome of such operation is shown (Schematic and code, side by side):


Next

Cellot Inc.

Slide-40

Confidential


Next

So this is the same formula but using integers.

The integer input size used is 8 bits. This result in an output (according to the formula) of 19 bits.

You may have noticed that the color of the lines and pins have changed from purple to black. This is because purple represents float and black represents “Bits”. Blue represents a 64-bit integer.

The Container color convention is:

white : there is no register in the Container (purely functional).

gray: contains registers.

light gray: a Cell. Contains one function and one register

The user may change both the Container color and the color convention.


Next

At this point, the application needs to be connected to the same FM generator. However, the FM generator provides float signal and the input to the new application is integer, therefore the user will add a float to 8-bit integer converter. The user will get this converter from the library


Next

Right click

Opens an “Explorer type” window from which you can choose the appropriate saved application

Right click

Right click

Cellot Inc.

Slide-43

Confidential


Next

and the results (after creating a new simulation window):


Next

Drag

Drag

Drop

Drop

Cellot Inc.

Slide-45

Confidential


Next

What do you think should be dropped?

The integer at the output is 19 bits.

Bits, in general, do not represent a value: the ‘Bits’ can represent collection of flags, PCM, log value, , float, char, string or anything else. Only the user knows what these bits represent. Therefore, beside the defaults provided, the user can add any formula to convert the bits into the appropriate value.

But not only this: the Bits can be presented as a collection to form an integer or in “Logic Analyzer” style, bus style, histogram or other.

While dropping a “Bits” signal, the user is forced to explicitly define the needed representation:


Next

The conversion to ‘Int’ is OK

Cellot Inc.

Slide-47

Confidential


Next

Cellot Inc.

Slide-48

Confidential


Next

Although it seems similar, a close look (Zoom In) will show the differences:

  • The user may place the integer result figure over the float result figure

  • The user can create a function to automatically compare the two results

    In this case the user chooses to compare by placing one graph over the other and zooms in the result:


Next

Cellot Inc.

Slide-50

Confidential


Next

Cellot Inc.

Slide-51

Confidential


Next

The user may try integers with different bit counts and compare each result to the float reference.

When satisfied with the “Integer” application, the user implement the application. The result is a downloadable code.

The following is a less detailed presentation starting with the Top Container.


Next

Cellot Inc.

Slide-53

Confidential


Next

Cellot Inc.

Slide-54

Confidential


Next

Remainder: The reference is:


Next

Cellot Inc.

Slide-56

Confidential


Next

Implementation

  • Only two different application Containers have to be implemented:

    • Multiply - accumulator [1]

    • 4 inputs - adder [2]

  • The 4 left Containers in the next slide are equivalent (implementing [1] )

Cellot Inc.

Slide-57

Confidential


Next

Cellot Inc.

Slide-58

Confidential


Next

Cellot Inc.

Slide-59

Confidential


Implementation

Next

Implementation

  • In the code for one of the four multiply-accumulators: ‘d17CombineAndMultiply’ (see slide above) there is a line marked out:

    // int iResult = iIntPart(fResult)

  • If this line is activated to replace the following line (which is doing round rather then integer) even in one Container, the 19-th bit is not accurate. This shows the accuracy the FPCL Developer Environment can achieve.

  • Following is the result of the second (Integer) filter implemented with that line (changed in only one multiply-accumulator) compared with the result of the filter implemented for downloading to the FPCL device. The engineer can see that the result is not accurate enough. By not changing that line, the results are absolutely identical.


Next

Cellot Inc.

Slide-61

Confidential


Last is the adder of 4 17 bit inputs as the code is trivial it has not been captured

Next

Last is the adder of 4, 17-bit, inputs. As the code is trivial it has not been captured.


Next

Cellot Inc.

Slide-63

Confidential


Next

In this presentation we have tried to show the simplicity of the implementation process. Hopefully, we did not cloud the issue with too many details as

the actual application comprises only on the following three slides:

58, the filter schematic diagram (resides in its Container)

59, the multiply-accumulator and

63, the 4 inputs adder.

These three applications / sub-applications are stored in the Library for future use.


Supported languages

Next

Supported Languages

  • Any Container can be independently implemented by Code or Schematic Capture or in Script or by importing from other environments (e.g. C++) or a combination of all of these. The demonstration uses both CSL (Cellot Simulation Language) code and schematic capture.

  • If C++ is used, the third partydeveloper environment (such as the Microsoft Visual C++) is usedand the compiled result is integrated into the FPCL Developer Environment.

  • If Verilog is used, the FPCL Developer Environment compiles the code.



ad