AliyunIoTSDK升级，支持绑定自定义主题

最新推荐文章于 2024-03-31 09:59:57 发布
最新推荐文章于 2024-03-31 09:59:57 发布
阅读量2.6k 收藏 20
点赞数 7
分类专栏： Arduino 第三方库教程 文章标签： 物联网 单片机 iot
本文为博主原创文章，未经允许，请勿转载
本文链接：https://blog.csdn.net/dpjcn1990/article/details/123603388
版权

忘记过去，超越自己

  • ❤️ 博客主页 单片机菜鸟哥，一个野生非专业硬件IOT爱好者 ❤️
  • ❤️ 本篇创建记录 2022-03-19 ❤️
  • ❤️ 本篇更新记录 2022-03-19 ❤️
  • 🎉 欢迎关注 🔎点赞 👍收藏 ⭐️留言📝
  • 🙏 此博客均由博主单独编写，不存在任何商业团队运营，如发现错误，请留言轰炸哦！及时修正！感谢支持！
  • 🔥 Arduino ESP8266教程累计帮助过超过1W+同学入门学习硬件网络编程，入选过选修课程，刊登过无线电杂志 🔥

快速导读

手把手代码注释，完整案例讲解开发过程以及细节，一键式运行代码。
ESP保姆级付费专栏群 707958244，不喜勿加，凭借付费专栏订单号加入

1、背景说明

  • 之前使用AliyunIoTSDK的时候发现不支持订阅自定义主题，所以干脆就升级一下，方便使用

2、涉及内容

AliyunIoTSDK只有两个文件：
在这里插入图片描述

2.1 AliyunIoTSDK.h 增加存储自定义主题

// 最多绑定20个回调
static poniter_desc poniter_array[20];
// 最多绑定10个主题
static poniter_desc poniter_topic[10];
static p_poniter_desc p_poniter_array;

2.2 AliyunIoTSDK.h 增加两个自定义订阅、取消订阅主题方法

  /**
   * 绑定事件回调，云服务下发的特定事件会进入回调
   * @param eventId 事件名
   */
  // static void bindEvent(const char * eventId, MQTT_CALLBACK_SIGNATURE);
  /**
   * 绑定属性回调，云服务下发的数据包含此 key 会进入回调，用于监听特定数据的下发
   * @param key 物模型的key
   */
  static int bindData(char *key, poniter_fun fp);
  /**
   * 卸载某个 key 的所有回调（慎用）
   * @param key 物模型的key
   */
  static int unbindData(char *key);

  static int bindTopic(char *topic, poniter_fun fp);
  /**
   * 卸载某个 key 的所有回调（慎用）
   * @param key 物模型的key
   */
  static int unbindTopic(char *topic);

2.3 AliyunIoTSDK.cpp 实现订阅、取消订阅方法

int AliyunIoTSDK::bindTopic(char *topic, poniter_fun fp)
{
    int i;
    for (i = 0; i < 10; i++)
    {
        if (!poniter_topic[i].fp)
        {
            poniter_topic[i].key = topic;
            poniter_topic[i].fp = fp;
            return 0;
        }
    }
    return -1;
}

int AliyunIoTSDK::unbindTopic(char *topic)
{
    int i;
    for (i = 0; i < 10; i++)
    {
        if (!strcmp(poniter_topic[i].key, topic))
        {
            poniter_topic[i].key = NULL;
            poniter_topic[i].fp = NULL;
            return 0;
        }
    }
    return -1;
}

2.4 AliyunIoTSDK.cpp 检测自定义主题修改点

void AliyunIoTSDK::mqttCheckConnect()
{
    if (client != NULL && !mqttConnecting)
    {
        if (!client->connected())
        {
            client->disconnect();
            Serial.println("Connecting to MQTT Server ...");
            mqttConnecting = true;
            if (client->connect(clientId, mqttUsername, mqttPwd))
            {
                // 自定义主题订阅
                for (int i = 0; i < 10; i++)
                {
                    if (poniter_topic[i].fp)
                    {
                        client->subscribe(poniter_topic[i].key);
                    }
                }
                Serial.println("MQTT Connected!");
            }
            else
            {
                Serial.print("MQTT Connect err:");
                Serial.println(client->state());
                retry_count++;
                if(retry_count > RETRY_CRASH_COUNT){
                    resetFunc();
                }
            }
            mqttConnecting = false;
        }
        else
        {
            Serial.println("state is connected");
            retry_count = 0;
        }
    }
}

