Collided with simulation is successful.
Now we go ahead to a fight, we click on export export hardware.
So this will be a bit of bitstream, right?
So this allows us to program our FPGA for men, right?
Is it right to boot using the same location where we have Vivaro project that is project onto school
43 and click Finish, right?
So once our export is successful, we will start launching.
I decided to go to digital console.
Now you will see successfully created in hardware platform, right?
Then we go to Toulouse and then we launch of deciding.
So here we will choose projects and the school, 43, which is the directory, we have all the really
big files.
So we go to a browse button and then we locate why this project?
And then here you have project and this got right.
So this will be the workspace for this ideology.
So this gives us an flexibility where you could find out all the hardware and software files in a scene
that right now we go ahead.
And first step is to invoke an hardware project, right?
So we click on create that one project.
We'll just be naming this as Amil GPI.
Right click next, and then we will be browsing our hybrid platform.
So this is located in an.
Why this project project and this of 43 and here you'll find an excessive file, so you just need to
invoke it and then you'll need to click on finish button.
Right.
So this will automatically give and the itis an idea about our hard work black faith.
So once our hardware platform is ready, the first thing that we do is to remove this out of reach two
to three, so that can be done by pressing control the AI that will initiate the process of building
a project.
So when the bill is finished, just select your phone project, right click on it.
OK, click on New and then you start creating an application project.
Great, so please select an application project, click next and choose the theme platform project.
So this also give us an idea that we could add a multiple track phone project, and depending on which
platform project we wish to run our application, we get the provision to choose the specific Black
One project here when we have a multiple black phone project been added into our project, right?
Here we will be choosing the theme Black Project, click next.
We'll just be naming the Zs Mill.
GPIO and disgraced up, remember that you cannot give a same name to your application project as well
as the black project, right?
So we usually named our platform project lettuce as you project.
And then the application project, the Niemi provided project time to school dressed up.
So this is the strategy that we often follow to name our application project and the platform project.
So once this is your click next and we will be using stand alone on the S7 Cortex-A9 on this busy right.
So once this is ready, we will be now using an halloway template.
So this give us an.
A list of any which could be used to interact with.
You are right.
So let me just go to a small step and here you have had the weight of cigarettes.
This consists of our main application, which will be executed on an FPGA, right?
So if you need to change the form, say the process is very simple, right?
So just right click on this window, right?
So this is our study, right click on it, choose a preference and then you see a direct link to a text
ready to right click on it.
And then you have color forms go in there and this automatically decodes to text one.
So you just click on an edit button to decide that you want to just choose a 14 click.
OK, apply, apply.
So now we start building, right?
So you'll be finding there are multiple files over here.
Then we create a new while when we open up the new application project if you go to an image.
OK, so this stop of board support package, so you just need to go in there.
So if you just go to a board support package, right, so we have added an image direct, so you'll
be finding the driver information over here.
So if you go over here, you could find out that we get GPIO.
So this is the recommended trailer for V7 GPIO page, right?
So we are utilizing a GPO paper, so we just need to include this library to get an access to the function,
which could be used to work with an GPI, right?
So we go ahead and we include this driver file, right?
So hashing to you.
Then we add GP, I'll be s right.
So this is the driver name which is mentioning that VSP file.
So Xilinx follow a specific terminology that is the name that is mentioned.
We're here.
You just need to add the X-ray.
So we go ahead and add to the X-ray.
So you have x GPI.
Yes.
So this will be the driver file, which consists of all the functions which could be used to work with
and GPI, when more important driver that we're required is the driver containing and hide hardware
information, right?
And this is X parameters daughter Rachel R2.8, you will be required in almost all the project.
OK, wherever you require to get an access to any hardware information.
So once this driver at first we explore the GPI driver, so just click on entry to explore the content
of each episode driver.
Now if you go in there.
OK, so you have certain hand right now, we already know how we utilize the tribal right.
So here we have a GPIO one fixed structure then.
You have an instant structure, right, so we follow the same process as discussing the point of the
so first we copy this config structure.
We go ahead and we create the pointer of it.
Great.
So let me emphasize GPIO can correct.
So this is the first thing that we require to initialize are predicated.
The next thing that it requires is an instance structure.
So we just copy the instance that chirpy studio here and let me just name just as GPI, right?
So these are the two magnitude thing that they require.
Next, we declare one function, right?
So that hasn't written anything.
And this could be used to initialize our GPI, right?
So we just need this as Tupaea right, and will be adding all the space that could be used to initialize
up everything, right?
So if you go to the GPI driver, right, so you could find out to see if you initialize function, right?
And you also have a look of confusion.
So first, we'll just call look up conflict.
So this help us to need the concrete structure, which will be utilizing it in see if she initialize
to initialize our framework.
So if you analyze the look of config, it just required a device to device IDs and hide that information.
So that could be found out from an experimental coordinates right the GPIO config, OK, and this will
be close to the lookup config.
And here we need to parse the device I.D. So you just need to go to an X parameter file and look for
GPI, right?
So if you just search for a GPIO, you could find out.
It takes us to the line number where we have all the data related to what GPL.
So we just need to copy the device and we need to add this as an argument to our lookup config function.
So this is the step one.
So this will give us a conflict structure and that could be utilized along with an instance structuring
of each address OK to initialize out Typekit.
So we'll call the initialize.
We go ahead, OK?
And then first argument I did have is an instance structure.
Then we have a config structure and in the set right, so we add an instance searcher.
Again, remember that instance structure here it required a pointer, right?
But we haven't declared it to be a point.
So you just need to pass an address of that structure.
So ampersand GPI, this is how we will be working with an instance structure in almost all the code
and config structured servers declare is a pointer, so we just need to GPIO config, right?
The last thing is a v, etc. So config structure itself consists of a visitor, so you just need to
use GPA of conflict.
OK, then we will be accessing the base interest rate.
So this is how you get access to the etc..
So once this is specified, OK, they do exist.
Another way to get a visa address.
If we go to an X parameter topic and to AGP, IOW could find out there will be set rates.
So this we said this could also be utilized as a third argument to the June issue.
Right.
And if you follow the explosive June issue like this basically written, so if you just explore the
functionality of it, right?
So this in the asked, So did you write and ask that you do basically represent the state itself by
initialization?
So if this is existing sets, then our initialization is successful and initialization free, right?
That is what.
Internet radio exists, so sex is basically is a value of zero 10 zero I initialization is successful
as our initialization is right to what we're going to do here is we declared one variable, but let
it just name the said status right?
And that will be storing the value that has been written by C of June-July.
Correct?
And then we verify whether its status is equal to existing success.
That is the case we'll just use.
Tell have.
OK, and we mentioned GPIO in it.
Success rate, again, we will be adding a new line, correct rail and would just mention the printer.
OK.
Do you elect three?
Right?
So this is how you perform an initialization of anybody set it right.
So we just go to a driver there.
We find out.
Look at whether we have a presence of a local up.
So if you look up, one fig is president and CEO of G Initializes Present of US, which ended the conflict
structure by passing a device IED to a local conflict.
And then we use the config structure along with an instance structure on a base edits to initialize
alphabetically to once initialization.
We go to a mean program now here you have an init platform.
In that moment, being the platform provides the function, which allows us to work with N, C and D
to write or C tokens.
So it will be keeping that OK and then we will be calling this function in our main application.
So this will flow from initialization of our GPI.
Now we will be find out the EPA is that I dare to.
Set the direction for output and to send a detective great, say if you go to again the GPIO tribe,
right, so you have EPIs that could be used to interact with an entire bank.
OK, but instead of an entire bank, we want to interact with the pin.
We know that Ben seven is where we have our reality, right?
So we also have a pin API to allow us to interact with our pins, right?
So we have set the direction right to.
This could be used to set up the direction if you explored the functionality by flipping by clicking
F3.
OK, so this set the direction of the specified BEN.
It does require an instance pointer as our first argument.
Then Ben is the pin number to which the data is to be read and write.
So we want to write the data where we have it and that is on pin number seven.
Wickets of second argument will be the pin number.
And third will be a direction right to zero for input direction and one for and output direction.
So we'll just be copying this.
We go back to an, I mean application right now.
We will be calling.
This first argument is an instance structure.
So its structure is.
Again, if you can see almost all the EPA's will require a pointer to an instant structure.
So whenever you specify an instance structure, you need to mandatorily added ampersand, right?
Typekit Ampersand GPO pin number seven.
OK, and then the redirection we want to set is an output rate, so that leads and output will just
be writing one.
Now let's write an application that will allow us to see a blinking effect on another year.
So we want to continuously see a blinking effect.
So we'll just be calling awhile one and then we want to write the reader.
So first, let's write a one two analogy.
So to do that, we do have a function, right?
So we have a function to read the pin value and write up invalid, right?
So here you could specify dates and structure again, up in number and the redirect.
We want to write that we just copy this.
We go back to our main application.
OK.
First is an instance structure, so I am placing UPI open number seven and the data that we want to
write is right.
Then we will be waiting for.
A delay of one second.
So two hour delay, we have a sleep, OK, so this provides the delay.
In second, whatever argument that you specify will be the delay that has been provided by the sleep
function.
So here argument is one that this will provide the delay of one second.
Right.
Then we again call the siem rape and function.
OK.
But this time we will be writing is so it will be turned on for us one nanosecond and then we will be
keeping it off for one nanosecond.
Right this way, we will be getting a blinking effect.
So again, we need to add a delay of one second.
So this completes and Typekit race.
So what?
Why we referred this as a simple benefit, Alice.
So we just need to perform an initialization.
Second, the detailed addiction and we are ready to send the reader to a briefing.
But when we considered an intermediate and a complex benefit, it's a day.
We also need to set up the differing frequency ranges, different clock ranges and then the wider range,
the mood up on operation and then only be able to write a redirect.
So usually when we consider a very, very large complex, so you'll need to do three to four configuration
before you actually saying that.
But when we consider a simple paper, do you just need to set up the dedication and you are ready to
write?
So this is how you work with an API, right?
So here we performed an initialization.
We are also verifying whether initialization is successful or not.
Right?
Then we set up the direction and we finally are writing a detailed so we are writing one for one second
and then zero for one second.
Right.
So let's just go ahead and first build up project, right?
So to build the project?
Just press control.
This will automatically see a project, build an entire project and generate an LFA, which will be
finally executing on next page.
So once bliss finish.
OK.
We select our application logic, right click OK, and then we have an option debug launch on hard,
right?
But this will automatically program our FPGA.
OK, so before you proceed to performing a debugging, you need to make sure that you have connected
your FPGA.
To the right to once programming is sexist, you will automatically see pointer way here, right?
We know will connect the serial terminal that we have over here, right?
So we are utilizing and you are very fitted, right.
So we already know that it is operating at one one five two zero zero.
So we go to a serial terminal, click on this plus button.
OK, so the board rate at which we are operating is one one five two zero zero, then we will be using.
Right.
So once this is done, you will be getting this disconnected on foot.
Then we just need to click on this resume button.
So once you click on this resume button, you could see the status as UPI.
And it is successful.
So if you observe the world, you could actually see the blinking effect on the mirror that is pressing
on.