From 8b414b8fdad68d2e8fd4651eae266852f0aa83a2 Mon Sep 17 00:00:00 2001 From: Jamie Drinkell <94254558+M0JXD@users.noreply.github.com> Date: Fri, 20 Sep 2024 19:23:57 +0000 Subject: [PATCH] Resistor IEC type, Buzzer Schematic Symbol and Buzzer Component (#827) * Add IEC option * Add Buzzer Schematic Symbol * Add Buzzer Component * Buzzer Symbols Cleanup Remove unused libraries, Datasheet stuff etc. * ResistorSymbol Cleanup --- .../src/org/diylc/components/misc/Buzzer.java | 226 ++++++++++++++++++ .../diylc/components/misc/BuzzerSymbol.java | 150 ++++++++++++ .../components/passive/ResistorSymbol.java | 70 ++++-- 3 files changed, 427 insertions(+), 19 deletions(-) create mode 100644 diylc/diylc-library/src/org/diylc/components/misc/Buzzer.java create mode 100644 diylc/diylc-library/src/org/diylc/components/misc/BuzzerSymbol.java diff --git a/diylc/diylc-library/src/org/diylc/components/misc/Buzzer.java b/diylc/diylc-library/src/org/diylc/components/misc/Buzzer.java new file mode 100644 index 00000000..3b2941a5 --- /dev/null +++ b/diylc/diylc-library/src/org/diylc/components/misc/Buzzer.java @@ -0,0 +1,226 @@ +/* + + DIY Layout Creator (DIYLC). + Copyright (c) 2009-2018 held jointly by the individual authors. + + This file is part of DIYLC. + + DIYLC is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + DIYLC is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with DIYLC. If not, see . + +*/ +package org.diylc.components.misc; + +import java.awt.Color; +import java.awt.Graphics2D; +import java.awt.Shape; +import java.awt.geom.Ellipse2D; +import java.awt.geom.Line2D; +import java.awt.geom.RoundRectangle2D; +import org.diylc.components.passive.AbstractRadialComponent; +import org.diylc.components.transform.SimpleComponentTransformer; +import org.diylc.core.CreationMethod; +import org.diylc.core.IDIYComponent; +import org.diylc.core.annotations.ComponentDescriptor; +import org.diylc.core.annotations.EditableProperty; +import org.diylc.core.annotations.PositiveMeasureValidator; +import org.diylc.core.measures.Voltage; +import org.diylc.core.measures.Size; +import org.diylc.core.measures.SizeUnit; + +@ComponentDescriptor(name = "PCB Buzzer", author = "M0JXD", category = "Misc", + creationMethod = CreationMethod.POINT_BY_POINT, instanceNamePrefix = "BZ", + description = "Vertically mounted Buzzer, active or passive", zOrder = IDIYComponent.COMPONENT, + transformer = SimpleComponentTransformer.class) +public class Buzzer extends AbstractRadialComponent { + // This component was forked from the Radial Capacitor, massive thanks to Bancika! + private static final long serialVersionUID = 1L; + + public static Size DEFAULT_SIZE = new Size(12d, SizeUnit.mm); + public static Color BODY_COLOR = Color.decode("#333333"); + public static Color BORDER_COLOR = BODY_COLOR.darker(); + public static Color MARKER_COLOR = Color.decode("#8CACEA"); + public static Color HOLE_COLOR = Color.decode("#9a97a8"); + public static Size HEIGHT = new Size(8.5d, SizeUnit.mm); + public static Size EDGE_RADIUS = new Size(1d, SizeUnit.mm); + public static Size PIN_SPACING = new Size(0.3d, SizeUnit.in); + + private Voltage value = null; + private Color markerColor = MARKER_COLOR; + private Color holeColor = HOLE_COLOR; + private boolean polarized = false; + private boolean folded = false; + private Size height = HEIGHT; + private boolean invert = false; + + public Buzzer() { + super(); + this.bodyColor = BODY_COLOR; + this.borderColor = BORDER_COLOR; + this.labelColor = Color.white; + setPinSpacing(PIN_SPACING); + } + + public Buzzer(String[] model) { + this(); + } + + @EditableProperty(validatorClass = PositiveMeasureValidator.class) + public Voltage getValue() { + return value; + } + + public void setValue(Voltage value) { + this.value = value; + } + + @Override + public String getValueForDisplay() { + return (getValue() == null ? "" : getValue().toString()) + (getValue() == null ? "" : " " + getValue().toString()); + } + + public void drawIcon(Graphics2D g2d, int width, int height) { + g2d.setColor(BODY_COLOR); + int margin = 3; + Ellipse2D body = + new Ellipse2D.Double(margin, margin, getClosestOdd(width - 2 * margin), getClosestOdd(width - 2 * margin)); + g2d.fill(body); + g2d.draw(body); + + // Add centre hole + + g2d.setColor(HOLE_COLOR); + double start_point = (width / 2) - (margin / 4) - 0.4; + Ellipse2D hole = + new Ellipse2D.Double(start_point, start_point, margin * 1.4, margin * 1.4); + g2d.fill(hole); + g2d.draw(hole); + } + + @Override + protected void decorateComponentBody(Graphics2D g2d, boolean outlineMode) { + + double width = getLength().convertToPixels(); + + // Add the hole in the middle + if (!folded) { + g2d.setColor(HOLE_COLOR); + double start_point = (width / 2) - width * 0.1; + Ellipse2D hole = + new Ellipse2D.Double(start_point, start_point, width * 0.2, width * 0.2); + g2d.fill(hole); + g2d.draw(hole); + } + + // Add polarity mark if desired + if (polarized && !folded) { + g2d.setColor(Color.white); + + // Vertical + g2d.draw(new Line2D.Double(width * 0.19, width * 0.4, width * 0.19, width * 0.6)); + // Horizontal + g2d.draw(new Line2D.Double(width * 0.08, width * 0.5, width * 0.30, width * 0.5)); + + } + } + + @Override + protected Size getDefaultWidth() { + return null; + } + + @Override + public Size getWidth() { + return super.getWidth(); + } + + @Override + protected Size getDefaultLength() { + // We'll reuse width property to set the diameter. + return DEFAULT_SIZE; + } + + @EditableProperty(name = "Diameter") + @Override + public Size getLength() { + return super.getLength(); + } + + @EditableProperty(name = "Marker") + public Color getMarkerColor() { + return markerColor; + } + + public void setMarkerColor(Color coverColor) { + this.markerColor = coverColor; + } + + @EditableProperty(name = "Hole") + public Color getHoleColor() { + return holeColor; + } + + public void setHoleColor(Color holeColor) { + this.holeColor = holeColor; + } + + @EditableProperty(name = "Polarized") + public boolean getPolarized() { + return polarized; + } + + public void setPolarized(boolean polarized) { + this.polarized = polarized; + } + + @EditableProperty + public boolean getFolded() { + return folded; + } + + public void setFolded(boolean folded) { + this.folded = folded; + } + + @EditableProperty + public Size getHeight() { + if (height == null) { + height = HEIGHT; + } + return height; + } + + public void setHeight(Size height) { + this.height = height; + } + + @EditableProperty(name = "Invert Polarity") + public boolean getInvert() { + return invert; + } + + public void setInvert(boolean invert) { + this.invert = invert; + } + + @Override + protected Shape getBodyShape() { + double height = (int) getHeight().convertToPixels(); + double diameter = (int) getLength().convertToPixels(); + if (folded) { + return new RoundRectangle2D.Double(0f, -height / 2 - LEAD_THICKNESS.convertToPixels() / 2, + getClosestOdd(diameter), getClosestOdd(height), EDGE_RADIUS.convertToPixels(), EDGE_RADIUS.convertToPixels()); + } + return new Ellipse2D.Double(0f, 0f, getClosestOdd(diameter), getClosestOdd(diameter)); + } +} diff --git a/diylc/diylc-library/src/org/diylc/components/misc/BuzzerSymbol.java b/diylc/diylc-library/src/org/diylc/components/misc/BuzzerSymbol.java new file mode 100644 index 00000000..84d4193c --- /dev/null +++ b/diylc/diylc-library/src/org/diylc/components/misc/BuzzerSymbol.java @@ -0,0 +1,150 @@ +/* + + DIY Layout Creator (DIYLC). + Copyright (c) 2009-2018 held jointly by the individual authors. + + This file is part of DIYLC. + + DIYLC is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + DIYLC is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with DIYLC. If not, see . + +*/ +package org.diylc.components.misc; + +import java.awt.Graphics2D; +import java.awt.Shape; +import java.awt.geom.Arc2D; +import java.awt.geom.Line2D; +import java.awt.geom.GeneralPath; +import java.lang.Math; +import org.diylc.components.AbstractSchematicLeadedSymbol; +import org.diylc.core.CreationMethod; +import org.diylc.core.IDIYComponent; +import org.diylc.core.annotations.ComponentDescriptor; +import org.diylc.core.annotations.EditableProperty; +import org.diylc.core.measures.Size; +import org.diylc.core.measures.SizeUnit; +import org.diylc.core.measures.VoltageUnit; + +@ComponentDescriptor(name = "Buzzer Symbol", author = "JD", category = "Schematic Symbols", + creationMethod = CreationMethod.POINT_BY_POINT, instanceNamePrefix = "BZ", description = "Buzzer schematic symbol", + zOrder = IDIYComponent.COMPONENT) +public class BuzzerSymbol extends AbstractSchematicLeadedSymbol { + private static final long serialVersionUID = 1L; + + private String value = "Buzzer Symbol"; + + public static Size DEFAULT_LENGTH = new Size(48.0, SizeUnit.px); + public static Size DEFAULT_WIDTH = new Size(120.0, SizeUnit.px); + + private org.diylc.core.measures.Voltage voltageNew = new org.diylc.core.measures.Voltage(12d, VoltageUnit.V); + + @Override + public String getValueForDisplay() { + return getValue().toString() + (getVoltageNew() == null ? "" : " " + getVoltageNew().toString()); + } + + @EditableProperty + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + + @EditableProperty(name = "Voltage") + public org.diylc.core.measures.Voltage getVoltageNew() { + return voltageNew; + } + + public void setVoltageNew(org.diylc.core.measures.Voltage voltageNew) { + this.voltageNew = voltageNew; + } + + + @Override + protected Size getDefaultWidth() { + return DEFAULT_WIDTH; + } + + @Override + protected Size getDefaultLength() { + return DEFAULT_LENGTH; + } + + @Override + protected Shape getBodyShape() { + // Divide by two as the whole thing sits "above" zero + // see useShapeRectAsPosition to understand + double length = getLength().convertToPixels(); + double width = getWidth().convertToPixels() / 2; + + Arc2D.Double arc = new Arc2D.Double(0, 0, length, length, 180, 180, Arc2D.CHORD); + + // width * 0.75 is an approx. Sqrt method seems a bit off? (maybe my maths sucks...) + Line2D.Double left_leads = new Line2D.Double(length * 0.25, width * 0.75, length * 0.25, width); + Line2D.Double right_leads = new Line2D.Double(length * 0.75, width * 0.75, length * 0.75, width); + + Line2D.Double left_leads_bottom = new Line2D.Double(length * 0.25, width, 0, width); + Line2D.Double right_leads_bottom = new Line2D.Double(length * 0.75, width, length, width); + + GeneralPath buzzer = new GeneralPath(); + buzzer.append(arc, false); + buzzer.append(left_leads, false); + buzzer.append(right_leads, false); + buzzer.append(right_leads_bottom, false); + buzzer.append(left_leads_bottom, false); + return buzzer; + } + + @Override + protected void decorateComponentBody(Graphics2D g2d, boolean outlineMode) { + // Could maybe add a Plus Sign for active buzzers? + } + + public void drawIcon(Graphics2D g2d, int width, int height) { + g2d.rotate(-Math.PI / 4, width / 2, height / 2); + g2d.setColor(COLOR); + + Arc2D.Double arc = new Arc2D.Double(width * 0.2, height * 0.1, width * 0.6, height * 0.6, 180, 180, Arc2D.CHORD); + g2d.draw(arc); + + Line2D.Double left_leads = new Line2D.Double(width * 0.35, height * 0.681, width * 0.35, height * 0.8); + Line2D.Double right_leads = new Line2D.Double(width * 0.65, width * 0.681, width * 0.65, height * 0.8); + g2d.draw(left_leads); + g2d.draw(right_leads); + + Line2D.Double left_leads_bottom = new Line2D.Double(width * 0.2, height * 0.8, width * 0.35, height * 0.8); + Line2D.Double right_leads_bottom = new Line2D.Double(width * 0.65, height * 0.8, width * 0.8, height * 0.8); + g2d.draw(left_leads_bottom); + g2d.draw(right_leads_bottom); + + // extensions in lead colour + g2d.setColor(LEAD_COLOR); + Line2D.Double left_lead_ext = new Line2D.Double(0, height * 0.8, width * 0.2, height * 0.8); + Line2D.Double right_lead_ext = new Line2D.Double(width * 0.8, height * 0.8, width, height * 0.8); + g2d.draw(left_lead_ext); + g2d.draw(right_lead_ext); + } + + @Override + public String getControlPointNodeName(int index) { + return getName() + "." + (index == 0 ? "+" : "-"); + } + + @Override + protected boolean useShapeRectAsPosition() { + return false; + } +} diff --git a/diylc/diylc-library/src/org/diylc/components/passive/ResistorSymbol.java b/diylc/diylc-library/src/org/diylc/components/passive/ResistorSymbol.java index b6d0a864..a8532c90 100644 --- a/diylc/diylc-library/src/org/diylc/components/passive/ResistorSymbol.java +++ b/diylc/diylc-library/src/org/diylc/components/passive/ResistorSymbol.java @@ -20,7 +20,7 @@ */ package org.diylc.components.passive; - + import java.awt.Graphics2D; import java.awt.Shape; import java.awt.geom.GeneralPath; @@ -45,7 +45,8 @@ public class ResistorSymbol extends AbstractSchematicLeadedSymbol { private static final long serialVersionUID = 1L; public static Size DEFAULT_LENGTH = new Size(0.3, SizeUnit.in); - public static Size DEFAULT_WIDTH = new Size(0.08, SizeUnit.in); + public static Size DEFAULT_WIDTH = new Size(0.08, SizeUnit.in); + private DrawStyle draw_style = DrawStyle.ANSI; private Resistance value = null; @Deprecated @@ -89,6 +90,18 @@ public class ResistorSymbol extends AbstractSchematicLeadedSymbol { public void setPowerNew(org.diylc.core.measures.Power powerNew) { this.powerNew = powerNew; + } + + @EditableProperty(name = "Draw Standard") + public DrawStyle getDrawStandard() { + if (draw_style == null) { + draw_style = DrawStyle.ANSI; + } + return draw_style; + } + + public void setDrawStandard(DrawStyle draw_style) { + this.draw_style = draw_style; } @@ -113,20 +126,39 @@ public class ResistorSymbol extends AbstractSchematicLeadedSymbol { } @Override - protected Shape getBodyShape() { - GeneralPath polyline = new GeneralPath(); - double length = getLength().convertToPixels(); - double width = getWidth().convertToPixels(); - polyline.moveTo(0, width / 2); - polyline.lineTo(length / 16, width); - polyline.lineTo(3 * length / 16, 0); - polyline.lineTo(5 * length / 16, width); - polyline.lineTo(7 * length / 16, 0); - polyline.lineTo(9 * length / 16, width); - polyline.lineTo(11 * length / 16, 0); - polyline.lineTo(13 * length / 16, width); - polyline.lineTo(15 * length / 16, 0); - polyline.lineTo(length, width / 2); - return polyline; - } -} + protected Shape getBodyShape() { + double length = getLength().convertToPixels(); + double width = getWidth().convertToPixels(); + if(getDrawStandard() == DrawStyle.ANSI) { + GeneralPath polyline = new GeneralPath(); + polyline.moveTo(0, width / 2); + polyline.lineTo(length / 16, width); + polyline.lineTo(3 * length / 16, 0); + polyline.lineTo(5 * length / 16, width); + polyline.lineTo(7 * length / 16, 0); + polyline.lineTo(9 * length / 16, width); + polyline.lineTo(11 * length / 16, 0); + polyline.lineTo(13 * length / 16, width); + polyline.lineTo(15 * length / 16, 0); + polyline.lineTo(length, width / 2); + return polyline; + } + + // (getDrawStandard() == DrawStyle.IEC) + else { + GeneralPath resistorShape = new GeneralPath(); + resistorShape.moveTo(0f, 0f); + resistorShape.lineTo(0f, width); + resistorShape.lineTo(length, width); + resistorShape.lineTo(length, 0f); + resistorShape.lineTo(0f, 0f); + return resistorShape; + } + } + + public enum DrawStyle { + ANSI, IEC + } +} + +