static void topicPass(char *topic,JsonVariant parm)
{
    for (int i = 0; i < 10; i++)
    {
        if (poniter_topic[i].key){
          if (strstr(topic, poniter_topic[i].key))
          {
            poniter_topic[i].fp(parm);
          }
        }
    }
}

3、具体实例使用（只是说明用法）


/**
 * 功能： smartArduino
 *
 * 详细描述：
 *   1、esp8266连接上wifi热点
 *   2、通过mqtt client方式连接上阿里云物联网平台
 *   3、监听阿里云控制信息，控制ws2812开关以及颜色
 */
#include <ESP8266WiFi.h>  // 引入Arduino ESP8266核心库
#include "AliyunIoTSDK.h" // 引入阿里云 IoT SDK

const char* WIFI_SSID     = "TP-LINK_5344"; // WiFi账号密码，更改成自己的
const char* WIFI_PASSWORD = "xxxxx"; // WiFi密码，更改成自己的

//-------- 设置产品和设备的信息，从阿里云物联网设备信息里查看 -------//
#define PRODUCT_KEY "gw5eDB82FOO"
#define DEVICE_NAME "device_8266"
#define DEVICE_SECRET "xxxxx"
#define REGION_ID "cn-shanghai"
#define TOPIC_RGB "/gw5eDB82FOO/device_8266/user/rgb"
#define TOPIC_STATUS "/gw5eDB82FOO/device_8266/user/status"
//-------- 设置产品和设备的信息，从阿里云物联网设备信息里查看 -------//

/******************* 函数声明 **********************/
void rgbCallback(JsonVariant p);
/******************* 函数声明 **********************/

int red = 255; // 红色
int green = 255; // 绿色
int blue = 255; // 蓝色

static WiFiClient espClient; // TCP Client

void setup() {
  // 延时2s，让电源稍微稳定一下
  delay(2000);
  // 初始化串口
  Serial.begin(115200);
  Serial.println("Project Running~");
  // 初始化网络
  wifi_station_set_auto_connect(0);//关闭自动连接
  ESP.wdtEnable(5000); //  启用看门狗
  doWiFiTick();
  // 设置两个自定义主题处理函数
  AliyunIoTSDK::bindTopic(TOPIC_STATUS,statusCallback);
  AliyunIoTSDK::bindTopic(TOPIC_RGB,rgbCallback);
  // 初始化 iot，需传入 wifi 的 client，和设备产品信息
  AliyunIoTSDK::begin(espClient, PRODUCT_KEY, DEVICE_NAME, DEVICE_SECRET, REGION_ID);
}

void loop() {
  // 定时喂狗
  ESP.wdtFeed();
  // wifi连接状态检测以及重连
  doWiFiTick();
  // Wifi处于连接状态
  if (WiFi.status() == WL_CONNECTED) {
    // 检测MQTT 阿里云
    AliyunIoTSDK::loop();
  }
  delay(1000);
}

// 控制开关的回调函数
// 数据协议：{"s":xxxx}
void statusCallback(JsonVariant p)
{
    Serial.println(F("statusCallback"));
    int status = p["s"];
    if (status == 1)
    {
      // 启动设备
      switchWS2812(true);
    } else {
      // 关闭设备
      switchWS2812(false);
    }
}

// rgb颜色控制的回调函数
// 数据协议：{"r":xxxx,"g":xxxx,"b":xxxx}
void rgbCallback(JsonVariant p)
{
    Serial.println(F("rgbCallback"));
    red = p["r"]; // 红色
    green = p["g"]; // 绿色
    blue = p["b"]; // 蓝色
    handleWS2812RGB(red,green,blue);
}

/**
 * 功能：设置ws2812颜色
 */
void handleWS2812RGB(int red,int green,int blue){
}

/**
 * 功能：开关ws2812
 */
void switchWS2812(bool open){
}

/**
 * 功能：连接Wifi路由心跳函数
 */
