WEBVTT

00:00.060 --> 00:04.790
So let's try to consider different scenarios by which you can apply stimulus.

00:05.250 --> 00:10.930
So first we'll understand how we can generate false constant like stimulus.

00:11.370 --> 00:15.090
OK, and then we'll understand how we can generate a clock like stimulus.

00:15.140 --> 00:16.350
OK, so.

00:17.940 --> 00:23.550
If you have decided that you do not want to use a process, OK, so we will understand how we generate

00:23.550 --> 00:26.880
a false conscience like stimuli without using a process.

00:27.170 --> 00:28.170
So you just go ahead.

00:28.560 --> 00:33.180
Is one of your signal for an input?

00:33.840 --> 00:35.600
B is also an off your signal.

00:35.610 --> 00:38.160
OK, so far this two signals.

00:38.160 --> 00:41.760
You want to generate a stimulus that is a dummy to be close to.

00:43.330 --> 00:44.980
Zero one zero.

00:45.310 --> 00:45.750
OK.

00:47.020 --> 00:54.820
And then what you can do is, OK, this is how you generate a single stimulus.

00:54.940 --> 00:56.590
OK, so one, one, one.

00:57.370 --> 00:59.590
OK, so this is how you generate a single stimulus.

00:59.770 --> 01:04.850
Now, if you want to do the multiple stimulus, so they must be separated by some time.

01:05.970 --> 01:10.850
OK, so what we do is let us assume that we have already initialized and B to A zero.

01:10.870 --> 01:13.900
So we want this value for 10 nanoseconds.

01:14.050 --> 01:16.770
So this value should be foo's after 10 nanoseconds.

01:16.780 --> 01:26.550
So we just need to include after ten, nine years and we will automatically force E to Seeto one one

01:26.560 --> 01:33.630
zero after then a second, then we will be full single digits in one zero one zero after 29.

01:34.960 --> 01:42.510
OK, so what will happen is that from zero to 10 nanosecond you have all zero from 10 to 20.

01:42.520 --> 01:50.040
You have this one zero one one zero and then from 20 to 30 we will have this value.

01:50.050 --> 01:52.500
So we will change our value at thirty nine.

01:53.050 --> 01:59.100
So we'll just make it as zero one one one zero zero after thirty nine.

01:59.590 --> 02:05.170
OK, so this is what we want and we also will do to stimulate like this.

02:05.180 --> 02:09.450
So 10 nanosecond we have this value that is all one.

02:09.460 --> 02:14.840
Then we have to do one one zero after twenty nine the second.

02:15.030 --> 02:22.300
OK, and finally we have one zero zero zero after thirty nine second.

02:22.480 --> 02:29.020
OK, so we know this thing when we are generating a different stimulus, we are using comma to separate

02:29.200 --> 02:32.670
different stimulus and after work it out.

02:33.120 --> 02:33.220
OK.

02:33.300 --> 02:36.280
So this is how you generate a full scale like.

02:37.900 --> 02:41.020
Stimulus without using a process.

02:41.050 --> 02:41.270
OK.

02:41.320 --> 02:44.390
So what we'll do is we'll just see whether this could work.

02:44.430 --> 02:49.660
So we'll go ahead inside of while and we'll just perform behavioral simulation.

02:49.840 --> 02:50.150
OK.

02:50.170 --> 02:56.050
So if everything goes fine, you'll be automatically seeing all the stimulus we generated for a year

02:56.340 --> 02:58.980
and we can then compare it with an output.

02:59.030 --> 03:02.490
OK, remember that duty consists of an operator.

03:02.800 --> 03:04.930
So we are expecting the result of.

03:04.930 --> 03:05.630
All right.

03:06.460 --> 03:08.590
So here you'll be observing some.

03:11.500 --> 03:13.000
Series of stimulus.

03:13.040 --> 03:19.420
OK, so what we'll do is we'll just try to tease the relics to a binary so that it becomes very easy

03:19.420 --> 03:21.160
to manipulate tourism to right.

03:21.160 --> 03:26.620
Click on and before then, you'll be finding relics just to find it.

03:27.100 --> 03:34.390
Similarly, you will be changing the meta binary and the result will also be changed to and by now you

03:34.390 --> 03:41.890
can just do it and it'll be noticing when we have zero, the result of it at zero when we have zero

03:41.890 --> 03:44.770
one one zero and one one one one.

03:45.010 --> 03:50.890
So in that case, if you are, this two will get all you can, in fact, observe the value over here.

03:50.920 --> 03:53.230
So here also you see the object.

03:53.740 --> 03:57.650
You just need to place a marker so that will represent your type.

03:58.180 --> 04:00.400
OK, or at the macro position.

04:00.400 --> 04:03.530
And you also be able to see the values over here, OK?

04:03.580 --> 04:06.790
In fact, you'll be finding that if you just click on an edge.

04:06.910 --> 04:10.930
So here from zero to 10 nanoseconds, you have zero.

04:11.290 --> 04:14.910
Then from twenty ten to twenty, we have the next stimuli.

04:14.920 --> 04:18.030
Similarly, from 20 to 30, we have a next similar.

04:18.280 --> 04:21.580
And from 13 the onwards we have our finest tool.

04:21.680 --> 04:25.120
OK, so here you successfully able to generate the stimulus.

04:25.150 --> 04:29.680
Now we'll just work and we'll try to understand how we can be helpful.

04:29.710 --> 04:31.270
Swanstrom with.

