1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
UART
****
.. py:module:: microbit.uart
The ``uart`` module lets you talk to a device connected to your board using
a serial interface.
Functions
=========
.. method:: init(baudrate=9600, bits=8, parity=None, stop=1, \*, tx=None, rx=None)
Initialize serial communication with the specified parameters on the
specified ``tx`` and ``rx`` pins. Note that for correct communication, the parameters
have to be the same on both communicating devices.
.. warning::
Initializing the UART on external pins will cause the Python console on
USB to become unaccessible, as it uses the same hardware. To bring the
console back you must reinitialize the UART without passing anything for
``tx`` or ``rx`` (or passing ``None`` to these arguments). This means
that calling ``uart.init(115200)`` is enough to restore the Python console.
The ``baudrate`` defines the speed of communication. Common baud
rates include:
* 9600
* 14400
* 19200
* 28800
* 38400
* 57600
* 115200
The ``bits`` defines the size of bytes being transmitted, and the board
only supports 8. The ``parity`` parameter defines how parity is checked,
and it can be ``None``, ``microbit.uart.ODD`` or ``microbit.uart.EVEN``.
The ``stop`` parameter tells the number of stop bits, and has to be 1 for
this board.
If ``tx`` and ``rx`` are not specified then the internal USB-UART TX/RX pins
are used which connect to the USB serial converter on the micro:bit, thus
connecting the UART to your PC. You can specify any other pins you want by
passing the desired pin objects to the ``tx`` and ``rx`` parameters.
.. note::
When connecting the device, make sure you "cross" the wires -- the TX
pin on your board needs to be connected with the RX pin on the device,
and the RX pin -- with the TX pin on the device. Also make sure the
ground pins of both devices are connected.
.. method:: uart.any()
Return ``True`` if any data is waiting, else ``False``.
.. method:: uart.read([nbytes])
Read bytes. If ``nbytes`` is specified then read at most that many
bytes, otherwise read as many bytes as possible.
Return value: a bytes object or ``None`` on timeout.
A bytes object contains a sequence of bytes. Because
`ASCII <https://en.wikipedia.org/wiki/ASCII>`_ characters can fit in
single bytes this type of object is often used to represent simple text
and offers methods to manipulate it as such, e.g. you can display the text
using the ``print()`` function.
You can also convert this object into a string object, and if there are
non-ASCII characters present the encoding can be specified::
msg_bytes = uart.read()
msg_str = str(msg, 'UTF-8')
.. note::
The timeout for all UART reads depends on the baudrate and is otherwise
not changeable via Python. The timeout, in milliseconds, is given by:
``microbit_uart_timeout_char = 13000 / baudrate + 1``
.. note::
The internal UART RX buffer is 64 bytes, so make sure data is read
before the buffer is full or some of the data might be lost.
.. warning::
Receiving ``0x03`` will stop your program by raising a Keyboard
Interrupt. You can enable or disable this using
:func:`micropython.kbd_intr()`.
.. method:: uart.readall()
Removed since version 1.0.
Instead, use :func:`uart.read()` with no arguments, which will read as much data
as possible.
.. method:: uart.readinto(buf[, nbytes])
Read bytes into the ``buf``. If ``nbytes`` is specified then read at most
that many bytes. Otherwise, read at most ``len(buf)`` bytes.
Return value: number of bytes read and stored into ``buf`` or ``None`` on
timeout.
.. method:: uart.readline()
Read a line, ending in a newline character.
Return value: the line read or ``None`` on timeout. The newline character is
included in the returned bytes.
.. method:: uart.write(buf)
Write the buffer to the bus, it can be a bytes object or a string::
uart.write('hello world')
uart.write(b'hello world')
uart.write(bytes([1, 2, 3]))
Return value: number of bytes written or ``None`` on timeout.
|