void doWiFiTick() {
  static bool taskStarted = false;
  static bool startSTAFlag = false;
  static uint32_t lastWiFiCheckTick = 0;

  if (!startSTAFlag) {
    startSTAFlag = true;

    Serial.print(F("connect to ap:"));
    Serial.println(WIFI_SSID);
    // 断开网络
    WiFi.disconnect();
    // 设置为Station模式
    WiFi.mode(WIFI_STA);
    // 连接到wifi热点
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
    Serial.printf("Heap size:%d\r\n", ESP.getFreeHeap());
    int cnt = 0;
    while (WiFi.status() != WL_CONNECTED) {
         delay(500);
         cnt++;
         Serial.print(".");
         if(cnt>=40){
             cnt = 0;
             //重启系统
             delayRestart(1);
         }
    }
  }

  //未连接1s重连
  if ( WiFi.status() != WL_CONNECTED ) {
    if (millis() - lastWiFiCheckTick > 1000) {
      lastWiFiCheckTick = millis();
      Serial.print(".");
    }
  }
  //连接成功建立
  else {
    if (taskStarted == false) {
      taskStarted = true;
      Serial.print(F("\r\nGet IP Address: "));
      Serial.println(WiFi.localIP());
    }
  }
}

4、具体库（直接copy覆盖即可）

4.1 AliyunIoTSDK.h

#ifndef ALIYUN_IOT_SDK_H
#define ALIYUN_IOT_SDK_H
#include <Arduino.h>
#include <ArduinoJson.h>
#include "Client.h"

typedef void (*poniter_fun)(JsonVariant ele); //定义一个函数指针

typedef struct poniter_desc
{
  char *key;
  poniter_fun fp;
} poniter_desc, *p_poniter_desc;

// 最多绑定20个回调
static poniter_desc poniter_array[20];
// 最多绑定10个主题
static poniter_desc poniter_topic[10];
static p_poniter_desc p_poniter_array;

class AliyunIoTSDK
{
private:
  // mqtt 链接信息，动态生成的
  static char mqttPwd[256];
  static char clientId[256];
  static char mqttUsername[100];
  static char domain[150];
 
  // 定时检查 mqtt 链接
  static void mqttCheckConnect();

  static void messageBufferCheck();
  static void sendBuffer();
public:
  
  // 标记一些 topic 模板
  static char ALINK_TOPIC_PROP_POST[150];
  static char ALINK_TOPIC_PROP_SET[150];
  static char ALINK_TOPIC_EVENT[150];
  // 在主程序 loop 中调用，检查连接和定时发送信息
  static void loop();

  /**
   * 初始化程序
   * @param ssid wifi名
   * @param passphrase wifi密码
   */
  static void begin(Client &espClient,
                    const char *_productKey,
                    const char *_deviceName,
                    const char *_deviceSecret,
                    const char *_region);

  /**
   * 发送数据
   * @param param 字符串形式的json 数据，例如 {"${key}":"${value}"}
   */
  static void send(const char *param);
  /**
   * 发送 float 格式数据
   * @param key 数据的 key
   * @param number 数据的值
   */
  static void send(char *key, float number);
  /**
   * 发送 int 格式数据
   * @param key 数据的 key
   * @param number 数据的值
   */
  static void send(char *key, int number);
  /**
   * 发送 double 格式数据
   * @param key 数据的 key
   * @param number 数据的值
   */
  static void send(char *key, double number);
  /**
   * 发送 string 格式数据
   * @param key 数据的 key
   * @param text 数据的值
   */
  static void send(char *key, char *text);

  /**
   * 发送事件到云平台（附带数据）
   * @param eventId 事件名，在阿里云物模型中定义好的
   * @param param 字符串形式的json 数据，例如 {"${key}":"${value}"}
   */
  static void sendEvent(const char *eventId, const char *param);
  /**
   * 发送事件到云平台（空数据）
   * @param eventId 事件名，在阿里云物模型中定义好的
   */
  static void sendEvent(const char *eventId);

  /**
   * 绑定回调，所有云服务下发的数据都会进回调
   */
  // static void bind(MQTT_CALLBACK_SIGNATURE);

