3
M]W; @ s d Z ddlZddlZG dd dejZejdd Zejdd Zed krG d
d d ej Z
ej Z ee e
d d
dZ
e je
e j e j dS )zSupport asyncio with serial ports. EXPERIMENTAL
Posix platforms only, Python 3.4+ only.
Windows event loops can not wait for serial ports with the current
implementation. It should be possible to get that working though.
Nc s e Zd ZdZ fddZedd Zdd Zdd Zd
d Z d d
Z
dd Z dd Z dd Z
dd Zd:ddZdd Zdd Zd d Zd d Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd;d-d.ZdSerialTransportug An asyncio transport model of a serial communication channel.
A transport class is an abstraction of a communication channel.
This allows protocol implementations to be developed against the
transport abstraction without needing to know the details of the
underlying channel, such as whether it is a pipe, a socket, or
indeed a serial port.
You generally won’t instantiate a transport yourself; instead, you
will call `create_serial_connection` which will create the
transport and try to initiate the underlying communication channel,
calling you back when it succeeds.
c sv t j || _|| _|| _d| _d| _d| _g | _| j d| _
d| _ d| j_ d| j_
|j|j| |j| j d S )NFi r )super__init___loop _protocol_serial_closing_protocol_paused_max_read_size
_write_buffer_set_write_buffer_limits _has_reader _has_writerZtimeoutZ
write_timeout call_soonconnection_made_ensure_reader)selfloopprotocolZserial_instance) __class__ /usr/lib/python3.6/aio.pyr % s
zSerialTransport.__init__c C s | j S )z The underlying Serial instance.)r )r r r r serial< s zSerialTransport.serialc C s dj | dS )NzH{self.__class__.__name__}({self._loop}, {self._protocol}, {self.serial}))r )format)r r r r __repr__A s zSerialTransport.__repr__c C s | j S )z2Return True if the transport is closing or closed.)r )r r r r
is_closingD s zSerialTransport.is_closingc C s | j s| jd dS )aD Close the transport gracefully.
Any buffered data will be written asynchronously. No more data
will be received and further writes will be silently ignored.
After all buffered data is flushed, the protocol's
connection_lost() method will be called with None as its
argument.
N)r _close)r r r r closeH s zSerialTransport.closec C sX y| j j| j}W n0 tjk
rB } z| j|d W Y d d }~X nX |rT| jj| d S )N)exc)r readr
r SerialExceptionr r
data_received)r dataer r r _read_readyT s zSerialTransport._read_readyc C s | j r
dS | j dkrzy| jj|}W n. tjk
rT } z| j|d dS d}~X nX |t|krfdS ||d }| j | j j
| | j dS )zWrite some data to the transport.
This method does not block; it buffers the data and arranges
for it to be sent out asynchronously. Writes made after the
transport has been closed will be ignored.Nr z%Fatal write error on serial transport) r get_write_buffer_sizer writer r _fatal_errorlen_ensure_writerr append_maybe_pause_protocol)r r" nr r r r r& ] s zSerialTransport.writec C s dS )z_Serial ports do not support the concept of end-of-file.
Always returns False.
Fr )r r r r
can_write_eofv s z SerialTransport.can_write_eofc C s | j dS )u Pause the receiving end of the transport.
No data will be passed to the protocol’s data_received() method
until resume_reading() is called.
N)_remove_reader)r r r r
pause_reading} s z SerialTransport.pause_readingc C s | j dS )zResume the receiving end of the transport.
Incoming data will be passed to the protocol's data_received()
method until pause_reading() is called.
N)r )r r r r resume_reading s z SerialTransport.resume_readingNc C s | j ||d | j dS )uL Set the high- and low-water limits for write flow control.
These two values control when call the protocol’s
pause_writing()and resume_writing() methods are called. If
specified, the low-water limit must be less than or equal to
the high-water limit. Neither high nor low can be negative.
)highlowN)r r+ )r r1 r2 r r r set_write_buffer_limits s z'SerialTransport.set_write_buffer_limitsc C s t tt| jS )zThe number of bytes in the write buffer.
This buffer is unbounded, so the result may be larger than the
the high water mark.
)summapr( r )r r r r r% s z%SerialTransport.get_write_buffer_sizec C s t dd S )Nz-Serial connections do not support end-of-file)NotImplementedError)r r r r write_eof s zSerialTransport.write_eofc C s | j d dS )a. Close the transport immediately.
Pending operations will not be given opportunity to complete,
and buffered data will be lost. No more data will be received
and further writes will be ignored. The protocol's
connection_lost() method will eventually be called.
N)_abort)r r r r abort s zSerialTransport.abortc C sl | j | jkrdS | jshd| _y| jj W n: tk
rf } z | jjd|| | jd W Y dd}~X nX dS )a
To be called whenever the write-buffer size increases.
Tests the current write-buffer size against the high water
mark configured for this transport. If the high water mark is
exceeded, the protocol is instructed to pause_writing().
NTz protocol.pause_writing() failed)message exception transportr )r% _high_waterr r
pause_writing Exceptionr call_exception_handler)r r r r r r+ s z%SerialTransport._maybe_pause_protocolc C sh | j rd| j | jkrdd| _ y| jj W n: tk
rb } z | jjd|| | jd W Y dd}~X nX dS )a- To be called whenever the write-buffer size decreases.
Tests the current write-buffer size against the low water
mark configured for this transport. If the write-buffer
size is below the low water mark, the protocol is
instructed that is can resume_writing().
Fz protocol.resume_writing() failed)r: r; r< r N)r r%
_low_waterr resume_writingr? r r@ )r r r r r _maybe_resume_protocol s z&SerialTransport._maybe_resume_protocolc C s dj | j}t|}| jj y| jj|}W nR ttfk
rR | jj| Y n t j
k
r } z| j |d W Y dd}~X nXX |t|kr| j | j
| jr| j r| j dS ||d }| jj| | j
dS )a Asynchronously write buffered data.
This method is called back asynchronously as a writer
registered with the asyncio event-loop against the
underlying file descriptor for the serial port.
Should the write-buffer become empty if this method
is invoked while the transport is closing, the protocol's
connection_lost() method will be called with None as its
argument.
z%Fatal write error on serial transportN)joinr r( clearr r& BlockingIOErrorInterruptedErrorr* r r r' _remove_writerrC r _flushedr )r r" Z num_bytesr, r r r r _write_ready s&
z SerialTransport._write_readyc C s. | j r*| j r*| jj| jj| j d| _ d S )NT)r
r r Z
add_readerr fdr$ )r r r r r s z SerialTransport._ensure_readerc C s | j r | jj| jj d| _ d S )NF)r
r Z
remove_readerr rL )r r r r r. s z SerialTransport._remove_readerc C s. | j r*| j r*| jj| jj| j d| _ d S )NT)r r r Z
add_writerr rL rK )r r r r r) s z SerialTransport._ensure_writerc C s | j r | jj| jj d| _ d S )NF)r r Z
remove_writerr rL )r r r r rI s z SerialTransport._remove_writerc C sd |dkr |dkrdnd| }|dkr,|d }|| ko>dkn sTt d||f || _|| _dS )z&Ensure consistent write-buffer limits.N@ i r z*high (%r) must be >= low (%r) must be >= 0i )
ValueErrorr= rA )r r1 r2 r r r r s z(SerialTransport._set_write_buffer_limits Fatal error on serial transportc C s& | j j||| | jd | j| dS )z?Report a fatal error to the event-loop and abort the transport.)r: r; r< r N)r r@ r r8 )r r r: r r r r' " s z SerialTransport._fatal_errorc C s | j dkS )z3True if the write buffer is empty, otherwise False.r )r% )r r r r rJ , s zSerialTransport._flushedc C s2 d| _ | j | j r.| j | jj| j| dS )a Close the transport gracefully.
If the write buffer is already empty, writing will be
stopped immediately and a call to the protocol's
connection_lost() method scheduled.
If the write buffer is not already empty, the
asynchronous writing will continue, and the _write_ready
method will call this _close method again when the
buffer has been flushed completely.
TN)r r. rJ rI r r _call_connection_lost)r r r r r r 0 s
zSerialTransport._closec C s* d| _ | j | j | jj| j| dS )aP Close the transport immediately.
Pending operations will not be given opportunity to complete,
and buffered data will be lost. No more data will be received
and further writes will be ignored. The protocol's
connection_lost() method will eventually be called with the
passed exception.
TN)r r. rI r r rQ )r r r r r r8 B s zSerialTransport._abortc C sH | j j z| jj| W d| jj | j j d| _ d| _d| _X dS )zClose the connection.
Informs the protocol through connection_lost() and clears
pending buffers and closes the serial connection.
N)r flushr connection_lostr rF r r )r r r r r rQ P s
z%SerialTransport._call_connection_lost)NN)NN)rP )N)!__name__
__module__ __qualname____doc__r propertyr r r r r$ r& r- r/ r0 r3 r% r7 r9 r+ rC rK r r. r) rI r r' rJ r r8 rQ
__classcell__r r )r r r s8
+
r c O s& t j||}| }t| ||}||fS )N)r Zserial_for_urlr )r protocol_factoryargskwargsZserr r< r r r create_serial_connectiond s r] c + s | j dtj }| j dtjj}tj||d}tj||d x2tf | fddd| D ]\}}||fV qZW tj| ||}t ||dS ) a A wrapper for create_serial_connection() returning a (reader,
writer) pair.
The reader returned is a StreamReader instance; the writer is a
StreamWriter instance.
The arguments are all the usual arguments to Serial(). Additional
optional keyword arguments are loop (to set the event loop instance
to use) and limit (to set the buffer limit passed to the
StreamReader.
This function is a coroutine.
r limit)r^ r )r c s S )Nr r )r r r s z(open_serial_connection..)r rZ N)
getasyncioget_event_loopZstreamsZ_DEFAULT_LIMIT StreamReaderZStreamReaderProtocolr] StreamWriter
StopIteration)r\ r r^ readerr< _writerr )r r open_serial_connectionl s ri __main__c @ s4 e Zd Zdd Zdd Zdd Zdd Zd d
Zd S ) Outputc C s& || _ td| d|j_|jd d S )Nz port openedFs hello world
)r< printr Zrtsr& )r r< r r r r s
zOutput.connection_madec C s$ t dt| d|kr | jj d S )Nz
data received
)rl reprr< r )r r" r r r r! s zOutput.data_receivedc C s t d tj j d S )Nz port closed)rl ra rb stop)r r r r r rS s zOutput.connection_lostc C s t d t | jj d S )Nz
pause writing)rl r< r% )r r r r r> s zOutput.pause_writingc C s t | jj t d d S )Nzresume writing)rl r< r% )r r r r rB s zOutput.resume_writingN)rT rU rV r r! rS r> rB r r r r rk s
rk z /dev/ttyUSB0i )Zbaudrate)rW ra r Z Transportr coroutiner] ri rT ZProtocolrk rb r coroZrun_until_completeZ run_foreverr r r r r s Q#