All right, now that a stark simulation, creative file.
And let us at all denotes.
Great.
So let us arrange these so this is a B. This is my L you out, so let us arrange these signals out.
So let's put Carrie out at the end.
This is you out that's put it at the end.
This is right.
A right to be right.
See, we're not going to be going to be using Griffitts right now, so let's put them at the end as
well.
All right, and select us well, we will not be using select at this this cycle, we will use it in
a second test cycle.
So let's just put it also at the end.
Now, let us change the radix for our inputs and outputs signals so they will be insigne decimals.
And we are going to test addition, subtraction, multiplication and division.
So we have zero zero zero zero zero one zero one zero and zero one one.
But instead of putting them manually, we could use the count command here.
So just take the up and choose this count value.
Let us count every 200 nanoseconds because, well, it's divided to 1000 nanoseconds and retesting only
four.
So 200 nanoseconds sounds convenient.
We'll be testing until here this is for the X or we're not going to be testing it right now.
All right.
And the two numbers we're going to use, or maybe 50 at four.
OK, so let's click on A and then hit the shortcut control of B, and by that we will put here fifty.
And I'm going to put here not four, maybe three.
Control all to be and I want three now.
We need to write be now, if you just do this in order to write and be, you know, by latching and
be input to the registers, you need to write great.
Ain't right to be here.
Right.
But if you just do it like this, it won't work.
Why?
Because simply our registers are the flip flops.
You can call them always erasing it's based and you there is no way to gauge it starting at 1:00, so
there is no transition between zero and one.
So what we need to do is we need to cut this to zero.
And this is my rising edge show.
This is where the writing is going to take place now after we write and B, they will go directly to
the value and we need to latch it to just to see after you calculated the result.
So let's wait a little bit here and let us Lache here resistor.
So now the result will be latched right here.
OK, and when we are legit, we should see oh, out right here having some value after we left it.
So after this instance, you know, the values are not changing.
Right.
So we don't need to write a Andray to be again, we just wrote them once.
The values are not changing for Gambi and all we need to do is whenever we change operation, we just
need to write the new result due to the operation change.
So zero zero one is going to subtract the numbers.
We're going to wait a bit and then we're going to let see in order to start with the result so that
we can see that the output of which is to see right here.
Same thing here.
After some times of changing the operation, a prison changes changes at this point until this point.
And let's take a point in between and just let's see, same thing.
Here we are.
Let's see.
OK, so every operation we are talking the new result.
OK, now let us it's simulation now.
All right.
So what should we call this?
It is Hailu.
Data flow.
And of course, we're going to get an error because we still did not fix this.
This shall be deleted to save simulation.
We still have one error, but the simulation settings, again restored default and then delete this.
All right, and we are starting the simulation and we're done.
All right, that's a.
Now let's change the radix.
We forgot to change the Reddick's for our out.
All right.
Great.
First, we have latched the new values to IMDB and then we are saying, OK, are you an adult because
the operation is zero zero zero, which Gurvitz bonds to audition.
So my help you out started giving me 53 immediately the moment I latched those values, right.
So, Aled, you out?
Well, give me the result almost immediately after we left the new values.
But as you can see, exit out is still zero, right?
Because we did not.
Lache, the the values with the dot org, the values in Occy, the moment we say, OK, hey, I want
to a stuff in C by hitting.
Right.
See I could see at this instant that OK, I am writing the result or C don't confuse Hailu out with
the output of our C the output of failed you out because if you take a look here, this is a due out,
it's the output of the value.
But we did not stock the result here and we need to store the results because whenever we change the
operation here, this number will change and we have not stored anything.
So we need to stock the result.
That's why the moment we hit our sea, we will see a result at RCL.
OK.
That's wonderful.
Next, we change the operation to zero zero one, which is subtraction.
Now, as you can see, a B did not change.
The moment we change operation, we can see you out giving us a new result.
Take a look here.
I mean, let me put them right next to each other.
The moment you change operation, the result of failed, you will change.
However, let's put it out here.
However, our out did not change yet, even though here we have bailed you out at 47, we can see that
there is nothing stored yet until let's put our C here until we say, OK, hey, I want to stock my
results right here, then we will see a data stored it.
Or see now the result is actually four to seven, which actually is correct for subtraction.
Next for multiplication.
Again, we change the operation here.
Once we change operation, they'll the you will calculate the new results for me, which is a hundred
fifty.
And I'm going to say, OK, hey, store my result in our C and then I will see that the result is stored
in our C.
Lastly, we are dividing 50 by three, so we change the operation to division.
We call you out calculating my new result.
And until I say OK stock, then we will result.
I won't be seeing sixteen.
Then we started with sixteen and as you can see here, this is an integer division and integer division.
You don't have any float numbers, you don't have any Gomaa five something, you don't have any float
number or fixed point number.
The result will be an integer.
This is why we are getting sixteen because, well, 16 times the three is forty eight and we have a
reminder of two.
OK, so this result will be calculated and it will disregard any reminders and it won't give you numbers
using the floating numbers or fixed point.
And it won't give you results using floating numbers.
OK, so we are good now we are ready to design a controller for the.