  /**
   * 绑定事件回调，云服务下发的特定事件会进入回调
   * @param eventId 事件名
   */
  // static void bindEvent(const char * eventId, MQTT_CALLBACK_SIGNATURE);
  /**
   * 绑定属性回调，云服务下发的数据包含此 key 会进入回调，用于监听特定数据的下发
   * @param key 物模型的key
   */
  static int bindData(char *key, poniter_fun fp);
  /**
   * 卸载某个 key 的所有回调（慎用）
   * @param key 物模型的key
   */
  static int unbindData(char *key);

  static int bindTopic(char *topic, poniter_fun fp);
  /**
   * 卸载某个 key 的所有回调（慎用）
   * @param key 物模型的key
   */
  static int unbindTopic(char *topic);
};
#endif

4.2 AliyunIoTSDK.cpp


#include "AliyunIoTSDK.h"
#include "PubSubClient.h"
#include <SHA256.h>

#define CHECK_INTERVAL 10000
#define MESSAGE_BUFFER_SIZE 10
#define RETRY_CRASH_COUNT 5

static const char *deviceName = NULL;
static const char *productKey = NULL;
static const char *deviceSecret = NULL;
static const char *region = NULL;

struct DeviceProperty
{
    String key;
    String value;
};

DeviceProperty PropertyMessageBuffer[MESSAGE_BUFFER_SIZE];

#define MQTT_PORT 1883

#define SHA256HMAC_SIZE 32
#define DATA_CALLBACK_SIZE 20

#define ALINK_BODY_FORMAT "{\"id\":\"123\",\"version\":\"1.0\",\"method\":\"thing.event.property.post\",\"params\":%s}"
#define ALINK_EVENT_BODY_FORMAT "{\"id\": \"123\",\"version\": \"1.0\",\"params\": %s,\"method\": \"thing.event.%s.post\"}"

static unsigned long lastMs = 0;
static int retry_count = 0;

static PubSubClient *client = NULL;

char AliyunIoTSDK::clientId[256] = "";
char AliyunIoTSDK::mqttUsername[100] = "";
char AliyunIoTSDK::mqttPwd[256] = "";
char AliyunIoTSDK::domain[150] = "";

char AliyunIoTSDK::ALINK_TOPIC_PROP_POST[150] = "";
char AliyunIoTSDK::ALINK_TOPIC_PROP_SET[150] = "";
char AliyunIoTSDK::ALINK_TOPIC_EVENT[150] = "";

static String hmac256(const String &signcontent, const String &ds)
{
    byte hashCode[SHA256HMAC_SIZE];
    SHA256 sha256;

    const char *key = ds.c_str();
    size_t keySize = ds.length();

    sha256.resetHMAC(key, keySize);
    sha256.update((const byte *)signcontent.c_str(), signcontent.length());
    sha256.finalizeHMAC(key, keySize, hashCode, sizeof(hashCode));

    String sign = "";
    for (byte i = 0; i < SHA256HMAC_SIZE; ++i)
    {
        sign += "0123456789ABCDEF"[hashCode[i] >> 4];
        sign += "0123456789ABCDEF"[hashCode[i] & 0xf];
    }

    return sign;
}

static void parmPass(JsonVariant parm)
{
    //    const char *method = parm["method"];
    for (int i = 0; i < DATA_CALLBACK_SIZE; i++)
    {
        if (poniter_array[i].key)
        {
            bool hasKey = parm["params"].containsKey(poniter_array[i].key);
            if (hasKey)
            {
                poniter_array[i].fp(parm["params"]);
            }
        }
    }
}

static void topicPass(char *topic,JsonVariant parm)
{
    for (int i = 0; i < 10; i++)
    {
        if (poniter_topic[i].key){
          if (strstr(topic, poniter_topic[i].key))
          {
            poniter_topic[i].fp(parm);
          }
        }
    }
}

