static int _read(_t *data, jack_nframes_t *framep, Tcl_Obj **bytes) {
if (ring_buffer_items_available_to_read(&data->rb) < 3+sizeof(jack_nframes_t)+sizeof(size_t))
return 0;
int n = ring_buffer_get(&data->rb, sizeof(*framep), (unsigned char *)framep);
size_t size;
n += ring_buffer_get(&data->rb, sizeof(size), (unsigned char *)&size);
*bytes = Tcl_NewObj();
n += ring_buffer_get(&data->rb, size, Tcl_SetByteArrayLength(*bytes, size));
return n;
}
SEXP R_ring_buffer_copy(SEXP srcPtr, SEXP destPtr, SEXP r_count) {
size_t count = INTEGER(r_count)[0];
ring_buffer *src = ring_buffer_get(srcPtr, 1),
*dest = ring_buffer_get(destPtr, 1);
data_t * head = (data_t *) ring_buffer_copy(dest, src, count);
if (head == NULL) {
// TODO: better reporting here; make this a general thing I think.
// See memcpy_from and tail_read for other places this is needed.
Rf_error("Buffer underflow");
}
return ScalarInteger(head - dest->data);
}
int uart_read (struct file * filp, char *buf, size_t count, loff_t *t)
{
int rcount=0;
// To do: increase the semaphore
while ( (rcount < count) && !ring_buffer_isenmpty(&ring) ) {
// read recive character form register
*(prbuf+rcount)=ring_buffer_get (&ring);
rcount++;
}
// To do: decrease the semaphore
if( rcount != 0 ) {
// Copy the data to user space
if( copy_to_user(buf, prbuf, rcount) != 0) {
return -EFAULT;
}
}
return rcount;
}
int uart_read (struct file * filp, char *buf, size_t count, loff_t *t)
{
int rcount=0;
if( ring_buffer_isenmpty(&ring) ) {
// To do: wait for an event.
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
bSleep=0;
wait_event_interruptible(wq, bSleep);
#elif LINUX_VERSION_CODE > KERNEL_VERSION(2,4,0)
interruptible_sleep_on(&wq);
#endif
}
while ( (rcount < count) && !ring_buffer_isenmpty(&ring) ) {
*(prbuf+rcount)=ring_buffer_get(&ring);
printk("uart_int: %c\n", *(prbuf+rcount));
rcount++;
}
if( rcount != 0 ) {
if( copy_to_user(buf, prbuf, rcount) != 0)
return -EFAULT;
}
return rcount;
}
void ring_buffer_finalize(SEXP extPtr) {
ring_buffer *buffer = ring_buffer_get(extPtr, 0);
if (buffer) {
ring_buffer_destroy(buffer);
R_ClearExternalPtr(extPtr);
}
}
bool
ring_cursor_next(Cursor *scursor) {
ring_buffer_cursor *cursor = (ring_buffer_cursor *)scursor;
bool out = ++cursor->pos < (cursor->rb->written - cursor->rb->capacity);
cursor->as_cursor.data = ring_buffer_get(cursor->rb, cursor->pos * cursor->width, cursor->width);
return out;
}
SEXP R_ring_buffer_data(SEXP extPtr) {
ring_buffer * buffer = ring_buffer_get(extPtr, 1);
size_t len = ring_buffer_size(buffer, 1);
SEXP ret = PROTECT(allocVector(RAWSXP, len));
memcpy(RAW(ret), ring_buffer_data(buffer), len);
UNPROTECT(1);
return ret;
}
bool
ring_cursor_prev(Cursor *scursor) {
ring_buffer_cursor *cursor = (ring_buffer_cursor *)scursor;
long max = cursor->rb->written / cursor->width;
if(cursor->pos > max) {
cursor->pos = max;
}
cursor->pos--;
return (cursor->as_cursor.data = ring_buffer_get(cursor->rb, cursor->pos * cursor->width, cursor->width));
}
SEXP R_ring_buffer_tail(SEXP extPtr) {
ring_buffer * buffer = ring_buffer_get(extPtr, 1);
if (ring_buffer_empty(buffer)) {
Rf_error("Buffer is empty");
}
SEXP ret = PROTECT(allocVector(RAWSXP, buffer->stride));
memcpy(RAW(ret), ring_buffer_tail(buffer), buffer->stride);
UNPROTECT(1);
return ret;
}
SEXP R_ring_buffer_memcpy_into(SEXP extPtr, SEXP src) {
ring_buffer *buffer = ring_buffer_get(extPtr, 1);
size_t len = LENGTH(src), stride = buffer->stride;
if (len % stride != 0) {
Rf_error("Incorrect size data (%d bytes); expected multiple of %d bytes",
len, stride);
}
size_t count = len / stride;
data_t * head = (data_t *) ring_buffer_memcpy_into(buffer, RAW(src), count);
return ScalarInteger(head - buffer->data);
}
void uart_a0_tx_rdy_handler(void) {
char c;
if (ring_buffer_get(_uart_a0_tx_ringbuffer_id, &c) == 0) {
UCA0TXBUF = c;
EUSCI_A_UART_enableInterrupt(EUSCI_A0_BASE,
EUSCI_A_UART_TRANSMIT_INTERRUPT);
} else { // ringbuffer empty, nothing to send anymore...
EUSCI_A_UART_disableInterrupt(EUSCI_A0_BASE,
EUSCI_A_UART_TRANSMIT_INTERRUPT);
UCA0IFG |= EUSCI_A_UART_TRANSMIT_INTERRUPT_FLAG;
}
}
SEXP R_ring_buffer_tail_read(SEXP extPtr, SEXP r_count) {
size_t count = INTEGER(r_count)[0];
ring_buffer * buffer = ring_buffer_get(extPtr, 1);
SEXP ret = PROTECT(allocVector(RAWSXP, count * buffer->stride));
if (ring_buffer_tail_read(buffer, RAW(ret), count) == NULL) {
Rf_error("Buffer underflow");
}
UNPROTECT(1);
// NOTE: In C we return the tail position here but that is not done
// for the R version.
return ret;
}
static int _get(ClientData clientData, Tcl_Interp *interp, int argc, Tcl_Obj* const *objv) {
// return the current detimed string
_t *dp = (_t *)clientData;
// hmm, how to avoid the buffer here, allocate a byte array?
unsigned n = ring_buffer_items_available_to_read(&dp->ring);
// fprintf(stderr, "%s:%d %u bytes available\n", __FILE__, __LINE__, n);
Tcl_Obj *result = Tcl_NewObj();
char *buff = Tcl_SetByteArrayLength(result, n);
ring_buffer_get(&dp->ring, n, buff);
Tcl_SetObjResult(interp, result);
return TCL_OK;
}
pstring *
ring_buffer_get_pstring(void *data, long off, int len) {
RingBuffer *rb = data;
char *val = ring_buffer_get(rb, off, len);
if(val == NULL) {
return NULL;
} else {
pstring *pstr = malloc(sizeof(pstring));
pstr->val = val;
pstr->len = len;
return pstr;
}
}
void uart_a0_tx_start_handler(void) {
if (EUSCI_A_UART_getInterruptStatus(EUSCI_A0_BASE,
EUSCI_A_UART_TRANSMIT_INTERRUPT_FLAG)) {
char c;
if (ring_buffer_get(_uart_a0_tx_ringbuffer_id, &c) == 0) {
UCA0TXBUF = c;
} else {
panic(
"uart_a0_tx_start_handler: invoked but tx_rbf is empty");
}
}
EUSCI_A_UART_enableInterrupt(EUSCI_A0_BASE,
EUSCI_A_UART_TRANSMIT_INTERRUPT);
}
SEXP R_ring_buffer_tail_offset(SEXP extPtr, SEXP r_offset) {
size_t offset = INTEGER(r_offset)[0];
ring_buffer * buffer = ring_buffer_get(extPtr, 1);
SEXP ret = PROTECT(allocVector(RAWSXP, buffer->stride));
data_t *data = (data_t*) ring_buffer_tail_offset(buffer, offset);
if (data == NULL) {
Rf_error("Buffer underflow");
}
memcpy(RAW(ret), data, buffer->stride);
UNPROTECT(1);
// NOTE: In C we return the tail position here but that is not done
// for the R version.
return ret;
}
pstring *
engine_get_document(Engine *engine, long doc_id) {
if (doc_id < 0) {
return NULL;
}
long off = doc_id * sizeof(DocRef);
DocRef *dr = ring_buffer_get(engine->docs, off, sizeof(DocRef));
if(dr == NULL) {
return NULL;
} else {
pstring *doc = ring_buffer_get_pstring(engine->stream, dr->off, dr->len);
free(dr);
return doc;
}
}
SEXP R_ring_buffer_memcpy_from(SEXP extPtr, SEXP r_count) {
size_t count = INTEGER(r_count)[0];
ring_buffer * buffer = ring_buffer_get(extPtr, 1);
SEXP ret = PROTECT(allocVector(RAWSXP, count * buffer->stride));
if (ring_buffer_memcpy_from(RAW(ret), buffer, count) == NULL) {
// TODO: this would be better reporting than just saying "Buffer
// underflow". But we need to switch here on stride being 1 or
// compute the byte size of `count` entries.
Rf_error("Buffer underflow (requested %d bytes but %d available)",
count, ring_buffer_used(buffer, 1) / buffer->stride);
}
UNPROTECT(1);
// NOTE: In C we return the tail position here but that is not done
// for the R version.
return ret;
}
int uart_read (struct file * filp, char *buf, size_t count, loff_t *t)
{
int rcount=0;
while ( (rcount < count) && !ring_buffer_isempty(&ring) ) {
// To do: read recive character form ring buffer
*(prbuf+rcount) = ring_buffer_get(&ring);
rcount++;
}
if( rcount != 0 ) {
// copy the data to user space
if( copy_to_user(buf, prbuf, rcount) != 0)
return -EFAULT;
}
return rcount;
}
static void draw_waveform(void) {
int n = MIN((int) round(current_width * display_zoom), sizeof_ring_buffer);
int m = current_width;
while (pthread_mutex_trylock(samples_drawable_lock) != 0) {
nanosecond_sleep();
}
while (pthread_mutex_trylock(ring_buffer->elements_lock) != 0) {
nanosecond_sleep();
}
memset(samples_drawable, 0, sizeof(TYPE) * current_width);
for(size_t i = 0; i < current_width; i++) {
int sample_offset = (int) round((i * n + m / 2.0) / m);
TYPE sample = ring_buffer_get(ring_buffer, sample_offset);
samples_drawable[i] = sample;
}
pthread_mutex_unlock(ring_buffer->elements_lock);
pthread_mutex_unlock(samples_drawable_lock);
glClearColor(base3[0], base3[1], base3[2], base3[3]);
glColor4fv(orange);
glLineWidth(1.0);
glBegin(GL_LINE_STRIP);
while (pthread_mutex_trylock(samples_drawable_lock) != 0) {
nanosecond_sleep();
}
for (size_t j = 0; j < current_width; j++) {
if (j == 0) {
continue;
}
TYPE sample = samples_drawable[current_width - j];
double gl_x_coord = j;
double gl_y_coord = sample * current_height;
if (fabs(gl_y_coord) < EPSILON) {
gl_y_coord = 1.0;
}
glVertex2f(gl_x_coord, gl_y_coord);
}
pthread_mutex_unlock(samples_drawable_lock);
glEnd();
}
int uart_read (struct file * filp, char *buf, size_t count, loff_t *t)
{
int rcount=0;
if( ring_buffer_isenmpty(&ring) ) {
// To do: wait for an event.
}
while ( (rcount < count) && !ring_buffer_isenmpty(&ring) ) {
*(prbuf+rcount)=ring_buffer_get (&ring);
rcount++;
}
if( rcount != 0 ) {
if( copy_to_user(buf, prbuf, rcount) != 0)
return -EFAULT;
}
return rcount;
}
void *
ring_cursor_entry(Cursor *scursor) {
ring_buffer_cursor *cursor = (ring_buffer_cursor *)scursor;
return ring_buffer_get(cursor->rb, cursor->pos * cursor->width, cursor->width);
}
SEXP R_ring_buffer_used(SEXP extPtr, SEXP bytes) {
return ScalarInteger(ring_buffer_used(ring_buffer_get(extPtr, 1),
logical_scalar(bytes)));
}
/**
* \brief Function for getting a char from the UART receive buffer
*
* \retval Next data byte in receive buffer
*/
static inline uint8_t uart_getchar(void)
{
return ring_buffer_get(&ring_buffer_in);
}
SEXP R_ring_buffer_reset(SEXP extPtr) {
ring_buffer_reset(ring_buffer_get(extPtr, 1));
return R_NilValue;
}
SEXP R_ring_buffer_empty(SEXP extPtr) {
return ScalarLogical(ring_buffer_empty(ring_buffer_get(extPtr, 1)));
}
SEXP R_ring_buffer_bytes_data(SEXP extPtr) {
return ScalarInteger(ring_buffer_bytes_data(ring_buffer_get(extPtr, 1)));
}
SEXP R_ring_buffer_stride(SEXP extPtr) {
return ScalarInteger(ring_buffer_get(extPtr, 1)->stride);
}
SEXP R_ring_buffer_clone(SEXP extPtr) {
ring_buffer *prev = ring_buffer_get(extPtr, 1);
return R_ring_buffer_build(ring_buffer_clone(prev));
}
SEXP R_ring_buffer_memset(SEXP extPtr, SEXP c, SEXP len) {
return ScalarInteger(ring_buffer_memset(ring_buffer_get(extPtr, 1),
RAW(c)[0], INTEGER(len)[0]));
}
