WEBVTT

00:00.150 --> 00:05.820
Let us try to implement a circular shifter, right, so it consists of a six foot site that will be

00:05.820 --> 00:11.480
a size of input data as well as an output shifter atlas deep machine.

00:11.700 --> 00:15.270
So adding this speed machine greatly simplifies the entire operation.

00:15.310 --> 00:22.410
OK, so whenever you have a complex expression, see that you try to incorporate the state machine,

00:22.410 --> 00:27.000
and that usually reduces the effort that we spend to design our control, Patrick.

00:27.480 --> 00:31.100
So let us just try to understand an entire flow of our system, right?

00:31.110 --> 00:36.930
So first thing that you'll be doing it, so we will be accepting the new input from the user, right?

00:37.140 --> 00:40.900
So that will be added to which user want to shift right here.

00:40.920 --> 00:48.030
One more thing that we'll be doing is, along with the data, will also be taking the shift conditions

00:48.180 --> 00:50.160
as an input from a user vessel.

00:50.160 --> 00:57.540
So here we design our shift register predominantly to shift in a right position as we progress further.

00:57.870 --> 01:03.350
OK, and as you saw your assignment, you will be developing a system that could chip in both the dedication

01:03.600 --> 01:04.930
to the right as well as well.

01:05.040 --> 01:10.320
So first, we'll just be going through a basic skeleton, so that will give us an idea of how you build

01:10.320 --> 01:10.830
the shifter.

01:10.980 --> 01:15.150
And then in an assignment, you could tackle a complex shift, right?

01:15.660 --> 01:17.710
So the first need is loading.

01:18.120 --> 01:20.080
So here we will be doing two things.

01:20.100 --> 01:25.980
First, the data, the input data that you want to shift and the number of the position that you want

01:25.980 --> 01:26.240
to share.

01:26.490 --> 01:30.510
So these are the two inputs that we will be taking from a user.

01:30.760 --> 01:36.330
So if you analyze a visual code right to be represent represented six fitting right in the direction

01:36.330 --> 01:36.810
as input.

01:37.200 --> 01:41.310
Again, to type a standard underscore logic underscore vector and the site is six.

01:41.500 --> 01:41.730
Great.

01:41.740 --> 01:43.050
So this will be an input data.

01:43.290 --> 01:50.460
And if you analyze the result of shifting operation so that we'll again have the same size that is five

01:50.460 --> 01:53.040
down to zero and the direction will only be an hour.

01:53.550 --> 01:59.470
Along with this, the second data that we are expecting from a user is the number of position that we

01:59.470 --> 02:00.480
are going to shift, right?

02:00.690 --> 02:06.850
So we will allow the maximum seven shift to be specified at an instance.

02:06.870 --> 02:07.170
OK.

02:07.380 --> 02:11.010
Hence, we declared the shift size to be two down to Z.

02:11.180 --> 02:11.300
Right.

02:11.310 --> 02:15.680
So this is capable of handling a maximum seven back position right now.

02:15.690 --> 02:20.340
You could actually increase the ship audition space as per your requirement.

02:20.620 --> 02:27.110
So as soon as we have as soon as we exactly know the data input, which we want to shift and the big

02:27.120 --> 02:34.800
positions which we want to ship, right, we proceed and check whether this system is able to perform

02:34.800 --> 02:35.730
the required shift.

02:35.820 --> 02:36.150
OK.

02:36.250 --> 02:43.620
So we have a counter variable that keep a track of number of shift positions that that keeps the track

02:43.620 --> 02:46.530
of the number of shift position we currently.

02:47.810 --> 02:49.880
Perform on any good detail, right?

02:50.120 --> 02:56.630
So if our count is not equal to the number of coalition that you have requested, in that case, we

02:56.630 --> 02:59.290
will be again performing a shifting operation, right?

02:59.300 --> 03:02.360
So we will be waiting here again before my shift, OK?

03:02.660 --> 03:08.240
As soon as the count becomes equal to number of shift position, OK, in that case, we look to achieve

03:08.450 --> 03:10.790
the user's specific shift position, right?

03:10.790 --> 03:14.420
So once that is done, we will be jumping into a new stage.

03:14.420 --> 03:20.990
So here what we're going to do is we will be verifying whether we have new data that users want to perform

03:20.990 --> 03:21.650
a shift, right?

