So first, let's proceed with an initial addition of a time, so we required to declare to structure
first within the config structure.
OK.
This again is a pointer and then the instant right.
So these are the two structure that we require to perform an initialization of our issue time.
Right.
So here we declare an independent function named as a timer.
This consist of all the function that.
Is used to perform an initialization of our private that you do with suit.
All right.
So we first call look up config where we add the device to where do you find device IDs from an experimental
file?
So if you just go to an X parameter dot fight and if you search for an issue timer, so you get all
the information related to an issue, a rate.
So here you have a device.
80 Something interesting is if you remember whenever you are utilizing the interpreter case of a GPI
or a timer.
So wherever you have a data related to that IP, there you get vector isolate.
That is the unique I.D. that we get for an interpreter.
But here you do not find anything as an interface.
So we will be understanding how you find out and interpret it for internal resources that we have with
the processing system, right?
So here you do not find anything as an interface.
OK, that is the specific difference that you will be finding between the interpreter knee into.
When we that will be finding is the specific difference between the example that we considered in a
previous video.
So we go ahead and first include the issue timer device.
Now this will return the convict structure, which we will be utilizing in a sea of Jaenisch light,
along with any structure and the base address, and that will perform an initialization rate.
So the status of initialization is written by this function, which is stored in this variable.
And then we are just verifying whether initialization is successful.
If status is equal to this, this axis.
Then we can see that timer and it is successful and we could just make it right.
But we could actually perform all the configuration of the timer here, except as discussed previously.
Right.
So the configuration that we need to do for our timer is first, we need to calculate the delay, just
assume that we want to generate a delay of one second rate.
So we know that this timer operate at half of the same frequency rate.
So it is operating at three three guards.
So we are loading it with three three three megahertz that basically provide us a delay of one second.
So let me just call this a first configuration of our timer, right?
So we go ahead and we call it over here.
In fact, we know that whenever we are working with the timer, the first thing that we do is to forcefully
stop our time right.
So we go ahead and we call this function, which allow us to stop the timer right?
Here we just need to pass the instance of geologists die, right?
Then we load our timer to provide a delay of one second.
So this will give us a delay of one second and then we are disabling and reload.
So this basically means when we want to generate a multiple event, we need to restart on a timer,
right?
So we have two ways we could use a reset timer.
Either we could use reset timer or we could use an awful lot more.
So both of this we discussed already, right since here we are disabling an auto reload mode since we
are disabling a lot to learn what you need to use a restart timer whenever we have it right.
And then the last thing that is starting a timer will be doing in a main function.
So these are all the configuration that we need to do.
So we are loaded our I must be able to get a delay of one second rate to this complete the goal that
you need during that time within right.
So once you complete the timer and your function, you go to a mean good, OK, I hear you call timer,
right?
So this will perform initialization of an issue timer as well as configuration, right?
The next step is to initialize of right to.
The next step is to initialize our GST rate.
So we already perform an initialization of a very fitted.
Now we proceed for initialization of the GSI.
So this also required structure, right?
So perfect structure and an instant structure, right?
Then we go ahead and we declare one function, which we refer to as an entire integrator.
This consists of all the function that could be used to perform an initialization of why general in
charge controller, right?
So first we call look upon where we add a device.
This will generate the config structure for us, which we will be utilizing in the CMG initialize along
with an instance structure and a b said.
Then we are verifying whether initialization is successful or not.
Right.
So this complete the process of initialization of our general controller.
The next step that we have is to both initialize as well as enable an exception handler on the power
when we supply power to the processing system.
The exception handler is would destabilize and initialize.
So we need to perform initialization as well as we need to enable it, right?
So all the driver related to an exception will be finding and then they'll underscore exception.
Darkness, right?
So if you just proceed first, we call exception in it again, in the registered handler, we need to
specify the type of an break.
So here we are utilizing an issue.
OK?
The master handler for us is that in Japan, and then we need to pass an instance structure for AGC,
right?
So here if you observe, we have not identified a right, so if you just customizing processing system.
OK.
And if you go to the interest rate, so here we have a fabric interface, so this enable us to connect
up to abuse or sent up to a.
So if you just go ahead to first, we have a built in.
Great.
So here we have an IQ board, right?
And then this allows this series of things to add to this great.
So since we are not utilizing any play, this won't be required in this example.
Similarly, we have a peer to peer into it, right?
But we are not sending out of a rate for an internal resources, such as the resources, which is private
to the unseen processing system.
OK, we do not need to do anything OK, even though remember that we have not connected any ben to an
IQ, all the fabric in depth.
OK.
But still, we need to specify this to be arguing right now when we consider an internal zinc processing
system, resource of the type of input will still be belonging to one of this category.
Like to be the.
Software Interrupt Prefecture Board Data Board are forced into our last right and research and undefined,
so these are the seeds of the suicide of entropy that we have, right?
So even though we are not utilizing the fabric into but still this belongs to an IQ, right?
So the first argument that it would be adding for this triangle, it is still alive.
So unless you prefer to use and other type of an job, you need to specify a Niharika as your type of
an intro for almost all the resources that you are Typekit, right?
Then the master handler for us is NDIC Master Hanger in the last argument that we need to add is the
infrastructure of our GC, which is right.
And then we need to enable the exception.
So this completes our step to walk where we initialize our exception and we enable the third part that
we do is to specify the function that will be called when we have an enterprise.
So we recognize and into the unique idea and then we specify an interest rate.
So we call the connect rate and instant sector for Gacy's II, then we need to find open, unique enterprise
data.
So we already know that we do not have any idea what here when we explore any parameter find.
So in that case, you get all the information related to appear so you could just explore this.
Hey, if I needed X parameters and let's start started.
So if you just click on an F3, OK, here you'll be finding all the missing information.
So here you have all the tied for the resources which are which are private to us in pricing system,
right?
So here you have the WD IDs, you dimer interface.
We also have what it is in jeopardy and so on and so forth, right?
So whenever you do not find out that information that you are looking for related to our hardware in
an experimental dot, which might just go and explore the parameters and the score based on each rate.
So this is included in an X parameter file, so you just need to explore it and all the missing information
you'll be finding in that fight, right?
So here you have an S.U. timer into tidy rate.
So that is what we going to call.
The next thing that we going to specify is the function that will be executed when we have an interface.
So we declare wide Daimler Handler, right?
So this is the function that we want to call when we have an interface, and that is what we gonna specify
over here, right?
So here the food argument could be zero, or it could also be the instance structure of our time, right?
So instead of searching for a time rischi, we'll just be adding di over here.
So this will serve as a callback data for us, right?
And then we need to enable right.
So we have a two switches, which we need to enable.
So here we have Ogi C never.
OK, so this will lose this right?
Next one, now we know that our driver file consists of an enabling trip, so we need to collect to
close this route so we go ahead to the timer driver, right?
And then here we have and enable it to operate.
So we just required an instant structure.
And that is what we have to do to give CSU timer enabling and instant structure right.
So this will close our switching.
And right now we are ready to send and interpret this struggle by referring to the.
Let us see what should be there in the interrupt, right?
First thing that we do as soon as we have an interface to disable it so that we do not have any new
request until we solve an existing one.
Right then we are performing two way check with timeout is really expired, right?
So if you demoted expire, then we'll just be mentioning we have an interest, OK, and we'll be printing
this right?
But this will always be a case that when we reach over here, our timer will be expired and then we
have an interest later said at one second.
OK, because we specified the counters that we we're able to get the deal of one, right?
Then we're hearing up all the pending OK and interpret so that we have a fresh interim request again
and then we are enabling an interim.
OK, so this allows us to start sensing a new interventions we disable are.
Auto reload, more so we need to forcefully call a restart timer, so to get the multiple interrupt
for all my time, right, so restart time.
And we need to pass an instant structure, right, so that what this will do is this will again reload
our timer to the value set that we're able to get the delay of one second.
So this complete the whole quarantining.
Topanga now only thing that we need to call in our main function is the time any which will perform
an initialization and no configuration of a timer and which will perform an initialization of ICAC,
right then we just need to call stacked EPA of our time.
So this will start our operation and then we are waiting for it to occur.
So this complete circle?
Let me just build our entire application project.
So once our bill is finished, we have any left right now.
What we want to do is we'll just be selecting our application project debugger launch on.
Right.
So this will automatically program our SPG.
The only thing that we need to do is to connect dominion to the respective computer and click on resume
button, right?
So you will see time and it is successful and it's successful and at an interval of one second.
You have an interrupt request from our issue time.
Right.
So this is how we utilize the pointer from our private sync resources, right?