107 lines
4.0 KiB
C
107 lines
4.0 KiB
C
/*
|
|
* Кольцевая очередь байтов для одного производителя и одного потребителя. Размер хранилища
|
|
* должен быть степенью двойки; одна позиция резервируется для различения пустого и полного
|
|
* состояния.
|
|
*/
|
|
|
|
#include "pcan_ring.h"
|
|
|
|
/* storage живёт не меньше контекста очереди. Степень двойки позволяет
|
|
* заменять остаток от деления маской size - 1 во всех операциях. */
|
|
bool pcan_ring_init(pcan_ring_t *rb, uint8_t *storage, uint16_t size)
|
|
{
|
|
if ((rb == NULL) || (storage == NULL) || (size < 2U) ||
|
|
((size & (uint16_t)(size - 1U)) != 0U)) {
|
|
return false;
|
|
}
|
|
rb->buf = storage;
|
|
rb->size = size;
|
|
rb->head = 0U;
|
|
rb->tail = 0U;
|
|
rb->dropped = 0U;
|
|
return true;
|
|
}
|
|
|
|
uint16_t pcan_ring_count(const pcan_ring_t *rb)
|
|
{
|
|
return (uint16_t)((rb->head - rb->tail) & (uint16_t)(rb->size - 1U));
|
|
}
|
|
|
|
/* head == tail обозначает пустую очередь, поэтому одна ячейка всегда
|
|
* остаётся незанятой: полезная вместимость равна size - 1. */
|
|
uint16_t pcan_ring_free(const pcan_ring_t *rb)
|
|
{
|
|
return (uint16_t)(rb->size - 1U - pcan_ring_count(rb));
|
|
}
|
|
|
|
bool pcan_ring_put(pcan_ring_t *rb, uint8_t byte)
|
|
{
|
|
uint16_t next = (uint16_t)((rb->head + 1U) & (uint16_t)(rb->size - 1U));
|
|
if (next == rb->tail) {
|
|
rb->dropped++;
|
|
return false;
|
|
}
|
|
/* Сначала данные, затем публикация индекса: потребитель не должен
|
|
* увидеть новую позицию до того, как байт записан в хранилище. */
|
|
rb->buf[rb->head] = byte;
|
|
PCAN_BARRIER();
|
|
rb->head = next;
|
|
return true;
|
|
}
|
|
|
|
bool pcan_ring_get(pcan_ring_t *rb, uint8_t *byte)
|
|
{
|
|
if (rb->head == rb->tail) {
|
|
return false;
|
|
}
|
|
*byte = rb->buf[rb->tail];
|
|
PCAN_BARRIER();
|
|
rb->tail = (uint16_t)((rb->tail + 1U) & (uint16_t)(rb->size - 1U));
|
|
return true;
|
|
}
|
|
|
|
/* Блок добавляется целиком либо отклоняется целиком. Это сохраняет
|
|
* границы отправляемого кадра при недостатке свободного места. */
|
|
bool pcan_ring_write(pcan_ring_t *rb, const uint8_t *data, uint16_t len)
|
|
{
|
|
if (pcan_ring_free(rb) < len) {
|
|
rb->dropped += len;
|
|
return false;
|
|
}
|
|
|
|
uint16_t mask = (uint16_t)(rb->size - 1U);
|
|
uint16_t head = rb->head;
|
|
for (uint16_t i = 0U; i < len; i++) {
|
|
rb->buf[head] = data[i];
|
|
head = (uint16_t)((head + 1U) & mask);
|
|
}
|
|
/* Публикуем весь блок одной записью: читатель никогда не увидит
|
|
кадр наполовину. */
|
|
PCAN_BARRIER();
|
|
rb->head = head;
|
|
return true;
|
|
}
|
|
|
|
/* Возвращает непрерывный участок до конца массива, а не обязательно всё
|
|
* содержимое кольца. После обработки вызывающий сдвигает tail через consume. */
|
|
uint16_t pcan_ring_linear(const pcan_ring_t *rb, const uint8_t **ptr)
|
|
{
|
|
uint16_t head = rb->head;
|
|
uint16_t tail = rb->tail;
|
|
|
|
if (head == tail) {
|
|
*ptr = NULL;
|
|
return 0U;
|
|
}
|
|
*ptr = &rb->buf[tail];
|
|
return (head > tail) ? (uint16_t)(head - tail)
|
|
: (uint16_t)(rb->size - tail);
|
|
}
|
|
|
|
/* Предусловие: len не превышает число доступных байтов. Проверка здесь
|
|
* не выполняется; обычно передают размер реально обработанного участка. */
|
|
void pcan_ring_consume(pcan_ring_t *rb, uint16_t len)
|
|
{
|
|
rb->tail = (uint16_t)((rb->tail + len) & (uint16_t)(rb->size - 1U));
|
|
}
|