Can you help me integrate your nanoMODBUS library On STM32F767 board?

[leoembeddeder]

@ntfreak @dervomsee @arhiv6 @carlfriess @LeZerb
hello, guys

Can you help me integrate your nanoMODBUS library On STM32F767 board? Using my STM32F767 CubeMX and KEIL project below, make examples separately in your examples folder, and I'll help you test them.

1.I use STM32F767 board , the USART1 for debug, no interrupt, just use printf debug

USART1_TX PA9
USART1_RX PA10

115200 bps

2.I use USART3 for Modbus USART, use interrupt

use 115200 baud rate, just use TTL RS232, No RS485

USART3_TX PB10
USART3_RX PB11
115200

3.you can use STM32 CubeIDE and MDK-ARM KEIL

4.I've already got printf working on serial port 1, so you can just use the printf function directly.

5.I’ve already set up the software framework using KEIL. In the app.c file, you can add your Modbus RTU code library.

6. about the Timer interrupt , you can use systick 50us every time

Here's my project zip file, please help me

Mdobus-STM32F767.zip

[jacobq]

This is not a bug report or feature request and so should be closed. Also, there is not enough information in your request, e.g.,

• It looks like you want to use USART3 at 115200 baud, but you did not specify whether you want to use RTU or ASCII transport (nanoMODBUS only support RTU at present) or whether you need to control bus direction (e.g., for RS-485 since it is half-duplex).
• You did not specify whether you are attempting to implement client (master) or server (slave) roles.
• You did not provide a schematic, just the MCU part number and source code for a mostly empty project.

If you would to increase the likelihood that others will freely help you, it would behoove you to show (1) what exactly you are trying to do, (2) what you have tried so far, (3) what is / isn't working and how you are making that determination, and (4) what examples / instructions / documentation you were looking at.

In my case, I was able to use this library to implement a Modbus RTU server communicating over RS-485 by mostly following the generic STM32 example and making a few changes:

• I wasn't using an RTOS but also didn't want to block execution with HAL_UART_Receive so set up my own circular buffer for received data as it arrives & call nmbs_server_poll from my main loop whenever that buffer isn't empty.
• I defined HAL_UART_TxCpltCallback to handle setting the bus direction back to receive and flushing out any data that was inadvertently received by the USART during transmission (since my application is half-duplex so cannot receive data from other nodes while transmitting)
• I had to raise the priority of my Modbus USART interrupt to avoid missing data because I had other interrupt handler code that could take a significant amount of time to execute (long enough to miss a byte & the USART I was using did not have a FIFO).

In case it's helpful, here are some excerpts from my code (absolutely no warranty or support):

My circular buffer library

#ifndef BUFFER_H
#define BUFFER_H

/// Simple implementation of a circular buffer data structure.
/// Note that this implementation is not designed to be thread-safe.
/// e.g., when an item is being added/produced the head index will change,
/// and similarly the tail index will change when an item is removed/consumed.
/// So any operations that depend on either of those values
/// (e.g. cb_is_empty compares head & tail)
/// needs to ensure that they do not change during that operation.


#include <stddef.h>
#include <stdint.h>

#define CIRCULAR_BUFFER_SIZE 512

// To avoid having to deal with strange cases like CIRCULAR_BUFFER_SIZE <= 2
// where there is capacity for at most one element, a minimum size of 8
// is required by design.
#define CIRCULAR_BUFFER_MIN_SIZE 8
#if CIRCULAR_BUFFER_SIZE < CIRCULAR_BUFFER_MIN_SIZE
#error CIRCULAR_BUFFER_SIZE must be at least CIRCULAR_BUFFER_MIN_SIZE
#endif

/// head/tail indices are stored as uint16_t so size cannot exceed 64k
#define CIRCULAR_BUFFER_MAX_SIZE 65536
#if CIRCULAR_BUFFER_SIZE > CIRCULAR_BUFFER_MAX_SIZE
#error CIRCULAR_BUFFER_SIZE cannot exceed CIRCULAR_BUFFER_MAX_SIZE
#endif


/// Core data structure to track the state of the circular buffer
/// When head and tail are equal the buffer is considered empty.
/// Thus the capacity is actually one less than the array size,
/// and the buffer is full when incrementing tail would make
/// it equal to head (after accounting for wrap-around).
struct circular_buffer
{
    /// index of next array element to be read/consumed
    uint16_t head;
    /// index of next array element to be written/produced
    uint16_t tail;
    /// storage for elements in circular buffer
    uint8_t array[CIRCULAR_BUFFER_SIZE];
};


/// Sets head, tail, and all storage elements to zero so that
/// the data structure is ready to be used
/// (i.e., initializes to predetermined unambiguous empty state).
/// Caller must ensure exclusive access (place within critical section).
static inline
void cb_init(volatile struct circular_buffer * const cb)
{
    cb->head = 0;
    cb->tail = 0;
    for (uint16_t i=0; i < CIRCULAR_BUFFER_SIZE; i++)
        cb->array[i] = 0;
}


/// Returns whether or not the circular buffer is empty
/// (has no unconsumed values available to ready).
static inline
int8_t cb_is_empty(const volatile struct circular_buffer * const cb)
{
    return cb->head == cb->tail ? 1 : 0;
}


/// Returns whether or not the circular buffer is full
/// (has no available capacity).
static inline
int8_t cb_is_full(const volatile struct circular_buffer * const cb)
{
    size_t temp_tail = cb->tail + 1;
    if (temp_tail >= CIRCULAR_BUFFER_SIZE)
        temp_tail = 0;
    // Would this hypothetical new tail index reach the head index (overflow case)?
    return cb->head == temp_tail ? 1 : 0;
}

/// Returns the number of elements ready to be consumed.
/// @param cb pointer to circular buffer structure to examine.
/// @retval Number of elements currently enqueued in the circular buffer.
static inline
int32_t cb_available(const volatile struct circular_buffer * const cb)
{
    // 3 cases to consider:
    //   * head < tail  (normal: n = tail - head)
    //   * head == tail (empty: n = 0, special case of "normal")
    //   * head > tail (head wrapped: n = tail + (CIRCULAR_BUFFER_SIZE - head))
    int32_t n = cb->tail;
    n -= cb->head;
    if (n < 0)
    {
        n += CIRCULAR_BUFFER_SIZE;
    }
    return n;
}



/// Returns the oldest unconsumed value without consuming it.
/// It is the caller's responsibility to properly handle the case of an empty buffer.
/// @retval oldest unconsumed value or, if the buffer is empty, the most-recently consumed value.
static inline
uint8_t cb_peek(const volatile struct circular_buffer * const cb)
{
    return cb->array[cb->head];
}


/// Returns the oldest unconsumed value and consumes it (makes its storage space available).
/// It is the caller's responsibility to properly handle the case of an empty buffer.
/// @retval oldest unconsumed value or, if the buffer is empty, the most-recently consumed value.
static inline
uint8_t cb_consume(volatile struct circular_buffer * const cb)
{
    uint8_t retval = cb_peek(cb);
    if (!cb_is_empty(cb))
    {
        uint16_t new_head = cb->head + 1;
        if (new_head >= CIRCULAR_BUFFER_SIZE)
        {
            cb->head = 0;
        }
        else
        {
            cb->head = new_head;
        }
    }
    return retval;
}


/// Appends new value to the end of the circular buffer.
/// @param cb pointer to circular buffer structure to which a new element should be added
/// @param x new element to insert into the circular buffer
/// @retval 0 if new element was added successfully, otherwise 1
static inline
int8_t cb_produce(volatile struct circular_buffer * const cb, const uint8_t x)
{
    int8_t retval;
    if (!cb_is_full(cb))
    {
        retval = 0;
        uint16_t local_tail = cb->tail;
        cb->array[local_tail] = x;
        local_tail++;
        if (local_tail >= CIRCULAR_BUFFER_SIZE)
        {
            cb->tail = 0;
        }
        else
        {
            cb->tail = local_tail;
        }
    }
    else
    {
        retval = 1;
    }

    return retval;
}


