490 lines
22 KiB
Python
490 lines
22 KiB
Python
#!/usr/bin/env python3
|
||
"""Génère matrice_3x3.fzz : maquette 3x3 sur plaque à pastilles (vue platine)
|
||
+ schéma électrique (vue schéma). Coordonnées en px Fritzing (90 dpi)."""
|
||
import math, sys, zipfile, os
|
||
from xml.sax.saxutils import escape
|
||
|
||
PARTS = "/usr/share/fritzing/fritzing-parts/core/"
|
||
P = 9.0 # pas 0,1 pouce
|
||
|
||
# ---------------------------------------------------------------- modèle
|
||
instances = [] # dict: id, module, path, title, props, views{view:{...}}
|
||
idx = [1000]
|
||
def nid():
|
||
idx[0] += 1
|
||
return idx[0]
|
||
|
||
conns = {} # (inst_id, view, connector) -> list of (other_id, other_connector, other_layer)
|
||
def link(view, a, ca, la, b, cb, lb):
|
||
conns.setdefault((a, view, ca), []).append((b, cb, lb))
|
||
conns.setdefault((b, view, cb), []).append((a, ca, la))
|
||
|
||
# ---------------------------------------------------------------- géométries des pièces
|
||
LED = dict(module="d4d5af9700923b8a114f57961f29a8a0ColorLEDModuleID",
|
||
path=PARTS + "led-rgb-4pin-cathode_v5.fzp",
|
||
legs={"connector0": (1.35, 40.6875), "connector1": (10.35, 40.6875),
|
||
"connector2": (19.35, 40.6875), "connector3": (28.35, 40.6875)},
|
||
size=(0.33 * 90, 0.4521 * 90))
|
||
NPN = dict(module="2244EBEC10e", path=PARTS + "transistor_signal_NPN_TO92_CBE.fzp",
|
||
# connector2 = C (gauche), connector1 = B, connector0 = E (droite)
|
||
legs={"connector2": (1.35, 30.101), "connector1": (10.326, 30.101),
|
||
"connector0": (19.309, 30.101)},
|
||
size=(0.22954 * 90, 0.3344583 * 90))
|
||
RES = dict(module="ResistorModuleID", path=PARTS + "resistor.fzp",
|
||
legs={"connector0": (2.619, 4.5405), "connector1": (36.0063, 4.5405)},
|
||
size=(0.42917 * 90, 0.0971 * 90))
|
||
ARDUINO = dict(module="arduino_Uno_Rev3(fix)", path=PARTS + "arduino_Uno_Rev3(fix).fzp",
|
||
size=(2.94961 * 90, 2.1 * 90))
|
||
ARD_PIN = { # broche -> (connector id, x, y) dans le repère de la carte (non tournée)
|
||
"D2": ("connector63", 229.47, 9.0), "D3": ("connector64", 220.46, 9.0),
|
||
"D4": ("connector65", 211.46, 9.0), "D5": ("connector66", 202.46, 9.0),
|
||
"D6": ("connector67", 193.46, 9.0), "D7": ("connector68", 184.47, 9.0),
|
||
"D8": ("connector51", 170.06, 9.0), "D9": ("connector52", 161.06, 9.0),
|
||
"D10": ("connector53", 152.06, 9.0), "D11": ("connector54", 143.06, 9.0),
|
||
"D12": ("connector55", 134.06, 9.0), "D13": ("connector56", 125.06, 9.0),
|
||
"GND": ("connector57", 116.06, 9.0),
|
||
}
|
||
|
||
def rot_matrix(deg, w, h):
|
||
"""Rotation autour du centre (w/2, h/2), au format QTransform de Fritzing."""
|
||
cx, cy = w / 2, h / 2
|
||
a = math.radians(deg)
|
||
c, s = round(math.cos(a), 9), round(math.sin(a), 9)
|
||
m11, m12, m21, m22 = c, s, -s, c
|
||
m31 = cx - (m11 * cx + m21 * cy)
|
||
m32 = cy - (m12 * cx + m22 * cy)
|
||
return (m11, m12, m21, m22, m31, m32)
|
||
|
||
def apply(m, x, y):
|
||
m11, m12, m21, m22, m31, m32 = m
|
||
return (m11 * x + m21 * y + m31, m12 * x + m22 * y + m32)
|
||
|
||
def inv_apply(m, u, v):
|
||
m11, m12, m21, m22, m31, m32 = m
|
||
u, v = u - m31, v - m32
|
||
det = m11 * m22 - m12 * m21
|
||
return ((m22 * u - m21 * v) / det, (-m12 * u + m11 * v) / det)
|
||
|
||
# ---------------------------------------------------------------- vue platine (plaque à pastilles)
|
||
COLS, ROWS = 32, 34
|
||
BOARD = dict(id=nid(), module=f"{COLS}.{ROWS}PerfboardModuleID",
|
||
path=":/resources/parts/core/perfboard.fzp", title="Plaque à pastilles",
|
||
props={"size": f"{COLS}.{ROWS}"}, views={})
|
||
BOARD["views"]["breadboardView"] = dict(layer="breadboardbreadboard", x=0, y=0, z=1.5)
|
||
instances.append(BOARD)
|
||
|
||
def hole(c, r):
|
||
return (9 + P * c, 9 + P * r)
|
||
|
||
def hole_id(c, r):
|
||
return f"connector{r * 1000 + c}"
|
||
|
||
def add_part(spec, title, bb_pos, bb_rot=0, props=None, sch=None, legs_to=None):
|
||
"""legs_to : {connector: (col, row)} trous de la plaque où arrivent les pattes."""
|
||
inst = dict(id=nid(), module=spec["module"], path=spec["path"], title=title,
|
||
props=props or {}, views={}, legs={})
|
||
w, h = spec["size"]
|
||
m = rot_matrix(bb_rot, w, h) if bb_rot else None
|
||
inst["views"]["breadboardView"] = dict(layer="breadboard", x=bb_pos[0], y=bb_pos[1],
|
||
z=2.5, m=m)
|
||
if legs_to:
|
||
for con, (c, r) in legs_to.items():
|
||
sx, sy = spec["legs"][con]
|
||
hx, hy = hole(c, r)
|
||
u, v = hx - bb_pos[0], hy - bb_pos[1]
|
||
lx, ly = inv_apply(m, u, v) if m else (u, v)
|
||
inst["legs"][con] = ((sx, sy), (lx - sx, ly - sy))
|
||
link("breadboardView", inst["id"], con, "breadboard", BOARD["id"],
|
||
hole_id(c, r), "breadboardbreadboard")
|
||
inst["sch"] = sch
|
||
inst["holes"] = legs_to or {}
|
||
instances.append(inst)
|
||
return inst
|
||
|
||
def place_on_holes(spec, title, holes, rot=0, lift=1.0, props=None):
|
||
"""Place la pièce pour que ses pattes soient au-dessus des trous, puis plie les
|
||
pattes vers les trous. lift = longueur de patte visible, en pas de 0,1 po."""
|
||
cons = list(holes)
|
||
# centre des trous visés, centre des départs de pattes
|
||
hx = sum(hole(*holes[c])[0] for c in cons) / len(cons)
|
||
hy = sum(hole(*holes[c])[1] for c in cons) / len(cons)
|
||
sx = sum(spec["legs"][c][0] for c in cons) / len(cons)
|
||
sy = sum(spec["legs"][c][1] for c in cons) / len(cons)
|
||
w, h = spec["size"]
|
||
m = rot_matrix(rot, w, h) if rot else None
|
||
tx, ty = apply(m, sx, sy) if m else (sx, sy)
|
||
if rot == 0:
|
||
pos = (hx - tx, hy - ty - lift * P)
|
||
else:
|
||
pos = (hx - tx, hy - ty)
|
||
return add_part(spec, title, pos, rot, props, legs_to=holes)
|
||
|
||
wires = []
|
||
board_wires = [] # (trou a, trou b, couleur) pour le plan d'implantation
|
||
def bb_wire(a, b, color, title=None):
|
||
"""Fil entre deux trous de la plaque (a, b = (col, row))."""
|
||
(x1, y1), (x2, y2) = hole(*a), hole(*b)
|
||
board_wires.append((a, b, color))
|
||
w = dict(id=nid(), title=title or f"Fil{len(wires) + 1}", view="breadboardView",
|
||
x=x1, y=y1, dx=x2 - x1, dy=y2 - y1, color=color, flags=64,
|
||
layer="breadboardWire", z=(1.8 if color == NU else 3.5))
|
||
for k, (c, r) in enumerate((a, b)):
|
||
link("breadboardView", w["id"], f"connector{k}", "breadboardWire",
|
||
BOARD["id"], hole_id(c, r), "breadboardbreadboard")
|
||
wires.append(w)
|
||
return w
|
||
|
||
ARD_POS = (40.0, -280.0)
|
||
ARD_M = rot_matrix(180, *ARDUINO["size"])
|
||
ARD = dict(id=nid(), module=ARDUINO["module"], path=ARDUINO["path"], title="Arduino Uno",
|
||
props={}, views={}, legs={})
|
||
ARD["views"]["breadboardView"] = dict(layer="breadboardbreadboard", x=ARD_POS[0],
|
||
y=ARD_POS[1], z=1.6, m=ARD_M)
|
||
instances.append(ARD)
|
||
|
||
def ard_pin_xy(name):
|
||
_, px, py = ARD_PIN[name]
|
||
u, v = apply(ARD_M, px, py)
|
||
return (ARD_POS[0] + u, ARD_POS[1] + v)
|
||
|
||
def ard_wire(pin, hole_cr, color):
|
||
x1, y1 = ard_pin_xy(pin)
|
||
x2, y2 = hole(*hole_cr)
|
||
w = dict(id=nid(), title=f"Fil {pin}", view="breadboardView", x=x1, y=y1,
|
||
dx=x2 - x1, dy=y2 - y1, color=color, flags=64, layer="breadboardWire")
|
||
link("breadboardView", w["id"], "connector0", "breadboardWire", ARD["id"],
|
||
ARD_PIN[pin][0], "breadboardbreadboard")
|
||
link("breadboardView", w["id"], "connector1", "breadboardWire", BOARD["id"],
|
||
hole_id(*hole_cr), "breadboardbreadboard")
|
||
wires.append(w)
|
||
|
||
# couleurs de fils Fritzing
|
||
NU = "#a8a8a8" # fil nu étamé, côté soudure
|
||
ROUGE, VERT, BLEU = "#cc1414", "#47cc79", "#418dd9"
|
||
NOIR, JAUNE, ORANGE = "#404040", "#ffe24d", "#ff7033"
|
||
|
||
# --- implantation -------------------------------------------------------------
|
||
PAS = 6 # pas entre LED, en trous (6 × 2,54 = 15,24 mm)
|
||
X0, Y_LED = 2, (18, 24, 30) # LED (ligne r, colonne c) : pattes R K G B
|
||
COUL = {"R": 0, "G": 2, "B": 3} # décalage de la patte dans la LED
|
||
PIN_ANODE = {(c, k): f"D{2 + 3 * c + i}" for c in range(3) for i, k in enumerate("RGB")}
|
||
RES_VAL = {"R": "220Ω", "G": "150Ω", "B": "150Ω"}
|
||
COUL_FIL = {"R": ROUGE, "G": VERT, "B": BLEU}
|
||
ard_jobs = [] # (broche, trou, couleur) routés à la fin
|
||
|
||
leds = {}
|
||
for r in range(3):
|
||
for c in range(3):
|
||
x = X0 + PAS * c
|
||
leds[(r, c)] = place_on_holes(
|
||
LED, f"LED L{r}C{c}",
|
||
{"connector0": (x, Y_LED[r]), "connector1": (x + 1, Y_LED[r]),
|
||
"connector2": (x + 2, Y_LED[r]), "connector3": (x + 3, Y_LED[r])},
|
||
lift=0.6)
|
||
|
||
res_anode = {}
|
||
for c in range(3):
|
||
for k, off in COUL.items():
|
||
col = X0 + PAS * c + off
|
||
top, bot = (2, 6) if k in "RG" else (7, 11)
|
||
res_anode[(c, k)] = place_on_holes(
|
||
RES, f"R {k}{c}", {"connector0": (col, top), "connector1": (col, bot)},
|
||
rot=90, props={"resistance": RES_VAL[k]})
|
||
bb_wire((col, 1), (col, top), NU)
|
||
ard_jobs.append((PIN_ANODE[(c, k)], (col, 1), COUL_FIL[k]))
|
||
bb_wire((col, bot), (col, Y_LED[0]), NU)
|
||
bb_wire((col, Y_LED[0]), (col, Y_LED[1]), NU)
|
||
bb_wire((col, Y_LED[1]), (col, Y_LED[2]), NU)
|
||
|
||
XC, XB, XE = 21, 22, 23 # pattes C, B, E
|
||
X_GND = 30
|
||
trans, res_base = {}, {}
|
||
for r in range(3):
|
||
y = Y_LED[r] + 1
|
||
for c in range(3):
|
||
xk = X0 + PAS * c + 1
|
||
bb_wire((xk, Y_LED[r]), (xk, y), NU)
|
||
bb_wire((X0 + 1, y), (X0 + 1 + PAS, y), NOIR)
|
||
bb_wire((X0 + 1 + PAS, y), (X0 + 1 + 2 * PAS, y), NOIR)
|
||
bb_wire((X0 + 1 + 2 * PAS, y), (XC - 1, y), NOIR)
|
||
bb_wire((XC - 1, y), (XC, y), NU)
|
||
trans[r] = place_on_holes(NPN, f"T{r} (BC337)",
|
||
{"connector2": (XC, y), "connector1": (XB, y),
|
||
"connector0": (XE, y)}, lift=0.6)
|
||
res_base[r] = place_on_holes(RES, f"Rb{r}",
|
||
{"connector0": (XB, y + 1), "connector1": (XB + 4, y + 1)},
|
||
lift=0.0, props={"resistance": "1kΩ"})
|
||
bb_wire((XB, y), (XB, y + 1), NU)
|
||
xw = XB + 5 + r
|
||
bb_wire((XB + 4, y + 1), (xw, y + 1), NU)
|
||
ard_jobs.append((f"D{11 + r}", (xw, y + 1), JAUNE))
|
||
bb_wire((XE, y), (X_GND, y), NU)
|
||
yg = Y_LED[0] - 1
|
||
bb_wire((X_GND, yg), (X_GND, Y_LED[0] + 1), NU)
|
||
bb_wire((X_GND, Y_LED[0] + 1), (X_GND, Y_LED[1] + 1), NU)
|
||
bb_wire((X_GND, Y_LED[1] + 1), (X_GND, Y_LED[2] + 1), NU)
|
||
ard_jobs.append(("GND", (X_GND, yg), NOIR))
|
||
|
||
# routage des fils Arduino : descente, palier horizontal, descente (fils coudés)
|
||
def chain(points, color, pin, hole_cr):
|
||
ids = []
|
||
for i in range(len(points) - 1):
|
||
(x1, y1), (x2, y2) = points[i], points[i + 1]
|
||
w = dict(id=nid(), title=f"Fil {pin}", view="breadboardView", x=x1, y=y1,
|
||
dx=x2 - x1, dy=y2 - y1, color=color, flags=64, layer="breadboardWire")
|
||
wires.append(w)
|
||
ids.append(w["id"])
|
||
link("breadboardView", ids[0], "connector0", "breadboardWire", ARD["id"],
|
||
ARD_PIN[pin][0], "breadboardbreadboard")
|
||
link("breadboardView", ids[-1], "connector1", "breadboardWire", BOARD["id"],
|
||
hole_id(*hole_cr), "breadboardbreadboard")
|
||
for a_, b_ in zip(ids, ids[1:]):
|
||
link("breadboardView", a_, "connector1", "breadboardWire", b_, "connector0",
|
||
"breadboardWire")
|
||
|
||
header_y = ard_pin_xy("D2")[1]
|
||
jobs = [(pin, h, col, ard_pin_xy(pin)[0], hole(*h)[0]) for pin, h, col in ard_jobs]
|
||
droite = sorted([j for j in jobs if j[4] > j[3] + 0.5], key=lambda j: j[3])
|
||
gauche = sorted([j for j in jobs if j[4] < j[3] - 0.5], key=lambda j: -j[3])
|
||
niveau = {}
|
||
for groupe in (droite, gauche):
|
||
n = len(groupe)
|
||
for i, j in enumerate(groupe): # le plus à l'extérieur descend le plus bas
|
||
niveau[j[0]] = n - i
|
||
for pin, h, col, xp, xh in jobs:
|
||
yp = header_y
|
||
if pin in niveau:
|
||
yl = header_y + 18 + 9 * niveau[pin]
|
||
chain([(xp, yp), (xp, yl), (xh, yl), hole(*h)], col, pin, h)
|
||
else:
|
||
chain([(xp, yp), hole(*h)], col, pin, h)
|
||
|
||
# ---------------------------------------------------------------- vue schéma
|
||
K = 90 / 96 # px Inkscape -> px Fritzing (SVG en pouces)
|
||
SCH = { # terminaux dans le repère du symbole (px Fritzing)
|
||
"LED": {"connector0": (5.126, 35.457), "connector2": (23.172, 35.457),
|
||
"connector3": (41.297, 35.457), "connector1": (23.225, 1.5)},
|
||
"NPN": {"connector1": (0.4375, 18.4375), "connector2": (18.4375, 0.4375),
|
||
"connector0": (18.4375, 36.4375)},
|
||
"RES": {"connector0": (0.4375, 3.87), "connector1": (36.4375, 3.87)},
|
||
"RES_SIZE": (0.409722 * 90, 0.086 * 90),
|
||
}
|
||
def ard_sch(name):
|
||
con = ARD_PIN[name][0]
|
||
if name == "GND":
|
||
return (72.0, 207.0)
|
||
n = {"D2": 0, "D3": 1, "D4": 2, "D5": 3, "D6": 4, "D7": 5, "D8": 6, "D9": 7,
|
||
"D10": 8, "D11": 9, "D12": 10, "D13": 11}[name]
|
||
return (135.0, 54.0 + 9 * n)
|
||
|
||
def set_sch(inst, pos, rot=0, size=None):
|
||
m = rot_matrix(rot, *size) if rot else None
|
||
inst["views"]["schematicView"] = dict(layer="schematic", x=pos[0], y=pos[1], z=2.5, m=m)
|
||
inst["sch_pos"], inst["sch_m"] = pos, m
|
||
|
||
def place_sch(inst, table, con, target, rot=0, size=None):
|
||
"""Place le symbole pour que le terminal `con` tombe sur `target`."""
|
||
m = rot_matrix(rot, *size) if rot else None
|
||
lx, ly = SCH[table][con]
|
||
if m:
|
||
lx, ly = apply(m, lx, ly)
|
||
set_sch(inst, (target[0] - lx, target[1] - ly), rot, size)
|
||
|
||
def term(inst, table, con):
|
||
lx, ly = SCH[table][con]
|
||
if inst.get("sch_m"):
|
||
lx, ly = apply(inst["sch_m"], lx, ly)
|
||
return (inst["sch_pos"][0] + lx, inst["sch_pos"][1] + ly)
|
||
|
||
ends = {} # point arrondi -> [(wire_id, connector)]
|
||
def sch_poly(points, start=None, end=None):
|
||
ids = []
|
||
for (x1, y1), (x2, y2) in zip(points, points[1:]):
|
||
w = dict(id=nid(), title="Fil", view="schematicView", x=x1, y=y1, dx=x2 - x1,
|
||
dy=y2 - y1, color="#404040", flags=128, layer="schematicTrace",
|
||
mils="9.7222", z=5.5)
|
||
wires.append(w)
|
||
ids.append(w["id"])
|
||
for a_, b_ in zip(ids, ids[1:]):
|
||
link("schematicView", a_, "connector1", "schematicTrace", b_, "connector0",
|
||
"schematicTrace")
|
||
if start:
|
||
link("schematicView", ids[0], "connector0", "schematicTrace", start[0]["id"],
|
||
start[1], "schematic")
|
||
else:
|
||
ends.setdefault((round(points[0][0], 2), round(points[0][1], 2)), []).append(
|
||
(ids[0], "connector0"))
|
||
if end:
|
||
link("schematicView", ids[-1], "connector1", "schematicTrace", end[0]["id"],
|
||
end[1], "schematic")
|
||
else:
|
||
ends.setdefault((round(points[-1][0], 2), round(points[-1][1], 2)), []).append(
|
||
(ids[-1], "connector1"))
|
||
|
||
A_POS = (0.0, 450.0)
|
||
ARD["views"]["schematicView"] = dict(layer="schematic", x=A_POS[0], y=A_POS[1], z=2.5)
|
||
def apin(name):
|
||
x, y = ard_sch(name)
|
||
return (A_POS[0] + x, A_POS[1] + y)
|
||
ARDP = lambda name: (ARD, ARD_PIN[name][0])
|
||
|
||
MX, MY, PASS = 225.0, 60.0, 90.0
|
||
BUS_OFF = {"R": -27.0, "G": -18.0, "B": -9.0}
|
||
PROF = {"R": 9.0, "G": 18.0, "B": 27.0}
|
||
LEDCON = {"R": "connector0", "G": "connector2", "B": "connector3"}
|
||
RES_TOP = {"R": 315.0, "G": 360.0, "B": 405.0}
|
||
for (r, c), led in leds.items():
|
||
set_sch(led, (MX + PASS * c, MY + PASS * r))
|
||
for c in range(3):
|
||
for k in "RGB":
|
||
bx = MX + PASS * c + BUS_OFF[k]
|
||
res = res_anode[(c, k)]
|
||
# patte 1 (connector0) côté Arduino, en bas ; patte 2 côté LED, en haut
|
||
place_sch(res, "RES", "connector1", (bx, RES_TOP[k]), rot=270, size=SCH["RES_SIZE"])
|
||
top, bot = term(res, "RES", "connector1"), term(res, "RES", "connector0")
|
||
pin = PIN_ANODE[(c, k)]
|
||
px, py = apin(pin)
|
||
sch_poly([(px, py), (bx, py), bot], start=ARDP(pin), end=(res, "connector0"))
|
||
# bus : résistance -> jonctions des lignes 2, 1, 0
|
||
pts = [top] + [(bx, MY + PASS * r + 35.457 + PROF[k]) for r in (2, 1, 0)]
|
||
for i, (a_, b_) in enumerate(zip(pts, pts[1:])):
|
||
sch_poly([a_, b_], start=(res, "connector1") if i == 0 else None)
|
||
for r in range(3):
|
||
led = leds[(r, c)]
|
||
tx, ty = term(led, "LED", LEDCON[k])
|
||
jy = MY + PASS * r + 35.457 + PROF[k]
|
||
sch_poly([(tx, ty), (tx, jy), (bx, jy)], start=(led, LEDCON[k]))
|
||
|
||
XT = 545.0
|
||
XV = {0: 462.0, 1: 471.0, 2: 480.0}
|
||
X_GND_S, Y_GND_S = XT + 45.0, 690.0
|
||
for r in range(3):
|
||
yrl = MY + PASS * r + 1.5 - 9.0
|
||
ks = [term(leds[(r, c)], "LED", "connector1") for c in range(3)]
|
||
for c in range(3):
|
||
sch_poly([ks[c], (ks[c][0], yrl)], start=(leds[(r, c)], "connector1"))
|
||
t = trans[r]
|
||
set_sch(t, (XT, yrl + 18.0 - 0.4375))
|
||
cpt, bpt, ept = term(t, "NPN", "connector2"), term(t, "NPN", "connector1"), term(t, "NPN", "connector0")
|
||
sch_poly([(ks[0][0], yrl), (ks[1][0], yrl)])
|
||
sch_poly([(ks[1][0], yrl), (ks[2][0], yrl)])
|
||
sch_poly([(ks[2][0], yrl), (cpt[0], yrl), cpt], end=(t, "connector2"))
|
||
rb = res_base[r]
|
||
# patte 1 (connector0) côté base, patte 2 côté Arduino
|
||
place_sch(rb, "RES", "connector0", (bpt[0] - 9.0, bpt[1]), rot=180, size=SCH["RES_SIZE"])
|
||
rbase, rard = term(rb, "RES", "connector0"), term(rb, "RES", "connector1")
|
||
sch_poly([rbase, bpt], start=(rb, "connector0"), end=(t, "connector1"))
|
||
pin = f"D{11 + r}"
|
||
px, py = apin(pin)
|
||
sch_poly([(px, py), (XV[r], py), (XV[r], rard[1]), rard], start=ARDP(pin), end=(rb, "connector1"))
|
||
sch_poly([ept, (X_GND_S, ept[1])], start=(t, "connector0"))
|
||
yE = ept[1]
|
||
if r == 0:
|
||
y_e0 = yE
|
||
else:
|
||
sch_poly([(X_GND_S, prev_e), (X_GND_S, yE)])
|
||
prev_e = yE
|
||
gx, gy = apin("GND")
|
||
sch_poly([(X_GND_S, prev_e), (X_GND_S, Y_GND_S), (gx, Y_GND_S), (gx, gy)], end=ARDP("GND"))
|
||
|
||
for pt, lst in ends.items():
|
||
for i in range(len(lst)):
|
||
for j in range(i + 1, len(lst)):
|
||
link("schematicView", lst[i][0], lst[i][1], "schematicTrace", lst[j][0],
|
||
lst[j][1], "schematicTrace")
|
||
|
||
# ---------------------------------------------------------------- écriture XML
|
||
def fmt(v):
|
||
return f"{v:.4f}".rstrip("0").rstrip(".") if isinstance(v, float) else str(v)
|
||
|
||
def connects_xml(inst_id, view, con, indent):
|
||
out = []
|
||
for (oid, ocon, olayer) in conns.get((inst_id, view, con), []):
|
||
out.append(f'{indent}<connect connectorId="{ocon}" modelIndex="{oid}" layer="{olayer}"/>')
|
||
return "\n".join(out)
|
||
|
||
def part_xml(inst):
|
||
L = []
|
||
L.append(f'<instance moduleIdRef="{escape(inst["module"])}" modelIndex="{inst["id"]}" '
|
||
f'path="{escape(inst["path"])}">')
|
||
for k, v in inst["props"].items():
|
||
L.append(f' <property name="{k}" value="{escape(v)}"/>')
|
||
L.append(f' <title>{escape(inst["title"])}</title>')
|
||
L.append(' <views>')
|
||
for view, g in inst["views"].items():
|
||
L.append(f' <{view} layer="{g["layer"]}">')
|
||
if g.get("m"):
|
||
m11, m12, m21, m22, m31, m32 = g["m"]
|
||
L.append(f' <geometry z="{g["z"]}" x="{fmt(g["x"])}" y="{fmt(g["y"])}">')
|
||
L.append(f' <transform m11="{fmt(m11)}" m12="{fmt(m12)}" m13="0" '
|
||
f'm21="{fmt(m21)}" m22="{fmt(m22)}" m23="0" m31="{fmt(m31)}" '
|
||
f'm32="{fmt(m32)}" m33="1"/>')
|
||
L.append(' </geometry>')
|
||
else:
|
||
L.append(f' <geometry z="{g["z"]}" x="{fmt(g["x"])}" y="{fmt(g["y"])}"/>')
|
||
cons = sorted({c for (i, v, c) in conns if i == inst["id"] and v == view}
|
||
| (set(inst.get("legs", {})) if view == "breadboardView" else set()))
|
||
if cons:
|
||
L.append(' <connectors>')
|
||
for con in cons:
|
||
L.append(f' <connector connectorId="{con}" layer="{g["layer"]}">')
|
||
if view == "breadboardView" and con in inst.get("legs", {}):
|
||
(sx, sy), (lx, ly) = inst["legs"][con]
|
||
L.append(f' <geometry x="{fmt(sx)}" y="{fmt(sy)}"/>')
|
||
L.append(' <leg><point x="0" y="0"/><bezier/>'
|
||
f'<point x="{fmt(lx)}" y="{fmt(ly)}"/><bezier/></leg>')
|
||
else:
|
||
L.append(' <geometry x="0" y="0"/>')
|
||
L.append(' <connects>')
|
||
L.append(connects_xml(inst["id"], view, con, " "))
|
||
L.append(' </connects>')
|
||
L.append(' </connector>')
|
||
L.append(' </connectors>')
|
||
L.append(f' </{view}>')
|
||
L.append(' </views>')
|
||
L.append('</instance>')
|
||
return "\n".join(L)
|
||
|
||
def wire_xml(w):
|
||
view, layer = w["view"], w["layer"]
|
||
L = [f'<instance moduleIdRef="WireModuleID" modelIndex="{w["id"]}" '
|
||
f'path=":/resources/parts/core/wire.fzp">',
|
||
f' <title>{escape(w["title"])}</title>', ' <views>',
|
||
f' <{view} layer="{layer}">',
|
||
f' <geometry z="{w.get("z", 3.5)}" x="{fmt(w["x"])}" y="{fmt(w["y"])}" x1="0" y1="0" '
|
||
f'x2="{fmt(w["dx"])}" y2="{fmt(w["dy"])}" wireFlags="{w["flags"]}"/>',
|
||
f' <wireExtras mils="{w.get("mils", "22.2222")}" color="{w["color"]}" '
|
||
f'opacity="1" banded="0"/>',
|
||
' <connectors>']
|
||
for k in ("connector0", "connector1"):
|
||
L.append(f' <connector connectorId="{k}" layer="{layer}">')
|
||
L.append(' <geometry x="0" y="0"/>')
|
||
L.append(' <connects>')
|
||
L.append(connects_xml(w["id"], view, k, " "))
|
||
L.append(' </connects>')
|
||
L.append(' </connector>')
|
||
L += [' </connectors>', f' </{view}>', ' </views>', '</instance>']
|
||
return "\n".join(L)
|
||
|
||
def build(out_path, ino_path=None):
|
||
head = '''<?xml version="1.0" encoding="UTF-8"?>
|
||
<module fritzingVersion="1.0.5" icon=".png">
|
||
<views>
|
||
<view name="breadboardView" backgroundColor="#ffffff" gridSize="0.1in" showGrid="1" alignToGrid="1" viewFromBelow="0" colorWiresByLength="0"/>
|
||
<view name="schematicView" backgroundColor="#ffffff" gridSize="0.1in" showGrid="1" alignToGrid="1" viewFromBelow="0"/>
|
||
<view name="pcbView" backgroundColor="#333333" gridSize="0.05in" showGrid="1" alignToGrid="1" viewFromBelow="0"/>
|
||
</views>
|
||
<instances>
|
||
'''
|
||
body = "\n".join(part_xml(i) for i in instances) + "\n" + "\n".join(wire_xml(w) for w in wires)
|
||
xml = head + body + "\n</instances>\n</module>\n"
|
||
name = os.path.splitext(os.path.basename(out_path))[0]
|
||
with zipfile.ZipFile(out_path, "w", zipfile.ZIP_DEFLATED) as z:
|
||
z.writestr(name + ".fz", xml)
|
||
if ino_path:
|
||
z.write(ino_path, os.path.basename(ino_path))
|
||
|
||
if __name__ == "__main__" and sys.argv[1] != "/dev/null":
|
||
build(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else None)
|
||
print(len(instances), "pièces,", len(wires), "fils")
|