stm32开发之threadx+modulex+filex+shell组件(实现命令行动态加载程序)

前言

  1. 前几篇博客基本上已经将filex、levelx、threadx、modulex、shell 组件大概都记录了一遍.
  2. 本篇博客做个综合实际案例记录.

实现效果

在这里插入图片描述

代码程序

Modulex组件

源文件

/*
 * Copyright (c) 2024-2024，shchl
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2024-4-19     shchl   first version
 */
#include "includes.h"

#if 1
#define MODULE_DATA_SIZE           (20*1024)  /* 供动态APP使用 */
#define OBJECT_MEM_SIZE            (20*1024)    /* 供动态APP的动态内存管理申请使用 */
/*
*******************************************************************************************************
*                               外部引入变量
*******************************************************************************************************
*/

/*
*******************************************************************************************************
*                               变量
*******************************************************************************************************
*/
TX_QUEUE ResidentQueue;       /* 消息队列，用于主程序和动态APP通信 */
uint32_t MessageQueuesBuf[100];

/*
*********************************************************************************************************
*                                       静态全局变量
*********************************************************************************************************
*/
static ULONG memory_faults = 0;
static UCHAR *module_data_area;
static UCHAR *object_memory;

/*
*********************************************************************************************************
*                                      函数声明
*********************************************************************************************************
*/

static VOID module_fault_handler(TX_THREAD *thread, TXM_MODULE_INSTANCE *module);
/*
*********************************************************************************************************
*                                      外部函数
*********************************************************************************************************
*/

/*
*********************************************************************************************************
*	函 数 名: module_application_define
*	功能说明: 创建 模块管理任务线程
*	形    参: 无
*	返 回 值: 无
*********************************************************************************************************
*/
int module_application_define(void) {
    UINT status;
    /*模块 分配内存空间(使用全局数组的方式)*/
    static UCHAR obj_mem[OBJECT_MEM_SIZE];
    static UCHAR data_area[MODULE_DATA_SIZE];
    /*使用 动态内存分配的方式*/
//    object_memory = app_malloc(OBJECT_MEM_SIZE);
//    module_data_area = app_malloc(MODULE_DATA_SIZE);
    object_memory = obj_mem;
    module_data_area = data_area;
    /* 创建常驻消息队列 */
    if (tx_queue_create(&ResidentQueue, "Resident Queue",
                        TX_1_ULONG, MessageQueuesBuf,
                        16 * sizeof(ULONG)) != TX_SUCCESS) {
        Error_Handler();
    }

    /* 初始化动态加载管理器，主要是给动态APP的数据空间使用  */
    status = txm_module_manager_initialize((VOID *) module_data_area, MODULE_DATA_SIZE);

    if (status != TX_SUCCESS) {
        Error_Handler();
    }
    /* 供动态APP使用的对象内存池，主要各种控制块申请 */
    status = txm_module_manager_object_pool_create(object_memory, OBJECT_MEM_SIZE);
    if (status != TX_SUCCESS) {
        Error_Handler();
    }
    /* 注册faults管理 */
    status = txm_module_manager_memory_fault_notify(module_fault_handler);
    if (status != TX_SUCCESS) {
        Error_Handler();
    }
    return TX_SUCCESS;
}

TX_THREAD_EXPORT_LV1(module_application_define); /*首先创建模块应用*/
/*
*********************************************************************************************************
*	函 数 名: module_fault_handler
*	功能说明: 监测faults
*	形    参: ---
*	返 回 值: 无
*********************************************************************************************************
*/
static VOID module_fault_handler(TX_THREAD *thread, TXM_MODULE_INSTANCE *module) {
    tx_log("module_fault_handler: thread[%s],module[%s]\r\n", thread->tx_thread_name, module->txm_module_instance_name);
    /* 统计错误消息  */
    memory_faults++;
}


#endif

Modulex 调用的api接口(对modulex提供的函数进行封装)

头文件

/*
 * Copyright (c) 2024-2024，shchl
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2024-4-19     shchl   first version
 */

#ifndef STM32_PROJECT_APP_MODULE_API_H
#define STM32_PROJECT_APP_MODULE_API_H

#include "txm_module.h"

/**
 * @brief 模块信息结构体
 */
