Re: [Kicad-developers] Back annotate references from PCB

[Brian Piccioni]

Usually, pin swapping is constrained to the same package, so Unit A -> 
Unit B, or inputs of a particular unit. As I understand it, this is 
constrained by the schematic symbol definition.


When I was an engineer, I always had to sign off on a layout, just in 
case the PCB designer did something like what you describe. I'm guessing 
somebody goofed.




On 2022-05-29 4:09 p.m., Kevin Cozens wrote:

On 2019-12-02 12:52 a.m., Alexander Shuklin wrote:

I would say, pin swapping is just will be an another tool (you
probably need some specific piece of GUI for that).


Be very careful about how pin swapping is handled. Many years ago 
someone made a board that could be plugged in to an Amiga 1000 to 
allow the use of a 68020 CPU in place of the stock 68000.


The board editor swapped a few gates between packages to simplify 
routing. It didn't take in to account that it was swapping some gates 
between a regular LS part and an F part. As a result the final board 
would work properly if you installed one of the LS parts with a low 
enough propagation delay.




___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Kevin Cozens]

On 2019-12-02 12:52 a.m., Alexander Shuklin wrote:

I would say, pin swapping is just will be an another tool (you
probably need some specific piece of GUI for that).


Be very careful about how pin swapping is handled. Many years ago someone 
made a board that could be plugged in to an Amiga 1000 to allow the use of a 
68020 CPU in place of the stock 68000.


The board editor swapped a few gates between packages to simplify routing. 
It didn't take in to account that it was swapping some gates between a 
regular LS part and an F part. As a result the final board would work 
properly if you installed one of the LS parts with a low enough propagation 
delay.


--
Cheers!

Kevin.

http://www.ve3syb.ca/   | "Nerds make the shiny things that
https://www.patreon.com/KevinCozens | distract the mouth-breathers, and
| that's why we're powerful"
Owner of Elecraft K2 #2172  |
#include  | --Chris Hardwick

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Alexander Shuklin]

Hi all,
I would say, pin swapping is just will be an another tool (you
probably need some specific piece of GUI for that).
The reason I want back-annotation is to have proper geometrical
(geographical) re-annotation. We have contractor who ask if possible
renumber passive components in geometrical order, otherwise assembly
man will get mad when try to solder that by hand.

On Mon, 2 Dec 2019 at 01:17, Vesa Solonen  wrote:
>
> Andy Peters kirjoitti 1.12.2019 klo 21.45:
>
> > Anyway, it’s a lot easier to update the schematic with the new part and 
> > then forward-annotate, and this keeps both schematic and layout in sync.
>
> Assuming there is the schematic to start with. Sometimes it happens that
> there is just PCB data and one has to go backwards. Commercially that
> rarely makes sense and one may buy pretty extensive reverse engineering
> service form dedicated operators.
>
> > Pin-swapping and gate-swapping are much more important. The pin swapping 
> > makes for an interesting problem, which is making sure the resulting 
> > schematic isn’t a mess. Most likely an informal (or required) “rule” would 
> > be that you draw a net from each pin that can be swapped and you give them 
> > net labels, but you don’t draw that net to any other pin.
>
> Yes. This is exactly why I see value in a completely bilateral system.
> Drawing a schematic would benefit just as much autorouter as well as
> rubberbanding.
>
> > Thanks to everyone involved in adding the back-annotation feature!
>
> Indeed!
>
> -Vesa
>
> ___
> Mailing list: https://launchpad.net/~kicad-developers
> Post to : kicad-developers@lists.launchpad.net
> Unsubscribe : https://launchpad.net/~kicad-developers
> More help   : https://help.launchpad.net/ListHelp

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Vesa Solonen]

Andy Peters kirjoitti 1.12.2019 klo 21.45:

> Anyway, it’s a lot easier to update the schematic with the new part and then 
> forward-annotate, and this keeps both schematic and layout in sync.

Assuming there is the schematic to start with. Sometimes it happens that
there is just PCB data and one has to go backwards. Commercially that
rarely makes sense and one may buy pretty extensive reverse engineering
service form dedicated operators.

> Pin-swapping and gate-swapping are much more important. The pin swapping 
> makes for an interesting problem, which is making sure the resulting 
> schematic isn’t a mess. Most likely an informal (or required) “rule” would be 
> that you draw a net from each pin that can be swapped and you give them net 
> labels, but you don’t draw that net to any other pin.

Yes. This is exactly why I see value in a completely bilateral system.
Drawing a schematic would benefit just as much autorouter as well as
rubberbanding.

> Thanks to everyone involved in adding the back-annotation feature!

Indeed!

-Vesa

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[ja...@veith.net]

> On 01.12.19 21:06, Jon Evans wrote:


1) 
some cases (critical controlled impedance, small BGA decoupling, etc) we 
may decide during layout that it is best to switch to the "high density" 
(minimal pad size) version of the 0402.


This is alternate footprint. Implementation by reference in new symbol 
library would allow things like automatic footprint change for reflow / 
wave soldering if component pushed from front to back. Schematic is not 
affected and no need for backannotate. Data source should be symbol 
library rather than pcb. Allow workflow using footprints not defined in 
approved symbol lib is a further source for individual issues in the 
design. Kicad also always need generic workflow but avoid discussion 
about atomic lib here.
2) similarly, we might have a design with 0402 passives that we 
determine during layout needs to switch to 0201 in some cases to make 
proper layout possible.


This is a device change what affects schematic BOM. Probably it is 
useful to have a device change dialog for devices using same inherited 
drawable symbol (typical value change) whith/whithout copper changes. 
For intuitive use I would search this dialog in eeschema and it could be 
similar useful than text editor search&replace by regex. For exmaple 
change all pullup resistors from 4k7 to 1k.


Today typical 4k hi-res screens are in use for CAD. I always have the 
schematic on the screen beside PCB while routing. No need for reverse 
workflow. A powerful cross-probe highlight zoom/pan  is the better boost 
of productivity in this stage of the design. Agree with Brian, also my 
circuits have many changes while routing. This may be diffrent for 
contract PCB people what receive "ready" schematic from designer. PCB is 
another view of your schematic what always gives you diffrent insights 
and reasons not to follow the classical waterfall design workflow.


IMHO back annotate is usefull in 4 cases what all belong to the nice to 
have category. Same things can be done already without backannotation 
with only little manual work.


1) Pin swap: For example between the 2 inputs of a 7400 NAND gate
will only change 2 pin numbers in schematic. Using uC/FPGA with visible 
PinNames, these should also change using back annotation.


2) Gate swap: For example swap 2 (of four) NAND gates of a 7400
will change 2x3 pin numbers in schematic. Although Eagle and other Ecad 
is doing so, I would prefer not using A,B,C,D,E suffix to reference.  We 
see the gate position inside IC by pin numbers and all gates including 
power box may have the same reference. Warnings for unused gates is a 
matter of schematic DRC.


3) Intercomponent swap. For example if you have several 7400 in your 
circuit and change two gates between diffrent components. This is 
similar to 2 but reference change (not only reference suffix) is required.


4) geo or partitial manual renumber

Assume all, backanotate only needs Reference, PinNumber, PinName.
I dont see any disadvantage if backannotation writes changes to file(s) 
what are executed later on demand like forward annotate or netload is 
now. This allows to try several swap configurations and then 
backannotate after decision for best variant is done.


best
Jan

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Brian Piccioni]

As a complete amateur user I change footprints in layout all the time in order to experiment with spacing, how things look, modfy footprints, etc.. Sometimes you want to make a change to a library part, flag that part as a new part (I.e. BriansSOIC8), then update all SOIC8 in the layout.  The way I see it (and, again, as an amateur) is that making a change in the PCB then having to manually update the schematic is fraught with potential issues. Since we *can* change the footprint in the PCB it should be as easy as possible to then update the schematic with no error. Nobody would be forcing anybody to change their workflow: just making whatever method works best work better. Brian From: Jon EvansSent: December 1, 2019 3:06 PMTo: Andy PetersCc: KiCad DevelopersSubject: Re: [Kicad-developers] Back annotate references from PCB From another professional user, I have to disagree. There are at least two cases I can think of where changing the footprint during layout is important: 1) In my experience, it's common to keep multiple variants of IPC standard SMD footprints, especially for passives. By default, we specify the "medium density" variant of an 0402 resistor or capacitor, but in some cases (critical controlled impedance, small BGA decoupling, etc) we may decide during layout that it is best to switch to the "high density" (minimal pad size) version of the 0402. 2) similarly, we might have a design with 0402 passives that we determine during layout needs to switch to 0201 in some cases to make proper layout possible. In this case, it's indeed an entirely different part, not just a variant footprint for the same part, but the decision is made at layout time and back-annotated onto the schematic (which will then drive the BOM).  Neither of these workflows is particularly easy in KiCad today, but I'm mostly talking about my experience with commercial tools here.  This isn't necessarily me saying that these workflows need to be supported by this current back-annotation effort (I think they also depend on several other large future changes), just saying they are valid in my opinion.  -Jon On Sun, Dec 1, 2019, 14:46 Andy Peters <de...@latke.net> wrote:> On Dec 1, 2019, at 6:59 AM, Vesa Solonen <vesa.solo...@aalto.fi> wrote:> > Eeli Kaikkonen kirjoitti 1.12.2019 klo 0.08:> >> BTW, about the possibility of changing the footprint - I have always found>> being able to change footprints in pcbnew strange because then it's out of>> sync with the schematic and it has to be changed in the schematic manually>> and updated to layout anyways. Being able to update it from the layout to>> the schematic looks like an obvious missing feature.> > I would consider it a missing feature that the schematic-layout path is> anything but completely bilateral. Everything should be editable and> propagated both ways and question remains does it even make sense to> have different files. If a footprint is added or gate/pin swapped on the> PCB side the changes should show as rubber bands on the schematic, just> like it works from update PCB form schematic. Proper back annotation is> a good middle target, but having complete seamless bilateral data and> action model is way more usable albeit complex.I want to add the perspective of a professional user. We don’t change footprints in the layout editor. Why? Because NE5532D in SOIC-8 is not the same part as NE5532P in PDIP-8. Going backwards in this manner blows up the BOM, unless you can work out some way of back-annotating a different part number for each instance of this device without making mistakes. The footprints in pcbnew have no knowledge of a part number, so there is no way of changing that in layout and bringing it back to schematic.(I assume that most people use the schematic as the “master source,” and BOMs and such are generated from it, not layout.)The "house part number” decouples a thing on your schematic from what you order. There are a dozen resistor manufacturers, so rather than putting “manufacturer=Panasonic” and “base part number=ERJ-“ in the symbol, you can just put a house part number in a PN field and then a downstream database can map it to what your purchasing person can order.Anyway, it’s a lot easier to update the schematic with the new part and then forward-annotate, and this keeps both schematic and layout in sync.Pin-swapping and gate-swapping are much more important. The pin swapping makes for an interesting problem, which is making sure the resulting schematic isn’t a mess. Most likely an informal (or required) “rule” would be that you draw a net from each pin that can be swapped and you give them net labels, but you don’t draw that net to any other pin.Thanks to everyone involved in adding the back-annotation feature!-a___Mailing list: https://launchpad.net/~kicad-developersPost to     

Re: [Kicad-developers] Back annotate references from PCB

[Andy Peters]

> On Dec 1, 2019, at 1:06 PM, Jon Evans  wrote:
> 
> From another professional user, I have to disagree. There are at least two 
> cases I can think of where changing the footprint during layout is important:
> 
> 1) In my experience, it's common to keep multiple variants of IPC standard 
> SMD footprints, especially for passives. By default, we specify the "medium 
> density" variant of an 0402 resistor or capacitor, but in some cases 
> (critical controlled impedance, small BGA decoupling, etc) we may decide 
> during layout that it is best to switch to the "high density" (minimal pad 
> size) version of the 0402.

> 2) similarly, we might have a design with 0402 passives that we determine 
> during layout needs to switch to 0201 in some cases to make proper layout 
> possible. In this case, it's indeed an entirely different part, not just a 
> variant footprint for the same part, but the decision is made at layout time 
> and back-annotated onto the schematic (which will then drive the BOM). 
> 
> Neither of these workflows is particularly easy in KiCad today, but I'm 
> mostly talking about my experience with commercial tools here. 
> 
> This isn't necessarily me saying that these workflows need to be supported by 
> this current back-annotation effort (I think they also depend on several 
> other large future changes), just saying they are valid in my opinion. 

We do both of what you mention. But (and this is with Altium at the day job) 
when those footprint-change decisions are made, the layout guy finds it easier 
to update the schematics with the correct part and go forward. We do have 
symbols for the same part that call out the different footprints as needed for 
fab reasons.

Our main layout guy has access to the schematics and he keeps both the layout 
and the schematic on screen while working. So sure, a change like this is made 
at layout time, but it certainly seems easier to just change the schematic and 
go forward. Especially since you can do searches in the schematic editor for 
any set of parameters you like and let it change them all at the same time.

But of course everyone has methods that work for them.

-a 


> 
> -Jon 
> 
> On Sun, Dec 1, 2019, 14:46 Andy Peters  > wrote:
> 
> 
> > On Dec 1, 2019, at 6:59 AM, Vesa Solonen  > > wrote:
> > 
> > Eeli Kaikkonen kirjoitti 1.12.2019 klo 0.08:
> > 
> >> BTW, about the possibility of changing the footprint - I have always found
> >> being able to change footprints in pcbnew strange because then it's out of
> >> sync with the schematic and it has to be changed in the schematic manually
> >> and updated to layout anyways. Being able to update it from the layout to
> >> the schematic looks like an obvious missing feature.
> > 
> > I would consider it a missing feature that the schematic-layout path is
> > anything but completely bilateral. Everything should be editable and
> > propagated both ways and question remains does it even make sense to
> > have different files. If a footprint is added or gate/pin swapped on the
> > PCB side the changes should show as rubber bands on the schematic, just
> > like it works from update PCB form schematic. Proper back annotation is
> > a good middle target, but having complete seamless bilateral data and
> > action model is way more usable albeit complex.
> 
> I want to add the perspective of a professional user. 
> 
> We don’t change footprints in the layout editor. Why? Because NE5532D in 
> SOIC-8 is not the same part as NE5532P in PDIP-8. Going backwards in this 
> manner blows up the BOM, unless you can work out some way of back-annotating 
> a different part number for each instance of this device without making 
> mistakes. The footprints in pcbnew have no knowledge of a part number, so 
> there is no way of changing that in layout and bringing it back to schematic.
> 
> (I assume that most people use the schematic as the “master source,” and BOMs 
> and such are generated from it, not layout.)
> 
> The "house part number” decouples a thing on your schematic from what you 
> order. There are a dozen resistor manufacturers, so rather than putting 
> “manufacturer=Panasonic” and “base part number=ERJ-“ in the symbol, you can 
> just put a house part number in a PN field and then a downstream database can 
> map it to what your purchasing person can order.
> 
> Anyway, it’s a lot easier to update the schematic with the new part and then 
> forward-annotate, and this keeps both schematic and layout in sync.
> 
> Pin-swapping and gate-swapping are much more important. The pin swapping 
> makes for an interesting problem, which is making sure the resulting 
> schematic isn’t a mess. Most likely an informal (or required) “rule” would be 
> that you draw a net from each pin that can be swapped and you give them net 
> labels, but you don’t draw that net to any other pin.
> 
> Thanks to everyone involved in adding the back-annotation feature!
> 

___

Re: [Kicad-developers] Back annotate references from PCB

[Jon Evans]

>From another professional user, I have to disagree. There are at least two
cases I can think of where changing the footprint during layout is
important:

1) In my experience, it's common to keep multiple variants of IPC standard
SMD footprints, especially for passives. By default, we specify the "medium
density" variant of an 0402 resistor or capacitor, but in some cases
(critical controlled impedance, small BGA decoupling, etc) we may decide
during layout that it is best to switch to the "high density" (minimal pad
size) version of the 0402.

2) similarly, we might have a design with 0402 passives that we determine
during layout needs to switch to 0201 in some cases to make proper layout
possible. In this case, it's indeed an entirely different part, not just a
variant footprint for the same part, but the decision is made at layout
time and back-annotated onto the schematic (which will then drive the BOM).

Neither of these workflows is particularly easy in KiCad today, but I'm
mostly talking about my experience with commercial tools here.

This isn't necessarily me saying that these workflows need to be supported
by this current back-annotation effort (I think they also depend on several
other large future changes), just saying they are valid in my opinion.

-Jon

On Sun, Dec 1, 2019, 14:46 Andy Peters  wrote:

>
>
> > On Dec 1, 2019, at 6:59 AM, Vesa Solonen  wrote:
> >
> > Eeli Kaikkonen kirjoitti 1.12.2019 klo 0.08:
> >
> >> BTW, about the possibility of changing the footprint - I have always
> found
> >> being able to change footprints in pcbnew strange because then it's out
> of
> >> sync with the schematic and it has to be changed in the schematic
> manually
> >> and updated to layout anyways. Being able to update it from the layout
> to
> >> the schematic looks like an obvious missing feature.
> >
> > I would consider it a missing feature that the schematic-layout path is
> > anything but completely bilateral. Everything should be editable and
> > propagated both ways and question remains does it even make sense to
> > have different files. If a footprint is added or gate/pin swapped on the
> > PCB side the changes should show as rubber bands on the schematic, just
> > like it works from update PCB form schematic. Proper back annotation is
> > a good middle target, but having complete seamless bilateral data and
> > action model is way more usable albeit complex.
>
> I want to add the perspective of a professional user.
>
> We don’t change footprints in the layout editor. Why? Because NE5532D in
> SOIC-8 is not the same part as NE5532P in PDIP-8. Going backwards in this
> manner blows up the BOM, unless you can work out some way of
> back-annotating a different part number for each instance of this device
> without making mistakes. The footprints in pcbnew have no knowledge of a
> part number, so there is no way of changing that in layout and bringing it
> back to schematic.
>
> (I assume that most people use the schematic as the “master source,” and
> BOMs and such are generated from it, not layout.)
>
> The "house part number” decouples a thing on your schematic from what you
> order. There are a dozen resistor manufacturers, so rather than putting
> “manufacturer=Panasonic” and “base part number=ERJ-“ in the symbol, you can
> just put a house part number in a PN field and then a downstream database
> can map it to what your purchasing person can order.
>
> Anyway, it’s a lot easier to update the schematic with the new part and
> then forward-annotate, and this keeps both schematic and layout in sync.
>
> Pin-swapping and gate-swapping are much more important. The pin swapping
> makes for an interesting problem, which is making sure the resulting
> schematic isn’t a mess. Most likely an informal (or required) “rule” would
> be that you draw a net from each pin that can be swapped and you give them
> net labels, but you don’t draw that net to any other pin.
>
> Thanks to everyone involved in adding the back-annotation feature!
>
> -a
>
>
>
>
> ___
> Mailing list: https://launchpad.net/~kicad-developers
> Post to : kicad-developers@lists.launchpad.net
> Unsubscribe : https://launchpad.net/~kicad-developers
> More help   : https://help.launchpad.net/ListHelp
>
___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Andy Peters]

> On Dec 1, 2019, at 6:59 AM, Vesa Solonen  wrote:
> 
> Eeli Kaikkonen kirjoitti 1.12.2019 klo 0.08:
> 
>> BTW, about the possibility of changing the footprint - I have always found
>> being able to change footprints in pcbnew strange because then it's out of
>> sync with the schematic and it has to be changed in the schematic manually
>> and updated to layout anyways. Being able to update it from the layout to
>> the schematic looks like an obvious missing feature.
> 
> I would consider it a missing feature that the schematic-layout path is
> anything but completely bilateral. Everything should be editable and
> propagated both ways and question remains does it even make sense to
> have different files. If a footprint is added or gate/pin swapped on the
> PCB side the changes should show as rubber bands on the schematic, just
> like it works from update PCB form schematic. Proper back annotation is
> a good middle target, but having complete seamless bilateral data and
> action model is way more usable albeit complex.

I want to add the perspective of a professional user. 

We don’t change footprints in the layout editor. Why? Because NE5532D in SOIC-8 
is not the same part as NE5532P in PDIP-8. Going backwards in this manner blows 
up the BOM, unless you can work out some way of back-annotating a different 
part number for each instance of this device without making mistakes. The 
footprints in pcbnew have no knowledge of a part number, so there is no way of 
changing that in layout and bringing it back to schematic.

(I assume that most people use the schematic as the “master source,” and BOMs 
and such are generated from it, not layout.)

The "house part number” decouples a thing on your schematic from what you 
order. There are a dozen resistor manufacturers, so rather than putting 
“manufacturer=Panasonic” and “base part number=ERJ-“ in the symbol, you can 
just put a house part number in a PN field and then a downstream database can 
map it to what your purchasing person can order.

Anyway, it’s a lot easier to update the schematic with the new part and then 
forward-annotate, and this keeps both schematic and layout in sync.

Pin-swapping and gate-swapping are much more important. The pin swapping makes 
for an interesting problem, which is making sure the resulting schematic isn’t 
a mess. Most likely an informal (or required) “rule” would be that you draw a 
net from each pin that can be swapped and you give them net labels, but you 
don’t draw that net to any other pin.

Thanks to everyone involved in adding the back-annotation feature!

-a




___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Vesa Solonen]

Eeli Kaikkonen kirjoitti 1.12.2019 klo 0.08:

