So our generation is successful.
No, again, we follow the same procedure to export hardware to file export export hardware.
And this will be including industry, right?
So we'll be selecting the same territory where we have relied reliable project data once that Edison
go to tools and then launch by this lady right here.
We will be using the same workspace where we have our little project, right?
So go ahead and select the same workspace where we have our project right to work.
That is done.
We will be creating first platform project.
Okay, so that will basically involve this hardware specification.
The hardware that we have created in a Iraq right so we could create platform project will just be naming
this as multiple GPIO instance, OK?
Click next, and then we click on Browse Button.
We go to a directory where we have our highway.
Excessive light and then we click finish, the one sided platform project is really the first thing
that we.
Do is to remove this out of date status, very serious pest control envy.
This will automatically start building up our project.
And once Bill is successful, we select the platform project, right click new and then we select an
application project.
Right click next.
So this will automatically invoke the Black Swan project, or here will be selecting the theme platform
project and the name that will be utilizing for this is multiple GPA.
You are in this school district, right click next and then we will be invoking the High-Level Template,
right?
Now we go to a small stuff where we have our hollowed out sea and then we'll start building an application
right now.
Remember, in our hybrid design, we have two instances of any right.
So we need to independently initialize them.
We need to declare two instance structure and to convict structure, right?
This makes it so here I have code from our previous example.
So we'll just be copying it, going back to Envato.
Let us start adding the two drivers, which are mandatory.
The first one for a GPA, we require to include X to be able to attach rate.
This is the first driver that we require.
The second one is the experimental data checks parameters starting right.
So we are required to convict structure and to instance, structure, right?
So we'll just be now naming our config structure like this a switch config, OK, which will be working
with an initialization of a variable configured to work with the switch.
And then we have any lady config, right?
And this again, should be the point, right?
The these are the two config structure and an instance structure.
So we'll just be naming the assets, which are nearly right.
Once this is done now here we will proceed for initialization, right?
So let's first initialize which.
Consecrate, so here we will be adding switch config, no, you're required to pass a device idea.
So if you go to an X parameter dotage, and since we have correctly named up a referral according to
a functionality you'll be finding now finding a device, it becomes very easy.
So we'll just look for Switch and our APIs will be named according to the name that we have given to
a favorite line you could clearly see.
Now it is very easy to locate the device I.D. for a specific benefit right now, since this is working
with the switch, then just be passing the Switch ID.
You are here, OK, and then we have a status.
Let us just name this as status is so key since it is working with the switch.
And here we need to pass the instant structure, which is a step blue.
OK, one fixed structure will be a stable config.
And finally, we require two paths to be set right.
So this complete the initialization code for our switch now will just be copying this statement and
we'll modify it says that it will be working with an LCD.
So first thing that we do, it will be adding an added config.
OK, since this is the structure that will be working with an LCD, then we need to pass the device.
So we go to an experimental stage and then here we have our device idea, right?
So we go ahead and add the device.
I do.
We're here, right?
This do will be naming A-Z.
OK, since this will be working with an LCD.
The incident structure for an elite is really and then the config structure is.
Early in the school conflict, so that is what we going right over here and here, also a Confederate,
so this complete the goal.
Now we need to have over the boot of this state as this and state Israel is equal to exist just so we
could just use hand and open the door to here.
And then we will be adding statuses and status, right?
So this will verify whether both of this that is true.
This is and Steve Israel, OK, both I equals to exist to success.
And if that is the case, we could see GPIO and it is successful, eligible.
Just mentioned UPI it.
Right.
So this is how we will be writing the multiple initialization for the multiple peripheral APIs that
we have, right?
Remember in your design, if you have multiple types of scheme type, then you need to independently
initialize templates.
So that is what we did over here.
Then we already got a GPIO in it.
So we'll be going ahead and calling GPO and iterate.
The next step is to correctly set up the direction, right?
So for that, we go to our next episode or shortage right here.
We have a said direction EPA, right?
So we'll just be calling it.
This required the instant structure, the channel number and the direction that we want to set, right?
We will be going ahead.
OK, so instant structure for switches.
Switch.
Right.
We are utilizing a single channel for both types and we want to set it as an input port, so we just
need to add.
All right.
Similarly, for an LCD, we have an instant structure as.
A lady.
Now we are again utilizing a single agenda, and this should be settled and our proposal will just be
adding all zeros today.
So once this is done, we can actually set up the direction.
Now we'll start building an application, then application will be very simple.
It will be simply reading the data from the switch and then sending one to an illiterate.
So this will be doing at an interval of let's listen to second rate.
We declared one variable.
They just need this as you do, which will be storing the switch data.
OK.
So here we will go ahead.
We will be calling switcheroo and then we will be utilizing the discreet Reed API.
OK, and this just required an instant structure and a channel number.
Right?
So we'll go ahead.
So incident structure for us, which is established and the channel numbers were right.
So now what are we going to do is we will be writing this city down to anybody.
OK, so for that, we have a discreet right, OK, which have three arguments.
The first argument is, for instance, structures so far and the instance infrastructure is a lady,
the channel number is one, and the reader that we want to send is Switch three.
Right?
This makes sense.
And we want to repeat an entire process after an interval of two seconds and we'll just be calling Sleep
two and due to a pretense of while one, this will be continuously repeating until user press the reset
button.
OK, so this completes our application.
Now we are ready to build up our applications for breath control.
This will build up an entire application project, right?
So once our build is successful, we'll proceed to right click on an application project the DBA gets
and then launch on hardware.
So this will switch our due way from design perspective to a debug perspective.
Now will connect why it is still OK to go come six so that we able to recognize that there are initialization
is successful or not.
So we'll go and click on this plus button, select column six and the board rate at which we are working
is nine six zero zero two one serial terminal disconnected.
We'll just be going around and click on this resume button, right?
So here you could see GPO and it is successful now as we change the switch, look, you could observe.
The changes in elite state, right?
One more thing that we could do here is we could just bring the value of the.
Switch with that also help us to.
See the values of the switch that we are really engaged, so.
Here we will just be mentioning while you read.
OK.
But S.E. Rudy, new line character and then the reader we have is in switcheroo variable, right to
once you modify your application, go ahead.
First, disconnect your debug session.
OK, go back to design.
OK, and then we could just right click run or launch debug s launch on hard, right?
This will automatically reprogram a refugee, and then we will be again starting to see.
The values on a council, right, so will just be going ahead.
So what we could do here is he could also bring the value of the S.W.3d variables to this help us to
see whether we are getting corrected on any rate, so we'll go ahead and will modify our application
a bit to 0.5 and then value.
Right, OK.
But S.E. Rudy, again, do not forget to add a new line character and the value we have inside sushi
right to once you modify an application, the first thing that we do is to build your application project
else if you feel to build.
OK.
Just relaunching our debug session won't be updating your application.
You still be able to see your previous application been turning on an FPGA, right?
So first thing that you always do is as soon as you perform an update, you build your project rate.
So press control be of one spirit is successful.
OK.
We will again be relaunching our debug session, right?
So we go to the design perspective.
You select an application project, OK?
Make sure that you are building successful, then right click Right debug yes.
And then launch on heart rate will again go ahead and.
Disconnect are right, is still middle, OK, and connecting back to the same food which will be operating
at the board of nine six zero, right?
And then we are ready to perform execution of our call, right that this you could clearly see now we
are able to bring the value.
So as I change the values of the switch, you could see the changes of the values of a switch, right?
And again, you could also observe the same street on an early deals.