typedef struct module_info_struct {
#define MODULE_NAME_LEN 32
    char module_name[MODULE_NAME_LEN]; /*模块名*/
    uint32_t load_addr; /*加载地址地址(适用于flash方式,定位bin数据)*/
    TXM_MODULE_INSTANCE instance;  /* 模块实例 */
} module_info;

UINT app_txm_module_read(module_info *info, void (*info_out_handle)(TXM_MODULE_INSTANCE *instance, ULONG prop));

UINT app_txm_module_start(module_info *info);

UINT app_txm_module_stop(module_info *info);

UINT app_txm_module_unload(module_info *info);

UINT app_txm_module_fx_load(module_info *info, FX_MEDIA *media_ptr, CHAR *file_name);

UINT app_txm_module_file_load(module_info *info, CHAR *file_name, void (*bin_data_handle)(uint8_t *data, uint16_t len));

#endif //STM32_PROJECT_APP_MODULE_API_H

源文件

/*
 * Copyright (c) 2024-2024，shchl
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2024-4-19     shchl   first version
 */

#include "includes.h"
#include "app_file_api.h"

static FX_FILE module_file;


/*默认实现模块输出*/
static void app_txm_module_info_out(TXM_MODULE_INSTANCE *instance, ULONG prop) {
    tx_printf("===============================app_txm_module_info_out================================\r\n");
    tx_printf("------------------module build info------------------\r\n");
    tx_printf("\t--Compiled for %s compiler\r\n",
              ((prop >> 25) == 1) ? "CubeIDE (GNU)" : ((prop >> 24) == 1) ? "ARM KEIL" : "IAR EW");
    tx_printf("\t--Shared/external memory access is %s\r\n", ((prop & 0x04) == 0) ? "Disabled" : "Enabled");
    tx_printf("\t--MPU protection is %s\r\n", ((prop & 0x02) == 0) ? "Disabled" : "Enabled");
    tx_printf("\t--%s mode execution is enabled for the module\r\n\r\n", ((prop & 0x01) == 0) ? "Privileged" : "User");
    tx_printf("------------------module application info------------------\r\n");
    tx_printf("\t--application id %#lx;instance id:%#lx;name:%s\r\n",
              instance->txm_module_instance_application_module_id,
              instance->txm_module_instance_id,
              instance->txm_module_instance_name);
    tx_printf("\t--code section【start addr: %#lx||end addr:%#lx||size(bytes):%lu】\r\n",
              (ULONG) instance->txm_module_instance_code_start,
              (ULONG) instance->txm_module_instance_code_end,
              instance->txm_module_instance_code_size);
    tx_printf("\t--data section【start addr: %#lx||end addr:%#lx||size(bytes):%lu】\r\n",
              (ULONG) instance->txm_module_instance_data_start,
              (ULONG) instance->txm_module_instance_data_end,
              instance->txm_module_instance_data_size);

    tx_printf("\t--shared_memory 【addr:%#lx||size(bytes): %lu】\r\n",
              instance->txm_module_instance_shared_memory_address,
              instance->txm_module_instance_shared_memory_length);
}


UINT app_txm_module_start(module_info *info) {
    UINT status;
    /*确保模块已加载,校验逻辑内部已提供*/
    status = txm_module_manager_start(&info->instance);
    return status;
}

UINT app_txm_module_stop(module_info *info) {
    UINT status;
    /*确保模块已加载,校验逻辑内部已提供*/
    status = txm_module_manager_stop(&info->instance);

    return status;
}

UINT app_txm_module_unload(module_info *info) {

    UINT status;
    /*确保模块已加载,校验逻辑内部已提供*/
    status = txm_module_manager_unload(&info->instance);

    return status;

}

UINT app_txm_module_fx_load(module_info *info, FX_MEDIA *media_ptr, CHAR *file_name) {
    UINT status;
    /*判断media 设备是否挂载*/
    if (media_ptr->fx_media_id != FX_MEDIA_ID) {

        return TX_NOT_AVAILABLE;
    }
    if (info->instance.txm_module_instance_id == TXM_MODULE_ID) {

        return TXM_MODULE_ALREADY_LOADED;
    }
    /*确保模块已加载,校验逻辑内部已提供*/
    status = txm_module_manager_file_load(&info->instance,
                                          info->module_name,
                                          media_ptr,
                                          file_name);
    return status;
}

/**
 * @brief 从文件中加载模块文件,自定义数据处理
 * @param addr
 * @param file_name
 * @return
 */
UINT app_txm_module_file_load(module_info *info, CHAR *file_name,
                              void (*bin_data_handle)(uint8_t *data, uint16_t len)) {
    TX_INTERRUPT_SAVE_AREA
    if (!bin_data_handle) {
        return TX_PTR_ERROR;
    }
    /*判断media 设备是否挂载*/

    if (info->instance.txm_module_instance_id == TXM_MODULE_ID) {

        return TXM_MODULE_ALREADY_LOADED;
    }
#define READ_BUF_SIZE 2048
    TX_DISABLE
    uint8_t *cache_buf = app_malloc(READ_BUF_SIZE);
    TX_RESTORE
    if (cache_buf == NULL) return TX_NO_MEMORY;
    UINT status = app_fx_file_open(&module_file, file_name, FX_OPEN_FOR_READ);
    ULONG actual_read;
    if (status) {
        tx_printf("app_txm_module_file_load error:%#x\r\n", status);
        return TX_NOT_AVAILABLE;
    }
    do {
        status = fx_file_read(&module_file, cache_buf, READ_BUF_SIZE, &actual_read);
        bin_data_handle(cache_buf, actual_read);
    } while (status &= FX_END_OF_FILE);
    fx_file_close(&module_file);
    TX_DISABLE
    app_free(cache_buf);
    TX_RESTORE
    return TX_SUCCESS;
#undef READ_BUF_SIZE
}

/**
 * @brief 模块信息读取
 * @param info
 * @param info_out_handle 信息输出（可为null,使用默认输出）
 * @return
 */
UINT app_txm_module_read(module_info *info, void (*info_out_handle)(TXM_MODULE_INSTANCE *instance, ULONG prop)) {
    UINT status = TX_SUCCESS;
    ULONG module_properties;
    /*确定 模块是否已加载*/
    if (info->instance.txm_module_instance_id == TXM_MODULE_ID) {
        /* 获取动态APP属性 */
        status = txm_module_manager_properties_get(
                &info->instance,
                &module_properties);
    } else {  // 未加载
        /* 加载动态APP */
        return TXM_MODULE_UNLOADED;
    }
    if (status) {
        tx_log("txm_module_manager_properties_get error:[%d]\r\n", status);
        return status;
    }
    if (!info_out_handle) {
        /*模块信息打印*/
        app_txm_module_info_out(&info->instance, module_properties);
    } else {
        info_out_handle(&info->instance, module_properties);
    }
    return status;
}

对接shell 组件（命令行控制）

/*
 * Copyright (c) 2024-2024，shchl
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2024-4-19     shchl   first version
 */
#include "includes.h"

#if 1

#include "app_module_api.h"

static module_info app_module;


/**
 * @brief sys_thread 命令
 * @param argc
 * @param argv
 * @return
 */
int app_module_fnc(int argc, char *argv[]) {
    UINT status = TX_NOT_AVAILABLE;
    if (argc < 2 || argc > 3) {
        tx_printf("===========================USEG MANUAL=======================\r\n");
        tx_printf("module load ------- load module\r\n");
        return -1;
    }
    char *cmd = argv[1];
    if (argc == 3) {

        if (strstr(cmd, "load")) {

            status = app_txm_module_fx_load(&app_module, &g_fx_media, argv[2]);
        }
    } else {
        if (strstr(cmd, "info")) {
            status = app_txm_module_read(&app_module, NULL);
        } else if (strstr(cmd, "unload")) {
            status = app_txm_module_unload(&app_module);
        } else if (strstr(cmd, "start")) {
            status = app_txm_module_start(&app_module);
        } else if (strstr(cmd, "stop")) {
            status = app_txm_module_stop(&app_module);
        } else {
            logWarning("not support cmd");
        }
    }
    if (status)logError("err result:%d", status)
    return 0;
}

SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) |
                 SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN),
                 module,
                 app_module_fnc,
                 "module load");

#endif

bin 文件上传（通过ota方式）

/*
 * Copyright (c) 2024-2024，shchl
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2024-4-19     shchl   first version
 */
#include "includes.h"


#include "ymodem.h"
#include "app_file_api.h"
static char upload_file_name[64] = {0};
static size_t update_file_total_size;
static size_t rec_data_len = 0;

static FX_FILE ota_file;


static enum rym_code ymodem_on_begin(struct rym_ctx *ctx, uint8_t *buf, size_t len) {
    static char *tmp_file_name, *file_size;
    UINT stat;
    /* calculate and store file size */
    tmp_file_name = (char *) &buf[0];
    file_size = (char *) &buf[strlen(tmp_file_name) + 1];
    memcpy(upload_file_name, tmp_file_name, strlen(tmp_file_name));
    /*这里是保存的路径,现在是直接保存到根路径下*/
    sprintf(upload_file_name, "%s", tmp_file_name);
    stat = app_fx_file_open(&ota_file, upload_file_name, FX_OPEN_FOR_WRITE);
    if (stat) {
        return RYM_CODE_NAK;
    }
    fx_file_seek(&ota_file, FX_SEEK_BEGIN);

    update_file_total_size = atol(file_size);
    return RYM_CODE_ACK;
}


static enum rym_code ymodem_on_data(struct rym_ctx *ctx, uint8_t *buf, size_t len) {
    /*TODO 接收升级数据包处理*/
    fx_file_write(&ota_file, buf, len);

    rec_data_len += len;
    return RYM_CODE_ACK;
}

static void rym_delay_ms(size_t ms) {
    tx_thread_sleep(ms);
}

static uint32_t rym_sys_tick_get() {
    return tx_time_get();
}

static uint32_t rym_millisecond_to_tick(uint32_t ms) {
    uint32_t tick;
    tick = TX_TIMER_TICKS_PER_SECOND * (ms / 1000);
    tick += (TX_TIMER_TICKS_PER_SECOND * (ms % 1000) + 999) / 1000;
    /* return the calculated tick */
    return tick;
}
static size_t rym_write(struct rym_ctx *self, size_t offset, const uint8_t *buf, size_t len) {
    comSendBuf(COM1, (uint8_t *) (buf + offset), len);
    return len;
}

static size_t rym_read_wait(struct rym_ctx *self, size_t offset, uint8_t *buf, size_t len,
                            uint32_t timeout) {
    UNUSED(self);
    size_t readCnt = 0;
    uint32_t cur_tick = rym_sys_tick_get();
    while (len) {
        if (comGetChar(COM1, (uint8_t *) (buf + readCnt + offset)) == 1) {
            readCnt++;
            len--;
        } else {
            if (rym_sys_tick_get() > cur_tick + timeout) {
                break;
            }
        }
    }
    return readCnt;
}

static inline void ota_ymodem_lock() {
    /*由于shell 组件中已做了加锁处理,这里就可以不需要进行加锁*/
}

static inline void ota_ymodem_unlock() {
    /*由于shell 组件中已做了加锁处理,这里就可以不需要进行解锁*/
}
void console_ota_func() {
    struct rym_ctx rctx;
    /*变量重新初始化*/
    {
        memset(upload_file_name, 0, strlen(upload_file_name));/*清除上次的文件名*/
        rec_data_len = 0;
    }
    rctx.driver.rym_delay_ms = rym_delay_ms;
    rctx.driver.rym_sys_tick_get = rym_sys_tick_get;
    rctx.driver.rym_millisecond_to_tick = rym_millisecond_to_tick;
    rctx.driver.rym_write = rym_write;
    rctx.driver.rym_read_wait = rym_read_wait;
    /*内存分配*/
#ifdef RYM_CTX_USE_ALLOC_CALLBACK
    rctx.rym_malloc = (void *(*)(size_t)) app_malloc;
    rctx.rym_free = (void (*)(void *)) app_free;
#endif
    ota_ymodem_lock();/*加锁*/
    int32_t status = rym_recv_on_device(&rctx,
                                        ymodem_on_begin,
                                        ymodem_on_data,
                                        NULL, 1000);

    /*todo 是否需要重启芯片(针对于ota升级)*/
    /*关闭文件*/
    app_fx_file_close(&ota_file);

    ota_ymodem_unlock();/*解锁*/
    tx_printf("\r\n------------stats is:%ld------------\r\n", status);
    tx_printf("file name:%s;file size:%d; rec lec:%d\r\n", upload_file_name, update_file_total_size, rec_data_len);
}

#ifdef SHELL_USING_CMD_EXPORT

/*shell 脚本来管理*/
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC) | SHELL_CMD_DISABLE_RETURN,
                 ota, console_ota_func, "ymodem ota upgrade");

