So let's consider how we work with and interrupt when we consider the resources that are available with
the processing system.
So we'll be considering a suit similar here and we'll be going to an entire procedure for how we use
and interpret an issue of time.
Right now, we already know that time we're working to more pull more.
We already covered something that will be considering here is an inch or so as soon as time reaches
to zero.
So we'll automatically get an interrupt, OK, and that will be sensing and doing all respect to logic.
So only thing that we need to having a block design is and you work because that will help us to analyze
how our logic is working, right?
So by the time I enable, we do not need to do anything.
So the fundamental block design, the fundamental piece of script we are utilizing from the beginning
could just be added.
So we only have fixed.
OK.
And as you timer is enabled by default, we do not need to do anything.
OK.
So first thing that we do after our hardware design is ready to create an app.
So once that generation is successful, go ahead and create.
OK and exclude the hardware file along with an midstream into an SD.
Right.
So I have already written the code.
It will just be going through an entire code to understand the procedure.
Right?
So for general intra controller, we need to include a dirty joke.
Experimental detection will give us an idea about all the hardware related information S.U. timer we
require because we need to initialize that right?
And finally, the exception will be keeping this fundamental check with this right.
So first process when we start writing an application is to initialize a pacesetter as well.
Right.
So if you just go to a code.
So here we have a timer function that is used to initialize esut time, right?
So we required to structure one will be an instant structure, and either one will be the config structure.
Right.
So here we declare double that.
So we have a config structure.
We just go to the esut diamond artichoke.
There you'll be finding that new structure.
So first one of them is the config structure.
And then you have an instance of a up that we have to do with you.
Quite often fixed structure, you need to be a pointer.
So simple, declarative pointer.
And then we have a key right now to initialize the timer.
We post user lookup config function.
OK, and we pass device idea.
So where we will be getting a device, it is from x parameter dart h, right?
So if we just go to an experimental stage and look for s you timer, OK, you will be finding the device.
I do something interesting to note here.
Here it is.
You do not find an interrupt.
Be working.
All right.
So as in the case of a GPA, we immediately find an interrupt Aida unique interrupt that we specify
when we utilize du Gascony.
Right?
So in such case, whenever you are working within this block, OK, and you do not find any information.
So a new finding if you just go to an OK line, you have one more experimenter.
Hello, friends, I did the experiment during the school B. So if you just go in there.
So there you will be finding all the information related to the piece, right?
So here you would see the inject ideas that we required when we utilized to connect.
OK, and here you have you timeline to similarly, UTC into pages are also here.
OK.
Washed off the UPC is deep.
Yes, is also there.
They tend to run until so any information you wouldn't be able to find in the next parameter guarded
to you just need to go to experiment.
And this could be a store, and this is included in an experiment.
OK, so if you just go ahead and take it and experimented on that, you'll be finding this is included
in it.
Once we generate the data for our config structure.
OK.
We will be utilizing it in n cfd initially.
Right here, we'll be passing the instance structure, config structure.
And you said one more thing that we'll be doing is just to verify whether initialization is successful
or not.
So whatever this function, return.
We'll just be connecting it to see opportunity later to see if the rating s32 said that we'll be connecting
to a city.
OK, and then we were just verifying their statuses existing.
Success, if that is the case, will just be utilizing massive brain printer to specify that timer and
that success.
OK.
Else we just be biding.
Timer in.
Right.
This makes sense.
So this is an entire logic that we need to perform, OK, to initially take time.
Right?
The next initialization process is to initialize a general into a controller, right?
So to find out all the function, you have gassy, dark, right.
So here we have a structure.
First one is this config structure and then we have a.
So we just go there and we'll be declaring the config structure for you as well as an instance.
Right.
So perfect structure of Guinness 2.0 and name.
Yeah, if you create an independent function, we will be initiating RJC to first step is to use a lookup
party where we'll be passing our Jack device.
Again, this could be easily found or Chromecast parameter dot edge.
OK, and then we will be utilizing CFG initialize where we send instance structure.
The config structure and CPU researchers again will just be checking whether a pretense exists.
So here also will be clearing status.
OK.
And then this should be close to state state.
And then we'll just be verifying whether the GC images success rate.
The message that we'll be sending is GC and it successful.
Are you guys see?
And it feels right.
So these are the two mandatory step that we perform and this represent us step, right?
So we will be initialized, not benefited.
So very fitting awesome guesses as you timer.
And we'll also be initializing you guys.
Right?
So this completes step one.
The next step is to specify all the option related to the entropy controller, right?
So step before us is to enable an exception.
OK, so to do that, we first need to need an exception.
Then we need to identify the type of an OK by utilizing exception register handler.
OK, and then we need to enable it.
So if you just go ahead, the first function that we are calling by default is in select ception and
then in and register handler.
First thing that we need to specify is the type of an intro, which in this case is also an right.
So if you just go ahead.
So in a ZIL exception that h OK, we'll be finding, we have had unique ID for an eye.
So this will just be a single here, right?
So this is the first argument that we have then the next argument is an intro time to the right so far.
OK, yes, it will be a master handler that we have in NJEA.
So we'll just be going into C and there you have in my student comp. So this will just be adding as
a second argument with the typecasting exception.
Right?
And the last thing that we required is to specify, is it Gaussians?
So, OK.
So for us, it is saying this completes the step to where we are string the type of an intro.
OK.
And then we need to enable our exception.
Right.
So these are the three steps that we perform in step three, right?
Then the Step C is where we specify the intercept handler, OK, we will be enabling entropy, so we
need to enable an input from a paper.
OK.
And this you'll be finding an end to hated file, and we also need to output an intro from a value.
So this usually will be finding a net benefit of specific time.
So if you just go away first, we utilized GSU Connect.
Now here we need to first specify an end entropy instance, which is.
III, OK?
The second thing that we have is if you just go to F3, right?
So first, we need to specify instance, then the unique IED, right, so interrupted.
And that you will be finding when we go to experimentar and the school.
Yes.
So there you have an unique interrupted I.D., our timer.
So we just need to copy this and we need to add a it here.
Right.
So once you specify next is to specify an inch insofar as an interim time, there is timer handler,
right?
So that is what we specified along with the typecasting, right?
And the last thing is whether you want any data callback reference, this could be set at zero.
OK, if you do not want any or it could also be specified as a timer, so you'll be getting the data
related to a time, right?
So as we specify the interrupt handler, as well as a unique in jeopardy, the next step is to enable
and interrupt input.
You are right, and that could be done by utilizing enable function.
Then here we just need to specify and in chip instance and unique timer interrupt.
Right.
So this could be added here.
The next step that we have is to now we have enabled the input to AIG.
Now we also need to enable an output from the benefit and so that they could send an interest to AIG
and this could be found out from the diamond specification applied to for us, the diamond specific
idea probabilities.
See you guys.
OK, so here you'll be finding you have and function to enable.
So let me just look for the functions which are available for enabling an instructor.
If you just go to a timer driver.
OK, so here you have an option to enable an interest, OK, so just look forward whether we also have
anything related to a global interest rate.
So if you just go ahead.
So we do not have anything as global interest rate.
So if that is the case, you just need to then add this enable and that is what we are doing over here.
So if you just look for an interest in it.
So here we are utilizing and issue timer enable interest rate.
So this will enable an output from our favorite and this enable will enable an input to it.
So these are the two security check that we have between the source and destination of.
Right.
So these are all the managers need to perform.
The last thing that we need to do is to specify what you going to do when you have an interest rate.
So first thing that we do is to disable an interest rate.
So dysfunction you will be finding when you look at do the get paid off, the specific basis.
So you have an.
Enabling it to function, you also have a discipline to function, right, so you have a discipline
to function.
Then we will be moving ahead and we'll be checking whether timer is really expired, right?
So when time where you just do zero, we have an intro.
So here we'll just be checking with the timer is really expired.
So that will also be a two way check.
And once that is the case, will just be displaying that we have an interrupt.
OK.
And along with this, what are we gonna do is we will be clearing up the interview, you know, so clear
into this is the function that we utilize for that.
And then we are again enabling an intro, right?
So these are the series of steps, and these are very similar to what we do in and UPI.
All right.
Now will go ahead to our main program, so any platform is used to initialize you, are they then we
initializing hour timer.
This is used to initialize our JIC.
OK, so let's assume we want a delay of one second.
So we'll just be loading our timer to the value of three three three miga today because we know that
our esut timer operates at half of the frequency that is.
Half of six, seven, and that is 3:30 p.m. to me right here, what we do is listen to you.
We enable an hour to return.
So in that case, what will happen is as soon as our counter reaches to zero, this will automatically
initialize our counter back to the value that we specify.
That is thirty three meters.
So in that case, we will be continuously getting high unemployment rate.
So as soon as we reach to a zero will again be initializing to three thirty three meters and then will
be continuously getting an inch or in an interval of one second.
And then we just need to start our application, right?
So let's just go ahead and test this application.
Since we are utilizing an interview, we do not need to do anything.
We are just tweaking by utilizing a view, right?
So we are loading our timer.
OK, well, loading our timer with the value, depending on the delay that we want.
OK, then here we enable an hour to reload.
Now this will allow us to reload our timer as soon as it reaches to zero.
OK, and then we are starting our time so desired the operation specific setting that we are doing right
and then we are simply waiting.
So let me just go ahead and try to program on SPG.
So once programming is successful, will go away and will try to personally just disconnect our computer
and try to connect it back to respect your great religious school and try to really launch on hardware.
Now, if you see and if you do see that we have an interest at an interval of one ticket right now,
the reason we do that, this value.
OK, and as soon as it reaches to zero, we'll give you have an intro and then since we enable it all
to return more.
So counter will be automatically initialized to this right now if you just try to disable desire to
reload mode.
OK, ready, just try to disable one or two reload mode will not be finding that we will need the interrupt
continuously at an interval that we specify, right?
So if we just try to relaunch the session, OK, and if we just try this again.
OK, so let me just again try to perform an execution of a code.
OK, so we have disable an auto reload.
What will happen is this will only create a single update.
After that, we won't be finding anymore.
So we have a timer in Texas, but we have seen it successful and then we have a single in Japan after
that, since we have not included our timer.
OK, we won't be able to find out any further interest rate now.
This could be handled in second.
So if you are disabling an auto mode, so once you come out of fire and you just restart your time.
Right.
So what this will do is.
Now, this will again lower the symbol that you one.
OK, so for example, here we loaded our timer with 333 megahertz when we call restart timer.
So this will automatically lower the counter to that value.
OK.
It will again restart our time.
OK, and this could be verified by just seeing all the modification and performing the execution.
Right now, you could see we have an intro and then we again will see a repetition of an inch up with
this rate.
They call it the proceed with, then enabling an hour to reload more.
So there you do not need to use this restart timer function because that will automatically reload our
timer.
But if you are sticking to disabling inauguration mode, and that is when you come out of it and just
restart your time, so that will again be working in a similar fashion, right?
So this is how you utilize the entropy, then you type.