END_TEST


START_TEST (test_to_rb_from_fd)
{
    int fds[2];
    ck_assert(pipe(fds) == 0);

    ck_assert(write(fds[1], sample16, 16) == 16);

    ck_assert(rb_is_empty(rb));
    ck_assert_int_eq(rb_used(rb), 0);
    ck_assert_int_eq(rb_space(rb), 16);

    ssize_t result = rb_read(rb, fds[0], 10);
    ck_assert_int_eq(result, 10);

    ck_assert_int_eq(rb_used(rb), 10);
    ck_assert_int_eq(rb_space(rb), 6);
    ck_assert(!rb_is_empty(rb));
    ck_assert(!rb_is_full(rb));

    result = rb_read(rb, fds[0], 10);
    ck_assert_int_eq(result, 6);

    ck_assert_int_eq(rb_used(rb), 16);
    ck_assert_int_eq(rb_space(rb), 0);
    ck_assert(!rb_is_empty(rb));
    ck_assert(rb_is_full(rb));

    ck_assert(memcmp(rb->buffer, "0123456789ABCDEF", 16) == 0);
}
Esempio n. 2
0
static inline void usart_tx_irq(const usart_dev *dev) {
#ifdef ISR_PERF
    uint32_t t=stopwatch_getticks();
#endif
    /* Check USART Transmit Data Register Empty Interrupt */
    uint16_t sr = dev->USARTx->SR;
    if( (sr & USART_F_TXE) && (dev->USARTx->CR1 & USART_MASK_TXEIE) ){

	if (dev->txrb && !rb_is_empty(dev->txrb))  {
	    dev->USARTx->DR = rb_remove(dev->txrb);
	    dev->state->txbusy = 1;
	} else   {
	    /* Disable the USART Transmit Data Register Empty Interrupt */
	    dev->USARTx->CR1 &= ~USART_MASK_TXEIE;
	    dev->state->txbusy = 0;
	    // nops needed to deactivate the irq before irq handler is left
            asm volatile("nop");
            asm volatile("nop");
        }
    }
#ifdef ISR_PERF
    t = stopwatch_getticks() - t;
    isr_time += t;
    if(t>max_isr_time) max_isr_time=t;
#endif

}
END_TEST


START_TEST (test_to_scattered_memory_from_rb)
{
    rb_append(rb, sample16, 4);
    rb_append(rb, sample16, 8);
    rb_discard(rb, 4);
    rb_append(rb, sample16+8, 8);

    char outbuf[32];
    struct iovec iov[3];
    iov[0].iov_base = outbuf+12;
    iov[0].iov_len = 2;
    iov[1].iov_base = outbuf+7;
    iov[1].iov_len = 5;
    iov[2].iov_base = outbuf;
    iov[2].iov_len = 7;

    size_t result = rb_extractv(rb, iov, 3);
    ck_assert_int_eq(result, 14);

    ck_assert_int_eq(rb_space(rb), 14);
    ck_assert(!rb_is_empty(rb));
    ck_assert(!rb_is_full(rb));

    ck_assert(memcmp(outbuf, "789ABCD2345601", 14) == 0);
}
END_TEST


