[Raspberry Pi Pico C-SDK] Simple electronic compass using HMC5883L 3-axis digital compass

 介紹使用HMC5883L三軸數位羅盤，詳細內容如下列影片所示。

有關4-line serial TFT libarary請參閱：

[Raspberry Pi Pico (c-sdk)] Display: Ep 5 :TFT LCD 4-lines Serial(SPI) Driver -- A single Frame(128x160) takes only  11~12ms

成果影片

程式碼：

• CMakeLists.txt

# == DO NOT EDIT THE FOLLOWING LINES for the Raspberry Pi Pico VS Code Extension to work ==
if(WIN32)
    set(USERHOME $ENV{USERPROFILE})
else()
    set(USERHOME $ENV{HOME})
endif()
set(sdkVersion 2.1.1)
set(toolchainVersion 14_2_Rel1)
set(picotoolVersion 2.1.1)
set(picoVscode ${USERHOME}/.pico-sdk/cmake/pico-vscode.cmake)
if (EXISTS ${picoVscode})
    include(${picoVscode})
endif()
# ====================================================================================
# Generated Cmake Pico project file

cmake_minimum_required(VERSION 3.13)

set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)

# Initialise pico_sdk from installed location
# (note this can come from environment, CMake cache etc)
set(PICO_SDK_PATH "/home/duser/pico/pico-sdk")

set(PICO_BOARD pico CACHE STRING "Board type")

# Pull in Raspberry Pi Pico SDK (must be before project)
include(pico_sdk_import.cmake)

if (PICO_SDK_VERSION_STRING VERSION_LESS "1.4.0")
  message(FATAL_ERROR "Raspberry Pi Pico SDK version 1.4.0 (or later) required. Your version is ${PICO_SDK_VERSION_STRING}")
endif()

project(compass C CXX ASM)

# Initialise the Raspberry Pi Pico SDK
pico_sdk_init()

# Add executable. Default name is the project name, version 0.1

add_executable(compass compass.c )

pico_set_program_name(compass "compass")
pico_set_program_version(compass "0.1")

pico_enable_stdio_uart(compass 0)
pico_enable_stdio_usb(compass 1)

# Add the standard library to the build
target_link_libraries(compass
        pico_stdlib)

# Add the standard include files to the build
target_include_directories(compass PRIVATE
  ${CMAKE_CURRENT_LIST_DIR}
  ${CMAKE_CURRENT_LIST_DIR}/.. # for our common lwipopts or any other standard includes, if required
)

# Add any user requested libraries
target_link_libraries(compass 
        hardware_i2c
        hardware_dma
        )
add_subdirectory(pico_tft)
target_link_libraries( compass 
      pico_tft
      )

pico_add_extra_outputs(compass)

• compass.c

#include <stdio.h>
#include "stdlib.h"
#include "pico/stdlib.h"
#include "hardware/i2c.h"

#include "hardware/dma.h"
#include "hardware/pio.h"

#include "pico_tft.h"
#include "tft_string.h"
#include "fonts/font_fixedsys_mono_16.h"
#include "compass_img.h"
#include "string.h"
#include "registers.h"

#include "math.h"

#define I2C_PORT i2c0
#define I2C_SDA 16
#define I2C_SCL 17

#define DEVICE_ADDR   0x1E 

typedef struct _rotate_obj_t {
    uint8_t *srcimg;
    uint8_t *destimg;
    uint16_t width;
    uint16_t height;
    uint16_t angle;
} rotate_obj_t;


int16_t x_offset=-64;
int16_t z_offset= 76;

int main()
{
    uint8_t cmd_buf[4];
    uint8_t read_data[7];
    stdio_init_all();

    rotate_obj_t *rotate_img = (rotate_obj_t*) calloc(1, sizeof(rotate_obj_t));
    uint8_t *read_buff = (uint8_t*) calloc(TFT_WIDTH*TFT_HEIGHT*2, sizeof(uint8_t));  //frame buffer
    if (!read_buff) {
        printf("alloc memory error\n");
        return 0;
    }
     uint8_t *write_buff = (uint8_t*) calloc(TFT_WIDTH*TFT_HEIGHT*2, sizeof(uint8_t));  //frame buffer
    if (!write_buff) {
        printf("alloc memory error\n");
        return 0;
    }
    tft_init();
    tft_fill_rect(0,0, TFT_WIDTH, TFT_HEIGHT, 0xffff);

    // I2C Initialisation. Using it at 400Khz.
    i2c_init(I2C_PORT, 400*1000);
    
    gpio_set_function(I2C_SDA, GPIO_FUNC_I2C);
    gpio_set_function(I2C_SCL, GPIO_FUNC_I2C);
    gpio_pull_up(I2C_SDA);
    gpio_pull_up(I2C_SCL);


    // init 8-average, 15 Hz default, normal measurement
    cmd_buf[0] = 0x00;
    cmd_buf[1] = 0x70;
    i2c_write_blocking(i2c0, DEVICE_ADDR,cmd_buf, 2,true);
    cmd_buf[0] = 0x01;
    cmd_buf[1] = 0xa0; //0xa0
    i2c_write_blocking(i2c0, DEVICE_ADDR,cmd_buf, 2,true);
    
    int16_t x,y,z;
    double heading;

    memcpy(read_buff, image_data_compass, TFT_WIDTH*TFT_WIDTH*2);
    tft_rotate_image((uint16_t*)read_buff, (uint16_t*)write_buff, TFT_WIDTH, TFT_WIDTH, 90);
    tft_set_address_window (0, 0, TFT_WIDTH, TFT_WIDTH);
    tft_cmd(TFT_MEMORYWRITE, TFT_WIDTH*TFT_WIDTH*2,  (uint8_t*)write_buff);

    char buf_heading[10];
    while(1) {
        //Single-Measurement Mode (Default).
        cmd_buf[0] = 0x02;
        cmd_buf[1] = 0x01; //0x00
        i2c_write_blocking(i2c0, DEVICE_ADDR,cmd_buf, 2,false);
        sleep_ms(10);

        cmd_buf[0] = 0x03;
        i2c_write_blocking(i2c0, DEVICE_ADDR,cmd_buf, 1,false);    
        i2c_read_blocking(i2c0, DEVICE_ADDR, read_data, 6, false);

       
        x = ((uint16_t)read_data[0]) << 8 | read_data[1];
        z = ((uint16_t)read_data[2]) << 8 | read_data[3];
        y = ((uint16_t)read_data[4]) << 8 | read_data[5];

        
        printf("%d, %d, %d \n", x,y,z );  // print out for calibration           

        heading = atan2(x-x_offset,z-z_offset)*57.3; //180/PI

        if(heading < 0) heading+=360;
        
        //heading=360-heading; // N=0/360, E=90, S=180, W=270
        tft_rotate_image((uint16_t*)read_buff, (uint16_t*)write_buff, TFT_WIDTH, TFT_WIDTH, 360-heading);
        tft_set_address_window (0, 0, TFT_WIDTH, TFT_WIDTH);
        tft_cmd(TFT_MEMORYWRITE, TFT_WIDTH*TFT_WIDTH*2,  (uint8_t*)write_buff);
        sprintf(buf_heading, "%03.02f   ", heading);
        tft_draw_string_withbg(10, TFT_WIDTH+4, buf_heading, 0xf800, 0xffff, &font_fixedsys_mono_16);

        
    }

    return 0;
}

• compass_img.h:
  使用lcd-image-converter軟體產生。

[Raspberry Pi Pico W] MODBUS EP 3: Modbus TCP/RTU Gateway || Node-RED Modbus

 本文章介紹如何使用 nanoMODBUS 函式庫在 Raspberry Pi Pico W上實作 MODBUS TCP/RTU Gateway。使用 MODBUS TCP Master透過 Node-RED UI 控制兩個 Modbus RTU Slaves。

架構如下圖所示：

MODBUS TCP/RTU Gateway收到modbus tcp master(client) request 根據UintID轉送到相對應的MODUBS RTU Slave(msater)，Response依相反順序進行。

對應的code如下：

成果展示：

程式碼：

• CMakeLists.txt

# Generated Cmake Pico project file

cmake_minimum_required(VERSION 3.13)

set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

# Initialise pico_sdk from installed location
# (note this can come from environment, CMake cache etc)

# == DO NOT EDIT THE FOLLOWING LINES for the Raspberry Pi Pico VS Code Extension to work ==
if(WIN32)
    set(USERHOME $ENV{USERPROFILE})
else()
    set(USERHOME $ENV{HOME})
endif()
set(sdkVersion 2.1.0)
set(toolchainVersion 13_3_Rel1)
set(picotoolVersion 2.1.0)
set(picoVscode ${USERHOME}/.pico-sdk/cmake/pico-vscode.cmake)
if (EXISTS ${picoVscode})
    include(${picoVscode})
endif()
# ====================================================================================
set(PICO_BOARD pico_w CACHE STRING "Board type")

# Pull in Raspberry Pi Pico SDK (must be before project)
include(pico_sdk_import.cmake)

project(picow_modbus_gateway C CXX ASM)

# Initialise the Raspberry Pi Pico SDK
pico_sdk_init()

# Add executable. Default name is the project name, version 0.1

add_executable(picow_modbus_gateway picow_modbus_gateway.c 
                                    nanomodbus/nanomodbus.c
                                    picow_tcp_server/picow_tcp_server.c
                                    modbus_rtu_master/modbus_rtu_master.c
                                    modbus_tcp_client/modbus_tcp_client.c)

pico_set_program_name(picow_modbus_gateway "picow_modbus_gateway")
pico_set_program_version(picow_modbus_gateway "0.1")

# Modify the below lines to enable/disable output over UART/USB
pico_enable_stdio_uart(picow_modbus_gateway 0)
pico_enable_stdio_usb(picow_modbus_gateway 1)

# Add the standard library to the build
target_link_libraries(picow_modbus_gateway
        pico_stdlib)

# Add the standard include files to the build
target_include_directories(picow_modbus_gateway PRIVATE
  ${CMAKE_CURRENT_LIST_DIR}
)

# Add any user requested libraries
target_link_libraries(picow_modbus_gateway 
        pico_cyw43_arch_lwip_threadsafe_background
        pico_lwip_mdns
        )

pico_add_extra_outputs(picow_modbus_gateway)


  

• picow_modbus_gateway.c

#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/apps/mdns.h"
#include "picow_tcp_server/picow_tcp_server.h"
#include "nanomodbus/nanomodbus.h"
#include "lwip/pbuf.h"
#include "lwip/tcp.h"

#include "modbus_tcp_client/modbus_tcp_client.h"
#include "modbus_rtu_master/modbus_rtu_master.h"


/*
    MODBUS GATEWAY
    modbus tcp client <--> modbus tcp server
                                ^
                                |
                                v
                            modbus rtu client  <--> modbus rtu server
*/

int main()
{
    stdio_init_all();

    uart_setup(UART_ID);

//========== modbus rtu master(client) init ==========
    // nmbs_uart_read() and nmbs_uart_write() are implemented by the user 
    nmbs_platform_conf rtu_platform_conf;
    nmbs_platform_conf_create(&rtu_platform_conf);
    rtu_platform_conf.transport = NMBS_TRANSPORT_RTU;
    rtu_platform_conf.read = nmbs_uart_read;
    rtu_platform_conf.write = nmbs_uart_write;
 
    nmbs_error err = nmbs_client_create(&nmbs_rtu_master, &rtu_platform_conf);
    if (err != NMBS_ERROR_NONE) {
        fprintf(stderr, "Error creating modbus client\n");
        return 1;
    }
    // RTU: set read timeout and byte timeout
    nmbs_set_read_timeout(&nmbs_rtu_master, 2000);
    nmbs_set_byte_timeout(&nmbs_rtu_master, 2000);
// ============ modbus rtu master(client) init =============

// ====== Initialise the Wi-Fi chip =====
    if (cyw43_arch_init()) {
        printf("Wi-Fi init failed\n");
        return -1;
    }
    cyw43_gpio_set(&cyw43_state, CYW43_WL_GPIO_LED_PIN,false);
    
    // Enable wifi station
    cyw43_arch_enable_sta_mode();

    printf("Connecting to Wi-Fi...\n");
    if (cyw43_arch_wifi_connect_timeout_ms(SSID, PWD, CYW43_AUTH_WPA2_AES_PSK, 30000)) {
        printf("failed to connect.\n");
        return 1;
    } else {
        printf("Connected.\n");
        // Read the ip address in a human readable way
        uint8_t *ip_address = (uint8_t*)&(cyw43_state.netif[0].ip_addr.addr);
        printf("IP address %d.%d.%d.%d\n", ip_address[0], ip_address[1], ip_address[2], ip_address[3]);
    }
#if LWIP_MDNS_RESPONDER
    mdns_resp_init();
    uint8_t host_name[] = "picow_mb_gateway";
    if (mdns_resp_add_netif(netif_default, host_name)== ERR_OK)
    {
        printf("mDNS add successfully\n");
    } else {
        printf("mDNS failure\n");
    }
#endif
    picow_tcp_server_init();
    
//======= modbus tcp server(modbus server) init ======
    nmbs_platform_conf platform_conf;
    nmbs_platform_conf_create(&platform_conf);
    platform_conf.transport = NMBS_TRANSPORT_TCP;
    platform_conf.read = nmbs_transport_read;
    platform_conf.write = nmbs_transport_write;

    extern MB_SERVER_T *modbus_tcp_server;
    platform_conf.arg = modbus_tcp_server;
    
    nmbs_callbacks callbacks;
    nmbs_callbacks_create(&callbacks);
    callbacks.read_coils = handle_tcp_read_coils;
    callbacks.read_discrete_inputs = handle_tcp_read_discrete_inputs;
    callbacks.write_single_coil = handle_tcp_write_single_coil;
    callbacks.write_multiple_coils = handle_tcp_write_multiple_coils;
    callbacks.read_holding_registers = handler_tcp_read_holding_registers;
    callbacks.write_multiple_registers = handle_tcp_write_multiple_registers;
    callbacks.write_single_register = handle_tcp_write_single_register;
    callbacks.read_file_record = handle_tcp_read_file_record;
    callbacks.write_file_record = handle_tcp_write_file_record;
    callbacks.arg = modbus_tcp_server;
    
    err = nmbs_server_create(&nmbs_gateway_tcp, 0, &platform_conf, &callbacks);
    if (err != NMBS_ERROR_NONE) {
        fprintf(stderr, "Error creating modbus server\n");
        return 1;
    }

    // Set only the polling timeout. Byte timeout will be handled by the TCP connection
    nmbs_set_read_timeout(&nmbs_gateway_tcp, 2000);
//======= modbus tcp server(modbus server) init ======
    
    printf("Modbus TCP server started\n");
    cyw43_gpio_set(&cyw43_state, CYW43_WL_GPIO_LED_PIN,true);
//========================

    while (true) {
        nmbs_server_poll(&nmbs_gateway_tcp);
        
#if PICO_CYW43_ARCH_POLL
        cyw43_arch_poll();
         cyw43_arch_wait_for_work_until(make_timeout_time_ms(1000));
#else
        tight_loop_contents();
#endif
    }
}

  

picow_tcp_server:

• picow_tcp_server.c

#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"

#include "nanomodbus/nanomodbus.h"

#include "lwip/pbuf.h"
#include "lwip/tcp.h"

#include "picow_tcp_server.h"
#include "modbus_tcp_client/modbus_tcp_client.h"

MB_SERVER_T *modbus_tcp_server;


static err_t tcp_client_close(struct tcp_pcb *client_pcb) {
    err_t err = ERR_OK;
    if (client_pcb != NULL) {
        tcp_arg(client_pcb, NULL);
        tcp_poll(client_pcb, NULL, 0);
        tcp_sent(client_pcb, NULL);
        tcp_recv(client_pcb, NULL);
        tcp_err(client_pcb, NULL);
        err = tcp_close(client_pcb);
        if (err != ERR_OK) {
            DEBUG_printf("close failed %d, calling abort\n", err);
            tcp_abort(client_pcb);
            err = ERR_ABRT;
        }
        client_pcb = NULL;
    }

    return err;
}

static err_t tcp_server_close(void *arg) {
    MB_SERVER_T *state = (MB_SERVER_T*)arg;
    err_t err = ERR_OK;

    if (state->client_pcb != NULL) {
        tcp_arg(state->client_pcb, NULL);
        tcp_poll(state->client_pcb, NULL, 0);
        tcp_sent(state->client_pcb, NULL);
        tcp_recv(state->client_pcb, NULL);
        tcp_err(state->client_pcb, NULL);
        err = tcp_close(state->client_pcb);
        if (err != ERR_OK) {
            DEBUG_printf("close failed %d, calling abort\n", err);
            tcp_abort(state->client_pcb);
            err = ERR_ABRT;
        }
        state->client_pcb = NULL;
    }
    if (state->server_pcb) {
        tcp_arg(state->server_pcb, NULL);
        tcp_close(state->server_pcb);
        state->server_pcb = NULL;
    }
    return err;
}

static err_t tcp_server_sent(void *arg, struct tcp_pcb *tpcb, u16_t len) {
    MB_SERVER_T *state = (MB_SERVER_T*)arg;
    return ERR_OK;
}

err_t tcp_server_send_data(void *arg, struct tcp_pcb *tpcb)
{
    MB_SERVER_T *state = (MB_SERVER_T*)arg;

    return ERR_OK;
}

err_t tcp_server_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) {
    MB_SERVER_T *state = (MB_SERVER_T*)arg;
    state->client_pcb = tpcb;
    static modbus_queue_t temp_recv;
    if (!p) {
        tcp_client_close(tpcb);
        tcp_abort(tpcb);
        return ERR_ABRT;
    }

    if (p->tot_len > 0) {
        //DEBUG_printf("tcp_client_recv %d err %d\n", p->tot_len, err);

        // Receive the buffer 
        uint16_t recv_len = pbuf_copy_partial(p, temp_recv.buffer, p->tot_len, 0); 
        temp_recv.buffer_len = recv_len;
        //queue_add_blocking(&state->recv_queue, &temp_recv);
    if (!queue_try_add(&state->recv_queue, &temp_recv)) {
        printf("\n=======\n\nbusy\n-------\n");
        return ERR_INPROGRESS;
    }

        tcp_recved(tpcb, recv_len);
//Debug
        printf("---------recv---------\n");
        for (int i =0; i < recv_len; i++) {
            printf("%02x ",temp_recv.buffer[i]);
        }
        printf("\n-------------\n");
        
    }
    pbuf_free(p);

    nmbs_server_poll(&nmbs_gateway_tcp); // process modbus request

    return ERR_OK;


}

static err_t tcp_server_poll(void *arg, struct tcp_pcb *tpcb) {

    //nmbs_error err = nmbs_server_poll(&nmbs);   // process modbus request while tpc idle
    //if (err != NMBS_ERROR_NONE) {
    //    printf("Error on modbus connection - %s\n", nmbs_strerror(err));
        // In a more complete example, we would handle this error by checking its nmbs_error value
    //}
       
    return ERR_OK;
}

static void tcp_server_err(void *arg, err_t err) {
    if (err != ERR_ABRT) {
        DEBUG_printf("tcp_client_err_fn %d\n", err);
    }
}

static err_t tcp_server_accept(void *arg, struct tcp_pcb *client_pcb, err_t err) {
    MB_SERVER_T *state = (MB_SERVER_T*)arg;
    if (err != ERR_OK || client_pcb == NULL) {
        DEBUG_printf("Failure in accept\n");
        return err;
    }
    DEBUG_printf("Client connected\n");

    state->client_pcb = client_pcb;
    
    tcp_arg(state->client_pcb, state);
    tcp_sent(state->client_pcb, tcp_server_sent);
    tcp_recv(state->client_pcb, tcp_server_recv);
    tcp_poll(state->client_pcb, tcp_server_poll, POLL_TIME_S * 2);
    tcp_err(state->client_pcb, tcp_server_err);

    return ERR_OK;
}

static bool tcp_server_open(void *arg) {
    MB_SERVER_T *state = (MB_SERVER_T*)arg;
    DEBUG_printf("Starting server at %s on port %u\n", ip4addr_ntoa(netif_ip4_addr(netif_list)), MODBUS_TCP_PORT);

    struct tcp_pcb *pcb = tcp_new_ip_type(IPADDR_TYPE_ANY);
    if (!pcb) {
        DEBUG_printf("failed to create pcb\n");
        return false;
    }

    err_t err = tcp_bind(pcb, NULL, MODBUS_TCP_PORT);
    //err_t err = tcp_bind(pcb, netif_ip4_addr(netif_list), MODBUS_TCP_PORT);
    if (err) {
        DEBUG_printf("failed to bind to port %u\n", MODBUS_TCP_PORT);
        return false;
    }

    state->server_pcb = tcp_listen_with_backlog(pcb, 1);
    if (!state->server_pcb) {
        DEBUG_printf("failed to listen\n");
        if (pcb) {
            tcp_close(pcb);
        }
        return false;
    }

    tcp_arg(state->server_pcb, state);
    tcp_accept(state->server_pcb, tcp_server_accept);

    return true;
}

void picow_tcp_server_init(void) {
    /* modbus TCP server  init*/
    modbus_tcp_server = calloc(1, sizeof(MB_SERVER_T));
    if (!modbus_tcp_server) {
        return;
    }

    queue_init(&modbus_tcp_server->recv_queue, sizeof(modbus_queue_t), 4);

    if (!tcp_server_open(modbus_tcp_server)) {
        DEBUG_printf("tcp server open error\n");
        return;
    }

    return;

}


  

• picow_tcp_server.h

#define MODBUS_TCP_PORT 502            //MODBUS default port
#define DEBUG_printf printf
#define POLL_TIME_S 1


#define SSID "your-SSID"
#define PWD "your-PASSWORD"

#include "pico/util/queue.h"

typedef struct __modbus_queue_t{
    uint8_t buffer[260];
    uint16_t buffer_len;
} modbus_queue_t;

typedef struct TCP_CLIENT_T_ {
    struct tcp_pcb *server_pcb;
    struct tcp_pcb *client_pcb;
    bool connected;
    bool dns_found;
    queue_t recv_queue;
    uint8_t server_host_name[256];
    uint16_t recv_count;
    uint16_t start_index;
    uint16_t queue_left;
    modbus_queue_t temp_recv;
} MB_SERVER_T;

void picow_tcp_server_init(void);
  

modbus_tcp_client:

• modbus_tcp_client.c

#include "stdio.h"
#include "pico/stdlib.h"
#include "modbus_tcp_client.h"


#include "lwip/pbuf.h"
#include "lwip/tcp.h"
#include "picow_tcp_server/picow_tcp_server.h"
#include "modbus_rtu_master/modbus_rtu_master.h"

//#define _DEBUG
#ifdef _DEBUG
#define DEBUG_PRINT(...) printf(__VA_ARGS__)
#else
#define DEBUG_PRINT(...) (void) (0)
#endif

nmbs_t nmbs_gateway_tcp;

// A single nmbs_bitfield variable can keep 2000 coils
bool terminate = false;
nmbs_bitfield server_coils[MAX_CLIENT_DEVICES] = {0};
uint16_t server_registers[MAX_CLIENT_DEVICES][REGS_ADDR_MAX] = {0};
uint16_t server_file[MAX_CLIENT_DEVICES][FILE_SIZE_MAX];


#define UNUSED_PARAM(x) ((x) = (x))

void sighandler(int s) {
    UNUSED_PARAM(s);
    terminate = true;
}

nmbs_error handle_tcp_read_coils(uint16_t address, uint16_t quantity, nmbs_bitfield coils_out, uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);
    MB_SERVER_T * mb = (MB_SERVER_T*) arg;


    if (address + quantity > COILS_ADDR_MAX + 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    nmbs_set_destination_rtu_address(&nmbs_rtu_master, unit_id);
    nmbs_error err = nmbs_read_coils(&nmbs_rtu_master, address, quantity, coils_out); 
    if (err != NMBS_ERROR_NONE) {
        DEBUG_printf("Error info(read coils): unit_id:%d, %s\n", unit_id, 
                    nmbs_strerror(err));
        return err;
    }    
     
    for (int i = 0; i < quantity; i++) {
        nmbs_bitfield_write(server_coils[unit_id], address + i, nmbs_bitfield_read(coils_out, i));
    }
  
    return NMBS_ERROR_NONE;
}

