How to setup serial port in base workspace and access from function workspace?

Question

Wess Gates 2023-8-3

0
链接

此问题的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/2004452-how-to-setup-serial-port-in-base-workspace-and-access-from-function-workspace

评论： Walter Roberson 2023-8-8

Hello,

I would like to setup a serial port via s = serialport(port,baudrate) in the base workspace (initialization file) since serial port setup wont change during the life of the connection this really only needs to run once. However, I would like to call the serial port object from other function/functions workspace/workspaces. What are best practices to achieve this or is this even an acceptable practice at all?

Thank you,

Wess

0 个评论
显示 -2更早的评论隐藏 -2更早的评论

请先登录，再进行评论。

请先登录，再回答此问题。

Answer 1

dpb 2023-8-3

0
链接

此回答的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/2004452-how-to-setup-serial-port-in-base-workspace-and-access-from-function-workspace#answer_1282987

Simply pass the returned serial port object to the function(s) where it's needed.

Best factorization would probably be to write a little function to call to do the initialization as well rather than just a bunch of constants buried inline in code; gives you the flexibility to change parameters if/when needed.

31 个评论
显示 29更早的评论隐藏 29更早的评论

Wess Gates 2023-8-3

在 MATLAB Online 中打开

Most definately avoided even the idea of evalin etc.... I was attempting to be brief in the original question per the forum etiqutte but after running the profiler per @dpb suggestion I am wondering if I have left important info out?

I am reading/writing to serial via "brut force" method. I am not using a call back funtion or waiting for numByets etc... so I am guessing I probably need to do that. The number of calls to the "serial like functions" is out of control? Maybe some kind of underlying OS/MATALB level interrupts on Tx/Rx or something along those lines?

However, I was testing with and without (rateControl) and the number of calls at the serial I/O level is just as high as if rateControl is ignored from what I can tell.

MyRateObject = rateControl(my10HzRate);
reset(MyRateObject);
myRateLoop()
%execute stuff
waitfor(MyRateObject);
end

I appreciate the help and dicussion. Here is screen shot of performance.

I basically initialize serial in runSimulation and from here I pass it to simulate which then passes it to gncStep.

Walter Roberson 2023-8-4

在 MATLAB Online 中打开

It is a bit tricky to construct equivalent timing tests. For example if you global a reference to a variable but do nothing with the variable otherwise, then is that really equivalent work to "using" the variable somehow? That is why the functions have class() calls -- for the side effect of forcing the function to refer to the variable somehow.

On my system, the timings were about

no serial, just rand, t = 0.000648458

serial created outside loop, passed in, t = 0.847501

serial created outside loop, evalin, t = 0.854252

serial created outside loop, global, t = 0.818474

with some variability. Over several executions, the global seems to be consistently faster, then passing the value in, with evalin slower.

If you uncomment the t2 and t3 tests (and displaying), those take a little over 20 seconds each on my system -- which demonstrates that creating and destroying the serial port inside the loop is pretty costly.

In some of my earlier versions of the code, the timings were measurably faster than what is displayed above. It turned out that the time required to delete() the serial port was significant, so it made a difference to delete() inside the timing section instead of after the timing section. Also, it turned out that not having a reference to the object (e.g., just passing it in without using it) made quite large difference to the timing.

clear all
%"prime the pump" -- in case the first serialport() call needs to
%pull functions into memory or the like
s = serialport('/dev/tty.URT1', 19200); delete(s);
%start the test
N = 25;
start = tic; for K = 1 : N; version0(); end; t1 = toc(start);
%{
clear s; start = tic; for K = 1 : N; s = serialport('/dev/tty.URT1', 19200); version0(); delete(s); end; t2 = toc(start);
start = tic; for K = 1 : N; version1(); end; t3 = toc(start);
%}
clear s;  start = tic; s = serialport('/dev/tty.URT1', 19200); for K = 1 : N; version2(s); end; delete(s); t4 = toc(start); 
clear s;  start = tic; s = serialport('/dev/tty.URT1', 19200); for K = 1 : N; version3(); end; delete(s); t5 = toc(start);
clear s; global s
start = tic; s = serialport('/dev/tty.URT1', 19200); for K = 1 : N; version4(); end; delete(s); t6 = toc(start);
fprintf('no serial, just rand, t = %g\n', t1);
%{
fprintf('serial created inside loop, but unused, t = %g\n', t2);
fprintf('serial created inside function, t = %g\n', t3);
%}
fprintf('serial created outside loop, passed in, t = %g\n', t4);
fprintf('serial created outside loop, evalin, t = %g\n', t5);
fprintf('serial created outside loop, global, t = %g\n', t6);
function version0
  rand(1,1000);
end
function version1
   s = serialport('/dev/tty.URT1', 19200);
   rand(1,1000);
   delete(s);
