> For the complete documentation index, see [llms.txt](https://development-test.pycom.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://development-test.pycom.io/firmware-and-api-reference/pycom/machine/rmt.md). # 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, wait\_tx\_done) 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. * `wait_tx_done` : * `False`: Allows the function to send asynchronosly without waiting for the transmission to be done. * `True`: will wait for transmission to be done ## Constants * Define the level of the pulse: `RMT.LOW`, `RMT.HIGH`