bool ringbuffer_get(ringbuffer_t* b, unsigned char* out) {
// false if buffer empty
if(ringbuffer_empty(b))
return false;
*out = b->buffer[b->pos_read];
b->pos_read = (b->pos_read+1) & RINGBUFFER_MASK;
return true;
}
int taskloop_process_one()
{
task_callback task;
if (ringbuffer_empty(&taskqueue.tasks))
return 0;
ringbuffer_pop(&taskqueue.tasks, &task);
task();
return 1;
}
void ringbuffer_popqueue(ringbuffer_t* buffer, void* element)
{
if (ringbuffer_empty(buffer)){ return; }
/* FIFO implementation */
void* source = buffer->element + ((buffer->start) * (buffer->element_size));
memcpy(element, source, buffer->element_size);
buffer->start++;
buffer->count--;
if (buffer->start == buffer->element_max)
{
buffer->start = 0;
}
}
uint32_t ringbuffer_read_lock_size(kringbuffer_t* rb) {
verify(rb);
if (ringbuffer_empty(rb)) {
return 0;
}
rb->lock_type = 1;
rb->lock_size = 0;
if (rb->write_pos > rb->read_pos) {
rb->lock_size = rb->write_pos - rb->read_pos;
} else {
rb->lock_size = rb->max_size - rb->read_pos;
}
return rb->lock_size;
}
void ringbuffer_popstack(ringbuffer_t *buffer, void* element)
{
int index;
if (ringbuffer_empty(buffer))
{
return;
}
/* LIFO implementation */
index = buffer->start + buffer->count - 1;
if (index >= buffer->element_max)
{
index = index - buffer->element_max;
}
void* source = (buffer->element) + index * (buffer->element_size);
buffer->count--;
memcpy(element, source, buffer->element_size);
}
uint32_t ringbuffer_window_read_lock_size(kringbuffer_t* rb) {
verify(rb);
if (ringbuffer_empty(rb)) {
return 0;
}
if (rb->window_read_pos == rb->write_pos) {
rb->window_read_pos = 0;
return 0;
}
if (!rb->window_read_pos) {
rb->window_read_pos = rb->read_pos;
}
rb->window_read_lock_size = 0;
if (rb->write_pos > rb->window_read_pos) {
rb->window_read_lock_size = rb->write_pos - rb->window_read_pos;
} else {
rb->window_read_lock_size = rb->max_size - rb->window_read_pos;
}
return rb->window_read_lock_size;
}
int main()
{
struct RingBuffer *h = NULL;
int x = 10, y = INT_MAX, z = 2863311530, m = -3333;
int offset_remove = 2;
int offset_insert = 3;
int offset_data = 4;
assert(ringbuffer_init(&h, 3, sizeof(x)) == 0);
assert(ringbuffer_push(h, (unsigned char *)&x) == RBE_SUCCESS);
assert(ringbuffer_push(h, (unsigned char *)&y) == RBE_SUCCESS);
assert(ringbuffer_full(h) != 0);
assert(ringbuffer_pop(h) == RBE_SUCCESS);
assert(ringbuffer_push(h, (unsigned char *)&z) == RBE_SUCCESS);
assert(ringbuffer_full(h) != 0);
assert(ringbuffer_resize(&h, 5) == RBE_SUCCESS);
assert(ringbuffer_full(h) == 0);
assert(ringbuffer_empty(h) == 0);
assert(ringbuffer_push(h, (unsigned char *)&m) == RBE_SUCCESS);
assert(ringbuffer_push(h, (unsigned char *)&x) == RBE_SUCCESS);
assert(ringbuffer_full(h) != 0);
{ /* checking the data: x y z m x */
unsigned *off = (unsigned *) h;
int *values = (int *) off + offset_data;
assert(*(off + offset_remove) == 1 * sizeof(x));
assert(*(off + offset_insert) == 0);
assert(values[0] == x);
assert(values[1] == y);
assert(values[2] == z);
assert(values[3] == m);
assert(values[4] == x);
}
ringbuffer_destroy(&h);
return 0;
}
void usbdev_acm_evt_in(usbdev_t *dev)
{
usbdev_ops_t *driver = dev->driver;
static int32_t data_send_zlp = 0;
if (!start_tx) {
return;
}
if (!mutex_trylock(&tx_rb_lock)) {
return;
}
size_t len_to_send = ringbuffer_get(&cdcacm_tx_rb, (char*)send_buffer,
USBDEV_ACM_EP_PACKET_SIZE);
if (len_to_send == 0) {
start_tx = 0;
if (data_send_zlp == 0) {
mutex_unlock(&tx_rb_lock);
return;
}
data_send_zlp = 0;
}
size_t len_sent = driver->write_ep(ENDPOINT_ADDR_IN(USBDEV_ACM_EP_BULKIN),
send_buffer, len_to_send);
unsigned retval = ringbuffer_empty(&cdcacm_tx_rb);
if (retval && (len_sent == USBDEV_ACM_EP_PACKET_SIZE)) {
data_send_zlp = 1;
}
else {
data_send_zlp = 0;
}
mutex_unlock(&tx_rb_lock);
}
/**
* @brief FSM handling function for receiving data.
*
* @param[in,out] tcb TCB holding the connection information.
* @param[in,out] buf Buffer to store received data into.
* @param[in] len Maximum number of bytes to receive.
*
* @returns Number of successfully received bytes.
*/
static int _fsm_call_recv(gnrc_tcp_tcb_t *tcb, void *buf, size_t len)
{
DEBUG("gnrc_tcp_fsm.c : _fsm_call_recv()\n");
if (ringbuffer_empty(&tcb->rcv_buf)) {
return 0;
}
/* Read data into 'buf' up to 'len' bytes from receive buffer */
size_t rcvd = ringbuffer_get(&(tcb->rcv_buf), buf, len);
/* If receive buffer can store more than GNRC_TCP_MSS: open window to available buffer size */
if (ringbuffer_get_free(&tcb->rcv_buf) >= GNRC_TCP_MSS) {
tcb->rcv_wnd = ringbuffer_get_free(&(tcb->rcv_buf));
/* Send ACK to anounce window update */
gnrc_pktsnip_t *out_pkt = NULL;
uint16_t seq_con = 0;
_pkt_build(tcb, &out_pkt, &seq_con, MSK_ACK, tcb->snd_nxt, tcb->rcv_nxt, NULL, 0);
_pkt_send(tcb, out_pkt, seq_con, false);
}
return rcvd;
}
