Day2--使用ESP32双核、U8G2 OLED任务、任务以绝对频率运行、任务内存优化

已于 2022-12-03 16:52:15 修改
阅读量2.9k 收藏 22
点赞数 6
分类专栏： ESP32 FreeRTOS 文章标签： c++ 开发语言
于 2022-12-02 10:17:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45355603/article/details/128120021
版权

使用ESP32双核

ESP32-C系列为单核，ESP32的core0主要运行WI-FI和蓝牙

  API:

      xPortGetCoreID() 获取当前任务运行的核心

      xTaskCreate() 有系统选择运行核心，优先选择0

      xTaskCreatePinnedToCore() 指派任何给指定核心

Arduino的setup和loop默认运行在core1 

#include <Arduino.h>

void taskA(void *ptParam)
{
  while (1)
  {
    Serial.println(xPortGetCoreID()); // 获取当前任务运行的核心
  }
}

void setup()
{
  // put your setup code here, to run once:
  Serial.begin(115200);
  xTaskCreatePinnedToCore(taskA, "Task A", 1024 * 4, NULL, 1, NULL, 0); // 最后一个参数为核心0
}

void loop()
{
}

U8G2 OLED任务

 创建任务时使用空指针的原因，加快速度，可以接收任何类型的数据

注意事项，把U8G2相关的配置（初始化）写进任务中，不要写道setup中

#include <U8g2lib.h>
#include <Wire.h>

void oledTask(void *pvParam)
{
  U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/U8X8_PIN_NONE);
  u8g2.begin();
  for (;;)
  {
    u8g2.clearBuffer();                    // clear the internal memory
    u8g2.setFont(u8g2_font_ncenB08_tr);    // choose a suitable font
    u8g2.drawStr(15, 10, "LONELY BINARY"); // write something to the internal memory
    u8g2.sendBuffer();                     // transfer internal memory to the display
    vTaskDelay(1000);
  }
}

void setup()
{ // loopBack , Priority 1, Core 1
  xTaskCreatePinnedToCore(oledTask, "OLED Task", 1024 * 6, NULL, 1, NULL, 1);

  vTaskDelete(NULL); // 删除setup任务，节省内存空间
}

void loop()
{
}

任务以绝对频率运行

实时操作系统要求必须在指定的时间内处理数据（比如每3秒显示一次数据，不能快，也不能慢）

vTaskDelayUntil函数比vTaskDelay函数定时精准，用处：周期性获取传感器数据（蓝牙发送数据）

vTaskDelayUntil函数比vTaskDelay函数多了一个记录任务本次被唤醒的时刻的变量，因此如果想要实现控制任务能够周期性运行的话，vTaskDelayUntil函数是一种比较简单的方法。

注意：LastWakeTime中保存的是上次唤醒时间，进入vTaskDelayUntil后会判断，如果上次唤醒时间大于当前时间,说明节拍计数器溢出了，就不在延时直接执行了。

  API：

    vTaskDelayUntil(&xLastWakeTime, xFrequency)

      最后一次的唤醒时间是指针类型。

      本函数会自动更新xLastWakeTime为最后一次唤醒的时间

      所以无需手动在while循环内对其手动赋值

    xTaskGetTickCount()

      TickCount和 Arduino Millis一样

      uint32_t类型 49天后overflow(溢出)

void showStockTask(void *ptParam)
{
  static float stockPrice = 99.57; //股票价格
  //最后一次唤醒的tick count，第一次使用需要赋值
  //以后此变量会由vTaskDelayUntil自动更新
  TickType_t xLastWakeTime = xTaskGetTickCount(); // 相当于millis

  const TickType_t xFrequency = 3000; // 间隔 3000 ticks = 3 seconds

  for (;;)
  {
    //恰恰算算，经过思考，既然我们叫做LastWakeTime，那么 vTaskDelayUntil 应该放在循环的第一句话
    //如果放在循环的最后一句话，应该改为xLastSleepTime 才更加合适
    vTaskDelayUntil(&xLastWakeTime, xFrequency);

    //验证当前唤醒的时刻tick count
    Serial.println(xTaskGetTickCount());
    //验证xLastWake Time是否被vTaskDelayUntil更新
    // Serial.println(xLastWakeTime);

    // ------- 很复杂的交易股票计算，时间不定 ---------
    stockPrice = stockPrice * (1 + random(1, 20) / 100.0);
    vTaskDelay(random(500, 2000));

    Serial.print("Stock Price : $");
    Serial.println(stockPrice);

    //使用vTaskDelay试试看会如何
    // vTaskDelay(xFrequency);   // 测试结果显示，差距很大，时间不精确
  }
}