end
function version2(s)
  class(s);
  rand(1,1000);
end
function version3()
  s = evalin('base', 's');
  class(s);
  rand(1,1000);
end
function version4()
  global s
  class(s);
  rand(1,1000);
end

dpb 2023-8-5

编辑：dpb 2023-8-5

That's pretty discouraging, Walter; there's only 5% difference between the best/worst of those. So is the conclusion just referencing a serial object is extremely expensive without even trying to use it to actually communicate? If that were to be so, it would seem to really make serial communication troublesome.

Or, is it more likely we're timing the wrong thing or demonstrated the wrong architecture?

Seems like what would have to do would be to do more like my earlier flow path of creating the port object, then passing it to the communications function that does its thing with the port until done, then returns to let the port be closed.

That, of course, presumes the port object is designed such that once it is open one can read/write to it without the excessive overhead of just getting around the container wrapper.

That's where my knowledge of how to use serialport fails; I understand low level interrupts from the 8520 UART (or its modern equivalents) and handling them directly; that's very fast even on old silicon but I don't know how to code the MATLAB serialport object to mimic it -- there isn't much in the way of useful examples using the object "in anger".

Walter Roberson 2023-8-5

在 MATLAB Online 中打开

I created a version that created a serial port, wrote a double into the base workspace, evalin() the double in a loop, the ndelete the serial port. That was the slowest version of them all, slower than where the evalin() was fetching the serial port. I don't understand that.

I also created a version that uses the same framework but does not create any serial port, just testing the speed of the different ways of accessing data. The fastest way for that was parameter passing, then global, then evalin() being slowest. All of those times were effectively noise compared to the times involving creating the serial ports -- so creating a serial port object appears to take about 0.8 seconds on my system.

I would wonder about whether the differences in timing I saw with the serial port version were just down to noise in the amount of time it took to create the serial object, but in my tests it was pretty consistent that if I did create a serial object, that global was the fastest access... even though Mathworks specifically documents that global is notably slower than the other ways of passing data.

I am starting to wonder whether some of the timings I see are accidents of code order in combination with JIT.

That is, historically I have noticed in the past that in a number of my timing tests, the first timing loop often executes more slowly than the other timing loops -- so if I added another copy of the first timing loop measuring exactly the same thing, that the times for the second copy would be significally better than the first version. This was not something that could be explained by simple JIT, since the code under test was being executed in a loop. The time taken to JIT something might affect the first one or two executions, but after that it should be fully JIT'd... but the longer times did not just affect the first one or two iterations of the timing loop.

In other timing-loop tests I found that the first 3 (especially) iterations often had much higher times, so now I might discard the first 5 iterations in figuring out mean / variance on timing.

Thus I am wondering whether in this particular case, changing the order of the code might affect which one was fastest.

clear all
%start the test
N = 25;
start = tic; for K = 1 : N; version0(); end; t1 = toc(start);
clear s;  start = tic; s = 50; for K = 1 : N; version3(); end; t5 = toc(start);
clear s;  start = tic; s = 50; for K = 1 : N; version2(s); end; t7 = toc(start); 
clear s; global s
start = tic; s = 50; for K = 1 : N; version4(); end; t6 = toc(start);
fprintf('overhead, t = %g\n', t1);
fprintf('double evalin, t = %g\n', t5);
fprintf('double global, t = %g\n', t6);
fprintf('double passed in, t = %g\n', t7);
function version0
  %rand(1,1000);
end
function version1
   s = serialport('/dev/tty.URT1', 19200);
   %rand(1,1000);
   delete(s);
end
function version2(s)
  class(s);
  %rand(1,1000);
end
function version3()
  s = evalin('base', 's');
  class(s);
  %rand(1,1000);
end
function version4()
  global s
  class(s);
  %rand(1,1000);
end

Walter Roberson 2023-8-5

在 MATLAB Online 中打开

