コード例 #1
0
        private string GenerateCommandArgs(TestBench Testbench_obj)
        {
            string commandArgs = "";
            var    icg         = Testbench_obj.Parameters.FirstOrDefault(p => p.Name.Equals("interChipSpace")); // in mm
            var    eg          = Testbench_obj.Parameters.FirstOrDefault(p => p.Name.Equals("boardEdgeSpace")); // in mm
            var    maxRetries  = Testbench_obj.Parameters.FirstOrDefault(p => p.Name.Equals("maxRetries"));
            var    maxThreads  = Testbench_obj.Parameters.FirstOrDefault(p => p.Name.Equals("maxThreads"));     // MOT-729

            if (Testbench_obj.Impl.Children.ComponentAssemblyCollection.Where(ca => string.IsNullOrEmpty(((GME.MGA.IMgaFCO)ca.Impl).RegistryValue["layoutFile"]) == false).Count() > 0)
            {
                // there is a layoutFile for the SUT. The layout.json takes up the whole board
                commandArgs += " -e 0 -i 0";
            }
            else
            {
                if (icg != null)
                {
                    commandArgs += " -i " + icg.Value;
                }
                if (eg != null)
                {
                    commandArgs += " -e " + eg.Value;
                }
            }
            if (maxRetries != null)
            {
                commandArgs += " -s " + maxRetries.Value;
            }
            if (maxThreads != null)
            {
                commandArgs += " -t " + maxThreads.Value;   // MOT-729
            }

            return(commandArgs);
        }
コード例 #2
0
        public override void visit(TestBench obj)
        {
            // Create a sheet for the testbench
            var sheet_obj = new Eagle.sheet();

            schematic_obj.sheets.sheet.Add(sheet_obj);
        }
コード例 #3
0
        private void CommonTraversal(TestBench TestBench_obj)
        {
            // 1. A first traversal maps CyPhy objects to a corresponding but significantly lighter weight object network that only includes a
            //     small set of concepts/classes : TestBench, ComponentAssembly, Component, Parameter, Port, Connection
            // 2. Second and third traversal passes compute the layout of the graph in schematic
            // 3. Forth traversal wires the object network
            //      the object network is hierarchical, but the wiring is direct and skips hierarchy. The dependency on CyPhy is largely localized to the
            //      traversal/visitor code (CyPhyVisitors.cs)

            TestBench_obj.accept(new CyPhyBuildVisitor(this.mainParameters.ProjectDirectory, this.mode, Traceability, mgaIdToDomainIDs, selectedSpiceModels)
            {
                Logger = Logger
            });

            if (mode == Mode.EDA)
            {
                TestBench_obj.accept(new CyPhyLayoutVisitor()
                {
                    Logger = Logger
                });
                TestBench_obj.accept(new CyPhyLayout2Visitor()
                {
                    Logger = Logger
                });
            }

            TestBench_obj.accept(new CyPhyConnectVisitor(this.mode)
            {
                Logger = Logger
            });
        }
コード例 #4
0
        private List <Component> CollectGroundNodes(TestBench obj)
        {
            var gnds = obj.TestComponents.Where(t =>
                                                Grounds.Any(GetSpiceType(t).Item2.Contains)
                                                ).ToList();
            var cgnds = obj.ComponentAssemblies.SelectMany(ca => CollectGroundNodes(ca)).ToList();

            return(gnds.Union(cgnds).ToList());
        }
コード例 #5
0
        private void CopyResourceFromTestBench(TestBench Testbench_obj, string param, string destFileName = null)
        {
            var par = Testbench_obj.Parameters.Where(p => p.Name.Equals(param)).FirstOrDefault();

            if (par == null)
            {
                return;
            }

            if (String.IsNullOrWhiteSpace(destFileName))
            {
                destFileName = Path.GetFileName(par.Value);
            }

            String pathSrcFile = Path.Combine(Testbench_obj.Impl.Impl.Project.GetRootDirectoryPath(),
                                              par.Value);

            try
            {
                CopyFile(par.Value, destFileName);
            }
            catch (FileNotFoundException)
            {
                Logger.WriteError("This test bench specifies a {0} file, {1}, that cannot be found.",
                                  param,
                                  par.Value);
                throw;
            }
            catch (DirectoryNotFoundException)
            {
                // If the directory of the source file doesn't exist, throw this error.
                if (!Directory.Exists(Path.Combine(this.mainParameters.ProjectDirectory,
                                                   Path.GetDirectoryName(par.Value))))
                {
                    Logger.WriteError("This test bench specifies a {0} file, {1}, that cannot be found.",
                                      param,
                                      par.Value);
                    throw;
                }
                else
                {
                    // The destination directory must not exist.
                    Logger.WriteError("The output directory, {0}, does not exist.",
                                      this.mainParameters.OutputDirectory);
                    throw;
                }
            }
        }
