lby/mr-library
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1.优化格式。

Browse Source
This commit is contained in:
MacRsh
2023-06-19 00:31:37 +08:00
parent 71260176c2
commit 2e6c5df5a9
29 changed files with 417 additions and 383 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
README.md
View File

@@ -108,6 +108,7 @@ struct mr_object
事件服务器是一种异步事件处理机制,它通过事件分发和回调的方式,可以有效地提高系统的异步处理能力、解耦性和可扩展性。
事件服务器包含两个主要组件:事件服务器和事件客户端。
- 事件服务器用于接收和分发事件,它内部维护一个事件队列用于存储待处理事件和一个事件列表用于存储注册的事件客户端。
- 事件客户端用于处理特定类型的事件,它需要注册到事件服务器并提供一个回调函数。
@@ -137,16 +138,16 @@ struct mr_event_client
### 事件服务操作接口
| 接口 | 描述 |
|:-------------------------|:-----------------|
| mr_event_server_find | 从内核容器查找事件服务器 |
| mr_event_server_add | 添加事件服务器到内核容器 |
| mr_event_server_remove | 从内核容器移除事件服务器 |
| mr_event_server_notify | 通知事件服务器事件发生 |
| mr_event_server_handle | 事件服务器分发事件 |
| mr_event_client_find | 从事件服务器查找事件客户端 |
| mr_event_client_create | 创建事件客户端到事件服务器 |
| mr_client_delete | 从事件服务器移除事件客户端 |
| 接口 | 描述 |
|:-----------------------|:--------------|
| mr_event_server_find | 从内核容器查找事件服务器 |
| mr_event_server_add | 添加事件服务器到内核容器 |
| mr_event_server_remove | 从内核容器移除事件服务器 |
| mr_event_server_notify | 通知事件服务器事件发生 |
| mr_event_server_handle | 事件服务器分发事件 |
| mr_event_client_find | 从事件服务器查找事件客户端 |
| mr_event_client_create | 创建事件客户端到事件服务器 |
| mr_client_delete | 从事件服务器移除事件客户端 |
### 事件服务使用示例：
@@ -205,7 +206,9 @@ int main(void)
}
}
```
现象：
```c
event1_cb
event2_cb

15
bsp/wch/driver/drv_adc.c
View File

@@ -57,22 +57,18 @@ mr_err_t ch32_adc_channel_configure(mr_adc_t adc, struct mr_adc_config *config)
{
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
GPIOx = GPIOA;
}
else if (config->channel <= 10)
} else if (config->channel <= 10)
{
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
GPIOx = GPIOB;
}
else if (config->channel <= 15)
} else if (config->channel <= 15)
{
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
GPIOx = GPIOC;
}
else if (config->channel <= 17)
} else if (config->channel <= 17)
{
ADC_TempSensorVrefintCmd(ENABLE);
}
else
} else
{
return -MR_ERR_INVALID;
}
@@ -80,8 +76,7 @@ mr_err_t ch32_adc_channel_configure(mr_adc_t adc, struct mr_adc_config *config)
if (config->state == MR_ENABLE)
{
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
}
else
} else
{
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
}

15
bsp/wch/driver/drv_gpio.c
View File

@@ -149,34 +149,29 @@ static mr_err_t ch32_pin_configure(mr_pin_t pin, struct mr_pin_config *config)
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
else if (config->number == mask[config->number % 16])
} else if (config->number == mask[config->number % 16])
{
if (config->number % 16 >= 5 && config->number % 16 <= 9)
{
if (mask[5] == -1 && mask[6] == -1 && mask[7] == -1 && mask[8] == -1 && mask[9] == -1)
{
EXTI_InitStructure.EXTI_LineCmd = DISABLE;
}
else
} else
{
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
}
}
else if (config->number % 16 >= 10 && config->number % 16 <= 15)
} else if (config->number % 16 >= 10 && config->number % 16 <= 15)
{
if (mask[10] == -1 && mask[11] == -1 && mask[12] == -1 && mask[13] == -1 && mask[14] == -1
&& mask[15] == -1)
{
EXTI_InitStructure.EXTI_LineCmd = DISABLE;
}
else
} else
{
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
}
}
else
} else
{
EXTI_InitStructure.EXTI_LineCmd = DISABLE;
}

12
bsp/wch/driver/drv_spi.c
View File

