独钓寒江雪

u8g2_SetFont(&u8g2, u8g2_font_wqy12_t_gb2312);
u8g2_DrawUTF8(&u8g2, 1, 18, "我拿起那40米的大砍刀");
u8g2_DrawUTF8(&u8g2, 5, 40, "削你那15米的铅笔");
u8g2_SendBuffer(&u8g2);

#include <rtthread.h>
#include <rtdevice.h>

#define PWM_DEV_NAME        "pwm1"      // 硬件定时器设备名
#define PWM_CHANNEL1        1           // 通道1
#define PWM_CHANNEL2        2           // 通道2

struct rt_device_pwm *pwm_dev;

static int pwm_demo(int argc, char *argv[])
{
    rt_uint32_t period, pulse1, pulse2;

    pwm_dev = (struct rt_device_pwm *)rt_device_find(PWM_DEV_NAME);
    if (pwm_dev == RT_NULL)
    {
        rt_kprintf("can't find %s device!\n", PWM_DEV_NAME);
        return -1;
    }

    // 2. 设置周期和脉宽（单位：纳秒）
    period = 50000;      // 20kHz = 1s/20000 = 50,000ns
    pulse1 = period * 30 / 100; // 30% 占空比
    pulse2 = period * 60 / 100; // 60% 占空比

    // 3. 配置 PWM 通道1
    rt_pwm_set(pwm_dev, PWM_CHANNEL1, period, pulse1);
    rt_pwm_enable(pwm_dev, PWM_CHANNEL1);

    // 4. 配置 PWM 通道2
    rt_pwm_set(pwm_dev, PWM_CHANNEL2, period, pulse2);
    rt_pwm_enable(pwm_dev, PWM_CHANNEL2);

    return 0;
}

MSH_CMD_EXPORT(pwm_demo, pwm demo);

#include <rtthread.h>
#include <rtdevice.h>

#define PULSE_ENCODER_DEV_NAME    "pulse3"

static int pulse_encoder_demo(int argc, char *argv[])
{
    rt_err_t ret = RT_EOK;
    rt_device_t pulse_encoder_dev = RT_NULL;

    rt_int32_t count;

    /* 查找脉冲编码器设备 */
    pulse_encoder_dev = rt_device_find(PULSE_ENCODER_DEV_NAME);
    if (pulse_encoder_dev == RT_NULL)
    {
        rt_kprintf("pulse encoder sample run failed! can't find %s device!\n", PULSE_ENCODER_DEV_NAME);
        return RT_ERROR;
    }

    /* 以只读方式打开设备 */
    ret = rt_device_open(pulse_encoder_dev, RT_DEVICE_OFLAG_RDONLY);
    if (ret != RT_EOK)
    {
        rt_kprintf("open %s device failed!\n", PULSE_ENCODER_DEV_NAME);
        return ret;
    }

    for(rt_uint32_t i = 0; i <= 10000; i++)
    {
        rt_thread_mdelay(500);

        rt_device_read(pulse_encoder_dev, 0, &count, 1);
        rt_device_control(pulse_encoder_dev, PULSE_ENCODER_CMD_CLEAR_COUNT, RT_NULL);
        rt_kprintf("get count %d\n",count);
    }

    rt_device_close(pulse_encoder_dev);
    return ret;
}

MSH_CMD_EXPORT(pulse_encoder_demo, pulse_encoder_demo);

#include <stdio.h>
#include <stdint.h>

#include "mqttclient.h"


static void on_message_receive(void* client, message_data_t* msg)
{
    (void) client;
    rt_kprintf("-----------------------------------------------------------------------------------");
    rt_kprintf("%s:%d %s()...\ntopic: %s\nmessage:%s", __FILE__, __LINE__, __FUNCTION__, msg->topic_name, (char*)msg->message->payload);
    rt_kprintf("-----------------------------------------------------------------------------------");
}


static int mqtt_say_hello(mqtt_client_t *client)
{
    mqtt_message_t msg;
    memset(&msg, 0, sizeof(msg));

    msg.qos = 0;
    msg.payload = (void *) "payload to sent";

    return mqtt_publish(client, "demo_topic", &msg);
}


int mqtt_demo(void)
{
    mqtt_client_t *client = NULL;

    mqtt_log_init();

    client = mqtt_lease();

    mqtt_set_host(client, "192.168.88.234");
    mqtt_set_port(client, "1883");
    mqtt_set_clean_session(client, 1);
    mqtt_set_keep_alive_interval(client, 10);

    mqtt_connect(client);
    mqtt_subscribe(client, "demo_topic", QOS0, on_message_receive);

    while (1) {
        mqtt_say_hello(client);
        mqtt_sleep_ms(4 * 1000);
    }
}