START_TEST (test_to_fd_from_rb)
{
    int fds[2];
    ck_assert(pipe(fds) == 0);

    rb_append(rb, sample16, 16);
    ck_assert(rb_is_full(rb));

    ssize_t result = rb_write(rb, fds[1], 10);
    ck_assert_int_eq(result, 10);

    ck_assert_int_eq(rb_used(rb), 6);
    ck_assert_int_eq(rb_space(rb), 10);

    char outbuf[32];
    ck_assert_int_eq(read(fds[0], outbuf, sizeof(outbuf)), 10);
    ck_assert(memcmp(outbuf, "0123456789", 10) == 0);

    result = rb_write(rb, fds[1], 10);
    ck_assert_int_eq(result, 6);
    ck_assert(rb_is_empty(rb));

    ck_assert_int_eq(read(fds[0], outbuf, sizeof(outbuf)), 6);
    ck_assert(memcmp(outbuf, "ABCDEF", 6) == 0);
}
int usb_read(void  * buf, unsigned int nbytes)
{
	U16 toread = nbytes;
	U16 received;
	U8 *buffer8 = (U8 *)buf;

	if (usb_ready == 0)
	{
		return 0;
	}
	
	received = 0;
	
	if (!rxfifo) 
	{
		return 0;
	}
		
	// blocking mode
	while(toread)
	{
		/* get characters from ring buffer */
		if (!rb_is_empty(rxfifo))
		{
			*buffer8 = rb_remove(rxfifo);
			received++;
			buffer8++;
			toread--;
		}
	}

	return received;
}
Esempio n. 6
0
File: main.c Progetto: lythm/orb3d
int main(int argc, char* argv[])
{
	unsigned int left = 0;
	unsigned int size = 0;
	unsigned int i = 0;
	struct ring_buffer rb;
	char buffer[100];

	for(i = 0; i < 100; ++i)
	{
		buffer[i] = i;
	}
	
	rb_alloc(&rb, 100);

	for(i = 0; i < 100; ++i)
	{
		rb_write(&rb, buffer, 33);
		rb_read(&rb, buffer, 32);
	}
	

	printf("%d,%d  %d,%d\n", rb_length(&rb), rb_left(&rb), rb_is_full(&rb), rb_is_empty(&rb));

	rb_free(&rb);

	
	return 0;
}
Esempio n. 7
0
int
ringbuffer_empty(RingBuffer *rb)
{
    int ret;
    pthread_mutex_lock(&rb->lock);
    ret = rb_is_empty(rb);
    pthread_mutex_unlock(&rb->lock);
    return ret;
}
END_TEST


START_TEST (test_clear)
{
    rb_append(rb, sample16, 16);
    ck_assert(rb_is_full(rb));

    rb_clear(rb);
    ck_assert(rb_is_empty(rb));
}
END_TEST


START_TEST (test_to_memory_from_rb)
{
    rb_append(rb, sample16, 16);

    char outbuf[32];
    size_t result = rb_extract(rb, outbuf, 10);
    ck_assert_int_eq(result, 10);

    ck_assert_int_eq(rb_space(rb), 10);
    ck_assert(!rb_is_empty(rb));
    ck_assert(!rb_is_full(rb));

    result = rb_extract(rb, outbuf + 10, 10);
    ck_assert_int_eq(result, 6);
    ck_assert(rb_is_empty(rb));
    ck_assert(!rb_is_full(rb));

    ck_assert(memcmp(outbuf, "0123456789ABCDEF", 16) == 0);
}
Esempio n. 10
0
void ipc_read(IPC* ipc)
{
    for (;;)
    {
        error(ERROR_OK);
        if (rb_is_empty(&__GLOBAL->process->ipcs))
            svc_call(SVC_IPC_WAIT, ANY_HANDLE, ANY_CMD, ANY_HANDLE);
        ipc_peek(__GLOBAL->process->ipcs.tail, ipc);
        if (ipc->cmd == HAL_REQ(HAL_SYSTEM, IPC_PING))
            ipc_write(ipc);
        else
            break;
    }
}
Esempio n. 11
0
void scsis_error_get(SCSIS* scsis, SCSIS_ERROR *err)
{
    unsigned int idx;
    if (rb_is_empty(&scsis->rb_error))
    {
        err->key_sense = SENSE_KEY_NO_SENSE;
        err->ascq = ASCQ_NO_ADDITIONAL_SENSE_INFORMATION;
    }
    else
    {
        idx = rb_get(&scsis->rb_error);
        err->key_sense = scsis->errors[idx].key_sense;
        err->ascq = scsis->errors[idx].ascq;
    }
}
Esempio n. 12
0
END_TEST


START_TEST (test_to_rb_from_memory_wrapped_around)
{
    ck_assert_int_eq(rb_append(rb, sample16, 8), 8);
    ck_assert_int_eq(rb_discard(rb, 7), 7);
    ck_assert_int_eq(rb_used(rb), 1);

    size_t result = rb_append(rb, sample16, 16);
    ck_assert_int_eq(result, 15);
    ck_assert(!rb_is_empty(rb));
    ck_assert(rb_is_full(rb));

    ck_assert(memcmp(rb->buffer, "89ABCDE701234567", 16) == 0);
}
Esempio n. 13
0
END_TEST


