Let us try to understand and implementation of a shifted with the high level description, so that allows
you to play a very prominent role in this process where we want to perform in the rotation or a shifting
operation in the single floor.
So we'll try to implement for a bit battleship, which can perform shift of at least the magnitude of
Tribbett with a single fluxing or that we will understand as we proceed forward with an operation of
multiplexed and battleship.
So let us assume that when we do so, this is a simple case of an mux that we have added and all at
least one night.
So whenever we apply, let us suppose zero zero command at the select line of this two stages.
So we want that shift will happen.
So whatever input we have, that is easy to represent my verbeke to.
It should be the same position that it is again.
So let us assume that this is DESIERTO.
This is my LSP position, so when we apply 090, these two should be transferred as it is to the output.
So to do that, we know that when we apply here.
So all the marks since the selection line of all the marks is tied together, all the 029 will be selected
and applied it right.
So let us assume that this is and B looks OK.
So here we want that to be applied at all.
Right.
So here since we want D zero and at this point what we can simply do is we can simply connect it over
here.
So what this will do is as soon as we apply for the S1 nine, it will have all the zero line selected
and whatever we have connected to zero will be transferred to.
All right.
So we'll be finding these, which is connected to the first input or the first looks of light will be
transferred as it is to the output.
And then since here also we have applied.
So this allows us to transfer from the input of this mix to be zero.
And similarly, we want that when we have zero zero here, we should get Devah right.
So this is the next bit that we want to be having.
And so what we can do is we can when we can do it here.
And since we applied zero and since all the lines are tied together, it is for sure that zero line
of all the marks will be selected.
So we have connected the one over here.
And then if we can connect this to the zero, thing will be getting will be getting different at this.
Similarly, if we can connect this line.
To the zero lane of the second stage of multiplexed will begin to do and finally did, so did two and
then finally we get D3.
Now let us assume that when we apply zero one, we want the.
Shift in direction every single shift.
So what we can call it is we want that shift happening and that the magnitude of what so magnitude,
all of one represent that we are targeting a single shift and we are that the battle that we are designing
is operating for a left or left ship operation.
So whenever we apply 01, whenever we apply to here, we'll be applying the decisions here will give
me one right.
So whenever we apply this command to our battle shifted, this will basically shift the the input input
that we have in a left direction with the magnitude of one.
Right.
So whatever we have at this position will come over here.
Whatever we have this position, it will come here.
And whatever we have at this position, it will come over.
And finally, we want to implement the logical shift, not the automatic shift.
So the three will finally or in fact, rotate operation.
We called it as an operation.
So since we are targeting a repeat operation, this debate will come over here.
OK, you can also target to go for an.
Other type of shifter, such as?
Such as these three can be thrown out and then you can have Bengazi, so that is also possible by just
changing logic, right?
So this is what we want when we want.
OK, so whenever we apply a zero one.
OK, so this this one should be zero and then this should be right.
So this line will be transferred to another.
Right.
So here now since we want these three and we know that this line is being tied to Zeder, so just connect
all the inputs over here, OK?
And we want that.
Now, add this line we should get and we know that these three, when we apply, will be out of this.
So what we can do is I can simply select.
This line, I can connect with you and just to distinguish and use some different colour for back to
green will be the colors which are in fact green will not be a good color to some dark blue will be
a color that we are targeting.
So this will be the operation or this will be giving us a shift in a direction with the magnitude of
one.
Similarly, for this bit, we want to have a visual so that you that what we can do is you can connect
this line directly to the looks of this.
And similarly.
To have a fever over here, we can now we know that this will result in two days when when we apply
zero here so we can simply connected to it here.
And finally.
OK, so just to make a diagram bit more clear and then finally, we want you to have a lead, so we'll
be simply connecting.
Of this to this.
So this will result in the right now when we feed one seed.
OK, so when we feed one zettl, we want that at an output.
We want to shift again election with the magnitude of, OK, so whatever we have at this this second
shift operation, we will we can simply shift again in the magnitude of one and then we can get a shift
with the magnitude of two if we compare that with an input that is available at this stage.
So what I can do is I can simply copy distribute.
And then I can simply.
Bring them here, right?
And finally, since we are planning to implement this data will come at this point.
So now if we can compare this, which is our cooperation with the result of this operation and finding
V0 is being shifted to the division has been shifted to de de de de is going through, which would be.
So this is the shift that the magnitude of.
OK, so we know that now this first line will be selected and here Delaplane will be selected.
So what I would also be expecting a district operation should be connected to.
The first line of this was Egypt looks OK, so for this line, we are expecting the right to do so when
we apply.
This line will be selected and then for to have that, we will be simply waiting to right for the second
line.
We are expecting three.
So if we can just see.
So we need to write the next line.
We want be zero.
So we'll be taking the easy road here.
And then finally, if we can just compare any one of the operations, like suppose let us assume what
will happen at this late date.
So since this is zero, this line will be selected and then this line is connected to this and here
since we are applying one.
So one is going to be zero.
So if we can figure it out for at this stage, we will be getting these, which is what we know for
when we apply one when we want that the shift should happen in with the magnitude of three.
So again, if we can look at this stage and if I can shift this with the magnitude of one, I'll be
getting the other direction.
Badakshan with the magnitude of three if we compare this with this.
So I can just get this entire thing.
And if I can just be stored here.
And since we are planning since we are planning to relocate operations or whatever we have here, we
will be applying or.
Right.
So, no, we'll be finding when we shift the input with a magnitude of three, the result that we are
getting is something like this, like.
So that you can actually compelled by law to look into this and so here if you have a visitor.
So first shift will take this to this second shift from this position to this position.
And finally, third shift operations will be zero from this position to this position.
And that is the reason why we are getting a break.
So let us know what will happen when we apply.
So we'll consider anyone.
OK, so this late and since one is selected, so this will be the line that will be right.
And then this is connected to this.
And here also we are applying what we are getting, Deep Throat.
So from here to here, we'll be getting deeper.
And that is exactly matching to what we had expected.
So we just have designed for one of the condition and another condition is actually matching to what
we had expected.
So this is a typical operation of about which is just strictly implemented with the hardware description,
like, OK, let us start designing our system.
OK.
So this is what we planning to do.
So from that I got myself.
You can figure out that we want to perform some liquidity operations and the base component that we
want to use as an fix it.
So anyway, we need some base model for our multiplexed and then only we can prosecute.
OK, now that proceed, that Prostratin can either be with the structural modeling style or much easier
to be, which is utilizing an IP block diagram or the block diagonal feature that we have with.
OK.
So Will we looked into this, so let us create a multiplex.
So I just need a new source.
And then since this is and so I just mean Buddhist monks, single output and then we probably have a
three.
And then finish first and go to the NBA, which are basically our first, then we have a select input
which is used to decide which line should be transported.
And finally, we have an output.
Right, which again, will have a side of single bit.
But right now, this side's depend on input.
So I just click, OK, so this will create a good template for us where we can start designing that
system.
OK, so for shmucks, we can use any modeling glickstein in fact you can use the only state we can use
behavioral modeling state to let us just use or just just proceed with the.
Dataflow more day, OK, so why will be equal a OK then then your select will become one right is else
it will be close to B then R Select will become one and.
And there you can see it will be close to it would be close it is, you see.
Then.
Nothing much, right?
So whenever we have selected someone will be passing it on whenever we have a select or will be passive
or just and it will be a good idea since 80 percent of the electorate is just see or hear.
And one, you so eager to present that the position of Moxa remember, this sense of mission depends
strongly upon one of.
So remember that when we are targeting E or when we are connecting something so that if there's an issue,
which is our first big time here, also we have to be right.
And whenever we consider one, we will be passing the and we have a Z, so we'll just see what it is.
So this will be our schematic.
And we just looked in Glenarden schematic whether we are getting what we had expected.
So I'm just going to annotated analysis and I want a schematic.
OK, so this will give us an idea of how the system is implemented, depending on the scale that we
have written here.
Right.
So this is an example of a diplomatic state since this is very, very simple example, you can actually
proceed with the multiple one states.
So implementing Mocksville behaved in exchange will also be very easy.
In fact, utilizing a structure monadic style and implementing must also be very, very easy.
OK, so here we have input and then we have an input.
We and depending on the condition of the select of able to choose the component that is in our delux
will be bussy, either A or B.
OK, so now let's try to use a block design to implement the system that we are talking.
So we'll just click on Create Block Design the next.
OK, so now we are inside our blog to see what I do is I just.
Make this window float and then side by side will be keeping a schematic.
OK, so this will help us to design the entire system.
OK, so first we need to either you can create an IP of the box that we have designed or we can directly
either knocked it.
So to do that or we can just right.
Click and then here we have two option.
You can either write an IP Oregon either out and so click on add more than it will automatically locate
all the modules that you have created.
So this is the model that we are targeting.
So just click, OK, so this will automatically add an instance form.
Right.
So now you can see that the president's position and then Luxenberg.
Right.
And B is also representing one position, which is exactly similar to what we are using in the schematic.
So I can just copy this and I can be stored four times to implement the first stage.
Right.
So I just.
Copy and paste it four times.
So now this represents first and then I can copy this entire thing.
And then I can piece them here like.
So now we have our second stage that we required to implement.
So for this, we can see here we have our first D.C. vote so that we want to connect it to this.
So what we can do is we can use it at.
Or we can either create a book.
OK, so let's just name it as the same name that we have in the schematic, so it will have a direction
of an input and the size of a single person to just create it and then.
Or we can simply.
Connect this input to me, and again, this included also connected to the first line of the Moxham
to night.
So this is M0, this is one this is M2.
And then the phosphate, which is our DNA is also connected to to this this implementor.
The state for diesel.
Now, let us create one more board will be named as Devinn, and it will be an input for.
So I simply connect first and just move it.
Good here and let it just so when is connected to Mux and one zero nine so eight of and when and then
it is also connected to the first line of Moxham three.
So this will be almost empty.
So first, that is B of.
And.
Three months, right, likewise, now we can actually add two more both or either we can be and now
we know that this.
The first storyline line of this, Moxham should be connected to the bike and simply click on that spin
and I can make it extend.
So this will add basically a different name to it.
And if I can just go into AVADO and if I can open the schematic that we are targeting here in the properties,
we get the option that we can change the name.
So I just simply change it to be.
And then if we can just locating.
Do we have a.
I'll be making it axonal.
I'll be clicking over here and then here I'll be changing the.
So this will basically create.
Twenty three.
Now let's connect the remaining production.
OK, so this B that is Moxham, one first name is connected to BP, so I can simply put it out there
like.
This this bee is connected to the two selected and connected to the two, and then this basically completes
an entire night.
So For Selecter will be.
Again, considering a separate bus.
OK, so let's assume that this is someone who is going to make it external, OK?
And then I can actually connect.
All the subsequent marksman's.
OK, so this completes the implementation of a hostage now here we know that this line is connected
to 012 and food and food will be basically aof of Dismukes.
And it is connected to, first off, this second strike to be of this second mux.
Similarly, this is connected to root of this looks like with all of this connected to it.
And then this is also connected to.
This decision is also connected to this one, right?
So M6 will basically be this.
And this one is connected to.
Dismukes like.
Finally, this one is connected to our last.
And we want this to, again, be an exchange, right, so this completes.
And diet designing for that and then one more thing is remaining that is making out all right.
So I'll simply make them extend all the lines and I'll go to Florida, where I'll be changing the name
of each and every one so I can now make this window dog so that we can shift to Wardo and then properties.
We can change the name of all the selection.
OK, so I simply named this as Esswein.
OK, and this to be Asuda instead of zero.
Why undisclosed or will be naming it does why this will become Vivan?
OK, this will become our way to and then finally, we have something that isn't quite so, this significantly
reduce the amount of effort that we need to do to perform a mapping when we are planning to delay the
structural.
And this is also handy when we are planning to use and build eyepiece that savings spiritist.
So let it just regenerate.
And it is valedictories.
So if all the critical connections are made through subsequent what it is doing, it will it will pass
the validation or it will show a notification as validation success.
So as soon as we completed this, now we need to generate an ID which can be used to perform for the
processes of future design.
So just right.
Click on our design and was generating our products.
So this will generate the necessary product.
And then finally we can create and deliver.
We can create an actual rapert.
To select the default option, as we are told, manages to create an for us now, as soon as that deal
is ready, we can proceed with the behavioral model and we can actually feed some input combination
and check whether our output is giving back which option.
So now we have created Stelco.
So now we can go to run simulation performed on behaviorial simulation.
So here will be feeding some random stimuli and will be verifying whether we are actually already expecting
out of our system.
OK, so here you can actually proceed with the structure.
And then you can do actual mapping.
And then we can have an implementation of it.
And you can also use a for loop to implement this system.
So we will try to go at each and every piece of actually implementing this vital shift as we proceed
forward.
So let's feed this feed.
A constituent here in search of a clock.
OK, so.
One, and then here also legislative presedo and.
Lost will be won, right?
So what we can actually do is we can select all this input and select all the inputs and we can create
a buzz out of it so that identification of the shifting operation becomes very, very easy.
So this is how you create a buzz, you select all the inputs and then you simply create a new one right
here will be feeding the zettl and will be feeding the UN or in fact, here we can use of blowholes.
So let's just go with the clock so we will to verify all the functionality in a single go so full and
to zero, and then let us have a huge difference between the two birute so that we are able to verify
the functionalities, one of the properties that is 509 and let it just create a buzz out of it.
Right.
So select the inputs and then you watch us on four also for an output will be selecting everything just
right click and then we create a new watch.
So this will be our input.
We're going to be the NIMET by the clicking and then we have an option.
So this would be an input data.
So input data.
Then we also have this representing output line, so we'll just rename it as an output data.
And then this represents a shift magnitude.
Right.
So just name does shift.
Shift magnitude to let it just try to run it and try to do out of it, right.
So input data is to constant that is just gene theoretics to binary.
So it is one one to one.
Right.
And depending on then shift magnitude, you'll be finding all the details.
Otsuji so that it just zoom in a bit.
And we'll try to make both the line to operate on the binary number, so just click Reddick's and Binary,
right, click Reddick's.
So now let's try to analyze, all right.
So we'll be finding for this bus when we are feeding one zero, if we can just do in all of us, finding
one is out as sandwiches, which should be an endless is great.
But right now, when we are considering this bus, it is on an industry position that will just move
this down.
So now this will be similarly why zero should represent that unless we do it the way it should be done,
then we have Wilen, then we have to find three and four and also we should have zero and then Devinn
then doing fine.
Now let's try to analyze it is OK.
So when we say zero zero.
So here if we can observe two four zero one four zero zero, we are expecting that the input should
be passed as it is through an open line, which is what we are getting out here.
So one zero one one.
But when we are applying zero one, when we are applying zero one, he'll be finding we are expecting
that this should be at this position.
And then we have this one, too.
We should go left and find them.
So we are expecting a zero and one one run rate, but then we are getting some different views.
So let's just to a block, I'm just trying to notice what we consider.
Right.
So if we can just go to a block diagram, will we find this is this one line?
So this should be connected to this one, but it is connected to it and this line is connected to this.
So if you can just move back to a simulation and if you can just bring this ASUDA again to an embassy
position.
Now, this entire operation, what we discussed.
So this one zero now represent a shift with the magnitude of right.
So this will come here and then this one will be going over here.
So after the first shift, operation is a bigger one, one, one.
And then again, when we perform a shift operation, be fighting, this will be going on here.
And this all three ones will be more.
So we'll be getting one on one.
OK, so this verified the functionality of that and shift it affordable battleship to the left operation.
OK, so this is how you can be to watch your lines and then you can be such that you could you verify
the functionality.