#endif

模块程序

#define TXM_MODULE


#include "txm_module.h"




/*
*********************************************************************************************************
*                                    宏定义
*********************************************************************************************************
*/
#define DEFAULT_STACK_SIZE        1024

#define App_Printf_ID1       (TXM_APPLICATION_REQUEST_ID_BASE)
#define App_Printf_ID2       (TXM_APPLICATION_REQUEST_ID_BASE + 1)


#define MODULE_THREAD_PRIO                         3
#define MODULE_THREAD_PREEMPTION_THRESHOLD         MODULE_THREAD_PRIO

ULONG      AppModuleStk[DEFAULT_STACK_SIZE/4];

/* 相关控制块 */
TX_THREAD               *thread_0;
TX_QUEUE                *resident_queue;

/* 函数 */
void thread_0_entry(ULONG thread_input);
void Error_Handler1(void);


/*
*********************************************************************************************************
*	函 数 名: default_module_start
*	功能说明: 动态APP入口
*	形    参: ---
*	返 回 值: 无
*********************************************************************************************************
*/
void  demo_module_start(ULONG id)
{
    CHAR    *pointer;

    /* 从主程序申请相关控制块，不在APP里面申请，防止APP出问题了影响主程序 */
    txm_module_object_allocate((void*)&thread_0, sizeof(TX_THREAD));
    /* 创建任务 */
    tx_thread_create(thread_0,
                     "module thread qqq",
                     thread_0_entry,
                     0,
                     &AppModuleStk[0],
                     DEFAULT_STACK_SIZE,
                     MODULE_THREAD_PRIO,
                     MODULE_THREAD_PREEMPTION_THRESHOLD,
                     TX_NO_TIME_SLICE,
                     TX_AUTO_START);

}

/*
*********************************************************************************************************
*	函 数 名: thread_0_entry
*	功能说明: 动态APP里面的任务
*	形    参: ---
*	返 回 值: 无
*********************************************************************************************************
*/
void thread_0_entry(ULONG thread_input)
{
    /* 防止警告 */
    UINT num = 0;
    while(1)
    {
        /* 调用主程序里面的串口打印 */
        num++;
        txm_module_application_request(App_Printf_ID1, num, 0, 0);
        tx_thread_sleep(1000);
    }
}

/*
*********************************************************************************************************
*	函 数 名: thread_0_entry
*	功能说明: 执行出错
*	形    参: ---
*	返 回 值: 无
*********************************************************************************************************
*/
void Error_Handler1(void)
{
    tx_thread_sleep(TX_WAIT_FOREVER);
}

加入宏定义

在txm_module_port.h中加入,不在txm_module_user.h加,由于我们编译模块的时候，是没有加入相关宏定义的，所以
txm_module_user.h中是不会生效的

#define FX_FILEX_PRESENT
#define TXM_MODULE_KERNEL_STACK_SIZE    2048  // 内核栈设置大一些,由于使用了filex

构建模块bin

  1. 由于加入filex ，所以构建模块时，脚本文件配置加入对应的filex头文件相关路径,然后重新生成库文件和模块bin文件
    在这里插入图片描述

测试

生成好的bin文件，通过ota上传到sd卡

在这里插入图片描述

加载module文件

在这里插入图片描述

查看module信息

在这里插入图片描述

启动模块

  1. 为了方便停止,10秒打印一次模块调用的信息
    在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

查看线程信息

在这里插入图片描述
在这里插入图片描述

停止模块

在这里插入图片描述

总结

  1. 目前已经可以动态加载模块了,后面再补充两个模块之间通信的记录

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/560338.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

easyx库的学习(文字绘制)

easyx库的学习(文字绘制)

前言 昨天刚刚写完了基本图形的制作&#xff0c;今天直接可以来看看&#xff0c;在easyx中使用文字 直接看代码吧 文字绘制 void drawTest() {printf("hello,EasyX");//指的是在控制台打印//设置字体大小&#xff0c;样式settextstyle(30, 0, "微软雅黑&quo…
阅读更多...
4.4 @ControllerAdvice全局数据处理

4.4 @ControllerAdvice全局数据处理

