rmt: refactor examples
This commit is contained in:
morris
parent
8fd8695ea1
commit
357cc19da3
|
|
@ -3,4 +3,4 @@
|
|||
cmake_minimum_required(VERSION 3.5)
|
||||
|
||||
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
|
||||
project(infrared_nec)
|
||||
project(ir_protocols)
|
||||
|
|
@ -3,7 +3,7 @@
|
|||
# project subdirectory.
|
||||
#
|
||||
|
||||
PROJECT_NAME := infrared_nec
|
||||
PROJECT_NAME := ir_protocols
|
||||
|
||||
include $(IDF_PATH)/make/project.mk
|
||||
|
||||
72
examples/peripherals/rmt/ir_protocols/README.md
Normal file
72
examples/peripherals/rmt/ir_protocols/README.md
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
# IR Protocol Example
|
||||
|
||||
(See the README.md file in the upper level 'examples' directory for more information about examples.)
|
||||
|
||||
This example illustrates how to encode and decode RMT signals with/to common IR protocols (e.g. NEC and RC5).
|
||||
|
||||
[NEC](https://www.sbprojects.net/knowledge/ir/nec.php) and [RC5](https://www.sbprojects.net/knowledge/ir/rc5.php) have different encoding rules, but both can be compatible to RMT data format.
|
||||
|
||||
The example supports building and parsing both normal and extended NEC/RC5 protocol. And also supports `repeat code` which would be sent out if one remote key got pressed for a specific long time.
|
||||
|
||||
## How to Use Example
|
||||
|
||||
### Hardware Required
|
||||
|
||||
* A development board with ESP32 SoC (e.g. ESP32-DevKitC or ESP-WROVER-KIT)
|
||||
* An USB cable for power supply and programming
|
||||
* A 5mm infrared LED (e.g. IR333C) used to transmit encoded IR signals
|
||||
* An infrared receiver module (e.g. IRM-3638T), which integrates a demodulator and AGC circuit.
|
||||
|
||||
Example connection :
|
||||
|
||||
| ESP32 | IR333C | IRM-3638T |
|
||||
| -------- | ------ | --------- |
|
||||
| GPIO18 | Tx | × |
|
||||
| GPIO19 | × | Rx |
|
||||
| VCC 5V | √ | × |
|
||||
| VCC 3.3V | × | √ |
|
||||
| GND | GND | GND |
|
||||
|
||||
|
||||
### Configure the Project
|
||||
|
||||
Open the project configuration menu (`idf.py menuconfig`).
|
||||
|
||||
In the `Example Connection Configuration` menu:
|
||||
|
||||
* Select the infrared protocol used in the example under `Infrared Protocol` option.
|
||||
* Set the GPIO number used for transmitting the IR signal under `RMT TX GPIO` option.
|
||||
* Set the GPIO number used for receiving the demodulated IR signal under `RMT RX GPIO` option.
|
||||
|
||||
### Build and Flash
|
||||
|
||||
Run `idf.py -p PORT flash monitor` to build, flash and monitor the project.
|
||||
|
||||
(To exit the serial monitor, type ``Ctrl-]``.)
|
||||
|
||||
See the [Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html) for full steps to configure and use ESP-IDF to build projects.
|
||||
|
||||
## Example Output
|
||||
|
||||
Run this example, you will see the following output log (for NEC protocol):
|
||||
```
|
||||
I (2000) example: Send command 0x20 to address 0x10
|
||||
I (2070) example: Scan Code --- addr: 0x0010 cmd: 0x0020
|
||||
I (2220) example: Scan Code (repeat) --- addr: 0x0010 cmd: 0x0020
|
||||
I (4240) example: Send command 0x21 to address 0x10
|
||||
I (4310) example: Scan Code --- addr: 0x0010 cmd: 0x0021
|
||||
I (4460) example: Scan Code (repeat) --- addr: 0x0010 cmd: 0x0021
|
||||
I (6480) example: Send command 0x22 to address 0x10
|
||||
I (6550) example: Scan Code --- addr: 0x0010 cmd: 0x0022
|
||||
I (6700) example: Scan Code (repeat) --- addr: 0x0010 cmd: 0x0022
|
||||
I (8720) example: Send command 0x23 to address 0x10
|
||||
I (8790) example: Scan Code --- addr: 0x0010 cmd: 0x0023
|
||||
I (8940) example: Scan Code (repeat) --- addr: 0x0010 cmd: 0x0023
|
||||
I (10960) example: Send command 0x24 to address 0x10
|
||||
I (11030) example: Scan Code --- addr: 0x0010 cmd: 0x0024
|
||||
I (11180) example: Scan Code (repeat) --- addr: 0x0010 cmd: 0x0024
|
||||
```
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
For any technical queries, please open an [issue] (https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you soon.
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
set(component_srcs "src/ir_builder_rmt_nec.c"
|
||||
"src/ir_builder_rmt_rc5.c"
|
||||
"src/ir_parser_rmt_nec.c"
|
||||
"src/ir_parser_rmt_rc5.c")
|
||||
|
||||
idf_component_register(SRCS "${component_srcs}"
|
||||
INCLUDE_DIRS "include"
|
||||
PRIV_INCLUDE_DIRS ""
|
||||
PRIV_REQUIRES "driver"
|
||||
REQUIRES "")
|
||||
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
COMPONENT_ADD_INCLUDEDIRS := include
|
||||
|
||||
COMPONENT_SRCDIRS := src
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Timings for NEC protocol
|
||||
*
|
||||
*/
|
||||
#define NEC_LEADING_CODE_HIGH_US (9000)
|
||||
#define NEC_LEADING_CODE_LOW_US (4500)
|
||||
#define NEC_PAYLOAD_ONE_HIGH_US (560)
|
||||
#define NEC_PAYLOAD_ONE_LOW_US (1690)
|
||||
#define NEC_PAYLOAD_ZERO_HIGH_US (560)
|
||||
#define NEC_PAYLOAD_ZERO_LOW_US (560)
|
||||
#define NEC_REPEAT_CODE_HIGH_US (9000)
|
||||
#define NEC_REPEAT_CODE_LOW_US (2250)
|
||||
#define NEC_ENDING_CODE_HIGH_US (560)
|
||||
|
||||
/**
|
||||
* @brief Timings for RC5 protocol
|
||||
*
|
||||
*/
|
||||
#define RC5_PULSE_DURATION_US (889)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
@ -0,0 +1,272 @@
|
|||
// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "esp_err.h"
|
||||
|
||||
#define IR_TOOLS_FLAGS_PROTO_EXT (1 << 0) /*!< Enable Extended IR protocol */
|
||||
#define IR_TOOLS_FLAGS_INVERSE (1 << 1) /*!< Inverse the IR signal, i.e. take high level as low, and vice versa */
|
||||
|
||||
/**
|
||||
* @brief IR device type
|
||||
*
|
||||
*/
|
||||
typedef void *ir_dev_t;
|
||||
|
||||
/**
|
||||
* @brief IR builder type
|
||||
*
|
||||
*/
|
||||
typedef struct ir_builder_s ir_builder_t;
|
||||
|
||||
/**
|
||||
* @brief IR parser type
|
||||
*
|
||||
*/
|
||||
typedef struct ir_parser_s ir_parser_t;
|
||||
|
||||
/**
|
||||
* @brief Type definition of IR builder
|
||||
*
|
||||
*/
|
||||
struct ir_builder_s {
|
||||
/**
|
||||
* @brief Period time of sending repeat code
|
||||
*
|
||||
*/
|
||||
uint32_t repeat_period_ms;
|
||||
|
||||
/**
|
||||
* @brief Build frame header
|
||||
*
|
||||
* @param[in] builder: Handle of IR builder
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: Build frame header successfully
|
||||
* - ESP_FAIL: Build frame header failed because some error occurred
|
||||
*/
|
||||
esp_err_t (*make_head)(ir_builder_t *builder);
|
||||
|
||||
/**
|
||||
* @brief Build logic bit zero
|
||||
*
|
||||
* @param[in] builder: Handle of IR builder
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: Build logic bit zero successfully
|
||||
* - ESP_FAIL: Build logic bit zero failed because some error occurred
|
||||
*/
|
||||
esp_err_t (*make_logic0)(ir_builder_t *builder);
|
||||
|
||||
/**
|
||||
* @brief Build logic bit one
|
||||
*
|
||||
* @param[in] builder: Handle of IR builder
|
||||
*
|
||||
* @return
|
||||
* ESP_OK: Build logic bit one successfully
|
||||
* ESP_FAIL: Build logic bit one failed because some error occurred
|
||||
*/
|
||||
esp_err_t (*make_logic1)(ir_builder_t *builder);
|
||||
|
||||
/**
|
||||
* @brief Build frame tail
|
||||
*
|
||||
* @param[in] builder: Handle of IR builder
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: Build frame tail successfully
|
||||
* - ESP_FAIL: Build frame tail failed because some error occurred
|
||||
*/
|
||||
esp_err_t (*make_end)(ir_builder_t *builder);
|
||||
|
||||
/**
|
||||
* @brief Build a complete frame
|
||||
*
|
||||
* @param[in] builder: Handle of IR builder
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: Build a complete frame successfully
|
||||
* - ESP_FAIL: Build a complete frame failed because some error occurred
|
||||
*/
|
||||
esp_err_t (*build_frame)(ir_builder_t *builder, uint32_t address, uint32_t command);
|
||||
|
||||
/**
|
||||
* @brief Build a repeat frame
|
||||
*
|
||||
* @param[in] builder: Handle of IR builder
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: Build a repeat frame successfully
|
||||
* - ESP_FAIL: Build a repeat frame failed because some error occurred
|
||||
*/
|
||||
esp_err_t (*build_repeat_frame)(ir_builder_t *builder);
|
||||
|
||||
/**
|
||||
* @brief Get the result frame after a series of building steps
|
||||
*
|
||||
* @param[in] builder: Handle of IR builder
|
||||
* @param[out] result: Result of frame building, which contains all of the raw data that could be send directly
|
||||
* @param[out] length: Length of result data
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: Get result data successfully
|
||||
* - ESP_ERR_INVALID_ARG: Get result data failed because of invalid arguments
|
||||
* - ESP_FAIL: Get result data failed because some other errors occurred
|
||||
*/
|
||||
esp_err_t (*get_result)(ir_builder_t *builder, void *result, uint32_t *length);
|
||||
|
||||
/**
|
||||
* @brief Free resources used by IR builder
|
||||
*
|
||||
* @param[in] builder: Handle of IR builder
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: Free resources successfully
|
||||
* - ESP_FAIL: Free resources failed because some error occurred
|
||||
*/
|
||||
esp_err_t (*del)(ir_builder_t *builder);
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Type definition of IR parser
|
||||
*
|
||||
*/
|
||||
struct ir_parser_s {
|
||||
/**
|
||||
* @brief Input raw data to IR parser
|
||||
*
|
||||
* @param[in] parser: Handle of IR parser
|
||||
* @param[in] raw_data: Raw data which need decoding by IR parser
|
||||
* @param[in] length: Length of raw data
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: Input raw data successfully
|
||||
* - ESP_ERR_INVALID_ARG: Input raw data failed because of invalid argument
|
||||
* - ESP_FAIL: Input raw data failed because some other error occurred
|
||||
*/
|
||||
esp_err_t (*input)(ir_parser_t *parser, void *raw_data, uint32_t length);
|
||||
|
||||
/**
|
||||
* @brief Get the scan code after decoding of raw data
|
||||
*
|
||||
* @param[in] parser: Handle of IR parser
|
||||
* @param[out] address: Address of the scan code
|
||||
* @param[out] command: Command of the scan code
|
||||
* @param[out] repeat: Indicate if it's a repeat code
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: Get scan code successfully
|
||||
* - ESP_ERR_INVALID_ARG: Get scan code failed because of invalid arguments
|
||||
* - ESP_FAIL: Get scan code failed because some error occurred
|
||||
*/
|
||||
esp_err_t (*get_scan_code)(ir_parser_t *parser, uint32_t *address, uint32_t *command, bool *repeat);
|
||||
|
||||
/**
|
||||
* @brief Free resources used by IR parser
|
||||
*
|
||||
* @param[in] parser: Handle of IR parser
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: Free resource successfully
|
||||
* - ESP_FAIL: Free resources fail failed because some error occurred
|
||||
*/
|
||||
esp_err_t (*del)(ir_parser_t *parser);
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Configuration type of IR builder
|
||||
*
|
||||
*/
|
||||
typedef struct {
|
||||
uint32_t buffer_size; /*!< Size of the internal buffer used by IR builder */
|
||||
ir_dev_t dev_hdl; /*!< IR device handle */
|
||||
uint32_t flags; /*!< Flags for IR builder, different flags will enable different features */
|
||||
} ir_builder_config_t;
|
||||
|
||||
/**
|
||||
* @brief Configuration type of IR parser
|
||||
*
|
||||
*/
|
||||
typedef struct {
|
||||
ir_dev_t dev_hdl; /*!< IR device handle */
|
||||
uint32_t flags; /*!< Flags for IR parser, different flags will enable different features */
|
||||
uint32_t margin_us; /*!< Timing parameter, indicating the tolerance to environment noise */
|
||||
} ir_parser_config_t;
|
||||
|
||||
/**
|
||||
* @brief Default configuration for IR builder
|
||||
*
|
||||
*/
|
||||
#define IR_BUILDER_DEFAULT_CONFIG(dev) \
|
||||
{ \
|
||||
.buffer_size = 64, \
|
||||
.dev_hdl = dev, \
|
||||
.flags = 0, \
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Default configuration for IR parser
|
||||
*
|
||||
*/
|
||||
#define IR_PARSER_DEFAULT_CONFIG(dev) \
|
||||
{ \
|
||||
.dev_hdl = dev, \
|
||||
.flags = 0, \
|
||||
.margin_us = 200, \
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Creat a NEC protocol builder
|
||||
*
|
||||
* @param config: configuration of NEC builder
|
||||
* @return
|
||||
* Handle of NEC builder or NULL
|
||||
*/
|
||||
ir_builder_t *ir_builder_rmt_new_nec(const ir_builder_config_t *config);
|
||||
|
||||
/**
|
||||
* @brief Creat a RC5 protocol builder
|
||||
*
|
||||
* @param config: configuration of RC5 builder
|
||||
* @return
|
||||
* Handle of RC5 builder or NULL
|
||||
*/
|
||||
ir_builder_t *ir_builder_rmt_new_rc5(const ir_builder_config_t *config);
|
||||
|
||||
/**
|
||||
* @brief Creat a NEC protocol parser
|
||||
*
|
||||
* @param config: configuration of NEC parser
|
||||
* @return
|
||||
* Handle of NEC parser or NULL
|
||||
*/
|
||||
ir_parser_t *ir_parser_rmt_new_nec(const ir_parser_config_t *config);
|
||||
|
||||
/**
|
||||
* @brief Creat a RC5 protocol parser
|
||||
*
|
||||
* @param config: configuration of RC5 parser
|
||||
* @return
|
||||
* Handle of RC5 parser or NULL
|
||||
*/
|
||||
ir_parser_t *ir_parser_rmt_new_rc5(const ir_parser_config_t *config);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
@ -0,0 +1,206 @@
|
|||
// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.#include <stdlib.h>
|
||||
#include <sys/cdefs.h>
|
||||
#include "esp_log.h"
|
||||
#include "ir_tools.h"
|
||||
#include "ir_timings.h"
|
||||
#include "driver/rmt.h"
|
||||
|
||||
static const char *TAG = "nec_builder";
|
||||
#define NEC_CHECK(a, str, goto_tag, ret_value, ...) \
|
||||
do \
|
||||
{ \
|
||||
if (!(a)) \
|
||||
{ \
|
||||
ESP_LOGE(TAG, "%s(%d): " str, __FUNCTION__, __LINE__, ##__VA_ARGS__); \
|
||||
ret = ret_value; \
|
||||
goto goto_tag; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
typedef struct {
|
||||
ir_builder_t parent;
|
||||
uint32_t buffer_size;
|
||||
uint32_t cursor;
|
||||
uint32_t flags;
|
||||
uint32_t leading_code_high_ticks;
|
||||
uint32_t leading_code_low_ticks;
|
||||
uint32_t repeat_code_high_ticks;
|
||||
uint32_t repeat_code_low_ticks;
|
||||
uint32_t payload_logic0_high_ticks;
|
||||
uint32_t payload_logic0_low_ticks;
|
||||
uint32_t payload_logic1_high_ticks;
|
||||
uint32_t payload_logic1_low_ticks;
|
||||
uint32_t ending_code_high_ticks;
|
||||
uint32_t ending_code_low_ticks;
|
||||
bool inverse;
|
||||
rmt_item32_t buffer[0];
|
||||
} nec_builder_t;
|
||||
|
||||
static esp_err_t nec_builder_make_head(ir_builder_t *builder)
|
||||
{
|
||||
nec_builder_t *nec_builder = __containerof(builder, nec_builder_t, parent);
|
||||
nec_builder->cursor = 0;
|
||||
nec_builder->buffer[nec_builder->cursor].level0 = !nec_builder->inverse;
|
||||
nec_builder->buffer[nec_builder->cursor].duration0 = nec_builder->leading_code_high_ticks;
|
||||
nec_builder->buffer[nec_builder->cursor].level1 = nec_builder->inverse;
|
||||
nec_builder->buffer[nec_builder->cursor].duration1 = nec_builder->leading_code_low_ticks;
|
||||
nec_builder->cursor += 1;
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t nec_builder_make_logic0(ir_builder_t *builder)
|
||||
{
|
||||
nec_builder_t *nec_builder = __containerof(builder, nec_builder_t, parent);
|
||||
nec_builder->buffer[nec_builder->cursor].level0 = !nec_builder->inverse;
|
||||
nec_builder->buffer[nec_builder->cursor].duration0 = nec_builder->payload_logic0_high_ticks;
|
||||
nec_builder->buffer[nec_builder->cursor].level1 = nec_builder->inverse;
|
||||
nec_builder->buffer[nec_builder->cursor].duration1 = nec_builder->payload_logic0_low_ticks;
|
||||
nec_builder->cursor += 1;
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t nec_builder_make_logic1(ir_builder_t *builder)
|
||||
{
|
||||
nec_builder_t *nec_builder = __containerof(builder, nec_builder_t, parent);
|
||||
nec_builder->buffer[nec_builder->cursor].level0 = !nec_builder->inverse;
|
||||
nec_builder->buffer[nec_builder->cursor].duration0 = nec_builder->payload_logic1_high_ticks;
|
||||
nec_builder->buffer[nec_builder->cursor].level1 = nec_builder->inverse;
|
||||
nec_builder->buffer[nec_builder->cursor].duration1 = nec_builder->payload_logic1_low_ticks;
|
||||
nec_builder->cursor += 1;
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t nec_builder_make_end(ir_builder_t *builder)
|
||||
{
|
||||
nec_builder_t *nec_builder = __containerof(builder, nec_builder_t, parent);
|
||||
nec_builder->buffer[nec_builder->cursor].level0 = !nec_builder->inverse;
|
||||
nec_builder->buffer[nec_builder->cursor].duration0 = nec_builder->ending_code_high_ticks;
|
||||
nec_builder->buffer[nec_builder->cursor].level1 = nec_builder->inverse;
|
||||
nec_builder->buffer[nec_builder->cursor].duration1 = nec_builder->ending_code_low_ticks;
|
||||
nec_builder->cursor += 1;
|
||||
nec_builder->buffer[nec_builder->cursor].val = 0;
|
||||
nec_builder->cursor += 1;
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t nec_build_frame(ir_builder_t *builder, uint32_t address, uint32_t command)
|
||||
{
|
||||
esp_err_t ret = ESP_OK;
|
||||
nec_builder_t *nec_builder = __containerof(builder, nec_builder_t, parent);
|
||||
if (!nec_builder->flags & IR_TOOLS_FLAGS_PROTO_EXT) {
|
||||
uint8_t low_byte = address & 0xFF;
|
||||
uint8_t high_byte = (address >> 8) & 0xFF;
|
||||
NEC_CHECK(low_byte == ~high_byte, "address not match standard NEC protocol", err, ESP_ERR_INVALID_ARG);
|
||||
low_byte = command & 0xFF;
|
||||
high_byte = (command >> 8) & 0xFF;
|
||||
NEC_CHECK(low_byte == ~high_byte, "command not match standard NEC protocol", err, ESP_ERR_INVALID_ARG);
|
||||
}
|
||||
builder->make_head(builder);
|
||||
// LSB -> MSB
|
||||
for (int i = 0; i < 16; i++) {
|
||||
if (address & (1 << i)) {
|
||||
builder->make_logic1(builder);
|
||||
} else {
|
||||
builder->make_logic0(builder);
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < 16; i++) {
|
||||
if (command & (1 << i)) {
|
||||
builder->make_logic1(builder);
|
||||
} else {
|
||||
builder->make_logic0(builder);
|
||||
}
|
||||
}
|
||||
builder->make_end(builder);
|
||||
return ESP_OK;
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static esp_err_t nec_build_repeat_frame(ir_builder_t *builder)
|
||||
{
|
||||
nec_builder_t *nec_builder = __containerof(builder, nec_builder_t, parent);
|
||||
nec_builder->cursor = 0;
|
||||
nec_builder->buffer[nec_builder->cursor].level0 = !nec_builder->inverse;
|
||||
nec_builder->buffer[nec_builder->cursor].duration0 = nec_builder->repeat_code_high_ticks;
|
||||
nec_builder->buffer[nec_builder->cursor].level1 = nec_builder->inverse;
|
||||
nec_builder->buffer[nec_builder->cursor].duration1 = nec_builder->repeat_code_low_ticks;
|
||||
nec_builder->cursor += 1;
|
||||
nec_builder_make_end(builder);
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t nec_builder_get_result(ir_builder_t *builder, void *result, uint32_t *length)
|
||||
{
|
||||
esp_err_t ret = ESP_OK;
|
||||
nec_builder_t *nec_builder = __containerof(builder, nec_builder_t, parent);
|
||||
NEC_CHECK(result && length, "result and length can't be null", err, ESP_ERR_INVALID_ARG);
|
||||
*(rmt_item32_t **)result = nec_builder->buffer;
|
||||
*length = nec_builder->cursor;
|
||||
return ESP_OK;
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static esp_err_t nec_builder_del(ir_builder_t *builder)
|
||||
{
|
||||
nec_builder_t *nec_builder = __containerof(builder, nec_builder_t, parent);
|
||||
free(nec_builder);
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
ir_builder_t *ir_builder_rmt_new_nec(const ir_builder_config_t *config)
|
||||
{
|
||||
ir_builder_t *ret = NULL;
|
||||
NEC_CHECK(config, "nec configuration can't be null", err, NULL);
|
||||
NEC_CHECK(config->buffer_size, "buffer size can't be zero", err, NULL);
|
||||
|
||||
uint32_t builder_size = sizeof(nec_builder_t) + config->buffer_size * sizeof(rmt_item32_t);
|
||||
nec_builder_t *nec_builder = calloc(1, builder_size);
|
||||
NEC_CHECK(nec_builder, "request memory for nec_builder failed", err, NULL);
|
||||
|
||||
nec_builder->buffer_size = config->buffer_size;
|
||||
nec_builder->flags = config->flags;
|
||||
if (config->flags & IR_TOOLS_FLAGS_INVERSE) {
|
||||
nec_builder->inverse = true;
|
||||
}
|
||||
|
||||
uint32_t counter_clk_hz = 0;
|
||||
NEC_CHECK(rmt_get_counter_clock((rmt_channel_t)config->dev_hdl, &counter_clk_hz) == ESP_OK,
|
||||
"get rmt counter clock failed", err, NULL);
|
||||
float ratio = (float)counter_clk_hz / 1e6;
|
||||
nec_builder->leading_code_high_ticks = (uint32_t)(ratio * NEC_LEADING_CODE_HIGH_US);
|
||||
nec_builder->leading_code_low_ticks = (uint32_t)(ratio * NEC_LEADING_CODE_LOW_US);
|
||||
nec_builder->repeat_code_high_ticks = (uint32_t)(ratio * NEC_REPEAT_CODE_HIGH_US);
|
||||
nec_builder->repeat_code_low_ticks = (uint32_t)(ratio * NEC_REPEAT_CODE_LOW_US);
|
||||
nec_builder->payload_logic0_high_ticks = (uint32_t)(ratio * NEC_PAYLOAD_ZERO_HIGH_US);
|
||||
nec_builder->payload_logic0_low_ticks = (uint32_t)(ratio * NEC_PAYLOAD_ZERO_LOW_US);
|
||||
nec_builder->payload_logic1_high_ticks = (uint32_t)(ratio * NEC_PAYLOAD_ONE_HIGH_US);
|
||||
nec_builder->payload_logic1_low_ticks = (uint32_t)(ratio * NEC_PAYLOAD_ONE_LOW_US);
|
||||
nec_builder->ending_code_high_ticks = (uint32_t)(ratio * NEC_ENDING_CODE_HIGH_US);
|
||||
nec_builder->ending_code_low_ticks = 0x7FFF;
|
||||
nec_builder->parent.make_head = nec_builder_make_head;
|
||||
nec_builder->parent.make_logic0 = nec_builder_make_logic0;
|
||||
nec_builder->parent.make_logic1 = nec_builder_make_logic1;
|
||||
nec_builder->parent.make_end = nec_builder_make_end;
|
||||
nec_builder->parent.build_frame = nec_build_frame;
|
||||
nec_builder->parent.build_repeat_frame = nec_build_repeat_frame;
|
||||
nec_builder->parent.get_result = nec_builder_get_result;
|
||||
nec_builder->parent.del = nec_builder_del;
|
||||
nec_builder->parent.repeat_period_ms = 110;
|
||||
return &nec_builder->parent;
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -0,0 +1,190 @@
|
|||
// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
#include <stdlib.h>
|
||||
#include <sys/cdefs.h>
|
||||
#include "esp_log.h"
|
||||
#include "ir_tools.h"
|
||||
#include "ir_timings.h"
|
||||
#include "driver/rmt.h"
|
||||
|
||||
static const char *TAG = "rc5_builder";
|
||||
#define RC5_CHECK(a, str, goto_tag, ret_value, ...) \
|
||||
do \
|
||||
{ \
|
||||
if (!(a)) \
|
||||
{ \
|
||||
ESP_LOGE(TAG, "%s(%d): " str, __FUNCTION__, __LINE__, ##__VA_ARGS__); \
|
||||
ret = ret_value; \
|
||||
goto goto_tag; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
typedef struct {
|
||||
ir_builder_t parent;
|
||||
uint32_t buffer_size;
|
||||
uint32_t cursor;
|
||||
uint32_t pulse_duration_ticks;
|
||||
uint32_t flags;
|
||||
bool toggle;
|
||||
bool s2_bit;
|
||||
bool inverse;
|
||||
rmt_item32_t buffer[0];
|
||||
} rc5_builder_t;
|
||||
|
||||
static esp_err_t rc5_builder_make_head(ir_builder_t *builder)
|
||||
{
|
||||
rc5_builder_t *rc5_builder = __containerof(builder, rc5_builder_t, parent);
|
||||
rc5_builder->cursor = 0;
|
||||
rc5_builder->toggle = !rc5_builder->toggle;
|
||||
// S1 default (not inverse) is 0
|
||||
rc5_builder->buffer[rc5_builder->cursor].level0 = rc5_builder->inverse;
|
||||
rc5_builder->buffer[rc5_builder->cursor].duration0 = rc5_builder->pulse_duration_ticks;
|
||||
rc5_builder->buffer[rc5_builder->cursor].level1 = !rc5_builder->inverse;
|
||||
rc5_builder->buffer[rc5_builder->cursor].duration1 = rc5_builder->pulse_duration_ticks;
|
||||
rc5_builder->cursor += 1;
|
||||
// S2 default (not inverse) is depend on whether use extended protocol
|
||||
rc5_builder->buffer[rc5_builder->cursor].level0 = rc5_builder->s2_bit ^ rc5_builder->inverse;
|
||||
rc5_builder->buffer[rc5_builder->cursor].duration0 = rc5_builder->pulse_duration_ticks;
|
||||
rc5_builder->buffer[rc5_builder->cursor].level1 = !(rc5_builder->s2_bit ^ rc5_builder->inverse);
|
||||
rc5_builder->buffer[rc5_builder->cursor].duration1 = rc5_builder->pulse_duration_ticks;
|
||||
rc5_builder->cursor += 1;
|
||||
// T
|
||||
rc5_builder->buffer[rc5_builder->cursor].level0 = rc5_builder->toggle;
|
||||
rc5_builder->buffer[rc5_builder->cursor].duration0 = rc5_builder->pulse_duration_ticks;
|
||||
rc5_builder->buffer[rc5_builder->cursor].level1 = !rc5_builder->toggle;
|
||||
rc5_builder->buffer[rc5_builder->cursor].duration1 = rc5_builder->pulse_duration_ticks;
|
||||
rc5_builder->cursor += 1;
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t rc5_builder_make_logic0(ir_builder_t *builder)
|
||||
{
|
||||
rc5_builder_t *rc5_builder = __containerof(builder, rc5_builder_t, parent);
|
||||
rc5_builder->buffer[rc5_builder->cursor].level0 = !rc5_builder->inverse;
|
||||
rc5_builder->buffer[rc5_builder->cursor].duration0 = rc5_builder->pulse_duration_ticks;
|
||||
rc5_builder->buffer[rc5_builder->cursor].level1 = rc5_builder->inverse;
|
||||
rc5_builder->buffer[rc5_builder->cursor].duration1 = rc5_builder->pulse_duration_ticks;
|
||||
rc5_builder->cursor += 1;
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t rc5_builder_make_logic1(ir_builder_t *builder)
|
||||
{
|
||||
rc5_builder_t *rc5_builder = __containerof(builder, rc5_builder_t, parent);
|
||||
rc5_builder->buffer[rc5_builder->cursor].level0 = rc5_builder->inverse;
|
||||
rc5_builder->buffer[rc5_builder->cursor].duration0 = rc5_builder->pulse_duration_ticks;
|
||||
rc5_builder->buffer[rc5_builder->cursor].level1 = !rc5_builder->inverse;
|
||||
rc5_builder->buffer[rc5_builder->cursor].duration1 = rc5_builder->pulse_duration_ticks;
|
||||
rc5_builder->cursor += 1;
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t rc5_builder_make_end(ir_builder_t *builder)
|
||||
{
|
||||
rc5_builder_t *rc5_builder = __containerof(builder, rc5_builder_t, parent);
|
||||
rc5_builder->buffer[rc5_builder->cursor].val = 0;
|
||||
rc5_builder->cursor += 1;
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t rc5_build_frame(ir_builder_t *builder, uint32_t address, uint32_t command)
|
||||
{
|
||||
rc5_builder_t *rc5_builder = __containerof(builder, rc5_builder_t, parent);
|
||||
if (rc5_builder->flags & IR_TOOLS_FLAGS_PROTO_EXT) {
|
||||
// RC5-extended protocol uses S2 bit as a 7th command bit (MSB of a command)
|
||||
if (command > 63) {
|
||||
rc5_builder->s2_bit = true;
|
||||
} else {
|
||||
rc5_builder->s2_bit = false;
|
||||
}
|
||||
}
|
||||
builder->make_head(builder);
|
||||
// MSB -> LSB
|
||||
for (int i = 4; i >= 0; i--) {
|
||||
if (address & (1 << i)) {
|
||||
builder->make_logic1(builder);
|
||||
} else {
|
||||
builder->make_logic0(builder);
|
||||
}
|
||||
}
|
||||
for (int i = 5; i >= 0; i--) {
|
||||
if (command & (1 << i)) {
|
||||
builder->make_logic1(builder);
|
||||
} else {
|
||||
builder->make_logic0(builder);
|
||||
}
|
||||
}
|
||||
builder->make_end(builder);
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t rc5_build_repeat_frame(ir_builder_t *builder)
|
||||
{
|
||||
// repeat frame is just the latest build frame, so do nothing here
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t rc5_builder_get_result(ir_builder_t *builder, void *result, uint32_t *length)
|
||||
{
|
||||
esp_err_t ret = ESP_OK;
|
||||
rc5_builder_t *rc5_builder = __containerof(builder, rc5_builder_t, parent);
|
||||
RC5_CHECK(result && length, "result and length can't be null", err, ESP_ERR_INVALID_ARG);
|
||||
*(rmt_item32_t **)result = rc5_builder->buffer;
|
||||
*length = rc5_builder->cursor;
|
||||
return ESP_OK;
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static esp_err_t rc5_builder_del(ir_builder_t *builder)
|
||||
{
|
||||
rc5_builder_t *rc5_builder = __containerof(builder, rc5_builder_t, parent);
|
||||
free(rc5_builder);
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
ir_builder_t *ir_builder_rmt_new_rc5(const ir_builder_config_t *config)
|
||||
{
|
||||
ir_builder_t *ret = NULL;
|
||||
RC5_CHECK(config, "rc5 configuration can't be null", err, NULL);
|
||||
RC5_CHECK(config->buffer_size, "buffer size can't be zero", err, NULL);
|
||||
|
||||
uint32_t builder_size = sizeof(rc5_builder_t) + config->buffer_size * sizeof(rmt_item32_t);
|
||||
rc5_builder_t *rc5_builder = calloc(1, builder_size);
|
||||
RC5_CHECK(rc5_builder, "request memory for rc5_builder failed", err, NULL);
|
||||
|
||||
rc5_builder->buffer_size = config->buffer_size;
|
||||
rc5_builder->flags = config->flags;
|
||||
if (config->flags & IR_TOOLS_FLAGS_INVERSE) {
|
||||
rc5_builder->inverse = true;
|
||||
}
|
||||
|
||||
uint32_t counter_clk_hz = 0;
|
||||
RC5_CHECK(rmt_get_counter_clock((rmt_channel_t)config->dev_hdl, &counter_clk_hz) == ESP_OK,
|
||||
"get rmt counter clock failed", err, NULL);
|
||||
float ratio = (float)counter_clk_hz / 1e6;
|
||||
rc5_builder->pulse_duration_ticks = (uint32_t)(ratio * RC5_PULSE_DURATION_US);
|
||||
rc5_builder->parent.make_head = rc5_builder_make_head;
|
||||
rc5_builder->parent.make_logic0 = rc5_builder_make_logic0;
|
||||
rc5_builder->parent.make_logic1 = rc5_builder_make_logic1;
|
||||
rc5_builder->parent.make_end = rc5_builder_make_end;
|
||||
rc5_builder->parent.build_frame = rc5_build_frame;
|
||||
rc5_builder->parent.build_repeat_frame = rc5_build_repeat_frame;
|
||||
rc5_builder->parent.get_result = rc5_builder_get_result;
|
||||
rc5_builder->parent.del = rc5_builder_del;
|
||||
rc5_builder->parent.repeat_period_ms = 114;
|
||||
return &rc5_builder->parent;
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -0,0 +1,218 @@
|
|||
// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
#include <stdlib.h>
|
||||
#include <sys/cdefs.h>
|
||||
#include "esp_log.h"
|
||||
#include "ir_tools.h"
|
||||
#include "ir_timings.h"
|
||||
#include "driver/rmt.h"
|
||||
|
||||
static const char *TAG = "nec_parser";
|
||||
#define NEC_CHECK(a, str, goto_tag, ret_value, ...) \
|
||||
do \
|
||||
{ \
|
||||
if (!(a)) \
|
||||
{ \
|
||||
ESP_LOGE(TAG, "%s(%d): " str, __FUNCTION__, __LINE__, ##__VA_ARGS__); \
|
||||
ret = ret_value; \
|
||||
goto goto_tag; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define NEC_DATA_FRAME_RMT_WORDS (34)
|
||||
#define NEC_REPEAT_FRAME_RMT_WORDS (2)
|
||||
|
||||
typedef struct {
|
||||
ir_parser_t parent;
|
||||
uint32_t flags;
|
||||
uint32_t leading_code_high_ticks;
|
||||
uint32_t leading_code_low_ticks;
|
||||
uint32_t repeat_code_high_ticks;
|
||||
uint32_t repeat_code_low_ticks;
|
||||
uint32_t payload_logic0_high_ticks;
|
||||
uint32_t payload_logic0_low_ticks;
|
||||
uint32_t payload_logic1_high_ticks;
|
||||
uint32_t payload_logic1_low_ticks;
|
||||
uint32_t margin_ticks;
|
||||
rmt_item32_t *buffer;
|
||||
uint32_t cursor;
|
||||
uint32_t last_address;
|
||||
uint32_t last_command;
|
||||
bool repeat;
|
||||
bool inverse;
|
||||
} nec_parser_t;
|
||||
|
||||
static inline bool nec_check_in_range(uint32_t raw_ticks, uint32_t target_ticks, uint32_t margin_ticks)
|
||||
{
|
||||
return (raw_ticks < (target_ticks + margin_ticks)) && (raw_ticks > (target_ticks - margin_ticks));
|
||||
}
|
||||
|
||||
static bool nec_parse_head(nec_parser_t *nec_parser)
|
||||
{
|
||||
nec_parser->cursor = 0;
|
||||
rmt_item32_t item = nec_parser->buffer[nec_parser->cursor];
|
||||
bool ret = (item.level0 == nec_parser->inverse) && (item.level1 != nec_parser->inverse) &&
|
||||
nec_check_in_range(item.duration0, nec_parser->leading_code_high_ticks, nec_parser->margin_ticks) &&
|
||||
nec_check_in_range(item.duration1, nec_parser->leading_code_low_ticks, nec_parser->margin_ticks);
|
||||
nec_parser->cursor += 1;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool nec_parse_logic0(nec_parser_t *nec_parser)
|
||||
{
|
||||
rmt_item32_t item = nec_parser->buffer[nec_parser->cursor];
|
||||
bool ret = (item.level0 == nec_parser->inverse) && (item.level1 != nec_parser->inverse) &&
|
||||
nec_check_in_range(item.duration0, nec_parser->payload_logic0_high_ticks, nec_parser->margin_ticks) &&
|
||||
nec_check_in_range(item.duration1, nec_parser->payload_logic0_low_ticks, nec_parser->margin_ticks);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool nec_parse_logic1(nec_parser_t *nec_parser)
|
||||
{
|
||||
rmt_item32_t item = nec_parser->buffer[nec_parser->cursor];
|
||||
bool ret = (item.level0 == nec_parser->inverse) && (item.level1 != nec_parser->inverse) &&
|
||||
nec_check_in_range(item.duration0, nec_parser->payload_logic1_high_ticks, nec_parser->margin_ticks) &&
|
||||
nec_check_in_range(item.duration1, nec_parser->payload_logic1_low_ticks, nec_parser->margin_ticks);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static esp_err_t nec_parse_logic(ir_parser_t *parser, bool *logic)
|
||||
{
|
||||
esp_err_t ret = ESP_FAIL;
|
||||
bool logic_value = false;
|
||||
nec_parser_t *nec_parser = __containerof(parser, nec_parser_t, parent);
|
||||
if (nec_parse_logic0(nec_parser)) {
|
||||
logic_value = false;
|
||||
ret = ESP_OK;
|
||||
} else if (nec_parse_logic1(nec_parser)) {
|
||||
logic_value = true;
|
||||
ret = ESP_OK;
|
||||
}
|
||||
if (ret == ESP_OK) {
|
||||
*logic = logic_value;
|
||||
}
|
||||
nec_parser->cursor += 1;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool nec_parse_repeat_frame(nec_parser_t *nec_parser)
|
||||
{
|
||||
nec_parser->cursor = 0;
|
||||
rmt_item32_t item = nec_parser->buffer[nec_parser->cursor];
|
||||
bool ret = (item.level0 == nec_parser->inverse) && (item.level1 != nec_parser->inverse) &&
|
||||
nec_check_in_range(item.duration0, nec_parser->repeat_code_high_ticks, nec_parser->margin_ticks) &&
|
||||
nec_check_in_range(item.duration1, nec_parser->repeat_code_low_ticks, nec_parser->margin_ticks);
|
||||
nec_parser->cursor += 1;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static esp_err_t nec_parser_input(ir_parser_t *parser, void *raw_data, uint32_t length)
|
||||
{
|
||||
esp_err_t ret = ESP_OK;
|
||||
nec_parser_t *nec_parser = __containerof(parser, nec_parser_t, parent);
|
||||
NEC_CHECK(raw_data, "input data can't be null", err, ESP_ERR_INVALID_ARG);
|
||||
nec_parser->buffer = raw_data;
|
||||
// Data Frame costs 34 items and Repeat Frame costs 2 items
|
||||
if (length == NEC_DATA_FRAME_RMT_WORDS) {
|
||||
nec_parser->repeat = false;
|
||||
} else if (length == NEC_REPEAT_FRAME_RMT_WORDS) {
|
||||
nec_parser->repeat = true;
|
||||
} else {
|
||||
ret = ESP_FAIL;
|
||||
}
|
||||
return ret;
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static esp_err_t nec_parser_get_scan_code(ir_parser_t *parser, uint32_t *address, uint32_t *command, bool *repeat)
|
||||
{
|
||||
esp_err_t ret = ESP_FAIL;
|
||||
uint32_t addr = 0;
|
||||
uint32_t cmd = 0;
|
||||
bool logic_value = false;
|
||||
nec_parser_t *nec_parser = __containerof(parser, nec_parser_t, parent);
|
||||
NEC_CHECK(address && command && repeat, "address, command and repeat can't be null", out, ESP_ERR_INVALID_ARG);
|
||||
if (nec_parser->repeat) {
|
||||
if (nec_parse_repeat_frame(nec_parser)) {
|
||||
*address = nec_parser->last_address;
|
||||
*command = nec_parser->last_command;
|
||||
*repeat = true;
|
||||
ret = ESP_OK;
|
||||
}
|
||||
} else {
|
||||
if (nec_parse_head(nec_parser)) {
|
||||
for (int i = 0; i < 16; i++) {
|
||||
if (nec_parse_logic(parser, &logic_value) == ESP_OK) {
|
||||
addr |= (logic_value << i);
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < 16; i++) {
|
||||
if (nec_parse_logic(parser, &logic_value) == ESP_OK) {
|
||||
cmd |= (logic_value << i);
|
||||
}
|
||||
}
|
||||
*address = addr;
|
||||
*command = cmd;
|
||||
*repeat = false;
|
||||
// keep it as potential repeat code
|
||||
nec_parser->last_address = addr;
|
||||
nec_parser->last_command = cmd;
|
||||
ret = ESP_OK;
|
||||
}
|
||||
}
|
||||
out:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static esp_err_t nec_parser_del(ir_parser_t *parser)
|
||||
{
|
||||
nec_parser_t *nec_parser = __containerof(parser, nec_parser_t, parent);
|
||||
free(nec_parser);
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
ir_parser_t *ir_parser_rmt_new_nec(const ir_parser_config_t *config)
|
||||
{
|
||||
ir_parser_t *ret = NULL;
|
||||
NEC_CHECK(config, "nec configuration can't be null", err, NULL);
|
||||
|
||||
nec_parser_t *nec_parser = calloc(1, sizeof(nec_parser_t));
|
||||
NEC_CHECK(nec_parser, "request memory for nec_parser failed", err, NULL);
|
||||
|
||||
nec_parser->flags = config->flags;
|
||||
if (config->flags & IR_TOOLS_FLAGS_INVERSE) {
|
||||
nec_parser->inverse = true;
|
||||
}
|
||||
|
||||
uint32_t counter_clk_hz = 0;
|
||||
NEC_CHECK(rmt_get_counter_clock((rmt_channel_t)config->dev_hdl, &counter_clk_hz) == ESP_OK,
|
||||
"get rmt counter clock failed", err, NULL);
|
||||
float ratio = (float)counter_clk_hz / 1e6;
|
||||
nec_parser->leading_code_high_ticks = (uint32_t)(ratio * NEC_LEADING_CODE_HIGH_US);
|
||||
nec_parser->leading_code_low_ticks = (uint32_t)(ratio * NEC_LEADING_CODE_LOW_US);
|
||||
nec_parser->repeat_code_high_ticks = (uint32_t)(ratio * NEC_REPEAT_CODE_HIGH_US);
|
||||
nec_parser->repeat_code_low_ticks = (uint32_t)(ratio * NEC_REPEAT_CODE_LOW_US);
|
||||
nec_parser->payload_logic0_high_ticks = (uint32_t)(ratio * NEC_PAYLOAD_ZERO_HIGH_US);
|
||||
nec_parser->payload_logic0_low_ticks = (uint32_t)(ratio * NEC_PAYLOAD_ZERO_LOW_US);
|
||||
nec_parser->payload_logic1_high_ticks = (uint32_t)(ratio * NEC_PAYLOAD_ONE_HIGH_US);
|
||||
nec_parser->payload_logic1_low_ticks = (uint32_t)(ratio * NEC_PAYLOAD_ONE_LOW_US);
|
||||
nec_parser->margin_ticks = (uint32_t)(ratio * config->margin_us);
|
||||
nec_parser->parent.input = nec_parser_input;
|
||||
nec_parser->parent.get_scan_code = nec_parser_get_scan_code;
|
||||
nec_parser->parent.del = nec_parser_del;
|
||||
return &nec_parser->parent;
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -0,0 +1,165 @@
|
|||
// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
#include <stdlib.h>
|
||||
#include <sys/cdefs.h>
|
||||
#include "esp_log.h"
|
||||
#include "ir_tools.h"
|
||||
#include "ir_timings.h"
|
||||
#include "driver/rmt.h"
|
||||
|
||||
static const char *TAG = "rc5_parser";
|
||||
#define RC5_CHECK(a, str, goto_tag, ret_value, ...) \
|
||||
do \
|
||||
{ \
|
||||
if (!(a)) \
|
||||
{ \
|
||||
ESP_LOGE(TAG, "%s(%d): " str, __FUNCTION__, __LINE__, ##__VA_ARGS__); \
|
||||
ret = ret_value; \
|
||||
goto goto_tag; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define RC5_MAX_FRAME_RMT_WORDS (14) // S1+S2+T+ADDR(5)+CMD(6)
|
||||
|
||||
typedef struct {
|
||||
ir_parser_t parent;
|
||||
uint32_t flags;
|
||||
uint32_t pulse_duration_ticks;
|
||||
uint32_t margin_ticks;
|
||||
rmt_item32_t *buffer;
|
||||
uint32_t buffer_len;
|
||||
uint32_t last_command;
|
||||
uint32_t last_address;
|
||||
bool last_t_bit;
|
||||
} rc5_parser_t;
|
||||
|
||||
static inline bool rc5_check_in_range(uint32_t raw_ticks, uint32_t target_ticks, uint32_t margin_ticks)
|
||||
{
|
||||
return (raw_ticks < (target_ticks + margin_ticks)) && (raw_ticks > (target_ticks - margin_ticks));
|
||||
}
|
||||
|
||||
static esp_err_t rc5_parser_input(ir_parser_t *parser, void *raw_data, uint32_t length)
|
||||
{
|
||||
esp_err_t ret = ESP_OK;
|
||||
rc5_parser_t *rc5_parser = __containerof(parser, rc5_parser_t, parent);
|
||||
rc5_parser->buffer = raw_data;
|
||||
rc5_parser->buffer_len = length;
|
||||
if (length > RC5_MAX_FRAME_RMT_WORDS) {
|
||||
ret = ESP_FAIL;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline bool rc5_duration_one_unit(rc5_parser_t *rc5_parser, uint32_t duration)
|
||||
{
|
||||
return (duration < (rc5_parser->pulse_duration_ticks + rc5_parser->margin_ticks)) &&
|
||||
(duration > (rc5_parser->pulse_duration_ticks - rc5_parser->margin_ticks));
|
||||
}
|
||||
|
||||
static inline bool rc5_duration_two_unit(rc5_parser_t *rc5_parser, uint32_t duration)
|
||||
{
|
||||
return (duration < (rc5_parser->pulse_duration_ticks * 2 + rc5_parser->margin_ticks)) &&
|
||||
(duration > (rc5_parser->pulse_duration_ticks * 2 - rc5_parser->margin_ticks));
|
||||
}
|
||||
|
||||
static esp_err_t rc5_parser_get_scan_code(ir_parser_t *parser, uint32_t *address, uint32_t *command, bool *repeat)
|
||||
{
|
||||
esp_err_t ret = ESP_FAIL;
|
||||
uint32_t parse_result = 0; // 32 bit is enough to hold the parse result of one RC5 frame
|
||||
uint32_t addr = 0;
|
||||
uint32_t cmd = 0;
|
||||
bool s1 = true;
|
||||
bool s2 = true;
|
||||
bool t = false;
|
||||
bool exchange = false;
|
||||
rc5_parser_t *rc5_parser = __containerof(parser, rc5_parser_t, parent);
|
||||
RC5_CHECK(address && command && repeat, "address, command and repeat can't be null", out, ESP_ERR_INVALID_ARG);
|
||||
for (int i = 0; i < rc5_parser->buffer_len; i++) {
|
||||
if (rc5_duration_one_unit(rc5_parser, rc5_parser->buffer[i].duration0)) {
|
||||
parse_result <<= 1;
|
||||
parse_result |= exchange;
|
||||
if (rc5_duration_two_unit(rc5_parser, rc5_parser->buffer[i].duration1)) {
|
||||
exchange = !exchange;
|
||||
}
|
||||
} else if (rc5_duration_two_unit(rc5_parser, rc5_parser->buffer[i].duration0)) {
|
||||
parse_result <<= 1;
|
||||
parse_result |= rc5_parser->buffer[i].level0;
|
||||
parse_result <<= 1;
|
||||
parse_result |= !rc5_parser->buffer[i].level0;
|
||||
if (rc5_duration_one_unit(rc5_parser, rc5_parser->buffer[i].duration1)) {
|
||||
exchange = !exchange;
|
||||
}
|
||||
} else {
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
if (!(rc5_parser->flags & IR_TOOLS_FLAGS_INVERSE)) {
|
||||
parse_result = ~parse_result;
|
||||
}
|
||||
s1 = ((parse_result & 0x2000) >> 13) & 0x01;
|
||||
s2 = ((parse_result & 0x1000) >> 12) & 0x01;
|
||||
t = ((parse_result & 0x800) >> 11) & 0x01;
|
||||
// Check S1, must be 1
|
||||
if (s1) {
|
||||
if (!(rc5_parser->flags & IR_TOOLS_FLAGS_PROTO_EXT) && !s2) {
|
||||
// Not standard RC5 protocol, but S2 is 0
|
||||
goto out;
|
||||
}
|
||||
addr = (parse_result & 0x7C0) >> 6;
|
||||
cmd = (parse_result & 0x3F);
|
||||
if (!s2) {
|
||||
cmd |= 1 << 6;
|
||||
}
|
||||
*repeat = (t == rc5_parser->last_t_bit && addr == rc5_parser->last_address && cmd == rc5_parser->last_command);
|
||||
*address = addr;
|
||||
*command = cmd;
|
||||
rc5_parser->last_address = addr;
|
||||
rc5_parser->last_command = cmd;
|
||||
rc5_parser->last_t_bit = t;
|
||||
ret = ESP_OK;
|
||||
}
|
||||
out:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static esp_err_t rc5_parser_del(ir_parser_t *parser)
|
||||
{
|
||||
rc5_parser_t *rc5_parser = __containerof(parser, rc5_parser_t, parent);
|
||||
free(rc5_parser);
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
ir_parser_t *ir_parser_rmt_new_rc5(const ir_parser_config_t *config)
|
||||
{
|
||||
ir_parser_t *ret = NULL;
|
||||
RC5_CHECK(config, "rc5 configuration can't be null", err, NULL);
|
||||
|
||||
rc5_parser_t *rc5_parser = calloc(1, sizeof(rc5_parser_t));
|
||||
RC5_CHECK(rc5_parser, "request memory for rc5_parser failed", err, NULL);
|
||||
|
||||
rc5_parser->flags = config->flags;
|
||||
|
||||
uint32_t counter_clk_hz = 0;
|
||||
RC5_CHECK(rmt_get_counter_clock((rmt_channel_t)config->dev_hdl, &counter_clk_hz) == ESP_OK,
|
||||
"get rmt counter clock failed", err, NULL);
|
||||
float ratio = (float)counter_clk_hz / 1e6;
|
||||
rc5_parser->pulse_duration_ticks = (uint32_t)(ratio * RC5_PULSE_DURATION_US);
|
||||
rc5_parser->margin_ticks = (uint32_t)(ratio * config->margin_us);
|
||||
rc5_parser->parent.input = rc5_parser_input;
|
||||
rc5_parser->parent.get_scan_code = rc5_parser_get_scan_code;
|
||||
rc5_parser->parent.del = rc5_parser_del;
|
||||
return &rc5_parser->parent;
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
idf_component_register(SRCS "ir_protocols_main.c"
|
||||
INCLUDE_DIRS ".")
|
||||
33
examples/peripherals/rmt/ir_protocols/main/Kconfig.projbuild
Normal file
33
examples/peripherals/rmt/ir_protocols/main/Kconfig.projbuild
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
menu "Example Configuration"
|
||||
choice EXAMPLE_IR_PROTOCOL
|
||||
prompt "Infrared Protocol"
|
||||
default EXAMPLE_IR_PROTOCOL_NEC
|
||||
help
|
||||
Choose the IR protocol used in the example.
|
||||
|
||||
config EXAMPLE_IR_PROTOCOL_NEC
|
||||
bool "NEC"
|
||||
help
|
||||
NEC is a kind of Pulse Distance Protocol.
|
||||
It uses ASK modulation and pulse distance encoding with a carrier frequency of 38 kHz.
|
||||
|
||||
config EXAMPLE_IR_PROTOCOL_RC5
|
||||
bool "RC5"
|
||||
help
|
||||
The RC5 protocol was introduced by Philips.
|
||||
It uses ASK modulation and Manchester encoding with carrier frequency fixed at 36 kHz.
|
||||
|
||||
endchoice
|
||||
|
||||
config EXAMPLE_RMT_TX_GPIO
|
||||
int "RMT TX GPIO"
|
||||
default 18
|
||||
help
|
||||
Set the GPIO number used for transmitting the RMT signal.
|
||||
|
||||
config EXAMPLE_RMT_RX_GPIO
|
||||
int "RMT RX GPIO"
|
||||
default 19
|
||||
help
|
||||
Set the GPIO number used for receiving the RMT signal.
|
||||
endmenu
|
||||
119
examples/peripherals/rmt/ir_protocols/main/ir_protocols_main.c
Normal file
119
examples/peripherals/rmt/ir_protocols/main/ir_protocols_main.c
Normal file
|
|
@ -0,0 +1,119 @@
|
|||
/* IR protocols example
|
||||
|
||||
This example code is in the Public Domain (or CC0 licensed, at your option.)
|
||||
|
||||
Unless required by applicable law or agreed to in writing, this
|
||||
software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
||||
CONDITIONS OF ANY KIND, either express or implied.
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "sdkconfig.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "esp_log.h"
|
||||
#include "driver/rmt.h"
|
||||
#include "ir_tools.h"
|
||||
|
||||
static const char *TAG = "example";
|
||||
|
||||
static rmt_channel_t example_tx_channel = RMT_CHANNEL_0;
|
||||
static rmt_channel_t example_rx_channel = RMT_CHANNEL_1;
|
||||
|
||||
/**
|
||||
* @brief RMT Receive Task
|
||||
*
|
||||
*/
|
||||
static void example_ir_rx_task(void *arg)
|
||||
{
|
||||
uint32_t addr = 0;
|
||||
uint32_t cmd = 0;
|
||||
uint32_t length = 0;
|
||||
bool repeat = false;
|
||||
RingbufHandle_t rb = NULL;
|
||||
rmt_item32_t *items = NULL;
|
||||
|
||||
rmt_config_t rmt_rx_config = RMT_DEFAULT_CONFIG_RX(CONFIG_EXAMPLE_RMT_RX_GPIO, example_rx_channel);
|
||||
rmt_config(&rmt_rx_config);
|
||||
rmt_driver_install(example_rx_channel, 1000, 0);
|
||||
ir_parser_config_t ir_parser_config = IR_PARSER_DEFAULT_CONFIG((ir_dev_t)example_rx_channel);
|
||||
ir_parser_config.flags |= IR_TOOLS_FLAGS_PROTO_EXT; // Using extended IR protocols (both NEC and RC5 have extended version)
|
||||
ir_parser_t *ir_parser = NULL;
|
||||
#if CONFIG_EXAMPLE_IR_PROTOCOL_NEC
|
||||
ir_parser = ir_parser_rmt_new_nec(&ir_parser_config);
|
||||
#elif CONFIG_EXAMPLE_IR_PROTOCOL_RC5
|
||||
ir_parser = ir_parser_rmt_new_rc5(&ir_parser_config);
|
||||
#endif
|
||||
|
||||
//get RMT RX ringbuffer
|
||||
rmt_get_ringbuf_handle(example_rx_channel, &rb);
|
||||
// Start receive
|
||||
rmt_rx_start(example_rx_channel, true);
|
||||
while (rb) {
|
||||
items = (rmt_item32_t *) xRingbufferReceive(rb, &length, 1000);
|
||||
if (items) {
|
||||
length /= 4; // one RMT = 4 Bytes
|
||||
if (ir_parser->input(ir_parser, items, length) == ESP_OK) {
|
||||
if (ir_parser->get_scan_code(ir_parser, &addr, &cmd, &repeat) == ESP_OK) {
|
||||
ESP_LOGI(TAG, "Scan Code %s --- addr: 0x%04x cmd: 0x%04x", repeat ? "(repeat)" : "", addr, cmd);
|
||||
}
|
||||
}
|
||||
//after parsing the data, return spaces to ringbuffer.
|
||||
vRingbufferReturnItem(rb, (void *) items);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
ir_parser->del(ir_parser);
|
||||
rmt_driver_uninstall(example_rx_channel);
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief RMT Transmit Task
|
||||
*
|
||||
*/
|
||||
static void example_ir_tx_task(void *arg)
|
||||
{
|
||||
uint32_t addr = 0x10;
|
||||
uint32_t cmd = 0x20;
|
||||
rmt_item32_t *items = NULL;
|
||||
uint32_t length = 0;
|
||||
ir_builder_t *ir_builder = NULL;
|
||||
|
||||
rmt_config_t rmt_tx_config = RMT_DEFAULT_CONFIG_TX(CONFIG_EXAMPLE_RMT_TX_GPIO, example_tx_channel);
|
||||
rmt_tx_config.tx_config.carrier_en = true;
|
||||
rmt_config(&rmt_tx_config);
|
||||
rmt_driver_install(example_tx_channel, 0, 0);
|
||||
ir_builder_config_t ir_builder_config = IR_BUILDER_DEFAULT_CONFIG((ir_dev_t)example_tx_channel);
|
||||
ir_builder_config.flags |= IR_TOOLS_FLAGS_PROTO_EXT; // Using extended IR protocols (both NEC and RC5 have extended version)
|
||||
#if CONFIG_EXAMPLE_IR_PROTOCOL_NEC
|
||||
ir_builder = ir_builder_rmt_new_nec(&ir_builder_config);
|
||||
#elif CONFIG_EXAMPLE_IR_PROTOCOL_RC5
|
||||
ir_builder = ir_builder_rmt_new_rc5(&ir_builder_config);
|
||||
#endif
|
||||
while (1) {
|
||||
vTaskDelay(pdMS_TO_TICKS(2000));
|
||||
ESP_LOGI(TAG, "Send command 0x%x to address 0x%x", cmd, addr);
|
||||
// Send new key code
|
||||
ESP_ERROR_CHECK(ir_builder->build_frame(ir_builder, addr, cmd));
|
||||
ESP_ERROR_CHECK(ir_builder->get_result(ir_builder, &items, &length));
|
||||
//To send data according to the waveform items.
|
||||
rmt_write_items(example_tx_channel, items, length, true);
|
||||
// Send repeat code
|
||||
vTaskDelay(pdMS_TO_TICKS(ir_builder->repeat_period_ms));
|
||||
ESP_ERROR_CHECK(ir_builder->build_repeat_frame(ir_builder));
|
||||
ESP_ERROR_CHECK(ir_builder->get_result(ir_builder, &items, &length));
|
||||
rmt_write_items(example_tx_channel, items, length, true);
|
||||
cmd++;
|
||||
}
|
||||
ir_builder->del(ir_builder);
|
||||
rmt_driver_uninstall(example_tx_channel);
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
|
||||
void app_main(void)
|
||||
{
|
||||
xTaskCreate(example_ir_rx_task, "ir_rx_task", 2048, NULL, 10, NULL);
|
||||
xTaskCreate(example_ir_tx_task, "ir_tx_task", 2048, NULL, 10, NULL);
|
||||
}
|
||||
|
|
@ -3,4 +3,4 @@
|
|||
cmake_minimum_required(VERSION 3.5)
|
||||
|
||||
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
|
||||
project(rmt_tx)
|
||||
project(led_strip)
|
||||
|
|
@ -3,7 +3,6 @@
|
|||
# project subdirectory.
|
||||
#
|
||||
|
||||
PROJECT_NAME := rmt_tx
|
||||
PROJECT_NAME := led_strip
|
||||
|
||||
include $(IDF_PATH)/make/project.mk
|
||||
|
||||
52
examples/peripherals/rmt/led_strip/README.md
Normal file
52
examples/peripherals/rmt/led_strip/README.md
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
# RMT Transmit Example -- LED Strip
|
||||
|
||||
(See the README.md file in the upper level 'examples' directory for more information about examples.)
|
||||
|
||||
Although RMT peripheral is mainly designed for infrared remote applications, it can also support other generic protocols thanks to its flexible data format. [WS2812](http://www.world-semi.com/Certifications/WS2812B.html) is a digital RGB LED which integrates a driver circuit and a single control wire. The protocol data format defined in WS2812 is compatible to that in RMT peripheral. This example will illustrate how to drive an WS2812 LED strip based on the RMT driver.
|
||||
|
||||
## How to Use Example
|
||||
|
||||
### Hardware Required
|
||||
|
||||
* A development board with ESP32 SoC (e.g., ESP32-DevKitC, ESP-WROVER-KIT, etc.)
|
||||
* A USB cable for Power supply and programming
|
||||
* A WS2812 LED strip
|
||||
|
||||
Connection :
|
||||
|
||||
```
|
||||
--- 5V
|
||||
|
|
||||
+
|
||||
GPIO18 +-----------------+---|>| (WS2812)
|
||||
DI +
|
||||
|
|
||||
--- GND
|
||||
```
|
||||
|
||||
### Configure the Project
|
||||
|
||||
Open the project configuration menu (`idf.py menuconfig`).
|
||||
|
||||
In the `Example Connection Configuration` menu:
|
||||
|
||||
* Set the GPIO number used for transmitting the IR signal under `RMT TX GPIO` optin.
|
||||
* Set the number of LEDs in a strip under `Number of LEDS in a strip` option.
|
||||
|
||||
### Build and Flash
|
||||
|
||||
Run `idf.py -p PORT flash monitor` to build, flash and monitor the project.
|
||||
|
||||
(To exit the serial monitor, type ``Ctrl-]``.)
|
||||
|
||||
See the [Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html) for full steps to configure and use ESP-IDF to build projects.
|
||||
|
||||
## Example Output
|
||||
|
||||
Connect the `DI` signal of WS2812 LED strip to the GPIO you set in menuconfig.
|
||||
|
||||
Run the example, you will see a rainbow chasing demonstration effect. To change the chasing speed, you can update the `EXAMPLE_CHASE_SPEED_MS` value in `led_strip_main.c` file.
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
For any technical queries, please open an [issue] (https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you soon.
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
set(component_srcs "src/led_strip_rmt_ws2812.c")
|
||||
|
||||
idf_component_register(SRCS "${component_srcs}"
|
||||
INCLUDE_DIRS "include"
|
||||
PRIV_INCLUDE_DIRS ""
|
||||
PRIV_REQUIRES "driver"
|
||||
REQUIRES "")
|
||||
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
COMPONENT_ADD_INCLUDEDIRS := include
|
||||
|
||||
COMPONENT_SRCDIRS := src
|
||||
|
|
@ -0,0 +1,126 @@
|
|||
// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
#pragma once
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "esp_err.h"
|
||||
|
||||
/**
|
||||
* @brief LED Strip Type
|
||||
*
|
||||
*/
|
||||
typedef struct led_strip_s led_strip_t;
|
||||
|
||||
/**
|
||||
* @brief LED Strip Device Type
|
||||
*
|
||||
*/
|
||||
typedef void *led_strip_dev_t;
|
||||
|
||||
/**
|
||||
* @brief Declare of LED Strip Type
|
||||
*
|
||||
*/
|
||||
struct led_strip_s {
|
||||
/**
|
||||
* @brief Set RGB for a specific pixel
|
||||
*
|
||||
* @param strip: LED strip
|
||||
* @param index: index of pixel to set
|
||||
* @param red: red part of color
|
||||
* @param green: green part of color
|
||||
* @param blue: blue part of color
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: Set RGB for a specific pixel successfully
|
||||
* - ESP_ERR_INVALID_ARG: Set RGB for a specific pixel failed because of invalid parameters
|
||||
* - ESP_FAIL: Set RGB for a specific pixel failed because other error occurred
|
||||
*/
|
||||
esp_err_t (*set_pixel)(led_strip_t *strip, uint32_t index, uint32_t red, uint32_t green, uint32_t blue);
|
||||
|
||||
/**
|
||||
* @brief Refresh memory colors to LEDs
|
||||
*
|
||||
* @param strip: LED strip
|
||||
* @param timeout_ms: timeout value for refreshing task
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: Refresh successfully
|
||||
* - ESP_ERR_TIMEOUT: Refresh failed because of timeout
|
||||
* - ESP_FAIL: Refresh failed because some other error occurred
|
||||
*
|
||||
* @note:
|
||||
* After updating the LED colors in the memory, a following invocation of this API is needed to flush colors to strip.
|
||||
*/
|
||||
esp_err_t (*refresh)(led_strip_t *strip, uint32_t timeout_ms);
|
||||
|
||||
/**
|
||||
* @brief Clear LED strip (turn off all LEDs)
|
||||
*
|
||||
* @param strip: LED strip
|
||||
* @param timeout_ms: timeout value for clearing task
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: Clear LEDs successfully
|
||||
* - ESP_ERR_TIMEOUT: Clear LEDs failed because of timeout
|
||||
* - ESP_FAIL: Clear LEDs failed because some other error occurred
|
||||
*/
|
||||
esp_err_t (*clear)(led_strip_t *strip, uint32_t timeout_ms);
|
||||
|
||||
/**
|
||||
* @brief Free LED strip resources
|
||||
*
|
||||
* @param strip: LED strip
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK: Free resources successfully
|
||||
* - ESP_FAIL: Free resources failed because error occurred
|
||||
*/
|
||||
esp_err_t (*del)(led_strip_t *strip);
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief LED Strip Configuration Type
|
||||
*
|
||||
*/
|
||||
typedef struct {
|
||||
uint32_t max_leds; /*!< Maximum LEDs in a single strip */
|
||||
led_strip_dev_t dev; /*!< LED strip device (e.g. RMT channel, PWM channel, etc) */
|
||||
} led_strip_config_t;
|
||||
|
||||
/**
|
||||
* @brief Default configuration for LED strip
|
||||
*
|
||||
*/
|
||||
#define LED_STRIP_DEFAULT_CONFIG(number, dev_hdl) \
|
||||
{ \
|
||||
.max_leds = number, \
|
||||
.dev = dev_hdl, \
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Install a new ws2812 driver (based on RMT peripheral)
|
||||
*
|
||||
* @param config: LED strip configuration
|
||||
* @return
|
||||
* LED strip instance or NULL
|
||||
*/
|
||||
led_strip_t *led_strip_new_rmt_ws2812(const led_strip_config_t *config);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
@ -0,0 +1,171 @@
|
|||
// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/cdefs.h>
|
||||
#include "esp_log.h"
|
||||
#include "esp_attr.h"
|
||||
#include "led_strip.h"
|
||||
#include "driver/rmt.h"
|
||||
|
||||
static const char *TAG = "ws2812";
|
||||
#define STRIP_CHECK(a, str, goto_tag, ret_value, ...) \
|
||||
do \
|
||||
{ \
|
||||
if (!(a)) \
|
||||
{ \
|
||||
ESP_LOGE(TAG, "%s(%d): " str, __FUNCTION__, __LINE__, ##__VA_ARGS__); \
|
||||
ret = ret_value; \
|
||||
goto goto_tag; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define WS2812_T0H_NS (350)
|
||||
#define WS2812_T0L_NS (1000)
|
||||
#define WS2812_T1H_NS (1000)
|
||||
#define WS2812_T1L_NS (350)
|
||||
#define WS2812_RESET_US (280)
|
||||
|
||||
static uint32_t ws2812_t0h_ticks = 0;
|
||||
static uint32_t ws2812_t1h_ticks = 0;
|
||||
static uint32_t ws2812_t0l_ticks = 0;
|
||||
static uint32_t ws2812_t1l_ticks = 0;
|
||||
|
||||
typedef struct {
|
||||
led_strip_t parent;
|
||||
rmt_channel_t rmt_channel;
|
||||
uint32_t strip_len;
|
||||
uint8_t buffer[0];
|
||||
} ws2812_t;
|
||||
|
||||
/**
|
||||
* @brief Conver RGB data to RMT format.
|
||||
*
|
||||
* @note For WS2812, R,G,B each contains 256 different choices (i.e. uint8_t)
|
||||
*
|
||||
* @param[in] src: source data, to converted to RMT format
|
||||
* @param[in] dest: place where to store the convert result
|
||||
* @param[in] src_size: size of source data
|
||||
* @param[in] wanted_num: number of RMT items that want to get
|
||||
* @param[out] translated_size: number of source data that got converted
|
||||
* @param[out] item_num: number of RMT items which are converted from source data
|
||||
*/
|
||||
static void IRAM_ATTR ws2812_rmt_adapter(const void *src, rmt_item32_t *dest, size_t src_size,
|
||||
size_t wanted_num, size_t *translated_size, size_t *item_num)
|
||||
{
|
||||
if (src == NULL || dest == NULL) {
|
||||
*translated_size = 0;
|
||||
*item_num = 0;
|
||||
return;
|
||||
}
|
||||
const rmt_item32_t bit0 = {{{ ws2812_t0h_ticks, 1, ws2812_t0l_ticks, 0 }}}; //Logical 0
|
||||
const rmt_item32_t bit1 = {{{ ws2812_t1h_ticks, 1, ws2812_t1l_ticks, 0 }}}; //Logical 1
|
||||
size_t size = 0;
|
||||
size_t num = 0;
|
||||
uint8_t *psrc = (uint8_t *)src;
|
||||
rmt_item32_t *pdest = dest;
|
||||
while (size < src_size && num < wanted_num) {
|
||||
for (int i = 0; i < 8; i++) {
|
||||
// MSB first
|
||||
if (*psrc & (1 << (7 - i))) {
|
||||
pdest->val = bit1.val;
|
||||
} else {
|
||||
pdest->val = bit0.val;
|
||||
}
|
||||
num++;
|
||||
pdest++;
|
||||
}
|
||||
size++;
|
||||
psrc++;
|
||||
}
|
||||
*translated_size = size;
|
||||
*item_num = num;
|
||||
}
|
||||
|
||||
static esp_err_t ws2812_set_pixel(led_strip_t *strip, uint32_t index, uint32_t red, uint32_t green, uint32_t blue)
|
||||
{
|
||||
esp_err_t ret = ESP_OK;
|
||||
ws2812_t *ws2812 = __containerof(strip, ws2812_t, parent);
|
||||
STRIP_CHECK(index < ws2812->strip_len, "index out of the maximum number of leds", err, ESP_ERR_INVALID_ARG);
|
||||
uint32_t start = index * 3;
|
||||
// In thr order of GRB
|
||||
ws2812->buffer[start + 0] = green & 0xFF;
|
||||
ws2812->buffer[start + 1] = red & 0xFF;
|
||||
ws2812->buffer[start + 2] = blue & 0xFF;
|
||||
return ESP_OK;
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static esp_err_t ws2812_refresh(led_strip_t *strip, uint32_t timeout_ms)
|
||||
{
|
||||
esp_err_t ret = ESP_OK;
|
||||
ws2812_t *ws2812 = __containerof(strip, ws2812_t, parent);
|
||||
STRIP_CHECK(rmt_write_sample(ws2812->rmt_channel, ws2812->buffer, ws2812->strip_len * 3, true) == ESP_OK,
|
||||
"transmit RMT samples failed", err, ESP_FAIL);
|
||||
return rmt_wait_tx_done(ws2812->rmt_channel, pdMS_TO_TICKS(timeout_ms));
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static esp_err_t ws2812_clear(led_strip_t *strip, uint32_t timeout_ms)
|
||||
{
|
||||
ws2812_t *ws2812 = __containerof(strip, ws2812_t, parent);
|
||||
// Write zero to turn off all leds
|
||||
memset(ws2812->buffer, 0, ws2812->strip_len * 3);
|
||||
return ws2812_refresh(strip, timeout_ms);
|
||||
}
|
||||
|
||||
static esp_err_t ws2812_del(led_strip_t *strip)
|
||||
{
|
||||
ws2812_t *ws2812 = __containerof(strip, ws2812_t, parent);
|
||||
free(ws2812);
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
led_strip_t *led_strip_new_rmt_ws2812(const led_strip_config_t *config)
|
||||
{
|
||||
led_strip_t *ret = NULL;
|
||||
STRIP_CHECK(config, "configuration can't be null", err, NULL);
|
||||
|
||||
// 24 bits per led
|
||||
uint32_t ws2812_size = sizeof(ws2812_t) + config->max_leds * 3;
|
||||
ws2812_t *ws2812 = calloc(1, ws2812_size);
|
||||
STRIP_CHECK(ws2812, "request memory for ws2812 failed", err, NULL);
|
||||
|
||||
uint32_t counter_clk_hz = 0;
|
||||
STRIP_CHECK(rmt_get_counter_clock((rmt_channel_t)config->dev, &counter_clk_hz) == ESP_OK,
|
||||
"get rmt counter clock failed", err, NULL);
|
||||
// ns -> ticks
|
||||
float ratio = (float)counter_clk_hz / 1e9;
|
||||
ws2812_t0h_ticks = (uint32_t)(ratio * WS2812_T0H_NS);
|
||||
ws2812_t0l_ticks = (uint32_t)(ratio * WS2812_T0L_NS);
|
||||
ws2812_t1h_ticks = (uint32_t)(ratio * WS2812_T1H_NS);
|
||||
ws2812_t1l_ticks = (uint32_t)(ratio * WS2812_T1L_NS);
|
||||
|
||||
// set ws2812 to rmt adapter
|
||||
rmt_translator_init((rmt_channel_t)config->dev, ws2812_rmt_adapter);
|
||||
|
||||
ws2812->rmt_channel = (rmt_channel_t)config->dev;
|
||||
ws2812->strip_len = config->max_leds;
|
||||
|
||||
ws2812->parent.set_pixel = ws2812_set_pixel;
|
||||
ws2812->parent.refresh = ws2812_refresh;
|
||||
ws2812->parent.clear = ws2812_clear;
|
||||
ws2812->parent.del = ws2812_del;
|
||||
|
||||
return &ws2812->parent;
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
2
examples/peripherals/rmt/led_strip/main/CMakeLists.txt
Normal file
2
examples/peripherals/rmt/led_strip/main/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
idf_component_register(SRCS "led_strip_main.c"
|
||||
INCLUDE_DIRS ".")
|
||||
13
examples/peripherals/rmt/led_strip/main/Kconfig.projbuild
Normal file
13
examples/peripherals/rmt/led_strip/main/Kconfig.projbuild
Normal file
|
|
@ -0,0 +1,13 @@
|
|||
menu "Example Configuration"
|
||||
config EXAMPLE_RMT_TX_GPIO
|
||||
int "RMT TX GPIO"
|
||||
default 18
|
||||
help
|
||||
Set the GPIO number used for transmitting the RMT signal.
|
||||
|
||||
config EXAMPLE_STRIP_LED_NUMBER
|
||||
int "Number of LEDS in a strip"
|
||||
default 24
|
||||
help
|
||||
A single RGB strip contains several LEDs.
|
||||
endmenu
|
||||
116
examples/peripherals/rmt/led_strip/main/led_strip_main.c
Normal file
116
examples/peripherals/rmt/led_strip/main/led_strip_main.c
Normal file
|
|
@ -0,0 +1,116 @@
|
|||
/* RMT example -- RGB LED Strip
|
||||
|
||||
This example code is in the Public Domain (or CC0 licensed, at your option.)
|
||||
|
||||
Unless required by applicable law or agreed to in writing, this
|
||||
software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
||||
CONDITIONS OF ANY KIND, either express or implied.
|
||||
*/
|
||||
#include "sdkconfig.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "esp_log.h"
|
||||
#include "driver/rmt.h"
|
||||
#include "led_strip.h"
|
||||
|
||||
static const char *TAG = "example";
|
||||
|
||||
#define RMT_TX_CHANNEL RMT_CHANNEL_0
|
||||
|
||||
#define EXAMPLE_CHASE_SPEED_MS (10)
|
||||
|
||||
/**
|
||||
* @brief Simple helper function, converting HSV color space to RGB color space
|
||||
*
|
||||
* Wiki: https://en.wikipedia.org/wiki/HSL_and_HSV
|
||||
*
|
||||
*/
|
||||
void led_strip_hsv2rgb(uint32_t h, uint32_t s, uint32_t v, uint32_t *r, uint32_t *g, uint32_t *b)
|
||||
{
|
||||
h %= 360; // h -> [0,360]
|
||||
uint32_t rgb_max = v * 2.55f;
|
||||
uint32_t rgb_min = rgb_max * (100 - s) / 100.0f;
|
||||
|
||||
uint32_t i = h / 60;
|
||||
uint32_t diff = h % 60;
|
||||
|
||||
// RGB adjustment amount by hue
|
||||
uint32_t rgb_adj = (rgb_max - rgb_min) * diff / 60;
|
||||
|
||||
switch (i) {
|
||||
case 0:
|
||||
*r = rgb_max;
|
||||
*g = rgb_min + rgb_adj;
|
||||
*b = rgb_min;
|
||||
break;
|
||||
case 1:
|
||||
*r = rgb_max - rgb_adj;
|
||||
*g = rgb_max;
|
||||
*b = rgb_min;
|
||||
break;
|
||||
case 2:
|
||||
*r = rgb_min;
|
||||
*g = rgb_max;
|
||||
*b = rgb_min + rgb_adj;
|
||||
break;
|
||||
case 3:
|
||||
*r = rgb_min;
|
||||
*g = rgb_max - rgb_adj;
|
||||
*b = rgb_max;
|
||||
break;
|
||||
case 4:
|
||||
*r = rgb_min + rgb_adj;
|
||||
*g = rgb_min;
|
||||
*b = rgb_max;
|
||||
break;
|
||||
default:
|
||||
*r = rgb_max;
|
||||
*g = rgb_min;
|
||||
*b = rgb_max - rgb_adj;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void app_main(void)
|
||||
{
|
||||
uint32_t red = 0;
|
||||
uint32_t green = 0;
|
||||
uint32_t blue = 0;
|
||||
uint16_t hue = 0;
|
||||
uint16_t start_rgb = 0;
|
||||
|
||||
rmt_config_t config = RMT_DEFAULT_CONFIG_TX(CONFIG_EXAMPLE_RMT_TX_GPIO, RMT_TX_CHANNEL);
|
||||
// set counter clock to 40MHz
|
||||
config.clk_div = 2;
|
||||
|
||||
ESP_ERROR_CHECK(rmt_config(&config));
|
||||
ESP_ERROR_CHECK(rmt_driver_install(config.channel, 0, 0));
|
||||
|
||||
// install ws2812 driver
|
||||
led_strip_config_t strip_config = LED_STRIP_DEFAULT_CONFIG(CONFIG_EXAMPLE_STRIP_LED_NUMBER, (led_strip_dev_t)config.channel);
|
||||
led_strip_t *strip = led_strip_new_rmt_ws2812(&strip_config);
|
||||
if (!strip) {
|
||||
ESP_LOGE(TAG, "install WS2812 driver failed");
|
||||
}
|
||||
// Clear LED strip (turn off all LEDs)
|
||||
ESP_ERROR_CHECK(strip->clear(strip, 100));
|
||||
// Show simple rainbow chasing pattern
|
||||
ESP_LOGI(TAG, "LED Rainbow Chase Start");
|
||||
while (true) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
for (int j = i; j < CONFIG_EXAMPLE_STRIP_LED_NUMBER; j += 3) {
|
||||
// Build RGB values
|
||||
hue = j * 360 / CONFIG_EXAMPLE_STRIP_LED_NUMBER + start_rgb;
|
||||
led_strip_hsv2rgb(hue, 100, 100, &red, &green, &blue);
|
||||
// Write RGB values to strip driver
|
||||
ESP_ERROR_CHECK(strip->set_pixel(strip, j, red, green, blue));
|
||||
}
|
||||
// Flush RGB values to LEDs
|
||||
ESP_ERROR_CHECK(strip->refresh(strip, 100));
|
||||
vTaskDelay(pdMS_TO_TICKS(EXAMPLE_CHASE_SPEED_MS));
|
||||
strip->clear(strip, 50);
|
||||
vTaskDelay(pdMS_TO_TICKS(EXAMPLE_CHASE_SPEED_MS));
|
||||
}
|
||||
start_rgb += 60;
|
||||
}
|
||||
}
|
||||
6
examples/peripherals/rmt/morse_code/CMakeLists.txt
Normal file
6
examples/peripherals/rmt/morse_code/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
# The following lines of boilerplate have to be in your project's CMakeLists
|
||||
# in this exact order for cmake to work correctly
|
||||
cmake_minimum_required(VERSION 3.5)
|
||||
|
||||
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
|
||||
project(morse_code)
|
||||
9
examples/peripherals/rmt/morse_code/Makefile
Normal file
9
examples/peripherals/rmt/morse_code/Makefile
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
#
|
||||
# This is a project Makefile. It is assumed the directory this Makefile resides in is a
|
||||
# project subdirectory.
|
||||
#
|
||||
|
||||
PROJECT_NAME := morse_code
|
||||
|
||||
include $(IDF_PATH)/make/project.mk
|
||||
|
||||
|
|
@ -1,8 +1,8 @@
|
|||
# _RMT Transmit Example_
|
||||
# RMT Transmit Example -- Morse Code
|
||||
|
||||
(See the README.md file in the upper level 'examples' directory for more information about examples.)
|
||||
|
||||
This example will shows how to configure and operate the remote control (RMT) peripheral to transmit a sample message in the [Morse code](https://en.wikipedia.org/wiki/Morse_code), it also shows how to transmit custom format of data.
|
||||
This example mainly illustrates how to transmit the [Morse code](https://en.wikipedia.org/wiki/Morse_code) using the RMT driver.
|
||||
|
||||
## How to Use Example
|
||||
|
||||
|
|
@ -29,39 +29,34 @@ GPIO18 +----/\/\/\----+------|>|-----+ GND
|
|||
|
||||
### Configure the Project
|
||||
|
||||
```
|
||||
idf.py menuconfig
|
||||
```
|
||||
Open the project configuration menu (`idf.py menuconfig`).
|
||||
|
||||
* Set serial port under Serial Flasher Options.
|
||||
In the `Example Connection Configuration` menu:
|
||||
|
||||
* Set the GPIO number used for transmitting the IR signal under `RMT TX GPIO` optin.
|
||||
|
||||
### Build and Flash
|
||||
|
||||
Build the project and flash it to the board, then run monitor tool to view serial output:
|
||||
|
||||
```
|
||||
idf.py -p PORT flash monitor
|
||||
```
|
||||
Run `idf.py -p PORT flash monitor` to build, flash and monitor the project.
|
||||
|
||||
(To exit the serial monitor, type ``Ctrl-]``.)
|
||||
|
||||
See the [Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html) for full steps to configure and use ESP-IDF to build projects.
|
||||
|
||||
|
||||
## Example Output
|
||||
|
||||
To be able to see and hear the message output by the RMT, connect a LED and a speaker or an earphone (be careful - it may be loud) to the GPIO18(the pin can be changed by modify the definition of `RMT_TX_GPIO` in `main/rmt_tx_main.c`).
|
||||
To be able to see and hear the message output by the RMT, connect an LED and a speaker or an earphone (be careful it might make a large noise) to the GPIO you set in the menuconfig.
|
||||
|
||||
Run this example, you will see the following output log:
|
||||
```
|
||||
RMT Tx: Transmission complete
|
||||
RMT Tx: Sample transmission complete
|
||||
Run the example, you will see the following output log:
|
||||
|
||||
``` bash
|
||||
...
|
||||
I (304) example: Configuring transmitter
|
||||
I (2814) example: Transmission complete
|
||||
...
|
||||
```
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
* Programming fail
|
||||
|
||||
* Hardware connection is not correct: run `idf.py -p PORT monitor`, and reboot your board to see if there is any output logs.
|
||||
* The baud rate for downloading is too high: lower your baud rate in the `menuconfig` menu, and try again.
|
||||
|
||||
For any technical queries, please open an [issue] (https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you soon.
|
||||
2
examples/peripherals/rmt/morse_code/main/CMakeLists.txt
Normal file
2
examples/peripherals/rmt/morse_code/main/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
idf_component_register(SRCS "morse_code_main.c"
|
||||
INCLUDE_DIRS ".")
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
menu "Example Configuration"
|
||||
config EXAMPLE_RMT_TX_GPIO
|
||||
int "RMT TX GPIO"
|
||||
default 18
|
||||
help
|
||||
Set the GPIO number used for transmitting the RMT signal.
|
||||
endmenu
|
||||
4
examples/peripherals/rmt/morse_code/main/component.mk
Normal file
4
examples/peripherals/rmt/morse_code/main/component.mk
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
#
|
||||
# Main Makefile. This is basically the same as a component makefile.
|
||||
#
|
||||
# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)
|
||||
80
examples/peripherals/rmt/morse_code/main/morse_code_main.c
Normal file
80
examples/peripherals/rmt/morse_code/main/morse_code_main.c
Normal file
|
|
@ -0,0 +1,80 @@
|
|||
/* RMT example -- Morse Code
|
||||
|
||||
This example code is in the Public Domain (or CC0 licensed, at your option.)
|
||||
|
||||
Unless required by applicable law or agreed to in writing, this
|
||||
software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
||||
CONDITIONS OF ANY KIND, either express or implied.
|
||||
*/
|
||||
#include "sdkconfig.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "esp_log.h"
|
||||
#include "driver/rmt.h"
|
||||
|
||||
static const char *TAG = "example";
|
||||
|
||||
#define RMT_TX_CHANNEL RMT_CHANNEL_0
|
||||
|
||||
/*
|
||||
* Prepare a raw table with a message in the Morse code
|
||||
*
|
||||
* The message is "ESP" : . ... .--.
|
||||
*
|
||||
* The table structure represents the RMT item structure:
|
||||
* {duration, level, duration, level}
|
||||
*
|
||||
*/
|
||||
static const rmt_item32_t morse_esp[] = {
|
||||
// E : dot
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dot
|
||||
{{{ 32767, 0, 32767, 0 }}}, // SPACE
|
||||
// S : dot, dot, dot
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dot
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dot
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dot
|
||||
{{{ 32767, 0, 32767, 0 }}}, // SPACE
|
||||
// P : dot, dash, dash, dot
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dot
|
||||
{{{ 32767, 1, 32767, 1 }}},
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dash
|
||||
{{{ 32767, 1, 32767, 1 }}},
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dash
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dot
|
||||
// RMT end marker
|
||||
{{{ 0, 1, 0, 0 }}}
|
||||
};
|
||||
|
||||
/*
|
||||
* Initialize the RMT Tx channel
|
||||
*/
|
||||
static void rmt_tx_init(void)
|
||||
{
|
||||
rmt_config_t config = RMT_DEFAULT_CONFIG_TX(CONFIG_EXAMPLE_RMT_TX_GPIO, RMT_TX_CHANNEL);
|
||||
// enable the carrier to be able to hear the Morse sound
|
||||
// if the RMT_TX_GPIO is connected to a speaker
|
||||
config.tx_config.carrier_en = true;
|
||||
config.tx_config.carrier_duty_percent = 50;
|
||||
// set audible career frequency of 611 Hz
|
||||
// actually 611 Hz is the minimum, that can be set
|
||||
// with current implementation of the RMT API
|
||||
config.tx_config.carrier_freq_hz = 611;
|
||||
// set the maximum clock divider to be able to output
|
||||
// RMT pulses in range of about one hundred milliseconds
|
||||
config.clk_div = 255;
|
||||
|
||||
ESP_ERROR_CHECK(rmt_config(&config));
|
||||
ESP_ERROR_CHECK(rmt_driver_install(config.channel, 0, 0));
|
||||
}
|
||||
|
||||
void app_main(void *ignore)
|
||||
{
|
||||
ESP_LOGI(TAG, "Configuring transmitter");
|
||||
rmt_tx_init();
|
||||
|
||||
while (1) {
|
||||
ESP_ERROR_CHECK(rmt_write_items(RMT_TX_CHANNEL, morse_esp, sizeof(morse_esp) / sizeof(morse_esp[0]), true));
|
||||
ESP_LOGI(TAG, "Transmission complete");
|
||||
vTaskDelay(1000 / portTICK_PERIOD_MS);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,80 +0,0 @@
|
|||
# _RMT NEC_TX_RX Example_
|
||||
|
||||
(See the README.md file in the upper level 'examples' directory for more information about examples.)
|
||||
|
||||
This example uses the remote control (RMT) peripheral to transmit and receive codes for the NEC infrared remote protocol.
|
||||
|
||||
## How to Use Example
|
||||
|
||||
### Hardware Required
|
||||
|
||||
* A development board with ESP32 SoC (e.g., ESP32-DevKitC, ESP-WROVER-KIT, etc.)
|
||||
* A USB cable for Power supply and programming
|
||||
|
||||
By default, this example runs a self test which assumes the TX pin (GPIO18) and RX pin (GPIO19) are _connected together_.
|
||||
|
||||
To disable self-test mode, comment out RMT_RX_SELF_TEST in infrared_nec_main.c, after which, you need to connect a IR transmitter and a receiver to GPIO18 and GPIO19.
|
||||
|
||||
The TX pin and RX pin can be modified in top of the main/infrared_nec_main.c file.
|
||||
|
||||
```
|
||||
#define RMT_TX_GPIO_NUM 18 /*!< GPIO number for transmitter signal */
|
||||
#define RMT_RX_GPIO_NUM 19 /*!< GPIO number for receiver */
|
||||
```
|
||||
|
||||
### Configure the Project
|
||||
|
||||
```
|
||||
idf.py menuconfig
|
||||
```
|
||||
|
||||
* Set serial port under Serial Flasher Options.
|
||||
|
||||
### Build and Flash
|
||||
|
||||
Build the project and flash it to the board, then run monitor tool to view serial output:
|
||||
|
||||
```
|
||||
idf.py -p PORT flash monitor
|
||||
```
|
||||
|
||||
(To exit the serial monitor, type ``Ctrl-]``.)
|
||||
|
||||
See the Getting Started Guide for full steps to configure and use ESP-IDF to build projects.
|
||||
|
||||
## Example Output
|
||||
|
||||
Run this example, you will see the following output log:
|
||||
```
|
||||
NEC: RMT TX DATA
|
||||
NEC: RMT RCV --- addr: 0xee11 cmd: 0xff00
|
||||
NEC: RMT RCV --- addr: 0xed12 cmd: 0xfe01
|
||||
NEC: RMT RCV --- addr: 0xec13 cmd: 0xfd02
|
||||
NEC: RMT RCV --- addr: 0xeb14 cmd: 0xfc03
|
||||
NEC: RMT RCV --- addr: 0xea15 cmd: 0xfb04
|
||||
NEC: RMT RCV --- addr: 0xe916 cmd: 0xfa05
|
||||
NEC: RMT RCV --- addr: 0xe817 cmd: 0xf906
|
||||
NEC: RMT RCV --- addr: 0xe718 cmd: 0xf807
|
||||
NEC: RMT RCV --- addr: 0xe619 cmd: 0xf708
|
||||
NEC: RMT RCV --- addr: 0xe51a cmd: 0xf609
|
||||
NEC: RMT RCV --- addr: 0xe41b cmd: 0xf50a
|
||||
NEC: RMT RCV --- addr: 0xe31c cmd: 0xf40b
|
||||
NEC: RMT RCV --- addr: 0xe21d cmd: 0xf30c
|
||||
NEC: RMT RCV --- addr: 0xe11e cmd: 0xf20d
|
||||
NEC: RMT RCV --- addr: 0xe01f cmd: 0xf10e
|
||||
NEC: RMT RCV --- addr: 0xdf20 cmd: 0xf00f
|
||||
NEC: RMT RCV --- addr: 0xde21 cmd: 0xef10
|
||||
NEC: RMT RCV --- addr: 0xdd22 cmd: 0xee11
|
||||
NEC: RMT RCV --- addr: 0xdc23 cmd: 0xed12
|
||||
NEC: RMT RCV --- addr: 0xdb24 cmd: 0xec13
|
||||
NEC: RMT RCV --- addr: 0xda25 cmd: 0xeb14
|
||||
```
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
* Programming fail
|
||||
|
||||
* Hardware connection is not correct: run `idf.py -p PORT monitor`, and reboot your board to see if there is any output logs.
|
||||
* The baud rate for downloading is too high: lower your baud rate in the `menuconfig` menu, and try again.
|
||||
|
||||
For any technical queries, please open an [issue] (https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you soon.
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
idf_component_register(SRCS "infrared_nec_main.c"
|
||||
INCLUDE_DIRS ".")
|
||||
|
|
@ -1,362 +0,0 @@
|
|||
/* NEC remote infrared RMT example
|
||||
|
||||
This example code is in the Public Domain (or CC0 licensed, at your option.)
|
||||
|
||||
Unless required by applicable law or agreed to in writing, this
|
||||
software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
||||
CONDITIONS OF ANY KIND, either express or implied.
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "freertos/queue.h"
|
||||
#include "freertos/semphr.h"
|
||||
#include "esp_err.h"
|
||||
#include "esp_log.h"
|
||||
#include "driver/rmt.h"
|
||||
|
||||
static const char* NEC_TAG = "NEC";
|
||||
|
||||
//CHOOSE SELF TEST OR NORMAL TEST
|
||||
#define RMT_RX_SELF_TEST 1
|
||||
|
||||
/******************************************************/
|
||||
/***** SELF TEST: *****/
|
||||
/*Connect RMT_TX_GPIO_NUM with RMT_RX_GPIO_NUM */
|
||||
/*TX task will send NEC data with carrier disabled */
|
||||
/*RX task will print NEC data it receives. */
|
||||
/******************************************************/
|
||||
#if RMT_RX_SELF_TEST
|
||||
#define RMT_RX_ACTIVE_LEVEL 1 /*!< Data bit is active high for self test mode */
|
||||
#define RMT_TX_CARRIER_EN 0 /*!< Disable carrier for self test mode */
|
||||
#else
|
||||
//Test with infrared LED, we have to enable carrier for transmitter
|
||||
//When testing via IR led, the receiver waveform is usually active-low.
|
||||
#define RMT_RX_ACTIVE_LEVEL 0 /*!< If we connect with a IR receiver, the data is active low */
|
||||
#define RMT_TX_CARRIER_EN 1 /*!< Enable carrier for IR transmitter test with IR led */
|
||||
#endif
|
||||
|
||||
#define RMT_TX_CHANNEL 1 /*!< RMT channel for transmitter */
|
||||
#define RMT_TX_GPIO_NUM 18 /*!< GPIO number for transmitter signal */
|
||||
#define RMT_RX_CHANNEL 0 /*!< RMT channel for receiver */
|
||||
#define RMT_RX_GPIO_NUM 19 /*!< GPIO number for receiver */
|
||||
#define RMT_CLK_DIV 100 /*!< RMT counter clock divider */
|
||||
#define RMT_TICK_10_US (80000000/RMT_CLK_DIV/100000) /*!< RMT counter value for 10 us.(Source clock is APB clock) */
|
||||
|
||||
#define NEC_HEADER_HIGH_US 9000 /*!< NEC protocol header: positive 9ms */
|
||||
#define NEC_HEADER_LOW_US 4500 /*!< NEC protocol header: negative 4.5ms*/
|
||||
#define NEC_BIT_ONE_HIGH_US 560 /*!< NEC protocol data bit 1: positive 0.56ms */
|
||||
#define NEC_BIT_ONE_LOW_US (2250-NEC_BIT_ONE_HIGH_US) /*!< NEC protocol data bit 1: negative 1.69ms */
|
||||
#define NEC_BIT_ZERO_HIGH_US 560 /*!< NEC protocol data bit 0: positive 0.56ms */
|
||||
#define NEC_BIT_ZERO_LOW_US (1120-NEC_BIT_ZERO_HIGH_US) /*!< NEC protocol data bit 0: negative 0.56ms */
|
||||
#define NEC_BIT_END 560 /*!< NEC protocol end: positive 0.56ms */
|
||||
#define NEC_BIT_MARGIN 20 /*!< NEC parse margin time */
|
||||
|
||||
#define NEC_ITEM_DURATION(d) ((d & 0x7fff)*10/RMT_TICK_10_US) /*!< Parse duration time from memory register value */
|
||||
#define NEC_DATA_ITEM_NUM 34 /*!< NEC code item number: header + 32bit data + end */
|
||||
#define RMT_TX_DATA_NUM 100 /*!< NEC tx test data number */
|
||||
#define rmt_item32_tIMEOUT_US 9500 /*!< RMT receiver timeout value(us) */
|
||||
|
||||
/*
|
||||
* @brief Build register value of waveform for NEC one data bit
|
||||
*/
|
||||
static inline void nec_fill_item_level(rmt_item32_t* item, int high_us, int low_us)
|
||||
{
|
||||
item->level0 = 1;
|
||||
item->duration0 = (high_us) / 10 * RMT_TICK_10_US;
|
||||
item->level1 = 0;
|
||||
item->duration1 = (low_us) / 10 * RMT_TICK_10_US;
|
||||
}
|
||||
|
||||
/*
|
||||
* @brief Generate NEC header value: active 9ms + negative 4.5ms
|
||||
*/
|
||||
static void nec_fill_item_header(rmt_item32_t* item)
|
||||
{
|
||||
nec_fill_item_level(item, NEC_HEADER_HIGH_US, NEC_HEADER_LOW_US);
|
||||
}
|
||||
|
||||
/*
|
||||
* @brief Generate NEC data bit 1: positive 0.56ms + negative 1.69ms
|
||||
*/
|
||||
static void nec_fill_item_bit_one(rmt_item32_t* item)
|
||||
{
|
||||
nec_fill_item_level(item, NEC_BIT_ONE_HIGH_US, NEC_BIT_ONE_LOW_US);
|
||||
}
|
||||
|
||||
/*
|
||||
* @brief Generate NEC data bit 0: positive 0.56ms + negative 0.56ms
|
||||
*/
|
||||
static void nec_fill_item_bit_zero(rmt_item32_t* item)
|
||||
{
|
||||
nec_fill_item_level(item, NEC_BIT_ZERO_HIGH_US, NEC_BIT_ZERO_LOW_US);
|
||||
}
|
||||
|
||||
/*
|
||||
* @brief Generate NEC end signal: positive 0.56ms
|
||||
*/
|
||||
static void nec_fill_item_end(rmt_item32_t* item)
|
||||
{
|
||||
nec_fill_item_level(item, NEC_BIT_END, 0x7fff);
|
||||
}
|
||||
|
||||
/*
|
||||
* @brief Check whether duration is around target_us
|
||||
*/
|
||||
inline bool nec_check_in_range(int duration_ticks, int target_us, int margin_us)
|
||||
{
|
||||
if(( NEC_ITEM_DURATION(duration_ticks) < (target_us + margin_us))
|
||||
&& ( NEC_ITEM_DURATION(duration_ticks) > (target_us - margin_us))) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* @brief Check whether this value represents an NEC header
|
||||
*/
|
||||
static bool nec_header_if(rmt_item32_t* item)
|
||||
{
|
||||
if((item->level0 == RMT_RX_ACTIVE_LEVEL && item->level1 != RMT_RX_ACTIVE_LEVEL)
|
||||
&& nec_check_in_range(item->duration0, NEC_HEADER_HIGH_US, NEC_BIT_MARGIN)
|
||||
&& nec_check_in_range(item->duration1, NEC_HEADER_LOW_US, NEC_BIT_MARGIN)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* @brief Check whether this value represents an NEC data bit 1
|
||||
*/
|
||||
static bool nec_bit_one_if(rmt_item32_t* item)
|
||||
{
|
||||
if((item->level0 == RMT_RX_ACTIVE_LEVEL && item->level1 != RMT_RX_ACTIVE_LEVEL)
|
||||
&& nec_check_in_range(item->duration0, NEC_BIT_ONE_HIGH_US, NEC_BIT_MARGIN)
|
||||
&& nec_check_in_range(item->duration1, NEC_BIT_ONE_LOW_US, NEC_BIT_MARGIN)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* @brief Check whether this value represents an NEC data bit 0
|
||||
*/
|
||||
static bool nec_bit_zero_if(rmt_item32_t* item)
|
||||
{
|
||||
if((item->level0 == RMT_RX_ACTIVE_LEVEL && item->level1 != RMT_RX_ACTIVE_LEVEL)
|
||||
&& nec_check_in_range(item->duration0, NEC_BIT_ZERO_HIGH_US, NEC_BIT_MARGIN)
|
||||
&& nec_check_in_range(item->duration1, NEC_BIT_ZERO_LOW_US, NEC_BIT_MARGIN)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* @brief Parse NEC 32 bit waveform to address and command.
|
||||
*/
|
||||
static int nec_parse_items(rmt_item32_t* item, int item_num, uint16_t* addr, uint16_t* data)
|
||||
{
|
||||
int w_len = item_num;
|
||||
if(w_len < NEC_DATA_ITEM_NUM) {
|
||||
return -1;
|
||||
}
|
||||
int i = 0, j = 0;
|
||||
if(!nec_header_if(item++)) {
|
||||
return -1;
|
||||
}
|
||||
uint16_t addr_t = 0;
|
||||
for(j = 0; j < 16; j++) {
|
||||
if(nec_bit_one_if(item)) {
|
||||
addr_t |= (1 << j);
|
||||
} else if(nec_bit_zero_if(item)) {
|
||||
addr_t |= (0 << j);
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
item++;
|
||||
i++;
|
||||
}
|
||||
uint16_t data_t = 0;
|
||||
for(j = 0; j < 16; j++) {
|
||||
if(nec_bit_one_if(item)) {
|
||||
data_t |= (1 << j);
|
||||
} else if(nec_bit_zero_if(item)) {
|
||||
data_t |= (0 << j);
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
item++;
|
||||
i++;
|
||||
}
|
||||
*addr = addr_t;
|
||||
*data = data_t;
|
||||
return i;
|
||||
}
|
||||
|
||||
/*
|
||||
* @brief Build NEC 32bit waveform.
|
||||
*/
|
||||
static int nec_build_items(int channel, rmt_item32_t* item, int item_num, uint16_t addr, uint16_t cmd_data)
|
||||
{
|
||||
int i = 0, j = 0;
|
||||
if(item_num < NEC_DATA_ITEM_NUM) {
|
||||
return -1;
|
||||
}
|
||||
nec_fill_item_header(item++);
|
||||
i++;
|
||||
for(j = 0; j < 16; j++) {
|
||||
if(addr & 0x1) {
|
||||
nec_fill_item_bit_one(item);
|
||||
} else {
|
||||
nec_fill_item_bit_zero(item);
|
||||
}
|
||||
item++;
|
||||
i++;
|
||||
addr >>= 1;
|
||||
}
|
||||
for(j = 0; j < 16; j++) {
|
||||
if(cmd_data & 0x1) {
|
||||
nec_fill_item_bit_one(item);
|
||||
} else {
|
||||
nec_fill_item_bit_zero(item);
|
||||
}
|
||||
item++;
|
||||
i++;
|
||||
cmd_data >>= 1;
|
||||
}
|
||||
nec_fill_item_end(item);
|
||||
i++;
|
||||
return i;
|
||||
}
|
||||
|
||||
/*
|
||||
* @brief RMT transmitter initialization
|
||||
*/
|
||||
static void nec_tx_init(void)
|
||||
{
|
||||
rmt_config_t rmt_tx;
|
||||
rmt_tx.channel = RMT_TX_CHANNEL;
|
||||
rmt_tx.gpio_num = RMT_TX_GPIO_NUM;
|
||||
rmt_tx.mem_block_num = 1;
|
||||
rmt_tx.clk_div = RMT_CLK_DIV;
|
||||
rmt_tx.tx_config.loop_en = false;
|
||||
rmt_tx.tx_config.carrier_duty_percent = 50;
|
||||
rmt_tx.tx_config.carrier_freq_hz = 38000;
|
||||
rmt_tx.tx_config.carrier_level = 1;
|
||||
rmt_tx.tx_config.carrier_en = RMT_TX_CARRIER_EN;
|
||||
rmt_tx.tx_config.idle_level = 0;
|
||||
rmt_tx.tx_config.idle_output_en = true;
|
||||
rmt_tx.rmt_mode = 0;
|
||||
rmt_config(&rmt_tx);
|
||||
rmt_driver_install(rmt_tx.channel, 0, 0);
|
||||
}
|
||||
|
||||
/*
|
||||
* @brief RMT receiver initialization
|
||||
*/
|
||||
static void nec_rx_init(void)
|
||||
{
|
||||
rmt_config_t rmt_rx;
|
||||
rmt_rx.channel = RMT_RX_CHANNEL;
|
||||
rmt_rx.gpio_num = RMT_RX_GPIO_NUM;
|
||||
rmt_rx.clk_div = RMT_CLK_DIV;
|
||||
rmt_rx.mem_block_num = 1;
|
||||
rmt_rx.rmt_mode = RMT_MODE_RX;
|
||||
rmt_rx.rx_config.filter_en = true;
|
||||
rmt_rx.rx_config.filter_ticks_thresh = 100;
|
||||
rmt_rx.rx_config.idle_threshold = rmt_item32_tIMEOUT_US / 10 * (RMT_TICK_10_US);
|
||||
rmt_config(&rmt_rx);
|
||||
rmt_driver_install(rmt_rx.channel, 1000, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief RMT receiver demo, this task will print each received NEC data.
|
||||
*
|
||||
*/
|
||||
static void rmt_example_nec_rx_task(void *arg)
|
||||
{
|
||||
int channel = RMT_RX_CHANNEL;
|
||||
nec_rx_init();
|
||||
RingbufHandle_t rb = NULL;
|
||||
//get RMT RX ringbuffer
|
||||
rmt_get_ringbuf_handle(channel, &rb);
|
||||
rmt_rx_start(channel, 1);
|
||||
while(rb) {
|
||||
size_t rx_size = 0;
|
||||
//try to receive data from ringbuffer.
|
||||
//RMT driver will push all the data it receives to its ringbuffer.
|
||||
//We just need to parse the value and return the spaces of ringbuffer.
|
||||
rmt_item32_t* item = (rmt_item32_t*) xRingbufferReceive(rb, &rx_size, 1000);
|
||||
if(item) {
|
||||
uint16_t rmt_addr;
|
||||
uint16_t rmt_cmd;
|
||||
int offset = 0;
|
||||
while(1) {
|
||||
//parse data value from ringbuffer.
|
||||
int res = nec_parse_items(item + offset, rx_size / 4 - offset, &rmt_addr, &rmt_cmd);
|
||||
if(res > 0) {
|
||||
offset += res + 1;
|
||||
ESP_LOGI(NEC_TAG, "RMT RCV --- addr: 0x%04x cmd: 0x%04x", rmt_addr, rmt_cmd);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
//after parsing the data, return spaces to ringbuffer.
|
||||
vRingbufferReturnItem(rb, (void*) item);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief RMT transmitter demo, this task will periodically send NEC data. (100 * 32 bits each time.)
|
||||
*
|
||||
*/
|
||||
static void rmt_example_nec_tx_task(void *arg)
|
||||
{
|
||||
vTaskDelay(10);
|
||||
nec_tx_init();
|
||||
esp_log_level_set(NEC_TAG, ESP_LOG_INFO);
|
||||
int channel = RMT_TX_CHANNEL;
|
||||
uint16_t cmd = 0x0;
|
||||
uint16_t addr = 0x11;
|
||||
int nec_tx_num = RMT_TX_DATA_NUM;
|
||||
for(;;) {
|
||||
ESP_LOGI(NEC_TAG, "RMT TX DATA");
|
||||
size_t size = (sizeof(rmt_item32_t) * NEC_DATA_ITEM_NUM * nec_tx_num);
|
||||
//each item represent a cycle of waveform.
|
||||
rmt_item32_t* item = (rmt_item32_t*) malloc(size);
|
||||
int item_num = NEC_DATA_ITEM_NUM * nec_tx_num;
|
||||
memset((void*) item, 0, size);
|
||||
int i, offset = 0;
|
||||
while(1) {
|
||||
//To build a series of waveforms.
|
||||
i = nec_build_items(channel, item + offset, item_num - offset, ((~addr) << 8) | addr, ((~cmd) << 8) | cmd);
|
||||
if(i < 0) {
|
||||
break;
|
||||
}
|
||||
cmd++;
|
||||
addr++;
|
||||
offset += i;
|
||||
}
|
||||
//To send data according to the waveform items.
|
||||
rmt_write_items(channel, item, item_num, true);
|
||||
//Wait until sending is done.
|
||||
rmt_wait_tx_done(channel, portMAX_DELAY);
|
||||
//before we free the data, make sure sending is already done.
|
||||
free(item);
|
||||
vTaskDelay(2000 / portTICK_PERIOD_MS);
|
||||
}
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
|
||||
void app_main(void)
|
||||
{
|
||||
xTaskCreate(rmt_example_nec_rx_task, "rmt_nec_rx_task", 2048, NULL, 10, NULL);
|
||||
xTaskCreate(rmt_example_nec_tx_task, "rmt_nec_tx_task", 2048, NULL, 10, NULL);
|
||||
}
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
idf_component_register(SRCS "rmt_tx_main.c"
|
||||
INCLUDE_DIRS ".")
|
||||
|
|
@ -1,131 +0,0 @@
|
|||
/* RMT transmit example
|
||||
|
||||
This example code is in the Public Domain (or CC0 licensed, at your option.)
|
||||
|
||||
Unless required by applicable law or agreed to in writing, this
|
||||
software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
||||
CONDITIONS OF ANY KIND, either express or implied.
|
||||
*/
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "esp_log.h"
|
||||
#include "driver/rmt.h"
|
||||
|
||||
static const char *RMT_TX_TAG = "RMT Tx";
|
||||
|
||||
#define RMT_TX_CHANNEL RMT_CHANNEL_0
|
||||
#define RMT_TX_GPIO 18
|
||||
#define SAMPLE_CNT (10)
|
||||
|
||||
/*
|
||||
* Prepare a raw table with a message in the Morse code
|
||||
*
|
||||
* The message is "ESP" : . ... .--.
|
||||
*
|
||||
* The table structure represents the RMT item structure:
|
||||
* {duration, level, duration, level}
|
||||
*
|
||||
*/
|
||||
rmt_item32_t items[] = {
|
||||
// E : dot
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dot
|
||||
//
|
||||
{{{ 32767, 0, 32767, 0 }}}, // SPACE
|
||||
// S : dot, dot, dot
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dot
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dot
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dot
|
||||
//
|
||||
{{{ 32767, 0, 32767, 0 }}}, // SPACE
|
||||
// P : dot, dash, dash, dot
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dot
|
||||
{{{ 32767, 1, 32767, 1 }}},
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dash
|
||||
{{{ 32767, 1, 32767, 1 }}},
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dash
|
||||
{{{ 32767, 1, 32767, 0 }}}, // dot
|
||||
|
||||
// RMT end marker
|
||||
{{{ 0, 1, 0, 0 }}}
|
||||
};
|
||||
|
||||
//Convert uint8_t type of data to rmt format data.
|
||||
static void IRAM_ATTR u8_to_rmt(const void* src, rmt_item32_t* dest, size_t src_size,
|
||||
size_t wanted_num, size_t* translated_size, size_t* item_num)
|
||||
{
|
||||
if(src == NULL || dest == NULL) {
|
||||
*translated_size = 0;
|
||||
*item_num = 0;
|
||||
return;
|
||||
}
|
||||
const rmt_item32_t bit0 = {{{ 32767, 1, 15000, 0 }}}; //Logical 0
|
||||
const rmt_item32_t bit1 = {{{ 32767, 1, 32767, 0 }}}; //Logical 1
|
||||
size_t size = 0;
|
||||
size_t num = 0;
|
||||
uint8_t *psrc = (uint8_t *)src;
|
||||
rmt_item32_t* pdest = dest;
|
||||
while (size < src_size && num < wanted_num) {
|
||||
for(int i = 0; i < 8; i++) {
|
||||
if(*psrc & (0x1 << i)) {
|
||||
pdest->val = bit1.val;
|
||||
} else {
|
||||
pdest->val = bit0.val;
|
||||
}
|
||||
num++;
|
||||
pdest++;
|
||||
}
|
||||
size++;
|
||||
psrc++;
|
||||
}
|
||||
*translated_size = size;
|
||||
*item_num = num;
|
||||
}
|
||||
|
||||
/*
|
||||
* Initialize the RMT Tx channel
|
||||
*/
|
||||
static void rmt_tx_int(void)
|
||||
{
|
||||
rmt_config_t config;
|
||||
config.rmt_mode = RMT_MODE_TX;
|
||||
config.channel = RMT_TX_CHANNEL;
|
||||
config.gpio_num = RMT_TX_GPIO;
|
||||
config.mem_block_num = 1;
|
||||
config.tx_config.loop_en = 0;
|
||||
// enable the carrier to be able to hear the Morse sound
|
||||
// if the RMT_TX_GPIO is connected to a speaker
|
||||
config.tx_config.carrier_en = 1;
|
||||
config.tx_config.idle_output_en = 1;
|
||||
config.tx_config.idle_level = 0;
|
||||
config.tx_config.carrier_duty_percent = 50;
|
||||
// set audible career frequency of 611 Hz
|
||||
// actually 611 Hz is the minimum, that can be set
|
||||
// with current implementation of the RMT API
|
||||
config.tx_config.carrier_freq_hz = 611;
|
||||
config.tx_config.carrier_level = 1;
|
||||
// set the maximum clock divider to be able to output
|
||||
// RMT pulses in range of about one hundred milliseconds
|
||||
config.clk_div = 255;
|
||||
|
||||
ESP_ERROR_CHECK(rmt_config(&config));
|
||||
ESP_ERROR_CHECK(rmt_driver_install(config.channel, 0, 0));
|
||||
ESP_ERROR_CHECK(rmt_translator_init(config.channel, u8_to_rmt));
|
||||
}
|
||||
|
||||
void app_main(void *ignore)
|
||||
{
|
||||
ESP_LOGI(RMT_TX_TAG, "Configuring transmitter");
|
||||
rmt_tx_int();
|
||||
int number_of_items = sizeof(items) / sizeof(items[0]);
|
||||
const uint8_t sample[SAMPLE_CNT] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
|
||||
|
||||
while (1) {
|
||||
ESP_ERROR_CHECK(rmt_write_items(RMT_TX_CHANNEL, items, number_of_items, true));
|
||||
ESP_LOGI(RMT_TX_TAG, "Transmission complete");
|
||||
vTaskDelay(1000 / portTICK_PERIOD_MS);
|
||||
ESP_ERROR_CHECK(rmt_write_sample(RMT_TX_CHANNEL, sample, SAMPLE_CNT, true));
|
||||
ESP_LOGI(RMT_TX_TAG, "Sample transmission complete");
|
||||
vTaskDelay(2000 / portTICK_PERIOD_MS);
|
||||
}
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
Loading…
Reference in a new issue