breadkit 0.1.0 → 0.2.0

data/lib/breadkit/templates/555.bk.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+title "NE555 astable LED blinker"
+board :half
+supply :USB, voltage: 5, plus: "B+1", minus: "B-1"
+net :VCC, at: "B+1"
+net :GND, at: "B-1"
+
+ic :U1, "NE555", at: "e20"
+resistor :R1, "1k", pins: %w[g30 g21]
+resistor :R2, "10k", pins: %w[h21 h22]
+resistor :R3, "330", pins: %w[a22 a25]
+capacitor :C1, "10n", pins: %w[h23 h24]
+electrolytic :C2, "100u", plus: "g22", minus: "j24"
+led :D1, color: :red, anode: "b25", cathode: "b27"
+
+wire "i30", "B+", color: :red
+wire "g20", "B+", color: :red
+wire "b20", "B-", color: :black
+wire "b21", "i22", color: :yellow
+wire "a23", "B+", color: :red
+wire "a27", "B-", color: :black
+wire "i24", "B-", color: :black
+
+expect do
+  connected "U1.1", :GND
+  connected "U1.2", "U1.6", "C2.plus"
+  connected "U1.4", :VCC
+  connected "U1.8", :VCC
+  connected "U1.3", "R3.1"
+  connected "R3.2", "D1.anode"
+  connected "D1.cathode", :GND
+  isolated :VCC, :GND
+end

data/lib/breadkit/templates/arduino.bk.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+title "Arduino UNO LED"
+board :half
+offboard :UNO, "arduino_uno", side: :left
+
+resistor :R1, "330", pins: %w[a10 a14]
+led :D1, color: :red, anode: "b14", cathode: "b16"
+
+wire "UNO.D13", "c10", color: :yellow
+wire "a16", "UNO.GND", color: :black
+
+expect do
+  connected "UNO.D13", "R1.1"
+  connected "R1.2", "D1.anode"
+  connected "D1.cathode", "UNO.GND"
+end

data/lib/breadkit/templates/led.bk.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+title "LED with current-limiting resistor"
+board :half
+
+supply :USB, voltage: 5, plus: "B+1", minus: "B-1"
+net :VCC, at: "B+1"
+net :GND, at: "B-1"
+
+resistor :R1, "330", pins: %w[a10 a14]
+led :D1, color: :red, anode: "b14", cathode: "b16"
+
+wire "c10", "B+", color: :red
+wire "a16", "B-", color: :black
+
+expect do
+  connected :VCC, "R1.1"
+  connected "R1.2", "D1.anode"
+  connected "D1.cathode", :GND
+  isolated :VCC, :GND
+end

data/lib/breadkit/value.rb

@@ -2,6 +2,7 @@
 
 module Breadkit
   class Value
+    QUALIFIER = /\s+(\d+(?:\.\d+)?%|\d+(?:\.\d+)?(?:\/\d+(?:\.\d+)?)?[WV])\z/i
     MULTIPLIERS = { "p" => 1e-12, "n" => 1e-9, "u" => 1e-6, "m" => 1e-3,
                     "R" => 1.0, "r" => 1.0, "k" => 1e3, "K" => 1e3,
                     "M" => 1e6, "G" => 1e9 }.freeze
@@ -13,7 +14,7 @@ module Breadkit
     def self.parse(input)
       return input.to_f if input.is_a?(Numeric)
 
-      text = input.to_s.strip.sub(/(?:Ω|Ω|ohm|[FfHhVv])\z/i, "").tr("µμ", "uu")
+      text = split_spec(input).first.sub(/(?:Ω|Ω|ohm|[FfHhVv])\z/i, "").tr("µμ", "uu")
       if (match = /\A(\d*)([pnuRrmkKMG])(\d+)\z/.match(text))
         whole = match[1].empty? ? 0 : match[1].to_i
         return (whole + match[3].to_f / (10**match[3].length)) * MULTIPLIERS.fetch(match[2])
@@ -24,8 +25,46 @@ module Breadkit
       match[1].to_f * MULTIPLIERS.fetch(match[2], 1.0)
     end
 