void setup()
{
  Serial.begin(115200);
  xTaskCreate(showStockTask, "Show Stock Price", 1024 * 6, NULL, 1, NULL);
}

void loop()
{
}

任务内存优化

1024单位是STACK，不是字节，1STACK=4Byte，因此，1024K是4KB字节空间。1024*4是16KB字节空间。虽然ESP32的RAM有320KB，算是几款MCU中最大的了。但由于是STACK，也不能太任意的用了。需要注意用量。

创建任务时，如果分配的内存空间过小，则会导致程序不断重启。

变量在stack中

建立任务时会占用额外的内存空间，大概368 bytes 

如果有很多数据需要串口输出，单独创建一个task（例如蓝牙发送所有数据，其他任务通过多任务传参的方式把需要输出的数据发送给，打印输出task）

  API：

    ESP.getHeapSize() //  本程序Heap最大尺寸（空间总大小）

    ESP.getFreeHeap() //  当前Free Heap最大尺寸（当前可用剩余空间大小）

    uxTaskGetStackHighWaterMark(taskHandle) // Task内存使用最大水位线，内存是水

/*
  程序： 内存管理
  公众号：孤独的二进制
  API：
    ESP.getHeapSize() //本程序Heap最大尺寸
    ESP.getFreeHeap() //当前Free Heap最大尺寸
    uxTaskGetStackHighWaterMark(taskHandle) //Task内存使用最大水位线，内存是水

    What is the Highest Water Mark?
    the minimum amount of remaining stack space that was available to the task
    since the task started executing - that is the amount of stack that remained
    unused when the task stack was at its greatest (deepest) value. This is what
    is referred to as the stack 'high water mark'.
*/
#include <Arduino.h>
TaskHandle_t taskHandle; // 计算任务的空间大小使用
int taskMem = 1024;

void task(void *ptParam)
{
  // volatile char hello[1000] = {0}; //必须要用volatile修饰语，否则会被编译器优化掉
  while (1)
  {

    //不推荐在task中执行，因为Serial.print也会消耗内存
    // vTaskDelay(2000);
    // int waterMark = uxTaskGetStackHighWaterMark(nullptr);
    // Serial.print("Task Free Memory: ");
    // Serial.print(waterMark);
    // Serial.println(" Bytes");
    // Serial.print("Task Used Memory: ");
    // Serial.print(taskMem - waterMark);
    // Serial.println(" Bytes");
    // Serial.println("");
  }
}
void setup()
{
  Serial.begin(115200);
  Serial.println("串口打印测试");
  int heapSize = ESP.getHeapSize(); // 得到可用空间大小
  Serial.print("Total Heap Size:  ");
  Serial.print(heapSize);
  Serial.println(" Bytes");

  int heapFree = ESP.getFreeHeap(); // 得到当前运行命令状态下所剩余尺寸
  Serial.print("Free Heap Size:  ");
  Serial.print(heapFree);
  Serial.println(" Bytes");
  Serial.println("");

  Serial.println("Create Task ...");
  xTaskCreate(task, "", taskMem, NULL, 1, &taskHandle);

  Serial.print("Free Heap Size:  ");
  Serial.print(ESP.getFreeHeap());
  Serial.println(" Bytes");
  Serial.println("");

  vTaskDelay(2000);
  /*      重要          */
  int waterMark = uxTaskGetStackHighWaterMark(taskHandle);  // 计算任务用了多少内存
  Serial.print("Task Free Memory: ");  // 任务剩余空间
  Serial.print(waterMark);
  Serial.println(" Bytes");
  Serial.print("Task Used Memory: ");
  Serial.print(taskMem - waterMark);  // 任务使用空间
  Serial.println(" Bytes");
}