> BTW, about the possibility of changing the footprint - I have always found
> being able to change footprints in pcbnew strange because then it's out of
> sync with the schematic and it has to be changed in the schematic manually
> and updated to layout anyways. Being able to update it from the layout to
> the schematic looks like an obvious missing feature.

I would consider it a missing feature that the schematic-layout path is
anything but completely bilateral. Everything should be editable and
propagated both ways and question remains does it even make sense to
have different files. If a footprint is added or gate/pin swapped on the
PCB side the changes should show as rubber bands on the schematic, just
like it works from update PCB form schematic. Proper back annotation is
a good middle target, but having complete seamless bilateral data and
action model is way more usable albeit complex.

-Vesa

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Alexander Shuklin]

Hi all,
I moved my patch at the top of kicad master again, so there shouldn't
be build problems anymore.
That's link.
https://github.com/jasuramme/kicad-source-mirror/commit/c00d66bbf943cc29aa2db3b50c6647341ca81969

> I noticed one problem. It's possible to add a footprint to PCB without 
> schematic. Some people might want to do that (e.g. mounting holes or 
> fiducials), yet back-annotate. It's not possible now.
That's good catch, I'll fix it. I think there will be an option like
"ignore footprints with no associated symbol" then.
> Annotation is changing reference designators, right? If changing values and 
> footprints is implemented it's not annotation and clearly shouldn't be in the 
> annotation dialog
Yep, in the beginning I didn't think about back-annotate footprints
and values, that's why it's in the annotation dialog. I will start
making new dialog, and if anybody against, please write in here

On Sun, 1 Dec 2019 at 02:36, Eeli Kaikkonen  wrote:
>
> su 1. jouluk. 2019 klo 0.27 Alexander Shuklin (jasura...@gmail.com) kirjoitti:
>>
>> Hi Eeli,
>> first of all sorry for problems with compilation.
>
>
> No need to apology. I ran "git rebase origin/master" as Jon told, it worked.
>
> With this Core 2 Duo I know how you feel about compilation time. It just 
> makes unsuccessful compilations quite annoying.
>
> Eeli Kaikkonen
> ___
> Mailing list: https://launchpad.net/~kicad-developers
> Post to : kicad-developers@lists.launchpad.net
> Unsubscribe : https://launchpad.net/~kicad-developers
> More help   : https://help.launchpad.net/ListHelp

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Eeli Kaikkonen]

su 1. jouluk. 2019 klo 0.27 Alexander Shuklin (jasura...@gmail.com)
kirjoitti:

> Hi Eeli,
> first of all sorry for problems with compilation.
>

No need to apology. I ran "git rebase origin/master" as Jon told, it worked.

With this Core 2 Duo I know how you feel about compilation time. It just
makes unsuccessful compilations quite annoying.

Eeli Kaikkonen
___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Alexander Shuklin]

Hi Eeli,
first of all sorry for problems with compilation. I see, now it's
happen when I wiped out the CMAKE build tree. I believe that's nothing
to deal with my patch, but I still feel sorry for that.
That's why I'm asking you in mailing list: I'm not sure what way to
prefer. If anybody will agree that some dialog "update schematic from
PCB" should be done, I'll do that, there no problems.
Unfortunately my laptop is to slow and once I'll get clean tree
compiled I'll update my fork. It's probably will be tomorrow morning.
I'm really sorry, but it takes for clean build for about 4 hours (

On Sun, 1 Dec 2019 at 01:09, Eeli Kaikkonen  wrote:
>
> I noticed one problem. It's possible to add a footprint to PCB without 
> schematic. Some people might want to do that (e.g. mounting holes or 
> fiducials), yet back-annotate. It's not possible now.
>
> Greying out unused options is a good idea, polite towards the user, better 
> usability.
>
> Annotation is changing reference designators, right? If changing values and 
> footprints is implemented it's not annotation and clearly shouldn't be in the 
> annotation dialog. Even if they aren't implemented, I find having this 
> back-annotation option in the eeschema annotation dialog cumbersome or 
> strange for some reason, I don't know why. Maybe I just expect symmetric 
> update possibilities, i.e. Tools->Update PCB from schematic / Tools->Update 
> schematic from PCB. In that case the dialogs must be different, of course. 
> But maybe it's just my workflow: I use eeschema Tools->Update PCB. So I 
> expect to have the ability to push the changes instead of pulling.
>
> BTW, about the possibility of changing the footprint - I have always found 
> being able to change footprints in pcbnew strange because then it's out of 
> sync with the schematic and it has to be changed in the schematic manually 
> and updated to layout anyways. Being able to update it from the layout to the 
> schematic looks like an obvious missing feature.
>
> Eeli Kaikkonen
>
> la 30. marrask. 2019 klo 9.54 Alexander Shuklin (jasura...@gmail.com) 
> kirjoitti:
>>
>> Dear all!
>> Thanks for your helpful comments. I want to show you draft of what
>> I've done for just now.
>> I know, that sometimes people don't like if somebody change their
>> code, I just rearranged some. In existing algorithms I divide method
>> to 2 parts for I could reuse it in my patch(made
>> checkForDuplicatedElements from SCH_REFERENCE_LIST::CheckAnnotation).
>> I just cannot find better solution to do that. And I added some helper
>> functions to the SCH_REFERENCE with witch you can get data about
>> component faster. I would say that changes should be in separate
>> commit. If them acceptable, should I divide my patch when it will be
>> ready?
>> In old pieces where I touched the code, I tried to leave code
>> formatting like it was. I'm not sure if I had to. Git checks suggest
>> to reformat it, but I feel it looks better like it's done already.
>> I almost haven't done anything with design. I just added "Back
>> annotate from PCB" option to the annotation dialog (see in the
>> screenshot) and I had a plan to grey out some not useful(for back
>> annoation) dialog options when you chose that option and enable them
>> back when you moved to another one.
>> But... Eeli came with idea that if PCB holds not only references, but
>> also footprints and values, we can back-annotate them to the schematic
>> as well. I would say, you need to have checkboxes then with options
>> "references, values, footprints" and probably that's better to make a
>> new dialog for that. I don't like to create new dialog, but if I will
>> add them to existing annotation dialog, I believe that will look
>> messy. What would you think?
>> Can you advice me with some code design? In my primary job I usually
>> want to split functions on small pieces, but in that case it will be
>> too much methods in the class. So, normally I'm trying to split
>> classes as well. Now I see that SCH_EDIT_FRAME is already very big. So
>> I don't want to have more than one method for back-annotation. Is it
>> ok to use some independent function, (which is not member of
>> SCH_EDIT_FRAME) like I did in annotate.cpp (int
>> getPcbModulesFromCPTREE) ?
>> And if you have any other code suggestions please, don't hesitate to tell.
>> Wayne, I've checked my code behavior with multi components, with
>> components re-used in schematics in one project or separate projects,
>> with PCB which is not up to date with schematic and it don't break it.
>> If it found any errors it opens "Update PCB from Schematic" dialog
>> Another thing is: I was looking for undo/redo feature and now it holds
>> different changes for different sheets. Basically if you back annotate
>> more than one sch files, you can run undo only for one sheet. I would
>> say in that case there's no point to implement undo/redo feature now,
>> as it will confuse a lot. Or undo behavior has to be changed somehow.
>> You

Re: [Kicad-developers] Back annotate references from PCB

[Eeli Kaikkonen]

I noticed one problem. It's possible to add a footprint to PCB without
schematic. Some people might want to do that (e.g. mounting holes or
fiducials), yet back-annotate. It's not possible now.

Greying out unused options is a good idea, polite towards the user, better
usability.

Annotation is changing reference designators, right? If changing values and
footprints is implemented it's not annotation and clearly shouldn't be in
the annotation dialog. Even if they aren't implemented, I find having this
back-annotation option in the eeschema annotation dialog cumbersome or
strange for some reason, I don't know why. Maybe I just expect symmetric
update possibilities, i.e. Tools->Update PCB from schematic / Tools->Update
schematic from PCB. In that case the dialogs must be different, of course.
But maybe it's just my workflow: I use eeschema Tools->Update PCB. So I
expect to have the ability to push the changes instead of pulling.

BTW, about the possibility of changing the footprint - I have always found
being able to change footprints in pcbnew strange because then it's out of
sync with the schematic and it has to be changed in the schematic manually
and updated to layout anyways. Being able to update it from the layout to
the schematic looks like an obvious missing feature.

Eeli Kaikkonen

la 30. marrask. 2019 klo 9.54 Alexander Shuklin (jasura...@gmail.com)
kirjoitti:

> Dear all!
> Thanks for your helpful comments. I want to show you draft of what
> I've done for just now.
> I know, that sometimes people don't like if somebody change their
> code, I just rearranged some. In existing algorithms I divide method
> to 2 parts for I could reuse it in my patch(made
> checkForDuplicatedElements from SCH_REFERENCE_LIST::CheckAnnotation).
> I just cannot find better solution to do that. And I added some helper
> functions to the SCH_REFERENCE with witch you can get data about
> component faster. I would say that changes should be in separate
> commit. If them acceptable, should I divide my patch when it will be
> ready?
> In old pieces where I touched the code, I tried to leave code
> formatting like it was. I'm not sure if I had to. Git checks suggest
> to reformat it, but I feel it looks better like it's done already.
> I almost haven't done anything with design. I just added "Back
> annotate from PCB" option to the annotation dialog (see in the
> screenshot) and I had a plan to grey out some not useful(for back
> annoation) dialog options when you chose that option and enable them
> back when you moved to another one.
> But... Eeli came with idea that if PCB holds not only references, but
> also footprints and values, we can back-annotate them to the schematic
> as well. I would say, you need to have checkboxes then with options
> "references, values, footprints" and probably that's better to make a
> new dialog for that. I don't like to create new dialog, but if I will
> add them to existing annotation dialog, I believe that will look
> messy. What would you think?
> Can you advice me with some code design? In my primary job I usually
> want to split functions on small pieces, but in that case it will be
> too much methods in the class. So, normally I'm trying to split
> classes as well. Now I see that SCH_EDIT_FRAME is already very big. So
> I don't want to have more than one method for back-annotation. Is it
> ok to use some independent function, (which is not member of
> SCH_EDIT_FRAME) like I did in annotate.cpp (int
> getPcbModulesFromCPTREE) ?
> And if you have any other code suggestions please, don't hesitate to tell.
> Wayne, I've checked my code behavior with multi components, with
> components re-used in schematics in one project or separate projects,
> with PCB which is not up to date with schematic and it don't break it.
> If it found any errors it opens "Update PCB from Schematic" dialog
> Another thing is: I was looking for undo/redo feature and now it holds
> different changes for different sheets. Basically if you back annotate
> more than one sch files, you can run undo only for one sheet. I would
> say in that case there's no point to implement undo/redo feature now,
> as it will confuse a lot. Or undo behavior has to be changed somehow.
> You don't have undo feature in annotation either, probably for same
> reason.
>
> Many thanks, I hope my patch is not very bad.
> You can find that patch in my fork:
>
> https://github.com/jasuramme/kicad-source-mirror/commit/64dc222de6149cc789158db80bbe0696cf47dc3d
>
>
___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Jon Evans]

That error was fixed by Seth this morning, you may need to rebase on latest

On Sat, Nov 30, 2019 at 2:02 PM Eeli Kaikkonen 
wrote:

>
>
> la 30. marrask. 2019 klo 9.54 Alexander Shuklin (jasura...@gmail.com)
> kirjoitti:
>
>>
>> Many thanks, I hope my patch is not very bad.
>> You can find that patch in my fork:
>>
>> https://github.com/jasuramme/kicad-source-mirror/commit/64dc222de6149cc789158db80bbe0696cf47dc3d
>>
>>
> I've got error when compiling (on Linux):
>
> eeschema/netlist_object.cpp:254:47: error: no match for ‘operator=’
> (operand types are ‘std::vector’ and ‘wxArrayString’)
>  bus_contents_vec = alias->Members();
>
>
> I just made a fresh clone from https://gitlab.com/kicad/code/kicad and
> compiled it successfully. Then I added your fork as remote, checked out to
> backanno and tried to compile.
>
> Can you fork from the new kicad gitlab repo?
>
> Eeli Kaikkonen
> ___
> Mailing list: https://launchpad.net/~kicad-developers
> Post to : kicad-developers@lists.launchpad.net
> Unsubscribe : https://launchpad.net/~kicad-developers
> More help   : https://help.launchpad.net/ListHelp
>
___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Eeli Kaikkonen]

la 30. marrask. 2019 klo 9.54 Alexander Shuklin (jasura...@gmail.com)
kirjoitti:

>
> Many thanks, I hope my patch is not very bad.
> You can find that patch in my fork:
>
> https://github.com/jasuramme/kicad-source-mirror/commit/64dc222de6149cc789158db80bbe0696cf47dc3d
>
>
I've got error when compiling (on Linux):

eeschema/netlist_object.cpp:254:47: error: no match for ‘operator=’
(operand types are ‘std::vector’ and ‘wxArrayString’)
 bus_contents_vec = alias->Members();


I just made a fresh clone from https://gitlab.com/kicad/code/kicad and
compiled it successfully. Then I added your fork as remote, checked out to
backanno and tried to compile.

Can you fork from the new kicad gitlab repo?

Eeli Kaikkonen
___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[mitjan696-ubu...@yahoo.co.uk]

or maybe not. And
>> unfortunately at this point you cannot do that with python, as there
>> no python scripts in schematic editor. If it will be useful, I can do
>> that of course. Eeli, what I would suggest, I believe in few days I
>> will make draft commit and mark it (Work In Progress) to show how It
>> works, and we could discuss how it's gonna work with values and
>> footprints it will not be a big deal to change it.
>>
>> On Sat, 23 Nov 2019 at 21:03, Brian Piccioni
>>  wrote:
>> >
>> > It has occurred to me (Alexander please chime in) that once back 
>> > annotation has been solved subject to all the issues raised by Wayne and 
>> > others that it would be a general solution.
>> >
>> >
>> >
>> > Of course, this would end up being a sizeable change to Kicad since the 
>> > various edit functions, etc., who have to be modified to incorporate the 
>> > feature.
>> >
>> >
>> >
>> > Like you I often fiddle with different packages and values and I typically 
>> > switch to eeSchema, make the change, then hit F8 to update the PCB. It 
>> > seems to me it would be easier for the appropriate changes to simply be 
>> > reflected back to the schematic.
>> >
>> >
>> >
>> > Brian
>> >
>> >
>> >
>> > From: Eeli Kaikkonen
>> > Sent: November 23, 2019 12:56 PM
>> > To: kicad-developers
>> > Subject: Re: [Kicad-developers] Back annotate references from PCB
>> >
>> >
>> >
>> >
>> >
>> >
>> >
>> > la 23. marrask. 2019 klo 14.52 Brian Piccioni 
>> > (br...@documenteddesigns.com) kirjoitti:
>> >
>> > By having a single integrated tool analogous to “Update PCB From 
>> > Schematic” can ensure coherency.
>> >
>> > Can this do other kinds of changes than just annotation? I'm thinking of 
>> > changing the footprint or value. For example I could use Change Footprint 
>> > feature in pcbnew and propagate that change to eeschema. That's not so 
>> > difficult to do in eeshcema and update the board, but often it would feel 
>> > much more natural to e.g. test if 0402 R package would be physically 
>> > better for some situation than 0603 and then update the shcematic based on 
>> > the board if it fits.
>> >
>> >
>> >
>> > Eeli Kaikkonen
>> >
>> >
>> >
>> > ___
>> > Mailing list: https://launchpad.net/~kicad-developers
>> > Post to    : kicad-developers@lists.launchpad.net
>> > Unsubscribe : https://launchpad.net/~kicad-developers
>> > More help  : https://help.launchpad.net/ListHelp
>
> ___
> Mailing list: https://launchpad.net/~kicad-developers
> Post to    : kicad-developers@lists.launchpad.net
> Unsubscribe : https://launchpad.net/~kicad-developers
> More help  : https://help.launchpad.net/ListHelp

___
Mailing list: https://launchpad.net/~kicad-developers
Post to    : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help  : https://help.launchpad.net/ListHelp
  ___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Kevin Cozens]

On 2019-11-22 2:29 p.m., Brian wrote:
Can someone tell me an example use-case for a single schematic symbol 
corresponding to multiple board entities within a single project?


Here is another example use case.

I drew up the schematic for an LED sign panel. It has 10 8x8 LED blocks in 
two rows of 5 blocks. Each column pair of LED blocks has the same wiring 
with only the component references being different. I could have used a 
single schematic file showing the wiring 5 column pairs of LEDs. I didn't 
actually do that because I either didn't know the feature existed or didn't 
know how to make use of that feature at the time.


--
Cheers!

Kevin.

http://www.ve3syb.ca/   | "Nerds make the shiny things that
https://www.patreon.com/KevinCozens | distract the mouth-breathers, and
| that's why we're powerful"
Owner of Elecraft K2 #2172  |
#include  | --Chris Hardwick

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Alexander Shuklin]

Hi Eeli,
no, you are actually right.
I just don't want to make a new dialog before we will be sure that we
definitely need it. But in case that you will propagate not only
references you suppose to have new one.

On Sun, 24 Nov 2019 at 12:27, Eeli Kaikkonen  wrote:
>
> I probably don't understand everything which has been said, but as far as I 
> can see there are actually two things going on which could and should be 
> independent.
>
> 1. Doing geographical reannotation in pcb.
> 2. Propagating changes made in the pcb back to the schematic.
>
> I believe they should be completely different, and number 2 should be 
> generic, taking care of all changes which reasonably can be propagated from 
> the board to the schematic. Basically Update PCB from Schematic backwards, 
> i.e. Update Schematic from Board. With a similar UI dialog, of course. Undo 
> could also be similar. Or do I just think it's so "simple" and can't see 
> something?
>
> It's easy to see that number 1 isn't difficult and could be done with a 
> python script (although many people would like to see it in the main KiCad, I 
> think).
>
> Eeli Kaikkonen
>
> su 24. marrask. 2019 klo 8.57 Alexander Shuklin (jasura...@gmail.com) 
> kirjoitti:
>>
>> Hi Eeli and Brian,
>> Sorry for delay, unfortunately I cannot answer too often.
>>
>> > It has occurred to me (Alexander please chime in) that once back 
>> > annotation has been solved subject to all the issues raised by Wayne and 
>> > others that it would be a general solution.
>>
>> Unfortunately no. All stuff mentioned by Wayne is has to be
>> implemented in back-annotation, that's situations which back
>> annotation will have to care about, otherwise it will be crap. I meant
>> I see some general tool as geometrical (geographical?) re-annotation
>> in pcbnew, which do left->right top->down or opposite directions being
>> in C++ GUI, but if you want re-annotate in some different manner, you
>> are free to use python scripts, as you could easily back annotate
>> after that.
>>
>> > Can this do other kinds of changes than just annotation? I'm thinking of 
>> > changing the footprint or value
>>
>> Of course that's possible, and not a big deal to add this into
>> back-annotation algorithm. I just think how to do it better. I would
>> say we will need to have some GUI for that then. I mean, you probably
>> want to choose what do you want to back-annotate... or maybe not. And
>> unfortunately at this point you cannot do that with python, as there
>> no python scripts in schematic editor. If it will be useful, I can do
>> that of course. Eeli, what I would suggest, I believe in few days I
>> will make draft commit and mark it (Work In Progress) to show how It
>> works, and we could discuss how it's gonna work with values and
>> footprints it will not be a big deal to change it.
>>
>> On Sat, 23 Nov 2019 at 21:03, Brian Piccioni
>>  wrote:
>> >
>> > It has occurred to me (Alexander please chime in) that once back 
>> > annotation has been solved subject to all the issues raised by Wayne and 
>> > others that it would be a general solution.
>> >
>> >
>> >
>> > Of course, this would end up being a sizeable change to Kicad since the 
>> > various edit functions, etc., who have to be modified to incorporate the 
>> > feature.
>> >
>> >
>> >
>> > Like you I often fiddle with different packages and values and I typically 
>> > switch to eeSchema, make the change, then hit F8 to update the PCB. It 
>> > seems to me it would be easier for the appropriate changes to simply be 
>> > reflected back to the schematic.
>> >
>> >
>> >
>> > Brian
>> >
>> >
>> >
>> > From: Eeli Kaikkonen
>> > Sent: November 23, 2019 12:56 PM
>> > To: kicad-developers
>> > Subject: Re: [Kicad-developers] Back annotate references from PCB
>> >
>> >
>> >
>> >
>> >
>> >
>> >
>> > la 23. marrask. 2019 klo 14.52 Brian Piccioni 
>> > (br...@documenteddesigns.com) kirjoitti:
>> >
>> > By having a single integrated tool analogous to “Update PCB From 
>> > Schematic” can ensure coherency.
>> >
>> > Can this do other kinds of changes than just annotation? I'm thinking of 
>> > changing the footprint or value. For example I could use Change Footprint 
>> > feature in pcbnew and propagate that change to 

Re: [Kicad-developers] Back annotate references from PCB

[Eeli Kaikkonen]

I probably don't understand everything which has been said, but as far as I
can see there are actually two things going on which could and should be
independent.

1. Doing geographical reannotation in pcb.
2. Propagating changes made in the pcb back to the schematic.

