So we're back here and let's explain from Chubb, how is this FSM working along with guilt?
We have two processes.
They are running in parallel.
This is responsible for Glocke.
This is responsible for specifying what next the state should be.
So first there was a reset.
This we said, well, tell me, OK, start with that in its state.
We already defined our states here using this type keyword.
And from the state, we could create point, there is one of them is next state and the other is going
state.
No, we said we are the current state will be in it.
OK, so this one will start evaluating.
It's going to say, OK, what is my current state?
Well, it was set in other process to end it.
So it will be in it and it's going to set everything to zero because, well, this is the initial state
and we should be at Initializing State.
All right.
No, he it's going to wait.
If there is any start or any accumulate in order to branch to other states, if nothing is oppressed,
well, next state will be also in it.
So when the clock comes again here and the clock has a falling at, this current state will be set to
the next state.
What is my next state?
Well, we have set it right here to end it because.
Well, we did not for a start with not to accumulate.
We are still at in it.
OK, so my current state here is in it.
Now, this process is running parallel at saying what is my current state?
It's still in it.
Now, let's say a start was pressed and accumulation is still zero.
Well, it's going to trigger the first condition is a start equals one and accomplishing goal zero.
Yes, it is.
Well, that means that my next state should be fetch.
So this one is running.
There is a clock all the time.
There was a clock all the time.
And we have a falling Gegè clock.
And now it's going to say, what is my current state?
It is my next state.
Well, what did we said?
The next state to next state was said to fetch.
So now this one is also working in Berlin.
It says, OK, what's the current state?
It is French.
It means that I need to jump to fetch.
Is it this?
Is it no.
Is it the switch?
Yes.
Well, it's going to change all the outputs to this and it's going to say, hey, my next step is a
process.
Now, this one is running in parallel and following each comes and it says, hey, my current state
is next state, which was set here to process.
OK, so state now is the process.
This one is running in parallel that says, well, the current state right now is actually process.
All right.
Will it jump to anything?
No will jump to fetch, no will the jump to accumulate?
No, it will jump to process.
And in the process, we are just giving time for you to write stuff and calculate stuff now.
Next, the next step is going to be the right result.
So process will execute.
It will say, hey, next step is the right result.
We jump back here.
State equal next to state, which is right result at No.
Grinstead As a result, this case will check out his current status, right result, it will jump back
all the way to right result.
It's going to drive right three to one in order to get results in.
You're just through, see, and it's going to jump back to the initial state.
So by sitting next to initial state, we are setting Gergana State also to initial stage when we evaluate
this block and it goes like that.
Now we are in it now, if we have a start equals one and accumulate equals one, well, next stage will
be accumulate this time, this process will set this to accumulate.
And, well, we will evaluate that case you accumulate and we will jump to accumulate and we will be
writing.
See, and we are rerouting the data from sea to Aliu and this is it.
This is how a state machine works with two processors.
Next will start simulation for On the Block before we integrate it to the full design.