From 54ba5af369d21351d46b3dbf3ff2a78b38ed4cf9 Mon Sep 17 00:00:00 2001 From: William Yang Date: Tue, 4 Feb 2025 18:15:41 +1100 Subject: [PATCH] Added differential taper parametric search --- simulations/differential_taper/.gitignore | 33 + .../differential_taper/differential.kicad_dru | 39 + .../differential_taper/differential.kicad_pcb | 1013 +++++++++++++++++ .../differential_taper/differential.kicad_pro | 647 +++++++++++ .../differential_taper/differential.kicad_sch | 919 +++++++++++++++ .../fab/differential-B_Cu.gbr | 77 ++ .../fab/differential-Edge_Cuts.gbr | 23 + .../fab/differential-F_Cu.gbr | 85 ++ .../fab/differential-In1_Cu.gbr | 200 ++++ .../fab/differential-NPTH.drl | 12 + .../fab/differential-PTH.drl | 21 + .../fab/differential-bottom-pos.csv | 3 + .../fab/differential-top-pos.csv | 4 + simulations/differential_taper/fp-lib-table | 4 + .../differential_taper/generate_tapers.py | 316 +++++ .../differential_taper/simulation.json | 104 ++ simulations/gerber2ems | 2 +- simulations/run_simulations.py | 6 +- 18 files changed, 3506 insertions(+), 2 deletions(-) create mode 100644 simulations/differential_taper/.gitignore create mode 100644 simulations/differential_taper/differential.kicad_dru create mode 100644 simulations/differential_taper/differential.kicad_pcb create mode 100644 simulations/differential_taper/differential.kicad_pro create mode 100644 simulations/differential_taper/differential.kicad_sch create mode 100644 simulations/differential_taper/fab/differential-B_Cu.gbr create mode 100644 simulations/differential_taper/fab/differential-Edge_Cuts.gbr create mode 100644 simulations/differential_taper/fab/differential-F_Cu.gbr create mode 100644 simulations/differential_taper/fab/differential-In1_Cu.gbr create mode 100644 simulations/differential_taper/fab/differential-NPTH.drl create mode 100644 simulations/differential_taper/fab/differential-PTH.drl create mode 100644 simulations/differential_taper/fab/differential-bottom-pos.csv create mode 100644 simulations/differential_taper/fab/differential-top-pos.csv create mode 100644 simulations/differential_taper/fp-lib-table create mode 100644 simulations/differential_taper/generate_tapers.py create mode 100644 simulations/differential_taper/simulation.json diff --git a/simulations/differential_taper/.gitignore b/simulations/differential_taper/.gitignore new file mode 100644 index 0000000..aff960d --- /dev/null +++ b/simulations/differential_taper/.gitignore @@ -0,0 +1,33 @@ +# gerber2ems outputs +ems/ +ems_*/ +output/ +variants*/ + +# For PCBs designed using KiCad: https://www.kicad.org/ +# Format documentation: https://kicad.org/help/file-formats/ + +# Temporary files +*.000 +*.bak +*.bck +*.kicad_pcb-bak +*.kicad_sch-bak +*-backups +*.kicad_prl +*.sch-bak +*~ +_autosave-* +*.tmp +*-save.pro +*-save.kicad_pcb +fp-info-cache +~*.lck +\#auto_saved_files# + +# Netlist files (exported from Eeschema) +*.net + +# Autorouter files (exported from Pcbnew) +*.dsn +*.ses diff --git a/simulations/differential_taper/differential.kicad_dru b/simulations/differential_taper/differential.kicad_dru new file mode 100644 index 0000000..b9b7d99 --- /dev/null +++ b/simulations/differential_taper/differential.kicad_dru @@ -0,0 +1,39 @@ +(version 1) +(rule "Pad clearance" + (condition "A.type == 'pad'") + (constraint clearance (min 0.01mm)) +) + +(rule "Track clearance" + (condition "A.type == 'track' && B.type == 'track'") + (constraint clearance (min 0.01mm)) +) + +(rule "Track clearance" + (condition "A.type == 'track' && B.type == 'Via'") + (constraint clearance (min 0.01mm)) +) + +(rule "Track clearance" + (condition "A.type == 'Zone' && B.type == 'Via'") + (constraint clearance (min 0.01mm)) +) + +(rule "Zone Min Width Rule" + (condition "A.Type == 'Zone' && A.NetClass != B.NetClass") + (constraint physical_clearance (min 0.01mm)) + (constraint track_width (min 0.01mm)) +) + +(rule "Annular via width" + (condition "A.NetClass != B.NetClass") + (constraint annular_width (min 0.01mm)) + (constraint hole_clearance (min 0.01mm)) + (constraint hole_to_hole (min 0.01mm)) + (constraint physical_hole_clearance (min 0.01mm)) +) + +(rule "Prevent Via to Ground Plane" + (constraint zone_connection none) + (condition "A.Type == 'Via' && B.Type == 'Zone'") +) diff --git a/simulations/differential_taper/differential.kicad_pcb b/simulations/differential_taper/differential.kicad_pcb new file mode 100644 index 0000000..45c5aef --- /dev/null +++ b/simulations/differential_taper/differential.kicad_pcb @@ -0,0 +1,1013 @@ +(kicad_pcb + (version 20240108) + (generator "pcbnew") + (generator_version "8.0") + (general + (thickness 0.49) + (legacy_teardrops no) + ) + (paper "A4") + (layers + (0 "F.Cu" signal) + (1 "In1.Cu" signal) + (2 "In2.Cu" signal) + (31 "B.Cu" signal) + (32 "B.Adhes" user "B.Adhesive") + (33 "F.Adhes" user "F.Adhesive") + (34 "B.Paste" user) + (35 "F.Paste" user) + (36 "B.SilkS" user "B.Silkscreen") + (37 "F.SilkS" user "F.Silkscreen") + (38 "B.Mask" user) + (39 "F.Mask" user) + (40 "Dwgs.User" user "User.Drawings") + (41 "Cmts.User" user "User.Comments") + (42 "Eco1.User" user "User.Eco1") + (43 "Eco2.User" user "User.Eco2") + (44 "Edge.Cuts" user) + (45 "Margin" user) + (46 "B.CrtYd" user "B.Courtyard") + (47 "F.CrtYd" user "F.Courtyard") + (48 "B.Fab" user) + (49 "F.Fab" user) + (50 "User.1" user) + (51 "User.2" user) + (52 "User.3" user) + (53 "User.4" user) + (54 "User.5" user) + (55 "User.6" user) + (56 "User.7" user) + (57 "User.8" user) + (58 "User.9" user) + ) + (setup + (stackup + (layer "F.SilkS" + (type "Top Silk Screen") + ) + (layer "F.Paste" + (type "Top Solder Paste") + ) + (layer "F.Mask" + (type "Top Solder Mask") + (thickness 0.01) + ) + (layer "F.Cu" + (type "copper") + (thickness 0.035) + ) + (layer "dielectric 1" + (type "prepreg") + (thickness 0.1) + (material "FR4") + (epsilon_r 4.6) + (loss_tangent 0.02) + ) + (layer "In1.Cu" + (type "copper") + (thickness 0.035) + ) + (layer "dielectric 2" + (type "core") + (thickness 0.13) + (material "FR4") + (epsilon_r 4.5) + (loss_tangent 0.02) + ) + (layer "In2.Cu" + (type "copper") + (thickness 0.035) + ) + (layer "dielectric 3" + (type "prepreg") + (thickness 0.1) + (material "FR4") + (epsilon_r 4.5) + (loss_tangent 0.02) + ) + (layer "B.Cu" + (type "copper") + (thickness 0.035) + ) + (layer "B.Mask" + (type "Bottom Solder Mask") + (thickness 0.01) + ) + (layer "B.Paste" + (type "Bottom Solder Paste") + ) + (layer "B.SilkS" + (type "Bottom Silk Screen") + ) + (copper_finish "None") + (dielectric_constraints no) + ) + (pad_to_mask_clearance 0) + (allow_soldermask_bridges_in_footprints no) + (aux_axis_origin 148 129) + (pcbplotparams + (layerselection 0x0001000_fffffffb) + (plot_on_all_layers_selection 0x0000000_00000000) + (disableapertmacros no) + (usegerberextensions no) + (usegerberattributes yes) + (usegerberadvancedattributes yes) + (creategerberjobfile no) + (dashed_line_dash_ratio 12.000000) + (dashed_line_gap_ratio 3.000000) + (svgprecision 6) + (plotframeref no) + (viasonmask no) + (mode 1) + (useauxorigin yes) + (hpglpennumber 1) + (hpglpenspeed 20) + (hpglpendiameter 15.000000) + (pdf_front_fp_property_popups yes) + (pdf_back_fp_property_popups yes) + (dxfpolygonmode yes) + (dxfimperialunits yes) + (dxfusepcbnewfont yes) + (psnegative no) + (psa4output no) + (plotreference yes) + (plotvalue yes) + (plotfptext yes) + (plotinvisibletext no) + (sketchpadsonfab no) + (subtractmaskfromsilk no) + (outputformat 1) + (mirror no) + (drillshape 0) + (scaleselection 1) + (outputdirectory "fab") + ) + ) + (net 0 "") + (net 1 "GND") + (net 2 "A-") + (net 3 "A+") + (footprint "simulation_port:pad_0.1mm" + (layer "F.Cu") + (uuid "26d0cb6e-15ab-4415-a34d-1bb8eb560170") + (at 148.4 127.1175) + (property "Reference" "GND1" + (at 0 -4.5 0) + (unlocked yes) + (layer "F.SilkS") + (uuid "f702c82f-c137-46ed-b3ec-42090ff9fd4a") + (effects + (font + (size 1 1) + (thickness 0.1) + ) + ) + ) + (property "Value" "Ground" + (at 0 -3 0) + (unlocked yes) + (layer "F.Fab") + (uuid "06e546b7-0b18-41f0-ba39-0129db6d6f0d") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property "Footprint" "simulation_port:pad_0.1mm" + (at 0 -4 0) + (unlocked yes) + (layer "F.Fab") + (hide yes) + (uuid "7d1ce8b8-461d-4538-9017-58f0526202c7") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property "Datasheet" "" + (at 0 -4 0) + (unlocked yes) + (layer "F.Fab") + (hide yes) + (uuid "0205fdcf-52b3-407e-a2cf-63fd40da9b63") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property "Description" "test point" + (at 0 -4 0) + (unlocked yes) + (layer "F.Fab") + (hide yes) + (uuid "07a49b7d-3209-4b7e-89f5-d1bc5fc477a0") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property ki_fp_filters "Pin* Test*") + (path "/daab5a74-b160-4e51-ae63-89f9e7a355be") + (sheetname "Root") + (sheetfile "differential.kicad_sch") + (attr smd) + (fp_line + (start -0.04 -0.04) + (end 0.04 -0.04) + (stroke + (width 0.005) + (type default) + ) + (layer "Dwgs.User") + (uuid "ac90392d-549f-4bea-8b1a-b09ba0f44f2a") + ) + (fp_text user "${REFERENCE}" + (at 0 -1.5 0) + (unlocked yes) + (layer "F.Fab") + (uuid "fb4a1f77-46f2-4627-8e3d-d930811d5f8b") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (pad "1" smd roundrect + (at 0 0) + (size 0.1 0.1) + (layers "F.Cu" "F.Paste" "F.Mask") + (roundrect_rratio 0.1) + (net 1 "GND") + (pinfunction "1") + (pintype "passive") + (thermal_bridge_angle 45) + (teardrops + (best_length_ratio 0.5) + (max_length 1) + (best_width_ratio 1) + (max_width 2) + (curve_points 0) + (filter_ratio 0.9) + (enabled yes) + (allow_two_segments yes) + (prefer_zone_connections yes) + ) + (uuid "30a4136b-05d8-464b-ba97-a519984322cf") + ) + ) + (footprint "simulation_port:pad_0.15mm" + (layer "F.Cu") + (uuid "d9209cd3-9351-48f6-a472-3b6f8ef264fe") + (at 148.53 127.474999 180) + (property "Reference" "SP0" + (at 0 -4.5 180) + (unlocked yes) + (layer "F.SilkS") + (uuid "09fd4ed0-953e-4faa-a683-6bca5e37acd2") + (effects + (font + (size 1 1) + (thickness 0.1) + ) + ) + ) + (property "Value" "Simulation_Port" + (at 0 -3 180) + (unlocked yes) + (layer "F.Fab") + (uuid "4a9d5094-3e7f-42fc-93a4-134d038145e6") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property "Footprint" "simulation_port:pad_0.15mm" + (at 0 -4 180) + (unlocked yes) + (layer "F.Fab") + (hide yes) + (uuid "7fb87916-24b5-4fa0-9849-67bc87c34134") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property "Datasheet" "" + (at 0 -4 180) + (unlocked yes) + (layer "F.Fab") + (hide yes) + (uuid "babb7b75-4cea-43c9-8ed0-d0871105504d") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property "Description" "test point" + (at 0 -4 180) + (unlocked yes) + (layer "F.Fab") + (hide yes) + (uuid "804dc78a-766a-437e-8229-17be3157f0d0") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property ki_fp_filters "Pin* Test*") + (path "/a5c92765-00ff-4693-b703-7a5c7fedd439") + (sheetname "Root") + (sheetfile "differential.kicad_sch") + (attr smd) + (fp_line + (start -0.06 -0.06) + (end 0.06 -0.06) + (stroke + (width 0.01) + (type default) + ) + (layer "Dwgs.User") + (uuid "850b9cfa-2e9b-4e45-8d12-6fa7fa9c5d5b") + ) + (fp_text user "${REFERENCE}" + (at 0 -1.5 180) + (unlocked yes) + (layer "F.Fab") + (uuid "e823f004-9907-47f6-b47e-d4e73a8006b8") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (pad "1" smd roundrect + (at 0 0 180) + (size 0.15 0.15) + (layers "F.Cu" "F.Paste" "F.Mask") + (roundrect_rratio 0.1) + (net 1 "GND") + (pinfunction "1") + (pintype "passive") + (thermal_bridge_angle 45) + (teardrops + (best_length_ratio 0.5) + (max_length 1) + (best_width_ratio 1) + (max_width 2) + (curve_points 0) + (filter_ratio 0.9) + (enabled yes) + (allow_two_segments yes) + (prefer_zone_connections yes) + ) + (uuid "955fe0ae-ae57-41f0-926c-7dec238372d7") + ) + ) + (footprint "simulation_port:pad_0.15mm" + (layer "F.Cu") + (uuid "ee4ab571-3750-4c61-98c7-887034d96196") + (at 148.83 127.474999 180) + (property "Reference" "SP2" + (at 0 -4.5 180) + (unlocked yes) + (layer "F.SilkS") + (uuid "931bf548-0401-4058-b8e2-24160667b611") + (effects + (font + (size 1 1) + (thickness 0.1) + ) + ) + ) + (property "Value" "Simulation_Port" + (at 0 -3 180) + (unlocked yes) + (layer "F.Fab") + (uuid "3a75a9bc-bf95-42d4-8b9c-b795405d34f3") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property "Footprint" "simulation_port:pad_0.15mm" + (at 0 -4 180) + (unlocked yes) + (layer "F.Fab") + (hide yes) + (uuid "6645f5d8-a606-4d73-b281-690397578783") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property "Datasheet" "" + (at 0 -4 180) + (unlocked yes) + (layer "F.Fab") + (hide yes) + (uuid "d11359f3-5eb0-4a95-b64c-7e354244db71") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property "Description" "test point" + (at 0 -4 180) + (unlocked yes) + (layer "F.Fab") + (hide yes) + (uuid "347a1bbd-47e4-4c11-ade6-e7cfc7c81613") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (property ki_fp_filters "Pin* Test*") + (path "/ed3a6216-814d-4795-8ecd-7eebfc55452a") + (sheetname "Root") + (sheetfile "differential.kicad_sch") + (attr smd) + (fp_line + (start -0.06 -0.06) + (end 0.06 -0.06) + (stroke + (width 0.01) + (type default) + ) + (layer "Dwgs.User") + (uuid "862bb5c7-f2d3-4592-af6f-c58e0fd004eb") + ) + (fp_text user "${REFERENCE}" + (at 0 -1.5 180) + (unlocked yes) + (layer "F.Fab") + (uuid "e24ba738-3980-4335-b6a3-21b242e82692") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + ) + ) + (pad "1" smd roundrect + (at 0 0 180) + (size 0.15 0.15) + (layers "F.Cu" "F.Paste" "F.Mask") + (roundrect_rratio 0.1) + (net 1 "GND") + (pinfunction "1") + (pintype "passive") + (thermal_bridge_angle 45) + (teardrops + (best_length_ratio 0.5) + (max_length 1) + (best_width_ratio 1) + (max_width 2) + (curve_points 0) + (filter_ratio 0.9) + (enabled yes) + (allow_two_segments yes) + (prefer_zone_connections yes) + ) + (uuid "77c5ab30-06f3-48fb-a950-26a04341b47a") + ) + ) + (footprint "simulation_port:pad_0.15mm" + (layer "B.Cu") + (uuid "3025e913-85a9-4fd8-be7e-525b9908a25b") + (at 148.53 128.5 180) + (property "Reference" "SP1" + (at 0 4.5 0) + (unlocked yes) + (layer "B.SilkS") + (uuid "7e034696-5b32-4b8a-aea2-fbef25b35d4d") + (effects + (font + (size 1 1) + (thickness 0.1) + ) + (justify mirror) + ) + ) + (property "Value" "Simulation_Port" + (at 0 3 0) + (unlocked yes) + (layer "B.Fab") + (uuid "33254b66-75e9-4daa-828f-48dd7d596fc7") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + (justify mirror) + ) + ) + (property "Footprint" "simulation_port:pad_0.15mm" + (at 0 4 0) + (unlocked yes) + (layer "B.Fab") + (hide yes) + (uuid "918293c7-1d7a-42b7-9a6e-080f9a3bb9bd") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + (justify mirror) + ) + ) + (property "Datasheet" "" + (at 0 4 0) + (unlocked yes) + (layer "B.Fab") + (hide yes) + (uuid "5f5fb5b8-6442-4420-b29c-7f57bedde8cd") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + (justify mirror) + ) + ) + (property "Description" "test point" + (at 0 4 0) + (unlocked yes) + (layer "B.Fab") + (hide yes) + (uuid "5e3ebc68-e09c-48c5-aba5-1e8b967d5d23") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + (justify mirror) + ) + ) + (property ki_fp_filters "Pin* Test*") + (path "/bf13c176-fb4a-4e98-a210-6ed5c67779c6") + (sheetname "Root") + (sheetfile "differential.kicad_sch") + (attr smd) + (fp_line + (start 0.06 0.06) + (end -0.06 0.06) + (stroke + (width 0.01) + (type default) + ) + (layer "Dwgs.User") + (uuid "e4f1a26e-d974-4f20-b4f2-42bbf3ad7e57") + ) + (fp_text user "${REFERENCE}" + (at 0 1.5 0) + (unlocked yes) + (layer "B.Fab") + (uuid "94a44037-051d-4638-a27b-9bc9a1aa9865") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + (justify mirror) + ) + ) + (pad "1" smd roundrect + (at 0 0 180) + (size 0.15 0.15) + (layers "B.Cu" "B.Paste" "B.Mask") + (roundrect_rratio 0.1) + (net 1 "GND") + (pinfunction "1") + (pintype "passive") + (thermal_bridge_angle 45) + (teardrops + (best_length_ratio 0.5) + (max_length 1) + (best_width_ratio 1) + (max_width 2) + (curve_points 0) + (filter_ratio 0.9) + (enabled yes) + (allow_two_segments yes) + (prefer_zone_connections yes) + ) + (uuid "a56edd44-71b2-4f83-abac-eead4295d4af") + ) + ) + (footprint "simulation_port:pad_0.15mm" + (layer "B.Cu") + (uuid "c83ffe97-b0d3-4901-a4a1-bd4edb8ba91a") + (at 148.83 128.5 180) + (property "Reference" "SP3" + (at 0 4.5 0) + (unlocked yes) + (layer "B.SilkS") + (uuid "3ed12973-7a0a-453e-9422-2d6d29210c49") + (effects + (font + (size 1 1) + (thickness 0.1) + ) + (justify mirror) + ) + ) + (property "Value" "Simulation_Port" + (at 0 3 0) + (unlocked yes) + (layer "B.Fab") + (uuid "cc11c209-57d9-400d-9aee-d48321608f28") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + (justify mirror) + ) + ) + (property "Footprint" "simulation_port:pad_0.15mm" + (at 0 4 0) + (unlocked yes) + (layer "B.Fab") + (hide yes) + (uuid "55c12fe9-8aeb-4fd6-8d81-2e82557382ea") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + (justify mirror) + ) + ) + (property "Datasheet" "" + (at 0 4 0) + (unlocked yes) + (layer "B.Fab") + (hide yes) + (uuid "3719679e-5cf7-4831-b464-dd40cfe2bba8") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + (justify mirror) + ) + ) + (property "Description" "test point" + (at 0 4 0) + (unlocked yes) + (layer "B.Fab") + (hide yes) + (uuid "b8293ad8-5809-4c84-8590-f72ba38b3555") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + (justify mirror) + ) + ) + (property ki_fp_filters "Pin* Test*") + (path "/d206b72b-f746-46b7-b758-20959411d48d") + (sheetname "Root") + (sheetfile "differential.kicad_sch") + (attr smd) + (fp_line + (start 0.06 0.06) + (end -0.06 0.06) + (stroke + (width 0.01) + (type default) + ) + (layer "Dwgs.User") + (uuid "e3ab99e4-2ac2-42f2-8b2e-55445a18e08c") + ) + (fp_text user "${REFERENCE}" + (at 0 1.5 0) + (unlocked yes) + (layer "B.Fab") + (uuid "98c7faff-f388-4bce-b8ee-3fda3dbf1574") + (effects + (font + (size 1 1) + (thickness 0.15) + ) + (justify mirror) + ) + ) + (pad "1" smd roundrect + (at 0 0 180) + (size 0.15 0.15) + (layers "B.Cu" "B.Paste" "B.Mask") + (roundrect_rratio 0.1) + (net 1 "GND") + (pinfunction "1") + (pintype "passive") + (thermal_bridge_angle 45) + (teardrops + (best_length_ratio 0.5) + (max_length 1) + (best_width_ratio 1) + (max_width 2) + (curve_points 0) + (filter_ratio 0.9) + (enabled yes) + (allow_two_segments yes) + (prefer_zone_connections yes) + ) + (uuid "fae3bdb6-58c3-472d-b450-1ff138c8bcfb") + ) + ) + (gr_rect + (start 148.7575 128.4275) + (end 148.9025 128.5725) + (stroke + (width 0.005) + (type solid) + ) + (fill solid) + (layer "In1.Cu") + (net 2) + (uuid "47bef157-ed2e-4328-830d-30ceadbb6e01") + ) + (gr_rect + (start 148.4575 127.402499) + (end 148.6025 127.547499) + (stroke + (width 0.005) + (type solid) + ) + (fill solid) + (layer "In1.Cu") + (net 3) + (uuid "95ae9e9d-b116-475e-adc3-c1750bb8f288") + ) + (gr_rect + (start 148.7575 127.402499) + (end 148.9025 127.547499) + (stroke + (width 0.005) + (type solid) + ) + (fill solid) + (layer "In1.Cu") + (net 2) + (uuid "dc8423aa-f322-4778-ab7f-d1cf0755df2b") + ) + (gr_rect + (start 148.4575 128.4275) + (end 148.6025 128.5725) + (stroke + (width 0.005) + (type solid) + ) + (fill solid) + (layer "In1.Cu") + (net 3) + (uuid "fb7fa2a7-68b7-4084-a3a1-59bc7c801829") + ) + (gr_rect + (start 147.995 126.9152) + (end 149.335 129.0052) + (stroke + (width 0.1) + (type solid) + ) + (fill none) + (layer "Edge.Cuts") + (uuid "77b50aa8-4421-4f49-b47e-dc2b0f042f79") + ) + (via + (at 148.635 127.1675) + (size 0.2) + (drill 0.15) + (layers "F.Cu" "B.Cu") + (net 1) + (uuid "1bd71190-d667-48c5-aa4b-273b10edd489") + ) + (via + (at 149.1 128.7) + (size 0.2) + (drill 0.15) + (layers "F.Cu" "B.Cu") + (free yes) + (net 1) + (uuid "53db1352-2d1f-48e4-a0cd-81f8800ab97d") + ) + (via + (at 148.635 128.8) + (size 0.2) + (drill 0.15) + (layers "F.Cu" "B.Cu") + (net 1) + (uuid "c68f7c10-80e8-47b6-90b3-563d33a71573") + ) + (via + (at 148.2 127.2) + (size 0.2) + (drill 0.15) + (layers "F.Cu" "B.Cu") + (free yes) + (net 1) + (uuid "f058416c-b679-44ae-9d97-f9c8ebb79639") + ) + (via + (at 148.2 128.7) + (size 0.2) + (drill 0.15) + (layers "F.Cu" "B.Cu") + (free yes) + (net 1) + (uuid "f4313ee2-0f2a-4d95-98f3-d055eed00366") + ) + (via + (at 149.1 127.2) + (size 0.2) + (drill 0.15) + (layers "F.Cu" "B.Cu") + (free yes) + (net 1) + (uuid "f95f493b-7521-45ed-aa95-d98844a52d5d") + ) + (segment + (start 148.83 127.474999) + (end 148.830001 127.475) + (width 0.15) + (layer "In1.Cu") + (net 2) + (uuid "70f22003-6f27-470e-9567-8f7f6defb499") + ) + (segment + (start 148.830001 127.475) + (end 148.830001 128.499999) + (width 0.15) + (layer "In1.Cu") + (net 2) + (uuid "866c4254-df7a-4642-8cb7-39aba114e08f") + ) + (segment + (start 148.830001 128.499999) + (end 148.83 128.5) + (width 0.15) + (layer "In1.Cu") + (net 2) + (uuid "b9d3e79c-d254-4f18-a98f-3a862ea14058") + ) + (segment + (start 148.529999 127.475) + (end 148.529999 128.499999) + (width 0.15) + (layer "In1.Cu") + (net 3) + (uuid "301d21d4-6af7-454a-8f7d-0a4bfcbc945e") + ) + (segment + (start 148.529999 128.499999) + (end 148.53 128.5) + (width 0.15) + (layer "In1.Cu") + (net 3) + (uuid "5e06f777-6503-4738-95dc-13e340863437") + ) + (segment + (start 148.53 127.474999) + (end 148.529999 127.475) + (width 0.15) + (layer "In1.Cu") + (net 3) + (uuid "8fadef6b-a785-430b-af17-4588e21f1774") + ) + (zone + (net 1) + (net_name "GND") + (layer "F.Cu") + (uuid "ba079b3f-276e-4e76-8d0f-4b36b15ed27f") + (hatch none 0.1) + (priority 1) + (connect_pads yes + (clearance 0.1) + ) + (min_thickness 0.1) + (filled_areas_thickness no) + (fill yes + (thermal_gap 0.25) + (thermal_bridge_width 0.25) + ) + (polygon + (pts + (xy 148.11 127.0175) (xy 149.265 127.0175) (xy 149.265 127.5175) (xy 148.11 127.5175) + ) + ) + (filled_polygon + (layer "F.Cu") + (pts + (xy 149.250648 127.031852) (xy 149.265 127.0665) (xy 149.265 127.4685) (xy 149.250648 127.503148) + (xy 149.216 127.5175) (xy 148.159 127.5175) (xy 148.124352 127.503148) (xy 148.11 127.4685) (xy 148.11 127.0665) + (xy 148.124352 127.031852) (xy 148.159 127.0175) (xy 149.216 127.0175) + ) + ) + ) + (zone + (net 1) + (net_name "GND") + (layer "In1.Cu") + (uuid "79876d40-545d-442e-85e4-6adea09a635b") + (hatch none 0.5) + (connect_pads no + (clearance 0.1) + ) + (min_thickness 0.2) + (filled_areas_thickness no) + (fill yes + (thermal_gap 0.5) + (thermal_bridge_width 0.5) + (island_removal_mode 1) + (island_area_min 10) + ) + (polygon + (pts + (xy 148.1 128.935) (xy 149.270859 128.935057) (xy 149.270859 127.010057) (xy 148.1 127.01) + ) + ) + (filled_polygon + (layer "In1.Cu") + (pts + (xy 149.171864 127.010052) (xy 149.230054 127.028962) (xy 149.266015 127.078464) (xy 149.270859 127.109052) + (xy 149.270859 128.836052) (xy 149.251952 128.894243) (xy 149.202452 128.930207) (xy 149.171854 128.935052) + (xy 148.198995 128.935004) (xy 148.140805 128.916094) (xy 148.104844 128.866592) (xy 148.1 128.836004) + (xy 148.1 127.42071) (xy 148.304498 127.42071) (xy 148.304498 127.531377) (xy 148.304499 127.531386) + (xy 148.304499 128.447156) (xy 148.304498 128.44717) (xy 148.304498 128.556372) (xy 148.3045 128.556385) + (xy 148.3045 128.602934) (xy 148.327793 128.659167) (xy 148.370833 128.702207) (xy 148.427066 128.7255) + (xy 148.427067 128.7255) (xy 148.632932 128.7255) (xy 148.632934 128.7255) (xy 148.642115 128.721696) + (xy 148.70311 128.716896) (xy 148.717877 128.721694) (xy 148.727066 128.7255) (xy 148.773614 128.7255) + (xy 148.773622 128.725501) (xy 148.785145 128.725501) (xy 148.886378 128.725501) (xy 148.886386 128.7255) + (xy 148.932933 128.7255) (xy 148.932934 128.7255) (xy 148.989167 128.702207) (xy 149.032207 128.659167) + (xy 149.0555 128.602934) (xy 149.0555 128.556385) (xy 149.055501 128.556376) (xy 149.055501 127.422171) + (xy 149.0555 127.422157) (xy 149.0555 127.372065) (xy 149.032207 127.315833) (xy 149.032207 127.315832) + (xy 148.989167 127.272792) (xy 148.932934 127.249499) (xy 148.932933 127.249499) (xy 148.886386 127.249499) + (xy 148.886378 127.249498) (xy 148.874855 127.249498) (xy 148.785145 127.249498) (xy 148.773622 127.249498) + (xy 148.773614 127.249499) (xy 148.727064 127.249499) (xy 148.717885 127.253301) (xy 148.656888 127.258101) + (xy 148.642115 127.253301) (xy 148.632936 127.249499) (xy 148.632934 127.249499) (xy 148.487934 127.249499) + (xy 148.427066 127.249499) (xy 148.403774 127.259147) (xy 148.370834 127.272791) (xy 148.327792 127.315833) + (xy 148.3045 127.372065) (xy 148.3045 127.420688) (xy 148.304498 127.42071) (xy 148.1 127.42071) + (xy 148.1 127.109004) (xy 148.118907 127.050813) (xy 148.168407 127.014849) (xy 148.198999 127.010004) + ) + ) + ) + (zone + (net 1) + (net_name "GND") + (layer "B.Cu") + (uuid "9d0d7af6-d126-4302-820f-8a0a6754ba88") + (hatch none 0.1) + (priority 1) + (connect_pads yes + (clearance 0.1) + ) + (min_thickness 0.1) + (filled_areas_thickness no) + (fill yes + (thermal_gap 0.25) + (thermal_bridge_width 0.25) + ) + (polygon + (pts + (xy 148.105 128.45) (xy 149.265 128.45) (xy 149.265 128.925) (xy 148.105 128.925) + ) + ) + (filled_polygon + (layer "B.Cu") + (pts + (xy 149.250648 128.464352) (xy 149.265 128.499) (xy 149.265 128.876) (xy 149.250648 128.910648) + (xy 149.216 128.925) (xy 148.154 128.925) (xy 148.119352 128.910648) (xy 148.105 128.876) (xy 148.105 128.499) + (xy 148.119352 128.464352) (xy 148.154 128.45) (xy 149.216 128.45) + ) + ) + ) +) diff --git a/simulations/differential_taper/differential.kicad_pro b/simulations/differential_taper/differential.kicad_pro new file mode 100644 index 0000000..3517fc2 --- /dev/null +++ b/simulations/differential_taper/differential.kicad_pro @@ -0,0 +1,647 @@ +{ + "board": { + "3dviewports": [], + "design_settings": { + "defaults": { + "apply_defaults_to_fp_fields": false, + "apply_defaults_to_fp_shapes": false, + "apply_defaults_to_fp_text": false, + "board_outline_line_width": 0.1, + "copper_line_width": 0.2, + "copper_text_italic": false, + "copper_text_size_h": 1.5, + "copper_text_size_v": 1.5, + "copper_text_thickness": 0.3, + "copper_text_upright": false, + "courtyard_line_width": 0.05, + "dimension_precision": 4, + "dimension_units": 3, + "dimensions": { + "arrow_length": 1270000, + "extension_offset": 500000, + "keep_text_aligned": true, + "suppress_zeroes": false, + "text_position": 0, + "units_format": 1 + }, + "fab_line_width": 0.1, + "fab_text_italic": false, + "fab_text_size_h": 1.0, + "fab_text_size_v": 1.0, + "fab_text_thickness": 0.15, + "fab_text_upright": false, + "other_line_width": 0.15, + "other_text_italic": false, + "other_text_size_h": 1.0, + "other_text_size_v": 1.0, + "other_text_thickness": 0.15, + "other_text_upright": false, + "pads": { + "drill": 0.0, + "height": 0.2, + "width": 0.2 + }, + "silk_line_width": 0.15, + "silk_text_italic": false, + "silk_text_size_h": 1.0, + "silk_text_size_v": 1.0, + "silk_text_thickness": 0.15, + "silk_text_upright": false, + "zones": { + "45_degree_only": false, + "min_clearance": 0.1 + } + }, + "diff_pair_dimensions": [ + { + "gap": 0.0, + "via_gap": 0.0, + "width": 0.0 + }, + { + "gap": 0.15, + "via_gap": 0.25, + "width": 0.15 + } + ], + "drc_exclusions": [], + "meta": { + "version": 2 + }, + "rule_severities": { + "annular_width": "error", + "clearance": "error", + "connection_width": "warning", + "copper_edge_clearance": "error", + "copper_sliver": "warning", + "courtyards_overlap": "error", + "diff_pair_gap_out_of_range": "error", + "diff_pair_uncoupled_length_too_long": "error", + "drill_out_of_range": "error", + "duplicate_footprints": "warning", + "extra_footprint": "warning", + "footprint": "error", + "footprint_symbol_mismatch": "warning", + "footprint_type_mismatch": "error", + "hole_clearance": "error", + "hole_near_hole": "error", + "holes_co_located": "warning", + "invalid_outline": "error", + "isolated_copper": "warning", + "item_on_disabled_layer": "error", + "items_not_allowed": "error", + "length_out_of_range": "error", + "lib_footprint_issues": "warning", + "lib_footprint_mismatch": "warning", + "malformed_courtyard": "error", + "microvia_drill_out_of_range": "error", + "missing_courtyard": "ignore", + "missing_footprint": "warning", + "net_conflict": "warning", + "npth_inside_courtyard": "ignore", + "padstack": "error", + "pth_inside_courtyard": "ignore", + "shorting_items": "error", + "silk_edge_clearance": "warning", + "silk_over_copper": "warning", + "silk_overlap": "warning", + "skew_out_of_range": "error", + "solder_mask_bridge": "error", + "starved_thermal": "error", + "text_height": "warning", + "text_thickness": "warning", + "through_hole_pad_without_hole": "error", + "too_many_vias": "error", + "track_dangling": "warning", + "track_width": "error", + "tracks_crossing": "error", + "unconnected_items": "error", + "unresolved_variable": "error", + "via_dangling": "warning", + "zones_intersect": "error" + }, + "rules": { + "allow_blind_buried_vias": false, + "allow_microvias": false, + "max_error": 0.005, + "min_clearance": 0.01, + "min_connection": 0.0, + "min_copper_edge_clearance": 0.0, + "min_hole_clearance": 0.01, + "min_hole_to_hole": 0.1, + "min_microvia_diameter": 0.2, + "min_microvia_drill": 0.1, + "min_resolved_spokes": 2, + "min_silk_clearance": 0.0, + "min_text_height": 0.8, + "min_text_thickness": 0.08, + "min_through_hole_diameter": 0.1, + "min_track_width": 0.05, + "min_via_annular_width": 0.05, + "min_via_diameter": 0.03, + "solder_mask_clearance": 0.0, + "solder_mask_min_width": 0.0, + "solder_mask_to_copper_clearance": 0.0, + "use_height_for_length_calcs": true + }, + "teardrop_options": [ + { + "td_onpadsmd": true, + "td_onroundshapesonly": false, + "td_ontrackend": false, + "td_onviapad": true + } + ], + "teardrop_parameters": [ + { + "td_allow_use_two_tracks": true, + "td_curve_segcount": 0, + "td_height_ratio": 1.0, + "td_length_ratio": 0.5, + "td_maxheight": 2.0, + "td_maxlen": 1.0, + "td_on_pad_in_zone": false, + "td_target_name": "td_round_shape", + "td_width_to_size_filter_ratio": 0.9 + }, + { + "td_allow_use_two_tracks": true, + "td_curve_segcount": 0, + "td_height_ratio": 1.0, + "td_length_ratio": 0.5, + "td_maxheight": 2.0, + "td_maxlen": 1.0, + "td_on_pad_in_zone": false, + "td_target_name": "td_rect_shape", + "td_width_to_size_filter_ratio": 0.9 + }, + { + "td_allow_use_two_tracks": true, + "td_curve_segcount": 0, + "td_height_ratio": 1.0, + "td_length_ratio": 0.5, + "td_maxheight": 2.0, + "td_maxlen": 1.0, + "td_on_pad_in_zone": false, + "td_target_name": "td_track_end", + "td_width_to_size_filter_ratio": 0.9 + } + ], + "track_widths": [ + 0.0, + 0.1, + 0.2, + 0.45, + 0.5, + 2.0 + ], + "tuning_pattern_settings": { + "diff_pair_defaults": { + "corner_radius_percentage": 80, + "corner_style": 1, + "max_amplitude": 1.0, + "min_amplitude": 0.2, + "single_sided": false, + "spacing": 1.0 + }, + "diff_pair_skew_defaults": { + "corner_radius_percentage": 80, + "corner_style": 1, + "max_amplitude": 1.0, + "min_amplitude": 0.2, + "single_sided": false, + "spacing": 0.6 + }, + "single_track_defaults": { + "corner_radius_percentage": 80, + "corner_style": 1, + "max_amplitude": 1.0, + "min_amplitude": 0.2, + "single_sided": false, + "spacing": 0.6 + } + }, + "via_dimensions": [ + { + "diameter": 0.0, + "drill": 0.0 + }, + { + "diameter": 0.2, + "drill": 0.15 + }, + { + "diameter": 0.35, + "drill": 0.2 + }, + { + "diameter": 0.45, + "drill": 0.3 + } + ], + "zones_allow_external_fillets": false, + "zones_use_no_outline": true + }, + "ipc2581": { + "dist": "", + "distpn": "", + "internal_id": "", + "mfg": "", + "mpn": "" + }, + "layer_presets": [], + "viewports": [] + }, + "boards": [], + "cvpcb": { + "equivalence_files": [] + }, + "erc": { + "erc_exclusions": [], + "meta": { + "version": 0 + }, + "pin_map": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 2, + 0, + 1, + 0, + 0, + 1, + 0, + 2, + 2, + 2, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 2 + ], + [ + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 2, + 1, + 1, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2 + ], + [ + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 2 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 2 + ], + [ + 0, + 2, + 1, + 2, + 0, + 0, + 1, + 0, + 2, + 2, + 2, + 2 + ], + [ + 0, + 2, + 0, + 1, + 0, + 0, + 1, + 0, + 2, + 0, + 0, + 2 + ], + [ + 0, + 2, + 1, + 1, + 0, + 0, + 1, + 0, + 2, + 0, + 0, + 2 + ], + [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ] + ], + "rule_severities": { + "bus_definition_conflict": "error", + "bus_entry_needed": "error", + "bus_to_bus_conflict": "error", + "bus_to_net_conflict": "error", + "conflicting_netclasses": "error", + "different_unit_footprint": "error", + "different_unit_net": "error", + "duplicate_reference": "error", + "duplicate_sheet_names": "error", + "endpoint_off_grid": "warning", + "extra_units": "error", + "global_label_dangling": "warning", + "hier_label_mismatch": "error", + "label_dangling": "error", + "lib_symbol_issues": "warning", + "missing_bidi_pin": "warning", + "missing_input_pin": "warning", + "missing_power_pin": "error", + "missing_unit": "warning", + "multiple_net_names": "warning", + "net_not_bus_member": "warning", + "no_connect_connected": "warning", + "no_connect_dangling": "warning", + "pin_not_connected": "error", + "pin_not_driven": "error", + "pin_to_pin": "warning", + "power_pin_not_driven": "error", + "similar_labels": "warning", + "simulation_model_issue": "ignore", + "unannotated": "error", + "unit_value_mismatch": "error", + "unresolved_variable": "error", + "wire_dangling": "error" + } + }, + "libraries": { + "pinned_footprint_libs": [], + "pinned_symbol_libs": [] + }, + "meta": { + "filename": "differential.kicad_pro", + "version": 1 + }, + "net_settings": { + "classes": [ + { + "bus_width": 12, + "clearance": 0.15, + "diff_pair_gap": 0.25, + "diff_pair_via_gap": 0.25, + "diff_pair_width": 0.2, + "line_style": 0, + "microvia_diameter": 0.3, + "microvia_drill": 0.1, + "name": "Default", + "pcb_color": "rgba(0, 0, 0, 0.000)", + "schematic_color": "rgba(0, 0, 0, 0.000)", + "track_width": 0.25, + "via_diameter": 0.8, + "via_drill": 0.4, + "wire_width": 6 + } + ], + "meta": { + "version": 3 + }, + "net_colors": null, + "netclass_assignments": null, + "netclass_patterns": [] + }, + "pcbnew": { + "last_paths": { + "gencad": "", + "idf": "", + "netlist": "", + "plot": "fab", + "pos_files": "fab", + "specctra_dsn": "", + "step": "", + "svg": "", + "vrml": "" + }, + "page_layout_descr_file": "" + }, + "schematic": { + "annotate_start_num": 0, + "bom_export_filename": "", + "bom_fmt_presets": [], + "bom_fmt_settings": { + "field_delimiter": ",", + "keep_line_breaks": false, + "keep_tabs": false, + "name": "CSV", + "ref_delimiter": ",", + "ref_range_delimiter": "", + "string_delimiter": "\"" + }, + "bom_presets": [], + "bom_settings": { + "exclude_dnp": false, + "fields_ordered": [ + { + "group_by": false, + "label": "Reference", + "name": "Reference", + "show": true + }, + { + "group_by": true, + "label": "Value", + "name": "Value", + "show": true + }, + { + "group_by": false, + "label": "Datasheet", + "name": "Datasheet", + "show": true + }, + { + "group_by": false, + "label": "Footprint", + "name": "Footprint", + "show": true + }, + { + "group_by": false, + "label": "Qty", + "name": "${QUANTITY}", + "show": true + }, + { + "group_by": true, + "label": "DNP", + "name": "${DNP}", + "show": true + }, + { + "group_by": false, + "label": "#", + "name": "${ITEM_NUMBER}", + "show": false + }, + { + "group_by": false, + "label": "Description", + "name": "Description", + "show": false + } + ], + "filter_string": "", + "group_symbols": true, + "name": "", + "sort_asc": true, + "sort_field": "Reference" + }, + "connection_grid_size": 50.0, + "drawing": { + "dashed_lines_dash_length_ratio": 12.0, + "dashed_lines_gap_length_ratio": 3.0, + "default_line_thickness": 6.0, + "default_text_size": 50.0, + "field_names": [], + "intersheets_ref_own_page": false, + "intersheets_ref_prefix": "", + "intersheets_ref_short": false, + "intersheets_ref_show": false, + "intersheets_ref_suffix": "", + "junction_size_choice": 3, + "label_size_ratio": 0.375, + "operating_point_overlay_i_precision": 3, + "operating_point_overlay_i_range": "~A", + "operating_point_overlay_v_precision": 3, + "operating_point_overlay_v_range": "~V", + "overbar_offset_ratio": 1.23, + "pin_symbol_size": 25.0, + "text_offset_ratio": 0.15 + }, + "legacy_lib_dir": "", + "legacy_lib_list": [], + "meta": { + "version": 1 + }, + "net_format_name": "", + "ngspice": { + "fix_include_paths": true, + "fix_passive_vals": false, + "meta": { + "version": 0 + }, + "model_mode": 0, + "workbook_filename": "" + }, + "page_layout_descr_file": "", + "plot_directory": "", + "spice_adjust_passive_values": false, + "spice_current_sheet_as_root": false, + "spice_external_command": "spice \"%I\"", + "spice_model_current_sheet_as_root": true, + "spice_save_all_currents": false, + "spice_save_all_dissipations": false, + "spice_save_all_voltages": false, + "subpart_first_id": 65, + "subpart_id_separator": 0 + }, + "sheets": [ + [ + "653b107b-a2dc-425a-91a9-9d549617e849", + "Root" + ] + ], + "text_variables": {} +} diff --git a/simulations/differential_taper/differential.kicad_sch b/simulations/differential_taper/differential.kicad_sch new file mode 100644 index 0000000..4109ca6 --- /dev/null +++ b/simulations/differential_taper/differential.kicad_sch @@ -0,0 +1,919 @@ +(kicad_sch + (version 20231120) + (generator "eeschema") + (generator_version "8.0") + (uuid "653b107b-a2dc-425a-91a9-9d549617e849") + (paper "A4") + (lib_symbols + (symbol "Connector:TestPoint" + (pin_numbers hide) + (pin_names + (offset 0.762) hide) + (exclude_from_sim no) + (in_bom yes) + (on_board yes) + (property "Reference" "TP" + (at 0 6.858 0) + (effects + (font + (size 1.27 1.27) + ) + ) + ) + (property "Value" "TestPoint" + (at 0 5.08 0) + (effects + (font + (size 1.27 1.27) + ) + ) + ) + (property "Footprint" "" + (at 5.08 0 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Datasheet" "~" + (at 5.08 0 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Description" "test point" + (at 0 0 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "ki_keywords" "test point tp" + (at 0 0 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "ki_fp_filters" "Pin* Test*" + (at 0 0 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (symbol "TestPoint_0_1" + (circle + (center 0 3.302) + (radius 0.762) + (stroke + (width 0) + (type default) + ) + (fill + (type none) + ) + ) + ) + (symbol "TestPoint_1_1" + (pin passive line + (at 0 0 90) + (length 2.54) + (name "1" + (effects + (font + (size 1.27 1.27) + ) + ) + ) + (number "1" + (effects + (font + (size 1.27 1.27) + ) + ) + ) + ) + ) + ) + (symbol "power:GND" + (power) + (pin_numbers hide) + (pin_names + (offset 0) hide) + (exclude_from_sim no) + (in_bom yes) + (on_board yes) + (property "Reference" "#PWR" + (at 0 -6.35 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Value" "GND" + (at 0 -3.81 0) + (effects + (font + (size 1.27 1.27) + ) + ) + ) + (property "Footprint" "" + (at 0 0 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Datasheet" "" + (at 0 0 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Description" "Power symbol creates a global label with name \"GND\" , ground" + (at 0 0 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "ki_keywords" "global power" + (at 0 0 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (symbol "GND_0_1" + (polyline + (pts + (xy 0 0) (xy 0 -1.27) (xy 1.27 -1.27) (xy 0 -2.54) (xy -1.27 -1.27) (xy 0 -1.27) + ) + (stroke + (width 0) + (type default) + ) + (fill + (type none) + ) + ) + ) + (symbol "GND_1_1" + (pin power_in line + (at 0 0 270) + (length 0) + (name "~" + (effects + (font + (size 1.27 1.27) + ) + ) + ) + (number "1" + (effects + (font + (size 1.27 1.27) + ) + ) + ) + ) + ) + ) + ) + (wire + (pts + (xy 139.7 71.12) (xy 139.7 134.62) + ) + (stroke + (width 0) + (type default) + ) + (uuid "3b6da432-4095-455d-a277-314b8b733ebb") + ) + (wire + (pts + (xy 113.03 71.12) (xy 113.03 134.62) + ) + (stroke + (width 0) + (type default) + ) + (uuid "446d0b20-336e-462b-8104-ad3d49cc2236") + ) + (label "A-" + (at 139.7 107.95 90) + (fields_autoplaced yes) + (effects + (font + (size 1.27 1.27) + ) + (justify left bottom) + ) + (uuid "81d7fed4-888c-452d-99b9-f8402e0088c2") + ) + (label "A+" + (at 113.03 107.95 90) + (fields_autoplaced yes) + (effects + (font + (size 1.27 1.27) + ) + (justify left bottom) + ) + (uuid "8ce19c4c-3554-4965-a729-2d297923301c") + ) + (symbol + (lib_id "power:GND") + (at 167.64 71.12 0) + (unit 1) + (exclude_from_sim no) + (in_bom yes) + (on_board yes) + (dnp no) + (fields_autoplaced yes) + (uuid "1cc7ae10-9a95-4ee7-8a1f-c3df332f272c") + (property "Reference" "#PWR01" + (at 167.64 77.47 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Value" "GND" + (at 167.64 76.2 0) + (effects + (font + (size 1.27 1.27) + ) + ) + ) + (property "Footprint" "" + (at 167.64 71.12 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Datasheet" "" + (at 167.64 71.12 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Description" "Power symbol creates a global label with name \"GND\" , ground" + (at 167.64 71.12 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (pin "1" + (uuid "3743cdce-a63e-413a-a390-dc5c0ff0e60b") + ) + (instances + (project "" + (path "/653b107b-a2dc-425a-91a9-9d549617e849" + (reference "#PWR01") + (unit 1) + ) + ) + ) + ) + (symbol + (lib_id "power:GND") + (at 113.03 144.78 180) + (unit 1) + (exclude_from_sim no) + (in_bom yes) + (on_board yes) + (dnp no) + (fields_autoplaced yes) + (uuid "62bad711-22da-4fc3-89e1-128b7325a53a") + (property "Reference" "#PWR04" + (at 113.03 138.43 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Value" "GND" + (at 113.03 139.7 0) + (effects + (font + (size 1.27 1.27) + ) + ) + ) + (property "Footprint" "" + (at 113.03 144.78 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Datasheet" "" + (at 113.03 144.78 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Description" "Power symbol creates a global label with name \"GND\" , ground" + (at 113.03 144.78 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (pin "1" + (uuid "81c7cc36-a822-42ff-bad8-2a6789fa558d") + ) + (instances + (project "differential" + (path "/653b107b-a2dc-425a-91a9-9d549617e849" + (reference "#PWR04") + (unit 1) + ) + ) + ) + ) + (symbol + (lib_id "power:GND") + (at 113.03 63.5 0) + (unit 1) + (exclude_from_sim no) + (in_bom yes) + (on_board yes) + (dnp no) + (fields_autoplaced yes) + (uuid "688f1587-614f-464b-b0f7-f421904af803") + (property "Reference" "#PWR02" + (at 113.03 69.85 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Value" "GND" + (at 113.03 68.58 0) + (effects + (font + (size 1.27 1.27) + ) + ) + ) + (property "Footprint" "" + (at 113.03 63.5 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Datasheet" "" + (at 113.03 63.5 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Description" "Power symbol creates a global label with name \"GND\" , ground" + (at 113.03 63.5 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (pin "1" + (uuid "742506af-0eef-4ca4-b520-4cef8166d0f0") + ) + (instances + (project "differential" + (path "/653b107b-a2dc-425a-91a9-9d549617e849" + (reference "#PWR02") + (unit 1) + ) + ) + ) + ) + (symbol + (lib_id "power:GND") + (at 139.7 144.78 180) + (unit 1) + (exclude_from_sim no) + (in_bom yes) + (on_board yes) + (dnp no) + (fields_autoplaced yes) + (uuid "8d984e93-fd85-4211-8dd1-5d2f929444d1") + (property "Reference" "#PWR05" + (at 139.7 138.43 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Value" "GND" + (at 139.7 139.7 0) + (effects + (font + (size 1.27 1.27) + ) + ) + ) + (property "Footprint" "" + (at 139.7 144.78 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Datasheet" "" + (at 139.7 144.78 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Description" "Power symbol creates a global label with name \"GND\" , ground" + (at 139.7 144.78 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (pin "1" + (uuid "2d361f3f-3b3d-4f89-af0f-e60e143711dc") + ) + (instances + (project "differential" + (path "/653b107b-a2dc-425a-91a9-9d549617e849" + (reference "#PWR05") + (unit 1) + ) + ) + ) + ) + (symbol + (lib_id "Connector:TestPoint") + (at 113.03 63.5 0) + (unit 1) + (exclude_from_sim no) + (in_bom yes) + (on_board yes) + (dnp no) + (fields_autoplaced yes) + (uuid "a5c92765-00ff-4693-b703-7a5c7fedd439") + (property "Reference" "SP0" + (at 115.57 58.9279 0) + (effects + (font + (size 1.27 1.27) + ) + (justify left) + ) + ) + (property "Value" "Simulation_Port" + (at 115.57 61.4679 0) + (effects + (font + (size 1.27 1.27) + ) + (justify left) + ) + ) + (property "Footprint" "simulation_port:pad_0.15mm" + (at 118.11 63.5 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Datasheet" "~" + (at 118.11 63.5 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Description" "test point" + (at 113.03 63.5 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (pin "1" + (uuid "d530ad7c-9422-445b-987c-0323841078f5") + ) + (instances + (project "differential" + (path "/653b107b-a2dc-425a-91a9-9d549617e849" + (reference "SP0") + (unit 1) + ) + ) + ) + ) + (symbol + (lib_id "power:GND") + (at 139.7 63.5 0) + (unit 1) + (exclude_from_sim no) + (in_bom yes) + (on_board yes) + (dnp no) + (fields_autoplaced yes) + (uuid "be0b4ca7-8c8d-4487-9e7d-1215ffac5844") + (property "Reference" "#PWR03" + (at 139.7 69.85 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Value" "GND" + (at 139.7 68.58 0) + (effects + (font + (size 1.27 1.27) + ) + ) + ) + (property "Footprint" "" + (at 139.7 63.5 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Datasheet" "" + (at 139.7 63.5 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Description" "Power symbol creates a global label with name \"GND\" , ground" + (at 139.7 63.5 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (pin "1" + (uuid "b3299ac1-2918-4f5e-ab6a-1658e10d1158") + ) + (instances + (project "differential" + (path "/653b107b-a2dc-425a-91a9-9d549617e849" + (reference "#PWR03") + (unit 1) + ) + ) + ) + ) + (symbol + (lib_id "Connector:TestPoint") + (at 113.03 144.78 180) + (unit 1) + (exclude_from_sim no) + (in_bom yes) + (on_board yes) + (dnp no) + (fields_autoplaced yes) + (uuid "bf13c176-fb4a-4e98-a210-6ed5c67779c6") + (property "Reference" "SP1" + (at 115.57 146.8119 0) + (effects + (font + (size 1.27 1.27) + ) + (justify right) + ) + ) + (property "Value" "Simulation_Port" + (at 115.57 149.3519 0) + (effects + (font + (size 1.27 1.27) + ) + (justify right) + ) + ) + (property "Footprint" "simulation_port:pad_0.15mm" + (at 107.95 144.78 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Datasheet" "~" + (at 107.95 144.78 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Description" "test point" + (at 113.03 144.78 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (pin "1" + (uuid "8f74edbe-5d33-49b0-ad4f-024faa96170e") + ) + (instances + (project "differential" + (path "/653b107b-a2dc-425a-91a9-9d549617e849" + (reference "SP1") + (unit 1) + ) + ) + ) + ) + (symbol + (lib_id "Connector:TestPoint") + (at 139.7 144.78 180) + (unit 1) + (exclude_from_sim no) + (in_bom yes) + (on_board yes) + (dnp no) + (fields_autoplaced yes) + (uuid "d206b72b-f746-46b7-b758-20959411d48d") + (property "Reference" "SP3" + (at 142.24 146.8119 0) + (effects + (font + (size 1.27 1.27) + ) + (justify right) + ) + ) + (property "Value" "Simulation_Port" + (at 142.24 149.3519 0) + (effects + (font + (size 1.27 1.27) + ) + (justify right) + ) + ) + (property "Footprint" "simulation_port:pad_0.15mm" + (at 134.62 144.78 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Datasheet" "~" + (at 134.62 144.78 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Description" "test point" + (at 139.7 144.78 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (pin "1" + (uuid "4847b432-bcad-48aa-9a73-c56c664a3782") + ) + (instances + (project "differential" + (path "/653b107b-a2dc-425a-91a9-9d549617e849" + (reference "SP3") + (unit 1) + ) + ) + ) + ) + (symbol + (lib_id "Connector:TestPoint") + (at 167.64 71.12 0) + (unit 1) + (exclude_from_sim no) + (in_bom yes) + (on_board yes) + (dnp no) + (fields_autoplaced yes) + (uuid "daab5a74-b160-4e51-ae63-89f9e7a355be") + (property "Reference" "GND1" + (at 170.18 66.5479 0) + (effects + (font + (size 1.27 1.27) + ) + (justify left) + ) + ) + (property "Value" "Ground" + (at 170.18 69.0879 0) + (effects + (font + (size 1.27 1.27) + ) + (justify left) + ) + ) + (property "Footprint" "simulation_port:pad_0.1mm" + (at 172.72 71.12 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Datasheet" "~" + (at 172.72 71.12 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Description" "test point" + (at 167.64 71.12 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (pin "1" + (uuid "1d29df0a-d000-4c81-982c-9151e92b5033") + ) + (instances + (project "differential" + (path "/653b107b-a2dc-425a-91a9-9d549617e849" + (reference "GND1") + (unit 1) + ) + ) + ) + ) + (symbol + (lib_id "Connector:TestPoint") + (at 139.7 63.5 0) + (unit 1) + (exclude_from_sim no) + (in_bom yes) + (on_board yes) + (dnp no) + (fields_autoplaced yes) + (uuid "ed3a6216-814d-4795-8ecd-7eebfc55452a") + (property "Reference" "SP2" + (at 142.24 58.9279 0) + (effects + (font + (size 1.27 1.27) + ) + (justify left) + ) + ) + (property "Value" "Simulation_Port" + (at 142.24 61.4679 0) + (effects + (font + (size 1.27 1.27) + ) + (justify left) + ) + ) + (property "Footprint" "simulation_port:pad_0.15mm" + (at 144.78 63.5 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Datasheet" "~" + (at 144.78 63.5 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (property "Description" "test point" + (at 139.7 63.5 0) + (effects + (font + (size 1.27 1.27) + ) + (hide yes) + ) + ) + (pin "1" + (uuid "9febd859-cc8e-4bd5-865e-1868c9d55827") + ) + (instances + (project "differential" + (path "/653b107b-a2dc-425a-91a9-9d549617e849" + (reference "SP2") + (unit 1) + ) + ) + ) + ) + (sheet_instances + (path "/" + (page "1") + ) + ) +) diff --git a/simulations/differential_taper/fab/differential-B_Cu.gbr b/simulations/differential_taper/fab/differential-B_Cu.gbr new file mode 100644 index 0000000..993a717 --- /dev/null +++ b/simulations/differential_taper/fab/differential-B_Cu.gbr @@ -0,0 +1,77 @@ +%TF.GenerationSoftware,KiCad,Pcbnew,8.0.5*% +%TF.CreationDate,2025-02-04T16:35:11+11:00*% +%TF.ProjectId,differential,64696666-6572-4656-9e74-69616c2e6b69,rev?*% +%TF.SameCoordinates,PX8d24d00PY7b06240*% +%TF.FileFunction,Copper,L4,Bot*% +%TF.FilePolarity,Positive*% +%FSLAX46Y46*% +G04 Gerber Fmt 4.6, Leading zero omitted, Abs format (unit mm)* +G04 Created by KiCad (PCBNEW 8.0.5) date 2025-02-04 16:35:11* +%MOMM*% +%LPD*% +G01* +G04 APERTURE LIST* +G04 Aperture macros list* +%AMRoundRect* +0 Rectangle with rounded corners* +0 $1 Rounding radius* +0 $2 $3 $4 $5 $6 $7 $8 $9 X,Y pos of 4 corners* +0 Add a 4 corners polygon primitive as box body* +4,1,4,$2,$3,$4,$5,$6,$7,$8,$9,$2,$3,0* +0 Add four circle primitives for the rounded corners* +1,1,$1+$1,$2,$3* +1,1,$1+$1,$4,$5* +1,1,$1+$1,$6,$7* +1,1,$1+$1,$8,$9* +0 Add four rect primitives between the rounded corners* +20,1,$1+$1,$2,$3,$4,$5,0* +20,1,$1+$1,$4,$5,$6,$7,0* +20,1,$1+$1,$6,$7,$8,$9,0* +20,1,$1+$1,$8,$9,$2,$3,0*% +G04 Aperture macros list end* +%TA.AperFunction,SMDPad,CuDef*% +%ADD10RoundRect,0.015000X0.060000X0.060000X-0.060000X0.060000X-0.060000X-0.060000X0.060000X-0.060000X0*% +%TD*% +%TA.AperFunction,ViaPad*% +%ADD11C,0.200000*% +%TD*% +G04 APERTURE END LIST* +D10* +%TO.P,SP3,1,1*% +%TO.N,GND*% +X830000Y500000D03* +%TD*% +%TO.P,SP1,1,1*% +%TO.N,GND*% +X530000Y500000D03* +%TD*% +D11* +%TO.N,GND*% +X200000Y1800000D03* +X1100000Y1800000D03* +X200000Y300000D03* +X1100000Y300000D03* +X635000Y1832500D03* +X635000Y200000D03* +%TD*% +%TA.AperFunction,Conductor*% +%TO.N,GND*% +G36* +X1250648Y535648D02* +G01* +X1265000Y501000D01* +X1265000Y124000D01* +X1250648Y89352D01* +X1216000Y75000D01* +X154000Y75000D01* +X119352Y89352D01* +X105000Y124000D01* +X105000Y501000D01* +X119352Y535648D01* +X154000Y550000D01* +X1216000Y550000D01* +X1250648Y535648D01* +G37* +%TD.AperFunction*% +%TD*% +M02* diff --git a/simulations/differential_taper/fab/differential-Edge_Cuts.gbr b/simulations/differential_taper/fab/differential-Edge_Cuts.gbr new file mode 100644 index 0000000..1428c58 --- /dev/null +++ b/simulations/differential_taper/fab/differential-Edge_Cuts.gbr @@ -0,0 +1,23 @@ +%TF.GenerationSoftware,KiCad,Pcbnew,8.0.5*% +%TF.CreationDate,2025-02-04T16:35:11+11:00*% +%TF.ProjectId,differential,64696666-6572-4656-9e74-69616c2e6b69,rev?*% +%TF.SameCoordinates,PX8d24d00PY7b06240*% +%TF.FileFunction,Profile,NP*% +%FSLAX46Y46*% +G04 Gerber Fmt 4.6, Leading zero omitted, Abs format (unit mm)* +G04 Created by KiCad (PCBNEW 8.0.5) date 2025-02-04 16:35:11* +%MOMM*% +%LPD*% +G01* +G04 APERTURE LIST* +%TA.AperFunction,Profile*% +%ADD10C,0.100000*% +%TD*% +G04 APERTURE END LIST* +D10* +X-5000Y2084800D02* +X1335000Y2084800D01* +X1335000Y-5200D01* +X-5000Y-5200D01* +X-5000Y2084800D01* +M02* diff --git a/simulations/differential_taper/fab/differential-F_Cu.gbr b/simulations/differential_taper/fab/differential-F_Cu.gbr new file mode 100644 index 0000000..8106ab9 --- /dev/null +++ b/simulations/differential_taper/fab/differential-F_Cu.gbr @@ -0,0 +1,85 @@ +%TF.GenerationSoftware,KiCad,Pcbnew,8.0.5*% +%TF.CreationDate,2025-02-04T16:35:11+11:00*% +%TF.ProjectId,differential,64696666-6572-4656-9e74-69616c2e6b69,rev?*% +%TF.SameCoordinates,PX8d24d00PY7b06240*% +%TF.FileFunction,Copper,L1,Top*% +%TF.FilePolarity,Positive*% +%FSLAX46Y46*% +G04 Gerber Fmt 4.6, Leading zero omitted, Abs format (unit mm)* +G04 Created by KiCad (PCBNEW 8.0.5) date 2025-02-04 16:35:11* +%MOMM*% +%LPD*% +G01* +G04 APERTURE LIST* +G04 Aperture macros list* +%AMRoundRect* +0 Rectangle with rounded corners* +0 $1 Rounding radius* +0 $2 $3 $4 $5 $6 $7 $8 $9 X,Y pos of 4 corners* +0 Add a 4 corners polygon primitive as box body* +4,1,4,$2,$3,$4,$5,$6,$7,$8,$9,$2,$3,0* +0 Add four circle primitives for the rounded corners* +1,1,$1+$1,$2,$3* +1,1,$1+$1,$4,$5* +1,1,$1+$1,$6,$7* +1,1,$1+$1,$8,$9* +0 Add four rect primitives between the rounded corners* +20,1,$1+$1,$2,$3,$4,$5,0* +20,1,$1+$1,$4,$5,$6,$7,0* +20,1,$1+$1,$6,$7,$8,$9,0* +20,1,$1+$1,$8,$9,$2,$3,0*% +G04 Aperture macros list end* +%TA.AperFunction,SMDPad,CuDef*% +%ADD10RoundRect,0.015000X0.060000X0.060000X-0.060000X0.060000X-0.060000X-0.060000X0.060000X-0.060000X0*% +%TD*% +%TA.AperFunction,SMDPad,CuDef*% +%ADD11RoundRect,0.010000X-0.040000X-0.040000X0.040000X-0.040000X0.040000X0.040000X-0.040000X0.040000X0*% +%TD*% +%TA.AperFunction,ViaPad*% +%ADD12C,0.200000*% +%TD*% +G04 APERTURE END LIST* +D10* +%TO.P,SP2,1,1*% +%TO.N,GND*% +X830000Y1525001D03* +%TD*% +%TO.P,SP0,1,1*% +%TO.N,GND*% +X530000Y1525001D03* +%TD*% +D11* +%TO.P,GND1,1,1*% +%TO.N,GND*% +X400000Y1882500D03* +%TD*% +D12* +%TO.N,GND*% +X200000Y1800000D03* +X1100000Y1800000D03* +X200000Y300000D03* +X1100000Y300000D03* +X635000Y1832500D03* +X635000Y200000D03* +%TD*% +%TA.AperFunction,Conductor*% +%TO.N,GND*% +G36* +X1250648Y1968148D02* +G01* +X1265000Y1933500D01* +X1265000Y1531500D01* +X1250648Y1496852D01* +X1216000Y1482500D01* +X159000Y1482500D01* +X124352Y1496852D01* +X110000Y1531500D01* +X110000Y1933500D01* +X124352Y1968148D01* +X159000Y1982500D01* +X1216000Y1982500D01* +X1250648Y1968148D01* +G37* +%TD.AperFunction*% +%TD*% +M02* diff --git a/simulations/differential_taper/fab/differential-In1_Cu.gbr b/simulations/differential_taper/fab/differential-In1_Cu.gbr new file mode 100644 index 0000000..6c08013 --- /dev/null +++ b/simulations/differential_taper/fab/differential-In1_Cu.gbr @@ -0,0 +1,200 @@ +%TF.GenerationSoftware,KiCad,Pcbnew,8.0.5*% +%TF.CreationDate,2025-02-04T16:35:11+11:00*% +%TF.ProjectId,differential,64696666-6572-4656-9e74-69616c2e6b69,rev?*% +%TF.SameCoordinates,PX8d24d00PY7b06240*% +%TF.FileFunction,Copper,L2,Inr*% +%TF.FilePolarity,Positive*% +%FSLAX46Y46*% +G04 Gerber Fmt 4.6, Leading zero omitted, Abs format (unit mm)* +G04 Created by KiCad (PCBNEW 8.0.5) date 2025-02-04 16:35:11* +%MOMM*% +%LPD*% +G01* +G04 APERTURE LIST* +%TA.AperFunction,Conductor*% +%ADD10C,0.005000*% +%TD*% +%TA.AperFunction,ViaPad*% +%ADD11C,0.200000*% +%TD*% +%TA.AperFunction,Conductor*% +%ADD12C,0.150000*% +%TD*% +G04 APERTURE END LIST* +%TO.N,A+*% +D10* +X457500Y572500D02* +X602500Y572500D01* +X602500Y427500D01* +X457500Y427500D01* +X457500Y572500D01* +%TA.AperFunction,Conductor*% +G36* +X457500Y572500D02* +G01* +X602500Y572500D01* +X602500Y427500D01* +X457500Y427500D01* +X457500Y572500D01* +G37* +%TD.AperFunction*% +%TO.N,A-*% +X757500Y572500D02* +X902500Y572500D01* +X902500Y427500D01* +X757500Y427500D01* +X757500Y572500D01* +%TA.AperFunction,Conductor*% +G36* +X757500Y572500D02* +G01* +X902500Y572500D01* +X902500Y427500D01* +X757500Y427500D01* +X757500Y572500D01* +G37* +%TD.AperFunction*% +X757500Y1597501D02* +X902500Y1597501D01* +X902500Y1452501D01* +X757500Y1452501D01* +X757500Y1597501D01* +%TA.AperFunction,Conductor*% +G36* +X757500Y1597501D02* +G01* +X902500Y1597501D01* +X902500Y1452501D01* +X757500Y1452501D01* +X757500Y1597501D01* +G37* +%TD.AperFunction*% +%TO.N,A+*% +X457500Y1597501D02* +X602500Y1597501D01* +X602500Y1452501D01* +X457500Y1452501D01* +X457500Y1597501D01* +%TA.AperFunction,Conductor*% +G36* +X457500Y1597501D02* +G01* +X602500Y1597501D01* +X602500Y1452501D01* +X457500Y1452501D01* +X457500Y1597501D01* +G37* +%TD.AperFunction*% +%TD*% +D11* +%TO.N,GND*% +X200000Y1800000D03* +X1100000Y1800000D03* +X200000Y300000D03* +X1100000Y300000D03* +X635000Y1832500D03* +X635000Y200000D03* +%TD*% +D12* +%TO.N,A-*% +X830001Y1525000D02* +X830001Y500001D01* +%TO.N,A+*% +X529999Y1525000D02* +X529999Y500001D01* +%TO.N,A-*% +X830001Y500001D02* +X830000Y500000D01* +X830000Y1525001D02* +X830001Y1525000D01* +%TO.N,A+*% +X529999Y500001D02* +X530000Y500000D01* +X530000Y1525001D02* +X529999Y1525000D01* +%TD*% +%TA.AperFunction,Conductor*% +%TO.N,GND*% +G36* +X1171864Y1989948D02* +G01* +X1230054Y1971038D01* +X1266015Y1921536D01* +X1270859Y1890948D01* +X1270859Y163948D01* +X1251952Y105757D01* +X1202452Y69793D01* +X1171854Y64948D01* +X198995Y64996D01* +X140805Y83906D01* +X104844Y133408D01* +X100000Y163996D01* +X100000Y1579290D01* +X304498Y1579290D01* +X304498Y1468623D01* +X304499Y1468614D01* +X304499Y552844D01* +X304498Y552830D01* +X304498Y443628D01* +X304500Y443615D01* +X304500Y397066D01* +X327793Y340833D01* +X370833Y297793D01* +X427066Y274500D01* +X427067Y274500D01* +X632932Y274500D01* +X632934Y274500D01* +X642115Y278304D01* +X703110Y283104D01* +X717877Y278306D01* +X727066Y274500D01* +X773614Y274500D01* +X773622Y274499D01* +X785145Y274499D01* +X886378Y274499D01* +X886386Y274500D01* +X932933Y274500D01* +X932934Y274500D01* +X989167Y297793D01* +X1032207Y340833D01* +X1055500Y397066D01* +X1055500Y443615D01* +X1055501Y443624D01* +X1055501Y1577829D01* +X1055500Y1577843D01* +X1055500Y1627935D01* +X1032207Y1684167D01* +X1032207Y1684168D01* +X989167Y1727208D01* +X932934Y1750501D01* +X932933Y1750501D01* +X886386Y1750501D01* +X886378Y1750502D01* +X874855Y1750502D01* +X785145Y1750502D01* +X773622Y1750502D01* +X773614Y1750501D01* +X727064Y1750501D01* +X717885Y1746699D01* +X656888Y1741899D01* +X642115Y1746699D01* +X632936Y1750501D01* +X632934Y1750501D01* +X487934Y1750501D01* +X427066Y1750501D01* +X403774Y1740853D01* +X370834Y1727209D01* +X327792Y1684167D01* +X304500Y1627935D01* +X304500Y1579312D01* +X304498Y1579290D01* +X100000Y1579290D01* +X100000Y1890996D01* +X118907Y1949187D01* +X168407Y1985151D01* +X198999Y1989996D01* +X1171864Y1989948D01* +G37* +%TD.AperFunction*% +%TD*% +M02* diff --git a/simulations/differential_taper/fab/differential-NPTH.drl b/simulations/differential_taper/fab/differential-NPTH.drl new file mode 100644 index 0000000..00a9560 --- /dev/null +++ b/simulations/differential_taper/fab/differential-NPTH.drl @@ -0,0 +1,12 @@ +M48 +; DRILL file {KiCad 8.0.5} date 2025-02-04T16:35:12+1100 +; FORMAT={-:-/ absolute / metric / decimal} +; #@! TF.CreationDate,2025-02-04T16:35:12+11:00 +; #@! TF.GenerationSoftware,Kicad,Pcbnew,8.0.5 +; #@! TF.FileFunction,NonPlated,1,4,NPTH +FMAT,2 +METRIC +% +G90 +G05 +M30 diff --git a/simulations/differential_taper/fab/differential-PTH.drl b/simulations/differential_taper/fab/differential-PTH.drl new file mode 100644 index 0000000..445681d --- /dev/null +++ b/simulations/differential_taper/fab/differential-PTH.drl @@ -0,0 +1,21 @@ +M48 +; DRILL file {KiCad 8.0.5} date 2025-02-04T16:35:12+1100 +; FORMAT={-:-/ absolute / metric / decimal} +; #@! TF.CreationDate,2025-02-04T16:35:12+11:00 +; #@! TF.GenerationSoftware,Kicad,Pcbnew,8.0.5 +; #@! TF.FileFunction,Plated,1,4,PTH +FMAT,2 +METRIC +; #@! TA.AperFunction,Plated,PTH,ViaDrill +T1C0.150 +% +G90 +G05 +T1 +X0.2Y1.8 +X0.2Y0.3 +X0.635Y1.833 +X0.635Y0.2 +X1.1Y1.8 +X1.1Y0.3 +M30 diff --git a/simulations/differential_taper/fab/differential-bottom-pos.csv b/simulations/differential_taper/fab/differential-bottom-pos.csv new file mode 100644 index 0000000..5426f88 --- /dev/null +++ b/simulations/differential_taper/fab/differential-bottom-pos.csv @@ -0,0 +1,3 @@ +Ref,Val,Package,PosX,PosY,Rot,Side +"SP1","Simulation_Port","pad_0.15mm",0.530000,0.500000,180.000000,bottom +"SP3","Simulation_Port","pad_0.15mm",0.830000,0.500000,180.000000,bottom diff --git a/simulations/differential_taper/fab/differential-top-pos.csv b/simulations/differential_taper/fab/differential-top-pos.csv new file mode 100644 index 0000000..891bbe8 --- /dev/null +++ b/simulations/differential_taper/fab/differential-top-pos.csv @@ -0,0 +1,4 @@ +Ref,Val,Package,PosX,PosY,Rot,Side +"GND1","Ground","pad_0.1mm",0.400000,1.882500,0.000000,top +"SP0","Simulation_Port","pad_0.15mm",0.530000,1.525001,180.000000,top +"SP2","Simulation_Port","pad_0.15mm",0.830000,1.525001,180.000000,top diff --git a/simulations/differential_taper/fp-lib-table b/simulations/differential_taper/fp-lib-table new file mode 100644 index 0000000..a54d1a4 --- /dev/null +++ b/simulations/differential_taper/fp-lib-table @@ -0,0 +1,4 @@ +(fp_lib_table + (version 7) + (lib (name "simulation_port")(type "KiCad")(uri "${KIPRJMOD}/../simulation_port.pretty")(options "")(descr "")) +) diff --git a/simulations/differential_taper/generate_tapers.py b/simulations/differential_taper/generate_tapers.py new file mode 100644 index 0000000..eac98fa --- /dev/null +++ b/simulations/differential_taper/generate_tapers.py @@ -0,0 +1,316 @@ +from gerber2ems.config import Config +from gerber2ems.constants import PIXEL_SIZE_MICRONS +from gerber2ems.simulation import Simulation +import gerber2ems.importer as importer +import PIL +import PIL.Image +import PIL.ImageChops +import PIL.ImageDraw +import PIL.ImageOps +import argparse +import coloredlogs +import json +import logging +import math +import numpy as np +import os +import shutil + +logger = logging.getLogger(__name__) + +COPLANAR_GAP_UM = 150 +COPLANAR_WIDTH_UM = 200 + +class TaperConfig: + def __init__(self, width, length, overlap, coplanar_gap, coplanar_width): + self.width_um = width + self.length_um = length + self.overlap_um = overlap + self.coplanar_gap_um = coplanar_gap + self.coplanar_width_um = coplanar_width + +def create_arg_parser(): + parser = argparse.ArgumentParser( + prog="generate_tapers", + description="Generate modified simulation files with varying taper configurations", + ) + parser.add_argument("--config", dest="config", type=str, default="./simulation.json") + parser.add_argument("-i", "--input", dest="input", type=str, default="./fab") + parser.add_argument("-o", "--output", dest="output", type=str, default="./variants_simulation") + group = parser.add_mutually_exclusive_group() + group.add_argument("-d", "--debug", action="store_true", dest="debug") + group.add_argument("-l", "--log", choices=["DEBUG", "INFO", "WARNING", "ERROR"], dest="log_level") + parser.add_argument("--skip-convert", dest="skip_convert", action="store_true", help="Skip generating base Gerber images") + parser.add_argument("--skip-cleanup", dest="skip_cleanup", action="store_true", help="Skip cleaning up old variants") + return parser + +def main(): + parser = create_arg_parser() + args = parser.parse_args() + setup_logging(args) + + OUTPUT_PATH = os.path.realpath(args.output) + + class Arguments(object): pass + app_args = Arguments() + app_args.config = os.path.realpath(args.config) + app_args.input = os.path.realpath(args.input) + app_args.output = os.path.join(OUTPUT_PATH, "base") + app_args.debug = False + + with open(args.config) as fp: + config_json = json.load(fp) + + Config._instance = None + config = Config(config_json, app_args) + importer.import_port_positions() + + if not (args.skip_cleanup or args.skip_convert): + create_dir(OUTPUT_PATH, cleanup=True) + logger.info("Cleaning up output folder") + + if not args.skip_convert: + create_dir(config.dirs.output_dir, cleanup=True) + create_dir(config.dirs.image_dir, cleanup=True) + importer.process_gbrs_to_pngs() + else: + logger.info("Skipping image conversion") + + pair = config.diff_pairs[0] + validate_diff_pair(pair) + + signal_layer, ref_0_layer, ref_1_layer = get_port_layers(pair) + im_ref_0 = get_layer_image(ref_0_layer.file) + im_ref_1 = get_layer_image(ref_1_layer.file) + im_signal = get_layer_image(signal_layer.file) + + taper_configs = [ + # width (um), length (um), overlap (um) + ] + for width in (100, 150, 200, 250): + for length in (300, 400, 500): + for overlap in (200, 300, 400, 500, 600): + taper_configs.append((width, length, overlap)) + + get_variant_name = lambda taper_config: "_".join(map(str, taper_config)) + logger.info("Output variant parameters to csv file") + with open(os.path.join(OUTPUT_PATH, "variants.csv"), "w+") as fp: + fp.write("Name, Width (um), Length (um), Overlap (um)\n") + for taper_config in taper_configs: + fp.write(get_variant_name(taper_config)) + fp.write(", ") + fp.write(", ".join(map(str, taper_config))) + fp.write("\n") + + VARIANTS_DIR = os.path.join(OUTPUT_PATH, "variants") + create_dir(VARIANTS_DIR, cleanup=not args.skip_cleanup) + for taper_config in taper_configs: + logger.info(f"Creating variant: {','.join(map(str, taper_config))}") + width_um, length_um, overlap_um = taper_config + taper_config_obj = TaperConfig(width_um, length_um, overlap_um, COPLANAR_GAP_UM, COPLANAR_WIDTH_UM) + im_taper_0, im_taper_1 = create_taper(taper_config_obj, pair, im_signal.size) + im_ref_0_taper = add_taper_to_ref_plane(im_taper_0, im_ref_0) + im_ref_1_taper = add_taper_to_ref_plane(im_taper_1, im_ref_1) + im_debug = create_debug_image(im_signal, im_ref_0, im_ref_1, im_taper_0, im_taper_1) + # NOTE: flip to correct for flipping when loading it in + im_ref_0_taper = im_ref_0_taper.transpose(PIL.Image.FLIP_TOP_BOTTOM) + im_ref_1_taper = im_ref_1_taper.transpose(PIL.Image.FLIP_TOP_BOTTOM) + im_debug = im_debug.transpose(PIL.Image.FLIP_TOP_BOTTOM) + # save to folder + variant_name = get_variant_name(taper_config) + variant_path = os.path.join(VARIANTS_DIR, variant_name) + if not os.path.exists(variant_path) or not args.skip_cleanup: + try: + shutil.rmtree(variant_path) + except: + pass + shutil.copytree(config.dirs.output_dir, variant_path) + else: + logger.info(f"Skipping init of variant={variant_name}") + variant_images_path = os.path.join(variant_path, "images") + im_ref_0_taper.save(os.path.join(variant_images_path, f"{ref_0_layer.file}.png")) + im_ref_1_taper.save(os.path.join(variant_images_path, f"{ref_1_layer.file}.png")) + im_debug.save(os.path.join(variant_images_path, f"{ref_0_layer.file}_{ref_1_layer.file}_taper_debug.png")) + +def create_dir(path, cleanup=False): + directory_path = path + if cleanup and os.path.exists(directory_path): + shutil.rmtree(directory_path) + if not os.path.exists(directory_path): + os.mkdir(directory_path) + +def validate_diff_pair(pair): + config = Config.get() + port_indices = [pair.start_p, pair.stop_p, pair.start_n, pair.stop_n] + ports = [config.ports[i] for i in port_indices] + port = ports[0] + signal_layer_index = port.layer + port_width = port.width + port_length = port.length + is_same_signal = all((port.layer == signal_layer_index for port in ports)) + is_same_width = all((port.width == port_width for port in ports)) + is_same_length = all((port.length == port_length for port in ports)) + assert(is_same_signal) + assert(is_same_width) + assert(is_same_length) + assert(ports[0].plane == ports[2].plane) + assert(ports[1].plane == ports[3].plane) + +def get_port_layers(pair): + config = Config.get() + ports = config.ports + port_0 = ports[pair.start_p] + port_1 = ports[pair.stop_p] + ref_0_layer_index = port_0.plane + ref_1_layer_index = port_1.plane + signal_layer_index = port_0.layer + metal_layers = config.get_metals() + ref_0_layer = metal_layers[ref_0_layer_index] + ref_1_layer = metal_layers[ref_1_layer_index] + signal_layer = metal_layers[signal_layer_index] + assert(ref_0_layer.file != None) + assert(ref_1_layer.file != None) + assert(signal_layer.file != None) + return (signal_layer, ref_0_layer, ref_1_layer) + +def get_layer_image(name): + config = Config.get() + # NOTE: We flip the image so position lines up correctly + # Need to flip back any modified images when saving them + filepath = os.path.join(config.dirs.image_dir, f"{name}.png") + im = PIL.Image.open(filepath) + im_flip = im.transpose(PIL.Image.FLIP_TOP_BOTTOM) + im_gray = im_flip.convert("L") + im_thresh = im_gray.point(lambda p: 255 if p < config.nanomesh.threshold else 0) + return im_thresh + +def create_taper(taper_config: TaperConfig, pair, im_size): + # taper properties + taper_overlap_um = taper_config.overlap_um + taper_width_um = taper_config.width_um + taper_length_um = taper_config.length_um + coplanar_gap_um = taper_config.coplanar_gap_um + coplanar_width_um = taper_config.coplanar_width_um + + # port properties + config = Config.get() + port_indices = [pair.start_p, pair.stop_p, pair.start_n, pair.stop_n] + ports = [config.ports[i] for i in port_indices] + width_um = ports[0].width + height_um = ports[1].length + + # common axes + x_pos_um = ports[0].position[0] + x_neg_um = ports[2].position[0] + x_pos_um, x_neg_um = min(x_pos_um, x_neg_um), max(x_pos_um, x_neg_um) + y_start_um = ports[0].position[1] + y_end_um = ports[1].position[1] + y_start_um, y_end_um = min(y_start_um, y_end_um), max(y_start_um, y_end_um) + y_midline_um = int((y_start_um + y_end_um)/2) + x_left_um = int(x_pos_um - width_um/2 - coplanar_gap_um - coplanar_width_um) + x_right_um = int(x_neg_um + width_um/2 + coplanar_gap_um + coplanar_width_um) + + y_taper_top_um = y_midline_um - int(taper_overlap_um/2) + y_taper_bottom_um = y_midline_um + int(taper_overlap_um/2) + + # blit to bitmap (255 means empty, 0 means copper) + im_taper_0 = PIL.Image.new("L", im_size, 255) + im_taper_1 = PIL.Image.new("L", im_size, 255) + drawer_0 = PIL.ImageDraw.Draw(im_taper_0) + drawer_1 = PIL.ImageDraw.Draw(im_taper_1) + + as_coord = lambda p: tuple(map(int, p)) + to_px = lambda p: tuple((int(x/PIXEL_SIZE_MICRONS) for x in p)) + + def draw_triangle(drawer, start, width, height): + p0 = (start[0]-width/2, start[1]) + p1 = (start[0]+width/2, start[1]) + p2 = (start[0], start[1]+height) + points = (p0, p1,p2) + points = [to_px(point) for point in points] + drawer.polygon(points, fill=0) + + drawer_0.rectangle(tuple(map(to_px, ((x_left_um, y_start_um), (x_right_um, y_taper_top_um)))), fill=0) + draw_triangle(drawer_0, (x_pos_um, y_taper_top_um), taper_width_um, taper_length_um) + draw_triangle(drawer_0, (x_neg_um, y_taper_top_um), taper_width_um, taper_length_um) + draw_triangle(drawer_0, (x_left_um+coplanar_width_um/2, y_taper_top_um), coplanar_width_um, taper_length_um) + draw_triangle(drawer_0, (x_right_um-coplanar_width_um/2, y_taper_top_um), coplanar_width_um, taper_length_um) + + fill = (0,128,128,128) + drawer_1.rectangle(tuple(map(to_px, ((x_left_um, y_taper_bottom_um), (x_right_um, y_end_um)))), fill=0) + draw_triangle(drawer_1, (x_pos_um, y_taper_bottom_um), taper_width_um, -taper_length_um) + draw_triangle(drawer_1, (x_neg_um, y_taper_bottom_um), taper_width_um, -taper_length_um) + draw_triangle(drawer_1, (x_left_um+coplanar_width_um/2, y_taper_bottom_um), coplanar_width_um, -taper_length_um) + draw_triangle(drawer_1, (x_right_um-coplanar_width_um/2, y_taper_bottom_um), coplanar_width_um, -taper_length_um) + + if ports[0].position[1] < ports[1].position[1]: + return (im_taper_0, im_taper_1) + else: + return (im_taper_1, im_taper_0) + +def add_taper_to_ref_plane(im_ref, im_taper): + im_ref_inv = PIL.ImageOps.invert(im_ref) + im_taper_inv = PIL.ImageOps.invert(im_taper) + im_inv = PIL.ImageChops.add(im_ref_inv, im_taper_inv) + # im = PIL.ImageOps.invert(im_inv) + return im_inv + +def create_debug_image(im_signal, im_ref_0, im_ref_1, im_taper_0, im_taper_1): + def convert_to_alpha(im, colour): + im_mask = 255 - np.array(im, dtype=np.uint16) + im_mask = im_mask.reshape(im_mask.shape + (1,)) + total_channels = 4 + shape = im_mask.shape[:2] + (total_channels,) + im_fill = np.full(shape, colour, dtype=np.uint16) + im_out = im_fill*im_mask + im_out = np.clip(im_out, a_min=0, a_max=255) + opacity = colour[3] + im_out[:,:,3:4] = np.clip(im_mask, a_min=0, a_max=1)*opacity + im_out = im_out.astype(np.uint8) + im_out = PIL.Image.fromarray(im_out, mode="RGBA") + return im_out + + im_ref_0 = convert_to_alpha(im_ref_0, (0,255,0,64)) + im_ref_1 = convert_to_alpha(im_ref_1, (0,0,255,64)) + im_signal = convert_to_alpha(im_signal, (255,0,0,80)) + im_taper_0 = convert_to_alpha(im_taper_0, (128,128,0,100)) + im_taper_1 = convert_to_alpha(im_taper_1, (0,128,128,100)) + + im_out = PIL.Image.new("RGBA", im_signal.size, (255,255,255,255)) + im_out = PIL.Image.alpha_composite(im_out, im_ref_0) + im_out = PIL.Image.alpha_composite(im_out, im_ref_1) + im_out = PIL.Image.alpha_composite(im_out, im_signal) + im_out = PIL.Image.alpha_composite(im_out, im_taper_0) + im_out = PIL.Image.alpha_composite(im_out, im_taper_1) + return im_out + +def setup_logging(args): + level = logging.INFO + if args.debug: + level = logging.DEBUG + if args.log_level is not None: + level = logging.getLevelName(args.log_level) + + if level == logging.DEBUG: + coloredlogs.install( + fmt="[%(asctime)s][%(name)s:%(lineno)d][%(levelname).4s] %(message)s", + datefmt="%H:%M:%S", + level=level, + logger=logger, + ) + else: + coloredlogs.install( + fmt="[%(asctime)s][%(levelname).4s] %(message)s", + datefmt="%H:%M:%S", + level=level, + logger=logger, + ) + + # Temporary fix to disable logging from other libraries + to_disable = ["PIL", "matplotlib"] + for name in to_disable: + disabled_logger = logging.getLogger(name) + disabled_logger.setLevel(logging.ERROR) + +if __name__ == "__main__": + main() diff --git a/simulations/differential_taper/simulation.json b/simulations/differential_taper/simulation.json new file mode 100644 index 0000000..1576860 --- /dev/null +++ b/simulations/differential_taper/simulation.json @@ -0,0 +1,104 @@ +{ + "format_version": "1.1", + "frequency": { + "start": 0.5e9, + "stop": 40e9 + }, + "max_steps": 60e3, + "via": { + "filling_epsilon": 1, + "plating_thickness": 10 + }, + "mesh": { + "xy": 12, + "inter_layers": 4, + "margin": { + "xy": 100, + "z": 100 + }, + "smoothing_ratio": 2 + }, + "margin": { + "xy": 500, + "z": 500 + }, + "offset": { + "x": -0.055, + "y": -0.050 + }, + "ports": [ + { + "width": 150, + "length": 150, + "impedance": 42.5, + "layer": 1, + "plane": 0, + "excite": true + }, + { + "width": 150, + "length": 150, + "impedance": 42.5, + "layer": 1, + "plane": 2, + "excite": false + }, + { + "width": 150, + "length": 150, + "impedance": 42.5, + "layer": 1, + "plane": 0, + "excite": true + }, + { + "width": 150, + "length": 150, + "impedance": 42.5, + "layer": 1, + "plane": 2, + "excite": false + } + ], + "differential_pairs": [ + { + "start_p": 0, + "stop_p": 1, + "start_n": 2, + "stop_n": 3, + "name": "A" + } + ], + "layers": [ + { + "name": "F_Cu", + "file": "F_Cu", + "type": "copper" + }, + { + "name": "Dielectric inner 1", + "type": "core", + "thickness": 0.100, + "epsilon": 4.1, + "export_field": true + }, + { + "name": "In1_Cu", + "file": "In1_Cu", + "type": "copper", + "export_field": true + }, + { + "name": "Dielectric inner 2", + "type": "core", + "thickness": 0.100, + "epsilon": 4.1, + "export_field": true + }, + { + "name": "B_Cu", + "file": "B_Cu", + "type": "copper" + } + ] +} \ No newline at end of file diff --git a/simulations/gerber2ems b/simulations/gerber2ems index fe7c835..4db3ea6 160000 --- a/simulations/gerber2ems +++ b/simulations/gerber2ems @@ -1 +1 @@ -Subproject commit fe7c835416bf9a1237fb6adc64ec03ba3d1f03ab +Subproject commit 4db3ea6ab4c868ff1034f456a1ef7d6d5e5cf0f7 diff --git a/simulations/run_simulations.py b/simulations/run_simulations.py index 7678698..fceb84f 100644 --- a/simulations/run_simulations.py +++ b/simulations/run_simulations.py @@ -20,12 +20,13 @@ def create_argument_parser(): parser.add_argument("-p", "--postprocess", dest="postprocess", action="store_true", help="Run postprocessing pass") parser.add_argument("-a", "--all", dest="all", action="store_true", help="Run all steps") parser.add_argument("-i", "--input", dest="input", type=str, default="./fab") - parser.add_argument("-o", "--output", dest="output", type=str, default="./output") + parser.add_argument("-o", "--output", dest="output", type=str, default="./variants_simulation") group = parser.add_mutually_exclusive_group() group.add_argument("-d", "--debug", action="store_true", dest="debug") group.add_argument("-l", "--log", choices=["DEBUG", "INFO", "WARNING", "ERROR"], dest="log_level") parser.add_argument("-t", "--threads", dest="threads", type=int, default=None, help="Total threads to use for openEMS simulation") parser.add_argument("-r", "--restart", dest="restart", action="store_true", help="Restart all variant simulations") + parser.add_argument("--ef", "--export-field", dest="export_field", action="store_true", help="Export E-field data from simulation") return parser """ @@ -75,6 +76,8 @@ def main(): base_command_args.append("--debug") if args.threads: base_command_args.extend(["--threads", str(args.threads)]) + if args.export_field: + base_command_args.append("--export-field") def create_command_args(variant_dir, flags): command_args = [] @@ -108,6 +111,7 @@ def create_command_args(variant_dir, flags): logger.info(f"Cached variant={variant}, step={name}") def retry_run(args, max_retries=5): + logger.info(f"Running command={' '.join(args)}, max_retries={max_retries}") for i in range(max_retries): result = subprocess.run(args, capture_output=False) if result.returncode == 0: