WEBVTT

00:00.150 --> 00:03.770
So let us try to understand the downgrades by we shall.

00:04.230 --> 00:09.480
OK, so the Dow basically is what is the.

00:10.660 --> 00:17.560
Significance of this syntax that we have utilized in this speech and then that it did exist, any other

00:17.560 --> 00:19.740
approach for achieving the same result?

00:19.870 --> 00:20.100
Right.

00:21.280 --> 00:29.110
So this is regarding the overlapping sequence that we have implemented and then we have also written

00:29.110 --> 00:35.650
the first, what we'll do is we'll try to understand the syntax that we have used in an.

00:36.630 --> 00:43.020
The tests that are posted long and then will later understand what other alternatives that we have at

00:43.020 --> 00:49.910
the site, so our agenda is basically to send a random signal to the D and poor that we have.

00:49.920 --> 00:50.170
Right.

00:50.370 --> 00:52.110
So if you just go through the.

00:54.280 --> 00:56.640
Good, OK, so what we are doing is.

01:00.090 --> 01:03.750
So here we have our top model, which we are testing.

01:03.780 --> 01:10.650
OK, so this is designed to test all the inputs are declared with the signal giver and then they are

01:10.650 --> 01:16.530
initialized to see, whereas our output are also declared with the signal, but they are not initially.

01:16.560 --> 01:18.600
So this is the first thing that are doing.

01:19.050 --> 01:25.740
And then to send a random values to the dean, what we are doing is we have declared one vector.

01:25.800 --> 01:27.630
OK, so multiverse signal.

01:27.630 --> 01:30.120
We have Bechler, which is having the size of it.

01:30.120 --> 01:32.670
But and then our plan is to send.

01:34.480 --> 01:40.090
Each bullet entered from an this is what we are doing is Bloxwich, what we are doing is we are sending

01:40.090 --> 01:40.460
in this.

01:40.500 --> 01:42.070
We hope we are achieving that.

01:42.340 --> 01:49.150
They just trying to understand, OK, so if you just analyze the processes and to do to what this means

01:49.150 --> 01:54.900
with each new clock, we will be updating or evaluating on our particular issue.

01:54.950 --> 02:01.150
OK, so in this case, as soon as our clock changes, you will be noticing what we are doing is we are

02:01.150 --> 02:07.170
checking the edge of a clock and if we have a positive clock, we are checking whether other counties

02:07.330 --> 02:10.120
less than so considered the first iteration.

02:10.150 --> 02:13.870
So here we have declared a signal and we have initialize.

02:13.870 --> 02:14.890
It was right.

02:14.920 --> 02:17.650
So for a first count will have a value of the.

02:18.740 --> 02:25.790
Bogus account will have a value of zero, and since it is less than eight, so we will be executing

02:25.790 --> 02:27.510
the expression that are written inside.

02:27.530 --> 02:29.990
And if so, in this case, Dean.

02:31.080 --> 02:35.810
No, being a single bitrate, so Dean will be close to OK, so 10.

02:37.130 --> 02:40.070
And then since I don't have a value zero, it will be.

02:41.210 --> 02:50.540
Dempsey and if you see we have a best multiple attractive, so this value is zero, the next is one.

02:51.610 --> 02:54.950
Two and so on, up to seven, we have that right.

02:55.240 --> 03:02.380
So when we say Dean equals to 10, 10, zero to that basically means Dean will be equal to Seydou from

03:02.380 --> 03:02.620
here.

03:02.840 --> 03:03.100
Right?

03:03.520 --> 03:04.370
This makes sense.

03:04.780 --> 03:06.280
It will be close to 130.

03:07.320 --> 03:13.560
So it will be equal to one, since our victory this week will consist of one, right?

03:13.740 --> 03:18.130
And then we are increment incrementing the chondrite, so we are incrementing the count.

03:18.150 --> 03:24.660
So after we complete our first cycle, count will now be equal to.

03:28.370 --> 03:35.790
One, right, so in the next cycle, what will happen is, again, it is less than eight days and will

03:35.790 --> 03:37.730
now be close to them.

03:39.190 --> 03:40.090
We'll get them.

03:42.290 --> 03:48.290
So in this case, 10 basically means the next speed that we have in invective, so that is.

03:49.580 --> 03:57.080
So we'll be sending being equal to zero on our boat and then on that clock count will be.

03:57.530 --> 04:00.110
So this is we are for sending.

04:00.140 --> 04:07.550
So this is the way that we have utilized to send this aid one after another to the dean signal that

04:07.550 --> 04:08.200
we have declared.

04:08.240 --> 04:08.510
Right.

04:08.840 --> 04:16.370
And once it reaches to and know, since our camp is having a max size of about it, we cannot have any

04:16.370 --> 04:18.290
value or it will simply be an undefined.

04:18.300 --> 04:20.450
So we are making contact.

04:20.480 --> 04:21.260
Any questions?

04:21.470 --> 04:28.750
So if you just run, this school will be finding this signal, the aid that we have stored inside it,

04:28.750 --> 04:32.840
and we'll take it again and again and be able to see a light signal.

04:32.870 --> 04:36.480
OK, so let's just go ahead and try to perform a simulation.

04:36.500 --> 04:36.750
Right.

04:37.010 --> 04:44.300
So if I just set this as a talk, OK, and if I try to perform a simulation, so we'll be noticing that

04:44.300 --> 04:46.370
the Dean values continuously changing.

04:46.430 --> 04:52.880
OK, this is basically due to the fact that we are as soon as we lose to Mexico and we are making count

04:52.880 --> 04:56.110
to be close to zero and then we will see it.

04:56.380 --> 04:58.420
So this is the first wave that we have utilized.

04:58.470 --> 05:04.360
OK, well, what we are doing is we have a vector or multiple segment, OK?

05:04.640 --> 05:07.820
And then utilizing acounter variable.

05:07.880 --> 05:15.200
OK, so we are utilizing acounter variable and then we are sending a single value.

05:16.910 --> 05:17.600
From.

05:18.970 --> 05:19.600
Victor.

05:21.910 --> 05:28.180
OK, so this is a matter that we have, you know, in fact, in some of the scenarios, you can actually

05:28.180 --> 05:31.090
replace this vector with the files.

05:31.600 --> 05:37.080
So you have a file where you have a data and then you read the letter from a fight and then you send

05:37.300 --> 05:40.360
one by one the big data to the signal.

05:40.810 --> 05:42.540
So this is the method that we have utilized.

05:42.580 --> 05:45.550
OK, so let us try to solve the other question.

05:45.550 --> 05:51.470
That is whether there is any other approach that can be made to achieve the same result.

05:51.560 --> 05:53.390
OK, yes, they do exist.

05:53.430 --> 05:55.510
Another approach will be understanding them.

05:56.080 --> 06:04.030
OK, so other approach would be that if you do not want to have multiple signals like this, you can

06:04.030 --> 06:04.810
man you are.

06:06.070 --> 06:08.830
So if you do not want to generate.

06:10.110 --> 06:15.030
The signal automatically considering a vector, you can generate the manual.

06:15.420 --> 06:16.940
Well, we do that now.

06:17.460 --> 06:22.860
Then once we declare the signal, if you remember it is already been initialized to correct.

06:23.070 --> 06:30.060
So when we declare anything as an input like this signal did standard and the school logic.

06:30.420 --> 06:32.990
So we are initializing it to zero here.

06:33.300 --> 06:33.570
Right.

06:33.590 --> 06:36.730
So how we can do the manual stimulus is simple.

06:36.750 --> 06:43.050
So let us assume that the zero we want to have for 10 nanoseconds and then we want to make it one.

06:43.080 --> 06:50.720
So what we'll be doing is we will be making the nickless to and just before we have a next clock cycle,

06:50.730 --> 06:58.800
that is we know that since the clock stimulus that we have utilized inside our test bench is having

06:58.800 --> 07:02.250
a period of 10 nanosecond and that you can verify it right from here.

07:03.090 --> 07:09.600
So you'll be finding that we are waiting for five nanoseconds and then we are making it so the it and

07:09.600 --> 07:09.770
then.

07:10.830 --> 07:18.790
So just before you have your next positive, which you try to apply the full value to the right.

07:19.020 --> 07:20.150
So that is what we are doing.

07:20.160 --> 07:23.980
So we know that the period of our clock will be a nanosecond.

07:24.240 --> 07:27.800
So on the night nanosecond we are making being to be close to.

07:27.810 --> 07:32.080
Similarly, the next block will appear at 20 nanoseconds.

07:32.280 --> 07:37.650
So just before the next block is that is at 19 nanosecond, we are making it.

07:38.040 --> 07:45.360
Similarly will be finding we want to basically generate one zero one zero one zero one.

07:45.600 --> 07:45.850
Right.

07:46.110 --> 07:49.220
And this you can make sure from zero to right.

07:49.380 --> 07:51.050
So we are going like this.

07:51.060 --> 07:53.550
We are going from right to left to.

07:54.500 --> 07:57.470
We are basically sending first one, then zero.

07:57.530 --> 08:00.200
Then again, one, then zero, then again one.

08:00.200 --> 08:00.890
Then zero.

08:01.040 --> 08:01.710
One zero.

08:01.710 --> 08:01.910
Right.

08:01.930 --> 08:03.920
So this is the combination that we want to say.

08:04.760 --> 08:08.660
So here what we are doing is we know that the initial value zero.

08:09.410 --> 08:11.230
So we have say No.

08:11.240 --> 08:12.900
One, then zero.

08:13.340 --> 08:14.840
Then again, when?

08:14.840 --> 08:18.360
Then again, zero one zero one zero and so on.

08:18.360 --> 08:18.680
And so.

08:18.780 --> 08:19.070
Right.

08:19.370 --> 08:23.330
So this is an alternate with the second approach that you can utilize.

08:23.340 --> 08:30.230
What we are doing here is we are changing or forcefully applying the stimulus to a deed of a single

08:30.230 --> 08:31.740
bank just before.

08:32.420 --> 08:36.650
That is one second one nanosecond prior to our clock rate.

08:36.890 --> 08:40.080
So for a first lifecycle period will be 10 nanoseconds.

08:40.130 --> 08:43.790
So we are applying a dean at nine nine.

08:44.150 --> 08:44.460
Right.

08:44.870 --> 08:48.020
And then next block, which of which will appear at 20.

08:48.050 --> 08:50.540
So we are applying it 90 nanoseconds, then.

08:50.540 --> 08:51.330
Twenty nine nine.

08:51.680 --> 08:53.590
Thirty nine, forty nine and so on and forth.

08:53.610 --> 08:59.270
And stimulus remains, that is one zero one zero one.

08:59.300 --> 09:03.220
And then again, you can apply more stimulus if required.

09:03.590 --> 09:05.300
So if you just go to and we value.

09:05.510 --> 09:08.910
OK, so I have already created a testament to let us first understand.

09:09.650 --> 09:12.590
So this is exactly what we are doing in the previous two.

09:12.820 --> 09:18.410
OK, we are generating the clock off period then and then.

09:18.950 --> 09:21.190
Since then we are directly focusing.

09:21.200 --> 09:26.900
We do not require to have a process so close to one after nine nanoseconds and zero after ninety nanosecond,

09:26.900 --> 09:30.830
second one after twenty nine indeed of the thirty nine nanoseconds.

09:30.830 --> 09:34.360
And finally we are again making it one of the forty nine nine the second rate.

09:34.490 --> 09:41.120
And we are just changing a behavior which is the architecture that we have right now will go ahead and

09:41.150 --> 09:42.460
will perform the simulation.

09:42.470 --> 09:44.680
So first we will said this as it source.

09:47.590 --> 09:51.510
And then again, then we'll be able to simulation.

09:56.450 --> 09:58.400
So now you'll be finding that.

09:59.240 --> 10:06.170
Be able to get the stimuli over here to zero one zero one zero, and then we also are able to get out

10:06.170 --> 10:06.680
as one.

10:06.850 --> 10:09.640
OK, so here we are able to detect the sequence, right?

10:11.280 --> 10:18.150
So this is the second way that you can utilize to generate a stimulus to more visitors.

10:18.170 --> 10:24.660
So, for example, the third way that you will that you the same result is utilizing the clock like

10:24.660 --> 10:25.120
behavior.

10:25.470 --> 10:31.870
So you can call the process OK, and then you can use a dean equals to not of the.

10:31.890 --> 10:37.260
So with each what will happen is with after a period of ten and a second.

10:37.530 --> 10:39.320
So we are waiting for a nanosecond.

10:39.370 --> 10:41.670
So the initial value of the end will be zero.

10:42.030 --> 10:42.560
Right.

10:43.140 --> 10:49.560
So this will be true for a nanosecond and then we are making being equals to not of being so here as

10:49.560 --> 10:51.080
soon as it is then a nanosecond.

10:52.460 --> 10:59.270
We will make DiNicola close to it and this value will continue for 10, right, and then again, after

10:59.270 --> 11:01.120
10 nanoseconds, it will be negative.

11:01.340 --> 11:05.800
So we will again get 10 on the second and then so on and so forth.

11:05.860 --> 11:06.060
Right.

11:07.460 --> 11:13.520
So here we are not getting a random stimulus, but the clock like signals since our state machine or

11:14.220 --> 11:20.910
the sequester dictate that we have implemented required one zero one zero like the signal.

11:20.930 --> 11:22.660
So this can also be utilized.

11:22.670 --> 11:25.350
So this is our third approach that you can utilize.

11:25.700 --> 11:29.960
So if I just show you the simulation, it will also be giving us the same result.

11:29.990 --> 11:34.850
OK, so let me just go ahead and inside that speech to.

11:36.040 --> 11:36.490
OK.

11:38.380 --> 11:41.590
You'll be noticing that if I just comment on this.

11:42.590 --> 11:45.380
OK, we have declared.

11:46.420 --> 11:52.690
This as a third of what we are doing is close to north of me, and then we are waiting for a nanosecond

11:52.690 --> 11:53.640
to match our clock.

11:54.190 --> 11:58.600
So if I just see you out and try to run a behavioral simulation.

12:07.550 --> 12:14.620
So if I just try to fit the viewpoint to the screen, we will be finding the exact same result.

12:14.670 --> 12:18.180
What we are getting with the first night.

12:19.730 --> 12:25.130
The food that you would use to achieve the same thing is, again, applying a manual stimulant.

12:25.220 --> 12:31.210
OK, so here also we have applied a manual stimulant, but here we are not utilized the process.

12:31.220 --> 12:31.540
Right.

12:32.210 --> 12:38.930
So we can also utilize the process and then we can also utilize the process and generate the manual

12:38.930 --> 12:39.990
stimulants like this.

12:40.020 --> 12:45.440
OK, so this this can be considered a condition of an automatic stimulus, right?

12:46.370 --> 12:49.700
This can be considered as generating a manual stimulus.

12:49.970 --> 12:52.750
That is, you are deciding the shape of a vehicle.

12:52.850 --> 12:56.330
So utilizing the process also such things can be achieved.

12:56.720 --> 12:57.260
I'll you.

12:57.260 --> 12:59.520
That is like this.

12:59.540 --> 13:02.560
OK, so we are calling a process, OK.

13:02.990 --> 13:06.800
And then what we are doing is since an initial value of being is zero.

13:08.020 --> 13:13.860
So we are keeping that value for a nanoseconds, so we are calling for a nanosecond, then we are making

13:13.870 --> 13:17.440
being to be close to when we are waiting for a nanosecond.

13:17.770 --> 13:24.160
And then this is how we are generating one zero one zero one zero one zero one and so on.

13:24.430 --> 13:33.910
And then whenever you have a process without a sensitivity list, it is a good idea or you need to add

13:34.000 --> 13:36.120
wait till we find it.

13:36.120 --> 13:39.100
We have already had it before a nanosecond and later.

13:39.160 --> 13:43.060
Do I just want to have a stimuli up to this point?

13:43.060 --> 13:49.410
That is, I only want to have one zero one zero one zero one zero and then continuously see.

13:49.630 --> 13:55.510
OK, so for that reason I have filed every so often this will continue to be having a previous one.

13:55.510 --> 13:59.060
We just see if we want to have a continuously changing value.

13:59.110 --> 14:02.050
Then you can just remove this wait and then you'll be finding again.

14:02.050 --> 14:05.410
This thing will be repeated as soon as we reached the last one.

14:09.830 --> 14:16.550
OK, so let me just go ahead and try to perform a simulation, so if you just go ahead and now if I

14:16.550 --> 14:17.720
just come this out.

14:18.500 --> 14:20.330
And if I uncommented this.

14:28.940 --> 14:29.390
OK.

14:30.260 --> 14:34.080
So here we are generating a manual stimulus inside a process.

14:34.490 --> 14:40.970
So the difference between this method rate, so this method and this method is so here we have not utilized

14:40.970 --> 14:41.630
the process.

14:43.030 --> 14:49.090
And here we are utilizing the process so this, too, can be considered as an alternative to each other

14:49.240 --> 14:56.680
option, dating a manual view from sheep's, whereas if you consider this to this matter, here we are

14:56.680 --> 15:00.160
utilizing a plot to generate an automatic view from ships.

15:01.980 --> 15:05.550
So let's just go ahead and again relaunch a simulation.

15:13.560 --> 15:21.660
So if I just now go to a refund, you'll be finding that if you have a refund stimulus package and after

15:21.660 --> 15:28.350
some time we have to do two operations, we might be able to test every form because we are getting

15:28.740 --> 15:30.450
changes in of signals.

15:30.700 --> 15:34.710
OK, so there are four ways by which you can proceed, right?

15:34.740 --> 15:37.350
So the first phase is clean up.

15:38.380 --> 15:39.280
This thing of it.

15:43.910 --> 15:49.370
OK, so to summarize this question from Beashel, OK, so what are the different ways by which you can

15:49.370 --> 15:56.150
generate a stimulus for investment so you can either have an vector, OK, where you have all the stimuli

15:56.160 --> 16:00.230
that you want to say and then bit by bit you are.

16:01.220 --> 16:03.770
Sending a stimuli to an input.

16:03.800 --> 16:06.120
OK, so this is our first method that we have.

16:06.560 --> 16:11.470
The second method could be that you use manual stimulus.

16:12.450 --> 16:19.570
OK, generated by you and sending it one by one after some period just before your clocks.

16:19.920 --> 16:26.790
OK, so here we are utilizing unofficial keyword and then the simulator sent just before the clocks.

16:27.510 --> 16:30.420
OK, so this can be considered the second way.

16:31.890 --> 16:40.260
The third way could be you can use a process and then you can use the clock like signal to generate

16:40.260 --> 16:43.260
a stimulus for an input what we are doing over here.

16:43.890 --> 16:49.740
So these are purely clock signals and this can actually be utilized to generate a stimulus for.

16:50.270 --> 16:52.320
OK, so this is the food.

16:52.320 --> 16:57.860
We could be that you use a process, OK, and then you send the manual stimulus.

16:57.870 --> 17:03.420
Remember, if you want to continuously have this signal be sent to anyone who want to innovate and you

17:03.420 --> 17:04.160
activate.