nmbs_error handle_tcp_read_discrete_inputs(uint16_t address, uint16_t quantity, nmbs_bitfield coils_out, uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (address + quantity > COILS_ADDR_MAX + 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    nmbs_set_destination_rtu_address(&nmbs_rtu_master, unit_id);
    nmbs_error err = nmbs_read_discrete_inputs(&nmbs_rtu_master, address, quantity, coils_out);
    if (err != NMBS_ERROR_NONE) {
        DEBUG_printf("Error info(read discrete coils): unit_id:%d, %s\n", unit_id, 
                    nmbs_strerror(err));
        return err;
    }
     
    for (int i = 0; i < quantity; i++) {
        nmbs_bitfield_write(server_coils[unit_id], address + i, nmbs_bitfield_read(coils_out, i));
    }

    return NMBS_ERROR_NONE;
}

nmbs_error handle_tcp_write_single_coil(uint16_t address, bool value, uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (address > COILS_ADDR_MAX )
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    nmbs_set_destination_rtu_address(&nmbs_rtu_master, unit_id);
    nmbs_error err = nmbs_write_single_coil(&nmbs_rtu_master, address, value);
    if (err != NMBS_ERROR_NONE) {
        DEBUG_printf("Error info(write single coil): unit_id:%d, %s\n", unit_id, 
                    nmbs_strerror(err));
        return err;
    }

    // Write coils values to our server_coils
    nmbs_bitfield_write(server_coils[unit_id], address, value);

    return NMBS_ERROR_NONE;
}

nmbs_error handle_tcp_write_multiple_coils(uint16_t address, uint16_t quantity, const nmbs_bitfield coils, uint8_t unit_id,
                                       void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (address + quantity > COILS_ADDR_MAX + 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    nmbs_set_destination_rtu_address(&nmbs_rtu_master, unit_id);
    nmbs_error err = nmbs_write_multiple_coils(&nmbs_rtu_master, address, quantity, coils);
    if (err != NMBS_ERROR_NONE) {
        DEBUG_printf("Error info(write mulitple coils): unit_id:%d, %s\n", unit_id, 
                    nmbs_strerror(err));
        uart_reset(UART_ID);
        return err;
    }

    // Write coils values to our server_coils
    for (int i = 0; i < quantity; i++) {
        nmbs_bitfield_write(server_coils[unit_id], address + i, nmbs_bitfield_read(coils, i));
    }

    return NMBS_ERROR_NONE;
}


nmbs_error handler_tcp_read_holding_registers(uint16_t address, uint16_t quantity, uint16_t* registers_out, uint8_t unit_id,
                                          void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (address + quantity > REGS_ADDR_MAX + 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    nmbs_set_destination_rtu_address(&nmbs_rtu_master, unit_id);
    nmbs_error err = nmbs_read_holding_registers(&nmbs_rtu_master, address, quantity, registers_out);
    // Read our registers values into registers_out
    if (err != NMBS_ERROR_NONE) {
        DEBUG_printf("Error info(read holding regiseters): unit_id:%d, %s\n", unit_id, 
                    nmbs_strerror(err));
        return err;
    }

    for (int i = 0; i < quantity; i++)
        server_registers[unit_id][address + i] = registers_out[i];

    return NMBS_ERROR_NONE;
}

nmbs_error handle_tcp_write_single_register(uint16_t address, uint16_t value, uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (address > REGS_ADDR_MAX)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;
    
    nmbs_set_destination_rtu_address(&nmbs_rtu_master, unit_id);
    nmbs_error err = nmbs_write_single_register(&nmbs_rtu_master, address, value);
    if (err != NMBS_ERROR_NONE) {
        DEBUG_printf("Error info(write single register): unit_id:%d, %s\n", unit_id, 
                    nmbs_strerror(err));
        return err;
    }
    // Write registers values to our server_registers

        server_registers[unit_id][address] = value;

    return NMBS_ERROR_NONE;
}

nmbs_error handle_tcp_write_multiple_registers(uint16_t address, uint16_t quantity, const uint16_t* registers,
                                           uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (address + quantity > REGS_ADDR_MAX + 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;
    
    nmbs_set_destination_rtu_address(&nmbs_rtu_master, unit_id);
    nmbs_error err = nmbs_write_multiple_registers(&nmbs_rtu_master, address, quantity, registers);
    if (err != NMBS_ERROR_NONE) {
        DEBUG_printf("Error info(write multiple registers): unit_id:%d, %s\n", unit_id, 
                    nmbs_strerror(err));
        return err;
    }

    // Write registers values to our server_registers
    for (int i = 0; i < quantity; i++)
        server_registers[unit_id][address + i] = registers[i];

    return NMBS_ERROR_NONE;
}

nmbs_error handle_tcp_read_file_record(uint16_t file_number, uint16_t record_number, uint16_t* registers, uint16_t count,
                                   uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (file_number != 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    if ((record_number + count) > FILE_SIZE_MAX)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;
    
    nmbs_set_destination_rtu_address(&nmbs_rtu_master, unit_id);
    nmbs_error err = nmbs_read_file_record(&nmbs_rtu_master, file_number, record_number, registers, count);
    if (err != NMBS_ERROR_NONE) {
        DEBUG_printf("Error info: unit_id:%d, %s\n", unit_id, 
                    nmbs_strerror(err));
        return err;
    }

    memcpy(registers, server_file[unit_id] + record_number, count * sizeof(uint16_t));

    return NMBS_ERROR_NONE;
}


nmbs_error handle_tcp_write_file_record(uint16_t file_number, uint16_t record_number, const uint16_t* registers,
                                    uint16_t count, uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (file_number != 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    if ((record_number + count) > FILE_SIZE_MAX)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    nmbs_set_destination_rtu_address(&nmbs_rtu_master, unit_id);
    nmbs_error err = nmbs_write_file_record(&nmbs_rtu_master, file_number, record_number, registers, count);
    if (err != NMBS_ERROR_NONE) {
        DEBUG_printf("Error info: unit_id:%d, %s\n", unit_id, 
                    nmbs_strerror(err));
        return err;
    }

    memcpy(server_file[unit_id] + record_number, registers, count * sizeof(uint16_t));

    return NMBS_ERROR_NONE;
}

int32_t nmbs_transport_read(uint8_t* buf, uint16_t count, int32_t timeout_ms, void* arg) {
    MB_SERVER_T *state=(MB_SERVER_T*) arg;
 
    uint16_t loop_count = 0;

    if (state->queue_left == 0) {
        while (queue_is_empty(&state->recv_queue) && loop_count < 20) {           
            loop_count++;
            busy_wait_ms(50);
        }
        if (!queue_try_remove(&(state->recv_queue), &state->temp_recv))  {
                return 0;
        } else {
            DEBUG_PRINT("\t\t\t\t---loop count:%d\n", loop_count);
        }
        state->queue_left = state->temp_recv.buffer_len;
    }
   
    state->recv_count = state->queue_left <= count ? state->queue_left : count;
    state->start_index = state->temp_recv.buffer_len-state->queue_left;
    for (int i=0; i < state->recv_count; i++) buf[i] = state->temp_recv.buffer[state->start_index+i];

    state->queue_left = state->queue_left-state->recv_count;

    //Debug
#ifdef _DEBUG
    DEBUG_PRINT("\n=====transport read:%d:%d\n", count, state->temp_recv.buffer_len);
    for (int i=0; i < state->recv_count; i++) {
        DEBUG_PRINT("%02x ", buf[i]);
    }
    DEBUG_PRINT("\n==\n");
#endif
    return state->recv_count;
}

int32_t nmbs_transport_write(const uint8_t* buf, uint16_t count, int32_t timeout_ms, void* arg) {
    MB_SERVER_T *state = (MB_SERVER_T*)arg;

    // Debug
#ifdef _DEBUG
    DEBUG_PRINT("====\nnmbs_transport_write count:%d\n", count);
    for (int i=0; i < count;i++) {
        DEBUG_PRINT("%02x ", buf[i]);
    }
    DEBUG_PRINT("\n====\n");
#endif
    err_t err = tcp_write(state->client_pcb, buf, count, 0 /*TCP_WRITE_FLAG_COPY*/);
    if (err != ERR_OK) 
    {
        //tcp_abort(state->tcp_pcb);
        DEBUG_PRINT("tcp_write error:%d:%d\n", err, tcp_sndbuf(state->client_pcb)); 
        return 0;
    }

    err = tcp_output(state->client_pcb);
    if (err != ERR_OK) 
    {
        DEBUG_PRINT("%s:tcp_output:%d\n", state->server_host_name, err); 
        return 0;
    }

    return count;
}

  

• modbus_tcp_client.h

#ifndef __MODBUS_GATEWAY_TCP_CLIENT__
#define __MODBUS_GATEWAY_TCP_CLIENT__

#include "nanomodbus/nanomodbus.h"

extern nmbs_t nmbs_gateway_tcp;

nmbs_error handle_tcp_read_coils(uint16_t address, uint16_t quantity, nmbs_bitfield coils_out, uint8_t unit_id, void* arg);
nmbs_error handle_tcp_read_discrete_inputs(uint16_t address, uint16_t quantity, nmbs_bitfield coils_out, uint8_t unit_id, void* arg);
nmbs_error handle_tcp_write_single_coil(uint16_t address, bool value, uint8_t unit_id, void* arg);
nmbs_error handle_tcp_write_multiple_coils(uint16_t address, uint16_t quantity, const nmbs_bitfield coils, uint8_t unit_id, void* arg);
nmbs_error handler_tcp_read_holding_registers(uint16_t address, uint16_t quantity, uint16_t* registers_out, uint8_t unit_id, void* arg);
nmbs_error handle_tcp_write_single_register(uint16_t address, uint16_t value, uint8_t unit_id, void* arg);
nmbs_error handle_tcp_write_multiple_registers(uint16_t address, uint16_t quantity, const uint16_t* registers,
                                           uint8_t unit_id, void* arg);
nmbs_error handle_tcp_read_file_record(uint16_t file_number, uint16_t record_number, uint16_t* registers, uint16_t count,
                                   uint8_t unit_id, void* arg);
nmbs_error handle_tcp_write_file_record(uint16_t file_number, uint16_t record_number, const uint16_t* registers,
                                    uint16_t count, uint8_t unit_id, void* arg);                                  
int32_t nmbs_transport_read(uint8_t* buf, uint16_t count, int32_t byte_timeout_ms, void* arg);
int32_t nmbs_transport_write(const uint8_t* buf, uint16_t count, int32_t byte_timeout_ms,void* arg);


#endif 
  

modbus_rtu_master:

• modbus_rtu_master.c

#include "stdio.h"
#include "pico/stdlib.h"
#include "modbus_rtu_master.h"

nmbs_t nmbs_rtu_master;

int32_t nmbs_uart_read(uint8_t* buf, uint16_t count, int32_t byte_timeout_ms, void* arg){
    uint64_t start_time = time_us_64();
    int32_t bytes_read = 0;
    uint64_t timeout_us = (uint64_t) byte_timeout_ms * 1000;
    while (time_us_64() - start_time < timeout_us && bytes_read < count) {
        if (uart_is_readable(UART_ID)) {
            buf[bytes_read++] = uart_getc(UART_ID);
            start_time = time_us_64();    // Reset start time after a successful read
        }
    }
    
    return bytes_read;    
}

int32_t nmbs_uart_write(const uint8_t* buf, uint16_t count, int32_t byte_timeout_ms, void* arg) {
    uart_write_blocking(UART_ID, buf, count);

    return count;
}

void uart_reset(uart_inst_t* uart) {
    uart_deinit(uart);
    uart_setup(uart);
}

void uart_setup(uart_inst_t* uart) {
    // Set up our UART
    uart_init(uart, BAUD_RATE);

    gpio_set_function(UART_TX_PIN, GPIO_FUNC_UART);
    gpio_set_function(UART_RX_PIN, GPIO_FUNC_UART);

    int __unused actual = uart_set_baudrate(UART_ID, BAUD_RATE);
    uart_set_hw_flow(UART_ID, false, false);
    uart_set_format(UART_ID, DATA_BITS, STOP_BITS, PARITY);
    uart_set_fifo_enabled(UART_ID, false);
}
  

• modbus_rtu_master.h

#ifndef __MODBUS_GATEWAY_RTU_MASTER__
#define __MODBUS_GATEWAY_RTU_MASTER__

#include "nanomodbus/nanomodbus.h"

// UART defines
#define UART_ID uart1
#define UART_TX_PIN 4
#define UART_RX_PIN 5

#define BAUD_RATE       115200
#define DATA_BITS       8
#define STOP_BITS       1
#define PARITY          UART_PARITY_EVEN


// The data model of this sever will support coils addresses 0 to 100 and registers addresses from 0 to 32
#define COILS_ADDR_MAX      100
#define REGS_ADDR_MAX       32
#define FILE_SIZE_MAX       32
#define MAX_CLIENT_DEVICES  64

extern nmbs_t nmbs_rtu_master;


int32_t nmbs_uart_read(uint8_t* buf, uint16_t count, int32_t byte_timeout_ms, void* arg);
int32_t nmbs_uart_write(const uint8_t* buf, uint16_t count, int32_t byte_timeout_ms, void* arg);
void uart_reset(uart_inst_t* uart);
void uart_setup(uart_inst_t* uart);
#endif
  

nanoMODBUS:

 原始library起參閱https://github.com/debevv/nanoMODBUS

在本文章專案中作以下修改部份程式碼：

Node-RED Modbus client:

• flow:
  
  
  
  
  
• flow code:

[
    {
        "id": "48fad0c0f57cea35",
        "type": "tab",
        "label": "Flow 1",
        "disabled": false,
        "info": "",
        "env": []
    },
    {
        "id": "67287decfe7536cf",
        "type": "ui_colour_picker",
        "z": "48fad0c0f57cea35",
        "name": "",
        "label": "Color of LED",
        "group": "fc04be05304743a6",
        "format": "rgb",
        "outformat": "object",
        "showSwatch": true,
        "showPicker": false,
        "showValue": false,
        "showHue": true,
        "showAlpha": false,
        "showLightness": false,
        "square": "true",
        "dynOutput": "false",
        "order": 2,
        "width": 0,
        "height": 0,
        "passthru": false,
        "topic": "color",
        "topicType": "str",
        "className": "",
        "x": 510,
        "y": 40,
        "wires": [
            [
                "e50739a98c836bc2"
            ]
        ]
    },
    {
        "id": "730e5141782e4353",
        "type": "ui_slider",
        "z": "48fad0c0f57cea35",
        "name": "",
        "label": "num 0f Leds",
        "tooltip": "",
        "group": "fc04be05304743a6",
        "order": 3,
        "width": 0,
        "height": 0,
        "passthru": false,
        "outs": "all",
        "topic": "leds",
        "topicType": "str",
        "min": 0,
        "max": 10,
        "step": 1,
        "className": "",
        "x": 530,
        "y": 140,
        "wires": [
            [
                "945a43328cae473b"
            ]
        ]
    },
    {
        "id": "850f63e35b7c0dd6",
        "type": "function",
        "z": "48fad0c0f57cea35",
        "name": "Modbus Uint 2",
        "func": "var regs = [4];\nregs[0] = flow.get('color_red');\nregs[1] = flow.get('color_green');\nregs[2] = flow.get('color_blue');\nregs[3] = flow.get('num_leds');\nmsg.payload = {value: regs, 'fc': 16, 'unitid': 2, 'address': 0, 'quantity': 4 };\nreturn msg;\n",
        "outputs": 1,
        "timeout": 0,
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 900,
        "y": 80,
        "wires": [
            [
                "0b897cabd78f207b"
            ]
        ]
    },
    {
        "id": "e50739a98c836bc2",
        "type": "change",
        "z": "48fad0c0f57cea35",
        "name": "set flow color",
        "rules": [
            {
                "t": "set",
                "p": "color_red",
                "pt": "flow",
                "to": "payload.r",
                "tot": "msg"
            },
            {
                "t": "set",
                "p": "color_green",
                "pt": "flow",
                "to": "payload.g",
                "tot": "msg"
            },
            {
                "t": "set",
                "p": "color_blue",
                "pt": "flow",
                "to": "payload.b",
                "tot": "msg"
            }
        ],
        "action": "",
        "property": "",
        "from": "",
        "to": "",
        "reg": false,
        "x": 710,
        "y": 40,
        "wires": [
            [
                "850f63e35b7c0dd6"
            ]
        ]
    },
    {
        "id": "945a43328cae473b",
        "type": "change",
        "z": "48fad0c0f57cea35",
        "name": "",
        "rules": [
            {
                "t": "set",
                "p": "num_leds",
                "pt": "flow",
                "to": "payload",
                "tot": "msg"
            }
        ],
        "action": "",
        "property": "",
        "from": "",
        "to": "",
        "reg": false,
        "x": 710,
        "y": 140,
        "wires": [
            [
                "850f63e35b7c0dd6"
            ]
        ]
    },
    {
        "id": "0b897cabd78f207b",
        "type": "modbus-flex-write",
        "z": "48fad0c0f57cea35",
        "name": "",
        "showStatusActivities": false,
        "showErrors": false,
        "showWarnings": true,
        "server": "54922a4357ba259d",
        "emptyMsgOnFail": false,
        "keepMsgProperties": false,
        "delayOnStart": false,
        "startDelayTime": "",
        "x": 1090,
        "y": 260,
        "wires": [
            [
                "24a8a58f01fcf5cc",
                "00a3c1cedc235bc8"
            ],
            []
        ]
    },
    {
        "id": "24a8a58f01fcf5cc",
        "type": "modbus-response",
        "z": "48fad0c0f57cea35",
        "name": "",
        "registerShowMax": 20,
        "x": 1130,
        "y": 160,
        "wires": []
    },
    {
        "id": "40e24a450a247c58",
        "type": "ui_button",
        "z": "48fad0c0f57cea35",
        "name": "Gate",
        "group": "fc04be05304743a6",
        "order": 8,
        "width": 2,
        "height": 1,
        "passthru": false,
        "label": "{{lbl}}",
        "tooltip": "",
        "color": "",
        "bgcolor": "{{background}}",
        "className": "",
        "icon": "{{myicon}}",
        "payload": "u1_coil0",
        "payloadType": "flow",
        "topic": "addr0",
        "topicType": "str",
        "x": 570,
        "y": 240,
        "wires": [
            [
                "c24f886f7213b046"
            ]
        ]
    },
    {
        "id": "5654c6c9dbd8c887",
        "type": "function",
        "z": "48fad0c0f57cea35",
        "name": "Modbus Uint 1",
        "func": "if (msg.address == 0)\n    msg.payload = {value: msg.payload, 'fc': 15, 'unitid': 1, 'address': msg.address, 'quantity': msg.quantity };\nif (msg.address == 1)\n    msg.payload = {value: msg.payload, 'fc': 5, 'unitid': 1, 'address': msg.address, 'quantity': msg.quantity };\nreturn msg;\n",
        "outputs": 1,
        "timeout": 0,
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 900,
        "y": 320,
        "wires": [
            [
                "0b897cabd78f207b"
            ]
        ]
    },
    {
        "id": "c24f886f7213b046",
        "type": "function",
        "z": "48fad0c0f57cea35",
        "name": "Uint 1",
        "func": "var newmsg={};\n\nif (msg.payload == true) {\n    if (msg.topic == 'addr0') {\n        newmsg.lbl = 'CLOSE';\n        newmsg.background=\"magenta\";\n    }\n    else {\n        newmsg.lbl = \"OFF\";\n        newmsg.background=\"red\";\n    }\n    newmsg.myicon = 'fa-toggle-off';\n\n    \n} else { \n    if (msg.topic == 'addr0') {\n        newmsg.lbl='OPEN';\n        newmsg.background='lightblue';\n    }\n    else {\n        newmsg.lbl = 'ON';\n        newmsg.background='blue';\n    }\n    newmsg.myicon = 'fa-toggle-on';\n    \n}\nnewmsg.topic = msg.topic;\nlet address =2;\nif (newmsg.topic == 'addr0') {\n    address =0;\n    //newmsg.payload={};\n    flow.set('u1_coil0', !msg.payload);\n    flow.set('u1_coil1', !msg.payload);\n    newmsg.payload = [msg.payload, msg.payload];\n    newmsg.quantity = 2;\n}\nif (newmsg.topic == 'addr1') {\n    address =1;\n    flow.set('u1_coil1', !msg.payload);\n    newmsg.payload=msg.payload;\n    newmsg.quantity = 1;\n}\nnewmsg.address=address;\n\nreturn newmsg;",
        "outputs": 1,
        "timeout": 0,
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 710,
        "y": 320,
        "wires": [
            [
                "5654c6c9dbd8c887",
                "b090ab4f179755b5"
            ]
        ]
    },
    {
        "id": "3009c8f5180b8b48",
        "type": "ui_button",
        "z": "48fad0c0f57cea35",
        "name": "Light",
        "group": "fc04be05304743a6",
        "order": 12,
        "width": 2,
        "height": 1,
        "passthru": false,
        "label": "{{lbl}}",
        "tooltip": "",
        "color": "",
        "bgcolor": "{{background}}",
        "className": "",
        "icon": "{{myicon}}",
        "payload": "u1_coil1",
        "payloadType": "flow",
        "topic": "addr1",
        "topicType": "str",
        "x": 570,
        "y": 420,
        "wires": [
            [
                "c24f886f7213b046"
            ]
        ]
    },
    {
        "id": "b090ab4f179755b5",
        "type": "switch",
        "z": "48fad0c0f57cea35",
        "name": "toggle",
        "property": "topic",
        "propertyType": "msg",
        "rules": [
            {
                "t": "eq",
                "v": "addr0",
                "vt": "str"
            },
            {
                "t": "eq",
                "v": "addr1",
                "vt": "str"
            }
        ],
        "checkall": "false",
        "repair": false,
        "outputs": 2,
        "x": 430,
        "y": 360,
        "wires": [
            [
                "deb6e9852981cbe7"
            ],
            [
                "ea4d168a958d4731"
            ]
        ]
    },
    {
        "id": "7fcff809d9501142",
        "type": "modbus-getter",
        "z": "48fad0c0f57cea35",
        "name": "Uint1 FC:1",
        "showStatusActivities": false,
        "showErrors": false,
        "showWarnings": true,
        "logIOActivities": false,
        "unitid": "1",
        "dataType": "Coil",
        "adr": "0",
        "quantity": "2",
        "server": "54922a4357ba259d",
        "useIOFile": false,
        "ioFile": "",
        "useIOForPayload": false,
        "emptyMsgOnFail": false,
        "keepMsgProperties": false,
        "delayOnStart": false,
        "startDelayTime": "",
        "x": 170,
        "y": 340,
        "wires": [
            [
                "78865a9a77ef7a00",
                "cf34a46dd051bf77"
            ],
            []
        ]
    },
    {
        "id": "78865a9a77ef7a00",
        "type": "function",
        "z": "48fad0c0f57cea35",
        "name": "get coil 0 init value",
        "func": "var newmsg={};\nflow.set('u1_coil0',!msg.payload[0]);\n\nnewmsg.payload=msg.payload[0];\n\nif (msg.payload[0] == false) {\n    newmsg.lbl = \"OPEN\";\n    newmsg.myicon='fa-toggle-on';\n    newmsg.background='lightblue';\n} else {\n    newmsg.lbl = 'CLOSE';\n    newmsg.myicon='fa-toggle-off';\n    newmsg.background='magenta';\n}\nreturn newmsg;",
        "outputs": 1,
        "timeout": 0,
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 290,
        "y": 240,
        "wires": [
            [
                "deb6e9852981cbe7"
            ]
        ]
    },
    {
        "id": "cf34a46dd051bf77",
        "type": "function",
        "z": "48fad0c0f57cea35",
        "name": "get coil 1 init value",
        "func": "var newmsg={};\nflow.set('u1_coil1',!msg.payload[1]);\n\nnewmsg.payload=msg.payload[1];\n\nif (msg.payload[1] == false) {\n    newmsg.lbl = \"ON\";\n    newmsg.background='blue';\n    newmsg.myicon='fa-toggle-on';\n} else {\n    newmsg.lbl = 'OFF';\n    newmsg.myicon='fa-toggle-off';\n    newmsg.background='red';\n}\n//newmsg.label = newmsg.label_v;\nreturn newmsg;",
        "outputs": 1,
        "timeout": 0,
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 290,
        "y": 460,
        "wires": [
            [
                "ea4d168a958d4731"
            ]
        ]
    },
    {
        "id": "714e1f0e2afa0885",
        "type": "function",
        "z": "48fad0c0f57cea35",
        "name": "color",
        "func": "var newmsg={};\nnewmsg.payload = {r:msg.payload[0],g:msg.payload[1],b:msg.payload[2], a:1};\nreturn newmsg;",
        "outputs": 1,
        "timeout": 0,
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 330,
        "y": 40,
        "wires": [
            [
                "67287decfe7536cf"
            ]
        ]
    },
    {
        "id": "c1fc304462222840",
        "type": "function",
        "z": "48fad0c0f57cea35",
        "name": "num_of_leds",
        "func": "var newmsg = {};\nnewmsg.payload = msg.payload[3];\nreturn newmsg;",
        "outputs": 1,
        "timeout": 0,
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 350,
        "y": 140,
        "wires": [
            [
                "730e5141782e4353"
            ]
        ]
    },
    {
        "id": "22c0fbed37498038",
        "type": "ui_text",
        "z": "48fad0c0f57cea35",
        "group": "fc04be05304743a6",
        "order": 1,
        "width": 0,
        "height": 0,
        "name": "",
        "label": "Unit 1",
        "format": "{{msg.payload}}",
        "layout": "row-left",
        "className": "",
        "style": true,
        "font": "Times New Roman,Times,serif",
        "fontSize": "22",
        "color": "#0000ff",
        "x": 890,
        "y": 280,
        "wires": []
    },
    {
        "id": "b3dc9565e22052fe",
        "type": "ui_text",
        "z": "48fad0c0f57cea35",
        "group": "fc04be05304743a6",
        "order": 5,
        "width": 0,
        "height": 0,
        "name": "",
        "label": "Unit 2",
        "format": "{{msg.payload}}",
        "layout": "row-left",
        "className": "",
        "style": true,
        "font": "Times New Roman,Times,serif",
        "fontSize": "22",
        "color": "#0000ff",
        "x": 890,
        "y": 40,
        "wires": []
    },
    {
        "id": "40896a542df60d8a",
        "type": "ui_text",
        "z": "48fad0c0f57cea35",
        "group": "fc04be05304743a6",
        "order": 6,
        "width": 1,
        "height": 2,
        "name": "",
        "label": "Gate",
        "format": "{{msg.payload}}",
        "layout": "col-center",
        "className": "",
        "style": true,
        "font": "",
        "fontSize": "15",
        "color": "#8f0a0a",
        "x": 710,
        "y": 240,
        "wires": []
    },
    {
        "id": "4828163558cac23f",
        "type": "ui_text",
        "z": "48fad0c0f57cea35",
        "group": "fc04be05304743a6",
        "order": 10,
        "width": 1,
        "height": 2,
        "name": "",
        "label": "Light:",
        "format": "{{msg.payload}}",
        "layout": "col-center",
        "className": "",
        "style": true,
        "font": "Verdana,Verdana,Geneva,sans-serif",
        "fontSize": "15",
        "color": "#133305",
        "x": 710,
        "y": 420,
        "wires": []
    },
    {
        "id": "7710bdc96bee5a64",
        "type": "link in",
        "z": "48fad0c0f57cea35",
        "name": "Unit 1:Read Coil 1",
        "links": [
            "336bf1d73e3c16f0"
        ],
        "x": 35,
        "y": 340,
        "wires": [
            [
                "7fcff809d9501142"
            ]
        ]
    },
    {
        "id": "336bf1d73e3c16f0",
        "type": "link out",
        "z": "48fad0c0f57cea35",
        "name": "Unit 1: Read Coil 1",
        "mode": "link",
        "links": [
            "7710bdc96bee5a64"
        ],
        "x": 1235,
        "y": 300,
        "wires": []
    },
    {
        "id": "fe478f2f1bf74258",
        "type": "ui_ui_control",
        "z": "48fad0c0f57cea35",
        "name": "",
        "events": "all",
        "x": 80,
        "y": 200,
        "wires": [
            [
                "4855c1d9cb3c5de3",
                "7fcff809d9501142"
            ]
        ]
    },
    {
        "id": "4855c1d9cb3c5de3",
        "type": "modbus-getter",
        "z": "48fad0c0f57cea35",
        "name": "Unit2 FC:3",
        "showStatusActivities": false,
        "showErrors": false,
        "showWarnings": true,
        "logIOActivities": false,
        "unitid": "2",
        "dataType": "HoldingRegister",
        "adr": "0",
        "quantity": "4",
        "server": "54922a4357ba259d",
        "useIOFile": false,
        "ioFile": "",
        "useIOForPayload": false,
        "emptyMsgOnFail": false,
        "keepMsgProperties": false,
        "delayOnStart": false,
        "startDelayTime": "",
        "x": 170,
        "y": 100,
        "wires": [
            [
                "714e1f0e2afa0885",
                "c1fc304462222840"
            ],
            []
        ]
    },
    {
        "id": "ea4d168a958d4731",
        "type": "ui_template",
        "z": "48fad0c0f57cea35",
        "group": "fc04be05304743a6",
        "name": "Light Status",
        "order": 11,
        "width": 2,
        "height": 2,
        "format": "<script>\n(function(scope) {\n    scope.$watch('msg', function(msg) {\n        if (msg) {\n            if (msg.payload) {\n                scope.light_icon=\"light_on.png\";\n            } else {\n                scope.light_icon=\"light_off.png\";\n            }\n        }\n\n\n    });\n\n})(scope);\n</script>\n\n\n<div>\n    <img src = {{light_icon}} width=60 height=60>\n    \n</div>\n",
        "storeOutMessages": true,
        "fwdInMessages": true,
        "resendOnRefresh": true,
        "templateScope": "local",
        "className": "",
        "x": 510,
        "y": 480,
        "wires": [
            [
                "3009c8f5180b8b48"
            ]
        ]
    },
    {
        "id": "deb6e9852981cbe7",
        "type": "ui_template",
        "z": "48fad0c0f57cea35",
        "group": "fc04be05304743a6",
        "name": "Gate Status",
        "order": 7,
        "width": 2,
        "height": 2,
        "format": "<script>\n(function(scope) {\n    scope.$watch('msg', function(msg) {\n        if (msg) {\n            if (msg.payload) {\n                scope.light_icon=\"gate_open.png\";\n            } else {\n                scope.light_icon=\"gate_close.png\";\n            }\n        }\n\n\n    });\n\n})(scope);\n</script>\n\n\n<div>\n    <img src = {{light_icon}} width=60 height=60>\n    \n</div>\n",
        "storeOutMessages": true,
        "fwdInMessages": true,
        "resendOnRefresh": true,
        "templateScope": "local",
        "className": "",
        "x": 490,
        "y": 300,
        "wires": [
            [
                "40e24a450a247c58"
            ]
        ]
    },
    {
        "id": "1f2e434da8912dc8",
        "type": "ui_template",
        "z": "48fad0c0f57cea35",
        "group": "fc04be05304743a6",
        "name": "seprate line",
        "order": 4,
        "width": 0,
        "height": 0,
        "format": "<div>\n    <img src='line.png' width=250>\n</div>",
        "storeOutMessages": true,
        "fwdInMessages": true,
        "resendOnRefresh": true,
        "templateScope": "local",
        "className": "",
        "x": 630,
        "y": 180,
        "wires": [
            []
        ]
    },
    {
        "id": "d11918fa96d8a971",
        "type": "link in",
        "z": "48fad0c0f57cea35",
        "name": "Unit 2: read registers",
        "links": [
            "41175f479b349001"
        ],
        "x": 45,
        "y": 100,
        "wires": [
            [
                "4855c1d9cb3c5de3"
            ]
        ]
    },
    {
        "id": "41175f479b349001",
        "type": "link out",
        "z": "48fad0c0f57cea35",
        "name": "Unit 2: read registers",
        "mode": "link",
        "links": [
            "d11918fa96d8a971"
        ],
        "x": 1235,
        "y": 340,
        "wires": []
    },
    {
        "id": "00a3c1cedc235bc8",
        "type": "switch",
        "z": "48fad0c0f57cea35",
        "name": "link out",
        "property": "payload.unitid",
        "propertyType": "msg",
        "rules": [
            {
                "t": "eq",
                "v": "1",
                "vt": "num"
            },
            {
                "t": "eq",
                "v": "2",
                "vt": "num"
            }
        ],
        "checkall": "true",
        "repair": false,
        "outputs": 2,
        "x": 1120,
        "y": 320,
        "wires": [
            [
                "336bf1d73e3c16f0"
            ],
            [
                "41175f479b349001"
            ]
        ]
    },
    {
        "id": "60796979c4948a75",
        "type": "ui_spacer",
        "z": "48fad0c0f57cea35",
        "name": "spacer",
        "group": "fc04be05304743a6",
        "order": 9,
        "width": 2,
        "height": 1
    },
    {
        "id": "136b2d0e7ac84aae",
        "type": "ui_spacer",
        "z": "48fad0c0f57cea35",
        "name": "spacer",
        "group": "fc04be05304743a6",
        "order": 13,
        "width": 2,
        "height": 1
    },
    {
        "id": "fc04be05304743a6",
        "type": "ui_group",
        "name": "Gateway",
        "tab": "cb1cfb3cbe2a4244",
        "order": 1,
        "disp": true,
        "width": 5,
        "collapse": false,
        "className": ""
    },
    {
        "id": "54922a4357ba259d",
        "type": "modbus-client",
        "name": "picow_mb_gateway",
        "clienttype": "tcp",
        "bufferCommands": true,
        "stateLogEnabled": false,
        "queueLogEnabled": false,
        "failureLogEnabled": true,
        "tcpHost": "picow_mb_gateway.local",
        "tcpPort": 502,
        "tcpType": "DEFAULT",
        "serialPort": "/dev/ttyUSB",
        "serialType": "RTU-BUFFERD",
        "serialBaudrate": 9600,
        "serialDatabits": 8,
        "serialStopbits": 1,
        "serialParity": "none",
        "serialConnectionDelay": 100,
        "serialAsciiResponseStartDelimiter": "0x3A",
        "unit_id": 1,
        "commandDelay": 1,
        "clientTimeout": 2000,
        "reconnectOnTimeout": false,
        "reconnectTimeout": 2000,
        "parallelUnitIdsAllowed": true,
        "showErrors": false,
        "showWarnings": true,
        "showLogs": true
    },
    {
        "id": "cb1cfb3cbe2a4244",
        "type": "ui_tab",
        "name": "MODBUS",
        "icon": "dashboard",
        "disabled": false,
        "hidden": false
    }
]
  

[Raspberry Pi Pico] MODBUS EP. 2. Modbus RTU

 本文章介紹使用nanoMODBUS library 在Raspberry Pi Pico上實做MODBUS RTU。以一組MODBUS Master使用LVGL介面，控制兩個Modbus Slaves: 對Slave 1 以write single coil 遙控門的開/關與上鎖/解鎖，以Read Coils 讀取磁簧開關狀態，判斷門的開啟狀態。對Slave 2以write multiple registers 控制WS2812燈條的顏色與點亮LED的個數。

實驗架構如下圖：

MODBUS RTU APU 如下圖所示：

其他Function code 與data內容請參閱以下modbus文件連結：https://modbus.org/docs/Modbus_Application_Protocol_V1_1b3.pdf

成果影片：

程式碼：

本實驗專案使用nanoMODBUS(modbus protocol) library網址如下：

https://github.com/debevv/nanoMODBUS

Slave 1: 

• CMakeLists.txt

# Generated Cmake Pico project file

cmake_minimum_required(VERSION 3.13)

set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

# Initialise pico_sdk from installed location
# (note this can come from environment, CMake cache etc)

# == DO NOT EDIT THE FOLLOWING LINES for the Raspberry Pi Pico VS Code Extension to work ==
if(WIN32)
    set(USERHOME $ENV{USERPROFILE})
else()
    set(USERHOME $ENV{HOME})
endif()
set(sdkVersion 2.1.0)
set(toolchainVersion 13_3_Rel1)
set(picotoolVersion 2.1.0)
set(picoVscode ${USERHOME}/.pico-sdk/cmake/pico-vscode.cmake)
if (EXISTS ${picoVscode})
    include(${picoVscode})
endif()
# ====================================================================================
set(PICO_BOARD pico CACHE STRING "Board type")

# Pull in Raspberry Pi Pico SDK (must be before project)
include(pico_sdk_import.cmake)

project(pico_modbus_rtu C CXX ASM)

# Initialise the Raspberry Pi Pico SDK
pico_sdk_init()

# Add executable. Default name is the project name, version 0.1

add_executable(pico_modbus_rtu pico_modbus_rtu.c 
                                nanomodbus/nanomodbus.c
                                )

pico_set_program_name(pico_modbus_rtu "pico_modbus_rtu")
pico_set_program_version(pico_modbus_rtu "0.1")

# Modify the below lines to enable/disable output over UART/USB
pico_enable_stdio_uart(pico_modbus_rtu 0)
pico_enable_stdio_usb(pico_modbus_rtu 0)

# Add the standard library to the build
target_link_libraries(pico_modbus_rtu
        pico_stdlib
        hardware_pwm)

# Add the standard include files to the build
target_include_directories(pico_modbus_rtu PRIVATE
  ${CMAKE_CURRENT_LIST_DIR}
)

# Add any user requested libraries
target_link_libraries(pico_modbus_rtu 
        hardware_i2c
        )

pico_add_extra_outputs(pico_modbus_rtu)


  

• pico_modbus_rtu.c

#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/i2c.h"
#include "hardware/uart.h"
#include "nanomodbus/nanomodbus.h"
#include "hardware/pwm.h"

#define PWM_DOOR_PIN            14
#define PWM_LOCK_PIN            15
#define REED_SWITCH_PIN         16

#define BAUD_RATE               115200
#define DATA_BITS               8
#define STOP_BITS               1
#define PARITY                  UART_PARITY_EVEN

#define DOOR_OPEN_CLOSE_ADDRESS    1
#define DOOR_LOCK_ADDRESS          2   
#define REED_SWITCH_ADDRESS        3

#define UART_ID uart1
// Use pins 4 and 5 for UART1
#define UART_TX_PIN             4
#define UART_RX_PIN             5

// The data model of this sever will support coils addresses 0 to 3
#define COILS_ADDR_MAX      4
#define RTU_SERVER_ADDRESS  1

uint pwm_ch_door, pwm_slice_door;
uint pwm_ch_locker, pwm_slice_locker;
int32_t servo_door_ang, servo_locker_ang;

void setServoAngle(int ang, uint pwm_ch, uint slice);


nmbs_t nmbs;
// A single nmbs_bitfield variable can keep 2000 coils
bool terminate = false;
nmbs_bitfield server_coils = {0};

#define UNUSED_PARAM(x) ((x) = (x))

void sighandler(int s) {
    UNUSED_PARAM(s);
    terminate = true;
}

nmbs_error handle_read_coils(uint16_t address, uint16_t quantity, nmbs_bitfield coils_out, uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);
    if (address + quantity > COILS_ADDR_MAX + 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    // Read our coils values into coils_out
    for (int i = 0; i < quantity; i++) {
        bool value = nmbs_bitfield_read(server_coils, address + i);
        nmbs_bitfield_write(coils_out, i, value);
    }

    return NMBS_ERROR_NONE;
}


nmbs_error handle_write_single_coil(uint16_t address, bool value, uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    //if (address > COILS_ADDR_MAX )
    if (address != DOOR_OPEN_CLOSE_ADDRESS &&  address != DOOR_LOCK_ADDRESS)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    // Write coils values to our server_coils
 
        nmbs_bitfield_write(server_coils, address, value);
     // set servo motor
    if (address == DOOR_OPEN_CLOSE_ADDRESS) {
        setServoAngle(-1*value*90, pwm_ch_door, pwm_slice_door);
    }
    if (address == DOOR_LOCK_ADDRESS) {
        setServoAngle(value*90, pwm_ch_locker, pwm_slice_locker);
    }
    
    //gpio_put(address+2, value);  // address 0 map to gpio 2
    return NMBS_ERROR_NONE;
}


int32_t nmbs_uart_read(uint8_t* buf, uint16_t count, int32_t byte_timeout_ms, void* arg){
    uint64_t start_time = time_us_64();
    int32_t bytes_read = 0;
    uint64_t timeout_us = (uint64_t) byte_timeout_ms * 1000;
    while (time_us_64() - start_time < timeout_us && bytes_read < count) {
        if (uart_is_readable(UART_ID)) {
            buf[bytes_read++] = uart_getc(UART_ID);
            start_time = time_us_64();    // Reset start time after a successful read
        }
    }

    return bytes_read;    
}
int32_t nmbs_uart_write(const uint8_t* buf, uint16_t count, int32_t byte_timeout_ms, void* arg) {
    uart_write_blocking(UART_ID, buf, count);

    return count;
}

//servo motor library
void setServoAngle(int ang, uint pwm_ch, uint slice) {
    uint16_t top_count = (uint16_t)(ang/0.09 + 1500);  // angle 0: 1.5 ms duty
    pwm_set_chan_level(slice, pwm_ch, top_count);
}

void servo_init(uint pin, uint *pwm_ch, uint* slice) {
    // set Servo pwm
    gpio_set_function(pin, GPIO_FUNC_PWM);
    *slice = pwm_gpio_to_slice_num(pin);
    *pwm_ch = pwm_gpio_to_channel(pin);
    pwm_config c = pwm_get_default_config();
    pwm_config_set_clkdiv(&c, 125);  // 20ms period, steps 20000, clkdiv = 125 
    pwm_config_set_wrap(&c, 20000);
    pwm_config_set_phase_correct(&c, false);
    pwm_init(*slice, &c, true);    
}

void reed_switch_sensor_callback(uint gpio, uint32_t events) {
    if (gpio == REED_SWITCH_PIN) {
        if (events == GPIO_IRQ_EDGE_RISE) {
            nmbs_bitfield_write(server_coils, REED_SWITCH_ADDRESS, 1);
        }
        if (events == GPIO_IRQ_EDGE_FALL) {
            nmbs_bitfield_write(server_coils, REED_SWITCH_ADDRESS, 0);
        }
    }
}

int main()
{
    stdio_init_all();

    gpio_set_irq_enabled_with_callback(REED_SWITCH_PIN, GPIO_IRQ_EDGE_RISE | GPIO_IRQ_EDGE_FALL, 
            true, &reed_switch_sensor_callback);

    //servo motor init 
    servo_locker_ang = 0;
    servo_door_ang = 0;
    servo_init(PWM_DOOR_PIN, &pwm_ch_door, &pwm_slice_door);
    servo_init(PWM_LOCK_PIN, &pwm_ch_locker, &pwm_slice_locker);

    setServoAngle(servo_door_ang, pwm_ch_door, pwm_slice_door);
    setServoAngle(servo_locker_ang, pwm_ch_locker, pwm_slice_locker);


    // Set up our UART
    uart_init(UART_ID, BAUD_RATE);
    gpio_set_function(UART_TX_PIN, GPIO_FUNC_UART);
    gpio_set_function(UART_RX_PIN, GPIO_FUNC_UART);
    int __unused actual = uart_set_baudrate(UART_ID, BAUD_RATE);
    uart_set_hw_flow(UART_ID, false, false);
    uart_set_format(UART_ID, DATA_BITS, STOP_BITS, PARITY);
    uart_set_fifo_enabled(UART_ID, false);
  
    
    // nmbs_uart_read() and nmbs_uart_write() are implemented by the user 
    nmbs_platform_conf platform_conf;
    nmbs_platform_conf_create(&platform_conf);
    platform_conf.transport = NMBS_TRANSPORT_RTU;
    platform_conf.read = nmbs_uart_read;
    platform_conf.write = nmbs_uart_write;
    
    nmbs_callbacks callbacks;
    nmbs_callbacks_create(&callbacks);
    callbacks.read_coils = handle_read_coils;
    callbacks.write_single_coil = handle_write_single_coil;
    
    nmbs_error err = nmbs_server_create(&nmbs, RTU_SERVER_ADDRESS, &platform_conf, &callbacks);
    if (err != NMBS_ERROR_NONE) {
        fprintf(stderr, "Error creating modbus server\n");
        return 1;
    }

    // Set only the polling timeout. Byte timeout will be handled by the TCP connection
    nmbs_set_read_timeout(&nmbs, 1000);

    while (true) {

        nmbs_server_poll(&nmbs);

        tight_loop_contents();
    }
}

  

Slave 2: 

• CMakeLists.txt(main)

# == DO NOT EDIT THE FOLLOWING LINES for the Raspberry Pi Pico VS Code Extension to work ==
if(WIN32)
    set(USERHOME $ENV{USERPROFILE})
else()
    set(USERHOME $ENV{HOME})
endif()
set(sdkVersion 2.1.0)
set(toolchainVersion 13_3_Rel1)
set(picotoolVersion 2.1.0)
set(picoVscode ${USERHOME}/.pico-sdk/cmake/pico-vscode.cmake)
if (EXISTS ${picoVscode})
    include(${picoVscode})
endif()
# ====================================================================================
# == DO NOT EDIT THE FOLLOWING LINES for the Raspberry Pi Pico VS Code Extension to work ==
if(WIN32)
    set(USERHOME $ENV{USERPROFILE})
else()
    set(USERHOME $ENV{HOME})
endif()
set(sdkVersion 2.1.0)
set(toolchainVersion 13_3_Rel1)
set(picotoolVersion 2.1.0)
set(picoVscode ${USERHOME}/.pico-sdk/cmake/pico-vscode.cmake)
if (EXISTS ${picoVscode})
    include(${picoVscode})
endif()
# ====================================================================================
# Generated Cmake Pico project file

cmake_minimum_required(VERSION 3.13)

set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

# Initialise pico_sdk from installed location
# (note this can come from environment, CMake cache etc)

# == DO NOT EDIT THE FOLLOWING LINES for the Raspberry Pi Pico VS Code Extension to work ==
if(WIN32)
    set(USERHOME $ENV{USERPROFILE})
else()
    set(USERHOME $ENV{HOME})
endif()
set(sdkVersion 2.1.0)
set(toolchainVersion 13_3_Rel1)
set(picotoolVersion 2.1.0)
set(picoVscode ${USERHOME}/.pico-sdk/cmake/pico-vscode.cmake)
if (EXISTS ${picoVscode})
    include(${picoVscode})
endif()
# ====================================================================================
set(PICO_BOARD pico CACHE STRING "Board type")

# Pull in Raspberry Pi Pico SDK (must be before project)
include(pico_sdk_import.cmake)

project(pico_modbus_rtu_slave2 C CXX ASM)

# Initialise the Raspberry Pi Pico SDK
pico_sdk_init()

# Add executable. Default name is the project name, version 0.1

add_executable(pico_modbus_rtu_slave2 pico_modbus_rtu_slave2.c 
                                nanomodbus/nanomodbus.c
                                )

pico_set_program_name(pico_modbus_rtu_slave2 "pico_modbus_rtu_slave2")
pico_set_program_version(pico_modbus_rtu_slave2 "0.1")

# Modify the below lines to enable/disable output over UART/USB
pico_enable_stdio_uart(pico_modbus_rtu_slave2 0)
pico_enable_stdio_usb(pico_modbus_rtu_slave2 1)

# Add the standard library to the build
target_link_libraries(pico_modbus_rtu_slave2
        pico_stdlib
        )

# Add the standard include files to the build
target_include_directories(pico_modbus_rtu_slave2 PRIVATE
  ${CMAKE_CURRENT_LIST_DIR}
)

# Add any user requested libraries
target_link_libraries(pico_modbus_rtu_slave2 
        hardware_i2c
        )
add_subdirectory (ws2812)
target_link_libraries(pico_modbus_rtu_slave2
        ws2812
        )
pico_add_extra_outputs(pico_modbus_rtu_slave2)


 

• pico_modbus_rtu_slave2.c

#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/i2c.h"
#include "hardware/uart.h"
#include "nanomodbus/nanomodbus.h"
#include "hardware/pio.h"
#include "ws2812.h"

#define UART_ID uart1
#define UART_TX_PIN 4
#define UART_RX_PIN 5

#define BAUD_RATE 115200
#define DATA_BITS 8
#define STOP_BITS 1
#define PARITY    UART_PARITY_EVEN

// The data model of this sever will support registers addresses from 0 to 1
#define REGS_ADDR_MAX 2  // register 0 for color, register 1 for the number of leds

#define RTU_SERVER_ADDRESS 2

#define WS2812_PIO          pio0  //WS2812 LED PIO parameters
#define WS2812_SM           0
#define WS2812_PIN          16
#define TOTAL_LEDS_NUM      10

nmbs_t nmbs;
bool terminate = false;
uint16_t server_registers[REGS_ADDR_MAX] = {0};


#define UNUSED_PARAM(x) ((x) = (x))

void sighandler(int s) {
    UNUSED_PARAM(s);
    terminate = true;
}

nmbs_error handler_read_holding_registers(uint16_t address, uint16_t quantity, uint16_t* registers_out, uint8_t unit_id,
                                          void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (address + quantity > REGS_ADDR_MAX + 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;


    return NMBS_ERROR_NONE;
}

nmbs_error handle_write_multiple_registers(uint16_t address, uint16_t quantity, const uint16_t* registers,
                                           uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (address + quantity > REGS_ADDR_MAX + 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    // Write registers values to our server_registers
    for (int i = 0; i < quantity; i++)
        server_registers[address + i] = registers[i];
  
    // ========== ws2812, color, led nums
    int pixels;
    uint16_t le_color = server_registers[0] >> 8 | (server_registers[0] & 0x00ff) <<8;
    uint32_t color = urgb_u32(le_color >> 11, (le_color&0x3e0) >> 5,le_color & 0x1f);
    for (pixels =0; pixels < server_registers[1] && pixels < TOTAL_LEDS_NUM; pixels++) {
        ws2812_put_grb_pixel(WS2812_PIO, WS2812_SM,  color);
    }
    for (int i = pixels; i < TOTAL_LEDS_NUM; i++) {
        ws2812_put_grb_pixel(WS2812_PIO, WS2812_SM,  0);
    }

    return NMBS_ERROR_NONE;
}

int32_t nmbs_uart_read(uint8_t* buf, uint16_t count, int32_t byte_timeout_ms, void* arg){
    uint64_t start_time = time_us_64();
    int32_t bytes_read = 0;
    uint64_t timeout_us = (uint64_t) byte_timeout_ms * 1000;
    while (time_us_64() - start_time < timeout_us && bytes_read < count) {
        if (uart_is_readable(UART_ID)) {
            buf[bytes_read++] = uart_getc(UART_ID);
            start_time = time_us_64();    // Reset start time after a successful read
        }
    }

    return bytes_read;    
}
int32_t nmbs_uart_write(const uint8_t* buf, uint16_t count, int32_t byte_timeout_ms, void* arg) {
    uart_write_blocking(UART_ID, buf, count);

    return count;
}


int main()
{
    stdio_init_all();
    
    ws2812_init(WS2812_PIO, WS2812_SM, WS2812_PIN);

    // Set up our UART
    uart_init(UART_ID, BAUD_RATE);
    gpio_set_function(UART_TX_PIN, GPIO_FUNC_UART);
    gpio_set_function(UART_RX_PIN, GPIO_FUNC_UART);
    int __unused actual = uart_set_baudrate(UART_ID, BAUD_RATE);
    uart_set_hw_flow(UART_ID, false, false);
    uart_set_format(UART_ID, DATA_BITS, STOP_BITS, PARITY);
    uart_set_fifo_enabled(UART_ID, false);
  
    // nmbs_uart_read() and nmbs_uart_write() are implemented by the user 
    nmbs_platform_conf platform_conf;
    nmbs_platform_conf_create(&platform_conf);
    platform_conf.transport = NMBS_TRANSPORT_RTU;
    platform_conf.read = nmbs_uart_read;
    platform_conf.write = nmbs_uart_write;
    
    nmbs_callbacks callbacks;
    nmbs_callbacks_create(&callbacks);

    callbacks.read_holding_registers = handler_read_holding_registers;
    callbacks.write_multiple_registers = handle_write_multiple_registers;
    
    nmbs_error err = nmbs_server_create(&nmbs, RTU_SERVER_ADDRESS, &platform_conf, &callbacks);
    if (err != NMBS_ERROR_NONE) {
        fprintf(stderr, "Error creating modbus server\n");
        return 1;
    }

    // Set only the polling timeout. Byte timeout will be handled by the TCP connection
    nmbs_set_read_timeout(&nmbs, 1000);

    while (true) {
        nmbs_server_poll(&nmbs);

        tight_loop_contents();
    }
}

 

WS2812 Library:

• CMakeLists.txt

add_library(ws2812 INTERFACE)
pico_generate_pio_header(ws2812 ${CMAKE_CURRENT_LIST_DIR}/ws2812.pio)
target_sources(ws2812 INTERFACE
    ${CMAKE_CURRENT_LIST_DIR}/ws2812.c
)

target_include_directories(ws2812 INTERFACE
    ${CMAKE_CURRENT_LIST_DIR}
)

target_link_libraries(ws2812 INTERFACE
        hardware_pio
)

 

• ws2812.c

#include "ws2812.h"

#include "stdlib.h"
#include "string.h"


#define green 0x1f0000
#define red 0x001f00
#define blue 0x00001f

static void ws2812_program_init(PIO pio, uint sm, uint pin, float freq) {
    
    uint offset = pio_add_program(pio, &ws2812_program);
    pio_sm_config c = ws2812_program_get_default_config(offset);

    pio_gpio_init(pio, pin);
    pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, true);

    sm_config_set_sideset_pins(&c, pin);
    sm_config_set_out_shift(&c, false, true, 24);
    sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX);

    int cycles_per_bit = 6;
    float div = clock_get_hz(clk_sys) / (freq * cycles_per_bit);
    sm_config_set_clkdiv(&c, div);

    pio_sm_init(pio, sm, offset, &c);
    pio_sm_set_enabled(pio, sm, true);
}

void ws2812_put_grb_pixel(PIO pio, uint sm, uint32_t pixel_grb) {
    pio_sm_put_blocking(pio, sm, pixel_grb << 8u);
}

uint32_t urgb_u32(uint8_t r, uint8_t g, uint8_t b) {
    return
            ((uint32_t) (r) << 8) |
            ((uint32_t) (g) << 16) |
            (uint32_t) (b);
}

void ws2812_init(PIO pio, uint sm, uint ws2812_pin) {

    ws2812_program_init(pio, sm,  ws2812_pin, 800000);
}



 

• ws1812.h

#ifndef _WS2812_H_
#define _WS2812_H_
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/pio.h"
#include "ws2812.pio.h"
#include "hardware/clocks.h"



void ws2812_init(PIO pio, uint sm, uint ws2812_pin);
void ws2812_put_grb_pixel(PIO pio, uint sm, uint32_t pixel_grb);
uint32_t urgb_u32(uint8_t r, uint8_t g, uint8_t b);

#endif 
 

• ws2812.pio

.program ws2812
.side_set 1

.wrap_target
bitloop:
    out x, 1       side 0 [1]
    jmp !x do_zero side 1 [1]
do_one:
    jmp  bitloop   side 1 [1]
do_zero:
    nop            side 0 [1]
.wrap


 

modbus master:

pico_lvgl library 請參閱以前文章：

[Raspberry Pi Pico (c-sdk)] LVGL  Graphics Library  &  Pico PIO TFT display driver(Serial or Parallel)

• CMakeLists.txt:

# == DO NOT EDIT THE FOLLOWING LINES for the Raspberry Pi Pico VS Code Extension to work ==
if(WIN32)
    set(USERHOME $ENV{USERPROFILE})
else()
    set(USERHOME $ENV{HOME})
endif()
set(sdkVersion 2.1.0)
set(toolchainVersion 13_3_Rel1)
set(picotoolVersion 2.1.0)
set(picoVscode ${USERHOME}/.pico-sdk/cmake/pico-vscode.cmake)
if (EXISTS ${picoVscode})
    include(${picoVscode})
endif()
# ====================================================================================
# == DO NOT EDIT THE FOLLOWING LINES for the Raspberry Pi Pico VS Code Extension to work ==
if(WIN32)
    set(USERHOME $ENV{USERPROFILE})
else()
    set(USERHOME $ENV{HOME})
endif()
set(sdkVersion 2.1.0)
set(toolchainVersion 13_3_Rel1)
set(picotoolVersion 2.1.0)
set(picoVscode ${USERHOME}/.pico-sdk/cmake/pico-vscode.cmake)
if (EXISTS ${picoVscode})
    include(${picoVscode})
endif()
# ====================================================================================
# Generated Cmake Pico project file

cmake_minimum_required(VERSION 3.13)

set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

# Initialise pico_sdk from installed location
# (note this can come from environment, CMake cache etc)

# == DO NOT EDIT THE FOLLOWING LINES for the Raspberry Pi Pico VS Code Extension to work ==
if(WIN32)
    set(USERHOME $ENV{USERPROFILE})
else()
    set(USERHOME $ENV{HOME})
endif()
set(sdkVersion 2.1.0)
set(toolchainVersion 13_3_Rel1)
set(picotoolVersion 2.1.0)
set(picoVscode ${USERHOME}/.pico-sdk/cmake/pico-vscode.cmake)
if (EXISTS ${picoVscode})
    include(${picoVscode})
endif()
# ====================================================================================
set(PICO_BOARD pico CACHE STRING "Board type")

# Pull in Raspberry Pi Pico SDK (must be before project)
include(pico_sdk_import.cmake)

project(pico_modbus_rtu_master C CXX ASM)

# Initialise the Raspberry Pi Pico SDK
pico_sdk_init()

# Add executable. Default name is the project name, version 0.1

add_executable(pico_modbus_rtu_master pico_modbus_rtu_master.c 
                                nanomodbus/nanomodbus.c
                                modbus_master_ui.c
                                )

pico_set_program_name(pico_modbus_rtu_master "pico_modbus_rtu")
pico_set_program_version(pico_modbus_rtu_master "0.1")

# Modify the below lines to enable/disable output over UART/USB
pico_enable_stdio_uart(pico_modbus_rtu_master 0)
pico_enable_stdio_usb(pico_modbus_rtu_master 0)

# Add the standard library to the build
target_link_libraries(pico_modbus_rtu_master
        pico_stdlib
       )

# Add the standard include files to the build
target_include_directories(pico_modbus_rtu_master PRIVATE
  ${CMAKE_CURRENT_LIST_DIR}
)

# Add any user requested libraries
target_link_libraries(pico_modbus_rtu_master 
        hardware_i2c
        hardware_pio
        )
add_subdirectory(pico_lvgl)
target_link_libraries(pico_modbus_rtu_master
        pico_lvgl
)

pico_add_extra_outputs(pico_modbus_rtu_master)


 

• modbus_master_ui.c

#include "stdio.h"
#include "pico/stdlib.h"
#include "lvgl/lvgl.h"
#include "pico_modbus_rtu_master.h"
#include "nanomodbus/nanomodbus.h"
#include "images/door_open.h"
#include "images/door_close.h"
#include "images/lock.h"
#include "images/unlock.h"
#include "images/open.h"
#include "images/close.h"

#define TOTAL_LED_NUM   10

extern nmbs_t nmbs;
LV_IMG_DECLARE(door_open);
LV_IMG_DECLARE(door_close);
LV_IMG_DECLARE(door_lock);
LV_IMG_DECLARE(door_unlock);
LV_IMG_DECLARE(open);
LV_IMG_DECLARE(close);

lv_obj_t *door, *lock_obj;
lv_obj_t* slider_label;

lv_color_t led_color;
int32_t led_num;

static void slider_event_cb(lv_event_t *e) {
    lv_obj_t *obj = lv_event_get_target(e);
    lv_event_code_t code = lv_event_get_code(e);
    uint16_t registers[2];

    if (code == LV_EVENT_VALUE_CHANGED) {
        led_num = lv_slider_get_value(obj)/TOTAL_LED_NUM;
        lv_label_set_text_fmt(slider_label, "%d", led_num);
        // send to modbus server
        registers[0] = led_color.full;
        registers[1] = led_num;
        nmbs_set_destination_rtu_address(&nmbs, RTU_WS2812_SERVER_ADDRESS);
        nmbs_error err = nmbs_write_multiple_registers(&nmbs, 0, 2, registers);
    }
}

static void color_picker_cb(lv_event_t *e) {
    lv_obj_t *color_picker = lv_event_get_target(e);
    lv_event_code_t code = lv_event_get_code(e);
    if (code == LV_EVENT_VALUE_CHANGED) {
        uint16_t registers[2];
        led_color = lv_colorwheel_get_rgb(color_picker);
        // send to modbus server
        registers[0] = led_color.full;
        registers[1] = led_num;
        nmbs_set_destination_rtu_address(&nmbs, RTU_WS2812_SERVER_ADDRESS);
        nmbs_error err = nmbs_write_multiple_registers(&nmbs, 0, 2, registers);
    }
}

static void btn_lock_event_handler(lv_event_t * e)
{ 
    lv_event_code_t code = lv_event_get_code(e);
    lv_obj_t * obj = lv_event_get_target(e);
    lv_obj_t *label = lv_obj_get_child(obj, 0);
    lv_obj_t* img = lv_obj_get_child(obj, 1);
    uint8_t address;
    nmbs_bitfield coils;
   int i;
    if(code == LV_EVENT_CLICKED) {
        nmbs_set_destination_rtu_address(&nmbs, RTU_DOOR_SERVER_ADDRESS);
        nmbs_error err = nmbs_read_coils(&nmbs, 0, 4, coils);
        if (nmbs_bitfield_read(coils,DOOR_LOCK_ADDRESS) == 1) {
            err = nmbs_write_single_coil(&nmbs, DOOR_LOCK_ADDRESS, 0);
            lv_label_set_text(label, "Lock");
            lv_img_set_src(img, &lock);
        } else {
            err = nmbs_write_single_coil(&nmbs, DOOR_LOCK_ADDRESS, 1);
            lv_label_set_text(label, "Unlock");
            lv_img_set_src(img, &unlock);
        }
           //lv_timer_handler();
    }
}

static void btn_door_event_handler(lv_event_t * e)
{ 
    lv_event_code_t code = lv_event_get_code(e);
    lv_obj_t * obj = lv_event_get_target(e);
    lv_obj_t *label = lv_obj_get_child(obj, 0);
    lv_obj_t *img = lv_obj_get_child(obj, 1);
    uint8_t address;
    nmbs_bitfield coils;
   int i;
    if(code == LV_EVENT_CLICKED) {
        nmbs_set_destination_rtu_address(&nmbs, RTU_DOOR_SERVER_ADDRESS);
        nmbs_error err = nmbs_read_coils(&nmbs, 0, 4, coils);
        if (nmbs_bitfield_read(coils,REED_SWITCH_ADDRESS) == 1) {
            err = nmbs_write_single_coil(&nmbs, DOOR_OPEN_CLOSE_ADDRESS, 0);
            lv_img_set_src(door, &door_close);
            lv_label_set_text(label, "Open");
            lv_img_set_src(img, &open);
        } else {
            err = nmbs_write_single_coil(&nmbs, DOOR_OPEN_CLOSE_ADDRESS, 1);
            lv_img_set_src(door, &door_open);
            lv_label_set_text(label, "Close");
            lv_img_set_src(img, &close);
        }
        //lv_timer_handler();
    }
}

void draw_master_ui() {
    
    lv_obj_t*  label = lv_label_create(lv_scr_act());
    lv_label_set_text_fmt(label, "Slave\nAddr %d", RTU_DOOR_SERVER_ADDRESS);
    lv_obj_align(label, LV_ALIGN_TOP_LEFT, 5,5);

    lv_obj_t* btn = lv_btn_create(lv_scr_act());
    lv_obj_align(btn, LV_ALIGN_TOP_MID, 70, 20);
    label = lv_label_create(btn);
    lv_obj_t *img = lv_img_create(btn);
    lv_label_set_text(label, "Open");
    lv_img_set_src(img, &open);
    lv_obj_align(img, LV_ALIGN_LEFT_MID, 0,0);
    lv_obj_align_to(label, img, LV_ALIGN_OUT_RIGHT_MID, 5, 0);
    lv_obj_set_size(btn, 120, 60);
    lv_obj_set_style_bg_color(btn, lv_color_hex(0x00cf00), 0);
    lv_obj_add_event_cb(btn, btn_door_event_handler, LV_EVENT_ALL, NULL);
    

    btn = lv_btn_create(lv_scr_act());
    lv_obj_align(btn, LV_ALIGN_TOP_MID, 70, 90);
    label = lv_label_create(btn);
    img = lv_img_create(btn);
    lv_label_set_text(label, "Lock");
    lv_img_set_src(img, &lock);
    lv_obj_align(img, LV_ALIGN_LEFT_MID, 0,0);
    lv_obj_align_to(label, img, LV_ALIGN_OUT_RIGHT_MID, 5, 0);
    lv_obj_set_size(btn, 120, 60);
    lv_obj_set_style_bg_color(btn, lv_color_hex(0x00cf00), 0);
    lv_obj_add_event_cb(btn, btn_lock_event_handler, LV_EVENT_ALL, NULL);

    door = lv_img_create(lv_scr_act());
    lv_img_set_src(door, &door_close);
    lv_obj_align(door, LV_ALIGN_TOP_MID, -90, 10);
    lv_obj_set_size(door, 160, 160);

// ============== line 
    static lv_point_t line_points[] = { {5, 0}, {470,0} };
    /*Create style*/
    static lv_style_t style_line;
    lv_style_init(&style_line);
    lv_style_set_line_width(&style_line, 8);
    lv_style_set_line_color(&style_line, lv_palette_main(LV_PALETTE_BLUE));
    lv_style_set_line_rounded(&style_line, true);
    lv_style_set_shadow_width(&style_line,1);

    /*Create a line and apply the new style*/
    lv_obj_t * line1;
    line1 = lv_line_create(lv_scr_act());
    lv_line_set_points(line1, line_points, 2);     /*Set the points*/
    lv_obj_add_style(line1, &style_line, 0);
    lv_obj_align(line1, LV_ALIGN_TOP_LEFT, 0, 170);
    // ===========
    label = lv_label_create(lv_scr_act());
    lv_label_set_text_fmt(label, "Slave\nAddr %d", RTU_WS2812_SERVER_ADDRESS);
    lv_obj_align_to(label, line1, LV_ALIGN_OUT_BOTTOM_LEFT, 5,5);

    lv_obj_t *color_wheel = lv_colorwheel_create(lv_scr_act(), true);
    lv_obj_set_size(color_wheel, 120, 120);
    lv_obj_align(color_wheel, LV_ALIGN_BOTTOM_MID, -90, -20);
    led_color = lv_color_make(0xff, 0,0);
    lv_colorwheel_set_rgb(color_wheel, led_color);
    //lv_colorwheel_set_mode(color_wheel, LV_COLORWHEEL_MODE_VALUE);
    lv_colorwheel_set_mode_fixed(color_wheel, true);
    lv_obj_add_event_cb(color_wheel, color_picker_cb, LV_EVENT_VALUE_CHANGED, NULL);

    lv_obj_t * slider = lv_slider_create(lv_scr_act());
    lv_obj_align(slider, LV_ALIGN_BOTTOM_MID, 100, -60);
    lv_obj_set_size(slider, 180, 20);
    lv_obj_add_event_cb(slider, slider_event_cb, LV_EVENT_VALUE_CHANGED, NULL);

    /*Create a label below the slider*/
    slider_label = lv_label_create(lv_scr_act());
    lv_label_set_text(slider_label, "0");
    lv_obj_align_to(slider_label, slider, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);
    


    
}
 

• pico_modbus_rtu_master.c

#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/i2c.h"
#include "hardware/uart.h"
#include "nanomodbus/nanomodbus.h"
#include "hardware/pio.h"
#include "pico_lvgl.h"
#include "pico_modbus_rtu_master.h"

nmbs_t nmbs;
bool terminate = false;
nmbs_bitfield server_coils = {0};
uint16_t server_registers[REGS_ADDR_MAX] = {0};

PIO TFT_PIO = pio1;
#define TFT_SM 1
#define TFT_SDI_GPIO 9
#define TFT_CSX_DCX_SCK_GPIO 6 // CSX=8, DCX=7, SCK=6, SIDE_SET

#define UNUSED_PARAM(x) ((x) = (x))

void draw_master_ui();

void sighandler(int s) {
    UNUSED_PARAM(s);
    terminate = true;
}

nmbs_error handle_read_coils(uint16_t address, uint16_t quantity, nmbs_bitfield coils_out, uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);
    if (address + quantity > COILS_ADDR_MAX + 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    // Read our coils values into coils_out
    for (int i = 0; i < quantity; i++) {
        bool value = nmbs_bitfield_read(server_coils, address + i);
        nmbs_bitfield_write(coils_out, i, value);
    }

    return NMBS_ERROR_NONE;
}

nmbs_error handle_read_discrete_inputs(uint16_t address, uint16_t quantity, nmbs_bitfield coils_out, uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (address + quantity > COILS_ADDR_MAX + 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    // Read our coils values into coils_out
    for (int i = 0; i < quantity; i++) {
        bool value = nmbs_bitfield_read(server_coils, address + i);
        nmbs_bitfield_write(coils_out, i, value);
    }

    return NMBS_ERROR_NONE;
}

nmbs_error handle_write_single_coil(uint16_t address, bool value, uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (address != DOOR_OPEN_CLOSE_ADDRESS &&  address != DOOR_OPEN_CLOSE_ADDRESS)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    // Write coils values to our server_coils
 
        nmbs_bitfield_write(server_coils, address, value);

    return NMBS_ERROR_NONE;
}

nmbs_error handle_write_multiple_coils(uint16_t address, uint16_t quantity, const nmbs_bitfield coils, uint8_t unit_id,
                                       void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (address + quantity > COILS_ADDR_MAX + 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    // Write coils values to our server_coils
    for (int i = 0; i < quantity; i++) {
        nmbs_bitfield_write(server_coils, address + i, nmbs_bitfield_read(coils, i));
    }

    return NMBS_ERROR_NONE;
}


nmbs_error handler_read_holding_registers(uint16_t address, uint16_t quantity, uint16_t* registers_out, uint8_t unit_id,
                                          void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (address + quantity > REGS_ADDR_MAX + 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    return NMBS_ERROR_NONE;
}

nmbs_error handle_write_single_register(uint16_t address, uint16_t value, uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (address > REGS_ADDR_MAX)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    // Write registers values to our server_registers

    return NMBS_ERROR_NONE;
}

nmbs_error handle_write_multiple_registers(uint16_t address, uint16_t quantity, const uint16_t* registers,
                                           uint8_t unit_id, void* arg) {
    UNUSED_PARAM(arg);
    UNUSED_PARAM(unit_id);

    if (address + quantity > REGS_ADDR_MAX + 1)
        return NMBS_EXCEPTION_ILLEGAL_DATA_ADDRESS;

    // Write registers values to our server_registers
    for (int i = 0; i < quantity; i++)
        server_registers[address + i] = registers[i];

    return NMBS_ERROR_NONE;
}

int32_t nmbs_uart_read(uint8_t* buf, uint16_t count, int32_t byte_timeout_ms, void* arg){
    uint64_t start_time = time_us_64();
    int32_t bytes_read = 0;
    uint64_t timeout_us = (uint64_t) byte_timeout_ms * 1000;
    while (time_us_64() - start_time < timeout_us && bytes_read < count) {
        if (uart_is_readable(UART_ID)) {
            buf[bytes_read++] = uart_getc(UART_ID);
            start_time = time_us_64();    // Reset start time after a successful read
        }
    }

    return bytes_read;    
}
int32_t nmbs_uart_write(const uint8_t* buf, uint16_t count, int32_t byte_timeout_ms, void* arg) {
    uart_write_blocking(UART_ID, buf, count);

    return count;
}

nmbs_error err;
int main()
{
    stdio_init_all();

    pico_lvgl_tft_init(TFT_PIO, TFT_SM, TFT_SDI_GPIO, TFT_CSX_DCX_SCK_GPIO);
    tft_set_orientation(TFT_ORIENTATION_LANDSCAPE);

    pico_lvgl_display_init(5);
    pico_lvgl_xpt2046_init();

    draw_master_ui();
    lv_timer_handler();


    // Set up our UART
    uart_init(UART_ID, BAUD_RATE);

    gpio_set_function(UART_TX_PIN, GPIO_FUNC_UART);
    gpio_set_function(UART_RX_PIN, GPIO_FUNC_UART);

    int __unused actual = uart_set_baudrate(UART_ID, BAUD_RATE);
    uart_set_hw_flow(UART_ID, false, false);
    uart_set_format(UART_ID, DATA_BITS, STOP_BITS, PARITY);
    uart_set_fifo_enabled(UART_ID, false);

    // nmbs_uart_read() and nmbs_uart_write() are implemented by the user 
    nmbs_platform_conf platform_conf;
    nmbs_platform_conf_create(&platform_conf);
    platform_conf.transport = NMBS_TRANSPORT_RTU;
    platform_conf.read = nmbs_uart_read;
    platform_conf.write = nmbs_uart_write;
 
    err = nmbs_client_create(&nmbs, &platform_conf);
    if (err != NMBS_ERROR_NONE) {
        fprintf(stderr, "Error creating modbus client\n");
        return 1;
    }

    // Set only the polling timeout. Byte timeout will be handled by the TCP connection
    nmbs_set_read_timeout(&nmbs, 1000);

    uint16_t registers[2] = {0,10};
    nmbs_set_destination_rtu_address(&nmbs, RTU_WS2812_SERVER_ADDRESS);
    nmbs_error err = nmbs_write_multiple_registers(&nmbs, 0, 2, registers);

    nmbs_set_destination_rtu_address(&nmbs, RTU_DOOR_SERVER_ADDRESS);
    err = nmbs_write_single_coil(&nmbs, DOOR_LOCK_ADDRESS, false);
    err = nmbs_write_single_coil(&nmbs, DOOR_OPEN_CLOSE_ADDRESS, false);
    nmbs_bitfield coils;

    while (true) {
        lv_timer_handler();

        sleep_ms(5);
    }
}

 

• pico_modbus_rtu_master.h

#ifndef __PICO_MODBUS_RTU_MASETER_
#define __PICO_MODBUS_RTU_MASETER_

// UART defines
#define UART_ID uart0
#define UART_TX_PIN 0
#define UART_RX_PIN 1

#define BAUD_RATE       115200
#define DATA_BITS       8
#define STOP_BITS       1
#define PARITY          UART_PARITY_EVEN

#define DOOR_OPEN_CLOSE_ADDRESS     1
#define DOOR_LOCK_ADDRESS           2
#define REED_SWITCH_ADDRESS         3

// The data model of this sever will support coils addresses 0 to 100 and registers addresses from 0 to 32
#define COILS_ADDR_MAX 4
#define REGS_ADDR_MAX 2

#define RTU_DOOR_SERVER_ADDRESS 1
#define RTU_WS2812_SERVER_ADDRESS 2

#endif