Blocking read from FIFO in Linux app?

[<j_clifton@aerosimulation.com>]

I installed RTLinux 3.0 on Kernel 2.2.18 on a dual processor PIII 500MHz. All I
need is a 60Hz signal to a Linux app. I originally tried modifying the Kernel Hz
from 100 to 960 but for some reason there were a tremendous amount of jitter
whereas 100Hz was fairly stable.

For my second attempt, I installed RTL 3.0 and cobbled up a pair of programs
from the examples. In my test program everything is fine and the jitter is quite
low no matter what I try to peturb it. When I try to use the read in a large Ada
program it works for a while and then I start getting zero bytes back from the
FIFO sometimes instead of blocking until the FIFO is non empty. I put in code to
read the FIFO again if the read returns zero bytes but instead of blocking on
the FIFO my CPU utilization is 100%.

I like having the FIFO return a structure which is the tic count and the elapsed
time from the RDTSC instruction because it allows me to detect frame overruns
but I could use a semaphore if anyone has a reliable example.

Jon Clifton

    

all: rtlinux_mod.o linux_app

include ../../rtl.mk

linux_app: linux_app.c
	$(CC) ${USER_CFLAGS} ${INCLUDE} -Wall -O2 -o linux_app linux_app.c

test: all
	@ -/sbin/rmmod rtlinux_mod
	(cd ../../; scripts/rmrtl)
	(cd ../../; scripts/insrtl)
	@/sbin/insmod -v rtlinux_mod.o
	@./linux_app

stop_test:
	@ -/sbin/rmmod rtlinux_mod
	-/sbin/rmmod rtl_fifo
	-/sbin/rmmod rtl_sched
	-/sbin/rmmod rtl_time

clean:
	rm -f *.o linux_app

include $(RTL_DIR)/Rules.make

#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>

#define NANOSECONDS_PER_TICK (double)((double)1000.00/(double)500.00) 
int main(){
	int fd,count;
	int tics=0;
	struct { int count; unsigned int d;}D;
	double f;
	double sum=0.0;
	if( (fd = open("/dev/rtf0",O_RDONLY) ) < 0 ){
		perror("Can't open fifo");
		exit(-1);
	}
	read(fd,&D,sizeof(D));
	count = D.count;
	while( (read(fd,&D,sizeof(D))  == sizeof(D))){
		f = (double)D.d;
		f = ((f) * NANOSECONDS_PER_TICK)/1000;
                sum+=f;
		tics++;
		printf("Delay was %f microseconds, avg=%f, D={%8d, %08x}\n",
			f,sum/(double)tics, D.count, D.d);
		if(count && (count+1 != D.count))
			printf("Dropped a packet at %d ",count);
		count = D.count;
	}
	return 0;
}

#include <rtl.h>
#include <rtl_fifo.h>
#include <time.h>
#include <rtl_sched.h>
#include <rtl_sync.h>
#include <pthread.h>
#include <posix/unistd.h>

#define FRAME_INTERVAL 16695149LL /* fudged 16.67ms */
#define FIFO_SIZE 4000

pthread_t thread;
int fd;
int stop = 0;
static void copy_device_data(unsigned int *);

void *start_routine(void *arg){
	struct sched_param p;
	struct {int i; unsigned int d; }D = {0,0};

	p.sched_priority=1;
	pthread_setschedparam (pthread_self(), SCHED_FIFO, &p);
	pthread_make_periodic_np (pthread_self(), 
		clock_gethrtime(CLOCK_RTL_SCHED),
		FRAME_INTERVAL);
	copy_device_data(&D.d);

	while(!stop){
		pthread_wait_np();
		copy_device_data(&D.d);
		D.i++;
		/* ignore write fails, we just drop the data */
		write(fd,&D,sizeof(D));
	}
	return 0;
}
int init_module(void){
	
	rtf_destroy(0);
        rtf_create(0,FIFO_SIZE);
	if ( (fd = open("/dev/rtf0",O_WRONLY | O_NONBLOCK )) < 0)
	{
		rtl_printf("rtlinux_mod cannot open fifo\n");
		rtl_printf("Error number is %d\n",errno);
		return -1;
	}
	return( pthread_create(&thread,NULL,start_routine,0));
}

void cleanup_module(void){ 
	stop = 1;
	close(fd);
	rtf_destroy(0);
	pthread_delete_np(thread);
	return;
}

static void copy_device_data(unsigned int *x)
{
	static int last=0;
	int d;
	rdtscl(d);
	*x= (d - last);
	last = d;
	return;
}


#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>

#define CPU_MHz 500.00L
#define NANOSECONDS_PER_TICK (double)((double)1000.00/(double)CPU_MHz) 
//#define DEBUG

int rtl_wait(void) {
          //(int * tics, double * delta_t){
	static int firstpass=1;
	static int fd;
	static int rtl_count;
	static int n=0;
	static int nbytes=0;
	static double sum;
	struct { int rtl_count; unsigned int d;}D;
	double f;

	if (firstpass) {
		if( (fd = open("/dev/rtf0",O_RDONLY) ) < 0 ){
			perror("Can't open fifo");
			exit(-1);
		}
		firstpass=0;
		n=0;
		sum=0.0;
		read(fd,&D,sizeof(D));
		rtl_count = D.rtl_count;
	}
	while (0 ==(nbytes= read(fd,&D,sizeof(D))));
	if (sizeof(D) != nbytes) {
		fprintf(stderr,"read %d ",nbytes);
		perror("FIFO failed to block");
	}
#ifdef DEBUG
	f = (double)D.d;
	f = ((f) * NANOSECONDS_PER_TICK)/1000.0;
	n++;
	sum+=f;
	printf("Delay was %f microseconds, avg=%f, sec=%5d f=%2d, D={ %8d, %08x}\n",
		f,sum/(double)n, n/60, 1+(n%60), D.rtl_count, D.d);
#endif
	if(rtl_count && (rtl_count+1 != D.rtl_count))
		printf("Dropped %x tics at %x\n",
			D.rtl_count-(rtl_count-1), rtl_count);
	rtl_count = D.rtl_count;
//	*tics=rtl_count;
//	*delta_t=f;
//	return;
	return rtl_count;
}