version check n.
Skip this Video
Loading SlideShow in 5 Seconds..
Version Check PowerPoint Presentation
Download Presentation
Version Check

play fullscreen
1 / 67

Version Check

66 Views Download Presentation
Download Presentation

Version Check

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. 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 <<<

  2. Cellot From Idea to Product & ASIC Development Demonstration

  3. 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

  4. 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.

  5. 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.

  6. 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

  7. 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.

  8. 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

  9. 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

  10. 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.

  11. 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

  12. Next Right click The user adds float type input and output pins Cellot Inc. Slide-11 Cellot Proprietary

  13. 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.

  14. Next Double-Click The user double-clicks on the Container to edit its schematic diagram Cellot Inc. Slide-13 Cellot Proprietary

  15. 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

  16. Next Right click The user connects the function gate output to the automatically created output pin Cellot Inc. Slide-15 Cellot Proprietary

  17. 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:

  18. 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

  19. 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:

  20. 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

  21. Next The user exits insertion mode and connects the lines and back to the float filter schematic diagram Cellot Inc. Slide-20 Cellot Proprietary

  22. 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:

  23. 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

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

  25. Next Right Click Cellot Inc. Slide-24 Cellot Proprietary

  26. 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

  27. 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:

  28. 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

  29. Next Have you noticed? When the line is connected, the icon which indicates an error in the application disappears. Lets see this again:

  30. Next The user connects the FM generator output to the Filter (reference) input Cellot Inc. Slide-29 Cellot Proprietary

  31. 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:

  32. Next Right click Cellot Inc. Slide-31 Cellot Proprietary

  33. 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

  34. Next Now it’s time to see the results:

  35. Next Right click Double-click FM and Filter Reference Cellot Inc. Slide-34 Cellot Proprietary

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

  37. Next Drag Drag Drop Drop Cellot Inc. Slide-36 Cellot Proprietary

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

  39. Next Right click Cellot Inc. Slide-38 Confidential

  40. 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):

  41. Next Cellot Inc. Slide-40 Confidential

  42. 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.

  43. 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

  44. 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

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

  46. Next Drag Drag Drop Drop Cellot Inc. Slide-45 Confidential

  47. 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:

  48. Next The conversion to ‘Int’ is OK Cellot Inc. Slide-47 Confidential

  49. Next Cellot Inc. Slide-48 Confidential

  50. 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: