Improve slcan.py #1490

mikisama · 2023-01-17T04:23:34Z

Improve receiving performance
Fix an issue that the first read may blocking even if the timeout parameter is not None.

1. Improve receiving performance 2. Fix an issue that the first read may blocking even if the `timeout` parameter is not `None`.

mikisama · 2023-01-17T05:03:05Z

test code

bus = slcanBus(channel="COM11", bitrate=20000)

tx_msg = Message(
    arbitration_id=0x3C,
    is_extended_id=False,
    is_remote_frame=False,
    dlc=8,
    data=bytes(
        [
            0x01,
            0x02,
            0x10,
            0x01,
            0xFF,
            0xFF,
            0xFF,
            0xFF,
        ]
    ),
)

rx_msg = Message(
    arbitration_id=0x3D,
    is_extended_id=False,
    is_remote_frame=True,
    dlc=8,
)

for _ in range(16):
    bus.send(tx_msg)
    bus.send(rx_msg)
    msg = bus.recv()
    print(msg)

bus.shutdown()

gap is 39ms

gap is 1ms

| ID:0x3C | ID:0x3D | <-- gap(39ms) --> | ID:0x3C | ID:0x3D |

| ID:0x3C | ID:0x3D | <-- gap(1ms) ---> | ID:0x3C | ID:0x3D |

zariiii9003 · 2023-01-17T16:51:35Z

can/interfaces/slcan.py

@@ -161,7 +162,6 @@ def _read(self, timeout: Optional[float]) -> Optional[str]:
            while not (
                ord(self._OK) in self._buffer or ord(self._ERROR) in self._buffer
            ):
-                self.serialPortOrig.timeout = time_left


Why did you remove this?

Setting the serial port timeout in the while loop slow down the RX performance.

Is there a way to ensure, that the function respects the timeout parameter?

Is there a way to ensure, that the function respects the timeout parameter?

This is the test code for testing the timeout parameter

import time from can.interfaces.slcan import slcanBus from can.message import Message bus = slcanBus(channel="COM11", bitrate=20000, sleep_after_open=0) tx_msg = Message( arbitration_id=0x3C, is_extended_id=False, is_remote_frame=False, dlc=8, data=bytes( [ 0x01, 0x02, 0x10, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, ] ), ) rx_msg = Message( arbitration_id=0x3D, is_extended_id=False, is_remote_frame=True, dlc=8, ) count = 5 timeout = 1 start_time = time.time() for _ in range(count): bus.send(tx_msg) bus.send(rx_msg) msg = bus.recv(timeout) assert msg is None print(msg) end_time = time.time() spend_time = end_time - start_time assert abs((timeout * count) - spend_time) < 0.1 print(f"{spend_time:.3f}") bus.shutdown()

This is the result

With this proposed change I think there's still a scenario where the timeout is not enforced.

read_all sounds good to me.

def _read(self, timeout: Optional[float]) -> Optional[str]: _timeout = serial.Timeout(timeout) with error_check("Could not read from serial device"): while not _timeout.expired(): new_data = self.serialPortOrig.read_all() if new_data is not None: self._buffer.extend(new_data) else: time.sleep(0.001) continue for terminator in (self._ERROR, self._OK): if terminator in self._buffer: i = self._buffer.index(terminator) + 1 string = self._buffer[:i].decode() del self._buffer[:i] return string return None

The serial port must be instantiated with timeout=0.

But what about when there is data in the buffer? What if there were an infinite amount of 'junk'?

@Tbruno25

def read(self, __size: int = ...) -> bytes: ... def read_all(self): return self.read(self.in_waiting)

If there is data in the buffer, the read method only copies it out. Only when the data bytes in the buffer are smaller than the parameter __size, the read method will blocking until the data bytes in the buffer is __size, then copy it out.

Since the in_waiting parameter shows the current number of bytes in the buffer, blocking will not occur. (The time to copy data out is negligibly small)

