So now let us try to understand the typical format that we have for our signal, and so we already have
added this old school.
OK, and this is the template that we get with then we this so we have not added any food to our duty.
So we just consider to the monster signal and variable so entity could be without the boats, right?
And that is usually the case when you write the test, when traits of this fish do not have input and
output.
We could just demonstrate the concept with a cool like, that's right.
So this is your re not synthesize it, but so you won't be getting any logic because you have to specify
input.
Right?
So we start with an architecture, right?
So here we have an architecture, then we can write.
So this is the first space where we could declare full thing so we could add Cygnet because our company,
we collect memories, or we could also add user defined Typekit.
So these are the full components that we specify over here.
OK.
So to declare a signal, we start with the keyword signal, right?
Then we provide the name to a segment.
So let me just an e.
Then we specify the type, right?
So we add all right and then the detail that you want to have for a signal, right?
So that is what you want to specify.
Now, since we haven't covered much on the lead today, we will be simultaneously covering the data
types that we have with the right.
So as you complete a specification of today, then you use Coolen equals two without this piece, OK,
who added initial value to the signal?
Right.
And finally, as you complete specifying an initial value, then you add a semicolon, right?
So this is how you declare the signal.
And if you consider a variable rate to begin, we have a process and between processes and begin, we
get the space to declare variable rate.
The process could have a name.
So we'll just be adding this as even so, B one is the name for our process and we could have a multiple
process, right?
So let it just start B2 also.
So as we start the process, we need to end the process before we start declaring the new process,
right?
So in process?
This makes sense.
So we declared our process even OK.
And then we have a space between process and begin to declare the component that could be placed between
this.
And then we end up the process by calling and process to declare repeat process P2.
So we start with the P2 again.
Process the space to declare the component that process can have.
Begin.
And the last thing that we're going to do this in process and process, right?
So to declare a variable for Process B one, we will start with the key word of it, then we provide
the new to a variable really, just assume it to be then cool.
OK, then we specify the due date again.
We will not be adding ADT until we discussed it to initialize the variable.
We will just be utilizing gold equals two.
OK, without this piece, and then we add value to a variable.
And finally, we add a semicolon, right?
So this is how we declared a variable.
So this variable will be local to the process.
So Process B2 simply could not access this variable, right?
This makes it so this is how we declare signal and the variable rate.
So signal will be declared between architecture and begin.
OK, remember this thing, whereas variable will be declared between ROS and Begin.
This is this piece which is allocated for a declaration of what?