基于rt thread 的信号量实现读写锁的控制结构体和相关API函数，要求条理清晰

首先，需要定义一个结构体来表示读写锁的控制结构，如下所示：

typedef struct rwlock
{
    rt_uint16_t read_count;   // 读者数量
    rt_uint16_t write_count;  // 写者数量
    rt_sem_t read_sem;        // 读信号量
    rt_sem_t write_sem;       // 写信号量
} rwlock_t;

其中，`read_count` 表示当前有多少个读者正在读取数据，`write_count` 表示当前有多少个写者正在修改数据，`read_sem` 是用来控制读者的信号量，`write_sem` 是用来控制写者的信号量。

接下来，定义相关的 API 函数：

void rwlock_init(rwlock_t *lock);
void rwlock_read_lock(rwlock_t *lock);
void rwlock_read_unlock(rwlock_t *lock);
void rwlock_write_lock(rwlock_t *lock);
void rwlock_write_unlock(rwlock_t *lock);

其中，`rwlock_init` 用于初始化读写锁，`rwlock_read_lock` 和 `rwlock_write_lock` 分别用于获取读锁和写锁，`rwlock_read_unlock` 和 `rwlock_write_unlock` 分别用于释放读锁和写锁。

下面是具体实现：

void rwlock_init(rwlock_t *lock)
{
    lock->read_count = 0;
    lock->write_count = 0;
    rt_sem_init(&(lock->read_sem), "read_sem", 0, RT_IPC_FLAG_FIFO);
    rt_sem_init(&(lock->write_sem), "write_sem", 1, RT_IPC_FLAG_FIFO);
}

void rwlock_read_lock(rwlock_t *lock)
{
    rt_sem_take(&(lock->write_sem), RT_WAITING_FOREVER);
    rt_atomic_inc(&(lock->read_count));
    if (lock->read_count == 1)
    {
        rt_sem_take(&(lock->read_sem), RT_WAITING_FOREVER);
    }
    rt_sem_release(&(lock->write_sem));
}

void rwlock_read_unlock(rwlock_t *lock)
{
    rt_atomic_dec(&(lock->read_count));
    if (lock->read_count == 0)
    {
        rt_sem_release(&(lock->read_sem));
    }
}

void rwlock_write_lock(rwlock_t *lock)
{
    rt_sem_take(&(lock->write_sem), RT_WAITING_FOREVER);
    rt_atomic_inc(&(lock->write_count));
    if (lock->write_count == 1)
    {
        rt_sem_take(&(lock->read_sem), RT_WAITING_FOREVER);
    }
    rt_sem_release(&(lock->write_sem));
}

void rwlock_write_unlock(rwlock_t *lock)
{
    rt_atomic_dec(&(lock->write_count));
    if (lock->write_count == 0)
    {
        rt_sem_release(&(lock->read_sem));
    }
}

在实现读锁和写锁的时候，需要注意以下几点：

1. 获取读锁时，需要先获取写锁，然后再增加读者数量，如果是第一个读者，需要获取读信号量。
2. 释放读锁时，需要减少读者数量，如果没有读者，需要释放读信号量。
3. 获取写锁时，需要先获取写锁，然后再增加写者数量，如果是第一个写者，需要获取读信号量。
4. 释放写锁时，需要减少写者数量，如果没有写者，需要释放读信号量。

这样就实现了一个基于 rt thread 的读写锁。