-    def initialize(value)
-      @unit = value.to_s.strip[/\A.*?(Ω|Ω|ohm|[FfHhVv])\z/i, 1]&.then { |suffix| %w[Ω Ω ohm].include?(suffix.downcase) ? "Ω" : suffix.upcase } || "Ω"
+    def self.tolerance(input)
+      suffix = split_spec(input).last.find { |item| item.end_with?("%") }
+      suffix && suffix.to_f / 100.0
+    end
+
+    def self.power_rating(input)
+      suffix = split_spec(input).last.find { |item| item.upcase.end_with?("W") }
+      return unless suffix
+
+      quantity = suffix[0...-1]
+      quantity.include?("/") ? quantity.split("/").map(&:to_f).reduce(:/) : quantity.to_f
+    end
+
+    def self.voltage_rating(input)
+      suffix = split_spec(input).last.find { |item| item.upcase.end_with?("V") }
+      suffix&.to_f
+    end
+
+    def self.split_spec(input)
+      base = input.to_s.strip
+      qualifiers = []
+      while (match = QUALIFIER.match(base))
+        qualifiers.unshift(match[1])
+        base = base[0...match.begin(0)]
+      end
+      kinds = qualifiers.map { |item| item[-1].upcase }
+      raise ArgumentError, "duplicate value qualifier: #{input.inspect}" unless kinds.uniq == kinds
+      qualifiers.each do |item|
+        quantity = item[0...-1]
+        numbers = quantity.split("/").map(&:to_f)
+        invalid = numbers.any? { |number| !number.finite? || !number.positive? } || (item.end_with?("%") && numbers.first >= 100)
+        raise ArgumentError, "invalid value qualifier: #{item}" if invalid
+      end
+      [base, qualifiers]
+    end
+
+    def initialize(value, category: nil)
+      explicit = self.class.split_spec(value).first[/\A.*?(Ω|Ω|ohm|[FfHhVv])\z/i, 1]
+      @unit = explicit&.then { |suffix| %w[Ω Ω ohm].include?(suffix.downcase) ? "Ω" : suffix.upcase } ||
+              { resistor: "Ω", capacitor: "F", electrolytic: "F", inductor: "H", supply: "V" }.fetch(category&.to_sym, "")
       @value = self.class.parse(value)
       freeze
     end

data/lib/breadkit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Breadkit
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/breadkit/wire_suggestions.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Breadkit
+  class WireSuggestions
+    def initialize(circuit)
+      @circuit = circuit
+    end
+
+    def call
+      return [] if circuit.diagnostics.any? { |item| item.severity == "error" }
+      return [] unless circuit.potentials.conflicts.empty?
+
+      occupied = occupied_holes
+      bodies = component_bodies
+      proposed_nets = UnionFind.new
+      proposed_potentials = {}
+      circuit.expectations.flat_map do |group|
+        next [] if group[:when] || group["when"]
+
+        Array(group[:entries] || group["entries"]).filter_map do |entry|
+          next unless (entry[:kind] || entry["kind"]) == "connected"
+
+          refs = Array(entry[:refs] || entry["refs"]).map(&:to_s)
+          next unless refs.length == 2
+
+          first, second = refs.map { |ref| placed_pin_hole(ref) }
+          next unless first && second
+          left_net, right_net = refs.map { |ref| circuit.net_of(ref) }
+          next unless left_net && right_net && left_net != right_net
+
+          left_root = proposed_nets.find(left_net.name)
+          right_root = proposed_nets.find(right_net.name)
+          next if left_root == right_root
+
+          left_potential = proposed_potentials.fetch(left_root, left_net.potential)
+          right_potential = proposed_potentials.fetch(right_root, right_net.potential)
+          next if left_potential && right_potential && (left_potential - right_potential).abs > 1e-9
+
+          left = free_strip_holes(first, occupied, bodies)
+          right = free_strip_holes(second, occupied, bodies)
+          next if left.empty? || right.empty?
+
+          from, to = left.product(right).min_by do |a, b|
+            [(a.x - b.x)**2 + (a.y - b.y)**2, a.x, a.y, b.x, b.y, a.id, b.id]
+          end
+          occupied[from.id] = true
+          occupied[to.id] = true
+          proposed_nets.union(left_root, right_root)
+          proposed_potentials[proposed_nets.find(left_root)] = left_potential || right_potential
+          { from: from.id, to: to.id, refs: refs }
+        end
+      end.uniq
+    end
+
+    private
+
+    attr_reader :circuit
+
+    def placed_pin_hole(reference)
+      parsed = HoleId.parse(reference, board: circuit.board)
+      return unless parsed.kind == :pin
+
+      hole_id = circuit.components[parsed.ref]&.pin(parsed.pin)&.hole_id
+      hole_id if hole_id && circuit.board.hole(hole_id)
+    rescue ArgumentError
+      nil
+    end
+
+    def free_strip_holes(pin_hole, occupied, bodies)
+      Array(circuit.board.strip(pin_hole)).filter_map { |id| circuit.board.hole(id) }
+        .reject { |hole| occupied[hole.id] || bodies.any? { |body| covered?(hole, body) } }
+    end
+
+    def occupied_holes
+      ids = circuit.components.values.flat_map { |component| component.pins.values.filter_map(&:hole_id) }
+      ids.concat(circuit.supplies.flat_map { |supply| [supply.plus, supply.minus] })
+      circuit.wires.each do |wire|
+        next if wire.electrical == false
+
+        [wire.from, wire.to].each do |endpoint|
+          hole = circuit.board.hole(endpoint)
+          ids << hole.id if hole
+        end
+      end
+      ids.to_h { |id| [id, true] }
+    end
+
+    def component_bodies
+      circuit.components.values.filter_map do |component|
+        component.body_bounds(circuit.board)
+      end
+    end
+
+    def covered?(hole, bounds)
+      left, top, width, height = bounds
+      hole.x > left + 1e-6 && hole.x < left + width - 1e-6 &&
+        hole.y > top + 1e-6 && hole.y < top + height - 1e-6
+    end
+  end
+
+  class Circuit
+    def wire_suggestions
+      WireSuggestions.new(self).call
+    end
+  end
+end

