RT-Thread-发送一会数据后，就报了hardfaultRT-Thread问答社区

发送一会数据后，就报了hardfault

发布于 2024-09-03 19:48:42 浏览：182 订阅该版

```
accept connection ok!
psr: 0x20000000
r00: 0x00fa88f7
r01: 0x000f7548
r02: 0x000f7548
r03: 0x00000000
r04: 0xdeadbeef
r05: 0xdeadbeef
r06: 0xdeadbeef
r07: 0x1ffe1ff0
r08: 0xdeadbeef
r09: 0xdeadbeef
r10: 0xdeadbeef
r11: 0xdeadbeef
r12: 0x00000000
 lr: 0x0008a77b
 pc: 0x00000000
hard fault on thread: etx

thread   pri  status      sp     stack size max used left tick  error
-------- ---  ------- ---------- ----------  ------  ---------- ---
app_main   9  suspend 0x000004e0 0x00001000    50%   0x0000000a OK
app_afe    8  suspend 0x00000248 0x00000800    62%   0x00000003 OK
tshell    20  suspend 0x000000d0 0x00001000    07%   0x00000009 OK
ftp       19  suspend 0x0000016c 0x00000800    33%   0x00000054 OK
sys work  23  suspend 0x00000084 0x00000800    26%   0x0000000a OK
tcpip     11  suspend 0x000000f0 0x00000400    79%   0x0000000b OK
etx       12  running 0x000000b0 0x00000400    17%   0x0000000f OK
erx       12  ready   0x00000108 0x00000400    49%   0x00000008 OK
tidle0    31  ready   0x00000060 0x00000100    66%   0x00000006 OK
timer      4  suspend 0x00000080 0x00000200    32%   0x00000009 OK
main      10  suspend 0x00000148 0x00000800    56%   0x00000001 OK
usage fault:
SCB_CFSR_UFSR:0x02 INVSTATE 
```

```c
    struct sockaddr_in server_addr,client_addr;
    socklen_t sin_size;
    //创建sock
    static int sock;
    static uint8_t init_modbus = 1;
    static uint8_t net_sta = 1;
    static uint32_t tcp_recv_time = 0;
    int rtu_ret = 0,tcp_ret = 0;
    //清空缓冲区

memset(modbus_tx_buf,0,1024);
    memset(modbus_rx_buf,0,300);

memset(modbus_tx_buf1,0,1024);
    memset(modbus_rx_buf1,0,300);

if (init_modbus)
    {
        init_modbus = 0;
        init_modbus_point_table(); //初始化点表

modbus_common_init(&g_modbus_rtu, modbus_tx_buf, 300, modbus_rx_buf, 300); /**<初始化moudbus_RTU*/
        g_modbus_rtu.slave = 1;

modbus_common_init(&g_modbus_tcp, modbus_tx_buf1, 1024, modbus_rx_buf1, 300); /**<初始化moudbus_TCP*/
//        _modbus_tcp_set_options(&g_modbus_tcp.info.sft);
        g_modbus_tcp.slave = 1;
#if 1
        /* 一个socket在使用前，需要预先创建出来，指定SOCK_STREAM为TCP的socket */
        if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
        {
            /* 创建失败的错误处理 */
            rt_kprintf("Socket error\n");
            /* 释放已分配的接收缓冲 */
        }

/* 初始化服务端地址 */
        server_addr.sin_family = AF_INET;
        server_addr.sin_port = htons(_MODBUD_TCP_PORT); /* 服务端工作的端口 */
        server_addr.sin_addr.s_addr = INADDR_ANY;
        rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));

/* 绑定socket到服务端地址 */
        if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
        {
            /* 绑定失败 */
            rt_kprintf("Unable to bind\n");
        }

/* 在socket上进行监听 */
        if (listen(sock, 5) == -1)
        {
            rt_kprintf("Listen error\n");
        }
#endif
    }
    else
    {

//RTU
        rtu_ret =  modbus_rtu_slave_handle(&g_modbus_rtu,&m_slave_util);
        if(rtu_ret)
        {
            hal_send_usart_data(1,g_modbus_rtu.send_buf, g_modbus_rtu.send_bufsz);
        }

//TCP
        if(net_sta == 0)
        {
            sin_size = sizeof(struct sockaddr_in);
            /* 接受一个客户端连接socket的请求，这个函数调用是阻塞式的 */
            g_modbus_tcp.info.sft.s = accept(sock, (struct sockaddr *)&client_addr, &sin_size);
            /* 返回的是连接成功的socket */
            if (g_modbus_tcp.info.sft.s < 0)
            {
                rt_kprintf("accept connection failed! errno = %d\r\n", errno);
                return;
            }
            else {
                rt_kprintf("accept connection ok!\r\n");
                net_sta = 1;
            }
        }
        else
        {
            tcp_ret =  modbus_tcp_slave_handle(&g_modbus_tcp,&m_slave_util);
            if(tcp_ret)
            {
                tcp_recv_time = get_sys_time_ms();
                _modbus_tcp_send(&g_modbus_tcp.info.sft,g_modbus_tcp.send_buf,g_modbus_tcp.send_bufsz);
            }

//10S 内如果还是没有接收到数据那么重新发起连接请求
            if(tcp_ret == 0 && get_interval_time(tcp_recv_time) > 1000)
            {
                net_sta = 0;
                closesocket(g_modbus_tcp.info.sft.s);
            }
        }
    }
    memset(g_modbus_tcp.send_buf,0,1024);
    memset(g_modbus_tcp.read_buf,0,300);
```