clear all
%"prime the pump" -- in case the first serialport() call needs to
%pull functions into memory or the like
s = serialport('/dev/tty.URT1', 19200); delete(s);
%start the test
N = 25;
start = tic; for K = 1 : N; version0(); end; t1 = toc(start);
%{
clear s; start = tic; for K = 1 : N; s = serialport('/dev/tty.URT1', 19200); version0(); delete(s); end; t2 = toc(start);
start = tic; for K = 1 : N; version1(); end; t3 = toc(start);
%}
clear s;  start = tic; s = serialport('/dev/tty.URT1', 19200); t = 50; for K = 1 : N; version2(s); end; delete(s); t4 = toc(start); 
clear s;  start = tic; s = serialport('/dev/tty.URT1', 19200); t = 50; for K = 1 : N; version3(); end; delete(s); t5 = toc(start);
clear s;  start = tic; s = serialport('/dev/tty.URT1', 19200); t = 50; for K = 1 : N; version2(t); end; delete(s); t7 = toc(start); 
clear s;  start = tic; t = serialport('/dev/tty.URT1', 19200); s = 50; for K = 1 : N; version3(); end; delete(t); t8 = toc(start);
clear s; global s
start = tic; s = serialport('/dev/tty.URT1', 19200); for K = 1 : N; version4(); end; delete(s); t6 = toc(start);
fprintf('no serial, just rand, t = %g\n', t1);
%{
fprintf('serial created inside loop, but unused, t = %g\n', t2);
fprintf('serial created inside function, t = %g\n', t3);
%}
fprintf('serial created outside loop, passed in, t = %g\n', t4);
fprintf('serial created outside loop, evalin, t = %g\n', t5);
fprintf('serial created outside loop, global, t = %g\n', t6);
fprintf('serial created outside loop, something else passed in, t = %g\n', t7);
fprintf('serial created outside loop, something else evalin, t = %g\n', t8);
function version0
  %rand(1,1000);
end
function version1
   s = serialport('/dev/tty.URT1', 19200);
   %rand(1,1000);
   delete(s);
end
function version2(s)
  class(s);
  %rand(1,1000);
end
function version3()
  s = evalin('base', 's');
  class(s);
  %rand(1,1000);
end
function version4()
  global s
  class(s);
  %rand(1,1000);
end

Walter Roberson 2023-8-7

The processing model used by serialport() and a number of other routines (for example the UDP routines) is as-if steam is of data is continuous until end-of-file / end-of-connection, and that each time you ask for input, the routine should wait patiently for data to become available. As far as the processing model is concerned, any timeout processing exists only to allow the designer to put limits on how long to wait in cases where the stream has failed (for example loss of power, or cable got unplugged, disk failed, or so on.)

The processing model is not designed for real(-ish) time work. It is not designed for the program to be able to poll and say "Hey, is there any available data? If not then I have something else to do", and it is not designed for a program to be able to say, "I'm willing to wait 200 ms for data now, and it is a normal circumstance for data to not always be available, but after 200 ms I have to do something else for a while".

The only way the processing model gives to be able to handle data not currently available is to raise an error() (though serialport() itself allows configuring an error function for timeouts.)

What can you do to avoid problems? Well, you have to pay attention to the NumBytesAvailabe -- and to deliberately skip read() or readline() if there is not enough data. Or configure a BytesAvailableFcn callback to handle data as it comes in.

dpb 2023-8-7

You set the number of bytes available to something other than 1; I think 64 is default but it can be what makes sense with your communications protocol if it isn't record-based as it seems the idea of the implementator was when writing it as Walter pointed out, being terminator based.

If the device supports hardware RTS/CTS, then it shouldn't lose data as long as your callback can service the port "frequently enough".

You should be able to poll, reading the NumBytesAvailable value and then pull that number; if another arrives meanwhile, it should not be lost; the Q? will be whether the implementation is up to handling the internal counter correctly so if there are N bytes available when ask but N+1 when the read() operation is performed, will the new query after the N are read show 1+however_many_more_come_since?

With direct access to the port in the olden days, you could always find out how that all worked; when its wrapped in an only semi-transparent shell, it's not so easy to determine.

dpb 2023-8-8

"you might be able to use textscan but for that kind of work it would also be common to use text manipulation to extract the pieces and convert them as needed, as that would tend to have lower overhead than using textscan()"

I hadn't thought necessarily of the former; wonder how the new(ish) extract() and patterns stuff might stack up. I've begun using them a fair amount for convenience, but not for anything that has an performance impact that would show; purely for convenience in writing some pattern matching.

Personally, I'd not think of textscan first, either, but would tend to drop straight down to sscanf for such low-level work.

But, there's the other end of starting with the highest level there is and then only worry about performance/optimization if/when that is shown to not be fast enough.

Walter Roberson 2023-8-8

Early on, I tested the pattern-based routines, and at least at that time they were much slower than regexp() . But that might have changed.

请先登录，再进行评论。

How to setup serial port in base workspace and access from function workspace?

0 个评论
显示 -2更早的评论隐藏 -2更早的评论

回答（1 个）

31 个评论
显示 29更早的评论隐藏 29更早的评论

另请参阅

类别

标签

产品

版本

Community Treasure Hunt

How to setup serial port in base workspace and access from function workspace?

0 个评论 显示 -2更早的评论隐藏 -2更早的评论

回答（1 个）

31 个评论 显示 29更早的评论隐藏 29更早的评论

另请参阅

类别

标签

产品

版本

Community Treasure Hunt

0 个评论
显示 -2更早的评论隐藏 -2更早的评论

31 个评论
显示 29更早的评论隐藏 29更早的评论