I believe they should be completely different, and number 2 should be
generic, taking care of all changes which reasonably can be propagated from
the board to the schematic. Basically Update PCB from Schematic backwards,
i.e. Update Schematic from Board. With a similar UI dialog, of course. Undo
could also be similar. Or do I just think it's so "simple" and can't see
something?

It's easy to see that number 1 isn't difficult and could be done with a
python script (although many people would like to see it in the main KiCad,
I think).

Eeli Kaikkonen

su 24. marrask. 2019 klo 8.57 Alexander Shuklin (jasura...@gmail.com)
kirjoitti:

> Hi Eeli and Brian,
> Sorry for delay, unfortunately I cannot answer too often.
>
> > It has occurred to me (Alexander please chime in) that once back
> annotation has been solved subject to all the issues raised by Wayne and
> others that it would be a general solution.
>
> Unfortunately no. All stuff mentioned by Wayne is has to be
> implemented in back-annotation, that's situations which back
> annotation will have to care about, otherwise it will be crap. I meant
> I see some general tool as geometrical (geographical?) re-annotation
> in pcbnew, which do left->right top->down or opposite directions being
> in C++ GUI, but if you want re-annotate in some different manner, you
> are free to use python scripts, as you could easily back annotate
> after that.
>
> > Can this do other kinds of changes than just annotation? I'm thinking of
> changing the footprint or value
>
> Of course that's possible, and not a big deal to add this into
> back-annotation algorithm. I just think how to do it better. I would
> say we will need to have some GUI for that then. I mean, you probably
> want to choose what do you want to back-annotate... or maybe not. And
> unfortunately at this point you cannot do that with python, as there
> no python scripts in schematic editor. If it will be useful, I can do
> that of course. Eeli, what I would suggest, I believe in few days I
> will make draft commit and mark it (Work In Progress) to show how It
> works, and we could discuss how it's gonna work with values and
> footprints it will not be a big deal to change it.
>
> On Sat, 23 Nov 2019 at 21:03, Brian Piccioni
>  wrote:
> >
> > It has occurred to me (Alexander please chime in) that once back
> annotation has been solved subject to all the issues raised by Wayne and
> others that it would be a general solution.
> >
> >
> >
> > Of course, this would end up being a sizeable change to Kicad since the
> various edit functions, etc., who have to be modified to incorporate the
> feature.
> >
> >
> >
> > Like you I often fiddle with different packages and values and I
> typically switch to eeSchema, make the change, then hit F8 to update the
> PCB. It seems to me it would be easier for the appropriate changes to
> simply be reflected back to the schematic.
> >
> >
> >
> > Brian
> >
> >
> >
> > From: Eeli Kaikkonen
> > Sent: November 23, 2019 12:56 PM
> > To: kicad-developers
> > Subject: Re: [Kicad-developers] Back annotate references from PCB
> >
> >
> >
> >
> >
> >
> >
> > la 23. marrask. 2019 klo 14.52 Brian Piccioni (
> br...@documenteddesigns.com) kirjoitti:
> >
> > By having a single integrated tool analogous to “Update PCB From
> Schematic” can ensure coherency.
> >
> > Can this do other kinds of changes than just annotation? I'm thinking of
> changing the footprint or value. For example I could use Change Footprint
> feature in pcbnew and propagate that change to eeschema. That's not so
> difficult to do in eeshcema and update the board, but often it would feel
> much more natural to e.g. test if 0402 R package would be physically better
> for some situation than 0603 and then update the shcematic based on the
> board if it fits.
> >
> >
> >
> > Eeli Kaikkonen
> >
> >
> >
> > ___
> > Mailing list: https://launchpad.net/~kicad-developers
> > Post to : kicad-developers@lists.launchpad.net
> > Unsubscribe : https://launchpad.net/~kicad-developers
> > More help   : https://help.launchpad.net/ListHelp
>
___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[jp charras]

Le 24/11/2019 à 07:58, Alexander Shuklin a écrit :
> Hi Eeli and Brian,
> Sorry for delay, unfortunately I cannot answer too often.
> 
>> It has occurred to me (Alexander please chime in) that once back annotation 
>> has been solved subject to all the issues raised by Wayne and others that it 
>> would be a general solution.
> 
> Unfortunately no. All stuff mentioned by Wayne is has to be
> implemented in back-annotation, that's situations which back
> annotation will have to care about, otherwise it will be crap. I meant
> I see some general tool as geometrical (geographical?) re-annotation
> in pcbnew, which do left->right top->down or opposite directions being
> in C++ GUI, but if you want re-annotate in some different manner, you
> are free to use python scripts, as you could easily back annotate
> after that.
> 
>> Can this do other kinds of changes than just annotation? I'm thinking of 
>> changing the footprint or value
> 
> Of course that's possible, and not a big deal to add this into
> back-annotation algorithm. I just think how to do it better. I would
> say we will need to have some GUI for that then. I mean, you probably
> want to choose what do you want to back-annotate... or maybe not. And
> unfortunately at this point you cannot do that with python, as there
> no python scripts in schematic editor. If it will be useful, I can do
> that of course. Eeli, what I would suggest, I believe in few days I
> will make draft commit and mark it (Work In Progress) to show how It
> works, and we could discuss how it's gonna work with values and
> footprints it will not be a big deal to change it.

Back annotation imply undo/redo feature.
It locks like it will be not trivial.

> 
> On Sat, 23 Nov 2019 at 21:03, Brian Piccioni
>  wrote:
>>
>> It has occurred to me (Alexander please chime in) that once back annotation 
>> has been solved subject to all the issues raised by Wayne and others that it 
>> would be a general solution.
>>
>>
>>
>> Of course, this would end up being a sizeable change to Kicad since the 
>> various edit functions, etc., who have to be modified to incorporate the 
>> feature.
>>
>>
>>
>> Like you I often fiddle with different packages and values and I typically 
>> switch to eeSchema, make the change, then hit F8 to update the PCB. It seems 
>> to me it would be easier for the appropriate changes to simply be reflected 
>> back to the schematic.
>>
>>
>>
>> Brian
>>
>>
>>
>> From: Eeli Kaikkonen
>> Sent: November 23, 2019 12:56 PM
>> To: kicad-developers
>> Subject: Re: [Kicad-developers] Back annotate references from PCB
>>
>>
>>
>>
>>
>>
>>
>> la 23. marrask. 2019 klo 14.52 Brian Piccioni (br...@documenteddesigns.com) 
>> kirjoitti:
>>
>> By having a single integrated tool analogous to “Update PCB From Schematic” 
>> can ensure coherency.
>>
>> Can this do other kinds of changes than just annotation? I'm thinking of 
>> changing the footprint or value. For example I could use Change Footprint 
>> feature in pcbnew and propagate that change to eeschema. That's not so 
>> difficult to do in eeshcema and update the board, but often it would feel 
>> much more natural to e.g. test if 0402 R package would be physically better 
>> for some situation than 0603 and then update the shcematic based on the 
>> board if it fits.
>>
>>
>>
>> Eeli Kaikkonen
>>
>>
>>
>> ___
>> Mailing list: https://launchpad.net/~kicad-developers
>> Post to : kicad-developers@lists.launchpad.net
>> Unsubscribe : https://launchpad.net/~kicad-developers
>> More help   : https://help.launchpad.net/ListHelp
> 
> ___
> Mailing list: https://launchpad.net/~kicad-developers
> Post to : kicad-developers@lists.launchpad.net
> Unsubscribe : https://launchpad.net/~kicad-developers
> More help   : https://help.launchpad.net/ListHelp
> 


-- 
Jean-Pierre CHARRAS

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Alexander Shuklin]

Hi Eeli and Brian,
Sorry for delay, unfortunately I cannot answer too often.

> It has occurred to me (Alexander please chime in) that once back annotation 
> has been solved subject to all the issues raised by Wayne and others that it 
> would be a general solution.

Unfortunately no. All stuff mentioned by Wayne is has to be
implemented in back-annotation, that's situations which back
annotation will have to care about, otherwise it will be crap. I meant
I see some general tool as geometrical (geographical?) re-annotation
in pcbnew, which do left->right top->down or opposite directions being
in C++ GUI, but if you want re-annotate in some different manner, you
are free to use python scripts, as you could easily back annotate
after that.

> Can this do other kinds of changes than just annotation? I'm thinking of 
> changing the footprint or value

Of course that's possible, and not a big deal to add this into
back-annotation algorithm. I just think how to do it better. I would
say we will need to have some GUI for that then. I mean, you probably
want to choose what do you want to back-annotate... or maybe not. And
unfortunately at this point you cannot do that with python, as there
no python scripts in schematic editor. If it will be useful, I can do
that of course. Eeli, what I would suggest, I believe in few days I
will make draft commit and mark it (Work In Progress) to show how It
works, and we could discuss how it's gonna work with values and
footprints it will not be a big deal to change it.

On Sat, 23 Nov 2019 at 21:03, Brian Piccioni
 wrote:
>
> It has occurred to me (Alexander please chime in) that once back annotation 
> has been solved subject to all the issues raised by Wayne and others that it 
> would be a general solution.
>
>
>
> Of course, this would end up being a sizeable change to Kicad since the 
> various edit functions, etc., who have to be modified to incorporate the 
> feature.
>
>
>
> Like you I often fiddle with different packages and values and I typically 
> switch to eeSchema, make the change, then hit F8 to update the PCB. It seems 
> to me it would be easier for the appropriate changes to simply be reflected 
> back to the schematic.
>
>
>
> Brian
>
>
>
> From: Eeli Kaikkonen
> Sent: November 23, 2019 12:56 PM
> To: kicad-developers
> Subject: Re: [Kicad-developers] Back annotate references from PCB
>
>
>
>
>
>
>
> la 23. marrask. 2019 klo 14.52 Brian Piccioni (br...@documenteddesigns.com) 
> kirjoitti:
>
> By having a single integrated tool analogous to “Update PCB From Schematic” 
> can ensure coherency.
>
> Can this do other kinds of changes than just annotation? I'm thinking of 
> changing the footprint or value. For example I could use Change Footprint 
> feature in pcbnew and propagate that change to eeschema. That's not so 
> difficult to do in eeshcema and update the board, but often it would feel 
> much more natural to e.g. test if 0402 R package would be physically better 
> for some situation than 0603 and then update the shcematic based on the board 
> if it fits.
>
>
>
> Eeli Kaikkonen
>
>
>
> ___
> Mailing list: https://launchpad.net/~kicad-developers
> Post to : kicad-developers@lists.launchpad.net
> Unsubscribe : https://launchpad.net/~kicad-developers
> More help   : https://help.launchpad.net/ListHelp

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Brian Piccioni]

It has occurred to me (Alexander please chime in) that once back annotation has been solved subject to all the issues raised by Wayne and others that it would be a general solution. Of course, this would end up being a sizeable change to Kicad since the various edit functions, etc., who have to be modified to incorporate the feature. Like you I often fiddle with different packages and values and I typically switch to eeSchema, make the change, then hit F8 to update the PCB. It seems to me it would be easier for the appropriate changes to simply be reflected back to the schematic. Brian From: Eeli KaikkonenSent: November 23, 2019 12:56 PMTo: kicad-developersSubject: Re: [Kicad-developers] Back annotate references from PCB   la 23. marrask. 2019 klo 14.52 Brian Piccioni (br...@documenteddesigns.com) kirjoitti:By having a single integrated tool analogous to “Update PCB From Schematic” can ensure coherency.Can this do other kinds of changes than just annotation? I'm thinking of changing the footprint or value. For example I could use Change Footprint feature in pcbnew and propagate that change to eeschema. That's not so difficult to do in eeshcema and update the board, but often it would feel much more natural to e.g. test if 0402 R package would be physically better for some situation than 0603 and then update the shcematic based on the board if it fits. Eeli Kaikkonen 

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Eeli Kaikkonen]

la 23. marrask. 2019 klo 14.52 Brian Piccioni (br...@documenteddesigns.com)
kirjoitti:

> By having a single integrated tool analogous to “Update PCB From
> Schematic” can ensure coherency.
>
Can this do other kinds of changes than just annotation? I'm thinking of
changing the footprint or value. For example I could use Change Footprint
feature in pcbnew and propagate that change to eeschema. That's not so
difficult to do in eeshcema and update the board, but often it would feel
much more natural to e.g. test if 0402 R package would be physically better
for some situation than 0603 and then update the shcematic based on the
board if it fits.

Eeli Kaikkonen
___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Brian Piccioni]

Indeed. I’ve had geographical annotation in c++ working for some time now. Having different commands in PCBNew and eeSchema could lead to all sorts of nightmares. During testing I found myself with “half done” projects where I had inadvertently got the annotation on the PCB and schematics out of synch. This is a complete nightmare to fix even on a small board. In fact the reason I started the work was because geographic annotation is a huge amount of work manually and back annotation is not just a lot of work but really easy to screw up. By having a single integrated tool analogous to “Update PCB From Schematic” can ensure coherency. From: Alexander ShuklinSent: November 23, 2019 5:44 AMTo: Dino GhilardiCc: kicad-developersSubject: Re: [Kicad-developers] Back annotate references from PCB Well,I cannot make back annotation in python, it has to be c++. Actuallythat's why I jumped on that problem. Because once it's done you canuse python for geometrical annotation. Actually I've seen pythonscript to do that, but it parses sch file like plain text, which isbad.Python scripts can do powerful job, and as I see, some very uncommonstuff better to have as python plugins, and something general instandard GUI. I would say that geometrical annotation is more or lesscommon stuff, and I would like to see it integrated in KiCad itself.But I'm not the person who supposed to decide that. Anyway, Brianalready busy with doing that in C++, so I believe that's alright.If there will be some dialog with just common geometrical annotation,you still can use python scripts to do some specific one. On Sat, 23 Nov 2019 at 13:30, Dino Ghilardi  wrote:> > On 23/11/19 10:05, Alexander Shuklin wrote:> > Hi Dino,> > I would say "back annotation" and "geographical annotation" are just> > different things. We with Brian plan to implement both of them.> > Basically when you want to get references from board and apply them to> > corresponding schematic, that back annotation. If you re-annotate> > footprints in PCB according it's position that's geographical> > annotation. I think we will do geographical annotation, which will> > call back annotation straight away.> > Sometimes there's a reason to have back-annotation without> > geographical annotation: once I was asked by our designer "to rename> > that, that and that one connector", for it would correspond his wires> > numbers and documentation. Of course you can still do it manually, but> > if back annotation will be implemented, why not to let user call it> > alone?> >> > Good point. Having two tools at the price of one would be better than> have one tool only (and having back annotation function exported to> python would open the door to user's personal custom back-annotate scripts).> By the way: How about implementing back annotation in kicad itself and> the "geographical annotation" as a python action-plugin (that calls back> annotation on all selected components)? That would enable users to> create their custom back-annotation scripts with different> "unconventional geometries" easily, just modifying the original script> source.> Drawback: I don't know which of the two  methods ("all in c++" or "core> functions in c++ and higher level as a script") will be easier to> implement/debug.> > Cheers,> Dino.> > > > > > >  ___Mailing list: https://launchpad.net/~kicad-developersPost to : kicad-developers@lists.launchpad.netUnsubscribe : https://launchpad.net/~kicad-developersMore help   : https://help.launchpad.net/ListHelp 

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Alexander Shuklin]

Well,
I cannot make back annotation in python, it has to be c++. Actually
that's why I jumped on that problem. Because once it's done you can
use python for geometrical annotation. Actually I've seen python
script to do that, but it parses sch file like plain text, which is
bad.
Python scripts can do powerful job, and as I see, some very uncommon
stuff better to have as python plugins, and something general in
standard GUI. I would say that geometrical annotation is more or less
common stuff, and I would like to see it integrated in KiCad itself.
But I'm not the person who supposed to decide that. Anyway, Brian
already busy with doing that in C++, so I believe that's alright.
If there will be some dialog with just common geometrical annotation,
you still can use python scripts to do some specific one.

On Sat, 23 Nov 2019 at 13:30, Dino Ghilardi  wrote:
>
> On 23/11/19 10:05, Alexander Shuklin wrote:
> > Hi Dino,
> > I would say "back annotation" and "geographical annotation" are just
> > different things. We with Brian plan to implement both of them.
> > Basically when you want to get references from board and apply them to
> > corresponding schematic, that back annotation. If you re-annotate
> > footprints in PCB according it's position that's geographical
> > annotation. I think we will do geographical annotation, which will
> > call back annotation straight away.
> > Sometimes there's a reason to have back-annotation without
> > geographical annotation: once I was asked by our designer "to rename
> > that, that and that one connector", for it would correspond his wires
> > numbers and documentation. Of course you can still do it manually, but
> > if back annotation will be implemented, why not to let user call it
> > alone?
> >
>
> Good point. Having two tools at the price of one would be better than
> have one tool only (and having back annotation function exported to
> python would open the door to user's personal custom back-annotate scripts).
> By the way: How about implementing back annotation in kicad itself and
> the "geographical annotation" as a python action-plugin (that calls back
> annotation on all selected components)? That would enable users to
> create their custom back-annotation scripts with different
> "unconventional geometries" easily, just modifying the original script
> source.
> Drawback: I don't know which of the two  methods ("all in c++" or "core
> functions in c++ and higher level as a script") will be easier to
> implement/debug.
>
> Cheers,
> Dino.
>
>
>
>
>
>
>

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Dino Ghilardi]

On 23/11/19 10:05, Alexander Shuklin wrote:

Hi Dino,
I would say "back annotation" and "geographical annotation" are just
different things. We with Brian plan to implement both of them.
Basically when you want to get references from board and apply them to
corresponding schematic, that back annotation. If you re-annotate
footprints in PCB according it's position that's geographical
annotation. I think we will do geographical annotation, which will
call back annotation straight away.
Sometimes there's a reason to have back-annotation without
geographical annotation: once I was asked by our designer "to rename
that, that and that one connector", for it would correspond his wires
numbers and documentation. Of course you can still do it manually, but
if back annotation will be implemented, why not to let user call it
alone?



Good point. Having two tools at the price of one would be better than 
have one tool only (and having back annotation function exported to 
python would open the door to user's personal custom back-annotate scripts).
By the way: How about implementing back annotation in kicad itself and 
the "geographical annotation" as a python action-plugin (that calls back 
annotation on all selected components)? That would enable users to 
create their custom back-annotation scripts with different 
"unconventional geometries" easily, just modifying the original script 
source.
Drawback: I don't know which of the two  methods ("all in c++" or "core 
functions in c++ and higher level as a script") will be easier to 
implement/debug.


Cheers,
Dino.








___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Alexander Shuklin]

Hi Wayne,
thanks, now I think I understood all that cases. I'll go back to code
and will take care of them.

On Fri, 22 Nov 2019 at 20:00, Wayne Stambaugh  wrote:
>
> I would prefer that you did ask questions rather than spending a lot of
> development time on a solution that would not be accepted because it
> breaks things.  This is not a trivial problem although it may appear
> that way.  There are plenty of ways to implement back annotation that
> will break things in unexpected ways.  There are a very few ways to not
> break things.  This is why I'm telling you this.  If you don't care
> about the schematic and the board references being synchronized, then
> back-annotation isn't really necessary.  As soon as you attempt to
> back-annotated the schematic from the board, all of the issues that I
> have previously discussed come in to play and have to be addressed.
>
> On 11/22/19 9:53 AM, Alexander Shuklin wrote:
> > Excuse me for so much questions. There's plenty of ways how it can be
> > done, and I'm quite new, maybe I don't see some simple way.
> > I can back up data from pcbnew which is not up to date to schematics,
> > after that I call update pcb dialog. Somebody will want to update pcb
> > by references and after that I will have pcbnew old data which is not
> > up to date either to schematics or layout anymore. I don't think there
> > will be straight forward solution how to solve it.
> > May I just open update pcb dialog and ask user to care about schematic
> > and layout being up to date?
> >
> > On Fri, 22 Nov 2019 at 17:16, Wayne Stambaugh  wrote:
> >>
> >> There is no need to create your own dialog.  Just call the update board
> >> from schematic function before you back annotate.  You will have to make
> >> a temporary copy of your board reference changes because updating from
> >> the schematic will clobber any reference changes in the board.
> >>
> >> On 11/22/19 9:13 AM, Alexander Shuklin wrote:
> >>> Hi Wayne,
> >>>
> >>> I don't want to start PCB update from eeschema straight away, because
> >>> if you run back-annotation, you already changed some references in
> >>> layout and you gonna lose it. And probably you can get some footprints
> >>> which are not connected to any of components in schematics as there's
> >>> possibility in pcbnew to create them. What I almost done is reporting
> >>> about all errors in dialog (I currently use annotation dialog in
> >>> eeschema, but I can create my own if it necessary), and if there's any
> >>> errors, it will not allow you to back-annotate. It will ask you to fix
> >>> them first.
> >>> But if you want, I can run "update pcb from schematic" dialog.
> >>>
> >>> On Fri, 22 Nov 2019 at 16:30, Wayne Stambaugh  
> >>> wrote:
> 
>  Hi Alexander,
> 
>  You must ensure that all of the reference paths are up to date with the
>  schematic before you attempt to back annotate from the board.  Schematic
>  changes can result in the footprint paths in the board being out of sync
>  so you have to perform and update board from schematic (this code
>  already exists) before you attempt to run the back annotation process
>  from the board editor to ensure all of the paths are up to date.  This
>  will ensure when you back annotate that there is a one to one
>  correlation between board footprint sheet paths and schematic symbol
>  sheet paths.
> 
>  Cheers,
> 
>  Wayne
> 
>  On 11/22/19 1:18 AM, Alexander Shuklin wrote:
> > Hi Wayne,
> > thanks for answer.
> > Hopefully I will show you commit soon, so team could look, check and
> > suggest something about that. I'm aware about differences between
> > PCBnew and eeschema and just now I'm writing algorithm that will check
> > it.
> > Do you mean that some schematic file(.sch) can be used in more than
> > one projects? So, I don't plan to change the unique IDs and those
> > components will still be linked to each other, but if references will
> > be changed it will make a mess in another project.
> > I have 3 ideas how I can deal with that:
> > 1) create a dialog, which will say something like "please make sure,
> > that your schematic files are not shared between different projects"
> > 2) I can go by recently opened projects, parse schematics in each of
> > them and look if any schematic uses sheet, which already in use in
> > current project. I'm now sure, but I would presume, that it will be
> > quite slow.
> > 3) To hold information in what project this particular schematics was
> > used. So that's should be saved in .sch file then. But I don't think
> > that information will be very valuable.
> >
> >
> > On Thu, 21 Nov 2019 at 00:07, Wayne Stambaugh  
> > wrote:
> >>
> >> On 11/7/19 5:06 AM, Alexander Shuklin wrote:
> >>> Hi,
> >>> is it alright to answer anybody in one letter?
> >>> First of all, don't take amiss if I 

