mirror of https://codeberg.org/topola/topola.git
729 lines
25 KiB
Rust
729 lines
25 KiB
Rust
// SPDX-FileCopyrightText: 2024 Topola contributors
|
|
//
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
//! Module for managing the various Specctra PCB design, including loading the
|
|
//! Design DSN file, creating the [`Board`] object from the file, as well as
|
|
//! exporting the session file
|
|
|
|
use std::collections::{btree_map::Entry as BTreeMapEntry, BTreeMap};
|
|
|
|
use geo::{point, Point, Rotate};
|
|
|
|
use crate::{
|
|
board::{AccessMesadata, Board},
|
|
drawing::{
|
|
dot::{FixedDotWeight, GeneralDotWeight},
|
|
graph::{GetMaybeNet, MakePrimitive},
|
|
primitive::MakePrimitiveShape,
|
|
seg::{FixedSegWeight, GeneralSegWeight},
|
|
Drawing,
|
|
},
|
|
geometry::{primitive::PrimitiveShape, GetLayer, GetWidth},
|
|
layout::{poly::SolidPolyWeight, Layout, LayoutEdit},
|
|
math::{Circle, PointWithRotation},
|
|
specctra::{
|
|
mesadata::SpecctraMesadata,
|
|
read::ListTokenizer,
|
|
structure::{self, DsnFile, Layer, Pcb, Shape},
|
|
write::ListWriter,
|
|
},
|
|
};
|
|
|
|
pub use specctra_core::error::ParseErrorContext;
|
|
|
|
/// This struct is responsible for managing the various Specctra components of a PCB design,
|
|
/// including parsing the DSN file, handling the resolution, unit of measurement,
|
|
/// and organizing the PCB's structure, placement, library, network, and wiring.
|
|
/// It provides functionality for reading from a DSN file and writing Specctra's .SES session files.
|
|
#[derive(Debug)]
|
|
pub struct SpecctraDesign {
|
|
pcb: Pcb,
|
|
}
|
|
|
|
impl SpecctraDesign {
|
|
/// Loads a [`SpecctraDesign`] structure instance from a buffered reader.
|
|
///
|
|
/// This function reads the Specctra Design data from an input stream.
|
|
/// Later the data is parsed and loaded into a [`SpecctraDesign`] structure,
|
|
/// allowing further operations such as rule validation, routing, or netlist management.
|
|
pub fn load(reader: impl std::io::BufRead) -> Result<SpecctraDesign, ParseErrorContext> {
|
|
let mut list_reader = ListTokenizer::new(reader);
|
|
let dsn = list_reader.read_value::<DsnFile>()?;
|
|
|
|
Ok(Self { pcb: dsn.pcb })
|
|
}
|
|
|
|
/// Function to get name of the DSN file
|
|
///
|
|
/// This function returns the name of the `Pcb` objects
|
|
pub fn get_name(&self) -> &str {
|
|
&self.pcb.name
|
|
}
|
|
|
|
/// Writes the Specctra Session (.ses) file format using the current board layout and mesadata.
|
|
///
|
|
/// This function generates a Specctra SES session file that represents the board's net routing and
|
|
/// writes it to the provided output stream. The session data includes routed nets, wires,
|
|
/// layers, and other essential information for routing management.
|
|
pub fn write_ses(
|
|
&self,
|
|
board: &Board<SpecctraMesadata>,
|
|
writer: impl std::io::Write,
|
|
) -> Result<(), std::io::Error> {
|
|
let mesadata = board.mesadata();
|
|
let drawing = board.layout().drawing();
|
|
|
|
let mut net_outs = BTreeMap::<usize, structure::NetOut>::new();
|
|
for index in drawing.primitive_nodes() {
|
|
let primitive = index.primitive(drawing);
|
|
|
|
if let Some(net) = primitive.maybe_net() {
|
|
let coords = match primitive.shape() {
|
|
PrimitiveShape::Seg(seg) => {
|
|
vec![
|
|
structure::Point {
|
|
x: seg.from.x(),
|
|
y: seg.from.y(),
|
|
},
|
|
structure::Point {
|
|
x: seg.to.x(),
|
|
y: seg.to.y(),
|
|
},
|
|
]
|
|
}
|
|
|
|
PrimitiveShape::Bend(bend) => {
|
|
// Since general circle arcs don't seem to be supported
|
|
// we're downgrading each one to a chain of straight
|
|
// line segments.
|
|
// TODO: make this configurable? pick a smarter value?
|
|
let segment_count: usize = 100;
|
|
bend.render_discretization(segment_count + 1)
|
|
.map(Into::into)
|
|
.collect()
|
|
}
|
|
|
|
// Intentionally skipped for now.
|
|
// Topola stores trace segments and dots joining them
|
|
// as separate objects, but the Specctra formats and KiCad
|
|
// appear to consider them implicit.
|
|
// TODO: Vias
|
|
PrimitiveShape::Dot(_) => continue,
|
|
};
|
|
|
|
let wire = structure::WireOut {
|
|
path: structure::Path {
|
|
layer: mesadata
|
|
.layer_layername(primitive.layer())
|
|
.ok_or_else(|| {
|
|
std::io::Error::new(
|
|
std::io::ErrorKind::InvalidData,
|
|
format!(
|
|
"tried to reference invalid primitive layer {}",
|
|
primitive.layer()
|
|
),
|
|
)
|
|
})?
|
|
.to_owned(),
|
|
width: primitive.width(),
|
|
coords,
|
|
},
|
|
};
|
|
|
|
let net_out = match net_outs.entry(net) {
|
|
BTreeMapEntry::Occupied(occ) => occ.into_mut(),
|
|
BTreeMapEntry::Vacant(vac) => vac.insert(structure::NetOut {
|
|
name: mesadata
|
|
.net_netname(net)
|
|
.ok_or_else(|| {
|
|
std::io::Error::new(
|
|
std::io::ErrorKind::InvalidData,
|
|
format!("tried to reference invalid net ID {}", net),
|
|
)
|
|
})?
|
|
.to_owned(),
|
|
wire: Vec::new(),
|
|
via: Vec::new(),
|
|
}),
|
|
};
|
|
net_out.wire.push(wire);
|
|
}
|
|
}
|
|
|
|
let ses = structure::SesFile {
|
|
session: structure::Session {
|
|
id: "ID".to_string(),
|
|
routes: structure::Routes {
|
|
resolution: structure::Resolution {
|
|
unit: self.pcb.resolution.unit.clone(),
|
|
value: 1.0,
|
|
},
|
|
library_out: structure::Library {
|
|
images: Vec::new(),
|
|
padstacks: Vec::new(),
|
|
},
|
|
network_out: structure::NetworkOut {
|
|
net: net_outs.into_values().collect(),
|
|
},
|
|
},
|
|
},
|
|
};
|
|
|
|
ListWriter::new(writer).write_value(&ses)
|
|
}
|
|
|
|
/// Generates a [`Board<SpecctraMesadata>`] from the current PCB data.
|
|
///
|
|
/// This function takes the internal `Pcb` structure and transforms it into a [`Board`] object,
|
|
/// which is used for layout and routing operations. The board is initialized with [`SpecctraMesadata`],
|
|
/// which includes layer and net mappings, and is populated with components, pins, vias, and wires
|
|
/// from the PCB definition.
|
|
pub fn make_board(&self, recorder: &mut LayoutEdit) -> Board<SpecctraMesadata> {
|
|
let mesadata = SpecctraMesadata::from_pcb(&self.pcb);
|
|
let mut board = Board::new(Layout::new(Drawing::new(
|
|
mesadata,
|
|
self.pcb.structure.layers.len(),
|
|
self.pcb.structure.boundary.to_polygon(),
|
|
self.pcb
|
|
.structure
|
|
.place_boundary
|
|
.as_ref()
|
|
.map(|i| i.to_polygon()),
|
|
)));
|
|
|
|
// mapping of pin -> net prepared for adding pins
|
|
let pin_nets = self
|
|
.pcb
|
|
.network
|
|
.nets
|
|
.iter()
|
|
.filter_map(|net_pin_assignments| {
|
|
// resolve the id so we don't work with strings
|
|
let net = board
|
|
.layout()
|
|
.drawing()
|
|
.rules()
|
|
.netname_net(&net_pin_assignments.name)
|
|
.unwrap();
|
|
|
|
net_pin_assignments.pins.as_ref().map(|pins| {
|
|
// take the list of pins
|
|
// and for each pin output (pin name, net id)
|
|
pins.names.iter().map(move |pinname| (pinname.clone(), net))
|
|
})
|
|
})
|
|
// flatten the nested iters into a single stream of tuples
|
|
.flatten()
|
|
.collect::<BTreeMap<String, usize>>();
|
|
|
|
// add pins from components
|
|
for component in &self.pcb.placement.components {
|
|
let image = self
|
|
.pcb
|
|
.library
|
|
.images
|
|
.iter()
|
|
.find(|image| image.name == component.name)
|
|
.unwrap();
|
|
|
|
for place in &component.places {
|
|
let place_side_is_front = place.side == "front";
|
|
let get_layer = |board: &Board<SpecctraMesadata>, name: &str| {
|
|
Self::layer(board, &self.pcb.structure.layers, name, place_side_is_front)
|
|
};
|
|
|
|
for pin in &image.pins {
|
|
let pinname = format!("{}-{}", place.name, pin.id);
|
|
let net = pin_nets.get(&pinname).copied();
|
|
|
|
let padstack = self.pcb.library.find_padstack_by_name(&pin.name).unwrap();
|
|
|
|
for shape in padstack.shapes.iter() {
|
|
match shape {
|
|
Shape::Circle(circle) => {
|
|
let layer = get_layer(&board, &circle.layer);
|
|
Self::add_circle(
|
|
recorder,
|
|
&mut board,
|
|
place.point_with_rotation(),
|
|
pin.point_with_rotation(),
|
|
circle.diameter / 2.0,
|
|
layer,
|
|
net,
|
|
Some(pinname.clone()),
|
|
)
|
|
}
|
|
Shape::Rect(rect) => {
|
|
let layer = get_layer(&board, &rect.layer);
|
|
Self::add_rect(
|
|
recorder,
|
|
&mut board,
|
|
place.point_with_rotation(),
|
|
pin.point_with_rotation(),
|
|
rect.x1,
|
|
rect.y1,
|
|
rect.x2,
|
|
rect.y2,
|
|
layer,
|
|
net,
|
|
Some(pinname.clone()),
|
|
)
|
|
}
|
|
Shape::Path(path) => {
|
|
let layer = get_layer(&board, &path.layer);
|
|
Self::add_path(
|
|
recorder,
|
|
&mut board,
|
|
place.point_with_rotation(),
|
|
pin.point_with_rotation(),
|
|
&path.coords,
|
|
path.width,
|
|
layer,
|
|
net,
|
|
Some(pinname.clone()),
|
|
)
|
|
}
|
|
Shape::Polygon(polygon) => {
|
|
let layer = get_layer(&board, &polygon.layer);
|
|
Self::add_polygon(
|
|
recorder,
|
|
&mut board,
|
|
place.point_with_rotation(),
|
|
pin.point_with_rotation(),
|
|
&polygon.coords,
|
|
polygon.width,
|
|
layer,
|
|
net,
|
|
Some(pinname.clone()),
|
|
)
|
|
}
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for via in &self.pcb.wiring.vias {
|
|
let net = board.layout().drawing().rules().netname_net(&via.net);
|
|
|
|
let padstack = self.pcb.library.find_padstack_by_name(&via.name).unwrap();
|
|
|
|
let get_layer = |board: &Board<SpecctraMesadata>, name: &str| {
|
|
Self::layer(board, &self.pcb.structure.layers, name, true)
|
|
};
|
|
|
|
for shape in &padstack.shapes {
|
|
match shape {
|
|
Shape::Circle(circle) => {
|
|
let layer = get_layer(&board, &circle.layer);
|
|
Self::add_circle(
|
|
recorder,
|
|
&mut board,
|
|
// TODO: refactor?
|
|
// should this call take PointWithRotation?
|
|
PointWithRotation::from_xy(via.x, via.y),
|
|
PointWithRotation::default(),
|
|
circle.diameter / 2.0,
|
|
layer,
|
|
net,
|
|
None,
|
|
)
|
|
}
|
|
Shape::Rect(rect) => {
|
|
let layer = get_layer(&board, &rect.layer);
|
|
Self::add_rect(
|
|
recorder,
|
|
&mut board,
|
|
PointWithRotation::from_xy(via.x, via.y),
|
|
PointWithRotation::default(),
|
|
rect.x1,
|
|
rect.y1,
|
|
rect.x2,
|
|
rect.y2,
|
|
layer,
|
|
net,
|
|
None,
|
|
)
|
|
}
|
|
Shape::Path(path) => {
|
|
let layer = get_layer(&board, &path.layer);
|
|
Self::add_path(
|
|
recorder,
|
|
&mut board,
|
|
PointWithRotation::from_xy(via.x, via.y),
|
|
PointWithRotation::default(),
|
|
&path.coords,
|
|
path.width,
|
|
layer,
|
|
net,
|
|
None,
|
|
)
|
|
}
|
|
Shape::Polygon(polygon) => {
|
|
let layer = get_layer(&board, &polygon.layer);
|
|
Self::add_polygon(
|
|
recorder,
|
|
&mut board,
|
|
PointWithRotation::from_xy(via.x, via.y),
|
|
PointWithRotation::default(),
|
|
&polygon.coords,
|
|
polygon.width,
|
|
layer,
|
|
net,
|
|
None,
|
|
)
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
for wire in self.pcb.wiring.wires.iter() {
|
|
let layer = board
|
|
.layout()
|
|
.drawing()
|
|
.rules()
|
|
.layername_layer(&wire.path.layer)
|
|
.unwrap();
|
|
let net = board.layout().drawing().rules().netname_net(&wire.net);
|
|
|
|
Self::add_path(
|
|
recorder,
|
|
&mut board,
|
|
PointWithRotation::default(),
|
|
PointWithRotation::default(),
|
|
&wire.path.coords,
|
|
wire.path.width,
|
|
layer,
|
|
net,
|
|
None,
|
|
);
|
|
}
|
|
|
|
board
|
|
}
|
|
|
|
fn layer(
|
|
board: &Board<SpecctraMesadata>,
|
|
layers: &[Layer],
|
|
layername: &str,
|
|
front: bool,
|
|
) -> usize {
|
|
let image_layer = board
|
|
.layout()
|
|
.drawing()
|
|
.rules()
|
|
.layername_layer(layername)
|
|
.unwrap();
|
|
|
|
if front {
|
|
image_layer
|
|
} else {
|
|
layers.len() - image_layer - 1
|
|
}
|
|
}
|
|
|
|
fn add_circle(
|
|
recorder: &mut LayoutEdit,
|
|
board: &mut Board<SpecctraMesadata>,
|
|
place: PointWithRotation,
|
|
pin: PointWithRotation,
|
|
r: f64,
|
|
layer: usize,
|
|
maybe_net: Option<usize>,
|
|
maybe_pin: Option<String>,
|
|
) {
|
|
let circle = Circle {
|
|
pos: Self::pos(place, pin, 0.0, 0.0),
|
|
r,
|
|
};
|
|
|
|
board.add_fixed_dot_infringably(
|
|
recorder,
|
|
FixedDotWeight(GeneralDotWeight {
|
|
circle,
|
|
layer,
|
|
maybe_net,
|
|
}),
|
|
maybe_pin,
|
|
);
|
|
}
|
|
|
|
fn add_rect(
|
|
recorder: &mut LayoutEdit,
|
|
board: &mut Board<SpecctraMesadata>,
|
|
place: PointWithRotation,
|
|
pin: PointWithRotation,
|
|
x1: f64,
|
|
y1: f64,
|
|
x2: f64,
|
|
y2: f64,
|
|
layer: usize,
|
|
maybe_net: Option<usize>,
|
|
maybe_pin: Option<String>,
|
|
) {
|
|
// Corners.
|
|
let dot_1_1 = board.add_fixed_dot_infringably(
|
|
recorder,
|
|
FixedDotWeight(GeneralDotWeight {
|
|
circle: Circle {
|
|
pos: Self::pos(place, pin, x1, y1),
|
|
r: 0.5,
|
|
},
|
|
layer,
|
|
maybe_net,
|
|
}),
|
|
None,
|
|
);
|
|
let dot_2_1 = board.add_fixed_dot_infringably(
|
|
recorder,
|
|
FixedDotWeight(GeneralDotWeight {
|
|
circle: Circle {
|
|
pos: Self::pos(place, pin, x2, y1),
|
|
r: 0.5,
|
|
},
|
|
layer,
|
|
maybe_net,
|
|
}),
|
|
None,
|
|
);
|
|
let dot_2_2 = board.add_fixed_dot_infringably(
|
|
recorder,
|
|
FixedDotWeight(GeneralDotWeight {
|
|
circle: Circle {
|
|
pos: Self::pos(place, pin, x2, y2),
|
|
r: 0.5,
|
|
},
|
|
layer,
|
|
maybe_net,
|
|
}),
|
|
None,
|
|
);
|
|
let dot_1_2 = board.add_fixed_dot_infringably(
|
|
recorder,
|
|
FixedDotWeight(GeneralDotWeight {
|
|
circle: Circle {
|
|
pos: Self::pos(place, pin, x1, y2),
|
|
r: 0.5,
|
|
},
|
|
layer,
|
|
maybe_net,
|
|
}),
|
|
None,
|
|
);
|
|
// Sides.
|
|
let seg1 = board.add_fixed_seg_infringably(
|
|
recorder,
|
|
dot_1_1,
|
|
dot_2_1,
|
|
FixedSegWeight(GeneralSegWeight {
|
|
width: 1.0,
|
|
layer,
|
|
maybe_net,
|
|
}),
|
|
None,
|
|
);
|
|
let seg2 = board.add_fixed_seg_infringably(
|
|
recorder,
|
|
dot_2_1,
|
|
dot_2_2,
|
|
FixedSegWeight(GeneralSegWeight {
|
|
width: 1.0,
|
|
layer,
|
|
maybe_net,
|
|
}),
|
|
None,
|
|
);
|
|
let seg3 = board.add_fixed_seg_infringably(
|
|
recorder,
|
|
dot_2_2,
|
|
dot_1_2,
|
|
FixedSegWeight(GeneralSegWeight {
|
|
width: 1.0,
|
|
layer,
|
|
maybe_net,
|
|
}),
|
|
None,
|
|
);
|
|
let seg4 = board.add_fixed_seg_infringably(
|
|
recorder,
|
|
dot_1_2,
|
|
dot_1_1,
|
|
FixedSegWeight(GeneralSegWeight {
|
|
width: 1.0,
|
|
layer,
|
|
maybe_net,
|
|
}),
|
|
None,
|
|
);
|
|
|
|
board.add_poly_with_nodes(
|
|
recorder,
|
|
SolidPolyWeight { layer, maybe_net }.into(),
|
|
maybe_pin,
|
|
&[
|
|
dot_1_1.into(),
|
|
dot_1_2.into(),
|
|
dot_2_2.into(),
|
|
dot_2_1.into(),
|
|
seg1.into(),
|
|
seg2.into(),
|
|
seg3.into(),
|
|
seg4.into(),
|
|
],
|
|
);
|
|
}
|
|
|
|
fn add_path(
|
|
recorder: &mut LayoutEdit,
|
|
board: &mut Board<SpecctraMesadata>,
|
|
place: PointWithRotation,
|
|
pin: PointWithRotation,
|
|
coords: &[structure::Point],
|
|
width: f64,
|
|
layer: usize,
|
|
maybe_net: Option<usize>,
|
|
maybe_pin: Option<String>,
|
|
) {
|
|
// add the first coordinate in the wire path as a dot and save its index
|
|
let mut prev_pos = Self::pos(place, pin, coords[0].x, coords[0].y);
|
|
let mut prev_index = board.add_fixed_dot_infringably(
|
|
recorder,
|
|
FixedDotWeight(GeneralDotWeight {
|
|
circle: Circle {
|
|
pos: prev_pos,
|
|
r: width / 2.0,
|
|
},
|
|
layer,
|
|
maybe_net,
|
|
}),
|
|
maybe_pin.clone(),
|
|
);
|
|
|
|
// iterate through path coords starting from the second
|
|
for coord in coords.iter().skip(1) {
|
|
let pos = Self::pos(place, pin, coord.x, coord.y);
|
|
|
|
if pos == prev_pos {
|
|
continue;
|
|
}
|
|
|
|
let index = board.add_fixed_dot_infringably(
|
|
recorder,
|
|
FixedDotWeight(GeneralDotWeight {
|
|
circle: Circle {
|
|
pos,
|
|
r: width / 2.0,
|
|
},
|
|
layer,
|
|
maybe_net,
|
|
}),
|
|
maybe_pin.clone(),
|
|
);
|
|
|
|
// add a seg between the current and previous coords
|
|
let _ = board.add_fixed_seg_infringably(
|
|
recorder,
|
|
prev_index,
|
|
index,
|
|
FixedSegWeight(GeneralSegWeight {
|
|
width,
|
|
layer,
|
|
maybe_net,
|
|
}),
|
|
maybe_pin.clone(),
|
|
);
|
|
|
|
prev_index = index;
|
|
prev_pos = pos;
|
|
}
|
|
}
|
|
|
|
fn add_polygon(
|
|
recorder: &mut LayoutEdit,
|
|
board: &mut Board<SpecctraMesadata>,
|
|
place: PointWithRotation,
|
|
pin: PointWithRotation,
|
|
mut coords: &[structure::Point],
|
|
width: f64,
|
|
layer: usize,
|
|
maybe_net: Option<usize>,
|
|
maybe_pin: Option<String>,
|
|
) {
|
|
let mut nodes = Vec::with_capacity(coords.len() * 2 - 1);
|
|
|
|
// add the first coordinate in the wire path as a dot and save its index
|
|
let first_index = board.add_fixed_dot_infringably(
|
|
recorder,
|
|
FixedDotWeight(GeneralDotWeight {
|
|
circle: Circle {
|
|
pos: Self::pos(place, pin, coords[0].x, coords[0].y),
|
|
r: width / 2.0,
|
|
},
|
|
layer,
|
|
maybe_net,
|
|
}),
|
|
None,
|
|
);
|
|
nodes.push(first_index.into());
|
|
let mut prev_index = first_index;
|
|
|
|
if approx::abs_diff_eq!(coords[0].x, coords.last().unwrap().x)
|
|
&& approx::abs_diff_eq!(coords[0].y, coords.last().unwrap().y)
|
|
{
|
|
coords = &coords[..coords.len() - 1];
|
|
}
|
|
|
|
let seg_weight = FixedSegWeight(GeneralSegWeight {
|
|
width,
|
|
layer,
|
|
maybe_net,
|
|
});
|
|
|
|
// iterate through path coords starting from the second
|
|
for coord in &coords[1..] {
|
|
let index = board.add_fixed_dot_infringably(
|
|
recorder,
|
|
FixedDotWeight(GeneralDotWeight {
|
|
circle: Circle {
|
|
pos: Self::pos(place, pin, coord.x, coord.y),
|
|
r: width / 2.0,
|
|
},
|
|
layer,
|
|
maybe_net,
|
|
}),
|
|
None,
|
|
);
|
|
nodes.push(index.into());
|
|
|
|
// add a seg between the current and previous coords
|
|
nodes.push(
|
|
board
|
|
.add_fixed_seg_infringably(recorder, prev_index, index, seg_weight, None)
|
|
.into(),
|
|
);
|
|
|
|
prev_index = index;
|
|
}
|
|
|
|
// add a seg between the last and first coords
|
|
nodes.push(
|
|
board
|
|
.add_fixed_seg_infringably(recorder, prev_index, first_index, seg_weight, None)
|
|
.into(),
|
|
);
|
|
|
|
board.add_poly_with_nodes(
|
|
recorder,
|
|
SolidPolyWeight { layer, maybe_net }.into(),
|
|
maybe_pin,
|
|
&nodes[..],
|
|
);
|
|
}
|
|
|
|
fn pos(place: PointWithRotation, pin: PointWithRotation, x: f64, y: f64) -> Point {
|
|
let pos = (point! {x: x, y: y} + pin.pos).rotate_around_point(pin.rot, pin.pos);
|
|
(pos + place.pos).rotate_around_point(place.rot, place.pos)
|
|
}
|
|
}
|