So first thing that you're going to do here is to declare it right to let it just go ahead.
And we know that are send and receive function work for then you day to go to work.
OK, you could clearly see.
That are you what you sing?
OK, expect the leader to be in, you wait for my right.
We go ahead and we declare.
You wait, right?
And they just name this as the OK, and this will be an array consisting of an 11 elements.
And will also be initializing it to ladies.
Is you?
Hello.
Right, right, so if you count the number of bytes that we have, right, so we have one two three
four five six seven eight nine 10 and 11 eight to 11 character averaging and each character can be represented
within you.
So this could be stored in this area.
So once this is sent, this will serve as the data buffer for us.
Right now, we call you what same function, right?
So it will just be going ahead and then OK, after we perform an initialization we call Sane, right?
First argument is an instance structure, which is you lot.
And then second argument is the pointer to a little before, right?
So here we could just add an embassy and then we could mention that phrase so far zero element of an
finale.
Right.
So this is how we represent the appointed to our data over the other method that you will use this,
you would just mention data, right?
So this will be the second way that you have, which will be providing a correct address for our data
before it.
But the easier we will be using ampersand and then data zero to this basically mean the starting address
of our body weight.
So once this is specified, the next is to specify the number of bytes that we want to transmit.
So here we want to transmit 11 by great.
These are all the argument that you want to provide to.
You are saying function right now, if you just read the description of this function.
Now, this function have a different behavior, considering the different mood, so we are utilizing
a formula here.
So in a poll mode, this function will only send as much data as the can buffer, right?
And if you exceed the size which the people could not hold in in that case, you need to repetitively
run an application, right?
There's also returned the number of bytes actually sent.
So we need to wait till we reach to the value of 11 because we want the same 11 byte.
So how we do that is that it just store this value in one variable.
Now we know that this region is.
So do you let it just name discount hoagie?
And initialize this to a z of so let me just copy this.
OK, declared it over here, and initially it was hit right.
So this variable will keep track of the number of bytes that are actually set right.
So while we could just use while count is not equal to 11.
OK, we could just say we do it here, right?
So we could yet update the value of account and then we'll again be checking whether count is equal
to 11 or not.
Right?
Again, as soon as our count becomes equal to 11, we'll be simply coming out of the what is right,
and in that case, we could just mention.
Data saying successfully, right.
This is a one off movie that we have with us where what we are doing is we are calling you what the
same function.
And then this basically returns the number of bytes which are actually saying and we are waiting for
our count to reach to a value of 11.
So as soon as cowardly just to a value of 11 will be coming out of a while.
And then we'll be sending the string data transmission, our data saying this successful right now here
we need to verify whether.
This returns bye, bye bye.
There it is, with each new bite to whether it returns one or the total bytes that have been sent to
flat rate.
So that could be verified like this, so just go ahead and build an application project.
OK.
And what we're going to do is with each new iteration we'll get with each new iteration, we'll also
be presenting the value of concrete so out.
OK, but since 0d.
And let me just try to bring the value of call, right?
So if you just try to build an application project, no.
OK.
And then debug as launch one hideaway.
So we do not need to do any changes to a serial terminal since we properly configured it to work at
nine six zero zero.
And now you could see you are in, it is successful.
And hello world.
OK, that is what we receive.
Then count is the 11 right and finally data successfully we get so we will be waiting for all the 11
byte to be transmitted and then will be coming out of this way.
Look, and then we just mentioned to sing, OK, successful.
This is what we going to do.
Let it just proceed to build an application project.
And once our build is successful, OK, we could just go ahead to our right this minute, OK, and then
we will just go ahead and relaunch it.
Debug fission.
Right?
So this will automatically reprogram that FPGA and since are white serial terminal is already connected
to the correct portrait as well as correct.
And you just need to go ahead and click on resume button, right?
So you could see you.
What you need is successful.
Then we have to wait and see and successful to be able to send it correctly.
You could just add a new link between Helloworld and data successfully, right?
So here we could just add a new line corrected that is just again the builder application project and
then try to run naked on an FPGA, right?
So again, we will be launching our feedback session.
And then once this is done, will just be clicking on a resume button, wait till you see you are in,
it is successful at lower and then D.D.S. successful road to the Hallowell city that we have in that
data buffer.
So this is how we could proceed, sending the data to the UART terminal right now.
The next target will be to understand how we receive the data from the city.