granicus.if.org Git - esp-idf/blob - components/driver/include/driver/rmt.h

   1 // Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #ifndef _DRIVER_RMT_CTRL_H_
  16 #define _DRIVER_RMT_CTRL_H_
  17 #include "esp_err.h"
  18 #include "soc/rmt_reg.h"
  19 #include "soc/dport_reg.h"
  20 #include "soc/rmt_struct.h"
  21 #include "freertos/FreeRTOS.h"
  22 #include "freertos/semphr.h"
  23 #include "freertos/xtensa_api.h"
  24 #include "freertos/ringbuf.h"
  25 #include "driver/gpio.h"
  26 #include "driver/periph_ctrl.h"
  27
  28 #ifdef __cplusplus
  29 extern "C" {
  30 #endif
  31
  32 #define RMT_MEM_BLOCK_BYTE_NUM (256)
  33 #define RMT_MEM_ITEM_NUM  (RMT_MEM_BLOCK_BYTE_NUM/4)
  34
  35 typedef enum {
  36     RMT_CHANNEL_0=0, /*!< RMT Channel0 */
  37     RMT_CHANNEL_1,   /*!< RMT Channel1 */
  38     RMT_CHANNEL_2,   /*!< RMT Channel2 */
  39     RMT_CHANNEL_3,   /*!< RMT Channel3 */
  40     RMT_CHANNEL_4,   /*!< RMT Channel4 */
  41     RMT_CHANNEL_5,   /*!< RMT Channel5 */
  42     RMT_CHANNEL_6,   /*!< RMT Channel6 */
  43     RMT_CHANNEL_7,   /*!< RMT Channel7 */
  44     RMT_CHANNEL_MAX
  45 } rmt_channel_t;
  46
  47 typedef enum {
  48     RMT_MEM_OWNER_TX = 0,  /*!< RMT RX mode, RMT transmitter owns the memory block*/
  49     RMT_MEM_OWNER_RX = 1,  /*!< RMT RX mode, RMT receiver owns the memory block*/
  50     RMT_MEM_OWNER_MAX,
  51 }rmt_mem_owner_t;
  52
  53 typedef enum {
  54     RMT_BASECLK_REF = 0,   /*!< RMT source clock system reference tick, 1MHz by default(Not supported in this version) */
  55     RMT_BASECLK_APB,       /*!< RMT source clock is APB CLK, 80Mhz by default */
  56     RMT_BASECLK_MAX,
  57 } rmt_source_clk_t;
  58
  59 typedef enum {
  60     RMT_DATA_MODE_FIFO = 0,  /*<! RMT memory access in FIFO mode */
  61     RMT_DATA_MODE_MEM = 1,   /*<! RMT memory access in memory mode */
  62     RMT_DATA_MODE_MAX,
  63 } rmt_data_mode_t;
  64
  65 typedef enum {
  66     RMT_MODE_TX=0,   /*!< RMT TX mode */
  67     RMT_MODE_RX,     /*!< RMT RX mode */
  68     RMT_MODE_MAX
  69 } rmt_mode_t;
  70
  71 typedef enum {
  72     RMT_IDLE_LEVEL_LOW=0,   /*!< RMT TX idle level: low Level */
  73     RMT_IDLE_LEVEL_HIGH,    /*!< RMT TX idle level: high Level */
  74     RMT_IDLE_LEVEL_MAX,
  75 } rmt_idle_level_t;
  76
  77 typedef enum {
  78     RMT_CARRIER_LEVEL_LOW=0,  /*!< RMT carrier wave is modulated for low Level output */
  79     RMT_CARRIER_LEVEL_HIGH,   /*!< RMT carrier wave is modulated for high Level output */
  80     RMT_CARRIER_LEVEL_MAX
  81 } rmt_carrier_level_t;
  82
  83 /**
  84  * @brief Data struct of RMT TX configure parameters
  85  */
  86 typedef struct {
  87     bool loop_en;                         /*!< RMT loop output mode*/
  88     uint32_t carrier_freq_hz;             /*!< RMT carrier frequency */
  89     uint8_t carrier_duty_percent;         /*!< RMT carrier duty (%) */
  90     rmt_carrier_level_t carrier_level;    /*!< RMT carrier level */
  91     bool carrier_en;                      /*!< RMT carrier enable */
  92     rmt_idle_level_t idle_level;          /*!< RMT idle level */
  93     bool idle_output_en;                  /*!< RMT idle level output enable*/
  94 }rmt_tx_config_t;
  95
  96 /**
  97  * @brief Data struct of RMT RX configure parameters
  98  */
  99 typedef struct {
 100     bool filter_en;                    /*!< RMT receiver filer enable*/
 101     uint8_t filter_ticks_thresh;       /*!< RMT filter tick  number */
 102     uint16_t idle_threshold;           /*!< RMT RX idle threshold */
 103 }rmt_rx_config_t;
 104
 105 /**
 106  * @brief Data struct of RMT configure parameters
 107  */
 108 typedef struct {
 109     rmt_mode_t rmt_mode;               /*!< RMT mode: transmitter or receiver */
 110     rmt_channel_t channel;             /*!< RMT channel */
 111     uint8_t clk_div;                   /*!< RMT channel counter divider */
 112     gpio_num_t gpio_num;               /*!< RMT GPIO number */
 113     uint8_t mem_block_num;             /*!< RMT memory block number */
 114     union{
 115         rmt_tx_config_t tx_config;     /*!< RMT TX parameter */
 116         rmt_rx_config_t rx_config;     /*!< RMT RX parameter */
 117     };
 118 } rmt_config_t;
 119
 120 typedef intr_handle_t rmt_isr_handle_t;
 121
 122 /**
 123  * @brief Set RMT clock divider, channel clock is divided from source clock.
 124  *
 125  * @param channel RMT channel (0-7)
 126  *
 127  * @param div_cnt RMT counter clock divider
 128  *
 129  * @return
 130  *     - ESP_ERR_INVALID_ARG Parameter error
 131  *     - ESP_OK Success
 132  */
 133 esp_err_t rmt_set_clk_div(rmt_channel_t channel, uint8_t div_cnt);
 134
 135 /**
 136  * @brief Get RMT clock divider, channel clock is divided from source clock.
 137  *
 138  * @param channel RMT channel (0-7)
 139  *
 140  * @param div_cnt pointer to accept RMT counter divider
 141  *
 142  * @return
 143  *     - ESP_ERR_INVALID_ARG Parameter error
 144  *     - ESP_OK Success
 145  */
 146 esp_err_t rmt_get_clk_div(rmt_channel_t channel, uint8_t* div_cnt);
 147
 148 /**
 149  * @brief Set RMT RX idle threshold value
 150  *
 151  *        In receive mode, when no edge is detected on the input signal
 152  *        for longer than idle_thres channel clock cycles,
 153  *        the receive process is finished.
 154  *
 155  * @param channel RMT channel (0-7)
 156  *
 157  * @param thresh RMT RX idle threshold
 158  *
 159  * @return
 160  *     - ESP_ERR_INVALID_ARG Parameter error
 161  *     - ESP_OK Success
 162  */
 163 esp_err_t rmt_set_rx_idle_thresh(rmt_channel_t channel, uint16_t thresh);
 164
 165 /**
 166  * @brief Get RMT idle threshold value.
 167  *
 168  *        In receive mode, when no edge is detected on the input signal
 169  *        for longer than idle_thres channel clock cycles,
 170  *        the receive process is finished.
 171  *
 172  * @param channel RMT channel (0-7)
 173  *
 174  * @param thresh pointer to accept RMT RX idle threshold value
 175  *
 176  * @return
 177  *     - ESP_ERR_INVALID_ARG Parameter error
 178  *     - ESP_OK Success
 179  */
 180 esp_err_t rmt_get_rx_idle_thresh(rmt_channel_t channel, uint16_t *thresh);
 181
 182 /**
 183  * @brief Set RMT memory block number for RMT channel
 184  *
 185  *        This function is used to configure the amount of memory blocks allocated to channel n
 186  *        The 8 channels share a 512x32-bit RAM block which can be read and written
 187  *        by the processor cores over the APB bus, as well as read by the transmitters
 188  *        and written by the receivers.
 189  *        The RAM address range for channel n is start_addr_CHn to end_addr_CHn, which are defined by:
 190  *        Memory block start address is RMT_CHANNEL_MEM(n) (in soc/rmt_reg.h),
 191  *        that is, start_addr_chn = RMT base address + 0x800 + 64 ∗ 4 ∗ n, and
 192  *        end_addr_chn = RMT base address + 0x800 +  64 ∗ 4 ∗ n + 64 ∗ 4 ∗ RMT_MEM_SIZE_CHn mod 512 ∗ 4
 193  *        @note
 194  *        If memory block number of one channel is set to a value greater than 1, this channel will occupy the memory
 195  *        block of the next channel.
 196  *        Channel0 can use at most 8 blocks of memory, accordingly channel7 can only use one memory block.
 197  *
 198  * @param channel RMT channel (0-7)
 199  *
 200  * @param rmt_mem_num RMT RX memory block number, one block has 64 * 32 bits.
 201  *
 202  * @return
 203  *     - ESP_ERR_INVALID_ARG Parameter error
 204  *     - ESP_OK Success
 205  */
 206 esp_err_t rmt_set_mem_block_num(rmt_channel_t channel, uint8_t rmt_mem_num);
 207
 208 /**
 209  * @brief Get RMT memory block number
 210  *
 211  * @param channel RMT channel (0-7)
 212  *
 213  * @param rmt_mem_num Pointer to accept RMT RX memory block number
 214  *
 215  * @return
 216  *     - ESP_ERR_INVALID_ARG Parameter error
 217  *     - ESP_OK Success
 218  */
 219 esp_err_t rmt_get_mem_block_num(rmt_channel_t channel, uint8_t* rmt_mem_num);
 220
 221 /**
 222  * @brief Configure RMT carrier for TX signal.
 223  *
 224  *        Set different values for carrier_high and carrier_low to set different frequency of carrier.
 225  *        The unit of carrier_high/low is the source clock tick, not the divided channel counter clock.
 226  *
 227  * @param channel RMT channel (0-7)
 228  *
 229  * @param carrier_en Whether to enable output carrier.
 230  *
 231  * @param high_level High level duration of carrier
 232  *
 233  * @param low_level Low level duration of carrier.
 234  *
 235  * @param carrier_level Configure the way carrier wave is modulated for channel0-7.
 236  *
 237  *                      1'b1:transmit on low output level
 238  *
 239  *                      1'b0:transmit on high output level
 240  *
 241  * @return
 242  *     - ESP_ERR_INVALID_ARG Parameter error
 243  *     - ESP_OK Success
 244  */
 245 esp_err_t rmt_set_tx_carrier(rmt_channel_t channel, bool carrier_en, uint16_t high_level, uint16_t low_level, rmt_carrier_level_t carrier_level);
 246
 247 /**
 248  * @brief Set RMT memory in low power mode.
 249  *
 250  *        Reduce power consumed by memory. 1:memory is in low power state.
 251  *
 252  * @param channel RMT channel (0-7)
 253  *
 254  * @param pd_en RMT memory low power enable.
 255  *
 256  * @return
 257  *     - ESP_ERR_INVALID_ARG Parameter error
 258  *     - ESP_OK Success
 259  */
 260 esp_err_t rmt_set_mem_pd(rmt_channel_t channel, bool pd_en);
 261
 262 /**
 263  * @brief Get RMT memory low power mode.
 264  *
 265  * @param channel RMT channel (0-7)
 266  *
 267  * @param pd_en Pointer to accept RMT memory low power mode.
 268  *
 269  * @return
 270  *     - ESP_ERR_INVALID_ARG Parameter error
 271  *     - ESP_OK Success
 272  */
 273 esp_err_t rmt_get_mem_pd(rmt_channel_t channel, bool* pd_en);
 274
 275 /**
 276  * @brief Set RMT start sending data from memory.
 277  *
 278  * @param channel RMT channel (0-7)
 279  *
 280  * @param tx_idx_rst Set true to reset memory index for TX.
 281  *        Otherwise, transmitter will continue sending from the last index in memory.
 282  *
 283  * @return
 284  *     - ESP_ERR_INVALID_ARG Parameter error
 285  *     - ESP_OK Success
 286  */
 287 esp_err_t rmt_tx_start(rmt_channel_t channel, bool tx_idx_rst);
 288
 289 /**
 290  * @brief Set RMT stop sending.
 291  *
 292  * @param channel RMT channel (0-7)
 293  *
 294  * @return
 295  *     - ESP_ERR_INVALID_ARG Parameter error
 296  *     - ESP_OK Success
 297  */
 298 esp_err_t rmt_tx_stop(rmt_channel_t channel);
 299
 300 /**
 301  * @brief Set RMT start receiving data.
 302  *
 303  * @param channel RMT channel (0-7)
 304  *
 305  * @param rx_idx_rst Set true to reset memory index for receiver.
 306  *                   Otherwise, receiver will continue receiving data to the last index in memory.
 307  *
 308  * @return
 309  *     - ESP_ERR_INVALID_ARG Parameter error
 310  *     - ESP_OK Success
 311  */
 312 esp_err_t rmt_rx_start(rmt_channel_t channel, bool rx_idx_rst);
 313
 314 /**
 315  * @brief Set RMT stop receiving data.
 316  *
 317  * @param channel RMT channel (0-7)
 318  *
 319  * @return
 320  *     - ESP_ERR_INVALID_ARG Parameter error
 321  *     - ESP_OK Success
 322  */
 323 esp_err_t rmt_rx_stop(rmt_channel_t channel);
 324
 325 /**
 326  * @brief Reset RMT TX/RX memory index.
 327  *
 328  * @param channel RMT channel (0-7)
 329  *
 330  * @return
 331  *     - ESP_ERR_INVALID_ARG Parameter error
 332  *     - ESP_OK Success
 333  */
 334 esp_err_t rmt_memory_rw_rst(rmt_channel_t channel);
 335
 336 /**
 337  * @brief Set RMT memory owner.
 338  *
 339  * @param channel RMT channel (0-7)
 340  *
 341  * @param owner To set when the transmitter or receiver can process the memory of channel.
 342  *
 343  * @return
 344  *     - ESP_ERR_INVALID_ARG Parameter error
 345  *     - ESP_OK Success
 346  */
 347 esp_err_t rmt_set_memory_owner(rmt_channel_t channel, rmt_mem_owner_t owner);
 348
 349 /**
 350  * @brief Get RMT memory owner.
 351  *
 352  * @param channel RMT channel (0-7)
 353  *
 354  * @param owner Pointer to get memory owner.
 355  *
 356  * @return
 357  *     - ESP_ERR_INVALID_ARG Parameter error
 358  *     - ESP_OK Success
 359  */
 360 esp_err_t rmt_get_memory_owner(rmt_channel_t channel, rmt_mem_owner_t* owner);
 361
 362 /**
 363  * @brief Set RMT tx loop mode.
 364  *
 365  * @param channel RMT channel (0-7)
 366  *
 367  * @param loop_en To enable RMT transmitter loop sending mode.
 368  *
 369  *                If set true, transmitter will continue sending from the first data
 370  *                to the last data in channel0-7 again and again.
 371  *
 372  * @return
 373  *     - ESP_ERR_INVALID_ARG Parameter error
 374  *     - ESP_OK Success
 375  */
 376 esp_err_t rmt_set_tx_loop_mode(rmt_channel_t channel, bool loop_en);
 377
 378 /**
 379  * @brief Get RMT tx loop mode.
 380  *
 381  * @param channel RMT channel (0-7)
 382  *
 383  * @param loop_en Pointer to accept RMT transmitter loop sending mode.
 384  *
 385  * @return
 386  *     - ESP_ERR_INVALID_ARG Parameter error
 387  *     - ESP_OK Success
 388  */
 389 esp_err_t rmt_get_tx_loop_mode(rmt_channel_t channel, bool* loop_en);
 390
 391 /**
 392  * @brief Set RMT RX filter.
 393  *
 394  *        In receive mode, channel0-7 will ignore input pulse when the pulse width is smaller than threshold.
 395  *        Counted in source clock, not divided counter clock.
 396  *
 397  * @param channel RMT channel (0-7)
 398  *
 399  * @param rx_filter_en To enable RMT receiver filter.
 400  *
 401  * @param thresh Threshold of pulse width for receiver.
 402  *
 403  * @return
 404  *     - ESP_ERR_INVALID_ARG Parameter error
 405  *     - ESP_OK Success
 406  */
 407 esp_err_t rmt_set_rx_filter(rmt_channel_t channel, bool rx_filter_en, uint8_t thresh);
 408
 409 /**
 410  * @brief Set RMT source clock
 411  *
 412  *        RMT module has two source clock:
 413  *        1. APB clock which is 80Mhz
 414  *        2. REF tick clock, which would be 1Mhz( not supported in this version).
 415  *
 416  * @param channel RMT channel (0-7)
 417  *
 418  * @param base_clk To choose source clock for RMT module.
 419  *
 420  * @return
 421  *     - ESP_ERR_INVALID_ARG Parameter error
 422  *     - ESP_OK Success
 423  */
 424 esp_err_t rmt_set_source_clk(rmt_channel_t channel, rmt_source_clk_t base_clk);
 425
 426 /**
 427  * @brief Get RMT source clock
 428  *
 429  *        RMT module has two source clock:
 430  *        1. APB clock which is 80Mhz
 431  *        2. REF tick clock, which would be 1Mhz( not supported in this version).
 432  *
 433  * @param channel RMT channel (0-7)
 434  *
 435  * @param src_clk Pointer to accept source clock for RMT module.
 436  *
 437  * @return
 438  *     - ESP_ERR_INVALID_ARG Parameter error
 439  *     - ESP_OK Success
 440  */
 441 esp_err_t rmt_get_source_clk(rmt_channel_t channel, rmt_source_clk_t* src_clk);
 442
 443 /**
 444  * @brief Set RMT idle output level for transmitter
 445  *
 446  * @param channel RMT channel (0-7)
 447  *
 448  * @param idle_out_en To enable idle level output.
 449  *
 450  * @param level To set the output signal's level for channel0-7 in idle state.
 451  *
 452  * @return
 453  *     - ESP_ERR_INVALID_ARG Parameter error
 454  *     - ESP_OK Success
 455  */
 456 esp_err_t rmt_set_idle_level(rmt_channel_t channel, bool idle_out_en, rmt_idle_level_t level);
 457
 458 /**
 459  * @brief Get RMT status
 460  *
 461  * @param channel RMT channel (0-7)
 462  *
 463  * @param status Pointer to accept channel status.
 464  *
 465  * @return
 466  *     - ESP_ERR_INVALID_ARG Parameter error
 467  *     - ESP_OK Success
 468  */
 469 esp_err_t rmt_get_status(rmt_channel_t channel, uint32_t* status);
 470
 471 /**
 472  * @brief Set mask value to RMT interrupt enable register.
 473  *
 474  * @param mask Bit mask to set to the register
 475  *
 476  */
 477 void rmt_set_intr_enable_mask(uint32_t mask);
 478
 479 /**
 480  * @brief Clear mask value to RMT interrupt enable register.
 481  *
 482  * @param mask Bit mask to clear the register
 483  *
 484  */
 485 void rmt_clr_intr_enable_mask(uint32_t mask);
 486
 487 /**
 488  * @brief Set RMT RX interrupt enable
 489  *
 490  * @param channel RMT channel (0 - 7)
 491  *
 492  * @param en enable or disable RX interrupt.
 493  *
 494  * @return
 495  *     - ESP_ERR_INVALID_ARG Parameter error
 496  *     - ESP_OK Success
 497  */
 498 esp_err_t rmt_set_rx_intr_en(rmt_channel_t channel, bool en);
 499
 500 /**
 501  * @brief Set RMT RX error interrupt enable
 502  *
 503  * @param channel RMT channel (0 - 7)
 504  *
 505  * @param en enable or disable RX err interrupt.
 506  *
 507  * @return
 508  *     - ESP_ERR_INVALID_ARG Parameter error
 509  *     - ESP_OK Success
 510  */
 511 esp_err_t rmt_set_err_intr_en(rmt_channel_t channel, bool en);
 512
 513 /**
 514  * @brief Set RMT TX interrupt enable
 515  *
 516  * @param channel RMT channel (0 - 7)
 517  *
 518  * @param en enable or disable TX interrupt.
 519  *
 520  * @return
 521  *     - ESP_ERR_INVALID_ARG Parameter error
 522  *     - ESP_OK Success
 523  */
 524 esp_err_t rmt_set_tx_intr_en(rmt_channel_t channel, bool en);
 525
 526 /**
 527  * @brief Set RMT TX threshold event interrupt enable
 528  *
 529  * Causes an interrupt when a threshold number of items have been transmitted.
 530  *
 531  * @param channel RMT channel (0 - 7)
 532  *
 533  * @param en enable or disable TX event interrupt.
 534  *
 535  * @param evt_thresh RMT event interrupt threshold value
 536  *
 537  * @return
 538  *     - ESP_ERR_INVALID_ARG Parameter error
 539  *     - ESP_OK Success
 540  */
 541 esp_err_t rmt_set_tx_thr_intr_en(rmt_channel_t channel, bool en, uint16_t evt_thresh);
 542
 543 /**
 544  * @brief Set RMT pins
 545  *
 546  * @param channel RMT channel (0 - 7)
 547  *
 548  * @param mode TX or RX mode for RMT
 549  *
 550  * @param gpio_num GPIO number to transmit or receive the signal.
 551  *
 552  * @return
 553  *     - ESP_ERR_INVALID_ARG Parameter error
 554  *     - ESP_OK Success
 555  */
 556 esp_err_t rmt_set_pin(rmt_channel_t channel, rmt_mode_t mode, gpio_num_t gpio_num);
 557
 558 /**
 559  * @brief Configure RMT parameters
 560  *
 561  * @param rmt_param RMT parameter structor
 562  *
 563  * @return
 564  *     - ESP_ERR_INVALID_ARG Parameter error
 565  *     - ESP_OK Success
 566  */
 567 esp_err_t rmt_config(rmt_config_t* rmt_param);
 568
 569 /**
 570  * @brief   register RMT interrupt handler, the handler is an ISR.
 571  *
 572  *          The handler will be attached to the same CPU core that this function is running on.
 573  * @note If you already called rmt_driver_install to use system RMT driver,
 574  *          please do not register ISR handler again.
 575  *
 576  * @param fn Interrupt handler function.
 577  * @param arg Parameter for handler function
 578  * @param  intr_alloc_flags Flags used to allocate the interrupt. One or multiple (ORred)
 579  *            ESP_INTR_FLAG_* values. See esp_intr_alloc.h for more info.
 580  * @param  handle If non-zero, a handle to later clean up the ISR gets stored here.
 581  *
 582  * @return
 583  *     - ESP_OK Success
 584  *     - ESP_ERR_INVALID_ARG Function pointer error.
 585  *     - ESP_FAIL System driver installed, can not register ISR handler for RMT
 586  */
 587 esp_err_t rmt_isr_register(void (* fn)(void* ), void * arg, int intr_alloc_flags, rmt_isr_handle_t *handle);
 588
 589 /**
 590  * @brief   Deregister previously registered RMT interrupt handler
 591  *
 592  * @param handle Handle obtained from rmt_isr_register
 593  *
 594  * @return
 595  *     - ESP_OK Success
 596  *     - ESP_ERR_INVALID_ARG Handle invalid
 597  */
 598 esp_err_t rmt_isr_deregister(rmt_isr_handle_t handle);
 599
 600 /**
 601  * @brief Fill memory data of channel with given RMT items.
 602  *
 603  * @param channel RMT channel (0 - 7)
 604  *
 605  * @param item Pointer of items.
 606  *
 607  * @param item_num RMT sending items number.
 608  *
 609  * @param mem_offset Index offset of memory.
 610  *
 611  * @return
 612  *     - ESP_ERR_INVALID_ARG Parameter error
 613  *     - ESP_OK Success
 614  */
 615 esp_err_t rmt_fill_tx_items(rmt_channel_t channel, rmt_item32_t* item, uint16_t item_num, uint16_t mem_offset);
 616
 617 /**
 618  * @brief Initialize RMT driver
 619  *
 620  * @param channel RMT channel (0 - 7)
 621  *
 622  * @param rx_buf_size Size of RMT RX ringbuffer. Can be 0 if the RX ringbuffer is not used.
 623  *
 624  * @param intr_alloc_flags Flags for the RMT driver interrupt handler. Pass 0 for default flags. See esp_intr_alloc.h for details.
 625  *
 626  * @return
 627  *     - ESP_ERR_INVALID_STATE Driver is already installed, call rmt_driver_uninstall first.
 628  *     - ESP_ERR_NO_MEM Memory allocation failure
 629  *     - ESP_ERR_INVALID_ARG Parameter error
 630  *     - ESP_OK Success
 631  */
 632 esp_err_t rmt_driver_install(rmt_channel_t channel, size_t rx_buf_size, int intr_alloc_flags);
 633
 634 /**
 635  * @brief Uninstall RMT driver.
 636  *
 637  * @param channel RMT channel (0 - 7)
 638  *
 639  * @return
 640  *     - ESP_ERR_INVALID_ARG Parameter error
 641  *     - ESP_OK Success
 642  */
 643 esp_err_t rmt_driver_uninstall(rmt_channel_t channel);
 644
 645 /**
 646  * @brief RMT send waveform from rmt_item array.
 647  *
 648  *        This API allows user to send waveform with any length.
 649  *
 650  * @param channel RMT channel (0 - 7)
 651  *
 652  * @param rmt_item head point of RMT items array.
 653  *
 654  * @param item_num RMT data item number.
 655  *
 656  * @param wait_tx_done If set 1, it will block the task and wait for sending done.
 657  *
 658  *                     If set 0, it will not wait and return immediately.
 659  *
 660  *                     @note
 661  *                     This function will not copy data, instead, it will point to the original items,
 662  *                     and send the waveform items.
 663  *                     If wait_tx_done is set to true, this function will block and will not return until
 664  *                     all items have been sent out.
 665  *                     If wait_tx_done is set to false, this function will return immediately, and the driver
 666  *                     interrupt will continue sending the items. We must make sure the item data will not be
 667  *                     damaged when the driver is still sending items in driver interrupt.
 668  *
 669  * @return
 670  *     - ESP_ERR_INVALID_ARG Parameter error
 671  *     - ESP_OK Success
 672  */
 673 esp_err_t rmt_write_items(rmt_channel_t channel, rmt_item32_t* rmt_item, int item_num, bool wait_tx_done);
 674
 675 /**
 676  * @brief Wait RMT TX finished.
 677  *
 678  * @param channel RMT channel (0 - 7)
 679  *
 680  * @return
 681  *     - ESP_ERR_INVALID_ARG Parameter error
 682  *     - ESP_OK Success
 683  */
 684 esp_err_t rmt_wait_tx_done(rmt_channel_t channel);
 685
 686 /**
 687  * @brief Get ringbuffer from UART.
 688  *
 689  *        Users can get the RMT RX ringbuffer handler, and process the RX data.
 690  *
 691  * @param channel RMT channel (0 - 7)
 692  *
 693  * @param buf_handler Pointer to buffer handler to accept RX ringbuffer handler.
 694  *
 695  * @return
 696  *     - ESP_ERR_INVALID_ARG Parameter error
 697  *     - ESP_OK Success
 698  */
 699 esp_err_t rmt_get_ringbuf_handler(rmt_channel_t channel, RingbufHandle_t* buf_handler);
 700
 701 /***************************EXAMPLE**********************************
 702  *
 703  * @note
 704  * You can also refer to example/09_rmt_nec_tx_rx to have more information about how to use RMT module.
 705  *
 706  * ----------------EXAMPLE OF RMT SETTING ---------------------
 707  * @code{c}
 708  * //1. enable RMT
 709  * //enable RMT module, or you can not set any register of it.
 710  * //this will be done in rmt_config API.
 711  * periph_module_enable(PERIPH_RMT_MODULE);
 712  * @endcode
 713  *
 714  * @code{c}
 715  * //2. set RMT transmitter
 716  * void rmt_tx_init()
 717  * {
 718  *     rmt_config_t rmt_tx;
 719  *     rmt_tx.channel = 0;
 720  *     rmt_tx.gpio_num = 16;
 721  *     rmt_tx.mem_block_num = 1;
 722  *     rmt_tx.clk_div = 100;
 723  *     rmt_tx.tx_config.loop_en = false;
 724  *     rmt_tx.tx_config.carrier_duty_percent = 50;
 725  *     rmt_tx.tx_config.carrier_freq_hz = 38000;
 726  *     rmt_tx.tx_config.carrier_level = 1;
 727  *     rmt_tx.tx_config.carrier_en = RMT_TX_CARRIER_EN;
 728  *     rmt_tx.tx_config.idle_level = 0;
 729  *     rmt_tx.tx_config.idle_output_en = true;
 730  *     rmt_tx.rmt_mode = 0;
 731  *     rmt_config(&rmt_tx);
 732  *
 733  *     //install system RMT driver, disable rx ringbuffer for transmitter.
 734  *     rmt_driver_install(rmt_tx.channel, 0, 0);
 735  * }
 736  *
 737  * @endcode
 738  * @code{c}
 739  * //3. set RMT receiver
 740  * void rmt_rx_init()
 741  * {
 742  *     rmt_config_t rmt_rx;
 743  *     rmt_rx.channel = 1;
 744  *     rmt_rx.gpio_num = 19;
 745  *     rmt_rx.clk_div = 100;
 746  *     rmt_rx.mem_block_num = 1;
 747  *     rmt_rx.rmt_mode = RMT_MODE_RX;
 748  *     rmt_rx.rx_config.filter_en = true;
 749  *     rmt_rx.rx_config.filter_ticks_thresh = 100;
 750  *     rmt_rx.rx_config.idle_threshold = 0xffff;
 751  *     rmt_config(&rmt_rx);
 752  *
 753  *     //install system RMT driver.
 754  *     rmt_driver_install(rmt_rx.channel, 1000, 0);
 755  * }
 756  *
 757  * ----------------EXAMPLE OF RMT INTERRUPT ------------------
 758  * @code{c}
 759  *
 760  * rmt_isr_register(rmt_isr, NULL, 0);           //hook the ISR handler for RMT interrupt
 761  * @endcode
 762  * @note
 763  *     0. If you have called rmt_driver_install, you don't need to set ISR handler any more.
 764  *
 765  * ----------------EXAMPLE OF INTERRUPT HANDLER ---------------
 766  * @code{c}
 767  * #include "esp_attr.h"
 768  * void IRAM_ATTR rmt_isr_handler(void* arg)
 769  * {
 770  *    //read RMT interrupt status.
 771  *    uint32_t intr_st = RMT.int_st.val;
 772  *
 773  *    //you will find which channels have triggered fade_end interrupt here,
 774  *    //then, you can post some event to RTOS queue to process the event.
 775  *    //later we will add a queue in the driver code.
 776  *
 777  *   //clear RMT interrupt status.
 778  *    RMT.int_clr.val = intr_st;
 779  * }
 780  * @endcode
 781  *
 782  *--------------------------END OF EXAMPLE --------------------------
 783  */
 784
 785
 786
 787
 788
 789 #ifdef __cplusplus
 790 }
 791 #endif
 792
 793 #endif /* _DRIVER_RMT_CTRL_H_ */