mirror of
https://github.com/sascha-hemi/pycom-documentation.git
synced 2026-03-21 18:06:13 +01:00
135 lines
5.6 KiB
Markdown
135 lines
5.6 KiB
Markdown
---
|
|
search:
|
|
keywords:
|
|
- RMT
|
|
- Remote
|
|
- Remote Controller
|
|
- Pulse
|
|
---
|
|
|
|
# RMT
|
|
|
|
The RMT \(Remote Control\) module is primarily designed to send and receive infrared remote control signals that use on-off-keying of a carrier frequency, but due to its design it can be used to generate various types of signals.
|
|
|
|
## Quick Usage Example: sending
|
|
|
|
```python
|
|
import machine
|
|
|
|
# create a RMT object for transmission
|
|
rmt = machine.RMT(channel=3, gpio="P20", tx_idle_level=0)
|
|
# create series of bits to send
|
|
data = (1,0,1,0,1,0,1,0,1)
|
|
# define duration of the bits, time unit depends on the selected RMT channel
|
|
duration = 10000
|
|
# send the signal
|
|
rmt.send_pulses(duration, data)
|
|
```
|
|
|
|
## Quick Usage Example: receiving
|
|
|
|
```python
|
|
import machine
|
|
# create a RMT object
|
|
rmt = machine.RMT(channel=3)
|
|
# Configure RTM for receiving
|
|
rmt.init(gpio="P20", rx_idle_threshold=12000)
|
|
# wait for any number of pulses until one longer than rx_idle_threshold
|
|
data = rmt.recv_pulses()
|
|
```
|
|
|
|
## Constructors
|
|
|
|
#### class machine.RMT\(channel,...\)
|
|
|
|
Construct an RMT object on the given channel. `channel` can be 2-7. With no additional parameters, the RMT object is created but not initialised. If extra arguments are given, the RMT is initialised for transmission or reception. See `init` for parameters of initialisation. The resolution which a pulse can be sent/received depends on the selected channel:
|
|
|
|
| Channel | Resolution | Maximum Pulse Width |
|
|
| :--- | :--- | :--- |
|
|
| 0 | Used by on-board LED | |
|
|
| 1 | Used by `pycom.pulses_get()` | |
|
|
| 2 | 100nS | 3.2768 ms |
|
|
| 3 | 100nS | 3.2768 ms |
|
|
| 4 | 1000nS | 32.768 ms |
|
|
| 5 | 1000nS | 32.768 ms |
|
|
| 6 | 3125nS | 102.4 ms |
|
|
| 7 | 3125nS | 102.4 ms |
|
|
|
|
## Methods
|
|
|
|
#### rmt.init\(gpio, rx\_idle\_threshold, rx\_filter\_threshold, tx\_idle\_level, tx\_carrier\)
|
|
|
|
Initialise the RMT peripheral with the given parameters:
|
|
|
|
* `gpio` is the GPIO Pin to use.
|
|
* `rx_idle_threshold` is the maximum duration of a valid pulse. The represented time unit \(resolution\) depends on the selected channel, value can be 0-65535.
|
|
* `rx_filter_threshold` is the minimum duration of a valid pulse. The represented time unit \(resolution\) depends on the selected channel, value can be 0-31.
|
|
* `tx_idle_level` is the output signal's level after the transmission is finished, can be RMT.HIGH or RMT.LOW.
|
|
* `tx_carrier` is the modulation of the pulses to send.
|
|
|
|
Either `rx_idle_threshold` or `tx_idle_level` must be defined, both cannot be given at the same time because a channel can be configured in RX or TX mode only. `rx_filter_threshold` is not mandatory parameter. If not given then all pulses are accepted with duration less than `rx_idle_threshold`. `tx_carrier` is not mandatory parameters. If not given no modulation is used on the sent pulses.
|
|
|
|
The `tx_carrier` parameter is a tuple with the following structure:
|
|
|
|
* `carrier_freq_hz` is the carrier's frequency in Hz.
|
|
* `carrier_duty_percent` is the duty percent of the carrier's signal, can be 0%-100%.
|
|
* `carrier_level` is the level of the pulse to modulate, can be RMT.HIGH or RMT.LOW.
|
|
|
|
#### rmt.deinit\(\)
|
|
|
|
Deinitialise the RMT object.
|
|
|
|
{% hint style="info" %}
|
|
If an RMT object needs to be reconfigured from RX/TX to TX/RX, then either first `deinit()` must be called or the `init()` again with the desired configuration.
|
|
{% endhint %}
|
|
|
|
#### rmt.pulses\_get\(pulses, timeout\)
|
|
|
|
Reads in pulses from the GPIO pin.
|
|
|
|
* `pulses` if not specified, this function will keep reading pulses until the
|
|
|
|
`rx_idle_threshold` is exceeded. If it is specified this function will return
|
|
|
|
the exactly that number of pulses, ignoring anything shorter than
|
|
|
|
`rx_filter_threshold` or longer than `rx_idle_threshold`.
|
|
|
|
* `timeout` is specified, this function will return if the first pulse does
|
|
|
|
not occur within `timeout` microseconds. If not specified, it will wait
|
|
|
|
indefinitely.
|
|
|
|
Return value: Tuple of items with the following structure: `(level, duration)`:
|
|
|
|
* `level` represents the level of the received bit/pulse, can be 0 or 1.
|
|
* `duration` represents the duration of the received pulse, the time unit \(resolution\) depends on the selected channel.
|
|
|
|
{% hint style="info" %}
|
|
Maximum of 128 pulses can be received in a row without receiving "idle" signal. If the incoming pulse sequence contains more than 128 pulses the rest is dropped and the receiver waits for another sequence of pulses. The `pulses_get` function can be called to receive more than 128 pulses, however the above mentioned limitation should be kept in mind when evaluating the received data.
|
|
{% endhint %}
|
|
|
|
#### rmt.pulses\_send\(duration, data, start\_level\)
|
|
|
|
Generates pulses as defined by the parameters below
|
|
|
|
* `duration` represents the duration of the pulses to be sent,
|
|
|
|
the time unit \(resolution\) depends on the selected channel.
|
|
|
|
* `data` Tuple that represents the sequence of pulses to be sent, must be
|
|
|
|
composed of 0 or 1 elements.
|
|
|
|
* `start_level` defines the state \(HIGH/LOW\) of the first pulse given by
|
|
|
|
`duration` if `data` is not given.
|
|
|
|
`data` must be a tuple and `duration` can be a tuple or a single number, with `data` being optional. In the case that only `duration` is provided, it must be a tuple and you must also provide `start_level` which will dictate the level of the first duration, the signal level then toggles between each duration value. If `data` is provided and `duration` is a single number, each pulse in `data` will have have an equal length as set by `duration`. If `data` and `duration` are provided as tuples, they must be of the same number of elements, with each pulse lasting its matching duration.
|
|
|
|
## Constants
|
|
|
|
* Define the level of the pulse: `RMT.LOW`, `RMT.HIGH`
|
|
|