Translation status

9,437 Strings 100%
Browse Translate
50,287 Words 100%
321,211 Characters 100%

Strings status

Strings Words Characters
9,437 50,287 321,211
All strings Browse Translate Zen
9,437 50,287 321,211
Translated strings Browse Translate Zen
66 86 561
Translated strings with dismissed checks Browse Translate Zen
1 1 9
Strings with comments Browse Translate Zen

Other components

Component Translated Unfinished Unfinished words Unfinished characters Untranslated Checks Suggestions Comments
v8 GPL-3.0 99% 2 58 328 1 57 0 0
Browse all components

Overview

Project website www.kicad.org
Instructions for translators

Does KiCad in your native language still have a few English menu options or text blocks? Or maybe you are fluent in a language that KiCad doesn’t yet have? If so, then we’d love for you to contribute to the translation!

To get started with translation, you can use Weblate here to build up the existing translations or start a new translation all together.

Whether you update one string or all of them, you’ve helped improve KiCad for other users! Mailing list for translators: <<kicad-doc-devs@lists.launchpad.net>
Project maintainers User avatar sethhillbrand User avatar craftyjon User avatar imcinerney
Translation license GNU General Public License v3.0 or later
Translation process
  • Translations can be made directly.
  • Translation suggestions can be made.
  • Any authenticated user can contribute.
  • The translation uses bilingual files.