MSH_CMD_EXPORT(mqtt_demo, mqtt_demo);

#include <rtthread.h>
#include <mb.h>
#include <mb_m.h>

#define MB_POLL_THREAD_PRIORITY  10
#define MB_SEND_THREAD_PRIORITY  RT_THREAD_PRIORITY_MAX - 1

static void rtu_master_demo_thread(void *parameter) {
    eMBMasterReqErrCode error_code = MB_MRE_NO_ERR;
    rt_uint16_t error_count = 0;
    USHORT data[2] = {0};

    while (1){
        data[0] = (USHORT)(rt_tick_get() / 10);
        data[1] = (USHORT)(rt_tick_get() % 10);

        error_code = eMBMasterReqWriteMultipleHoldingRegister(
            1,     /* salve address */
            2,     /* register start address */
            2,     /* register total number */
            data,  /* data to be written */
            RT_WAITING_FOREVER); /* timeout */

        /* Record the number of errors */
        if (error_code != MB_MRE_NO_ERR)
        {
            error_count++;
        }
    }
}

static void modbus_master_poll(void *parameter){
    // uart5
    eMBMasterInit(MB_RTU, 5, 115200, MB_PAR_EVEN);
    eMBMasterEnable();

    while (1){
        eMBMasterPoll();
        rt_thread_mdelay(500);
    }
}

int freemodbus_rtu_master_demo(){
    static rt_uint8_t is_init = 0;
    rt_thread_t tid1 = RT_NULL, tid2 = RT_NULL;

    if (is_init > 0){
        rt_kprintf("libmodbus_rtu_master is running\n");
        return -RT_ERROR;
    }
    tid1 = rt_thread_create("modbus_master_poll", modbus_master_poll, RT_NULL, 512, MB_POLL_THREAD_PRIORITY, 10);
    if (tid1 != RT_NULL){
        rt_thread_startup(tid1);
    }
    else{
        goto __exit;
    }

    tid2 = rt_thread_create("rtu_master_demo_thread", rtu_master_demo_thread, RT_NULL, 512, MB_SEND_THREAD_PRIORITY, 10);
    if (tid2 != RT_NULL){
        rt_thread_startup(tid2);
    }
    else{
        goto __exit;
    }

    is_init = 1;
    return RT_EOK;

__exit:
    if (tid1) rt_thread_delete(tid1);
    if (tid2) rt_thread_delete(tid2);

    return -RT_ERROR;
}

MSH_CMD_EXPORT(freemodbus_rtu_master_demo, freemodbus_rtu_master_demo)

#include <rtthread.h>
#include <mb.h>
#include <mb_m.h>
#include <user_mb_app.h>

#define MB_POLL_THREAD_PRIORITY  10
#define MB_SEND_THREAD_PRIORITY  RT_THREAD_PRIORITY_MAX - 1

extern USHORT usSRegHoldBuf[S_REG_HOLDING_NREGS];

// master来读取slave的数据
static void rtu_slave_demo_thread(void *parameter)
{
    USHORT*           usRegHoldingBuf;
    usRegHoldingBuf = usSRegHoldBuf;
    rt_base_t level;

    while (1){
        level = rt_hw_interrupt_disable();

        usRegHoldingBuf[3] = (USHORT)(rt_tick_get() / 100);

        rt_hw_interrupt_enable(level);

        rt_thread_mdelay(1000);
    }
}

static void modbus_slave_poll(void *parameter)
{
    // 从机地址1, uart5
    eMBInit(MB_RTU, 1, 5, 115200, MB_PAR_EVEN);
    eMBEnable();
    while (1)
    {
        eMBPoll();
        rt_thread_mdelay(200);
    }
}
int freemodbus_rtu_slave_demo(){
    static rt_uint8_t is_init = 0;
    rt_thread_t tid1 = RT_NULL, tid2 = RT_NULL;

    if (is_init > 0){
        rt_kprintf("sample is running\n");
        return -RT_ERROR;
    }
    tid1 = rt_thread_create("modbus_slave_poll", modbus_slave_poll, RT_NULL, 512, MB_POLL_THREAD_PRIORITY, 10);
    if (tid1 != RT_NULL){
        rt_thread_startup(tid1);
    }
    else{
        goto __exit;
    }

    tid2 = rt_thread_create("rtu_slave_demo_thread", rtu_slave_demo_thread, RT_NULL, 512, MB_SEND_THREAD_PRIORITY, 10);
    if (tid2 != RT_NULL){
        rt_thread_startup(tid2);
    }
    else{
        goto __exit;
    }

    is_init = 1;
    return RT_EOK;

__exit:
    if (tid1) rt_thread_delete(tid1);

    if (tid2) rt_thread_delete(tid2);

    return -RT_ERROR;
}

MSH_CMD_EXPORT(freemodbus_rtu_slave_demo, freemodbus_rtu_slave_demo)

#include <rtthread.h>
#include <rtdevice.h>
#include <modbus.h>

static void rtu_master_demo_thread(void *param){
    uint16_t tab_reg[64] = {0};
    modbus_t* ctx = RT_NULL;

    ctx = modbus_new_rtu("/dev/uart5", 115200, 'N', 8, 1);
    modbus_rtu_set_serial_mode(ctx, MODBUS_RTU_RS232);
    modbus_set_slave(ctx, 3);
    modbus_connect(ctx);
    modbus_set_response_timeout(ctx, 0, 1000000);
    int num = 0;
    while (1)
    {
        memset(tab_reg, 0, 64 * 2);
        int regs = modbus_read_registers(ctx, 0, 20, tab_reg);
        printf("-------------------------------------------\n");
        printf("[%4d][read num = %d]", num, regs);
        num++;
        int i;
        for (i = 0; i < 20; i++)
        {
            printf("<%#x>", tab_reg[i]);
        }
        printf("\n");
        printf("-------------------------------------------\n");
        rt_thread_mdelay(2000);
    }

    modbus_close(ctx);
    modbus_free(ctx);
}

int libmodbus_rtu_master_demo(){
    rt_thread_t tid;
    tid = rt_thread_create("rtu_master_demo",
                           rtu_master_demo_thread, RT_NULL,
                           2048,
                           12, 10);
    if (tid != RT_NULL) rt_thread_startup(tid);
    return RT_EOK;
}

MSH_CMD_EXPORT(libmodbus_rtu_master_demo, libmodbus_rtu_master_demo)

#include <rtthread.h>
#include <rtdevice.h>
#include <modbus.h>
#include <sal_socket.h>

static void tcp_master_demo_thread(void *param)
{
    uint16_t tab_reg[64] = {0};
    modbus_t *ctx = RT_NULL;

    ctx = modbus_new_tcp("192.168.88.61", 502, AF_INET);
    modbus_set_slave(ctx, 3);
    modbus_set_response_timeout(ctx, 0, 1000000);
_modbus_tcp_start:
    if(modbus_connect(ctx) < 0)  goto _modbus_tcp_restart;

    int num = 0;
    while (1)
    {
        memset(tab_reg, 0, 64 * 2);
        int regs = modbus_read_registers(ctx, 0, 20, tab_reg);
        if(regs < 0) goto _modbus_tcp_restart;

        printf("-------------------------------------------\n");
        printf("[%4d][read num = %d]", num, regs);
        num++;
        int i;
        for (i = 0; i < 20; i++)
        {
            printf("<%#x>", tab_reg[i]);
        }
        printf("\n");
        printf("-------------------------------------------\n");
        rt_thread_mdelay(1000);
    }

_modbus_tcp_restart:
    modbus_close(ctx);
    rt_thread_mdelay(2000);
    goto _modbus_tcp_start;

    modbus_free(ctx);
}

int libmodbus_tcp_master_demo(){
    rt_thread_t tid;
    tid = rt_thread_create("tcp_master_demo",
                           tcp_master_demo_thread, RT_NULL,
                           2048,
                           12, 10);
    if (tid != RT_NULL) rt_thread_startup(tid);
    return RT_EOK;
}

MSH_CMD_EXPORT(libmodbus_tcp_master_demo, libmodbus_tcp_master_demo)

#include <rtthread.h>
#include <rtdevice.h>
#include <modbus.h>
#include <sal_socket.h>

#define MAX_CLIENT_NUM  3
#define CLIENT_TIMEOUT  10

typedef struct
{
    int fd;
    rt_tick_t tick_timeout;
}client_session_t;