data/lib/breadkit.rb

@@ -6,21 +6,46 @@ require "did_you_mean"
 
 require_relative "breadkit/version"
 require_relative "breadkit/value"
+require_relative "breadkit/color"
 require_relative "breadkit/hole_id"
 require_relative "breadkit/model"
 require_relative "breadkit/board"
 require_relative "breadkit/part_library"
 require_relative "breadkit/dsl"
+require_relative "breadkit/structured_input"
+require_relative "breadkit/part_lock"
+require_relative "breadkit/formatter"
 require_relative "breadkit/resolver"
 require_relative "breadkit/analysis"
+require_relative "breadkit/wire_suggestions"
+require_relative "breadkit/jumper_kit"
+require_relative "breadkit/dc_analysis"
+require_relative "breadkit/patterns"
 require_relative "breadkit/ir"
+require_relative "breadkit/exporters"
+require_relative "breadkit/fritzing_export"
 require_relative "breadkit/cli"
 
 module Breadkit
   class Error < StandardError; end
-  class DSLError < Error; end
+  class DSLError < Error
+    attr_reader :location
 
-  def self.load(path)
-    path.end_with?(".json") ? IR::Reader.new.read_file(path) : Resolver.new.call(DSL.load_file(path))
+    def initialize(message, location: nil)
+      super(message)
+      @location = location
+    end
+  end
+
+  def self.load(path, timeout: 10)
+    return IR::Reader.new.read_file(path) if path.end_with?(".json")
+
+    document = if path.end_with?(".bk.yml", ".bk.yaml", ".bk.toml")
+      StructuredInput.load_file(path)
+    else
+      DSL.load_file(path, timeout: timeout)
+    end
+    PartLock.verify(document, path)
+    Resolver.new.call(document)
   end
 end

data/package.json