Re: [Kicad-developers] Back annotate references from PCB

[Alexander Shuklin]

Hi Dino,
I would say "back annotation" and "geographical annotation" are just
different things. We with Brian plan to implement both of them.
Basically when you want to get references from board and apply them to
corresponding schematic, that back annotation. If you re-annotate
footprints in PCB according it's position that's geographical
annotation. I think we will do geographical annotation, which will
call back annotation straight away.
Sometimes there's a reason to have back-annotation without
geographical annotation: once I was asked by our designer "to rename
that, that and that one connector", for it would correspond his wires
numbers and documentation. Of course you can still do it manually, but
if back annotation will be implemented, why not to let user call it
alone?

On Sat, 23 Nov 2019 at 01:33, Dino Ghilardi  wrote:
>
> On 22/11/19 23:14, Andy Peters wrote:
> >
> >> On Nov 22, 2019, at 2:30 PM, Dino Ghilardi  wrote:
> >>
> >> Just my two cents on this.
> >>
> >> Considering that the actual "manual work-around" to do the "back 
> >> annotation" now can be:
> >>
> >> -Open pcbnew and eeschema at the same time
> >> -Select the component you want to rename on pcbnew
> >> -the right symbol gets highlighted (but not selected) automatically in 
> >> eeschema
> >> -select the highlighted component in eeschema, press "U" shortcut (edit 
> >> reference)
> >> -change the reference in the dialog
> >> -press F8 to update the pcb
> >>
> >> A possible approach is to use this sequence of operations (...future 
> >> python script?).
> >>
> >> Since the mechanism to find the correct symbol on eeschema seems yet 
> >> implemented, probably the only missing parts would be to implement is
> >>
> >> Enable from pcbnew the command "select the highlighted component and/or 
> >> open the "edit reference" dialog.
> >>
> >> Drawbacks:
> >> -Requires eeschema and pcbnew open at the same time (may be this is not a  
> >> a problem since we also have DRC that opens eeschema when run).
> >> -Requires to check that schematic and layout are synchronized before 
> >> starting the back-annotation (probably needed also for all the other 
> >> implementations).
> >> -For bigger schematics the full-update via F8 can become slow, so as a 
> >> future improvement, after a first working implementation could be a way to 
> >> update only the modified field.
> >
> > I have done manual back-annotation because automated back-annotation (what 
> > Brian Piccioni is doing) didn’t exist.
> >
> > I’m in the habit of doing “geographical re-annotation” after a layout has 
> > completed. This is where the layout is scanned and, say, the resistor most 
> > near the upper left is numbered R1, the resistor to its right is then R2, 
> > and so on. This is purely an aid for the human assembler and the human 
> > debugging the design. It’s not really interesting for automated assembly.
> >
> > You can do this manually, on a small design, using the approach you 
> > suggest, but for anything complex (my last board was 165 mm x 125 mm with 
> > about 150 capacitors, a hundred resistors, and a bunch of ICs) it’s 
> > impossible.
> >
> > So it really needs to be automated. The options, as I see them, are few and 
> > simple: origin, direction (increasing in X or increasing in Y) and an 
> > option to not re-annotate a part (maybe don’t change the reference 
> > designators for connectors). The logic of the sorting is straightforward, 
> > but it’s a task best left to the machines.
> >
> > -a
> --
>
>
> I agree,
> my comment was more "low level": to automate the high level
> "origin-direction-etc... the first step would be having the lower part
> "up-and-running", then build the fully automated part on that.
>
> P.S.: I like the term "geographical annotation" more than "back
> annotation" for this feature.
>
> Another possible approach I can think about is adding "board
> geographical (re)annotation in eeschema "annotate schematic" tool: if
> eeschema can "ask" the position to pcbnew it also can re-annotate the
> components according to position.
> Since pcbnew does not move components if only the reference changes in
> eeschema, this could be also a solution.
>
> Drawback: probably this approach is less intuitive to the user that
> expects to be able to change references in pcbnew.
>
> Cheers,
> Dino.
>
>
> ___
> Mailing list: https://launchpad.net/~kicad-developers
> Post to : kicad-developers@lists.launchpad.net
> Unsubscribe : https://launchpad.net/~kicad-developers
> More help   : https://help.launchpad.net/ListHelp

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[jp charras]

Le 23/11/2019 à 00:05, ja...@veith.net a écrit :
>> On 22.11.19 21:12, Wayne Stambaugh wrote:
>> What Jeff described is the simplest case.  Where things really get
>> interesting is when you start sharing schematic files between projects.
> 
> Imho multiple use of a schematic requires separate instance data.
> Similar problem for the recently discussed variant/do not fit where
> the values are different instead reference designators. Could imagine
> both, e.g. a filter circuit used multiple times for different frequency
> whether its on the same board or not. If used outside project, the
> project file could link instance data to schematic. Penalty is not
> having complete schematics in one file.

I agree: sharing the same schematic file between projects projects is
the best way to break the projects.

For instance:
- projects can have different libraries using the same library nickname,
and having different symbols having the same lib id between projects.
- alternate references (AR lines) exist only for complex hierarchies
when the same file has more than one instance in the same project
- when the hierarchy is not complex, only the F0 field (reference)
stores the reference.
So, changing it in a project breaks the other project if this sheet is
shared between projects.
And there are more subtle cases (what about swapping 2 units in a
multi-unit component in a project?)

So sharing a sheet file between projects is just madness.

-- 
Jean-Pierre CHARRAS

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[ja...@veith.net]

> On 22.11.19 21:12, Wayne Stambaugh wrote:

What Jeff described is the simplest case.  Where things really get
interesting is when you start sharing schematic files between projects.


Imho multiple use of a schematic requires separate instance data. 
Similar problem for the recently discussed variant/do not fit where

the values are different instead reference designators. Could imagine
both, e.g. a filter circuit used multiple times for different frequency
whether its on the same board or not. If used outside project, the 
project file could link instance data to schematic. Penalty is not 
having complete schematics in one file.




___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Dino Ghilardi]

On 22/11/19 23:14, Andy Peters wrote:



On Nov 22, 2019, at 2:30 PM, Dino Ghilardi  wrote:

Just my two cents on this.

Considering that the actual "manual work-around" to do the "back annotation" 
now can be:

-Open pcbnew and eeschema at the same time
-Select the component you want to rename on pcbnew
-the right symbol gets highlighted (but not selected) automatically in eeschema
-select the highlighted component in eeschema, press "U" shortcut (edit 
reference)
-change the reference in the dialog
-press F8 to update the pcb

A possible approach is to use this sequence of operations (...future python 
script?).

Since the mechanism to find the correct symbol on eeschema seems yet 
implemented, probably the only missing parts would be to implement is

Enable from pcbnew the command "select the highlighted component and/or open the 
"edit reference" dialog.

Drawbacks:
-Requires eeschema and pcbnew open at the same time (may be this is not a  a 
problem since we also have DRC that opens eeschema when run).
-Requires to check that schematic and layout are synchronized before starting 
the back-annotation (probably needed also for all the other implementations).
-For bigger schematics the full-update via F8 can become slow, so as a future 
improvement, after a first working implementation could be a way to update only 
the modified field.


I have done manual back-annotation because automated back-annotation (what 
Brian Piccioni is doing) didn’t exist.

I’m in the habit of doing “geographical re-annotation” after a layout has 
completed. This is where the layout is scanned and, say, the resistor most near 
the upper left is numbered R1, the resistor to its right is then R2, and so on. 
This is purely an aid for the human assembler and the human debugging the 
design. It’s not really interesting for automated assembly.

You can do this manually, on a small design, using the approach you suggest, 
but for anything complex (my last board was 165 mm x 125 mm with about 150 
capacitors, a hundred resistors, and a bunch of ICs) it’s impossible.

So it really needs to be automated. The options, as I see them, are few and 
simple: origin, direction (increasing in X or increasing in Y) and an option to 
not re-annotate a part (maybe don’t change the reference designators for 
connectors). The logic of the sorting is straightforward, but it’s a task best 
left to the machines.

-a

--


I agree,
   my comment was more "low level": to automate the high level 
"origin-direction-etc... the first step would be having the lower part 
"up-and-running", then build the fully automated part on that.


P.S.: I like the term "geographical annotation" more than "back 
annotation" for this feature.


Another possible approach I can think about is adding "board 
geographical (re)annotation in eeschema "annotate schematic" tool: if 
eeschema can "ask" the position to pcbnew it also can re-annotate the 
components according to position.
Since pcbnew does not move components if only the reference changes in 
eeschema, this could be also a solution.


Drawback: probably this approach is less intuitive to the user that 
expects to be able to change references in pcbnew.


Cheers,
Dino.


___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Andy Peters]

> On Nov 22, 2019, at 2:30 PM, Dino Ghilardi  wrote:
> 
> Just my two cents on this.
> 
> Considering that the actual "manual work-around" to do the "back annotation" 
> now can be:
> 
> -Open pcbnew and eeschema at the same time
> -Select the component you want to rename on pcbnew
> -the right symbol gets highlighted (but not selected) automatically in 
> eeschema
> -select the highlighted component in eeschema, press "U" shortcut (edit 
> reference)
> -change the reference in the dialog
> -press F8 to update the pcb
> 
> A possible approach is to use this sequence of operations (...future python 
> script?).
> 
> Since the mechanism to find the correct symbol on eeschema seems yet 
> implemented, probably the only missing parts would be to implement is
> 
> Enable from pcbnew the command "select the highlighted component and/or open 
> the "edit reference" dialog.
> 
> Drawbacks:
> -Requires eeschema and pcbnew open at the same time (may be this is not a  a 
> problem since we also have DRC that opens eeschema when run).
> -Requires to check that schematic and layout are synchronized before starting 
> the back-annotation (probably needed also for all the other implementations).
> -For bigger schematics the full-update via F8 can become slow, so as a future 
> improvement, after a first working implementation could be a way to update 
> only the modified field.

I have done manual back-annotation because automated back-annotation (what 
Brian Piccioni is doing) didn’t exist.

I’m in the habit of doing “geographical re-annotation” after a layout has 
completed. This is where the layout is scanned and, say, the resistor most near 
the upper left is numbered R1, the resistor to its right is then R2, and so on. 
This is purely an aid for the human assembler and the human debugging the 
design. It’s not really interesting for automated assembly.

You can do this manually, on a small design, using the approach you suggest, 
but for anything complex (my last board was 165 mm x 125 mm with about 150 
capacitors, a hundred resistors, and a bunch of ICs) it’s impossible.

So it really needs to be automated. The options, as I see them, are few and 
simple: origin, direction (increasing in X or increasing in Y) and an option to 
not re-annotate a part (maybe don’t change the reference designators for 
connectors). The logic of the sorting is straightforward, but it’s a task best 
left to the machines.

-a
___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Andy Peters]

> On Nov 22, 2019, at 2:17 PM, Brian  wrote:
> 
> An aside...
> 
> On 11/22/19 3:14 PM, Andy Peters wrote:
> 
>> Now select that sub-sheet symbol by left-clicking/holding and drawing a 
>> rectangle around it. Right-click and choose “duplicate block.” Now you have 
>> a new instance of that same sub-sheet.
> As a user, I would not expect "Duplicate" to mean "Create a shallow copy."  I 
> would expect the duplicated block to be completely independent of the 
> original block.  If that is actually the behavior (a shallow copy, i.e. a new 
> reference to the same block), "Duplicate" is a misleading term.
> 
> How, then, would I take a sub-sheet and create a deep copy, in the case that 
> my intent was to modify the copy in some way without affecting the original?
> 
> Thanks for engaging on my rabbit-trail!

“Copy” and “duplicate” are (as both nouns and verbs) mostly synonymous. 
“Duplicate” means:
 
1: consisting of or existing in two corresponding or identical parts or 
examples 
duplicate invoices

2: being the same as another 
duplicate copies

(One might argue that “duplicate copies” is redundant.)

In the case of the EESchema user interface, the operation makes a new instance 
of the selected object. That is, it really does make a duplicate. A sheet 
really is no different from a part symbol. Would you expect that your copy of 
the part symbol did not include the footprint? So, I think, “duplicate …” is 
the correct term, and the result is what the user should expect.

Now I just did a test, and realized that when you do the block-select to 
highlight/select the subsheet symbol, the right-click context menu includes 
both “Copy” and “Duplicate."

So what is the difference between “copy” and “duplicate” in the context of 
Kicad? They are not the same! 

The former (copy) puts the selected things into the copy/paste buffer. It 
doesn’t immediately add anything to your schematic. You can then go to anywhere 
in your schematic project (even to another sheet), do a Paste, and there’s a 
copy of your objects. But you can only copy blocks, not individual things.

The latter (duplicate) is immediate - the new instance of the selected stuff is 
now on your cursor and you can move and place it, but only on the current 
sheet. And, notably, the stuff you selected and duplicated does _NOT_ go into 
the copy/paste buffer. 

Now I’m going down the rabbit-hole, too! Why? Because when you select a single 
symbol/thing on a sheet, there is no “copy” available. That is, you can’t do 
Ctrl-C (or Cmd-C) on a resistors symbol and copy it, and in the right-click 
context menu you do not see Copy as an option. But you do see Duplicate as an 
option — and its hotkey is C! You have to do a block-select of the resistor to 
do a proper copy.

OK! 

So to answer, "How, then, would I take a sub-sheet and create a deep copy, in 
the case that my intent was to modify the copy in some way without affecting 
the original?”

Block-select the subsheet symbol and either copy or duplicate it. After you 
place the new instance of that subsheet symbol, mouse over the new symbol and 
hit E (for Edit), and a small dialog pops up. Give the copy a new File Name. 
(And give it a better sheet name, too.) After you click “OK,” you’ll get a 
message box asking for confirmation: “Create a new file newsubsheet.sch with 
the contents subsheet.sch? This cannot be undone.” Click YES and it will create 
a new file for your new subsheet. (Remember each sheet in a Kicad schematic is 
its own file.) The things in that new file are identical to what is in the 
source of the copy, but when you edit the new subsheet the older (source) 
subsheet is not affected.

Hope this helps. I use subsheets, both multiple-instances of the same subsheet 
as well as separate sheets, all the time.

-a
___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Dino Ghilardi]

Just my two cents on this.

Considering that the actual "manual work-around" to do the "back 
annotation" now can be:


-Open pcbnew and eeschema at the same time
-Select the component you want to rename on pcbnew
-the right symbol gets highlighted (but not selected) automatically in 
eeschema
-select the highlighted component in eeschema, press "U" shortcut (edit 
reference)

-change the reference in the dialog
-press F8 to update the pcb

A possible approach is to use this sequence of operations (...future 
python script?).


Since the mechanism to find the correct symbol on eeschema seems yet 
implemented, probably the only missing parts would be to implement is


Enable from pcbnew the command "select the highlighted component and/or 
open the "edit reference" dialog.


Drawbacks:
 -Requires eeschema and pcbnew open at the same time (may be this is 
not a  a problem since we also have DRC that opens eeschema when run).
 -Requires to check that schematic and layout are synchronized before 
starting the back-annotation (probably needed also for all the other 
implementations).
 -For bigger schematics the full-update via F8 can become slow, so as a 
future improvement, after a first working implementation could be a way 
to update only the modified field.



Cheers,
Dino.



___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Brian]

An aside...

On 11/22/19 3:14 PM, Andy Peters wrote:

Now select that sub-sheet symbol by left-clicking/holding and drawing 
a rectangle around it. Right-click and choose “duplicate block.” Now 
you have a new instance of that same sub-sheet.
As a user, I would not expect "Duplicate" to mean "Create a shallow 
copy."  I would expect the duplicated block to be completely independent 
of the original block.  If that is actually the behavior (a shallow 
copy, i.e. a new reference to the same block), "Duplicate" is a 
misleading term.


How, then, would I take a sub-sheet and create a deep copy, in the case 
that my intent was to modify the copy in some way without affecting the 
original?


Thanks for engaging on my rabbit-trail!

-B

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Andy Peters]

> On Nov 22, 2019, at 12:42 PM, Brian  wrote:
> 
>>> On 22 Nov 2019, at 19:29, Brian >> > wrote:
>>> 
>>> From the peanut gallery:
>>> 
>>> Can someone tell me an example use-case for a single schematic symbol 
>>> corresponding to multiple board entities within a single project?
>>> 
>>> As perhaps a rather naïve PCB designer, it seems like mostly a bad idea to 
>>> me to have anything other than 1:1.
>>> 
>>> Thanks,
>>> -Brian Henning 

>> On 11/22/19 2:37 PM, Jeff Young wrote:
>>> Hi Brian,
>>> 
>>> Imagine you’re doing an audio amplifier.  Your main schematic sheet has 4 
>>> subsheets: PSU, control logic, left channel and right channel.  Both left 
>>> channel and right channel point to the same sub-page.  So there’s a single 
>>> schematic symbol for each part in the left & right channel, which gets 
>>> annotated as two different references (ie: Q101 and Q201), and attached to 
>>> two different footprints.
>>> 
>>> Cheers,
>>> Jeff.
>>> 

> Hi Jeff,
> 
> Thanks for helping me understand this.  So how would someone looking at the 
> schematic know that this one symbol represents both Q101 and Q201?  For that 
> matter, if there's some instructions or a tutorial about creating a situation 
> like this (one schematic drawing representing multiple instances of the 
> subcircuit on the pcb), I'd be interested to learn it.  I have a couple 
> projects in the pipeline where I might find this feature useful; in the past, 
> I've manually copy/pasted sections of a schematic to repeat subcircuits.
> 
> Thanks,
> -Brian

When I first read Brian H’s message, “multiple board entities” stood out — I 
thought he was talking about having more than one physical PCB in the project! 
Now I understand his concern.

Brian — when you have a design which uses multiple instantiations of the same 
sub-sheet, when you look at that design in the schematic editor (are we still 
calling it EESChema?) you can navigate through the sub-sheets using the 
Hierarchical Navigator. In each instance of a sub-sheet, you will see that each 
component has been assigned unique reference designators.

So do a simple test. Create a project. In the project’s main sheet, choose 
Create Hierarchical sheet from the right-hand menu. Give it a reasonable file 
name (like subsheet.sch) and give it a reasonable Sheet Name. (Sheet name is 
basically a reference designator for a sub-sheet.) Enter that sheet, add some 
parts. keep it simple, like a single inverting op-amp circuit, so an op-amp 
symbol and two resistors. Add two power symbols for the op-amp power. Add 
hierarchical labels for the input and output. Don’t worry about annotation yet. 
Save the sheet. 

Navigate back to the top. Right-click on the sub-sheet symbol and choose 
“Import sheet pins.” You need to do this once for each hierarchical label you 
added. This is how you bring nets up to a higher level. Now select that 
sub-sheet symbol by left-clicking/holding and drawing a rectangle around it. 
Right-click and choose “duplicate block.” Now you have a new instance of that 
same sub-sheet. Place it. Then right-click on it, choose “Edit …” (or just hit 
E) and give it a better sheet name. Now you have two unique instances of that 
sub-sheet. Choose Tools -> Annotate Schematic. When that’s done, enter each of 
the sub-sheets — you will see that they each have unique reference designators 
for the same symbols. Also, the non-hierarchical (local) nets in each sub-sheet 
will have unique net labels! So when you export the netlist for PCB it’ll work 
as you expect.

Oh, yeah, when you print out the schematic, you will get as many sheets as you 
have instances of the sub-sheets. So the simple example here, with a top-level 
sheet and two instances of a single sub-sheet will give you three printed pages.

Try it!

-a___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Wayne Stambaugh]