void loop()
{
}

任务优先级

可以设置0~24之间的任意数字，0最小，24优先级最大

看门狗

防止死机，每一个CPU都有一只看门狗，ESP32有两个核心，所以有两只狗，看门狗是针对任务的，不是针对CPU，默认情况下在核心0有一只看门狗

队列单种数据（重要）

FIFO：first in first out

队列：queue，先进先出

队列是一种数据结构，可以包含一组固定大小的数据，在创建队列的同时，队列的长度和所包含数据类型的大小就确认下来了，一个队列可以有多个写入数据的任务和多个读取数据的任务。当一个任务试图从队列读取 数据的时候，它可以设置一个堵塞时间（block time）。这是当队列数据为空时，任务会进入阻塞状态的时间。当有数据在队列或者到达阻塞时间的时候，任务都会进入就绪状态。如果有多个任务同时在阻塞状态等待队列数据，优先级高的任务会在数据到达时进入就绪状态；在优先级相同的时候，等待时间长的任务会进入就绪状态。同理可以推及多个任务写入数据时候的运行状态。

使用步骤：

  1. 创建队列（设定队列长度，数据大小size）
  2. 往队列里发送数据
  3. 读取数据
  4. 案例：聊天室发信息

API：

    QueueHandle_t xQueueCreate( UBaseType_t uxQueueLength,

                             UBaseType_t uxItemSize );

    BaseType_t xQueueSend(

                            QueueHandle_t xQueue,

                            const void * pvItemToQueue,

                            TickType_t xTicksToWait

                         );

    BaseType_t xQueueReceive(

                               QueueHandle_t xQueue,

                               void *pvBuffer,

                               TickType_t xTicksToWait

                            );

队列多种数据（超级重要）

案例：通过队列+结构体的方式，将DHT22的温度和湿度数据在不同的任务间传输

创建队列：长度（可以放几个数据）、大小（每个数据的大小）

编程技巧：可以创建一个结构体类型，然后创建多个对象进行调用。

可以采用这种方法给上位机发送数据（把LCD显示部分的程序改为自己需要的数据）

/*
   程序：  消息队列
   公众号：孤独的二进制
   说明：本实例使用结构体巧妙的通过当个队列传输多个设备多种数据类型
        在接收方，我们通过deviceID来判断数据来源和value的意义

   API：
    QueueHandle_t xQueueCreate( UBaseType_t uxQueueLength,
                             UBaseType_t uxItemSize );

    BaseType_t xQueueSend(
                            QueueHandle_t xQueue,
                            const void * pvItemToQueue,
                            TickType_t xTicksToWait
                         );
    BaseType_t xQueueReceive(
                               QueueHandle_t xQueue,
                               void *pvBuffer,
                               TickType_t xTicksToWait
                            );

*/
#include "DHTesp.h"
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);
/*设备ID，共有2个设备*/
#define DHT22_ID 0 
#define LDR_ID 1

typedef struct
{
  byte deviceID;
  float value1;
  float value2;
} SENSOR;

QueueHandle_t queueSensor = xQueueCreate(8, sizeof(SENSOR)); // 长度8，采用sizeof自动计算需要的空间

void dht22(void *ptParam)
{

  const byte dhtPin = 32;
  DHTesp dhtSensor;
  dhtSensor.setup(dhtPin, DHTesp::DHT22);

  SENSOR dht22Sensor;  // 创建一个结构体对象
  dht22Sensor.deviceID = DHT22_ID;

  while (1)
  {
    TempAndHumidity data = dhtSensor.getTempAndHumidity();

    // Serial.println("Temp: " + String(data.temperature, 2) + "°C");
    // Serial.println("Humidity: " + String(data.humidity, 1) + "%");

    dht22Sensor.value1 = data.temperature;
    dht22Sensor.value2 = data.humidity;

/*往队列里发送数据，如果队列数据是满的，等待2s，如果2s之后，队列还是满的，就放弃写操作*/
    // TickType_t timeOut = portMAX_DELAY;  不要用这个，时间为49天
    TickType_t timeOut = 2000;
    if (xQueueSend(queueSensor, &dht22Sensor, timeOut) != pdPASS)
    {
      Serial.println("DHT22: Queue is full.");
    }

    vTaskDelay(1000); // 这个时间如果比较短，则队列很快就满了
  }
}

