2. Cellot Proprietary Slide-0 Cellot Inc. 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 Version Check >>> From Idea to Product <<< Next If animation is OK, proceed to the next slide.

3. Cellot Proprietary Slide-1 Cellot Inc. From Idea to Product & ASIC Development Demonstration

4. Cellot Proprietary Slide-2 Cellot Inc.  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 target application is a simple FIR filter: 8 Tap, 8 Bit (19 Bit out) Introduction >>> From Idea to Product <<< Please note: Italic fonts are used for additional explanation Next

5. Cellot Proprietary Slide-3 Cellot Inc.  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. Development Steps There are two steps in the “From Idea to Product” procedure: This presentation shows how a user implements the application. Next

6. Cellot Proprietary Slide-4 Cellot Inc. 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. Containers and Gates Next

7. Cellot Proprietary Slide-5 Cellot Inc. Container Developer Environment Function FPCL mapping Container Function Container Function Applicatio n Container Sub Applicatio n Cell Compiler Eliminates Containers Library Connections Next

8. Cellot Proprietary Slide-6 Cellot Inc. 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

9. Slide-7 Cellot Proprietary Cellot Inc. This is an empty page ready to insert the application The user adds a heading … ! 8 Tap 8 Bit FIR Filter Choose “Documentation” from the “Library” menu … The user double-clicks the documentation icon for the documentation sheet to appear Opens an “Explorer type” window from which the user can choose an empty documentation sheet. and continues with documentation: Next

10. Slide-8 Cellot Inc. The user inserts the documentation in this documentation sheet and returns back to the upper schematic diagram of the upper container Cellot Proprietary 8 Tap 8 Bit FIR Filter Next

11. Cellot Proprietary Slide-9 Cellot Inc. 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

12. Slide-10 Cellot Inc. 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 Proprietary Next

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

14. Cellot Proprietary Slide-12 Cellot Inc. 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

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

16. Locate the gate, Slide-14 Cellot Inc. Cellot Proprietary 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) 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 Next

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

18. Cellot Proprietary Slide-16 Cellot Inc. 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

19. Slide-17 Cellot Inc. Cellot Proprietary 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 Double-Click Next

20. Cellot Proprietary Slide-18 Cellot Inc. 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

21. Slide-19 Cellot Inc. Cellot Proprietary Right Click Next Again, the schematic of the “Delay” Container is not empty: the pins are already there. Clicking this button enables the user a multiple paste operation

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

23. Cellot Proprietary Slide-21 Cellot Inc. By now, you’ve seen the schematic diagrams of the following: original schematic diagram, filter, documentation and delay. Next Top Container Doc Float Filter Delay Filter Formula 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: Reg

24. Slide-22 Cellot Inc. Cellot Proprietary 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. Next

25. Cellot Proprietary Slide-23 Cellot Inc. The last step to complete building the float reference filter is to insert the function code. Next

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

27. Slide-25 Cellot Inc. Cellot Proprietary 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; } Next

28. Cellot Proprietary Slide-26 Cellot Inc. 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

29. Slide-27 Cellot Inc. Cellot Proprietary Opens an “Explorer type” window from which you can choose the appropriate saved application The user connects the FM generator output to the reference Filter input Next

30. Cellot Proprietary Slide-28 Cellot Inc. Have you noticed? When the line is connected, the icon which indicates an error in the application disappears. Lets see this again: Next

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

32. Cellot Proprietary Slide-30 Cellot Inc. 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

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

34. Cellot Proprietary Slide-32 Cellot Inc. 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

35. Cellot Proprietary Slide-33 Cellot Inc. Now it’s time to see the results: Next

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

37. Cellot Proprietary Slide-35 Cellot Inc. In the following slide, the user can drag and drop any pin or connection point from the schematic diagram to the simulation window. Next

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

39. Cellot Proprietary Slide-37 Cellot Inc. Using the same tool, the user creates the integer implementation (with the exact same formula) Next

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

41. Cellot Proprietary Slide-39 Cellot Inc. 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

42. Slide-40Confidential Cellot Inc. Next

43. Cellot Proprietary Slide-41 Cellot Inc. 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

44. Cellot Proprietary Slide-42 Cellot Inc. 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

45. Slide-43Confidential Cellot Inc. Opens an “Explorer type” window from which you can choose the appropriate saved application Right click Next

46. Cellot Proprietary Slide-44 Cellot Inc. and the results (after creating a new simulation window): Next

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

48. Cellot Proprietary Slide-46 Cellot Inc. 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

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

50. Slide-48Confidential Cellot Inc. Next

51. Cellot Proprietary Slide-49 Cellot Inc. 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

52. Slide-50Confidential Cellot Inc. Next

53. Slide-51Confidential Cellot Inc. Next

54. Cellot Proprietary Slide-52 Cellot Inc. 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

55. Slide-53Confidential Cellot Inc. Next

56. Slide-54Confidential Cellot Inc. Next

57. Cellot Proprietary Slide-55 Cellot Inc. Remainder: The reference is: Next

58. Slide-56Confidential Cellot Inc. Next

59. Slide-57Confidential Cellot Inc.  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] ) Implementation Next

60. Slide-58Confidential Cellot Inc. Next

61. Slide-59Confidential Cellot Inc. Next

62. Cellot Proprietary Slide-60 Cellot Inc.  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. Implementation Next

63. Slide-61Confidential Cellot Inc. Next

64. Cellot Proprietary Slide-62 Cellot Inc. Last is the adder of 4, 17-bit, inputs. As the code is trivial it has not been captured. Next

65. Slide-63Confidential Cellot Inc. Next

66. Cellot Proprietary Slide-64 Cellot Inc. 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. Next

67. Cellot Proprietary Slide-65 Cellot Inc.  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 party developer environment (such as the Microsoft Visual C++) is used and the compiled result is integrated into the FPCL Developer Environment.  If Verilog is used, the FPCL Developer Environment compiles the code. Supported Languages Next

68. Cellot Proprietary Slide-66 Cellot Inc. Thank you