t;>> follow a number of steps:
>>>>>  
>>>>>
>>>>>  1. Ensure the schematics, PCB, and netlist are coherent and
>>>>> without error (I.e. nothing in the schematics or PCB which is
>>>>> not in the other, netlist corresponds to schematic and PCB);
>>>>>  2. Manually edit each component on the board and keep a record of
>>>>> every change in a “change list”;
>>>>>  3. Manually edit the schematic in accordance with the “change list”;
>>>>>  4. Regenerate the netlist;
>>>>>  5. Update PCB from schematics;
>>>>>  6. Verify that the schematics and PCB are still coherent.
>>>>>
>>>>>  
>>>>> Manually editing the schematic would consist of going from
>>>>> component to component, looking up the component ref des in the
>>>>> “change list”, changing the ref des to the new value, and moving to
>>>>> the next component. The final step would only be necessary due to
>>>>> the near certainty that manual re-annotation would have introduced
>>>>> errors.
>>>>>  
>>>>> This is, more or less, what I do in my standalone application.
>>>>> Unfortunately, I also run roughshod over timestamps, etc..
>>>>> Nonetheless, the application has been well received and appears to
>>>>> be used a fair bit.
>>>>>  
>>>>> If we were to write a demon (probably the wrong term) which
>>>>> essentially did the same steps, would that address your concerns?
>>>>>  
>>>>> Of course, we would use Kiway to accomplish the transfers but the
>>>>> approach would be pretty much identical to a manual re-annotation
>>>>> except far less likely to introduce errors.
>>>>>  
>>>>> If that would not work, can you please explain why? Perhaps if we
>>>>> understand why we can suggest solutions.
>>>>>  
>>>>> Brian
>>>>>  
>>>>> *From: *Wayne Stambaugh <mailto:stambau...@gmail.com>
>>>>> *Sent: *November 22, 2019 12:03 PM
>>>>> *To: *Alexander Shuklin <mailto:jasura...@gmail.com>
>>>>> *Cc: *KiCad Developers <mailto:kicad-developers@lists.launchpad.net>
>>>>> *Subject: *Re: [Kicad-developers] Back annotate references from PCB
>>>>>  
>>>>> I would prefer that you did ask questions rather than spending a lot of
>>>>> development time on a solution that would not be accepted because it
>>>>> breaks things.  This is not a trivial problem although it may appear
>>>>> that way.  There are plenty of ways to implement back annotation that
>>>>> will break things in unexpected ways.  There are a very few ways to not
>>>>> break things.  This is why I'm telling you this.  If you don't care
>>>>> about the schematic and the board references being synchronized, then
>>>>> back-annotation isn't really necessary.  As soon as you attempt to
>>>>> back-annotated the schematic from the board, all of the issues that I
>>>>> have previously discussed come in to play and have to be addressed.
>>>>>  
>>>>> On 11/22/19 9:53 AM, Alexander Shuklin wrote:
>>>>> > Excuse me for so much questions. There's plenty of ways how it can be
>>>>> > done, and I'm quite new, maybe I don't see some simple way.
>>>>> > I can back up data from pcbnew which is not up to date to schematics,
>>>>> > after that I call update pcb dialog. Somebody will want to update pcb
>>>>> > by references and after that I will have pcbnew old data which is not
>>>>> > up to date either to schematics or layout anymore. I don't think
>>>>> there
>>>>> > will be straight forward solution how to solve it.
>>>>> > May I just open update pcb dialog and ask user to care about
>>>>> schematic
>>>>> > and layout being up to date?
>>>>> >
>>>>> > On Fri, 22 Nov 2019 at 17:16, Wayne Stambaugh
>>>>> mailto:stambau...@gmail.com>> wrote:
>>>>> >> 
>>>>> >> There is no need to create your own dialog.  Just call the
>>>>> update board
>>>>> >> from schematic function before you back annotate.  You will have
>>>>> to mak

Re: [Kicad-developers] Back annotate references from PCB

[Jeff Young]

Hi Brian,

If you double-click into the left channel you’ll see Q101.  If you double-click 
into the right, you’ll see Q201.  So it looks like there are two.  But if you 
edit either one it goes back to a single file so both will be changed.

(To be honest I’ve never used this feature, so I’m not 100% sure the above is 
correct.  But I’m pretty sure.)

My guess is there’s a tutorial somewhere; perhaps Wayne or JP could comment?

Cheers,
Jeff.


> On 22 Nov 2019, at 19:42, Brian  wrote:
> 
> Hi Jeff,
> 
> Thanks for helping me understand this.  So how would someone looking at the 
> schematic know that this one symbol represents both Q101 and Q201?  For that 
> matter, if there's some instructions or a tutorial about creating a situation 
> like this (one schematic drawing representing multiple instances of the 
> subcircuit on the pcb), I'd be interested to learn it.  I have a couple 
> projects in the pipeline where I might find this feature useful; in the past, 
> I've manually copy/pasted sections of a schematic to repeat subcircuits.
> 
> Thanks,
> -Brian
> 
> On 11/22/19 2:37 PM, Jeff Young wrote:
>> Hi Brian,
>> 
>> Imagine you’re doing an audio amplifier.  Your main schematic sheet has 4 
>> subsheets: PSU, control logic, left channel and right channel.  Both left 
>> channel and right channel point to the same sub-page.  So there’s a single 
>> schematic symbol for each part in the left & right channel, which gets 
>> annotated as two different references (ie: Q101 and Q201), and attached to 
>> two different footprints.
>> 
>> Cheers,
>> Jeff.
>> 
>>> On 22 Nov 2019, at 19:29, Brian >> <mailto:lotha...@gmail.com>> wrote:
>>> 
>>> From the peanut gallery:
>>> 
>>> Can someone tell me an example use-case for a single schematic symbol 
>>> corresponding to multiple board entities within a single project?
>>> 
>>> As perhaps a rather naïve PCB designer, it seems like mostly a bad idea to 
>>> me to have anything other than 1:1.
>>> 
>>> Thanks,
>>> -Brian Henning 
>>> 
>>>> On Nov 22, 2019, at 1:44 PM, Brian Piccioni >>> <mailto:br...@documenteddesigns.com>> wrote:
>>>> 
>>>> 
>>>> Wayne 
>>>>  
>>>> I thought I would weigh in as I am collaborating with Alexander.
>>>>  
>>>> If a designer manually re-annotates a board and schematics he would follow 
>>>> a number of steps:
>>>>  
>>>> Ensure the schematics, PCB, and netlist are coherent and without error 
>>>> (I.e. nothing in the schematics or PCB which is not in the other, netlist 
>>>> corresponds to schematic and PCB);
>>>> Manually edit each component on the board and keep a record of every 
>>>> change in a “change list”;
>>>> Manually edit the schematic in accordance with the “change list”;
>>>> Regenerate the netlist;
>>>> Update PCB from schematics;
>>>> Verify that the schematics and PCB are still coherent.
>>>>  
>>>> Manually editing the schematic would consist of going from component to 
>>>> component, looking up the component ref des in the “change list”, changing 
>>>> the ref des to the new value, and moving to the next component. The final 
>>>> step would only be necessary due to the near certainty that manual 
>>>> re-annotation would have introduced errors.
>>>>  
>>>> This is, more or less, what I do in my standalone application. 
>>>> Unfortunately, I also run roughshod over timestamps, etc.. Nonetheless, 
>>>> the application has been well received and appears to be used a fair bit.
>>>>  
>>>> If we were to write a demon (probably the wrong term) which essentially 
>>>> did the same steps, would that address your concerns?
>>>>  
>>>> Of course, we would use Kiway to accomplish the transfers but the approach 
>>>> would be pretty much identical to a manual re-annotation except far less 
>>>> likely to introduce errors.
>>>>  
>>>> If that would not work, can you please explain why? Perhaps if we 
>>>> understand why we can suggest solutions.
>>>>  
>>>> Brian
>>>>  
>>>> From: Wayne Stambaugh <mailto:stambau...@gmail.com>
>>>> Sent: November 22, 2019 12:03 PM
>>>> To: Alexander Shuklin <mailto:jasura...@gmail.com>
>>>> Cc: KiCad Developers <mailto:kicad-developers@lists.launchpad.net

Re: [Kicad-developers] Back annotate references from PCB

[Brian]

Hi Jeff,

Thanks for helping me understand this.  So how would someone looking at 
the schematic know that this one symbol represents both Q101 and Q201?  
For that matter, if there's some instructions or a tutorial about 
creating a situation like this (one schematic drawing representing 
multiple instances of the subcircuit on the pcb), I'd be interested to 
learn it.  I have a couple projects in the pipeline where I might find 
this feature useful; in the past, I've manually copy/pasted sections of 
a schematic to repeat subcircuits.


Thanks,
-Brian

On 11/22/19 2:37 PM, Jeff Young wrote:

Hi Brian,

Imagine you’re doing an audio amplifier.  Your main schematic sheet 
has 4 subsheets: PSU, control logic, left channel and right channel. 
 Both left channel and right channel point to the same sub-page.  So 
there’s a single schematic symbol for each part in the left & right 
channel, which gets annotated as two different references (ie: Q101 
and Q201), and attached to two different footprints.


Cheers,
Jeff.

On 22 Nov 2019, at 19:29, Brian <mailto:lotha...@gmail.com>> wrote:


From the peanut gallery:

Can someone tell me an example use-case for a single schematic symbol 
corresponding to multiple board entities within a single project?


As perhaps a rather naïve PCB designer, it seems like mostly a bad 
idea to me to have anything other than 1:1.


Thanks,
-Brian Henning

On Nov 22, 2019, at 1:44 PM, Brian Piccioni 
mailto:br...@documenteddesigns.com>> 
wrote:



Wayne
I thought I would weigh in as I am collaborating with Alexander.
If a designer manually re-annotates a board and schematics he would 
follow a number of steps:


 1. Ensure the schematics, PCB, and netlist are coherent and without
error (I.e. nothing in the schematics or PCB which is not in the
other, netlist corresponds to schematic and PCB);
 2. Manually edit each component on the board and keep a record of
every change in a “change list”;
 3. Manually edit the schematic in accordance with the “change list”;
 4. Regenerate the netlist;
 5. Update PCB from schematics;
 6. Verify that the schematics and PCB are still coherent.

Manually editing the schematic would consist of going from component 
to component, looking up the component ref des in the “change list”, 
changing the ref des to the new value, and moving to the next 
component. The final step would only be necessary due to the near 
certainty that manual re-annotation would have introduced errors.
This is, more or less, what I do in my standalone application. 
Unfortunately, I also run roughshod over timestamps, etc.. 
Nonetheless, the application has been well received and appears to 
be used a fair bit.
If we were to write a demon (probably the wrong term) which 
essentially did the same steps, would that address your concerns?
Of course, we would use Kiway to accomplish the transfers but the 
approach would be pretty much identical to a manual re-annotation 
except far less likely to introduce errors.
If that would not work, can you please explain why? Perhaps if we 
understand why we can suggest solutions.

Brian
*From:*Wayne Stambaugh <mailto:stambau...@gmail.com>
*Sent:*November 22, 2019 12:03 PM
*To:*Alexander Shuklin <mailto:jasura...@gmail.com>
*Cc:*KiCad Developers <mailto:kicad-developers@lists.launchpad.net>
*Subject:*Re: [Kicad-developers] Back annotate references from PCB
I would prefer that you did ask questions rather than spending a lot of
development time on a solution that would not be accepted because it
breaks things.  This is not a trivial problem although it may appear
that way.  There are plenty of ways to implement back annotation that
will break things in unexpected ways.  There are a very few ways to not
break things.  This is why I'm telling you this.  If you don't care
about the schematic and the board references being synchronized, then
back-annotation isn't really necessary.  As soon as you attempt to
back-annotated the schematic from the board, all of the issues that I
have previously discussed come in to play and have to be addressed.
On 11/22/19 9:53 AM, Alexander Shuklin wrote:
> Excuse me for so much questions. There's plenty of ways how it can be
> done, and I'm quite new, maybe I don't see some simple way.
> I can back up data from pcbnew which is not up to date to schematics,
> after that I call update pcb dialog. Somebody will want to update pcb
> by references and after that I will have pcbnew old data which is not
> up to date either to schematics or layout anymore. I don't think there
> will be straight forward solution how to solve it.
> May I just open update pcb dialog and ask user to care about schematic
> and layout being up to date?
>
> On Fri, 22 Nov 2019 at 17:16, Wayne Stambaugh 
mailto:stambau...@gmail.com>> wrote:

>>
>> There is no need to create your own dialog. 

Re: [Kicad-developers] Back annotate references from PCB

[Jeff Young]

Hi Brian,

Imagine you’re doing an audio amplifier.  Your main schematic sheet has 4 
subsheets: PSU, control logic, left channel and right channel.  Both left 
channel and right channel point to the same sub-page.  So there’s a single 
schematic symbol for each part in the left & right channel, which gets 
annotated as two different references (ie: Q101 and Q201), and attached to two 
different footprints.

Cheers,
Jeff.

> On 22 Nov 2019, at 19:29, Brian  wrote:
> 
> From the peanut gallery:
> 
> Can someone tell me an example use-case for a single schematic symbol 
> corresponding to multiple board entities within a single project?
> 
> As perhaps a rather naïve PCB designer, it seems like mostly a bad idea to me 
> to have anything other than 1:1.
> 
> Thanks,
> -Brian Henning 
> 
>> On Nov 22, 2019, at 1:44 PM, Brian Piccioni > <mailto:br...@documenteddesigns.com>> wrote:
>> 
>> 
>> Wayne 
>>  
>> I thought I would weigh in as I am collaborating with Alexander.
>>  
>> If a designer manually re-annotates a board and schematics he would follow a 
>> number of steps:
>>  
>> Ensure the schematics, PCB, and netlist are coherent and without error (I.e. 
>> nothing in the schematics or PCB which is not in the other, netlist 
>> corresponds to schematic and PCB);
>> Manually edit each component on the board and keep a record of every change 
>> in a “change list”;
>> Manually edit the schematic in accordance with the “change list”;
>> Regenerate the netlist;
>> Update PCB from schematics;
>> Verify that the schematics and PCB are still coherent.
>>  
>> Manually editing the schematic would consist of going from component to 
>> component, looking up the component ref des in the “change list”, changing 
>> the ref des to the new value, and moving to the next component. The final 
>> step would only be necessary due to the near certainty that manual 
>> re-annotation would have introduced errors.
>>  
>> This is, more or less, what I do in my standalone application. 
>> Unfortunately, I also run roughshod over timestamps, etc.. Nonetheless, the 
>> application has been well received and appears to be used a fair bit.
>>  
>> If we were to write a demon (probably the wrong term) which essentially did 
>> the same steps, would that address your concerns?
>>  
>> Of course, we would use Kiway to accomplish the transfers but the approach 
>> would be pretty much identical to a manual re-annotation except far less 
>> likely to introduce errors.
>>  
>> If that would not work, can you please explain why? Perhaps if we understand 
>> why we can suggest solutions.
>>  
>> Brian
>>  
>> From: Wayne Stambaugh <mailto:stambau...@gmail.com>
>> Sent: November 22, 2019 12:03 PM
>> To: Alexander Shuklin <mailto:jasura...@gmail.com>
>> Cc: KiCad Developers <mailto:kicad-developers@lists.launchpad.net>
>> Subject: Re: [Kicad-developers] Back annotate references from PCB
>>  
>> I would prefer that you did ask questions rather than spending a lot of
>> development time on a solution that would not be accepted because it
>> breaks things.  This is not a trivial problem although it may appear
>> that way.  There are plenty of ways to implement back annotation that
>> will break things in unexpected ways.  There are a very few ways to not
>> break things.  This is why I'm telling you this.  If you don't care
>> about the schematic and the board references being synchronized, then
>> back-annotation isn't really necessary.  As soon as you attempt to
>> back-annotated the schematic from the board, all of the issues that I
>> have previously discussed come in to play and have to be addressed.
>>  
>> On 11/22/19 9:53 AM, Alexander Shuklin wrote:
>> > Excuse me for so much questions. There's plenty of ways how it can be
>> > done, and I'm quite new, maybe I don't see some simple way.
>> > I can back up data from pcbnew which is not up to date to schematics,
>> > after that I call update pcb dialog. Somebody will want to update pcb
>> > by references and after that I will have pcbnew old data which is not
>> > up to date either to schematics or layout anymore. I don't think there
>> > will be straight forward solution how to solve it.
>> > May I just open update pcb dialog and ask user to care about schematic
>> > and layout being up to date?
>> >
>> > On Fri, 22 Nov 2019 at 17:16, Wayne Stambaugh > > <mailto:stambau...@gmail.com>> wrote:
>> >> 
&

Re: [Kicad-developers] Back annotate references from PCB

[Brian]

From the peanut gallery:

Can someone tell me an example use-case for a single schematic symbol 
corresponding to multiple board entities within a single project?

As perhaps a rather naïve PCB designer, it seems like mostly a bad idea to me 
to have anything other than 1:1.

Thanks,
-Brian Henning 