According to my test, the MAX receive buffer size in win10 is 16384, and ubuntu 20.04 is 4095. I'm not sure whether it can be changed. But I think there will not be infinite junk.

import serial import time with serial.Serial("COM11") as ser: # send a start command to make # the STM32 dev board start sending data. ser.write(b"start") while True: time.sleep(0.5) print(f"in_waiting {ser.in_waiting}")

@zariiii9003

Looks good. Just a few minor changes requested.

According to my test, the read_all method returns b'' if there is no data that can be read out.

So the if new_data is not None: should be changed to if new_data:, otherwise it will never do time.sleep, which will cause high CPU usage.

def _read(self, timeout: Optional[float]) -> Optional[str]: _timeout = serial.Timeout(timeout) with error_check("Could not read from serial device"): while not _timeout.expired(): new_data = self.serialPortOrig.read_all() if new_data: self._buffer.extend(new_data) else: time.sleep(0.001) continue for terminator in (self._ERROR, self._OK): if terminator in self._buffer: i = self._buffer.index(terminator) + 1 string = self._buffer[:i].decode() del self._buffer[:i] return string return None

The serial port must be instantiated with timeout=0.

By the way, I did not initialize the timeout parameter of serialPortOrig at all and it defaults to None. It seems still works for me.

I'm curious. If you don't set the timeout to 0, what will happen to you?

I'm curious. If you don't set the timeout to 0, what will happen to you?

Nothing, i don't have an interface to test this 😄

According to my test, the MAX receive buffer size in win10 is 16384, and ubuntu 20.04 is 4095. I'm not sure whether it can be changed. But I think there will not be infinite junk.

Interesting! And I agree -- I wasn't considering the physical limitations of the hardware/kernel. Good catch 🙂

mikisama

The timeout parameter still needs to improve.

can/interfaces/slcan.py

mikisama · 2023-01-27T08:51:14Z

@zariiii9003

There is a slight performance difference between the _read method using pyserial.read_all and pyserial.read.
Any suggestions?

Performance Comparison

# the original version
| ID:0x3C | ID:0x3D | <-- 39ms    ---> | ID:0x3C | ID:0x3D |

# the read_all version
| ID:0x3C | ID:0x3D | <-- 2~3.8ms ---> | ID:0x3C | ID:0x3D |

# the read version
| ID:0x3C | ID:0x3D | <-- 1~2ms   ---> | ID:0x3C | ID:0x3D |

the performance test code

from can.interfaces.slcan import slcanBus
from can.message import Message

bus = slcanBus(channel="COM11", bitrate=20000, sleep_after_open=0)

data_frm = Message(
    arbitration_id=0x3C,
    is_extended_id=False,
    is_remote_frame=False,
    dlc=8,
)

remote_frm = Message(
    arbitration_id=0x3D,
    is_extended_id=False,
    is_remote_frame=True,
    dlc=8,
)

for _ in range(16):
    # send a data frame
    bus.send(data_frm)
    # send a remote frame
    bus.send(remote_frm)
    # receive a data frame if a node respond the remote frame
    msg = bus.recv()
    print(msg)

# bus.shutdown()

_read method using pyserial.read_all

def _read(self, timeout: Optional[float]) -> Optional[str]:
    _timeout = serial.Timeout(timeout)

    with error_check("Could not read from serial device"):
        while True:
            new_data = self.serialPortOrig.read_all()
            if new_data:
                self._buffer.extend(new_data)
            else:
                if _timeout.expired():
                    break
                else:
                    time.sleep(0.001)
                    continue

            for terminator in (self._ERROR, self._OK):
                if terminator in self._buffer:
                    i = self._buffer.index(terminator) + 1
                    string = self._buffer[:i].decode()
                    del self._buffer[:i]
                    return string

        return None

_read method using pyserial.read

def _read(self, timeout: Optional[float]) -> Optional[str]:
    _timeout = serial.Timeout(timeout)
    self.serialPortOrig.timeout = timeout

    with error_check("Could not read from serial device"):
        while True:
            new_data = self.serialPortOrig.read()
            if new_data:
                self._buffer.extend(new_data)
            else:
                if _timeout.expired():
                    break
                else:
                    continue

            for terminator in (self._ERROR, self._OK):
                if terminator in self._buffer:
                    i = self._buffer.index(terminator) + 1
                    string = self._buffer[:i].decode()
                    del self._buffer[:i]
                    return string

        return None

zariiii9003 · 2023-01-27T12:04:12Z

Can you tell whether the delay is due to time.sleep or the in_waiting call of pyserial?

mikisama · 2023-01-28T02:09:59Z

Can you tell whether the delay is due to time.sleep or the in_waiting call of pyserial?

@zariiii9003

When I remove time.sleep(0.001), their performance is almost the same. But the CPU usage is high.
Maybe pyserial.read is a better choice. What do you think? 🤔

zariiii9003 · 2023-01-28T10:59:23Z

Yes, i agree, your pyserial.read seems like a good compromise. Regarding the sleep, did you test this on Python 3.11? There have been improvements regards sleep precision.

mikisama · 2023-01-28T12:18:13Z

Yes, you are right. python 3.11.1 have better performance than python 3.10.8.

# the read_all version with python 3.10.8
| ID:0x3C | ID:0x3D | <-- 2~3.8ms ---> | ID:0x3C | ID:0x3D |

# the read_all version with python 3.11.1
| ID:0x3C | ID:0x3D | <-- 1~2.4ms ---> | ID:0x3C | ID:0x3D |

In python 3.11.1, almost all gaps are 2ms, and some gaps are 1ms
In python 3.10.8, almost all gaps are 3ms, and some gaps are 2ms.

zariiii9003 · 2023-01-28T13:22:15Z

Since self.serialPortOrig.read() only reads a single byte, we can simplify the control flow a bit:

    def _read(self, timeout: Optional[float]) -> Optional[str]:
        _timeout = serial.Timeout(timeout)
        self.serialPortOrig.timeout = timeout

        with error_check("Could not read from serial device"):
            while True:
                new_byte = self.serialPortOrig.read(size=1)
                if new_byte:
                    self._buffer.extend(new_byte)

                if new_byte in (self._ERROR, self._OK):
                    string = self._buffer.decode()
                    del self._buffer[:]
                    return string

                if _timeout.expired():
                    break

            return None

I added size=1 and renamed new_data so it is more obvious to the reader.

mikisama · 2023-01-29T01:03:30Z

Since self.serialPortOrig.read() only reads a single byte, we can simplify the control flow a bit:

    def _read(self, timeout: Optional[float]) -> Optional[str]:
        _timeout = serial.Timeout(timeout)
        self.serialPortOrig.timeout = timeout

        with error_check("Could not read from serial device"):
            while True:
                new_byte = self.serialPortOrig.read(size=1)
                if new_byte:
                    self._buffer.extend(new_byte)

                if new_byte in (self._ERROR, self._OK):
                    string = self._buffer.decode()
                    del self._buffer[:]
                    return string

                if _timeout.expired():
                    break

            return None

I added size=1 and renamed new_data so it is more obvious to the reader.

Yes, Looks better. 👍

to make the code easier to understand and read.

mikisama

Still need to improve.

Can not handle partial receive

~~After the test, I found a very strange thing.~~

~~When the timeout=0, the previous version received fewer None.~~

Before.

After change.

mikisama

Still need to improve.

can/interfaces/slcan.py

the full SLCAN message.

the class variable `self._buffer` can be replaced by the local variable `buffer`.

This reverts commit 3eb80b9.

mikisama · 2023-01-29T04:40:54Z

can/interfaces/slcan.py

                        string = self._buffer[:i].decode()
                        del self._buffer[:i]
                        return string
+                else:
+                    if _timeout.expired():


Do we really need _timeout to handle timeout?

The timeout can be determined when pyserial.read returns b''.

The timeout of pyserial.read is reset on every read call, so it might add up. The timeout argument of the user should be respected, _timeout takes care of that.

I think the timeout's add up should be ignored.
For python on windows, the timer's resolution is about 16ms, obviously it is not very accurate.
And I think the timeout add up is not as big as the impact of timer jitter.

That depends on the timeout value, It might be seconds, or minutes, or hours, i don't know what users might be doing.

zariiii9003 · 2023-01-29T11:57:59Z

You call it with timeout=0, it times out immediately. Call it with timeout=None for a blocking call. That behaviour seems correct to me.

mikisama · 2023-01-29T12:48:51Z

You call it with timeout=0, it times out immediately. Call it with timeout=None for a blocking call. That behaviour seems correct to me.

Yes, calling it with timeout=None is ok, and I rarely set timeout to 0 when I actually use it.
But some unit tests contain recv(0) and all of them failed.

def _read(self, timeout: Optional[float]) -> Optional[str]:
    _timeout = serial.Timeout(timeout)
    self.serialPortOrig.timeout = timeout

    with error_check("Could not read from serial device"):
        while True:
            new_byte = self.serialPortOrig.read(1)
            if new_byte:
                self._buffer.extend(new_byte)

            if new_byte in (self._ERROR, self._OK):
                string = self._buffer.decode()
                del self._buffer[:]
                return string

            if _timeout.expired():
                break

        return None

zariiii9003 · 2023-01-29T13:24:26Z

How about this? I added the in_waiting check before the timeout check.

    def _read(self, timeout: Optional[float]) -> Optional[str]:
        _timeout = serial.Timeout(timeout)
        self.serialPortOrig.timeout = timeout

        with error_check("Could not read from serial device"):
            while True:
                new_byte = self.serialPortOrig.read(size=1)
                if new_byte:
                    self._buffer.extend(new_byte)

                if new_byte in (self._ERROR, self._OK):
                    string = self._buffer.decode()
                    del self._buffer[:]
                    return string

                if self.serialPortOrig.in_waiting:
                    continue

                if _timeout.expired():
                    break

            return None

mikisama · 2023-01-29T13:35:01Z

How about this? I added the in_waiting check before the timeout check.

    def _read(self, timeout: Optional[float]) -> Optional[str]:
        _timeout = serial.Timeout(timeout)
        self.serialPortOrig.timeout = timeout

        with error_check("Could not read from serial device"):
            while True:
                new_byte = self.serialPortOrig.read(size=1)
                if new_byte:
                    self._buffer.extend(new_byte)

                if new_byte in (self._ERROR, self._OK):
                    string = self._buffer.decode()
                    del self._buffer[:]
                    return string

                if self.serialPortOrig.in_waiting:
                    continue

                if _timeout.expired():
                    break

            return None

Unit test passed.
Currently, I don't have a SLCAN device around. I'll have to do a test with a SLCAN device tomorrow and tell you the results.

zariiii9003 · 2023-01-30T08:35:35Z

What if we call in_waiting only once?

    def _read(self, timeout: Optional[float]) -> Optional[str]:
        _timeout = serial.Timeout(timeout)
        self.serialPortOrig.timeout = timeout

        with error_check("Could not read from serial device"):
            while True:
                for _ in range(max(1, self.serialPortOrig.in_waiting)):
                    new_byte = self.serialPortOrig.read(size=1)
                    if new_byte:
                        self._buffer.extend(new_byte)
					else:
					    break
				    
                    if new_byte in (self._ERROR, self._OK):
                        string = self._buffer.decode()
                        del self._buffer[:]
                        return string

                if _timeout.expired():
                    break

            return None

Edit: i added max, otherwise we'll cause a hot loop and high CPU usage again.

mikisama · 2023-01-30T11:05:16Z

What if we call in_waiting only once?

    def _read(self, timeout: Optional[float]) -> Optional[str]:
        _timeout = serial.Timeout(timeout)
        self.serialPortOrig.timeout = timeout

        with error_check("Could not read from serial device"):
            while True:
                for _ in range(max(1, self.serialPortOrig.in_waiting)):
                    new_byte = self.serialPortOrig.read(size=1)
                    if new_byte:
                        self._buffer.extend(new_byte)
					else:
					    break
				    
                    if new_byte in (self._ERROR, self._OK):
                        string = self._buffer.decode()
                        del self._buffer[:]
                        return string

                if _timeout.expired():
                    break

            return None

Edit: i added max, otherwise we'll cause a hot loop and high CPU usage again.

Better than pyserial.read_all version but not as good as justpyserial.read.
CPU usage is almost unchanged

mikisama · 2023-01-30T11:49:55Z

I try remove the _timeout

def _read(self, timeout: Optional[float]) -> Optional[str]:
    self.serialPortOrig.timeout = timeout

    with error_check("Could not read from serial device"):
        while True:
            new_byte = self.serialPortOrig.read(1)
            if new_byte:
                self._buffer.extend(new_byte)
                if new_byte in (self._ERROR, self._OK):
                    i = self._buffer.index(new_byte) + 1
                    string = self._buffer[:i].decode()
                    del self._buffer[:i]
                    return string
            else:
                break

        return None

Then run this code

from can.interfaces.slcan import slcanBus
from can.message import Message

bus = slcanBus(channel="COM11", bitrate=20000, sleep_after_open=0)

data_frm = Message(
    arbitration_id=0x3C,
    is_extended_id=False,
    is_remote_frame=False,
    dlc=8,
    data=bytes(
        [
            0x01,
            0x02,
            0x10,
            0x01,
            0xFF,
            0xFF,
            0xFF,
            0xFF,
        ]
    ),
)

remote_frm = Message(
    arbitration_id=0x3D,
    is_extended_id=False,
    is_remote_frame=True,
    dlc=8,
    data=None,
)

TIMEOUT = 1
# TIMEOUT = 10
# TIMEOUT = 100

for _ in range(64):
    # send a data frame
    bus.send(data_frm)
    # send a remote frame
    bus.send(remote_frm)
    # receive a data frame if a node respond the remote frame
    # I make the stm32 device not ack the remote frame, so `recv` will always bloking and return `None`
    msg = bus.recv(TIMEOUT)
    assert msg is None
    print(msg)

# bus.shutdown()

TIMEOUT=1 and we got 1006.03ms

TIMEOUT=10 and we got 10.00914s =>10009.14ms

TIMEOUT=100 and we got 1:40.01856 => 100018.56ms

The pyserial.timeout was more accurate than we expected.
The timeout add-up effect is not obvious.

zariiii9003 · 2023-01-30T12:25:50Z

But how can you ensure the timeout? Try this example:

import time
from threading import Thread

from can.interfaces.slcan import slcanBus


def send_thread(_bus: slcanBus):
    while True:
        bus.serialPortOrig.write(b"f")
        time.sleep(2.0)


if __name__ == '__main__':
    bus = slcanBus(channel="loop://")
    thread = Thread(target=send_thread, args=(bus,))
    thread.start()
    while True:
        t0 = time.perf_counter()
        bus.recv(3.0)
        print(time.perf_counter() - t0)

It should time out every 3 seconds, but it blocks forever.

mikisama · 2023-01-31T00:30:34Z

But how can you ensure the timeout? Try this example:

import time
from threading import Thread

from can.interfaces.slcan import slcanBus


def send_thread(_bus: slcanBus):
    while True:
        bus.serialPortOrig.write(b"f")
        time.sleep(2.0)


if __name__ == '__main__':
    bus = slcanBus(channel="loop://")
    thread = Thread(target=send_thread, args=(bus,))
    thread.start()
    while True:
        t0 = time.perf_counter()
        bus.recv(3.0)
        print(time.perf_counter() - t0)

It should time out every 3 seconds, but it blocks forever.

Thanks for the example code, I finally get your point.

I noticed that there are two types of SLCAN devices categorized by how data is transmitted to the PC.

Serial based. The MCU sends the SLCAN data byte by byte to FT232 through the UART, then the FT232 sends the SLCAN data to PC through the USB.

CAN <--> MCU <--> FT232 <--> PC

USB CDC VCOM based. The MCU sends the whole SLCAN data to the PC via one USB transfer.

CAN <--> MCU <--> PC

Since my SLCAN device is CDC VCOM based. Before seeing your example code, I don't understand why there is an add-up effect.😂

mikisama · 2023-01-31T01:44:32Z

What if we call in_waiting only once?

    def _read(self, timeout: Optional[float]) -> Optional[str]:
        _timeout = serial.Timeout(timeout)
        self.serialPortOrig.timeout = timeout

        with error_check("Could not read from serial device"):
            while True:
                for _ in range(max(1, self.serialPortOrig.in_waiting)):
                    new_byte = self.serialPortOrig.read(size=1)
                    if new_byte:
                        self._buffer.extend(new_byte)
					else:
					    break
				    
                    if new_byte in (self._ERROR, self._OK):
                        string = self._buffer.decode()
                        del self._buffer[:]
                        return string

                if _timeout.expired():
                    break

            return None

Edit: i added max, otherwise we'll cause a hot loop and high CPU usage again.

@zariiii9003
I'm sorry. This code works fine. I don't know why the test result was not very good yesterday.
This code is currently the best solution.

But it still can't handle timeout accurately.

mikisama · 2023-01-31T02:02:24Z

I change self.serialPortOrig.timeout=timeout to self.serialPortOrig.timeout=0.001
It can now handle timeout with relative accuracy.

…readable.

mikisama · 2023-01-31T05:04:21Z

can/interfaces/slcan.py

@@ -287,7 +287,9 @@ def get_version(

        string = self._read(timeout)

-        if len(string) == 6 and string[0] == cmd:
+        if not string:


Re-added the None checking.
Due to the unit test using the loop:// parameter, self._read will read back the content sent by self._write(cmd). It can not catch the None error.

the data in the input buffer.

mikisama · 2023-01-31T09:04:19Z

@zariiii9003
Do you know what's wrong with pypy?
Some github CI tests failed, and they were all pypy based.

zariiii9003

LGTM. I will merge if you are happy with the performance.

mikisama · 2023-02-04T04:43:59Z

LGTM. I will merge if you are happy with the performance.

Thanks for your review. The performance seems to be good so far.

Improve slcan.py

2c9e1e6

1. Improve receiving performance 2. Fix an issue that the first read may blocking even if the `timeout` parameter is not `None`.

zariiii9003 reviewed Jan 17, 2023

View reviewed changes

Tbruno25 mentioned this pull request Jan 20, 2023

Add unittest to verify interface Bus.recv timeouts #1492

Closed

mikisama and others added 2 commits January 27, 2023 14:14

Merge branch 'hardbyte:develop' into develop

f95ca7d

use read_all to read out serial port data.

7fa9f5c

mikisama commented Jan 27, 2023

View reviewed changes

can/interfaces/slcan.py Outdated Show resolved Hide resolved

fix when the timeout parameter is 0, it cannot enter the while loop.

c581cc9

zariiii9003 added the backend:slcan label Jan 27, 2023

zariiii9003 added this to the Next Release milestone Jan 27, 2023

For performance reason, revert to using read to read serial data.

8722a11

add size=1 and renamed new_data to new_byte

fa62a63

to make the code easier to understand and read.

mikisama commented Jan 29, 2023

View reviewed changes

can/interfaces/slcan.py Outdated Show resolved Hide resolved

mikisama added 4 commits January 29, 2023 10:53

fix the issue of returning None before receiving

73ce3dd

the full SLCAN message.

Due to the simplification of the control flow,

3eb80b9

the class variable `self._buffer` can be replaced by the local variable `buffer`.

Revert "Due to the simplification of the control flow,"

2bbee49

This reverts commit 3eb80b9.

Simplify the control flow for finding the end of a SLCAN message.

1635381

mikisama commented Jan 29, 2023

View reviewed changes

mikisama and others added 7 commits January 31, 2023 10:12

improve the timeout handling of slcan.py

42db106

Merge branch 'hardbyte:develop' into develop

6f994cc

Change the plain format calls to f-strings.

3c8a9e3

using bytearray.fromhex to parse the frame's data.

ce3b9a4

change del self._buffer[:] to self._buffer.clear since it's more …

2c22b4e

…readable.

Simplify the timeout handling

09e1248

fix the issue when the returned string is None.

e3a388b

mikisama commented Jan 31, 2023

View reviewed changes

using pyserial.reset_input_buffer to discard

370a2ff

the data in the input buffer.

mikisama added 2 commits February 1, 2023 08:59

fix failing PyPy test

68c9c71

fix failing PyPy test

cec01d7

mikisama requested review from zariiii9003 and Tbruno25 and removed request for zariiii9003 and Tbruno25 February 1, 2023 01:29

improve the comments

6c3b13a

zariiii9003 approved these changes Feb 2, 2023

View reviewed changes

zariiii9003 merged commit b16f8aa into hardbyte:develop Feb 4, 2023

silverv mentioned this pull request Apr 21, 2023

Fix inefficiencies, causes write delays to drop #1572

Draft

zariiii9003 mentioned this pull request Dec 13, 2024

SLCAN problems retrieving the interface's serial number and version #1902

Closed

Improve slcan.py #1490

Improve slcan.py #1490

Conversation

mikisama commented Jan 17, 2023

mikisama commented Jan 17, 2023

test code

gap is 39ms

gap is 1ms

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mikisama Jan 27, 2023 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mikisama left a comment

Choose a reason for hiding this comment

mikisama commented Jan 27, 2023 • edited Loading

Performance Comparison

the performance test code

_read method using pyserial.read_all

_read method using pyserial.read

zariiii9003 commented Jan 27, 2023

mikisama commented Jan 28, 2023

zariiii9003 commented Jan 28, 2023

mikisama commented Jan 28, 2023 • edited Loading

zariiii9003 commented Jan 28, 2023

mikisama commented Jan 29, 2023

mikisama left a comment • edited Loading

Choose a reason for hiding this comment

mikisama left a comment

Choose a reason for hiding this comment

mikisama Jan 29, 2023 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

zariiii9003 commented Jan 29, 2023

mikisama commented Jan 29, 2023

zariiii9003 commented Jan 29, 2023

mikisama commented Jan 29, 2023

zariiii9003 commented Jan 30, 2023 • edited Loading

mikisama commented Jan 30, 2023

mikisama commented Jan 30, 2023

zariiii9003 commented Jan 30, 2023

mikisama commented Jan 31, 2023 • edited Loading

mikisama commented Jan 31, 2023 • edited Loading

mikisama commented Jan 31, 2023

mikisama Jan 31, 2023 • edited Loading

Choose a reason for hiding this comment

mikisama commented Jan 31, 2023

zariiii9003 left a comment

Choose a reason for hiding this comment

mikisama commented Feb 4, 2023

mikisama Jan 27, 2023 •

edited

Loading

mikisama commented Jan 27, 2023 •

edited

Loading

mikisama commented Jan 28, 2023 •

edited

Loading

mikisama left a comment •

edited

Loading

mikisama Jan 29, 2023 •

edited

Loading

zariiii9003 commented Jan 30, 2023 •

edited

Loading

mikisama commented Jan 31, 2023 •

edited

Loading

mikisama commented Jan 31, 2023 •

edited

Loading

mikisama Jan 31, 2023 •

edited

Loading