START_TEST (test_to_rb_from_memory_in_center)
{
    ck_assert_int_eq(rb_append(rb, sample16, 8), 8);
    ck_assert_int_eq(rb_discard(rb, 7), 7);
    ck_assert_int_eq(rb_append(rb, sample16, 11), 11);
    ck_assert_int_eq(rb_used(rb), 12);
    ck_assert_int_eq(rb_space(rb), 4);

    size_t result = rb_append(rb, sample16, 16);
    ck_assert_int_eq(result, 4);
    ck_assert(!rb_is_empty(rb));
    ck_assert(rb_is_full(rb));

    ck_assert(memcmp(rb->buffer, "89A0123701234567", 16) == 0);
}
Esempio n. 14
0
static inline void usart_tx_irq(usart_dev *dev)
    {
    /* Check USART Transmit Data Register Empty Interrupt */
    if (USART_GetITStatus(dev->USARTx, USART_IT_TXE) != RESET)
	{
	if (!rb_is_empty(dev->txrb))
	    {
	    dev->USARTx->DR = rb_remove(dev->txrb);
	    dev->txbusy = 1;
	    }
	else
	    {
	    /* Disable the USART Transmit Data Register Empty Interrupt */
	    USART_ITConfig(dev->USARTx, USART_IT_TXE, DISABLE);
	    dev->txbusy = 0;
	    }
	}
    }
Esempio n. 15
0
END_TEST


START_TEST (test_to_memory_from_rb_wrapped_around)
{
    rb_append(rb, sample16, 16);
    rb_discard(rb, 10);
    rb_append(rb, sample16, 6);
    ck_assert_int_eq(rb_space(rb), 4);

    char outbuf[32];
    size_t result = rb_extract(rb, outbuf, 16);
    ck_assert_int_eq(result, 12);

    ck_assert(rb_is_empty(rb));
    ck_assert(!rb_is_full(rb));

    ck_assert(memcmp(outbuf, "ABCDEF012345", 12) == 0);
}
Esempio n. 16
0
int
ringbuffer_get(RingBuffer *rb, void *elem)
{
    pthread_mutex_lock(&rb->lock);

    rb->waiters++;
    while (rb_is_empty(rb)) {
        pthread_cond_wait(&rb->cond, &rb->lock);
    }
    rb->waiters--;

    rb->used--;
    memcpy(elem, rb_item_at(rb, rb->start), rb->elem_size);
    rb->dump(rb->dump_ud, rb_item_at(rb, rb->start));
    rb->start = (rb->start + 1) % rb->size;

    pthread_mutex_unlock(&rb->lock);
    return 0;
}
Esempio n. 17
0
END_TEST


START_TEST (test_to_rb_from_scattered_memory)
{
    ck_assert_int_eq(rb_append(rb, sample16, 8), 8);
    ck_assert_int_eq(rb_discard(rb, 7), 7);
    ck_assert_int_eq(rb_used(rb), 1);

    struct iovec iov[3];
    iov[0].iov_base = sample16 + 4;
    iov[0].iov_len = 5;
    iov[1].iov_base = sample16;
    iov[1].iov_len = 4;
    iov[2].iov_base = sample16 + 9;
    iov[2].iov_len = 7;

    size_t result = rb_appendv(rb, iov, 3);
    ck_assert_int_eq(result, 15);
    ck_assert(!rb_is_empty(rb));
    ck_assert(rb_is_full(rb));

    ck_assert(memcmp(rb->buffer, "39ABCDE745678012", 16) == 0);
}
Esempio n. 18
0
int buffering_flush(neo4j_iostream_t *stream)
{
    struct buffering_iostream *ios = container_of(stream,
            struct buffering_iostream, _iostream);
    if (ios->delegate == NULL)
    {
        errno = EPIPE;
        return -1;
    }
    if (!rb_is_empty(ios->sndbuf))
    {
        struct iovec iov[2];
        unsigned int iovcnt = rb_data_iovec(ios->sndbuf, iov,
                rb_size(ios->sndbuf));
        size_t written;
        if (neo4j_ios_writev_all(ios->delegate, iov, iovcnt, &written))
        {
            rb_discard(ios->sndbuf, written);
            return -1;
        }
        rb_clear(ios->sndbuf);
    }
    return neo4j_ios_flush(ios->delegate);
}
Esempio n. 19
0
/* edogaldo: Waits for the transmission of outgoing serial data to complete (Arduino 1.0 api specs) */
void HardwareSerial::flush(void) {
    while(!rb_is_empty(this->usart_device->wb)); // wait for TX buffer empty
    while(!((this->usart_device->regs->SR) & (1<<USART_SR_TC_BIT))); // wait for TC (Transmission Complete) flag set 
}
Esempio n. 20
0
void at45_process_done_q() {
	while(!rb_is_empty(&at45_tx_done_q)) {
		at45_get_data();
	}
}