コード例 #6
0
        private void GenerateReferenceDesignatorMappingTable(TestBench Testbench_obj)
        {
            using (var sw = new StreamWriter(Path.Combine(this.mainParameters.OutputDirectory, "reference_designator_mapping_table.html")))
            {
                // Get all nested assemblies using an interative approach.
                var assemblies = new List <ComponentAssembly>();
                assemblies.AddRange(Testbench_obj.ComponentAssemblies);
                for (int i = 0; i < assemblies.Count; i++)
                {
                    var assembly = assemblies[i];
                    assemblies.AddRange(assembly.ComponentAssemblyInstances);
                }

                // Get all instances from everywhere.
                var componentInstances = assemblies.SelectMany(a => a.ComponentInstances).ToList();
                componentInstances.AddRange(Testbench_obj.TestComponents);

                // Build mapping table
                List <XrefItem> xrefTable = new List <XrefItem>();
                foreach (var ci in componentInstances)
                {
                    String   path   = ci.Impl.Path;
                    String   refDes = ci.Name;
                    XrefItem row    = new XrefItem()
                    {
                        ReferenceDesignator = refDes, GmePath = path
                    };
                    xrefTable.Add(row);
                }

                // Convert it to HTML
                string html = Xref2Html.makeHtmlFile(
                    "",
                    xrefTable,
                    "");

                // Write mapping table to file
                sw.Write(html);
            }
        }
コード例 #7
0
        private Eagle.eagle GenerateSchematicCode(TestBench TestBench_obj)
        {
            // load schematic library
            Eagle.eagle eagle = null;
            try
            {
                eagle = Eagle.eagle.Deserialize(CyPhy2Schematic.Properties.Resources.schematicTemplate);
                Logger.WriteInfo("Parsed Eagle Library schema version: " + eagle.version);
            }
            catch (Exception e)
            {
                eagle = new Eagle.eagle();  // create an empty eagle object network
                Logger.WriteError("Error parsing XML: " + e.Message + "<br>Inner: " + e.InnerException + "<br>Stack: " + e.StackTrace);
            }
            // 2. The second traversal walks the lighter weight (largely CyPhy independent) object network and maps to the eagle XML object network
            //    the classes of this object network are automatically derived from the eagle XSD using the XSD2Code tool in the META repo
            //    an important step of this traversal is the routing which is implemented currently as a simple rats nest routing,
            //        the traversal and visitor code is localized in (SchematicTraversal.cs)
            TestBench_obj.accept(new EdaVisitor(this)
            {
                eagle_obj = eagle,
                Logger    = Logger
            });

            // 2.5  Finally a serializer (XSD generated code), walks the object network and generates the XML file
            System.IO.Directory.CreateDirectory(this.mainParameters.OutputDirectory);
            String outFile = Path.Combine(this.mainParameters.OutputDirectory, "schema.sch");

            try
            {
                eagle.SaveToFile(outFile);
            }
            catch (Exception ex)
            {
                Logger.WriteError("Error Saving Schema File: {0}<br> Exception: {1}<br> Trace: {2}",
                                  outFile, ex.Message, ex.StackTrace);
            }

            return(eagle);
        }
コード例 #8
0
        public override void visit(TestBench obj)
        {
            if (obj.SolverParameters.ContainsKey("SpiceAnalysis"))
            {
                circuit_obj.analysis = obj.SolverParameters["SpiceAnalysis"];
            }
            var tracesParam = obj.Parameters.Where(p => p.Name.Equals("Traces")).FirstOrDefault();

            if (tracesParam != null)
            {
                SigIntegrityTraces = tracesParam.Value.Split(new char[] { ' ', ',' });
            }

            // process all ground nets first before they get assigned another number
            var gnds   = CollectGroundNodes(obj);
            var gports = gnds.SelectMany(g => g.Ports).ToList();

            foreach (var gp in gports)
            {
                visit(gp, "0");
            }
        }