4.4 ControllerAdvice全局数据处理 1. 全局异常处理 &#xff20;ExceptionHandler2. 添加全局数据 ModelAttribute3. 请求参数预处理 InitBinder 顾名思义&#xff0c;&#xff20;ControllerAdvice 就是&#xff20;Controller 增强版。&#xff20;ControllerAdvice 主要用来…
阅读更多...
【LAMMPS学习】八、基础知识(3.8)计算扩散系数

【LAMMPS学习】八、基础知识(3.8)计算扩散系数

8. 基础知识 此部分描述了如何使用 LAMMPS 为用户和开发人员执行各种任务。术语表页面还列出了 MD 术语&#xff0c;以及相应 LAMMPS 手册页的链接。 LAMMPS 源代码分发的 examples 目录中包含的示例输入脚本以及示例脚本页面上突出显示的示例输入脚本还展示了如何设置和运行各…
阅读更多...
esp32-通过wifi使用timelib库同步时间（三）

esp32-通过wifi使用timelib库同步时间（三）

库的安装 本文基于platformIO&#xff0c;安装较为简单如下图 实例代码 完整代码如下&#xff0c;如果时间获取超时请使用time1.aliyun.com获取时间。 /** Time_NTP.pde* Example showing time sync to NTP time source** This sketch uses the Ethernet library*/#include …
阅读更多...
通过实例学C#之序列化与反序列化XmlSerializer类

通过实例学C#之序列化与反序列化XmlSerializer类

简介 可以将类序列化成xml文件&#xff0c;或者将xml文件反序列化成类对象&#xff0c;一般用于保存或加载项目参数。 构造函数 XmlSerializer() 不使用函数创建一个xmlSerializer对象。 XmlSerializer(Type type) 使用type对象创建一个xmlSerializer对象&#xff0c;注意&…
阅读更多...
NotePad++联动ABAQUS

NotePad++联动ABAQUS

Abaqus 中脚本运行 1. 命令区kernel Command Line Interface &#xff08;KCLI&#xff09; execfile(C:\\temp\second develop\chapter2\pyTest1.py)2. CAE-Run Script File->Run Script 3. Abaqus command Abaqus cae noGUIscript.py(前后处理都可)Abaqus Python scr…
阅读更多...
牛x之路 - Day1

牛x之路 - Day1

Day1 微积分之屠龙宝刀&#xff08;武林秘籍&#xff09; 之前的一些东西都在pdf上记得笔记&#xff0c; 没有在这个上面展示一遍&#xff0c;只好学到相关内容的时候再提叙啦&#xff1b;所以其实再写这个小记的时候&#xff0c;我已经看了一半的书&#xff0c;但是不要紧&am…
阅读更多...
【结构型模式】组合模式

【结构型模式】组合模式

一、组合模式概述 组合模式的定义与意图&#xff1a;将对象组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一致的方式处理个别对象以及对象组合。&#xff08;对象结构型&#xff09; 组合模式分析&#xff1a; 1.当容器对象的某一个方法被调用时&#xff0c;将遍…
阅读更多...
OpenHarmony网络协议通信—kcp

OpenHarmony网络协议通信—kcp

kcp 是一种 ARQ 协议,可解决在网络拥堵情况下 tcp 协议的网络速度慢的问题 下载安装 直接在 OpenHarmony-SIG 仓中搜索 kcp 并下载。 使用说明 准备一套完整的 OpenHarmony 3.1 Beta 代码 库代码存放路径&#xff1a;./third_party/kcp 修改添加依赖的编译脚本 在/develo…
阅读更多...
书生·浦语实战营第二期（六）——Agent

书生·浦语实战营第二期（六）——Agent

一、概述&#xff1a; 1.1、Lagent: Lagent 是一个轻量级开源智能体框架&#xff0c;旨在让用户可以高效地构建基于大语言模型的智能体。同时它也提供了一些典型工具以增强大语言模型的能力。 Lagent 目前已经支持了包括 AutoGPT、ReAct 等在内的多个经典智能体范式&#xf…
阅读更多...
jeecgflow之camunda工作流-串行流程

jeecgflow之camunda工作流-串行流程

引言 UserTask用户任务,是需要人处理后才能流转的任务。 本文将构建一个简单的串行流程带大家快速入门camunda工作流。 BPMN在线建模 如需亲自体验文章案例&#xff0c;请访问如下网址。 JeecgFlow演示站点 需求 我们以三国为背景&#xff0c; 假设系统中拥有将军&#xff0c…
阅读更多...
ardunio中自定义的库文件

