| Server IP : 23.254.227.96 / Your IP : 216.73.216.183 Web Server : Apache/2.4.62 (Unix) OpenSSL/1.1.1k System : Linux hwsrv-1277026.hostwindsdns.com 4.18.0-477.13.1.el8_8.x86_64 #1 SMP Tue May 30 14:53:41 EDT 2023 x86_64 User : viralblo ( 1001) PHP Version : 8.1.31 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON Directory : /proc/self/root/lib/python3.6/site-packages/serial/__pycache__/ |
Upload File : |
3
M�]W�; � @ s� d Z ddlZddlZG dd� dej�Zejdd� �Zejdd� �Zed kr�G d
d � d ej �Z
ej � Z ee e
d d
d�Z
e je
� e j� e j� dS )z�Support 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� fdd�Zedd� �Zdd� Zdd � Zd
d � Z d d
� Z
dd� Z dd� Z dd� Z
dd� Zd:dd�Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd;d-d.�Zd<d0d1�Zd2d3� Z d=d4d5�Z d6d7� Z d8d9� Z � Z S )>�SerialTransportug 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_soon�connection_made�_ensure_reader)�self�loop�protocolZserial_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 | d�S )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 �data�er r r � _read_readyT s zSerialTransport._read_readyc C s� | j r
dS | j� dkr�y| jj|�}W n. tjk
rT } z| j|d� dS d}~X nX |t|�krfdS |dksrt�||d� }| j � | j
j |� | j � dS )z�Write 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_error�len�AssertionError�_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 )z�Resume 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.
)�high�lowN)r r, )r r2 r3 r r r �set_write_buffer_limits� s z'SerialTransport.set_write_buffer_limitsc C s t tt| j��S )z�The number of bytes in the write buffer.
This buffer is unbounded, so the result may be larger than the
the high water mark.
)�sum�mapr( r )r r r r r% � s z%SerialTransport.get_write_buffer_sizec C s t d��d 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 rA )r r r r r �_maybe_resume_protocol� s z&SerialTransport._maybe_resume_protocolc C s dj | j�}t|�}|s td��| jj� y| jj|�}W nR ttfk
r^ | jj |� Y n� t
j k
r� } z| j |d� W Y dd}~X n|X |t|�kr�| j
� s�t�| j� | j� | jr�| j
� r�| j� dS |dks�t�||d� }| jj |� | j� | j�st�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 Write buffer should not be emptyz%Fatal write error on serial transportNr )�joinr r( r) �clearr r& �BlockingIOError�InterruptedErrorr+ r r r' �_flushed�_remove_writerrD r r r )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 rM )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 rM rL )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 rM )r r r r rK 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> rB )r r2 r3 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 rA r r9 )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 rK 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/ rK r r rR )r r r r r r9 B s zSerialTransport._abortc C sj | j s
t�| j st�| j s"t�| jj� z| jj|� W d| jj � | jj
� d| _d| _d| _ X dS )z�Close the connection.
Informs the protocol through connection_lost() and clears
pending buffers and closes the serial connection.
N) r r) r r
r �flushr �connection_lostr rG r r )r r r r r rR P s
z%SerialTransport._call_connection_lost)NN)NN)rQ )N)!�__name__�
__module__� __qualname__�__doc__r �propertyr r r r r$ r& r. r0 r1 r4 r% r8 r: r, rD rL r r/ r* rK r r' rJ r r9 rR �
__classcell__r r )r r r s8
+
r c O s& t j||�}|� }t| ||�}||fS )N)r Zserial_for_urlr )r �protocol_factory�args�kwargsZserr r= r r r �create_serial_connectiond s r^ c + s� | j dtj� �}| j dtjj�}tj||d�}tj||d�� x2tf |� fdd�d�| ��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 �<lambda>� s z(open_serial_connection.<locals>.<lambda>)r r[ N)
�get�asyncio�get_event_loopZstreamsZ_DEFAULT_LIMIT� StreamReaderZStreamReaderProtocolr^ � StreamWriter�
StopIteration)r] r r_ �readerr= �_�writerr )r r �open_serial_connectionl s rj �__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�
)rm �reprr= r )r r" r r r r! � s zOutput.data_receivedc C s t d� tj� j� d S )Nz port closed)rm rb rc �stop)r r r r r rT � s zOutput.connection_lostc C s t d� t | jj� � d S )Nz
pause writing)rm r= r% )r r r r r? � s zOutput.pause_writingc C s t | jj� � t d� d S )Nzresume writing)rm r= r% )r r r r rC � s zOutput.resume_writingN)rU rV rW r r! rT r? rC r r r r rl � s
rl z /dev/ttyUSB0i � )Zbaudrate)rX rb r Z Transportr � coroutiner^ rj rU ZProtocolrl rc r �coroZrun_until_completeZ run_foreverr r r r r �<module> s Q#