コード例 #9
0
        private void GenerateSpiceCommandFile(TestBench Testbench_obj)
        {
            var spiceBat = new StreamWriter(Path.Combine(this.mainParameters.OutputDirectory, "runspice.bat"));

            spiceBat.Write(CyPhy2Schematic.Properties.Resources.runspice);

            // find a voltage source test component
            var voltageSrc = Testbench_obj.Impl.Children
                             .TestComponentCollection
                             .FirstOrDefault(c => c.Children.SPICEModelCollection
                                             .Select(x => x.Attributes.Class)
                                             .Contains("V"));

            if (voltageSrc != null)
            {
                // add a call to spice post process
                spiceBat.Write("if exist \"schema.raw\" (\n");
                spiceBat.Write("\t\"%META_PATH%\\bin\\python27\\scripts\\python.exe\" -E -m SpiceVisualizer.post_process -m {0} schema.raw\n", voltageSrc.Name);
                spiceBat.Write(")\n");
            }
            spiceBat.Close();
        }
コード例 #10
0
        private void CopyBoardFilesSpecifiedInPcbComponent(TestBench tb_obj)
        {
            // Look to see if there is a PCB component in the top level assembly
            var compImpl = tb_obj.ComponentAssemblies
                           .SelectMany(c => c.ComponentInstances)
                           .Select(i => i.Impl)
                           .FirstOrDefault(j => (j as Tonka.Component).Attributes
                                           .Classifications
                                           .Contains("pcb_board") ||
                                           (j as Tonka.Component).Attributes
                                           .Classifications
                                           .Contains("template.pcb_template"));
            var comp = (compImpl != null) ? compImpl as Tonka.Component : null;

            if (comp == null)
            {
                return;
            }

            CopyResourceFromComp(comp, "boardTemplate");
            CopyResourceFromComp(comp, "designRules");
            CopyResourceFromComp(comp, "autoRouterConfig", "autoroute.ctl");
        }
コード例 #11
0
        private void GenerateSpiceCode(TestBench TestBench_obj)
        {
            var circuit = new Spice.Circuit()
            {
                name = TestBench_obj.Name
            };
            var siginfo = new Spice.SignalContainer()
            {
                name = TestBench_obj.Name, objectToNetId = new Dictionary <CyPhy2SchematicInterpreter.IDs, string>()
            };

            // now traverse the object network with Spice Visitor to build the spice and siginfo object network
            TestBench_obj.accept(new SpiceVisitor(Traceability, mgaIdToDomainIDs, this)
            {
                circuit_obj = circuit, siginfo_obj = siginfo, mode = this.mode
            });
            String spiceTemplateFile = Path.Combine(this.mainParameters.OutputDirectory, "schema.cir.template");

            circuit.Serialize(spiceTemplateFile);
            String siginfoFile = Path.Combine(this.mainParameters.OutputDirectory, "siginfo.json");

            siginfo.Serialize(siginfoFile);
        }