> On Nov 22, 2019, at 1:44 PM, Brian Piccioni  
> wrote:
> 
> 
> Wayne
>  
> I thought I would weigh in as I am collaborating with Alexander.
>  
> If a designer manually re-annotates a board and schematics he would follow a 
> number of steps:
>  
> Ensure the schematics, PCB, and netlist are coherent and without error (I.e. 
> nothing in the schematics or PCB which is not in the other, netlist 
> corresponds to schematic and PCB);
> Manually edit each component on the board and keep a record of every change 
> in a “change list”;
> Manually edit the schematic in accordance with the “change list”;
> Regenerate the netlist;
> Update PCB from schematics;
> Verify that the schematics and PCB are still coherent.
>  
> Manually editing the schematic would consist of going from component to 
> component, looking up the component ref des in the “change list”, changing 
> the ref des to the new value, and moving to the next component. The final 
> step would only be necessary due to the near certainty that manual 
> re-annotation would have introduced errors.
>  
> This is, more or less, what I do in my standalone application. Unfortunately, 
> I also run roughshod over timestamps, etc.. Nonetheless, the application has 
> been well received and appears to be used a fair bit.
>  
> If we were to write a demon (probably the wrong term) which essentially did 
> the same steps, would that address your concerns?
>  
> Of course, we would use Kiway to accomplish the transfers but the approach 
> would be pretty much identical to a manual re-annotation except far less 
> likely to introduce errors.
>  
> If that would not work, can you please explain why? Perhaps if we understand 
> why we can suggest solutions.
>  
> Brian
>  
> From: Wayne Stambaugh
> Sent: November 22, 2019 12:03 PM
> To: Alexander Shuklin
> Cc: KiCad Developers
> Subject: Re: [Kicad-developers] Back annotate references from PCB
>  
> I would prefer that you did ask questions rather than spending a lot of
> development time on a solution that would not be accepted because it
> breaks things.  This is not a trivial problem although it may appear
> that way.  There are plenty of ways to implement back annotation that
> will break things in unexpected ways.  There are a very few ways to not
> break things.  This is why I'm telling you this.  If you don't care
> about the schematic and the board references being synchronized, then
> back-annotation isn't really necessary.  As soon as you attempt to
> back-annotated the schematic from the board, all of the issues that I
> have previously discussed come in to play and have to be addressed.
>  
> On 11/22/19 9:53 AM, Alexander Shuklin wrote:
> > Excuse me for so much questions. There's plenty of ways how it can be
> > done, and I'm quite new, maybe I don't see some simple way.
> > I can back up data from pcbnew which is not up to date to schematics,
> > after that I call update pcb dialog. Somebody will want to update pcb
> > by references and after that I will have pcbnew old data which is not
> > up to date either to schematics or layout anymore. I don't think there
> > will be straight forward solution how to solve it.
> > May I just open update pcb dialog and ask user to care about schematic
> > and layout being up to date?
> >
> > On Fri, 22 Nov 2019 at 17:16, Wayne Stambaugh  wrote:
> >> 
> >> There is no need to create your own dialog.  Just call the update board
> >> from schematic function before you back annotate.  You will have to make
> >> a temporary copy of your board reference changes because updating from
> >> the schematic will clobber any reference changes in the board.
> >> 
> >> On 11/22/19 9:13 AM, Alexander Shuklin wrote:
> >>> Hi Wayne,
> >>> 
> >>> I don't want to start PCB update from eeschema straight away, because
> >>> if you run back-annotation, you already changed some references in
> >>> layout and you gonna lose it. And probably you can get some footprints
> >>> which are not connected to any of components in schematics as there's
> >>> possibility in pcbnew to create them. What I almost done is reporting
> >>> about all errors in dialog (I currently use annotation dialog in
> >>> eeschema, but I can create my own if it

Re: [Kicad-developers] Back annotate references from PCB

[Brian Piccioni]

Wayne  I thought I would weigh in as I am collaborating with Alexander. If a designer manually re-annotates a board and schematics he would follow a number of steps: Ensure the schematics, PCB, and netlist are coherent and without error (I.e. nothing in the schematics or PCB which is not in the other, netlist corresponds to schematic and PCB);Manually edit each component on the board and keep a record of every change in a “change list”;Manually edit the schematic in accordance with the “change list”;Regenerate the netlist;Update PCB from schematics;Verify that the schematics and PCB are still coherent. Manually editing the schematic would consist of going from component to component, looking up the component ref des in the “change list”, changing the ref des to the new value, and moving to the next component. The final step would only be necessary due to the near certainty that manual re-annotation would have introduced errors. This is, more or less, what I do in my standalone application. Unfortunately, I also run roughshod over timestamps, etc.. Nonetheless, the application has been well received and appears to be used a fair bit. If we were to write a demon (probably the wrong term) which essentially did the same steps, would that address your concerns? Of course, we would use Kiway to accomplish the transfers but the approach would be pretty much identical to a manual re-annotation except far less likely to introduce errors. If that would not work, can you please explain why? Perhaps if we understand why we can suggest solutions. Brian From: Wayne StambaughSent: November 22, 2019 12:03 PMTo: Alexander ShuklinCc: KiCad DevelopersSubject: Re: [Kicad-developers] Back annotate references from PCB I would prefer that you did ask questions rather than spending a lot ofdevelopment time on a solution that would not be accepted because itbreaks things.  This is not a trivial problem although it may appearthat way.  There are plenty of ways to implement back annotation thatwill break things in unexpected ways.  There are a very few ways to notbreak things.  This is why I'm telling you this.  If you don't careabout the schematic and the board references being synchronized, thenback-annotation isn't really necessary.  As soon as you attempt toback-annotated the schematic from the board, all of the issues that Ihave previously discussed come in to play and have to be addressed. On 11/22/19 9:53 AM, Alexander Shuklin wrote:> Excuse me for so much questions. There's plenty of ways how it can be> done, and I'm quite new, maybe I don't see some simple way.> I can back up data from pcbnew which is not up to date to schematics,> after that I call update pcb dialog. Somebody will want to update pcb> by references and after that I will have pcbnew old data which is not> up to date either to schematics or layout anymore. I don't think there> will be straight forward solution how to solve it.> May I just open update pcb dialog and ask user to care about schematic> and layout being up to date?> > On Fri, 22 Nov 2019 at 17:16, Wayne Stambaugh  wrote:>> >> There is no need to create your own dialog.  Just call the update board>> from schematic function before you back annotate.  You will have to make>> a temporary copy of your board reference changes because updating from>> the schematic will clobber any reference changes in the board.>> >> On 11/22/19 9:13 AM, Alexander Shuklin wrote:>>> Hi Wayne,>>> >>> I don't want to start PCB update from eeschema straight away, because>>> if you run back-annotation, you already changed some references in>>> layout and you gonna lose it. And probably you can get some footprints>>> which are not connected to any of components in schematics as there's>>> possibility in pcbnew to create them. What I almost done is reporting>>> about all errors in dialog (I currently use annotation dialog in>>> eeschema, but I can create my own if it necessary), and if there's any>>> errors, it will not allow you to back-annotate. It will ask you to fix>>> them first.>>> But if you want, I can run "update pcb from schematic" dialog.>>> >>> On Fri, 22 Nov 2019 at 16:30, Wayne Stambaugh  wrote:>>>> >>>> Hi Alexander,>>>> >>>> You must ensure that all of the reference paths are up to date with the>>>> schematic before you attempt to back annotate from the board.  Schematic>>>> changes can result in the footprint paths in the board being out of sync>>>> so you have to perform and update board from schematic (this code>>>> already exists) before you attempt to run the back annotation process>>>> from the board editor to ensure all of the paths are up t

Re: [Kicad-developers] Back annotate references from PCB

[Wayne Stambaugh]

I would prefer that you did ask questions rather than spending a lot of
development time on a solution that would not be accepted because it
breaks things.  This is not a trivial problem although it may appear
that way.  There are plenty of ways to implement back annotation that
will break things in unexpected ways.  There are a very few ways to not
break things.  This is why I'm telling you this.  If you don't care
about the schematic and the board references being synchronized, then
back-annotation isn't really necessary.  As soon as you attempt to
back-annotated the schematic from the board, all of the issues that I
have previously discussed come in to play and have to be addressed.

On 11/22/19 9:53 AM, Alexander Shuklin wrote:
> Excuse me for so much questions. There's plenty of ways how it can be
> done, and I'm quite new, maybe I don't see some simple way.
> I can back up data from pcbnew which is not up to date to schematics,
> after that I call update pcb dialog. Somebody will want to update pcb
> by references and after that I will have pcbnew old data which is not
> up to date either to schematics or layout anymore. I don't think there
> will be straight forward solution how to solve it.
> May I just open update pcb dialog and ask user to care about schematic
> and layout being up to date?
> 
> On Fri, 22 Nov 2019 at 17:16, Wayne Stambaugh  wrote:
>>
>> There is no need to create your own dialog.  Just call the update board
>> from schematic function before you back annotate.  You will have to make
>> a temporary copy of your board reference changes because updating from
>> the schematic will clobber any reference changes in the board.
>>
>> On 11/22/19 9:13 AM, Alexander Shuklin wrote:
>>> Hi Wayne,
>>>
>>> I don't want to start PCB update from eeschema straight away, because
>>> if you run back-annotation, you already changed some references in
>>> layout and you gonna lose it. And probably you can get some footprints
>>> which are not connected to any of components in schematics as there's
>>> possibility in pcbnew to create them. What I almost done is reporting
>>> about all errors in dialog (I currently use annotation dialog in
>>> eeschema, but I can create my own if it necessary), and if there's any
>>> errors, it will not allow you to back-annotate. It will ask you to fix
>>> them first.
>>> But if you want, I can run "update pcb from schematic" dialog.
>>>
>>> On Fri, 22 Nov 2019 at 16:30, Wayne Stambaugh  wrote:

 Hi Alexander,

 You must ensure that all of the reference paths are up to date with the
 schematic before you attempt to back annotate from the board.  Schematic
 changes can result in the footprint paths in the board being out of sync
 so you have to perform and update board from schematic (this code
 already exists) before you attempt to run the back annotation process
 from the board editor to ensure all of the paths are up to date.  This
 will ensure when you back annotate that there is a one to one
 correlation between board footprint sheet paths and schematic symbol
 sheet paths.

 Cheers,

 Wayne

 On 11/22/19 1:18 AM, Alexander Shuklin wrote:
> Hi Wayne,
> thanks for answer.
> Hopefully I will show you commit soon, so team could look, check and
> suggest something about that. I'm aware about differences between
> PCBnew and eeschema and just now I'm writing algorithm that will check
> it.
> Do you mean that some schematic file(.sch) can be used in more than
> one projects? So, I don't plan to change the unique IDs and those
> components will still be linked to each other, but if references will
> be changed it will make a mess in another project.
> I have 3 ideas how I can deal with that:
> 1) create a dialog, which will say something like "please make sure,
> that your schematic files are not shared between different projects"
> 2) I can go by recently opened projects, parse schematics in each of
> them and look if any schematic uses sheet, which already in use in
> current project. I'm now sure, but I would presume, that it will be
> quite slow.
> 3) To hold information in what project this particular schematics was
> used. So that's should be saved in .sch file then. But I don't think
> that information will be very valuable.
>
>
> On Thu, 21 Nov 2019 at 00:07, Wayne Stambaugh  
> wrote:
>>
>> On 11/7/19 5:06 AM, Alexander Shuklin wrote:
>>> Hi,
>>> is it alright to answer anybody in one letter?
>>> First of all, don't take amiss if I keep silence for a day, as I have
>>> 2 little children and at the best case I have couple of hours a day on
>>> my own.
>>>
>>> On Wed, 6 Nov 2019 at 16:27, Wayne Stambaugh  
>>> wrote:
 Complex schematic hierarchies (using the same schematic more than once 
 in a design) always trips up new developers.
>>> Ca

Re: [Kicad-developers] Back annotate references from PCB

[Alexander Shuklin]

Excuse me for so much questions. There's plenty of ways how it can be
done, and I'm quite new, maybe I don't see some simple way.
I can back up data from pcbnew which is not up to date to schematics,
after that I call update pcb dialog. Somebody will want to update pcb
by references and after that I will have pcbnew old data which is not
up to date either to schematics or layout anymore. I don't think there
will be straight forward solution how to solve it.
May I just open update pcb dialog and ask user to care about schematic
and layout being up to date?

On Fri, 22 Nov 2019 at 17:16, Wayne Stambaugh  wrote:
>
> There is no need to create your own dialog.  Just call the update board
> from schematic function before you back annotate.  You will have to make
> a temporary copy of your board reference changes because updating from
> the schematic will clobber any reference changes in the board.
>
> On 11/22/19 9:13 AM, Alexander Shuklin wrote:
> > Hi Wayne,
> >
> > I don't want to start PCB update from eeschema straight away, because
> > if you run back-annotation, you already changed some references in
> > layout and you gonna lose it. And probably you can get some footprints
> > which are not connected to any of components in schematics as there's
> > possibility in pcbnew to create them. What I almost done is reporting
> > about all errors in dialog (I currently use annotation dialog in
> > eeschema, but I can create my own if it necessary), and if there's any
> > errors, it will not allow you to back-annotate. It will ask you to fix
> > them first.
> > But if you want, I can run "update pcb from schematic" dialog.
> >
> > On Fri, 22 Nov 2019 at 16:30, Wayne Stambaugh  wrote:
> >>
> >> Hi Alexander,
> >>
> >> You must ensure that all of the reference paths are up to date with the
> >> schematic before you attempt to back annotate from the board.  Schematic
> >> changes can result in the footprint paths in the board being out of sync
> >> so you have to perform and update board from schematic (this code
> >> already exists) before you attempt to run the back annotation process
> >> from the board editor to ensure all of the paths are up to date.  This
> >> will ensure when you back annotate that there is a one to one
> >> correlation between board footprint sheet paths and schematic symbol
> >> sheet paths.
> >>
> >> Cheers,
> >>
> >> Wayne
> >>
> >> On 11/22/19 1:18 AM, Alexander Shuklin wrote:
> >>> Hi Wayne,
> >>> thanks for answer.
> >>> Hopefully I will show you commit soon, so team could look, check and
> >>> suggest something about that. I'm aware about differences between
> >>> PCBnew and eeschema and just now I'm writing algorithm that will check
> >>> it.
> >>> Do you mean that some schematic file(.sch) can be used in more than
> >>> one projects? So, I don't plan to change the unique IDs and those
> >>> components will still be linked to each other, but if references will
> >>> be changed it will make a mess in another project.
> >>> I have 3 ideas how I can deal with that:
> >>> 1) create a dialog, which will say something like "please make sure,
> >>> that your schematic files are not shared between different projects"
> >>> 2) I can go by recently opened projects, parse schematics in each of
> >>> them and look if any schematic uses sheet, which already in use in
> >>> current project. I'm now sure, but I would presume, that it will be
> >>> quite slow.
> >>> 3) To hold information in what project this particular schematics was
> >>> used. So that's should be saved in .sch file then. But I don't think
> >>> that information will be very valuable.
> >>>
> >>>
> >>> On Thu, 21 Nov 2019 at 00:07, Wayne Stambaugh  
> >>> wrote:
> 
>  On 11/7/19 5:06 AM, Alexander Shuklin wrote:
> > Hi,
> > is it alright to answer anybody in one letter?
> > First of all, don't take amiss if I keep silence for a day, as I have
> > 2 little children and at the best case I have couple of hours a day on
> > my own.
> >
> > On Wed, 6 Nov 2019 at 16:27, Wayne Stambaugh  
> > wrote:
> >> Complex schematic hierarchies (using the same schematic more than once 
> >> in a design) always trips up new developers.
> > Can you please explain a bit more? I know that you can use
> > hierarchical sheets, so there will be more than one sch files in the
> > schematic. And there's also "multi-symbols" which have few eeschema
> > symbols but one footprint. I'm not quite understand what means "using
> > the same schematic more than once in a design", as every symbol has
> > unique ID. Is it something else I'm not aware of?
> 
>  Yes, every symbol has a unique path ID but that doesn't mean that the
>  board and the schematic will always be in sync so this is where issues
>  come into play.  There also can be unique IDs from other projects
>  because schematics can be shared between projects so you have to be
>  careful not to break all of thes

Re: [Kicad-developers] Back annotate references from PCB

[Wayne Stambaugh]

There is no need to create your own dialog.  Just call the update board
from schematic function before you back annotate.  You will have to make
a temporary copy of your board reference changes because updating from
the schematic will clobber any reference changes in the board.

On 11/22/19 9:13 AM, Alexander Shuklin wrote:
> Hi Wayne,
> 
> I don't want to start PCB update from eeschema straight away, because
> if you run back-annotation, you already changed some references in
> layout and you gonna lose it. And probably you can get some footprints
> which are not connected to any of components in schematics as there's
> possibility in pcbnew to create them. What I almost done is reporting
> about all errors in dialog (I currently use annotation dialog in
> eeschema, but I can create my own if it necessary), and if there's any
> errors, it will not allow you to back-annotate. It will ask you to fix
> them first.
> But if you want, I can run "update pcb from schematic" dialog.
> 
> On Fri, 22 Nov 2019 at 16:30, Wayne Stambaugh  wrote:
>>
>> Hi Alexander,
>>
>> You must ensure that all of the reference paths are up to date with the
>> schematic before you attempt to back annotate from the board.  Schematic
>> changes can result in the footprint paths in the board being out of sync
>> so you have to perform and update board from schematic (this code
>> already exists) before you attempt to run the back annotation process
>> from the board editor to ensure all of the paths are up to date.  This
>> will ensure when you back annotate that there is a one to one
>> correlation between board footprint sheet paths and schematic symbol
>> sheet paths.
>>
>> Cheers,
>>
>> Wayne
>>
>> On 11/22/19 1:18 AM, Alexander Shuklin wrote:
>>> Hi Wayne,
>>> thanks for answer.
>>> Hopefully I will show you commit soon, so team could look, check and
>>> suggest something about that. I'm aware about differences between
>>> PCBnew and eeschema and just now I'm writing algorithm that will check
>>> it.
>>> Do you mean that some schematic file(.sch) can be used in more than
>>> one projects? So, I don't plan to change the unique IDs and those
>>> components will still be linked to each other, but if references will
>>> be changed it will make a mess in another project.
>>> I have 3 ideas how I can deal with that:
>>> 1) create a dialog, which will say something like "please make sure,
>>> that your schematic files are not shared between different projects"
>>> 2) I can go by recently opened projects, parse schematics in each of
>>> them and look if any schematic uses sheet, which already in use in
>>> current project. I'm now sure, but I would presume, that it will be
>>> quite slow.
>>> 3) To hold information in what project this particular schematics was
>>> used. So that's should be saved in .sch file then. But I don't think
>>> that information will be very valuable.
>>>
>>>
>>> On Thu, 21 Nov 2019 at 00:07, Wayne Stambaugh  wrote:

 On 11/7/19 5:06 AM, Alexander Shuklin wrote:
> Hi,
> is it alright to answer anybody in one letter?
> First of all, don't take amiss if I keep silence for a day, as I have
> 2 little children and at the best case I have couple of hours a day on
> my own.
>
> On Wed, 6 Nov 2019 at 16:27, Wayne Stambaugh  wrote:
>> Complex schematic hierarchies (using the same schematic more than once 
>> in a design) always trips up new developers.
> Can you please explain a bit more? I know that you can use
> hierarchical sheets, so there will be more than one sch files in the
> schematic. And there's also "multi-symbols" which have few eeschema
> symbols but one footprint. I'm not quite understand what means "using
> the same schematic more than once in a design", as every symbol has
> unique ID. Is it something else I'm not aware of?

 Yes, every symbol has a unique path ID but that doesn't mean that the
 board and the schematic will always be in sync so this is where issues
 come into play.  There also can be unique IDs from other projects
 because schematics can be shared between projects so you have to be
 careful not to break all of these cases.

>> You'll want to take a close look at KIWAY::ExpressMail() and 
>> KIWAY_PLAYER::KiwayMailIn()
> Ok, I'll look at that. I think I've seen that in footprints back 
> annotation.
>> This is unfortunate.  Being able to work directly with on of the lead 
>> developers would have made this task a lot easier to understand.  You 
>> are always free to reach out for help on this mailing list.
> Thanks for that. Actually now i think to join FOSDEM, but I need visa
> and I'm not sure yet.
>> Asking first prevents you from working on something that someone else 
>> may already be working on and writing code that would be immediately 
>> rejected
> Actually I already made that mistake, when made board statistics
> dialog. It was ac

Re: [Kicad-developers] Back annotate references from PCB

[Alexander Shuklin]

Hi Wayne,

I don't want to start PCB update from eeschema straight away, because
if you run back-annotation, you already changed some references in
layout and you gonna lose it. And probably you can get some footprints
which are not connected to any of components in schematics as there's
possibility in pcbnew to create them. What I almost done is reporting
about all errors in dialog (I currently use annotation dialog in
eeschema, but I can create my own if it necessary), and if there's any
errors, it will not allow you to back-annotate. It will ask you to fix
them first.
But if you want, I can run "update pcb from schematic" dialog.

On Fri, 22 Nov 2019 at 16:30, Wayne Stambaugh  wrote:
>
> Hi Alexander,
>
> You must ensure that all of the reference paths are up to date with the
> schematic before you attempt to back annotate from the board.  Schematic
> changes can result in the footprint paths in the board being out of sync
> so you have to perform and update board from schematic (this code
> already exists) before you attempt to run the back annotation process
> from the board editor to ensure all of the paths are up to date.  This
> will ensure when you back annotate that there is a one to one
> correlation between board footprint sheet paths and schematic symbol
> sheet paths.
>
> Cheers,
>
> Wayne
>
> On 11/22/19 1:18 AM, Alexander Shuklin wrote:
> > Hi Wayne,
> > thanks for answer.
> > Hopefully I will show you commit soon, so team could look, check and
> > suggest something about that. I'm aware about differences between
> > PCBnew and eeschema and just now I'm writing algorithm that will check
> > it.
> > Do you mean that some schematic file(.sch) can be used in more than
> > one projects? So, I don't plan to change the unique IDs and those
> > components will still be linked to each other, but if references will
> > be changed it will make a mess in another project.
> > I have 3 ideas how I can deal with that:
> > 1) create a dialog, which will say something like "please make sure,
> > that your schematic files are not shared between different projects"
> > 2) I can go by recently opened projects, parse schematics in each of
> > them and look if any schematic uses sheet, which already in use in
> > current project. I'm now sure, but I would presume, that it will be
> > quite slow.
> > 3) To hold information in what project this particular schematics was
> > used. So that's should be saved in .sch file then. But I don't think
> > that information will be very valuable.
> >
> >
> > On Thu, 21 Nov 2019 at 00:07, Wayne Stambaugh  wrote:
> >>
> >> On 11/7/19 5:06 AM, Alexander Shuklin wrote:
> >>> Hi,
> >>> is it alright to answer anybody in one letter?
> >>> First of all, don't take amiss if I keep silence for a day, as I have
> >>> 2 little children and at the best case I have couple of hours a day on
> >>> my own.
> >>>
> >>> On Wed, 6 Nov 2019 at 16:27, Wayne Stambaugh  wrote:
>  Complex schematic hierarchies (using the same schematic more than once 
>  in a design) always trips up new developers.
> >>> Can you please explain a bit more? I know that you can use
> >>> hierarchical sheets, so there will be more than one sch files in the
> >>> schematic. And there's also "multi-symbols" which have few eeschema
> >>> symbols but one footprint. I'm not quite understand what means "using
> >>> the same schematic more than once in a design", as every symbol has
> >>> unique ID. Is it something else I'm not aware of?
> >>
> >> Yes, every symbol has a unique path ID but that doesn't mean that the
> >> board and the schematic will always be in sync so this is where issues
> >> come into play.  There also can be unique IDs from other projects
> >> because schematics can be shared between projects so you have to be
> >> careful not to break all of these cases.
> >>
>  You'll want to take a close look at KIWAY::ExpressMail() and 
>  KIWAY_PLAYER::KiwayMailIn()
> >>> Ok, I'll look at that. I think I've seen that in footprints back 
> >>> annotation.
>  This is unfortunate.  Being able to work directly with on of the lead 
>  developers would have made this task a lot easier to understand.  You 
>  are always free to reach out for help on this mailing list.
> >>> Thanks for that. Actually now i think to join FOSDEM, but I need visa
> >>> and I'm not sure yet.
>  Asking first prevents you from working on something that someone else 
>  may already be working on and writing code that would be immediately 
>  rejected
> >>> Actually I already made that mistake, when made board statistics
> >>> dialog. It was accepted, but I felt myself really stupid.
>  Good luck and thank you for your interest in contributing to KiCad.
> >>> Thanks! I will try hard to match coding and git polices.
> >>>
> >>> On Wed, 6 Nov 2019 at 17:24, Jon Evans  wrote:
>  Eeschema now keeps its internal net state up to date continuously, but I 
>  didn't work on any continuous syncing to PcbNe

Re: [Kicad-developers] Back annotate references from PCB

[Wayne Stambaugh]

You got it!  Schematic files can be shared multiple times not only in
the current schematic but multiple times in other project schematics as
well.  You could have a symbol in a schematic file with the same
reference more than once with many different sheet paths.