04:32.310 --> 04:41.280
The use of a process, right, so we'll just proceed now what we'll do is we'll just keep this.

04:42.460 --> 04:49.720
As it is inside of you, you'll also get the help if you do not understand a good leader.

04:49.750 --> 04:53.010
OK, now we'll proceed with the process, OK?

04:53.050 --> 04:57.610
And here we are doing that process to not have any sensitivity.

04:57.670 --> 05:02.170
Let's remember that whenever process do not have any sensitivity.

05:02.370 --> 05:05.410
So this is enough to hide your simulator.

05:05.770 --> 05:13.930
OK, so first thing, when you write the process is to Alawite students who want to Alawite statement

05:14.720 --> 05:17.000
will be immediately finding that one needs to go.

05:17.060 --> 05:25.090
And so if I just remove the filing process will issue an error that is a chosen warning that we have

05:25.090 --> 05:26.470
a possible infinite loop.

05:26.470 --> 05:31.490
And this will seriously divide the simulator if you do not Alawites.

05:31.900 --> 05:38.080
OK, so when you have decided that we would be proceeding with the process statement for generating

05:38.080 --> 05:44.860
a false concern like stimuli, the first thing that you should always do is after you write the forces,

05:44.860 --> 05:50.620
OK, and then process just before any process.

05:50.690 --> 05:54.560
I try to see it later on when you can do to stimulate.

05:55.030 --> 06:01.660
You will be forgetting right now, really try to generate the steam civil right so E will be the tool.

06:01.780 --> 06:05.380
This is the first rally that we've used to zero one one zero.

06:07.000 --> 06:09.820
And then we will be close to.

06:11.260 --> 06:12.730
One zero one zero.

06:13.330 --> 06:16.210
These are the two stimuli that we have.

06:16.650 --> 06:22.900
OK, and this was after 10 nanoseconds for our first 10 nanoseconds, we have value of seat.

06:23.190 --> 06:30.660
OK, so to create a time delays in the second method that we are using, a process we stick with.

06:30.960 --> 06:33.690
We wait for ten, nine the second.

06:34.510 --> 06:38.260
So this stimulus will be generated after 10 nanoseconds.

06:38.260 --> 06:41.700
OK, and then we can again wait for 10 nanosecond.

06:41.890 --> 06:48.910
We can then fool sat next to the next value that we want is one zero one zero.

06:49.450 --> 06:52.630
OK, similarly for Obi we wish to have.

06:53.530 --> 06:57.430
Zero one zero or one two, right?

06:57.910 --> 07:03.540
And then again, we'll just wait for 10 nanoseconds, then we will be conducting our final stimulus,

07:03.700 --> 07:06.470
OK, which is zero one zero zero.

07:06.880 --> 07:10.460
OK, and we need to be close to one zero zero.

07:10.530 --> 07:14.230
See that since it is a multiple.

07:14.260 --> 07:15.360
Well, OK.

07:15.360 --> 07:21.590
And then we already have our data bit stupid so we can skip adding.

07:21.610 --> 07:23.860
Wait for the signal if you wish you can.

07:23.860 --> 07:25.230
Just out of eight 14.

07:25.810 --> 07:26.080
Right.

07:26.440 --> 07:33.730
So this is how you use the process if you want to generate a false question like stimulus, OK, and

07:33.730 --> 07:37.510
then you generate a stimulus for A and B and then you use A it.

07:37.930 --> 07:41.850
So if you do not want to use the process, you need to use a common after.

07:42.400 --> 07:47.120
Whereas if you want to stick around with the process, then you need to use a veto.

07:47.920 --> 07:54.310
So let me just see you go and try to relaunch the simulation and see if this code works in a similar

07:54.310 --> 07:54.730
fashion.

07:54.760 --> 07:58.070
OK, so here we have a change in input and proposal.

07:58.150 --> 08:04.690
Instead of going to run simulation and performing a behavioral simulation, we can just click on Reland

08:04.700 --> 08:07.690
Simulation until unless you do not change your.

08:08.920 --> 08:13.060
We can use a relaunched simulation to refresh our simulation.

08:15.740 --> 08:21.590
Now, if I just go to an untold and we will be observing the reform at the beginning, and if I just

08:21.590 --> 08:26.880
try to zoom in, you'll be finding for both zero, we have zero to 10 nanoseconds.

08:27.260 --> 08:32.690
Then the next tumulus is still 29, 30 and so on and so forth.

08:33.380 --> 08:34.700
And it'll be finding that.

08:34.700 --> 08:41.690
The researchers also see that is if you just performing or in between these two will be finding we have

08:41.690 --> 08:43.670
one one, one seed and so on.

08:43.670 --> 08:44.080
And so.

08:45.760 --> 08:52.430
So those are the two matters that can be used to generate a false constant like stimulus.

08:52.790 --> 08:53.190
OK.

08:54.500 --> 09:01.010
So you can either proceed to generate a Cibolo without using a process where you will be using an officer

09:01.610 --> 09:05.360
and then you use a comma to distinguish between the different process.

09:05.600 --> 09:11.480
OK, with a different time period, or you can use a process where you can pass a different stimuli

09:11.480 --> 09:12.620
and then you can use it.

09:13.400 --> 09:19.220
Right now you have at least a fundamental understanding how we use a false constant to generate a stimulus.

09:19.250 --> 09:25.370
Now, what will target is we'll try to understand how we can do the full scale stimulus.