void ldr(void *ptParam)
{
  const float GAMMA = 0.7;
  const float RL10 = 50;
  const byte ldrPIN = 27;
  pinMode(ldrPIN, INPUT);

  SENSOR ldrSensor;
  ldrSensor.deviceID = LDR_ID;

  while (1)
  {
    int analogValue = analogRead(ldrPIN);

    float voltage = analogValue / 4095. * 5;
    float resistance = 2000 * voltage / (1 - voltage / 5);
    float lux = pow(RL10 * 1e3 * pow(10, GAMMA) / resistance, (1 / GAMMA));

    // Serial.print("LDR Light Sensor lux : ");
    // Serial.println(lux);

    ldrSensor.value1 = lux;
    // ldrSensor.value2 = 0.0; 这条语句不要也行

    // TickType_t timeOut = portMAX_DELAY;
    TickType_t timeOut = 2000;
    if (xQueueSend(queueSensor, &ldrSensor, timeOut) != pdPASS)
    {
      Serial.println("LDR: Queue is full.");
    }

    vTaskDelay(1000);
  }
}

void lcdTask(void *ptParam)
{ // LCD任务主体

  lcd.init();
  lcd.backlight();

  lcd.setCursor(0, 0);
  lcd.print("   LONELY  BINARY  ");

  SENSOR data;  // 
  while (1)
  {
    // TickType_t timeOut = portMAX_DELAY;
    TickType_t timeOut = 2000;
    if (xQueueReceive(queueSensor, &data, timeOut) == pdPASS)
    {

      switch (data.deviceID)
      {
      case DHT22_ID:
        lcd.setCursor(0, 1);
        lcd.print("Temp: " + String(data.value1, 2) + "c");
        lcd.setCursor(0, 2);
        lcd.print("Humidity: " + String(data.value2, 1) + "%");
        break;
      case LDR_ID:
        lcd.setCursor(0, 3);
        if (data.value1 > 50)
        {
          lcd.print("Bright ");
        }
        else
        {
          lcd.print("Dark ");
        }
        // lcd.setCursor(0, 3);
        lcd.print(String(data.value1, 2) + " lux");
        break;
      default:
        Serial.println("LCD: Unkown Device");
        break;
      }
    }
    else
    {
      Serial.println("LCD: Message Queue is Empty");
    };

    vTaskDelay(2000);
  }
}

void setup()
{
  Serial.begin(115200);

  xTaskCreate(dht22, "DHT22", 1024 * 4, NULL, 1, NULL);
  xTaskCreate(ldr, "LDR LIGHT", 1024 * 4, NULL, 1, NULL);
  xTaskCreate(lcdTask, "lcd", 1024 * 8, NULL, 1, NULL);
}

