RT-Thread-串口DMA中断接收函数引用信号量获取keil编译有问题，RT-Thread Studio编译代码正常运行，求解惑RT-Thread问答社区

串口DMA中断接收函数引用信号量获取keil编译有问题，RT-Thread Studio编译代码正常运行，求解惑

发布于 2024-10-31 21:48:18 浏览：23 订阅该版

//DMA空闲中断回调函数里调用这个函数

```c
rt_err_t rx_callback3(rt_device_t dev, rt_size_t size)
{
    rt_size_t len = 0;
    rx_len = size;
    len = rt_device_read(u3_dev, 0, uart3_rx_buf, rx_len);
    rt_kprintf("COM data len %d = %d \n", len, rx_len );

for (int var = 0; var < len ; var++) {
        rt_kprintf("COM receive data%d = 0x%X  \n", var, uart3_rx_buf[var] );
    }
    if (rx_len != 0) {
	   //这个ringbuf_write函数内有信号量获取
        rt_size_t write_size = ringbuf_write(uart3_rx_ringbuf, uart3_rx_buf, rx_len, RT_WAITING_NO);
        if (write_size == rx_len) {
            rt_mq_send(uart3_rx_mq, &rx_len, sizeof(rt_size_t));
        } else {
            if (uart3_rx_ringbuf->bufFull) {
                uart_receive_size = 0;
                rt_mq_send(uart3_rx_mq, &uart_receive_size, sizeof(rt_size_t));
            }
            if (write_size == 0) {
                uart_receive_size = 0;
                rt_mq_send(uart3_rx_mq, &uart_receive_size, sizeof(rt_size_t));
            }
        }
    }

return RT_EOK;
}
```

ringbuf_write是同事网上找的代码，原先他用RT-Thread Studio编译，代码居然正常跑，我改keil编译之后在 信号量获取函数里面的 RT_ASSERT断言就通过不了，程序直接跑不了。虽然我修改代码可以解决问题，但是想不明白为什么一模一样的代码，RT-Thread Studio编译出来的程序能正常呢，keil的为啥不行！

```c
  /* parameter check */
    RT_ASSERT(sem != RT_NULL);
    RT_ASSERT(rt_object_get_type(&sem->parent.parent) == RT_Object_Class_Semaphore);
*/
```

```c
rt_size_t ringbuf_write(st_ringbuf_t rbt, void *buffer, rt_size_t size, rt_int32_t time)
{
    rt_size_t ret = 0;
    rt_size_t tailSize = 0;

if (rbt == RT_NULL)
    {
        LOG_D("Try to write a null ringbuf, abort.");        
        return 0;
    }

if (buffer == RT_NULL)
    {
        LOG_D("Input a null buffer in ringbuf_write, abort.");         
        return 0;
    }

/* take the sem succesfully, then space from the buffer. */
	//信号量获取在这里
    if (rt_sem_take(rbt->tx_sem, time) == RT_EOK)
    {
        /* test the bufFull flag, if the buf is full ,we quit now. */
        if (rbt->bufFull == RT_TRUE)
        {
            ret = 0;
        }
        else
        {
            /* buffer size is enough to write all obj. */
            if (size <= (rbt->bufMaxSize - rbt->bufNowSize))
            {
                tailSize = (rbt->tailIndex - rbt->txIndex + 1);

if (size <=  tailSize)
                {
                    rt_memcpy((rt_uint8_t *)rbt->head + rbt->txIndex * rbt->objSize, buffer, rbt->objSize * size);
                    rbt->txIndex += size;
                    rbt->bufNowSize += size;
                    ret = size;

if (rbt->txIndex - 1 == rbt->tailIndex)
                    {
                        rbt->txIndex = 0;
                    }
                }
                else
                {
                    rt_memcpy((rt_uint8_t *)rbt->head + rbt->txIndex * rbt->objSize, buffer, rbt->objSize * (tailSize));
                    ret += (tailSize);
                    rbt->bufNowSize += ret;
                    size -= ret;
                    rbt->txIndex = 0;
                    rt_memcpy((rt_uint8_t *)rbt->head, (rt_uint8_t *)buffer + ret * rbt->objSize, rbt->objSize * (size));
                    rbt->txIndex += size;
                    rbt->bufNowSize += size;
                    ret += size;
                }
            }
            else
            {
                /* we don't hanlde it when buffer size is not enough to write all objs. */
                ret = 0;
            }

/* test if buffr is full or empty, update the flag. */
            if (rbt->bufMaxSize == rbt->bufNowSize)
            {
                rbt->bufFull = RT_TRUE;
                rbt->bufEmpty = RT_FALSE;
            }
            else
            {
                rbt->bufFull = RT_FALSE;
            }

if (rbt->bufNowSize == 0)
            {
                rbt->bufEmpty = RT_TRUE;
                rbt->bufFull = RT_FALSE;
            }
            else
            {
                rbt->bufEmpty = RT_FALSE;
            }
        }
        rt_sem_release(rbt->tx_sem);
    }
    else
    {
        ret = 0;
    }

return ret;
}
```