KozmotronikTech/rmaker_multi_device
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add RGB light as a device.

Browse Source
This commit is contained in:
Ismail Sahillioglu
2025-05-03 11:50:44 +03:00
parent eab859ebe2
commit 1f217020d6
3 changed files with 197 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
examples/gpio/main/app_driver.c
View File

@@ -12,6 +12,10 @@
#include <esp_log.h>
#include <app_reset.h>
#include <ws2812_led.h>
#include "esp_err.h"
#include "esp_rmaker_core.h"
#include "esp_rmaker_standard_types.h"
#include "app_priv.h"
#define RMT_TX_CHANNEL RMT_CHANNEL_0
@@ -27,6 +31,11 @@
#define WIFI_RESET_BUTTON_TIMEOUT 3
#define FACTORY_RESET_BUTTON_TIMEOUT 10
static uint16_t rgb_hue = RGB_HUE_DEFAULT;
static uint16_t rgb_saturation = RGB_SATURATION_DEFAULT;
static uint16_t rgb_brightness = RGB_BRIGHTNESS_DEFAULT;
static bool rgb_power = RGB_POWER_DEFAULT;
esp_err_t app_driver_set_gpio(const char *name, bool state)
{
if (strcmp(name, "Red") == 0) {
@@ -41,6 +50,62 @@ esp_err_t app_driver_set_gpio(const char *name, bool state)
return ESP_OK;
}
esp_err_t app_light_set_led(uint32_t hue, uint32_t saturation, uint32_t brightness)
{
// Her ne zaman bu bu işlev çağrılırsa, RGB ışığın gücü açılır
if (!rgb_power) {
rgb_power = true;
esp_rmaker_param_update_and_report(
esp_rmaker_device_get_param_by_type(light_device, ESP_RMAKER_PARAM_POWER),
esp_rmaker_bool(rgb_power));
}
return ws2812_led_set_hsv(hue, saturation, brightness);
}
esp_err_t app_light_set_power(bool power)
{
rgb_power = power;
if (power) {
ws2812_led_set_hsv(rgb_hue, rgb_saturation, rgb_brightness);
} else {
ws2812_led_clear();
}
return ESP_OK;
}
esp_err_t app_light_init(void)
{
esp_err_t ret = ws2812_led_init();
if (ret != ESP_OK) {
return ret;
}
if (rgb_power) {
ret = ws2812_led_set_hsv(rgb_hue, rgb_saturation, rgb_brightness);
} else {
ret = ws2812_led_clear();
}
return ESP_OK;
}
esp_err_t app_light_set_brightness(uint16_t brightness)
{
rgb_brightness = brightness;
return app_light_set_led(rgb_hue, rgb_saturation, brightness);
}
esp_err_t app_light_set_hue(uint16_t hue)
{
rgb_hue = hue;
return app_light_set_led(hue, rgb_saturation, rgb_brightness);
}
esp_err_t app_light_set_saturation(uint16_t saturation)
{
rgb_saturation = saturation;
return app_light_set_led(rgb_hue, saturation, rgb_brightness);
}
void app_driver_init()
{
app_reset_button_register(app_reset_button_create(BUTTON_GPIO, BUTTON_ACTIVE_LEVEL),
@@ -58,4 +123,6 @@ void app_driver_init()
gpio_set_level(OUTPUT_GPIO_RED, false);
gpio_set_level(OUTPUT_GPIO_GREEN, false);
gpio_set_level(OUTPUT_GPIO_BLUE, false);
app_light_init();
}

119
examples/gpio/main/app_main.c
View File

@@ -7,6 +7,7 @@
CONDITIONS OF ANY KIND, either express or implied.
*/
#include <stdio.h>
#include <string.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
@@ -14,7 +15,8 @@
#include <nvs_flash.h>
#include <esp_rmaker_core.h>
#include <esp_rmaker_standard_types.h>
#include <esp_rmaker_standard_params.h>
#include <esp_rmaker_standard_devices.h>
#include <app_network.h>
#include <app_insights.h>
@@ -23,6 +25,101 @@
static const char *TAG = "app_main";
esp_rmaker_device_t *light_device;
#ifdef CONFIG_ESP_RMAKER_CMD_RESP_ENABLE
#include "json_parser.h"
#include "esp_rmaker_cmd_resp.h"
#include <esp_rmaker_standard_types.h>
static char resp_data[100];
/* Callback to handle commands received from the RainMaker cloud via the Command - Response Framework
*
* Sample payloads:
* - {"on":true}
* - {"brightness":30}
*/
esp_err_t led_light_cmd_handler(const void *in_data, size_t in_len, void **out_data, size_t *out_len, esp_rmaker_cmd_ctx_t *ctx, void *priv_data)
{
if (in_data == NULL) {
ESP_LOGE(TAG, "No data received");
return ESP_FAIL;
}
ESP_LOGI(TAG, "Received command: %s", (char *)in_data);
jparse_ctx_t jctx;
if (json_parse_start(&jctx, (char *)in_data, in_len) != 0) {
snprintf(resp_data, sizeof(resp_data), "{\"status\":\"fail\", \"description\":\"Invalid JSON\"}");
} else {
int brightness;
bool on_state;
if (json_obj_get_int(&jctx, "brightness", &brightness) == 0) {
if (brightness < 0 || brightness > 100) {
snprintf(resp_data, sizeof(resp_data), "{\"status\":\"fail\", \"description\":\"Invalid brightness value\"}");
} else {
app_light_set_brightness(brightness);
esp_rmaker_param_update_and_report(
esp_rmaker_device_get_param_by_type(light_device, ESP_RMAKER_PARAM_BRIGHTNESS),
esp_rmaker_int(brightness));
snprintf(resp_data, sizeof(resp_data), "{\"status\":\"success\"}");
}
}
else if (json_obj_get_bool(&jctx, "on", &on_state) == 0) {
app_light_set_power(on_state);
esp_rmaker_param_update_and_report(
esp_rmaker_device_get_param_by_type(light_device, ESP_RMAKER_PARAM_POWER),
esp_rmaker_bool(on_state));
snprintf(resp_data, sizeof(resp_data), "{\"status\":\"success\"}");
}
else {
snprintf(resp_data, sizeof(resp_data), "{\"status\":\"fail\", \"description\":\"Invalid param\"}");
}
}
*out_data = resp_data;
*out_len = strlen(resp_data);
return ESP_OK;
}
#endif /* CONFIG_ESP_RMAKER_CMD_RESP_ENABLE */
// Callback to handle param updates from the Rainmaker cloud
static esp_err_t bulk_write_cb(const esp_rmaker_device_t *device, const esp_rmaker_param_write_req_t write_req[],
uint8_t count, void *priv_data, esp_rmaker_write_ctx_t *ctx)
{
if (ctx) {
ESP_LOGI(TAG, "Received write request via : %s", esp_rmaker_device_cb_src_to_str(ctx->src));
}
ESP_LOGI(TAG, "Light received %d params in write", count);
for (int i = 0; i < count; i++) {
const esp_rmaker_param_t *param = write_req[i].param;
esp_rmaker_param_val_t val = write_req[i].val;
const char *device_name = esp_rmaker_device_get_name(device);
const char *param_name = esp_rmaker_param_get_name(param);
if (strcmp(param_name, ESP_RMAKER_DEF_POWER_NAME) == 0) {
ESP_LOGI(TAG, "Received value = %s for %s - %s", val.val.b ? "true" : "false", device_name, param_name);
app_light_set_power(val.val.b);
}
else if (strcmp(param_name, ESP_RMAKER_DEF_BRIGHTNESS_NAME) == 0) {
ESP_LOGI(TAG, "Received value = %d for %s - %s", val.val.i, device_name, param_name);
app_light_set_brightness(val.val.i);
}
else if (strcmp(param_name, ESP_RMAKER_DEF_HUE_NAME) == 0) {
ESP_LOGI(TAG, "Received value = %d for %s - %s", val.val.i, device_name, param_name);
app_light_set_hue(val.val.i);
}
else if (strcmp(param_name, ESP_RMAKER_DEF_SATURATION_NAME) == 0) {
ESP_LOGI(TAG, "Received value = %d for %s - %s", val.val.i, device_name, param_name);
app_light_set_saturation(val.val.i);
}
else {
ESP_LOGI(TAG, "Updating for %s", param_name);
}
esp_rmaker_param_update(param, val);
}
return ESP_OK;
}
/* Callback to handle commands received from the RainMaker cloud */
static esp_err_t write_cb(const esp_rmaker_device_t *device, const esp_rmaker_param_t *param,
const esp_rmaker_param_val_t val, void *priv_data, esp_rmaker_write_ctx_t *ctx)
@@ -36,6 +133,7 @@ static esp_err_t write_cb(const esp_rmaker_device_t *device, const esp_rmaker_pa
return ESP_OK;
}
void app_main()
{
/* Initialize Application specific hardware drivers and
@@ -86,15 +184,34 @@ void app_main()
esp_rmaker_node_add_device(node, gpio_device);
// Create the light device
light_device = esp_rmaker_lightbulb_device_create("Light", NULL, RGB_POWER_DEFAULT);
esp_rmaker_device_add_bulk_cb(light_device, bulk_write_cb, NULL);
esp_rmaker_device_add_param(light_device, esp_rmaker_brightness_param_create(ESP_RMAKER_DEF_BRIGHTNESS_NAME, RGB_BRIGHTNESS_DEFAULT));
esp_rmaker_device_add_param(light_device, esp_rmaker_hue_param_create(ESP_RMAKER_DEF_HUE_NAME, RGB_HUE_DEFAULT));
esp_rmaker_device_add_param(light_device, esp_rmaker_saturation_param_create(ESP_RMAKER_DEF_SATURATION_NAME, RGB_SATURATION_DEFAULT));
esp_rmaker_node_add_device(node, light_device);
/* Enable OTA */
esp_rmaker_ota_enable_default();
/* Enable Insights. Requires CONFIG_ESP_INSIGHTS_ENABLED=y */
app_insights_enable();
#ifdef CONFIG_ESP_RMAKER_CMD_RESP_ENABLE
/* Register the command response handler */
esp_rmaker_cmd_register(ESP_RMAKER_CMD_CUSTOM_START,
ESP_RMAKER_USER_ROLE_PRIMARY_USER | ESP_RMAKER_USER_ROLE_SECONDARY_USER,
led_light_cmd_handler, false, NULL);
#endif /* CONFIG_ESP_RMAKER_CMD_RESP_ENABLE */
/* Start the ESP RainMaker Agent */
esp_rmaker_start();
err = app_network_set_custom_mfg_data(MGF_DATA_DEVICE_TYPE_LIGHT, MFG_DATA_DEVICE_SUBTYPE_LIGHT);
/* Start the Wi-Fi.
* If the node is provisioned, it will start connection attempts,
* else, it will start Wi-Fi provisioning. The function will return

12
examples/gpio/main/app_priv.h
View File

@@ -10,5 +10,17 @@
#include <stdbool.h>
#include <esp_err.h>
#define RGB_POWER_DEFAULT false
#define RGB_HUE_DEFAULT 180
#define RGB_SATURATION_DEFAULT 100
#define RGB_BRIGHTNESS_DEFAULT 25
extern esp_rmaker_device_t *light_device;
void app_driver_init(void);
esp_err_t app_driver_set_gpio(const char *name, bool state);
esp_err_t app_light_set(uint32_t hue, uint32_t saturation, uint32_t brightness);
esp_err_t app_light_set_power(bool power);
esp_err_t app_light_set_brightness(uint16_t brightness);
esp_err_t app_light_set_hue(uint16_t hue);
esp_err_t app_light_set_saturation(uint16_t saturation);