void loop() {}
⁢稚子
关注
  • 6
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在NodeJs中使用node-schedule增加定时器任务的方法
10-15
在Node.js环境中，如果你需要创建复杂的定时任务，`node-schedule`是一个非常实用的库。本文将详细介绍如何从零开始在Node.js中使用`node-schedule`来添加定时器任务，以及如何在实际项目中应用它。 首先，安装`...
ESP32从零开始（7）—— 任务的建立和删除
weixin_45652444的博客
07-21 5419
这是本人的学习历程，属于学习总结。分享给大家，仅作参考。 （如果哪里有问题请留言指出。谢谢~） 概述 本项目通过Cmake构建。 一、用到的Linux操作指令 //切换目录 cd 目录 //新建文件夹。 p 确保目录名称存在，不存在的就建一个。 mkdir -p 文件夹名 //删除文件夹及里面所有文件 rm -rf 目录名字 //新建文件 touch 文件名.后缀 /////////////////////////////////////////////////////// //v.
esp32 cam xTaskCreatePinnedToCore 使用方法
weixin_48336761的博客
05-04 4823
xTaskCreatePinnedToCore()是一个FreeRTOS库函数，用于创建一个新的任务，并将其固定到ESP32的指定核心上运行，实现多核多任务开发。
编译器优化入门（基于ESP32）
最新发布
qq_40773212的博客
06-17 235
这是编译器的"无优化"级别。在这个级别上，编译器不会进行任何优化，以最快的速度生成代码。这意味着编译器将直接按照源代码的字面意义生成机器代码，不考虑运行时的性能。这个优化级别专注于生成更小的可执行文件。它尝试通过各种优化手段减少程序的体积，同时也会考虑程序的运行效率。这个优化级别是为调试而设计的，它尝试在不显著影响程序性能的情况下，生成更容易调试的代码。这是编译器的"中等"优化级别。它启用了大多数不涉及显著增加编译时间的优化选项。ESP-IDF 支持多种编译器，但默认情况下，它使用的是乐鑫官方提供的。
(ESP32学习6)双核CPU的调用
热门推荐
ailta的博客
06-01 2万+
本来之前从来没有用过双核做东西，但是突然意识到他好像是双核的，所以找了一些资料更第一篇双核的调用，还是挺有趣的 博文会持续更FreeRTOS与双核相关内容，这一章先做一件最简单的事情：在两个核上创建简单任务让他们跑起来 先看代码再讲解 #include <soc/soc.h> #include <soc/rtc_cntl_reg.h> void Task1code( void *pvParameters ); void Task2code( void *pvParameters )
esp32之点亮一盏灯
物联网研究室BBC的博客
09-23 6095
我还记得当初学51单片机导师与我们说，当你点亮一盏灯，那么你已经学会了80%，就当个笑话吧，但也不是并无道理 源码路径esp-idf/examples/get-started/blink #include &lt;stdio.h&gt; #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "driver/gpi...
3.在ESP32上充分利用双核的FreeRTOS多核编程
m0_60134435的博客
01-23 2953
定义将在各个核心上运行的任务函数。每个任务函数中可以包含不同的逻辑，根据需要进行处理。// 核心0的任务逻辑// 核心1的任务逻辑通过充分利用ESP32的双核，可以在不同的核心上运行不同的任务，提高系统性能和响应速度。在项目中，可以根据具体需求合理规划任务分配，达到最佳的多核利用效果。同时，在低功耗应用中，通过任务分配和控制核心工作状态，可以有效地实现功耗的优化。在ESP32上使用双核是一种高效的多核编程方式，值得开发者深入学习和应用。
ESP32 Arduino双核编程示例
perseverance51博客
09-16 4093
ESP32 Arduino双核编程 实例代码 /* 保存数据的结构*/ typedef struct{ int sender; char *msg; }Data; /* 这个变量保持队列句柄 */ xQueueHandle xQueue; TaskHandle_t xTask1; TaskHandle_t xTask2; void setup() { Serial.begin(112500); /* 创建队列，其大小可包含5个元素Data */ xQueue = xQueueCreat
python定时任务 每天运行一次.md
03-26
python定时任务 每天运行一次 在 Python 中可以使用 schedule 模块来实现定时任务。以下是一个每天运行一次的例子： import schedule import time def job(): print("I'm running at 5:00am every day.") # 设定...
obsidian-day-planner:一个黑曜石插件，用于从Markdown笔记中的任务列表中计划和管理番茄定时器
03-20
日程安排者该存储库包含一个用于的插件，用于从Markdown注释中的任务列表中计划和管理番茄定时器。这是该插件版本的早期版本，在打开Obsidian并启用该插件时，它将在后台持续运行。请首先在测试库中试用该插件，最...
day05-Elasticsearch01day05-Elasticsearch01
10-25
1. 数据模型：Elasticsearch基于Lucene构建，使用倒排索引技术，以提高搜索效率。每个文档都有一个唯一的_id，存储在索引（Index）中，索引可以看作数据库，类型（Type）类似于表，文档是数据的基本单元。 2. ...
Linux定时任务Crontab命令使用详解与总结
09-15
Linux定时任务是系统管理的重要组成部分，它允许管理员或用户安排任务在特定时间自动执行。Crontab命令是实现这一功能的核心工具，适用于Unix和Linux操作系统。Crontab代表“cron table”，它允许用户定义一系列定时...
S1-03 线程间通讯
Mars.CN
01-11 880
函数，函数传入两个变量，第一个是互斥信号量的句柄，也就是我们之前创建的那个key，第二个是等待的超时时间，例程中设置的是1000个Tick（注意，这里不是毫秒，而是系统Tick，如果需要使用毫秒，可以用pdMS_TO_TICKS进行运算），如果在固定时间内获得了信号量，则返回pdPASS，如果返回的是pdFalse或其他的值，则表示获取失败。我们假设有一个场景，一个冰箱里放了 100 个汉堡，冰箱旁有两个人，一个是吃货，不停的吃，另一个是厨子，隔一段时间公布一下冰箱里剩余的汉堡数量和被吃货吃掉的汉堡数量。
ESP32学习笔记-双核编程
ssismm的博客
03-19 983
日拱一卒。
ESP32 FreeRTOS-任务的创建与删除 (1)
believe666的博客
10-05 3422
对FreeRTOS创建任务和删除任务
如何使双核心的ESP32开启双核功能同时执行多任务
优信电子的博客
10-20 5235
双核的ESP32并行执行多任务
ESP32开发：从入门到精通的全面指南
weixin_57178023的博客
04-16 1万+
ESP32 是一款功能强大的微控制器，它可以帮助开发者构建各种物联网（IoT）应用。ESP32 拥有 WiFi 和蓝牙无线连接功能，并且可以轻松地与各种传感器和设备进行通信。本文将介绍 ESP32 的基本知识和常用开发工具，以及如何开始 ESP32 的开发。
单核与多核CPU的区别与联系-结合ESP32浅谈
wangyx1234的博客
11-08 4062
1）多核 CPU 从运算数量上提升设备处理数据的速度，从功能上可以将多核 CPU 分为 SMP\AMP 两种。 2）多核情况下速率并没有成倍的提升，因为配套的设备、多核的协调都需要一些小的损耗。 3）使用多核后要考虑共享资源、多核间的协调同步的问题。 4）ESP32 是双核 CPU 结构，相比单核，它的任务创建机制，优先级调度策略、抢占机制、时间片轮转机制、SysTick 的使用机制都有所不同，驱动开发中这些问题尤其重要，应用开发中关注这些将有益于实现更高效的代码。
【ESP32系列开发】ESP32-PICO-D4 使用双核
飘雪冰峰的博客
12-14 5599
ESP32 双核使用
kill -9批量杀任务
09-02
使用kill命令的选项"-9"可以强制终止进程。要批量使用kill -9命令杀死任务，可以通过组合使用ps、grep和awk命令来实现。首先，使用ps命令获取所有相关的进程。然后，使用grep命令过滤出需要终止的进程。最后，使用awk命令将需要终止的进程ID提取出来并传递给kill命令。以下是具体的命令示例： ps -ef | grep java | grep datax | grep -v grep | awk '{print "kill -9 "$2}' | sh 以上命令的执行过程如下：首先，使用ps -ef命令列出所有正在运行的进程；然后，使用grep命令过滤出包含"java"和"datax"关键字的进程；着，使用grep -v grep命令去除掉grep进程本身；最后，使用awk命令将过滤结果中的进程ID提取出来，并使用kill -9命令强制终止这些进程。 请注意，kill -9命令会立即终止进程，但也可能会导致数据丢失或其他不可预测的后果。因此，在使用kill -9命令之前，请确保您已经保存了所有需要保存的数据，并确保您理解并接受了潜在的风险。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [oracle kill -9 会话](https://blog.csdn.net/weixin_39629969/article/details/116350055)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* [Linux批量kill进程 (批量杀掉进程)、CentOS](https://blog.csdn.net/sunny_day_day/article/details/127973923)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值