Once we create a new project, we will be finding with each to this step.
OK, there you get a flu navigator, the suit strap, the properties tab and then at the bottom side
you have a console message log designed, right?
So as you properly sang as and when required to use, any one of this option will be understanding more
on that.
So the target for this specifically do is to understand the flu, navigate the different option that
you see in a flu, navigate, right?
So the first option that you see is our project manager, right?
So inside this, you have two options.
So you have this entire four option that have been included in the project manager.
The first thing that is setting allows to change the language at the right time are pushing 30 by three
to see you have a region where you could perform changes in a project device later on our target language.
But usually once you perform a changing an entire flow, need to be performed right.
So setting allows to change the device in Gingin or the setting related to simulation in operation nine
different pieces.
But the primary use of this will be to change the device or a language if required.
Right.
Then we have an.
So whenever you require to add and as you follow this option, we'll get the services that could be
added as either very low visual art, a system, right?
Then we have a language.
So whenever you are in a specific need to invoke a correct component, for example, addresses in block
many.
So there you need to follow a certain cooling style, so that could be easily this by analyzing the
language template.
So if you just go to a language tabloid and look for the device that you want to implement, such as
Ma'am.
So you get a series of attempting to just follow a template and then you could implement an exact rate.
The next one is an ipecac.
So here you'll be getting a series of IP, which are feed available for the license that you have.
Applied to the right to decide the future option.
Now these are predominantly related to very long and we still call, so we will be skipping this option
in the most part of the course only when we are designing our own IP.
OK, very true, right?
Are very local.
They're only we will be walking around with this option, right?
The second option is an IP integrated.
This allows us to create a block design, right?
And for an embedded system design, this is a standard methodology that is schematic based design very
utilized and IP integrate, right?
So for most of part of the goods, we will be preparing to go with that design.
So you just need to click on create blog design, and this will add the canvas where we can start invoking
an IP use and then create, tie and hydrate, right?
So these are two ways that we have, either you could specify your thoughts in a text based methodology
where you very love me.
Still, our system will good.
And the second one is to add your design into a schematic.
So this idea to design methods that we have is that the first option?
And from this, you could clearly guess that the first step that we do in an BJU based design is to
specify your design.
So there are multiple methods.
Two of them we discussed.
One of them is to add or specify the text based source that is very low still on our system.
The second was to utilize the schematic that is utilizing an IP integrator, but remember an entire
floor?
OK.
We need to have a very local.
So even though we do need the schematic, ultimately we will be creating a wrapper or grew out of it.
And then we are allowed to use this option that you'll see below IP integrated.
The next option that you have is a simulation.
So this is used to.
But far more functional verification of the design.
So usually when we consider any major design, we do not work on a signal level.
OK.
If we wish to work on a signal level, the best choice that we have is entirely will not be performing
simulation.
Look at the signal level and applying a random stimulus because you'll be finding the signals will be
there and approaching.
Each and every combination is next to an impossible right.
So usually either an eyelid, then you want to analyze the signals or a V will be debugging.
Odd applications that are the standard practice actually for the next one is an ideal analysis.
So this give us the idea about the cells that we are utilizing.
For example, when we break down certain they still go to work, all components are invoked light that
could be easily understand by Anakin.
And this is then this give us an idea of either the design that we are expecting is what we are invoking,
right?
Since this is converted into something that our feature in this turn.
So we have certain set of primitives for each FPGA family.
So synthesis transform.
I still call into the primitives, which could be downloaded on an SPG, right?
Then comes an implementation, so the implementation will choose the specific position where we will
be adding a logical UI depending on the preference specified in and const.
Right.
So this is what an implementation do.
Then we have a condition of a bit, right?
So finally, when we download our program, we'll get our logic on to budget and only we will be able
to test on higher rate.
So it requires a bit fight that could be generated by the bitstream option and then open hardware manager
allow us to connect the device either locally or remotely to override.
Right.
So these are the series of options now, since we will not be working on the signal level when we consider
an embedded design.
OK, at least for the most part, of course.
In fact, some of the debugging technique when we tackle there, we will be utilizing annihilate to
capture the signals on the net.
But far less so the case in an embedded system design.
We hardly work on the signal level that is individually triggering a signal.
So simulation analysis, synthesis and implementation are not used when we work with an embedded system
design.
So most of the time what will happen is we'll be creating a block to say we'll be specifying in hybrid
design by adding an IP, then a fire IP do not consist of any unrecognized booed by value.
So what it means will be our understanding in the next video to see if we were able to understand output.
And then in that case, what we will do is it will automatically specify a constraint so we do not need
to do anything right.
In that case, we will directly go to generate stream, so we start to then block the site.
We directly go to Bitstream and then we will be exporting the big filing to an s.
This will be our normal flow.
But if you add an IP whose input and output ports are not recognized by and we do OK usually when we
create our custom APIs.
In that case.
We need to perform a synthesis, OK, and then we need to specify the country, which basically will
tell where you want to connect our input and output.
And then again, we'll be going to the Djindjic Midstream, right?
So this will be our normal.
So we started the block design.
If all the words that we have in our design, if they are defined and understood by we are the way before,
in that case, we will directly be jumping to changed midstream.
The second scenario will be when we have added some of the ports which are not going to stand by and
we are.
This will happen when we create custom APIs.
So in that case, we will be starting with a create block design, performing a synthesis, specifying
the poofs and then generating a mixture.
So this will be I flues know when we started that embedded system design using the Viper.