@@ -89,8 +89,7 @@ static mr_err_t ch32_spi_configure(mr_spi_bus_t spi_bus, struct mr_spi_config *c
{
RCC_APB2PeriphClockCmd(driver->info.spi_periph_clock, ENABLE);
pclk_freq = RCC_ClockStruct.PCLK2_Frequency;
}
else
} else
{
RCC_APB1PeriphClockCmd(driver->info.spi_periph_clock, ENABLE);
pclk_freq = RCC_ClockStruct.PCLK1_Frequency;
@@ -100,8 +99,7 @@ static mr_err_t ch32_spi_configure(mr_spi_bus_t spi_bus, struct mr_spi_config *c
if (config->cs_active == MR_SPI_CS_ACTIVE_NONE)
{
SPI_InitStructure.SPI_NSS = SPI_NSS_Hard;
}
else
} else
{
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
}
@@ -158,8 +156,7 @@ static mr_err_t ch32_spi_configure(mr_spi_bus_t spi_bus, struct mr_spi_config *c
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(driver->info.gpio_port, &GPIO_InitStructure);
}
else
} else
{
SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
@@ -215,8 +212,7 @@ static void ch32_spi_cs_crtl(mr_spi_bus_t spi_bus, mr_uint16_t cs_pin, mr_uint8_
if (state == MR_ENABLE)
{
GPIO_WriteBit(PIN_STPORT(cs_pin), PIN_STPIN(cs_pin), spi_bus->config.cs_active);
}
else
} else
{
GPIO_WriteBit(PIN_STPORT(cs_pin), PIN_STPIN(cs_pin), !spi_bus->config.cs_active);
}

70
bsp/wch/driver/drv_timer.c
View File

@@ -193,8 +193,11 @@ static mr_uint32_t ch32_timer_get_count(mr_timer_t timer)
void TIM1_UP_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM1_UP_IRQHandler(void)
{
mr_timer_device_isr(&timer_device[TIMER1_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM1, TIM_IT_Update);
if (TIM_GetITStatus(TIM1, TIM_IT_Update) != RESET)
{
mr_timer_device_isr(&timer_device[TIMER1_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM1, TIM_IT_Update);
}
}
#endif
@@ -202,8 +205,11 @@ void TIM1_UP_IRQHandler(void)
void TIM2_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM2_IRQHandler(void)
{
mr_timer_device_isr(&timer_device[TIMER2_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
{
mr_timer_device_isr(&timer_device[TIMER2_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
}
}
#endif
@@ -211,8 +217,11 @@ void TIM2_IRQHandler(void)
void TIM3_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM3_IRQHandler(void)
{
mr_timer_device_isr(&timer_device[TIMER3_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)
{
mr_timer_device_isr(&timer_device[TIMER3_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
}
}
#endif
@@ -220,8 +229,11 @@ void TIM3_IRQHandler(void)
void TIM4_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM4_IRQHandler(void)
{
mr_timer_device_isr(&timer_device[TIMER4_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
{
mr_timer_device_isr(&timer_device[TIMER4_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
}
}
#endif
@@ -229,8 +241,11 @@ void TIM4_IRQHandler(void)
void TIM5_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM5_IRQHandler(void)
{
mr_timer_device_isr(&timer_device[TIMER5_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM5, TIM_IT_Update);
if(TIM_GetITStatus(TIM5, TIM_IT_Update) != RESET)
{
mr_timer_device_isr(&timer_device[TIMER5_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM5, TIM_IT_Update);
}
}
#endif
@@ -238,8 +253,11 @@ void TIM5_IRQHandler(void)
void TIM6_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM6_IRQHandler(void)
{
mr_timer_device_isr(&timer_device[TIMER6_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM6, TIM_IT_Update);
if(TIM_GetITStatus(TIM6, TIM_IT_Update) != RESET)
{
mr_timer_device_isr(&timer_device[TIMER6_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM6, TIM_IT_Update);
}
}
#endif
@@ -247,8 +265,11 @@ void TIM6_IRQHandler(void)
void TIM7_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM7_IRQHandler(void)
{
mr_timer_device_isr(&timer_device[TIMER7_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM7, TIM_IT_Update);
if(TIM_GetITStatus(TIM7, TIM_IT_Update) != RESET)
{
mr_timer_device_isr(&timer_device[TIMER7_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM7, TIM_IT_Update);
}
}
#endif
@@ -256,8 +277,11 @@ void TIM7_IRQHandler(void)
void TIM8_UP_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM8_UP_IRQHandler(void)
{
mr_timer_device_isr(&timer_device[TIMER8_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM8, TIM_IT_Update);
if (TIM_GetITStatus(TIM8, TIM_IT_Update) != RESET)
{
mr_timer_device_isr(&timer_device[TIMER8_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM8, TIM_IT_Update);
}
}
#endif
@@ -265,8 +289,11 @@ void TIM8_UP_IRQHandler(void)
void TIM9_UP_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM9_UP_IRQHandler(void)
{
mr_timer_device_isr(&timer_device[TIMER9_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM9, TIM_IT_Update);
if (TIM_GetITStatus(TIM9, TIM_IT_Update) != RESET)
{
mr_timer_device_isr(&timer_device[TIMER9_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM9, TIM_IT_Update);
}
}
#endif
@@ -274,8 +301,11 @@ void TIM9_UP_IRQHandler(void)
void TIM10_UP_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void TIM10_UP_IRQHandler(void)
{
mr_timer_device_isr(&timer_device[TIMER10_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM10, TIM_IT_Update);
if (TIM_GetITStatus(TIM10, TIM_IT_Update) != RESET)
{
mr_timer_device_isr(&timer_device[TIMER10_INDEX], MR_TIMER_EVENT_PIT_INT);
TIM_ClearITPendingBit(TIM10, TIM_IT_Update);
}
}
#endif

88
bsp/wch/driver/drv_uart.c
View File

@@ -266,113 +266,105 @@ static mr_uint8_t ch32_serial_read(mr_serial_t serial)
return 0;
}
static void ch32_serial_start_tx(mr_serial_t serial)
{
struct ch32_uart *driver = (struct ch32_uart *)serial->device.data;
USART_ITConfig(driver->info.Instance, USART_IT_TXE, ENABLE);
}
static void ch32_serial_stop_tx(mr_serial_t serial)
{
struct ch32_uart *driver = (struct ch32_uart *)serial->device.data;
USART_ITConfig(driver->info.Instance, USART_IT_TXE, DISABLE);
}
static void ch32_serial_isr(mr_serial_t serial)
{
struct ch32_uart *driver = (struct ch32_uart *)serial->device.data;
if (USART_GetITStatus(driver->info.Instance, USART_IT_RXNE) != RESET)
{
mr_serial_device_isr(serial, MR_SERIAL_EVENT_RX_INT);
USART_ClearITPendingBit(driver->info.Instance, USART_IT_RXNE);
}
if (USART_GetITStatus(driver->info.Instance, USART_IT_TXE) != RESET)
{
mr_serial_device_isr(serial, MR_SERIAL_EVENT_TX_INT);
USART_ClearITPendingBit(driver->info.Instance, USART_IT_TXE);
}
}
#ifdef BSP_UART_1
void USART1_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void USART1_IRQHandler(void)
{
ch32_serial_isr(&serial_device[UART1_INDEX]);
if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
{
mr_serial_device_isr(&serial_device[UART1_INDEX], MR_SERIAL_EVENT_RX_INT);
USART_ClearITPendingBit(USART1, USART_IT_RXNE);
}
}
#endif
#ifdef BSP_UART_2
void USART2_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void USART2_IRQHandler(void)
{
ch32_serial_isr(&serial_device[UART2_INDEX]);
if (USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
{
mr_serial_device_isr(&serial_device[UART2_INDEX], MR_SERIAL_EVENT_RX_INT);
USART_ClearITPendingBit(USART2, USART_IT_RXNE);
}
}
#endif
#ifdef BSP_UART_3
void USART3_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void USART3_IRQHandler(void)
{
ch32_serial_isr(&serial_device[UART3_INDEX]);
if (USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
{
mr_serial_device_isr(&serial_device[UART3_INDEX], MR_SERIAL_EVENT_RX_INT);
USART_ClearITPendingBit(USART3, USART_IT_RXNE);
}
}
#endif
#ifdef BSP_UART_4
void UART4_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void UART4_IRQHandler(void)
{
ch32_serial_isr(&serial_device[UART4_INDEX]);
if (USART_GetITStatus(UART4, USART_IT_RXNE) != RESET)
{
mr_serial_device_isr(&serial_device[UART4_INDEX], MR_SERIAL_EVENT_RX_INT);
}
}
#endif
#ifdef BSP_UART_5
void UART5_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void UART5_IRQHandler(void)
{
ch32_serial_isr(&serial_device[UART5_INDEX]);
if (USART_GetITStatus(UART5, USART_IT_RXNE) != RESET)
{
mr_serial_device_isr(&serial_device[UART5_INDEX], MR_SERIAL_EVENT_RX_INT);
USART_ClearITPendingBit(UART5, USART_IT_RXNE);
}
}
#endif
#ifdef BSP_UART_6
void UART6_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void UART6_IRQHandler(void)
{
ch32_serial_isr(&serial_device[UART6_INDEX]);
if (USART_GetITStatus(UART6, USART_IT_RXNE) != RESET)
{
mr_serial_device_isr(&serial_device[UART6_INDEX], MR_SERIAL_EVENT_RX_INT);
USART_ClearITPendingBit(UART6, USART_IT_RXNE);
}
}
#endif
#ifdef BSP_UART_7
void UART7_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void UART7_IRQHandler(void)
{
ch32_serial_isr(&serial_device[UART7_INDEX]);
if (USART_GetITStatus(UART7, USART_IT_RXNE) != RESET)
{
mr_serial_device_isr(&serial_device[UART7_INDEX], MR_SERIAL_EVENT_RX_INT);
USART_ClearITPendingBit(UART7, USART_IT_RXNE);
}
}
#endif
#ifdef BSP_UART_8
void UART8_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void UART8_IRQHandler(void)
{
ch32_serial_isr(&serial_device[UART8_INDEX]);
if (USART_GetITStatus(UART8, USART_IT_RXNE) != RESET)
{
mr_serial_device_isr(&serial_device[UART8_INDEX], MR_SERIAL_EVENT_RX_INT);
USART_ClearITPendingBit(UART8, USART_IT_RXNE);
}
}
#endif
@@ -386,8 +378,6 @@ mr_err_t ch32_uart_init(void)
ch32_serial_configure,
ch32_serial_write,
ch32_serial_read,
ch32_serial_start_tx,
ch32_serial_stop_tx,
};
while (count--)

2
device/adc/adc.c
View File

@@ -63,7 +63,7 @@ static mr_ssize_t mr_adc_read(mr_device_t device, mr_off_t pos, void *buffer, mr
recv_buffer++;
}
return (mr_ssize_t)size;
return (mr_ssize_t)recv_size;
}
static mr_err_t _err_io_adc_configure(mr_adc_t adc, mr_uint8_t state)

2
device/dac/dac.c
View File

@@ -63,7 +63,7 @@ static mr_ssize_t mr_dac_write(mr_device_t device, mr_off_t pos, const void *buf
send_buffer++;
}
return (mr_ssize_t)size;
return (mr_ssize_t)send_size;
}
static mr_err_t _err_io_dac_configure(mr_dac_t dac, mr_uint8_t state)

68
device/i2c/i2c.c
View File

@@ -84,21 +84,18 @@ static void mr_i2c_bus_send_address(mr_i2c_device_t i2c_device, mr_uint8_t read_
{
i2c_device->bus->ops->write(i2c_device->bus, (mr_uint8_t)(0xf1 | ((i2c_device->address) >> 8) << 1));
i2c_device->bus->ops->write(i2c_device->bus, (mr_uint8_t)(i2c_device->address << 2));
}
else
} else
{
i2c_device->bus->ops->write(i2c_device->bus, (mr_uint8_t)(i2c_device->address << 1 | 0x01));
}
}
else
} else
{
/* Send the write address signal */
if (i2c_device->config.address_mode == MR_I2C_ADDRESS_MODE_10)
{
i2c_device->bus->ops->write(i2c_device->bus, (mr_uint8_t)(0xf0 | ((i2c_device->address) >> 8) << 1));
i2c_device->bus->ops->write(i2c_device->bus, (mr_uint8_t)(i2c_device->address << 2));
}
else
} else
{
i2c_device->bus->ops->write(i2c_device->bus, (mr_uint8_t)(i2c_device->address << 1));
}
@@ -110,7 +107,7 @@ static mr_err_t mr_i2c_bus_open(mr_device_t device)
mr_i2c_bus_t i2c_bus = (mr_i2c_bus_t)device;
struct mr_i2c_config default_config = MR_I2C_CONFIG_DEFAULT;
/* Setting i2c-bus to default-config */
/* Setting i2c-bus to default config, if the baud-rate not set */
if (i2c_bus->config.baud_rate == 0)
{
i2c_bus->config = default_config;
@@ -123,7 +120,7 @@ static mr_err_t mr_i2c_bus_close(mr_device_t device)
{
mr_i2c_bus_t i2c_bus = (mr_i2c_bus_t)device;
/* Setting i2c-bus to close-config */
/* Setting i2c-bus to close config */
i2c_bus->config.baud_rate = 0;
return i2c_bus->ops->configure(i2c_bus, &i2c_bus->config);
@@ -134,7 +131,7 @@ static mr_err_t mr_i2c_device_open(mr_device_t device)
mr_i2c_device_t i2c_device = (mr_i2c_device_t)device;
struct mr_i2c_config default_config = MR_I2C_CONFIG_DEFAULT;
/* Setting i2c-device to default-config */
/* Setting i2c-device to default config, if the baud-rate not set */
if (i2c_device->config.baud_rate == 0)
{
i2c_device->config = default_config;
@@ -147,7 +144,7 @@ static mr_err_t mr_i2c_device_close(mr_device_t device)
{
mr_i2c_device_t i2c_device = (mr_i2c_device_t)device;
/* Setting i2c-device to close-config */
/* Setting i2c-device to close config */
i2c_device->config.baud_rate = 0;
/* Disconnect from the i2c-bus */
@@ -159,6 +156,7 @@ static mr_err_t mr_i2c_device_close(mr_device_t device)
static mr_err_t mr_i2c_device_ioctl(mr_device_t device, int cmd, void *args)
{
mr_i2c_device_t i2c_device = (mr_i2c_device_t)device;
mr_err_t ret = MR_ERR_OK;
switch (cmd & _MR_CTRL_FLAG_MASK)
{
@@ -193,7 +191,11 @@ static mr_err_t mr_i2c_device_ioctl(mr_device_t device, int cmd, void *args)
}
/* Open the i2c-bus */
mr_device_open(i2c_bus, MR_OPEN_RDWR);
ret = mr_device_open(i2c_bus, MR_OPEN_RDWR);
if (ret != MR_ERR_OK)
{
return ret;
}
i2c_device->bus = (mr_i2c_bus_t)i2c_bus;
return MR_ERR_OK;
}
@@ -214,7 +216,6 @@ static mr_ssize_t mr_i2c_device_read(mr_device_t device, mr_off_t pos, void *buf
ret = mr_take_i2c_bus(i2c_device);
if (ret != MR_ERR_OK)
{
MR_LOG_E("Device %s: Failed to take i2c-bus\r\n", device->object.name);
return ret;
}
@@ -229,16 +230,16 @@ static mr_ssize_t mr_i2c_device_read(mr_device_t device, mr_off_t pos, void *buf
/* Send the i2c-bus read command */
mr_i2c_bus_send_address(i2c_device, _MR_I2C_READ);
for (recv_size = 0; recv_size < size; recv_size++)
for (recv_size = 0; recv_size < size; recv_size += sizeof(*recv_buffer))
{
*recv_buffer = i2c_device->bus->ops->read(i2c_device->bus, (mr_state_t)(recv_size == 0));
*recv_buffer = i2c_device->bus->ops->read(i2c_device->bus, (recv_size == 0));
recv_buffer++;
}
/* Release i2c-bus */
mr_release_i2c_bus(i2c_device);
return (mr_ssize_t)size;
return (mr_ssize_t)recv_size;
}
static mr_ssize_t mr_i2c_device_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size)
@@ -252,7 +253,6 @@ static mr_ssize_t mr_i2c_device_write(mr_device_t device, mr_off_t pos, const vo
ret = mr_take_i2c_bus(i2c_device);
if (ret != MR_ERR_OK)
{
MR_LOG_E("Device %s: Failed to take i2c-bus\r\n", device->object.name);
return ret;
}
@@ -265,7 +265,7 @@ static mr_ssize_t mr_i2c_device_write(mr_device_t device, mr_off_t pos, const vo
i2c_device->bus->ops->write(i2c_device->bus, (mr_uint8_t)pos);
}
for (send_size = 0; send_size < size; send_size++)
for (send_size = 0; send_size < size; send_size += sizeof(*send_buffer))
{
i2c_device->bus->ops->write(i2c_device->bus, *send_buffer);
send_buffer++;
@@ -274,7 +274,7 @@ static mr_ssize_t mr_i2c_device_write(mr_device_t device, mr_off_t pos, const vo
/* Release i2c-bus */
mr_release_i2c_bus(i2c_device);
return (mr_ssize_t)size;
return (mr_ssize_t)send_size;
}
static mr_err_t _err_io_i2c_configure(mr_i2c_bus_t i2c_bus, struct mr_i2c_config *config)
@@ -298,7 +298,7 @@ static void _err_io_i2c_write(mr_i2c_bus_t i2c_bus, mr_uint8_t data)
MR_ASSERT(0);
}
static mr_uint8_t _err_io_i2c_read(mr_i2c_bus_t i2c_bus, mr_state_t ack_state)
static mr_uint8_t _err_io_i2c_read(mr_i2c_bus_t i2c_bus, mr_uint8_t ack_state)
{
MR_ASSERT(0);
return 0;
@@ -364,6 +364,23 @@ mr_err_t mr_i2c_device_add(mr_i2c_device_t i2c_device,
MR_ASSERT(support_flag != MR_OPEN_CLOSED);
MR_ASSERT(bus_name != MR_NULL);
/* Attach the i2c-device to the i2c-bus */
mr_device_t i2c_bus = mr_device_find(bus_name);
if (i2c_bus == MR_NULL)
{
return -MR_ERR_NOT_FOUND;
}
if (i2c_bus->type != MR_DEVICE_TYPE_I2C_BUS)
{
return -MR_ERR_INVALID;
}
ret = mr_device_open(i2c_bus, MR_OPEN_RDWR);
if (ret != MR_ERR_OK)
{
return ret;
}
i2c_device->bus = (mr_i2c_bus_t)i2c_bus;
/* Add the i2c-device to the container */
ret = mr_device_add(&i2c_device->device, name, MR_DEVICE_TYPE_I2C, support_flag, &device_ops, MR_NULL);
if (ret != MR_ERR_OK)
@@ -376,19 +393,6 @@ mr_err_t mr_i2c_device_add(mr_i2c_device_t i2c_device,
i2c_device->bus = MR_NULL;
i2c_device->address = address;
/* Attach the i2c-device to the i2c-bus */
mr_device_t i2c_bus = mr_device_find(bus_name);
if (i2c_bus == MR_NULL)
{
return -MR_ERR_NOT_FOUND;
}
if (i2c_bus->type != MR_DEVICE_TYPE_I2C_BUS)
{
return -MR_ERR_INVALID;
}
mr_device_open(i2c_bus, MR_OPEN_RDWR);
i2c_device->bus = (mr_i2c_bus_t)i2c_bus;
return MR_ERR_OK;
}

3
device/i2c/i2c.h
View File

@@ -32,7 +32,6 @@
struct mr_i2c_config
{
mr_uint32_t baud_rate;
mr_uint8_t host_slave;
mr_uint8_t address_mode;
};
@@ -55,7 +54,7 @@ struct mr_i2c_bus_ops
void (*start)(mr_i2c_bus_t i2c_bus);
void (*stop)(mr_i2c_bus_t i2c_bus);
void (*write)(mr_i2c_bus_t i2c_bus, mr_uint8_t data);
mr_uint8_t (*read)(mr_i2c_bus_t i2c_bus, mr_state_t ack_state);
mr_uint8_t (*read)(mr_i2c_bus_t i2c_bus, mr_uint8_t ack_state);
};
struct mr_i2c_bus

21
device/pin/pin.c
View File

@@ -23,8 +23,7 @@ static mr_err_t mr_pin_ioctl(mr_device_t device, int cmd, void *args)
{
if (args)
{
ret = pin->ops->configure(pin, args);
return ret;
return pin->ops->configure(pin, (struct mr_pin_config *)args);
}
return -MR_ERR_INVALID;
}
@@ -44,30 +43,40 @@ static mr_ssize_t mr_pin_read(mr_device_t device, mr_off_t pos, void *buffer, mr
{
mr_pin_t pin = (mr_pin_t)device;
mr_uint8_t *recv_buffer = (mr_uint8_t *)buffer;
mr_size_t recv_size = 0;
if (size < sizeof(*recv_buffer))
{
return -MR_ERR_INVALID;
}
*recv_buffer = pin->ops->read(pin, (mr_uint16_t)pos);
for (recv_size = 0; recv_size < size; recv_size += sizeof(*recv_buffer))
{
*recv_buffer = pin->ops->read(pin, (mr_uint16_t)pos);
recv_buffer++;
}
return (mr_ssize_t)sizeof(*recv_buffer);
return (mr_ssize_t)recv_size;
}
static mr_ssize_t mr_pin_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size)
{
mr_pin_t pin = (mr_pin_t)device;
mr_uint8_t *send_buffer = (mr_uint8_t *)buffer;
mr_size_t send_size = 0;
if (size < sizeof(*send_buffer))
{
return -MR_ERR_INVALID;
}
pin->ops->write(pin, (mr_uint16_t)pos, *send_buffer);
for (send_size = 0; send_size < size; send_size += sizeof(*send_buffer))
{
pin->ops->write(pin, (mr_uint16_t)pos, *send_buffer);
send_buffer++;
}
return (mr_ssize_t)sizeof(*send_buffer);
return (mr_ssize_t)send_size;
}
static mr_err_t _err_io_pin_configure(mr_pin_t pin, struct mr_pin_config *config)

55
device/spi/spi.c
View File

@@ -80,7 +80,7 @@ static mr_err_t mr_spi_bus_open(mr_device_t device)
mr_spi_bus_t spi_bus = (mr_spi_bus_t)device;
struct mr_spi_config default_config = MR_SPI_CONFIG_DEFAULT;
/* Setting spi-bus to default-config */
/* Setting spi-bus to default config, if the baud-rate not set */
if (spi_bus->config.baud_rate == 0)
{
spi_bus->config = default_config;
@@ -93,7 +93,7 @@ static mr_err_t mr_spi_bus_close(mr_device_t device)
{
mr_spi_bus_t spi_bus = (mr_spi_bus_t)device;
/* Setting spi-bus to close-config */
/* Setting spi-bus to close config */
spi_bus->config.baud_rate = 0;
return spi_bus->ops->configure(spi_bus, &spi_bus->config);
@@ -104,7 +104,7 @@ static mr_err_t mr_spi_device_open(mr_device_t device)
mr_spi_device_t spi_device = (mr_spi_device_t)device;
struct mr_spi_config default_config = MR_SPI_CONFIG_DEFAULT;
/* Setting spi-device to default-config */
/* Setting spi-device to default config, if the baud-rate not set */
if (spi_device->config.baud_rate == 0)
{
spi_device->config = default_config;
@@ -117,7 +117,7 @@ static mr_err_t mr_spi_device_close(mr_device_t device)
{
mr_spi_device_t spi_device = (mr_spi_device_t)device;
/* Setting spi-device to close-config */
/* Setting spi-device to close config */
spi_device->config.baud_rate = 0;
/* Disconnect from the spi-bus */
@@ -166,7 +166,11 @@ static mr_err_t mr_spi_device_ioctl(mr_device_t device, int cmd, void *args)
}
/* Open the spi-bus */
mr_device_open(spi_bus, MR_OPEN_RDWR);
ret = mr_device_open(spi_bus, MR_OPEN_RDWR);
if (ret != MR_ERR_OK)
{
return ret;
}
spi_device->bus = (mr_spi_bus_t)spi_bus;
return MR_ERR_OK;
}
@@ -228,7 +232,7 @@ static mr_ssize_t mr_spi_device_read(mr_device_t device, mr_off_t pos, void *buf
spi_device->bus->ops->transfer(spi_device->bus, (mr_uint8_t)pos);
}
for (recv_size = 0; recv_size < size; recv_size++)
for (recv_size = 0; recv_size < size; recv_size += sizeof(recv_buffer))
{
*recv_buffer = spi_device->bus->ops->transfer(spi_device->bus, 0u);
recv_buffer++;
@@ -237,7 +241,7 @@ static mr_ssize_t mr_spi_device_read(mr_device_t device, mr_off_t pos, void *buf
/* Release spi-bus */
mr_release_spi_bus(spi_device);
return (mr_ssize_t)size;
return (mr_ssize_t)recv_size;
}
static mr_ssize_t mr_spi_device_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size)
@@ -260,7 +264,7 @@ static mr_ssize_t mr_spi_device_write(mr_device_t device, mr_off_t pos, const vo
spi_device->bus->ops->transfer(spi_device->bus, (mr_uint8_t)pos);
}
for (send_size = 0; send_size < size; send_size++)
for (send_size = 0; send_size < size; send_size += sizeof(send_buffer))
{
spi_device->bus->ops->transfer(spi_device->bus, *send_buffer);
send_buffer++;
@@ -269,7 +273,7 @@ static mr_ssize_t mr_spi_device_write(mr_device_t device, mr_off_t pos, const vo
/* Release spi-bus */
mr_release_spi_bus(spi_device);
return (mr_ssize_t)size;
return (mr_ssize_t)send_size;
}
static mr_err_t _err_io_spi_configure(mr_spi_bus_t spi_bus, struct mr_spi_config *config)
@@ -342,8 +346,7 @@ mr_err_t mr_spi_device_add(mr_spi_device_t spi_device,
mr_spi_device_write,
};
#if (MR_CONF_PIN == MR_CONF_ENABLE)
struct mr_pin_config pin_config = {cs_pin,
MR_PIN_MODE_OUTPUT};
struct mr_pin_config pin_config = {cs_pin, MR_PIN_MODE_OUTPUT};
mr_device_t pin = MR_NULL;
#endif
@@ -353,6 +356,23 @@ mr_err_t mr_spi_device_add(mr_spi_device_t spi_device,
MR_ASSERT(support_flag != MR_OPEN_CLOSED);
MR_ASSERT(bus_name != MR_NULL);
/* Attach the spi-device to the spi-bus */
mr_device_t spi_bus = mr_device_find(bus_name);
if (spi_bus == MR_NULL)
{
return -MR_ERR_NOT_FOUND;
}
if (spi_bus->type != MR_DEVICE_TYPE_SPI_BUS)
{
return -MR_ERR_INVALID;
}
ret = mr_device_open(spi_bus, MR_OPEN_RDWR);
if (ret != MR_ERR_OK)
{
return ret;
}
spi_device->bus = (mr_spi_bus_t)spi_bus;
/* Add the spi-device to the container */
ret = mr_device_add(&spi_device->device, name, MR_DEVICE_TYPE_SPI, support_flag, &device_ops, MR_NULL);
if (ret != MR_ERR_OK)
@@ -365,19 +385,6 @@ mr_err_t mr_spi_device_add(mr_spi_device_t spi_device,
spi_device->bus = MR_NULL;
spi_device->cs_pin = cs_pin;
/* Attach the spi-device to the spi-bus */
mr_device_t spi_bus = mr_device_find(bus_name);
if (spi_bus == MR_NULL)
{
return -MR_ERR_NOT_FOUND;
}
if (spi_bus->type != MR_DEVICE_TYPE_SPI_BUS)
{
return -MR_ERR_INVALID;
}
mr_device_open(spi_bus, MR_OPEN_RDWR);
spi_device->bus = (mr_spi_bus_t)spi_bus;
#if (MR_CONF_PIN == MR_CONF_ENABLE)
/* Configure pin */
pin = mr_device_find("pin");

1
device/spi/spi.h
View File

@@ -43,7 +43,6 @@
struct mr_spi_config
{
mr_uint32_t baud_rate;
mr_uint8_t host_slave;
mr_uint8_t mode;
mr_uint8_t bit_order;

46
document/developer/device/pin.md
View File

@@ -7,13 +7,13 @@
1. 从[仓库](https://gitee.com/MacRsh/mr-library.git)获取最新的代码。
2. 整理文件仅保留必要的文件：
| 名称 | 描述 |
|:-----------|:-----|
| mr_library | |
| -device | 设备文件 |
| -driver | 驱动文件 |
| -include | 库头文件 |
| -src | 库源文件 |
| 名称 | 描述 |
|:-----------|:-----|
| mr_library | |
| -device | 设备文件 |
| -driver | 驱动文件 |
| -include | 库头文件 |
| -src | 库源文件 |
3. 在`mrboard.h`中添加芯片头文件，并为适配的芯片添加支持的宏：BSP_GPIO_x。
4. 在`driver`目录中新建名为`drv_gpio.c`和`drv_gpio.h`，并添加版权信息：
```c
@@ -38,27 +38,28 @@
## 注册PIN设备
以CH32为例，将前缀修改为适配的型号即可，如果您有关于硬件的信息需要引入，请在`mr_pin_device_add`函数`data`参数中传入（注意使用模板时请去除中文注释）：
以CH32为例，将前缀修改为适配的型号即可，如果您有关于硬件的信息需要引入，请在`mr_pin_device_add`函数`data`
参数中传入（注意使用模板时请去除中文注释）：
```c
/* 定义pin驱动 */
static struct mr_pin pin_driver;
static struct mr_pin pin_device;
/* 注册pin设备 */
mr_err_t ch32_gpio_init(void)
{
mr_err_t ret = MR_ERR_OK;
static struct mr_pin_ops ops =
{
ch32_pin_configure,
ch32_pin_write,
ch32_pin_read,
};
mr_err_t ret = MR_ERR_OK;
static struct mr_pin_ops ops =
{
ch32_pin_configure,
ch32_pin_write,
ch32_pin_read,
};
ret = mr_pin_device_add(&pin_driver, "pin", &ops, MR_NULL);
MR_ASSERT(ret == MR_ERR_OK);
ret = mr_pin_device_add(&pin_device, "pin", &ops, MR_NULL);
MR_ASSERT(ret == MR_ERR_OK);
return MR_ERR_OK;
return MR_ERR_OK;
}
/* 导出到驱动自动初始化 */
AUTO_INIT_DRIVER_EXPORT(ch32_gpio_init);
@@ -128,7 +129,7 @@ struct mr_pin_config
#define
MR_PIN_MODE_HIGH /* 高电平触发 */
````
注意模式配置时，请定义一个数组，用于存储外部中断源是哪个GPIO，-1代表未被占用。
注意模式配置时，请定义一个数组，用于存储外部中断源是哪个GPIO，-1代表未被占用。
```c
static mr_int32_t mask[16] = {-1,
-1,
@@ -147,7 +148,7 @@ struct mr_pin_config
-1,
-1};
```
#### write
```c
@@ -169,6 +170,7 @@ static mr_uint8_t ch32_pin_read(mr_pin_t pin, mr_uint16_t number)
#### 中断回调函数
以CH32为例，在中断中调用以下函数完成框架对中断的接管：
```c
void mr_pin_device_isr(mr_pin_t pin, mr_int32_t number)
```
@@ -181,7 +183,7 @@ void EXTI0_IRQHandler(void)
{
if (EXTI_GetITStatus(EXTI_Line0) != RESET)
{
mr_pin_device_isr(&pin_driver, mask[0]);
mr_pin_device_isr(&pin_device, mask[0]);
EXTI_ClearITPendingBit(EXTI_Line0);
}
}

1
document/user/device/adc.md
View File

@@ -77,6 +77,7 @@ struct mr_adc_config
```
使用示例如下所示:
```c
/* 寻找ADC1设备 */
mr_device_t adc_device = mr_device_find("adc1");

17
document/user/device/dac.md
View File

@@ -96,18 +96,19 @@ mr_device_ioctl(dac_device, MR_CTRL_CONFIG, &dac_config);
mr_ssize_t mr_device_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size);
```
| 参数 | 描述 |
|:-----------|:--------|
| device | DAC设备句柄 |
| pos | 写入位置 |
| buffer | 写入数据 |
| size | 写入数据大小 |
| **返回** | |
| 实际写入的数据大小 | |
| 参数 | 描述 |
|:----------|:--------|
| device | DAC设备句柄 |
| pos | 写入位置 |
| buffer | 写入数据 |
| size | 写入数据大小 |
| **返回** | |
| 实际写入的数据大小 | |
**写入位置**:指需要写入数据的通道。
使用示例如下所示:
```c
/* 设置DAC1通道3值为1200 */
mr_uint32_t dac_value = 1200;

2
document/user/device/pin.md
View File

@@ -71,7 +71,7 @@ struct mr_pin_config
```
- 编号:`mr-library`对GPIO进行编码，计算公式(端口号,引脚号) `->` ('A' - 端口号) * 16 + 引脚号，例如 B13 = 1 * 16 + 13 =
29。
29。
- 模式:支持对GPIO进行普通和中断模式配置。
```c

48
document/user/event_server.md
View File

@@ -3,6 +3,7 @@
事件服务器是一种异步事件处理机制,它通过事件分发和回调的方式,可以有效地提高系统的异步处理能力、解耦性和可扩展性。
事件服务器包含两个主要组件:事件服务器和事件客户端。
- 事件服务器用于接收和分发事件,它内部维护一个事件队列用于存储待处理事件和一个事件列表用于存储注册的事件客户端。
- 事件客户端用于处理特定类型的事件,它需要注册到事件服务器并提供一个回调函数。
@@ -74,12 +75,12 @@ mr_err_t mr_event_server_add(mr_event_server_t server, const char *name, mr_size
mr_err_t mr_event_server_remove(mr_event_server_t server);
```
| 参数 | 描述 |
|:-------------|:------|
| server | 服务器句柄 |
| **返回** | |
| MR_ERR_OK | 移除成功 |
| 错误码 | 移除失败 |
| 参数 | 描述 |
|:----------|:------|
| server | 服务器句柄 |
| **返回** | |
| MR_ERR_OK | 移除成功 |
| 错误码 | 移除失败 |
### 通知服务器，事件发生
@@ -87,13 +88,13 @@ mr_err_t mr_event_server_remove(mr_event_server_t server);
mr_err_t mr_event_server_notify(mr_event_server_t server, mr_uint8_t id);
```
| 参数 | 描述 |
|:-------------|:-----------|
| server | 服务器句柄 |
| id | 发生事件的客户端id |
| **返回** | |
| MR_ERR_OK | 通知成功 |
| 错误码 | 通知失败 |
| 参数 | 描述 |
|:----------|:-----------|
| server | 服务器句柄 |
| id | 发生事件的客户端id |
| **返回** | |
| MR_ERR_OK | 通知成功 |
| 错误码 | 通知失败 |
### 服务器分发事件，唤醒客户端
@@ -101,9 +102,9 @@ mr_err_t mr_event_server_notify(mr_event_server_t server, mr_uint8_t id);
void mr_event_server_handle(mr_event_server_t server);
```
| 参数 | 描述 |
|:-------------|:------|
| server | 服务器句柄 |
| 参数 | 描述 |
|:-------|:------|
| server | 服务器句柄 |
### 查找客户端
@@ -111,14 +112,13 @@ void mr_event_server_handle(mr_event_server_t server);
mr_event_client_t mr_event_client_find(mr_uint8_t id, mr_event_server_t server);
```
| 参数 | 描述 |
|:---------|:------|
| id | 客户端id |
| server | 服务器句柄 |
| **返回** | |
| 客户端句柄 | 查找成功 |
| MR_NULL | 查找失败 |
| 参数 | 描述 |
|:--------|:------|
| id | 客户端id |
| server | 服务器句柄 |
| **返回** | |
| 客户端句柄 | 查找成功 |
| MR_NULL | 查找失败 |
### 创建新客户端

1
document/user/usage_guide.md
View File

@@ -43,6 +43,7 @@
----------
## 剩余文档目录
| 名称 | 描述 |
|:---------------|:-------|
| document | |

4
driver/mrdrv.h
View File

@@ -33,6 +33,10 @@
#include "drv_dac.h"
#endif /* MR_CONF_DAC */
#if (MR_CONF_TIMER == MR_CONF_ENABLE)
#include "drv_timer.h"
#endif /* MR_CONF_TIMER */
#if (MR_CONF_I2C == MR_CONF_ENABLE)
#include "drv_i2c.h"
#endif /* MR_CONF_I2C */

10
include/mrdef.h
View File

@@ -180,21 +180,20 @@ struct mr_avl
struct mr_avl *left_child; /* Point to left-child node */
struct mr_avl *right_child; /* Point to right-child node */
};
typedef struct mr_avl *mr_avl_t; /* Type for list-tree */
typedef struct mr_avl *mr_avl_t; /* Type for avl-tree */
/**
* Fifo
*/
struct mr_fifo
{
mr_uint8_t *buffer; /* Buffer pool */
mr_uint16_t read_mirror: 1; /* Read mirror flag */
mr_uint16_t read_index: 15; /* Read index */
mr_uint16_t write_mirror: 1; /* Write mirror flag */
mr_uint16_t write_index: 15; /* Write index */
mr_uint16_t size; /* Buffer pool size */
mr_uint8_t *buffer; /* Buffer pool */
};
typedef struct mr_fifo *mr_fifo_t; /* Type for fifo */
@@ -220,9 +219,8 @@ enum mr_container_type
struct mr_container
{
struct mr_list list; /* Container list */
enum mr_container_type type; /* Container type */
struct mr_list list; /* Container list */
};
typedef struct mr_container *mr_container_t; /* Type for container */
@@ -231,7 +229,7 @@ typedef struct mr_container *mr_container_t; /* Type for
*/
struct mr_object
{
char name[MR_CONF_NAME_MAX + 1]; /* Object name */
char name[MR_CONF_NAME_MAX]; /* Object name */
struct mr_list list; /* Object list */
};
typedef struct mr_object *mr_object_t; /* Type for object */

62
package/fifo/README.md
View File

@@ -18,9 +18,9 @@ void fifo_init(fifo_t fifo, void *pool, size_t pool_size);
void fifo_reset(fifo_t fifo);
```
| 参数 | 描述 |
|:-----|:---------|
| fifo | FIFO句柄 |
| 参数 | 描述 |
|:-----|:-------|
| fifo | FIFO句柄 |
### 获取FIFO缓存的数据大小
@@ -28,11 +28,11 @@ void fifo_reset(fifo_t fifo);
size_t fifo_get_data_size(fifo_t fifo);
```
| 参数 | 描述 |
|:----------|:--------|
| fifo | FIFO句柄 |
| **返回** | |
| size | 缓存的数据大小 |
| 参数 | 描述 |
|:-------|:--------|
| fifo | FIFO句柄 |
| **返回** | |
| size | 缓存的数据大小 |
### 从FIFO缓存读取数据
@@ -40,41 +40,41 @@ size_t fifo_get_data_size(fifo_t fifo);
size_t fifo_read(fifo_t fifo, void *buffer, size_t size);
```
| 参数 | 描述 |
|:--------|:-----------------|
| fifo | FIFO句柄 |
| buffer | 要从FIFO缓存读取的数据缓冲区 |
| size | 读取大小 |
| **返回** | |
| size | 实际读取的数据大小 |
| 参数 | 描述 |
|:-------|:-----------------|
| fifo | FIFO句柄 |
| buffer | 要从FIFO缓存读取的数据缓冲区 |
| size | 读取大小 |
| **返回** | |
| size | 实际读取的数据大小 |
### 向FIFO缓存写入数据
### 向FIFO缓存写入数据
```c
size_t fifo_write(fifo_t fifo, const void *buffer, size_t size);
```
| 参数 | 描述 |
|:----------|:----------------|
| fifo | FIFO句柄 |
| buffer | 要写入FIFO缓存的数据缓冲区 |
| size | 写入大小 |
| **返回** | |
| size | 实际写入的数据大小 |
| 参数 | 描述 |
|:-------|:----------------|
| fifo | FIFO句柄 |
| buffer | 要写入FIFO缓存的数据缓冲区 |
| size | 写入大小 |
| **返回** | |
| size | 实际写入的数据大小 |
### 强制向FIFO缓存写入数据
### 强制向FIFO缓存写入数据
```c
size_t fifo_write_force(fifo_t fifo, const void *buffer, size_t size);
```
| 参数 | 描述 |
|:--------|:----------------|
| fifo | FIFO句柄 |
| buffer | 要写入FIFO缓存的数据缓冲区 |
| size | 写入大小 |
| **返回** | |
| size | 实际写入的数据大小 |
| 参数 | 描述 |
|:-------|:----------------|
| fifo | FIFO句柄 |
| buffer | 要写入FIFO缓存的数据缓冲区 |
| size | 写入大小 |
| **返回** | |
| size | 实际写入的数据大小 |
----------

6
package/fifo/fifo.c
View File

@@ -64,8 +64,7 @@ size_t fifo_get_data_size(fifo_t fifo)
if (fifo->read_mirror == fifo->write_mirror)
{
return 0;
}
else
} else
{
return fifo->size;
}
@@ -74,8 +73,7 @@ size_t fifo_get_data_size(fifo_t fifo)
if (fifo->write_index > fifo->read_index)
{
return fifo->write_index - fifo->read_index;
}
else
} else
{
return fifo->size - fifo->read_index + fifo->write_index;
}

104
package/list/README.md
View File

@@ -6,9 +6,9 @@
void slist_init(slist_t list);
```
| 参数 | 描述 |
|:----------|:-------|
| list | 单链表句柄 |
| 参数 | 描述 |
|:-----|:------|
| list | 单链表句柄 |
### 向单链表尾部追加节点
@@ -16,32 +16,32 @@ void slist_init(slist_t list);
void slist_append(slist_t list, slist_t node);
```
| 参数 | 描述 |
|:--------|:-------|
| list | 单链表句柄 |
| node | 要追加的节点 |
| 参数 | 描述 |
|:-----|:-------|
| list | 单链表句柄 |
| node | 要追加的节点 |
### 在单链表中节点后插入节点
### 在单链表中节点后插入节点
```c
void slist_insert_after(slist_t list, slist_t node);
```
| 参数 | 描述 |
|:-------|:----------|
| list | 单链表句柄 |
| node | 要插入的节点 |
| 参数 | 描述 |
|:-----|:-------|
| list | 单链表句柄 |
| node | 要插入的节点 |
### 从单链表中移除节点
### 从单链表中移除节点
```c
void slist_remove(slist_t list, slist_t node);
```
| 参数 | 描述 |
|:-------|:----------|
| list | 单链表句柄 |
| node | 要移除的节点 |
| 参数 | 描述 |
|:-----|:-------|
| list | 单链表句柄 |
| node | 要移除的节点 |
### 获取单链表长度
@@ -49,11 +49,11 @@ void slist_remove(slist_t list, slist_t node);
size_t slist_get_length(slist_t list);
```
| 参数 | 描述 |
|:-------|:---------|
| list | 单链表句柄 |
| **返回** | |
| size | 单链表长度 |
| 参数 | 描述 |
|:-------|:------|
| list | 单链表句柄 |
| **返回** | |
| size | 单链表长度 |
### 获取单链表尾节点
@@ -67,7 +67,7 @@ slist_t slist_get_tail(slist_t list);
| **返回** | |
| slist | 单链表尾节点 |
### 检查单链表是否为空
### 检查单链表是否为空
```c
int slist_is_empty(slist_t list);
@@ -85,20 +85,20 @@ int slist_is_empty(slist_t list);
void list_init(list_t list);
```
| 参数 | 描述 |
|:-------|:---------|
| list | 双链表句柄 |
| 参数 | 描述 |
|:-----|:------|
| list | 双链表句柄 |
### 在双链表后插入节点
### 在双链表后插入节点
```c
void list_insert_after(list_t list, list_t node);
```
| 参数 | 描述 |
|:--------|:---------|
| list | 双链表句柄 |
| node | 要插入的节点 |
| 参数 | 描述 |
|:-----|:-------|
| list | 双链表句柄 |
| node | 要插入的节点 |
### 在双链表前插入节点
@@ -106,32 +106,32 @@ void list_insert_after(list_t list, list_t node);
void list_insert_before(list_t list, list_t node);
```
| 参数 | 描述 |
|:-------|:---------|
| list | 双链表句柄 |
| node | 要插入的节点 |
| 参数 | 描述 |
|:-----|:-------|
| list | 双链表句柄 |
| node | 要插入的节点 |
### 从双链表中移除节点
### 从双链表中移除节点
```c
void list_remove(list_t node);
```
| 参数 | 描述 |
|:--------|:---------|
| node | 要移除的节点 |
| 参数 | 描述 |
|:-----|:-------|
| node | 要移除的节点 |
### 获取双链表长度
### 获取双链表长度
```c
size_t list_get_length(list_t list);
```
| 参数 | 描述 |
|:-------|:---------|
| list | 双链表句柄 |
| **返回** | |
| size | 双链表长度 |
| 参数 | 描述 |
|:-------|:------|
| list | 双链表句柄 |
| **返回** | |
| size | 双链表长度 |
### 检查双链表是否为空
@@ -152,13 +152,13 @@ int list_is_empty(list_t list);
((type *)((char *)(node) - (unsigned long)(&((type *)0)->member)))
```
| 参数 | 描述 |
|:-------|:----------------|
| node | 结构体中子结构体的指针 |
| type | 结构体类型 |
| member | 子结构体在结构体中的位置 |
| **返回** | |
| struct | 结构体指针 |
| 参数 | 描述 |
|:-------|:-------------|
| node | 结构体中子结构体的指针 |
| type | 结构体类型 |
| member | 子结构体在结构体中的位置 |
| **返回** | |
| struct | 结构体指针 |
#### 使用示例：

46
package/soft_i2c/README.md
View File

@@ -53,11 +53,11 @@ struct i2c_bus_ops
void i2c_bus_init(i2c_bus_t bus, const struct i2c_bus_ops *ops, void *data);
```
| 参数 | 描述 |
|:-----|:-------|
| bus | 总线句柄 |
| ops | 总线方法 |
| data | 总线数据 |
| 参数 | 描述 |
|:-----|:-----|
| bus | 总线句柄 |
| ops | 总线方法 |
| data | 总线数据 |
### 初始化I2C设备
@@ -65,11 +65,11 @@ void i2c_bus_init(i2c_bus_t bus, const struct i2c_bus_ops *ops, void *data);
void i2c_device_init(i2c_device_t device, uint8_t addr, i2c_bus_t bus);
```
| 参数 | 描述 |
|:-------|:-------|
| device | 设备句柄 |
| addr | 设备地址 |
| bus | 总线句柄 |
| 参数 | 描述 |
|:-------|:-----|
| device | 设备句柄 |
| addr | 设备地址 |
| bus | 总线句柄 |
### 向I2C设备寄存器写入数据
@@ -89,12 +89,12 @@ void i2c_device_write_reg(i2c_device_t device, uint8_t reg, uint8_t data);
void i2c_device_write_reg(i2c_device_t device, uint8_t reg, uint8_t data);
```
| 参数 | 描述 |
|:--------|:--------|
| device | 设备句柄 |
| reg | 寄存器地址 |
| **返回** | |
| data | 读取到的数据 |
| 参数 | 描述 |
|:-------|:-------|
| device | 设备句柄 |
| reg | 寄存器地址 |
| **返回** | |
| data | 读取到的数据 |
### 向I2C设备传输数据（先写入再读取）
@@ -106,13 +106,13 @@ void i2c_device_transfer(i2c_device_t device,
size_t read_size);
```
| 参数 | 描述 |
|:----------------|:-------|
| device | 设备句柄 |
| write_buffer | 要写入的数据 |
| write_size | 写入数据大小 |
| read_buffer | 要读取的数据 |
| read_size | 读取数据大小 |
| 参数 | 描述 |
|:-------------|:-------|
| device | 设备句柄 |
| write_buffer | 要写入的数据 |
| write_size | 写入数据大小 |
| read_buffer | 要读取的数据 |
| read_size | 读取数据大小 |
## 使用示例：

6
package/soft_i2c/soft_i2c.c
View File

@@ -42,8 +42,7 @@ static void i2c_bus_send_ack(i2c_bus_t bus, uint8_t ack)
if (ack)
{
bus->ops->sda_ctrl(bus, 1);
}
else
} else
{
bus->ops->sda_ctrl(bus, 0);
}
@@ -80,8 +79,7 @@ static void i2c_bus_write(i2c_bus_t bus, uint8_t data)
if (data & 0x80)
{
bus->ops->sda_ctrl(bus, 1);
}
else
} else
{
bus->ops->sda_ctrl(bus, 0);
}

20
src/device.c
View File

@@ -60,12 +60,13 @@ mr_err_t mr_device_add(mr_device_t device,
}
/* Initialize the private fields */
device->rx_cb = MR_NULL;
device->tx_cb = MR_NULL;
device->type = type;
device->support_flag = support_flag;
device->open_flag = MR_OPEN_CLOSED;
device->ref_count = 0;
device->data = data;
device->rx_cb = MR_NULL;
device->tx_cb = MR_NULL;
/* Set operations as null-ops if ops is null */
device->ops = (ops == MR_NULL) ? &null_ops : ops;
@@ -95,12 +96,13 @@ mr_err_t mr_device_remove(mr_device_t device)
}
/* Initialize the private fields */
device->rx_cb = MR_NULL;
device->tx_cb = MR_NULL;
device->type = MR_DEVICE_TYPE_NONE;
device->support_flag = MR_OPEN_CLOSED;
device->open_flag = MR_OPEN_CLOSED;
device->ref_count = 0;
device->data = MR_NULL;
device->rx_cb = MR_NULL;
device->tx_cb = MR_NULL;
/* Set operations as null-ops */
device->ops = &null_ops;
@@ -139,7 +141,7 @@ mr_err_t mr_device_open(mr_device_t device, mr_uint16_t flags)
/* Set the device status to active */
device->open_flag |= MR_OPEN_ACTIVE;
/* Call the device-open function, if provided */
/* Call the open function, if provided */
if (device->ops->open == MR_NULL)
{
return MR_ERR_OK;
@@ -179,7 +181,7 @@ mr_err_t mr_device_close(mr_device_t device)
device->rx_cb = MR_NULL;
device->tx_cb = MR_NULL;
/* Call the device-close function, if provided */
/* Call the close function, if provided */
if (device->ops->close == MR_NULL)
{
return MR_ERR_OK;
@@ -201,7 +203,7 @@ mr_err_t mr_device_ioctl(mr_device_t device, int cmd, void *args)
{
MR_ASSERT(device != MR_NULL);
/* Call the device-ioctl function, if provided */
/* Call the ioctl function, if provided */
if (device->ops->ioctl == MR_NULL)
{
return -MR_ERR_UNSUPPORTED;
@@ -231,7 +233,7 @@ mr_ssize_t mr_device_read(mr_device_t device, mr_off_t pos, void *buffer, mr_siz
return -MR_ERR_UNSUPPORTED;
}
/* Call the device-read function, if provided */
/* Call the read function, if provided */
if (device->ops->read == MR_NULL)
{
return -MR_ERR_IO;
@@ -261,7 +263,7 @@ mr_ssize_t mr_device_write(mr_device_t device, mr_off_t pos, const void *buffer,
return -MR_ERR_UNSUPPORTED;
}
/* Call the device-write function, if provided */
/* Call the write function, if provided */
if (device->ops->write == MR_NULL)
{
return -MR_ERR_IO;

35
src/kernel.c
View File

@@ -13,19 +13,16 @@
static struct mr_container mr_kernel_container[_MR_CONTAINER_TYPE_MASK] =
{
{
.type = MR_CONTAINER_TYPE_MISC,
.list = {&mr_kernel_container[MR_CONTAINER_TYPE_MISC].list,
&mr_kernel_container[MR_CONTAINER_TYPE_MISC].list}
MR_CONTAINER_TYPE_MISC,
{&mr_kernel_container[MR_CONTAINER_TYPE_MISC].list, &mr_kernel_container[MR_CONTAINER_TYPE_MISC].list}
},
{
.type = MR_CONTAINER_TYPE_DEVICE,
.list = {&mr_kernel_container[MR_CONTAINER_TYPE_DEVICE].list,
&mr_kernel_container[MR_CONTAINER_TYPE_DEVICE].list}
MR_CONTAINER_TYPE_DEVICE,
{&mr_kernel_container[MR_CONTAINER_TYPE_DEVICE].list, &mr_kernel_container[MR_CONTAINER_TYPE_DEVICE].list}
},
{
.type = MR_CONTAINER_TYPE_SERVER,
.list = {&mr_kernel_container[MR_CONTAINER_TYPE_SERVER].list,
&mr_kernel_container[MR_CONTAINER_TYPE_SERVER].list}
MR_CONTAINER_TYPE_SERVER,
{&mr_kernel_container[MR_CONTAINER_TYPE_SERVER].list, &mr_kernel_container[MR_CONTAINER_TYPE_SERVER].list}
},
};
@@ -40,6 +37,11 @@ mr_container_t mr_container_find(enum mr_container_type type)
{
MR_ASSERT(type < _MR_CONTAINER_TYPE_MASK);
if (type >= _MR_CONTAINER_TYPE_MASK)
{
return MR_NULL;
}
return &mr_kernel_container[type];
}
@@ -62,6 +64,10 @@ mr_object_t mr_object_find(const char *name, enum mr_container_type type)
/* Get corresponding container */
container = mr_container_find(type);
if (container == MR_NULL)
{
return MR_NULL;
}
/* Disable interrupt */
mr_interrupt_disable();
@@ -112,6 +118,10 @@ mr_err_t mr_object_add(mr_object_t object, const char *name, enum mr_container_t
/* Find the container for the specified flag */
container = mr_container_find(type);
if (container == MR_NULL)
{
return -MR_ERR_NOT_FOUND;
}
/* Disable interrupt */
mr_interrupt_disable();
@@ -164,11 +174,7 @@ mr_err_t mr_object_move(mr_object_t object, enum mr_container_type type)
MR_ASSERT(type < _MR_CONTAINER_TYPE_MASK);
/* Remove the object from its current container */
ret = mr_object_remove(object);
if (ret != MR_ERR_OK)
{
return ret;
}
mr_object_remove(object);
/* Add the object to the new container */
ret = mr_object_add(object, object->name, type);
@@ -185,6 +191,7 @@ mr_err_t mr_object_move(mr_object_t object, enum mr_container_type type)
void mr_object_rename(mr_object_t object, char *name)
{
MR_ASSERT(object != MR_NULL);
MR_ASSERT(name != MR_NULL);
mr_strncpy(object->name, name, MR_CONF_NAME_MAX);
}

17
src/kservice.c
View File

@@ -155,8 +155,8 @@ void mr_fifo_init(mr_fifo_t fifo, void *pool, mr_size_t pool_size)
fifo->read_mirror = 0;
fifo->write_mirror = 0;
fifo->buffer = pool;
fifo->size = pool_size;
fifo->buffer = pool;
}
/**
@@ -192,8 +192,7 @@ mr_size_t mr_fifo_get_data_size(mr_fifo_t fifo)
if (fifo->read_mirror == fifo->write_mirror)
{
return 0;
}
else
} else
{
return fifo->size;
}
@@ -202,8 +201,7 @@ mr_size_t mr_fifo_get_data_size(mr_fifo_t fifo)
if (fifo->write_index > fifo->read_index)
{
return fifo->write_index - fifo->read_index;
}
else
} else
{
return fifo->size - fifo->read_index + fifo->write_index;
}
@@ -490,12 +488,10 @@ void mr_avl_insert(mr_avl_t *tree, mr_avl_t node)
if (node->value < (*tree)->value)
{
mr_avl_insert(&(*tree)->left_child, node);
}
else if (node->value > (*tree)->value)
} else if (node->value > (*tree)->value)
{
mr_avl_insert(&(*tree)->right_child, node);
}
else
} else
{
return;
}
@@ -550,8 +546,7 @@ mr_avl_t mr_avl_find(mr_avl_t tree, mr_uint32_t value)
if (value < tree->value)
{
return mr_avl_find(tree->left_child, value);
}
else if (value > tree->value)
} else if (value > tree->value)
{
return mr_avl_find(tree->right_child, value);
}