// 所有云服务的回调都会首先进入这里，例如属性下发
static void callback(char *topic, byte *payload, unsigned int length)
{
    Serial.print("Message arrived [");
    Serial.print(topic);
    Serial.print("] ");
    payload[length] = '\0';
    Serial.println((char *)payload);

    if (strstr(topic, AliyunIoTSDK::ALINK_TOPIC_PROP_SET))
    {
        StaticJsonDocument<200> doc;
        DeserializationError error = deserializeJson(doc, payload); //反序列化JSON数据

        if (!error) //检查反序列化是否成功
        {
            parmPass(doc.as<JsonVariant>()); //将参数传递后打印输出
        }
    } else {
        StaticJsonDocument<200> doc;
        DeserializationError error = deserializeJson(doc, payload); //反序列化JSON数据

        if (!error) //检查反序列化是否成功
        {
            topicPass(topic,doc.as<JsonVariant>()); //将参数传递后打印输出
        }
    }
}

static bool mqttConnecting = false;
void(* resetFunc) (void) = 0; //制造重启命令
void AliyunIoTSDK::mqttCheckConnect()
{
    if (client != NULL && !mqttConnecting)
    {
        if (!client->connected())
        {
            client->disconnect();
            Serial.println("Connecting to MQTT Server ...");
            mqttConnecting = true;
            if (client->connect(clientId, mqttUsername, mqttPwd))
            {
                // 自定义主题订阅
                for (int i = 0; i < 10; i++)
                {
                    if (poniter_topic[i].fp)
                    {
                        client->subscribe(poniter_topic[i].key);
                    }
                }
                Serial.println("MQTT Connected!");
            }
            else
            {
                Serial.print("MQTT Connect err:");
                Serial.println(client->state());
                retry_count++;
                if(retry_count > RETRY_CRASH_COUNT){
                    resetFunc();
                }
            }
            mqttConnecting = false;
        }
        else
        {
            Serial.println("state is connected");
            retry_count = 0;
        }
    }
}

void AliyunIoTSDK::begin(Client &espClient,
                         const char *_productKey,
                         const char *_deviceName,
                         const char *_deviceSecret,
                         const char *_region)
{

    client = new PubSubClient(espClient);
    productKey = _productKey;
    deviceName = _deviceName;
    deviceSecret = _deviceSecret;
    region = _region;
    long times = millis();
    String timestamp = String(times);

    sprintf(clientId, "%s|securemode=3,signmethod=hmacsha256,timestamp=%s|", deviceName, timestamp.c_str());

    String signcontent = "clientId";
    signcontent += deviceName;
    signcontent += "deviceName";
    signcontent += deviceName;
    signcontent += "productKey";
    signcontent += productKey;
    signcontent += "timestamp";
    signcontent += timestamp;

    String pwd = hmac256(signcontent, deviceSecret);

    strcpy(mqttPwd, pwd.c_str());

    sprintf(mqttUsername, "%s&%s", deviceName, productKey);
    sprintf(ALINK_TOPIC_PROP_POST, "/sys/%s/%s/thing/event/property/post", productKey, deviceName);
    sprintf(ALINK_TOPIC_PROP_SET, "/sys/%s/%s/thing/service/property/set", productKey, deviceName);
    sprintf(ALINK_TOPIC_EVENT, "/sys/%s/%s/thing/event", productKey, deviceName);

    sprintf(domain, "%s.iot-as-mqtt.%s.aliyuncs.com", productKey, region);
    client->setServer(domain, MQTT_PORT); /* 连接WiFi之后，连接MQTT服务器 */
    client->setCallback(callback);

    mqttCheckConnect();
}

void AliyunIoTSDK::loop()
{
    client->loop();
    if (millis() - lastMs >= CHECK_INTERVAL)
    {
        lastMs = millis();
        mqttCheckConnect();
        messageBufferCheck();
    }
}

void AliyunIoTSDK::sendEvent(const char *eventId, const char *param)
{
    char topicKey[156];
    sprintf(topicKey, "%s/%s/post", ALINK_TOPIC_EVENT, eventId);
    char jsonBuf[1024];
    sprintf(jsonBuf, ALINK_EVENT_BODY_FORMAT, param, eventId);
    Serial.println(jsonBuf);
    boolean d = client->publish(topicKey, jsonBuf);
    Serial.print("publish:0 成功:");
    Serial.println(d);
}
void AliyunIoTSDK::sendEvent(const char *eventId)
{
    sendEvent(eventId, "{}");
}
unsigned long lastSendMS = 0;