static void tcp_slave_demo_thread(void *param)
{
    int server_fd = -1;
    modbus_t *ctx = NULL;
    modbus_mapping_t *mb_mapping = NULL;
    client_session_t client_session[MAX_CLIENT_NUM];

    for (int i = 0; i < MAX_CLIENT_NUM; i++)
    {
        client_session[i].fd = -1;
        client_session[i].tick_timeout = rt_tick_get() + rt_tick_from_millisecond(CLIENT_TIMEOUT * 1000);
    }

    int max_fd = -1;
    fd_set readset;
    int rc;
    struct timeval select_timeout;
    select_timeout.tv_sec = 1;
    select_timeout.tv_usec = 0;

    ctx = modbus_new_tcp(RT_NULL, 1502, AF_INET);
    RT_ASSERT(ctx != RT_NULL);
    mb_mapping = modbus_mapping_new(MODBUS_MAX_READ_BITS, 0,
                                    MODBUS_MAX_READ_REGISTERS, 0);
    RT_ASSERT(mb_mapping != RT_NULL);

_mbtcp_start:
    server_fd = modbus_tcp_listen(ctx, 1);
    if (server_fd < 0)
        goto _mbtcp_restart;

    while (1)
    {
        max_fd = -1;
        FD_ZERO(&readset);
        FD_SET(server_fd, &readset);

        if(max_fd < server_fd)
            max_fd = server_fd;

        for (int i = 0; i < MAX_CLIENT_NUM; i++)
        {
            if(client_session[i].fd >= 0)
            {
                FD_SET(client_session[i].fd, &readset);
                if(max_fd < client_session[i].fd)
                    max_fd = client_session[i].fd;
            }
        }

        rc = select(max_fd + 1, &readset, RT_NULL, RT_NULL, &select_timeout);
        if(rc < 0)
        {
            goto _mbtcp_restart;
        }
        else if(rc > 0)
        {
            if(FD_ISSET(server_fd, &readset))
            {
                int client_sock_fd = modbus_tcp_accept(ctx, &server_fd);
                if(client_sock_fd >= 0)
                {
                    int index = -1;
                    for (int i = 0; i < MAX_CLIENT_NUM; i++)
                    {
                        if(client_session[i].fd < 0)
                        {
                            index = i;
                            break;
                        }
                    }
                    if(index >= 0)
                    {
                        client_session[index].fd = client_sock_fd;
                        client_session[index].tick_timeout = rt_tick_get() + rt_tick_from_millisecond(CLIENT_TIMEOUT * 1000);
                    }
                    else
                    {
                        close(client_sock_fd);
                    }
                }
            }

            for (int i = 0; i < MAX_CLIENT_NUM; i++)
            {
                if(client_session[i].fd >= 0)
                {
                    if(FD_ISSET(client_session[i].fd, &readset))
                    {
                        uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH];
                        modbus_set_socket(ctx, client_session[i].fd);

                        rc = modbus_receive(ctx, query);
                        if (rc > 0)
                        {
                            rc = modbus_reply(ctx, query, rc, mb_mapping);
                            if(rc < 0)
                            {
                                close(client_session[i].fd);
                                client_session[i].fd = -1;
                            }
                            else
                            {
                                client_session[i].tick_timeout = rt_tick_get() + rt_tick_from_millisecond(CLIENT_TIMEOUT * 1000);
                            }
                        }
                        else
                        {
                            close(client_session[i].fd);
                            client_session[i].fd = -1;
                        }
                    }
                }
            }
        }

        // 客户端超时未收到数据断开
        for(int i =0;i<MAX_CLIENT_NUM;i++)
        {
            if(client_session[i].fd >= 0)
            {
                //超时
                if((rt_tick_get() - client_session[i].tick_timeout) < (RT_TICK_MAX / 2))
                {
                    close(client_session[i].fd);
                    client_session[i].fd = -1;
                }
            }
        }
    }

_mbtcp_restart:
    if(server_fd >= 0)
    {
        close(server_fd);
        server_fd = -1;
    }

    for(int i =0;i<MAX_CLIENT_NUM;i++)
    {
        if(client_session[i].fd >= 0)
        {
            close(client_session[i].fd);
            client_session[i].fd = -1;
        }
    }

    rt_thread_mdelay(5000);
    goto _mbtcp_start;

    modbus_free(ctx);
}

int libmodbus_tcp_slave_demo(){
    rt_thread_t tid;
    tid = rt_thread_create("tcp_slave_demo",
                           tcp_slave_demo_thread, RT_NULL,
                           2048,
                           12, 10);
    if (tid != RT_NULL) rt_thread_startup(tid);
    return RT_EOK;
}

MSH_CMD_EXPORT(libmodbus_tcp_slave_demo, libmodbus_tcp_slave_demo)