So now we'll discuss what the different reporting mechanism that we have with this when we consider
sending a at concentrate, so to demonstrate we will utilize again the same hardware design that we
utilized to verify that the toolchain is successfully configured.
So we have a micro place, which is configured to have a local memory of 128GB.
And then you work like Typekit because utilizing it will be sending the reader to up until the rest
of the things-I as it is.
OK, so the clock is connected to the assist dropping and reads it is again connected to ready for a
recipient.
Right?
And we also invoke the Halloway.
Right now we have a three situation which you could find frequently when you are designing an application.
OK, so you want to send the constant string on to a concert.
So this include, for example, you have a paper and you read a function to initialize the peripheral
to whether initialization is successful or not.
Okay, so this represents the constant string that we want to send to a user, right?
So this is one of the situation that other situation that we have is to debug the value of a variable
rate.
So you handle this situation now variable could take of 6.2 value, or it could also take a the rate.
So we have a three situations which you frequently find out great.
So either it may be a constant that we want to send to the console, or it may be fixed by an integer
value that we want to send to a user our floating point, right?
So in all the three cases, we'll be profiling the three reporting mechanism that we have to either
print or print or print, right?
So whenever you have that, is you a requirement to send the constant string right that gives you?
We utilize first upgrade, right?
So brain function and then we will just be mentioning that this is a constant string and along with
the new line character.
So that this we will just be receiving our code and building up our entire core right.
So this will generate and will fight which we will be sending on tokens.
And so I've already collected the.
Instigator of to.
Six, OK, which works at nine six zero zero.
So let it just go ahead and try to execute our application to run this launch on hard, right?
So now you could clearly be able to send a constant stream utilizing.
And when you go to the a sticky day, you have an application folder.
So I have named my application as I look and inside the debug, you see nearly five.
So this represents executable file size, which will be utilizing for profiling.
So when we use a print and saying the constant stream, two of them, so the size of your file is 82.
So that is what we want to mention with you.
So with print and constant stream, we get the size of 80 to keep right now will modify our code and
utilize print, right?
So this is the second we all conveying the message to any user.
So let's just see what works and then again, relaunch the session on and hide it right?
So we should be able to see the similar result.
What we are getting in the previous case, we do able to see a constant stream.
And now if you analyze the debug folder to the sides of any file is one one one key, right?
So which is greater than what we are getting in the case of, right?
So one one, one last week that we have it is utilizing a deliberate effort.
So we'll just be adding that sleeping, therefore here will be saving the.
And again, we will be relaunching I debug session.
So right click on a full brightness launch on high, right?
So here also we are expecting the same result.
And then if you analyze any fight, so it is giving us around A.D. 70, right?
So all the three mechanism supports sending the constants.
Do you want to consult?
And you can clearly see that print is consuming the least amount of memory, right?
So this helps to build a complex application because when we consider an embedded system, so we have
a limited amount of memory which is available to us.
So we always try to use an API which consumes less amount of memory so that as we modifier hardware
to include a complex paper, we could have a spare amount of memory for our building and application
with that benefit.
So whenever you have a situation to send the constant stream the most efficient way to use a print,
right?
Are you good prosecutors helping to write?
The next scenario that you could probably find is sending a variable value that is just declared one
fixed point where you call for an integer type.
OK.
And we'll just be naming this data and the value that you have is to right now, our agenda is to send
this value utilizing the three mechanism that we have, right?
So again, we start with the brain statement, so OK.
And then we will be adding a value, just try to format specified to the 0d and variable, which is
holding the value of this, right?
So if you add this code, you could clearly see we get an error indicating that there are more argument
than is expecting to print.
Simply do not support sending the values of available on open source, so you could not add any argument
OK for printing the variable value.
So here in the first case, if you consider sending variable values on your console utilizing print,
it is simply not applicable, right?
The next mechanism that we have is a print app, so let it just include printed CEVA code and allow
the code to build up OK, and then right click Run as launch on superintending support and variable
argument.
So you could bring the values of the label and you could see that we could bring the fixed point number.
OK of integer type, whose value is real on the concept and the size that we are getting, is it down
to fifty nine?
Right.
So we'll just be writing with the print we are able to send the value and the size of any file is around
250 90.
Next, we will consider taking that so easily printed to allow us to send a fixed point number on tokens.
So we'll just modify our code and relaunch debug session, right?
So let me just go ahead and try to execute the code so you could clearly see we are gaining.
But to see the value to it as we are getting in the previous case, just need to add a new line character.
OK, so that we could see the value printed in the next slide.
So let's just go ahead and again, try to relaunch the feedback session.
OK, and now you could clearly see that we are able to get the result what we are getting in a previous
its value and to it.
In this case, though, yeah, let's say that we are getting is around eighty seven kb, which is much
less that's compared to the print state.
So whenever you are in a situation where you want to send the variable value, OK, specifically a fixed
point value, or you can so that the preferred method is to print, right?
Now remember, I sprint do not support sending the variable value.
We are not allowed to utilize it, sending the variable values on a console.
Similarly, select Braindead do not support sending the floating point values on to open, right?
So we'll just be demonstrating this with an example again.
Great.
Do not support sending the variable values on a console, so we could not simply saying the floating
point number utilizing print on the console.
Right?
Let it just declared data and we will be modifying it.
So float.
Greta, OK, and the value that you have is to a point.
OK, now let me just go ahead and try to celebrate the value by saying zero.
OK, this is the format specified that you use for sending the starting by number and again, those
sorts of details.
Right?
So let me just see what could.
So our bill is successful.
We are not getting any error.
Now, if you just try to run an application on you and there.
So you could clearly see we won't be able to send the floating point number right, so they would render
this simply incapable of sending a floating point number.
So they're just be adding anywhere here.
So we are elected only one option that is printed.
So if you just modify our code to include printer and let it just save our code and try to execute an
application again on to an FPGA so that this modification now you could really see that we are able
to send a floating going number utilizing a printer function, right?
So this is so and easily find that we get is our size 266 key, right?
So we have three mechanism of sending the values on to so so whenever you are in a situation the same,
the constant string pressure to go with 0.8 or whenever you are sending the fixed point variable values
on your so prefer to go with self-branded and whenever you are planning to send the floating by number
on tokens.
So prefer to go with bring them right.
There's either three either narratives that we have and we already discussed what are the situation
in which you will be using one or at right?