@@ -3,7 +3,7 @@
   "private": true,
   "version": "0.0.0",
   "scripts": {
-    "build": "mkdir -p _site && cp -R site/. _site/ && tailwindcss -i site/styles.css -o _site/assets/site.css --minify"
+    "build": "mkdir -p _site/schema && cp -R site/. _site/ && cp -R schema/. _site/schema/ && tailwindcss -i site/styles.css -o _site/assets/site.css --minify"
   },
   "devDependencies": {
     "@tailwindcss/cli": "4.3.3",

data/schema/board-v1.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://breadkit.github.io/breadkit/schema/board-v1.json",
+  "title": "Breadkit board definition v1",
+  "type": "object",
+  "required": ["id", "terminal"],
+  "properties": {
+    "id": { "type": "string", "minLength": 1 },
+    "name": { "type": "string" },
+    "ground_labels": { "type": "array", "items": { "type": "string" } },
+    "terminal": {
+      "type": "object", "required": ["columns", "rows", "groups"],
+      "properties": {
+        "columns": { "type": "integer", "minimum": 1 },
+        "rows": { "type": "array", "minItems": 1, "items": { "type": "string", "minLength": 1 } },
+        "groups": { "type": "array", "items": { "type": "array", "minItems": 1, "items": { "type": "string" } } },
+        "ravine_between": { "type": "array", "prefixItems": [{ "type": "string" }, { "type": "string" }], "minItems": 2, "maxItems": 2 },
+        "strip_direction": { "enum": ["column", "row"] },
+        "wire_attachment": { "enum": ["socket", "solder"] }
+      }, "additionalProperties": false
+    },
+    "rails": {
+      "type": "array", "items": { "type": "object", "required": ["id", "side", "order"],
+        "properties": { "id": { "type": "string" }, "side": { "enum": ["top", "bottom", "left", "right", "center"] }, "order": { "type": "integer", "minimum": 0 }, "polarity": { "enum": ["+", "-"] } },
+        "additionalProperties": false }
+    },
+    "rail_layout": {
+      "type": "object", "required": ["segments"],
+      "properties": {
+        "holes": { "type": "integer", "minimum": 1 }, "group_size": { "type": "integer", "minimum": 1 },
+        "start_column": { "type": "integer", "minimum": 1 }, "start_row": { "type": "integer", "minimum": 1 },
+        "segments": { "$ref": "#/$defs/segments" }, "split_segments": { "$ref": "#/$defs/segments" }
+      }, "additionalProperties": false
+    }
+  },
+  "additionalProperties": false,
+  "$defs": { "segments": { "type": "array", "items": { "type": "array", "prefixItems": [{ "type": "integer" }, { "type": "integer" }], "minItems": 2, "maxItems": 2 } } }
+}

data/schema/ir-v1.json