On 11/22/19 6:55 AM, Alexander Shuklin wrote:
> Ooops,
> I just realized what are you own about.
> I wasn't aware that's it is possible to use schematic sheet twice and
> have different references in it according to sheet path. I never used
> it during PCB production :)
> That's not a problem I will use component "path" rather than just
> timestamp. Thanks for tip!
> 
> On Fri, 22 Nov 2019 at 09:18, Alexander Shuklin  wrote:
>>
>> Hi Wayne,
>> thanks for answer.
>> Hopefully I will show you commit soon, so team could look, check and
>> suggest something about that. I'm aware about differences between
>> PCBnew and eeschema and just now I'm writing algorithm that will check
>> it.
>> Do you mean that some schematic file(.sch) can be used in more than
>> one projects? So, I don't plan to change the unique IDs and those
>> components will still be linked to each other, but if references will
>> be changed it will make a mess in another project.
>> I have 3 ideas how I can deal with that:
>> 1) create a dialog, which will say something like "please make sure,
>> that your schematic files are not shared between different projects"
>> 2) I can go by recently opened projects, parse schematics in each of
>> them and look if any schematic uses sheet, which already in use in
>> current project. I'm now sure, but I would presume, that it will be
>> quite slow.
>> 3) To hold information in what project this particular schematics was
>> used. So that's should be saved in .sch file then. But I don't think
>> that information will be very valuable.
>>
>>
>> On Thu, 21 Nov 2019 at 00:07, Wayne Stambaugh  wrote:
>>>
>>> On 11/7/19 5:06 AM, Alexander Shuklin wrote:
 Hi,
 is it alright to answer anybody in one letter?
 First of all, don't take amiss if I keep silence for a day, as I have
 2 little children and at the best case I have couple of hours a day on
 my own.

 On Wed, 6 Nov 2019 at 16:27, Wayne Stambaugh  wrote:
> Complex schematic hierarchies (using the same schematic more than once in 
> a design) always trips up new developers.
 Can you please explain a bit more? I know that you can use
 hierarchical sheets, so there will be more than one sch files in the
 schematic. And there's also "multi-symbols" which have few eeschema
 symbols but one footprint. I'm not quite understand what means "using
 the same schematic more than once in a design", as every symbol has
 unique ID. Is it something else I'm not aware of?
>>>
>>> Yes, every symbol has a unique path ID but that doesn't mean that the
>>> board and the schematic will always be in sync so this is where issues
>>> come into play.  There also can be unique IDs from other projects
>>> because schematics can be shared between projects so you have to be
>>> careful not to break all of these cases.
>>>
> You'll want to take a close look at KIWAY::ExpressMail() and 
> KIWAY_PLAYER::KiwayMailIn()
 Ok, I'll look at that. I think I've seen that in footprints back 
 annotation.
> This is unfortunate.  Being able to work directly with on of the lead 
> developers would have made this task a lot easier to understand.  You are 
> always free to reach out for help on this mailing list.
 Thanks for that. Actually now i think to join FOSDEM, but I need visa
 and I'm not sure yet.
> Asking first prevents you from working on something that someone else may 
> already be working on and writing code that would be immediately rejected
 Actually I already made that mistake, when made board statistics
 dialog. It was accepted, but I felt myself really stupid.
> Good luck and thank you for your interest in contributing to KiCad.
 Thanks! I will try hard to match coding and git polices.

 On Wed, 6 Nov 2019 at 17:24, Jon Evans  wrote:
> Eeschema now keeps its internal net state up to date continuously, but I 
> didn't work on any continuous syncing to PcbNew.  The way it works in 
> Eeschema, the graphical schematic is still the driving source of truth; 
> the netlist does not drive the schematic.
 Am I right in general idea: Eeschema creates netlist which updates
 continuously. And PCB updates through eeschema by "uppdate PCB from
 schematic" tool. It isn't planned to do that automatically and
 continuously, is it?

 On Wed, 6 Nov 2019 at 17:56, Brian Piccioni  
 wrote:
> My utility is up on GitHub as a standalone app. I learned enough c++ and 
> wxWidgets so porting it to Kicad should be useful.
 I've seen your app, and bug report. And actually I try to jump in
 because I use geometrical renumber of components as well)))
> Replacing my 

Re: [Kicad-developers] Back annotate references from PCB

[Wayne Stambaugh]

Hi Alexander,

You must ensure that all of the reference paths are up to date with the
schematic before you attempt to back annotate from the board.  Schematic
changes can result in the footprint paths in the board being out of sync
so you have to perform and update board from schematic (this code
already exists) before you attempt to run the back annotation process
from the board editor to ensure all of the paths are up to date.  This
will ensure when you back annotate that there is a one to one
correlation between board footprint sheet paths and schematic symbol
sheet paths.

Cheers,

Wayne

On 11/22/19 1:18 AM, Alexander Shuklin wrote:
> Hi Wayne,
> thanks for answer.
> Hopefully I will show you commit soon, so team could look, check and
> suggest something about that. I'm aware about differences between
> PCBnew and eeschema and just now I'm writing algorithm that will check
> it.
> Do you mean that some schematic file(.sch) can be used in more than
> one projects? So, I don't plan to change the unique IDs and those
> components will still be linked to each other, but if references will
> be changed it will make a mess in another project.
> I have 3 ideas how I can deal with that:
> 1) create a dialog, which will say something like "please make sure,
> that your schematic files are not shared between different projects"
> 2) I can go by recently opened projects, parse schematics in each of
> them and look if any schematic uses sheet, which already in use in
> current project. I'm now sure, but I would presume, that it will be
> quite slow.
> 3) To hold information in what project this particular schematics was
> used. So that's should be saved in .sch file then. But I don't think
> that information will be very valuable.
> 
> 
> On Thu, 21 Nov 2019 at 00:07, Wayne Stambaugh  wrote:
>>
>> On 11/7/19 5:06 AM, Alexander Shuklin wrote:
>>> Hi,
>>> is it alright to answer anybody in one letter?
>>> First of all, don't take amiss if I keep silence for a day, as I have
>>> 2 little children and at the best case I have couple of hours a day on
>>> my own.
>>>
>>> On Wed, 6 Nov 2019 at 16:27, Wayne Stambaugh  wrote:
 Complex schematic hierarchies (using the same schematic more than once in 
 a design) always trips up new developers.
>>> Can you please explain a bit more? I know that you can use
>>> hierarchical sheets, so there will be more than one sch files in the
>>> schematic. And there's also "multi-symbols" which have few eeschema
>>> symbols but one footprint. I'm not quite understand what means "using
>>> the same schematic more than once in a design", as every symbol has
>>> unique ID. Is it something else I'm not aware of?
>>
>> Yes, every symbol has a unique path ID but that doesn't mean that the
>> board and the schematic will always be in sync so this is where issues
>> come into play.  There also can be unique IDs from other projects
>> because schematics can be shared between projects so you have to be
>> careful not to break all of these cases.
>>
 You'll want to take a close look at KIWAY::ExpressMail() and 
 KIWAY_PLAYER::KiwayMailIn()
>>> Ok, I'll look at that. I think I've seen that in footprints back annotation.
 This is unfortunate.  Being able to work directly with on of the lead 
 developers would have made this task a lot easier to understand.  You are 
 always free to reach out for help on this mailing list.
>>> Thanks for that. Actually now i think to join FOSDEM, but I need visa
>>> and I'm not sure yet.
 Asking first prevents you from working on something that someone else may 
 already be working on and writing code that would be immediately rejected
>>> Actually I already made that mistake, when made board statistics
>>> dialog. It was accepted, but I felt myself really stupid.
 Good luck and thank you for your interest in contributing to KiCad.
>>> Thanks! I will try hard to match coding and git polices.
>>>
>>> On Wed, 6 Nov 2019 at 17:24, Jon Evans  wrote:
 Eeschema now keeps its internal net state up to date continuously, but I 
 didn't work on any continuous syncing to PcbNew.  The way it works in 
 Eeschema, the graphical schematic is still the driving source of truth; 
 the netlist does not drive the schematic.
>>> Am I right in general idea: Eeschema creates netlist which updates
>>> continuously. And PCB updates through eeschema by "uppdate PCB from
>>> schematic" tool. It isn't planned to do that automatically and
>>> continuously, is it?
>>>
>>> On Wed, 6 Nov 2019 at 17:56, Brian Piccioni  
>>> wrote:
 My utility is up on GitHub as a standalone app. I learned enough c++ and 
 wxWidgets so porting it to Kicad should be useful.
>>> I've seen your app, and bug report. And actually I try to jump in
>>> because I use geometrical renumber of components as well)))
 Replacing my homebrew parsing of PCB, Schematic, and netlist files to 
 calls to internal Kicad functions/methods in the respective apps;
 

Re: [Kicad-developers] Back annotate references from PCB

[Alexander Shuklin]

Ooops,
I just realized what are you own about.
I wasn't aware that's it is possible to use schematic sheet twice and
have different references in it according to sheet path. I never used
it during PCB production :)
That's not a problem I will use component "path" rather than just
timestamp. Thanks for tip!

On Fri, 22 Nov 2019 at 09:18, Alexander Shuklin  wrote:
>
> Hi Wayne,
> thanks for answer.
> Hopefully I will show you commit soon, so team could look, check and
> suggest something about that. I'm aware about differences between
> PCBnew and eeschema and just now I'm writing algorithm that will check
> it.
> Do you mean that some schematic file(.sch) can be used in more than
> one projects? So, I don't plan to change the unique IDs and those
> components will still be linked to each other, but if references will
> be changed it will make a mess in another project.
> I have 3 ideas how I can deal with that:
> 1) create a dialog, which will say something like "please make sure,
> that your schematic files are not shared between different projects"
> 2) I can go by recently opened projects, parse schematics in each of
> them and look if any schematic uses sheet, which already in use in
> current project. I'm now sure, but I would presume, that it will be
> quite slow.
> 3) To hold information in what project this particular schematics was
> used. So that's should be saved in .sch file then. But I don't think
> that information will be very valuable.
>
>
> On Thu, 21 Nov 2019 at 00:07, Wayne Stambaugh  wrote:
> >
> > On 11/7/19 5:06 AM, Alexander Shuklin wrote:
> > > Hi,
> > > is it alright to answer anybody in one letter?
> > > First of all, don't take amiss if I keep silence for a day, as I have
> > > 2 little children and at the best case I have couple of hours a day on
> > > my own.
> > >
> > > On Wed, 6 Nov 2019 at 16:27, Wayne Stambaugh  wrote:
> > >> Complex schematic hierarchies (using the same schematic more than once 
> > >> in a design) always trips up new developers.
> > > Can you please explain a bit more? I know that you can use
> > > hierarchical sheets, so there will be more than one sch files in the
> > > schematic. And there's also "multi-symbols" which have few eeschema
> > > symbols but one footprint. I'm not quite understand what means "using
> > > the same schematic more than once in a design", as every symbol has
> > > unique ID. Is it something else I'm not aware of?
> >
> > Yes, every symbol has a unique path ID but that doesn't mean that the
> > board and the schematic will always be in sync so this is where issues
> > come into play.  There also can be unique IDs from other projects
> > because schematics can be shared between projects so you have to be
> > careful not to break all of these cases.
> >
> > >> You'll want to take a close look at KIWAY::ExpressMail() and 
> > >> KIWAY_PLAYER::KiwayMailIn()
> > > Ok, I'll look at that. I think I've seen that in footprints back 
> > > annotation.
> > >> This is unfortunate.  Being able to work directly with on of the lead 
> > >> developers would have made this task a lot easier to understand.  You 
> > >> are always free to reach out for help on this mailing list.
> > > Thanks for that. Actually now i think to join FOSDEM, but I need visa
> > > and I'm not sure yet.
> > >> Asking first prevents you from working on something that someone else 
> > >> may already be working on and writing code that would be immediately 
> > >> rejected
> > > Actually I already made that mistake, when made board statistics
> > > dialog. It was accepted, but I felt myself really stupid.
> > >> Good luck and thank you for your interest in contributing to KiCad.
> > > Thanks! I will try hard to match coding and git polices.
> > >
> > > On Wed, 6 Nov 2019 at 17:24, Jon Evans  wrote:
> > >> Eeschema now keeps its internal net state up to date continuously, but I 
> > >> didn't work on any continuous syncing to PcbNew.  The way it works in 
> > >> Eeschema, the graphical schematic is still the driving source of truth; 
> > >> the netlist does not drive the schematic.
> > > Am I right in general idea: Eeschema creates netlist which updates
> > > continuously. And PCB updates through eeschema by "uppdate PCB from
> > > schematic" tool. It isn't planned to do that automatically and
> > > continuously, is it?
> > >
> > > On Wed, 6 Nov 2019 at 17:56, Brian Piccioni  
> > > wrote:
> > >> My utility is up on GitHub as a standalone app. I learned enough c++ and 
> > >> wxWidgets so porting it to Kicad should be useful.
> > > I've seen your app, and bug report. And actually I try to jump in
> > > because I use geometrical renumber of components as well)))
> > >> Replacing my homebrew parsing of PCB, Schematic, and netlist files to 
> > >> calls to internal Kicad functions/methods in the respective apps;
> > >> Once this is done I’ll use Kiway to communicate the changes between 
> > >> eeSchema and PCBNew.
> > > Have you already start to create communication between ee

Re: [Kicad-developers] Back annotate references from PCB

[Alexander Shuklin]

Hi Wayne,
thanks for answer.
Hopefully I will show you commit soon, so team could look, check and
suggest something about that. I'm aware about differences between
PCBnew and eeschema and just now I'm writing algorithm that will check
it.
Do you mean that some schematic file(.sch) can be used in more than
one projects? So, I don't plan to change the unique IDs and those
components will still be linked to each other, but if references will
be changed it will make a mess in another project.
I have 3 ideas how I can deal with that:
1) create a dialog, which will say something like "please make sure,
that your schematic files are not shared between different projects"
2) I can go by recently opened projects, parse schematics in each of
them and look if any schematic uses sheet, which already in use in
current project. I'm now sure, but I would presume, that it will be
quite slow.
3) To hold information in what project this particular schematics was
used. So that's should be saved in .sch file then. But I don't think
that information will be very valuable.


On Thu, 21 Nov 2019 at 00:07, Wayne Stambaugh  wrote:
>
> On 11/7/19 5:06 AM, Alexander Shuklin wrote:
> > Hi,
> > is it alright to answer anybody in one letter?
> > First of all, don't take amiss if I keep silence for a day, as I have
> > 2 little children and at the best case I have couple of hours a day on
> > my own.
> >
> > On Wed, 6 Nov 2019 at 16:27, Wayne Stambaugh  wrote:
> >> Complex schematic hierarchies (using the same schematic more than once in 
> >> a design) always trips up new developers.
> > Can you please explain a bit more? I know that you can use
> > hierarchical sheets, so there will be more than one sch files in the
> > schematic. And there's also "multi-symbols" which have few eeschema
> > symbols but one footprint. I'm not quite understand what means "using
> > the same schematic more than once in a design", as every symbol has
> > unique ID. Is it something else I'm not aware of?
>
> Yes, every symbol has a unique path ID but that doesn't mean that the
> board and the schematic will always be in sync so this is where issues
> come into play.  There also can be unique IDs from other projects
> because schematics can be shared between projects so you have to be
> careful not to break all of these cases.
>
> >> You'll want to take a close look at KIWAY::ExpressMail() and 
> >> KIWAY_PLAYER::KiwayMailIn()
> > Ok, I'll look at that. I think I've seen that in footprints back annotation.
> >> This is unfortunate.  Being able to work directly with on of the lead 
> >> developers would have made this task a lot easier to understand.  You are 
> >> always free to reach out for help on this mailing list.
> > Thanks for that. Actually now i think to join FOSDEM, but I need visa
> > and I'm not sure yet.
> >> Asking first prevents you from working on something that someone else may 
> >> already be working on and writing code that would be immediately rejected
> > Actually I already made that mistake, when made board statistics
> > dialog. It was accepted, but I felt myself really stupid.
> >> Good luck and thank you for your interest in contributing to KiCad.
> > Thanks! I will try hard to match coding and git polices.
> >
> > On Wed, 6 Nov 2019 at 17:24, Jon Evans  wrote:
> >> Eeschema now keeps its internal net state up to date continuously, but I 
> >> didn't work on any continuous syncing to PcbNew.  The way it works in 
> >> Eeschema, the graphical schematic is still the driving source of truth; 
> >> the netlist does not drive the schematic.
> > Am I right in general idea: Eeschema creates netlist which updates
> > continuously. And PCB updates through eeschema by "uppdate PCB from
> > schematic" tool. It isn't planned to do that automatically and
> > continuously, is it?
> >
> > On Wed, 6 Nov 2019 at 17:56, Brian Piccioni  
> > wrote:
> >> My utility is up on GitHub as a standalone app. I learned enough c++ and 
> >> wxWidgets so porting it to Kicad should be useful.
> > I've seen your app, and bug report. And actually I try to jump in
> > because I use geometrical renumber of components as well)))
> >> Replacing my homebrew parsing of PCB, Schematic, and netlist files to 
> >> calls to internal Kicad functions/methods in the respective apps;
> >> Once this is done I’ll use Kiway to communicate the changes between 
> >> eeSchema and PCBNew.
> > Have you already start to create communication between eeschema and
> > pcbnew? If not, don't you mind if I'll start with that first? From my
> > point of view, that's a worst part in this question today. For example
> > you can renumber modules in pcbnew even by python scripts, but you
> > have no any tool to change schematic after that. And by the way it's
> > not only about renumber of all components. Somebody would like to
> > change some references in pcbnew by hand at push that data back to
> > schematics.
> >> In the final version, if I understand correctly, in V6 changes to the PCB 
> >> 

Re: [Kicad-developers] Back annotate references from PCB

[Wayne Stambaugh]

On 11/7/19 5:06 AM, Alexander Shuklin wrote:
> Hi,
> is it alright to answer anybody in one letter?
> First of all, don't take amiss if I keep silence for a day, as I have
> 2 little children and at the best case I have couple of hours a day on
> my own.
> 
> On Wed, 6 Nov 2019 at 16:27, Wayne Stambaugh  wrote:
>> Complex schematic hierarchies (using the same schematic more than once in a 
>> design) always trips up new developers.
> Can you please explain a bit more? I know that you can use
> hierarchical sheets, so there will be more than one sch files in the
> schematic. And there's also "multi-symbols" which have few eeschema
> symbols but one footprint. I'm not quite understand what means "using
> the same schematic more than once in a design", as every symbol has
> unique ID. Is it something else I'm not aware of?

Yes, every symbol has a unique path ID but that doesn't mean that the
board and the schematic will always be in sync so this is where issues
come into play.  There also can be unique IDs from other projects
because schematics can be shared between projects so you have to be
careful not to break all of these cases.

>> You'll want to take a close look at KIWAY::ExpressMail() and 
>> KIWAY_PLAYER::KiwayMailIn()
> Ok, I'll look at that. I think I've seen that in footprints back annotation.
>> This is unfortunate.  Being able to work directly with on of the lead 
>> developers would have made this task a lot easier to understand.  You are 
>> always free to reach out for help on this mailing list.
> Thanks for that. Actually now i think to join FOSDEM, but I need visa
> and I'm not sure yet.
>> Asking first prevents you from working on something that someone else may 
>> already be working on and writing code that would be immediately rejected
> Actually I already made that mistake, when made board statistics
> dialog. It was accepted, but I felt myself really stupid.
>> Good luck and thank you for your interest in contributing to KiCad.
> Thanks! I will try hard to match coding and git polices.
> 
> On Wed, 6 Nov 2019 at 17:24, Jon Evans  wrote:
>> Eeschema now keeps its internal net state up to date continuously, but I 
>> didn't work on any continuous syncing to PcbNew.  The way it works in 
>> Eeschema, the graphical schematic is still the driving source of truth; the 
>> netlist does not drive the schematic.
> Am I right in general idea: Eeschema creates netlist which updates
> continuously. And PCB updates through eeschema by "uppdate PCB from
> schematic" tool. It isn't planned to do that automatically and
> continuously, is it?
> 
> On Wed, 6 Nov 2019 at 17:56, Brian Piccioni  
> wrote:
>> My utility is up on GitHub as a standalone app. I learned enough c++ and 
>> wxWidgets so porting it to Kicad should be useful.
> I've seen your app, and bug report. And actually I try to jump in
> because I use geometrical renumber of components as well)))
>> Replacing my homebrew parsing of PCB, Schematic, and netlist files to calls 
>> to internal Kicad functions/methods in the respective apps;
>> Once this is done I’ll use Kiway to communicate the changes between eeSchema 
>> and PCBNew.
> Have you already start to create communication between eeschema and
> pcbnew? If not, don't you mind if I'll start with that first? From my
> point of view, that's a worst part in this question today. For example
> you can renumber modules in pcbnew even by python scripts, but you
> have no any tool to change schematic after that. And by the way it's
> not only about renumber of all components. Somebody would like to
> change some references in pcbnew by hand at push that data back to
> schematics.
>> In the final version, if I understand correctly, in V6 changes to the PCB 
>> will be back-annotated to the schematic in order to support pin and  gate 
>> swapping. So updating the PCB will immediately incorporate the changes to 
>> the schematic. I haven’t seen any discussions of how this will be done but 
>> clearly if the prototype as described above works it will be trivial to 
>> support the V6 common database.
> Hm... I haven't think about that... I'm not sure if pin swapping will
> interact with back-annotation tool. I wouldn't say that, but if
> somebody has comments and thoughts about that, it would be greatly
> appreciated.
> 
> As far as I see now, It should be some tool a bit similar to "Update
> PCB from schematic", which will utilize KiWay functions to send data
> between PCBnew and eeschema..
> 

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Alexander Shuklin]

Hi,
is it alright to answer anybody in one letter?
First of all, don't take amiss if I keep silence for a day, as I have
2 little children and at the best case I have couple of hours a day on
my own.

