Subversion Repositories f9daq

Compare Revisions

Ignore whitespace Rev 230 → Rev 231

/cvi/instr/RedPitaya/sockserv/Makefile
1,5 → 1,5
#CFLAGS = -DMRP
##
CFLAGS = -DMRP
#
# $Id: Makefile 1249 2014-02-22 20:21:40Z ales.bardorfer $
#
# (c) Red Pitaya http://www.redpitaya.com
/cvi/instr/RedPitaya/sockserv/daq.c
29,6 → 29,7
 
 
void timerast (signumber, code, context) int signumber, code; struct sigcontext context; {
fprintf(stderr, "Timeout\n");
timer_out = TRUE;
}
 
80,7 → 81,7
#ifndef MRP
rp_calib_params_t rp_calib_params; /** Pointer to externally defined calibration parameters. */ rp_calib_params_t *gen_calib_params = NULL;
#endif
int daq_init (char * buff, int nb) {
int daq_init (char * buff) {
#ifdef DEBUG
fprintf (stderr, "Server: init\n");
#endif
151,6 → 152,9
return 0;
}
 
 
int16_t chdata[16*1024];
//float chfdata[16*1024];
int daq_run (const char *par, char ** data, int *maxlen)
 
{
158,16 → 162,15
int *data_buf;
int neve;
 
unsigned short *sbuff = (unsigned short *) (par+4);
unsigned short *sbuff = (unsigned short *) (par);
unsigned short maxeve = sbuff[0];
unsigned short nsamples = sbuff[1];
unsigned short tout = sbuff[2];
unsigned char trigger = par[10];
unsigned char chmask = par[11];
unsigned char trigger = par[6];
unsigned char chmask = par[7];
 
neve = 0;
timer_out = FALSE;
tmlnk (tout);
int eventsize = 0;
if (chmask & 0x1) eventsize += (nsamples+2);
if (chmask & 0x2) eventsize += (nsamples+2);
201,14 → 204,28
rp_AcqStart();
usleep(sleeptime);
rp_AcqSetTriggerSrc(trigger);
timer_out = FALSE;
tmlnk (tout);
rp_acq_trig_src_t source;
do {
rp_AcqGetTriggerSrc(&source);
//printf("TRG %d src %d\n", trigger, source);
if (timer_out || ctrl_c) break;
} while (source == trigger);
tmulk ();
 
usleep(sleeptime);
 
/*
rp_acq_trig_state_t state = RP_TRIG_STATE_TRIGGERED;
do {
rp_AcqGetTriggerSrc(&state);
rp_AcqGetTriggerState(&state);
} while (state == RP_TRIG_STATE_WAITING );
//while(rp_AcqSetTriggerState(trigger));
*/
 
 
 
#else
 
osc_fpga_arm_trigger();
215,7 → 232,9
usleep(sleeptime);
osc_fpga_set_trigger(trigger);
 
while (g_osc_fpga_reg_mem->trig_source != 0){}
while (g_osc_fpga_reg_mem->trig_source != 0){
if (timer_out || ctrl_c) break;
}
// with this loop the program waits until the acquistion is completed before continue.
int trig_ptr = g_osc_fpga_reg_mem->wr_ptr_trigger; // get pointer to mem. adress where trigger was met
int * ch_signal[2];
232,7 → 251,9
#ifdef MRP
const int c[2] = {RP_CH_1, RP_CH_2};
unsigned int isamples = nsamples;
rp_AcqGetOldestDataV(c[id], &isamples, (float *) data_buf);
//rp_AcqGetLatestDataV(c[id], &isamples, chfdata );
rp_AcqGetLatestDataRaw(c[id], &isamples, chdata);
for (int i=0;i<nsamples;i++) *(data_buf++) = chdata[i];
#else
 
const int BUF = 16*1024;
251,12 → 272,12
*(data_buf++) = 0x3;
*(data_buf++) = neve;
neve++;
if (ieve+1 % 1000 == 0) printf("Event %d\n", ieve);
if (ieve+1 % 500 == 0) fprintf(stderr, "Event %d\n", ieve);
if (timer_out) break;
 
}
 
tmulk ();
 
int *len = ibuf;
int *nev = ibuf + 1;
271,7 → 292,6
 
#define MAXLEN 0XFFFF
struct RUNHDR {
int len;
unsigned short neve;
unsigned short nsamples;
unsigned short tout;
328,7 → 348,6
struct RUNHDR runhdr;
 
 
runhdr.len = sizeof(struct RUNHDR);
runhdr.neve =10000;
runhdr.nsamples = 1024;
runhdr.tout = 1000;
402,7 → 421,7
printf("argdata %d nloops %d\n",argdata,runhdr.nloops);
 
daq_init((char *)&inihdr, sizeof(inihdr));
daq_init((char *)&inihdr);
FILE *fp=NULL;
if (strlen(filename)>0) fp = fopen(filename, "wb");
/cvi/instr/RedPitaya/sockserv/daq.h
1,7 → 1,7
#ifndef DAQ_H
#define DAQ_H
 
int daq_init (char * buff, int len);
int daq_init (char * buff);
int daq_clear ();
int daq_end ();
int daq_run (const char *par, char ** buff, int *maxlen);
/cvi/instr/RedPitaya/sockserv/sockserv.c
1,223 → 1,209
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
/*
C socket server example, handles multiple clients using threads */
#include<stdio.h>
#include<string.h> //strlen
#include<stdlib.h> //strlen
#include<sys/socket.h>
#include<arpa/inet.h> //inet_addr
#include<unistd.h>
#//write
#include<pthread.h>
#include "daq.h"
/* #define DEBUG */
 
#define PORT 9930
#define EXIT_FAILURE 1
//the thread function
 
int make_socket (port)
unsigned short int port;
{
int sock;
struct sockaddr_in name;
 
/* create the socket. */
sock = socket (AF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
perror ("socket");
exit (EXIT_FAILURE);
}
/* give the socket name */
name.sin_family = AF_INET;
name.sin_port = htons (port);
name.sin_addr.s_addr = htonl (INADDR_ANY);
if (bind (sock, (struct sockaddr *) &name, sizeof (name)) < 0)
{
perror ("bind");
exit (EXIT_FAILURE);
}
return sock;
 
void *connection_handler(void *);
int is_connected = 0;
int ncalls=0;
extern int ctrl_c;
 
int writesock(int sock, int id , char *msg, int len ){
int hdr[2];
hdr[0]= id;
hdr[1]= len + 8;
write(sock , hdr , 8);
return write(sock , msg , len);
}
 
void write_socket (sock_num, buff, len)
int sock_num, len;
char *buff;
{
int status;
 
do
{
if (0 > (status = write (sock_num, buff, len)))
int main(int argc , char *argv[]) {
int socket_desc , client_sock , c , *new_sock=NULL;
struct sockaddr_in server , client;
 
if (argc >1) return daq_main(argc, argv);
//Create socket
socket_desc = socket(AF_INET , SOCK_STREAM , 0);
if (socket_desc == -1)
{
perror ("\nwrite(write_socket)");
exit (EXIT_FAILURE);
printf("Could not create socket");
}
len -= status;
buff += status;
}
while (len);
}
puts("Socket created");
//Prepare the sockaddr_in structure
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons( PORT );
//Bind
if( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0)
{
//print the error message
perror("bind failed. Error");
return 1;
}
puts("bind done");
//Listen
listen(socket_desc , 3);
//Accept and incoming connection
puts("Waiting for incoming connections...");
c = sizeof(struct sockaddr_in);
//Accept and incoming connection
puts("Waiting for incoming connections...");
c = sizeof(struct sockaddr_in);
while( (client_sock = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c)) )
{
puts("Connection accepted");
pthread_t sniffer_thread;
 
void read_socket (sock_num, buff, len)
int sock_num, len;
char *buff;
{
int status;
if (is_connected){
char message[0xFF]="Only one client can connect. Disconnect it first!";
perror(message);
writesock(client_sock , 0, message , strlen(message));
close (client_sock);
continue;
}
new_sock = (int *) malloc(1);
*new_sock = client_sock;
if( pthread_create( &sniffer_thread , NULL , connection_handler , (void*) new_sock) < 0)
{
perror("could not create thread");
return 1;
}
 
do
{
if (0 > (status = read (sock_num, buff, len)))
//Now join the thread , so that we dont terminate before the thread
//pthread_join( sniffer_thread , NULL);
puts("Handler assigned");
}
if (client_sock < 0)
{
perror ("\nread(read_socket)");
exit (EXIT_FAILURE);
perror("accept failed");
return 1;
}
len -= status;
buff += status;
}
while (len);
return 0;
}
 
 
 
int main (int argc, char ** argv)
{
int sock_org, sock_cam, sock_new;
int bufsize = 10000000;
int recvdata[0xFF];
char *data, status, connected = 0;
char msg;
void *daq_handler(void *rdata){
if (argc >1) return daq_main(argc, argv);
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
//Get the socket descriptor
int sock = *(int*)rdata;
int *idata = (int *)rdata;
char * settings = (char *) (idata+2);
daq_init(settings);
settings +=12;
int bufsize = 0;
char * data = NULL;
 
data = malloc(sizeof(int) * bufsize);
int *idata = (int*)data;
fd_set active_fd_set, read_fd_set;
struct sockaddr_in clientname;
size_t size;
//for(int i =0;i<5;i++) printf("%d %d\n",i, idata[i]);
while (1){
int nb = daq_run ( settings, &data, &bufsize );
int error = 0;
socklen_t len = sizeof (error);
int retval = getsockopt (sock, SOL_SOCKET, SO_ERROR, &error, &len);
if (retval!=0 || error!=0) break;
writesock(sock , 1, data , nb );
if (ctrl_c) break;
//break;
}
if (data!=NULL) free(data);
fprintf(stderr, "Exiting thread %d\n", sock ) ;
return NULL;
}
 
/*
* This will handle connection for each client
* */
 
/* map camac memory */
//map_camac ();
void *connection_handler(void *socket_desc) {
//Get the socket descriptor
int sock = *(int*)socket_desc;
int read_size;
char *message , client_message[2000];
is_connected = 1;
//Send some messages to the client
message = "Info from connection handler\n";
writesock(sock , 0, message , strlen(message));
//Receive a message from client
pthread_t daq_thread = 0;
 
/* Create the socket and set it up to accept connections */
sock_org = make_socket (PORT);
if (listen (sock_org, 1) < 0)
{
perror ("listen");
exit (EXIT_FAILURE);
}
/* Initialize the set of active sockets */
FD_ZERO (&active_fd_set);
FD_SET (sock_org, &active_fd_set);
 
while (1)
{
read_fd_set = active_fd_set;
if (select (32, &read_fd_set, 0, 0, 0) <0)
while( (read_size = recv(sock , client_message , 2000 , 0)) > 0 )
{
perror ("select");
exit (EXIT_FAILURE);
}
if (FD_ISSET (sock_org, &read_fd_set))
{
size = sizeof (clientname);
sock_new = accept (sock_org, (struct sockaddr *) &clientname, &size);
if (sock_new < 0)
{
perror ("accept");
exit (EXIT_FAILURE);
}
fprintf (stderr, "Server: connect from host %s, port %hd.\n",
inet_ntoa (clientname.sin_addr),
ntohs (clientname.sin_port));
if (connected)
{
msg = 0;
status = send (sock_new, &msg, 1, 0);
{
perror ("send");
exit (EXIT_FAILURE);
}
close (sock_new);
}
else
{
msg = 1;
status = send (sock_new, &msg, 1, 0);
if (status < 0)
//Send the message back to client
int * hdr = (int *) client_message;
printf("Received %d bytes RECID = %d LEN %d\n",read_size, hdr[0], hdr[1]);
switch (hdr[0]){
case 0:
ctrl_c = 0;
hdr[0]= sock;
if( pthread_create( &daq_thread , NULL , daq_handler , (void*) &client_message) < 0)
{
perror("could not create daq thread");
}
break;
case 1:
ctrl_c = 1;
sleep(1);
if (daq_thread) {
pthread_cancel(daq_thread);
daq_thread = 0;
}
 
break;
default: break;
 
{
perror ("send");
exit (EXIT_FAILURE);
}
sock_cam = sock_new;
FD_SET (sock_cam, &active_fd_set);
connected = 1;
}
}
else
if(read_size == 0)
{
/* Data ariving on an already-connected socket. */
status = recv (sock_cam, &msg, 1, 0);
if (status < 0)
{
perror ("recv");
exit (EXIT_FAILURE);
}
if (status == 0) msg = 0;
 
#ifdef DEBUG
fprintf (stderr, "Server: Cmd(%d): %d\n", status, msg);
#endif
 
switch (msg)
{
case 0:
fprintf (stderr, "Server: disconnecting\n");
close (sock_cam);
FD_CLR (sock_cam, &active_fd_set);
connected = 0;
daq_end();
break;
case 1:
read_socket (sock_cam, &data[8], 12);
daq_init (&data[8], idata[0]);
fprintf (stderr, "Server: Init finished\n");
break;
case 2:
daq_clear ();
break;
case 3:
fprintf (stderr, "Server: Run Start\n");
 
read_socket (sock_cam, (char *) &recvdata[1], 8);
puts("Client disconnected");
fflush(stdout);
}
else if(read_size == -1)
{
perror("recv failed");
daq_run ((const char *) recvdata, &data, &bufsize );
idata = (int*)data;
#ifdef DEBUG
fprintf (stderr, "Server: Run end: %d\n", idata[0]);
#endif
}
if (daq_thread) {
pthread_cancel(daq_thread);
daq_thread = 0;
}
 
write_socket (sock_cam, &msg, 1);
//Free the socket pointer
free(socket_desc);
socket_desc = 0;
is_connected = 0;
return 0;
}
 
#ifdef DEBUG
fprintf (stderr, "Server: Data ready(%d): %d\n", status, msg);
#endif
 
break;
case 4:
write_socket (sock_cam, &msg, 1);
write_socket (sock_cam, data, idata[0]);
 
#ifdef DEBUG
fprintf (stderr, "Server: Data sent: %d, %d, %d\n",
idata[0], idata[1], idata[2]);
#endif
 
break;
default:
fprintf (stderr, "Server: unknown command -> exiting...\n");
exit (EXIT_FAILURE);
}
}
}
if (data !=NULL) free(data);
}