ardunio中自定义的库文件

1、Arduino的扩展库都是放在 libraries目录下的。完整路径为&#xff1a;C:\Users\41861\AppData\Local\Arduino15\libraries 所以我们需要在这个目录下创建一个文件夹&#xff0c;比如上面的例子是esp32上led灯控制程序&#xff0c;于是我创建了 m_led文件夹&#xff08;前面加…
阅读更多...
根据 Excel 列生成 SQL

根据 Excel 列生成 SQL

公司有个历史数据刷数据的需求, 开发功能有点浪费, 手工刷数据有点慢, 所以研究了下 excel 直接生成 SQL, 挺好用, 记录一下; 例如这是我们的数据, 要求把创建时间和完成时间刷进数据库中, 工单编号唯一 Excel 公式如下: "UPDATE service_order SET create…
阅读更多...
浅析Redis④：字典dict实现

浅析Redis④：字典dict实现

什么是dict&#xff1f; 在 Redis 中&#xff0c;dict 是指哈希表&#xff08;hash table&#xff09;的一种实现&#xff0c;用于存储键值对数据。dict 是 Redis 中非常常用的数据结构之一&#xff0c;用于实现 Redis 的键空间。 在 Redis 源码中&#xff0c;dict 是一个通用…
阅读更多...
linux中如何挂载yum云仓库进行软件的安装

linux中如何挂载yum云仓库进行软件的安装

1.首先在根目录下建立文件&#xff0c;用来挂载镜像文件 [rootclient ~]# mkdir /rhel9 2.挂载镜像文件&#xff1a; [rootclient ~]# mount /dev/cdrom /rhel9 3.切换到 /etc/yum.repos.d 下的目录并查看 &#xff0c;创建 rhel9.repo文件&#xff0c;并编辑云仓库域名&am…
阅读更多...
【LLM 论文】Self-Consistency — 一种在 LLM 中提升 CoT 表现的解码策略

【LLM 论文】Self-Consistency — 一种在 LLM 中提升 CoT 表现的解码策略

论文&#xff1a;Self-Consistency Improves Chain of Thought Reasoning in Language Models ⭐⭐⭐⭐⭐ ICLR 2023, Google Research 文章目录 论文速读 论文速读 本工作提出了一种解码策略&#xff1a;self-consistency&#xff0c;并可以用于 CoT prompting 中。 该策略提…
阅读更多...
Linux使用Libevent库实现一个网页服务器---C语言程序

Linux使用Libevent库实现一个网页服务器---C语言程序

Web服务器 这一个库的实现 其他的知识都是这一个专栏里面的文章 实际使用 编译的时候需要有一个libevent库 gcc httpserv.c -o httpserv -levent实际使用的时候需要指定端口以及共享的目录 ./httpserv 80 .这一个函数会吧这一个文件夹下面的所有文件共享出去 实际的效果, 这…
阅读更多...
NLP_知识图谱_三元组实战

NLP_知识图谱_三元组实战

文章目录 三元组含义如何构建知识图谱模型的整体结构基于transformers框架的三元组抽取baselinehow to use预训练模型下载地址训练数据下载地址 结构图代码及数据bertconfig.jsonvocab.txt datadev.jsonschemas.jsontrain.jsonvocab.json 与bert跟data同个目录model.pytrain.py…
阅读更多...
华为ensp中rip和ospf路由重分发 原理及配置命令

华为ensp中rip和ospf路由重分发 原理及配置命令

作者主页&#xff1a;点击&#xff01; ENSP专栏&#xff1a;点击&#xff01; 创作时间&#xff1a;2024年4月20日20点21分 路由重分发&#xff08;Route Redistribution&#xff09;是指路由器将从一种路由协议学习到的路由信息&#xff0c;通过另一种路由协议通告出去的功…
阅读更多...
Linux环境变量深度解析

Linux环境变量深度解析

文章目录 一、引言二、环境变量的基本概念1、环境变量的定义2、环境变量的作用与意义 三、环境变量的导入1、导入所需文件2、登陆时的导入 四、环境变量的设置方法1、查看环境变量的方式2、使用export命令临时设置环境变量3、修改配置文件以永久设置环境变量 五、命令行参数与环…
阅读更多...
最新文章

Copyright @ 2022~2023