On Wed, 6 Nov 2019 at 16:27, Wayne Stambaugh  wrote:
> Complex schematic hierarchies (using the same schematic more than once in a 
> design) always trips up new developers.
Can you please explain a bit more? I know that you can use
hierarchical sheets, so there will be more than one sch files in the
schematic. And there's also "multi-symbols" which have few eeschema
symbols but one footprint. I'm not quite understand what means "using
the same schematic more than once in a design", as every symbol has
unique ID. Is it something else I'm not aware of?
> You'll want to take a close look at KIWAY::ExpressMail() and 
> KIWAY_PLAYER::KiwayMailIn()
Ok, I'll look at that. I think I've seen that in footprints back annotation.
> This is unfortunate.  Being able to work directly with on of the lead 
> developers would have made this task a lot easier to understand.  You are 
> always free to reach out for help on this mailing list.
Thanks for that. Actually now i think to join FOSDEM, but I need visa
and I'm not sure yet.
> Asking first prevents you from working on something that someone else may 
> already be working on and writing code that would be immediately rejected
Actually I already made that mistake, when made board statistics
dialog. It was accepted, but I felt myself really stupid.
> Good luck and thank you for your interest in contributing to KiCad.
Thanks! I will try hard to match coding and git polices.

On Wed, 6 Nov 2019 at 17:24, Jon Evans  wrote:
> Eeschema now keeps its internal net state up to date continuously, but I 
> didn't work on any continuous syncing to PcbNew.  The way it works in 
> Eeschema, the graphical schematic is still the driving source of truth; the 
> netlist does not drive the schematic.
Am I right in general idea: Eeschema creates netlist which updates
continuously. And PCB updates through eeschema by "uppdate PCB from
schematic" tool. It isn't planned to do that automatically and
continuously, is it?

On Wed, 6 Nov 2019 at 17:56, Brian Piccioni  wrote:
> My utility is up on GitHub as a standalone app. I learned enough c++ and 
> wxWidgets so porting it to Kicad should be useful.
I've seen your app, and bug report. And actually I try to jump in
because I use geometrical renumber of components as well)))
> Replacing my homebrew parsing of PCB, Schematic, and netlist files to calls 
> to internal Kicad functions/methods in the respective apps;
> Once this is done I’ll use Kiway to communicate the changes between eeSchema 
> and PCBNew.
Have you already start to create communication between eeschema and
pcbnew? If not, don't you mind if I'll start with that first? From my
point of view, that's a worst part in this question today. For example
you can renumber modules in pcbnew even by python scripts, but you
have no any tool to change schematic after that. And by the way it's
not only about renumber of all components. Somebody would like to
change some references in pcbnew by hand at push that data back to
schematics.
>In the final version, if I understand correctly, in V6 changes to the PCB will 
>be back-annotated to the schematic in order to support pin and  gate swapping. 
>So updating the PCB will immediately incorporate the changes to the schematic. 
>I haven’t seen any discussions of how this will be done but clearly if the 
>prototype as described above works it will be trivial to support the V6 common 
>database.
Hm... I haven't think about that... I'm not sure if pin swapping will
interact with back-annotation tool. I wouldn't say that, but if
somebody has comments and thoughts about that, it would be greatly
appreciated.

As far as I see now, It should be some tool a bit similar to "Update
PCB from schematic", which will utilize KiWay functions to send data
between PCBnew and eeschema..

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Brian Piccioni]

Kiway is a “sockets” (I think that is the correct term) system for 
communications between things like eeSchema and PCBNew. That’s how if you 
select a part in PCBNew and have eeSchema running it highlights the part in the 
schematic.

The way I envision the prototype working is that I’ll prepare a “change list” 
in PCBNew and pipe that over to eeSchema which will update the schematic. Then 
those changes will be imported into PCBNew. Alternatively I might create a 
means so that changing a ref-des in PCBNew uses Kiway to update that refdes in 
the schematic. Note that these are for proof of concept at the moment and so I 
can figure out how the Kicad code works. I am not a professional programmer so 
this is a big deal.

In the final version, if I understand correctly, in V6 changes to the PCB will 
be back-annotated to the schematic in order to support pin and  gate swapping. 
So updating the PCB will immediately incorporate the changes to the schematic. 
I haven’t seen any discussions of how this will be done but clearly if the 
prototype as described above works it will be trivial to support the V6 common 
database.

As I indicated my application parses the files, creates a change list, then 
updates all the files so actually incorporating the function into Kicad is 
(with the exception of Kiway communications) a small subset of what the 
application already does. Its just a matter of stripping out the parsing. 

From: Alexander Shuklin
Sent: November 6, 2019 11:22 AM
To: Brian Piccioni; Wayne Stambaugh; Simon Richter
Cc: ian.s.mciner...@ieee.org; KiCad Developers
Subject: Re: [Kicad-developers] Back annotate references from PCB

Hi,
thanks for answers!
Brian, I will definitely like to give a hand. But before start
everything I need to study things guys talking about. I haven't really
look about KIWAY yet. Probably after that I will have more clear look
how to implement that.
And many thanks for suggestions and advices.

On Wed, 6 Nov 2019 at 17:56, Brian Piccioni  wrote:
>
> Brian here.
>
>
>
> My utility is up on GitHub as a standalone app. I learned enough c++ and 
> wxWidgets so porting it to Kicad should be useful.
>
>
>
> I set porting it to Kicad itself to the side for a few months so I could 
> catch up with life and since it is destined for V6 (IIRC) I have some time.  
> While there is a lot of code in Kicad and lots of moving parts I have a clear 
> path to porting it over using Kiway, etc.. Essentially this means
>
>
>
> Replacing my homebrew parsing of PCB, Schematic, and netlist files to calls 
> to internal Kicad functions/methods in the respective apps;
> Once this is done I’ll use Kiway to communicate the changes between eeSchema 
> and PCBNew.
>
>
>
> As near as I can determine, everything I need to extract from the files is 
> already in Kicad.
>
>
>
> When I set things aside I was trying to figure out what I needed to do in 
> order to add a toolbar call in Tools to access my code. Since there seems to 
> be numerous files associated with such a change I found it rather daunting.
>
>
>
> If anybody wants to help they are welcome to reach out to me directly.
>
>
>
> Brian
>
>
>
>
>
> From: Ian McInerney
> Sent: November 6, 2019 9:08 AM
> To: KiCad Developers; jasura...@gmail.com
> Cc: Brian Piccioni
> Subject: Re: [Kicad-developers] Back annotate references from PCB
>
>
>
> I thought that was part of the connectivity stuff that Jon was working on (it 
> certainly wasn't me, and I don't know if there is another Ian contributing 
> code right now). I remember seeing some email threads on real-time updates to 
> the information in Eeschema.
>
>
>
> The wishlist item that Wayne mentioned is [1]. Brian filed that a while ago 
> because he had created a tool to do the back annotation based on the 
> geography of the board. I don't know where he is with porting it into the 
> KiCad codebase right now, but you should definitely reach out to him and 
> coordinate work so that you don't duplicate effort.
>
>
>
> -Ian
>
>
>
> [1] https://bugs.launchpad.net/kicad/+bug/1748205
>
>
>
> On Wed, Nov 6, 2019 at 1:47 PM Simon Richter  wrote:
>
> Hi,
>
> On Wed, Nov 06, 2019 at 08:26:52AM -0500, Wayne Stambaugh wrote:
>
> > > May I implement some back annotation feature from PCB to schematic?
>
> > You are welcome to contribute to KiCad.  I suspect it will not be as
> > easy as you think it will be.  Complex schematic hierarchies (using the
> > same schematic more than once in a design) always trips up new developers.
>
> I dimly remember that there was some work (Ian did that IIRC) to make the
> netlist the master document and attach the schematic and PCB information to
> that, with a fir

Re: [Kicad-developers] Back annotate references from PCB

[Alexander Shuklin]

Hi,
thanks for answers!
Brian, I will definitely like to give a hand. But before start
everything I need to study things guys talking about. I haven't really
look about KIWAY yet. Probably after that I will have more clear look
how to implement that.
And many thanks for suggestions and advices.

On Wed, 6 Nov 2019 at 17:56, Brian Piccioni  wrote:
>
> Brian here.
>
>
>
> My utility is up on GitHub as a standalone app. I learned enough c++ and 
> wxWidgets so porting it to Kicad should be useful.
>
>
>
> I set porting it to Kicad itself to the side for a few months so I could 
> catch up with life and since it is destined for V6 (IIRC) I have some time.  
> While there is a lot of code in Kicad and lots of moving parts I have a clear 
> path to porting it over using Kiway, etc.. Essentially this means
>
>
>
> Replacing my homebrew parsing of PCB, Schematic, and netlist files to calls 
> to internal Kicad functions/methods in the respective apps;
> Once this is done I’ll use Kiway to communicate the changes between eeSchema 
> and PCBNew.
>
>
>
> As near as I can determine, everything I need to extract from the files is 
> already in Kicad.
>
>
>
> When I set things aside I was trying to figure out what I needed to do in 
> order to add a toolbar call in Tools to access my code. Since there seems to 
> be numerous files associated with such a change I found it rather daunting.
>
>
>
> If anybody wants to help they are welcome to reach out to me directly.
>
>
>
> Brian
>
>
>
>
>
> From: Ian McInerney
> Sent: November 6, 2019 9:08 AM
> To: KiCad Developers; jasura...@gmail.com
> Cc: Brian Piccioni
> Subject: Re: [Kicad-developers] Back annotate references from PCB
>
>
>
> I thought that was part of the connectivity stuff that Jon was working on (it 
> certainly wasn't me, and I don't know if there is another Ian contributing 
> code right now). I remember seeing some email threads on real-time updates to 
> the information in Eeschema.
>
>
>
> The wishlist item that Wayne mentioned is [1]. Brian filed that a while ago 
> because he had created a tool to do the back annotation based on the 
> geography of the board. I don't know where he is with porting it into the 
> KiCad codebase right now, but you should definitely reach out to him and 
> coordinate work so that you don't duplicate effort.
>
>
>
> -Ian
>
>
>
> [1] https://bugs.launchpad.net/kicad/+bug/1748205
>
>
>
> On Wed, Nov 6, 2019 at 1:47 PM Simon Richter  wrote:
>
> Hi,
>
> On Wed, Nov 06, 2019 at 08:26:52AM -0500, Wayne Stambaugh wrote:
>
> > > May I implement some back annotation feature from PCB to schematic?
>
> > You are welcome to contribute to KiCad.  I suspect it will not be as
> > easy as you think it will be.  Complex schematic hierarchies (using the
> > same schematic more than once in a design) always trips up new developers.
>
> I dimly remember that there was some work (Ian did that IIRC) to make the
> netlist the master document and attach the schematic and PCB information to
> that, with a first patch to keep the netlist up-to-date continuously.
>
> It would probably make sense to join that effort, because any other
> solution would conflict heavily with that.
>
>Simon
>
> ___
> Mailing list: https://launchpad.net/~kicad-developers
> Post to : kicad-developers@lists.launchpad.net
> Unsubscribe : https://launchpad.net/~kicad-developers
> More help   : https://help.launchpad.net/ListHelp
>
>

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Brian Piccioni]

Brian here.

My utility is up on GitHub as a standalone app. I learned enough c++ and 
wxWidgets so porting it to Kicad should be useful.

I set porting it to Kicad itself to the side for a few months so I could catch 
up with life and since it is destined for V6 (IIRC) I have some time.  While 
there is a lot of code in Kicad and lots of moving parts I have a clear path to 
porting it over using Kiway, etc.. Essentially this means 

1) Replacing my homebrew parsing of PCB, Schematic, and netlist files to calls 
to internal Kicad functions/methods in the respective apps;
2) Once this is done I’ll use Kiway to communicate the changes between eeSchema 
and PCBNew.

As near as I can determine, everything I need to extract from the files is 
already in Kicad.

When I set things aside I was trying to figure out what I needed to do in order 
to add a toolbar call in Tools to access my code. Since there seems to be 
numerous files associated with such a change I found it rather daunting.

If anybody wants to help they are welcome to reach out to me directly. 

Brian


From: Ian McInerney
Sent: November 6, 2019 9:08 AM
To: KiCad Developers; jasura...@gmail.com
Cc: Brian Piccioni
Subject: Re: [Kicad-developers] Back annotate references from PCB

I thought that was part of the connectivity stuff that Jon was working on (it 
certainly wasn't me, and I don't know if there is another Ian contributing code 
right now). I remember seeing some email threads on real-time updates to the 
information in Eeschema.

The wishlist item that Wayne mentioned is [1]. Brian filed that a while ago 
because he had created a tool to do the back annotation based on the geography 
of the board. I don't know where he is with porting it into the KiCad codebase 
right now, but you should definitely reach out to him and coordinate work so 
that you don't duplicate effort.

-Ian

[1] https://bugs.launchpad.net/kicad/+bug/1748205

On Wed, Nov 6, 2019 at 1:47 PM Simon Richter  wrote:
Hi,

On Wed, Nov 06, 2019 at 08:26:52AM -0500, Wayne Stambaugh wrote:

> > May I implement some back annotation feature from PCB to schematic?

> You are welcome to contribute to KiCad.  I suspect it will not be as
> easy as you think it will be.  Complex schematic hierarchies (using the
> same schematic more than once in a design) always trips up new developers.

I dimly remember that there was some work (Ian did that IIRC) to make the
netlist the master document and attach the schematic and PCB information to
that, with a first patch to keep the netlist up-to-date continuously.

It would probably make sense to join that effort, because any other
solution would conflict heavily with that.

   Simon

___
Mailing list: https://launchpad.net/~kicad-developers
Post to     : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Jon Evans]

Eeschema now keeps its internal net state up to date continuously, but I
didn't work on any continuous syncing to PcbNew.  The way it works in
Eeschema, the graphical schematic is still the driving source of truth; the
netlist does not drive the schematic.

-Jon

On Wed, Nov 6, 2019 at 9:08 AM Ian McInerney 
wrote:

> I thought that was part of the connectivity stuff that Jon was working on
> (it certainly wasn't me, and I don't know if there is another Ian
> contributing code right now). I remember seeing some email threads on
> real-time updates to the information in Eeschema.
>
> The wishlist item that Wayne mentioned is [1]. Brian filed that a while
> ago because he had created a tool to do the back annotation based on the
> geography of the board. I don't know where he is with porting it into the
> KiCad codebase right now, but you should definitely reach out to him and
> coordinate work so that you don't duplicate effort.
>
> -Ian
>
> [1] https://bugs.launchpad.net/kicad/+bug/1748205
>
> On Wed, Nov 6, 2019 at 1:47 PM Simon Richter 
> wrote:
>
>> Hi,
>>
>> On Wed, Nov 06, 2019 at 08:26:52AM -0500, Wayne Stambaugh wrote:
>>
>> > > May I implement some back annotation feature from PCB to schematic?
>>
>> > You are welcome to contribute to KiCad.  I suspect it will not be as
>> > easy as you think it will be.  Complex schematic hierarchies (using the
>> > same schematic more than once in a design) always trips up new
>> developers.
>>
>> I dimly remember that there was some work (Ian did that IIRC) to make the
>> netlist the master document and attach the schematic and PCB information
>> to
>> that, with a first patch to keep the netlist up-to-date continuously.
>>
>> It would probably make sense to join that effort, because any other
>> solution would conflict heavily with that.
>>
>>Simon
>>
>> ___
>> Mailing list: https://launchpad.net/~kicad-developers
>> Post to : kicad-developers@lists.launchpad.net
>> Unsubscribe : https://launchpad.net/~kicad-developers
>> More help   : https://help.launchpad.net/ListHelp
>>
> ___
> Mailing list: https://launchpad.net/~kicad-developers
> Post to : kicad-developers@lists.launchpad.net
> Unsubscribe : https://launchpad.net/~kicad-developers
> More help   : https://help.launchpad.net/ListHelp
>
___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Ian McInerney]

I thought that was part of the connectivity stuff that Jon was working on
(it certainly wasn't me, and I don't know if there is another Ian
contributing code right now). I remember seeing some email threads on
real-time updates to the information in Eeschema.

The wishlist item that Wayne mentioned is [1]. Brian filed that a while ago
because he had created a tool to do the back annotation based on the
geography of the board. I don't know where he is with porting it into the
KiCad codebase right now, but you should definitely reach out to him and
coordinate work so that you don't duplicate effort.

-Ian

[1] https://bugs.launchpad.net/kicad/+bug/1748205

On Wed, Nov 6, 2019 at 1:47 PM Simon Richter 
wrote:

> Hi,
>
> On Wed, Nov 06, 2019 at 08:26:52AM -0500, Wayne Stambaugh wrote:
>
> > > May I implement some back annotation feature from PCB to schematic?
>
> > You are welcome to contribute to KiCad.  I suspect it will not be as
> > easy as you think it will be.  Complex schematic hierarchies (using the
> > same schematic more than once in a design) always trips up new
> developers.
>
> I dimly remember that there was some work (Ian did that IIRC) to make the
> netlist the master document and attach the schematic and PCB information to
> that, with a first patch to keep the netlist up-to-date continuously.
>
> It would probably make sense to join that effort, because any other
> solution would conflict heavily with that.
>
>Simon
>
> ___
> Mailing list: https://launchpad.net/~kicad-developers
> Post to : kicad-developers@lists.launchpad.net
> Unsubscribe : https://launchpad.net/~kicad-developers
> More help   : https://help.launchpad.net/ListHelp
>
___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Simon Richter]

Hi,

On Wed, Nov 06, 2019 at 08:26:52AM -0500, Wayne Stambaugh wrote:

> > May I implement some back annotation feature from PCB to schematic?

> You are welcome to contribute to KiCad.  I suspect it will not be as
> easy as you think it will be.  Complex schematic hierarchies (using the
> same schematic more than once in a design) always trips up new developers.

I dimly remember that there was some work (Ian did that IIRC) to make the
netlist the master document and attach the schematic and PCB information to
that, with a first patch to keep the netlist up-to-date continuously.

It would probably make sense to join that effort, because any other
solution would conflict heavily with that.

   Simon

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp

Re: [Kicad-developers] Back annotate references from PCB

[Wayne Stambaugh]

Hi Alexander,

On 11/6/19 5:39 AM, Alexander Shuklin wrote:
> Hi all,
> I used some Python script to renumber components in PCB and annotate
> it back to schematics. I think now it's usually done by parsing .sch
> file as a plain text and re-writing references inside.

This is fine for your own personal use but this would not be an
acceptable solution for inclusion into KiCad.

> May I implement some back annotation feature from PCB to schematic?

You are welcome to contribute to KiCad.  I suspect it will not be as
easy as you think it will be.  Complex schematic hierarchies (using the
same schematic more than once in a design) always trips up new developers.

> I looked a bit and probably easiest way - to add a new option in
> "Import->Footprint Association File" in eeschema. Something like
> "update references according timestamps". And get information about
> references and timestamps from .cmp file.

This also would not be an acceptable solution.  We are doing away with
intermediate files and using the internal message passing features
present in the code base.  You'll want to take a close look at
KIWAY::ExpressMail() and KIWAY_PLAYER::KiwayMailIn() and where they are
used in the board and schematic editors.  This is the method for passing
information between the board and schematic editors (actually any object
derived from KIWAY_PLAYER).

> I would be happy to join you and discuss that at the FOSDEM, but
> unfortunately I cannot go there ;'-(

This is unfortunate.  Being able to work directly with on of the lead
developers would have made this task a lot easier to understand.  You
are always free to reach out for help on this mailing list.

> And second question, sorry if it's stupid: If I want some new feature
> in KiCad, what do I do first? Write here and ask like "Hi, I want to
> implement that."? Or should I use some other stuff like IRC? Or first
> I do patch and team will look if that's useful?

You got it right.  This is the place to ask all development questions
related to KiCad.  You also get kudos for asking before you started
coding.  This is mistake a lot of developers make.  Asking first
prevents you from working on something that someone else may already be
working on and writing code that would be immediately rejected (in the
case of your solution using intermediate files).  You've already saved
yourself the time and aggravation of not having to rewrite any code.
That being said, I think someone was or is working on something similar
to implement a tool to reassign references base on the board geography
and then back annotating the schematic.  This would have a lot of
overlap with what you are proposing so you may want to collaborate with
that person.  Off the top of my head, I cannot remember who is working
on it but hopefully they will chime in.

The preferred method for small changes are patches created using `git
format-patch` and attaching them to an email to this list.  For larger
changes which might include what you are proposing, please use the merge
request feature[1] on Launchpad.  We have a coding[2] and a commit
message format[3] policies that all developers are expected to follow.
We provide a simple commit hook tool[4] for git that makes following the
coding policy easier.

> I'm quite new to open source and still not sure how to behave if I
> want to do some improvements

You are off to a good start.  The most important thing apart from your
coding skill is to be willing to cooperate with the development team.
Good luck and thank you for your interest in contributing to KiCad.

Cheers,

Wayne

[1]: https://code.launchpad.net/kicad/+merges
[2]:
http://docs.kicad-pcb.org/doxygen/md_Documentation_development_coding-style-policy.html
[3]: http://docs.kicad-pcb.org/doxygen/commit_messages.html
[4]:
http://docs.kicad-pcb.org/doxygen/md_Documentation_development_coding-style-policy.html#tools

> 
> Best regards,
> Alex
> 
> ___
> Mailing list: https://launchpad.net/~kicad-developers
> Post to : kicad-developers@lists.launchpad.net
> Unsubscribe : https://launchpad.net/~kicad-developers
> More help   : https://help.launchpad.net/ListHelp
> 

___
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help   : https://help.launchpad.net/ListHelp