/// Reverses the cb_produce operation.
/// @param cb pointer to circular buffer structure to which a new element should be added
/// @retval 0 if most recently added element was removed successfully, otherwise 1 (e.g., if buffer was empty)
static inline
int8_t cb_unproduce(volatile struct circular_buffer * const cb)
{
    int8_t retval;
    if (!cb_is_empty(cb))
    {
        retval = 0;
        int32_t local_tail = cb->tail;
        local_tail--;
        // Account for "wrap-around"
        if (local_tail < 0)
        {
            cb->tail = CIRCULAR_BUFFER_SIZE - 1;
        }
        else
        {
            cb->tail = (uint16_t)local_tail;
        }
    }
    else
    {
        retval = 1;
    }

    return retval;
}

#endif //BUFFER_H

My read & write functions

// Note: during start-up (e.g., at the beginning of nmbs_server_init) call:
//     cb_init(&modbus_usart_rx_cb);
// to initialize this data structure. 
// There should also be some lines like the following to connect the read/write functions:
//     conf.transport = NMBS_TRANSPORT_RTU;
//     conf.read = read_modbus_serial;
//     conf.write = write_modbus_serial;
 
volatile struct circular_buffer modbus_usart_rx_cb;


int32_t read_modbus_serial(uint8_t* buf, uint16_t count, int32_t byte_timeout_ms, void* arg)
{
    const uint32_t start_tick = HAL_GetTick();
    uint16_t  i = 0;
    while (i < count)
    {
        if (!cb_is_empty(&modbus_usart_rx_cb))
        {
            // Ensure atomic access to modbus_usart_rx_cb
            __disable_irq();
            buf[i] = cb_consume(&modbus_usart_rx_cb);
            __enable_irq();
            i++;
        }
        else
        {
            // Abort in case of timeout
            const uint32_t this_tick = HAL_GetTick();
            const int32_t elapsed_ms = this_tick - start_tick;
            if (elapsed_ms > byte_timeout_ms && byte_timeout_ms >= 0)
            {
                break;
            }
        }
    };
    return i == count ? count : 0;
}

int32_t write_modbus_serial(const uint8_t* buf, uint16_t count, int32_t byte_timeout_ms, void* arg)
{
    // TODO: Schedule this write rather than block
    // Modbus RTU requires an interframe spacing of at least 1.75 ms
    // (for 115200 baud the t3.5 time would otherwise be only 334 us)
    HAL_Delay(2);

    MODBUS_RS485_TX_ENABLE;
    // We're half-duplex so disable receive while transmitting
    MODBUS_USART->CR1 &= ~USART_CR1_RXNEIE_RXFNEIE;

    HAL_StatusTypeDef status = HAL_UART_Transmit_DMA(&MB_UART, buf, count);
    return (status == HAL_OK) ? count : 0;
}

Interrupt handler

void USART3_4_5_6_LPUART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART3_4_5_6_LPUART1_IRQn 0 */
    // Modbus USART receive
    if ((MODBUS_USART->CR1 & USART_CR1_RXNEIE_RXFNEIE) && (MODBUS_USART->ISR & USART_ISR_RXNE_RXFNE))
    {
        extern volatile struct circular_buffer modbus_usart_rx_cb;
        cb_produce(&modbus_usart_rx_cb, MODBUS_USART->RDR);
    }

  /* USER CODE END USART3_4_5_6_LPUART1_IRQn 0 */
  // ...
  // Call `HAL_UART_IRQHandler` for whatever peripherals you've set up in STM32CubeMX
  // ...
  /* USER CODE BEGIN USART3_4_5_6_LPUART1_IRQn 1 */

  /* USER CODE END USART3_4_5_6_LPUART1_IRQn 1 */
}


/**
  * @brief Tx Transfer completed callback.
  * @param huart UART handle.
  * @retval None
  */
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart == &MB_UART)
    {
        __disable_irq();
        MODBUS_RS485_TX_DISABLE;
        MODBUS_USART->RQR = USART_RQR_RXFRQ;
        MODBUS_USART->CR1 |= USART_CR1_RXNEIE_RXFNEIE;
        __enable_irq();
    }
}