@@ -1,21 +1,16 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://breadkit.github.io/breadkit/schema/ir-v1.json",
   "title": "Breadkit IR v1",
   "type": "object",
   "required": ["schema_version", "title", "board", "components", "wires", "supplies", "labels", "expectations"],
   "properties": {
     "schema_version": { "const": 1 },
+    "source_root": { "type": "string" },
     "title": { "type": ["string", "null"] },
-    "part_definitions": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "required": ["id", "pins"],
-        "properties": { "id": { "type": "string" }, "pins": { "type": "array", "items": { "type": "object" } } },
-        "additionalProperties": true
-      }
-    },
-    "board_definition": { "type": "object" },
+    "steps": { "type": "array", "items": { "$ref": "#/$defs/step" } },
+    "part_definitions": { "type": "array", "items": { "$ref": "#/$defs/partDefinition" } },
+    "board_definition": { "$ref": "#/$defs/boardDefinition" },
     "lint_disables": { "type": "array", "items": { "type": "object" } },
     "board": {
       "type": "object",
@@ -38,12 +33,53 @@
   },
   "additionalProperties": true,
   "$defs": {
+    "partDefinition": {
+      "type": "object", "required": ["id", "pins"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "datasheet_url": { "type": "string", "format": "uri", "pattern": "^https://" },
+        "pins": { "type": "array", "items": { "type": "object", "required": ["num"],
+          "properties": { "num": { "type": ["string", "integer"] }, "name": { "type": "string" }, "type": { "type": "string" }, "role": { "type": "string" }, "max_current": { "type": "number", "exclusiveMinimum": 0 } } } },
+        "placement": { "enum": ["leads", "dip", "footprint", "offboard"] },
+        "max_lead_span_mm": { "type": "number", "exclusiveMinimum": 0 },
+        "polarity": { "type": "object" }, "footprint": { "type": "object" },
+        "provides": { "type": "array", "items": { "type": "object", "required": ["positive", "negative", "voltage"],
+          "properties": { "positive": { "type": "string" }, "negative": { "type": "string" }, "voltage": { "type": "number", "exclusiveMinimum": 0 } } } }
+      }
+    },
+    "boardDefinition": {
+      "type": "object", "required": ["id", "terminal"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "terminal": { "type": "object", "required": ["columns", "rows", "groups"],
+          "properties": {
+            "columns": { "type": "integer", "minimum": 1 },
+            "rows": { "type": "array", "items": { "type": "string" } },
+            "groups": { "type": "array", "items": { "type": "array", "items": { "type": "string" } } },
+            "ravine_between": { "type": "array", "items": { "type": "string" }, "minItems": 2, "maxItems": 2 },
+            "strip_direction": { "enum": ["column", "row"] },
+            "wire_attachment": { "enum": ["socket", "solder"] }
+          } },
+        "rails": { "type": "array", "items": { "type": "object", "required": ["id"],
+          "properties": { "id": { "type": "string" }, "side": { "type": "string" }, "order": { "type": "integer" }, "polarity": { "enum": ["+", "-"] } } } },
+        "rail_layout": { "type": "object", "properties": { "segments": { "type": "array" }, "split_segments": { "type": "array" } } }
+      }
+    },
     "source": {
       "type": "object",
       "required": ["path", "line"],
       "properties": { "path": { "type": "string" }, "line": { "type": "integer", "minimum": 1 } }
     },
     "nullableSource": { "anyOf": [{ "type": "null" }, { "$ref": "#/$defs/source" }] },
+    "step": {
+      "type": "object",
+      "required": ["number"],
+      "properties": {
+        "number": { "type": "integer", "minimum": 1 },
+        "title": { "type": ["string", "null"], "minLength": 1 },
+        "source": { "$ref": "#/$defs/nullableSource" }
+      }
+    },
     "location": {
       "type": "object",
       "required": ["path", "line"],
@@ -59,6 +95,7 @@
         "attrs": { "type": "object" },
         "pins": { "type": "object", "additionalProperties": { "type": ["string", "null"] } },
         "unused": { "type": "array", "items": { "type": "string" } },
+        "step": { "type": "integer", "minimum": 1 },
         "source": { "$ref": "#/$defs/nullableSource" }
       }
     },
@@ -71,6 +108,7 @@
         "to": { "type": "string" },
         "color": { "type": ["string", "null"] },
         "route": { "type": "string" },
+        "step": { "type": "integer", "minimum": 1 },
         "source": { "$ref": "#/$defs/nullableSource" }
       }
     },
@@ -80,8 +118,12 @@
       "properties": {
         "name": { "type": "string" },
         "voltage": { "type": "number" },
+        "isolated": { "type": "boolean" },
+        "voltage_range": { "type": ["array", "null"], "prefixItems": [{ "type": "number", "exclusiveMinimum": 0 }, { "type": "number", "exclusiveMinimum": 0 }], "minItems": 2, "maxItems": 2 },
+        "current_limit": { "type": ["number", "null"], "exclusiveMinimum": 0 },
         "plus": { "type": "string" },
         "minus": { "type": "string" },
+        "step": { "type": "integer", "minimum": 1 },
         "source": { "$ref": "#/$defs/nullableSource" }
       }
     },
@@ -91,6 +133,7 @@
       "properties": {
         "net": { "type": "string" },
         "at": { "type": "string" },
+        "step": { "type": "integer", "minimum": 1 },
         "source": { "$ref": "#/$defs/nullableSource" }
       }
     },
@@ -99,14 +142,16 @@
       "required": ["strict", "entries", "location"],
       "properties": {
         "strict": { "type": "boolean" },
+        "when": { "type": "string", "minLength": 1 },
         "entries": {
           "type": "array",
           "items": {
             "type": "object",
             "required": ["kind", "refs", "location"],
             "properties": {
-              "kind": { "enum": ["connected", "isolated", "net"] },
+              "kind": { "enum": ["connected", "isolated", "net", "voltage", "current"] },
               "refs": { "type": "array", "items": { "type": "string" } },
+              "range": { "type": "array", "items": { "type": "number" }, "minItems": 2, "maxItems": 2 },
               "location": { "$ref": "#/$defs/location" }
             }
           }