// 检查是否有数据需要发送
void AliyunIoTSDK::messageBufferCheck()
{
    int bufferSize = 0;
    for (int i = 0; i < MESSAGE_BUFFER_SIZE; i++)
    {
        if (PropertyMessageBuffer[i].key.length() > 0)
        {
            bufferSize++;
        }
    }
    // Serial.println("bufferSize:");
    // Serial.println(bufferSize);
    if (bufferSize > 0)
    {
        if (bufferSize >= MESSAGE_BUFFER_SIZE)
        {
            sendBuffer();
        }
        else
        {
            unsigned long nowMS = millis();
            // 3s 发送一次数据
            if (nowMS - lastSendMS > 5000)
            {
                sendBuffer();
                lastSendMS = nowMS;
            }
        }
    }
}

// 发送 buffer 数据
void AliyunIoTSDK::sendBuffer()
{
    int i;
    String buffer;
    for (i = 0; i < MESSAGE_BUFFER_SIZE; i++)
    {
        if (PropertyMessageBuffer[i].key.length() > 0)
        {
            buffer += "\"" + PropertyMessageBuffer[i].key + "\":" + PropertyMessageBuffer[i].value + ",";
            PropertyMessageBuffer[i].key = "";
            PropertyMessageBuffer[i].value = "";
        }
    }

    buffer = "{" + buffer.substring(0, buffer.length() - 1) + "}";
    send(buffer.c_str());
}

void addMessageToBuffer(char *key, String value)
{
    int i;
    for (i = 0; i < MESSAGE_BUFFER_SIZE; i++)
    {
        if (PropertyMessageBuffer[i].key.length() == 0)
        {
            PropertyMessageBuffer[i].key = key;
            PropertyMessageBuffer[i].value = value;
            break;
        }
    }
}
void AliyunIoTSDK::send(const char *param)
{

    char jsonBuf[1024];
    sprintf(jsonBuf, ALINK_BODY_FORMAT, param);
    Serial.println(jsonBuf);
    boolean d = client->publish(ALINK_TOPIC_PROP_POST, jsonBuf);
    Serial.print("publish:0 成功:");
    Serial.println(d);
}
void AliyunIoTSDK::send(char *key, float number)
{
    addMessageToBuffer(key, String(number));
    messageBufferCheck();
}
void AliyunIoTSDK::send(char *key, int number)
{
    addMessageToBuffer(key, String(number));
    messageBufferCheck();
}
void AliyunIoTSDK::send(char *key, double number)
{
    addMessageToBuffer(key, String(number));
    messageBufferCheck();
}

void AliyunIoTSDK::send(char *key, char *text)
{
    addMessageToBuffer(key, "\"" + String(text) + "\"");
    messageBufferCheck();
}

int AliyunIoTSDK::bindData(char *key, poniter_fun fp)
{
    int i;
    for (i = 0; i < DATA_CALLBACK_SIZE; i++)
    {
        if (!poniter_array[i].fp)
        {
            poniter_array[i].key = key;
            poniter_array[i].fp = fp;
            return 0;
        }
    }
    return -1;
}

int AliyunIoTSDK::bindTopic(char *topic, poniter_fun fp)
{
    int i;
    for (i = 0; i < 10; i++)
    {
        if (!poniter_topic[i].fp)
        {
            poniter_topic[i].key = topic;
            poniter_topic[i].fp = fp;
            return 0;
        }
    }
    return -1;
}

int AliyunIoTSDK::unbindTopic(char *topic)
{
    int i;
    for (i = 0; i < 10; i++)
    {
        if (!strcmp(poniter_topic[i].key, topic))
        {
            poniter_topic[i].key = NULL;
            poniter_topic[i].fp = NULL;
            return 0;
        }
    }
    return -1;
}

