Give a warm welcome.
Yeah, hi, everyone.
Thank you.
Yeah, my name's Daniel, and I'll talk about my tool,
Wirevis, to make your wiring documentation easier,
and hopefully more beautiful.
When we're talking about electrical documentation of your projects,
we can talk about different levels.
On the PCB level, let's say you're designing your small circuit board,
we have excellent tools, obviously, first and foremost,
KaiKed, so this one gives you schematic capture,
PCB layouting, perfect.
On the other end of the spectrum, if you want to document your entire system,
let's say, could be house wiring, could be a big machine,
some switching cabinet, you also have some tools.
For example, Q Electric, probably a bit lesser or less known,
also an open source alternative to generate,
also some wiring diagrams here.
You can see, for example, the power distribution bus,
and then how some consumers branch off from that.
I don't think you see my pointer anyway.
Yeah, there's something in the middle.
What if you need to document individual cables?
This happened to me a lot in my previous jobs,
and I found that there were no good solutions.
To give an example, let's say you want to build this simple cable,
just one into the other, maybe the pin out is a bit,
not a straightforward.
Let's say you need to build a small harness,
where one connector maps into multiple,
so this could be in your robot, in your microscope,
in your rocket, you never know.
What if you need to document a wire that's a bit more complex?
So in this case, one and maybe needs to be fed into some screw terminals,
so you have some ferials.
But actually, some of the wires,
also need to branch off to some other connector.
And on the other side, you need to shorten some wires,
some custom connector, you also need to heat shrink,
solder connections, and also there's a TBS diode in the middle,
because EMC said so.
How do you actually cleanly document this?
And when I was designing wires for my projects,
both personal and professional,
I didn't really find much in this respect.
Stuff I found, sometimes pin out,
would just be described in Excel sheets, basically.
Okay, pin one from this goes to pin nine over there.
But it's not pretty, it's not very readable.
You can use paint or other tools.
I mean, yeah, it's a bit more understandable,
graphically, but could look updating this every time you change a design.
You kind of use other tools, so I think this is actually a key cut.
I mean, yes, it's pretty clean,
it's relatively understandable, but it's not really the tool for the job.
You do have tools for the job.
This I think is solid works electrical,
so this looks pretty fancy.
You can have like build materials,
colors, color assignments, graphical representation,
but you need to fork out probably thousands,
if not tens of thousands of dollars.
And so I decided to make my own.
So what is my service?
Let's just simply go for a demo.
We start by creating a small text file, just a demo file.
And let's start describing our little wire.
Let's say we just want to connect some serial port on one device with some other one.
So you need RX, TX, and maybe a ground line.
So let's start with the connector on one side.
Let's say we have some type of molex connector.
It's a plug, three pins.
Then that's a basic information we need.
And then if we know a very specific wire that we want to use,
we can specify some, yeah, manufacturer data as well.
And in this case, because it's just one wire,
we don't need to show the name.
It's just something we use the reference internally.
Now we've got a components.
Let's hook them up.
So we have a section in our file called connections.
In this case, we'll just do one connection set.
So we specify, we want to jump from connector X1, pin1,
via cable one, wire number one, two connector X2.
And in this case, because we actually label the pins,
we can reference them.
So we want to go to the ground pin of that connector zoo.
This is just for one of the lines.
And if we want to wire multiple connections,
we just add more columns basically to this connection set.
So here you see pin 2, wire 2 to the RX pin,
and the same for wire 3, transmit.
This basically describes our cable.
So we feed this Yamufa that we just created into our wire viz tool.
It's just a command line tool.
And as output, we get a graphical representation of the wire.
You look at it and you immediately understand what's going on here.
You have a connector on one side, connect on the other.
You can easily see the crossover of the cables.
You have all the information you need to procure this.
You procure the connectors to assemble it and to understand the function.
So summarizing, wire viz is just text input.
So it's easy to edit and it's easy to version control.
You can just add these files to your kit of your project and easily update them.
All the graphics are all generated and auto layout it as well.
So you don't even need to care about dragging some boxes here and there to make it look pretty.
It will just work.
It understands some color codes.
So for example, we said we want to fold the din standard for the conductors in the cable.
It understands American wire gauge versus square millimeter gauge conversion.
So some handy tools for engineers.
It also generates a bill of materials.
So if you have an ERP.
For example, your PC system, you can just export the bomb and you'll know what you need to buy.
You can add some metadata to your wire.
So for example, who created it?
Who approved it?
When was it created?
What revision is it?
Et cetera.
You can add title blocks.
You'll see this in a second.
You can use templates if you're constantly using the same connector types.
Or always wiring a bunch of SPI or simple bus connectors.
You can just template that.
And of course, it's open source goes without saying here.
Let's look at a more complex example.
So here you can see this is more of a wiring harness.
Kind of thing.
You see multiple connectors, multiple wires between them.
You even see some LEDs and discrete components like the TBS diode I mentioned before.
They're just treated as connectors right now.
So if you zoom in on a few parts of this diagram.
You see we don't only show the connector of our actual wiring harness,
but we can show the relationship of that connector with whatever's on the other side.
In this case, the Raspberry Pi like GPIO header.
So now we can also map the names on the header to the names of our signals.
And with a few arrows in between, you actually can understand how the data is flowing.
What's going where?
In the wires themselves.
Obviously, the colors are very, very visual way of understanding what goes where.
But if you print this out or if you're color blind or you just cannot represent it with colors.
The color codes are also included here.
And if the wiring gets a bit too messy and you cannot even follow the lines from one into the other,
each wire also tells you, okay, where is this, for example, on the top of the red wire going.
Oh, it comes from connector X1, pin number two, which is five volts in.
And it goes to connect X4 pin one.
So you don't need to manually trace every line there.
You can see on the bottom cable, W2, it adds some extra components that you need.
In this case, it's just a bit of heat shrink.
Also, it's just a tool that you can use to describe graphs basically.
So this is the example they use on their documentation.
You have some nodes, you join them with edges or some arrows.
And this is how it's created. It's just another simple markup language.
If you have you define some properties, for example, the colors.
I think it's quite easy to understand.
And then you represent the relationships between the nodes with the arrows.
So, for example, in the sub graph, you can see they, their A0 goes to A1, goes to A2, goes to A3,
and that creates the little arrows that join them.
So, describe the graph.
It's simple language. It takes care of the layout.
By itself, you just describe the relationships.
And the output that it creates is pretty clean.
It's a bit boring at first. It's not the most beautiful.
It's a bit unpredictable, so because it does the auto layouting,
you don't always have full control over what goes where.
So in this case, you can notice the nodes in the B column.
They're not fully aligned because it tries to optimize the distance between nodes,
and stuff a bit unpredictable, but it's very customizable.
So, how do we get from something that looks like this,
to a pretty wiring diagram that looks like that?
I'm not going to give a full explanation of how this is done,
but I'll give you some little hints, and maybe you can find something that works for you
in your project to use graph vids for some other uses.
If we look at what wire vids generates, it generates graph vids code.
In the beginning, you just specify a few basic attributes,
like colors, a bit of layout information that it should go from left to right,
instead of touch bottom, et cetera.
And then, actually, it's a ton of HTML code.
Each of the nodes, because graph vids has this nice property,
that if you define your node, in this case, X1,
and you define the label.
Instead of using quote marks, you use these angle brackets.
Everything that's within it will be interpreted as HTML,
so you can start designing tables and tables within tables.
It feels a bit retro, kind of, but it works very well
for the structured information that I want to convey.
Also, if you using tables, the cells within have a special property called port.
Here you can see I've named it port P1R for port 1 on the right,
and this allows you to, later when drawing the arrows or in my case,
the wires to not just go to the node of the cable,
but to the actual pin of the connector.
And lastly, when you're defining the edges,
so the arrows are wires between the nodes.
If you give them a color, it will just render them on color,
but you can just specify a list of colors,
and it will basically draw parallel lines,
so this allows us to have nice black borders,
and then any color we want in between.
And then when we're defining the connection between them,
so we say from X1 to Y1, et cetera,
we can expand this a bit with the ports that we defined earlier,
so we say from X1, port 5 right to Y1,
and then small W1 to specify the first conductor,
so this gives us better control of how we actually link up stuff.
And to make it look pretty, you can actually add one more thing.
So these letters, they basically stand for east and west,
and it just makes sure that the arrow or in my case the wire
doesn't come in like some random direction,
but actually cleanly from the east or west or from the left or from the right,
and this really helps in keeping things clean.
That's pretty much all I have.
The main aim of this tool.
At least not right now.
Hello.
Yeah, I'm one of you users, really like it.
Thank you.
I wanted to ask, so I've had some cases where,
for example, I have a connector,
and I'm trying to connect pin 1 to pin 3 of the same one,
and because you just showed an example of how the routing work
is the graph is, so using the right side,
and then usually connecting it to the left side,
so kind of ends up doing a route around.
Is there where you can force it to go to itself from the same side?
Yes.
To repeat the question,
if you want to do a loop back,
basically from one pin of the connector to another pin of the same connector,
how that's, how that's doable.
Because the basic logic is,
if you are kind of left or right,
so you would have the connector,
then it goes to the wire,
and then it kind of forces the wire to loop around
and come in on the other side of the connector.
It's something that's still open.
One hack that I found is you can define,
let's say, from pin 1 to wire, whatever,
and just not go anywhere,
and then as a second connection,
you say from pin 3 goes to the same wire,
and then you end up with like a wire shaped or like a forked wire,
that goes to two places on one end,
and nowhere on the other.
And so if you know what to expect,
or if you know what this means,
it's pretty clear,
but it's not the prettiest.
So definitely a point for improvement in the future.
Thanks for the talk.
Really interesting.
Is there any kind of validation
on the electrical layer possible in this too?
Like to grab on TX, whatever.
Yeah. So the question was,
is there any validation on the,
basically electrical logic of this circuit?
So are all the grounds connected or are there any short circuits?
Not right now,
an intermediate step would be to export,
for example, a net list,
that at least tells you which pins are connected,
like if you have multiple connectors,
where is one signal actually routed,
where does it go?
So you have a better overview.
It's not yet implemented.
It's definitely a cool feature.
It's a bit tricky because sometimes,
yeah,
so, yes, go ahead.
If you're also showing like connections that are external
to your actually wiring harness,
but just referenced, for example,
like this Raspberry Pi connection,
you would have to make sure that there's no,
like you would also need to define those.
So it gets a bit tricky,
but in principle, it should be doable,
but not yet so far.
Thank you very much for that.
How much does this scale, for example,
is anybody used this to document the structure cable
in system inside data center?
So the question was,
how much does it scale,
and can I actually represent
the full wiring of data centers?
And by default,
it deletes it because most people
don't really need it,
but you can specify,
I only want the graph is output,
and then you can use it for whatever you want.
So yes, it's totally doable.
Yes.
Okay, thank you, Daniel,
any further question,
till be out in the hallway,
and thank you.
Thank you.