v2.0.0 Add support for ESP32S2 and update ESP-IDF to 4.4 (#4996)

This is very much still work in progress and much more will change before the final 2.0.0

Some APIs have changed. New libraries have been added. LittleFS included.

Co-authored-by: Seon Rozenblum <seonr@3sprockets.com>
Co-authored-by: Me No Dev <me-no-dev@users.noreply.github.com>
Co-authored-by: geeksville <kevinh@geeksville.com>
Co-authored-by: Mike Dunston <m_dunston@comcast.net>
Co-authored-by: Unexpected Maker <seon@unexpectedmaker.com>
Co-authored-by: Seon Rozenblum <seonr@3sprockets.com>
Co-authored-by: microDev <70126934+microDev1@users.noreply.github.com>
Co-authored-by: tobozo <tobozo@users.noreply.github.com>
Co-authored-by: bobobo1618 <bobobo1618@users.noreply.github.com>
Co-authored-by: lorol <lorolouis@gmail.com>
Co-authored-by: geeksville <kevinh@geeksville.com>
Co-authored-by: Limor "Ladyada" Fried <limor@ladyada.net>
Co-authored-by: Sweety <switi.mhaiske@espressif.com>
Co-authored-by: Loick MAHIEUX <loick111@gmail.com>
Co-authored-by: Larry Bernstone <lbernstone@gmail.com>
Co-authored-by: Valerii Koval <valeros@users.noreply.github.com>
Co-authored-by: 快乐的我531 <2302004040@qq.com>
Co-authored-by: chegewara <imperiaonline4@gmail.com>
Co-authored-by: Clemens Kirchgatterer <clemens@1541.org>
Co-authored-by: Aron Rubin <aronrubin@gmail.com>
Co-authored-by: Pete Lewis <601236+lewispg228@users.noreply.github.com>
This commit is contained in:
Me No Dev
2021-04-05 14:23:58 +03:00
committed by GitHub
parent 46d5afb17f
commit 5502879a5b
5209 changed files with 826360 additions and 322816 deletions

View File

@ -0,0 +1,107 @@
#include "RMaker.h"
#if ESP_IDF_VERSION_MAJOR >= 4 && CONFIG_IDF_TARGET_ESP32
#include <esp_rmaker_schedule.h>
#include <esp_rmaker_utils.h>
bool wifiLowLevelInit(bool persistent);
static esp_err_t err;
static void event_handler(void *arg, esp_event_base_t event_base, int event_id, void *event_data)
{
if (event_base == RMAKER_EVENT) {
switch (event_id) {
case RMAKER_EVENT_INIT_DONE:
log_i("RainMaker Initialised.");
break;
case RMAKER_EVENT_CLAIM_STARTED:
log_i("RainMaker Claim Started.");
break;
case RMAKER_EVENT_CLAIM_SUCCESSFUL:
log_i("RainMaker Claim Successful.");
break;
case RMAKER_EVENT_CLAIM_FAILED:
log_i("RainMaker Claim Failed.");
break;
default:
log_i("Unhandled RainMaker Event:");
}
}
}
void RMakerClass::setTimeSync(bool val)
{
rainmaker_cfg.enable_time_sync = val;
}
Node RMakerClass::initNode(const char *name, const char *type)
{
wifiLowLevelInit(true);
Node node;
esp_rmaker_node_t *rnode = NULL;
esp_event_handler_register(RMAKER_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL);
rnode = esp_rmaker_node_init(&rainmaker_cfg, name, type);
if (!rnode){
log_e("Node init failed");
return node;
}
node.setNodeHandle(rnode);
return node;
}
esp_err_t RMakerClass::start()
{
err = esp_rmaker_start();
if(err != ESP_OK){
log_e("ESP RainMaker core task failed");
}
return err;
}
esp_err_t RMakerClass::stop()
{
err = esp_rmaker_stop();
if(err != ESP_OK) {
log_e("ESP RainMaker stop error");
}
return err;
}
esp_err_t RMakerClass::deinitNode(Node rnode)
{
err = esp_rmaker_node_deinit(rnode.getNodeHandle());
if(err != ESP_OK) {
log_e("Node deinit failed");
}
return err;
}
esp_err_t RMakerClass::setTimeZone(const char *tz)
{
err = esp_rmaker_time_set_timezone(tz);
if(err != ESP_OK) {
log_e("Setting time zone error");
}
return err;
}
esp_err_t RMakerClass::enableSchedule()
{
err = esp_rmaker_schedule_enable();
if(err != ESP_OK) {
log_e("Schedule enable failed");
}
return err;
}
esp_err_t RMakerClass::enableOTA(ota_type_t type, const char *cert)
{
esp_rmaker_ota_config_t ota_config;
ota_config.server_cert = cert;
err = esp_rmaker_ota_enable(&ota_config, type);
if(err != ESP_OK) {
log_e("OTA enable failed");
}
return err;
}
RMakerClass RMaker;
#endif

View File

@ -0,0 +1,28 @@
#include "esp_system.h"
#if ESP_IDF_VERSION_MAJOR >= 4 && CONFIG_IDF_TARGET_ESP32
#include "Arduino.h"
#include "RMakerNode.h"
#include "RMakerQR.h"
#include <esp_rmaker_standard_types.h>
class RMakerClass
{
private:
esp_rmaker_config_t rainmaker_cfg = {false};
public:
void setTimeSync(bool val);
Node initNode(const char *name, const char *type = "ESP RainMaker with Arduino");
esp_err_t deinitNode(Node node);
esp_err_t setTimeZone(const char *tz = "Asia/Shanghai");
esp_err_t enableSchedule();
esp_err_t enableOTA(ota_type_t type, const char *cert = ESP_RMAKER_OTA_DEFAULT_SERVER_CERT);
esp_err_t start();
esp_err_t stop();
};
extern RMakerClass RMaker;
#endif

View File

@ -0,0 +1,209 @@
#include "RMakerDevice.h"
#if ESP_IDF_VERSION_MAJOR >= 4 && CONFIG_IDF_TARGET_ESP32
static esp_err_t err;
typedef void (*deviceWriteCb)(Device*, Param*, const param_val_t val, void *priv_data, write_ctx_t *ctx);
typedef void (*deviceReadCb)(Device*, Param*, void *priv_data, read_ctx_t *ctx);
void (*write_cb)(Device*, Param*, param_val_t, void*, write_ctx_t*);
void (*read_cb)(Device*, Param*, void*, read_ctx_t*);
Device device;
Param param;
static esp_err_t write_callback(const device_handle_t *dev_handle, const param_handle_t *par_handle, const param_val_t val, void *priv_data, write_ctx_t *ctx)
{
device.setDeviceHandle(dev_handle);
param.setParamHandle(par_handle);
write_cb(&device, &param, val, priv_data, ctx);
return ESP_OK;
}
static esp_err_t read_callback(const device_handle_t *dev_handle, const param_handle_t *par_handle, void *priv_data, read_ctx_t *ctx)
{
device.setDeviceHandle(dev_handle);
param.setParamHandle(par_handle);
read_cb(&device, &param, priv_data, ctx);
return ESP_OK;
}
esp_err_t Device::deleteDevice()
{
err = esp_rmaker_device_delete(getDeviceHandle());
if(err != ESP_OK) {
log_e("Device deletion error");
return err;
}
return ESP_OK;
}
void Device::addCb(deviceWriteCb writeCb, deviceReadCb readCb)
{
write_cb = writeCb;
read_cb = readCb;
err = esp_rmaker_device_add_cb(getDeviceHandle(), write_callback, read_callback);
if(err != ESP_OK) {
log_e("Callback register error");
}
}
esp_err_t Device::addDeviceAttr(const char *attr_name, const char *val)
{
err = esp_rmaker_device_add_attribute(getDeviceHandle(), attr_name, val);
if(err != ESP_OK) {
log_e("Failed to add attriute to the device");
return err;
}
return ESP_OK;
}
//Generic Parameter
esp_err_t Device::addParam(Param parameter)
{
err = esp_rmaker_device_add_param(getDeviceHandle(), parameter.getParamHandle());
if(err != ESP_OK) {
log_e("Adding custom parameter error");
return err;
}
return ESP_OK;
}
//Standard Device Parameter
esp_err_t Device::addNameParam(const char *param_name)
{
param_handle_t *param = esp_rmaker_name_param_create(param_name, getDeviceName());
return esp_rmaker_device_add_param(getDeviceHandle(), param);
}
esp_err_t Device::addPowerParam(bool val, const char *param_name)
{
param_handle_t *param = esp_rmaker_power_param_create(param_name, val);
return esp_rmaker_device_add_param(getDeviceHandle(), param);
}
esp_err_t Device::addBrightnessParam(int val, const char *param_name)
{
param_handle_t *param = esp_rmaker_brightness_param_create(param_name, val);
return esp_rmaker_device_add_param(getDeviceHandle(), param);
}
esp_err_t Device::addHueParam(int val, const char *param_name)
{
param_handle_t *param = esp_rmaker_hue_param_create(param_name, val);
return esp_rmaker_device_add_param(getDeviceHandle(), param);
}
esp_err_t Device::addSaturationParam(int val, const char *param_name)
{
param_handle_t *param = esp_rmaker_saturation_param_create(param_name, val);
return esp_rmaker_device_add_param(getDeviceHandle(), param);
}
esp_err_t Device::addIntensityParam(int val, const char *param_name)
{
param_handle_t *param = esp_rmaker_intensity_param_create(param_name, val);
return esp_rmaker_device_add_param(getDeviceHandle(), param);
}
esp_err_t Device::addCCTParam(int val, const char *param_name)
{
param_handle_t *param = esp_rmaker_cct_param_create(param_name, val);
return esp_rmaker_device_add_param(getDeviceHandle(), param);
}
esp_err_t Device::addDirectionParam(int val, const char *param_name)
{
param_handle_t *param = esp_rmaker_direction_param_create(param_name, val);
return esp_rmaker_device_add_param(getDeviceHandle(), param);
}
esp_err_t Device::addSpeedParam(int val, const char *param_name)
{
param_handle_t *param = esp_rmaker_speed_param_create(param_name, val);
return esp_rmaker_device_add_param(getDeviceHandle(), param);
}
esp_err_t Device::addTempratureParam(float val, const char *param_name)
{
param_handle_t *param = esp_rmaker_temperature_param_create(param_name, val);
return esp_rmaker_device_add_param(getDeviceHandle(), param);
}
param_handle_t *Device::getParamByName(const char *param_name)
{
return esp_rmaker_device_get_param_by_name(getDeviceHandle(), param_name);
}
esp_err_t Device::assignPrimaryParam(param_handle_t *param)
{
err = esp_rmaker_device_assign_primary_param(getDeviceHandle(), param);
if(err != ESP_OK){
log_e("Assigning primary param error");
}
return err;
}
const param_handle_t* getParamHandlebyName(const esp_rmaker_device_t *device_handle, const char *param_name)
{
const param_handle_t *param = esp_rmaker_device_get_param_by_name(device_handle, param_name);
return param;
}
esp_err_t Device::updateAndReportParam(const char *param_name, bool my_val)
{
const param_handle_t *param = getParamHandlebyName(getDeviceHandle(), param_name);
param_val_t val = esp_rmaker_bool(my_val);
err = esp_rmaker_param_update_and_report(param, val);
if(err != ESP_OK) {
log_e("Update paramter failed");
return err;
}else {
log_i("Device : %s, Param Name : %s, Val : %s", getDeviceName(), param_name, my_val ? "true" : "false");
}
return ESP_OK;
}
esp_err_t Device::updateAndReportParam(const char *param_name, int my_val)
{
const param_handle_t *param = getParamHandlebyName(getDeviceHandle(), param_name);
param_val_t val = esp_rmaker_int(my_val);
esp_err_t err = esp_rmaker_param_update_and_report(param, val);
if(err != ESP_OK) {
log_e("Update paramter failed");
return err;
}else {
log_i("Device : %s, Param Name : %s, Val : %d", getDeviceName(), param_name, my_val);
}
return ESP_OK;
}
esp_err_t Device::updateAndReportParam(const char *param_name, float my_val)
{
const param_handle_t *param = getParamHandlebyName(getDeviceHandle(), param_name);
param_val_t val = esp_rmaker_float(my_val);
esp_err_t err = esp_rmaker_param_update_and_report(param, val);
if(err != ESP_OK) {
log_e("Update paramter failed");
return err;
}else {
log_i("Device : %s, Param Name : %s, Val : %f", getDeviceName(), param_name, my_val);
}
return ESP_OK;
}
esp_err_t Device::updateAndReportParam(const char *param_name, const char *my_val)
{
const param_handle_t *param = getParamHandlebyName(getDeviceHandle(), param_name);
param_val_t val = esp_rmaker_str(my_val);
esp_err_t err = esp_rmaker_param_update_and_report(param, val);
if(err != ESP_OK) {
log_e("Update paramter failed");
return err;
}else {
log_i("Device : %s, Param Name : %s, Val : %s", getDeviceName(), param_name, my_val);
}
return ESP_OK;
}
#endif

View File

@ -0,0 +1,154 @@
#include "esp_system.h"
#if ESP_IDF_VERSION_MAJOR >= 4 && CONFIG_IDF_TARGET_ESP32
#include "RMakerParam.h"
#include <esp_rmaker_standard_devices.h>
#include <esp_rmaker_standard_params.h>
class Device
{
private:
const device_handle_t *device_handle;
public:
Device()
{
device_handle = NULL;
}
Device(const char *dev_name, const char *dev_type = NULL, void *priv_data = NULL)
{
device_handle = esp_rmaker_device_create(dev_name, dev_type, priv_data);
if(device_handle == NULL){
log_e("Device create error");
}
}
void setDeviceHandle(const esp_rmaker_device_t *device_handle)
{
this->device_handle = device_handle;
}
const char *getDeviceName()
{
return esp_rmaker_device_get_name(device_handle);
}
const esp_rmaker_device_t *getDeviceHandle()
{
return device_handle;
}
typedef void (*deviceWriteCb)(Device*, Param*, const param_val_t val, void *priv_data, write_ctx_t *ctx);
typedef void (*deviceReadCb)(Device*, Param*, void *priv_data, read_ctx_t *ctx);
esp_err_t deleteDevice();
void addCb(deviceWriteCb write_cb, deviceReadCb read_cb = NULL);
esp_err_t addDeviceAttr(const char *attr_name, const char *val);
param_handle_t *getParamByName(const char *param_name);
esp_err_t assignPrimaryParam(param_handle_t *param);
//Generic Device Parameter
esp_err_t addParam(Param parameter);
//Standard Device Parameter
esp_err_t addNameParam(const char *param_name = ESP_RMAKER_DEF_NAME_PARAM);
esp_err_t addPowerParam(bool val, const char *param_name = ESP_RMAKER_DEF_POWER_NAME);
esp_err_t addBrightnessParam(int val, const char *param_name = ESP_RMAKER_DEF_BRIGHTNESS_NAME);
esp_err_t addHueParam(int val, const char *param_name = ESP_RMAKER_DEF_HUE_NAME);
esp_err_t addSaturationParam(int val, const char *param_name = ESP_RMAKER_DEF_SATURATION_NAME);
esp_err_t addIntensityParam(int val, const char *param_name = ESP_RMAKER_DEF_INTENSITY_NAME);
esp_err_t addCCTParam(int val, const char *param_name = ESP_RMAKER_DEF_CCT_NAME);
esp_err_t addDirectionParam(int val, const char *param_name = ESP_RMAKER_DEF_DIRECTION_NAME);
esp_err_t addSpeedParam(int val, const char *param_name = ESP_RMAKER_DEF_SPEED_NAME);
esp_err_t addTempratureParam(float val, const char *param_name = ESP_RMAKER_DEF_TEMPERATURE_NAME);
//Update Parameter
esp_err_t updateAndReportParam(const char *param_name, bool val);
esp_err_t updateAndReportParam(const char *param_name, int val);
esp_err_t updateAndReportParam(const char *param_name, float val);
esp_err_t updateAndReportParam(const char *param_name, const char *val);
};
class Switch : public Device
{
public:
Switch()
{
standardSwitchDevice("Switch", NULL, true);
}
Switch(const char *dev_name, void *priv_data = NULL, bool power = true)
{
standardSwitchDevice(dev_name, priv_data, power);
}
void standardSwitchDevice(const char *dev_name, void *priv_data, bool power)
{
esp_rmaker_device_t *dev_handle = esp_rmaker_switch_device_create(dev_name, priv_data, power);
setDeviceHandle(dev_handle);
if(dev_handle == NULL){
log_e("Switch device not created");
}
}
};
class LightBulb : public Device
{
public:
LightBulb()
{
standardLightBulbDevice("Light", NULL, true);
}
LightBulb(const char *dev_name, void *priv_data = NULL, bool power = true)
{
standardLightBulbDevice(dev_name, priv_data, power);
}
void standardLightBulbDevice(const char *dev_name, void *priv_data, bool power)
{
esp_rmaker_device_t *dev_handle = esp_rmaker_lightbulb_device_create(dev_name, priv_data, power);
setDeviceHandle(dev_handle);
if(dev_handle == NULL){
log_e("Light device not created");
}
}
};
class Fan : public Device
{
public:
Fan()
{
standardFanDevice("Fan", NULL, true);
}
Fan(const char *dev_name, void *priv_data = NULL, bool power = true)
{
standardFanDevice(dev_name, priv_data, power);
}
void standardFanDevice(const char *dev_name, void *priv_data, bool power)
{
esp_rmaker_device_t *dev_handle = esp_rmaker_fan_device_create(dev_name, priv_data, power);
setDeviceHandle(dev_handle);
if(dev_handle == NULL){
log_e("Fan device not created");
}
}
};
class TemperatureSensor : public Device
{
public:
TemperatureSensor()
{
standardTemperatureSensorDevice("Temperature-Sensor", NULL, 25.0);
}
TemperatureSensor(const char *dev_name, void *priv_data = NULL, float temp = 25.0)
{
standardTemperatureSensorDevice(dev_name, priv_data, temp);
}
void standardTemperatureSensorDevice(const char *dev_name, void *priv_data, float temp)
{
esp_rmaker_device_t *dev_handle = esp_rmaker_temp_sensor_device_create(dev_name, priv_data, temp);
setDeviceHandle(dev_handle);
if(dev_handle == NULL){
log_e("Temperature Sensor device not created");
}
}
};
#endif

View File

@ -0,0 +1,41 @@
#include "RMakerNode.h"
#if ESP_IDF_VERSION_MAJOR >= 4 && CONFIG_IDF_TARGET_ESP32
static esp_err_t err;
esp_err_t Node::addDevice(Device device)
{
err = esp_rmaker_node_add_device(node, device.getDeviceHandle());
if(err != ESP_OK){
log_e("Device was not added to the Node");
}
return err;
}
esp_err_t Node::removeDevice(Device device)
{
err = esp_rmaker_node_remove_device(node, device.getDeviceHandle());
if(err != ESP_OK){
log_e("Device was not removed from the Node");
}
return err;
}
char *Node::getNodeID()
{
return esp_rmaker_get_node_id();
}
node_info_t *Node::getNodeInfo()
{
return esp_rmaker_node_get_info(node);
}
esp_err_t Node::addNodeAttr(const char *attr_name, const char *val)
{
err = esp_rmaker_node_add_attribute(node, attr_name, val);
if(err != ESP_OK) {
log_e("Failed to add attribute to the Node");
}
return err;
}
#endif

View File

@ -0,0 +1,33 @@
#include "esp_system.h"
#if ESP_IDF_VERSION_MAJOR >= 4 && CONFIG_IDF_TARGET_ESP32
#include "RMakerDevice.h"
class Node
{
private:
esp_rmaker_node_t *node;
public:
Node()
{
node = NULL;
}
void setNodeHandle(esp_rmaker_node_t *rnode)
{
node = rnode;
}
esp_rmaker_node_t *getNodeHandle()
{
return node;
}
esp_err_t addDevice(Device device);
esp_err_t removeDevice(Device device);
char *getNodeID();
node_info_t *getNodeInfo();
esp_err_t addNodeAttr(const char *attr_name, const char *val);
};
#endif

View File

@ -0,0 +1,33 @@
#include "RMakerParam.h"
#if ESP_IDF_VERSION_MAJOR >= 4 && CONFIG_IDF_TARGET_ESP32
static esp_err_t err;
esp_err_t Param::addUIType(const char *ui_type)
{
err = esp_rmaker_param_add_ui_type(param_handle, ui_type);
if(err != ESP_OK) {
log_e("Add UI type error");
}
return err;
}
esp_err_t Param::addBounds(param_val_t min, param_val_t max, param_val_t step)
{
err = esp_rmaker_param_add_bounds(param_handle, min, max, step);
if(err != ESP_OK) {
log_e("Add Bounds error");
}
return err;
}
esp_err_t Param::updateAndReport(param_val_t val)
{
err = esp_rmaker_param_update_and_report(getParamHandle(), val);
if(err != ESP_OK){
log_e("Update and Report param failed");
}
return err;
}
#endif

View File

@ -0,0 +1,38 @@
#include "esp_system.h"
#if ESP_IDF_VERSION_MAJOR >= 4 && CONFIG_IDF_TARGET_ESP32
#include "RMakerType.h"
class Param
{
private:
const param_handle_t *param_handle;
public:
Param()
{
param_handle = NULL;
}
Param(const char *param_name, const char *param_type, param_val_t val, uint8_t properties)
{
param_handle = esp_rmaker_param_create(param_name, param_type, val, properties);
}
void setParamHandle(const param_handle_t *param_handle)
{
this->param_handle = param_handle;
}
const char *getParamName()
{
return esp_rmaker_param_get_name(param_handle);
}
const param_handle_t *getParamHandle()
{
return param_handle;
}
esp_err_t addUIType(const char *ui_type);
esp_err_t addBounds(param_val_t min, param_val_t max, param_val_t step);
esp_err_t updateAndReport(param_val_t val);
};
#endif

View File

@ -0,0 +1,24 @@
#include "esp_system.h"
#if ESP_IDF_VERSION_MAJOR >= 4 && CONFIG_IDF_TARGET_ESP32
#include <qrcode.h>
#define PROV_QR_VERSION "v1"
#define QRCODE_BASE_URL "https://rainmaker.espressif.com/qrcode.html"
static void printQR(const char *name, const char *pop, const char *transport)
{
if (!name || !pop || !transport) {
log_w("Cannot generate QR code payload. Data missing.");
return;
}
char payload[150];
snprintf(payload, sizeof(payload), "{\"ver\":\"%s\",\"name\":\"%s\"" \
",\"pop\":\"%s\",\"transport\":\"%s\"}",
PROV_QR_VERSION, name, pop, transport);
log_i("Scan this QR code from the phone app for Provisioning.");
qrcode_display(payload);
log_i("If QR code is not visible, copy paste the below URL in a browser.\n%s?data=%s", QRCODE_BASE_URL, payload);
}
#endif

View File

@ -0,0 +1,24 @@
#include "RMakerType.h"
#if ESP_IDF_VERSION_MAJOR >= 4 && CONFIG_IDF_TARGET_ESP32
param_val_t value(int ival)
{
return esp_rmaker_int(ival);
}
param_val_t value(bool bval)
{
return esp_rmaker_bool(bval);
}
param_val_t value(char *sval)
{
return esp_rmaker_str(sval);
}
param_val_t value(float fval)
{
return esp_rmaker_float(fval);
}
#endif

View File

@ -0,0 +1,23 @@
#include "esp_system.h"
#if ESP_IDF_VERSION_MAJOR >= 4 && CONFIG_IDF_TARGET_ESP32
#include <esp_rmaker_core.h>
#include <esp_rmaker_ota.h>
#include <esp_err.h>
#include <esp32-hal.h>
typedef esp_rmaker_node_t* node_t;
typedef esp_rmaker_node_info_t node_info_t;
typedef esp_rmaker_param_val_t param_val_t;
typedef esp_rmaker_write_ctx_t write_ctx_t;
typedef esp_rmaker_read_ctx_t read_ctx_t;
typedef esp_rmaker_device_t device_handle_t;
typedef esp_rmaker_param_t param_handle_t;
typedef esp_rmaker_ota_type_t ota_type_t;
param_val_t value(int);
param_val_t value(bool);
param_val_t value(char *);
param_val_t value(float);
#endif