コード例 #12
0
        public override void visit(TestBench obj)
        {
            Logger.WriteDebug("CyPhyBuildVisitor::visit({0})", obj.Impl.Path);

            var testBench = obj.Impl;
            var ca        = testBench.Children.ComponentAssemblyCollection.FirstOrDefault();

            if (ca == null)
            {
                Logger.WriteFailed("No valid component assembly in testbench {0}", obj.Name);
                return;
            }
            var componentAssembly_obj = new ComponentAssembly(ca);

            obj.ComponentAssemblies.Add(componentAssembly_obj);
            this.systemUnderTest = componentAssembly_obj.SystemUnderTest = componentAssembly_obj;
            componentAssembly_obj.selectedSpiceModels = selectedSpiceModels;

            var tcs = testBench.Children.TestComponentCollection;

            foreach (var tc in tcs)
            {
                var component_obj = new Component(tc);
                component_obj.SystemUnderTest = this.systemUnderTest;
                obj.TestComponents.Add(component_obj);
                CyPhyBuildVisitor.Components.Add(tc.ID, component_obj);   // Add to global component list, are these instance ID-s or component type ID-s?
            }

            foreach (var param in testBench.Children.ParameterCollection)
            {
                var param_obj = new Parameter()
                {
                    Name  = param.Name,
                    Value = param.Attributes.Value
                };
                obj.Parameters.Add(param_obj);
            }

            // solver parameters - currently using Dymola Solver object
            var solver = testBench.Children.SolverSettingsCollection.FirstOrDefault();

            if (solver != null)
            {
                obj.SolverParameters.Add("SpiceAnalysis", solver.Attributes.ToolSpecificAnnotations);
            }

            Dictionary <string, string> properties = testBench.Children.PropertyCollection.ToDictionary(param => param.Name, param => param.Attributes.Value);
            string spiceAnalysisType;

            if (properties.TryGetValue("Spice Analysis Type", out spiceAnalysisType))
            {
                if (spiceAnalysisType == "Transient Analysis")
                {
                    string stepSize = "0.0001";
                    properties.TryGetValue("Spice Step Size", out stepSize);
                    string endTime = "1";
                    properties.TryGetValue("Spice End Time", out endTime);
                    string startTime = "0";
                    properties.TryGetValue("Spice Start Time", out startTime);
                    obj.SolverParameters["SpiceAnalysis"] = String.Format(".TRAN {0} {1} {2}", stepSize, endTime, startTime);
                }
                else
                {
                    throw new ApplicationException(string.Format("Unsupported Spice Analysis Type '{0}'", spiceAnalysisType));
                }
            }
        }
コード例 #13
0
        public Result GenerateCode()
        {
            Result result = new Result();

            // map the root testbench obj
            var testbench = TonkaClasses.TestBench.Cast(this.mainParameters.CurrentFCO);

            if (testbench == null)
            {
                Logger.WriteError("Invalid context of invocation <{0}>, invoke the interpreter from a Testbench model",
                                  this.mainParameters.CurrentFCO.Name);
                return(result);
            }
            var TestBench_obj = new TestBench(testbench);

            BasePath = testbench.Path;

            CommonTraversal(TestBench_obj);

            GenerateReferenceDesignatorMappingTable(TestBench_obj);

            switch (mode)
            {
            case Mode.EDA:
                var eagleSch = GenerateSchematicCode(TestBench_obj);
                CopyBoardFilesSpecifiedInPcbComponent(TestBench_obj);
                CopyBoardFilesSpecifiedInTestBench(TestBench_obj);                                // copy DRU/board template file if the testbench has it specified
                GenerateLayoutCodeResult glcResult = GenerateLayoutCode(eagleSch, TestBench_obj); // MOT-782
                result.bonesFound = glcResult.bonesFound;
                var layout = glcResult.boardLayout;
                GenerateChipFitCommandFile();
                GenerateShowChipFitResultsCommandFile();
                GeneratePlacementCommandFile();
                GeneratePlaceOnlyCommandFile();
                GenerateLayoutReimportFiles(layout);
                result.runCommandArgs = GenerateCommandArgs(TestBench_obj);
                break;

            case Mode.SPICE_SI:
                // parse and map the nets to ports
                signalIntegrityLayout = new Layout.LayoutParser("layout.json", Logger, this)
                {
                    mode = this.mode
                };
                signalIntegrityLayout.BuildMaps();

                // spice code generator uses the mapped traces
                // to generate subcircuits for traces and inserts them appropriately
                GenerateSpiceCode(TestBench_obj);
                GenerateSpiceCommandFile(TestBench_obj);
                break;

            case Mode.SPICE:
                GeneratePopulateTemplateScriptFile();
                GenerateSpiceCode(TestBench_obj);
                GenerateSpiceCommandFile(TestBench_obj);
                GenerateSpiceViewerLauncher();
                break;

            default:
                throw new NotSupportedException(String.Format("Mode {0} is not supported", mode.ToString()));
            }

            return(result);
        }
コード例 #14
0
 private void CopyBoardFilesSpecifiedInTestBench(TestBench Testbench_obj)
 {
     CopyResourceFromTestBench(Testbench_obj, "designRules");
     CopyResourceFromTestBench(Testbench_obj, "boardTemplate");
     CopyResourceFromTestBench(Testbench_obj, "autorouterConfig", "autoroute.ctl");
 }
コード例 #15
0
 public virtual void upVisit(TestBench obj)
 {
 }