All right, so now that we have added the state, no, we can go back to simulation.
And let us add that signal over there.
Go back to insert node, node finder, get everything OK?
It should only get you the missing signal.
All right.
So if I just simulate this one more time, we should be able to see this data.
And here's my statement.
As you can see, I hit reset.
We are still in state zero.
So we hit start here.
But evaluation will start only at the falling edge of the clock.
So this is the following gauge right here.
And it sees that start is one right now.
It directly jumps to state one.
Now we are in state one and in a state one, which is fetch, it's going to rate A and B. So whatever
data are written are on the bus of and is going to be latched.
All the way here now.
After that, there was an automatic transition to the process stage, remember, so the following edge,
we jump into another state, which is, as you well know, which is the processing.
And here the numbers are being added or multiplied depending on the operation.
Now we wait for the next fall and get in order to see the next state.
And the next state is now the next state is when we write the result and register receipt.
So we see here we are at state four and the result is written.
And after that, the next polling edge, we see that we are back to state zero.
OK, and if we put this next to each other, you see that the state is changing only as the falling
edge of the clock and this is what we are expecting.
This is why clock is very important.
It organizes your whole circuit.
It makes it from under strict conditions.
It make transition happens at a certain time.
I mean, if this was a pure combination, you would see data flowing right and left whenever they want.
And this will create a lot of independence in a lot of issues.
So in order to avoid these dependencies and issues, we have a clock.
It organizes all the states.
It organizes all your circuit.
OK, now we have simulated the first the first condition, which is the don't flow.
Now, let us simulate the feedback from from what you see today.
So in order to do that, all we need to do is first we need to extend the simulation time.
It's a little bit short to do that.
So we go to edit and we go to set and time and we're going to change the one microsecond to two microseconds.
OK, and here we are going to reproduce the clock.
Again, let it be every two 100 sorry, not 100 that it be after every one hundredth.
OK, now this is the first cycle, it's complete.
Now at this moment we are back at state one.
And what we can do now is set, accumulate and start to want both of them.
So this will drive us in another way, right?
If we said this do to one, well, we are going to go to the state machine where we jump to the accumulated
state.
All right.
And we will see an accumulation of result, so let us do this.
So until here, we already know what what happens.
We already started that, now we are continuing the simulation.
You can see that we are jumping to state number two, which is the accumulate.
Then we are jumping, which is the accumulate.
And we can see that in accumulate.
Right.
See and select are being shorted at once.
And this is exactly what we want.
We are great see is being shot at this little vessel in the next state.
We are storing the data in the next state.
We are processing the data and then afterwards we are writing the data back to see one more time after
it's been fed back and recalculated.
And then we are back to state zero and this is exactly what we are expecting.
So our state machine is working and now it's time to integrate it to our full design.