Exploring Scripting in Altium


Well, hello everybody. Thank you
very much for joining us here today. This is Paul Taubman with Nine Dot
Connects. You are in the right place. If you are here for our
Webinar on scripting. You know, in fact you are here for a reason and we
know the topics of this nature are very important to you.
Number one, that Altium Designer is a
really large suite of tools. We totally get that. As a matter of fact,
when I worked at Altium many years ago, I was just laughing about the fact that
I only had to learn one tool because prior to that when I worked
in the defense industry, I probably needed to know
about 15 different tools. And yet about 10 years later here, I’m still working on Altium Designer
and there’s still many aspects of it to explore. It’s a really large suite and
there’s always that question to be asked, are we overlooking any capacity in Altium Designer
that might help us to automate. And then there’s also the desire to
automate the design process as well. And the question has to be asked, what are we trying to do to avoid turning
our designers into administrators? So if someone’s just sitting there and
they’re plucking away at an Excel sheet all day,
that’s taking really designed, talent and putting it into
an administrative mode. So those are the things that we know are
important to you is how do we make this design process move as easy as possible? How do we get the biggest bang of the
buck for our designers who should be designing and not doing things
that could be automated. So we here at Nine Dot Connects want to
encourage you to ask us and we’re going to tell it to you like it is. And there’s a lot of areas of Altium
that I think there’s questions about like subversion, scripting, auto routing,
FPGA, Nano boards, the Vault, or what’s also knows the EVS and SPICE. Some of these you’ve already
done in videos we’ve talked
about in past webinars. Some of them we haven’t talked about and
probably for some good reason to it too. But if you’re ever curious about any of
these things or other aspects of Altium, feel free to contact us
here at Nine Dot Connects. We’ll be more than happy to kind of give
you what they call the straight dope on it. So with that, welcome to
our webinar. Just one last note, if you want to know a little bit more
about us here at Nine Dot Connects, we have recently released the video. It’s a two minute introduction. We’ve made it such a way that hopefully
is just as entertaining as it is informative. If you go to ninedotconnects.com
you will immediately see that video. Just click on it and they will play away.
So there it is. Now today’s topic is a primer
to Altium Designer scripting. And this is kind of a loose agenda, we’re going to talk about what it is
and in a sense what it isn’t as well. We’re going to show how to run a script. I’m going to just talk about some
of the basics of script coding. A couple of words of caution towards the
end and also where to find references and materials. If I was to go
through this slowly and methodically, it would take me at least two work days
for us to go through all of this here. I only got one hour to do this, so I’m going to try get the key points
about scripting to hopefully give you a good idea of what it is and what it isn’t.
All right, let’s talk about purpose
first and foremost. So why do we want to bother
with scripting? Well, there’s really two things
that you can do at scripting. First and foremost to automate, what I’d call repetitive tasks or things
that would be very laborious if e had to do them by hand and a great
example of that is the logo creator. Then I’ll show you that example
here in just a moment. Also, the ability to create reports as well,
and I’ll show you an example of that. By the way, just as a side note
for administrative purposes here, what I’m going to be doing is, I will be
putting up the PowerPoint slides here, but I’m also going to be showing quite
a bit and Altium Designer the slides, we’re really there just to make sure
that I stay on focus because they have a lot to talk about and in very
little time to do it here. So we’re going to jump over here to Altium
Designer for a moment and let’s take a look at some of the scripts
that they have available. Everything that you pretty
much see on the screen, including the one I’m
going to demonstrate here, they do come from Altium Designer.
So Altium in the past, I think prior to Altium Designer 2010, it used to provide these
along with their software. And over time they removed it and
they made it….they may still make it available, but you’ve got to
download it from their website. It’s something that we cannot provide you, unfortunately due to our
relationship with Altium. However you go onto their
website and you look at them, it look onto their website.
In fact, if you just basically type in
and Google like Delphi examples, Altium or scripts example Altium, and you should be able to find
that downloaded full, it’s, I think it’s a zip folder and you can
download it at that point in time. That’s where I got it from as well.
And by the way, I’ll talk about more
references a towards the end. So the example that we’re looking at
here is one of their older examples, but it works rather nicely and it
gives a really good overview of what scriptings all about. So the one that we’re going to take a
look at here for just a little bit is this one called the PCB logo creator. And this is a really great example of
something that would be really laborious to do by hand. However Altium can do this and
manipulate the graphics so that you could actually bring a logo into Altium.
This is one of the older programs. I think there’s some better
things at Altium now provides, that’ll make the logos
look a little bit sharper, but it’s certainly a really good example
program of how you provide input into a script and how you get output
out of the script as well. Now just to take a step back and I’ll
talk again more about this as we go along. If you’re like me,
you’re probably what I’ll call old school. And the old school is that we
used to have a cursor prompt, the bottom left hand corner and we would
type something like run something or we would get a scan C command that
would say, hey, give me some input. We type it in press return, and then the program would continue and
things would scroll up the screen as you’re going along. We don’t have
that luxury here in Altium Designer. So what you’re going to find is that
we have to provide input through other means and one of the means that we do
that is thru what they call a form here. Now here’s an example of a project. So
this is the PCB Logo Creator project. As I mentioned,
it’s an example that Altium provides us. It is a project that’s called PRJSCR. It’s a very easy project to open and
start in terms of if you want to start a new project, it’s a matter of
going to File, New, Project, and then making sure that you
have script project click here. Most people will probably
be in PCB project, but if you click on script project and
then you provide the rest of the name and you press okay, it’s going to pretty much start a project
in a very similar manner as if you’re doing it PCB project. From there you simply just add in you
simply just add in the type of files that you want associated with it. So before
I go a little bit further into that, just want to show you this
one that already exists. So this an example of a project that
has really two files associated with it. The .pas really stands for Delphi and
think it’s because in the past Delphi was associated with Pascal.
In fact, they think has got its roots from Pascal
and that’s why you see the .pas over here.
Why do we use Delphi? Well this because Alison was written
in Delphi and that’s the same. So they used the Delphi scripting
language or made it available. There are other scripting
languages that you can use, but given that Altium was written in
Delphi and given that their developers are primarily well versed in Delphi and all
their examples are in Delphi or most of them are in Delphi, it’s probably best
that if you’re going to do scripting, you probably want to do it in Delphi. So here’s an example
of two different files. One that does have a form in code
and the other one which doesn’t, you can just write simply code. However there’s going to be
some limitations to that. The form is going to allow you to
basically put input or we’ll call it Conditions in there so that,
or initial conditions, in there so that when it kicks off,
it knows what to do here. And you can see this form here and we’ll
definitely go into a little bit more detail. Now if I want to run
this, how hard is it to run? It’s actually rather easy to run it.
It’s just a matter of doing a file open, opening the project. And then once you’ve got that
project open and it’s in focus, it’s really just a matter of
hitting the play button over here. And once I’ve done that, you’ll see that the code has now responded
because it’s now opening new session of a PCB doc. And now it’s brought up the form that
we just saw and now it’s an active form. So I’m going to load an example file. And this again is all ones that
Altium has provided over here. And I’m going to use this bitmap here. And the reason I’m going to use this
is that this is a true black and white. So again,
when they originally made this, you had to use a bitmap and you also had
to, it had to be a true black and white. It couldn’t be a gray scale because the
program was not going to be able to work with that.
I know as I said, subsequent things that they’ve added to
Altium and other scripts that they’ve built and allow this to be a little more
eloquent where you can really feed on other things other than just
a straight black and white. But this is an older program but it’s
still does a great job to show and explain things here. So now that I’ve got this
here, I’m going to let it convert. It’s going to take a moment to do it. So going back to what I was talking
about about on the purposes, what we’re doing over here is telling
Altium to basically draw this for us and once it set over here,
we’re going to actually have a logo. I think you’ll probably put it on, it’s going to put it on the top layer
cause I didn’t tell it to put it on the top overlay. But nevertheless it’s going to create
this logo based off of opening up that file, this text file or this bitmap
file, interpreting what those points are. And then putting in the primitives
necessary to make this whole thing up. So I’m going to exit out of this
here and you can take a look at this. So that’s one example of
what you can do with Altium. Let’s say we’ll call it
graphic manipulations. The second thing that you can do with it, and I’ve got another report at this
thing called the report here is textual reports.
And actually more often than not, a lot of aspects of automation in any
type of process is really getting the text from one location to another. It’s information that you need to
be formatting in one way or another. So for example, a lot of people when
they look at the bill of materials. Most people are content with the
idea of the bill of materials, just having columns of
parameters and then they, the rows just list each one
of the components. However, there are people who are saying,
well, no we’d actually would actually
prefer to have the component, and then the row list all the parameters
and then we put the next component list everything as rows.
So Altium itself doesn’t do that, but that’s another great example of what
you could possibly do with the scripts here. Now when this looking
at this code really quickly, if you’re familiar with let’s say a C++
or C and I spent a lot of time in C and also Basic and FORTRAN, I’m very
familiar with the print statements. They don’t really use
print statements here. You can see that in this situation
they’re using concatenations, they are using a lot of dots over here
as well which you’re going to find with that is this has to do with objects and
actions and we’ll spend a little bit time talking about these
things here as we go about, but in this case over here we’re doing
an action which is to add something to this thing which is an object called a
IntLib report which is probably defined up here. In fact it was. And you
could see, as a matter of fact, it was defined as
something called a Tclass. And we’ll go into more detail
about that here in a bit. And what you’re also seeing is the literal
string plus a concatenation of other things that are in here as well. So that
gives you kind of feel for the format. And I wish I can go into a
lot more depth of the code. I’m going to show you a code
here in a bit called TicTacToe. It’s another one that
comes from Altium Designer. And I commented the Heebie Jeebies out
of the whole thing. I mean, I just, I put all these extra comments in there
so I can understand what was going on with it and I’ll make that available to
anybody who wants that thing afterwards so they can get a better feel for how
the code and the constructs are working here. So there it is.
We’ve got this example. Here now in an example of this nature
because it’s just strictly a code and has no form to it, it relies upon the initial condition
of whatever window is open. And in this case over here, what I’m going to do is I’m going to
click on this schematic doc they already have open and I’m going to run it. Now
notice when I Click on the schematic doc, I don’t have a play button over here. So another way that I can run this is
I can go into DXP and I can go into run script.
Now that I’m in this run script here, any of my files that are open
over here are available to me. So it’s just a matter of doing a
file open. As long as it’s a script, it’s going to be listed over here. And I have actually two different
little programs I could run here. One’s called model type
is kind of a boring one. It just tells you what models
might be associated with it. It might be useful for
what you’re trying to do, but just to show you something
that’s got a little more meat to it. This is basically an integrated library
manager reports basically saying these are all of the components and where
they were located that you used on this particular schematic.
So when I press okay, you’ll notice that there was no form and
it just ran through it and just put it in the format that we set up in the code. So it gives you some idea as to what
we’ve got over here in terms of purposes. Either we’re trying to do some type
of graphical manipulation or trying to extract and get textual
information put into a text form. And those I think are the two biggest
things that you can do with it. All right. Let me continue here from our slide. And so what are the languages that
are supported in Altium Designer, as I mentioned Delphi is the biggest one. If you are used to these other
ones like especially Enable Basic, actually it’s javascript or Visual Basic,
you can certainly use those as well. Just keep in mind there won’t be as
many as examples to go off of on those. There’s also one called Enable Basic, which I got to be perfectly honest with
you, I’m not very familiar with that. I assume it’s just like basic programming,
and there was one called, it’s called TCL or better known as tickle.
This is, this used to be very popular
I’d say primarily in the
1980s in 1990’s with those who are doing a lot of work in
UNIX because it was a very good, like one line scripting type
of capability. You could
do a lot of things with it. It’s very,
very powerful, but it tends to be kept towards the folks
who are doing UNIX. But nevertheless, Altium can handle that as well.
Now, as I mentioned before, a lot of times we got to use something
that’s called a form and that’s how we put our initial conditions into our
program so that it can run off and do what needs to do. While there’s only three
of those five languages can do that, either Delphi,
VB or javascript. And if I jump out of here for
just a moment and I go into, so we’ve got our project over here, I’ll make that the that’s the one
I’m going to try to add it to here. I’m going to do to file new
and I go into script files. You’ll see what things we have available.
So you’ll notice that for script, that also means Delphi. Um, either
have a unit or I have a form. Same thing with the script,
what they mean by unit, and it’s just code only as opposed to
the form where I’ll get both of the opportunity to do both the code and the
form there and, and so on, so forth. Notice that TCL script and Enable Basic
script, do not have forms associated with them. So these would be things that you would
write strictly to run against some type of thing that’s already on the screen
to extract out information and then get some textual information out of it.
So that’s how you’d add those. If I click on this here. In fact,
we’ll put this form in there. Okay, let’s see where I put it. Sometimes it because it’s not
the the one that’s in focus up, drag it down over here.
So if I do a form here, I can put the code in here and then I
automatically get a form a over here as well. And I’ll just talk about this briefly
and then going to go into a little bit more about forms here
in a couple of minutes. To do a form is a little bit different
than using a schematic editor or a PCB editor. You actually have to
have two he panels up for that. One of them is the object inspector, which shows you the properties
of whatever it’s focused on. So right now it’s focused on form 2. And then it also shows you what’s called
properties and then the events mean what actions can you take
on this particular form. And actually quite frankly, you really don’t take too many
actions on the form itself, usually take it on a button or you take
it on a radial or you put it in a text box and we’ll see a really good
example of that here as we go along. The tool palette are all the different
things that you can add onto this form over here.
If you’re familiar with Delphi by the way, this looks remarkably similar to some of
the DELPHI programs out there if you’re trying to build a programs
to simply out of Delphi. So I have a suspicion that this was a
lot of this was taken from an existing code that Altium dropped in and it
would make sense to do so because if we understand these things called client
servers in the way Altium set up the entire architecture of Altium Designer, it would make sense that they could
just drop something in that was already there. So if it looks remarkably
similar to some of the programs, that doesn’t surprise me in the least
because Altium has the ability to do such a thing in their architecture.
So that’s where we’ve got over here. The only difference is, is that when you click on one of
these features and you drop it in, then you click once and it’ll drop it in. So it’s a little bit different from the
way we operate on primitives and the schematics and the PCB side. Also you don’t really double
click on it to get to its objects. Once you’ve got something on there, you click once on it to highlight it and
then it becomes all of its information really becomes available through
the object inspector at that point. So as I said, we’ll spend a little bit
more time on that here in just a moment. Let me jump back over
here to our current slide. We
talked about this for a little bit, but it’s good to understand
the concept of a project. You don’t have to do a script in
a project. However, in the past, if you’re going to do
anything with the form, you should have had done in a project
[garble] with the TicTacToe game. That was always a free document.
So it seems to work without a project, but if you’re going to split the
program into two or more files, and that’s very common for large files
for people who do a lot of programming. Then you definitely need to put that
into a project. And then of course, the other thing too is, which we’ll
call preventing of global variables. what happens here, and I’ll jump back over
here to Altium and go to our projects, is that if I’ve got a bunch
of free documents over here
and my coding isn’t all that good,
what happens is when I run these things, I can be leaving residual
information in the background. And if those variable names are
the same for each one of things, what I ran in one could actually impact
another script when I execute upon it as well. So one of the nice things about doing a
script in a project is that it can find all the variables to that
project and that project only. Nothing from the outside can influence
it and nothing within the project can influence the outside. Whereas
in the free docs, well, it’s kind of free range and
it can be the wild west. If you’re not really careful about A,
then your variable names and B, your initialization of variables
as you’re running these projects. So just be aware of that. Let’s jump on back over here. All right, now the limitations,
one of the things is, a lot of people look at the scripting say
thinking that they can somehow improve Altium by adding maybe new primitives
or what we consider to be primitives. And there are actually some pretty big
limitations to this. First and foremost, you can’t create new primitives.
And then secondly, within the primitives themselves, you
can’t add, remove or modify properties. And I’ll give you a really good example
of one that people ask for quite often. So let me jump back
over to our LCD example. A lot of people look at the power port. This is a very special
primitive in Altium Designer. If we go place and we will see that
we’ve got our power port up over here. And when they look at this over here, they’re little frustrated because they
may not have the symbol that they prefer to have. And they would even like to have it
in such a way that let’s say, Hey, if I draw this in the schematic editor,
let’s say the schematic library editor, I want to be able to somehow
associate it either to this one, this power point primitive itself or
create another power port primitive altogether that allows me to use whatever
symbols I create in the symbol library editor, well the scripting number one
will not allow you to create a brand new primitive. That’s number
one. And number two, the scripting will not allow you to
modify any of the existing properties of these primitives. So like the style is actually a
property of this power port here. It’s not going to allow you
to modify the enumerated list. So just keep those things in mind
because really you’re limited to, hey, this is what we’ve got here on the menu. You got to work with what
we got over here. No, you cannot change your custom order
something within the you know, within the menu that Altium
is providing you here. So just want to bring that to your
attention if you’re thinking of grandiose plans,
I know that if you’re, if there’s really big things that
you want to do with it, then Altium, I know they sell an SDK, which is called
a software developers kit. But even then, I don’t think they give you that much
reach into their basic primitives at that point in time. Now this kind
of gets really important here. As I mentioned early
on, I mentioned, again, we don’t have that neat little cursor
prompt at the bottom left hand corner of our screen. So we got to figure out ways of
providing input and output to our, um, basically to our our files
here. So when it comes to the input, there’s four different ways that I could
think of to do it. First and foremost, you could do it in the code itself, which
is kind of kludgy , but you can do it. And just to give you an example of that,
I was playing around with this. It’s actually a very
simple little program. And I like it because it just showed me
very quickly how I could put together a program in Altium Designer.
So here it is, I just initialize and I and J called
them integers and then I took, I made it a value, now notice has
got a dollar sign in front of it. For those people who are not
let’s say that coding savvy, that means it’s in hexadecimal format. And then there’s a J over here and it’s
also hesitant hexadecimal format as well. And what I’m doing here is I’m really
taking these two here in a sense, I’m adding together. In fact,
I’m doing an and operation. a logical and operation to both I and J. I’m having it convert to a string
and I’m going to show a message. So in this particular example,
I’m not using a form, I’m not relying on any information,
any of the other windows. I’m actually manipulating the
inputs through the program itself. And if I was to run this.
And I click on a, like I could do the runs through the
menu here or I can do the button. Okay, I get the number 10 and that would be
correct because what I’m doing over here is effectively ANDing all ones,
which is j to a, which is a hexadecimal version of of 10
it’s the decimal version of 10 and this is showing me the decimal version of it. So if I wanted to play with this all day,
I would just go in here, make a change, save it, and then keep rerunning it and
there get an answer. You can do that. That works rather nicely when
you’re trying to debug code. But obviously it’s not very eloquent
when you need to do something of a larger scale. So let’s go back over
here to our current slide here. Alright, jumped here. Let’s see. So initial conditions from
the screens are parameters. That’s another way we can do the, actually
jumped here. Let’s go to the form. We saw examples of the form.
Just like when we did the logo creator, we had a form that allowed us to take
information or put information in there. So at knew which layer to put it
into or the thickness of a line. If we wanted to put that in there.
If we did another, there’s another example like a board
outline where if you call it the board outline, we’ll say what layer you want and how
stick do you want the line to be when I draw this, this this lay, this outline. so that’s an example of some forms and
we’re going to see the TicTacToe one here in a little bit. We also have a initial conditions
of the screen are the parameters. This is what you primarily get from, we saw this again with
the report that we saw. So we opened up the schematic report,
pardon me, open up the schematic and then
we ran the library report on it. And so it was able to do that because
it took the initial conditions of the screen. It says, oh, okay, I’m
working in this editor over here. I can get access to the parameters of
that editor and then I can put that out into a text. And then the last thing
we can also do too is we can all, if we had an outside text file, and this again was what we saw with
with the logo creator is that we took a file, which effectively is a bitmap and we were
able to open that and have Altium read it in and then do something
with it like convert into lines, which in turn turned it into a logo.
Now on the output side of things, well how do we get some
outputs out of this? Well, we can see the results on the
screen like we saw with the logo, we can get results written to a text file, which is what we saw when
we ran that library report. And we can also see the
results place back on the form, which is what I’m going to show you in
the TicTacToe game here in just a moment. And that takes me to this point of forms.
I’ve alluded to this quite a few times, but I think we only spend a little more
time on to it because if you’re going to do something in Altium, more than likely you’re going to
need to do something through a form. So obviously they’re
there to provide input, but they are also graphical features for
helping you set up the program itself. And you’ll see these
examples as we go along. Now we have to understand
that when we’re making a form, we’re dealing with
something called objects. And I’ll talk more about objects a
little bit later on because we’re really dealing with something called
object oriented programming. But we are using something called objects. And in object oriented programming we
have three things. We have properties, we have a event and we have actions,
or what we call commands to the program. So let’s take a look at this
TicTacToe game here for just a moment. This is again one that
Altium has provided. What I’ve done with it is I have taken
the code and I have put in all these additional comments to it so that I can
understand line by line what’s going on with it. And also to really
also understand what is, we’ll say belongs to Altium and what
belongs to the Delphi scripting language too. So there’s some of these
commands that they used that even, let’s put it this way, every coder has their way of doing things
and the way they did things in this, I don’t think I would have
necessarily done the same thing. So a lot of times they had to
look and understand what the, what the coder was trying to get it to do. And in many times I remind myself
that, hey, this code does work. So obviously what this
individual did is correct. I just got understand how that
particular code was working. Okay, let’s jump back over here to the form
for just a moment. So in this form here, we’ve got all these different labels. And I’m going to click on one of these
labels over here and I’m going to jump back to the object inspector and I’m
going to go back to the property. So let’s notice a couple of things
here in the object inspector. First and foremost at the
top the top left corner, we have not only the name,
it’s also the caption too, but there’s actually a
name over here as well. We have the name and we
also have this object type. And as I mentioned earlier an object,
and you can think of an object, it’s like a primitive,
it’s not something that we can change. It’s nothing we can change at all in
terms of its properties or its its events or its actions.
It’s already been predefined to us. So we’ve got the properties here and we
can make these changes to them all day long. We can center things, we can change
your fonts, you can change their colors. Properties are those things that just
give you really a physical appearance to them. And then there’s also
an event over here as well. So notice that over here on this
particular cell it says LblCell0Click. And we’re going to see this here a
little bit more in just a moment. Keep that in mind.
But also notice if I click on LblCell4, the name changed over here and this event
also happens to have the same thing. So if I Click on something different over
here, the events are going to change. So even though I’m going to go
back to Cell3, even though Cell3, Cell4 look exactly the same. I’m actually looking at Cell4 now
cause I clicked on it, but go to Cell8, I’m clicked on it. Notice that they
all have the same thing. LblC0Click. because these all kind of work in the
same way in terms of what action needs to be taken when you’re doing something. And that’s really what’s happening with
the form over here is that this form isn’t going to do something
until you respond to it. So if you open up this form and then you, let’s say you go on vacation for two
weeks and you forget to close Altium Designer and you happen
to have this form left, it’s just going to sit there waiting to
til you make another command with it, assuming the power wasn’t turned off or
the administrators had somehow some way, some form pull away your license,
right? But if it was just sitting
there the whole time, this form is not going to
respond until you click on it. And then when you click on it,
that creates an event. And then the event forces the code to
respond, which is called an action. And that’s what we’re going to
see over here in just a moment. So just keep this by this in mind,
LblC0Click. When we go over to the form side,
pardon me, the code side of this, and we’ll go to very top here. We’ll notice that every single one of
these things that we have drawn in the form is also listed over here, whether it’s the radial group or our
scoreboard or buttons or our label. They are all defined over here.
But more importantly, when we define these things
that we’re going to use, we’re also got procedures for it. So you can see over here
that there’s this procedure. If I do a control f on this
here and I’m going to say, okay, I’m going to go forward and get
press. Okay, it does find it. If I do an f three is going
to jump me to the next one. So this is just calling out the procedure
and it notices a t center object. And I’ll talk about that in just a minute. But this procedure over here
is just like a function. The only difference between a function
and a procedure and scripting is that a function returns, a value,
where procedure does not. At least it doesn’t return it
back to the program. It will show, it may show something on the screen.
So when I click on f three over here, you can see that now if
someone was to click on that, and that’s what we see
over here is the event. So it will detect that click and it’ll
say, well, okay, who’s the sender? Who sent that? Well, if
we clicked on cell 8, then whatever the information is on
cell 8 is going to get sent through this procedure over here. And it’s going to do things like check
to make sure that the game is not over. It’s going to make sure that something’s
not already in it and then it’s going to check other things. It’s also going to put an x or an o
on it depending on whose turn it is. And it’s going to just keep
things moving along here. So just to show you how this is,
this all kind of works out. Let’s actually run the
program right now and in fact, I’ve just need to hit the run button and
it’ll come up and I pull this up for my other screen here. Okay, so
here’s the TicTacToe game. Now granted we didn’t draw any lines
across this and it’s one of the things I’m going to work on there,
but remember, those are objects and if those are
objects or things we’ve got to add to the code as well. So everything counts
when we’re doing these type of forms. So to start the game, I just, it’s a
matter of us clicking away. All right, so, you know, I’ll just throw some stuff
over here and as we’re going along, all right,
if we if it wins, it knows that it wins because they
will actually do an evaluation check. So when we click on this,
we kick off this event. And in this event over here eventually
is not only going to put an x in there, it’s also going to do a check to
wins to see if the game is won. Now it also has some smarts as well too.
So let’s do a new game over here. And by the way,
notice when I click new game, it was basically to set all the label. What they did was these labels over
here are just showing the value X or O. It basically send them back to blank.
So when I start this over here, let’s say I put an X here and I
want to put an O on this. Well, it knows because I clicked on
this particular label that, hey, you already got something over here so
don’t, I’m not going to overwrite it. So there was some smarts that were put
into this. If I want to reset the game, let’s say a new game is going to prompt
me to make sure that I really want to do that before it clears it out.
So these little things that they put in, have some smarts,
if there’s a draw to it, and let’s see if I could do a draw
real quick. We do this, we do this, he’ll block him. This is one that I think my kids and I
always seem to get into and they’ll show that, oh, it’s a draw, right? So it’s
smart enough to evaluate a draw as well. And these are the kinds of
things that are going on, but they’re all event driven.
Every time we click on something, it’s going to change it up. So if I do a
new game, O would go first in this case, and so on, so forth. if I press
exit, that’s what it’s going to do. So we look at the code here at the bottom,
especially the bottom ones, by the way, there’s always
one that’s called show modal. And this is basically say, hey, bring up
the form. So this almost always actually, I think pretty much always has to be
shown when you’re doing these types of things. But you’ll also see that
when we click the button over here, so this is another procedure
that was listed above. So if we click the button over here, it’s going to basically
do the close feature. Or if we click on the
reset score one over here, it’s going to take care
of some stuff for us. It’s going to prompt us with that
message, right? So we saw that message, a dialogue, and then it’s going to ask us whether
or not we want to actually press OK. If we press okay, we do one thing. If
we press zero, we do another thing. So we press cancel,
we just exit out of the procedure. So hopefully you’re kind of getting a
feel for this. Again, it’s event driven, which is very different from what I think
a lot of us have grown up with where we think of a main and we
call these functions as we’re
going and then there’s a logical process that goes along with it.
Really this is just being, being done as as buttons are
being pressed. Excuse me. As a matter of fact, it really isn’t a main in here which
when I first was looking at this I was struggling with, because I’m always looking for the main
when you’re doing these things here, there is a variable list. So then that to me it almost seems
like it’d be the start of that, but in the end there’s really,
it’s just a bunch of procedures and again, this procedures are called by the events
that we put in to whatever the button or feature we put into the form or the
objects if we want to use the proper name for it. All right, let me jump
back over here to our slides. So we’ve talked about this,
the forms here. Now in order to do things
in Altium Designer, we’ve got to understand how
the architecture is set up. And there’s two ways to interface
with the program in Altium Designer. 99.9999% of the time you’re using the
graphical user interface and that’s everything I have been showing you in
doing so far in Altium Designer with the exception of actually
running those programs, I’m actually using the
GUI interface to do it. When I click on something and drag it, I’m using the GUI interface and we’re
going into the menus and I’m clicking on something,
I’m using the GUI interface. Pretty much everything we do
is through the GUI interface. The other way that we can do is
we can use what’s called the API. It’s the application
programming interfaces where
basically there are portals into the code and we can send commands
in and do things and in turn we’ll get responses back out.
And this, the only way we can access
this is through the program. We wouldn’t access this
through a GUI interface. This is the actual client server
architecture in Altium Designer. So we are the clients. We ourselves
cannot do any of this stuff over here. We just simply are given the
ability to click on hot keys, or going to click into menus
and to basically tell which
commands we want to use. That gets all sent over to
something called the workspace
manager or the is also known as the DXP platform.
As a matter of fact, before Altium Designer
became Altium Designer, it was called the Designer
Explorer Platform and the
idea behind this was to get away from tool chains where you’d have
this one server and we’ll talk about servers here in just a moment and that
this server over here would manage all of the other servers.
Now if you look really closely at these, we would probably call these editors, but the fact of the matter is is that
these are not just the editors themselves. They also contain the primitives that
are specific to the schematic server or those perimeters to the PCB server,
excuse me, and so on and so forth. Like for
example, if I had a via primitive, I would not see that in the schematic
server. I would see them. The PCB server. Also,
if you’ve ever noticed that in, I’ll just jump out here
to take a look at this. You’ll notice that all of these
menu items over here and all those, these tile things that I can click on for
shortcuts are specific to this type of editor. Right now I’m in a
scripting editor. However, if I was to go back over here
to our LCD schematic, all right, this all got changed out.
All of these things got changed out. Notice that the tool
palettes no longer there, notice that the object inspector’s
no longer there. In turn, the schematic filter has
been replaced with it. All of these menus have been changed.
All these icons have been changed. That’s the workspace manager at work.
So when we click on that, the workspace manager recognized that
we were no longer in that one server and that we are switching over to the
other server. And, and that’s, that’s what it does. And that
there’s a lot of power behind that. Believe it or not, for us,
we don’t really see it. but from an architectural and
from a program standpoint, it is actually very powerful. one of
the things that they can do very easily, and we just saw this very recently in
Altium Designer 16 is that they can drop another server in here as
they are expanding the tool. So in Altium Designer is 16,
they introduced something
called the draftsmen tool. That’s not a part of any of
these other servers here. It’s really its own standalone server. And it’s easy to do because of the
way they set up this architecture, where in let’s say classical programming,
the way I was taught, you create all these functions and you’d
have a main and you’d go through these things and if you had
to make a change to it, you’d have to go through the main and
make all these modifications to address this new functionality,
which when you’ve got thousands, if not millions of lines of code
is next to impossible to do. That’s why so many people
usually abandoned code and
they started again cause it’s actually faster. because of the fact that the architecture
was not set up appropriately. Now, this is just another way of looking
at the client server architecture. We ourselves are the client, the server in like the workspace manager
is really just this piece of code. Now a lot of us think of
servers as these things, these boxes sitting in these cooled
rooms and they’re acting like, acting like servers.
Right? But the fact of matter is that really
a server is just a program and we, the clients are sending
things to the server. The server is doing whatever’s
necessary to process it and find data, process things,
move things so on, so forth and then sending
it back responds to us. All right now and API has the exact
same concept and as a matter of fact, there’s a really great little video out
there. It came from MuleSoft videos., The company, ee here at Nine Dot Connects do
not have an affiliation with them, but it was a really great little video.
A, Because it reminds me a lot of the
video that we put together for our introduction, which I mentioned at the
beginning of our Webinar here today, but also in addition to that a, it does a really good job explaining
both the concept of APIs and even though they didn’t mean it to do this, it also explains the concept
of client servers as well. Now where APIs or what’s a really
good realistic analogy of an API? Think of Google and the fact of matter
is everybody’s familiar with Google maps and you may go onto some website that
has no relationship to Google whatsoever, but when you go onto that
website, let’s say it’s like, um, let’s say maybe in like hotels.com and
I don’t know if they specifically use this, but I think they
would. When you go there, you want to see a map of the hotel. Well hotel.com’s not going to invest in
the same amount of time and energy into a mapping system that Google has already
done because Google is already made something like an API where in their
code at hotels.com and I again, I’m assuming they’ve used this over here, but I’m just going to say use this
as an example. They’re making, they’re making possibly a call out from
their code into the Google API that says, Hey, show me these regions
of these geological, these um, geographical locations of latitude,
longitude, and then send it back to me along with
this is the type of map that I want as well. So as a result they can
take this information, put, push it over to Google, Google’s APP or
API response to it and sends it back. And now you get to see the map
on that particular website. And of course Google gets a little bit
of a sweet deal out of this to some of these apps. You do have to, pardon
me, I should call them apps, APIs you do have to pay for.
But in addition to that, there’s advertising that
comes along with that as well. And Google gets its advertising dollars
from people using their APIs because they can push along some
of their advertisements, when that information is
getting passed back. So that’s, that’s the way to take a look at it.
So API is had become very, very popular on the web, but we can
use the same thing too in programs. And even Microsoft office has APIs
as well. Most programs these days, if you want any type of
level of automation into
allow other programs in there to do things will allow
you access to the API. But here’s a really great analogy to
understand that if you go to a restaurant, the last thing that you are going to do
in a restaurant is to go straight into the kitchen and cook your own dinner,
right? Either they’re going to kick you out
or offer you a job, one of the two. But you know, in all, in all seriousness, we don’t go to a restaurant in
order for us to cook our own food. We sit at a table and we get a menu.
And then what’s really that menu? Well, in our analogy, it’s all the command sets that we have
available to us in the parameters we would need to provide in order
for that command to work. Now we are cells don’t take the menu and
run to the kitchen and tell him what to do. We have something that’s called
the waiter, which in if we’re getting, we’re keeping with our analogy here is
really the interface and we tell the waiter or our interface what we want and
the interface goes to the server or in this case the API or in our case the
kitchen tells the kitchen staff what needs to be done.
And then after it gets processed, the waiter comes back with what
we asked for. So just a really, really great example of what an API is
and also really the client server setup as well. So take a look at that
video. It’s really, really great. Now, I’ve kind of spoke about
a couple of these things, but just to kind of remind you of them. what makes it so powerful for Altium
to use a client server architecture, but like for example, if they want to add in new servers now
they added the draftsman tool recently, a couple of years ago
they also opened another, or created another one that they
dropped in called open bus schematic. If you’re not doing anything with
FPGAs you probably haven’t seen it, but that was another example of them just
putting a brand new server into Altium Designer to address open bus issues
or design. Really it’s not issues, it’s really to do design.
It allows Altium to operate in one window. So Altium is not what
you’d call a tool chain. And back in the 1990s that was really
common to have these things like tool chains. You have a company that would specialize
in one particular software project product. Like they’d have a schematic editor
and then they may come out of another product that would be the PCB editor and
they would sit as separate programs on your,
on your computer, and then you’d have to export from
one and import into the other. And it was a bit of a hassle. And most of the people when
they first bought Altium, one of the things they loved about is
that they didn’t have to deal with that import export of the netlist for example. And that Altium kept their netlists so
tightly coupled that you didn’t have really any problems with that in which
tended to be a big problem when you have separate tool chains.
And putting a wrapper around a tool chain, that’s what people did quite
a bit. Um, I won’t blame on, there’s a couple of major companies
that used to do that all the time and I won’t mention them, but they would
just basically take these individual, disparate programs and
then they would wrap, put a big wrapper around them
and then somehow that wrapper, we supposed to make all these things talk
to each other. But unless you, um, it, it was never designed to
really do that and they would, there would be exceptions and issues and
it never really worked 100% of the time. So what Altium said,
it says, let’s put everything on this platform
and let’s make sure that the workspace manager knows how to talk to these things.
And they also said, let’s do this in an object
oriented programming, which I’ll talk about again here in a
little more detail in just a moment. allowed us a lot for data sharing,
which you just mentioned. So there’s no need for us to ever go out
of Altium to import or export things. Now granted, if you’re going outside of Altium to
another tool to import and export, then obviously you’ve got to do that.
But within Altium, notice how you never leave the the window. I don’t know if you’ve
ever really realized that, but when you’re working
in Altium Designer here, I just jumped from one window to another, the workspace manager handled that for me. I never have to minimize this
and go click on something else. I never have to export something and
then go to another server with an Altium Designer and have to import it in myself.
You don’t have to do that. The workspace manager handles all that
for us. And I think we tend to forget it. It’s really so obvious and so easy.
We just forget it’s even there, right? So it’s not that obvious
because it’s so obvious. So let’s go back over here and take
a look at this again. All right. And lastly, also allows for some
of the common GUI interfaces, which you can see here. So you’ll notice that there’s
commonality between tool functions. Now, that’s not to say that the workspace
manager has tool functions, which the other ones don’t have. But,
like for example, with the zooming, what you do in the schematic
server for zooming, most of that code is probably copied
over to the PCB side for zooming as well. In fact, they probably added a few extra features
on the PCB side of the schematic doesn’t have.
But if, and you know that this is not a part
of the workspace manager, for example, let me see if I can jump up over here,
because if you think of, was it a CAMtastic, I think that’s
the tool that they also have in here. The architecture allowed them
to drop that in here, right? They’re able to bolt in a tool that has
really nothing to do with the style or flavor that the rest of
Altium Designer has over here. but in order to zoom and Pan and do
the other things and that one you know, it’s kind of takes a separate
set of commands to do that. So they’re all kept in
that particular server. Let’s go on over here.
So let’s talk about OOPS. or better known as a object
oriented programming. And this is the basis for all
of Altium Designer’s primitives, or what we consider to be a primitive, like a power port or a node like a,
what do you call it, a junction node or a wire in a component. These are all things
that we call primitives, but really in programming they’re not
called primitives are called objects. In the classic programming that we,
most of us have grown up with, including myself and pretty much the
five languages I’ve learned over the last 30 years. all do the same thing. We
declare variables, we declare functions, we create a main, and then we manipulate all the variables
and the functions through the main, but I mentioned and alluded to earlier,
that’s problematic. And the reason why it’s problematic is
that when you’ve got a lot of people working on a code and you’ve
got thousands of lines of code, when you introduce something new to it,
it just takes a tremendous effort to try to make the code work to whatever
new thing that you provided to it. As a matter of fact, back in the
1980s there’s a book I was reading, it’s from 1986 about object oriented
programming where the author was trying to encourage people to to start contemplating
this concept of object oriented programming that the stats that he
had back then were just amazing. Everybody wanted to go to computers
back in the 1980s especially in the insurance industry,
which has a ton of forms. And yet it was really difficult for
them to do that because of using this classic programming structure
that I’m mentioning over here. So what he was doing was trying to do
a call to arms saying move to object oriented programming.
So what is object oriented programming? It is basically taking, instead of having variables sit separately
and their functions sit separately, you look at something from what it is
and what it can do. So for example, if we take a car and or any
other object for that matter, they have properties which
we’ll call data, like the color, the size of the engine, the type
of seats, the miles per gallon, so on and so forth.
And then there’s also actions, which are the functionality of the car. Like we expect the car
to be able to go reverse, or to go forward or to stop or to
play the radio and so on and so forth. So there’s properties and actions in the
idea behind the object as you roll all this up into something
that’s called a class. You take this and you present this as one, rather than having these things be
separated out as a bunch of variables, and as a bunch of functions. And by doing that over here you
really start to make it easier. So if you drop in something new
into the system, by the way, let’s say you create a new class of it,
it doesn’t interrupt all the other code, the other code will work just fine. Now it’s just a matter of making
this new object that you’ve created, work with the existing code and
since like, oh well if this, this other object is
supposed to work with this, then let’s make it now
talk with this over here. But it won’t interrupt everything else.
Where in the past if you had that, it would really cause a lot
of consternation, a lot of
code changes to do that. Now, one thing that I found with objects,
and this is a little bit confusing, is that this term called objects and
this term called class are thrown around quite a bit, but there’s actually a
meaning or difference between them. A class is what you’d call a
template of properties and methods. For example, if I wanted to create a car
class and I can’t do an Altium, let’s say I was writing some coding and
I send that to create a class and this class is going to be called car. And
then I could basically say, okay, my properties are going to be
the ones I’ve listed over here. I want as a part of my properties
of my class car, the color, the size of the engine, and the
type of seats, miles per gallon. But then I would also have my methods
as well, which would be my actions. So what happens when I need to go reverse
or if I need to go forward and to stop or and so on and so forth.
And that’s what I defined. But then the object is the thing itself.
So let’s say for instance, I have a, I created this, I created
this class called car. And
now later on in my program, I’m going to, I want to have something
that’s very specific to a car. So I maybe I’ll have an object that’s
called Toyota and then I will call that, I will have Toyota of class car meaning
that the Toyota will take on all of those properties and methods that have been
defined in class car. Now granted the values will change and
they’ll be specific to my object is now known as Toyota. But it’s using the class as the template
for all the information and maybe further down, I have one
for Ferrari, the same thing, it will be of class car but all of its
properties will be based off of this template that I’ve got and all
the values are going to be, um, all the values are going to be those
values that are specific to a Ferrari. If I jumped back over here very
quickly to what we’ve been doing, let’s go back to our TicTacToe
game here for a moment. That’s exactly what you’re seeing over
here. So if I zoom back up to this here. These are all things that are classes.
In fact, we call up this class called TForm and
the TLabels also part of that as well. So the TLabels,
well what are the properties and events? If we go back to the object inspector,
we see these properties, right? These are the properties that are
all specific to a TLabel. By the way, I cannot add or subtract anything to this.
Again, I cannot change the
classes in Altium Designer. I can only change the values
of those properties they have. Or the same thing with events.
I can’t create a new event. I can only add a value to
any one of these events. And if you get that concept, that’s going to take you a
long way in Altium Designer, because in the end when you’re
trying to get access to the vias, or you’re trying to get access to all
the wires in the schematic editor, if you understand that you’re trying
to get access to that class of via, or you’re trying to get either to the class itself to create one where
you’re trying to get to the objects, which represent them, then you’re
going to be able to say, okay, I want to extract out this information.
Or Hey, I want to manipulate the particular
via that’s at this location. Or I want then all the wires to be turned
blue because I’ve collected all the objects that were wires and now I want
to send a property to them that says, change your color property
to blue instead of black. So these are the kinds of
things that you can do. And as long as you get that concept, it’ll make it a lot easier for
you to code in Altium Designer. So let me jump back over here
to our slide deck. All right. So I do need to give you some warnings. so if you have whetted your whistle
for this, Just saying, okay, I’m kind of getting this thing.
I see where he’s going with this. This looks like it’d be a lot of fun.
Like spelunking a cave, there’s some warnings that
you got to have are right, cause spelunking can be a dangerous
thing when you’re doing cave exploring. The same thing when you’re getting into
some of the coding here or scripting coding here in Altium Designer.
So first and foremost, Altium has been undergoing a code change.
It used to be in Delphi, they’re trying to move it over to c sharp. C# is basically
Microsoft’s version of C++. And I think I’m only speculating on this, but I think Altium did that because
obviously they’re running on the Microsoft platform, which the operating system and they
want something that’s going to be very native to Microsoft. This coding has been going on since 2012.
There’s over a million lines of code. I remember having this conversation
with one of my colleagues when I used to work at Altium.
It was amazing back then. They may even be at 2
million lines of code. That’s a lot of code that needs to be
reviewed and changed. And they didn’t, they decided they just
couldn’t do it all at once. They’ve been doing it piecemeal, which
is why sometimes some of your functions, which seemed like they worked just fine
for years and under many versions don’t seem to work as a the same
way or same form anymore. And that’s probably because of the
code change that’s been going on. As a result what worked in one
version may not work in another. and here’s a really great example of
this at this company called Desktop EDA. So Desktop EDA is a company we represent
here at Nine Dot Connects for North America. It’s basically an intermediary tool
that goes between Altium Designer and a mechanical tool like
SolidWorks or SolidEdge. And what happens is that every single
time that Altium or SolidWorks, for example, let’s say we’re going to do the one
that goes between SolidWorks and Altium, every time they make a code change here, I guarantee you that Brian Watson of
Desktop EDA has to reevaluate it and put out yet another executable to make sure
that his code will work against these changes here. So that’s how drastic
some of these versions changes can be. It’d be nice if you could
say, hey, look for AD 15, you know,
that there’s one change over here, but sometimes even some of those minor
releases can change something to a point where he’s got to go in, make
a fix to it, and then send out a new executable to
those who might be using it. The second thing is that Altium Designer
does not make all of its functionality known.
So, I do know someone who got
burned by this kind of recently. We felt really bad for him because
there’s nothing we could a system with. It was not a project we were working on a,
and by the way, this individual is considered to be
an expert in Altium scripting. So, and as a matter of fact when we come
to it here at Nine Dot Connects, we ourselves do have an individual
who is a scripting expert. His name’s Jeff Condit. He’s done
webinars for us here in the past. but even then Jeff,
takes such jobs, and we take these jobs
here at Nine Dot Connects, really treat them like hot potatoes.
First and foremost, we would do them this time
and material and secondly, we would have to basically
have a disclosure stating
that we may not be able to finish the program because of these issues
with the functionality. You may say, Oh, this is a no brainer and logically and
pseudocode and makes a lot of sense and you come across something and it just
won’t provide the information we need. Or Altium has not given us a way to
access something that we need to see in there. And we’re, you know, you can
just, you just throw your hands up at, at that point. So, um, we you
know, when you’re going to do this, there are some of those types of dangers.
and then secondly, I’m not here to beat
up on the support team. I was a former member of the support team.
They work really hard, but the support team are not programmers. They are applications engineers and they
work on the GUI side of the interface. Their job is to help assist with primarily
the schematics and the PCB tools, whether it’s feature requests, bugs or just general know
how to type type of things. As a matter of fact in Altium, the one thing that always surprised me
is that there is very little interaction between the support group
and the coders. There’s always been somewhat
of a traditional firewall
between them over there. And in fact, most of the Delphi examples that you
see are really ones that were written by the coders themselves. So just keep in mind that the guys who
are working in the support team here are not coders or if they do, they’re hobbyists in it and their primary
job is to help customers in through let’s say the GUI
interface side of things. So therefore just know that scripting
Altium Designer is not necessarily an easy thing to do. You really do have to have some experience
in it and even if you have experience in it like I’ve had experience in it, you’ve got to understand this thing
of this object oriented programming. If you don’t really get that concept of
classes and objects and why they even bothered with it, it’s just going to really struggle with
it because you’re going to look at these examples and you’re like,
where did this come from? Is this something from Delphi is
something from Altium Designer, why are they doing this format it,
it takes it, you’ve got to really kind of build up
from the foundation of understanding object oriented programming to
really look at those examples. You may have to find alternative
ways of finding ways to do things. As I go back and remember my colleague
Jeff Condit was working on a project, this is before he joined us at Nine
Dot Connects a couple of years ago. And he was sweating bullets
because there was one, one thing he was really working
out that it wasn’t, he couldn’t, let’s say take the direct path in it, but he found a tricky way to get
around it and was able to make it work. So just be aware that things that should
be it either exposed or things that should work,
may not work in it. And then also just be ready
to explore on your own. The support from Altium is simply
just going to be limited out there. But there’s a lot of materials
and resources and that
takes me really to my next point here.
In terms of scripting examples, Altium Designer’s got those.
Here’s the link to them here. There’s also a tremendous number of other
examples that have been made available. And this was brought to my attention
by a good a good friend of mine, which shouldn’t necessary friend, but a
good colleague of mine, Randy Clemons, Randy and I have had conversations in
the past night. I apologize, Randy, if you’re out there, I still need to get
back to you in a couple of other things, but he is one of many contributors
to these additional Altium scripting examples. And plus they also go into a little bit
of a how-to tutorial on that site as well.
So I did take a brief look at it. Something to definitely take a look
at in addition to downloading Altium’s scripting examples as well.
If you’re interested in Delphi coding, I think the best site for keywords and
references is one called Delphi basics. It’s out of the UK.
And interestingly enough, if you just type in the keyword
that you want to know more about, you type in Delphi in the Google
search engine followed by that keyword, you’ll find it on there.
In fact, I think it’s almost easier to use a Google
search to find things on this website than to use the website itself
at times in terms of Delphi, how to videos,
this fellow by the name of Gerhard, I stumbled upon these
a couple of days ago, put out over 70 videos
on how to work in Delphi. So if you want to take a look at that,
that’s really cool. And he did it specifically for high
schoolers and college students and those people who just, they’re not,
let’s say, not programming experts, but people want to just learn how
to use a Delphi. And the lastly, if you want to learn a little bit more
about object oriented languages, um, there’s some interesting videos by a
fellow by the name of Dan Daniel Shiffman. Um,
it’s called the Coding Train. If you can get past his really corny
introductory video you’ll find that he’s very high energy and has a
great enthusiasm for teaching
these types of things to it. If you’ve got a few moments
I’d ask you do the following. Now I’m going to put up a survey here
and we’ll also show you the results as we’re going along. We just like to find out whether this
is something to be pursued or not. So we’ve got a couple of questions for
you and then the survey will be popped up here in just a moment and if he just
take a moment to fill those out are truly appreciate it.
So for those who are taking off, thank you very much for
joining us here today and um, and we’ll see you next month and just
give you a little brief preview for next month, we are going to go
back to our friend Sean Kelly. Sean is going to continue kind of with
his talk about signal integrity. However, unlike the other two where we were
talking more about the fundamentals of it, he’s actually going to show us how to
apply these things within the PCB tool itself. Thank you very much for your time and
we hope that you enjoyed this particular session. Folks.
I’m not sure why you showed up today, but we hear a Nine Dot Connects know that
topics of this nature are important to you. We know they’re important
for designing the PCB, especially as speeds are increasing
signal integrity issues are becoming more and more prevalent and a demand for
wireless is growing bigger and bigger each day. At Nine Dot Connects this is the
knowledge that we sell and we sell it in different ways. Most of you know that we sell this
knowledge in the form of trainings and coachings, especially with Altium Designer and most
recently with our new PCB fundamentals class. We’re also happy to announce that we have
just released two one-day classes for Altium Designer libraries and schematics.
In addition to coaching and training, we consult and this word is really
abused because anyone can call themselves consultants.
So what do we mean by it? It means that if you have any challenges
or issues with your PCB design, we can assist you. You have
a board that’ll be handling
large amounts of power? We can assist. Have boards that need compliance testing
are designed to be compliant to a standard? We can assist. In short, we
can assist you in achieving your design. And by the way, we’re more than happy
to assist in board layout as well. When I was doing design,
we had challenges, which we
call technological hurdles, and I’m sure you deal
with them all the time. And in some cases you may be avoiding
features like wireless or gigahertz speed devices, because this stuff may seem like major
technological hurdles to overcome, but you don’t have to wing it or
go at it alone or even avoid it. Let us here at Nine Dot Connects,
get you over those technological hurdles. So for more information, contact us and check us out on the web
at ninedotconnects.com thank you very much for taking a look at this
video and you have a wonderful day.

Leave a Reply

Your email address will not be published. Required fields are marked *