Source code repository git@gitlab.com:kicad/code/kicad.git
Repository branch master
Last remote commit Fix KeepUpright settings in Eagle gold files. aa1fb0604a
User avatar Jeff_Young authored 21 hours ago
Last commit in Weblate Translated using Weblate (Czech) d372271c34
User avatar Bach authored yesterday
Weblate repository https://hosted.weblate.org/git/kicad/master-source/
File mask translation/pofiles/*.po
Translation file Download translation/pofiles/pl.po
Last change May 26, 2024, 10:09 a.m.
Last author None
6 days ago

String statistics

Strings percent Hosted strings Words percent Hosted words Characters percent Hosted characters
Total 9,437 50,287 321,211
Translated 100% 9,437 100% 50,287 100% 321,211
Needs editing 0% 0 0% 0 0% 0
Read-only 0% 0 0% 0 0% 0
Failing checks 0% 0 0% 0 0% 0
Strings with suggestions 0% 0 0% 0 0% 0
Untranslated strings 0% 0 0% 0 0% 0
Last 12 months Previous

Activity in last 12 months

58 changes 422 changes 538 changes 171 changes 249 changes 449 changes 358 changes 846 changes 329 changes 902 changes 0 changes 16 changes 506 changes 553 changes 89 changes 91 changes 272 changes 313 changes 154 changes 198 changes 0 changes 401 changes 406 changes 130 changes
Jun Jul Aug Sep Oct Nov Dec Jan Feb Mar Apr May

Quick numbers

50,287
Hosted words
9,437
Hosted strings
100%
Translated
3
Contributors
and previous 30 days

Trends of last 30 days

+100%
Hosted words
—
+100%
Hosted strings
—
+100%
Translated
—
+100%
Contributors
—
User avatar None

Changes committed

  1. KiCad EDA
  2. master source
  3. Polish
Changes committed 2 weeks ago
User avatar ZbeeGin

Translation completed

  1. KiCad EDA
  2. master source
  3. Polish
Translation completed 2 weeks ago
User avatar ZbeeGin

Translation changed

  1. KiCad EDA
  2. master source
  3. Polish
### Top-level Clauses

(version <number>)

(rule <rule_name> <rule_clause> ...)


<br>

### Rule Clauses

(constraint <constraint_type> ...)

(condition "<expression>")

(layer "<layer_name>")

(severity <severity_name>)


<br>

### Constraints

| Constraint type | Argument type | Description |
|---------------------------|-----------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `annular_width` | min/opt/max | Checks the width of annular rings on vias.<br> |
| `assertion` | "&lt;expression>" | Checks the given expression.<br> |
| `clearance` | min | Specifies the **electrical** clearance between copper objects of different nets. (See `physical_clearance` if you wish to specify clearance between objects regardless of net.)<br><br>To allow copper objects to overlap (collide), create a `clearance` constraint with the `min` value less than zero (for example, `-1`).<br> |
| `courtyard_clearance` | min | Checks the clearance between footprint courtyards and generates an error if any two courtyards are closer than the `min` distance. If a footprint does not have a courtyard shape, no errors will be generated from this constraint.<br> |
| `diff_pair_gap` | min/opt/max | Checks the gap between coupled tracks in a differential pair. Coupled tracks are segments that are parallel to each other. Differential pair gap is not tested on uncoupled portions of a differential pair (for example, the fanout from a component).<br> |
| `diff_pair_uncoupled` | max | Checks the distance that a differential pair track is routed uncoupled from the other polarity track in the pair (for example, where the pair fans out from a component, or becomes uncoupled to pass around another object such as a via).<br> |
| `disallow` | `track`<br>`via`<br>`micro_via`<br>`buried_via`<br>`pad`<br>`zone`<br>`text`<br>`graphic`<br>`hole`<br>`footprint`<br> | Specify one or more object types to disallow, separated by spaces. For example, `(constraint disallow track)` or `(constraint disallow track via pad)`. If an object of this type matches the rule condition, a DRC error will be created.<br><br>This constraint is essentially the same as a keepout rule area, but can be used to create more specific keepout restrictions.<br> |
| `edge_clearance` | min/opt/max | Checks the clearance between objects and the board edge.<br><br>This can also be thought of as the "milling tolerance" as the board edge will include all graphical items on the `Edge.Cuts` layer as well as any *oval* pad holes. (See `physical_hole_clearance` for the drilling tolerance.)<br> |
| `length` | min/max | Checks the total routed length for the nets that match the rule condition and generates an error for each net that is below the `min` value (if specified) or above the `max` value (if specified) of the constraint.<br> |
| `hole` | min/max | Checks the size (diameter) of a drilled hole in a pad or via. For oval holes, the smaller (minor) diameter will be tested against the `min` value (if specified) and the larger (major) diameter will be tested against the `max` value (if specified).<br> |
| `hole_clearance` | min | Checks the clearance between a drilled hole in a pad or via and copper objects on a different net. The clearance is measured from the diameter of the hole, not its center.<br> |
| `hole_to_hole` | min | Checks the clearance between mechanically-drilled holes in pads and vias. The clearance is measured between the diameters of the holes, not between their centers.<br><br>This constraint is soley for the protection of drill bits. The clearance between **laser-drilled** (microvias) and other non-mechanically-drilled holes is not checked, nor is the clearance between **milled** (oval-shaped) and other non-mechanically-drilled holes.<br> |
| `physical_clearance` | min | Checks the clearance between two objects on a given layer (including non-copper layers).<br><br>While this can perform more general-purpose checks than `clearance`, it is much slower. Use `clearance` where possible.<br> |
| `physical_hole_clearance` | min | Checks the clearance between a drilled hole in a pad or via and another object, regardless of net. The clearance is measured from the diameter of the hole, not its center.<br><br>This can also be thought of as the "drilling tolerance" as it only includes **round** holes (see `edge_clearance` for the milling tolerance).<br> |
| `silk_clearance` | min/opt/max | Checks the clearance between objects on silkscreen layers and other objects.<br> |
| `skew` | max | Checks the total skew for the nets that match the rule condition, that is, the difference between the length of each net and the average of all the lengths of each net that is matched by the rule. If the absolute value of the difference between that average and the length of any one net is above the constraint `max` value, an error will be generated.<br> |
| `thermal_relief_gap` | min | Specifies the width of the gap between a pad and a zone with a thermal-relief connection.<br> |
| `thermal_spoke_width` | opt | Specifies the width of the spokes connecting a pad to a zone with a thermal-relief connection.<br> |
| `track_width` | min/opt/max | Checks the width of track and arc segments. An error will be generated for each segment that has a width below the `min` value (if specified) or above the `max` value (if specified).<br> |
| `via_count` | max | Counts the number of vias on every net matched by the rule condition. If that number exceeds the constraint `max` value on any matched net, an error will be generated for that net.<br> |
| `zone_connection` | `solid`<br>`thermal_reliefs`<br>`none` | Specifies the connection to be made between a zone and a pad.<br> |


### Items

* `A` &nbsp;&nbsp; _the first (or only) item under test_
* `B` &nbsp;&nbsp; _the second item under test (for binary tests)_
* `L` &nbsp;&nbsp; _the layer currently under test_

<br>

### Severity Names

* warning
* error
* exclusion
* ignore

<br>

### Examples

(version 1)

(rule HV
(constraint clearance (min 1.5mm))
(condition "A.NetClass == 'HV'"))


(rule HV
(layer outer)
(constraint clearance (min 1.5mm))
(condition "A.NetClass == 'HV'"))


(rule HV_HV
# wider clearance between HV tracks
(constraint clearance (min "1.5mm + 2.0mm"))
(condition "A.NetClass == 'HV' && B.NetClass == 'HV'"))


(rule HV_unshielded
(constraint clearance (min 2mm))
(condition "A.NetClass == 'HV' && !A.enclosedByArea('Shield*')"))


(rule heavy_thermals
(constraint thermal_spoke_width (min 0.5mm))
(condition "A.NetClass == 'HV'"))
<br><br>

### Notes

Version clause must be the first clause. It indicates the syntax version of the file so that
future rules parsers can perform automatic updates. It should be
set to "1".

Rules should be ordered by specificity. Later rules take
precedence over earlier rules; once a matching rule is found
no further rules will be checked.

Use Ctrl+/ to comment or uncomment line(s).
<br><br><br>

### Expression functions

All function parameters support simple wildcards (`*` and `?`).
<br><br>

A.intersectsCourtyard('<footprint_refdes>')
True if any part of `A` lies within the given footprint's principal courtyard.
<br><br>

A.intersectsFrontCourtyard('<footprint_refdes>')
True if any part of `A` lies within the given footprint's front courtyard.
<br><br>

A.intersectsBackCourtyard('<footprint_refdes>')
True if any part of `A` lies within the given footprint's back courtyard.
<br><br>

A.intersectsArea('<zone_name>')
True if any part of `A` lies within the given zone's outline.
<br><br>

A.enclosedByArea('<zone_name>')
True if all of `A` lies within the given zone's outline.

NB: this is potentially a more expensive call than `intersectsArea()`. Use `intersectsArea()`
where possible.
<br><br>

A.getField('<field_name>')
The value of the given field. Only footprints have fields, so a field is only returned if
`A` is a footprint.
<br><br>

A.isPlated()
True if `A` has a hole which is plated.
<br><br>

A.inDiffPair('<net_name>')
True if `A` has a net that is part of the specified differential pair.
`<net_name>` is the base name of the differential pair. For example, `inDiffPair('/CLK')`
matches items in the `/CLK_P` and `/CLK_N` nets.
<br><br>

AB.isCoupledDiffPair()
True if `A` and `B` are members of the same diff pair.
<br><br>

A.memberOfGroup('<group_name>')
True if `A` is a member of the given group. The name can contain wildcards.
Includes nested membership.
<br><br>

A.memberOfFootprint('<footprint_reference>|<footprint_id>')
True if `A` is a member of a footprint matching the given reference designator or footprint
ID. The parameter can contain wildcards.

NB: If matching against a footprint ID is desired, the parameter must contain a ':'.
<br><br>

A.memberOfSheet('<sheet_path>')
True if `A` is a member of the given schematic sheet. The sheet path can contain wildcards.
<br><br>

A.existsOnLayer('<layer_name>')
True if `A` exists on the given layer. The layer name can be
either the name assigned in Board Setup > Board Editor Layers or
the canonical name (ie: `F.Cu`).

NB: this returns true if `A` is on the given layer, independently
of whether or not the rule is being evaluated for that layer.
For the latter use a `(layer "layer_name")` clause in the rule.
<br><br>

### More Examples

(rule "copper keepout"
(constraint disallow track via zone)
(condition "A.intersectsArea('zone3')"))


(rule "BGA neckdown"
(constraint track_width (min 0.2mm) (opt 0.25mm))
(constraint clearance (min 0.05mm) (opt 0.08mm))
(condition "A.intersectsCourtyard('U3')"))


# prevent silk over tented vias
(rule silk_over_via
(constraint silk_clearance (min 0.2mm))
(condition "A.Type == '*Text' && B.Type == 'Via'"))


(rule "Distance between Vias of Different Nets"
(constraint hole_to_hole (min 0.254mm))
(condition "A.Type == 'Via' && B.Type == 'Via' && A.Net != B.Net"))

(rule "Clearance between Pads of Different Nets"
(constraint clearance (min 3.0mm))
(condition "A.Type == 'Pad' && B.Type == 'Pad' && A.Net != B.Net"))


(rule "Via Hole to Track Clearance"
(constraint hole_clearance (min 0.254mm))
(condition "A.Type == 'Via' && B.Type == 'Track'"))

(rule "Pad to Track Clearance"
(constraint clearance (min 0.2mm))
(condition "A.Type == 'Pad' && B.Type == 'Track'"))


(rule "clearance-to-1mm-cutout"
(constraint edge_clearance (min 0.8mm))
(condition "A.Layer == 'Edge.Cuts' && A.Line_Width == 1.0mm"))


(rule "Max Drill Hole Size Mechanical"
(constraint hole_size (max 6.3mm))
(condition "A.Pad_Type == 'NPTH, mechanical'"))

(rule "Max Drill Hole Size PTH"
(constraint hole_size (max 6.35mm))
(condition "A.Pad_Type == 'Through-hole'"))


# Specify an optimal gap for a particular diff-pair
(rule "dp clock gap"
(constraint diff_pair_gap (opt "0.8mm"))
(condition "A.inDiffPair('/CLK')"))

# Specify a larger clearance around any diff-pair
(rule "dp clearance"
(constraint clearance (min "1.5mm"))
(condition "A.inDiffPair('*') && !AB.isCoupledDiffPair()"))


# Don't use thermal reliefs on heatsink pads
(rule heat_sink_pad
(constraint zone_connection solid)
(condition "A.Fabrication_Property == 'Heatsink pad'"))

# Require all four thermal relief spokes to connect to parent zone
(rule fully_spoked_pads
(constraint min_resolved_spokes 4))

# Set thermal relief gap & spoke width for all zones
(rule defined_relief
(constraint thermal_relief_gap (min 10mil))
(constraint thermal_spoke_width (min 12mil)))

# Override thermal relief gap & spoke width for GND and PWR zones
(rule defined_relief_pwr
(constraint thermal_relief_gap (min 10mil))
(constraint thermal_spoke_width (min 12mil))
(condition "A.Name == 'zone_GND' || A.Name == 'zone_PWR'"))

# Prevent copper fills under the courtyards of capacitors
(rule no_copper_under_caps
(constraint physical_clearance (min 0mm))
(condition "A.Type == 'Zone' && B.Reference == 'C*'"))


# Prevent solder wicking from SMD pads
(rule holes_in_pads
(constraint physical_hole_clearance (min 0.2mm))
(condition "B.Pad_Type == 'SMD'"))

# Disallow solder mask margin overrides
(rule "disallow solder mask margin overrides"
(constraint assertion "A.Soldermask_Margin_Override == 0mm")
(condition "A.Type == 'Pad'"))


# Enforce a mechanical clearance between components and board edge
(rule front_mechanical_board_edge_clearance
(layer "F.Courtyard")
(constraint physical_clearance (min 3mm))
(condition "B.Layer == 'Edge.Cuts'"))


# Check current-carrying capacity
(rule high-current
(constraint track_width (min 1.0mm))
(constraint connection_width (min 0.8mm))
(condition "A.NetClass == 'Power'"))


# Separate drill bit and milling cutter size constraints
(rule "Plated through-hole size"
(constraint hole_size (min 0.2mm) (max 6.35mm))
(condition "A.isPlated() && A.Hole_Size_X == A.Hole_Size_Y"))

(rule "Plated slot size"
(constraint hole_size (min 0.5mm))
(condition "A.isPlated() && A.Hole_Size_X != A.Hole_Size_Y"))


### Documentation

For the full documentation see [https://docs.kicad.org](https://docs.kicad.org/GetMajorMinorVersion/en/pcbnew/pcbnew.html#custom_design_rules).
### Klauzule najwyższego poziomu

(version <numer>)

(rule <nazwa_reguły> <warunek_reguły> ...)


<br>

### Klauzule warunkowe

(constraint <typ_ograniczenia> ...)

(condition "<wyrażenie>")

(layer "<nazwa_warstwy>")

(severity <nazwa_ważności>)


<br>

### Typy ograniczeń

| Typ ograniczenia | Typ argumentu | Opis |
|---------------------------|------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `annular_width` | min/opt/max | Sprawdza szerokość okręgów przelotek.<br> |
| `assertion` | "&lt;expression>" | Sprawdza podane wyrażenie warunkowe.<br> |
| `clearance` | min | Określa **elektryczny** odstęp pomiędzy elementami miedzi różnych sieci. (Zobacz `physical_clearance` jeśli chcesz określić odstęp pomiędzy obiektami niezależnie od sieci.)<br><br>Aby umożliwić miedzianym obiektom nakładanie się (kolidowanie), utwórz ograniczenie `clearance` z wartością `min` mniejszą od zera (na przykład , `-1`).<br> |
| `courtyard_clearance` | min | Sprawdza odstęp pomiędzy polami zajętości footprintów i generuje błąd, jeśli dowolne dwa z nich są bliżej niż odległość `min`. Jeśli obrys nie ma oznaczonego tego kształtu nie zostaną wygenerowane żadne błędy.<br> |
| `diff_pair_gap` | min/opt/max | Sprawdza odstęp między ścieżkami pary różnicowej. Para różnicowa to odcinki równoległe do siebie. Odstęp między parami różnicowymi nie jest testowany na niesprzężonych częściach pary różnicowej (na przykład na rozgałęzieniu komponentu).<br> |
| `diff_pair_uncoupled` | max | Sprawdza odległość, z jaką jest poprowadzona ścieżka pary różnicowej bez odłączenia od ścieżki przeciwnej polaryzacji w parze (na przykład, gdy para rozchodzi się od komponentu lub zostaje rozłączona, aby ominąć inny obiekt, np. przelotkę).<br> |
| `disallow` | `track`<br>`via`<br>`micro_via`<br>`buried_via`<br>`pad`<br>`zone`<br>`text`<br>`graphic`<br>`hole`<br>`footprint`<br> | Określa jeden lub więcej typów obiektów, które stają się zabronione, oddzielając je spacjami. Na przykład `(constraint disallow track)` lub `(constraint disallow track via pad)`. Jeśli obiekt podanego typu pasuje do warunku reguły, zostanie utworzony błąd DRC.<br><br>To ograniczenie jest zasadniczo takie samo jak obszar odcięty, ale można go wykorzystać do utworzenia bardziej szczegółowych ograniczeń.<br> |
| `edge_clearance` | min/opt/max | Sprawdza odstęp między obiektami a krawędzią płytki.<br><br>Można to również traktować jako `tolerancję frezowania`, ponieważ krawędź płytki będzie zawierać wszystkie elementy graficzne na warstwie `Edge.Cuts` oraz wszelkie otwory *owalne*. (Zobacz `physical_hole_clearance`, aby zapoznać się z tolerancją wiercenia.)<br> |
| `length` | min/max | Sprawdza całkowitą długość trasy dla sieci spełniających warunek reguły i generuje błąd dla każdej sieci, która jest poniżej wartości `min` (jeśli została określona) lub powyżej wartości `max` (jeśli została określona) ograniczenia.<br> |
| `hole` | min/max | Sprawdza wielkość (średnicę) otworu wierconego w polu lutowniczym, lub przelotce. W przypadku otworów owalnych mniejsza (poboczna) średnica zostanie przetestowana w stosunku do wartości `min` (jeśli została określona), a większa (główna) średnica zostanie przetestowana w odniesieniu do wartości `max` (jeśli została określona).<br> |
| `hole_clearance` | min | Sprawdza odstęp pomiędzy wywierconym otworem w polu lutowniczym lub przelotce a miedzianymi elementami innej sieci. Odstęp mierzy się od średnicy otworu, a nie od jego środka.<br> |
| `hole_to_hole` | min | Sprawdza odstęp pomiędzy mechanicznie wywierconymi otworami w polach lutowniczych i przelotkach. Odstęp mierzy się pomiędzy średnicami otworów, a nie pomiędzy ich środkami.<br><br>Ograniczenie służy wyłącznie do ochrony wierteł. Nie sprawdza się odstępu między **wywierconymi laserowo** (mikroprzelotkami) a innymi otworami nie wierconymi mechanicznie, ani odstępem pomiędzy **frezowanymi** (owalnymi) otworami i innymi otworami nie wierconymi mechanicznie.<br> |
| `physical_clearance` | min | Sprawdza odstęp pomiędzy dwoma obiektami na danej warstwie (w tym warstwami nie będącymi sygnałowymi).<br><br>Chociaż można tym wykonywać kontrolę bardziej ogólnego przeznaczenia niż `clearance`, jest ona znacznie wolniejsza. Jeśli to możliwe, użyj `clearance`.<br> |
| `physical_hole_clearance` | min | Sprawdza odstęp pomiędzy wywierconym otworem w polu lutowniczym lub przelotce a innym obiektem, niezależnie od przynależnośći do sieci. odstęp mierzy się od średnicy otworu, a nie od jego środka.<br><br>Można to również traktować jako `tolerancję wiercenia`, ponieważ obejmuje tylko **okrągłe** otwory (zobacz `edge_clearance` dla tolerancja frezowania).<br> |
| `silk_clearance` | min/opt/max | Sprawdza odstęp pomiędzy obiektami na warstwach sitodruku a innymi obiektami.<br> |
| `skew` | max | Sprawdza całkowite nachylenie sieci spełniających warunek reguły, czyli różnicę między długością każdej sieci a średnią wszystkich długości każdej sieci spełniającej warunek reguły. Jeśli wartość bezwzględna różnicy między tą średnią a długością dowolnej sieci przekracza wartość ograniczenia `max`, zostanie wygenerowany błąd.<br> |
| `thermal_relief_gap` | min | Określa szerokość szczeliny pomiędzy polem lutowniczym a strefą z połączeniem termicznym.<br> |
| `thermal_spoke_width` | opt | Określa szerokość ramion łączących pole lutownicze ze strefą z połączeniem termicznym.<br> |
| `track_width` | min/opt/max | Sprawdza szerokość segmentów ścieżek i łuków. Błąd zostanie wygenerowany dla każdego segmentu, którego szerokość jest mniejsza niż wartość `min` (jeśli została określona) lub większa niż wartość `max` (jeśli została określona).<br> |
| `via_count` | max | Zlicza przelotki w każdej sieci spełniającej warunek reguły. Jeśli liczba ta przekroczy wartość ograniczenia `max` w dowolnej dopasowanej sieci, dla tej sieci zostanie wygenerowany błąd.<br> |
| `zone_connection` | `solid`<br>`thermal_reliefs`<br>`none` | Określa typ połączenia, które ma zostać wykonane pomiędzy strefą a polem lutowniczym.<br> |


### Elementy

* `A` &nbsp;&nbsp; _pierwszy (lub tylko jeden) element poddany testowi_
* `B` &nbsp;&nbsp; _drugi element poddany testowi (dla testów binarnych)_
* `L` &nbsp;&nbsp; _warstwa poddawana testowi_

<br>

### Poziomy naruszeń

* warning
* error
* exclusion
* ignore

<br>

### Przykłady

(version 1)

(rule HV
(constraint clearance (min 1.5mm))
(condition "A.NetClass == 'HV'"))


(rule HV
(layer outer)
(constraint clearance (min 1.5mm))
(condition "A.NetClass == 'HV'"))


(rule HV_HV
# szerszy odstęp pomiędzy ścieżkami HV
(constraint clearance (min "1.5mm + 2.0mm"))
(condition "A.NetClass == 'HV' && B.NetClass == 'HV'"))


(rule HV_unshielded
(constraint clearance (min 2mm))
(condition "A.NetClass == 'HV' && !A.insideArea('Shield*')"))


(rule heavy_thermals
(constraint thermal_spoke_width (min 0.5mm))
(condition "A.NetClass == 'HV'"))
<br><br>

### Uwagi

Klauzula wersji musi być pierwszą klauzulą. Oznacza ona wersję składni zastosowanej w pliku,
wobec czego przyszłe parsery będą mogły przeprowadzać automatyczne aktualizacje. Obecnie powinna
być ustawiona na "1".

Reguły powinny być uporządkowane według szczegółowości. Dalsze reguły
mają pierwszeństwo nad regułami wcześniejszymi; jak tylko odnaleziona
będzie pasująca reguła dalsze reguły nie będą sprawdzane.

Użyj Ctrl+/ by zakomentować lub odkomentować linię.
<br><br><br>

### Funkcje wyrażeniowe

Wszystkie parametry funkcji obsługują proste sybmole wieloznaczne (`*` oraz `?`).
<br><br>

A.intersectsCourtyard('<oznaczenie_footprintu>')
Prawdziwe jeśli dowolna część `A` leży wewnątrz obszaru zajętości podanego footprintu.
<br><br>

A.intersectsFrontCourtyard('<oznaczenie_footprintu>')
Prawdziwe jeśli dowolna część `A` leży wewnątrz obszaru zajętości podanego footprintu na stronie górnej.
<br><br>

A.intersectsBackCourtyard('<oznaczenie_footprintu>')
Prawdziwe jeśli dowolna część `A` leży wewnątrz obszaru zajętości podanego footprintu na stronie dolnej.
<br><br>

A.intersectsArea('<nazwa_strefy>')
Prawdziwe jeśli dowolna część `A` leży w obrysie podanej strefy.
<br><br>

A.enclosedByArea('<nazwa_strefy>')
Prawdziwe jeśli całość `A` leży w obrysie podanej strefy.

UWAGA: Jest to potencjalnie bardziej czasochłonne wywołanie niż `intersectsArea()`. Użyj `intersectsArea()`
tam gdzie to możliwe.
<br><br>

A.getField('<nazwa_pola>')
Zwraca wartość podanego pola. Pola mają tylko footpriny, zatem pole jest zwracane tylko
gdy `A` jest footprintem.
<br><br>

A.isPlated()
Prawdziwe jeśli `A` posiada otwór, który jest metalizowany.
<br><br>

A.inDiffPair('<nazwa_sieci>')
Prawdziwe jeśli `A` posiada sieć, która jest składnikiem pary różnicowej.
`<nazwa_sieci>` to nazwa bazowa pary różnicowej. Na przykład `inDiffPair('/CLK')`
odnosi się do sieci zarówno `/CLK_P` jak i `/CLK_N`.
<br><br>

AB.isCoupledDiffPair()
Prawdziwe jeśli `A` i `B` są członkami tej samej pary różnicowej.
<br><br>

A.memberOfGroup('<nazwa_groupy>')
Prawdziwe jeśli `A` jest członkiem podanej grupy. Można użyć sybmoli wieloznacznych.
Nawet zagnieżdżonej w innej grupie.
<br><br>

A.memberOfFootprint('<odnośnik_do_footprintu>')
Prawdziwe jeśli `A` jest elementem footprintu pasującego do podanego oznaczenia.
Można użyć sybmoli wieloznacznych.

UWAGA: Jeśli wymagane jest też sprawdzenie ID footprintu, parametr musi zawierać ':'.
<br><br>

A.memberOfSheet('<ścieżka_arkusza>')
Prawda gdy `A` jest członkiem podanego arkusza. Ścieżka arkusza nie może zawierać znaków wieloznacznych.
<br><br>

A.existsOnLayer('<nazwa_warstwy>')
Prawdziwe jeśli `A` istnieje na określonej warstwie. Nazwa warstwy może być zarówno
nazwą przypisaną w oknie dialogowym Ustawienia Płytki > Ustawienia warstw jak też
jej nazwą kanoniczną (na przykład: `F.Cu`).

UWAGA: Zwraca prawdę, jeśli `A` znajduje się na danej warstwie,
niezależnie czy reguła jest oceniana dla tej warstwy.
W tym ostatnim przypadku użyj w regule klauzuli `(layer "nazwa_warstwy")`.
<br><br>

### Więcej przykładów

(rule "blokada strefy"
(constraint disallow track via zone)
(condition "A.intersectsArea('zone3')"))


(rule "BGA neckdown"
(constraint track_width (min 0.2mm) (opt 0.25mm))
(constraint clearance (min 0.05mm) (opt 0.08mm))
(condition "A.intersectsCourtyard('U3')"))


# zapobiega opisowi na przelotkach
(rule silk_over_via
(constraint silk_clearance (min 0.2mm))
(condition "A.Type == '*Text' && B.Type == 'Via'"))


(rule "Odległość między przelotkami różnych sieci"
(constraint hole_to_hole (min 0.254mm))
(condition "A.Type =='Via' && B.Type =='Via' && A.Net != B.Net"))

(rule "odstęp między polami różnych sieci"
(constraint clearance (min 3.0mm))
(condition "A.Type =='Pad' && B.Type =='Pad' && A.Net != B.Net"))


(rule "Odstęp między otworem a ścieżką"
(constraint hole_clearance (min 0.254mm))
(condition "A.Type =='Via' && B.Type =='Track'"))

(rule "Odstęp między polem a ścieżką"
(constraint clearance (min 0.2mm))
(condition "A.Type =='Pad' && B.Type =='Track'"))


(rule "clearance-to-1mm-cutout"
(constraint clearance (min 0.8mm))
(condition "A.Layer=='Edge.Cuts' && A.Thickness == 1.0mm"))


(rule "Maksymalny rozmiar otworu mechanicznego"
(constraint hole (max 6.3mm))
(condition "A.Pad_Type == 'NPTH, mechanical'"))

(rule "Maksymalny rozmiar otworu przewlekanego"
(constraint hole (max 6.35mm))
(condition "A.Pad_Type == 'Through-hole'"))


# Określa optymalną przerwę dla konkretnej pary różnicowej
(rule "odstęp dp dla lini zegarowej"
(constraint diff_pair_gap (opt "0.8mm"))
(condition "A.inDiffPair('CLK') && AB.isCoupledDiffPair()"))

# Określa większy odstęp wokół dowolnej pary różnicowej
(rule "odstęp dp"
(constraint clearance (min "1.5mm"))
(condition "A.inDiffPair('*') && !AB.isCoupledDiffPair()"))


# Nie używaj łącz termicznych na polach radiatorowych
(rule heat_sink_pad
(constraint zone_connection solid)
(condition "A.Fabrication_Property == 'Heatsink pad'"))

# Wymagaj wszystkich czterech łącz termicznych, aby połączyć się ze strefą nadrzędną
(rule fully_spoked_pads
(constraint min_resolved_spokes 4))

# Ustaw odstęp termiczny i szerokość łącza dla wszystkich stref
(rule defined_relief
(constraint thermal_relief_gap (min 10mil))
(constraint thermal_spoke_width (min 12mil)))

# Zastąp odstęp łącza termicznego oraz grubość łącz dla stref GND i PWR
(rule defined_relief_pwr
(constraint thermal_relief_gap (min 10mil))
(constraint thermal_spoke_width (min 12mil))
(condition "A.Name == 'zone_GND' || A.Name == 'zone_PWR'"))

# Nie dopuszczaj do tworzenia stref pod kondensatorami
(rule no_copper_under_caps
(constraint physical_clearance (min 0mm))
(condition "A.Type == 'Zone' && B.Reference == 'C*'"))


# Zapobiegaj tworzeniu nitek cyny dla pól SMD
(rule holes_in_pads
(constraint physical_hole_clearance (min 0.2mm))
(condition "B.Pad_Type == 'SMD'"))

# Nie zezwalaj na nadpisywanie marginesów maski lutowniczej
(rule "nie zezwalaj na nadpisywanie marginesów maski lutowniczej"
(constraint assertion "A.Soldermask_Margin_Override == 0mm")
(condition "A.Type == 'Pad'"))


# Wymuś odstęp pod względem mechanicznym pomiędzy komponentami a krawędzią płytki
(rule front_mechanical_board_edge_clearance
(layer "F.Courtyard")
(constraint physical_clearance (min 3mm))
(condition "B.Layer == 'Edge.Cuts'"))


# Sprawdź bieżącą obciążalność prądową
(rule high-current
(constraint track_width (min 1.0mm))
(constraint connection_width (min 0.8mm))
(condition "A.NetClass == 'Power'"))


# Oddzielne ograniczenia dotyczące rozmiaru wiertła oraz frezu
(rule "Rozmiar owiertu powlekanych otworów"
(constraint hole_size (min 0.2mm) (max 6.35mm))
(condition "A.isPlated() && A.Hole_Size_X == A.Hole_Size_Y"))

(rule "Rozmiar powlekanych slotów"
(constraint hole_size (min 0.5mm))
(condition "A.isPlated() && A.Hole_Size_X != A.Hole_Size_Y"))


### Dokumentacja

Pełna dokumentację można znaleźć pod adresem [https://docs.kicad.org](https://docs.kicad.org/GetMajorMinorVersion/en/pcbnew/pcbnew.html#custom_design_rules).
2 weeks ago
User avatar None

Changes committed

  1. KiCad EDA
  2. master source
  3. Polish
Changes committed 2 weeks ago
User avatar ZbeeGin

Translation changed

  1. KiCad EDA
  2. master source
  3. Polish
Distributes selected items between the top-most item and the bottom-most item so that the item centers are equally distributed
Rozkłada wybrane elementy między elementem znajdującym się najbardziej na górze a elementem znajdującym się najbardziej na dole, tak by punkty centralne były równo rozłożone
2 weeks ago
User avatar ZbeeGin

Translation changed

  1. KiCad EDA
  2. master source
  3. Polish
Distribute Vertically by Centers
Rozłóż pionowo na podstawie punktów centralnych
2 weeks ago
User avatar ZbeeGin

Translation changed

  1. KiCad EDA
  2. master source
  3. Polish
Distributes selected items between the top-most item and the bottom-most item so that the gaps between items are equal
Rozkłada wybrane elementy między elementem znajdującym się najbardziej na górze a elementem znajdującym się najbardziej na dole, tak by luka między elementami była równomierna
2 weeks ago
User avatar ZbeeGin

Translation changed

  1. KiCad EDA
  2. master source
  3. Polish
Distribute Vertically with Even Gaps
Rozłóż pionowo z wykorzystaniem równych luk
2 weeks ago
User avatar ZbeeGin

Translation changed

  1. KiCad EDA
  2. master source
  3. Polish
Distributes selected items between the left-most item and the right-most item so that the gaps between items are equal
Rozkłada wybrane elementy między elementem znajdującym się najbardziej na lewo a elementem znajdującym się najbardziej na prawo, tak by luka między elementami była równomierna
2 weeks ago
User avatar ZbeeGin

Translation changed

  1. KiCad EDA
  2. master source
  3. Polish
Distribute Horizontally with Even Gaps
Rozłóż poziomo z wykorzystaniem równych luk
2 weeks ago
Browse all translation changes