03:21.980 --> 03:27.770
So if we do not have any new data, so our system will be simply in an ideal waiting in this specific

03:27.770 --> 03:28.300
stage, right?

03:28.580 --> 03:34.940
So we will clearly see if we do not have a new leader, we will be simply waiting over here as we will

03:34.940 --> 03:40.940
be simply jumping back to our speed one which will allow us to load the new input data, right?

03:40.950 --> 03:44.150
So this is the simple machine that we have for our system.

03:44.520 --> 03:48.770
OK, and if you analyze the rest of the code, so we have a clock which is synchronized in signal.

03:49.010 --> 03:54.440
We also have a pin, which could be used to specify that the user have a new data on right.

03:54.800 --> 04:00.230
So if you do not have a new data, it will be simply zero if you have a valid new data.

04:00.500 --> 04:01.730
It will be equal to what?

04:02.540 --> 04:02.840
OK.

04:03.110 --> 04:06.230
So these are the series of proofs that are present in our system.

04:06.230 --> 04:07.970
So be to present our input data.

04:08.240 --> 04:13.370
Why replace who now could data after shift operation shift represent the number of bitcoin?

04:13.370 --> 04:14.540
You should use a want to shift.

04:14.630 --> 04:14.960
OK.

04:15.290 --> 04:18.500
Here we predominantly are developing the right shift.

04:18.690 --> 04:24.020
OK, so as we progress further the silent assignment there, you will be understanding how we could

04:24.020 --> 04:28.940
build a system that is capable of handling both right as well as left or right.

04:29.450 --> 04:30.920
So we proceed with an architecture.

04:31.100 --> 04:36.560
Now first, we declared a counter variable rate, so this will be keeping a track of a number of position

04:36.560 --> 04:38.120
we have shifted right now.

04:38.120 --> 04:43.700
We know that the maximum shift that we could have is seven rate, so this variable should be capable

04:43.700 --> 04:48.220
of handling at least seven who use the value of seven.

04:48.460 --> 04:54.230
So we will be declaring declaring a count variable, which will be of integer type, and it should be

04:54.230 --> 04:56.960
capable of handling a maximum seven.

04:57.350 --> 05:02.240
OK, so we declare the range to be from zero to eight and we also initialize to a zero rate.

05:02.750 --> 05:07.820
So all the shifting operation will be performed on a temporary data and then at the end we will be connecting

05:08.000 --> 05:09.620
the temporary data.

05:10.580 --> 05:17.240
So we declare a signal and temp, which is which will serve as a temporary register for us and that

05:17.240 --> 05:18.800
again have a size of six.

05:19.190 --> 05:24.650
So which is exactly equivalent to the size that we have for right now whenever you have a state machine?

05:25.460 --> 05:25.740
OK.

05:26.000 --> 05:32.780
The good idea instead of looking that instead of working on zero or one is to create our own.

05:34.500 --> 05:34.730
I.

05:35.320 --> 05:37.360
That could be used to hold the value of steel.

05:37.390 --> 05:37.630
Right.

05:37.870 --> 05:40.070
So RF isn't going to stop it.

05:40.120 --> 05:44.380
So how you declare a user defined Dieter Typekit, you start with the type.

05:44.690 --> 05:47.920
OK, so this will be working at this date.

05:47.920 --> 05:51.340
So we need this Typekit steel tape and is OK.

05:51.580 --> 05:57.070
Then you need to add apprentices and then you specify the data that you want to have for this database.

05:57.070 --> 05:58.660
So we want to have a three step.

05:58.960 --> 06:02.350
So we would have a law shift and the new data.

06:02.350 --> 06:04.900
These are the three states which are pattern right now.

06:04.900 --> 06:10.630
Depending on the velocity we'll get, different encoding style could be utilized to encode our state.

06:10.910 --> 06:16.550
It could be a binary encoding green coding one, hot and cooling and so on and so forth.

06:17.200 --> 06:19.240
Now, as soon as we declared our fate.

06:19.420 --> 06:19.680
Right.

06:19.700 --> 06:23.310
So the next step is to declare a signal that is working on this day.

06:23.560 --> 06:28.620
So we start with the Signal Studio, the variable that we'll be working on this state Typekit.

06:28.630 --> 06:33.760
And we initialize this to a lawsuit which will represent our first when we start out of the.