int AliyunIoTSDK::unbindData(char *key)
{
    int i;
    for (i = 0; i < DATA_CALLBACK_SIZE; i++)
    {
        if (!strcmp(poniter_array[i].key, key))
        {
            poniter_array[i].key = NULL;
            poniter_array[i].fp = NULL;
            return 0;
        }
    }
    return -1;
}
单片机菜鸟哥
关注
  • 7
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
AliyunIoTSDK.zip
05-18
arduino IDE 上阿里云平台会用到的库AliyunIoTSDK。 AliyunIoTSDK.h，SDK的头文件。
四、Arduino接入阿里云物联网平台[学习笔记]
xh1725115440的博客
04-23 895
AliyunIoTSDK可以帮助你快速连接阿里云 IoT 平台，通过和阿里云物联网开发平台配合，可快速实现各种硬件应用，包括了很上层的封装，无需自己解析数据体，绑定事件即可，在。arduino上阿里云所需要用到的四个库文件。物联网平台--监控运维--在线调试-------------------设置，显示发送指令成功。产品--功能定义--编辑草稿--添加自定义功能 填写完成--确认-->发布上线。物模型的topic，后面是物模型，系统topic无法转发，只能转发自定义topic。
基于 arduino IDE使用AliyunIoTSDK库接入阿里云
vor234的博客
11-22 4240
文中提到的 AliyunIoTSDK 这个 arduino 库，可以在 arduino 库商店里搜索到（搜索 AliyunIoTSDK），但是版本可能不一定是最新的，也可以手动把 github 上的项目 clone 下来，放到 arduino 的 library 库下，保证功能是最新的。
Arduino ESP8266&ESP32使用AliyunIoTSDK.h连接阿里云物联网平台
小途的博客
11-12 4608
AliyunIoTSDK是arduino的一个库，可以在arduino的应用商店中搜索到这个库，当时版本不一定是最新的，而且下载的地址在国外，下载会比较久，有时还不能下载成功，我之前就在下载他的库的时候花费了大量的时间。我这里提供基于AliyunIoTSDK库的开源项目地址：如果网站无法打开，可以使用我已经下载好的项目包：链接：https://share.weiyun.com/urYMY5tN 密码：yr6d78。
【Mena】AliyunIoTSDK库的超级增强版（实现RRPC）
weixin_43401559的博客
05-10 949
在使用阿里云与Nodemcu的交互中，会使用AliyunIoTSDK库进行数据发送和返回。使用这哥加强的SDK能够实现阿里云平台的RRPC和MQTT在自定义topic下的数据发送。 这里是.c文件 #include "AliyunIoTSDK.h" #include "PubSubClient.h" #include <SHA256.h> #define CHECK_INTERVAL 10000 #define MESSAGE_BUFFER_SIZE 10 #define RETRY_CRAS
jQuery绑定自定义事件的魔法升级版
01-19
jQuery绑定自定义事件 首先让我们来看看jQuery绑定自定义事件的使用方法，你可以使用bind或者live来订阅一个事件（当然1.7以后也可以使用on了），代码如下： $(#myElement).bind('customEventName',function(e){ .....
jQuery实现获取绑定自定义事件元素的方法
10-23
本文将详细讲解如何使用jQuery实现获取绑定自定义事件元素的方法，以及涉及到的事件绑定和元素操作技巧。 首先，我们要理解jQuery的事件绑定机制。`$.fn.bind`是jQuery用于绑定事件处理函数的核心方法。默认情况下...
Knockout自定义绑定创建方法
09-03
预置的绑定，如`value`、`text`等，能满足大部分需求，但有时候我们需要自定义绑定来实现特定的功能。本文将详细介绍如何创建和使用Knockout自定义绑定。 ### 自定义绑定的创建 创建自定义绑定时，你需要定义一个...
SpringMVC自定义参数绑定实现详解
08-25
SpringMVC自定义参数绑定实现详解 SpringMVC自定义参数绑定实现详解主要介绍了SpringMVC自定义参数绑定实现详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友可以...
aliyun-iot-client-sdk:阿里云物联网套件硬件端SDK
05-11
aliyun-iot-mqtt Node.js的MQTT客户端 安装 您可以使用npm将其安装为依赖项。 $ # save into package.json dependencies with -S $ npm install aliyun-iot-mqtt -S 用法 通过productKey＆deviceName＆deviceSecret认证的Aliyun IoT中心mqtt客户端。 获取数据 const Mqtt = require ( 'aliyun-iot-mqtt' ) ; const client = Mqtt . getAliyunIotMqttClient ( { productKey : "" , deviceName : "" , deviceSecret : "" , regionId : "cn-shanghai" ,
arduino上阿里云所需要用到的四个库文件.PubSubClient，ArduinoJson，AliyunIoTSDK，Crypto（SHA256）
05-18
arduino上阿里云所需要用到的四个库文件.PubSubClient，ArduinoJson，AliyunIoTSDK，Crypto（SHA256）。 PubSubClient.h，是发布/订阅功能的头文件；SHA256.h，是加密功能的头文件（Crypto里面已有包含这个了）；ArduinoJson.h，是支持Json数据格式的头文件；AliyunIoTSDK.h，是阿里云SDK的头文件。
用来连接阿里云物联网平台的arduino库（基于ESP8266）AliyunIoTSDK
01-31
arduino要想连接阿里云物联网平台，必须借助专业的库才能减少代码量。这个库可以帮助你快速连接阿里云 IoT 平台，通过和阿里云物联网开发平台配合，可快速实现各种硬件应用，包括了很上层的封装，无需自己解析数据体，绑定事件即可，在 arduino d1 wifi平台实际测试成功。
AliyunIoTSDK库使用问题和阿里云错误码解决
岁月无疆的博客
11-09 6770
1.AliyunIoTSDK库 使用问题 2. 阿里云错误编码解决
使用AliyunIoTSDK点亮led
韩盼盼的小窝
06-29 2353
#include <ESP8266WiFi.h> static WiFiClient espClient; #include <ArduinoJson.h> #include <AliyunIoTSDK.h> AliyunIoTSDK iot; #define PRODUCT_KEY "dsfdfsdfdf" #define DEVICE_NAME "Kdsfsdf2-01" #define DEVICE_SECRET "sdfsdf" #define REGI..
阿里云物联网设备SDK：构建智能硬件的新时代工具
gitblog_00026的博客
03-31 499
阿里云物联网设备SDK：构建智能硬件的新时代工具 项目地址:https://gitcode.com/aliyun/alibabacloud-iot-device-sdk 项目简介 阿里云物联网（IoT）设备SDK是一个强大而全面的开发工具，旨在帮助开发者快速、安全地将各种智能硬件接入阿里云物联网平台。此项目提供了多种编程语言的版本，包括C、Java、Python等，使得不同类型的设备都能轻松集成...
【ESP 保姆级教程】第三方库篇 —— 快速上手AliyunIoTSDK，api解释
单片机菜鸟哥的博客
06-04 3887
简要介绍AliyunIOTSDK使用以及注意事项。
从arduino板开始做到阿里云app控制--WeMos D1或ESP8266连接阿里云文章合集及源代码
ieeee.blog.csdn.net
04-30 5474
近期不断有麻油问我要源代码，就不遮掩了，将多日心血粘贴到此处，复制粘贴即可，还提供了下载连接，不过可能需要积分，看在辛苦敲字的份上，赞助一下吧伙计们。当然编译代码成功的前提是arduino环境搭建好。再附上前期敲的9段“实验记录”，希望对新手有帮助。arduino使用简单，对入门物联网非常适用，调试通过了，肯定可以对整个通信过程理解的更加深入。
esp8266/32+Arduino+MQTT+AliyunIoTSDK.h+阿里云iot,案例
u012525063的博客
02-07 3004
之前一直搞不定阿里云的Tkon令牌 后面看到这个AliyunIoTSDK库,超级简单 一行代码连接阿里云 在Arduino库里安装AliyunIoTSDK就行,前提要安装ArduinoJson,Crypto,PubSubClient库 AliyunIoTSDK介绍:https://github.com/yu-tou/arduino-aliyun-iot-sdk 依赖 PubSubClient ，在使用前，请务必修改 PubSubClient 的连接参数，否则无法使用 PubSubClient 中的 MQTT
qt绑定自定义类的信号
最新发布
06-04
在绑定自定义类的信号时，我们需要使用信号声明宏 Q_SIGNALS 和 emit 关键字。具体实现步骤如下： 1. 在自定义类的头文件中声明信号。例如： ``` class MyWidget : public QWidget { Q_OBJECT public: explicit...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

单片机菜鸟哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值