static drvM6802_controlThreadConfig* make_fpdpThreadConfig(drvM6802_taskConfig *ptaskConfig)
{
drvM6802_controlThreadConfig *pfpdpThreadConfig = NULL;
pfpdpThreadConfig = (drvM6802_controlThreadConfig*)malloc(sizeof(drvM6802_controlThreadConfig));
if(!pfpdpThreadConfig) return pfpdpThreadConfig;
sprintf(pfpdpThreadConfig->threadName, "FPDP_ctrl");
pfpdpThreadConfig->threadPriority = epicsThreadPriorityHigh;
pfpdpThreadConfig->threadStackSize = epicsThreadGetStackSize(epicsThreadStackBig);
pfpdpThreadConfig->threadFunc = (EPICSTHREADFUNC) FPDPthreadFunc;
pfpdpThreadConfig->threadParam = (void*) ptaskConfig;
pfpdpThreadConfig->threadQueueId = epicsMessageQueueCreate(100,sizeof(bufferingThreadQueueData));
bufferingQueueID = pfpdpThreadConfig->threadQueueId;
/* pfpdpThreadConfig->threadQueueId = 0; */
/* if(pfpdpThreadConfig->threadQueueId) ptaskConfig->taskStatus |= TASK_CONTQUEUE; */
epicsThreadCreate(pfpdpThreadConfig->threadName,
pfpdpThreadConfig->threadPriority,
pfpdpThreadConfig->threadStackSize,
(EPICSTHREADFUNC) pfpdpThreadConfig->threadFunc,
(void*) pfpdpThreadConfig->threadParam);
return pfpdpThreadConfig;
}
static long initialize()
{
epicsThreadId tid;
unsigned long cvtRecCnt = countCvtRecords();
if (!initConversionQ && cvtRecCnt > 0) {
initConversionQ = epicsMessageQueueCreate((unsigned)cvtRecCnt,
REINIT_MSG_SIZE);
if (!initConversionQ) {
nerrmsg("", "msgQCreate failed");
goto error;
}
tid = epicsThreadCreate("initCvt", epicsThreadPriorityLow, 20000,
(EPICSTHREADFUNC)initConversionTask, 0);
if (!tid) {
nerrmsg("", "taskSpawn failed");
goto error;
}
}
return 0;
error:
if (initConversionQ) epicsMessageQueueDestroy(initConversionQ);
return -1;
}
/*
static void print_channelConfig(drvM6802_taskConfig *ptaskConfig, int level)
{
drvM6802_channelConfig *pchannelConfig;
pchannelConfig = (drvM6802_channelConfig*) ellFirst(ptaskConfig->pchannelConfig);
while(pchannelConfig) {
epicsPrintf(" %s", pchannelConfig->chanName);
if(level>2) {
epicsPrintf("\tChannel, status: 0x%x, index: %d, gain: %f",
pchannelConfig->channelStatus,
pchannelConfig->chanIndex,
pchannelConfig->gain );
if(level>3) {
epicsPrintf(", conv.T: %f usec", pchannelConfig->conversionTime_usec);
}
}
epicsPrintf("\n");
pchannelConfig = (drvM6802_channelConfig*) ellNext(&pchannelConfig->node);
}
return;
}
*/
static drvM6802_controlThreadConfig* make_controlThreadConfig(drvM6802_taskConfig *ptaskConfig)
{
drvM6802_controlThreadConfig *pcontrolThreadConfig = NULL;
pcontrolThreadConfig = (drvM6802_controlThreadConfig*)malloc(sizeof(drvM6802_controlThreadConfig));
if(!pcontrolThreadConfig) return pcontrolThreadConfig;
sprintf(pcontrolThreadConfig->threadName, "%s_ctrl", ptaskConfig->taskName);
pcontrolThreadConfig->threadPriority = epicsThreadPriorityLow;
pcontrolThreadConfig->threadStackSize = epicsThreadGetStackSize(epicsThreadStackSmall);
pcontrolThreadConfig->threadFunc = (EPICSTHREADFUNC) controlThreadFunc;
pcontrolThreadConfig->threadParam = (void*) ptaskConfig;
pcontrolThreadConfig->threadQueueId = epicsMessageQueueCreate(100,sizeof(controlThreadQueueData));
epicsThreadCreate(pcontrolThreadConfig->threadName,
pcontrolThreadConfig->threadPriority,
pcontrolThreadConfig->threadStackSize,
(EPICSTHREADFUNC) pcontrolThreadConfig->threadFunc,
(void*) pcontrolThreadConfig->threadParam);
return pcontrolThreadConfig;
}
static void spawnThread(void *param)
{
subRecord *precord = (subRecord*) param;
queueId = epicsMessageQueueCreate(20, sizeof(myData*));
threadId = epicsThreadCreate("calcThread",
epicsThreadPriorityLow,
epicsThreadGetStackSize(epicsThreadStackSmall),
calcThread,
NULL);
if(dbSubFinalDebug) {
epicsPrintf("Thread Spawn by (thread) %s, (record) %s\n",
epicsThreadGetNameSelf(),
precord->name);
}
}
static long doCalc(acalcoutRecord *pcalc) {
calcMessage msg;
int doAsync = 0;
if (aCalcoutRecordDebug >= 10)
printf("acalcoutRecord(%s):doCalc\n", pcalc->name);
if ( acalcGetNumElements(pcalc) > aCalcAsyncThreshold )
doAsync = 1;
/* if required infrastructure doesn't yet exist, create it */
if (doAsync && acalcMsgQueue == NULL) {
acalcMsgQueue = epicsMessageQueueCreate(MAX_MSG, MSG_SIZE);
if (acalcMsgQueue==NULL) {
printf("aCalcoutRecord: Unable to create message queue\n");
return(-1);
}
acalcThreadId = epicsThreadCreate("acalcPerformTask", PRIORITY,
epicsThreadGetStackSize(epicsThreadStackBig),
(EPICSTHREADFUNC)acalcPerformTask, (void *)epicsThreadGetIdSelf());
if (acalcThreadId == NULL) {
printf("aCalcoutRecord: Unable to create acalcPerformTask\n");
epicsMessageQueueDestroy(acalcMsgQueue);
acalcMsgQueue = NULL;
return(-1);
}
}
/* Ideally, we should do short calculations in this thread, and queue long calculations.
* But aCalcPerform is not reentrant (global value stack), so for now we queue everything.
*/
if (doAsync) {
if (aCalcoutRecordDebug >= 2) printf("acalcoutRecord(%s):doCalc async\n", pcalc->name);
pcalc->cact = 1; /* Tell caller that we went asynchronous */
msg.pcalc = pcalc;
epicsMessageQueueSend(acalcMsgQueue, (void *)&msg, MSG_SIZE);
return(0);
} else {
if (aCalcoutRecordDebug >= 2) printf("acalcoutRecord(%s):doCalc sync\n", pcalc->name);
call_aCalcPerform(pcalc);
}
return(0);
}
int drvAsynNiPci6220Configure(char *portName, char *trgName, int extMode, int trigMode, int smp_mode)
{
int i;
sprintf(daq6220pvt.devName, "%s", portName);
sprintf(daq6220pvt.trgName, "%s", trgName);
daq6220pvt.trigMode = trigMode;
daq6220pvt.extMode = extMode;
if(smp_mode) /* Cont */
daq6220pvt.smp_mode = CONT_MODE;
else
daq6220pvt.smp_mode = FINITE_MODE;
daq6220pvt.rate = 1000.0;
daq6220pvt.sampsPerChan = 1000;
daq6220pvt.terminalConfig = DAQmx_Val_RSE;
daq6220pvt.pretriggerSamples = 1000;
daq6220pvt.triggerEdge = DAQmx_Val_Rising;
daq6220pvt.status = DAQ_STATUS_STOP;
daq6220pvt.totalRead = 0;
daq6220pvt.t0 = 0;
daq6220pvt.t1 = 1;
daq6220pvt.fBlipTime = -16;
for(i=0; i < 16; i++) {
daq6220pvt.mdsput[i] = 0;
daq6220pvt.int_mode[i] = 0;
daq6220pvt.gain[i] = 0.0;
daq6220pvt.offset[i] = 0.0;
}
daq6220pvt.DaqQueueId = epicsMessageQueueCreate(50,sizeof(DaqQueueData));
daq6220pvt.threadId = epicsThreadCreate(portName,
epicsThreadPriorityHigh,
epicsThreadGetStackSize(epicsThreadStackSmall),
(EPICSTHREADFUNC)NiPci6220MainThread, NULL);
return 0;
}
int drvAsynNiPci6220Configure(char *portName, int extMode, int trigMode)
{
int i;
daq6220pvt.trigMode = trigMode;
daq6220pvt.extMode = extMode;
daq6220pvt.rate = 10000.0;
daq6220pvt.sampsPerChan = 10000;
daq6220pvt.terminalConfig = DAQmx_Val_RSE;
daq6220pvt.pretriggerSamples = 10000;
daq6220pvt.triggerEdge = DAQmx_Val_Rising;
daq6220pvt.status = DAQ_STATUS_STOP;
daq6220pvt.t0 = 0;
daq6220pvt.t1 = 1;
daq6220pvt.fBlipTime = -16;
daq6220pvt.mdsput[0] = 1;
daq6220pvt.mdsput[1] = 1;
daq6220pvt.mdsput[2] = 1;
daq6220pvt.mdsput[3] = 1;
daq6220pvt.mdsput[4] = 1;
daq6220pvt.mdsput[5] = 1;
daq6220pvt.mdsput[6] = 1;
daq6220pvt.mdsput[7] = 1;
daq6220pvt.mdsput[8] = 1;
daq6220pvt.mdsput[9] = 1;
daq6220pvt.mdsput[10] = 1;
for(i=11; i < 16; i++)
daq6220pvt.mdsput[i] = 0;
memcpy(&daq6220pvt.mdsnode[0],"EC1_TCLC\0", 9);
memcpy(&daq6220pvt.mdsnode[1],"EC1_TCLM\0", 9);
memcpy(&daq6220pvt.mdsnode[2],"EC1_TPRL\0", 9);
memcpy(&daq6220pvt.mdsnode[3],"EC1_TSWD\0", 9);
memcpy(&daq6220pvt.mdsnode[4],"EC1_TDCBR\0", 10);
memcpy(&daq6220pvt.mdsnode[5],"EC1_TBTUN\0", 10);
memcpy(&daq6220pvt.mdsnode[6],"EC1_TRAD\0", 9);
memcpy(&daq6220pvt.mdsnode[7],"EC1_TMIRR\0", 10);
memcpy(&daq6220pvt.mdsnode[8],"EC1_VION1\0", 10);
memcpy(&daq6220pvt.mdsnode[9],"EC1_VION2\0", 10);
memcpy(&daq6220pvt.mdsnode[10],"EC1_VION3\0", 10);
printf("[%s]\n", daq6220pvt.mdsnode[0]);
printf("[%s]\n", daq6220pvt.mdsnode[1]);
printf("[%s]\n", daq6220pvt.mdsnode[2]);
printf("[%s]\n", daq6220pvt.mdsnode[3]);
printf("[%s]\n", daq6220pvt.mdsnode[4]);
printf("[%s]\n", daq6220pvt.mdsnode[5]);
printf("[%s]\n", daq6220pvt.mdsnode[6]);
printf("[%s]\n", daq6220pvt.mdsnode[7]);
printf("[%s]\n", daq6220pvt.mdsnode[8]);
printf("[%s]\n", daq6220pvt.mdsnode[9]);
printf("[%s]\n", daq6220pvt.mdsnode[10]);
daq6220pvt.DaqQueueId = epicsMessageQueueCreate(50,sizeof(DaqQueueData));
system("rm -f /tmp/nidaq_6220.dat");
daq6220pvt.threadId = epicsThreadCreate(portName,
epicsThreadPriorityHigh,
epicsThreadGetStackSize(epicsThreadStackSmall),
(EPICSTHREADFUNC)NiPci6220MainThread, NULL);
return 0;
}
IpUnidig::IpUnidig(const char *portName, int carrier, int slot, int msecPoll, int intVec, int risingMask, int fallingMask)
:asynPortDriver(portName,1,NUM_IPUNIDIG_PARAMS,
asynInt32Mask | asynUInt32DigitalMask | asynDrvUserMask,
asynUInt32DigitalMask,
0,1,0,0),
risingMask_(risingMask),
fallingMask_(fallingMask),
polarityMask_(risingMask)
{
//static const char *functionName = "IpUnidig";
ipac_idProm_t *id;
epicsUInt16 *base;
/* Default of 100 msec for backwards compatibility with old version */
if (msecPoll == 0) msecPoll = 100;
pollTime_ = msecPoll / 1000.;
messagesSent_ = 0;
messagesFailed_ = 0;
rebooting_ = 0;
forceCallback_ = 0;
oldBits_ = 0;
msgQId_ = epicsMessageQueueCreate(MAX_MESSAGES, sizeof(ipUnidigMessage));
if (ipmCheck(carrier, slot)) {
errlogPrintf("IpUnidig: bad carrier or slot\n");
}
id = (ipac_idProm_t *) ipmBaseAddr(carrier, slot, ipac_addrID);
base = (epicsUInt16 *) ipmBaseAddr(carrier, slot, ipac_addrIO);
baseAddress_ = base;
manufacturer_ = id->manufacturerId & 0xff;
model_ = id->modelId & 0xff;
switch (manufacturer_) {
case GREENSPRING_ID:
switch (model_) {
case UNIDIG_E:
case UNIDIG:
case UNIDIG_D:
case UNIDIG_O_24IO:
case UNIDIG_HV_16I8O:
case UNIDIG_E48:
case UNIDIG_I_O_24I:
case UNIDIG_I_E:
case UNIDIG_I:
case UNIDIG_I_D:
case UNIDIG_I_O_24IO:
case UNIDIG_I_HV_16I8O:
case UNIDIG_O_12I12O:
case UNIDIG_I_O_12I12O:
case UNIDIG_O_24I:
case UNIDIG_HV_8I16O:
case UNIDIG_I_HV_8I16O:
break;
default:
errlogPrintf("IpUnidig model 0x%x not supported\n",model_);
break;
}
break;
case SYSTRAN_ID:
if(model_ != SYSTRAN_DIO316I) {
errlogPrintf("IpUnidig model 0x%x not Systran DIO316I\n",model_);
}
break;
case SBS_ID:
if(model_ != SBS_IPOPTOIO8) {
errlogPrintf("IpUnidig model 0x%x not SBS IP-OPTOIO-8\n",model_);
}
break;
default:
errlogPrintf("IpUnidig manufacturer 0x%x not supported\n", manufacturer_);
break;
}
/* Set up the register pointers. Set the defaults for most modules */
/* Define registers in units of 16-bit words */
regs_.outputRegisterLow = base;
regs_.outputRegisterHigh = base + 0x1;
regs_.inputRegisterLow = base + 0x2;
regs_.inputRegisterHigh = base + 0x3;
regs_.outputEnableLow = base + 0x8;
regs_.outputEnableHigh = base + 0x5;
regs_.controlRegister0 = base + 0x6;
regs_.intVecRegister = base + 0x8;
regs_.intEnableRegisterLow = base + 0x9;
regs_.intEnableRegisterHigh = base + 0xa;
regs_.intPolarityRegisterLow = base + 0xb;
regs_.intPolarityRegisterHigh = base + 0xc;
regs_.intClearRegisterLow = base + 0xd;
regs_.intClearRegisterHigh = base + 0xe;
regs_.intPendingRegisterLow = base + 0xd;
regs_.intPendingRegisterHigh = base + 0xe;
regs_.DACRegister = base + 0xe;
/* Set things up for specific models which need to be treated differently */
switch (manufacturer_) {
case GREENSPRING_ID:
switch (model_) {
case UNIDIG_O_24IO:
case UNIDIG_O_12I12O:
case UNIDIG_I_O_24IO:
case UNIDIG_I_O_12I12O:
/* Enable outputs */
*regs_.controlRegister0 |= 0x4;
break;
case UNIDIG_HV_16I8O:
case UNIDIG_I_HV_16I8O:
/* These modules don't allow access to outputRegisterLow */
regs_.outputRegisterLow = NULL;
/* Set the comparator DAC for 2.5 volts. Each bit is 15 mV. */
*regs_.DACRegister = 2500/15;
break;
}
break;
case SYSTRAN_ID:
switch (model_) {
case SYSTRAN_DIO316I:
/* Different register layout */
regs_.outputRegisterLow = base;
regs_.outputRegisterHigh = base + 0x1;
regs_.inputRegisterLow = base + 0x2;
regs_.inputRegisterHigh = NULL;
regs_.controlRegister0 = base + 0x3;
regs_.controlRegister1 = base + 0x4;
/* Enable outputs for ports 0-3 */
*regs_.controlRegister0 |= 0xf;
/* Set direction of ports 0-1 to be output */
*regs_.controlRegister1 |= 0x3;
break;
}
break;
case SBS_ID:
switch (model_) {
case SBS_IPOPTOIO8:
/* Different register layout */
memset(®s_, 0, sizeof(regs_));
regs_.inputRegisterLow = base + 1;
regs_.outputRegisterLow = base + 2;
regs_.controlRegister0 = base + 3;
*regs_.controlRegister0 = 0x00; /* Start state machine reset */
*regs_.controlRegister0 = 0x01; /* .... */
*regs_.controlRegister0 = 0x00; /* State machine in state 0 */
*regs_.controlRegister0 = 0x2B; /* Select Port B DDR */
*regs_.controlRegister0 = 0xFF; /* All Port B bits are inputs */
*regs_.controlRegister0 = 0x2A; /* Select Port B DPPR */
*regs_.controlRegister0 = 0xFF; /* All Port B bits inverted */
*regs_.controlRegister0 = 0x01; /* Select MCCR */
*regs_.controlRegister0 = 0x84; /* Enable ports A and B */
break;
}
break;
}
switch (model_) {
case UNIDIG_I_O_24I:
case UNIDIG_I_E:
case UNIDIG_I:
case UNIDIG_I_D:
case UNIDIG_I_O_24IO:
case UNIDIG_I_HV_16I8O:
case UNIDIG_I_O_12I12O:
case UNIDIG_I_HV_8I16O:
supportsInterrupts_ = 1;
break;
default:
supportsInterrupts_ = 0;
break;
}
/* Create the asynPortDriver parameter for the data */
createParam(digitalInputString, asynParamUInt32Digital, &digitalInputParam_);
createParam(digitalOutputString, asynParamUInt32Digital, &digitalOutputParam_);
createParam(DACOutputString, asynParamInt32, &DACOutputParam_);
// We use this to call readUInt32Digital, which needs the correct reason
pasynUserSelf->reason = digitalInputParam_;
// Set the values of rising mask and falling mask in the parameter library, just for reporting purposes
asynPortDriver::setUInt32DigitalInterrupt(digitalInputParam_, risingMask_, interruptOnZeroToOne);
asynPortDriver::setUInt32DigitalInterrupt(digitalInputParam_, fallingMask_, interruptOnOneToZero);
/* Start the thread to poll and handle interrupt callbacks to
* device support */
epicsThreadCreate("ipUnidig",
epicsThreadPriorityHigh,
epicsThreadGetStackSize(epicsThreadStackBig),
(EPICSTHREADFUNC)pollerThreadC,
this);
/* If the interrupt vector is zero, don't bother with interrupts,
* since the user probably didn't pass this
* parameter to IpUnidig::init(). This is an optional parameter added
* after initial release. */
if (supportsInterrupts_ && (intVec !=0)) {
/* Interrupt support */
/* Write to the interrupt polarity and enable registers */
*regs_.intVecRegister = intVec;
if (devConnectInterruptVME(intVec, intFuncC, (void *)this)) {
errlogPrintf("ipUnidig interrupt connect failure\n");
}
*regs_.intPolarityRegisterLow = (epicsUInt16)polarityMask_;
*regs_.intPolarityRegisterHigh = (epicsUInt16)(polarityMask_ >> 16);
writeIntEnableRegs();
/* Enable IPAC module interrupts and set module status. */
ipmIrqCmd(carrier, slot, 0, ipac_irqEnable);
ipmIrqCmd(carrier, slot, 0, ipac_statActive);
}
int main(int argc, char**argv)
{
struct sockaddr_in si_me;
struct sockaddr_in moderator_udp_sockaddr;
unsigned short packet_tag;
unsigned int i,j,temp_NPACK;
SOCKET s, moderator_udp_sock_fd;
int this_frame_has_aligment_errors=0;
char temp_char;
unsigned int packet_id, local_packet_id;
long packet_id_gap;
int received_data_subsets=0;
moderation_type moderation=NOUDPMOD;
clock_t timer_a=0,timer_b;
double time_interval;
char moderator_string[MAX_STRLEN];
id_mode packet_id_mode;
ptr_list = epicsMessageQueueCreate(MAX_PENDING_BUFFERS, sizeof(unsigned char *));
if (ptr_list == 0) {
printf("epicsMessageQueueCreate failed\n");
return -1;
}
if (osiSockAttach() == 0) {
printf("osiSockAttach failed\n");
return -1;
}
if(argc==4){
if (strcmp(argv[3],"UDPMOD")==0)
moderation=UDPMOD;
else
moderation=NOUDPMOD;
verbose=atoi(argv[2]);
if (strcmp(argv[1],"FRAG_ID")==0)
packet_id_mode=FRAG_ID;
else
packet_id_mode=NOFRAG_ID;
}
if(argc==3){
verbose=atoi(argv[2]);
if (strcmp(argv[1],"FRAG_ID")==0)
packet_id_mode=FRAG_ID;
else
packet_id_mode=NOFRAG_ID;
}
else if(argc==2){
verbose=0;
if (strcmp(argv[1],"FRAG_ID")==0)
packet_id_mode=FRAG_ID;
else
packet_id_mode=NOFRAG_ID;
}
else{
verbose=0;
packet_id_mode=FRAG_ID;
moderation=NOUDPMOD;
}
buf=(unsigned char*)databuffer_allocation(MAX_PACK_LEN*DEFAULT_NPACK);
if ((s=epicsSocketCreate(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1)
{
printf("\r\nError creating socket error =%s", strerror(errno));
scanf("%c%*c",&temp_char);
return 1;
}
memset((char *) &si_me, 0, sizeof(si_me));
si_me.sin_family = AF_INET;
si_me.sin_port = htons(PORTA);
si_me.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(s, (struct sockaddr *) &si_me, sizeof(si_me))==-1)
{
printf("\r\nError in binding data receiver socket");
//wait_akey();
return 1;
}
if ((moderator_udp_sock_fd=epicsSocketCreate(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1)
{
printf("\r\nError creating moderator socket error =%s", strerror(errno));
scanf("%c%*c",&temp_char);
return 1;
}
memset((char *) &moderator_udp_sockaddr, 0, sizeof(moderator_udp_sockaddr));
moderator_udp_sockaddr.sin_family = AF_INET;
moderator_udp_sockaddr.sin_port = htons(MOD_UDP_REMOTE_PORT);
// The following is not support on Linux. Is it needed?
if (hostToIPAddr("192.168.0.255", &moderator_udp_sockaddr.sin_addr) < 0)
printf("PROC:hostToIPAddr failed\n");
//moderator_udp_sockaddr.sin_addr.S_un.S_un_b.s_b1=192; //l'indirizzo IP!!!
//moderator_udp_sockaddr.sin_addr.S_un.S_un_b.s_b2=168;
//moderator_udp_sockaddr.sin_addr.S_un.S_un_b.s_b3=0;
//moderator_udp_sockaddr.sin_addr.S_un.S_un_b.s_b4=255;
int buffsize;
osiSocklen_t czm = sizeof( int);
int received_bytes;
buffsize = MAXBUF;
if (setsockopt(s, SOL_SOCKET,
SO_RCVBUF,
(char*)&buffsize,
czm) != -1)
{
if(verbose>=2)printf("\r\nTrying to set Receive Buffer = %d", buffsize);
}
if (getsockopt(s, SOL_SOCKET,
SO_RCVBUF,
(char*)&buffsize,
&czm) != -1)
{
if(verbose>=2)printf("\r\nReceive buffer is now = %d ", buffsize);
if (buffsize == MAXBUF)
{
if(verbose>=2)printf("OK");
}
else
{
if(verbose>=2)printf("ERROR Buffer Size too big!");
}
}
epicsThreadCreate("key_proc",
epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
(EPICSTHREADFUNC)key_proc, (void*)&i);
epicsThreadCreate("module_data_parser_thread",
epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
(EPICSTHREADFUNC)module_data_parser_thread, NULL);
while(looping){
// sem_wait(&(ptr_list.put_sem));
this_frame_has_aligment_errors=0;
temp_NPACK=DEFAULT_NPACK;
i=0;
if(packet_id_mode==FRAG_ID){
while(i<temp_NPACK ){
j=0;
while(j<DAQ_PACK_FRAGM){
received_bytes=recvfrom(s,(char*) buf+(i*MAX_PACK_LEN), MAX_PACK_LEN,0, NULL, 0);
if (received_bytes== -1)
printf("\rError receiveing datagram");
else if(received_bytes==MAX_PACK_LEN){
if(i==0) timer_a=clock();
received_packets++;
packet_tag=*buf;
if(packet_tag & AUTOCAL_DATA)
temp_NPACK=AUTOCAL_NPACK;
else
temp_NPACK=DEFAULT_NPACK;
/********************************************************************/;
packet_id=buf[MAX_PACK_LEN*(i)+PACKET_ID_OFFSET]<<8;
packet_id+=buf[MAX_PACK_LEN*(i)+1+PACKET_ID_OFFSET];
packet_id=packet_id%DAQ_PACK_FRAGM;
packet_id_gap=(packet_id-j);
if(packet_id_gap!=0){
if(id_error_packets<10)
printf("ID: %d j= %d\n",packet_id,j);
id_error_packets++;
this_frame_has_aligment_errors=1;
}
if(packet_id_gap>=0){
j+=(packet_id_gap+1);
i+=(packet_id_gap+1);
}
else{
j=DAQ_PACK_FRAGM;
i+=DAQ_PACK_FRAGM;
}
}
}
if(moderation==UDPMOD){
sprintf(moderator_string,"DATASUBSET_RECEIVED %d %d\n",received_data_subsets,temp_NPACK/DAQ_PACK_FRAGM);
received_data_subsets++;
if (sendto(moderator_udp_sock_fd,
moderator_string,
strlen(moderator_string),
0,
(struct sockaddr*)&moderator_udp_sockaddr,
(osiSocklen_t)sizeof(moderator_udp_sockaddr))==-1)
printf("\r\n!!Error sending moderating datagram!!");
}
}
} else{
while(i<temp_NPACK ){
received_bytes=recvfrom(s,(char*) buf+(i*MAX_PACK_LEN), MAX_PACK_LEN,0, NULL, 0);
if (received_bytes== -1)
printf("\rError receiveing datagram");
else if(received_bytes==MAX_PACK_LEN){
if(i==0) timer_a=clock();
//i++;j++;
received_packets++;
packet_tag=*buf;
if(packet_tag & AUTOCAL_DATA)
temp_NPACK=AUTOCAL_NPACK;
else
temp_NPACK=DEFAULT_NPACK;
packet_id=buf[MAX_PACK_LEN*(i)+PACKET_ID_OFFSET]<<8;
packet_id+=buf[MAX_PACK_LEN*(i)+1+PACKET_ID_OFFSET];
packet_id_gap=(packet_id-i);//
if(packet_id_gap!=0){
id_error_packets++;
this_frame_has_aligment_errors=1;
}
if(packet_id_gap>=0){
i+=(packet_id_gap+1);
}
else{
i=temp_NPACK;
}
if((i%DAQ_PACK_FRAGM)==0 && i!=0 && moderation==UDPMOD){
sprintf(moderator_string,"DATASUBSET_RECEIVED %d %d\n",received_data_subsets,temp_NPACK/DAQ_PACK_FRAGM);
received_data_subsets++;
if (sendto(moderator_udp_sock_fd,
moderator_string,
strlen(moderator_string),
0,
(struct sockaddr*)&moderator_udp_sockaddr,
sizeof(moderator_udp_sockaddr))==-1)
printf("\r\n!!Error sending moderating datagram!!");
}
}
}
}
received_data_subsets=0;
if(verbose>=1){
timer_b=clock();
time_interval=(double)(timer_b-timer_a)/CLOCKS_PER_SEC;
printf("MAIN:%d packets(%d bytes each) have been received in %.3f s ",i,MAX_PACK_LEN,time_interval);
printf("(%.3f Mbps)\n",(i*MAX_PACK_LEN*8)/(time_interval*1024*1024));
}
i=0;
local_packet_id=0;
process_buf=(unsigned char*)databuffer_allocation((MAX_PACK_LEN-PACKET_EXTRA_BYTES+PACKET_TAG_BYTES)*DEFAULT_NPACK);
if((buf==NULL)||(process_buf==NULL)){
printf("error allocating buffers\n");
exit(0);
}
else
if(verbose>=1)
printf("MAIN:New Processing Buffer Allocated\n");
while((i<temp_NPACK))
{
memcpy(process_buf+PACKET_TAG_BYTES+(PACKET_SENSOR_DATA_BYTES*local_packet_id),
buf+PACKET_SENSOR_DATA_OFFSET+(MAX_PACK_LEN*i), PACKET_SENSOR_DATA_BYTES);
for(j=0;j<PACKET_TAG_BYTES;j++)
process_buf[PACKET_TAG_OFFSET+j]=buf[j];//copio il PACKET_TAG del buffer per processing
if(this_frame_has_aligment_errors)
process_buf[PACKET_TAG_OFFSET]|=FRAME_HAS_ALIGN_ERRORS;
else
process_buf[PACKET_TAG_OFFSET]&=(~FRAME_HAS_ALIGN_ERRORS);
local_packet_id++;
i++;
}
printf("Main: sending process_buf=%p\n", process_buf);
epicsMessageQueueSend(ptr_list, &process_buf, sizeof(&process_buf));
}
free(buf);
free(process_buf);
scanf("%c%*c",&temp_char);
return EXIT_SUCCESS;
}
